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 = -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 /* 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 /* Adds the function FUNC_NAME from NAMESPACE to the overload set.  */
 713
 714 static void
 715 make_symbol_overload_list_namespace (const char *func_name,
 716                                      const char *namespace)
 717 {
 718   if (namespace[0] == '\0')
 719     make_symbol_overload_list_qualified (func_name);
 720   else
 721     {
 722       char *concatenated_name
 723         = alloca (strlen (namespace) + 2 + strlen (func_name) + 1);
 724
 725       strcpy (concatenated_name, namespace);
 726       strcat (concatenated_name, "::");
 727       strcat (concatenated_name, func_name);
 728       make_symbol_overload_list_qualified (concatenated_name);
 729     }
 730 }
 731
 732 /* Search the namespace of the given type and namespace of and public base
 733  types.  */
 734
 735 static void
 736 make_symbol_overload_list_adl_namespace (struct type *type,
 737                                          const char *func_name)
 738 {
 739   char *namespace;
 740   char *type_name;
 741   int i, prefix_len;
 742
 743   while (TYPE_CODE (type) == TYPE_CODE_PTR || TYPE_CODE (type) == TYPE_CODE_REF
 744          || TYPE_CODE (type) == TYPE_CODE_ARRAY
 745          || TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
 746     {
 747       if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
 748         type = check_typedef(type);
 749       else
 750         type = TYPE_TARGET_TYPE (type);
 751     }
 752
 753   type_name = TYPE_NAME (type);
 754
 755   if (type_name == NULL)
 756     return;
 757
 758   prefix_len = cp_entire_prefix_len (type_name);
 759
 760   if (prefix_len != 0)
 761     {
 762       namespace = alloca (prefix_len + 1);
 763       strncpy (namespace, type_name, prefix_len);
 764       namespace[prefix_len] = '\0';
 765
 766       make_symbol_overload_list_namespace (func_name, namespace);
 767     }
 768
 769   /* Check public base type */
 770   if (TYPE_CODE (type) == TYPE_CODE_CLASS)
 771     for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
 772       {
 773         if (BASETYPE_VIA_PUBLIC (type, i))
 774           make_symbol_overload_list_adl_namespace (TYPE_BASECLASS (type, i),
 775                                                    func_name);
 776       }
 777 }
 778
 779 /* Adds the the overload list overload candidates for FUNC_NAME found through
 780    argument dependent lookup.  */
 781
 782 struct symbol **
 783 make_symbol_overload_list_adl (struct type **arg_types, int nargs,
 784                                const char *func_name)
 785 {
 786   int i;
 787
 788   gdb_assert (sym_return_val_size != -1);
 789
 790   for (i = 1; i <= nargs; i++)
 791     make_symbol_overload_list_adl_namespace (arg_types[i - 1], func_name);
 792
 793   return sym_return_val;
 794 }
 795
 796 /* This applies the using directives to add namespaces to search in,
 797    and then searches for overloads in all of those namespaces.  It
 798    adds the symbols found to sym_return_val.  Arguments are as in
 799    make_symbol_overload_list.  */
 800
 801 static void
 802 make_symbol_overload_list_using (const char *func_name,
 803                                  const char *namespace)
 804 {
 805   const struct using_direct *current;
 806   const struct block *block;
 807
 808   /* First, go through the using directives.  If any of them apply,
 809      look in the appropriate namespaces for new functions to match
 810      on.  */
 811
 812   for (block = get_selected_block (0);
 813        block != NULL;
 814        block = BLOCK_SUPERBLOCK (block))
 815     for (current = block_using (block);
 816         current != NULL;
 817         current = current->next)
 818       {
 819         /* If this is a namespace alias or imported declaration ignore it.  */
 820         if (current->alias != NULL || current->declaration != NULL)
 821           continue;
 822
 823         if (strcmp (namespace, current->import_dest) == 0)
 824           make_symbol_overload_list_using (func_name, current->import_src);
 825       }
 826
 827   /* Now, add names for this namespace.  */
 828   make_symbol_overload_list_namespace (func_name, namespace);
 829 }
 830
 831 /* This does the bulk of the work of finding overloaded symbols.
 832    FUNC_NAME is the name of the overloaded function we're looking for
 833    (possibly including namespace info).  */
 834
 835 static void
 836 make_symbol_overload_list_qualified (const char *func_name)
 837 {
 838   struct symbol *sym;
 839   struct symtab *s;
 840   struct objfile *objfile;
 841   const struct block *b, *surrounding_static_block = 0;
 842   struct dict_iterator iter;
 843   const struct dictionary *dict;
 844
 845   /* Look through the partial symtabs for all symbols which begin
 846      by matching FUNC_NAME.  Make sure we read that symbol table in. */
 847
 848   ALL_OBJFILES (objfile)
 849   {
 850     if (objfile->sf)
 851       objfile->sf->qf->expand_symtabs_for_function (objfile, func_name);
 852   }
 853
 854   /* Search upwards from currently selected frame (so that we can
 855      complete on local vars.  */
 856
 857   for (b = get_selected_block (0); b != NULL; b = BLOCK_SUPERBLOCK (b))
 858     {
 859       dict = BLOCK_DICT (b);
 860
 861       for (sym = dict_iter_name_first (dict, func_name, &iter);
 862            sym;
 863            sym = dict_iter_name_next (func_name, &iter))
 864         {
 865           overload_list_add_symbol (sym, func_name);
 866         }
 867     }
 868
 869   surrounding_static_block = block_static_block (get_selected_block (0));
 870
 871   /* Go through the symtabs and check the externs and statics for
 872      symbols which match.  */
 873
 874   ALL_PRIMARY_SYMTABS (objfile, s)
 875   {
 876     QUIT;
 877     b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
 878     dict = BLOCK_DICT (b);
 879
 880     for (sym = dict_iter_name_first (dict, func_name, &iter);
 881          sym;
 882          sym = dict_iter_name_next (func_name, &iter))
 883     {
 884       overload_list_add_symbol (sym, func_name);
 885     }
 886   }
 887
 888   ALL_PRIMARY_SYMTABS (objfile, s)
 889   {
 890     QUIT;
 891     b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
 892     /* Don't do this block twice.  */
 893     if (b == surrounding_static_block)
 894       continue;
 895     dict = BLOCK_DICT (b);
 896
 897     for (sym = dict_iter_name_first (dict, func_name, &iter);
 898          sym;
 899          sym = dict_iter_name_next (func_name, &iter))
 900     {
 901       overload_list_add_symbol (sym, func_name);
 902     }
 903   }
 904 }
 905
 906 /* Lookup the rtti type for a class name. */
 907
 908 struct type *
 909 cp_lookup_rtti_type (const char *name, struct block *block)
 910 {
 911   struct symbol * rtti_sym;
 912   struct type * rtti_type;
 913
 914   rtti_sym = lookup_symbol (name, block, STRUCT_DOMAIN, NULL);
 915
 916   if (rtti_sym == NULL)
 917     {
 918       warning (_("RTTI symbol not found for class '%s'"), name);
 919       return NULL;
 920     }
 921
 922   if (SYMBOL_CLASS (rtti_sym) != LOC_TYPEDEF)
 923     {
 924       warning (_("RTTI symbol for class '%s' is not a type"), name);
 925       return NULL;
 926     }
 927
 928   rtti_type = SYMBOL_TYPE (rtti_sym);
 929
 930   switch (TYPE_CODE (rtti_type))
 931     {
 932     case TYPE_CODE_CLASS:
 933       break;
 934     case TYPE_CODE_NAMESPACE:
 935       /* chastain/2003-11-26: the symbol tables often contain fake
 936          symbols for namespaces with the same name as the struct.
 937          This warning is an indication of a bug in the lookup order
 938          or a bug in the way that the symbol tables are populated.  */
 939       warning (_("RTTI symbol for class '%s' is a namespace"), name);
 940       return NULL;
 941     default:
 942       warning (_("RTTI symbol for class '%s' has bad type"), name);
 943       return NULL;
 944     }
 945
 946   return rtti_type;
 947 }
 948
 949 /* Don't allow just "maintenance cplus".  */
 950
 951 static  void
 952 maint_cplus_command (char *arg, int from_tty)
 953 {
 954   printf_unfiltered (_("\"maintenance cplus\" must be followed by the name of a command.\n"));
 955   help_list (maint_cplus_cmd_list, "maintenance cplus ", -1, gdb_stdout);
 956 }
 957
 958 /* This is a front end for cp_find_first_component, for unit testing.
 959    Be careful when using it: see the NOTE above
 960    cp_find_first_component.  */
 961
 962 static void
 963 first_component_command (char *arg, int from_tty)
 964 {
 965   int len;
 966   char *prefix;
 967
 968   if (!arg)
 969     return;
 970
 971   len = cp_find_first_component (arg);
 972   prefix = alloca (len + 1);
 973
 974   memcpy (prefix, arg, len);
 975   prefix[len] = '\0';
 976
 977   printf_unfiltered ("%s\n", prefix);
 978 }
 979
 980 extern initialize_file_ftype _initialize_cp_support; /* -Wmissing-prototypes */
 981
 982 #define SKIP_SPACE(P)                           \
 983   do                                            \
 984   {                                             \
 985     while (*(P) == ' ' || *(P) == '\t')         \
 986       ++(P);                                    \
 987   }                                             \
 988   while (0)
 989
 990 /* Returns the length of the operator name or 0 if INPUT does not
 991    point to a valid C++ operator.  INPUT should start with "operator".  */
 992 int
 993 cp_validate_operator (const char *input)
 994 {
 995   int i;
 996   char *copy;
 997   const char *p;
 998   struct expression *expr;
 999   struct value *val;
1000   struct gdb_exception except;
1001
1002   p = input;
1003
1004   if (strncmp (p, "operator", 8) == 0)
1005     {
1006       int valid = 0;
1007
1008       p += 8;
1009       SKIP_SPACE (p);
1010       for (i = 0; i < sizeof (operator_tokens) / sizeof (operator_tokens[0]);
1011            ++i)
1012         {
1013           int length = strlen (operator_tokens[i]);
1014
1015           /* By using strncmp here, we MUST have operator_tokens ordered!
1016              See additional notes where operator_tokens is defined above.  */
1017           if (strncmp (p, operator_tokens[i], length) == 0)
1018             {
1019               const char *op = p;
1020
1021               valid = 1;
1022               p += length;
1023
1024               if (strncmp (op, "new", 3) == 0
1025                   || strncmp (op, "delete", 6) == 0)
1026                 {
1027
1028                   /* Special case: new[] and delete[].  We must be careful
1029                      to swallow whitespace before/in "[]".  */
1030                   SKIP_SPACE (p);
1031
1032                   if (*p == '[')
1033                     {
1034                       ++p;
1035                       SKIP_SPACE (p);
1036                       if (*p == ']')
1037                         ++p;
1038                       else
1039                         valid = 0;
1040                     }
1041                 }
1042
1043               if (valid)
1044                 return (p - input);
1045             }
1046         }
1047
1048       /* Check input for a conversion operator.  */
1049
1050       /* Skip past base typename */
1051       while (*p != '*' && *p != '&' && *p != 0 && *p != ' ')
1052         ++p;
1053       SKIP_SPACE (p);
1054
1055       /* Add modifiers '*'/'&' */
1056       while (*p == '*' || *p == '&')
1057         {
1058           ++p;
1059           SKIP_SPACE (p);
1060         }
1061
1062       /* Check for valid type.  [Remember: input starts with
1063          "operator".]  */
1064       copy = savestring (input + 8, p - input - 8);
1065       expr = NULL;
1066       val = NULL;
1067       TRY_CATCH (except, RETURN_MASK_ALL)
1068         {
1069           expr = parse_expression (copy);
1070           val = evaluate_type (expr);
1071         }
1072
1073       xfree (copy);
1074       if (expr)
1075         xfree (expr);
1076
1077       if (val != NULL && value_type (val) != NULL)
1078         return (p - input);
1079     }
1080
1081   return 0;
1082 }
1083
1084 void
1085 _initialize_cp_support (void)
1086 {
1087   add_prefix_cmd ("cplus", class_maintenance, maint_cplus_command,
1088                   _("C++ maintenance commands."), &maint_cplus_cmd_list,
1089                   "maintenance cplus ", 0, &maintenancelist);
1090   add_alias_cmd ("cp", "cplus", class_maintenance, 1, &maintenancelist);
1091
1092   add_cmd ("first_component", class_maintenance, first_component_command,
1093            _("Print the first class/namespace component of NAME."),
1094            &maint_cplus_cmd_list);
1095 }