gdb/cp-support.c

   1 /* Helper routines for C++ support in GDB.
   2    Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008, 2009
   3    Free Software Foundation, Inc.
   4
   5    Contributed by MontaVista Software.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "cp-support.h"
  24 #include "gdb_string.h"
  25 #include "demangle.h"
  26 #include "gdb_assert.h"
  27 #include "gdbcmd.h"
  28 #include "dictionary.h"
  29 #include "objfiles.h"
  30 #include "frame.h"
  31 #include "symtab.h"
  32 #include "block.h"
  33 #include "complaints.h"
  34 #include "gdbtypes.h"
  35 #include "exceptions.h"
  36 #include "expression.h"
  37 #include "value.h"
  38
  39 #include "safe-ctype.h"
  40
  41 #define d_left(dc) (dc)->u.s_binary.left
  42 #define d_right(dc) (dc)->u.s_binary.right
  43
  44 /* Functions related to demangled name parsing.  */
  45
  46 static unsigned int cp_find_first_component_aux (const char *name,
  47                                                  int permissive);
  48
  49 static void demangled_name_complaint (const char *name);
  50
  51 /* Functions/variables related to overload resolution.  */
  52
  53 static int sym_return_val_size;
  54 static int sym_return_val_index;
  55 static struct symbol **sym_return_val;
  56
  57 static void overload_list_add_symbol (struct symbol *sym,
  58                                       const char *oload_name);
  59
  60 static void make_symbol_overload_list_using (const char *func_name,
  61                                              const char *namespace);
  62
  63 static void make_symbol_overload_list_qualified (const char *func_name);
  64
  65 static void read_in_psymtabs (const char *oload_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 /* Operator validation.
  77    NOTE: Multi-byte operators (usually the assignment variety operator)
  78    must appear before the single byte version, i.e., "+=" 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 /* Return 1 if STRING is clearly already in canonical form.  This
  89    function is conservative; things which it does not recognize are
  90    assumed to be non-canonical, and the parser will sort them out
  91    afterwards.  This speeds up the critical path for alphanumeric
  92    identifiers.  */
  93
  94 static int
  95 cp_already_canonical (const char *string)
  96 {
  97   /* Identifier start character [a-zA-Z_].  */
  98   if (!ISIDST (string[0]))
  99     return 0;
 100
 101   /* These are the only two identifiers which canonicalize to other
 102      than themselves or an error: unsigned -> unsigned int and
 103      signed -> int.  */
 104   if (string[0] == 'u' && strcmp (&string[1], "nsigned") == 0)
 105     return 0;
 106   else if (string[0] == 's' && strcmp (&string[1], "igned") == 0)
 107     return 0;
 108
 109   /* Identifier character [a-zA-Z0-9_].  */
 110   while (ISIDNUM (string[1]))
 111     string++;
 112
 113   if (string[1] == '\0')
 114     return 1;
 115   else
 116     return 0;
 117 }
 118
 119 /* Parse STRING and convert it to canonical form.  If parsing fails,
 120    or if STRING is already canonical, return NULL.  Otherwise return
 121    the canonical form.  The return value is allocated via xmalloc.  */
 122
 123 char *
 124 cp_canonicalize_string (const char *string)
 125 {
 126   struct demangle_component *ret_comp;
 127   unsigned int estimated_len;
 128   char *ret;
 129
 130   if (cp_already_canonical (string))
 131     return NULL;
 132
 133   ret_comp = cp_demangled_name_to_comp (string, NULL);
 134   if (ret_comp == NULL)
 135     return NULL;
 136
 137   estimated_len = strlen (string) * 2;
 138   ret = cp_comp_to_string (ret_comp, estimated_len);
 139
 140   if (strcmp (string, ret) == 0)
 141     {
 142       xfree (ret);
 143       return NULL;
 144     }
 145
 146   return ret;
 147 }
 148
 149 /* Convert a mangled name to a demangle_component tree.  *MEMORY is set to the
 150    block of used memory that should be freed when finished with the tree.
 151    DEMANGLED_P is set to the char * that should be freed when finished with
 152    the tree, or NULL if none was needed.  OPTIONS will be passed to the
 153    demangler.  */
 154
 155 static struct demangle_component *
 156 mangled_name_to_comp (const char *mangled_name, int options,
 157                       void **memory, char **demangled_p)
 158 {
 159   struct demangle_component *ret;
 160   char *demangled_name;
 161   int len;
 162
 163   /* If it looks like a v3 mangled name, then try to go directly
 164      to trees.  */
 165   if (mangled_name[0] == '_' && mangled_name[1] == 'Z')
 166     {
 167       ret = cplus_demangle_v3_components (mangled_name, options, memory);
 168       if (ret)
 169         {
 170           *demangled_p = NULL;
 171           return ret;
 172         }
 173     }
 174
 175   /* If it doesn't, or if that failed, then try to demangle the name.  */
 176   demangled_name = cplus_demangle (mangled_name, options);
 177   if (demangled_name == NULL)
 178    return NULL;
 179
 180   /* If we could demangle the name, parse it to build the component tree.  */
 181   ret = cp_demangled_name_to_comp (demangled_name, NULL);
 182
 183   if (ret == NULL)
 184     {
 185       xfree (demangled_name);
 186       return NULL;
 187     }
 188
 189   *demangled_p = demangled_name;
 190   return ret;
 191 }
 192
 193 /* Return the name of the class containing method PHYSNAME.  */
 194
 195 char *
 196 cp_class_name_from_physname (const char *physname)
 197 {
 198   void *storage = NULL;
 199   char *demangled_name = NULL, *ret;
 200   struct demangle_component *ret_comp, *prev_comp, *cur_comp;
 201   int done;
 202
 203   ret_comp = mangled_name_to_comp (physname, DMGL_ANSI, &storage,
 204                                    &demangled_name);
 205   if (ret_comp == NULL)
 206     return NULL;
 207
 208   done = 0;
 209
 210   /* First strip off any qualifiers, if we have a function or method.  */
 211   while (!done)
 212     switch (ret_comp->type)
 213       {
 214       case DEMANGLE_COMPONENT_CONST:
 215       case DEMANGLE_COMPONENT_RESTRICT:
 216       case DEMANGLE_COMPONENT_VOLATILE:
 217       case DEMANGLE_COMPONENT_CONST_THIS:
 218       case DEMANGLE_COMPONENT_RESTRICT_THIS:
 219       case DEMANGLE_COMPONENT_VOLATILE_THIS:
 220       case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
 221         ret_comp = d_left (ret_comp);
 222         break;
 223       default:
 224         done = 1;
 225         break;
 226       }
 227
 228   /* If what we have now is a function, discard the argument list.  */
 229   if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME)
 230     ret_comp = d_left (ret_comp);
 231
 232   /* If what we have now is a template, strip off the template
 233      arguments.  The left subtree may be a qualified name.  */
 234   if (ret_comp->type == DEMANGLE_COMPONENT_TEMPLATE)
 235     ret_comp = d_left (ret_comp);
 236
 237   /* What we have now should be a name, possibly qualified.  Additional
 238      qualifiers could live in the left subtree or the right subtree.  Find
 239      the last piece.  */
 240   done = 0;
 241   prev_comp = NULL;
 242   cur_comp = ret_comp;
 243   while (!done)
 244     switch (cur_comp->type)
 245       {
 246       case DEMANGLE_COMPONENT_QUAL_NAME:
 247       case DEMANGLE_COMPONENT_LOCAL_NAME:
 248         prev_comp = cur_comp;
 249         cur_comp = d_right (cur_comp);
 250         break;
 251       case DEMANGLE_COMPONENT_TEMPLATE:
 252       case DEMANGLE_COMPONENT_NAME:
 253       case DEMANGLE_COMPONENT_CTOR:
 254       case DEMANGLE_COMPONENT_DTOR:
 255       case DEMANGLE_COMPONENT_OPERATOR:
 256       case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
 257         done = 1;
 258         break;
 259       default:
 260         done = 1;
 261         cur_comp = NULL;
 262         break;
 263       }
 264
 265   ret = NULL;
 266   if (cur_comp != NULL && prev_comp != NULL)
 267     {
 268       /* We want to discard the rightmost child of PREV_COMP.  */
 269       *prev_comp = *d_left (prev_comp);
 270       /* The ten is completely arbitrary; we don't have a good estimate.  */
 271       ret = cp_comp_to_string (ret_comp, 10);
 272     }
 273
 274   xfree (storage);
 275   if (demangled_name)
 276     xfree (demangled_name);
 277   return ret;
 278 }
 279
 280 /* Return the child of COMP which is the basename of a method, variable,
 281    et cetera.  All scope qualifiers are discarded, but template arguments
 282    will be included.  The component tree may be modified.  */
 283
 284 static struct demangle_component *
 285 unqualified_name_from_comp (struct demangle_component *comp)
 286 {
 287   struct demangle_component *ret_comp = comp, *last_template;
 288   int done;
 289
 290   done = 0;
 291   last_template = NULL;
 292   while (!done)
 293     switch (ret_comp->type)
 294       {
 295       case DEMANGLE_COMPONENT_QUAL_NAME:
 296       case DEMANGLE_COMPONENT_LOCAL_NAME:
 297         ret_comp = d_right (ret_comp);
 298         break;
 299       case DEMANGLE_COMPONENT_TYPED_NAME:
 300         ret_comp = d_left (ret_comp);
 301         break;
 302       case DEMANGLE_COMPONENT_TEMPLATE:
 303         gdb_assert (last_template == NULL);
 304         last_template = ret_comp;
 305         ret_comp = d_left (ret_comp);
 306         break;
 307       case DEMANGLE_COMPONENT_CONST:
 308       case DEMANGLE_COMPONENT_RESTRICT:
 309       case DEMANGLE_COMPONENT_VOLATILE:
 310       case DEMANGLE_COMPONENT_CONST_THIS:
 311       case DEMANGLE_COMPONENT_RESTRICT_THIS:
 312       case DEMANGLE_COMPONENT_VOLATILE_THIS:
 313       case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
 314         ret_comp = d_left (ret_comp);
 315         break;
 316       case DEMANGLE_COMPONENT_NAME:
 317       case DEMANGLE_COMPONENT_CTOR:
 318       case DEMANGLE_COMPONENT_DTOR:
 319       case DEMANGLE_COMPONENT_OPERATOR:
 320       case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
 321         done = 1;
 322         break;
 323       default:
 324         return NULL;
 325         break;
 326       }
 327
 328   if (last_template)
 329     {
 330       d_left (last_template) = ret_comp;
 331       return last_template;
 332     }
 333
 334   return ret_comp;
 335 }
 336
 337 /* Return the name of the method whose linkage name is PHYSNAME.  */
 338
 339 char *
 340 method_name_from_physname (const char *physname)
 341 {
 342   void *storage = NULL;
 343   char *demangled_name = NULL, *ret;
 344   struct demangle_component *ret_comp;
 345   int done;
 346
 347   ret_comp = mangled_name_to_comp (physname, DMGL_ANSI, &storage,
 348                                    &demangled_name);
 349   if (ret_comp == NULL)
 350     return NULL;
 351
 352   ret_comp = unqualified_name_from_comp (ret_comp);
 353
 354   ret = NULL;
 355   if (ret_comp != NULL)
 356     /* The ten is completely arbitrary; we don't have a good estimate.  */
 357     ret = cp_comp_to_string (ret_comp, 10);
 358
 359   xfree (storage);
 360   if (demangled_name)
 361     xfree (demangled_name);
 362   return ret;
 363 }
 364
 365 /* If FULL_NAME is the demangled name of a C++ function (including an
 366    arg list, possibly including namespace/class qualifications),
 367    return a new string containing only the function name (without the
 368    arg list/class qualifications).  Otherwise, return NULL.  The
 369    caller is responsible for freeing the memory in question.  */
 370
 371 char *
 372 cp_func_name (const char *full_name)
 373 {
 374   char *ret;
 375   struct demangle_component *ret_comp;
 376   int done;
 377
 378   ret_comp = cp_demangled_name_to_comp (full_name, NULL);
 379   if (!ret_comp)
 380     return NULL;
 381
 382   ret_comp = unqualified_name_from_comp (ret_comp);
 383
 384   ret = NULL;
 385   if (ret_comp != NULL)
 386     ret = cp_comp_to_string (ret_comp, 10);
 387
 388   return ret;
 389 }
 390
 391 /* DEMANGLED_NAME is the name of a function, including parameters and
 392    (optionally) a return type.  Return the name of the function without
 393    parameters or return type, or NULL if we can not parse the name.  */
 394
 395 char *
 396 cp_remove_params (const char *demangled_name)
 397 {
 398   int done = 0;
 399   struct demangle_component *ret_comp;
 400   char *ret = NULL;
 401
 402   if (demangled_name == NULL)
 403     return NULL;
 404
 405   ret_comp = cp_demangled_name_to_comp (demangled_name, NULL);
 406   if (ret_comp == NULL)
 407     return NULL;
 408
 409   /* First strip off any qualifiers, if we have a function or method.  */
 410   while (!done)
 411     switch (ret_comp->type)
 412       {
 413       case DEMANGLE_COMPONENT_CONST:
 414       case DEMANGLE_COMPONENT_RESTRICT:
 415       case DEMANGLE_COMPONENT_VOLATILE:
 416       case DEMANGLE_COMPONENT_CONST_THIS:
 417       case DEMANGLE_COMPONENT_RESTRICT_THIS:
 418       case DEMANGLE_COMPONENT_VOLATILE_THIS:
 419       case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
 420         ret_comp = d_left (ret_comp);
 421         break;
 422       default:
 423         done = 1;
 424         break;
 425       }
 426
 427   /* What we have now should be a function.  Return its name.  */
 428   if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME)
 429     ret = cp_comp_to_string (d_left (ret_comp), 10);
 430
 431   return ret;
 432 }
 433
 434 /* Here are some random pieces of trivia to keep in mind while trying
 435    to take apart demangled names:
 436
 437    - Names can contain function arguments or templates, so the process
 438      has to be, to some extent recursive: maybe keep track of your
 439      depth based on encountering <> and ().
 440
 441    - Parentheses don't just have to happen at the end of a name: they
 442      can occur even if the name in question isn't a function, because
 443      a template argument might be a type that's a function.
 444
 445    - Conversely, even if you're trying to deal with a function, its
 446      demangled name might not end with ')': it could be a const or
 447      volatile class method, in which case it ends with "const" or
 448      "volatile".
 449
 450    - Parentheses are also used in anonymous namespaces: a variable
 451      'foo' in an anonymous namespace gets demangled as "(anonymous
 452      namespace)::foo".
 453
 454    - And operator names can contain parentheses or angle brackets.  */
 455
 456 /* FIXME: carlton/2003-03-13: We have several functions here with
 457    overlapping functionality; can we combine them?  Also, do they
 458    handle all the above considerations correctly?  */
 459
 460
 461 /* This returns the length of first component of NAME, which should be
 462    the demangled name of a C++ variable/function/method/etc.
 463    Specifically, it returns the index of the first colon forming the
 464    boundary of the first component: so, given 'A::foo' or 'A::B::foo'
 465    it returns the 1, and given 'foo', it returns 0.  */
 466
 467 /* The character in NAME indexed by the return value is guaranteed to
 468    always be either ':' or '\0'.  */
 469
 470 /* NOTE: carlton/2003-03-13: This function is currently only intended
 471    for internal use: it's probably not entirely safe when called on
 472    user-generated input, because some of the 'index += 2' lines in
 473    cp_find_first_component_aux might go past the end of malformed
 474    input.  */
 475
 476 unsigned int
 477 cp_find_first_component (const char *name)
 478 {
 479   return cp_find_first_component_aux (name, 0);
 480 }
 481
 482 /* Helper function for cp_find_first_component.  Like that function,
 483    it returns the length of the first component of NAME, but to make
 484    the recursion easier, it also stops if it reaches an unexpected ')'
 485    or '>' if the value of PERMISSIVE is nonzero.  */
 486
 487 /* Let's optimize away calls to strlen("operator").  */
 488
 489 #define LENGTH_OF_OPERATOR 8
 490
 491 static unsigned int
 492 cp_find_first_component_aux (const char *name, int permissive)
 493 {
 494   unsigned int index = 0;
 495   /* Operator names can show up in unexpected places.  Since these can
 496      contain parentheses or angle brackets, they can screw up the
 497      recursion.  But not every string 'operator' is part of an
 498      operater name: e.g. you could have a variable 'cooperator'.  So
 499      this variable tells us whether or not we should treat the string
 500      'operator' as starting an operator.  */
 501   int operator_possible = 1;
 502
 503   for (;; ++index)
 504     {
 505       switch (name[index])
 506         {
 507         case '<':
 508           /* Template; eat it up.  The calls to cp_first_component
 509              should only return (I hope!) when they reach the '>'
 510              terminating the component or a '::' between two
 511              components.  (Hence the '+ 2'.)  */
 512           index += 1;
 513           for (index += cp_find_first_component_aux (name + index, 1);
 514                name[index] != '>';
 515                index += cp_find_first_component_aux (name + index, 1))
 516             {
 517               if (name[index] != ':')
 518                 {
 519                   demangled_name_complaint (name);
 520                   return strlen (name);
 521                 }
 522               index += 2;
 523             }
 524           operator_possible = 1;
 525           break;
 526         case '(':
 527           /* Similar comment as to '<'.  */
 528           index += 1;
 529           for (index += cp_find_first_component_aux (name + index, 1);
 530                name[index] != ')';
 531                index += cp_find_first_component_aux (name + index, 1))
 532             {
 533               if (name[index] != ':')
 534                 {
 535                   demangled_name_complaint (name);
 536                   return strlen (name);
 537                 }
 538               index += 2;
 539             }
 540           operator_possible = 1;
 541           break;
 542         case '>':
 543         case ')':
 544           if (permissive)
 545             return index;
 546           else
 547             {
 548               demangled_name_complaint (name);
 549               return strlen (name);
 550             }
 551         case '\0':
 552         case ':':
 553           return index;
 554         case 'o':
 555           /* Operator names can screw up the recursion.  */
 556           if (operator_possible
 557               && strncmp (name + index, "operator", LENGTH_OF_OPERATOR) == 0)
 558             {
 559               index += LENGTH_OF_OPERATOR;
 560               while (ISSPACE(name[index]))
 561                 ++index;
 562               switch (name[index])
 563                 {
 564                   /* Skip over one less than the appropriate number of
 565                      characters: the for loop will skip over the last
 566                      one.  */
 567                 case '<':
 568                   if (name[index + 1] == '<')
 569                     index += 1;
 570                   else
 571                     index += 0;
 572                   break;
 573                 case '>':
 574                 case '-':
 575                   if (name[index + 1] == '>')
 576                     index += 1;
 577                   else
 578                     index += 0;
 579                   break;
 580                 case '(':
 581                   index += 1;
 582                   break;
 583                 default:
 584                   index += 0;
 585                   break;
 586                 }
 587             }
 588           operator_possible = 0;
 589           break;
 590         case ' ':
 591         case ',':
 592         case '.':
 593         case '&':
 594         case '*':
 595           /* NOTE: carlton/2003-04-18: I'm not sure what the precise
 596              set of relevant characters are here: it's necessary to
 597              include any character that can show up before 'operator'
 598              in a demangled name, and it's safe to include any
 599              character that can't be part of an identifier's name.  */
 600           operator_possible = 1;
 601           break;
 602         default:
 603           operator_possible = 0;
 604           break;
 605         }
 606     }
 607 }
 608
 609 /* Complain about a demangled name that we don't know how to parse.
 610    NAME is the demangled name in question.  */
 611
 612 static void
 613 demangled_name_complaint (const char *name)
 614 {
 615   complaint (&symfile_complaints,
 616              "unexpected demangled name '%s'", name);
 617 }
 618
 619 /* If NAME is the fully-qualified name of a C++
 620    function/variable/method/etc., this returns the length of its
 621    entire prefix: all of the namespaces and classes that make up its
 622    name.  Given 'A::foo', it returns 1, given 'A::B::foo', it returns
 623    4, given 'foo', it returns 0.  */
 624
 625 unsigned int
 626 cp_entire_prefix_len (const char *name)
 627 {
 628   unsigned int current_len = cp_find_first_component (name);
 629   unsigned int previous_len = 0;
 630
 631   while (name[current_len] != '\0')
 632     {
 633       gdb_assert (name[current_len] == ':');
 634       previous_len = current_len;
 635       /* Skip the '::'.  */
 636       current_len += 2;
 637       current_len += cp_find_first_component (name + current_len);
 638     }
 639
 640   return previous_len;
 641 }
 642
 643 /* Overload resolution functions.  */
 644
 645 /* Test to see if SYM is a symbol that we haven't seen corresponding
 646    to a function named OLOAD_NAME.  If so, add it to the current
 647    completion list. */
 648
 649 static void
 650 overload_list_add_symbol (struct symbol *sym, const char *oload_name)
 651 {
 652   int newsize;
 653   int i;
 654   char *sym_name;
 655
 656   /* If there is no type information, we can't do anything, so skip */
 657   if (SYMBOL_TYPE (sym) == NULL)
 658     return;
 659
 660   /* skip any symbols that we've already considered. */
 661   for (i = 0; i < sym_return_val_index; ++i)
 662     if (strcmp (SYMBOL_LINKAGE_NAME (sym),
 663                 SYMBOL_LINKAGE_NAME (sym_return_val[i])) == 0)
 664       return;
 665
 666   /* Get the demangled name without parameters */
 667   sym_name = cp_remove_params (SYMBOL_NATURAL_NAME (sym));
 668   if (!sym_name)
 669     return;
 670
 671   /* skip symbols that cannot match */
 672   if (strcmp (sym_name, oload_name) != 0)
 673     {
 674       xfree (sym_name);
 675       return;
 676     }
 677
 678   xfree (sym_name);
 679
 680   /* We have a match for an overload instance, so add SYM to the current list
 681    * of overload instances */
 682   if (sym_return_val_index + 3 > sym_return_val_size)
 683     {
 684       newsize = (sym_return_val_size *= 2) * sizeof (struct symbol *);
 685       sym_return_val = (struct symbol **) xrealloc ((char *) sym_return_val, newsize);
 686     }
 687   sym_return_val[sym_return_val_index++] = sym;
 688   sym_return_val[sym_return_val_index] = NULL;
 689 }
 690
 691 /* Return a null-terminated list of pointers to function symbols that
 692    are named FUNC_NAME and are visible within NAMESPACE.  */
 693
 694 struct symbol **
 695 make_symbol_overload_list (const char *func_name,
 696                            const char *namespace)
 697 {
 698   struct cleanup *old_cleanups;
 699
 700   sym_return_val_size = 100;
 701   sym_return_val_index = 0;
 702   sym_return_val = xmalloc ((sym_return_val_size + 1) *
 703                             sizeof (struct symbol *));
 704   sym_return_val[0] = NULL;
 705
 706   old_cleanups = make_cleanup (xfree, sym_return_val);
 707
 708   make_symbol_overload_list_using (func_name, namespace);
 709
 710   discard_cleanups (old_cleanups);
 711
 712   return sym_return_val;
 713 }
 714
 715 /* This applies the using directives to add namespaces to search in,
 716    and then searches for overloads in all of those namespaces.  It
 717    adds the symbols found to sym_return_val.  Arguments are as in
 718    make_symbol_overload_list.  */
 719
 720 static void
 721 make_symbol_overload_list_using (const char *func_name,
 722                                  const char *namespace)
 723 {
 724   const struct using_direct *current;
 725
 726   /* First, go through the using directives.  If any of them apply,
 727      look in the appropriate namespaces for new functions to match
 728      on.  */
 729
 730   for (current = block_using (get_selected_block (0));
 731        current != NULL;
 732        current = current->next)
 733     {
 734       if (strcmp (namespace, current->import_dest) == 0)
 735         {
 736           make_symbol_overload_list_using (func_name,
 737                                            current->import_src);
 738         }
 739     }
 740
 741   /* Now, add names for this namespace.  */
 742
 743   if (namespace[0] == '\0')
 744     {
 745       make_symbol_overload_list_qualified (func_name);
 746     }
 747   else
 748     {
 749       char *concatenated_name
 750         = alloca (strlen (namespace) + 2 + strlen (func_name) + 1);
 751       strcpy (concatenated_name, namespace);
 752       strcat (concatenated_name, "::");
 753       strcat (concatenated_name, func_name);
 754       make_symbol_overload_list_qualified (concatenated_name);
 755     }
 756 }
 757
 758 /* This does the bulk of the work of finding overloaded symbols.
 759    FUNC_NAME is the name of the overloaded function we're looking for
 760    (possibly including namespace info).  */
 761
 762 static void
 763 make_symbol_overload_list_qualified (const char *func_name)
 764 {
 765   struct symbol *sym;
 766   struct symtab *s;
 767   struct objfile *objfile;
 768   const struct block *b, *surrounding_static_block = 0;
 769   struct dict_iterator iter;
 770   const struct dictionary *dict;
 771
 772   /* Look through the partial symtabs for all symbols which begin
 773      by matching FUNC_NAME.  Make sure we read that symbol table in. */
 774
 775   read_in_psymtabs (func_name);
 776
 777   /* Search upwards from currently selected frame (so that we can
 778      complete on local vars.  */
 779
 780   for (b = get_selected_block (0); b != NULL; b = BLOCK_SUPERBLOCK (b))
 781     {
 782       dict = BLOCK_DICT (b);
 783
 784       for (sym = dict_iter_name_first (dict, func_name, &iter);
 785            sym;
 786            sym = dict_iter_name_next (func_name, &iter))
 787         {
 788           overload_list_add_symbol (sym, func_name);
 789         }
 790     }
 791
 792   surrounding_static_block = block_static_block (get_selected_block (0));
 793
 794   /* Go through the symtabs and check the externs and statics for
 795      symbols which match.  */
 796
 797   ALL_PRIMARY_SYMTABS (objfile, s)
 798   {
 799     QUIT;
 800     b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
 801     dict = BLOCK_DICT (b);
 802
 803     for (sym = dict_iter_name_first (dict, func_name, &iter);
 804          sym;
 805          sym = dict_iter_name_next (func_name, &iter))
 806     {
 807       overload_list_add_symbol (sym, func_name);
 808     }
 809   }
 810
 811   ALL_PRIMARY_SYMTABS (objfile, s)
 812   {
 813     QUIT;
 814     b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
 815     /* Don't do this block twice.  */
 816     if (b == surrounding_static_block)
 817       continue;
 818     dict = BLOCK_DICT (b);
 819
 820     for (sym = dict_iter_name_first (dict, func_name, &iter);
 821          sym;
 822          sym = dict_iter_name_next (func_name, &iter))
 823     {
 824       overload_list_add_symbol (sym, func_name);
 825     }
 826   }
 827 }
 828
 829 /* Look through the partial symtabs for all symbols which begin
 830    by matching FUNC_NAME.  Make sure we read that symbol table in. */
 831
 832 static void
 833 read_in_psymtabs (const char *func_name)
 834 {
 835   struct partial_symtab *ps;
 836   struct objfile *objfile;
 837
 838   ALL_PSYMTABS (objfile, ps)
 839   {
 840     if (ps->readin)
 841       continue;
 842
 843     if ((lookup_partial_symbol (ps, func_name, NULL, 1, VAR_DOMAIN)
 844          != NULL)
 845         || (lookup_partial_symbol (ps, func_name, NULL, 0, VAR_DOMAIN)
 846             != NULL))
 847       psymtab_to_symtab (ps);
 848   }
 849 }
 850
 851 /* Lookup the rtti type for a class name. */
 852
 853 struct type *
 854 cp_lookup_rtti_type (const char *name, struct block *block)
 855 {
 856   struct symbol * rtti_sym;
 857   struct type * rtti_type;
 858
 859   rtti_sym = lookup_symbol (name, block, STRUCT_DOMAIN, NULL);
 860
 861   if (rtti_sym == NULL)
 862     {
 863       warning (_("RTTI symbol not found for class '%s'"), name);
 864       return NULL;
 865     }
 866
 867   if (SYMBOL_CLASS (rtti_sym) != LOC_TYPEDEF)
 868     {
 869       warning (_("RTTI symbol for class '%s' is not a type"), name);
 870       return NULL;
 871     }
 872
 873   rtti_type = SYMBOL_TYPE (rtti_sym);
 874
 875   switch (TYPE_CODE (rtti_type))
 876     {
 877     case TYPE_CODE_CLASS:
 878       break;
 879     case TYPE_CODE_NAMESPACE:
 880       /* chastain/2003-11-26: the symbol tables often contain fake
 881          symbols for namespaces with the same name as the struct.
 882          This warning is an indication of a bug in the lookup order
 883          or a bug in the way that the symbol tables are populated.  */
 884       warning (_("RTTI symbol for class '%s' is a namespace"), name);
 885       return NULL;
 886     default:
 887       warning (_("RTTI symbol for class '%s' has bad type"), name);
 888       return NULL;
 889     }
 890
 891   return rtti_type;
 892 }
 893
 894 /* Don't allow just "maintenance cplus".  */
 895
 896 static  void
 897 maint_cplus_command (char *arg, int from_tty)
 898 {
 899   printf_unfiltered (_("\"maintenance cplus\" must be followed by the name of a command.\n"));
 900   help_list (maint_cplus_cmd_list, "maintenance cplus ", -1, gdb_stdout);
 901 }
 902
 903 /* This is a front end for cp_find_first_component, for unit testing.
 904    Be careful when using it: see the NOTE above
 905    cp_find_first_component.  */
 906
 907 static void
 908 first_component_command (char *arg, int from_tty)
 909 {
 910   int len;
 911   char *prefix;
 912
 913   if (!arg)
 914     return;
 915
 916   len = cp_find_first_component (arg);
 917   prefix = alloca (len + 1);
 918
 919   memcpy (prefix, arg, len);
 920   prefix[len] = '\0';
 921
 922   printf_unfiltered ("%s\n", prefix);
 923 }
 924
 925 extern initialize_file_ftype _initialize_cp_support; /* -Wmissing-prototypes */
 926
 927 #define SKIP_SPACE(P)                           \
 928   do                                            \
 929   {                                             \
 930     while (*(P) == ' ' || *(P) == '\t')         \
 931       ++(P);                                    \
 932   }                                             \
 933   while (0)
 934
 935 /* Returns the length of the operator name or 0 if INPUT does not
 936    point to a valid C++ operator.  INPUT should start with "operator".  */
 937 int
 938 cp_validate_operator (const char *input)
 939 {
 940   int i;
 941   char *copy;
 942   const char *p;
 943   struct expression *expr;
 944   struct value *val;
 945   struct gdb_exception except;
 946   struct cleanup *old_chain;
 947
 948   p = input;
 949
 950   if (strncmp (p, "operator", 8) == 0)
 951     {
 952       int valid = 0;
 953       p += 8;
 954
 955       SKIP_SPACE (p);
 956       for (i = 0; i < sizeof (operator_tokens) / sizeof (operator_tokens[0]);
 957            ++i)
 958         {
 959           int length = strlen (operator_tokens[i]);
 960           /* By using strncmp here, we MUST have operator_tokens ordered!
 961              See additional notes where operator_tokens is defined above.  */
 962           if (strncmp (p, operator_tokens[i], length) == 0)
 963             {
 964               const char *op = p;
 965               valid = 1;
 966               p += length;
 967
 968               if (strncmp (op, "new", 3) == 0
 969                   || strncmp (op, "delete", 6) == 0)
 970                 {
 971
 972                   /* Special case: new[] and delete[].  We must be careful
 973                      to swallow whitespace before/in "[]".  */
 974                   SKIP_SPACE (p);
 975
 976                   if (*p == '[')
 977                     {
 978                       ++p;
 979                       SKIP_SPACE (p);
 980                       if (*p == ']')
 981                         ++p;
 982                       else
 983                         valid = 0;
 984                     }
 985                 }
 986
 987               if (valid)
 988                 return (p - input);
 989             }
 990         }
 991
 992       /* Check input for a conversion operator.  */
 993
 994       /* Skip past base typename */
 995       while (*p != '*' && *p != '&' && *p != 0 && *p != ' ')
 996         ++p;
 997       SKIP_SPACE (p);
 998
 999       /* Add modifiers '*'/'&' */
1000       while (*p == '*' || *p == '&')
1001         {
1002           ++p;
1003           SKIP_SPACE (p);
1004         }
1005
1006       /* Check for valid type.  [Remember: input starts with
1007          "operator".]  */
1008       copy = savestring (input + 8, p - input - 8);
1009       expr = NULL;
1010       val = NULL;
1011       TRY_CATCH (except, RETURN_MASK_ALL)
1012         {
1013           expr = parse_expression (copy);
1014           val = evaluate_type (expr);
1015         }
1016
1017       xfree (copy);
1018       if (expr)
1019         xfree (expr);
1020
1021       if (val != NULL && value_type (val) != NULL)
1022         return (p - input);
1023     }
1024
1025   return 0;
1026 }
1027
1028 void
1029 _initialize_cp_support (void)
1030 {
1031   add_prefix_cmd ("cplus", class_maintenance, maint_cplus_command,
1032                   _("C++ maintenance commands."), &maint_cplus_cmd_list,
1033                   "maintenance cplus ", 0, &maintenancelist);
1034   add_alias_cmd ("cp", "cplus", class_maintenance, 1, &maintenancelist);
1035
1036   add_cmd ("first_component", class_maintenance, first_component_command,
1037            _("Print the first class/namespace component of NAME."),
1038            &maint_cplus_cmd_list);
1039 }