contrib/gdb-7/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 /* Used for cleanups to reset the "searched" flag in case of an error.  */
 842
 843 static void
 844 reset_directive_searched (void *data)
 845 {
 846   struct using_direct *direct = data;
 847   direct->searched = 0;
 848 }
 849
 850 /* This applies the using directives to add namespaces to search in,
 851    and then searches for overloads in all of those namespaces.  It
 852    adds the symbols found to sym_return_val.  Arguments are as in
 853    make_symbol_overload_list.  */
 854
 855 static void
 856 make_symbol_overload_list_using (const char *func_name,
 857                                  const char *namespace)
 858 {
 859   struct using_direct *current;
 860   const struct block *block;
 861
 862   /* First, go through the using directives.  If any of them apply,
 863      look in the appropriate namespaces for new functions to match
 864      on.  */
 865
 866   for (block = get_selected_block (0);
 867        block != NULL;
 868        block = BLOCK_SUPERBLOCK (block))
 869     for (current = block_using (block);
 870         current != NULL;
 871         current = current->next)
 872       {
 873         /* Prevent recursive calls.  */
 874         if (current->searched)
 875           continue;
 876
 877         /* If this is a namespace alias or imported declaration ignore it.  */
 878         if (current->alias != NULL || current->declaration != NULL)
 879           continue;
 880
 881         if (strcmp (namespace, current->import_dest) == 0)
 882           {
 883             /* Mark this import as searched so that the recursive call does
 884                not search it again.  */
 885             struct cleanup *old_chain;
 886             current->searched = 1;
 887             old_chain = make_cleanup (reset_directive_searched, current);
 888
 889             make_symbol_overload_list_using (func_name, current->import_src);
 890
 891             current->searched = 0;
 892             discard_cleanups (old_chain);
 893           }
 894       }
 895
 896   /* Now, add names for this namespace.  */
 897   make_symbol_overload_list_namespace (func_name, namespace);
 898 }
 899
 900 /* This does the bulk of the work of finding overloaded symbols.
 901    FUNC_NAME is the name of the overloaded function we're looking for
 902    (possibly including namespace info).  */
 903
 904 static void
 905 make_symbol_overload_list_qualified (const char *func_name)
 906 {
 907   struct symbol *sym;
 908   struct symtab *s;
 909   struct objfile *objfile;
 910   const struct block *b, *surrounding_static_block = 0;
 911   struct dict_iterator iter;
 912   const struct dictionary *dict;
 913
 914   /* Look through the partial symtabs for all symbols which begin
 915      by matching FUNC_NAME.  Make sure we read that symbol table in. */
 916
 917   ALL_OBJFILES (objfile)
 918   {
 919     if (objfile->sf)
 920       objfile->sf->qf->expand_symtabs_for_function (objfile, func_name);
 921   }
 922
 923   /* Search upwards from currently selected frame (so that we can
 924      complete on local vars.  */
 925
 926   for (b = get_selected_block (0); b != NULL; b = BLOCK_SUPERBLOCK (b))
 927     make_symbol_overload_list_block (func_name, b);
 928
 929   surrounding_static_block = block_static_block (get_selected_block (0));
 930
 931   /* Go through the symtabs and check the externs and statics for
 932      symbols which match.  */
 933
 934   ALL_PRIMARY_SYMTABS (objfile, s)
 935   {
 936     QUIT;
 937     b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
 938     make_symbol_overload_list_block (func_name, b);
 939   }
 940
 941   ALL_PRIMARY_SYMTABS (objfile, s)
 942   {
 943     QUIT;
 944     b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
 945     /* Don't do this block twice.  */
 946     if (b == surrounding_static_block)
 947       continue;
 948     make_symbol_overload_list_block (func_name, b);
 949   }
 950 }
 951
 952 /* Lookup the rtti type for a class name. */
 953
 954 struct type *
 955 cp_lookup_rtti_type (const char *name, struct block *block)
 956 {
 957   struct symbol * rtti_sym;
 958   struct type * rtti_type;
 959
 960   rtti_sym = lookup_symbol (name, block, STRUCT_DOMAIN, NULL);
 961
 962   if (rtti_sym == NULL)
 963     {
 964       warning (_("RTTI symbol not found for class '%s'"), name);
 965       return NULL;
 966     }
 967
 968   if (SYMBOL_CLASS (rtti_sym) != LOC_TYPEDEF)
 969     {
 970       warning (_("RTTI symbol for class '%s' is not a type"), name);
 971       return NULL;
 972     }
 973
 974   rtti_type = SYMBOL_TYPE (rtti_sym);
 975
 976   switch (TYPE_CODE (rtti_type))
 977     {
 978     case TYPE_CODE_CLASS:
 979       break;
 980     case TYPE_CODE_NAMESPACE:
 981       /* chastain/2003-11-26: the symbol tables often contain fake
 982          symbols for namespaces with the same name as the struct.
 983          This warning is an indication of a bug in the lookup order
 984          or a bug in the way that the symbol tables are populated.  */
 985       warning (_("RTTI symbol for class '%s' is a namespace"), name);
 986       return NULL;
 987     default:
 988       warning (_("RTTI symbol for class '%s' has bad type"), name);
 989       return NULL;
 990     }
 991
 992   return rtti_type;
 993 }
 994
 995 /* Don't allow just "maintenance cplus".  */
 996
 997 static  void
 998 maint_cplus_command (char *arg, int from_tty)
 999 {
1000   printf_unfiltered (_("\"maintenance cplus\" must be followed by the name of a command.\n"));
1001   help_list (maint_cplus_cmd_list, "maintenance cplus ", -1, gdb_stdout);
1002 }
1003
1004 /* This is a front end for cp_find_first_component, for unit testing.
1005    Be careful when using it: see the NOTE above
1006    cp_find_first_component.  */
1007
1008 static void
1009 first_component_command (char *arg, int from_tty)
1010 {
1011   int len;
1012   char *prefix;
1013
1014   if (!arg)
1015     return;
1016
1017   len = cp_find_first_component (arg);
1018   prefix = alloca (len + 1);
1019
1020   memcpy (prefix, arg, len);
1021   prefix[len] = '\0';
1022
1023   printf_unfiltered ("%s\n", prefix);
1024 }
1025
1026 extern initialize_file_ftype _initialize_cp_support; /* -Wmissing-prototypes */
1027
1028 #define SKIP_SPACE(P)                           \
1029   do                                            \
1030   {                                             \
1031     while (*(P) == ' ' || *(P) == '\t')         \
1032       ++(P);                                    \
1033   }                                             \
1034   while (0)
1035
1036 /* Returns the length of the operator name or 0 if INPUT does not
1037    point to a valid C++ operator.  INPUT should start with "operator".  */
1038 int
1039 cp_validate_operator (const char *input)
1040 {
1041   int i;
1042   char *copy;
1043   const char *p;
1044   struct expression *expr;
1045   struct value *val;
1046   struct gdb_exception except;
1047
1048   p = input;
1049
1050   if (strncmp (p, "operator", 8) == 0)
1051     {
1052       int valid = 0;
1053
1054       p += 8;
1055       SKIP_SPACE (p);
1056       for (i = 0; i < sizeof (operator_tokens) / sizeof (operator_tokens[0]);
1057            ++i)
1058         {
1059           int length = strlen (operator_tokens[i]);
1060
1061           /* By using strncmp here, we MUST have operator_tokens ordered!
1062              See additional notes where operator_tokens is defined above.  */
1063           if (strncmp (p, operator_tokens[i], length) == 0)
1064             {
1065               const char *op = p;
1066
1067               valid = 1;
1068               p += length;
1069
1070               if (strncmp (op, "new", 3) == 0
1071                   || strncmp (op, "delete", 6) == 0)
1072                 {
1073
1074                   /* Special case: new[] and delete[].  We must be careful
1075                      to swallow whitespace before/in "[]".  */
1076                   SKIP_SPACE (p);
1077
1078                   if (*p == '[')
1079                     {
1080                       ++p;
1081                       SKIP_SPACE (p);
1082                       if (*p == ']')
1083                         ++p;
1084                       else
1085                         valid = 0;
1086                     }
1087                 }
1088
1089               if (valid)
1090                 return (p - input);
1091             }
1092         }
1093
1094       /* Check input for a conversion operator.  */
1095
1096       /* Skip past base typename */
1097       while (*p != '*' && *p != '&' && *p != 0 && *p != ' ')
1098         ++p;
1099       SKIP_SPACE (p);
1100
1101       /* Add modifiers '*'/'&' */
1102       while (*p == '*' || *p == '&')
1103         {
1104           ++p;
1105           SKIP_SPACE (p);
1106         }
1107
1108       /* Check for valid type.  [Remember: input starts with
1109          "operator".]  */
1110       copy = savestring (input + 8, p - input - 8);
1111       expr = NULL;
1112       val = NULL;
1113       TRY_CATCH (except, RETURN_MASK_ALL)
1114         {
1115           expr = parse_expression (copy);
1116           val = evaluate_type (expr);
1117         }
1118
1119       xfree (copy);
1120       if (expr)
1121         xfree (expr);
1122
1123       if (val != NULL && value_type (val) != NULL)
1124         return (p - input);
1125     }
1126
1127   return 0;
1128 }
1129
1130 void
1131 _initialize_cp_support (void)
1132 {
1133   add_prefix_cmd ("cplus", class_maintenance, maint_cplus_command,
1134                   _("C++ maintenance commands."), &maint_cplus_cmd_list,
1135                   "maintenance cplus ", 0, &maintenancelist);
1136   add_alias_cmd ("cp", "cplus", class_maintenance, 1, &maintenancelist);
1137
1138   add_cmd ("first_component", class_maintenance, first_component_command,
1139            _("Print the first class/namespace component of NAME."),
1140            &maint_cplus_cmd_list);
1141 }