lex.c revision 132718
1/* Separate lexical analyzer for GNU C++. 2 Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 3 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. 4 Hacked by Michael Tiemann (tiemann@cygnus.com) 5 6This file is part of GCC. 7 8GCC is free software; you can redistribute it and/or modify 9it under the terms of the GNU General Public License as published by 10the Free Software Foundation; either version 2, or (at your option) 11any later version. 12 13GCC is distributed in the hope that it will be useful, 14but WITHOUT ANY WARRANTY; without even the implied warranty of 15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16GNU General Public License for more details. 17 18You should have received a copy of the GNU General Public License 19along with GCC; see the file COPYING. If not, write to 20the Free Software Foundation, 59 Temple Place - Suite 330, 21Boston, MA 02111-1307, USA. */ 22 23 24/* This file is the lexical analyzer for GNU C++. */ 25 26#include "config.h" 27#include "system.h" 28#include "coretypes.h" 29#include "tm.h" 30#include "input.h" 31#include "tree.h" 32#include "cp-tree.h" 33#include "cpplib.h" 34#include "lex.h" 35#include "flags.h" 36#include "c-pragma.h" 37#include "toplev.h" 38#include "output.h" 39#include "tm_p.h" 40#include "timevar.h" 41 42static int interface_strcmp (const char *); 43static void init_cp_pragma (void); 44 45static tree parse_strconst_pragma (const char *, int); 46static void handle_pragma_vtable (cpp_reader *); 47static void handle_pragma_unit (cpp_reader *); 48static void handle_pragma_interface (cpp_reader *); 49static void handle_pragma_implementation (cpp_reader *); 50static void handle_pragma_java_exceptions (cpp_reader *); 51 52static void init_operators (void); 53static void copy_lang_type (tree); 54 55/* A constraint that can be tested at compile time. */ 56#define CONSTRAINT(name, expr) extern int constraint_##name [(expr) ? 1 : -1] 57 58/* Functions and data structures for #pragma interface. 59 60 `#pragma implementation' means that the main file being compiled 61 is considered to implement (provide) the classes that appear in 62 its main body. I.e., if this is file "foo.cc", and class `bar' 63 is defined in "foo.cc", then we say that "foo.cc implements bar". 64 65 All main input files "implement" themselves automagically. 66 67 `#pragma interface' means that unless this file (of the form "foo.h" 68 is not presently being included by file "foo.cc", the 69 CLASSTYPE_INTERFACE_ONLY bit gets set. The effect is that none 70 of the vtables nor any of the inline functions defined in foo.h 71 will ever be output. 72 73 There are cases when we want to link files such as "defs.h" and 74 "main.cc". In this case, we give "defs.h" a `#pragma interface', 75 and "main.cc" has `#pragma implementation "defs.h"'. */ 76 77struct impl_files 78{ 79 const char *filename; 80 struct impl_files *next; 81}; 82 83static struct impl_files *impl_file_chain; 84 85 86/* Return something to represent absolute declarators containing a *. 87 TARGET is the absolute declarator that the * contains. 88 CV_QUALIFIERS is a list of modifiers such as const or volatile 89 to apply to the pointer type, represented as identifiers. 90 91 We return an INDIRECT_REF whose "contents" are TARGET 92 and whose type is the modifier list. */ 93 94tree 95make_pointer_declarator (tree cv_qualifiers, tree target) 96{ 97 if (target && TREE_CODE (target) == IDENTIFIER_NODE 98 && ANON_AGGRNAME_P (target)) 99 error ("type name expected before `*'"); 100 target = build_nt (INDIRECT_REF, target); 101 TREE_TYPE (target) = cv_qualifiers; 102 return target; 103} 104 105/* Return something to represent absolute declarators containing a &. 106 TARGET is the absolute declarator that the & contains. 107 CV_QUALIFIERS is a list of modifiers such as const or volatile 108 to apply to the reference type, represented as identifiers. 109 110 We return an ADDR_EXPR whose "contents" are TARGET 111 and whose type is the modifier list. */ 112 113tree 114make_reference_declarator (tree cv_qualifiers, tree target) 115{ 116 target = build_nt (ADDR_EXPR, target); 117 TREE_TYPE (target) = cv_qualifiers; 118 return target; 119} 120 121tree 122make_call_declarator (tree target, tree parms, tree cv_qualifiers, 123 tree exception_specification) 124{ 125 target = build_nt (CALL_EXPR, target, 126 tree_cons (parms, cv_qualifiers, NULL_TREE), 127 /* The third operand is really RTL. We 128 shouldn't put anything there. */ 129 NULL_TREE); 130 CALL_DECLARATOR_EXCEPTION_SPEC (target) = exception_specification; 131 return target; 132} 133 134void 135set_quals_and_spec (tree call_declarator, tree cv_qualifiers, 136 tree exception_specification) 137{ 138 CALL_DECLARATOR_QUALS (call_declarator) = cv_qualifiers; 139 CALL_DECLARATOR_EXCEPTION_SPEC (call_declarator) = exception_specification; 140} 141 142int interface_only; /* whether or not current file is only for 143 interface definitions. */ 144int interface_unknown; /* whether or not we know this class 145 to behave according to #pragma interface. */ 146 147 148void 149cxx_finish (void) 150{ 151 c_common_finish (); 152} 153 154/* A mapping from tree codes to operator name information. */ 155operator_name_info_t operator_name_info[(int) LAST_CPLUS_TREE_CODE]; 156/* Similar, but for assignment operators. */ 157operator_name_info_t assignment_operator_name_info[(int) LAST_CPLUS_TREE_CODE]; 158 159/* Initialize data structures that keep track of operator names. */ 160 161#define DEF_OPERATOR(NAME, C, M, AR, AP) \ 162 CONSTRAINT (C, sizeof "operator " + sizeof NAME <= 256); 163#include "operators.def" 164#undef DEF_OPERATOR 165 166static void 167init_operators (void) 168{ 169 tree identifier; 170 char buffer[256]; 171 struct operator_name_info_t *oni; 172 173#define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \ 174 sprintf (buffer, ISALPHA (NAME[0]) ? "operator %s" : "operator%s", NAME); \ 175 identifier = get_identifier (buffer); \ 176 IDENTIFIER_OPNAME_P (identifier) = 1; \ 177 \ 178 oni = (ASSN_P \ 179 ? &assignment_operator_name_info[(int) CODE] \ 180 : &operator_name_info[(int) CODE]); \ 181 oni->identifier = identifier; \ 182 oni->name = NAME; \ 183 oni->mangled_name = MANGLING; \ 184 oni->arity = ARITY; 185 186#include "operators.def" 187#undef DEF_OPERATOR 188 189 operator_name_info[(int) ERROR_MARK].identifier 190 = get_identifier ("<invalid operator>"); 191 192 /* Handle some special cases. These operators are not defined in 193 the language, but can be produced internally. We may need them 194 for error-reporting. (Eventually, we should ensure that this 195 does not happen. Error messages involving these operators will 196 be confusing to users.) */ 197 198 operator_name_info [(int) INIT_EXPR].name 199 = operator_name_info [(int) MODIFY_EXPR].name; 200 operator_name_info [(int) EXACT_DIV_EXPR].name = "(ceiling /)"; 201 operator_name_info [(int) CEIL_DIV_EXPR].name = "(ceiling /)"; 202 operator_name_info [(int) FLOOR_DIV_EXPR].name = "(floor /)"; 203 operator_name_info [(int) ROUND_DIV_EXPR].name = "(round /)"; 204 operator_name_info [(int) CEIL_MOD_EXPR].name = "(ceiling %)"; 205 operator_name_info [(int) FLOOR_MOD_EXPR].name = "(floor %)"; 206 operator_name_info [(int) ROUND_MOD_EXPR].name = "(round %)"; 207 operator_name_info [(int) ABS_EXPR].name = "abs"; 208 operator_name_info [(int) TRUTH_AND_EXPR].name = "strict &&"; 209 operator_name_info [(int) TRUTH_OR_EXPR].name = "strict ||"; 210 operator_name_info [(int) IN_EXPR].name = "in"; 211 operator_name_info [(int) RANGE_EXPR].name = "..."; 212 operator_name_info [(int) CONVERT_EXPR].name = "+"; 213 214 assignment_operator_name_info [(int) EXACT_DIV_EXPR].name 215 = "(exact /=)"; 216 assignment_operator_name_info [(int) CEIL_DIV_EXPR].name 217 = "(ceiling /=)"; 218 assignment_operator_name_info [(int) FLOOR_DIV_EXPR].name 219 = "(floor /=)"; 220 assignment_operator_name_info [(int) ROUND_DIV_EXPR].name 221 = "(round /=)"; 222 assignment_operator_name_info [(int) CEIL_MOD_EXPR].name 223 = "(ceiling %=)"; 224 assignment_operator_name_info [(int) FLOOR_MOD_EXPR].name 225 = "(floor %=)"; 226 assignment_operator_name_info [(int) ROUND_MOD_EXPR].name 227 = "(round %=)"; 228} 229 230/* The reserved keyword table. */ 231struct resword 232{ 233 const char *const word; 234 ENUM_BITFIELD(rid) const rid : 16; 235 const unsigned int disable : 16; 236}; 237 238/* Disable mask. Keywords are disabled if (reswords[i].disable & mask) is 239 _true_. */ 240#define D_EXT 0x01 /* GCC extension */ 241#define D_ASM 0x02 /* in C99, but has a switch to turn it off */ 242 243CONSTRAINT(ridbits_fit, RID_LAST_MODIFIER < sizeof(unsigned long) * CHAR_BIT); 244 245static const struct resword reswords[] = 246{ 247 { "_Complex", RID_COMPLEX, 0 }, 248 { "__FUNCTION__", RID_FUNCTION_NAME, 0 }, 249 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 }, 250 { "__alignof", RID_ALIGNOF, 0 }, 251 { "__alignof__", RID_ALIGNOF, 0 }, 252 { "__asm", RID_ASM, 0 }, 253 { "__asm__", RID_ASM, 0 }, 254 { "__attribute", RID_ATTRIBUTE, 0 }, 255 { "__attribute__", RID_ATTRIBUTE, 0 }, 256 { "__builtin_va_arg", RID_VA_ARG, 0 }, 257 { "__complex", RID_COMPLEX, 0 }, 258 { "__complex__", RID_COMPLEX, 0 }, 259 { "__const", RID_CONST, 0 }, 260 { "__const__", RID_CONST, 0 }, 261 { "__extension__", RID_EXTENSION, 0 }, 262 { "__func__", RID_C99_FUNCTION_NAME, 0 }, 263 { "__imag", RID_IMAGPART, 0 }, 264 { "__imag__", RID_IMAGPART, 0 }, 265 { "__inline", RID_INLINE, 0 }, 266 { "__inline__", RID_INLINE, 0 }, 267 { "__label__", RID_LABEL, 0 }, 268 { "__null", RID_NULL, 0 }, 269 { "__offsetof", RID_OFFSETOF, 0 }, 270 { "__offsetof__", RID_OFFSETOF, 0 }, 271 { "__real", RID_REALPART, 0 }, 272 { "__real__", RID_REALPART, 0 }, 273 { "__restrict", RID_RESTRICT, 0 }, 274 { "__restrict__", RID_RESTRICT, 0 }, 275 { "__signed", RID_SIGNED, 0 }, 276 { "__signed__", RID_SIGNED, 0 }, 277 { "__thread", RID_THREAD, 0 }, 278 { "__typeof", RID_TYPEOF, 0 }, 279 { "__typeof__", RID_TYPEOF, 0 }, 280 { "__volatile", RID_VOLATILE, 0 }, 281 { "__volatile__", RID_VOLATILE, 0 }, 282 { "asm", RID_ASM, D_ASM }, 283 { "auto", RID_AUTO, 0 }, 284 { "bool", RID_BOOL, 0 }, 285 { "break", RID_BREAK, 0 }, 286 { "case", RID_CASE, 0 }, 287 { "catch", RID_CATCH, 0 }, 288 { "char", RID_CHAR, 0 }, 289 { "class", RID_CLASS, 0 }, 290 { "const", RID_CONST, 0 }, 291 { "const_cast", RID_CONSTCAST, 0 }, 292 { "continue", RID_CONTINUE, 0 }, 293 { "default", RID_DEFAULT, 0 }, 294 { "delete", RID_DELETE, 0 }, 295 { "do", RID_DO, 0 }, 296 { "double", RID_DOUBLE, 0 }, 297 { "dynamic_cast", RID_DYNCAST, 0 }, 298 { "else", RID_ELSE, 0 }, 299 { "enum", RID_ENUM, 0 }, 300 { "explicit", RID_EXPLICIT, 0 }, 301 { "export", RID_EXPORT, 0 }, 302 { "extern", RID_EXTERN, 0 }, 303 { "false", RID_FALSE, 0 }, 304 { "float", RID_FLOAT, 0 }, 305 { "for", RID_FOR, 0 }, 306 { "friend", RID_FRIEND, 0 }, 307 { "goto", RID_GOTO, 0 }, 308 { "if", RID_IF, 0 }, 309 { "inline", RID_INLINE, 0 }, 310 { "int", RID_INT, 0 }, 311 { "long", RID_LONG, 0 }, 312 { "mutable", RID_MUTABLE, 0 }, 313 { "namespace", RID_NAMESPACE, 0 }, 314 { "new", RID_NEW, 0 }, 315 { "operator", RID_OPERATOR, 0 }, 316 { "private", RID_PRIVATE, 0 }, 317 { "protected", RID_PROTECTED, 0 }, 318 { "public", RID_PUBLIC, 0 }, 319 { "register", RID_REGISTER, 0 }, 320 { "reinterpret_cast", RID_REINTCAST, 0 }, 321 { "return", RID_RETURN, 0 }, 322 { "short", RID_SHORT, 0 }, 323 { "signed", RID_SIGNED, 0 }, 324 { "sizeof", RID_SIZEOF, 0 }, 325 { "static", RID_STATIC, 0 }, 326 { "static_cast", RID_STATCAST, 0 }, 327 { "struct", RID_STRUCT, 0 }, 328 { "switch", RID_SWITCH, 0 }, 329 { "template", RID_TEMPLATE, 0 }, 330 { "this", RID_THIS, 0 }, 331 { "throw", RID_THROW, 0 }, 332 { "true", RID_TRUE, 0 }, 333 { "try", RID_TRY, 0 }, 334 { "typedef", RID_TYPEDEF, 0 }, 335 { "typename", RID_TYPENAME, 0 }, 336 { "typeid", RID_TYPEID, 0 }, 337 { "typeof", RID_TYPEOF, D_ASM|D_EXT }, 338 { "union", RID_UNION, 0 }, 339 { "unsigned", RID_UNSIGNED, 0 }, 340 { "using", RID_USING, 0 }, 341 { "virtual", RID_VIRTUAL, 0 }, 342 { "void", RID_VOID, 0 }, 343 { "volatile", RID_VOLATILE, 0 }, 344 { "wchar_t", RID_WCHAR, 0 }, 345 { "while", RID_WHILE, 0 }, 346 347}; 348 349void 350init_reswords (void) 351{ 352 unsigned int i; 353 tree id; 354 int mask = ((flag_no_asm ? D_ASM : 0) 355 | (flag_no_gnu_keywords ? D_EXT : 0)); 356 357 ridpointers = ggc_calloc ((int) RID_MAX, sizeof (tree)); 358 for (i = 0; i < ARRAY_SIZE (reswords); i++) 359 { 360 id = get_identifier (reswords[i].word); 361 C_RID_CODE (id) = reswords[i].rid; 362 ridpointers [(int) reswords[i].rid] = id; 363 if (! (reswords[i].disable & mask)) 364 C_IS_RESERVED_WORD (id) = 1; 365 } 366} 367 368static void 369init_cp_pragma (void) 370{ 371 c_register_pragma (0, "vtable", handle_pragma_vtable); 372 c_register_pragma (0, "unit", handle_pragma_unit); 373 c_register_pragma (0, "interface", handle_pragma_interface); 374 c_register_pragma (0, "implementation", handle_pragma_implementation); 375 c_register_pragma ("GCC", "interface", handle_pragma_interface); 376 c_register_pragma ("GCC", "implementation", handle_pragma_implementation); 377 c_register_pragma ("GCC", "java_exceptions", handle_pragma_java_exceptions); 378} 379 380/* Initialize the C++ front end. This function is very sensitive to 381 the exact order that things are done here. It would be nice if the 382 initialization done by this routine were moved to its subroutines, 383 and the ordering dependencies clarified and reduced. */ 384bool 385cxx_init (void) 386{ 387 static const enum tree_code stmt_codes[] = { 388 c_common_stmt_codes, 389 cp_stmt_codes 390 }; 391 392 INIT_STATEMENT_CODES (stmt_codes); 393 394 /* We cannot just assign to input_filename because it has already 395 been initialized and will be used later as an N_BINCL for stabs+ 396 debugging. */ 397 push_srcloc ("<internal>", 0); 398 399 init_reswords (); 400 init_tree (); 401 init_cp_semantics (); 402 init_operators (); 403 init_method (); 404 init_error (); 405 406 current_function_decl = NULL; 407 408 class_type_node = ridpointers[(int) RID_CLASS]; 409 410 cxx_init_decl_processing (); 411 412 /* Create the built-in __null node. */ 413 null_node = build_int_2 (0, 0); 414 TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0); 415 ridpointers[RID_NULL] = null_node; 416 417 interface_unknown = 1; 418 419 if (c_common_init () == false) 420 { 421 pop_srcloc(); 422 return false; 423 } 424 425 init_cp_pragma (); 426 427 init_repo (main_input_filename); 428 429 pop_srcloc(); 430 return true; 431} 432 433/* Helper function to load global variables with interface 434 information. */ 435 436void 437extract_interface_info (void) 438{ 439 struct c_fileinfo *finfo; 440 441 finfo = get_fileinfo (input_filename); 442 interface_only = finfo->interface_only; 443 interface_unknown = finfo->interface_unknown; 444} 445 446/* Return nonzero if S is not considered part of an 447 INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */ 448 449static int 450interface_strcmp (const char* s) 451{ 452 /* Set the interface/implementation bits for this scope. */ 453 struct impl_files *ifiles; 454 const char *s1; 455 456 for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next) 457 { 458 const char *t1 = ifiles->filename; 459 s1 = s; 460 461 if (*s1 != *t1 || *s1 == 0) 462 continue; 463 464 while (*s1 == *t1 && *s1 != 0) 465 s1++, t1++; 466 467 /* A match. */ 468 if (*s1 == *t1) 469 return 0; 470 471 /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */ 472 if (strchr (s1, '.') || strchr (t1, '.')) 473 continue; 474 475 if (*s1 == '\0' || s1[-1] != '.' || t1[-1] != '.') 476 continue; 477 478 /* A match. */ 479 return 0; 480 } 481 482 /* No matches. */ 483 return 1; 484} 485 486 487 488/* Parse a #pragma whose sole argument is a string constant. 489 If OPT is true, the argument is optional. */ 490static tree 491parse_strconst_pragma (const char* name, int opt) 492{ 493 tree result, x; 494 enum cpp_ttype t; 495 496 t = c_lex (&x); 497 if (t == CPP_STRING) 498 { 499 result = x; 500 if (c_lex (&x) != CPP_EOF) 501 warning ("junk at end of #pragma %s", name); 502 return result; 503 } 504 505 if (t == CPP_EOF && opt) 506 return 0; 507 508 error ("invalid #pragma %s", name); 509 return (tree)-1; 510} 511 512static void 513handle_pragma_vtable (cpp_reader* dfile ATTRIBUTE_UNUSED ) 514{ 515 parse_strconst_pragma ("vtable", 0); 516 sorry ("#pragma vtable no longer supported"); 517} 518 519static void 520handle_pragma_unit (cpp_reader* dfile ATTRIBUTE_UNUSED ) 521{ 522 /* Validate syntax, but don't do anything. */ 523 parse_strconst_pragma ("unit", 0); 524} 525 526static void 527handle_pragma_interface (cpp_reader* dfile ATTRIBUTE_UNUSED ) 528{ 529 tree fname = parse_strconst_pragma ("interface", 1); 530 struct c_fileinfo *finfo; 531 const char *main_filename; 532 533 if (fname == (tree)-1) 534 return; 535 else if (fname == 0) 536 main_filename = lbasename (input_filename); 537 else 538 main_filename = TREE_STRING_POINTER (fname); 539 540 finfo = get_fileinfo (input_filename); 541 542 if (impl_file_chain == 0) 543 { 544 /* If this is zero at this point, then we are 545 auto-implementing. */ 546 if (main_input_filename == 0) 547 main_input_filename = input_filename; 548 } 549 550 interface_only = interface_strcmp (main_filename); 551#ifdef MULTIPLE_SYMBOL_SPACES 552 if (! interface_only) 553#endif 554 interface_unknown = 0; 555 556 finfo->interface_only = interface_only; 557 finfo->interface_unknown = interface_unknown; 558} 559 560/* Note that we have seen a #pragma implementation for the key MAIN_FILENAME. 561 We used to only allow this at toplevel, but that restriction was buggy 562 in older compilers and it seems reasonable to allow it in the headers 563 themselves, too. It only needs to precede the matching #p interface. 564 565 We don't touch interface_only or interface_unknown; the user must specify 566 a matching #p interface for this to have any effect. */ 567 568static void 569handle_pragma_implementation (cpp_reader* dfile ATTRIBUTE_UNUSED ) 570{ 571 tree fname = parse_strconst_pragma ("implementation", 1); 572 const char *main_filename; 573 struct impl_files *ifiles = impl_file_chain; 574 575 if (fname == (tree)-1) 576 return; 577 578 if (fname == 0) 579 { 580 if (main_input_filename) 581 main_filename = main_input_filename; 582 else 583 main_filename = input_filename; 584 main_filename = lbasename (main_filename); 585 } 586 else 587 { 588 main_filename = TREE_STRING_POINTER (fname); 589 if (cpp_included (parse_in, main_filename)) 590 warning ("#pragma implementation for %s appears after file is included", 591 main_filename); 592 } 593 594 for (; ifiles; ifiles = ifiles->next) 595 { 596 if (! strcmp (ifiles->filename, main_filename)) 597 break; 598 } 599 if (ifiles == 0) 600 { 601 ifiles = xmalloc (sizeof (struct impl_files)); 602 ifiles->filename = main_filename; 603 ifiles->next = impl_file_chain; 604 impl_file_chain = ifiles; 605 } 606} 607 608/* Indicate that this file uses Java-personality exception handling. */ 609static void 610handle_pragma_java_exceptions (cpp_reader* dfile ATTRIBUTE_UNUSED ) 611{ 612 tree x; 613 if (c_lex (&x) != CPP_EOF) 614 warning ("junk at end of #pragma GCC java_exceptions"); 615 616 choose_personality_routine (lang_java); 617} 618 619/* Issue an error message indicating that the lookup of NAME (an 620 IDENTIFIER_NODE) failed. Returns the ERROR_MARK_NODE. */ 621 622tree 623unqualified_name_lookup_error (tree name) 624{ 625 if (IDENTIFIER_OPNAME_P (name)) 626 { 627 if (name != ansi_opname (ERROR_MARK)) 628 error ("`%D' not defined", name); 629 } 630 else if (current_function_decl == 0) 631 error ("`%D' was not declared in this scope", name); 632 else 633 { 634 if (IDENTIFIER_NAMESPACE_VALUE (name) != error_mark_node 635 || IDENTIFIER_ERROR_LOCUS (name) != current_function_decl) 636 { 637 static int undeclared_variable_notice; 638 639 error ("`%D' undeclared (first use this function)", name); 640 641 if (! undeclared_variable_notice) 642 { 643 error ("(Each undeclared identifier is reported only once for each function it appears in.)"); 644 undeclared_variable_notice = 1; 645 } 646 } 647 /* Prevent repeated error messages. */ 648 SET_IDENTIFIER_NAMESPACE_VALUE (name, error_mark_node); 649 SET_IDENTIFIER_ERROR_LOCUS (name, current_function_decl); 650 } 651 652 return error_mark_node; 653} 654 655/* Like unqualified_name_lookup_error, but NAME is an unqualified-id 656 used as a function. Returns an appropriate expression for 657 NAME. */ 658 659tree 660unqualified_fn_lookup_error (tree name) 661{ 662 if (processing_template_decl) 663 { 664 /* In a template, it is invalid to write "f()" or "f(3)" if no 665 declaration of "f" is available. Historically, G++ and most 666 other compilers accepted that usage since they deferred all name 667 lookup until instantiation time rather than doing unqualified 668 name lookup at template definition time; explain to the user what 669 is going wrong. 670 671 Note that we have the exact wording of the following message in 672 the manual (trouble.texi, node "Name lookup"), so they need to 673 be kept in synch. */ 674 pedwarn ("there are no arguments to `%D' that depend on a template " 675 "parameter, so a declaration of `%D' must be available", 676 name, name); 677 678 if (!flag_permissive) 679 { 680 static bool hint; 681 if (!hint) 682 { 683 error ("(if you use `-fpermissive', G++ will accept your code, " 684 "but allowing the use of an undeclared name is " 685 "deprecated)"); 686 hint = true; 687 } 688 } 689 return name; 690 } 691 692 return unqualified_name_lookup_error (name); 693} 694 695tree 696build_lang_decl (enum tree_code code, tree name, tree type) 697{ 698 tree t; 699 700 t = build_decl (code, name, type); 701 retrofit_lang_decl (t); 702 703 return t; 704} 705 706/* Add DECL_LANG_SPECIFIC info to T. Called from build_lang_decl 707 and pushdecl (for functions generated by the backend). */ 708 709void 710retrofit_lang_decl (tree t) 711{ 712 struct lang_decl *ld; 713 size_t size; 714 715 if (CAN_HAVE_FULL_LANG_DECL_P (t)) 716 size = sizeof (struct lang_decl); 717 else 718 size = sizeof (struct lang_decl_flags); 719 720 ld = ggc_alloc_cleared (size); 721 722 ld->decl_flags.can_be_full = CAN_HAVE_FULL_LANG_DECL_P (t) ? 1 : 0; 723 ld->decl_flags.u1sel = TREE_CODE (t) == NAMESPACE_DECL ? 1 : 0; 724 ld->decl_flags.u2sel = 0; 725 if (ld->decl_flags.can_be_full) 726 ld->u.f.u3sel = TREE_CODE (t) == FUNCTION_DECL ? 1 : 0; 727 728 DECL_LANG_SPECIFIC (t) = ld; 729 if (current_lang_name == lang_name_cplusplus 730 || decl_linkage (t) == lk_none) 731 SET_DECL_LANGUAGE (t, lang_cplusplus); 732 else if (current_lang_name == lang_name_c) 733 SET_DECL_LANGUAGE (t, lang_c); 734 else if (current_lang_name == lang_name_java) 735 SET_DECL_LANGUAGE (t, lang_java); 736 else abort (); 737 738#ifdef GATHER_STATISTICS 739 tree_node_counts[(int)lang_decl] += 1; 740 tree_node_sizes[(int)lang_decl] += size; 741#endif 742} 743 744void 745cxx_dup_lang_specific_decl (tree node) 746{ 747 int size; 748 struct lang_decl *ld; 749 750 if (! DECL_LANG_SPECIFIC (node)) 751 return; 752 753 if (!CAN_HAVE_FULL_LANG_DECL_P (node)) 754 size = sizeof (struct lang_decl_flags); 755 else 756 size = sizeof (struct lang_decl); 757 ld = ggc_alloc (size); 758 memcpy (ld, DECL_LANG_SPECIFIC (node), size); 759 DECL_LANG_SPECIFIC (node) = ld; 760 761#ifdef GATHER_STATISTICS 762 tree_node_counts[(int)lang_decl] += 1; 763 tree_node_sizes[(int)lang_decl] += size; 764#endif 765} 766 767/* Copy DECL, including any language-specific parts. */ 768 769tree 770copy_decl (tree decl) 771{ 772 tree copy; 773 774 copy = copy_node (decl); 775 cxx_dup_lang_specific_decl (copy); 776 return copy; 777} 778 779/* Replace the shared language-specific parts of NODE with a new copy. */ 780 781static void 782copy_lang_type (tree node) 783{ 784 int size; 785 struct lang_type *lt; 786 787 if (! TYPE_LANG_SPECIFIC (node)) 788 return; 789 790 if (TYPE_LANG_SPECIFIC (node)->u.h.is_lang_type_class) 791 size = sizeof (struct lang_type); 792 else 793 size = sizeof (struct lang_type_ptrmem); 794 lt = ggc_alloc (size); 795 memcpy (lt, TYPE_LANG_SPECIFIC (node), size); 796 TYPE_LANG_SPECIFIC (node) = lt; 797 798#ifdef GATHER_STATISTICS 799 tree_node_counts[(int)lang_type] += 1; 800 tree_node_sizes[(int)lang_type] += size; 801#endif 802} 803 804/* Copy TYPE, including any language-specific parts. */ 805 806tree 807copy_type (tree type) 808{ 809 tree copy; 810 811 copy = copy_node (type); 812 copy_lang_type (copy); 813 return copy; 814} 815 816tree 817cxx_make_type (enum tree_code code) 818{ 819 tree t = make_node (code); 820 821 /* Create lang_type structure. */ 822 if (IS_AGGR_TYPE_CODE (code) 823 || code == BOUND_TEMPLATE_TEMPLATE_PARM) 824 { 825 struct lang_type *pi; 826 827 pi = ggc_alloc_cleared (sizeof (struct lang_type)); 828 829 TYPE_LANG_SPECIFIC (t) = pi; 830 pi->u.c.h.is_lang_type_class = 1; 831 832#ifdef GATHER_STATISTICS 833 tree_node_counts[(int)lang_type] += 1; 834 tree_node_sizes[(int)lang_type] += sizeof (struct lang_type); 835#endif 836 } 837 838 /* Set up some flags that give proper default behavior. */ 839 if (IS_AGGR_TYPE_CODE (code)) 840 { 841 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, interface_unknown); 842 CLASSTYPE_INTERFACE_ONLY (t) = interface_only; 843 844 /* Make sure this is laid out, for ease of use later. In the 845 presence of parse errors, the normal was of assuring this 846 might not ever get executed, so we lay it out *immediately*. */ 847 build_pointer_type (t); 848 } 849 else 850 /* We use TYPE_ALIAS_SET for the CLASSTYPE_MARKED bits. But, 851 TYPE_ALIAS_SET is initialized to -1 by default, so we must 852 clear it here. */ 853 TYPE_ALIAS_SET (t) = 0; 854 855 /* We need to allocate a TYPE_BINFO even for TEMPLATE_TYPE_PARMs 856 since they can be virtual base types, and we then need a 857 canonical binfo for them. Ideally, this would be done lazily for 858 all types. */ 859 if (IS_AGGR_TYPE_CODE (code) || code == TEMPLATE_TYPE_PARM 860 || code == BOUND_TEMPLATE_TEMPLATE_PARM 861 || code == TYPENAME_TYPE) 862 TYPE_BINFO (t) = make_binfo (size_zero_node, t, NULL_TREE, NULL_TREE); 863 864 return t; 865} 866 867tree 868make_aggr_type (enum tree_code code) 869{ 870 tree t = cxx_make_type (code); 871 872 if (IS_AGGR_TYPE_CODE (code)) 873 SET_IS_AGGR_TYPE (t, 1); 874 875 return t; 876} 877 878/* Return the type-qualifier corresponding to the identifier given by 879 RID. */ 880 881int 882cp_type_qual_from_rid (tree rid) 883{ 884 if (rid == ridpointers[(int) RID_CONST]) 885 return TYPE_QUAL_CONST; 886 else if (rid == ridpointers[(int) RID_VOLATILE]) 887 return TYPE_QUAL_VOLATILE; 888 else if (rid == ridpointers[(int) RID_RESTRICT]) 889 return TYPE_QUAL_RESTRICT; 890 891 abort (); 892 return TYPE_UNQUALIFIED; 893} 894