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, 2007, 2008 4 Free Software Foundation, Inc. 5 Hacked by Michael Tiemann (tiemann@cygnus.com) 6 7 This file is part of GCC. 8 9 GCC is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3, or (at your option) 12 any later version. 13 14 GCC is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with GCC; see the file COPYING3. If not see 21 <http://www.gnu.org/licenses/>. */ 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 41 static int interface_strcmp (const char *); 42 static void init_cp_pragma (void); 43 44 static tree parse_strconst_pragma (const char *, int); 45 static void handle_pragma_vtable (cpp_reader *); 46 static void handle_pragma_unit (cpp_reader *); 47 static void handle_pragma_interface (cpp_reader *); 48 static void handle_pragma_implementation (cpp_reader *); 49 static void handle_pragma_java_exceptions (cpp_reader *); 50 51 static void init_operators (void); 52 static 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 76 struct impl_files 77 { 78 const char *filename; 79 struct impl_files *next; 80 }; 81 82 static struct impl_files *impl_file_chain; 83 84 /* True if we saw "#pragma GCC java_exceptions". */ 85 bool pragma_java_exceptions; 86 87 void 88 cxx_finish (void) 89 { 90 c_common_finish (); 91 } 92 93 /* A mapping from tree codes to operator name information. */ 94 operator_name_info_t operator_name_info[(int) MAX_TREE_CODES]; 95 /* Similar, but for assignment operators. */ 96 operator_name_info_t assignment_operator_name_info[(int) MAX_TREE_CODES]; 97 98 /* Initialize data structures that keep track of operator names. */ 99 100 #define DEF_OPERATOR(NAME, C, M, AR, AP) \ 101 CONSTRAINT (C, sizeof "operator " + sizeof NAME <= 256); 102 #include "operators.def" 103 #undef DEF_OPERATOR 104 105 static void 106 init_operators (void) 107 { 108 tree identifier; 109 char buffer[256]; 110 struct operator_name_info_t *oni; 111 112 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \ 113 sprintf (buffer, ISALPHA (NAME[0]) ? "operator %s" : "operator%s", NAME); \ 114 identifier = get_identifier (buffer); \ 115 IDENTIFIER_OPNAME_P (identifier) = 1; \ 116 \ 117 oni = (ASSN_P \ 118 ? &assignment_operator_name_info[(int) CODE] \ 119 : &operator_name_info[(int) CODE]); \ 120 oni->identifier = identifier; \ 121 oni->name = NAME; \ 122 oni->mangled_name = MANGLING; \ 123 oni->arity = ARITY; 124 125 #include "operators.def" 126 #undef DEF_OPERATOR 127 128 operator_name_info[(int) ERROR_MARK].identifier 129 = get_identifier ("<invalid operator>"); 130 131 /* Handle some special cases. These operators are not defined in 132 the language, but can be produced internally. We may need them 133 for error-reporting. (Eventually, we should ensure that this 134 does not happen. Error messages involving these operators will 135 be confusing to users.) */ 136 137 operator_name_info [(int) INIT_EXPR].name 138 = operator_name_info [(int) MODIFY_EXPR].name; 139 operator_name_info [(int) EXACT_DIV_EXPR].name = "(ceiling /)"; 140 operator_name_info [(int) CEIL_DIV_EXPR].name = "(ceiling /)"; 141 operator_name_info [(int) FLOOR_DIV_EXPR].name = "(floor /)"; 142 operator_name_info [(int) ROUND_DIV_EXPR].name = "(round /)"; 143 operator_name_info [(int) CEIL_MOD_EXPR].name = "(ceiling %)"; 144 operator_name_info [(int) FLOOR_MOD_EXPR].name = "(floor %)"; 145 operator_name_info [(int) ROUND_MOD_EXPR].name = "(round %)"; 146 operator_name_info [(int) ABS_EXPR].name = "abs"; 147 operator_name_info [(int) TRUTH_AND_EXPR].name = "strict &&"; 148 operator_name_info [(int) TRUTH_OR_EXPR].name = "strict ||"; 149 operator_name_info [(int) RANGE_EXPR].name = "..."; 150 operator_name_info [(int) UNARY_PLUS_EXPR].name = "+"; 151 152 assignment_operator_name_info [(int) EXACT_DIV_EXPR].name 153 = "(exact /=)"; 154 assignment_operator_name_info [(int) CEIL_DIV_EXPR].name 155 = "(ceiling /=)"; 156 assignment_operator_name_info [(int) FLOOR_DIV_EXPR].name 157 = "(floor /=)"; 158 assignment_operator_name_info [(int) ROUND_DIV_EXPR].name 159 = "(round /=)"; 160 assignment_operator_name_info [(int) CEIL_MOD_EXPR].name 161 = "(ceiling %=)"; 162 assignment_operator_name_info [(int) FLOOR_MOD_EXPR].name 163 = "(floor %=)"; 164 assignment_operator_name_info [(int) ROUND_MOD_EXPR].name 165 = "(round %=)"; 166 } 167 168 /* Initialize the reserved words. */ 169 170 void 171 init_reswords (void) 172 { 173 unsigned int i; 174 tree id; 175 int mask = 0; 176 177 if (cxx_dialect != cxx0x) 178 mask |= D_CXX0X; 179 if (flag_no_asm) 180 mask |= D_ASM | D_EXT; 181 if (flag_no_gnu_keywords) 182 mask |= D_EXT; 183 184 /* The Objective-C keywords are all context-dependent. */ 185 mask |= D_OBJC; 186 187 ridpointers = GGC_CNEWVEC (tree, (int) RID_MAX); 188 for (i = 0; i < num_c_common_reswords; i++) 189 { 190 if (c_common_reswords[i].disable & D_CONLY) 191 continue; 192 id = get_identifier (c_common_reswords[i].word); 193 C_SET_RID_CODE (id, c_common_reswords[i].rid); 194 ridpointers [(int) c_common_reswords[i].rid] = id; 195 if (! (c_common_reswords[i].disable & mask)) 196 C_IS_RESERVED_WORD (id) = 1; 197 } 198 } 199 200 static void 201 init_cp_pragma (void) 202 { 203 c_register_pragma (0, "vtable", handle_pragma_vtable); 204 c_register_pragma (0, "unit", handle_pragma_unit); 205 c_register_pragma (0, "interface", handle_pragma_interface); 206 c_register_pragma (0, "implementation", handle_pragma_implementation); 207 c_register_pragma ("GCC", "interface", handle_pragma_interface); 208 c_register_pragma ("GCC", "implementation", handle_pragma_implementation); 209 c_register_pragma ("GCC", "java_exceptions", handle_pragma_java_exceptions); 210 } 211 212 /* TRUE if a code represents a statement. */ 213 214 bool statement_code_p[MAX_TREE_CODES]; 215 216 /* Initialize the C++ front end. This function is very sensitive to 217 the exact order that things are done here. It would be nice if the 218 initialization done by this routine were moved to its subroutines, 219 and the ordering dependencies clarified and reduced. */ 220 bool 221 cxx_init (void) 222 { 223 location_t saved_loc; 224 unsigned int i; 225 static const enum tree_code stmt_codes[] = { 226 CTOR_INITIALIZER, TRY_BLOCK, HANDLER, 227 EH_SPEC_BLOCK, USING_STMT, TAG_DEFN, 228 IF_STMT, CLEANUP_STMT, FOR_STMT, 229 WHILE_STMT, DO_STMT, BREAK_STMT, 230 CONTINUE_STMT, SWITCH_STMT, EXPR_STMT 231 }; 232 233 memset (&statement_code_p, 0, sizeof (statement_code_p)); 234 for (i = 0; i < ARRAY_SIZE (stmt_codes); i++) 235 statement_code_p[stmt_codes[i]] = true; 236 237 saved_loc = input_location; 238 input_location = BUILTINS_LOCATION; 239 240 init_reswords (); 241 init_tree (); 242 init_cp_semantics (); 243 init_operators (); 244 init_method (); 245 init_error (); 246 247 current_function_decl = NULL; 248 249 class_type_node = ridpointers[(int) RID_CLASS]; 250 251 cxx_init_decl_processing (); 252 253 if (c_common_init () == false) 254 { 255 input_location = saved_loc; 256 return false; 257 } 258 259 init_cp_pragma (); 260 261 init_repo (); 262 263 input_location = saved_loc; 264 return true; 265 } 266 267 /* Return nonzero if S is not considered part of an 268 INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */ 269 270 static int 271 interface_strcmp (const char* s) 272 { 273 /* Set the interface/implementation bits for this scope. */ 274 struct impl_files *ifiles; 275 const char *s1; 276 277 for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next) 278 { 279 const char *t1 = ifiles->filename; 280 s1 = s; 281 282 if (*s1 != *t1 || *s1 == 0) 283 continue; 284 285 while (*s1 == *t1 && *s1 != 0) 286 s1++, t1++; 287 288 /* A match. */ 289 if (*s1 == *t1) 290 return 0; 291 292 /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */ 293 if (strchr (s1, '.') || strchr (t1, '.')) 294 continue; 295 296 if (*s1 == '\0' || s1[-1] != '.' || t1[-1] != '.') 297 continue; 298 299 /* A match. */ 300 return 0; 301 } 302 303 /* No matches. */ 304 return 1; 305 } 306 307 308 309 /* Parse a #pragma whose sole argument is a string constant. 310 If OPT is true, the argument is optional. */ 311 static tree 312 parse_strconst_pragma (const char* name, int opt) 313 { 314 tree result, x; 315 enum cpp_ttype t; 316 317 t = pragma_lex (&result); 318 if (t == CPP_STRING) 319 { 320 if (pragma_lex (&x) != CPP_EOF) 321 warning (0, "junk at end of #pragma %s", name); 322 return result; 323 } 324 325 if (t == CPP_EOF && opt) 326 return NULL_TREE; 327 328 error ("invalid #pragma %s", name); 329 return error_mark_node; 330 } 331 332 static void 333 handle_pragma_vtable (cpp_reader* dfile ATTRIBUTE_UNUSED ) 334 { 335 parse_strconst_pragma ("vtable", 0); 336 sorry ("#pragma vtable no longer supported"); 337 } 338 339 static void 340 handle_pragma_unit (cpp_reader* dfile ATTRIBUTE_UNUSED ) 341 { 342 /* Validate syntax, but don't do anything. */ 343 parse_strconst_pragma ("unit", 0); 344 } 345 346 static void 347 handle_pragma_interface (cpp_reader* dfile ATTRIBUTE_UNUSED ) 348 { 349 tree fname = parse_strconst_pragma ("interface", 1); 350 struct c_fileinfo *finfo; 351 const char *filename; 352 353 if (fname == error_mark_node) 354 return; 355 else if (fname == 0) 356 filename = lbasename (input_filename); 357 else 358 filename = TREE_STRING_POINTER (fname); 359 360 finfo = get_fileinfo (input_filename); 361 362 if (impl_file_chain == 0) 363 { 364 /* If this is zero at this point, then we are 365 auto-implementing. */ 366 if (main_input_filename == 0) 367 main_input_filename = input_filename; 368 } 369 370 finfo->interface_only = interface_strcmp (filename); 371 /* If MULTIPLE_SYMBOL_SPACES is set, we cannot assume that we can see 372 a definition in another file. */ 373 if (!MULTIPLE_SYMBOL_SPACES || !finfo->interface_only) 374 finfo->interface_unknown = 0; 375 } 376 377 /* Note that we have seen a #pragma implementation for the key MAIN_FILENAME. 378 We used to only allow this at toplevel, but that restriction was buggy 379 in older compilers and it seems reasonable to allow it in the headers 380 themselves, too. It only needs to precede the matching #p interface. 381 382 We don't touch finfo->interface_only or finfo->interface_unknown; 383 the user must specify a matching #p interface for this to have 384 any effect. */ 385 386 static void 387 handle_pragma_implementation (cpp_reader* dfile ATTRIBUTE_UNUSED ) 388 { 389 tree fname = parse_strconst_pragma ("implementation", 1); 390 const char *filename; 391 struct impl_files *ifiles = impl_file_chain; 392 393 if (fname == error_mark_node) 394 return; 395 396 if (fname == 0) 397 { 398 if (main_input_filename) 399 filename = main_input_filename; 400 else 401 filename = input_filename; 402 filename = lbasename (filename); 403 } 404 else 405 { 406 filename = TREE_STRING_POINTER (fname); 407 if (cpp_included_before (parse_in, filename, input_location)) 408 warning (0, "#pragma implementation for %qs appears after " 409 "file is included", filename); 410 } 411 412 for (; ifiles; ifiles = ifiles->next) 413 { 414 if (! strcmp (ifiles->filename, filename)) 415 break; 416 } 417 if (ifiles == 0) 418 { 419 ifiles = XNEW (struct impl_files); 420 ifiles->filename = xstrdup (filename); 421 ifiles->next = impl_file_chain; 422 impl_file_chain = ifiles; 423 } 424 } 425 426 /* Indicate that this file uses Java-personality exception handling. */ 427 static void 428 handle_pragma_java_exceptions (cpp_reader* dfile ATTRIBUTE_UNUSED) 429 { 430 tree x; 431 if (pragma_lex (&x) != CPP_EOF) 432 warning (0, "junk at end of #pragma GCC java_exceptions"); 433 434 choose_personality_routine (lang_java); 435 pragma_java_exceptions = true; 436 } 437 438 /* Issue an error message indicating that the lookup of NAME (an 439 IDENTIFIER_NODE) failed. Returns the ERROR_MARK_NODE. */ 440 441 tree 442 unqualified_name_lookup_error (tree name) 443 { 444 if (IDENTIFIER_OPNAME_P (name)) 445 { 446 if (name != ansi_opname (ERROR_MARK)) 447 error ("%qD not defined", name); 448 } 449 else 450 { 451 error ("%qD was not declared in this scope", name); 452 /* Prevent repeated error messages by creating a VAR_DECL with 453 this NAME in the innermost block scope. */ 454 if (current_function_decl) 455 { 456 tree decl; 457 decl = build_decl (input_location, 458 VAR_DECL, name, error_mark_node); 459 DECL_CONTEXT (decl) = current_function_decl; 460 push_local_binding (name, decl, 0); 461 /* Mark the variable as used so that we do not get warnings 462 about it being unused later. */ 463 TREE_USED (decl) = 1; 464 } 465 } 466 467 return error_mark_node; 468 } 469 470 /* Like unqualified_name_lookup_error, but NAME is an unqualified-id 471 used as a function. Returns an appropriate expression for 472 NAME. */ 473 474 tree 475 unqualified_fn_lookup_error (tree name) 476 { 477 if (processing_template_decl) 478 { 479 /* In a template, it is invalid to write "f()" or "f(3)" if no 480 declaration of "f" is available. Historically, G++ and most 481 other compilers accepted that usage since they deferred all name 482 lookup until instantiation time rather than doing unqualified 483 name lookup at template definition time; explain to the user what 484 is going wrong. 485 486 Note that we have the exact wording of the following message in 487 the manual (trouble.texi, node "Name lookup"), so they need to 488 be kept in synch. */ 489 permerror (input_location, "there are no arguments to %qD that depend on a template " 490 "parameter, so a declaration of %qD must be available", 491 name, name); 492 493 if (!flag_permissive) 494 { 495 static bool hint; 496 if (!hint) 497 { 498 inform (input_location, "(if you use %<-fpermissive%>, G++ will accept your " 499 "code, but allowing the use of an undeclared name is " 500 "deprecated)"); 501 hint = true; 502 } 503 } 504 return name; 505 } 506 507 return unqualified_name_lookup_error (name); 508 } 509 510 tree 511 build_lang_decl (enum tree_code code, tree name, tree type) 512 { 513 tree t; 514 515 t = build_decl (input_location, 516 code, name, type); 517 retrofit_lang_decl (t); 518 519 return t; 520 } 521 522 /* Add DECL_LANG_SPECIFIC info to T. Called from build_lang_decl 523 and pushdecl (for functions generated by the back end). */ 524 525 void 526 retrofit_lang_decl (tree t) 527 { 528 struct lang_decl *ld; 529 size_t size; 530 int sel; 531 532 if (TREE_CODE (t) == FUNCTION_DECL) 533 sel = 1, size = sizeof (struct lang_decl_fn); 534 else if (TREE_CODE (t) == NAMESPACE_DECL) 535 sel = 2, size = sizeof (struct lang_decl_ns); 536 else if (TREE_CODE (t) == PARM_DECL) 537 sel = 3, size = sizeof (struct lang_decl_parm); 538 else if (LANG_DECL_HAS_MIN (t)) 539 sel = 0, size = sizeof (struct lang_decl_min); 540 else 541 gcc_unreachable (); 542 543 ld = GGC_CNEWVAR (struct lang_decl, size); 544 545 ld->u.base.selector = sel; 546 547 DECL_LANG_SPECIFIC (t) = ld; 548 if (current_lang_name == lang_name_cplusplus 549 || decl_linkage (t) == lk_none) 550 SET_DECL_LANGUAGE (t, lang_cplusplus); 551 else if (current_lang_name == lang_name_c) 552 SET_DECL_LANGUAGE (t, lang_c); 553 else if (current_lang_name == lang_name_java) 554 SET_DECL_LANGUAGE (t, lang_java); 555 else 556 gcc_unreachable (); 557 558 #ifdef GATHER_STATISTICS 559 tree_node_counts[(int)lang_decl] += 1; 560 tree_node_sizes[(int)lang_decl] += size; 561 #endif 562 } 563 564 void 565 cxx_dup_lang_specific_decl (tree node) 566 { 567 int size; 568 struct lang_decl *ld; 569 570 if (! DECL_LANG_SPECIFIC (node)) 571 return; 572 573 if (TREE_CODE (node) == FUNCTION_DECL) 574 size = sizeof (struct lang_decl_fn); 575 else if (TREE_CODE (node) == NAMESPACE_DECL) 576 size = sizeof (struct lang_decl_ns); 577 else if (TREE_CODE (node) == PARM_DECL) 578 size = sizeof (struct lang_decl_parm); 579 else if (LANG_DECL_HAS_MIN (node)) 580 size = sizeof (struct lang_decl_min); 581 else 582 gcc_unreachable (); 583 584 ld = GGC_NEWVAR (struct lang_decl, size); 585 memcpy (ld, DECL_LANG_SPECIFIC (node), size); 586 DECL_LANG_SPECIFIC (node) = ld; 587 588 #ifdef GATHER_STATISTICS 589 tree_node_counts[(int)lang_decl] += 1; 590 tree_node_sizes[(int)lang_decl] += size; 591 #endif 592 } 593 594 /* Copy DECL, including any language-specific parts. */ 595 596 tree 597 copy_decl (tree decl) 598 { 599 tree copy; 600 601 copy = copy_node (decl); 602 cxx_dup_lang_specific_decl (copy); 603 return copy; 604 } 605 606 /* Replace the shared language-specific parts of NODE with a new copy. */ 607 608 static void 609 copy_lang_type (tree node) 610 { 611 int size; 612 struct lang_type *lt; 613 614 if (! TYPE_LANG_SPECIFIC (node)) 615 return; 616 617 if (TYPE_LANG_SPECIFIC (node)->u.h.is_lang_type_class) 618 size = sizeof (struct lang_type); 619 else 620 size = sizeof (struct lang_type_ptrmem); 621 lt = GGC_NEWVAR (struct lang_type, size); 622 memcpy (lt, TYPE_LANG_SPECIFIC (node), size); 623 TYPE_LANG_SPECIFIC (node) = lt; 624 625 #ifdef GATHER_STATISTICS 626 tree_node_counts[(int)lang_type] += 1; 627 tree_node_sizes[(int)lang_type] += size; 628 #endif 629 } 630 631 /* Copy TYPE, including any language-specific parts. */ 632 633 tree 634 copy_type (tree type) 635 { 636 tree copy; 637 638 copy = copy_node (type); 639 copy_lang_type (copy); 640 return copy; 641 } 642 643 tree 644 cxx_make_type (enum tree_code code) 645 { 646 tree t = make_node (code); 647 648 /* Create lang_type structure. */ 649 if (RECORD_OR_UNION_CODE_P (code) 650 || code == BOUND_TEMPLATE_TEMPLATE_PARM) 651 { 652 struct lang_type *pi = GGC_CNEW (struct lang_type); 653 654 TYPE_LANG_SPECIFIC (t) = pi; 655 pi->u.c.h.is_lang_type_class = 1; 656 657 #ifdef GATHER_STATISTICS 658 tree_node_counts[(int)lang_type] += 1; 659 tree_node_sizes[(int)lang_type] += sizeof (struct lang_type); 660 #endif 661 } 662 663 /* Set up some flags that give proper default behavior. */ 664 if (RECORD_OR_UNION_CODE_P (code)) 665 { 666 struct c_fileinfo *finfo = get_fileinfo (input_filename); 667 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, finfo->interface_unknown); 668 CLASSTYPE_INTERFACE_ONLY (t) = finfo->interface_only; 669 } 670 671 return t; 672 } 673 674 tree 675 make_class_type (enum tree_code code) 676 { 677 tree t = cxx_make_type (code); 678 SET_CLASS_TYPE_P (t, 1); 679 return t; 680 } 681 682 /* Returns true if we are currently in the main source file, or in a 683 template instantiation started from the main source file. */ 684 685 bool 686 in_main_input_context (void) 687 { 688 struct tinst_level *tl = outermost_tinst_level(); 689 690 if (tl) 691 return strcmp (main_input_filename, 692 LOCATION_FILE (tl->locus)) == 0; 693 else 694 return strcmp (main_input_filename, input_filename) == 0; 695 } 696