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, 2005 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, 51 Franklin Street, Fifth Floor, 21Boston, MA 02110-1301, 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 "flags.h" 35#include "c-pragma.h" 36#include "toplev.h" 37#include "output.h" 38#include "tm_p.h" 39#include "timevar.h" 40 41static int interface_strcmp (const char *); 42static void init_cp_pragma (void); 43 44static tree parse_strconst_pragma (const char *, int); 45static void handle_pragma_vtable (cpp_reader *); 46static void handle_pragma_unit (cpp_reader *); 47static void handle_pragma_interface (cpp_reader *); 48static void handle_pragma_implementation (cpp_reader *); 49static void handle_pragma_java_exceptions (cpp_reader *); 50 51static void init_operators (void); 52static void copy_lang_type (tree); 53 54/* A constraint that can be tested at compile time. */ 55#define CONSTRAINT(name, expr) extern int constraint_##name [(expr) ? 1 : -1] 56 57/* Functions and data structures for #pragma interface. 58 59 `#pragma implementation' means that the main file being compiled 60 is considered to implement (provide) the classes that appear in 61 its main body. I.e., if this is file "foo.cc", and class `bar' 62 is defined in "foo.cc", then we say that "foo.cc implements bar". 63 64 All main input files "implement" themselves automagically. 65 66 `#pragma interface' means that unless this file (of the form "foo.h" 67 is not presently being included by file "foo.cc", the 68 CLASSTYPE_INTERFACE_ONLY bit gets set. The effect is that none 69 of the vtables nor any of the inline functions defined in foo.h 70 will ever be output. 71 72 There are cases when we want to link files such as "defs.h" and 73 "main.cc". In this case, we give "defs.h" a `#pragma interface', 74 and "main.cc" has `#pragma implementation "defs.h"'. */ 75 76struct impl_files 77{ 78 const char *filename; 79 struct impl_files *next; 80}; 81 82static struct impl_files *impl_file_chain; 83 84 85void 86cxx_finish (void) 87{ 88 c_common_finish (); 89} 90 91/* A mapping from tree codes to operator name information. */ 92operator_name_info_t operator_name_info[(int) LAST_CPLUS_TREE_CODE]; 93/* Similar, but for assignment operators. */ 94operator_name_info_t assignment_operator_name_info[(int) LAST_CPLUS_TREE_CODE]; 95 96/* Initialize data structures that keep track of operator names. */ 97 98#define DEF_OPERATOR(NAME, C, M, AR, AP) \ 99 CONSTRAINT (C, sizeof "operator " + sizeof NAME <= 256); 100#include "operators.def" 101#undef DEF_OPERATOR 102 103static void 104init_operators (void) 105{ 106 tree identifier; 107 char buffer[256]; 108 struct operator_name_info_t *oni; 109 110#define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \ 111 sprintf (buffer, ISALPHA (NAME[0]) ? "operator %s" : "operator%s", NAME); \ 112 identifier = get_identifier (buffer); \ 113 IDENTIFIER_OPNAME_P (identifier) = 1; \ 114 \ 115 oni = (ASSN_P \ 116 ? &assignment_operator_name_info[(int) CODE] \ 117 : &operator_name_info[(int) CODE]); \ 118 oni->identifier = identifier; \ 119 oni->name = NAME; \ 120 oni->mangled_name = MANGLING; \ 121 oni->arity = ARITY; 122 123#include "operators.def" 124#undef DEF_OPERATOR 125 126 operator_name_info[(int) ERROR_MARK].identifier 127 = get_identifier ("<invalid operator>"); 128 129 /* Handle some special cases. These operators are not defined in 130 the language, but can be produced internally. We may need them 131 for error-reporting. (Eventually, we should ensure that this 132 does not happen. Error messages involving these operators will 133 be confusing to users.) */ 134 135 operator_name_info [(int) INIT_EXPR].name 136 = operator_name_info [(int) MODIFY_EXPR].name; 137 operator_name_info [(int) EXACT_DIV_EXPR].name = "(ceiling /)"; 138 operator_name_info [(int) CEIL_DIV_EXPR].name = "(ceiling /)"; 139 operator_name_info [(int) FLOOR_DIV_EXPR].name = "(floor /)"; 140 operator_name_info [(int) ROUND_DIV_EXPR].name = "(round /)"; 141 operator_name_info [(int) CEIL_MOD_EXPR].name = "(ceiling %)"; 142 operator_name_info [(int) FLOOR_MOD_EXPR].name = "(floor %)"; 143 operator_name_info [(int) ROUND_MOD_EXPR].name = "(round %)"; 144 operator_name_info [(int) ABS_EXPR].name = "abs"; 145 operator_name_info [(int) TRUTH_AND_EXPR].name = "strict &&"; 146 operator_name_info [(int) TRUTH_OR_EXPR].name = "strict ||"; 147 operator_name_info [(int) RANGE_EXPR].name = "..."; 148 operator_name_info [(int) UNARY_PLUS_EXPR].name = "+"; 149 150 assignment_operator_name_info [(int) EXACT_DIV_EXPR].name 151 = "(exact /=)"; 152 assignment_operator_name_info [(int) CEIL_DIV_EXPR].name 153 = "(ceiling /=)"; 154 assignment_operator_name_info [(int) FLOOR_DIV_EXPR].name 155 = "(floor /=)"; 156 assignment_operator_name_info [(int) ROUND_DIV_EXPR].name 157 = "(round /=)"; 158 assignment_operator_name_info [(int) CEIL_MOD_EXPR].name 159 = "(ceiling %=)"; 160 assignment_operator_name_info [(int) FLOOR_MOD_EXPR].name 161 = "(floor %=)"; 162 assignment_operator_name_info [(int) ROUND_MOD_EXPR].name 163 = "(round %=)"; 164} 165 166/* The reserved keyword table. */ 167struct resword 168{ 169 const char *const word; 170 ENUM_BITFIELD(rid) const rid : 16; 171 const unsigned int disable : 16; 172}; 173 174/* Disable mask. Keywords are disabled if (reswords[i].disable & mask) is 175 _true_. */ 176#define D_EXT 0x01 /* GCC extension */ 177#define D_ASM 0x02 /* in C99, but has a switch to turn it off */ 178#define D_OBJC 0x04 /* Objective C++ only */ 179 180CONSTRAINT(ridbits_fit, RID_LAST_MODIFIER < sizeof(unsigned long) * CHAR_BIT); 181 182static const struct resword reswords[] = 183{ 184 { "_Complex", RID_COMPLEX, 0 }, 185 { "__FUNCTION__", RID_FUNCTION_NAME, 0 }, 186 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 }, 187 { "__alignof", RID_ALIGNOF, 0 }, 188 { "__alignof__", RID_ALIGNOF, 0 }, 189 { "__asm", RID_ASM, 0 }, 190 { "__asm__", RID_ASM, 0 }, 191 { "__attribute", RID_ATTRIBUTE, 0 }, 192 { "__attribute__", RID_ATTRIBUTE, 0 }, 193 { "__builtin_offsetof", RID_OFFSETOF, 0 }, 194 { "__builtin_va_arg", RID_VA_ARG, 0 }, 195 { "__complex", RID_COMPLEX, 0 }, 196 { "__complex__", RID_COMPLEX, 0 }, 197 { "__const", RID_CONST, 0 }, 198 { "__const__", RID_CONST, 0 }, 199 { "__extension__", RID_EXTENSION, 0 }, 200 { "__func__", RID_C99_FUNCTION_NAME, 0 }, 201 { "__imag", RID_IMAGPART, 0 }, 202 { "__imag__", RID_IMAGPART, 0 }, 203 { "__inline", RID_INLINE, 0 }, 204 { "__inline__", RID_INLINE, 0 }, 205 { "__label__", RID_LABEL, 0 }, 206 { "__null", RID_NULL, 0 }, 207 { "__real", RID_REALPART, 0 }, 208 { "__real__", RID_REALPART, 0 }, 209 { "__restrict", RID_RESTRICT, 0 }, 210 { "__restrict__", RID_RESTRICT, 0 }, 211 { "__signed", RID_SIGNED, 0 }, 212 { "__signed__", RID_SIGNED, 0 }, 213 { "__thread", RID_THREAD, 0 }, 214 { "__typeof", RID_TYPEOF, 0 }, 215 { "__typeof__", RID_TYPEOF, 0 }, 216 { "__volatile", RID_VOLATILE, 0 }, 217 { "__volatile__", RID_VOLATILE, 0 }, 218 { "asm", RID_ASM, D_ASM }, 219 { "auto", RID_AUTO, 0 }, 220 { "bool", RID_BOOL, 0 }, 221 { "break", RID_BREAK, 0 }, 222 { "case", RID_CASE, 0 }, 223 { "catch", RID_CATCH, 0 }, 224 { "char", RID_CHAR, 0 }, 225 { "class", RID_CLASS, 0 }, 226 { "const", RID_CONST, 0 }, 227 { "const_cast", RID_CONSTCAST, 0 }, 228 { "continue", RID_CONTINUE, 0 }, 229 { "default", RID_DEFAULT, 0 }, 230 { "delete", RID_DELETE, 0 }, 231 { "do", RID_DO, 0 }, 232 { "double", RID_DOUBLE, 0 }, 233 { "dynamic_cast", RID_DYNCAST, 0 }, 234 { "else", RID_ELSE, 0 }, 235 { "enum", RID_ENUM, 0 }, 236 { "explicit", RID_EXPLICIT, 0 }, 237 { "export", RID_EXPORT, 0 }, 238 { "extern", RID_EXTERN, 0 }, 239 { "false", RID_FALSE, 0 }, 240 { "float", RID_FLOAT, 0 }, 241 { "for", RID_FOR, 0 }, 242 { "friend", RID_FRIEND, 0 }, 243 { "goto", RID_GOTO, 0 }, 244 { "if", RID_IF, 0 }, 245 { "inline", RID_INLINE, 0 }, 246 { "int", RID_INT, 0 }, 247 { "long", RID_LONG, 0 }, 248 { "mutable", RID_MUTABLE, 0 }, 249 { "namespace", RID_NAMESPACE, 0 }, 250 { "new", RID_NEW, 0 }, 251 { "operator", RID_OPERATOR, 0 }, 252 { "private", RID_PRIVATE, 0 }, 253 { "protected", RID_PROTECTED, 0 }, 254 { "public", RID_PUBLIC, 0 }, 255 { "register", RID_REGISTER, 0 }, 256 { "reinterpret_cast", RID_REINTCAST, 0 }, 257 { "return", RID_RETURN, 0 }, 258 { "short", RID_SHORT, 0 }, 259 { "signed", RID_SIGNED, 0 }, 260 { "sizeof", RID_SIZEOF, 0 }, 261 { "static", RID_STATIC, 0 }, 262 { "static_cast", RID_STATCAST, 0 }, 263 { "struct", RID_STRUCT, 0 }, 264 { "switch", RID_SWITCH, 0 }, 265 { "template", RID_TEMPLATE, 0 }, 266 { "this", RID_THIS, 0 }, 267 { "throw", RID_THROW, 0 }, 268 { "true", RID_TRUE, 0 }, 269 { "try", RID_TRY, 0 }, 270 { "typedef", RID_TYPEDEF, 0 }, 271 { "typename", RID_TYPENAME, 0 }, 272 { "typeid", RID_TYPEID, 0 }, 273 { "typeof", RID_TYPEOF, D_ASM|D_EXT }, 274 { "union", RID_UNION, 0 }, 275 { "unsigned", RID_UNSIGNED, 0 }, 276 { "using", RID_USING, 0 }, 277 { "virtual", RID_VIRTUAL, 0 }, 278 { "void", RID_VOID, 0 }, 279 { "volatile", RID_VOLATILE, 0 }, 280 { "wchar_t", RID_WCHAR, 0 }, 281 { "while", RID_WHILE, 0 }, 282 283 /* The remaining keywords are specific to Objective-C++. NB: 284 All of them will remain _disabled_, since they are context- 285 sensitive. */ 286 287 /* These ObjC keywords are recognized only immediately after 288 an '@'. NB: The following C++ keywords double as 289 ObjC keywords in this context: RID_CLASS, RID_PRIVATE, 290 RID_PROTECTED, RID_PUBLIC, RID_THROW, RID_TRY and RID_CATCH. */ 291 { "compatibility_alias", RID_AT_ALIAS, D_OBJC }, 292 { "defs", RID_AT_DEFS, D_OBJC }, 293 { "encode", RID_AT_ENCODE, D_OBJC }, 294 { "end", RID_AT_END, D_OBJC }, 295 { "implementation", RID_AT_IMPLEMENTATION, D_OBJC }, 296 { "interface", RID_AT_INTERFACE, D_OBJC }, 297 { "protocol", RID_AT_PROTOCOL, D_OBJC }, 298 { "selector", RID_AT_SELECTOR, D_OBJC }, 299 { "finally", RID_AT_FINALLY, D_OBJC }, 300 { "synchronized", RID_AT_SYNCHRONIZED, D_OBJC }, 301 /* These are recognized only in protocol-qualifier context. */ 302 { "bycopy", RID_BYCOPY, D_OBJC }, 303 { "byref", RID_BYREF, D_OBJC }, 304 { "in", RID_IN, D_OBJC }, 305 { "inout", RID_INOUT, D_OBJC }, 306 { "oneway", RID_ONEWAY, D_OBJC }, 307 { "out", RID_OUT, D_OBJC }, 308}; 309 310void 311init_reswords (void) 312{ 313 unsigned int i; 314 tree id; 315 int mask = ((flag_no_asm ? D_ASM : 0) 316 | D_OBJC 317 | (flag_no_gnu_keywords ? D_EXT : 0)); 318 319 ridpointers = ggc_calloc ((int) RID_MAX, sizeof (tree)); 320 for (i = 0; i < ARRAY_SIZE (reswords); i++) 321 { 322 id = get_identifier (reswords[i].word); 323 C_RID_CODE (id) = reswords[i].rid; 324 ridpointers [(int) reswords[i].rid] = id; 325 if (! (reswords[i].disable & mask)) 326 C_IS_RESERVED_WORD (id) = 1; 327 } 328} 329 330static void 331init_cp_pragma (void) 332{ 333 c_register_pragma (0, "vtable", handle_pragma_vtable); 334 c_register_pragma (0, "unit", handle_pragma_unit); 335 c_register_pragma (0, "interface", handle_pragma_interface); 336 c_register_pragma (0, "implementation", handle_pragma_implementation); 337 c_register_pragma ("GCC", "interface", handle_pragma_interface); 338 c_register_pragma ("GCC", "implementation", handle_pragma_implementation); 339 c_register_pragma ("GCC", "java_exceptions", handle_pragma_java_exceptions); 340} 341 342/* TRUE if a code represents a statement. */ 343 344bool statement_code_p[MAX_TREE_CODES]; 345 346/* Initialize the C++ front end. This function is very sensitive to 347 the exact order that things are done here. It would be nice if the 348 initialization done by this routine were moved to its subroutines, 349 and the ordering dependencies clarified and reduced. */ 350bool 351cxx_init (void) 352{ 353 unsigned int i; 354 static const enum tree_code stmt_codes[] = { 355 CTOR_INITIALIZER, TRY_BLOCK, HANDLER, 356 EH_SPEC_BLOCK, USING_STMT, TAG_DEFN, 357 IF_STMT, CLEANUP_STMT, FOR_STMT, 358 WHILE_STMT, DO_STMT, BREAK_STMT, 359 CONTINUE_STMT, SWITCH_STMT, EXPR_STMT 360 }; 361 362 memset (&statement_code_p, 0, sizeof (statement_code_p)); 363 for (i = 0; i < ARRAY_SIZE (stmt_codes); i++) 364 statement_code_p[stmt_codes[i]] = true; 365 366 /* We cannot just assign to input_filename because it has already 367 been initialized and will be used later as an N_BINCL for stabs+ 368 debugging. */ 369#ifdef USE_MAPPED_LOCATION 370 push_srcloc (BUILTINS_LOCATION); 371#else 372 push_srcloc ("<built-in>", 0); 373#endif 374 375 init_reswords (); 376 init_tree (); 377 init_cp_semantics (); 378 init_operators (); 379 init_method (); 380 init_error (); 381 382 current_function_decl = NULL; 383 384 class_type_node = ridpointers[(int) RID_CLASS]; 385 386 cxx_init_decl_processing (); 387 388 /* The fact that G++ uses COMDAT for many entities (inline 389 functions, template instantiations, virtual tables, etc.) mean 390 that it is fundamentally unreliable to try to make decisions 391 about whether or not to output a particular entity until the end 392 of the compilation. However, the inliner requires that functions 393 be provided to the back end if they are to be inlined. 394 Therefore, we always use unit-at-a-time mode; in that mode, we 395 can provide entities to the back end and it will decide what to 396 emit based on what is actually needed. */ 397 flag_unit_at_a_time = 1; 398 399 if (c_common_init () == false) 400 { 401 pop_srcloc(); 402 return false; 403 } 404 405 init_cp_pragma (); 406 407 init_repo (); 408 409 pop_srcloc(); 410 return true; 411} 412 413/* Return nonzero if S is not considered part of an 414 INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */ 415 416static int 417interface_strcmp (const char* s) 418{ 419 /* Set the interface/implementation bits for this scope. */ 420 struct impl_files *ifiles; 421 const char *s1; 422 423 for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next) 424 { 425 const char *t1 = ifiles->filename; 426 s1 = s; 427 428 if (*s1 != *t1 || *s1 == 0) 429 continue; 430 431 while (*s1 == *t1 && *s1 != 0) 432 s1++, t1++; 433 434 /* A match. */ 435 if (*s1 == *t1) 436 return 0; 437 438 /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */ 439 if (strchr (s1, '.') || strchr (t1, '.')) 440 continue; 441 442 if (*s1 == '\0' || s1[-1] != '.' || t1[-1] != '.') 443 continue; 444 445 /* A match. */ 446 return 0; 447 } 448 449 /* No matches. */ 450 return 1; 451} 452 453 454 455/* Parse a #pragma whose sole argument is a string constant. 456 If OPT is true, the argument is optional. */ 457static tree 458parse_strconst_pragma (const char* name, int opt) 459{ 460 tree result, x; 461 enum cpp_ttype t; 462 463 t = c_lex (&x); 464 if (t == CPP_STRING) 465 { 466 result = x; 467 if (c_lex (&x) != CPP_EOF) 468 warning (0, "junk at end of #pragma %s", name); 469 return result; 470 } 471 472 if (t == CPP_EOF && opt) 473 return 0; 474 475 error ("invalid #pragma %s", name); 476 return (tree)-1; 477} 478 479static void 480handle_pragma_vtable (cpp_reader* dfile ATTRIBUTE_UNUSED ) 481{ 482 parse_strconst_pragma ("vtable", 0); 483 sorry ("#pragma vtable no longer supported"); 484} 485 486static void 487handle_pragma_unit (cpp_reader* dfile ATTRIBUTE_UNUSED ) 488{ 489 /* Validate syntax, but don't do anything. */ 490 parse_strconst_pragma ("unit", 0); 491} 492 493static void 494handle_pragma_interface (cpp_reader* dfile ATTRIBUTE_UNUSED ) 495{ 496 tree fname = parse_strconst_pragma ("interface", 1); 497 struct c_fileinfo *finfo; 498 const char *filename; 499 500 if (fname == (tree)-1) 501 return; 502 else if (fname == 0) 503 filename = lbasename (input_filename); 504 else 505 filename = ggc_strdup (TREE_STRING_POINTER (fname)); 506 507 finfo = get_fileinfo (input_filename); 508 509 if (impl_file_chain == 0) 510 { 511 /* If this is zero at this point, then we are 512 auto-implementing. */ 513 if (main_input_filename == 0) 514 main_input_filename = input_filename; 515 } 516 517 finfo->interface_only = interface_strcmp (filename); 518 /* If MULTIPLE_SYMBOL_SPACES is set, we cannot assume that we can see 519 a definition in another file. */ 520 if (!MULTIPLE_SYMBOL_SPACES || !finfo->interface_only) 521 finfo->interface_unknown = 0; 522} 523 524/* Note that we have seen a #pragma implementation for the key MAIN_FILENAME. 525 We used to only allow this at toplevel, but that restriction was buggy 526 in older compilers and it seems reasonable to allow it in the headers 527 themselves, too. It only needs to precede the matching #p interface. 528 529 We don't touch finfo->interface_only or finfo->interface_unknown; 530 the user must specify a matching #p interface for this to have 531 any effect. */ 532 533static void 534handle_pragma_implementation (cpp_reader* dfile ATTRIBUTE_UNUSED ) 535{ 536 tree fname = parse_strconst_pragma ("implementation", 1); 537 const char *filename; 538 struct impl_files *ifiles = impl_file_chain; 539 540 if (fname == (tree)-1) 541 return; 542 543 if (fname == 0) 544 { 545 if (main_input_filename) 546 filename = main_input_filename; 547 else 548 filename = input_filename; 549 filename = lbasename (filename); 550 } 551 else 552 { 553 filename = ggc_strdup (TREE_STRING_POINTER (fname)); 554#if 0 555 /* We currently cannot give this diagnostic, as we reach this point 556 only after cpplib has scanned the entire translation unit, so 557 cpp_included always returns true. A plausible fix is to compare 558 the current source-location cookie with the first source-location 559 cookie (if any) of the filename, but this requires completing the 560 --enable-mapped-location project first. See PR 17577. */ 561 if (cpp_included (parse_in, filename)) 562 warning (0, "#pragma implementation for %qs appears after " 563 "file is included", filename); 564#endif 565 } 566 567 for (; ifiles; ifiles = ifiles->next) 568 { 569 if (! strcmp (ifiles->filename, filename)) 570 break; 571 } 572 if (ifiles == 0) 573 { 574 ifiles = xmalloc (sizeof (struct impl_files)); 575 ifiles->filename = filename; 576 ifiles->next = impl_file_chain; 577 impl_file_chain = ifiles; 578 } 579} 580 581/* Indicate that this file uses Java-personality exception handling. */ 582static void 583handle_pragma_java_exceptions (cpp_reader* dfile ATTRIBUTE_UNUSED ) 584{ 585 tree x; 586 if (c_lex (&x) != CPP_EOF) 587 warning (0, "junk at end of #pragma GCC java_exceptions"); 588 589 choose_personality_routine (lang_java); 590} 591 592/* Issue an error message indicating that the lookup of NAME (an 593 IDENTIFIER_NODE) failed. Returns the ERROR_MARK_NODE. */ 594 595tree 596unqualified_name_lookup_error (tree name) 597{ 598 if (IDENTIFIER_OPNAME_P (name)) 599 { 600 if (name != ansi_opname (ERROR_MARK)) 601 error ("%qD not defined", name); 602 } 603 else 604 { 605 error ("%qD was not declared in this scope", name); 606 /* Prevent repeated error messages by creating a VAR_DECL with 607 this NAME in the innermost block scope. */ 608 if (current_function_decl) 609 { 610 tree decl; 611 decl = build_decl (VAR_DECL, name, error_mark_node); 612 DECL_CONTEXT (decl) = current_function_decl; 613 push_local_binding (name, decl, 0); 614 /* Mark the variable as used so that we do not get warnings 615 about it being unused later. */ 616 TREE_USED (decl) = 1; 617 } 618 } 619 620 return error_mark_node; 621} 622 623/* Like unqualified_name_lookup_error, but NAME is an unqualified-id 624 used as a function. Returns an appropriate expression for 625 NAME. */ 626 627tree 628unqualified_fn_lookup_error (tree name) 629{ 630 if (processing_template_decl) 631 { 632 /* In a template, it is invalid to write "f()" or "f(3)" if no 633 declaration of "f" is available. Historically, G++ and most 634 other compilers accepted that usage since they deferred all name 635 lookup until instantiation time rather than doing unqualified 636 name lookup at template definition time; explain to the user what 637 is going wrong. 638 639 Note that we have the exact wording of the following message in 640 the manual (trouble.texi, node "Name lookup"), so they need to 641 be kept in synch. */ 642 pedwarn ("there are no arguments to %qD that depend on a template " 643 "parameter, so a declaration of %qD must be available", 644 name, name); 645 646 if (!flag_permissive) 647 { 648 static bool hint; 649 if (!hint) 650 { 651 error ("(if you use %<-fpermissive%>, G++ will accept your " 652 "code, but allowing the use of an undeclared name is " 653 "deprecated)"); 654 hint = true; 655 } 656 } 657 return name; 658 } 659 660 return unqualified_name_lookup_error (name); 661} 662 663tree 664build_lang_decl (enum tree_code code, tree name, tree type) 665{ 666 tree t; 667 668 t = build_decl (code, name, type); 669 retrofit_lang_decl (t); 670 671 /* All nesting of C++ functions is lexical; there is never a "static 672 chain" in the sense of GNU C nested functions. */ 673 if (code == FUNCTION_DECL) 674 DECL_NO_STATIC_CHAIN (t) = 1; 675 676 return t; 677} 678 679/* Add DECL_LANG_SPECIFIC info to T. Called from build_lang_decl 680 and pushdecl (for functions generated by the backend). */ 681 682void 683retrofit_lang_decl (tree t) 684{ 685 struct lang_decl *ld; 686 size_t size; 687 688 if (CAN_HAVE_FULL_LANG_DECL_P (t)) 689 size = sizeof (struct lang_decl); 690 else 691 size = sizeof (struct lang_decl_flags); 692 693 ld = GGC_CNEWVAR (struct lang_decl, size); 694 695 ld->decl_flags.can_be_full = CAN_HAVE_FULL_LANG_DECL_P (t) ? 1 : 0; 696 ld->decl_flags.u1sel = TREE_CODE (t) == NAMESPACE_DECL ? 1 : 0; 697 ld->decl_flags.u2sel = 0; 698 if (ld->decl_flags.can_be_full) 699 ld->u.f.u3sel = TREE_CODE (t) == FUNCTION_DECL ? 1 : 0; 700 701 DECL_LANG_SPECIFIC (t) = ld; 702 if (current_lang_name == lang_name_cplusplus 703 || decl_linkage (t) == lk_none) 704 SET_DECL_LANGUAGE (t, lang_cplusplus); 705 else if (current_lang_name == lang_name_c) 706 SET_DECL_LANGUAGE (t, lang_c); 707 else if (current_lang_name == lang_name_java) 708 SET_DECL_LANGUAGE (t, lang_java); 709 else 710 gcc_unreachable (); 711 712#ifdef GATHER_STATISTICS 713 tree_node_counts[(int)lang_decl] += 1; 714 tree_node_sizes[(int)lang_decl] += size; 715#endif 716} 717 718void 719cxx_dup_lang_specific_decl (tree node) 720{ 721 int size; 722 struct lang_decl *ld; 723 724 if (! DECL_LANG_SPECIFIC (node)) 725 return; 726 727 if (!CAN_HAVE_FULL_LANG_DECL_P (node)) 728 size = sizeof (struct lang_decl_flags); 729 else 730 size = sizeof (struct lang_decl); 731 ld = GGC_NEWVAR (struct lang_decl, size); 732 memcpy (ld, DECL_LANG_SPECIFIC (node), size); 733 DECL_LANG_SPECIFIC (node) = ld; 734 735#ifdef GATHER_STATISTICS 736 tree_node_counts[(int)lang_decl] += 1; 737 tree_node_sizes[(int)lang_decl] += size; 738#endif 739} 740 741/* Copy DECL, including any language-specific parts. */ 742 743tree 744copy_decl (tree decl) 745{ 746 tree copy; 747 748 copy = copy_node (decl); 749 cxx_dup_lang_specific_decl (copy); 750 return copy; 751} 752 753/* Replace the shared language-specific parts of NODE with a new copy. */ 754 755static void 756copy_lang_type (tree node) 757{ 758 int size; 759 struct lang_type *lt; 760 761 if (! TYPE_LANG_SPECIFIC (node)) 762 return; 763 764 if (TYPE_LANG_SPECIFIC (node)->u.h.is_lang_type_class) 765 size = sizeof (struct lang_type); 766 else 767 size = sizeof (struct lang_type_ptrmem); 768 lt = GGC_NEWVAR (struct lang_type, size); 769 memcpy (lt, TYPE_LANG_SPECIFIC (node), size); 770 TYPE_LANG_SPECIFIC (node) = lt; 771 772#ifdef GATHER_STATISTICS 773 tree_node_counts[(int)lang_type] += 1; 774 tree_node_sizes[(int)lang_type] += size; 775#endif 776} 777 778/* Copy TYPE, including any language-specific parts. */ 779 780tree 781copy_type (tree type) 782{ 783 tree copy; 784 785 copy = copy_node (type); 786 copy_lang_type (copy); 787 return copy; 788} 789 790tree 791cxx_make_type (enum tree_code code) 792{ 793 tree t = make_node (code); 794 795 /* Create lang_type structure. */ 796 if (IS_AGGR_TYPE_CODE (code) 797 || code == BOUND_TEMPLATE_TEMPLATE_PARM) 798 { 799 struct lang_type *pi = GGC_CNEW (struct lang_type); 800 801 TYPE_LANG_SPECIFIC (t) = pi; 802 pi->u.c.h.is_lang_type_class = 1; 803 804#ifdef GATHER_STATISTICS 805 tree_node_counts[(int)lang_type] += 1; 806 tree_node_sizes[(int)lang_type] += sizeof (struct lang_type); 807#endif 808 } 809 810 /* Set up some flags that give proper default behavior. */ 811 if (IS_AGGR_TYPE_CODE (code)) 812 { 813 struct c_fileinfo *finfo = get_fileinfo (input_filename); 814 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, finfo->interface_unknown); 815 CLASSTYPE_INTERFACE_ONLY (t) = finfo->interface_only; 816 } 817 818 return t; 819} 820 821tree 822make_aggr_type (enum tree_code code) 823{ 824 tree t = cxx_make_type (code); 825 826 if (IS_AGGR_TYPE_CODE (code)) 827 SET_IS_AGGR_TYPE (t, 1); 828 829 return t; 830} 831