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