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 if (namespace[0] == '\0')
322 return lookup_symbol_file (name
, block
, domain
, 0, search
);
326 char *concatenated_name
= alloca (strlen (namespace) + 2
327 + strlen (name
) + 1);
329 strcpy (concatenated_name
, namespace);
330 strcat (concatenated_name
, "::");
331 strcat (concatenated_name
, name
);
332 return lookup_symbol_file (concatenated_name
, block
, domain
,
333 cp_is_in_anonymous (namespace), search
);
337 /* Used for cleanups to reset the "searched" flag incase
341 reset_directive_searched (void *data
)
343 struct using_direct
*direct
= data
;
344 direct
->searched
= 0;
347 /* Search for NAME by applying all import statements belonging to
348 BLOCK which are applicable in SCOPE. If DECLARATION_ONLY the
349 search is restricted to using declarations.
357 If SEARCH_PARENTS the search will include imports which are
358 applicable in parents of SCOPE.
368 If SCOPE is "A::B" and SEARCH_PARENTS is true the imports of
369 namespaces X and Y will be considered. If SEARCH_PARENTS is false
370 only the import of Y is considered. */
372 static struct symbol
*
373 cp_lookup_symbol_via_imports (const char *scope
,
375 const struct block
*block
,
376 const domain_enum domain
,
377 const int declaration_only
,
378 const int search_parents
)
380 struct using_direct
*current
;
381 struct symbol
*sym
= NULL
;
384 struct cleanup
*searched_cleanup
;
386 /* First, try to find the symbol in the given namespace. */
387 if (!declaration_only
)
388 sym
= cp_lookup_symbol_in_namespace (scope
, name
,
394 /* Go through the using directives. If any of them add new names to
395 the namespace we're searching in, see if we can find a match by
398 for (current
= block_using (block
);
400 current
= current
->next
)
402 const char **excludep
;
404 len
= strlen (current
->import_dest
);
405 directive_match
= (search_parents
406 ? (strncmp (scope
, current
->import_dest
,
407 strlen (current
->import_dest
)) == 0
410 || scope
[len
] == '\0'))
411 : strcmp (scope
, current
->import_dest
) == 0);
413 /* If the import destination is the current scope or one of its
414 ancestors then it is applicable. */
415 if (directive_match
&& !current
->searched
)
417 /* Mark this import as searched so that the recursive call
418 does not search it again. */
419 current
->searched
= 1;
420 searched_cleanup
= make_cleanup (reset_directive_searched
,
423 /* If there is an import of a single declaration, compare the
424 imported declaration (after optional renaming by its alias)
425 with the sought out name. If there is a match pass
426 current->import_src as NAMESPACE to direct the search
427 towards the imported namespace. */
428 if (current
->declaration
429 && strcmp (name
, current
->alias
430 ? current
->alias
: current
->declaration
) == 0)
431 sym
= cp_lookup_symbol_in_namespace (current
->import_src
,
432 current
->declaration
,
435 /* If this is a DECLARATION_ONLY search or a symbol was found
436 or this import statement was an import declaration, the
437 search of this import is complete. */
438 if (declaration_only
|| sym
!= NULL
|| current
->declaration
)
440 current
->searched
= 0;
441 discard_cleanups (searched_cleanup
);
449 /* Do not follow CURRENT if NAME matches its EXCLUDES. */
450 for (excludep
= current
->excludes
; *excludep
; excludep
++)
451 if (strcmp (name
, *excludep
) == 0)
455 discard_cleanups (searched_cleanup
);
459 if (current
->alias
!= NULL
460 && strcmp (name
, current
->alias
) == 0)
461 /* If the import is creating an alias and the alias matches
462 the sought name. Pass current->import_src as the NAME to
463 direct the search towards the aliased namespace. */
465 sym
= cp_lookup_symbol_in_namespace (scope
,
469 else if (current
->alias
== NULL
)
471 /* If this import statement creates no alias, pass
472 current->inner as NAMESPACE to direct the search
473 towards the imported namespace. */
474 sym
= cp_lookup_symbol_via_imports (current
->import_src
,
478 current
->searched
= 0;
479 discard_cleanups (searched_cleanup
);
489 /* Helper function that searches an array of symbols for one named
492 static struct symbol
*
493 search_symbol_list (const char *name
, int num
,
494 struct symbol
**syms
)
498 /* Maybe we should store a dictionary in here instead. */
499 for (i
= 0; i
< num
; ++i
)
501 if (strcmp (name
, SYMBOL_NATURAL_NAME (syms
[i
])) == 0)
507 /* Like cp_lookup_symbol_via_imports, but if BLOCK is a function, it
508 searches through the template parameters of the function and the
512 cp_lookup_symbol_imports_or_template (const char *scope
,
514 const struct block
*block
,
515 const domain_enum domain
)
517 struct symbol
*function
= BLOCK_FUNCTION (block
);
518 struct symbol
*result
;
520 if (symbol_lookup_debug
)
522 fprintf_unfiltered (gdb_stdlog
,
523 "cp_lookup_symbol_imports_or_template"
524 " (%s, %s, %s, %s)\n",
525 scope
, name
, host_address_to_string (block
),
526 domain_name (domain
));
529 if (function
!= NULL
&& SYMBOL_LANGUAGE (function
) == language_cplus
)
531 /* Search the function's template parameters. */
532 if (SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION (function
))
534 struct template_symbol
*templ
535 = (struct template_symbol
*) function
;
537 result
= search_symbol_list (name
,
538 templ
->n_template_arguments
,
539 templ
->template_arguments
);
542 if (symbol_lookup_debug
)
544 fprintf_unfiltered (gdb_stdlog
,
545 "cp_lookup_symbol_imports_or_template"
547 host_address_to_string (result
));
553 /* Search the template parameters of the function's defining
555 if (SYMBOL_NATURAL_NAME (function
))
557 struct type
*context
;
558 char *name_copy
= xstrdup (SYMBOL_NATURAL_NAME (function
));
559 struct cleanup
*cleanups
= make_cleanup (xfree
, name_copy
);
560 const struct language_defn
*lang
= language_def (language_cplus
);
562 = get_objfile_arch (SYMBOL_OBJFILE (function
));
563 const struct block
*parent
= BLOCK_SUPERBLOCK (block
);
567 unsigned int prefix_len
= cp_entire_prefix_len (name_copy
);
573 name_copy
[prefix_len
] = '\0';
574 context
= lookup_typename (lang
, arch
,
583 = search_symbol_list (name
,
584 TYPE_N_TEMPLATE_ARGUMENTS (context
),
585 TYPE_TEMPLATE_ARGUMENTS (context
));
588 do_cleanups (cleanups
);
589 if (symbol_lookup_debug
)
591 fprintf_unfiltered (gdb_stdlog
,
592 "cp_lookup_symbol_imports_or_template"
594 host_address_to_string (result
));
600 do_cleanups (cleanups
);
604 result
= cp_lookup_symbol_via_imports (scope
, name
, block
, domain
, 1, 1);
605 if (symbol_lookup_debug
)
607 fprintf_unfiltered (gdb_stdlog
,
608 "cp_lookup_symbol_imports_or_template (...) = %s\n",
610 ? host_address_to_string (result
) : "NULL");
615 /* Searches for NAME in the current namespace, and by applying
616 relevant import statements belonging to BLOCK and its parents.
617 SCOPE is the namespace scope of the context in which the search is
621 cp_lookup_symbol_namespace (const char *scope
,
623 const struct block
*block
,
624 const domain_enum domain
)
628 if (symbol_lookup_debug
)
630 fprintf_unfiltered (gdb_stdlog
,
631 "cp_lookup_symbol_namespace (%s, %s, %s, %s)\n",
632 scope
, name
, host_address_to_string (block
),
633 domain_name (domain
));
636 /* First, try to find the symbol in the given namespace. */
637 sym
= cp_lookup_symbol_in_namespace (scope
, name
,
641 if (symbol_lookup_debug
)
643 fprintf_unfiltered (gdb_stdlog
,
644 "cp_lookup_symbol_namespace (...) = %s\n",
645 host_address_to_string (sym
));
650 /* Search for name in namespaces imported to this and parent
652 while (block
!= NULL
)
654 sym
= cp_lookup_symbol_via_imports (scope
, name
, block
,
659 if (symbol_lookup_debug
)
661 fprintf_unfiltered (gdb_stdlog
,
662 "cp_lookup_symbol_namespace (...) = %s\n",
663 host_address_to_string (sym
));
668 block
= BLOCK_SUPERBLOCK (block
);
671 if (symbol_lookup_debug
)
673 fprintf_unfiltered (gdb_stdlog
,
674 "cp_lookup_symbol_namespace (...) = NULL\n");
679 /* Lookup NAME at namespace scope (or, in C terms, in static and
680 global variables). SCOPE is the namespace that the current
681 function is defined within; only consider namespaces whose length
682 is at least SCOPE_LEN. Other arguments are as in
683 cp_lookup_symbol_nonlocal.
685 For example, if we're within a function A::B::f and looking for a
686 symbol x, this will get called with NAME = "x", SCOPE = "A::B", and
687 SCOPE_LEN = 0. It then calls itself with NAME and SCOPE the same,
688 but with SCOPE_LEN = 1. And then it calls itself with NAME and
689 SCOPE the same, but with SCOPE_LEN = 4. This third call looks for
690 "A::B::x"; if it doesn't find it, then the second call looks for
691 "A::x", and if that call fails, then the first call looks for
694 static struct symbol
*
695 lookup_namespace_scope (const char *name
,
696 const struct block
*block
,
697 const domain_enum domain
,
703 if (scope
[scope_len
] != '\0')
705 /* Recursively search for names in child namespaces first. */
708 int new_scope_len
= scope_len
;
710 /* If the current scope is followed by "::", skip past that. */
711 if (new_scope_len
!= 0)
713 gdb_assert (scope
[new_scope_len
] == ':');
716 new_scope_len
+= cp_find_first_component (scope
+ new_scope_len
);
717 sym
= lookup_namespace_scope (name
, block
, domain
,
718 scope
, new_scope_len
);
723 /* Okay, we didn't find a match in our children, so look for the
724 name in the current namespace. */
726 namespace = alloca (scope_len
+ 1);
727 strncpy (namespace, scope
, scope_len
);
728 namespace[scope_len
] = '\0';
729 return cp_lookup_symbol_in_namespace (namespace, name
,
733 /* The C++-specific version of name lookup for static and global
734 names. This makes sure that names get looked for in all namespaces
735 that are in scope. NAME is the natural name of the symbol that
736 we're looking for, BLOCK is the block that we're searching within,
737 DOMAIN says what kind of symbols we're looking for. */
740 cp_lookup_symbol_nonlocal (const char *name
,
741 const struct block
*block
,
742 const domain_enum domain
)
745 const char *scope
= block_scope (block
);
747 if (symbol_lookup_debug
)
749 fprintf_unfiltered (gdb_stdlog
,
750 "cp_lookup_symbol_non_local"
751 " (%s, %s (scope %s), %s)\n",
752 name
, host_address_to_string (block
), scope
,
753 domain_name (domain
));
756 sym
= lookup_namespace_scope (name
, block
, domain
, scope
, 0);
759 if (symbol_lookup_debug
)
761 fprintf_unfiltered (gdb_stdlog
,
762 "cp_lookup_symbol_nonlocal (...) = %s\n",
763 host_address_to_string (sym
));
768 sym
= cp_lookup_symbol_namespace (scope
, name
, block
, domain
);
769 if (symbol_lookup_debug
)
771 fprintf_unfiltered (gdb_stdlog
,
772 "cp_lookup_symbol_nonlocal (...) = %s\n",
773 sym
!= NULL
? host_address_to_string (sym
) : "NULL");
778 /* Search through the base classes of PARENT_TYPE for a base class
779 named NAME and return its type. If not found, return NULL. */
782 cp_find_type_baseclass_by_name (struct type
*parent_type
, const char *name
)
786 CHECK_TYPEDEF (parent_type
);
787 for (i
= 0; i
< TYPE_N_BASECLASSES (parent_type
); ++i
)
789 struct type
*type
= check_typedef (TYPE_BASECLASS (parent_type
, i
));
790 const char *base_name
= TYPE_BASECLASS_NAME (parent_type
, i
);
792 if (base_name
== NULL
)
795 if (streq (base_name
, name
))
798 type
= cp_find_type_baseclass_by_name (type
, name
);
806 /* Search through the base classes of PARENT_TYPE for a symbol named
807 NAME in block BLOCK. */
809 static struct symbol
*
810 find_symbol_in_baseclass (struct type
*parent_type
, const char *name
,
811 const struct block
*block
)
815 struct cleanup
*cleanup
;
816 char *concatenated_name
;
819 concatenated_name
= NULL
;
820 cleanup
= make_cleanup (free_current_contents
, &concatenated_name
);
822 for (i
= 0; i
< TYPE_N_BASECLASSES (parent_type
); ++i
)
825 struct type
*base_type
= TYPE_BASECLASS (parent_type
, i
);
826 const char *base_name
= TYPE_BASECLASS_NAME (parent_type
, i
);
828 if (base_name
== NULL
)
831 /* Search this particular base class. */
832 sym
= cp_lookup_symbol_in_namespace (base_name
, name
, block
,
837 /* Now search all static file-level symbols. We have to do this for
838 things like typedefs in the class. First search in this symtab,
839 what we want is possibly there. */
840 len
= strlen (base_name
) + 2 + strlen (name
) + 1;
841 concatenated_name
= xrealloc (concatenated_name
, len
);
842 xsnprintf (concatenated_name
, len
, "%s::%s", base_name
, name
);
843 sym
= lookup_symbol_in_static_block (concatenated_name
, block
,
848 /* Nope. We now have to search all static blocks in all objfiles,
849 even if block != NULL, because there's no guarantees as to which
850 symtab the symbol we want is in. */
851 sym
= lookup_static_symbol (concatenated_name
, VAR_DOMAIN
);
855 /* If this class has base classes, search them next. */
856 CHECK_TYPEDEF (base_type
);
857 if (TYPE_N_BASECLASSES (base_type
) > 0)
859 sym
= find_symbol_in_baseclass (base_type
, name
, block
);
865 do_cleanups (cleanup
);
869 /* Look up a symbol named NESTED_NAME that is nested inside the C++
870 class or namespace given by PARENT_TYPE, from within the context
871 given by BLOCK. Return NULL if there is no such nested symbol. */
874 cp_lookup_nested_symbol (struct type
*parent_type
,
875 const char *nested_name
,
876 const struct block
*block
)
878 /* type_name_no_tag_or_error provides better error reporting using the
880 struct type
*saved_parent_type
= parent_type
;
882 CHECK_TYPEDEF (parent_type
);
884 if (symbol_lookup_debug
)
886 const char *type_name
= type_name_no_tag (saved_parent_type
);
888 fprintf_unfiltered (gdb_stdlog
,
889 "cp_lookup_nested_symbol (%s, %s, %s)\n",
890 type_name
!= NULL
? type_name
: "unnamed",
891 nested_name
, host_address_to_string (block
));
894 switch (TYPE_CODE (parent_type
))
896 case TYPE_CODE_STRUCT
:
897 case TYPE_CODE_NAMESPACE
:
898 case TYPE_CODE_UNION
:
900 /* NOTE: Handle modules here as well, because Fortran is re-using the C++
901 specific code to lookup nested symbols in modules, by calling the
902 function pointer la_lookup_symbol_nonlocal, which ends up here. */
903 case TYPE_CODE_MODULE
:
905 /* NOTE: carlton/2003-11-10: We don't treat C++ class members
906 of classes like, say, data or function members. Instead,
907 they're just represented by symbols whose names are
908 qualified by the name of the surrounding class. This is
909 just like members of namespaces; in particular,
910 lookup_symbol_namespace works when looking them up. */
913 const char *parent_name
= type_name_no_tag_or_error (saved_parent_type
);
915 = cp_lookup_symbol_in_namespace (parent_name
, nested_name
,
916 block
, VAR_DOMAIN
, 0);
917 char *concatenated_name
;
921 if (symbol_lookup_debug
)
923 fprintf_unfiltered (gdb_stdlog
,
924 "cp_lookup_nested_symbol (...) = %s\n",
925 host_address_to_string (sym
));
930 /* Now search all static file-level symbols. We have to do this
931 for things like typedefs in the class. We do not try to
932 guess any imported namespace as even the fully specified
933 namespace search is already not C++ compliant and more
934 assumptions could make it too magic. */
936 size
= strlen (parent_name
) + 2 + strlen (nested_name
) + 1;
937 concatenated_name
= alloca (size
);
938 xsnprintf (concatenated_name
, size
, "%s::%s",
939 parent_name
, nested_name
);
940 sym
= lookup_static_symbol (concatenated_name
, VAR_DOMAIN
);
943 if (symbol_lookup_debug
)
945 fprintf_unfiltered (gdb_stdlog
,
946 "cp_lookup_nested_symbol (...) = %s\n",
947 host_address_to_string (sym
));
952 /* If no matching symbols were found, try searching any
954 sym
= find_symbol_in_baseclass (parent_type
, nested_name
, block
);
955 if (symbol_lookup_debug
)
957 fprintf_unfiltered (gdb_stdlog
,
958 "cp_lookup_nested_symbol (...) = %s\n",
960 ? host_address_to_string (sym
) : "NULL");
966 case TYPE_CODE_METHOD
:
967 if (symbol_lookup_debug
)
969 fprintf_unfiltered (gdb_stdlog
,
970 "cp_lookup_nested_symbol (...) = NULL"
976 internal_error (__FILE__
, __LINE__
,
977 _("cp_lookup_nested_symbol called "
978 "on a non-aggregate type."));
982 /* The C++-version of lookup_transparent_type. */
984 /* FIXME: carlton/2004-01-16: The problem that this is trying to
985 address is that, unfortunately, sometimes NAME is wrong: it may not
986 include the name of namespaces enclosing the type in question.
987 lookup_transparent_type gets called when the type in question
988 is a declaration, and we're trying to find its definition; but, for
989 declarations, our type name deduction mechanism doesn't work.
990 There's nothing we can do to fix this in general, I think, in the
991 absence of debug information about namespaces (I've filed PR
992 gdb/1511 about this); until such debug information becomes more
993 prevalent, one heuristic which sometimes looks is to search for the
994 definition in namespaces containing the current namespace.
996 We should delete this functions once the appropriate debug
997 information becomes more widespread. (GCC 3.4 will be the first
998 released version of GCC with such information.) */
1001 cp_lookup_transparent_type (const char *name
)
1003 /* First, try the honest way of looking up the definition. */
1004 struct type
*t
= basic_lookup_transparent_type (name
);
1010 /* If that doesn't work and we're within a namespace, look there
1012 scope
= block_scope (get_selected_block (0));
1014 if (scope
[0] == '\0')
1017 return cp_lookup_transparent_type_loop (name
, scope
, 0);
1020 /* Lookup the type definition associated to NAME in namespaces/classes
1021 containing SCOPE whose name is strictly longer than LENGTH. LENGTH
1022 must be the index of the start of a component of SCOPE. */
1024 static struct type
*
1025 cp_lookup_transparent_type_loop (const char *name
,
1029 int scope_length
= length
+ cp_find_first_component (scope
+ length
);
1032 /* If the current scope is followed by "::", look in the next
1034 if (scope
[scope_length
] == ':')
1037 = cp_lookup_transparent_type_loop (name
, scope
,
1044 full_name
= alloca (scope_length
+ 2 + strlen (name
) + 1);
1045 strncpy (full_name
, scope
, scope_length
);
1046 strncpy (full_name
+ scope_length
, "::", 2);
1047 strcpy (full_name
+ scope_length
+ 2, name
);
1049 return basic_lookup_transparent_type (full_name
);
1052 /* This used to do something but was removed when it became
1056 maintenance_cplus_namespace (char *args
, int from_tty
)
1058 printf_unfiltered (_("The `maint namespace' command was removed.\n"));
1061 /* Provide a prototype to silence -Wmissing-prototypes. */
1062 extern initialize_file_ftype _initialize_cp_namespace
;
1065 _initialize_cp_namespace (void)
1067 struct cmd_list_element
*cmd
;
1069 cmd
= add_cmd ("namespace", class_maintenance
,
1070 maintenance_cplus_namespace
,
1071 _("Deprecated placeholder for removed functionality."),
1072 &maint_cplus_cmd_list
);
1073 deprecate_cmd (cmd
, NULL
);