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 symbol
*lookup_namespace_scope (const char *name
,
36 const struct block
*block
,
37 const domain_enum domain
,
41 static struct symbol
*lookup_symbol_file (const char *name
,
42 const struct block
*block
,
43 const domain_enum domain
,
44 int anonymous_namespace
,
47 static struct type
*cp_lookup_transparent_type_loop (const char *name
,
51 /* Check to see if SYMBOL refers to an object contained within an
52 anonymous namespace; if so, add an appropriate using directive. */
55 cp_scan_for_anonymous_namespaces (const struct symbol
*const symbol
,
56 struct objfile
*const objfile
)
58 if (SYMBOL_DEMANGLED_NAME (symbol
) != NULL
)
60 const char *name
= SYMBOL_DEMANGLED_NAME (symbol
);
61 unsigned int previous_component
;
62 unsigned int next_component
;
64 /* Start with a quick-and-dirty check for mention of "(anonymous
67 if (!cp_is_anonymous (name
))
70 previous_component
= 0;
71 next_component
= cp_find_first_component (name
+ previous_component
);
73 while (name
[next_component
] == ':')
75 if (((next_component
- previous_component
)
76 == CP_ANONYMOUS_NAMESPACE_LEN
)
77 && strncmp (name
+ previous_component
,
78 CP_ANONYMOUS_NAMESPACE_STR
,
79 CP_ANONYMOUS_NAMESPACE_LEN
) == 0)
81 int dest_len
= (previous_component
== 0
82 ? 0 : previous_component
- 2);
83 int src_len
= next_component
;
85 char *dest
= alloca (dest_len
+ 1);
86 char *src
= alloca (src_len
+ 1);
88 memcpy (dest
, name
, dest_len
);
89 memcpy (src
, name
, src_len
);
91 dest
[dest_len
] = '\0';
94 /* We've found a component of the name that's an
95 anonymous namespace. So add symbols in it to the
96 namespace given by the previous component if there is
97 one, or to the global namespace if there isn't. */
98 cp_add_using_directive (dest
, src
, NULL
, NULL
, NULL
, 1,
99 &objfile
->objfile_obstack
);
101 /* The "+ 2" is for the "::". */
102 previous_component
= next_component
+ 2;
103 next_component
= (previous_component
104 + cp_find_first_component (name
105 + previous_component
));
111 /* Add a using directive to using_directives. If the using directive
112 in question has already been added, don't add it twice.
114 Create a new struct using_direct which imports the namespace SRC
115 into the scope DEST. ALIAS is the name of the imported namespace
116 in the current scope. If ALIAS is NULL then the namespace is known
117 by its original name. DECLARATION is the name if the imported
118 varable if this is a declaration import (Eg. using A::x), otherwise
119 it is NULL. EXCLUDES is a list of names not to import from an
120 imported module or NULL. If COPY_NAMES is non-zero, then the
121 arguments are copied into newly allocated memory so they can be
122 temporaries. For EXCLUDES the VEC pointers are copied but the
123 pointed to characters are not copied. */
126 cp_add_using_directive (const char *dest
,
129 const char *declaration
,
130 VEC (const_char_ptr
) *excludes
,
132 struct obstack
*obstack
)
134 struct using_direct
*current
;
135 struct using_direct
*new;
137 /* Has it already been added? */
139 for (current
= using_directives
; current
!= NULL
; current
= current
->next
)
144 if (strcmp (current
->import_src
, src
) != 0)
146 if (strcmp (current
->import_dest
, dest
) != 0)
148 if ((alias
== NULL
&& current
->alias
!= NULL
)
149 || (alias
!= NULL
&& current
->alias
== NULL
)
150 || (alias
!= NULL
&& current
->alias
!= NULL
151 && strcmp (alias
, current
->alias
) != 0))
153 if ((declaration
== NULL
&& current
->declaration
!= NULL
)
154 || (declaration
!= NULL
&& current
->declaration
== NULL
)
155 || (declaration
!= NULL
&& current
->declaration
!= NULL
156 && strcmp (declaration
, current
->declaration
) != 0))
159 /* Compare the contents of EXCLUDES. */
160 for (ix
= 0; VEC_iterate (const_char_ptr
, excludes
, ix
, param
); ix
++)
161 if (current
->excludes
[ix
] == NULL
162 || strcmp (param
, current
->excludes
[ix
]) != 0)
164 if (ix
< VEC_length (const_char_ptr
, excludes
)
165 || current
->excludes
[ix
] != NULL
)
168 /* Parameters exactly match CURRENT. */
172 new = obstack_alloc (obstack
, (sizeof (*new)
173 + (VEC_length (const_char_ptr
, excludes
)
174 * sizeof (*new->excludes
))));
175 memset (new, 0, sizeof (*new));
179 new->import_src
= obstack_copy0 (obstack
, src
, strlen (src
));
180 new->import_dest
= obstack_copy0 (obstack
, dest
, strlen (dest
));
184 new->import_src
= src
;
185 new->import_dest
= dest
;
188 if (alias
!= NULL
&& copy_names
)
189 new->alias
= obstack_copy0 (obstack
, alias
, strlen (alias
));
193 if (declaration
!= NULL
&& copy_names
)
194 new->declaration
= obstack_copy0 (obstack
,
195 declaration
, strlen (declaration
));
197 new->declaration
= declaration
;
199 memcpy (new->excludes
, VEC_address (const_char_ptr
, excludes
),
200 VEC_length (const_char_ptr
, excludes
) * sizeof (*new->excludes
));
201 new->excludes
[VEC_length (const_char_ptr
, excludes
)] = NULL
;
203 new->next
= using_directives
;
204 using_directives
= new;
207 /* Test whether or not NAMESPACE looks like it mentions an anonymous
208 namespace; return nonzero if so. */
211 cp_is_anonymous (const char *namespace)
213 return (strstr (namespace, CP_ANONYMOUS_NAMESPACE_STR
)
217 /* The C++-specific version of name lookup for static and global
218 names. This makes sure that names get looked for in all namespaces
219 that are in scope. NAME is the natural name of the symbol that
220 we're looking for, BLOCK is the block that we're searching within,
221 DOMAIN says what kind of symbols we're looking for. */
224 cp_lookup_symbol_nonlocal (const char *name
,
225 const struct block
*block
,
226 const domain_enum domain
)
229 const char *scope
= block_scope (block
);
231 sym
= lookup_namespace_scope (name
, block
,
236 return cp_lookup_symbol_namespace (scope
, name
,
240 /* Look up NAME in the C++ namespace NAMESPACE. Other arguments are
241 as in cp_lookup_symbol_nonlocal. If SEARCH is non-zero, search
242 through base classes for a matching symbol. */
244 static struct symbol
*
245 cp_lookup_symbol_in_namespace (const char *namespace,
247 const struct block
*block
,
248 const domain_enum domain
, int search
)
250 if (namespace[0] == '\0')
252 return lookup_symbol_file (name
, block
, domain
, 0, search
);
256 char *concatenated_name
= alloca (strlen (namespace) + 2
257 + strlen (name
) + 1);
259 strcpy (concatenated_name
, namespace);
260 strcat (concatenated_name
, "::");
261 strcat (concatenated_name
, name
);
262 return lookup_symbol_file (concatenated_name
, block
, domain
,
263 cp_is_anonymous (namespace), search
);
267 /* Used for cleanups to reset the "searched" flag incase
271 reset_directive_searched (void *data
)
273 struct using_direct
*direct
= data
;
274 direct
->searched
= 0;
277 /* Search for NAME by applying all import statements belonging to
278 BLOCK which are applicable in SCOPE. If DECLARATION_ONLY the
279 search is restricted to using declarations.
287 If SEARCH_PARENTS the search will include imports which are
288 applicable in parents of SCOPE.
298 If SCOPE is "A::B" and SEARCH_PARENTS is true the imports of
299 namespaces X and Y will be considered. If SEARCH_PARENTS is false
300 only the import of Y is considered. */
303 cp_lookup_symbol_imports (const char *scope
,
305 const struct block
*block
,
306 const domain_enum domain
,
307 const int declaration_only
,
308 const int search_parents
)
310 struct using_direct
*current
;
311 struct symbol
*sym
= NULL
;
314 struct cleanup
*searched_cleanup
;
316 /* First, try to find the symbol in the given namespace. */
317 if (!declaration_only
)
318 sym
= cp_lookup_symbol_in_namespace (scope
, name
,
324 /* Go through the using directives. If any of them add new names to
325 the namespace we're searching in, see if we can find a match by
328 for (current
= block_using (block
);
330 current
= current
->next
)
332 const char **excludep
;
334 len
= strlen (current
->import_dest
);
335 directive_match
= (search_parents
336 ? (strncmp (scope
, current
->import_dest
,
337 strlen (current
->import_dest
)) == 0
340 || scope
[len
] == '\0'))
341 : strcmp (scope
, current
->import_dest
) == 0);
343 /* If the import destination is the current scope or one of its
344 ancestors then it is applicable. */
345 if (directive_match
&& !current
->searched
)
347 /* Mark this import as searched so that the recursive call
348 does not search it again. */
349 current
->searched
= 1;
350 searched_cleanup
= make_cleanup (reset_directive_searched
,
353 /* If there is an import of a single declaration, compare the
354 imported declaration (after optional renaming by its alias)
355 with the sought out name. If there is a match pass
356 current->import_src as NAMESPACE to direct the search
357 towards the imported namespace. */
358 if (current
->declaration
359 && strcmp (name
, current
->alias
360 ? current
->alias
: current
->declaration
) == 0)
361 sym
= cp_lookup_symbol_in_namespace (current
->import_src
,
362 current
->declaration
,
365 /* If this is a DECLARATION_ONLY search or a symbol was found
366 or this import statement was an import declaration, the
367 search of this import is complete. */
368 if (declaration_only
|| sym
!= NULL
|| current
->declaration
)
370 current
->searched
= 0;
371 discard_cleanups (searched_cleanup
);
379 /* Do not follow CURRENT if NAME matches its EXCLUDES. */
380 for (excludep
= current
->excludes
; *excludep
; excludep
++)
381 if (strcmp (name
, *excludep
) == 0)
385 discard_cleanups (searched_cleanup
);
389 if (current
->alias
!= NULL
390 && strcmp (name
, current
->alias
) == 0)
391 /* If the import is creating an alias and the alias matches
392 the sought name. Pass current->import_src as the NAME to
393 direct the search towards the aliased namespace. */
395 sym
= cp_lookup_symbol_in_namespace (scope
,
399 else if (current
->alias
== NULL
)
401 /* If this import statement creates no alias, pass
402 current->inner as NAMESPACE to direct the search
403 towards the imported namespace. */
404 sym
= cp_lookup_symbol_imports (current
->import_src
,
408 current
->searched
= 0;
409 discard_cleanups (searched_cleanup
);
419 /* Helper function that searches an array of symbols for one named
422 static struct symbol
*
423 search_symbol_list (const char *name
, int num
,
424 struct symbol
**syms
)
428 /* Maybe we should store a dictionary in here instead. */
429 for (i
= 0; i
< num
; ++i
)
431 if (strcmp (name
, SYMBOL_NATURAL_NAME (syms
[i
])) == 0)
437 /* Like cp_lookup_symbol_imports, but if BLOCK is a function, it
438 searches through the template parameters of the function and the
442 cp_lookup_symbol_imports_or_template (const char *scope
,
444 const struct block
*block
,
445 const domain_enum domain
)
447 struct symbol
*function
= BLOCK_FUNCTION (block
);
449 if (function
!= NULL
&& SYMBOL_LANGUAGE (function
) == language_cplus
)
451 /* Search the function's template parameters. */
452 if (SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION (function
))
454 struct template_symbol
*templ
455 = (struct template_symbol
*) function
;
456 struct symbol
*result
;
458 result
= search_symbol_list (name
,
459 templ
->n_template_arguments
,
460 templ
->template_arguments
);
465 /* Search the template parameters of the function's defining
467 if (SYMBOL_NATURAL_NAME (function
))
469 struct type
*context
;
470 char *name_copy
= xstrdup (SYMBOL_NATURAL_NAME (function
));
471 struct cleanup
*cleanups
= make_cleanup (xfree
, name_copy
);
472 const struct language_defn
*lang
= language_def (language_cplus
);
474 = get_objfile_arch (SYMBOL_OBJFILE (function
));
475 const struct block
*parent
= BLOCK_SUPERBLOCK (block
);
479 struct symbol
*result
;
480 unsigned int prefix_len
= cp_entire_prefix_len (name_copy
);
486 name_copy
[prefix_len
] = '\0';
487 context
= lookup_typename (lang
, arch
,
496 = search_symbol_list (name
,
497 TYPE_N_TEMPLATE_ARGUMENTS (context
),
498 TYPE_TEMPLATE_ARGUMENTS (context
));
501 do_cleanups (cleanups
);
506 do_cleanups (cleanups
);
510 return cp_lookup_symbol_imports (scope
, name
, block
, domain
, 1, 1);
513 /* Searches for NAME in the current namespace, and by applying
514 relevant import statements belonging to BLOCK and its parents.
515 SCOPE is the namespace scope of the context in which the search is
519 cp_lookup_symbol_namespace (const char *scope
,
521 const struct block
*block
,
522 const domain_enum domain
)
526 /* First, try to find the symbol in the given namespace. */
527 sym
= cp_lookup_symbol_in_namespace (scope
, name
,
532 /* Search for name in namespaces imported to this and parent
534 while (block
!= NULL
)
536 sym
= cp_lookup_symbol_imports (scope
, name
, block
,
542 block
= BLOCK_SUPERBLOCK (block
);
548 /* Lookup NAME at namespace scope (or, in C terms, in static and
549 global variables). SCOPE is the namespace that the current
550 function is defined within; only consider namespaces whose length
551 is at least SCOPE_LEN. Other arguments are as in
552 cp_lookup_symbol_nonlocal.
554 For example, if we're within a function A::B::f and looking for a
555 symbol x, this will get called with NAME = "x", SCOPE = "A::B", and
556 SCOPE_LEN = 0. It then calls itself with NAME and SCOPE the same,
557 but with SCOPE_LEN = 1. And then it calls itself with NAME and
558 SCOPE the same, but with SCOPE_LEN = 4. This third call looks for
559 "A::B::x"; if it doesn't find it, then the second call looks for
560 "A::x", and if that call fails, then the first call looks for
563 static struct symbol
*
564 lookup_namespace_scope (const char *name
,
565 const struct block
*block
,
566 const domain_enum domain
,
572 if (scope
[scope_len
] != '\0')
574 /* Recursively search for names in child namespaces first. */
577 int new_scope_len
= scope_len
;
579 /* If the current scope is followed by "::", skip past that. */
580 if (new_scope_len
!= 0)
582 gdb_assert (scope
[new_scope_len
] == ':');
585 new_scope_len
+= cp_find_first_component (scope
+ new_scope_len
);
586 sym
= lookup_namespace_scope (name
, block
, domain
,
587 scope
, new_scope_len
);
592 /* Okay, we didn't find a match in our children, so look for the
593 name in the current namespace. */
595 namespace = alloca (scope_len
+ 1);
596 strncpy (namespace, scope
, scope_len
);
597 namespace[scope_len
] = '\0';
598 return cp_lookup_symbol_in_namespace (namespace, name
,
602 /* Look up NAME in BLOCK's static block and in global blocks. If
603 ANONYMOUS_NAMESPACE is nonzero, the symbol in question is located
604 within an anonymous namespace. If SEARCH is non-zero, search through
605 base classes for a matching symbol. Other arguments are as in
606 cp_lookup_symbol_nonlocal. */
608 static struct symbol
*
609 lookup_symbol_file (const char *name
,
610 const struct block
*block
,
611 const domain_enum domain
,
612 int anonymous_namespace
, int search
)
614 struct symbol
*sym
= NULL
;
616 sym
= lookup_symbol_in_static_block (name
, block
, domain
);
620 if (anonymous_namespace
)
622 /* Symbols defined in anonymous namespaces have external linkage
623 but should be treated as local to a single file nonetheless.
624 So we only search the current file's global block. */
626 const struct block
*global_block
= block_global_block (block
);
628 if (global_block
!= NULL
)
629 sym
= lookup_symbol_in_block (name
, global_block
, domain
);
633 sym
= lookup_global_symbol (name
, block
, domain
);
641 char *klass
, *nested
;
642 unsigned int prefix_len
;
643 struct cleanup
*cleanup
;
644 struct symbol
*klass_sym
;
646 /* A simple lookup failed. Check if the symbol was defined in
649 cleanup
= make_cleanup (null_cleanup
, NULL
);
651 /* Find the name of the class and the name of the method,
653 prefix_len
= cp_entire_prefix_len (name
);
655 /* If no prefix was found, search "this". */
661 this = lookup_language_this (language_def (language_cplus
), block
);
664 do_cleanups (cleanup
);
668 type
= check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (this)));
669 /* If TYPE_NAME is NULL, abandon trying to find this symbol.
670 This can happen for lambda functions compiled with clang++,
671 which outputs no name for the container class. */
672 if (TYPE_NAME (type
) == NULL
)
674 klass
= xstrdup (TYPE_NAME (type
));
675 nested
= xstrdup (name
);
679 /* The class name is everything up to and including PREFIX_LEN. */
680 klass
= savestring (name
, prefix_len
);
682 /* The rest of the name is everything else past the initial scope
684 nested
= xstrdup (name
+ prefix_len
+ 2);
687 /* Add cleanups to free memory for these strings. */
688 make_cleanup (xfree
, klass
);
689 make_cleanup (xfree
, nested
);
691 /* Lookup a class named KLASS. If none is found, there is nothing
692 more that can be done. */
693 klass_sym
= lookup_global_symbol (klass
, block
, domain
);
694 if (klass_sym
== NULL
)
696 do_cleanups (cleanup
);
700 /* Look for a symbol named NESTED in this class. */
701 sym
= cp_lookup_nested_symbol (SYMBOL_TYPE (klass_sym
), nested
, block
);
702 do_cleanups (cleanup
);
708 /* Search through the base classes of PARENT_TYPE for a base class
709 named NAME and return its type. If not found, return NULL. */
712 find_type_baseclass_by_name (struct type
*parent_type
, const char *name
)
716 CHECK_TYPEDEF (parent_type
);
717 for (i
= 0; i
< TYPE_N_BASECLASSES (parent_type
); ++i
)
719 struct type
*type
= check_typedef (TYPE_BASECLASS (parent_type
, i
));
720 const char *base_name
= TYPE_BASECLASS_NAME (parent_type
, i
);
722 if (base_name
== NULL
)
725 if (streq (base_name
, name
))
728 type
= find_type_baseclass_by_name (type
, name
);
736 /* Search through the base classes of PARENT_TYPE for a symbol named
737 NAME in block BLOCK. */
739 static struct symbol
*
740 find_symbol_in_baseclass (struct type
*parent_type
, const char *name
,
741 const struct block
*block
)
745 struct cleanup
*cleanup
;
746 char *concatenated_name
;
749 concatenated_name
= NULL
;
750 cleanup
= make_cleanup (free_current_contents
, &concatenated_name
);
751 for (i
= 0; i
< TYPE_N_BASECLASSES (parent_type
); ++i
)
754 struct type
*base_type
= TYPE_BASECLASS (parent_type
, i
);
755 const char *base_name
= TYPE_BASECLASS_NAME (parent_type
, i
);
757 if (base_name
== NULL
)
760 /* Search this particular base class. */
761 sym
= cp_lookup_symbol_in_namespace (base_name
, name
, block
,
766 /* Now search all static file-level symbols. We have to do this for
767 things like typedefs in the class. First search in this symtab,
768 what we want is possibly there. */
769 len
= strlen (base_name
) + 2 + strlen (name
) + 1;
770 concatenated_name
= xrealloc (concatenated_name
, len
);
771 xsnprintf (concatenated_name
, len
, "%s::%s", base_name
, name
);
772 sym
= lookup_symbol_in_static_block (concatenated_name
, block
,
777 /* Nope. We now have to search all static blocks in all objfiles,
778 even if block != NULL, because there's no guarantees as to which
779 symtab the symbol we want is in. */
780 sym
= lookup_static_symbol (concatenated_name
, VAR_DOMAIN
);
784 /* If this class has base classes, search them next. */
785 CHECK_TYPEDEF (base_type
);
786 if (TYPE_N_BASECLASSES (base_type
) > 0)
788 sym
= find_symbol_in_baseclass (base_type
, name
, block
);
794 do_cleanups (cleanup
);
798 /* Look up a symbol named NESTED_NAME that is nested inside the C++
799 class or namespace given by PARENT_TYPE, from within the context
800 given by BLOCK. Return NULL if there is no such nested type. */
803 cp_lookup_nested_symbol (struct type
*parent_type
,
804 const char *nested_name
,
805 const struct block
*block
)
807 /* type_name_no_tag_required provides better error reporting using the
809 struct type
*saved_parent_type
= parent_type
;
811 CHECK_TYPEDEF (parent_type
);
813 switch (TYPE_CODE (parent_type
))
815 case TYPE_CODE_STRUCT
:
816 case TYPE_CODE_NAMESPACE
:
817 case TYPE_CODE_UNION
:
819 /* NOTE: Handle modules here as well, because Fortran is re-using the C++
820 specific code to lookup nested symbols in modules, by calling the
821 function pointer la_lookup_symbol_nonlocal, which ends up here. */
822 case TYPE_CODE_MODULE
:
824 /* NOTE: carlton/2003-11-10: We don't treat C++ class members
825 of classes like, say, data or function members. Instead,
826 they're just represented by symbols whose names are
827 qualified by the name of the surrounding class. This is
828 just like members of namespaces; in particular,
829 lookup_symbol_namespace works when looking them up. */
832 const char *parent_name
= type_name_no_tag_or_error (saved_parent_type
);
834 = cp_lookup_symbol_in_namespace (parent_name
, nested_name
,
835 block
, VAR_DOMAIN
, 0);
836 char *concatenated_name
;
841 /* Now search all static file-level symbols. We have to do this
842 for things like typedefs in the class. We do not try to
843 guess any imported namespace as even the fully specified
844 namespace search is already not C++ compliant and more
845 assumptions could make it too magic. */
847 size
= strlen (parent_name
) + 2 + strlen (nested_name
) + 1;
848 concatenated_name
= alloca (size
);
849 xsnprintf (concatenated_name
, size
, "%s::%s",
850 parent_name
, nested_name
);
851 sym
= lookup_static_symbol (concatenated_name
, VAR_DOMAIN
);
855 /* If no matching symbols were found, try searching any
857 return find_symbol_in_baseclass (parent_type
, nested_name
, block
);
861 case TYPE_CODE_METHOD
:
865 internal_error (__FILE__
, __LINE__
,
866 _("cp_lookup_nested_symbol called "
867 "on a non-aggregate type."));
871 /* The C++-version of lookup_transparent_type. */
873 /* FIXME: carlton/2004-01-16: The problem that this is trying to
874 address is that, unfortunately, sometimes NAME is wrong: it may not
875 include the name of namespaces enclosing the type in question.
876 lookup_transparent_type gets called when the type in question
877 is a declaration, and we're trying to find its definition; but, for
878 declarations, our type name deduction mechanism doesn't work.
879 There's nothing we can do to fix this in general, I think, in the
880 absence of debug information about namespaces (I've filed PR
881 gdb/1511 about this); until such debug information becomes more
882 prevalent, one heuristic which sometimes looks is to search for the
883 definition in namespaces containing the current namespace.
885 We should delete this functions once the appropriate debug
886 information becomes more widespread. (GCC 3.4 will be the first
887 released version of GCC with such information.) */
890 cp_lookup_transparent_type (const char *name
)
892 /* First, try the honest way of looking up the definition. */
893 struct type
*t
= basic_lookup_transparent_type (name
);
899 /* If that doesn't work and we're within a namespace, look there
901 scope
= block_scope (get_selected_block (0));
903 if (scope
[0] == '\0')
906 return cp_lookup_transparent_type_loop (name
, scope
, 0);
909 /* Lookup the type definition associated to NAME in namespaces/classes
910 containing SCOPE whose name is strictly longer than LENGTH. LENGTH
911 must be the index of the start of a component of SCOPE. */
914 cp_lookup_transparent_type_loop (const char *name
,
918 int scope_length
= length
+ cp_find_first_component (scope
+ length
);
921 /* If the current scope is followed by "::", look in the next
923 if (scope
[scope_length
] == ':')
926 = cp_lookup_transparent_type_loop (name
, scope
,
933 full_name
= alloca (scope_length
+ 2 + strlen (name
) + 1);
934 strncpy (full_name
, scope
, scope_length
);
935 strncpy (full_name
+ scope_length
, "::", 2);
936 strcpy (full_name
+ scope_length
+ 2, name
);
938 return basic_lookup_transparent_type (full_name
);
941 /* This used to do something but was removed when it became
945 maintenance_cplus_namespace (char *args
, int from_tty
)
947 printf_unfiltered (_("The `maint namespace' command was removed.\n"));
950 /* Provide a prototype to silence -Wmissing-prototypes. */
951 extern initialize_file_ftype _initialize_cp_namespace
;
954 _initialize_cp_namespace (void)
956 struct cmd_list_element
*cmd
;
958 cmd
= add_cmd ("namespace", class_maintenance
,
959 maintenance_cplus_namespace
,
960 _("Deprecated placeholder for removed functionality."),
961 &maint_cplus_cmd_list
);
962 deprecate_cmd (cmd
, NULL
);