contrib/gdb-7/gdb/cp-support.c

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