1 /* C/ObjC/C++ command line option handling. 2 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 3 Free Software Foundation, Inc. 4 Contributed by Neil Booth. 5 6 This file is part of GCC. 7 8 GCC is free software; you can redistribute it and/or modify it under 9 the terms of the GNU General Public License as published by the Free 10 Software Foundation; either version 3, or (at your option) any later 11 version. 12 13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 14 WARRANTY; without even the implied warranty of MERCHANTABILITY or 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 16 for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with GCC; see the file COPYING3. If not see 20 <http://www.gnu.org/licenses/>. */ 21 22 #include "config.h" 23 #include "system.h" 24 #include "coretypes.h" 25 #include "tree.h" 26 #include "c-common.h" 27 #include "c-pragma.h" 28 #include "flags.h" 29 #include "toplev.h" 30 #include "langhooks.h" 31 #include "diagnostic.h" 32 #include "intl.h" 33 #include "cppdefault.h" 34 #include "incpath.h" 35 #include "debug.h" /* For debug_hooks. */ 36 #include "opts.h" 37 #include "options.h" 38 #include "mkdeps.h" 39 #include "c-target.h" 40 #include "tm.h" /* For BYTES_BIG_ENDIAN, 41 DOLLARS_IN_IDENTIFIERS, 42 STDC_0_IN_SYSTEM_HEADERS, 43 TARGET_FLT_EVAL_METHOD_NON_DEFAULT and 44 TARGET_OPTF. */ 45 #include "tm_p.h" /* For C_COMMON_OVERRIDE_OPTIONS. */ 46 47 #ifndef DOLLARS_IN_IDENTIFIERS 48 # define DOLLARS_IN_IDENTIFIERS true 49 #endif 50 51 #ifndef TARGET_SYSTEM_ROOT 52 # define TARGET_SYSTEM_ROOT NULL 53 #endif 54 55 #ifndef TARGET_OPTF 56 #define TARGET_OPTF(ARG) 57 #endif 58 59 /* CPP's options. */ 60 cpp_options *cpp_opts; 61 62 /* Input filename. */ 63 static const char *this_input_filename; 64 65 /* Filename and stream for preprocessed output. */ 66 static const char *out_fname; 67 static FILE *out_stream; 68 69 /* Append dependencies to deps_file. */ 70 static bool deps_append; 71 72 /* If dependency switches (-MF etc.) have been given. */ 73 static bool deps_seen; 74 75 /* If -v seen. */ 76 static bool verbose; 77 78 /* Dependency output file. */ 79 static const char *deps_file; 80 81 /* The prefix given by -iprefix, if any. */ 82 static const char *iprefix; 83 84 /* The multilib directory given by -imultilib, if any. */ 85 static const char *imultilib; 86 87 /* The system root, if any. Overridden by -isysroot. */ 88 static const char *sysroot = TARGET_SYSTEM_ROOT; 89 90 /* Zero disables all standard directories for headers. */ 91 static bool std_inc = true; 92 93 /* Zero disables the C++-specific standard directories for headers. */ 94 static bool std_cxx_inc = true; 95 96 /* If the quote chain has been split by -I-. */ 97 static bool quote_chain_split; 98 99 /* If -Wunused-macros. */ 100 static bool warn_unused_macros; 101 102 /* If -Wvariadic-macros. */ 103 static bool warn_variadic_macros = true; 104 105 /* Number of deferred options. */ 106 static size_t deferred_count; 107 108 /* Number of deferred options scanned for -include. */ 109 static size_t include_cursor; 110 111 static void handle_OPT_d (const char *); 112 static void set_std_cxx98 (int); 113 static void set_std_cxx11 (int); 114 static void set_std_c89 (int, int); 115 static void set_std_c99 (int); 116 static void set_std_c11 (int); 117 static void check_deps_environment_vars (void); 118 static void handle_deferred_opts (void); 119 static void sanitize_cpp_opts (void); 120 static void add_prefixed_path (const char *, size_t); 121 static void push_command_line_include (void); 122 static void cb_file_change (cpp_reader *, const struct line_map *); 123 static void cb_dir_change (cpp_reader *, const char *); 124 static void c_finish_options (void); 125 126 #ifndef STDC_0_IN_SYSTEM_HEADERS 127 #define STDC_0_IN_SYSTEM_HEADERS 0 128 #endif 129 130 /* Holds switches parsed by c_common_handle_option (), but whose 131 handling is deferred to c_common_post_options (). */ 132 static void defer_opt (enum opt_code, const char *); 133 static struct deferred_opt 134 { 135 enum opt_code code; 136 const char *arg; 137 } *deferred_opts; 138 139 140 const unsigned int 141 c_family_lang_mask = (CL_C | CL_CXX | CL_ObjC | CL_ObjCXX); 142 143 /* Defer option CODE with argument ARG. */ 144 static void 145 defer_opt (enum opt_code code, const char *arg) 146 { 147 deferred_opts[deferred_count].code = code; 148 deferred_opts[deferred_count].arg = arg; 149 deferred_count++; 150 } 151 152 /* Return language mask for option parsing. */ 153 unsigned int 154 c_common_option_lang_mask (void) 155 { 156 static const unsigned int lang_flags[] = {CL_C, CL_ObjC, CL_CXX, CL_ObjCXX}; 157 158 return lang_flags[c_language]; 159 } 160 161 /* Common diagnostics initialization. */ 162 void 163 c_common_initialize_diagnostics (diagnostic_context *context) 164 { 165 /* This is conditionalized only because that is the way the front 166 ends used to do it. Maybe this should be unconditional? */ 167 if (c_dialect_cxx ()) 168 { 169 /* By default wrap lines at 80 characters. Is getenv 170 ("COLUMNS") preferable? */ 171 diagnostic_line_cutoff (context) = 80; 172 /* By default, emit location information once for every 173 diagnostic message. */ 174 diagnostic_prefixing_rule (context) = DIAGNOSTICS_SHOW_PREFIX_ONCE; 175 } 176 177 context->opt_permissive = OPT_fpermissive; 178 } 179 180 /* Whether options from all C-family languages should be accepted 181 quietly. */ 182 static bool accept_all_c_family_options = false; 183 184 /* Return whether to complain about a wrong-language option. */ 185 bool 186 c_common_complain_wrong_lang_p (const struct cl_option *option) 187 { 188 if (accept_all_c_family_options 189 && (option->flags & c_family_lang_mask)) 190 return false; 191 192 return true; 193 } 194 195 /* Initialize options structure OPTS. */ 196 void 197 c_common_init_options_struct (struct gcc_options *opts) 198 { 199 opts->x_flag_exceptions = c_dialect_cxx (); 200 opts->x_warn_pointer_arith = c_dialect_cxx (); 201 opts->x_warn_write_strings = c_dialect_cxx (); 202 opts->x_flag_warn_unused_result = true; 203 204 /* By default, C99-like requirements for complex multiply and divide. */ 205 opts->x_flag_complex_method = 2; 206 } 207 208 /* Common initialization before calling option handlers. */ 209 void 210 c_common_init_options (unsigned int decoded_options_count, 211 struct cl_decoded_option *decoded_options) 212 { 213 unsigned int i; 214 struct cpp_callbacks *cb; 215 216 parse_in = cpp_create_reader (c_dialect_cxx () ? CLK_GNUCXX: CLK_GNUC89, 217 ident_hash, line_table); 218 cb = cpp_get_callbacks (parse_in); 219 cb->error = c_cpp_error; 220 221 cpp_opts = cpp_get_options (parse_in); 222 cpp_opts->dollars_in_ident = DOLLARS_IN_IDENTIFIERS; 223 cpp_opts->objc = c_dialect_objc (); 224 225 /* Reset to avoid warnings on internal definitions. We set it just 226 before passing on command-line options to cpplib. */ 227 cpp_opts->warn_dollars = 0; 228 229 deferred_opts = XNEWVEC (struct deferred_opt, decoded_options_count); 230 231 if (c_language == clk_c) 232 { 233 /* If preprocessing assembly language, accept any of the C-family 234 front end options since the driver may pass them through. */ 235 for (i = 1; i < decoded_options_count; i++) 236 if (decoded_options[i].opt_index == OPT_lang_asm) 237 { 238 accept_all_c_family_options = true; 239 break; 240 } 241 } 242 } 243 244 /* Handle switch SCODE with argument ARG. VALUE is true, unless no- 245 form of an -f or -W option was given. Returns false if the switch was 246 invalid, true if valid. Use HANDLERS in recursive handle_option calls. */ 247 bool 248 c_common_handle_option (size_t scode, const char *arg, int value, 249 int kind, location_t loc, 250 const struct cl_option_handlers *handlers) 251 { 252 const struct cl_option *option = &cl_options[scode]; 253 enum opt_code code = (enum opt_code) scode; 254 bool result = true; 255 256 /* Prevent resetting the language standard to a C dialect when the driver 257 has already determined that we're looking at assembler input. */ 258 bool preprocessing_asm_p = (cpp_get_options (parse_in)->lang == CLK_ASM); 259 260 switch (code) 261 { 262 default: 263 if (cl_options[code].flags & c_family_lang_mask) 264 { 265 if ((option->flags & CL_TARGET) 266 && ! targetcm.handle_c_option (scode, arg, value)) 267 result = false; 268 break; 269 } 270 result = false; 271 break; 272 273 case OPT__output_pch_: 274 pch_file = arg; 275 break; 276 277 case OPT_A: 278 defer_opt (code, arg); 279 break; 280 281 case OPT_C: 282 cpp_opts->discard_comments = 0; 283 break; 284 285 case OPT_CC: 286 cpp_opts->discard_comments = 0; 287 cpp_opts->discard_comments_in_macro_exp = 0; 288 break; 289 290 case OPT_D: 291 defer_opt (code, arg); 292 break; 293 294 case OPT_H: 295 cpp_opts->print_include_names = 1; 296 break; 297 298 case OPT_F: 299 TARGET_OPTF (xstrdup (arg)); 300 break; 301 302 case OPT_I: 303 if (strcmp (arg, "-")) 304 add_path (xstrdup (arg), BRACKET, 0, true); 305 else 306 { 307 if (quote_chain_split) 308 error ("-I- specified twice"); 309 quote_chain_split = true; 310 split_quote_chain (); 311 inform (input_location, "obsolete option -I- used, please use -iquote instead"); 312 } 313 break; 314 315 case OPT_M: 316 case OPT_MM: 317 /* When doing dependencies with -M or -MM, suppress normal 318 preprocessed output, but still do -dM etc. as software 319 depends on this. Preprocessed output does occur if -MD, -MMD 320 or environment var dependency generation is used. */ 321 cpp_opts->deps.style = (code == OPT_M ? DEPS_SYSTEM: DEPS_USER); 322 flag_no_output = 1; 323 break; 324 325 case OPT_MD: 326 case OPT_MMD: 327 cpp_opts->deps.style = (code == OPT_MD ? DEPS_SYSTEM: DEPS_USER); 328 cpp_opts->deps.need_preprocessor_output = true; 329 deps_file = arg; 330 break; 331 332 case OPT_MF: 333 deps_seen = true; 334 deps_file = arg; 335 break; 336 337 case OPT_MG: 338 deps_seen = true; 339 cpp_opts->deps.missing_files = true; 340 break; 341 342 case OPT_MP: 343 deps_seen = true; 344 cpp_opts->deps.phony_targets = true; 345 break; 346 347 case OPT_MQ: 348 case OPT_MT: 349 deps_seen = true; 350 defer_opt (code, arg); 351 break; 352 353 case OPT_P: 354 flag_no_line_commands = 1; 355 break; 356 357 case OPT_U: 358 defer_opt (code, arg); 359 break; 360 361 case OPT_Wall: 362 warn_unused = value; 363 set_Wformat (value); 364 handle_generated_option (&global_options, &global_options_set, 365 OPT_Wimplicit, NULL, value, 366 c_family_lang_mask, kind, loc, 367 handlers, global_dc); 368 warn_char_subscripts = value; 369 warn_missing_braces = value; 370 warn_parentheses = value; 371 warn_return_type = value; 372 warn_sequence_point = value; /* Was C only. */ 373 warn_switch = value; 374 if (warn_strict_aliasing == -1) 375 set_Wstrict_aliasing (&global_options, value); 376 warn_address = value; 377 if (warn_strict_overflow == -1) 378 warn_strict_overflow = value; 379 warn_array_bounds = value; 380 warn_volatile_register_var = value; 381 382 /* Only warn about unknown pragmas that are not in system 383 headers. */ 384 warn_unknown_pragmas = value; 385 386 warn_uninitialized = value; 387 warn_maybe_uninitialized = value; 388 389 if (!c_dialect_cxx ()) 390 { 391 /* We set this to 2 here, but 1 in -Wmain, so -ffreestanding 392 can turn it off only if it's not explicit. */ 393 if (warn_main == -1) 394 warn_main = (value ? 2 : 0); 395 396 /* In C, -Wall turns on -Wenum-compare, which we do here. 397 In C++ it is on by default, which is done in 398 c_common_post_options. */ 399 if (warn_enum_compare == -1) 400 warn_enum_compare = value; 401 } 402 else 403 { 404 /* C++-specific warnings. */ 405 warn_sign_compare = value; 406 warn_reorder = value; 407 warn_cxx0x_compat = value; 408 warn_delnonvdtor = value; 409 warn_narrowing = value; 410 } 411 412 cpp_opts->warn_trigraphs = value; 413 cpp_opts->warn_comments = value; 414 cpp_opts->warn_num_sign_change = value; 415 416 if (warn_pointer_sign == -1) 417 warn_pointer_sign = value; 418 break; 419 420 case OPT_Wbuiltin_macro_redefined: 421 cpp_opts->warn_builtin_macro_redefined = value; 422 break; 423 424 case OPT_Wcomment: 425 cpp_opts->warn_comments = value; 426 break; 427 428 case OPT_Wc___compat: 429 /* Because -Wenum-compare is the default in C++, -Wc++-compat 430 implies -Wenum-compare. */ 431 if (warn_enum_compare == -1 && value) 432 warn_enum_compare = value; 433 /* Because C++ always warns about a goto which misses an 434 initialization, -Wc++-compat turns on -Wjump-misses-init. */ 435 if (warn_jump_misses_init == -1 && value) 436 warn_jump_misses_init = value; 437 cpp_opts->warn_cxx_operator_names = value; 438 break; 439 440 case OPT_Wc__0x_compat: 441 warn_narrowing = value; 442 break; 443 444 case OPT_Wdeprecated: 445 cpp_opts->cpp_warn_deprecated = value; 446 break; 447 448 case OPT_Wendif_labels: 449 cpp_opts->warn_endif_labels = value; 450 break; 451 452 case OPT_Wformat: 453 set_Wformat (value); 454 break; 455 456 case OPT_Wformat_: 457 set_Wformat (atoi (arg)); 458 break; 459 460 case OPT_Wimplicit: 461 gcc_assert (value == 0 || value == 1); 462 if (warn_implicit_int == -1) 463 handle_generated_option (&global_options, &global_options_set, 464 OPT_Wimplicit_int, NULL, value, 465 c_family_lang_mask, kind, loc, handlers, 466 global_dc); 467 if (warn_implicit_function_declaration == -1) 468 handle_generated_option (&global_options, &global_options_set, 469 OPT_Wimplicit_function_declaration, NULL, 470 value, c_family_lang_mask, kind, loc, 471 handlers, global_dc); 472 break; 473 474 case OPT_Winvalid_pch: 475 cpp_opts->warn_invalid_pch = value; 476 break; 477 478 case OPT_Wlong_long: 479 cpp_opts->cpp_warn_long_long = value; 480 break; 481 482 case OPT_Wmissing_include_dirs: 483 cpp_opts->warn_missing_include_dirs = value; 484 break; 485 486 case OPT_Wmultichar: 487 cpp_opts->warn_multichar = value; 488 break; 489 490 case OPT_Wnormalized_: 491 if (kind == DK_ERROR) 492 { 493 gcc_assert (!arg); 494 inform (input_location, "-Werror=normalized=: set -Wnormalized=nfc"); 495 cpp_opts->warn_normalize = normalized_C; 496 } 497 else 498 { 499 if (!value || (arg && strcasecmp (arg, "none") == 0)) 500 cpp_opts->warn_normalize = normalized_none; 501 else if (!arg || strcasecmp (arg, "nfkc") == 0) 502 cpp_opts->warn_normalize = normalized_KC; 503 else if (strcasecmp (arg, "id") == 0) 504 cpp_opts->warn_normalize = normalized_identifier_C; 505 else if (strcasecmp (arg, "nfc") == 0) 506 cpp_opts->warn_normalize = normalized_C; 507 else 508 error ("argument %qs to %<-Wnormalized%> not recognized", arg); 509 break; 510 } 511 512 case OPT_Wreturn_type: 513 warn_return_type = value; 514 break; 515 516 case OPT_Wtraditional: 517 cpp_opts->cpp_warn_traditional = value; 518 break; 519 520 case OPT_Wtrigraphs: 521 cpp_opts->warn_trigraphs = value; 522 break; 523 524 case OPT_Wundef: 525 cpp_opts->warn_undef = value; 526 break; 527 528 case OPT_Wunknown_pragmas: 529 /* Set to greater than 1, so that even unknown pragmas in 530 system headers will be warned about. */ 531 warn_unknown_pragmas = value * 2; 532 break; 533 534 case OPT_Wunused_macros: 535 warn_unused_macros = value; 536 break; 537 538 case OPT_Wvariadic_macros: 539 warn_variadic_macros = value; 540 break; 541 542 case OPT_Wwrite_strings: 543 warn_write_strings = value; 544 break; 545 546 case OPT_Weffc__: 547 warn_ecpp = value; 548 if (value) 549 warn_nonvdtor = true; 550 break; 551 552 case OPT_ansi: 553 if (!c_dialect_cxx ()) 554 set_std_c89 (false, true); 555 else 556 set_std_cxx98 (true); 557 break; 558 559 case OPT_d: 560 handle_OPT_d (arg); 561 break; 562 563 case OPT_fcond_mismatch: 564 if (!c_dialect_cxx ()) 565 { 566 flag_cond_mismatch = value; 567 break; 568 } 569 warning (0, "switch %qs is no longer supported", option->opt_text); 570 break; 571 572 case OPT_fbuiltin_: 573 if (value) 574 result = false; 575 else 576 disable_builtin_function (arg); 577 break; 578 579 case OPT_fdirectives_only: 580 cpp_opts->directives_only = value; 581 break; 582 583 case OPT_fdollars_in_identifiers: 584 cpp_opts->dollars_in_ident = value; 585 break; 586 587 case OPT_ffreestanding: 588 value = !value; 589 /* Fall through.... */ 590 case OPT_fhosted: 591 flag_hosted = value; 592 flag_no_builtin = !value; 593 break; 594 595 case OPT_fconstant_string_class_: 596 constant_string_class_name = arg; 597 break; 598 599 case OPT_fextended_identifiers: 600 cpp_opts->extended_identifiers = value; 601 break; 602 603 case OPT_foperator_names: 604 cpp_opts->operator_names = value; 605 break; 606 607 case OPT_fpch_deps: 608 cpp_opts->restore_pch_deps = value; 609 break; 610 611 case OPT_fpch_preprocess: 612 flag_pch_preprocess = value; 613 break; 614 615 case OPT_fpermissive: 616 flag_permissive = value; 617 global_dc->permissive = value; 618 break; 619 620 case OPT_fpreprocessed: 621 cpp_opts->preprocessed = value; 622 break; 623 624 case OPT_fdebug_cpp: 625 cpp_opts->debug = 1; 626 break; 627 628 case OPT_ftrack_macro_expansion: 629 if (value) 630 value = 2; 631 /* Fall Through. */ 632 633 case OPT_ftrack_macro_expansion_: 634 if (arg && *arg != '\0') 635 cpp_opts->track_macro_expansion = value; 636 else 637 cpp_opts->track_macro_expansion = 2; 638 break; 639 640 case OPT_frepo: 641 flag_use_repository = value; 642 if (value) 643 flag_implicit_templates = 0; 644 break; 645 646 case OPT_ftabstop_: 647 /* It is documented that we silently ignore silly values. */ 648 if (value >= 1 && value <= 100) 649 cpp_opts->tabstop = value; 650 break; 651 652 case OPT_fexec_charset_: 653 cpp_opts->narrow_charset = arg; 654 break; 655 656 case OPT_fwide_exec_charset_: 657 cpp_opts->wide_charset = arg; 658 break; 659 660 case OPT_finput_charset_: 661 cpp_opts->input_charset = arg; 662 break; 663 664 case OPT_ftemplate_depth_: 665 max_tinst_depth = value; 666 break; 667 668 case OPT_fvisibility_inlines_hidden: 669 visibility_options.inlines_hidden = value; 670 break; 671 672 case OPT_femit_struct_debug_baseonly: 673 set_struct_debug_option (&global_options, loc, "base"); 674 break; 675 676 case OPT_femit_struct_debug_reduced: 677 set_struct_debug_option (&global_options, loc, 678 "dir:ord:sys,dir:gen:any,ind:base"); 679 break; 680 681 case OPT_femit_struct_debug_detailed_: 682 set_struct_debug_option (&global_options, loc, arg); 683 break; 684 685 case OPT_idirafter: 686 add_path (xstrdup (arg), AFTER, 0, true); 687 break; 688 689 case OPT_imacros: 690 case OPT_include: 691 defer_opt (code, arg); 692 break; 693 694 case OPT_imultilib: 695 imultilib = arg; 696 break; 697 698 case OPT_iprefix: 699 iprefix = arg; 700 break; 701 702 case OPT_iquote: 703 add_path (xstrdup (arg), QUOTE, 0, true); 704 break; 705 706 case OPT_isysroot: 707 sysroot = arg; 708 break; 709 710 case OPT_isystem: 711 add_path (xstrdup (arg), SYSTEM, 0, true); 712 break; 713 714 case OPT_iwithprefix: 715 add_prefixed_path (arg, SYSTEM); 716 break; 717 718 case OPT_iwithprefixbefore: 719 add_prefixed_path (arg, BRACKET); 720 break; 721 722 case OPT_lang_asm: 723 cpp_set_lang (parse_in, CLK_ASM); 724 cpp_opts->dollars_in_ident = false; 725 break; 726 727 case OPT_nostdinc: 728 std_inc = false; 729 break; 730 731 case OPT_nostdinc__: 732 std_cxx_inc = false; 733 break; 734 735 case OPT_o: 736 if (!out_fname) 737 out_fname = arg; 738 else 739 error ("output filename specified twice"); 740 break; 741 742 /* We need to handle the -pedantic switches here, rather than in 743 c_common_post_options, so that a subsequent -Wno-endif-labels 744 is not overridden. */ 745 case OPT_pedantic_errors: 746 case OPT_pedantic: 747 cpp_opts->cpp_pedantic = 1; 748 cpp_opts->warn_endif_labels = 1; 749 if (warn_pointer_sign == -1) 750 warn_pointer_sign = 1; 751 if (warn_overlength_strings == -1) 752 warn_overlength_strings = 1; 753 if (warn_main == -1) 754 warn_main = 2; 755 break; 756 757 case OPT_print_objc_runtime_info: 758 print_struct_values = 1; 759 break; 760 761 case OPT_remap: 762 cpp_opts->remap = 1; 763 break; 764 765 case OPT_std_c__98: 766 case OPT_std_gnu__98: 767 if (!preprocessing_asm_p) 768 set_std_cxx98 (code == OPT_std_c__98 /* ISO */); 769 break; 770 771 case OPT_std_c__11: 772 case OPT_std_gnu__11: 773 if (!preprocessing_asm_p) 774 set_std_cxx11 (code == OPT_std_c__11 /* ISO */); 775 break; 776 777 case OPT_std_c90: 778 case OPT_std_iso9899_199409: 779 if (!preprocessing_asm_p) 780 set_std_c89 (code == OPT_std_iso9899_199409 /* c94 */, true /* ISO */); 781 break; 782 783 case OPT_std_gnu90: 784 if (!preprocessing_asm_p) 785 set_std_c89 (false /* c94 */, false /* ISO */); 786 break; 787 788 case OPT_std_c99: 789 if (!preprocessing_asm_p) 790 set_std_c99 (true /* ISO */); 791 break; 792 793 case OPT_std_gnu99: 794 if (!preprocessing_asm_p) 795 set_std_c99 (false /* ISO */); 796 break; 797 798 case OPT_std_c11: 799 if (!preprocessing_asm_p) 800 set_std_c11 (true /* ISO */); 801 break; 802 803 case OPT_std_gnu11: 804 if (!preprocessing_asm_p) 805 set_std_c11 (false /* ISO */); 806 break; 807 808 case OPT_trigraphs: 809 cpp_opts->trigraphs = 1; 810 break; 811 812 case OPT_traditional_cpp: 813 cpp_opts->traditional = 1; 814 break; 815 816 case OPT_v: 817 verbose = true; 818 break; 819 820 case OPT_Wabi: 821 warn_psabi = value; 822 break; 823 } 824 825 return result; 826 } 827 828 /* Default implementation of TARGET_HANDLE_C_OPTION. */ 829 830 bool 831 default_handle_c_option (size_t code ATTRIBUTE_UNUSED, 832 const char *arg ATTRIBUTE_UNUSED, 833 int value ATTRIBUTE_UNUSED) 834 { 835 return false; 836 } 837 838 /* Post-switch processing. */ 839 bool 840 c_common_post_options (const char **pfilename) 841 { 842 struct cpp_callbacks *cb; 843 844 /* Canonicalize the input and output filenames. */ 845 if (in_fnames == NULL) 846 { 847 in_fnames = XNEWVEC (const char *, 1); 848 in_fnames[0] = ""; 849 } 850 else if (strcmp (in_fnames[0], "-") == 0) 851 in_fnames[0] = ""; 852 853 if (out_fname == NULL || !strcmp (out_fname, "-")) 854 out_fname = ""; 855 856 if (cpp_opts->deps.style == DEPS_NONE) 857 check_deps_environment_vars (); 858 859 handle_deferred_opts (); 860 861 sanitize_cpp_opts (); 862 863 register_include_chains (parse_in, sysroot, iprefix, imultilib, 864 std_inc, std_cxx_inc && c_dialect_cxx (), verbose); 865 866 #ifdef C_COMMON_OVERRIDE_OPTIONS 867 /* Some machines may reject certain combinations of C 868 language-specific options. */ 869 C_COMMON_OVERRIDE_OPTIONS; 870 #endif 871 872 /* Excess precision other than "fast" requires front-end 873 support. */ 874 if (c_dialect_cxx ()) 875 { 876 if (flag_excess_precision_cmdline == EXCESS_PRECISION_STANDARD 877 && TARGET_FLT_EVAL_METHOD_NON_DEFAULT) 878 sorry ("-fexcess-precision=standard for C++"); 879 flag_excess_precision_cmdline = EXCESS_PRECISION_FAST; 880 } 881 else if (flag_excess_precision_cmdline == EXCESS_PRECISION_DEFAULT) 882 flag_excess_precision_cmdline = (flag_iso 883 ? EXCESS_PRECISION_STANDARD 884 : EXCESS_PRECISION_FAST); 885 886 /* By default we use C99 inline semantics in GNU99 or C99 mode. C99 887 inline semantics are not supported in GNU89 or C89 mode. */ 888 if (flag_gnu89_inline == -1) 889 flag_gnu89_inline = !flag_isoc99; 890 else if (!flag_gnu89_inline && !flag_isoc99) 891 error ("-fno-gnu89-inline is only supported in GNU99 or C99 mode"); 892 893 /* Default to ObjC sjlj exception handling if NeXT runtime. */ 894 if (flag_objc_sjlj_exceptions < 0) 895 flag_objc_sjlj_exceptions = flag_next_runtime; 896 if (flag_objc_exceptions && !flag_objc_sjlj_exceptions) 897 flag_exceptions = 1; 898 899 /* -Wextra implies the following flags 900 unless explicitly overridden. */ 901 if (warn_type_limits == -1) 902 warn_type_limits = extra_warnings; 903 if (warn_clobbered == -1) 904 warn_clobbered = extra_warnings; 905 if (warn_empty_body == -1) 906 warn_empty_body = extra_warnings; 907 if (warn_sign_compare == -1) 908 warn_sign_compare = extra_warnings; 909 if (warn_missing_field_initializers == -1) 910 warn_missing_field_initializers = extra_warnings; 911 if (warn_missing_parameter_type == -1) 912 warn_missing_parameter_type = extra_warnings; 913 if (warn_old_style_declaration == -1) 914 warn_old_style_declaration = extra_warnings; 915 if (warn_override_init == -1) 916 warn_override_init = extra_warnings; 917 if (warn_ignored_qualifiers == -1) 918 warn_ignored_qualifiers = extra_warnings; 919 920 /* -Wpointer-sign is disabled by default, but it is enabled if any 921 of -Wall or -pedantic are given. */ 922 if (warn_pointer_sign == -1) 923 warn_pointer_sign = 0; 924 925 if (warn_strict_aliasing == -1) 926 warn_strict_aliasing = 0; 927 if (warn_strict_overflow == -1) 928 warn_strict_overflow = 0; 929 if (warn_jump_misses_init == -1) 930 warn_jump_misses_init = 0; 931 932 /* -Woverlength-strings is off by default, but is enabled by -pedantic. 933 It is never enabled in C++, as the minimum limit is not normative 934 in that standard. */ 935 if (warn_overlength_strings == -1 || c_dialect_cxx ()) 936 warn_overlength_strings = 0; 937 938 /* Wmain is enabled by default in C++ but not in C. */ 939 /* Wmain is disabled by default for -ffreestanding (!flag_hosted), 940 even if -Wall was given (warn_main will be 2 if set by -Wall, 1 941 if set by -Wmain). */ 942 if (warn_main == -1) 943 warn_main = (c_dialect_cxx () && flag_hosted) ? 1 : 0; 944 else if (warn_main == 2) 945 warn_main = flag_hosted ? 1 : 0; 946 947 /* In C, -Wconversion enables -Wsign-conversion (unless disabled 948 through -Wno-sign-conversion). While in C++, 949 -Wsign-conversion needs to be requested explicitly. */ 950 if (warn_sign_conversion == -1) 951 warn_sign_conversion = (c_dialect_cxx ()) ? 0 : warn_conversion; 952 953 /* In C, -Wall and -Wc++-compat enable -Wenum-compare, which we do 954 in c_common_handle_option; if it has not yet been set, it is 955 disabled by default. In C++, it is enabled by default. */ 956 if (warn_enum_compare == -1) 957 warn_enum_compare = c_dialect_cxx () ? 1 : 0; 958 959 /* -Wpacked-bitfield-compat is on by default for the C languages. The 960 warning is issued in stor-layout.c which is not part of the front-end so 961 we need to selectively turn it on here. */ 962 if (warn_packed_bitfield_compat == -1) 963 warn_packed_bitfield_compat = 1; 964 965 /* Special format checking options don't work without -Wformat; warn if 966 they are used. */ 967 if (!warn_format) 968 { 969 warning (OPT_Wformat_y2k, 970 "-Wformat-y2k ignored without -Wformat"); 971 warning (OPT_Wformat_extra_args, 972 "-Wformat-extra-args ignored without -Wformat"); 973 warning (OPT_Wformat_zero_length, 974 "-Wformat-zero-length ignored without -Wformat"); 975 warning (OPT_Wformat_nonliteral, 976 "-Wformat-nonliteral ignored without -Wformat"); 977 warning (OPT_Wformat_contains_nul, 978 "-Wformat-contains-nul ignored without -Wformat"); 979 warning (OPT_Wformat_security, 980 "-Wformat-security ignored without -Wformat"); 981 } 982 983 if (warn_implicit == -1) 984 warn_implicit = 0; 985 986 if (warn_implicit_int == -1) 987 warn_implicit_int = 0; 988 989 /* -Wimplicit-function-declaration is enabled by default for C99. */ 990 if (warn_implicit_function_declaration == -1) 991 warn_implicit_function_declaration = flag_isoc99; 992 993 if (cxx_dialect == cxx0x) 994 { 995 /* If we're allowing C++0x constructs, don't warn about C++98 996 identifiers which are keywords in C++0x. */ 997 warn_cxx0x_compat = 0; 998 999 if (warn_narrowing == -1) 1000 warn_narrowing = 1; 1001 } 1002 else if (warn_narrowing == -1) 1003 warn_narrowing = 0; 1004 1005 if (flag_preprocess_only) 1006 { 1007 /* Open the output now. We must do so even if flag_no_output is 1008 on, because there may be other output than from the actual 1009 preprocessing (e.g. from -dM). */ 1010 if (out_fname[0] == '\0') 1011 out_stream = stdout; 1012 else 1013 out_stream = fopen (out_fname, "w"); 1014 1015 if (out_stream == NULL) 1016 { 1017 fatal_error ("opening output file %s: %m", out_fname); 1018 return false; 1019 } 1020 1021 if (num_in_fnames > 1) 1022 error ("too many filenames given. Type %s --help for usage", 1023 progname); 1024 1025 init_pp_output (out_stream); 1026 } 1027 else 1028 { 1029 init_c_lex (); 1030 1031 /* When writing a PCH file, avoid reading some other PCH file, 1032 because the default address space slot then can't be used 1033 for the output PCH file. */ 1034 if (pch_file) 1035 c_common_no_more_pch (); 1036 1037 /* Yuk. WTF is this? I do know ObjC relies on it somewhere. */ 1038 input_location = UNKNOWN_LOCATION; 1039 } 1040 1041 cb = cpp_get_callbacks (parse_in); 1042 cb->file_change = cb_file_change; 1043 cb->dir_change = cb_dir_change; 1044 cpp_post_options (parse_in); 1045 1046 input_location = UNKNOWN_LOCATION; 1047 1048 *pfilename = this_input_filename 1049 = cpp_read_main_file (parse_in, in_fnames[0]); 1050 /* Don't do any compilation or preprocessing if there is no input file. */ 1051 if (this_input_filename == NULL) 1052 { 1053 errorcount++; 1054 return false; 1055 } 1056 1057 if (flag_working_directory 1058 && flag_preprocess_only && !flag_no_line_commands) 1059 pp_dir_change (parse_in, get_src_pwd ()); 1060 1061 /* Disable LTO output when outputting a precompiled header. */ 1062 if (pch_file && flag_lto) 1063 { 1064 flag_lto = 0; 1065 flag_generate_lto = 0; 1066 } 1067 1068 return flag_preprocess_only; 1069 } 1070 1071 /* Front end initialization common to C, ObjC and C++. */ 1072 bool 1073 c_common_init (void) 1074 { 1075 /* Set up preprocessor arithmetic. Must be done after call to 1076 c_common_nodes_and_builtins for type nodes to be good. */ 1077 cpp_opts->precision = TYPE_PRECISION (intmax_type_node); 1078 cpp_opts->char_precision = TYPE_PRECISION (char_type_node); 1079 cpp_opts->int_precision = TYPE_PRECISION (integer_type_node); 1080 cpp_opts->wchar_precision = TYPE_PRECISION (wchar_type_node); 1081 cpp_opts->unsigned_wchar = TYPE_UNSIGNED (wchar_type_node); 1082 cpp_opts->bytes_big_endian = BYTES_BIG_ENDIAN; 1083 1084 /* This can't happen until after wchar_precision and bytes_big_endian 1085 are known. */ 1086 cpp_init_iconv (parse_in); 1087 1088 if (version_flag) 1089 c_common_print_pch_checksum (stderr); 1090 1091 /* Has to wait until now so that cpplib has its hash table. */ 1092 init_pragma (); 1093 1094 if (flag_preprocess_only) 1095 { 1096 c_finish_options (); 1097 preprocess_file (parse_in); 1098 return false; 1099 } 1100 1101 return true; 1102 } 1103 1104 /* Initialize the integrated preprocessor after debug output has been 1105 initialized; loop over each input file. */ 1106 void 1107 c_common_parse_file (void) 1108 { 1109 unsigned int i; 1110 1111 i = 0; 1112 for (;;) 1113 { 1114 c_finish_options (); 1115 pch_init (); 1116 push_file_scope (); 1117 c_parse_file (); 1118 pop_file_scope (); 1119 /* And end the main input file, if the debug writer wants it */ 1120 if (debug_hooks->start_end_main_source_file) 1121 (*debug_hooks->end_source_file) (0); 1122 if (++i >= num_in_fnames) 1123 break; 1124 cpp_undef_all (parse_in); 1125 cpp_clear_file_cache (parse_in); 1126 this_input_filename 1127 = cpp_read_main_file (parse_in, in_fnames[i]); 1128 /* If an input file is missing, abandon further compilation. 1129 cpplib has issued a diagnostic. */ 1130 if (!this_input_filename) 1131 break; 1132 } 1133 } 1134 1135 /* Common finish hook for the C, ObjC and C++ front ends. */ 1136 void 1137 c_common_finish (void) 1138 { 1139 FILE *deps_stream = NULL; 1140 1141 /* Don't write the deps file if there are errors. */ 1142 if (cpp_opts->deps.style != DEPS_NONE && !seen_error ()) 1143 { 1144 /* If -M or -MM was seen without -MF, default output to the 1145 output stream. */ 1146 if (!deps_file) 1147 deps_stream = out_stream; 1148 else 1149 { 1150 deps_stream = fopen (deps_file, deps_append ? "a": "w"); 1151 if (!deps_stream) 1152 fatal_error ("opening dependency file %s: %m", deps_file); 1153 } 1154 } 1155 1156 /* For performance, avoid tearing down cpplib's internal structures 1157 with cpp_destroy (). */ 1158 cpp_finish (parse_in, deps_stream); 1159 1160 if (deps_stream && deps_stream != out_stream 1161 && (ferror (deps_stream) || fclose (deps_stream))) 1162 fatal_error ("closing dependency file %s: %m", deps_file); 1163 1164 if (out_stream && (ferror (out_stream) || fclose (out_stream))) 1165 fatal_error ("when writing output to %s: %m", out_fname); 1166 } 1167 1168 /* Either of two environment variables can specify output of 1169 dependencies. Their value is either "OUTPUT_FILE" or "OUTPUT_FILE 1170 DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to 1171 and DEPS_TARGET is the target to mention in the deps. They also 1172 result in dependency information being appended to the output file 1173 rather than overwriting it, and like Sun's compiler 1174 SUNPRO_DEPENDENCIES suppresses the dependency on the main file. */ 1175 static void 1176 check_deps_environment_vars (void) 1177 { 1178 char *spec; 1179 1180 spec = getenv ("DEPENDENCIES_OUTPUT"); 1181 if (spec) 1182 cpp_opts->deps.style = DEPS_USER; 1183 else 1184 { 1185 spec = getenv ("SUNPRO_DEPENDENCIES"); 1186 if (spec) 1187 { 1188 cpp_opts->deps.style = DEPS_SYSTEM; 1189 cpp_opts->deps.ignore_main_file = true; 1190 } 1191 } 1192 1193 if (spec) 1194 { 1195 /* Find the space before the DEPS_TARGET, if there is one. */ 1196 char *s = strchr (spec, ' '); 1197 if (s) 1198 { 1199 /* Let the caller perform MAKE quoting. */ 1200 defer_opt (OPT_MT, s + 1); 1201 *s = '\0'; 1202 } 1203 1204 /* Command line -MF overrides environment variables and default. */ 1205 if (!deps_file) 1206 deps_file = spec; 1207 1208 deps_append = 1; 1209 deps_seen = true; 1210 } 1211 } 1212 1213 /* Handle deferred command line switches. */ 1214 static void 1215 handle_deferred_opts (void) 1216 { 1217 size_t i; 1218 struct deps *deps; 1219 1220 /* Avoid allocating the deps buffer if we don't need it. 1221 (This flag may be true without there having been -MT or -MQ 1222 options, but we'll still need the deps buffer.) */ 1223 if (!deps_seen) 1224 return; 1225 1226 deps = cpp_get_deps (parse_in); 1227 1228 for (i = 0; i < deferred_count; i++) 1229 { 1230 struct deferred_opt *opt = &deferred_opts[i]; 1231 1232 if (opt->code == OPT_MT || opt->code == OPT_MQ) 1233 deps_add_target (deps, opt->arg, opt->code == OPT_MQ); 1234 } 1235 } 1236 1237 /* These settings are appropriate for GCC, but not necessarily so for 1238 cpplib as a library. */ 1239 static void 1240 sanitize_cpp_opts (void) 1241 { 1242 /* If we don't know what style of dependencies to output, complain 1243 if any other dependency switches have been given. */ 1244 if (deps_seen && cpp_opts->deps.style == DEPS_NONE) 1245 error ("to generate dependencies you must specify either -M or -MM"); 1246 1247 /* -dM and dependencies suppress normal output; do it here so that 1248 the last -d[MDN] switch overrides earlier ones. */ 1249 if (flag_dump_macros == 'M') 1250 flag_no_output = 1; 1251 1252 /* By default, -fdirectives-only implies -dD. This allows subsequent phases 1253 to perform proper macro expansion. */ 1254 if (cpp_opts->directives_only && !cpp_opts->preprocessed && !flag_dump_macros) 1255 flag_dump_macros = 'D'; 1256 1257 /* Disable -dD, -dN and -dI if normal output is suppressed. Allow 1258 -dM since at least glibc relies on -M -dM to work. */ 1259 /* Also, flag_no_output implies flag_no_line_commands, always. */ 1260 if (flag_no_output) 1261 { 1262 if (flag_dump_macros != 'M') 1263 flag_dump_macros = 0; 1264 flag_dump_includes = 0; 1265 flag_no_line_commands = 1; 1266 } 1267 else if (cpp_opts->deps.missing_files) 1268 error ("-MG may only be used with -M or -MM"); 1269 1270 cpp_opts->unsigned_char = !flag_signed_char; 1271 cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS; 1272 1273 /* Wlong-long is disabled by default. It is enabled by: 1274 [-pedantic | -Wtraditional] -std=[gnu|c]++98 ; or 1275 [-pedantic | -Wtraditional] -std=non-c99 . 1276 1277 Either -Wlong-long or -Wno-long-long override any other settings. */ 1278 if (warn_long_long == -1) 1279 warn_long_long = ((pedantic || warn_traditional) 1280 && (c_dialect_cxx () ? cxx_dialect == cxx98 : !flag_isoc99)); 1281 cpp_opts->cpp_warn_long_long = warn_long_long; 1282 1283 /* Similarly with -Wno-variadic-macros. No check for c99 here, since 1284 this also turns off warnings about GCCs extension. */ 1285 cpp_opts->warn_variadic_macros 1286 = warn_variadic_macros && (pedantic || warn_traditional); 1287 1288 /* If we're generating preprocessor output, emit current directory 1289 if explicitly requested or if debugging information is enabled. 1290 ??? Maybe we should only do it for debugging formats that 1291 actually output the current directory? */ 1292 if (flag_working_directory == -1) 1293 flag_working_directory = (debug_info_level != DINFO_LEVEL_NONE); 1294 1295 if (cpp_opts->directives_only) 1296 { 1297 if (warn_unused_macros) 1298 error ("-fdirectives-only is incompatible with -Wunused_macros"); 1299 if (cpp_opts->traditional) 1300 error ("-fdirectives-only is incompatible with -traditional"); 1301 } 1302 } 1303 1304 /* Add include path with a prefix at the front of its name. */ 1305 static void 1306 add_prefixed_path (const char *suffix, size_t chain) 1307 { 1308 char *path; 1309 const char *prefix; 1310 size_t prefix_len, suffix_len; 1311 1312 suffix_len = strlen (suffix); 1313 prefix = iprefix ? iprefix : cpp_GCC_INCLUDE_DIR; 1314 prefix_len = iprefix ? strlen (iprefix) : cpp_GCC_INCLUDE_DIR_len; 1315 1316 path = (char *) xmalloc (prefix_len + suffix_len + 1); 1317 memcpy (path, prefix, prefix_len); 1318 memcpy (path + prefix_len, suffix, suffix_len); 1319 path[prefix_len + suffix_len] = '\0'; 1320 1321 add_path (path, chain, 0, false); 1322 } 1323 1324 /* Handle -D, -U, -A, -imacros, and the first -include. */ 1325 static void 1326 c_finish_options (void) 1327 { 1328 if (!cpp_opts->preprocessed) 1329 { 1330 size_t i; 1331 1332 { 1333 /* Make sure all of the builtins about to be declared have 1334 BUILTINS_LOCATION has their source_location. */ 1335 source_location builtins_loc = BUILTINS_LOCATION; 1336 cpp_force_token_locations (parse_in, &builtins_loc); 1337 1338 cpp_init_builtins (parse_in, flag_hosted); 1339 c_cpp_builtins (parse_in); 1340 1341 cpp_stop_forcing_token_locations (parse_in); 1342 } 1343 1344 /* We're about to send user input to cpplib, so make it warn for 1345 things that we previously (when we sent it internal definitions) 1346 told it to not warn. 1347 1348 C99 permits implementation-defined characters in identifiers. 1349 The documented meaning of -std= is to turn off extensions that 1350 conflict with the specified standard, and since a strictly 1351 conforming program cannot contain a '$', we do not condition 1352 their acceptance on the -std= setting. */ 1353 cpp_opts->warn_dollars = (cpp_opts->cpp_pedantic && !cpp_opts->c99); 1354 1355 cb_file_change (parse_in, 1356 linemap_add (line_table, LC_RENAME, 0, 1357 _("<command-line>"), 0)); 1358 1359 for (i = 0; i < deferred_count; i++) 1360 { 1361 struct deferred_opt *opt = &deferred_opts[i]; 1362 1363 if (opt->code == OPT_D) 1364 cpp_define (parse_in, opt->arg); 1365 else if (opt->code == OPT_U) 1366 cpp_undef (parse_in, opt->arg); 1367 else if (opt->code == OPT_A) 1368 { 1369 if (opt->arg[0] == '-') 1370 cpp_unassert (parse_in, opt->arg + 1); 1371 else 1372 cpp_assert (parse_in, opt->arg); 1373 } 1374 } 1375 1376 /* Start the main input file, if the debug writer wants it. */ 1377 if (debug_hooks->start_end_main_source_file 1378 && !flag_preprocess_only) 1379 (*debug_hooks->start_source_file) (0, this_input_filename); 1380 1381 /* Handle -imacros after -D and -U. */ 1382 for (i = 0; i < deferred_count; i++) 1383 { 1384 struct deferred_opt *opt = &deferred_opts[i]; 1385 1386 if (opt->code == OPT_imacros 1387 && cpp_push_include (parse_in, opt->arg)) 1388 { 1389 /* Disable push_command_line_include callback for now. */ 1390 include_cursor = deferred_count + 1; 1391 cpp_scan_nooutput (parse_in); 1392 } 1393 } 1394 } 1395 else 1396 { 1397 if (cpp_opts->directives_only) 1398 cpp_init_special_builtins (parse_in); 1399 1400 /* Start the main input file, if the debug writer wants it. */ 1401 if (debug_hooks->start_end_main_source_file 1402 && !flag_preprocess_only) 1403 (*debug_hooks->start_source_file) (0, this_input_filename); 1404 } 1405 1406 include_cursor = 0; 1407 push_command_line_include (); 1408 } 1409 1410 /* Give CPP the next file given by -include, if any. */ 1411 static void 1412 push_command_line_include (void) 1413 { 1414 while (include_cursor < deferred_count) 1415 { 1416 struct deferred_opt *opt = &deferred_opts[include_cursor++]; 1417 1418 if (!cpp_opts->preprocessed && opt->code == OPT_include 1419 && cpp_push_include (parse_in, opt->arg)) 1420 return; 1421 } 1422 1423 if (include_cursor == deferred_count) 1424 { 1425 include_cursor++; 1426 /* -Wunused-macros should only warn about macros defined hereafter. */ 1427 cpp_opts->warn_unused_macros = warn_unused_macros; 1428 /* Restore the line map from <command line>. */ 1429 if (!cpp_opts->preprocessed) 1430 cpp_change_file (parse_in, LC_RENAME, this_input_filename); 1431 1432 /* Set this here so the client can change the option if it wishes, 1433 and after stacking the main file so we don't trace the main file. */ 1434 line_table->trace_includes = cpp_opts->print_include_names; 1435 } 1436 } 1437 1438 /* File change callback. Has to handle -include files. */ 1439 static void 1440 cb_file_change (cpp_reader * ARG_UNUSED (pfile), 1441 const struct line_map *new_map) 1442 { 1443 if (flag_preprocess_only) 1444 pp_file_change (new_map); 1445 else 1446 fe_file_change (new_map); 1447 1448 if (new_map == 0 || (new_map->reason == LC_LEAVE && MAIN_FILE_P (new_map))) 1449 push_command_line_include (); 1450 } 1451 1452 void 1453 cb_dir_change (cpp_reader * ARG_UNUSED (pfile), const char *dir) 1454 { 1455 if (!set_src_pwd (dir)) 1456 warning (0, "too late for # directive to set debug directory"); 1457 } 1458 1459 /* Set the C 89 standard (with 1994 amendments if C94, without GNU 1460 extensions if ISO). There is no concept of gnu94. */ 1461 static void 1462 set_std_c89 (int c94, int iso) 1463 { 1464 cpp_set_lang (parse_in, c94 ? CLK_STDC94: iso ? CLK_STDC89: CLK_GNUC89); 1465 flag_iso = iso; 1466 flag_no_asm = iso; 1467 flag_no_gnu_keywords = iso; 1468 flag_no_nonansi_builtin = iso; 1469 flag_isoc94 = c94; 1470 flag_isoc99 = 0; 1471 flag_isoc11 = 0; 1472 } 1473 1474 /* Set the C 99 standard (without GNU extensions if ISO). */ 1475 static void 1476 set_std_c99 (int iso) 1477 { 1478 cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99); 1479 flag_no_asm = iso; 1480 flag_no_nonansi_builtin = iso; 1481 flag_iso = iso; 1482 flag_isoc11 = 0; 1483 flag_isoc99 = 1; 1484 flag_isoc94 = 1; 1485 } 1486 1487 /* Set the C 11 standard (without GNU extensions if ISO). */ 1488 static void 1489 set_std_c11 (int iso) 1490 { 1491 cpp_set_lang (parse_in, iso ? CLK_STDC11: CLK_GNUC11); 1492 flag_no_asm = iso; 1493 flag_no_nonansi_builtin = iso; 1494 flag_iso = iso; 1495 flag_isoc11 = 1; 1496 flag_isoc99 = 1; 1497 flag_isoc94 = 1; 1498 } 1499 1500 /* Set the C++ 98 standard (without GNU extensions if ISO). */ 1501 static void 1502 set_std_cxx98 (int iso) 1503 { 1504 cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX); 1505 flag_no_gnu_keywords = iso; 1506 flag_no_nonansi_builtin = iso; 1507 flag_iso = iso; 1508 cxx_dialect = cxx98; 1509 } 1510 1511 /* Set the C++ 2011 standard (without GNU extensions if ISO). */ 1512 static void 1513 set_std_cxx11 (int iso) 1514 { 1515 cpp_set_lang (parse_in, iso ? CLK_CXX11: CLK_GNUCXX11); 1516 flag_no_gnu_keywords = iso; 1517 flag_no_nonansi_builtin = iso; 1518 flag_iso = iso; 1519 /* C++11 includes the C99 standard library. */ 1520 flag_isoc94 = 1; 1521 flag_isoc99 = 1; 1522 cxx_dialect = cxx11; 1523 } 1524 1525 /* Args to -d specify what to dump. Silently ignore 1526 unrecognized options; they may be aimed at toplev.c. */ 1527 static void 1528 handle_OPT_d (const char *arg) 1529 { 1530 char c; 1531 1532 while ((c = *arg++) != '\0') 1533 switch (c) 1534 { 1535 case 'M': /* Dump macros only. */ 1536 case 'N': /* Dump names. */ 1537 case 'D': /* Dump definitions. */ 1538 case 'U': /* Dump used macros. */ 1539 flag_dump_macros = c; 1540 break; 1541 1542 case 'I': 1543 flag_dump_includes = 1; 1544 break; 1545 } 1546 } 1547