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"
26 #include "gdb_assert.h"
30 #include "dictionary.h"
36 static struct symbol
*lookup_namespace_scope (const char *name
,
37 const struct block
*block
,
38 const domain_enum domain
,
42 static struct symbol
*lookup_symbol_file (const char *name
,
43 const struct block
*block
,
44 const domain_enum domain
,
45 int anonymous_namespace
,
48 static struct type
*cp_lookup_transparent_type_loop (const char *name
,
52 /* Check to see if SYMBOL refers to an object contained within an
53 anonymous namespace; if so, add an appropriate using directive. */
56 cp_scan_for_anonymous_namespaces (const struct symbol
*const symbol
,
57 struct objfile
*const objfile
)
59 if (SYMBOL_DEMANGLED_NAME (symbol
) != NULL
)
61 const char *name
= SYMBOL_DEMANGLED_NAME (symbol
);
62 unsigned int previous_component
;
63 unsigned int next_component
;
65 /* Start with a quick-and-dirty check for mention of "(anonymous
68 if (!cp_is_anonymous (name
))
71 previous_component
= 0;
72 next_component
= cp_find_first_component (name
+ previous_component
);
74 while (name
[next_component
] == ':')
76 if (((next_component
- previous_component
)
77 == CP_ANONYMOUS_NAMESPACE_LEN
)
78 && strncmp (name
+ previous_component
,
79 CP_ANONYMOUS_NAMESPACE_STR
,
80 CP_ANONYMOUS_NAMESPACE_LEN
) == 0)
82 int dest_len
= (previous_component
== 0
83 ? 0 : previous_component
- 2);
84 int src_len
= next_component
;
86 char *dest
= alloca (dest_len
+ 1);
87 char *src
= alloca (src_len
+ 1);
89 memcpy (dest
, name
, dest_len
);
90 memcpy (src
, name
, src_len
);
92 dest
[dest_len
] = '\0';
95 /* We've found a component of the name that's an
96 anonymous namespace. So add symbols in it to the
97 namespace given by the previous component if there is
98 one, or to the global namespace if there isn't. */
99 cp_add_using_directive (dest
, src
, NULL
, NULL
, NULL
, 1,
100 &objfile
->objfile_obstack
);
102 /* The "+ 2" is for the "::". */
103 previous_component
= next_component
+ 2;
104 next_component
= (previous_component
105 + cp_find_first_component (name
106 + previous_component
));
112 /* Add a using directive to using_directives. If the using directive
113 in question has already been added, don't add it twice.
115 Create a new struct using_direct which imports the namespace SRC
116 into the scope DEST. ALIAS is the name of the imported namespace
117 in the current scope. If ALIAS is NULL then the namespace is known
118 by its original name. DECLARATION is the name if the imported
119 varable if this is a declaration import (Eg. using A::x), otherwise
120 it is NULL. EXCLUDES is a list of names not to import from an
121 imported module or NULL. If COPY_NAMES is non-zero, then the
122 arguments are copied into newly allocated memory so they can be
123 temporaries. For EXCLUDES the VEC pointers are copied but the
124 pointed to characters are not copied. */
127 cp_add_using_directive (const char *dest
,
130 const char *declaration
,
131 VEC (const_char_ptr
) *excludes
,
133 struct obstack
*obstack
)
135 struct using_direct
*current
;
136 struct using_direct
*new;
138 /* Has it already been added? */
140 for (current
= using_directives
; current
!= NULL
; current
= current
->next
)
145 if (strcmp (current
->import_src
, src
) != 0)
147 if (strcmp (current
->import_dest
, dest
) != 0)
149 if ((alias
== NULL
&& current
->alias
!= NULL
)
150 || (alias
!= NULL
&& current
->alias
== NULL
)
151 || (alias
!= NULL
&& current
->alias
!= NULL
152 && strcmp (alias
, current
->alias
) != 0))
154 if ((declaration
== NULL
&& current
->declaration
!= NULL
)
155 || (declaration
!= NULL
&& current
->declaration
== NULL
)
156 || (declaration
!= NULL
&& current
->declaration
!= NULL
157 && strcmp (declaration
, current
->declaration
) != 0))
160 /* Compare the contents of EXCLUDES. */
161 for (ix
= 0; VEC_iterate (const_char_ptr
, excludes
, ix
, param
); ix
++)
162 if (current
->excludes
[ix
] == NULL
163 || strcmp (param
, current
->excludes
[ix
]) != 0)
165 if (ix
< VEC_length (const_char_ptr
, excludes
)
166 || current
->excludes
[ix
] != NULL
)
169 /* Parameters exactly match CURRENT. */
173 new = obstack_alloc (obstack
, (sizeof (*new)
174 + (VEC_length (const_char_ptr
, excludes
)
175 * sizeof (*new->excludes
))));
176 memset (new, 0, sizeof (*new));
180 new->import_src
= obstack_copy0 (obstack
, src
, strlen (src
));
181 new->import_dest
= obstack_copy0 (obstack
, dest
, strlen (dest
));
185 new->import_src
= src
;
186 new->import_dest
= dest
;
189 if (alias
!= NULL
&& copy_names
)
190 new->alias
= obstack_copy0 (obstack
, alias
, strlen (alias
));
194 if (declaration
!= NULL
&& copy_names
)
195 new->declaration
= obstack_copy0 (obstack
,
196 declaration
, strlen (declaration
));
198 new->declaration
= declaration
;
200 memcpy (new->excludes
, VEC_address (const_char_ptr
, excludes
),
201 VEC_length (const_char_ptr
, excludes
) * sizeof (*new->excludes
));
202 new->excludes
[VEC_length (const_char_ptr
, excludes
)] = NULL
;
204 new->next
= using_directives
;
205 using_directives
= new;
208 /* Test whether or not NAMESPACE looks like it mentions an anonymous
209 namespace; return nonzero if so. */
212 cp_is_anonymous (const char *namespace)
214 return (strstr (namespace, CP_ANONYMOUS_NAMESPACE_STR
)
218 /* The C++-specific version of name lookup for static and global
219 names. This makes sure that names get looked for in all namespaces
220 that are in scope. NAME is the natural name of the symbol that
221 we're looking for, BLOCK is the block that we're searching within,
222 DOMAIN says what kind of symbols we're looking for, and if SYMTAB
223 is non-NULL, we should store the symtab where we found the symbol
226 Class, union, and enum tag names may be used in C++ without specifying
227 class-key or enum. If searching for a VAR_DOMAIN symbol fails,
228 this function will search STRUCT_DOMAIN. [This is actually done in
229 cp_lookup_symbol_in_namespace.] */
232 cp_lookup_symbol_nonlocal (const char *name
,
233 const struct block
*block
,
234 const domain_enum domain
)
237 const char *scope
= block_scope (block
);
239 sym
= lookup_namespace_scope (name
, block
,
244 return cp_lookup_symbol_namespace (scope
, name
,
248 /* Look up NAME in the C++ namespace NAMESPACE. Other arguments are
249 as in cp_lookup_symbol_nonlocal. If SEARCH is non-zero, search
250 through base classes for a matching symbol.
252 If DOMAIN is VAR_DOMAIN and no matching symbol exists in that domain,
253 this function will search STRUCT_DOMAIN for a match. */
255 static struct symbol
*
256 cp_lookup_symbol_in_namespace (const char *namespace,
258 const struct block
*block
,
259 const domain_enum domain
, int search
)
261 if (namespace[0] == '\0')
263 struct symbol
*sym
= lookup_symbol_file (name
, block
, domain
, 0, search
);
265 if (sym
== NULL
&& domain
== VAR_DOMAIN
)
266 sym
= lookup_symbol_file (name
, block
, STRUCT_DOMAIN
, 0, search
);
273 char *concatenated_name
= alloca (strlen (namespace) + 2
274 + strlen (name
) + 1);
276 strcpy (concatenated_name
, namespace);
277 strcat (concatenated_name
, "::");
278 strcat (concatenated_name
, name
);
279 sym
= lookup_symbol_file (concatenated_name
, block
, domain
,
280 cp_is_anonymous (namespace), search
);
282 if (sym
== NULL
&& domain
== VAR_DOMAIN
)
283 sym
= lookup_symbol_file (concatenated_name
, block
, STRUCT_DOMAIN
,
284 cp_is_anonymous (namespace), search
);
290 /* Used for cleanups to reset the "searched" flag incase
294 reset_directive_searched (void *data
)
296 struct using_direct
*direct
= data
;
297 direct
->searched
= 0;
300 /* Search for NAME by applying all import statements belonging to
301 BLOCK which are applicable in SCOPE. If DECLARATION_ONLY the
302 search is restricted to using declarations.
310 If SEARCH_PARENTS the search will include imports which are
311 applicable in parents of SCOPE.
321 If SCOPE is "A::B" and SEARCH_PARENTS is true the imports of
322 namespaces X and Y will be considered. If SEARCH_PARENTS is false
323 only the import of Y is considered. */
326 cp_lookup_symbol_imports (const char *scope
,
328 const struct block
*block
,
329 const domain_enum domain
,
330 const int declaration_only
,
331 const int search_parents
)
333 struct using_direct
*current
;
334 struct symbol
*sym
= NULL
;
337 struct cleanup
*searched_cleanup
;
339 /* First, try to find the symbol in the given namespace. */
340 if (!declaration_only
)
341 sym
= cp_lookup_symbol_in_namespace (scope
, name
,
347 /* Go through the using directives. If any of them add new names to
348 the namespace we're searching in, see if we can find a match by
351 for (current
= block_using (block
);
353 current
= current
->next
)
355 const char **excludep
;
357 len
= strlen (current
->import_dest
);
358 directive_match
= (search_parents
359 ? (strncmp (scope
, current
->import_dest
,
360 strlen (current
->import_dest
)) == 0
363 || scope
[len
] == '\0'))
364 : strcmp (scope
, current
->import_dest
) == 0);
366 /* If the import destination is the current scope or one of its
367 ancestors then it is applicable. */
368 if (directive_match
&& !current
->searched
)
370 /* Mark this import as searched so that the recursive call
371 does not search it again. */
372 current
->searched
= 1;
373 searched_cleanup
= make_cleanup (reset_directive_searched
,
376 /* If there is an import of a single declaration, compare the
377 imported declaration (after optional renaming by its alias)
378 with the sought out name. If there is a match pass
379 current->import_src as NAMESPACE to direct the search
380 towards the imported namespace. */
381 if (current
->declaration
382 && strcmp (name
, current
->alias
383 ? current
->alias
: current
->declaration
) == 0)
384 sym
= cp_lookup_symbol_in_namespace (current
->import_src
,
385 current
->declaration
,
388 /* If this is a DECLARATION_ONLY search or a symbol was found
389 or this import statement was an import declaration, the
390 search of this import is complete. */
391 if (declaration_only
|| sym
!= NULL
|| current
->declaration
)
393 current
->searched
= 0;
394 discard_cleanups (searched_cleanup
);
402 /* Do not follow CURRENT if NAME matches its EXCLUDES. */
403 for (excludep
= current
->excludes
; *excludep
; excludep
++)
404 if (strcmp (name
, *excludep
) == 0)
408 discard_cleanups (searched_cleanup
);
412 if (current
->alias
!= NULL
413 && strcmp (name
, current
->alias
) == 0)
414 /* If the import is creating an alias and the alias matches
415 the sought name. Pass current->import_src as the NAME to
416 direct the search towards the aliased namespace. */
418 sym
= cp_lookup_symbol_in_namespace (scope
,
422 else if (current
->alias
== NULL
)
424 /* If this import statement creates no alias, pass
425 current->inner as NAMESPACE to direct the search
426 towards the imported namespace. */
427 sym
= cp_lookup_symbol_imports (current
->import_src
,
431 current
->searched
= 0;
432 discard_cleanups (searched_cleanup
);
442 /* Helper function that searches an array of symbols for one named
445 static struct symbol
*
446 search_symbol_list (const char *name
, int num
,
447 struct symbol
**syms
)
451 /* Maybe we should store a dictionary in here instead. */
452 for (i
= 0; i
< num
; ++i
)
454 if (strcmp (name
, SYMBOL_NATURAL_NAME (syms
[i
])) == 0)
460 /* Like cp_lookup_symbol_imports, but if BLOCK is a function, it
461 searches through the template parameters of the function and the
465 cp_lookup_symbol_imports_or_template (const char *scope
,
467 const struct block
*block
,
468 const domain_enum domain
)
470 struct symbol
*function
= BLOCK_FUNCTION (block
);
472 if (function
!= NULL
&& SYMBOL_LANGUAGE (function
) == language_cplus
)
474 /* Search the function's template parameters. */
475 if (SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION (function
))
477 struct template_symbol
*templ
478 = (struct template_symbol
*) function
;
479 struct symbol
*result
;
481 result
= search_symbol_list (name
,
482 templ
->n_template_arguments
,
483 templ
->template_arguments
);
488 /* Search the template parameters of the function's defining
490 if (SYMBOL_NATURAL_NAME (function
))
492 struct type
*context
;
493 char *name_copy
= xstrdup (SYMBOL_NATURAL_NAME (function
));
494 struct cleanup
*cleanups
= make_cleanup (xfree
, name_copy
);
495 const struct language_defn
*lang
= language_def (language_cplus
);
497 = get_objfile_arch (SYMBOL_SYMTAB (function
)->objfile
);
498 const struct block
*parent
= BLOCK_SUPERBLOCK (block
);
502 struct symbol
*result
;
503 unsigned int prefix_len
= cp_entire_prefix_len (name_copy
);
509 name_copy
[prefix_len
] = '\0';
510 context
= lookup_typename (lang
, arch
,
519 = search_symbol_list (name
,
520 TYPE_N_TEMPLATE_ARGUMENTS (context
),
521 TYPE_TEMPLATE_ARGUMENTS (context
));
524 do_cleanups (cleanups
);
529 do_cleanups (cleanups
);
533 return cp_lookup_symbol_imports (scope
, name
, block
, domain
, 1, 1);
536 /* Searches for NAME in the current namespace, and by applying
537 relevant import statements belonging to BLOCK and its parents.
538 SCOPE is the namespace scope of the context in which the search is
541 Class, union, and enum tag names may be used in C++ without specifying
542 class-key or enum. If searching for a VAR_DOMAIN symbol fails,
543 this function will search STRUCT_DOMAIN. [This is done in
544 cp_lookup_symbol_in_namespace.] */
547 cp_lookup_symbol_namespace (const char *scope
,
549 const struct block
*block
,
550 const domain_enum domain
)
554 /* First, try to find the symbol in the given namespace. */
555 sym
= cp_lookup_symbol_in_namespace (scope
, name
,
560 /* Search for name in namespaces imported to this and parent
562 while (block
!= NULL
)
564 sym
= cp_lookup_symbol_imports (scope
, name
, block
,
570 block
= BLOCK_SUPERBLOCK (block
);
576 /* Lookup NAME at namespace scope (or, in C terms, in static and
577 global variables). SCOPE is the namespace that the current
578 function is defined within; only consider namespaces whose length
579 is at least SCOPE_LEN. Other arguments are as in
580 cp_lookup_symbol_nonlocal.
582 For example, if we're within a function A::B::f and looking for a
583 symbol x, this will get called with NAME = "x", SCOPE = "A::B", and
584 SCOPE_LEN = 0. It then calls itself with NAME and SCOPE the same,
585 but with SCOPE_LEN = 1. And then it calls itself with NAME and
586 SCOPE the same, but with SCOPE_LEN = 4. This third call looks for
587 "A::B::x"; if it doesn't find it, then the second call looks for
588 "A::x", and if that call fails, then the first call looks for
591 static struct symbol
*
592 lookup_namespace_scope (const char *name
,
593 const struct block
*block
,
594 const domain_enum domain
,
600 if (scope
[scope_len
] != '\0')
602 /* Recursively search for names in child namespaces first. */
605 int new_scope_len
= scope_len
;
607 /* If the current scope is followed by "::", skip past that. */
608 if (new_scope_len
!= 0)
610 gdb_assert (scope
[new_scope_len
] == ':');
613 new_scope_len
+= cp_find_first_component (scope
+ new_scope_len
);
614 sym
= lookup_namespace_scope (name
, block
, domain
,
615 scope
, new_scope_len
);
620 /* Okay, we didn't find a match in our children, so look for the
621 name in the current namespace. */
623 namespace = alloca (scope_len
+ 1);
624 strncpy (namespace, scope
, scope_len
);
625 namespace[scope_len
] = '\0';
626 return cp_lookup_symbol_in_namespace (namespace, name
,
630 /* Look up NAME in BLOCK's static block and in global blocks. If
631 ANONYMOUS_NAMESPACE is nonzero, the symbol in question is located
632 within an anonymous namespace. If SEARCH is non-zero, search through
633 base classes for a matching symbol. Other arguments are as in
634 cp_lookup_symbol_nonlocal. */
636 static struct symbol
*
637 lookup_symbol_file (const char *name
,
638 const struct block
*block
,
639 const domain_enum domain
,
640 int anonymous_namespace
, int search
)
642 struct symbol
*sym
= NULL
;
644 sym
= lookup_symbol_static (name
, block
, domain
);
648 if (anonymous_namespace
)
650 /* Symbols defined in anonymous namespaces have external linkage
651 but should be treated as local to a single file nonetheless.
652 So we only search the current file's global block. */
654 const struct block
*global_block
= block_global_block (block
);
656 if (global_block
!= NULL
)
657 sym
= lookup_symbol_aux_block (name
, global_block
, domain
);
661 sym
= lookup_symbol_global (name
, block
, domain
);
669 char *klass
, *nested
;
670 unsigned int prefix_len
;
671 struct cleanup
*cleanup
;
672 struct symbol
*klass_sym
;
674 /* A simple lookup failed. Check if the symbol was defined in
677 cleanup
= make_cleanup (null_cleanup
, NULL
);
679 /* Find the name of the class and the name of the method,
681 prefix_len
= cp_entire_prefix_len (name
);
683 /* If no prefix was found, search "this". */
689 this = lookup_language_this (language_def (language_cplus
), block
);
692 do_cleanups (cleanup
);
696 type
= check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (this)));
697 klass
= xstrdup (TYPE_NAME (type
));
698 nested
= xstrdup (name
);
702 /* The class name is everything up to and including PREFIX_LEN. */
703 klass
= savestring (name
, prefix_len
);
705 /* The rest of the name is everything else past the initial scope
707 nested
= xstrdup (name
+ prefix_len
+ 2);
710 /* Add cleanups to free memory for these strings. */
711 make_cleanup (xfree
, klass
);
712 make_cleanup (xfree
, nested
);
714 /* Lookup a class named KLASS. If none is found, there is nothing
715 more that can be done. */
716 klass_sym
= lookup_symbol_global (klass
, block
, STRUCT_DOMAIN
);
717 if (klass_sym
== NULL
)
719 do_cleanups (cleanup
);
723 /* Look for a symbol named NESTED in this class. */
724 sym
= cp_lookup_nested_symbol (SYMBOL_TYPE (klass_sym
), nested
, block
);
725 do_cleanups (cleanup
);
731 /* Search through the base classes of PARENT_TYPE for a base class
732 named NAME and return its type. If not found, return NULL. */
735 find_type_baseclass_by_name (struct type
*parent_type
, const char *name
)
739 CHECK_TYPEDEF (parent_type
);
740 for (i
= 0; i
< TYPE_N_BASECLASSES (parent_type
); ++i
)
742 struct type
*type
= check_typedef (TYPE_BASECLASS (parent_type
, i
));
743 const char *base_name
= TYPE_BASECLASS_NAME (parent_type
, i
);
745 if (base_name
== NULL
)
748 if (streq (base_name
, name
))
751 type
= find_type_baseclass_by_name (type
, name
);
759 /* Search through the base classes of PARENT_TYPE for a symbol named
760 NAME in block BLOCK. */
762 static struct symbol
*
763 find_symbol_in_baseclass (struct type
*parent_type
, const char *name
,
764 const struct block
*block
)
768 struct cleanup
*cleanup
;
769 char *concatenated_name
;
772 concatenated_name
= NULL
;
773 cleanup
= make_cleanup (free_current_contents
, &concatenated_name
);
774 for (i
= 0; i
< TYPE_N_BASECLASSES (parent_type
); ++i
)
777 struct type
*base_type
= TYPE_BASECLASS (parent_type
, i
);
778 const char *base_name
= TYPE_BASECLASS_NAME (parent_type
, i
);
780 if (base_name
== NULL
)
783 /* Search this particular base class. */
784 sym
= cp_lookup_symbol_in_namespace (base_name
, name
, block
,
789 /* Now search all static file-level symbols. We have to do this for
790 things like typedefs in the class. First search in this symtab,
791 what we want is possibly there. */
792 len
= strlen (base_name
) + 2 + strlen (name
) + 1;
793 concatenated_name
= xrealloc (concatenated_name
, len
);
794 xsnprintf (concatenated_name
, len
, "%s::%s", base_name
, name
);
795 sym
= lookup_symbol_static (concatenated_name
, block
, VAR_DOMAIN
);
799 /* Nope. We now have to search all static blocks in all objfiles,
800 even if block != NULL, because there's no guarantees as to which
801 symtab the symbol we want is in. */
802 sym
= lookup_static_symbol_aux (concatenated_name
, VAR_DOMAIN
);
806 /* If this class has base classes, search them next. */
807 CHECK_TYPEDEF (base_type
);
808 if (TYPE_N_BASECLASSES (base_type
) > 0)
810 sym
= find_symbol_in_baseclass (base_type
, name
, block
);
816 do_cleanups (cleanup
);
820 /* Look up a symbol named NESTED_NAME that is nested inside the C++
821 class or namespace given by PARENT_TYPE, from within the context
822 given by BLOCK. Return NULL if there is no such nested type. */
825 cp_lookup_nested_symbol (struct type
*parent_type
,
826 const char *nested_name
,
827 const struct block
*block
)
829 /* type_name_no_tag_required provides better error reporting using the
831 struct type
*saved_parent_type
= parent_type
;
833 CHECK_TYPEDEF (parent_type
);
835 switch (TYPE_CODE (parent_type
))
837 case TYPE_CODE_STRUCT
:
838 case TYPE_CODE_NAMESPACE
:
839 case TYPE_CODE_UNION
:
841 /* NOTE: Handle modules here as well, because Fortran is re-using the C++
842 specific code to lookup nested symbols in modules, by calling the
843 function pointer la_lookup_symbol_nonlocal, which ends up here. */
844 case TYPE_CODE_MODULE
:
846 /* NOTE: carlton/2003-11-10: We don't treat C++ class members
847 of classes like, say, data or function members. Instead,
848 they're just represented by symbols whose names are
849 qualified by the name of the surrounding class. This is
850 just like members of namespaces; in particular,
851 lookup_symbol_namespace works when looking them up. */
854 const char *parent_name
= type_name_no_tag_or_error (saved_parent_type
);
856 = cp_lookup_symbol_in_namespace (parent_name
, nested_name
,
857 block
, VAR_DOMAIN
, 0);
858 char *concatenated_name
;
863 /* Now search all static file-level symbols. We have to do this
864 for things like typedefs in the class. We do not try to
865 guess any imported namespace as even the fully specified
866 namespace search is already not C++ compliant and more
867 assumptions could make it too magic. */
869 size
= strlen (parent_name
) + 2 + strlen (nested_name
) + 1;
870 concatenated_name
= alloca (size
);
871 xsnprintf (concatenated_name
, size
, "%s::%s",
872 parent_name
, nested_name
);
873 sym
= lookup_static_symbol_aux (concatenated_name
, VAR_DOMAIN
);
877 /* If no matching symbols were found, try searching any
879 return find_symbol_in_baseclass (parent_type
, nested_name
, block
);
883 case TYPE_CODE_METHOD
:
887 internal_error (__FILE__
, __LINE__
,
888 _("cp_lookup_nested_symbol called "
889 "on a non-aggregate type."));
893 /* The C++-version of lookup_transparent_type. */
895 /* FIXME: carlton/2004-01-16: The problem that this is trying to
896 address is that, unfortunately, sometimes NAME is wrong: it may not
897 include the name of namespaces enclosing the type in question.
898 lookup_transparent_type gets called when the type in question
899 is a declaration, and we're trying to find its definition; but, for
900 declarations, our type name deduction mechanism doesn't work.
901 There's nothing we can do to fix this in general, I think, in the
902 absence of debug information about namespaces (I've filed PR
903 gdb/1511 about this); until such debug information becomes more
904 prevalent, one heuristic which sometimes looks is to search for the
905 definition in namespaces containing the current namespace.
907 We should delete this functions once the appropriate debug
908 information becomes more widespread. (GCC 3.4 will be the first
909 released version of GCC with such information.) */
912 cp_lookup_transparent_type (const char *name
)
914 /* First, try the honest way of looking up the definition. */
915 struct type
*t
= basic_lookup_transparent_type (name
);
921 /* If that doesn't work and we're within a namespace, look there
923 scope
= block_scope (get_selected_block (0));
925 if (scope
[0] == '\0')
928 return cp_lookup_transparent_type_loop (name
, scope
, 0);
931 /* Lookup the type definition associated to NAME in namespaces/classes
932 containing SCOPE whose name is strictly longer than LENGTH. LENGTH
933 must be the index of the start of a component of SCOPE. */
936 cp_lookup_transparent_type_loop (const char *name
,
940 int scope_length
= length
+ cp_find_first_component (scope
+ length
);
943 /* If the current scope is followed by "::", look in the next
945 if (scope
[scope_length
] == ':')
948 = cp_lookup_transparent_type_loop (name
, scope
,
955 full_name
= alloca (scope_length
+ 2 + strlen (name
) + 1);
956 strncpy (full_name
, scope
, scope_length
);
957 strncpy (full_name
+ scope_length
, "::", 2);
958 strcpy (full_name
+ scope_length
+ 2, name
);
960 return basic_lookup_transparent_type (full_name
);
963 /* This used to do something but was removed when it became
967 maintenance_cplus_namespace (char *args
, int from_tty
)
969 printf_unfiltered (_("The `maint namespace' command was removed.\n"));
972 /* Provide a prototype to silence -Wmissing-prototypes. */
973 extern initialize_file_ftype _initialize_cp_namespace
;
976 _initialize_cp_namespace (void)
978 struct cmd_list_element
*cmd
;
980 cmd
= add_cmd ("namespace", class_maintenance
,
981 maintenance_cplus_namespace
,
982 _("Deprecated placeholder for removed functionality."),
983 &maint_cplus_cmd_list
);
984 deprecate_cmd (cmd
, NULL
);