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));
99 /* Add a using directive to using_directives. If the using directive
100 in question has already been added, don't add it twice.
102 Create a new struct using_direct which imports the namespace SRC
103 into the scope DEST. ALIAS is the name of the imported namespace
104 in the current scope. If ALIAS is NULL then the namespace is known
105 by its original name. DECLARATION is the name if the imported
106 varable if this is a declaration import (Eg. using A::x), otherwise
107 it is NULL. EXCLUDES is a list of names not to import from an
108 imported module or NULL. If COPY_NAMES is non-zero, then the
109 arguments are copied into newly allocated memory so they can be
110 temporaries. For EXCLUDES the VEC pointers are copied but the
111 pointed to characters are not copied. */
114 cp_add_using_directive (const char *dest,
117 const char *declaration,
118 VEC (const_char_ptr) *excludes,
120 struct obstack *obstack)
122 struct using_direct *current;
123 struct using_direct *new;
125 /* Has it already been added? */
127 for (current = using_directives; current != NULL; current = current->next)
132 if (strcmp (current->import_src, src) != 0)
134 if (strcmp (current->import_dest, dest) != 0)
136 if ((alias == NULL && current->alias != NULL)
137 || (alias != NULL && current->alias == NULL)
138 || (alias != NULL && current->alias != NULL
139 && strcmp (alias, current->alias) != 0))
141 if ((declaration == NULL && current->declaration != NULL)
142 || (declaration != NULL && current->declaration == NULL)
143 || (declaration != NULL && current->declaration != NULL
144 && strcmp (declaration, current->declaration) != 0))
147 /* Compare the contents of EXCLUDES. */
148 for (ix = 0; VEC_iterate (const_char_ptr, excludes, ix, param); ix++)
149 if (current->excludes[ix] == NULL
150 || strcmp (param, current->excludes[ix]) != 0)
152 if (ix < VEC_length (const_char_ptr, excludes)
153 || current->excludes[ix] != NULL)
156 /* Parameters exactly match CURRENT. */
160 new = obstack_alloc (obstack, (sizeof (*new)
161 + (VEC_length (const_char_ptr, excludes)
162 * sizeof (*new->excludes))));
163 memset (new, 0, sizeof (*new));
167 new->import_src = obstack_copy0 (obstack, src, strlen (src));
168 new->import_dest = obstack_copy0 (obstack, dest, strlen (dest));
172 new->import_src = src;
173 new->import_dest = dest;
176 if (alias != NULL && copy_names)
177 new->alias = obstack_copy0 (obstack, alias, strlen (alias));
181 if (declaration != NULL && copy_names)
182 new->declaration = obstack_copy0 (obstack,
183 declaration, strlen (declaration));
185 new->declaration = declaration;
187 memcpy (new->excludes, VEC_address (const_char_ptr, excludes),
188 VEC_length (const_char_ptr, excludes) * sizeof (*new->excludes));
189 new->excludes[VEC_length (const_char_ptr, excludes)] = NULL;
191 new->next = using_directives;
192 using_directives = new;
195 /* Test whether or not NAMESPACE looks like it mentions an anonymous
196 namespace; return nonzero if so. */
199 cp_is_in_anonymous (const char *symbol_name)
201 return (strstr (symbol_name, CP_ANONYMOUS_NAMESPACE_STR)
205 /* Look up NAME in BLOCK's static block and in global blocks. If
206 ANONYMOUS_NAMESPACE is nonzero, the symbol in question is located
207 within an anonymous namespace. If SEARCH is non-zero, search through
208 base classes for a matching symbol. Other arguments are as in
209 cp_lookup_symbol_nonlocal. */
211 static struct symbol *
212 lookup_symbol_file (const char *name,
213 const struct block *block,
214 const domain_enum domain,
215 int anonymous_namespace, int search)
217 struct symbol *sym = NULL;
219 sym = lookup_symbol_in_static_block (name, block, domain);
223 if (anonymous_namespace)
225 /* Symbols defined in anonymous namespaces have external linkage
226 but should be treated as local to a single file nonetheless.
227 So we only search the current file's global block. */
229 const struct block *global_block = block_global_block (block);
231 if (global_block != NULL)
232 sym = lookup_symbol_in_block (name, global_block, domain);
236 sym = lookup_global_symbol (name, block, domain);
244 char *klass, *nested;
245 unsigned int prefix_len;
246 struct cleanup *cleanup;
247 struct symbol *klass_sym;
249 /* A simple lookup failed. Check if the symbol was defined in
252 cleanup = make_cleanup (null_cleanup, NULL);
254 /* Find the name of the class and the name of the method,
256 prefix_len = cp_entire_prefix_len (name);
258 /* If no prefix was found, search "this". */
264 this = lookup_language_this (language_def (language_cplus), block);
267 do_cleanups (cleanup);
271 type = check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (this)));
272 /* If TYPE_NAME is NULL, abandon trying to find this symbol.
273 This can happen for lambda functions compiled with clang++,
274 which outputs no name for the container class. */
275 if (TYPE_NAME (type) == NULL)
277 klass = xstrdup (TYPE_NAME (type));
278 nested = xstrdup (name);
282 /* The class name is everything up to and including PREFIX_LEN. */
283 klass = savestring (name, prefix_len);
285 /* The rest of the name is everything else past the initial scope
287 nested = xstrdup (name + prefix_len + 2);
290 /* Add cleanups to free memory for these strings. */
291 make_cleanup (xfree, klass);
292 make_cleanup (xfree, nested);
294 /* Lookup a class named KLASS. If none is found, there is nothing
295 more that can be done. */
296 klass_sym = lookup_global_symbol (klass, block, domain);
297 if (klass_sym == NULL)
299 do_cleanups (cleanup);
303 /* Look for a symbol named NESTED in this class. */
304 sym = cp_lookup_nested_symbol (SYMBOL_TYPE (klass_sym), nested, block);
305 do_cleanups (cleanup);
311 /* Look up NAME in the C++ namespace NAMESPACE. Other arguments are
312 as in cp_lookup_symbol_nonlocal. If SEARCH is non-zero, search
313 through base classes for a matching symbol. */
315 static struct symbol *
316 cp_lookup_symbol_in_namespace (const char *namespace,
318 const struct block *block,
319 const domain_enum domain, int search)
321 if (namespace[0] == '\0')
323 return lookup_symbol_file (name, block, domain, 0, search);
327 char *concatenated_name = alloca (strlen (namespace) + 2
328 + strlen (name) + 1);
330 strcpy (concatenated_name, namespace);
331 strcat (concatenated_name, "::");
332 strcat (concatenated_name, name);
333 return lookup_symbol_file (concatenated_name, block, domain,
334 cp_is_in_anonymous (namespace), search);
338 /* Used for cleanups to reset the "searched" flag incase
342 reset_directive_searched (void *data)
344 struct using_direct *direct = data;
345 direct->searched = 0;
348 /* Search for NAME by applying all import statements belonging to
349 BLOCK which are applicable in SCOPE. If DECLARATION_ONLY the
350 search is restricted to using declarations.
358 If SEARCH_PARENTS the search will include imports which are
359 applicable in parents of SCOPE.
369 If SCOPE is "A::B" and SEARCH_PARENTS is true the imports of
370 namespaces X and Y will be considered. If SEARCH_PARENTS is false
371 only the import of Y is considered. */
373 static struct symbol *
374 cp_lookup_symbol_via_imports (const char *scope,
376 const struct block *block,
377 const domain_enum domain,
378 const int declaration_only,
379 const int search_parents)
381 struct using_direct *current;
382 struct symbol *sym = NULL;
385 struct cleanup *searched_cleanup;
387 /* First, try to find the symbol in the given namespace. */
388 if (!declaration_only)
389 sym = cp_lookup_symbol_in_namespace (scope, name,
395 /* Go through the using directives. If any of them add new names to
396 the namespace we're searching in, see if we can find a match by
399 for (current = block_using (block);
401 current = current->next)
403 const char **excludep;
405 len = strlen (current->import_dest);
406 directive_match = (search_parents
407 ? (strncmp (scope, current->import_dest,
408 strlen (current->import_dest)) == 0
411 || scope[len] == '\0'))
412 : strcmp (scope, current->import_dest) == 0);
414 /* If the import destination is the current scope or one of its
415 ancestors then it is applicable. */
416 if (directive_match && !current->searched)
418 /* Mark this import as searched so that the recursive call
419 does not search it again. */
420 current->searched = 1;
421 searched_cleanup = make_cleanup (reset_directive_searched,
424 /* If there is an import of a single declaration, compare the
425 imported declaration (after optional renaming by its alias)
426 with the sought out name. If there is a match pass
427 current->import_src as NAMESPACE to direct the search
428 towards the imported namespace. */
429 if (current->declaration
430 && strcmp (name, current->alias
431 ? current->alias : current->declaration) == 0)
432 sym = cp_lookup_symbol_in_namespace (current->import_src,
433 current->declaration,
436 /* If this is a DECLARATION_ONLY search or a symbol was found
437 or this import statement was an import declaration, the
438 search of this import is complete. */
439 if (declaration_only || sym != NULL || current->declaration)
441 current->searched = 0;
442 discard_cleanups (searched_cleanup);
450 /* Do not follow CURRENT if NAME matches its EXCLUDES. */
451 for (excludep = current->excludes; *excludep; excludep++)
452 if (strcmp (name, *excludep) == 0)
456 discard_cleanups (searched_cleanup);
460 if (current->alias != NULL
461 && strcmp (name, current->alias) == 0)
462 /* If the import is creating an alias and the alias matches
463 the sought name. Pass current->import_src as the NAME to
464 direct the search towards the aliased namespace. */
466 sym = cp_lookup_symbol_in_namespace (scope,
470 else if (current->alias == NULL)
472 /* If this import statement creates no alias, pass
473 current->inner as NAMESPACE to direct the search
474 towards the imported namespace. */
475 sym = cp_lookup_symbol_via_imports (current->import_src,
479 current->searched = 0;
480 discard_cleanups (searched_cleanup);
490 /* Helper function that searches an array of symbols for one named
493 static struct symbol *
494 search_symbol_list (const char *name, int num,
495 struct symbol **syms)
499 /* Maybe we should store a dictionary in here instead. */
500 for (i = 0; i < num; ++i)
502 if (strcmp (name, SYMBOL_NATURAL_NAME (syms[i])) == 0)
508 /* Like cp_lookup_symbol_via_imports, but if BLOCK is a function, it
509 searches through the template parameters of the function and the
513 cp_lookup_symbol_imports_or_template (const char *scope,
515 const struct block *block,
516 const domain_enum domain)
518 struct symbol *function = BLOCK_FUNCTION (block);
519 struct symbol *result;
521 if (symbol_lookup_debug)
523 fprintf_unfiltered (gdb_stdlog,
524 "cp_lookup_symbol_imports_or_template"
525 " (%s, %s, %s, %s)\n",
526 scope, name, host_address_to_string (block),
527 domain_name (domain));
530 if (function != NULL && SYMBOL_LANGUAGE (function) == language_cplus)
532 /* Search the function's template parameters. */
533 if (SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION (function))
535 struct template_symbol *templ
536 = (struct template_symbol *) function;
538 result = search_symbol_list (name,
539 templ->n_template_arguments,
540 templ->template_arguments);
543 if (symbol_lookup_debug)
545 fprintf_unfiltered (gdb_stdlog,
546 "cp_lookup_symbol_imports_or_template"
548 host_address_to_string (result));
554 /* Search the template parameters of the function's defining
556 if (SYMBOL_NATURAL_NAME (function))
558 struct type *context;
559 char *name_copy = xstrdup (SYMBOL_NATURAL_NAME (function));
560 struct cleanup *cleanups = make_cleanup (xfree, name_copy);
561 const struct language_defn *lang = language_def (language_cplus);
563 = get_objfile_arch (SYMBOL_OBJFILE (function));
564 const struct block *parent = BLOCK_SUPERBLOCK (block);
568 unsigned int prefix_len = cp_entire_prefix_len (name_copy);
574 name_copy[prefix_len] = '\0';
575 context = lookup_typename (lang, arch,
584 = search_symbol_list (name,
585 TYPE_N_TEMPLATE_ARGUMENTS (context),
586 TYPE_TEMPLATE_ARGUMENTS (context));
589 do_cleanups (cleanups);
590 if (symbol_lookup_debug)
592 fprintf_unfiltered (gdb_stdlog,
593 "cp_lookup_symbol_imports_or_template"
595 host_address_to_string (result));
601 do_cleanups (cleanups);
605 result = cp_lookup_symbol_via_imports (scope, name, block, domain, 1, 1);
606 if (symbol_lookup_debug)
608 fprintf_unfiltered (gdb_stdlog,
609 "cp_lookup_symbol_imports_or_template (...) = %s\n",
611 ? host_address_to_string (result) : "NULL");
616 /* Searches for NAME in the current namespace, and by applying
617 relevant import statements belonging to BLOCK and its parents.
618 SCOPE is the namespace scope of the context in which the search is
622 cp_lookup_symbol_namespace (const char *scope,
624 const struct block *block,
625 const domain_enum domain)
629 if (symbol_lookup_debug)
631 fprintf_unfiltered (gdb_stdlog,
632 "cp_lookup_symbol_namespace (%s, %s, %s, %s)\n",
633 scope, name, host_address_to_string (block),
634 domain_name (domain));
637 /* First, try to find the symbol in the given namespace. */
638 sym = cp_lookup_symbol_in_namespace (scope, name,
642 if (symbol_lookup_debug)
644 fprintf_unfiltered (gdb_stdlog,
645 "cp_lookup_symbol_namespace (...) = %s\n",
646 host_address_to_string (sym));
651 /* Search for name in namespaces imported to this and parent
653 while (block != NULL)
655 sym = cp_lookup_symbol_via_imports (scope, name, block,
660 if (symbol_lookup_debug)
662 fprintf_unfiltered (gdb_stdlog,
663 "cp_lookup_symbol_namespace (...) = %s\n",
664 host_address_to_string (sym));
669 block = BLOCK_SUPERBLOCK (block);
672 if (symbol_lookup_debug)
674 fprintf_unfiltered (gdb_stdlog,
675 "cp_lookup_symbol_namespace (...) = NULL\n");
680 /* Lookup NAME at namespace scope (or, in C terms, in static and
681 global variables). SCOPE is the namespace that the current
682 function is defined within; only consider namespaces whose length
683 is at least SCOPE_LEN. Other arguments are as in
684 cp_lookup_symbol_nonlocal.
686 For example, if we're within a function A::B::f and looking for a
687 symbol x, this will get called with NAME = "x", SCOPE = "A::B", and
688 SCOPE_LEN = 0. It then calls itself with NAME and SCOPE the same,
689 but with SCOPE_LEN = 1. And then it calls itself with NAME and
690 SCOPE the same, but with SCOPE_LEN = 4. This third call looks for
691 "A::B::x"; if it doesn't find it, then the second call looks for
692 "A::x", and if that call fails, then the first call looks for
695 static struct symbol *
696 lookup_namespace_scope (const char *name,
697 const struct block *block,
698 const domain_enum domain,
704 if (scope[scope_len] != '\0')
706 /* Recursively search for names in child namespaces first. */
709 int new_scope_len = scope_len;
711 /* If the current scope is followed by "::", skip past that. */
712 if (new_scope_len != 0)
714 gdb_assert (scope[new_scope_len] == ':');
717 new_scope_len += cp_find_first_component (scope + new_scope_len);
718 sym = lookup_namespace_scope (name, block, domain,
719 scope, new_scope_len);
724 /* Okay, we didn't find a match in our children, so look for the
725 name in the current namespace. */
727 namespace = alloca (scope_len + 1);
728 strncpy (namespace, scope, scope_len);
729 namespace[scope_len] = '\0';
730 return cp_lookup_symbol_in_namespace (namespace, name,
734 /* The C++-specific version of name lookup for static and global
735 names. This makes sure that names get looked for in all namespaces
736 that are in scope. NAME is the natural name of the symbol that
737 we're looking for, BLOCK is the block that we're searching within,
738 DOMAIN says what kind of symbols we're looking for. */
741 cp_lookup_symbol_nonlocal (const char *name,
742 const struct block *block,
743 const domain_enum domain)
746 const char *scope = block_scope (block);
748 if (symbol_lookup_debug)
750 fprintf_unfiltered (gdb_stdlog,
751 "cp_lookup_symbol_non_local"
752 " (%s, %s (scope %s), %s)\n",
753 name, host_address_to_string (block), scope,
754 domain_name (domain));
757 sym = lookup_namespace_scope (name, block, domain, scope, 0);
760 if (symbol_lookup_debug)
762 fprintf_unfiltered (gdb_stdlog,
763 "cp_lookup_symbol_nonlocal (...) = %s\n",
764 host_address_to_string (sym));
769 sym = cp_lookup_symbol_namespace (scope, name, block, domain);
770 if (symbol_lookup_debug)
772 fprintf_unfiltered (gdb_stdlog,
773 "cp_lookup_symbol_nonlocal (...) = %s\n",
774 sym != NULL ? host_address_to_string (sym) : "NULL");
779 /* Search through the base classes of PARENT_TYPE for a base class
780 named NAME and return its type. If not found, return NULL. */
783 cp_find_type_baseclass_by_name (struct type *parent_type, const char *name)
787 CHECK_TYPEDEF (parent_type);
788 for (i = 0; i < TYPE_N_BASECLASSES (parent_type); ++i)
790 struct type *type = check_typedef (TYPE_BASECLASS (parent_type, i));
791 const char *base_name = TYPE_BASECLASS_NAME (parent_type, i);
793 if (base_name == NULL)
796 if (streq (base_name, name))
799 type = cp_find_type_baseclass_by_name (type, name);
807 /* Search through the base classes of PARENT_TYPE for a symbol named
808 NAME in block BLOCK. */
810 static struct symbol *
811 find_symbol_in_baseclass (struct type *parent_type, const char *name,
812 const struct block *block)
816 struct cleanup *cleanup;
817 char *concatenated_name;
820 concatenated_name = NULL;
821 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);