gdb/cp-support.c

   1 /* Helper routines for C++ support in GDB.
   2    Copyright (C) 2002-2005, 2007-2012 Free Software Foundation, Inc.
   3
   4    Contributed by MontaVista Software.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "cp-support.h"
  23 #include "gdb_string.h"
  24 #include "demangle.h"
  25 #include "gdb_assert.h"
  26 #include "gdbcmd.h"
  27 #include "dictionary.h"
  28 #include "objfiles.h"
  29 #include "frame.h"
  30 #include "symtab.h"
  31 #include "block.h"
  32 #include "complaints.h"
  33 #include "gdbtypes.h"
  34 #include "exceptions.h"
  35 #include "expression.h"
  36 #include "value.h"
  37
  38 #include "safe-ctype.h"
  39
  40 #include "psymtab.h"
  41
  42 #define d_left(dc) (dc)->u.s_binary.left
  43 #define d_right(dc) (dc)->u.s_binary.right
  44
  45 /* Functions related to demangled name parsing.  */
  46
  47 static unsigned int cp_find_first_component_aux (const char *name,
  48                                                  int permissive);
  49
  50 static void demangled_name_complaint (const char *name);
  51
  52 /* Functions/variables related to overload resolution.  */
  53
  54 static int sym_return_val_size = -1;
  55 static int sym_return_val_index;
  56 static struct symbol **sym_return_val;
  57
  58 static void overload_list_add_symbol (struct symbol *sym,
  59                                       const char *oload_name);
  60
  61 static void make_symbol_overload_list_using (const char *func_name,
  62                                              const char *namespace);
  63
  64 static void make_symbol_overload_list_qualified (const char *func_name);
  65
  66 /* The list of "maint cplus" commands.  */
  67
  68 struct cmd_list_element *maint_cplus_cmd_list = NULL;
  69
  70 /* The actual commands.  */
  71
  72 static void maint_cplus_command (char *arg, int from_tty);
  73 static void first_component_command (char *arg, int from_tty);
  74
  75 /* Operator validation.
  76    NOTE: Multi-byte operators (usually the assignment variety
  77    operator) must appear before the single byte version, i.e., "+="
  78    before "+".  */
  79 static const char *operator_tokens[] =
  80   {
  81     "++", "+=", "+", "->*", "->", "--", "-=", "-", "*=", "*",
  82     "/=", "/", "%=", "%", "!=", "==", "!", "&&", "<<=", "<<",
  83     ">>=", ">>", "<=", "<", ">=", ">", "~", "&=", "&", "|=",
  84     "||", "|", "^=", "^", "=", "()", "[]", ",", "new", "delete"
  85     /* new[] and delete[] require special whitespace handling */
  86   };
  87
  88 /* A list of typedefs which should not be substituted by replace_typedefs.  */
  89 static const char * const ignore_typedefs[] =
  90   {
  91     "std::istream", "std::iostream", "std::ostream", "std::string"
  92   };
  93
  94 static void
  95   replace_typedefs (struct demangle_parse_info *info,
  96                     struct demangle_component *ret_comp);
  97
  98 /* A convenience function to copy STRING into OBSTACK, returning a pointer
  99    to the newly allocated string and saving the number of bytes saved in LEN.
 100
 101    It does not copy the terminating '\0' byte!  */
 102
 103 static char *
 104 copy_string_to_obstack (struct obstack *obstack, const char *string,
 105                         long *len)
 106 {
 107   *len = strlen (string);
 108   return obstack_copy (obstack, string, *len);
 109 }
 110
 111 /* A cleanup wrapper for cp_demangled_name_parse_free.  */
 112
 113 static void
 114 do_demangled_name_parse_free_cleanup (void *data)
 115 {
 116   struct demangle_parse_info *info = (struct demangle_parse_info *) data;
 117
 118   cp_demangled_name_parse_free (info);
 119 }
 120
 121 /* Create a cleanup for C++ name parsing.  */
 122
 123 struct cleanup *
 124 make_cleanup_cp_demangled_name_parse_free (struct demangle_parse_info *info)
 125 {
 126   return make_cleanup (do_demangled_name_parse_free_cleanup, info);
 127 }
 128
 129 /* Return 1 if STRING is clearly already in canonical form.  This
 130    function is conservative; things which it does not recognize are
 131    assumed to be non-canonical, and the parser will sort them out
 132    afterwards.  This speeds up the critical path for alphanumeric
 133    identifiers.  */
 134
 135 static int
 136 cp_already_canonical (const char *string)
 137 {
 138   /* Identifier start character [a-zA-Z_].  */
 139   if (!ISIDST (string[0]))
 140     return 0;
 141
 142   /* These are the only two identifiers which canonicalize to other
 143      than themselves or an error: unsigned -> unsigned int and
 144      signed -> int.  */
 145   if (string[0] == 'u' && strcmp (&string[1], "nsigned") == 0)
 146     return 0;
 147   else if (string[0] == 's' && strcmp (&string[1], "igned") == 0)
 148     return 0;
 149
 150   /* Identifier character [a-zA-Z0-9_].  */
 151   while (ISIDNUM (string[1]))
 152     string++;
 153
 154   if (string[1] == '\0')
 155     return 1;
 156   else
 157     return 0;
 158 }
 159
 160 /* Inspect the given RET_COMP for its type.  If it is a typedef,
 161    replace the node with the typedef's tree.
 162
 163    Returns 1 if any typedef substitutions were made, 0 otherwise.  */
 164
 165 static int
 166 inspect_type (struct demangle_parse_info *info,
 167               struct demangle_component *ret_comp)
 168 {
 169   int i;
 170   char *name;
 171   struct symbol *sym;
 172   volatile struct gdb_exception except;
 173
 174   /* Copy the symbol's name from RET_COMP and look it up
 175      in the symbol table.  */
 176   name = (char *) alloca (ret_comp->u.s_name.len + 1);
 177   memcpy (name, ret_comp->u.s_name.s, ret_comp->u.s_name.len);
 178   name[ret_comp->u.s_name.len] = '\0';
 179
 180   /* Ignore any typedefs that should not be substituted.  */
 181   for (i = 0; i < ARRAY_SIZE (ignore_typedefs); ++i)
 182     {
 183       if (strcmp (name, ignore_typedefs[i]) == 0)
 184         return 0;
 185     }
 186
 187   sym = NULL;
 188   TRY_CATCH (except, RETURN_MASK_ALL)
 189   {
 190     sym = lookup_symbol (name, 0, VAR_DOMAIN, 0);
 191   }
 192
 193   if (except.reason >= 0 && sym != NULL)
 194     {
 195       struct type *otype = SYMBOL_TYPE (sym);
 196
 197       /* If the type is a typedef, replace it.  */
 198       if (TYPE_CODE (otype) == TYPE_CODE_TYPEDEF)
 199         {
 200           long len;
 201           int is_anon;
 202           struct type *type;
 203           struct demangle_parse_info *i;
 204           struct ui_file *buf;
 205
 206           /* Get the real type of the typedef.  */
 207           type = check_typedef (otype);
 208
 209           is_anon = (TYPE_TAG_NAME (type) == NULL
 210                      && (TYPE_CODE (type) == TYPE_CODE_ENUM
 211                          || TYPE_CODE (type) == TYPE_CODE_STRUCT
 212                          || TYPE_CODE (type) == TYPE_CODE_UNION));
 213           if (is_anon)
 214             {
 215               struct type *last = otype;
 216
 217               /* Find the last typedef for the type.  */
 218               while (TYPE_TARGET_TYPE (last) != NULL
 219                      && (TYPE_CODE (TYPE_TARGET_TYPE (last))
 220                          == TYPE_CODE_TYPEDEF))
 221                 last = TYPE_TARGET_TYPE (last);
 222
 223               /* If there is only one typedef for this anonymous type,
 224                  do not substitute it.  */
 225               if (type == otype)
 226                 return 0;
 227               else
 228                 /* Use the last typedef seen as the type for this
 229                    anonymous type.  */
 230                 type = last;
 231             }
 232
 233           buf = mem_fileopen ();
 234           TRY_CATCH (except, RETURN_MASK_ERROR)
 235           {
 236             type_print (type, "", buf, -1);
 237           }
 238
 239           /* If type_print threw an exception, there is little point
 240              in continuing, so just bow out gracefully.  */
 241           if (except.reason < 0)
 242             {
 243               ui_file_delete (buf);
 244               return 0;
 245             }
 246
 247           name = ui_file_obsavestring (buf, &info->obstack, &len);
 248           ui_file_delete (buf);
 249
 250           /* Turn the result into a new tree.  Note that this
 251              tree will contain pointers into NAME, so NAME cannot
 252              be free'd until all typedef conversion is done and
 253              the final result is converted into a string.  */
 254           i = cp_demangled_name_to_comp (name, NULL);
 255           if (i != NULL)
 256             {
 257               /* Merge the two trees.  */
 258               cp_merge_demangle_parse_infos (info, ret_comp, i);
 259
 260               /* Replace any newly introduced typedefs -- but not
 261                  if the type is anonymous (that would lead to infinite
 262                  looping).  */
 263               if (!is_anon)
 264                 replace_typedefs (info, ret_comp);
 265             }
 266           else
 267             {
 268               /* This shouldn't happen unless the type printer has
 269                  output something that the name parser cannot grok.
 270                  Nonetheless, an ounce of prevention...
 271
 272                  Canonicalize the name again, and store it in the
 273                  current node (RET_COMP).  */
 274               char *canon = cp_canonicalize_string_no_typedefs (name);
 275
 276               if (canon != NULL)
 277                 {
 278                   /* Copy the canonicalization into the obstack and
 279                      free CANON.  */
 280                   name = copy_string_to_obstack (&info->obstack, canon, &len);
 281                   xfree (canon);
 282                 }
 283
 284               ret_comp->u.s_name.s = name;
 285               ret_comp->u.s_name.len = len;
 286             }
 287
 288           return 1;
 289         }
 290     }
 291
 292   return 0;
 293 }
 294
 295 /* Replace any typedefs appearing in the qualified name
 296    (DEMANGLE_COMPONENT_QUAL_NAME) represented in RET_COMP for the name parse
 297    given in INFO.  */
 298
 299 static void
 300 replace_typedefs_qualified_name (struct demangle_parse_info *info,
 301                                  struct demangle_component *ret_comp)
 302 {
 303   long len;
 304   char *name;
 305   struct ui_file *buf = mem_fileopen ();
 306   struct demangle_component *comp = ret_comp;
 307
 308   /* Walk each node of the qualified name, reconstructing the name of
 309      this element.  With every node, check for any typedef substitutions.
 310      If a substitution has occurred, replace the qualified name node
 311      with a DEMANGLE_COMPONENT_NAME node representing the new, typedef-
 312      substituted name.  */
 313   while (comp->type == DEMANGLE_COMPONENT_QUAL_NAME)
 314     {
 315       if (d_left (comp)->type == DEMANGLE_COMPONENT_NAME)
 316         {
 317           struct demangle_component new;
 318
 319           ui_file_write (buf, d_left (comp)->u.s_name.s,
 320                          d_left (comp)->u.s_name.len);
 321           name = ui_file_obsavestring (buf, &info->obstack, &len);
 322           new.type = DEMANGLE_COMPONENT_NAME;
 323           new.u.s_name.s = name;
 324           new.u.s_name.len = len;
 325           if (inspect_type (info, &new))
 326             {
 327               char *n, *s;
 328               long slen;
 329
 330               /* A typedef was substituted in NEW.  Convert it to a
 331                  string and replace the top DEMANGLE_COMPONENT_QUAL_NAME
 332                  node.  */
 333
 334               ui_file_rewind (buf);
 335               n = cp_comp_to_string (&new, 100);
 336               if (n == NULL)
 337                 {
 338                   /* If something went astray, abort typedef substitutions.  */
 339                   ui_file_delete (buf);
 340                   return;
 341                 }
 342
 343               s = copy_string_to_obstack (&info->obstack, n, &slen);
 344               xfree (n);
 345
 346               d_left (ret_comp)->type = DEMANGLE_COMPONENT_NAME;
 347               d_left (ret_comp)->u.s_name.s = s;
 348               d_left (ret_comp)->u.s_name.len = slen;
 349               d_right (ret_comp) = d_right (comp);
 350               comp = ret_comp;
 351               continue;
 352             }
 353         }
 354       else
 355         {
 356           /* The current node is not a name, so simply replace any
 357              typedefs in it.  Then print it to the stream to continue
 358              checking for more typedefs in the tree.  */
 359           replace_typedefs (info, d_left (comp));
 360           name = cp_comp_to_string (d_left (comp), 100);
 361           if (name == NULL)
 362             {
 363               /* If something went astray, abort typedef substitutions.  */
 364               ui_file_delete (buf);
 365               return;
 366             }
 367           fputs_unfiltered (name, buf);
 368           xfree (name);
 369         }
 370       ui_file_write (buf, "::", 2);
 371       comp = d_right (comp);
 372     }
 373
 374   /* If the next component is DEMANGLE_COMPONENT_NAME, save the qualified
 375      name assembled above and append the name given by COMP.  Then use this
 376      reassembled name to check for a typedef.  */
 377
 378   if (comp->type == DEMANGLE_COMPONENT_NAME)
 379     {
 380       ui_file_write (buf, comp->u.s_name.s, comp->u.s_name.len);
 381       name = ui_file_obsavestring (buf, &info->obstack, &len);
 382
 383       /* Replace the top (DEMANGLE_COMPONENT_QUAL_NAME) node
 384          with a DEMANGLE_COMPONENT_NAME node containing the whole
 385          name.  */
 386       ret_comp->type = DEMANGLE_COMPONENT_NAME;
 387       ret_comp->u.s_name.s = name;
 388       ret_comp->u.s_name.len = len;
 389       inspect_type (info, ret_comp);
 390     }
 391   else
 392     replace_typedefs (info, comp);
 393
 394   ui_file_delete (buf);
 395 }
 396
 397
 398 /* A function to check const and volatile qualifiers for argument types.
 399
 400    "Parameter declarations that differ only in the presence
 401    or absence of `const' and/or `volatile' are equivalent."
 402    C++ Standard N3290, clause 13.1.3 #4.  */
 403
 404 static void
 405 check_cv_qualifiers (struct demangle_component *ret_comp)
 406 {
 407   while (d_left (ret_comp) != NULL
 408          && (d_left (ret_comp)->type == DEMANGLE_COMPONENT_CONST
 409              || d_left (ret_comp)->type == DEMANGLE_COMPONENT_VOLATILE))
 410     {
 411       d_left (ret_comp) = d_left (d_left (ret_comp));
 412     }
 413 }
 414
 415 /* Walk the parse tree given by RET_COMP, replacing any typedefs with
 416    their basic types.  */
 417
 418 static void
 419 replace_typedefs (struct demangle_parse_info *info,
 420                   struct demangle_component *ret_comp)
 421 {
 422   if (ret_comp)
 423     {
 424       switch (ret_comp->type)
 425         {
 426         case DEMANGLE_COMPONENT_ARGLIST:
 427           check_cv_qualifiers (ret_comp);
 428           /* Fall through */
 429
 430         case DEMANGLE_COMPONENT_FUNCTION_TYPE:
 431         case DEMANGLE_COMPONENT_TEMPLATE:
 432         case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
 433         case DEMANGLE_COMPONENT_TYPED_NAME:
 434           replace_typedefs (info, d_left (ret_comp));
 435           replace_typedefs (info, d_right (ret_comp));
 436           break;
 437
 438         case DEMANGLE_COMPONENT_NAME:
 439           inspect_type (info, ret_comp);
 440           break;
 441
 442         case DEMANGLE_COMPONENT_QUAL_NAME:
 443           replace_typedefs_qualified_name (info, ret_comp);
 444           break;
 445
 446         case DEMANGLE_COMPONENT_LOCAL_NAME:
 447         case DEMANGLE_COMPONENT_CTOR:
 448         case DEMANGLE_COMPONENT_ARRAY_TYPE:
 449         case DEMANGLE_COMPONENT_PTRMEM_TYPE:
 450           replace_typedefs (info, d_right (ret_comp));
 451           break;
 452
 453         case DEMANGLE_COMPONENT_CONST:
 454         case DEMANGLE_COMPONENT_RESTRICT:
 455         case DEMANGLE_COMPONENT_VOLATILE:
 456         case DEMANGLE_COMPONENT_VOLATILE_THIS:
 457         case DEMANGLE_COMPONENT_CONST_THIS:
 458         case DEMANGLE_COMPONENT_RESTRICT_THIS:
 459         case DEMANGLE_COMPONENT_POINTER:
 460         case DEMANGLE_COMPONENT_REFERENCE:
 461           replace_typedefs (info, d_left (ret_comp));
 462           break;
 463
 464         default:
 465           break;
 466         }
 467     }
 468 }
 469
 470 /* Parse STRING and convert it to canonical form, resolving any typedefs.
 471    If parsing fails, or if STRING is already canonical, return NULL.
 472    Otherwise return the canonical form.  The return value is allocated via
 473    xmalloc.  */
 474
 475 char *
 476 cp_canonicalize_string_no_typedefs (const char *string)
 477 {
 478   char *ret;
 479   unsigned int estimated_len;
 480   struct demangle_parse_info *info;
 481
 482   ret = NULL;
 483   estimated_len = strlen (string) * 2;
 484   info = cp_demangled_name_to_comp (string, NULL);
 485   if (info != NULL)
 486     {
 487       /* Replace all the typedefs in the tree.  */
 488       replace_typedefs (info, info->tree);
 489
 490       /* Convert the tree back into a string.  */
 491       ret = cp_comp_to_string (info->tree, estimated_len);
 492       gdb_assert (ret != NULL);
 493
 494       /* Free the parse information.  */
 495       cp_demangled_name_parse_free (info);
 496
 497       /* Finally, compare the original string with the computed
 498          name, returning NULL if they are the same.  */
 499       if (strcmp (string, ret) == 0)
 500         {
 501           xfree (ret);
 502           return NULL;
 503         }
 504     }
 505
 506   return ret;
 507 }
 508
 509 /* Parse STRING and convert it to canonical form.  If parsing fails,
 510    or if STRING is already canonical, return NULL.  Otherwise return
 511    the canonical form.  The return value is allocated via xmalloc.  */
 512
 513 char *
 514 cp_canonicalize_string (const char *string)
 515 {
 516   struct demangle_parse_info *info;
 517   unsigned int estimated_len;
 518   char *ret;
 519
 520   if (cp_already_canonical (string))
 521     return NULL;
 522
 523   info = cp_demangled_name_to_comp (string, NULL);
 524   if (info == NULL)
 525     return NULL;
 526
 527   estimated_len = strlen (string) * 2;
 528   ret = cp_comp_to_string (info->tree, estimated_len);
 529   cp_demangled_name_parse_free (info);
 530
 531   if (strcmp (string, ret) == 0)
 532     {
 533       xfree (ret);
 534       return NULL;
 535     }
 536
 537   return ret;
 538 }
 539
 540 /* Convert a mangled name to a demangle_component tree.  *MEMORY is
 541    set to the block of used memory that should be freed when finished
 542    with the tree.  DEMANGLED_P is set to the char * that should be
 543    freed when finished with the tree, or NULL if none was needed.
 544    OPTIONS will be passed to the demangler.  */
 545
 546 static struct demangle_parse_info *
 547 mangled_name_to_comp (const char *mangled_name, int options,
 548                       void **memory, char **demangled_p)
 549 {
 550   char *demangled_name;
 551   struct demangle_parse_info *info;
 552
 553   /* If it looks like a v3 mangled name, then try to go directly
 554      to trees.  */
 555   if (mangled_name[0] == '_' && mangled_name[1] == 'Z')
 556     {
 557       struct demangle_component *ret;
 558
 559       ret = cplus_demangle_v3_components (mangled_name,
 560                                           options, memory);
 561       if (ret)
 562         {
 563           info = cp_new_demangle_parse_info ();
 564           info->tree = ret;
 565           *demangled_p = NULL;
 566           return info;
 567         }
 568     }
 569
 570   /* If it doesn't, or if that failed, then try to demangle the
 571      name.  */
 572   demangled_name = cplus_demangle (mangled_name, options);
 573   if (demangled_name == NULL)
 574    return NULL;
 575
 576   /* If we could demangle the name, parse it to build the component
 577      tree.  */
 578   info = cp_demangled_name_to_comp (demangled_name, NULL);
 579
 580   if (info == NULL)
 581     {
 582       xfree (demangled_name);
 583       return NULL;
 584     }
 585
 586   *demangled_p = demangled_name;
 587   return info;
 588 }
 589
 590 /* Return the name of the class containing method PHYSNAME.  */
 591
 592 char *
 593 cp_class_name_from_physname (const char *physname)
 594 {
 595   void *storage = NULL;
 596   char *demangled_name = NULL, *ret;
 597   struct demangle_component *ret_comp, *prev_comp, *cur_comp;
 598   struct demangle_parse_info *info;
 599   int done;
 600
 601   info = mangled_name_to_comp (physname, DMGL_ANSI,
 602                                &storage, &demangled_name);
 603   if (info == NULL)
 604     return NULL;
 605
 606   done = 0;
 607   ret_comp = info->tree;
 608
 609   /* First strip off any qualifiers, if we have a function or
 610      method.  */
 611   while (!done)
 612     switch (ret_comp->type)
 613       {
 614       case DEMANGLE_COMPONENT_CONST:
 615       case DEMANGLE_COMPONENT_RESTRICT:
 616       case DEMANGLE_COMPONENT_VOLATILE:
 617       case DEMANGLE_COMPONENT_CONST_THIS:
 618       case DEMANGLE_COMPONENT_RESTRICT_THIS:
 619       case DEMANGLE_COMPONENT_VOLATILE_THIS:
 620       case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
 621         ret_comp = d_left (ret_comp);
 622         break;
 623       default:
 624         done = 1;
 625         break;
 626       }
 627
 628   /* If what we have now is a function, discard the argument list.  */
 629   if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME)
 630     ret_comp = d_left (ret_comp);
 631
 632   /* If what we have now is a template, strip off the template
 633      arguments.  The left subtree may be a qualified name.  */
 634   if (ret_comp->type == DEMANGLE_COMPONENT_TEMPLATE)
 635     ret_comp = d_left (ret_comp);
 636
 637   /* What we have now should be a name, possibly qualified.
 638      Additional qualifiers could live in the left subtree or the right
 639      subtree.  Find the last piece.  */
 640   done = 0;
 641   prev_comp = NULL;
 642   cur_comp = ret_comp;
 643   while (!done)
 644     switch (cur_comp->type)
 645       {
 646       case DEMANGLE_COMPONENT_QUAL_NAME:
 647       case DEMANGLE_COMPONENT_LOCAL_NAME:
 648         prev_comp = cur_comp;
 649         cur_comp = d_right (cur_comp);
 650         break;
 651       case DEMANGLE_COMPONENT_TEMPLATE:
 652       case DEMANGLE_COMPONENT_NAME:
 653       case DEMANGLE_COMPONENT_CTOR:
 654       case DEMANGLE_COMPONENT_DTOR:
 655       case DEMANGLE_COMPONENT_OPERATOR:
 656       case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
 657         done = 1;
 658         break;
 659       default:
 660         done = 1;
 661         cur_comp = NULL;
 662         break;
 663       }
 664
 665   ret = NULL;
 666   if (cur_comp != NULL && prev_comp != NULL)
 667     {
 668       /* We want to discard the rightmost child of PREV_COMP.  */
 669       *prev_comp = *d_left (prev_comp);
 670       /* The ten is completely arbitrary; we don't have a good
 671          estimate.  */
 672       ret = cp_comp_to_string (ret_comp, 10);
 673     }
 674
 675   xfree (storage);
 676   xfree (demangled_name);
 677   cp_demangled_name_parse_free (info);
 678   return ret;
 679 }
 680
 681 /* Return the child of COMP which is the basename of a method,
 682    variable, et cetera.  All scope qualifiers are discarded, but
 683    template arguments will be included.  The component tree may be
 684    modified.  */
 685
 686 static struct demangle_component *
 687 unqualified_name_from_comp (struct demangle_component *comp)
 688 {
 689   struct demangle_component *ret_comp = comp, *last_template;
 690   int done;
 691
 692   done = 0;
 693   last_template = NULL;
 694   while (!done)
 695     switch (ret_comp->type)
 696       {
 697       case DEMANGLE_COMPONENT_QUAL_NAME:
 698       case DEMANGLE_COMPONENT_LOCAL_NAME:
 699         ret_comp = d_right (ret_comp);
 700         break;
 701       case DEMANGLE_COMPONENT_TYPED_NAME:
 702         ret_comp = d_left (ret_comp);
 703         break;
 704       case DEMANGLE_COMPONENT_TEMPLATE:
 705         gdb_assert (last_template == NULL);
 706         last_template = ret_comp;
 707         ret_comp = d_left (ret_comp);
 708         break;
 709       case DEMANGLE_COMPONENT_CONST:
 710       case DEMANGLE_COMPONENT_RESTRICT:
 711       case DEMANGLE_COMPONENT_VOLATILE:
 712       case DEMANGLE_COMPONENT_CONST_THIS:
 713       case DEMANGLE_COMPONENT_RESTRICT_THIS:
 714       case DEMANGLE_COMPONENT_VOLATILE_THIS:
 715       case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
 716         ret_comp = d_left (ret_comp);
 717         break;
 718       case DEMANGLE_COMPONENT_NAME:
 719       case DEMANGLE_COMPONENT_CTOR:
 720       case DEMANGLE_COMPONENT_DTOR:
 721       case DEMANGLE_COMPONENT_OPERATOR:
 722       case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
 723         done = 1;
 724         break;
 725       default:
 726         return NULL;
 727         break;
 728       }
 729
 730   if (last_template)
 731     {
 732       d_left (last_template) = ret_comp;
 733       return last_template;
 734     }
 735
 736   return ret_comp;
 737 }
 738
 739 /* Return the name of the method whose linkage name is PHYSNAME.  */
 740
 741 char *
 742 method_name_from_physname (const char *physname)
 743 {
 744   void *storage = NULL;
 745   char *demangled_name = NULL, *ret;
 746   struct demangle_component *ret_comp;
 747   struct demangle_parse_info *info;
 748
 749   info = mangled_name_to_comp (physname, DMGL_ANSI,
 750                                &storage, &demangled_name);
 751   if (info == NULL)
 752     return NULL;
 753
 754   ret_comp = unqualified_name_from_comp (info->tree);
 755
 756   ret = NULL;
 757   if (ret_comp != NULL)
 758     /* The ten is completely arbitrary; we don't have a good
 759        estimate.  */
 760     ret = cp_comp_to_string (ret_comp, 10);
 761
 762   xfree (storage);
 763   xfree (demangled_name);
 764   cp_demangled_name_parse_free (info);
 765   return ret;
 766 }
 767
 768 /* If FULL_NAME is the demangled name of a C++ function (including an
 769    arg list, possibly including namespace/class qualifications),
 770    return a new string containing only the function name (without the
 771    arg list/class qualifications).  Otherwise, return NULL.  The
 772    caller is responsible for freeing the memory in question.  */
 773
 774 char *
 775 cp_func_name (const char *full_name)
 776 {
 777   char *ret;
 778   struct demangle_component *ret_comp;
 779   struct demangle_parse_info *info;
 780
 781   info = cp_demangled_name_to_comp (full_name, NULL);
 782   if (!info)
 783     return NULL;
 784
 785   ret_comp = unqualified_name_from_comp (info->tree);
 786
 787   ret = NULL;
 788   if (ret_comp != NULL)
 789     ret = cp_comp_to_string (ret_comp, 10);
 790
 791   cp_demangled_name_parse_free (info);
 792   return ret;
 793 }
 794
 795 /* DEMANGLED_NAME is the name of a function, including parameters and
 796    (optionally) a return type.  Return the name of the function without
 797    parameters or return type, or NULL if we can not parse the name.  */
 798
 799 char *
 800 cp_remove_params (const char *demangled_name)
 801 {
 802   int done = 0;
 803   struct demangle_component *ret_comp;
 804   struct demangle_parse_info *info;
 805   char *ret = NULL;
 806
 807   if (demangled_name == NULL)
 808     return NULL;
 809
 810   info = cp_demangled_name_to_comp (demangled_name, NULL);
 811   if (info == NULL)
 812     return NULL;
 813
 814   /* First strip off any qualifiers, if we have a function or method.  */
 815   ret_comp = info->tree;
 816   while (!done)
 817     switch (ret_comp->type)
 818       {
 819       case DEMANGLE_COMPONENT_CONST:
 820       case DEMANGLE_COMPONENT_RESTRICT:
 821       case DEMANGLE_COMPONENT_VOLATILE:
 822       case DEMANGLE_COMPONENT_CONST_THIS:
 823       case DEMANGLE_COMPONENT_RESTRICT_THIS:
 824       case DEMANGLE_COMPONENT_VOLATILE_THIS:
 825       case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
 826         ret_comp = d_left (ret_comp);
 827         break;
 828       default:
 829         done = 1;
 830         break;
 831       }
 832
 833   /* What we have now should be a function.  Return its name.  */
 834   if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME)
 835     ret = cp_comp_to_string (d_left (ret_comp), 10);
 836
 837   cp_demangled_name_parse_free (info);
 838   return ret;
 839 }
 840
 841 /* Here are some random pieces of trivia to keep in mind while trying
 842    to take apart demangled names:
 843
 844    - Names can contain function arguments or templates, so the process
 845      has to be, to some extent recursive: maybe keep track of your
 846      depth based on encountering <> and ().
 847
 848    - Parentheses don't just have to happen at the end of a name: they
 849      can occur even if the name in question isn't a function, because
 850      a template argument might be a type that's a function.
 851
 852    - Conversely, even if you're trying to deal with a function, its
 853      demangled name might not end with ')': it could be a const or
 854      volatile class method, in which case it ends with "const" or
 855      "volatile".
 856
 857    - Parentheses are also used in anonymous namespaces: a variable
 858      'foo' in an anonymous namespace gets demangled as "(anonymous
 859      namespace)::foo".
 860
 861    - And operator names can contain parentheses or angle brackets.  */
 862
 863 /* FIXME: carlton/2003-03-13: We have several functions here with
 864    overlapping functionality; can we combine them?  Also, do they
 865    handle all the above considerations correctly?  */
 866
 867
 868 /* This returns the length of first component of NAME, which should be
 869    the demangled name of a C++ variable/function/method/etc.
 870    Specifically, it returns the index of the first colon forming the
 871    boundary of the first component: so, given 'A::foo' or 'A::B::foo'
 872    it returns the 1, and given 'foo', it returns 0.  */
 873
 874 /* The character in NAME indexed by the return value is guaranteed to
 875    always be either ':' or '\0'.  */
 876
 877 /* NOTE: carlton/2003-03-13: This function is currently only intended
 878    for internal use: it's probably not entirely safe when called on
 879    user-generated input, because some of the 'index += 2' lines in
 880    cp_find_first_component_aux might go past the end of malformed
 881    input.  */
 882
 883 unsigned int
 884 cp_find_first_component (const char *name)
 885 {
 886   return cp_find_first_component_aux (name, 0);
 887 }
 888
 889 /* Helper function for cp_find_first_component.  Like that function,
 890    it returns the length of the first component of NAME, but to make
 891    the recursion easier, it also stops if it reaches an unexpected ')'
 892    or '>' if the value of PERMISSIVE is nonzero.  */
 893
 894 /* Let's optimize away calls to strlen("operator").  */
 895
 896 #define LENGTH_OF_OPERATOR 8
 897
 898 static unsigned int
 899 cp_find_first_component_aux (const char *name, int permissive)
 900 {
 901   unsigned int index = 0;
 902   /* Operator names can show up in unexpected places.  Since these can
 903      contain parentheses or angle brackets, they can screw up the
 904      recursion.  But not every string 'operator' is part of an
 905      operater name: e.g. you could have a variable 'cooperator'.  So
 906      this variable tells us whether or not we should treat the string
 907      'operator' as starting an operator.  */
 908   int operator_possible = 1;
 909
 910   for (;; ++index)
 911     {
 912       switch (name[index])
 913         {
 914         case '<':
 915           /* Template; eat it up.  The calls to cp_first_component
 916              should only return (I hope!) when they reach the '>'
 917              terminating the component or a '::' between two
 918              components.  (Hence the '+ 2'.)  */
 919           index += 1;
 920           for (index += cp_find_first_component_aux (name + index, 1);
 921                name[index] != '>';
 922                index += cp_find_first_component_aux (name + index, 1))
 923             {
 924               if (name[index] != ':')
 925                 {
 926                   demangled_name_complaint (name);
 927                   return strlen (name);
 928                 }
 929               index += 2;
 930             }
 931           operator_possible = 1;
 932           break;
 933         case '(':
 934           /* Similar comment as to '<'.  */
 935           index += 1;
 936           for (index += cp_find_first_component_aux (name + index, 1);
 937                name[index] != ')';
 938                index += cp_find_first_component_aux (name + index, 1))
 939             {
 940               if (name[index] != ':')
 941                 {
 942                   demangled_name_complaint (name);
 943                   return strlen (name);
 944                 }
 945               index += 2;
 946             }
 947           operator_possible = 1;
 948           break;
 949         case '>':
 950         case ')':
 951           if (permissive)
 952             return index;
 953           else
 954             {
 955               demangled_name_complaint (name);
 956               return strlen (name);
 957             }
 958         case '\0':
 959         case ':':
 960           return index;
 961         case 'o':
 962           /* Operator names can screw up the recursion.  */
 963           if (operator_possible
 964               && strncmp (name + index, "operator",
 965                           LENGTH_OF_OPERATOR) == 0)
 966             {
 967               index += LENGTH_OF_OPERATOR;
 968               while (ISSPACE(name[index]))
 969                 ++index;
 970               switch (name[index])
 971                 {
 972                   /* Skip over one less than the appropriate number of
 973                      characters: the for loop will skip over the last
 974                      one.  */
 975                 case '<':
 976                   if (name[index + 1] == '<')
 977                     index += 1;
 978                   else
 979                     index += 0;
 980                   break;
 981                 case '>':
 982                 case '-':
 983                   if (name[index + 1] == '>')
 984                     index += 1;
 985                   else
 986                     index += 0;
 987                   break;
 988                 case '(':
 989                   index += 1;
 990                   break;
 991                 default:
 992                   index += 0;
 993                   break;
 994                 }
 995             }
 996           operator_possible = 0;
 997           break;
 998         case ' ':
 999         case ',':
1000         case '.':
1001         case '&':
1002         case '*':
1003           /* NOTE: carlton/2003-04-18: I'm not sure what the precise
1004              set of relevant characters are here: it's necessary to
1005              include any character that can show up before 'operator'
1006              in a demangled name, and it's safe to include any
1007              character that can't be part of an identifier's name.  */
1008           operator_possible = 1;
1009           break;
1010         default:
1011           operator_possible = 0;
1012           break;
1013         }
1014     }
1015 }
1016
1017 /* Complain about a demangled name that we don't know how to parse.
1018    NAME is the demangled name in question.  */
1019
1020 static void
1021 demangled_name_complaint (const char *name)
1022 {
1023   complaint (&symfile_complaints,
1024              "unexpected demangled name '%s'", name);
1025 }
1026
1027 /* If NAME is the fully-qualified name of a C++
1028    function/variable/method/etc., this returns the length of its
1029    entire prefix: all of the namespaces and classes that make up its
1030    name.  Given 'A::foo', it returns 1, given 'A::B::foo', it returns
1031    4, given 'foo', it returns 0.  */
1032
1033 unsigned int
1034 cp_entire_prefix_len (const char *name)
1035 {
1036   unsigned int current_len = cp_find_first_component (name);
1037   unsigned int previous_len = 0;
1038
1039   while (name[current_len] != '\0')
1040     {
1041       gdb_assert (name[current_len] == ':');
1042       previous_len = current_len;
1043       /* Skip the '::'.  */
1044       current_len += 2;
1045       current_len += cp_find_first_component (name + current_len);
1046     }
1047
1048   return previous_len;
1049 }
1050
1051 /* Overload resolution functions.  */
1052
1053 /* Test to see if SYM is a symbol that we haven't seen corresponding
1054    to a function named OLOAD_NAME.  If so, add it to the current
1055    completion list.  */
1056
1057 static void
1058 overload_list_add_symbol (struct symbol *sym,
1059                           const char *oload_name)
1060 {
1061   int newsize;
1062   int i;
1063   char *sym_name;
1064
1065   /* If there is no type information, we can't do anything, so
1066      skip.  */
1067   if (SYMBOL_TYPE (sym) == NULL)
1068     return;
1069
1070   /* skip any symbols that we've already considered.  */
1071   for (i = 0; i < sym_return_val_index; ++i)
1072     if (strcmp (SYMBOL_LINKAGE_NAME (sym),
1073                 SYMBOL_LINKAGE_NAME (sym_return_val[i])) == 0)
1074       return;
1075
1076   /* Get the demangled name without parameters */
1077   sym_name = cp_remove_params (SYMBOL_NATURAL_NAME (sym));
1078   if (!sym_name)
1079     return;
1080
1081   /* skip symbols that cannot match */
1082   if (strcmp (sym_name, oload_name) != 0)
1083     {
1084       xfree (sym_name);
1085       return;
1086     }
1087
1088   xfree (sym_name);
1089
1090   /* We have a match for an overload instance, so add SYM to the
1091      current list of overload instances */
1092   if (sym_return_val_index + 3 > sym_return_val_size)
1093     {
1094       newsize = (sym_return_val_size *= 2) * sizeof (struct symbol *);
1095       sym_return_val = (struct symbol **)
1096         xrealloc ((char *) sym_return_val, newsize);
1097     }
1098   sym_return_val[sym_return_val_index++] = sym;
1099   sym_return_val[sym_return_val_index] = NULL;
1100 }
1101
1102 /* Return a null-terminated list of pointers to function symbols that
1103    are named FUNC_NAME and are visible within NAMESPACE.  */
1104
1105 struct symbol **
1106 make_symbol_overload_list (const char *func_name,
1107                            const char *namespace)
1108 {
1109   struct cleanup *old_cleanups;
1110   const char *name;
1111
1112   sym_return_val_size = 100;
1113   sym_return_val_index = 0;
1114   sym_return_val = xmalloc ((sym_return_val_size + 1) *
1115                             sizeof (struct symbol *));
1116   sym_return_val[0] = NULL;
1117
1118   old_cleanups = make_cleanup (xfree, sym_return_val);
1119
1120   make_symbol_overload_list_using (func_name, namespace);
1121
1122   if (namespace[0] == '\0')
1123     name = func_name;
1124   else
1125     {
1126       char *concatenated_name
1127         = alloca (strlen (namespace) + 2 + strlen (func_name) + 1);
1128       strcpy (concatenated_name, namespace);
1129       strcat (concatenated_name, "::");
1130       strcat (concatenated_name, func_name);
1131       name = concatenated_name;
1132     }
1133
1134   make_symbol_overload_list_qualified (name);
1135
1136   discard_cleanups (old_cleanups);
1137
1138   return sym_return_val;
1139 }
1140
1141 /* Add all symbols with a name matching NAME in BLOCK to the overload
1142    list.  */
1143
1144 static void
1145 make_symbol_overload_list_block (const char *name,
1146                                  const struct block *block)
1147 {
1148   struct dict_iterator iter;
1149   struct symbol *sym;
1150
1151   const struct dictionary *dict = BLOCK_DICT (block);
1152
1153   for (sym = dict_iter_name_first (dict, name, &iter);
1154        sym != NULL;
1155        sym = dict_iter_name_next (name, &iter))
1156     overload_list_add_symbol (sym, name);
1157 }
1158
1159 /* Adds the function FUNC_NAME from NAMESPACE to the overload set.  */
1160
1161 static void
1162 make_symbol_overload_list_namespace (const char *func_name,
1163                                      const char *namespace)
1164 {
1165   const char *name;
1166   const struct block *block = NULL;
1167
1168   if (namespace[0] == '\0')
1169     name = func_name;
1170   else
1171     {
1172       char *concatenated_name
1173         = alloca (strlen (namespace) + 2 + strlen (func_name) + 1);
1174
1175       strcpy (concatenated_name, namespace);
1176       strcat (concatenated_name, "::");
1177       strcat (concatenated_name, func_name);
1178       name = concatenated_name;
1179     }
1180
1181   /* Look in the static block.  */
1182   block = block_static_block (get_selected_block (0));
1183   if (block)
1184     make_symbol_overload_list_block (name, block);
1185
1186   /* Look in the global block.  */
1187   block = block_global_block (block);
1188   if (block)
1189     make_symbol_overload_list_block (name, block);
1190
1191 }
1192
1193 /* Search the namespace of the given type and namespace of and public
1194    base types.  */
1195
1196 static void
1197 make_symbol_overload_list_adl_namespace (struct type *type,
1198                                          const char *func_name)
1199 {
1200   char *namespace;
1201   char *type_name;
1202   int i, prefix_len;
1203
1204   while (TYPE_CODE (type) == TYPE_CODE_PTR
1205          || TYPE_CODE (type) == TYPE_CODE_REF
1206          || TYPE_CODE (type) == TYPE_CODE_ARRAY
1207          || TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1208     {
1209       if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1210         type = check_typedef(type);
1211       else
1212         type = TYPE_TARGET_TYPE (type);
1213     }
1214
1215   type_name = TYPE_NAME (type);
1216
1217   if (type_name == NULL)
1218     return;
1219
1220   prefix_len = cp_entire_prefix_len (type_name);
1221
1222   if (prefix_len != 0)
1223     {
1224       namespace = alloca (prefix_len + 1);
1225       strncpy (namespace, type_name, prefix_len);
1226       namespace[prefix_len] = '\0';
1227
1228       make_symbol_overload_list_namespace (func_name, namespace);
1229     }
1230
1231   /* Check public base type */
1232   if (TYPE_CODE (type) == TYPE_CODE_CLASS)
1233     for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
1234       {
1235         if (BASETYPE_VIA_PUBLIC (type, i))
1236           make_symbol_overload_list_adl_namespace (TYPE_BASECLASS (type,
1237                                                                    i),
1238                                                    func_name);
1239       }
1240 }
1241
1242 /* Adds the overload list overload candidates for FUNC_NAME found
1243    through argument dependent lookup.  */
1244
1245 struct symbol **
1246 make_symbol_overload_list_adl (struct type **arg_types, int nargs,
1247                                const char *func_name)
1248 {
1249   int i;
1250
1251   gdb_assert (sym_return_val_size != -1);
1252
1253   for (i = 1; i <= nargs; i++)
1254     make_symbol_overload_list_adl_namespace (arg_types[i - 1],
1255                                              func_name);
1256
1257   return sym_return_val;
1258 }
1259
1260 /* Used for cleanups to reset the "searched" flag in case of an
1261    error.  */
1262
1263 static void
1264 reset_directive_searched (void *data)
1265 {
1266   struct using_direct *direct = data;
1267   direct->searched = 0;
1268 }
1269
1270 /* This applies the using directives to add namespaces to search in,
1271    and then searches for overloads in all of those namespaces.  It
1272    adds the symbols found to sym_return_val.  Arguments are as in
1273    make_symbol_overload_list.  */
1274
1275 static void
1276 make_symbol_overload_list_using (const char *func_name,
1277                                  const char *namespace)
1278 {
1279   struct using_direct *current;
1280   const struct block *block;
1281
1282   /* First, go through the using directives.  If any of them apply,
1283      look in the appropriate namespaces for new functions to match
1284      on.  */
1285
1286   for (block = get_selected_block (0);
1287        block != NULL;
1288        block = BLOCK_SUPERBLOCK (block))
1289     for (current = block_using (block);
1290         current != NULL;
1291         current = current->next)
1292       {
1293         /* Prevent recursive calls.  */
1294         if (current->searched)
1295           continue;
1296
1297         /* If this is a namespace alias or imported declaration ignore
1298            it.  */
1299         if (current->alias != NULL || current->declaration != NULL)
1300           continue;
1301
1302         if (strcmp (namespace, current->import_dest) == 0)
1303           {
1304             /* Mark this import as searched so that the recursive call
1305                does not search it again.  */
1306             struct cleanup *old_chain;
1307             current->searched = 1;
1308             old_chain = make_cleanup (reset_directive_searched,
1309                                       current);
1310
1311             make_symbol_overload_list_using (func_name,
1312                                              current->import_src);
1313
1314             current->searched = 0;
1315             discard_cleanups (old_chain);
1316           }
1317       }
1318
1319   /* Now, add names for this namespace.  */
1320   make_symbol_overload_list_namespace (func_name, namespace);
1321 }
1322
1323 /* This does the bulk of the work of finding overloaded symbols.
1324    FUNC_NAME is the name of the overloaded function we're looking for
1325    (possibly including namespace info).  */
1326
1327 static void
1328 make_symbol_overload_list_qualified (const char *func_name)
1329 {
1330   struct symbol *sym;
1331   struct symtab *s;
1332   struct objfile *objfile;
1333   const struct block *b, *surrounding_static_block = 0;
1334   struct dict_iterator iter;
1335   const struct dictionary *dict;
1336
1337   /* Look through the partial symtabs for all symbols which begin by
1338      matching FUNC_NAME.  Make sure we read that symbol table in.  */
1339
1340   ALL_OBJFILES (objfile)
1341   {
1342     if (objfile->sf)
1343       objfile->sf->qf->expand_symtabs_for_function (objfile, func_name);
1344   }
1345
1346   /* Search upwards from currently selected frame (so that we can
1347      complete on local vars.  */
1348
1349   for (b = get_selected_block (0); b != NULL; b = BLOCK_SUPERBLOCK (b))
1350     make_symbol_overload_list_block (func_name, b);
1351
1352   surrounding_static_block = block_static_block (get_selected_block (0));
1353
1354   /* Go through the symtabs and check the externs and statics for
1355      symbols which match.  */
1356
1357   ALL_PRIMARY_SYMTABS (objfile, s)
1358   {
1359     QUIT;
1360     b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
1361     make_symbol_overload_list_block (func_name, b);
1362   }
1363
1364   ALL_PRIMARY_SYMTABS (objfile, s)
1365   {
1366     QUIT;
1367     b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
1368     /* Don't do this block twice.  */
1369     if (b == surrounding_static_block)
1370       continue;
1371     make_symbol_overload_list_block (func_name, b);
1372   }
1373 }
1374
1375 /* Lookup the rtti type for a class name.  */
1376
1377 struct type *
1378 cp_lookup_rtti_type (const char *name, struct block *block)
1379 {
1380   struct symbol * rtti_sym;
1381   struct type * rtti_type;
1382
1383   rtti_sym = lookup_symbol (name, block, STRUCT_DOMAIN, NULL);
1384
1385   if (rtti_sym == NULL)
1386     {
1387       warning (_("RTTI symbol not found for class '%s'"), name);
1388       return NULL;
1389     }
1390
1391   if (SYMBOL_CLASS (rtti_sym) != LOC_TYPEDEF)
1392     {
1393       warning (_("RTTI symbol for class '%s' is not a type"), name);
1394       return NULL;
1395     }
1396
1397   rtti_type = SYMBOL_TYPE (rtti_sym);
1398
1399   switch (TYPE_CODE (rtti_type))
1400     {
1401     case TYPE_CODE_CLASS:
1402       break;
1403     case TYPE_CODE_NAMESPACE:
1404       /* chastain/2003-11-26: the symbol tables often contain fake
1405          symbols for namespaces with the same name as the struct.
1406          This warning is an indication of a bug in the lookup order
1407          or a bug in the way that the symbol tables are populated.  */
1408       warning (_("RTTI symbol for class '%s' is a namespace"), name);
1409       return NULL;
1410     default:
1411       warning (_("RTTI symbol for class '%s' has bad type"), name);
1412       return NULL;
1413     }
1414
1415   return rtti_type;
1416 }
1417
1418 /* Don't allow just "maintenance cplus".  */
1419
1420 static  void
1421 maint_cplus_command (char *arg, int from_tty)
1422 {
1423   printf_unfiltered (_("\"maintenance cplus\" must be followed "
1424                        "by the name of a command.\n"));
1425   help_list (maint_cplus_cmd_list,
1426              "maintenance cplus ",
1427              -1, gdb_stdout);
1428 }
1429
1430 /* This is a front end for cp_find_first_component, for unit testing.
1431    Be careful when using it: see the NOTE above
1432    cp_find_first_component.  */
1433
1434 static void
1435 first_component_command (char *arg, int from_tty)
1436 {
1437   int len;
1438   char *prefix;
1439
1440   if (!arg)
1441     return;
1442
1443   len = cp_find_first_component (arg);
1444   prefix = alloca (len + 1);
1445
1446   memcpy (prefix, arg, len);
1447   prefix[len] = '\0';
1448
1449   printf_unfiltered ("%s\n", prefix);
1450 }
1451
1452 extern initialize_file_ftype _initialize_cp_support; /* -Wmissing-prototypes */
1453
1454 #define SKIP_SPACE(P)                           \
1455   do                                            \
1456   {                                             \
1457     while (*(P) == ' ' || *(P) == '\t')         \
1458       ++(P);                                    \
1459   }                                             \
1460   while (0)
1461
1462 /* Returns the length of the operator name or 0 if INPUT does not
1463    point to a valid C++ operator.  INPUT should start with
1464    "operator".  */
1465 int
1466 cp_validate_operator (const char *input)
1467 {
1468   int i;
1469   char *copy;
1470   const char *p;
1471   struct expression *expr;
1472   struct value *val;
1473   volatile struct gdb_exception except;
1474
1475   p = input;
1476
1477   if (strncmp (p, "operator", 8) == 0)
1478     {
1479       int valid = 0;
1480
1481       p += 8;
1482       SKIP_SPACE (p);
1483       for (i = 0;
1484            i < sizeof (operator_tokens) / sizeof (operator_tokens[0]);
1485            ++i)
1486         {
1487           int length = strlen (operator_tokens[i]);
1488
1489           /* By using strncmp here, we MUST have operator_tokens
1490              ordered!  See additional notes where operator_tokens is
1491              defined above.  */
1492           if (strncmp (p, operator_tokens[i], length) == 0)
1493             {
1494               const char *op = p;
1495
1496               valid = 1;
1497               p += length;
1498
1499               if (strncmp (op, "new", 3) == 0
1500                   || strncmp (op, "delete", 6) == 0)
1501                 {
1502
1503                   /* Special case: new[] and delete[].  We must be
1504                      careful to swallow whitespace before/in "[]".  */
1505                   SKIP_SPACE (p);
1506
1507                   if (*p == '[')
1508                     {
1509                       ++p;
1510                       SKIP_SPACE (p);
1511                       if (*p == ']')
1512                         ++p;
1513                       else
1514                         valid = 0;
1515                     }
1516                 }
1517
1518               if (valid)
1519                 return (p - input);
1520             }
1521         }
1522
1523       /* Check input for a conversion operator.  */
1524
1525       /* Skip past base typename.  */
1526       while (*p != '*' && *p != '&' && *p != 0 && *p != ' ')
1527         ++p;
1528       SKIP_SPACE (p);
1529
1530       /* Add modifiers '*' / '&'.  */
1531       while (*p == '*' || *p == '&')
1532         {
1533           ++p;
1534           SKIP_SPACE (p);
1535         }
1536
1537       /* Check for valid type.  [Remember: input starts with
1538          "operator".]  */
1539       copy = savestring (input + 8, p - input - 8);
1540       expr = NULL;
1541       val = NULL;
1542       TRY_CATCH (except, RETURN_MASK_ALL)
1543         {
1544           expr = parse_expression (copy);
1545           val = evaluate_type (expr);
1546         }
1547
1548       xfree (copy);
1549       if (expr)
1550         xfree (expr);
1551
1552       if (val != NULL && value_type (val) != NULL)
1553         return (p - input);
1554     }
1555
1556   return 0;
1557 }
1558
1559 void
1560 _initialize_cp_support (void)
1561 {
1562   add_prefix_cmd ("cplus", class_maintenance,
1563                   maint_cplus_command,
1564                   _("C++ maintenance commands."),
1565                   &maint_cplus_cmd_list,
1566                   "maintenance cplus ",
1567                   0, &maintenancelist);
1568   add_alias_cmd ("cp", "cplus",
1569                  class_maintenance, 1,
1570                  &maintenancelist);
1571
1572   add_cmd ("first_component",
1573            class_maintenance,
1574            first_component_command,
1575            _("Print the first class/namespace component of NAME."),
1576            &maint_cplus_cmd_list);
1577 }