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 /* If TYPE_NAME is NULL, abandon trying to find this symbol.
698 This can happen for lambda functions compiled with clang++,
699 which outputs no name for the container class. */
700 if (TYPE_NAME (type
) == NULL
)
702 klass
= xstrdup (TYPE_NAME (type
));
703 nested
= xstrdup (name
);
707 /* The class name is everything up to and including PREFIX_LEN. */
708 klass
= savestring (name
, prefix_len
);
710 /* The rest of the name is everything else past the initial scope
712 nested
= xstrdup (name
+ prefix_len
+ 2);
715 /* Add cleanups to free memory for these strings. */
716 make_cleanup (xfree
, klass
);
717 make_cleanup (xfree
, nested
);
719 /* Lookup a class named KLASS. If none is found, there is nothing
720 more that can be done. */
721 klass_sym
= lookup_symbol_global (klass
, block
, STRUCT_DOMAIN
);
722 if (klass_sym
== NULL
)
724 do_cleanups (cleanup
);
728 /* Look for a symbol named NESTED in this class. */
729 sym
= cp_lookup_nested_symbol (SYMBOL_TYPE (klass_sym
), nested
, block
);
730 do_cleanups (cleanup
);
736 /* Search through the base classes of PARENT_TYPE for a base class
737 named NAME and return its type. If not found, return NULL. */
740 find_type_baseclass_by_name (struct type
*parent_type
, const char *name
)
744 CHECK_TYPEDEF (parent_type
);
745 for (i
= 0; i
< TYPE_N_BASECLASSES (parent_type
); ++i
)
747 struct type
*type
= check_typedef (TYPE_BASECLASS (parent_type
, i
));
748 const char *base_name
= TYPE_BASECLASS_NAME (parent_type
, i
);
750 if (base_name
== NULL
)
753 if (streq (base_name
, name
))
756 type
= find_type_baseclass_by_name (type
, name
);
764 /* Search through the base classes of PARENT_TYPE for a symbol named
765 NAME in block BLOCK. */
767 static struct symbol
*
768 find_symbol_in_baseclass (struct type
*parent_type
, const char *name
,
769 const struct block
*block
)
773 struct cleanup
*cleanup
;
774 char *concatenated_name
;
777 concatenated_name
= NULL
;
778 cleanup
= make_cleanup (free_current_contents
, &concatenated_name
);
779 for (i
= 0; i
< TYPE_N_BASECLASSES (parent_type
); ++i
)
782 struct type
*base_type
= TYPE_BASECLASS (parent_type
, i
);
783 const char *base_name
= TYPE_BASECLASS_NAME (parent_type
, i
);
785 if (base_name
== NULL
)
788 /* Search this particular base class. */
789 sym
= cp_lookup_symbol_in_namespace (base_name
, name
, block
,
794 /* Now search all static file-level symbols. We have to do this for
795 things like typedefs in the class. First search in this symtab,
796 what we want is possibly there. */
797 len
= strlen (base_name
) + 2 + strlen (name
) + 1;
798 concatenated_name
= xrealloc (concatenated_name
, len
);
799 xsnprintf (concatenated_name
, len
, "%s::%s", base_name
, name
);
800 sym
= lookup_symbol_static (concatenated_name
, block
, VAR_DOMAIN
);
804 /* Nope. We now have to search all static blocks in all objfiles,
805 even if block != NULL, because there's no guarantees as to which
806 symtab the symbol we want is in. */
807 sym
= lookup_static_symbol_aux (concatenated_name
, VAR_DOMAIN
);
811 /* If this class has base classes, search them next. */
812 CHECK_TYPEDEF (base_type
);
813 if (TYPE_N_BASECLASSES (base_type
) > 0)
815 sym
= find_symbol_in_baseclass (base_type
, name
, block
);
821 do_cleanups (cleanup
);
825 /* Look up a symbol named NESTED_NAME that is nested inside the C++
826 class or namespace given by PARENT_TYPE, from within the context
827 given by BLOCK. Return NULL if there is no such nested type. */
830 cp_lookup_nested_symbol (struct type
*parent_type
,
831 const char *nested_name
,
832 const struct block
*block
)
834 /* type_name_no_tag_required provides better error reporting using the
836 struct type
*saved_parent_type
= parent_type
;
838 CHECK_TYPEDEF (parent_type
);
840 switch (TYPE_CODE (parent_type
))
842 case TYPE_CODE_STRUCT
:
843 case TYPE_CODE_NAMESPACE
:
844 case TYPE_CODE_UNION
:
846 /* NOTE: Handle modules here as well, because Fortran is re-using the C++
847 specific code to lookup nested symbols in modules, by calling the
848 function pointer la_lookup_symbol_nonlocal, which ends up here. */
849 case TYPE_CODE_MODULE
:
851 /* NOTE: carlton/2003-11-10: We don't treat C++ class members
852 of classes like, say, data or function members. Instead,
853 they're just represented by symbols whose names are
854 qualified by the name of the surrounding class. This is
855 just like members of namespaces; in particular,
856 lookup_symbol_namespace works when looking them up. */
859 const char *parent_name
= type_name_no_tag_or_error (saved_parent_type
);
861 = cp_lookup_symbol_in_namespace (parent_name
, nested_name
,
862 block
, VAR_DOMAIN
, 0);
863 char *concatenated_name
;
868 /* Now search all static file-level symbols. We have to do this
869 for things like typedefs in the class. We do not try to
870 guess any imported namespace as even the fully specified
871 namespace search is already not C++ compliant and more
872 assumptions could make it too magic. */
874 size
= strlen (parent_name
) + 2 + strlen (nested_name
) + 1;
875 concatenated_name
= alloca (size
);
876 xsnprintf (concatenated_name
, size
, "%s::%s",
877 parent_name
, nested_name
);
878 sym
= lookup_static_symbol_aux (concatenated_name
, VAR_DOMAIN
);
882 /* If no matching symbols were found, try searching any
884 return find_symbol_in_baseclass (parent_type
, nested_name
, block
);
888 case TYPE_CODE_METHOD
:
892 internal_error (__FILE__
, __LINE__
,
893 _("cp_lookup_nested_symbol called "
894 "on a non-aggregate type."));
898 /* The C++-version of lookup_transparent_type. */
900 /* FIXME: carlton/2004-01-16: The problem that this is trying to
901 address is that, unfortunately, sometimes NAME is wrong: it may not
902 include the name of namespaces enclosing the type in question.
903 lookup_transparent_type gets called when the type in question
904 is a declaration, and we're trying to find its definition; but, for
905 declarations, our type name deduction mechanism doesn't work.
906 There's nothing we can do to fix this in general, I think, in the
907 absence of debug information about namespaces (I've filed PR
908 gdb/1511 about this); until such debug information becomes more
909 prevalent, one heuristic which sometimes looks is to search for the
910 definition in namespaces containing the current namespace.
912 We should delete this functions once the appropriate debug
913 information becomes more widespread. (GCC 3.4 will be the first
914 released version of GCC with such information.) */
917 cp_lookup_transparent_type (const char *name
)
919 /* First, try the honest way of looking up the definition. */
920 struct type
*t
= basic_lookup_transparent_type (name
);
926 /* If that doesn't work and we're within a namespace, look there
928 scope
= block_scope (get_selected_block (0));
930 if (scope
[0] == '\0')
933 return cp_lookup_transparent_type_loop (name
, scope
, 0);
936 /* Lookup the type definition associated to NAME in namespaces/classes
937 containing SCOPE whose name is strictly longer than LENGTH. LENGTH
938 must be the index of the start of a component of SCOPE. */
941 cp_lookup_transparent_type_loop (const char *name
,
945 int scope_length
= length
+ cp_find_first_component (scope
+ length
);
948 /* If the current scope is followed by "::", look in the next
950 if (scope
[scope_length
] == ':')
953 = cp_lookup_transparent_type_loop (name
, scope
,
960 full_name
= alloca (scope_length
+ 2 + strlen (name
) + 1);
961 strncpy (full_name
, scope
, scope_length
);
962 strncpy (full_name
+ scope_length
, "::", 2);
963 strcpy (full_name
+ scope_length
+ 2, name
);
965 return basic_lookup_transparent_type (full_name
);
968 /* This used to do something but was removed when it became
972 maintenance_cplus_namespace (char *args
, int from_tty
)
974 printf_unfiltered (_("The `maint namespace' command was removed.\n"));
977 /* Provide a prototype to silence -Wmissing-prototypes. */
978 extern initialize_file_ftype _initialize_cp_namespace
;
981 _initialize_cp_namespace (void)
983 struct cmd_list_element
*cmd
;
985 cmd
= add_cmd ("namespace", class_maintenance
,
986 maintenance_cplus_namespace
,
987 _("Deprecated placeholder for removed functionality."),
988 &maint_cplus_cmd_list
);
989 deprecate_cmd (cmd
, NULL
);