gdb/cp-support.c

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