1 /* Helper routines for C++ support in GDB.
2 Copyright (C) 2003-2014 Free Software Foundation, Inc.
4 Contributed by David Carlton and by Kealia, Inc.
6 This file is part of GDB.
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 3 of the License, or
11 (at your option) any later version.
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.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "cp-support.h"
23 #include "gdb_obstack.h"
29 #include "dictionary.h"
35 static struct type
*cp_lookup_transparent_type_loop (const char *name
,
39 /* Check to see if SYMBOL refers to an object contained within an
40 anonymous namespace; if so, add an appropriate using directive. */
43 cp_scan_for_anonymous_namespaces (const struct symbol
*const symbol
,
44 struct objfile
*const objfile
)
46 if (SYMBOL_DEMANGLED_NAME (symbol
) != NULL
)
48 const char *name
= SYMBOL_DEMANGLED_NAME (symbol
);
49 unsigned int previous_component
;
50 unsigned int next_component
;
52 /* Start with a quick-and-dirty check for mention of "(anonymous
55 if (!cp_is_in_anonymous (name
))
58 previous_component
= 0;
59 next_component
= cp_find_first_component (name
+ previous_component
);
61 while (name
[next_component
] == ':')
63 if (((next_component
- previous_component
)
64 == CP_ANONYMOUS_NAMESPACE_LEN
)
65 && strncmp (name
+ previous_component
,
66 CP_ANONYMOUS_NAMESPACE_STR
,
67 CP_ANONYMOUS_NAMESPACE_LEN
) == 0)
69 int dest_len
= (previous_component
== 0
70 ? 0 : previous_component
- 2);
71 int src_len
= next_component
;
73 char *dest
= alloca (dest_len
+ 1);
74 char *src
= alloca (src_len
+ 1);
76 memcpy (dest
, name
, dest_len
);
77 memcpy (src
, name
, src_len
);
79 dest
[dest_len
] = '\0';
82 /* We've found a component of the name that's an
83 anonymous namespace. So add symbols in it to the
84 namespace given by the previous component if there is
85 one, or to the global namespace if there isn't. */
86 cp_add_using_directive (dest
, src
, NULL
, NULL
, NULL
, 1,
87 &objfile
->objfile_obstack
);
89 /* The "+ 2" is for the "::". */
90 previous_component
= next_component
+ 2;
91 next_component
= (previous_component
92 + cp_find_first_component (name
93 + previous_component
));
98 /* Add a using directive to using_directives. If the using directive
99 in question has already been added, don't add it twice.
101 Create a new struct using_direct which imports the namespace SRC
102 into the scope DEST. ALIAS is the name of the imported namespace
103 in the current scope. If ALIAS is NULL then the namespace is known
104 by its original name. DECLARATION is the name if the imported
105 varable if this is a declaration import (Eg. using A::x), otherwise
106 it is NULL. EXCLUDES is a list of names not to import from an
107 imported module or NULL. If COPY_NAMES is non-zero, then the
108 arguments are copied into newly allocated memory so they can be
109 temporaries. For EXCLUDES the VEC pointers are copied but the
110 pointed to characters are not copied. */
113 cp_add_using_directive (const char *dest
,
116 const char *declaration
,
117 VEC (const_char_ptr
) *excludes
,
119 struct obstack
*obstack
)
121 struct using_direct
*current
;
122 struct using_direct
*new;
124 /* Has it already been added? */
126 for (current
= using_directives
; current
!= NULL
; current
= current
->next
)
131 if (strcmp (current
->import_src
, src
) != 0)
133 if (strcmp (current
->import_dest
, dest
) != 0)
135 if ((alias
== NULL
&& current
->alias
!= NULL
)
136 || (alias
!= NULL
&& current
->alias
== NULL
)
137 || (alias
!= NULL
&& current
->alias
!= NULL
138 && strcmp (alias
, current
->alias
) != 0))
140 if ((declaration
== NULL
&& current
->declaration
!= NULL
)
141 || (declaration
!= NULL
&& current
->declaration
== NULL
)
142 || (declaration
!= NULL
&& current
->declaration
!= NULL
143 && strcmp (declaration
, current
->declaration
) != 0))
146 /* Compare the contents of EXCLUDES. */
147 for (ix
= 0; VEC_iterate (const_char_ptr
, excludes
, ix
, param
); ix
++)
148 if (current
->excludes
[ix
] == NULL
149 || strcmp (param
, current
->excludes
[ix
]) != 0)
151 if (ix
< VEC_length (const_char_ptr
, excludes
)
152 || current
->excludes
[ix
] != NULL
)
155 /* Parameters exactly match CURRENT. */
159 new = obstack_alloc (obstack
, (sizeof (*new)
160 + (VEC_length (const_char_ptr
, excludes
)
161 * sizeof (*new->excludes
))));
162 memset (new, 0, sizeof (*new));
166 new->import_src
= obstack_copy0 (obstack
, src
, strlen (src
));
167 new->import_dest
= obstack_copy0 (obstack
, dest
, strlen (dest
));
171 new->import_src
= src
;
172 new->import_dest
= dest
;
175 if (alias
!= NULL
&& copy_names
)
176 new->alias
= obstack_copy0 (obstack
, alias
, strlen (alias
));
180 if (declaration
!= NULL
&& copy_names
)
181 new->declaration
= obstack_copy0 (obstack
,
182 declaration
, strlen (declaration
));
184 new->declaration
= declaration
;
186 memcpy (new->excludes
, VEC_address (const_char_ptr
, excludes
),
187 VEC_length (const_char_ptr
, excludes
) * sizeof (*new->excludes
));
188 new->excludes
[VEC_length (const_char_ptr
, excludes
)] = NULL
;
190 new->next
= using_directives
;
191 using_directives
= new;
194 /* Test whether or not NAMESPACE looks like it mentions an anonymous
195 namespace; return nonzero if so. */
198 cp_is_in_anonymous (const char *symbol_name
)
200 return (strstr (symbol_name
, CP_ANONYMOUS_NAMESPACE_STR
)
204 /* Look up NAME in BLOCK's static block and in global blocks. If
205 ANONYMOUS_NAMESPACE is nonzero, the symbol in question is located
206 within an anonymous namespace. If SEARCH is non-zero, search through
207 base classes for a matching symbol. Other arguments are as in
208 cp_lookup_symbol_nonlocal. */
210 static struct symbol
*
211 lookup_symbol_file (const char *name
,
212 const struct block
*block
,
213 const domain_enum domain
,
214 int anonymous_namespace
, int search
)
216 struct symbol
*sym
= NULL
;
218 sym
= lookup_symbol_in_static_block (name
, block
, domain
);
222 if (anonymous_namespace
)
224 /* Symbols defined in anonymous namespaces have external linkage
225 but should be treated as local to a single file nonetheless.
226 So we only search the current file's global block. */
228 const struct block
*global_block
= block_global_block (block
);
230 if (global_block
!= NULL
)
231 sym
= lookup_symbol_in_block (name
, global_block
, domain
);
235 sym
= lookup_global_symbol (name
, block
, domain
);
243 char *klass
, *nested
;
244 unsigned int prefix_len
;
245 struct cleanup
*cleanup
;
246 struct symbol
*klass_sym
;
248 /* A simple lookup failed. Check if the symbol was defined in
251 cleanup
= make_cleanup (null_cleanup
, NULL
);
253 /* Find the name of the class and the name of the method,
255 prefix_len
= cp_entire_prefix_len (name
);
257 /* If no prefix was found, search "this". */
263 this = lookup_language_this (language_def (language_cplus
), block
);
266 do_cleanups (cleanup
);
270 type
= check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (this)));
271 /* If TYPE_NAME is NULL, abandon trying to find this symbol.
272 This can happen for lambda functions compiled with clang++,
273 which outputs no name for the container class. */
274 if (TYPE_NAME (type
) == NULL
)
276 klass
= xstrdup (TYPE_NAME (type
));
277 nested
= xstrdup (name
);
281 /* The class name is everything up to and including PREFIX_LEN. */
282 klass
= savestring (name
, prefix_len
);
284 /* The rest of the name is everything else past the initial scope
286 nested
= xstrdup (name
+ prefix_len
+ 2);
289 /* Add cleanups to free memory for these strings. */
290 make_cleanup (xfree
, klass
);
291 make_cleanup (xfree
, nested
);
293 /* Lookup a class named KLASS. If none is found, there is nothing
294 more that can be done. */
295 klass_sym
= lookup_global_symbol (klass
, block
, domain
);
296 if (klass_sym
== NULL
)
298 do_cleanups (cleanup
);
302 /* Look for a symbol named NESTED in this class. */
303 sym
= cp_lookup_nested_symbol (SYMBOL_TYPE (klass_sym
), nested
, block
);
304 do_cleanups (cleanup
);
310 /* Look up NAME in the C++ namespace NAMESPACE. Other arguments are
311 as in cp_lookup_symbol_nonlocal. If SEARCH is non-zero, search
312 through base classes for a matching symbol. */
314 static struct symbol
*
315 cp_lookup_symbol_in_namespace (const char *namespace,
317 const struct block
*block
,
318 const domain_enum domain
, int search
)
320 char *concatenated_name
= NULL
;
321 int is_anonymous
= namespace[0] != '\0' && cp_is_in_anonymous (namespace);
323 if (namespace[0] != '\0')
325 concatenated_name
= alloca (strlen (namespace) + 2
326 + strlen (name
) + 1);
327 strcpy (concatenated_name
, namespace);
328 strcat (concatenated_name
, "::");
329 strcat (concatenated_name
, name
);
330 name
= concatenated_name
;
333 return lookup_symbol_file (name
, block
, domain
, is_anonymous
, search
);
336 /* Used for cleanups to reset the "searched" flag incase
340 reset_directive_searched (void *data
)
342 struct using_direct
*direct
= data
;
343 direct
->searched
= 0;
346 /* Search for NAME by applying all import statements belonging to
347 BLOCK which are applicable in SCOPE. If DECLARATION_ONLY the
348 search is restricted to using declarations.
356 If SEARCH_PARENTS the search will include imports which are
357 applicable in parents of SCOPE.
367 If SCOPE is "A::B" and SEARCH_PARENTS is true the imports of
368 namespaces X and Y will be considered. If SEARCH_PARENTS is false
369 only the import of Y is considered. */
371 static struct symbol
*
372 cp_lookup_symbol_via_imports (const char *scope
,
374 const struct block
*block
,
375 const domain_enum domain
,
376 const int declaration_only
,
377 const int search_parents
)
379 struct using_direct
*current
;
380 struct symbol
*sym
= NULL
;
383 struct cleanup
*searched_cleanup
;
385 /* First, try to find the symbol in the given namespace. */
386 if (!declaration_only
)
387 sym
= cp_lookup_symbol_in_namespace (scope
, name
,
393 /* Go through the using directives. If any of them add new names to
394 the namespace we're searching in, see if we can find a match by
397 for (current
= block_using (block
);
399 current
= current
->next
)
401 const char **excludep
;
403 len
= strlen (current
->import_dest
);
404 directive_match
= (search_parents
405 ? (strncmp (scope
, current
->import_dest
,
406 strlen (current
->import_dest
)) == 0
409 || scope
[len
] == '\0'))
410 : strcmp (scope
, current
->import_dest
) == 0);
412 /* If the import destination is the current scope or one of its
413 ancestors then it is applicable. */
414 if (directive_match
&& !current
->searched
)
416 /* Mark this import as searched so that the recursive call
417 does not search it again. */
418 current
->searched
= 1;
419 searched_cleanup
= make_cleanup (reset_directive_searched
,
422 /* If there is an import of a single declaration, compare the
423 imported declaration (after optional renaming by its alias)
424 with the sought out name. If there is a match pass
425 current->import_src as NAMESPACE to direct the search
426 towards the imported namespace. */
427 if (current
->declaration
428 && strcmp (name
, current
->alias
429 ? current
->alias
: current
->declaration
) == 0)
430 sym
= cp_lookup_symbol_in_namespace (current
->import_src
,
431 current
->declaration
,
434 /* If this is a DECLARATION_ONLY search or a symbol was found
435 or this import statement was an import declaration, the
436 search of this import is complete. */
437 if (declaration_only
|| sym
!= NULL
|| current
->declaration
)
439 current
->searched
= 0;
440 discard_cleanups (searched_cleanup
);
448 /* Do not follow CURRENT if NAME matches its EXCLUDES. */
449 for (excludep
= current
->excludes
; *excludep
; excludep
++)
450 if (strcmp (name
, *excludep
) == 0)
454 discard_cleanups (searched_cleanup
);
458 if (current
->alias
!= NULL
459 && strcmp (name
, current
->alias
) == 0)
460 /* If the import is creating an alias and the alias matches
461 the sought name. Pass current->import_src as the NAME to
462 direct the search towards the aliased namespace. */
464 sym
= cp_lookup_symbol_in_namespace (scope
,
468 else if (current
->alias
== NULL
)
470 /* If this import statement creates no alias, pass
471 current->inner as NAMESPACE to direct the search
472 towards the imported namespace. */
473 sym
= cp_lookup_symbol_via_imports (current
->import_src
,
477 current
->searched
= 0;
478 discard_cleanups (searched_cleanup
);
488 /* Helper function that searches an array of symbols for one named
491 static struct symbol
*
492 search_symbol_list (const char *name
, int num
,
493 struct symbol
**syms
)
497 /* Maybe we should store a dictionary in here instead. */
498 for (i
= 0; i
< num
; ++i
)
500 if (strcmp (name
, SYMBOL_NATURAL_NAME (syms
[i
])) == 0)
506 /* Like cp_lookup_symbol_via_imports, but if BLOCK is a function, it
507 searches through the template parameters of the function and the
511 cp_lookup_symbol_imports_or_template (const char *scope
,
513 const struct block
*block
,
514 const domain_enum domain
)
516 struct symbol
*function
= BLOCK_FUNCTION (block
);
517 struct symbol
*result
;
519 if (symbol_lookup_debug
)
521 fprintf_unfiltered (gdb_stdlog
,
522 "cp_lookup_symbol_imports_or_template"
523 " (%s, %s, %s, %s)\n",
524 scope
, name
, host_address_to_string (block
),
525 domain_name (domain
));
528 if (function
!= NULL
&& SYMBOL_LANGUAGE (function
) == language_cplus
)
530 /* Search the function's template parameters. */
531 if (SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION (function
))
533 struct template_symbol
*templ
534 = (struct template_symbol
*) function
;
536 result
= search_symbol_list (name
,
537 templ
->n_template_arguments
,
538 templ
->template_arguments
);
541 if (symbol_lookup_debug
)
543 fprintf_unfiltered (gdb_stdlog
,
544 "cp_lookup_symbol_imports_or_template"
546 host_address_to_string (result
));
552 /* Search the template parameters of the function's defining
554 if (SYMBOL_NATURAL_NAME (function
))
556 struct type
*context
;
557 char *name_copy
= xstrdup (SYMBOL_NATURAL_NAME (function
));
558 struct cleanup
*cleanups
= make_cleanup (xfree
, name_copy
);
559 const struct language_defn
*lang
= language_def (language_cplus
);
561 = get_objfile_arch (SYMBOL_OBJFILE (function
));
562 const struct block
*parent
= BLOCK_SUPERBLOCK (block
);
566 unsigned int prefix_len
= cp_entire_prefix_len (name_copy
);
572 name_copy
[prefix_len
] = '\0';
573 context
= lookup_typename (lang
, arch
,
582 = search_symbol_list (name
,
583 TYPE_N_TEMPLATE_ARGUMENTS (context
),
584 TYPE_TEMPLATE_ARGUMENTS (context
));
587 do_cleanups (cleanups
);
588 if (symbol_lookup_debug
)
590 fprintf_unfiltered (gdb_stdlog
,
591 "cp_lookup_symbol_imports_or_template"
593 host_address_to_string (result
));
599 do_cleanups (cleanups
);
603 result
= cp_lookup_symbol_via_imports (scope
, name
, block
, domain
, 1, 1);
604 if (symbol_lookup_debug
)
606 fprintf_unfiltered (gdb_stdlog
,
607 "cp_lookup_symbol_imports_or_template (...) = %s\n",
609 ? host_address_to_string (result
) : "NULL");
614 /* Searches for NAME in the current namespace, and by applying
615 relevant import statements belonging to BLOCK and its parents.
616 SCOPE is the namespace scope of the context in which the search is
620 cp_lookup_symbol_namespace (const char *scope
,
622 const struct block
*block
,
623 const domain_enum domain
)
627 if (symbol_lookup_debug
)
629 fprintf_unfiltered (gdb_stdlog
,
630 "cp_lookup_symbol_namespace (%s, %s, %s, %s)\n",
631 scope
, name
, host_address_to_string (block
),
632 domain_name (domain
));
635 /* First, try to find the symbol in the given namespace. */
636 sym
= cp_lookup_symbol_in_namespace (scope
, name
,
640 if (symbol_lookup_debug
)
642 fprintf_unfiltered (gdb_stdlog
,
643 "cp_lookup_symbol_namespace (...) = %s\n",
644 host_address_to_string (sym
));
649 /* Search for name in namespaces imported to this and parent
651 while (block
!= NULL
)
653 sym
= cp_lookup_symbol_via_imports (scope
, name
, block
,
658 if (symbol_lookup_debug
)
660 fprintf_unfiltered (gdb_stdlog
,
661 "cp_lookup_symbol_namespace (...) = %s\n",
662 host_address_to_string (sym
));
667 block
= BLOCK_SUPERBLOCK (block
);
670 if (symbol_lookup_debug
)
672 fprintf_unfiltered (gdb_stdlog
,
673 "cp_lookup_symbol_namespace (...) = NULL\n");
678 /* Lookup NAME at namespace scope (or, in C terms, in static and
679 global variables). SCOPE is the namespace that the current
680 function is defined within; only consider namespaces whose length
681 is at least SCOPE_LEN. Other arguments are as in
682 cp_lookup_symbol_nonlocal.
684 For example, if we're within a function A::B::f and looking for a
685 symbol x, this will get called with NAME = "x", SCOPE = "A::B", and
686 SCOPE_LEN = 0. It then calls itself with NAME and SCOPE the same,
687 but with SCOPE_LEN = 1. And then it calls itself with NAME and
688 SCOPE the same, but with SCOPE_LEN = 4. This third call looks for
689 "A::B::x"; if it doesn't find it, then the second call looks for
690 "A::x", and if that call fails, then the first call looks for
693 static struct symbol
*
694 lookup_namespace_scope (const char *name
,
695 const struct block
*block
,
696 const domain_enum domain
,
702 if (scope
[scope_len
] != '\0')
704 /* Recursively search for names in child namespaces first. */
707 int new_scope_len
= scope_len
;
709 /* If the current scope is followed by "::", skip past that. */
710 if (new_scope_len
!= 0)
712 gdb_assert (scope
[new_scope_len
] == ':');
715 new_scope_len
+= cp_find_first_component (scope
+ new_scope_len
);
716 sym
= lookup_namespace_scope (name
, block
, domain
,
717 scope
, new_scope_len
);
722 /* Okay, we didn't find a match in our children, so look for the
723 name in the current namespace. */
725 namespace = alloca (scope_len
+ 1);
726 strncpy (namespace, scope
, scope_len
);
727 namespace[scope_len
] = '\0';
728 return cp_lookup_symbol_in_namespace (namespace, name
,
732 /* The C++-specific version of name lookup for static and global
733 names. This makes sure that names get looked for in all namespaces
734 that are in scope. NAME is the natural name of the symbol that
735 we're looking for, BLOCK is the block that we're searching within,
736 DOMAIN says what kind of symbols we're looking for. */
739 cp_lookup_symbol_nonlocal (const char *name
,
740 const struct block
*block
,
741 const domain_enum domain
)
744 const char *scope
= block_scope (block
);
746 if (symbol_lookup_debug
)
748 fprintf_unfiltered (gdb_stdlog
,
749 "cp_lookup_symbol_non_local"
750 " (%s, %s (scope %s), %s)\n",
751 name
, host_address_to_string (block
), scope
,
752 domain_name (domain
));
755 sym
= lookup_namespace_scope (name
, block
, domain
, scope
, 0);
758 if (symbol_lookup_debug
)
760 fprintf_unfiltered (gdb_stdlog
,
761 "cp_lookup_symbol_nonlocal (...) = %s\n",
762 host_address_to_string (sym
));
767 sym
= cp_lookup_symbol_namespace (scope
, name
, block
, domain
);
768 if (symbol_lookup_debug
)
770 fprintf_unfiltered (gdb_stdlog
,
771 "cp_lookup_symbol_nonlocal (...) = %s\n",
772 sym
!= NULL
? host_address_to_string (sym
) : "NULL");
777 /* Search through the base classes of PARENT_TYPE for a base class
778 named NAME and return its type. If not found, return NULL. */
781 cp_find_type_baseclass_by_name (struct type
*parent_type
, const char *name
)
785 CHECK_TYPEDEF (parent_type
);
786 for (i
= 0; i
< TYPE_N_BASECLASSES (parent_type
); ++i
)
788 struct type
*type
= check_typedef (TYPE_BASECLASS (parent_type
, i
));
789 const char *base_name
= TYPE_BASECLASS_NAME (parent_type
, i
);
791 if (base_name
== NULL
)
794 if (streq (base_name
, name
))
797 type
= cp_find_type_baseclass_by_name (type
, name
);
805 /* Search through the base classes of PARENT_TYPE for a symbol named
806 NAME in block BLOCK. */
808 static struct symbol
*
809 find_symbol_in_baseclass (struct type
*parent_type
, const char *name
,
810 const struct block
*block
)
814 struct cleanup
*cleanup
;
815 char *concatenated_name
;
818 concatenated_name
= NULL
;
819 cleanup
= make_cleanup (free_current_contents
, &concatenated_name
);
821 for (i
= 0; i
< TYPE_N_BASECLASSES (parent_type
); ++i
)
824 struct type
*base_type
= TYPE_BASECLASS (parent_type
, i
);
825 const char *base_name
= TYPE_BASECLASS_NAME (parent_type
, i
);
827 if (base_name
== NULL
)
830 /* Search this particular base class. */
831 sym
= cp_lookup_symbol_in_namespace (base_name
, name
, block
,
836 /* Now search all static file-level symbols. We have to do this for
837 things like typedefs in the class. First search in this symtab,
838 what we want is possibly there. */
839 len
= strlen (base_name
) + 2 + strlen (name
) + 1;
840 concatenated_name
= xrealloc (concatenated_name
, len
);
841 xsnprintf (concatenated_name
, len
, "%s::%s", base_name
, name
);
842 sym
= lookup_symbol_in_static_block (concatenated_name
, block
,
847 /* Nope. We now have to search all static blocks in all objfiles,
848 even if block != NULL, because there's no guarantees as to which
849 symtab the symbol we want is in. */
850 sym
= lookup_static_symbol (concatenated_name
, VAR_DOMAIN
);
854 /* If this class has base classes, search them next. */
855 CHECK_TYPEDEF (base_type
);
856 if (TYPE_N_BASECLASSES (base_type
) > 0)
858 sym
= find_symbol_in_baseclass (base_type
, name
, block
);
864 do_cleanups (cleanup
);
868 /* Look up a symbol named NESTED_NAME that is nested inside the C++
869 class or namespace given by PARENT_TYPE, from within the context
870 given by BLOCK. Return NULL if there is no such nested symbol. */
873 cp_lookup_nested_symbol (struct type
*parent_type
,
874 const char *nested_name
,
875 const struct block
*block
)
877 /* type_name_no_tag_or_error provides better error reporting using the
879 struct type
*saved_parent_type
= parent_type
;
881 CHECK_TYPEDEF (parent_type
);
883 if (symbol_lookup_debug
)
885 const char *type_name
= type_name_no_tag (saved_parent_type
);
887 fprintf_unfiltered (gdb_stdlog
,
888 "cp_lookup_nested_symbol (%s, %s, %s)\n",
889 type_name
!= NULL
? type_name
: "unnamed",
890 nested_name
, host_address_to_string (block
));
893 switch (TYPE_CODE (parent_type
))
895 case TYPE_CODE_STRUCT
:
896 case TYPE_CODE_NAMESPACE
:
897 case TYPE_CODE_UNION
:
899 /* NOTE: Handle modules here as well, because Fortran is re-using the C++
900 specific code to lookup nested symbols in modules, by calling the
901 function pointer la_lookup_symbol_nonlocal, which ends up here. */
902 case TYPE_CODE_MODULE
:
904 /* NOTE: carlton/2003-11-10: We don't treat C++ class members
905 of classes like, say, data or function members. Instead,
906 they're just represented by symbols whose names are
907 qualified by the name of the surrounding class. This is
908 just like members of namespaces; in particular,
909 lookup_symbol_namespace works when looking them up. */
912 const char *parent_name
= type_name_no_tag_or_error (saved_parent_type
);
914 = cp_lookup_symbol_in_namespace (parent_name
, nested_name
,
915 block
, VAR_DOMAIN
, 0);
916 char *concatenated_name
;
920 if (symbol_lookup_debug
)
922 fprintf_unfiltered (gdb_stdlog
,
923 "cp_lookup_nested_symbol (...) = %s\n",
924 host_address_to_string (sym
));
929 /* Now search all static file-level symbols. We have to do this
930 for things like typedefs in the class. We do not try to
931 guess any imported namespace as even the fully specified
932 namespace search is already not C++ compliant and more
933 assumptions could make it too magic. */
935 size
= strlen (parent_name
) + 2 + strlen (nested_name
) + 1;
936 concatenated_name
= alloca (size
);
937 xsnprintf (concatenated_name
, size
, "%s::%s",
938 parent_name
, nested_name
);
939 sym
= lookup_static_symbol (concatenated_name
, VAR_DOMAIN
);
942 if (symbol_lookup_debug
)
944 fprintf_unfiltered (gdb_stdlog
,
945 "cp_lookup_nested_symbol (...) = %s\n",
946 host_address_to_string (sym
));
951 /* If no matching symbols were found, try searching any
953 sym
= find_symbol_in_baseclass (parent_type
, nested_name
, block
);
954 if (symbol_lookup_debug
)
956 fprintf_unfiltered (gdb_stdlog
,
957 "cp_lookup_nested_symbol (...) = %s\n",
959 ? host_address_to_string (sym
) : "NULL");
965 case TYPE_CODE_METHOD
:
966 if (symbol_lookup_debug
)
968 fprintf_unfiltered (gdb_stdlog
,
969 "cp_lookup_nested_symbol (...) = NULL"
975 internal_error (__FILE__
, __LINE__
,
976 _("cp_lookup_nested_symbol called "
977 "on a non-aggregate type."));
981 /* The C++-version of lookup_transparent_type. */
983 /* FIXME: carlton/2004-01-16: The problem that this is trying to
984 address is that, unfortunately, sometimes NAME is wrong: it may not
985 include the name of namespaces enclosing the type in question.
986 lookup_transparent_type gets called when the type in question
987 is a declaration, and we're trying to find its definition; but, for
988 declarations, our type name deduction mechanism doesn't work.
989 There's nothing we can do to fix this in general, I think, in the
990 absence of debug information about namespaces (I've filed PR
991 gdb/1511 about this); until such debug information becomes more
992 prevalent, one heuristic which sometimes looks is to search for the
993 definition in namespaces containing the current namespace.
995 We should delete this functions once the appropriate debug
996 information becomes more widespread. (GCC 3.4 will be the first
997 released version of GCC with such information.) */
1000 cp_lookup_transparent_type (const char *name
)
1002 /* First, try the honest way of looking up the definition. */
1003 struct type
*t
= basic_lookup_transparent_type (name
);
1009 /* If that doesn't work and we're within a namespace, look there
1011 scope
= block_scope (get_selected_block (0));
1013 if (scope
[0] == '\0')
1016 return cp_lookup_transparent_type_loop (name
, scope
, 0);
1019 /* Lookup the type definition associated to NAME in namespaces/classes
1020 containing SCOPE whose name is strictly longer than LENGTH. LENGTH
1021 must be the index of the start of a component of SCOPE. */
1023 static struct type
*
1024 cp_lookup_transparent_type_loop (const char *name
,
1028 int scope_length
= length
+ cp_find_first_component (scope
+ length
);
1031 /* If the current scope is followed by "::", look in the next
1033 if (scope
[scope_length
] == ':')
1036 = cp_lookup_transparent_type_loop (name
, scope
,
1043 full_name
= alloca (scope_length
+ 2 + strlen (name
) + 1);
1044 strncpy (full_name
, scope
, scope_length
);
1045 strncpy (full_name
+ scope_length
, "::", 2);
1046 strcpy (full_name
+ scope_length
+ 2, name
);
1048 return basic_lookup_transparent_type (full_name
);
1051 /* This used to do something but was removed when it became
1055 maintenance_cplus_namespace (char *args
, int from_tty
)
1057 printf_unfiltered (_("The `maint namespace' command was removed.\n"));
1060 /* Provide a prototype to silence -Wmissing-prototypes. */
1061 extern initialize_file_ftype _initialize_cp_namespace
;
1064 _initialize_cp_namespace (void)
1066 struct cmd_list_element
*cmd
;
1068 cmd
= add_cmd ("namespace", class_maintenance
,
1069 maintenance_cplus_namespace
,
1070 _("Deprecated placeholder for removed functionality."),
1071 &maint_cplus_cmd_list
);
1072 deprecate_cmd (cmd
, NULL
);