1 /* Helper routines for C++ support in GDB. 2 Copyright (C) 2003-2004, 2007-2012 Free Software Foundation, Inc. 3 4 Contributed by David Carlton and by Kealia, Inc. 5 6 This file is part of GDB. 7 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. 12 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. 17 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/>. */ 20 21 #include "defs.h" 22 #include "cp-support.h" 23 #include "gdb_obstack.h" 24 #include "symtab.h" 25 #include "symfile.h" 26 #include "gdb_assert.h" 27 #include "block.h" 28 #include "objfiles.h" 29 #include "gdbtypes.h" 30 #include "dictionary.h" 31 #include "command.h" 32 #include "frame.h" 33 #include "buildsym.h" 34 #include "language.h" 35 36 static struct symbol *lookup_namespace_scope (const char *name, 37 const struct block *block, 38 const domain_enum domain, 39 const char *scope, 40 int scope_len); 41 42 static struct symbol *lookup_symbol_file (const char *name, 43 const struct block *block, 44 const domain_enum domain, 45 int anonymous_namespace); 46 47 static struct type *cp_lookup_transparent_type_loop (const char *name, 48 const char *scope, 49 int scope_len); 50 51 /* Check to see if SYMBOL refers to an object contained within an 52 anonymous namespace; if so, add an appropriate using directive. */ 53 54 void 55 cp_scan_for_anonymous_namespaces (const struct symbol *const symbol, 56 struct objfile *const objfile) 57 { 58 if (SYMBOL_DEMANGLED_NAME (symbol) != NULL) 59 { 60 const char *name = SYMBOL_DEMANGLED_NAME (symbol); 61 unsigned int previous_component; 62 unsigned int next_component; 63 64 /* Start with a quick-and-dirty check for mention of "(anonymous 65 namespace)". */ 66 67 if (!cp_is_anonymous (name)) 68 return; 69 70 previous_component = 0; 71 next_component = cp_find_first_component (name + previous_component); 72 73 while (name[next_component] == ':') 74 { 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) 80 { 81 int dest_len = (previous_component == 0 82 ? 0 : previous_component - 2); 83 int src_len = next_component; 84 85 char *dest = alloca (dest_len + 1); 86 char *src = alloca (src_len + 1); 87 88 memcpy (dest, name, dest_len); 89 memcpy (src, name, src_len); 90 91 dest[dest_len] = '\0'; 92 src[src_len] = '\0'; 93 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, 99 &objfile->objfile_obstack); 100 } 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)); 106 } 107 } 108 } 109 110 111 /* Add a using directive to using_directives. If the using directive 112 in question has already been added, don't add it twice. 113 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 imported 120 module or NULL. The arguments are copied into newly allocated memory so 121 they can be temporaries. For EXCLUDES the VEC pointers are copied but the 122 pointed to characters are not copied. */ 123 124 void 125 cp_add_using_directive (const char *dest, 126 const char *src, 127 const char *alias, 128 const char *declaration, 129 VEC (const_char_ptr) *excludes, 130 struct obstack *obstack) 131 { 132 struct using_direct *current; 133 struct using_direct *new; 134 135 /* Has it already been added? */ 136 137 for (current = using_directives; current != NULL; current = current->next) 138 { 139 int ix; 140 const char *param; 141 142 if (strcmp (current->import_src, src) != 0) 143 continue; 144 if (strcmp (current->import_dest, dest) != 0) 145 continue; 146 if ((alias == NULL && current->alias != NULL) 147 || (alias != NULL && current->alias == NULL) 148 || (alias != NULL && current->alias != NULL 149 && strcmp (alias, current->alias) != 0)) 150 continue; 151 if ((declaration == NULL && current->declaration != NULL) 152 || (declaration != NULL && current->declaration == NULL) 153 || (declaration != NULL && current->declaration != NULL 154 && strcmp (declaration, current->declaration) != 0)) 155 continue; 156 157 /* Compare the contents of EXCLUDES. */ 158 for (ix = 0; VEC_iterate (const_char_ptr, excludes, ix, param); ix++) 159 if (current->excludes[ix] == NULL 160 || strcmp (param, current->excludes[ix]) != 0) 161 break; 162 if (ix < VEC_length (const_char_ptr, excludes) 163 || current->excludes[ix] != NULL) 164 continue; 165 166 /* Parameters exactly match CURRENT. */ 167 return; 168 } 169 170 new = obstack_alloc (obstack, (sizeof (*new) 171 + (VEC_length (const_char_ptr, excludes) 172 * sizeof (*new->excludes)))); 173 memset (new, 0, sizeof (*new)); 174 175 new->import_src = obsavestring (src, strlen (src), obstack); 176 new->import_dest = obsavestring (dest, strlen (dest), obstack); 177 178 if (alias != NULL) 179 new->alias = obsavestring (alias, strlen (alias), obstack); 180 181 if (declaration != NULL) 182 new->declaration = obsavestring (declaration, strlen (declaration), 183 obstack); 184 185 memcpy (new->excludes, VEC_address (const_char_ptr, excludes), 186 VEC_length (const_char_ptr, excludes) * sizeof (*new->excludes)); 187 new->excludes[VEC_length (const_char_ptr, excludes)] = NULL; 188 189 new->next = using_directives; 190 using_directives = new; 191 } 192 193 /* Record the namespace that the function defined by SYMBOL was 194 defined in, if necessary. BLOCK is the associated block; use 195 OBSTACK for allocation. */ 196 197 void 198 cp_set_block_scope (const struct symbol *symbol, 199 struct block *block, 200 struct obstack *obstack, 201 const char *processing_current_prefix, 202 int processing_has_namespace_info) 203 { 204 if (processing_has_namespace_info) 205 { 206 block_set_scope 207 (block, obsavestring (processing_current_prefix, 208 strlen (processing_current_prefix), 209 obstack), 210 obstack); 211 } 212 else if (SYMBOL_DEMANGLED_NAME (symbol) != NULL) 213 { 214 /* Try to figure out the appropriate namespace from the 215 demangled name. */ 216 217 /* FIXME: carlton/2003-04-15: If the function in question is 218 a method of a class, the name will actually include the 219 name of the class as well. This should be harmless, but 220 is a little unfortunate. */ 221 222 const char *name = SYMBOL_DEMANGLED_NAME (symbol); 223 unsigned int prefix_len = cp_entire_prefix_len (name); 224 225 block_set_scope (block, 226 obsavestring (name, prefix_len, obstack), 227 obstack); 228 } 229 } 230 231 /* Test whether or not NAMESPACE looks like it mentions an anonymous 232 namespace; return nonzero if so. */ 233 234 int 235 cp_is_anonymous (const char *namespace) 236 { 237 return (strstr (namespace, CP_ANONYMOUS_NAMESPACE_STR) 238 != NULL); 239 } 240 241 /* The C++-specific version of name lookup for static and global 242 names. This makes sure that names get looked for in all namespaces 243 that are in scope. NAME is the natural name of the symbol that 244 we're looking for, BLOCK is the block that we're searching within, 245 DOMAIN says what kind of symbols we're looking for, and if SYMTAB 246 is non-NULL, we should store the symtab where we found the symbol 247 in it. */ 248 249 struct symbol * 250 cp_lookup_symbol_nonlocal (const char *name, 251 const struct block *block, 252 const domain_enum domain) 253 { 254 struct symbol *sym; 255 const char *scope = block_scope (block); 256 257 sym = lookup_namespace_scope (name, block, 258 domain, scope, 0); 259 if (sym != NULL) 260 return sym; 261 262 return cp_lookup_symbol_namespace (scope, name, 263 block, domain); 264 } 265 266 /* Look up NAME in the C++ namespace NAMESPACE. Other arguments are 267 as in cp_lookup_symbol_nonlocal. */ 268 269 static struct symbol * 270 cp_lookup_symbol_in_namespace (const char *namespace, 271 const char *name, 272 const struct block *block, 273 const domain_enum domain) 274 { 275 if (namespace[0] == '\0') 276 { 277 return lookup_symbol_file (name, block, domain, 0); 278 } 279 else 280 { 281 char *concatenated_name = alloca (strlen (namespace) + 2 282 + strlen (name) + 1); 283 284 strcpy (concatenated_name, namespace); 285 strcat (concatenated_name, "::"); 286 strcat (concatenated_name, name); 287 return lookup_symbol_file (concatenated_name, block, domain, 288 cp_is_anonymous (namespace)); 289 } 290 } 291 292 /* Used for cleanups to reset the "searched" flag incase 293 of an error. */ 294 295 static void 296 reset_directive_searched (void *data) 297 { 298 struct using_direct *direct = data; 299 direct->searched = 0; 300 } 301 302 /* Search for NAME by applying all import statements belonging to 303 BLOCK which are applicable in SCOPE. If DECLARATION_ONLY the 304 search is restricted to using declarations. 305 Example: 306 307 namespace A { 308 int x; 309 } 310 using A::x; 311 312 If SEARCH_PARENTS the search will include imports which are 313 applicable in parents of SCOPE. 314 Example: 315 316 namespace A { 317 using namespace X; 318 namespace B { 319 using namespace Y; 320 } 321 } 322 323 If SCOPE is "A::B" and SEARCH_PARENTS is true the imports of 324 namespaces X and Y will be considered. If SEARCH_PARENTS is false 325 only the import of Y is considered. */ 326 327 struct symbol * 328 cp_lookup_symbol_imports (const char *scope, 329 const char *name, 330 const struct block *block, 331 const domain_enum domain, 332 const int declaration_only, 333 const int search_parents) 334 { 335 struct using_direct *current; 336 struct symbol *sym = NULL; 337 int len; 338 int directive_match; 339 struct cleanup *searched_cleanup; 340 341 /* First, try to find the symbol in the given namespace. */ 342 if (!declaration_only) 343 sym = cp_lookup_symbol_in_namespace (scope, name, 344 block, domain); 345 346 if (sym != NULL) 347 return sym; 348 349 /* Go through the using directives. If any of them add new names to 350 the namespace we're searching in, see if we can find a match by 351 applying them. */ 352 353 for (current = block_using (block); 354 current != NULL; 355 current = current->next) 356 { 357 const char **excludep; 358 359 len = strlen (current->import_dest); 360 directive_match = (search_parents 361 ? (strncmp (scope, current->import_dest, 362 strlen (current->import_dest)) == 0 363 && (len == 0 364 || scope[len] == ':' 365 || scope[len] == '\0')) 366 : strcmp (scope, current->import_dest) == 0); 367 368 /* If the import destination is the current scope or one of its 369 ancestors then it is applicable. */ 370 if (directive_match && !current->searched) 371 { 372 /* Mark this import as searched so that the recursive call 373 does not search it again. */ 374 current->searched = 1; 375 searched_cleanup = make_cleanup (reset_directive_searched, 376 current); 377 378 /* If there is an import of a single declaration, compare the 379 imported declaration (after optional renaming by its alias) 380 with the sought out name. If there is a match pass 381 current->import_src as NAMESPACE to direct the search 382 towards the imported namespace. */ 383 if (current->declaration 384 && strcmp (name, current->alias 385 ? current->alias : current->declaration) == 0) 386 sym = cp_lookup_symbol_in_namespace (current->import_src, 387 current->declaration, 388 block, domain); 389 390 /* If this is a DECLARATION_ONLY search or a symbol was found 391 or this import statement was an import declaration, the 392 search of this import is complete. */ 393 if (declaration_only || sym != NULL || current->declaration) 394 { 395 current->searched = 0; 396 discard_cleanups (searched_cleanup); 397 398 if (sym != NULL) 399 return sym; 400 401 continue; 402 } 403 404 /* Do not follow CURRENT if NAME matches its EXCLUDES. */ 405 for (excludep = current->excludes; *excludep; excludep++) 406 if (strcmp (name, *excludep) == 0) 407 break; 408 if (*excludep) 409 { 410 discard_cleanups (searched_cleanup); 411 continue; 412 } 413 414 if (current->alias != NULL 415 && strcmp (name, current->alias) == 0) 416 /* If the import is creating an alias and the alias matches 417 the sought name. Pass current->import_src as the NAME to 418 direct the search towards the aliased namespace. */ 419 { 420 sym = cp_lookup_symbol_in_namespace (scope, 421 current->import_src, 422 block, domain); 423 } 424 else if (current->alias == NULL) 425 { 426 /* If this import statement creates no alias, pass 427 current->inner as NAMESPACE to direct the search 428 towards the imported namespace. */ 429 sym = cp_lookup_symbol_imports (current->import_src, 430 name, block, 431 domain, 0, 0); 432 } 433 current->searched = 0; 434 discard_cleanups (searched_cleanup); 435 436 if (sym != NULL) 437 return sym; 438 } 439 } 440 441 return NULL; 442 } 443 444 /* Helper function that searches an array of symbols for one named 445 NAME. */ 446 447 static struct symbol * 448 search_symbol_list (const char *name, int num, 449 struct symbol **syms) 450 { 451 int i; 452 453 /* Maybe we should store a dictionary in here instead. */ 454 for (i = 0; i < num; ++i) 455 { 456 if (strcmp (name, SYMBOL_NATURAL_NAME (syms[i])) == 0) 457 return syms[i]; 458 } 459 return NULL; 460 } 461 462 /* Like cp_lookup_symbol_imports, but if BLOCK is a function, it 463 searches through the template parameters of the function and the 464 function's type. */ 465 466 struct symbol * 467 cp_lookup_symbol_imports_or_template (const char *scope, 468 const char *name, 469 const struct block *block, 470 const domain_enum domain) 471 { 472 struct symbol *function = BLOCK_FUNCTION (block); 473 474 if (function != NULL && SYMBOL_LANGUAGE (function) == language_cplus) 475 { 476 int i; 477 struct cplus_specific *cps 478 = function->ginfo.language_specific.cplus_specific; 479 480 /* Search the function's template parameters. */ 481 if (SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION (function)) 482 { 483 struct template_symbol *templ 484 = (struct template_symbol *) function; 485 struct symbol *result; 486 487 result = search_symbol_list (name, 488 templ->n_template_arguments, 489 templ->template_arguments); 490 if (result != NULL) 491 return result; 492 } 493 494 /* Search the template parameters of the function's defining 495 context. */ 496 if (SYMBOL_NATURAL_NAME (function)) 497 { 498 struct type *context; 499 char *name_copy = xstrdup (SYMBOL_NATURAL_NAME (function)); 500 struct cleanup *cleanups = make_cleanup (xfree, name_copy); 501 const struct language_defn *lang = language_def (language_cplus); 502 struct gdbarch *arch = SYMBOL_SYMTAB (function)->objfile->gdbarch; 503 const struct block *parent = BLOCK_SUPERBLOCK (block); 504 505 while (1) 506 { 507 struct symbol *result; 508 unsigned int prefix_len = cp_entire_prefix_len (name_copy); 509 510 if (prefix_len == 0) 511 context = NULL; 512 else 513 { 514 name_copy[prefix_len] = '\0'; 515 context = lookup_typename (lang, arch, 516 name_copy, 517 parent, 1); 518 } 519 520 if (context == NULL) 521 break; 522 523 result 524 = search_symbol_list (name, 525 TYPE_N_TEMPLATE_ARGUMENTS (context), 526 TYPE_TEMPLATE_ARGUMENTS (context)); 527 if (result != NULL) 528 return result; 529 } 530 531 do_cleanups (cleanups); 532 } 533 } 534 535 return cp_lookup_symbol_imports (scope, name, block, domain, 1, 1); 536 } 537 538 /* Searches for NAME in the current namespace, and by applying 539 relevant import statements belonging to BLOCK and its parents. 540 SCOPE is the namespace scope of the context in which the search is 541 being evaluated. */ 542 543 struct symbol* 544 cp_lookup_symbol_namespace (const char *scope, 545 const char *name, 546 const struct block *block, 547 const domain_enum domain) 548 { 549 struct symbol *sym; 550 551 /* First, try to find the symbol in the given namespace. */ 552 sym = cp_lookup_symbol_in_namespace (scope, name, 553 block, domain); 554 if (sym != NULL) 555 return sym; 556 557 /* Search for name in namespaces imported to this and parent 558 blocks. */ 559 while (block != NULL) 560 { 561 sym = cp_lookup_symbol_imports (scope, name, block, 562 domain, 0, 1); 563 564 if (sym) 565 return sym; 566 567 block = BLOCK_SUPERBLOCK (block); 568 } 569 570 return NULL; 571 } 572 573 /* Lookup NAME at namespace scope (or, in C terms, in static and 574 global variables). SCOPE is the namespace that the current 575 function is defined within; only consider namespaces whose length 576 is at least SCOPE_LEN. Other arguments are as in 577 cp_lookup_symbol_nonlocal. 578 579 For example, if we're within a function A::B::f and looking for a 580 symbol x, this will get called with NAME = "x", SCOPE = "A::B", and 581 SCOPE_LEN = 0. It then calls itself with NAME and SCOPE the same, 582 but with SCOPE_LEN = 1. And then it calls itself with NAME and 583 SCOPE the same, but with SCOPE_LEN = 4. This third call looks for 584 "A::B::x"; if it doesn't find it, then the second call looks for 585 "A::x", and if that call fails, then the first call looks for 586 "x". */ 587 588 static struct symbol * 589 lookup_namespace_scope (const char *name, 590 const struct block *block, 591 const domain_enum domain, 592 const char *scope, 593 int scope_len) 594 { 595 char *namespace; 596 597 if (scope[scope_len] != '\0') 598 { 599 /* Recursively search for names in child namespaces first. */ 600 601 struct symbol *sym; 602 int new_scope_len = scope_len; 603 604 /* If the current scope is followed by "::", skip past that. */ 605 if (new_scope_len != 0) 606 { 607 gdb_assert (scope[new_scope_len] == ':'); 608 new_scope_len += 2; 609 } 610 new_scope_len += cp_find_first_component (scope + new_scope_len); 611 sym = lookup_namespace_scope (name, block, domain, 612 scope, new_scope_len); 613 if (sym != NULL) 614 return sym; 615 } 616 617 /* Okay, we didn't find a match in our children, so look for the 618 name in the current namespace. */ 619 620 namespace = alloca (scope_len + 1); 621 strncpy (namespace, scope, scope_len); 622 namespace[scope_len] = '\0'; 623 return cp_lookup_symbol_in_namespace (namespace, name, 624 block, domain); 625 } 626 627 /* Look up NAME in BLOCK's static block and in global blocks. If 628 ANONYMOUS_NAMESPACE is nonzero, the symbol in question is located 629 within an anonymous namespace. Other arguments are as in 630 cp_lookup_symbol_nonlocal. */ 631 632 static struct symbol * 633 lookup_symbol_file (const char *name, 634 const struct block *block, 635 const domain_enum domain, 636 int anonymous_namespace) 637 { 638 struct symbol *sym = NULL; 639 640 sym = lookup_symbol_static (name, block, domain); 641 if (sym != NULL) 642 return sym; 643 644 if (anonymous_namespace) 645 { 646 /* Symbols defined in anonymous namespaces have external linkage 647 but should be treated as local to a single file nonetheless. 648 So we only search the current file's global block. */ 649 650 const struct block *global_block = block_global_block (block); 651 652 if (global_block != NULL) 653 sym = lookup_symbol_aux_block (name, global_block, domain); 654 } 655 else 656 { 657 sym = lookup_symbol_global (name, block, domain); 658 } 659 660 return sym; 661 } 662 663 /* Look up a type named NESTED_NAME that is nested inside the C++ 664 class or namespace given by PARENT_TYPE, from within the context 665 given by BLOCK. Return NULL if there is no such nested type. */ 666 667 struct type * 668 cp_lookup_nested_type (struct type *parent_type, 669 const char *nested_name, 670 const struct block *block) 671 { 672 /* type_name_no_tag_required provides better error reporting using the 673 original type. */ 674 struct type *saved_parent_type = parent_type; 675 676 CHECK_TYPEDEF (parent_type); 677 678 switch (TYPE_CODE (parent_type)) 679 { 680 case TYPE_CODE_STRUCT: 681 case TYPE_CODE_NAMESPACE: 682 case TYPE_CODE_UNION: 683 { 684 /* NOTE: carlton/2003-11-10: We don't treat C++ class members 685 of classes like, say, data or function members. Instead, 686 they're just represented by symbols whose names are 687 qualified by the name of the surrounding class. This is 688 just like members of namespaces; in particular, 689 lookup_symbol_namespace works when looking them up. */ 690 691 const char *parent_name = type_name_no_tag_or_error (saved_parent_type); 692 struct symbol *sym 693 = cp_lookup_symbol_in_namespace (parent_name, nested_name, 694 block, VAR_DOMAIN); 695 char *concatenated_name; 696 697 if (sym != NULL && SYMBOL_CLASS (sym) == LOC_TYPEDEF) 698 return SYMBOL_TYPE (sym); 699 700 /* Now search all static file-level symbols. Not strictly 701 correct, but more useful than an error. We do not try to 702 guess any imported namespace as even the fully specified 703 namespace seach is is already not C++ compliant and more 704 assumptions could make it too magic. */ 705 706 concatenated_name = alloca (strlen (parent_name) + 2 707 + strlen (nested_name) + 1); 708 sprintf (concatenated_name, "%s::%s", 709 parent_name, nested_name); 710 sym = lookup_static_symbol_aux (concatenated_name, 711 VAR_DOMAIN); 712 if (sym != NULL && SYMBOL_CLASS (sym) == LOC_TYPEDEF) 713 return SYMBOL_TYPE (sym); 714 715 return NULL; 716 } 717 default: 718 internal_error (__FILE__, __LINE__, 719 _("cp_lookup_nested_type called " 720 "on a non-aggregate type.")); 721 } 722 } 723 724 /* The C++-version of lookup_transparent_type. */ 725 726 /* FIXME: carlton/2004-01-16: The problem that this is trying to 727 address is that, unfortunately, sometimes NAME is wrong: it may not 728 include the name of namespaces enclosing the type in question. 729 lookup_transparent_type gets called when the type in question 730 is a declaration, and we're trying to find its definition; but, for 731 declarations, our type name deduction mechanism doesn't work. 732 There's nothing we can do to fix this in general, I think, in the 733 absence of debug information about namespaces (I've filed PR 734 gdb/1511 about this); until such debug information becomes more 735 prevalent, one heuristic which sometimes looks is to search for the 736 definition in namespaces containing the current namespace. 737 738 We should delete this functions once the appropriate debug 739 information becomes more widespread. (GCC 3.4 will be the first 740 released version of GCC with such information.) */ 741 742 struct type * 743 cp_lookup_transparent_type (const char *name) 744 { 745 /* First, try the honest way of looking up the definition. */ 746 struct type *t = basic_lookup_transparent_type (name); 747 const char *scope; 748 749 if (t != NULL) 750 return t; 751 752 /* If that doesn't work and we're within a namespace, look there 753 instead. */ 754 scope = block_scope (get_selected_block (0)); 755 756 if (scope[0] == '\0') 757 return NULL; 758 759 return cp_lookup_transparent_type_loop (name, scope, 0); 760 } 761 762 /* Lookup the type definition associated to NAME in namespaces/classes 763 containing SCOPE whose name is strictly longer than LENGTH. LENGTH 764 must be the index of the start of a component of SCOPE. */ 765 766 static struct type * 767 cp_lookup_transparent_type_loop (const char *name, 768 const char *scope, 769 int length) 770 { 771 int scope_length = length + cp_find_first_component (scope + length); 772 char *full_name; 773 774 /* If the current scope is followed by "::", look in the next 775 component. */ 776 if (scope[scope_length] == ':') 777 { 778 struct type *retval 779 = cp_lookup_transparent_type_loop (name, scope, 780 scope_length + 2); 781 782 if (retval != NULL) 783 return retval; 784 } 785 786 full_name = alloca (scope_length + 2 + strlen (name) + 1); 787 strncpy (full_name, scope, scope_length); 788 strncpy (full_name + scope_length, "::", 2); 789 strcpy (full_name + scope_length + 2, name); 790 791 return basic_lookup_transparent_type (full_name); 792 } 793 794 /* This used to do something but was removed when it became 795 obsolete. */ 796 797 static void 798 maintenance_cplus_namespace (char *args, int from_tty) 799 { 800 printf_unfiltered (_("The `maint namespace' command was removed.\n")); 801 } 802 803 /* Provide a prototype to silence -Wmissing-prototypes. */ 804 extern initialize_file_ftype _initialize_cp_namespace; 805 806 void 807 _initialize_cp_namespace (void) 808 { 809 struct cmd_list_element *cmd; 810 811 cmd = add_cmd ("namespace", class_maintenance, 812 maintenance_cplus_namespace, 813 _("Deprecated placeholder for removed functionality."), 814 &maint_cplus_cmd_list); 815 deprecate_cmd (cmd, NULL); 816 } 817