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