gcc/c-opts.c

   1 /* C/ObjC/C++ command line option handling.
   2    Copyright (C) 2002, 2003 Free Software Foundation, Inc.
   3    Contributed by Neil Booth.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "tree.h"
  27 #include "c-common.h"
  28 #include "c-pragma.h"
  29 #include "flags.h"
  30 #include "toplev.h"
  31 #include "langhooks.h"
  32 #include "tree-inline.h"
  33 #include "diagnostic.h"
  34 #include "intl.h"
  35 #include "cppdefault.h"
  36 #include "c-incpath.h"
  37 #include "debug.h"              /* For debug_hooks.  */
  38 #include "opts.h"
  39 #include "c-options.h"
  40
  41 #ifndef DOLLARS_IN_IDENTIFIERS
  42 # define DOLLARS_IN_IDENTIFIERS true
  43 #endif
  44
  45 #ifndef TARGET_SYSTEM_ROOT
  46 # define TARGET_SYSTEM_ROOT NULL
  47 #endif
  48
  49 #ifndef TARGET_EBCDIC
  50 # define TARGET_EBCDIC 0
  51 #endif
  52
  53 static const int lang_flags[] = {CL_C, CL_OBJC, CL_CXX, CL_OBJCXX};
  54
  55 static int saved_lineno;
  56
  57 /* CPP's options.  */
  58 static cpp_options *cpp_opts;
  59
  60 /* Input filename.  */
  61 static const char *in_fname;
  62
  63 /* Filename and stream for preprocessed output.  */
  64 static const char *out_fname;
  65 static FILE *out_stream;
  66
  67 /* Append dependencies to deps_file.  */
  68 static bool deps_append;
  69
  70 /* If dependency switches (-MF etc.) have been given.  */
  71 static bool deps_seen;
  72
  73 /* If -v seen.  */
  74 static bool verbose;
  75
  76 /* Dependency output file.  */
  77 static const char *deps_file;
  78
  79 /* The prefix given by -iprefix, if any.  */
  80 static const char *iprefix;
  81
  82 /* The system root, if any.  Overridden by -isysroot.  */
  83 static const char *sysroot = TARGET_SYSTEM_ROOT;
  84
  85 /* Zero disables all standard directories for headers.  */
  86 static bool std_inc = true;
  87
  88 /* Zero disables the C++-specific standard directories for headers.  */
  89 static bool std_cxx_inc = true;
  90
  91 /* If the quote chain has been split by -I-.  */
  92 static bool quote_chain_split;
  93
  94 /* If -Wunused-macros.  */
  95 static bool warn_unused_macros;
  96
  97 /* Number of deferred options, deferred options array size.  */
  98 static size_t deferred_count, deferred_size;
  99
 100 /* Number of deferred options scanned for -include.  */
 101 static size_t include_cursor;
 102
 103 static void missing_arg PARAMS ((enum opt_code));
 104 static void set_Wimplicit PARAMS ((int));
 105 static void complain_wrong_lang PARAMS ((size_t));
 106 static void write_langs PARAMS ((char *, int));
 107 static void print_help PARAMS ((void));
 108 static void handle_OPT_d PARAMS ((const char *));
 109 static void set_std_cxx98 PARAMS ((int));
 110 static void set_std_c89 PARAMS ((int, int));
 111 static void set_std_c99 PARAMS ((int));
 112 static void check_deps_environment_vars PARAMS ((void));
 113 static void handle_deferred_opts PARAMS ((void));
 114 static void sanitize_cpp_opts PARAMS ((void));
 115 static void add_prefixed_path PARAMS ((const char *, size_t));
 116 static void push_command_line_include PARAMS ((void));
 117 static void cb_file_change PARAMS ((cpp_reader *, const struct line_map *));
 118 static void finish_options PARAMS ((void));
 119
 120 #ifndef STDC_0_IN_SYSTEM_HEADERS
 121 #define STDC_0_IN_SYSTEM_HEADERS 0
 122 #endif
 123
 124 /* Holds switches parsed by c_common_handle_option (), but whose
 125    handling is deferred to c_common_post_options ().  */
 126 static void defer_opt PARAMS ((enum opt_code, const char *));
 127 static struct deferred_opt
 128 {
 129   enum opt_code code;
 130   const char *arg;
 131 } *deferred_opts;
 132
 133 /* Complain that switch OPT_INDEX expects an argument but none was
 134    provided.  */
 135 static void
 136 missing_arg (enum opt_code code)
 137 {
 138   const char *opt_text = cl_options[code].opt_text;
 139
 140   switch (code)
 141     {
 142     case OPT__output_pch_:
 143     case OPT_Wformat_:
 144     case OPT_d:
 145     case OPT_fabi_version_:
 146     case OPT_fbuiltin_:
 147     case OPT_fdump_:
 148     case OPT_fname_mangling_version_:
 149     case OPT_ftabstop_:
 150     case OPT_ftemplate_depth_:
 151     case OPT_iprefix:
 152     case OPT_iwithprefix:
 153     case OPT_iwithprefixbefore:
 154     default:
 155       error ("missing argument to \"-%s\"", opt_text);
 156       break;
 157
 158     case OPT_fconstant_string_class_:
 159       error ("no class name specified with \"-%s\"", opt_text);
 160       break;
 161
 162     case OPT_A:
 163       error ("assertion missing after \"-%s\"", opt_text);
 164       break;
 165
 166     case OPT_D:
 167     case OPT_U:
 168       error ("macro name missing after \"-%s\"", opt_text);
 169       break;
 170
 171     case OPT_I:
 172     case OPT_idirafter:
 173     case OPT_isysroot:
 174     case OPT_isystem:
 175       error ("missing path after \"-%s\"", opt_text);
 176       break;
 177
 178     case OPT_MF:
 179     case OPT_MD:
 180     case OPT_MMD:
 181     case OPT_include:
 182     case OPT_imacros:
 183     case OPT_o:
 184       error ("missing filename after \"-%s\"", opt_text);
 185       break;
 186
 187     case OPT_MQ:
 188     case OPT_MT:
 189       error ("missing target after \"-%s\"", opt_text);
 190       break;
 191     }
 192 }
 193
 194 /* Defer option CODE with argument ARG.  */
 195 static void
 196 defer_opt (code, arg)
 197      enum opt_code code;
 198      const char *arg;
 199 {
 200   /* FIXME: this should be in c_common_init_options, which should take
 201      argc and argv.  */
 202   if (!deferred_opts)
 203     {
 204       extern int save_argc;
 205       deferred_size = save_argc;
 206       deferred_opts = (struct deferred_opt *)
 207         xmalloc (deferred_size * sizeof (struct deferred_opt));
 208     }
 209
 210   if (deferred_count == deferred_size)
 211     abort ();
 212
 213   deferred_opts[deferred_count].code = code;
 214   deferred_opts[deferred_count].arg = arg;
 215   deferred_count++;
 216 }
 217
 218 /* Common initialization before parsing options.  */
 219 int
 220 c_common_init_options (lang)
 221      enum c_language_kind lang;
 222 {
 223   c_language = lang;
 224   parse_in = cpp_create_reader (lang == clk_c ? CLK_GNUC89 : CLK_GNUCXX,
 225                                 ident_hash);
 226   cpp_opts = cpp_get_options (parse_in);
 227   cpp_opts->dollars_in_ident = DOLLARS_IN_IDENTIFIERS;
 228   if (flag_objc)
 229     cpp_opts->objc = 1;
 230
 231   flag_const_strings = (lang == clk_cplusplus);
 232   warn_pointer_arith = (lang == clk_cplusplus);
 233
 234   return lang_flags[(c_language << 1) + flag_objc];
 235 }
 236
 237 /* Handle switch SCODE with argument ARG.  ON is true, unless no-
 238    form of an -f or -W option was given.  Returns 0 if the switch was
 239    invalid, a negative number to prevent language-independent
 240    processing in toplev.c (a hack necessary for the short-term).  */
 241 int
 242 c_common_handle_option (size_t scode, const char *arg, int on)
 243 {
 244   const struct cl_option *option = &cl_options[scode];
 245   enum opt_code code = (enum opt_code) scode;
 246   int result = 1, lang_mask;
 247
 248   if (code == N_OPTS)
 249     {
 250       if (!in_fname)
 251         in_fname = arg;
 252       else if (!out_fname)
 253         out_fname = arg;
 254       else
 255           error ("too many filenames given.  Type %s --help for usage",
 256                  progname);
 257       return 1;
 258     }
 259
 260   lang_mask = lang_flags[(c_language << 1) + flag_objc];
 261   if (!(option->flags & lang_mask))
 262     {
 263       complain_wrong_lang (code);
 264       return 1;
 265     }
 266
 267   if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE)))
 268     {
 269       missing_arg (code);
 270       return 1;
 271     }
 272
 273   switch (code)
 274     {
 275     default:
 276       return 0;
 277
 278     case OPT__help:
 279       print_help ();
 280       break;
 281
 282     case OPT__output_pch_:
 283       pch_file = arg;
 284       break;
 285
 286     case OPT_A:
 287       defer_opt (code, arg);
 288       break;
 289
 290     case OPT_C:
 291       cpp_opts->discard_comments = 0;
 292       break;
 293
 294     case OPT_CC:
 295       cpp_opts->discard_comments = 0;
 296       cpp_opts->discard_comments_in_macro_exp = 0;
 297       break;
 298
 299     case OPT_D:
 300       defer_opt (code, arg);
 301       break;
 302
 303     case OPT_E:
 304       flag_preprocess_only = 1;
 305       break;
 306
 307     case OPT_H:
 308       cpp_opts->print_include_names = 1;
 309       break;
 310
 311     case OPT_I:
 312       if (strcmp (arg, "-"))
 313         add_path (xstrdup (arg), BRACKET, 0);
 314       else
 315         {
 316           if (quote_chain_split)
 317             error ("-I- specified twice");
 318           quote_chain_split = true;
 319           split_quote_chain ();
 320         }
 321       break;
 322
 323     case OPT_M:
 324     case OPT_MM:
 325       /* When doing dependencies with -M or -MM, suppress normal
 326          preprocessed output, but still do -dM etc. as software
 327          depends on this.  Preprocessed output does occur if -MD, -MMD
 328          or environment var dependency generation is used.  */
 329       cpp_opts->deps.style = (code == OPT_M ? DEPS_SYSTEM: DEPS_USER);
 330       flag_no_output = 1;
 331       cpp_opts->inhibit_warnings = 1;
 332       break;
 333
 334     case OPT_MD:
 335     case OPT_MMD:
 336       cpp_opts->deps.style = (code == OPT_MD ? DEPS_SYSTEM: DEPS_USER);
 337       deps_file = arg;
 338       break;
 339
 340     case OPT_MF:
 341       deps_seen = true;
 342       deps_file = arg;
 343       break;
 344
 345     case OPT_MG:
 346       deps_seen = true;
 347       cpp_opts->deps.missing_files = true;
 348       break;
 349
 350     case OPT_MP:
 351       deps_seen = true;
 352       cpp_opts->deps.phony_targets = true;
 353       break;
 354
 355     case OPT_MQ:
 356     case OPT_MT:
 357       deps_seen = true;
 358       defer_opt (code, arg);
 359       break;
 360
 361     case OPT_P:
 362       flag_no_line_commands = 1;
 363       break;
 364
 365     case OPT_U:
 366       defer_opt (code, arg);
 367       break;
 368
 369     case OPT_Wabi:
 370       warn_abi = on;
 371       break;
 372
 373     case OPT_Wall:
 374       set_Wunused (on);
 375       set_Wformat (on);
 376       set_Wimplicit (on);
 377       warn_char_subscripts = on;
 378       warn_missing_braces = on;
 379       warn_parentheses = on;
 380       warn_return_type = on;
 381       warn_sequence_point = on; /* Was C only.  */
 382       if (c_language == clk_cplusplus)
 383         warn_sign_compare = on;
 384       warn_switch = on;
 385       warn_strict_aliasing = on;
 386
 387       /* Only warn about unknown pragmas that are not in system
 388          headers.  */
 389       warn_unknown_pragmas = on;
 390
 391       /* We save the value of warn_uninitialized, since if they put
 392          -Wuninitialized on the command line, we need to generate a
 393          warning about not using it without also specifying -O.  */
 394       if (warn_uninitialized != 1)
 395         warn_uninitialized = (on ? 2 : 0);
 396
 397       if (c_language == clk_c)
 398         /* We set this to 2 here, but 1 in -Wmain, so -ffreestanding
 399            can turn it off only if it's not explicit.  */
 400         warn_main = on * 2;
 401       else
 402         {
 403           /* C++-specific warnings.  */
 404           warn_nonvdtor = on;
 405           warn_reorder = on;
 406           warn_nontemplate_friend = on;
 407         }
 408
 409       cpp_opts->warn_trigraphs = on;
 410       cpp_opts->warn_comments = on;
 411       cpp_opts->warn_num_sign_change = on;
 412       cpp_opts->warn_multichar = on;    /* Was C++ only.  */
 413       break;
 414
 415     case OPT_Wbad_function_cast:
 416       warn_bad_function_cast = on;
 417       break;
 418
 419     case OPT_Wcast_qual:
 420       warn_cast_qual = on;
 421       break;
 422
 423     case OPT_Wchar_subscripts:
 424       warn_char_subscripts = on;
 425       break;
 426
 427     case OPT_Wcomment:
 428     case OPT_Wcomments:
 429       cpp_opts->warn_comments = on;
 430       break;
 431
 432     case OPT_Wconversion:
 433       warn_conversion = on;
 434       break;
 435
 436     case OPT_Wctor_dtor_privacy:
 437       warn_ctor_dtor_privacy = on;
 438       break;
 439
 440     case OPT_Wdeprecated:
 441       warn_deprecated = on;
 442       cpp_opts->warn_deprecated = on;
 443       break;
 444
 445     case OPT_Wdiv_by_zero:
 446       warn_div_by_zero = on;
 447       break;
 448
 449     case OPT_Weffc__:
 450       warn_ecpp = on;
 451       break;
 452
 453     case OPT_Wendif_labels:
 454       cpp_opts->warn_endif_labels = on;
 455       break;
 456
 457     case OPT_Werror:
 458       cpp_opts->warnings_are_errors = on;
 459       break;
 460
 461     case OPT_Werror_implicit_function_declaration:
 462       mesg_implicit_function_declaration = 2;
 463       break;
 464
 465     case OPT_Wfloat_equal:
 466       warn_float_equal = on;
 467       break;
 468
 469     case OPT_Wformat:
 470       set_Wformat (on);
 471       break;
 472
 473     case OPT_Wformat_:
 474       set_Wformat (atoi (arg));
 475       break;
 476
 477     case OPT_Wformat_extra_args:
 478       warn_format_extra_args = on;
 479       break;
 480
 481     case OPT_Wformat_nonliteral:
 482       warn_format_nonliteral = on;
 483       break;
 484
 485     case OPT_Wformat_security:
 486       warn_format_security = on;
 487       break;
 488
 489     case OPT_Wformat_y2k:
 490       warn_format_y2k = on;
 491       break;
 492
 493     case OPT_Wformat_zero_length:
 494       warn_format_zero_length = on;
 495       break;
 496
 497     case OPT_Wimplicit:
 498       set_Wimplicit (on);
 499       break;
 500
 501     case OPT_Wimplicit_function_declaration:
 502       mesg_implicit_function_declaration = on;
 503       break;
 504
 505     case OPT_Wimplicit_int:
 506       warn_implicit_int = on;
 507       break;
 508
 509     case OPT_Wimport:
 510       cpp_opts->warn_import = on;
 511       break;
 512
 513     case OPT_Winvalid_offsetof:
 514       warn_invalid_offsetof = on;
 515       break;
 516
 517     case OPT_Winvalid_pch:
 518       cpp_opts->warn_invalid_pch = on;
 519       break;
 520
 521     case OPT_Wlong_long:
 522       warn_long_long = on;
 523       break;
 524
 525     case OPT_Wmain:
 526       if (on)
 527         warn_main = 1;
 528       else
 529         warn_main = -1;
 530       break;
 531
 532     case OPT_Wmissing_braces:
 533       warn_missing_braces = on;
 534       break;
 535
 536     case OPT_Wmissing_declarations:
 537       warn_missing_declarations = on;
 538       break;
 539
 540     case OPT_Wmissing_format_attribute:
 541       warn_missing_format_attribute = on;
 542       break;
 543
 544     case OPT_Wmissing_prototypes:
 545       warn_missing_prototypes = on;
 546       break;
 547
 548     case OPT_Wmultichar:
 549       cpp_opts->warn_multichar = on;
 550       break;
 551
 552     case OPT_Wnested_externs:
 553       warn_nested_externs = on;
 554       break;
 555
 556     case OPT_Wnon_template_friend:
 557       warn_nontemplate_friend = on;
 558       break;
 559
 560     case OPT_Wnon_virtual_dtor:
 561       warn_nonvdtor = on;
 562       break;
 563
 564     case OPT_Wnonnull:
 565       warn_nonnull = on;
 566       break;
 567
 568     case OPT_Wold_style_cast:
 569       warn_old_style_cast = on;
 570       break;
 571
 572     case OPT_Woverloaded_virtual:
 573       warn_overloaded_virtual = on;
 574       break;
 575
 576     case OPT_Wparentheses:
 577       warn_parentheses = on;
 578       break;
 579
 580     case OPT_Wpmf_conversions:
 581       warn_pmf2ptr = on;
 582       break;
 583
 584     case OPT_Wpointer_arith:
 585       warn_pointer_arith = on;
 586       break;
 587
 588     case OPT_Wprotocol:
 589       warn_protocol = on;
 590       break;
 591
 592     case OPT_Wselector:
 593       warn_selector = on;
 594       break;
 595
 596     case OPT_Wredundant_decls:
 597       warn_redundant_decls = on;
 598       break;
 599
 600     case OPT_Wreorder:
 601       warn_reorder = on;
 602       break;
 603
 604     case OPT_Wreturn_type:
 605       warn_return_type = on;
 606       break;
 607
 608     case OPT_Wsequence_point:
 609       warn_sequence_point = on;
 610       break;
 611
 612     case OPT_Wsign_compare:
 613       warn_sign_compare = on;
 614       break;
 615
 616     case OPT_Wsign_promo:
 617       warn_sign_promo = on;
 618       break;
 619
 620     case OPT_Wstrict_prototypes:
 621       warn_strict_prototypes = on;
 622       break;
 623
 624     case OPT_Wsynth:
 625       warn_synth = on;
 626       break;
 627
 628     case OPT_Wsystem_headers:
 629       cpp_opts->warn_system_headers = on;
 630       break;
 631
 632     case OPT_Wtraditional:
 633       warn_traditional = on;
 634       cpp_opts->warn_traditional = on;
 635       break;
 636
 637     case OPT_Wtrigraphs:
 638       cpp_opts->warn_trigraphs = on;
 639       break;
 640
 641     case OPT_Wundeclared_selector:
 642       warn_undeclared_selector = on;
 643       break;
 644
 645     case OPT_Wundef:
 646       cpp_opts->warn_undef = on;
 647       break;
 648
 649     case OPT_Wunknown_pragmas:
 650       /* Set to greater than 1, so that even unknown pragmas in
 651          system headers will be warned about.  */
 652       warn_unknown_pragmas = on * 2;
 653       break;
 654
 655     case OPT_Wunused_macros:
 656       warn_unused_macros = on;
 657       break;
 658
 659     case OPT_Wwrite_strings:
 660       if (c_language == clk_c)
 661         flag_const_strings = on;
 662       else
 663         warn_write_strings = on;
 664       break;
 665
 666     case OPT_ansi:
 667       if (c_language == clk_c)
 668         set_std_c89 (false, true);
 669       else
 670         set_std_cxx98 (true);
 671       break;
 672
 673     case OPT_d:
 674       handle_OPT_d (arg);
 675       break;
 676
 677     case OPT_fcond_mismatch:
 678       if (c_language == clk_c)
 679         {
 680           flag_cond_mismatch = on;
 681           break;
 682         }
 683       /* Fall through.  */
 684
 685     case OPT_fall_virtual:
 686     case OPT_fenum_int_equiv:
 687     case OPT_fguiding_decls:
 688     case OPT_fhonor_std:
 689     case OPT_fhuge_objects:
 690     case OPT_flabels_ok:
 691     case OPT_fname_mangling_version_:
 692     case OPT_fnew_abi:
 693     case OPT_fnonnull_objects:
 694     case OPT_fsquangle:
 695     case OPT_fstrict_prototype:
 696     case OPT_fthis_is_variable:
 697     case OPT_fvtable_thunks:
 698     case OPT_fxref:
 699       warning ("switch \"%s\" is no longer supported", option->opt_text);
 700       break;
 701
 702     case OPT_fabi_version_:
 703       flag_abi_version = read_integral_parameter (arg, option->opt_text, 1);
 704       break;
 705
 706     case OPT_faccess_control:
 707       flag_access_control = on;
 708       break;
 709
 710     case OPT_falt_external_templates:
 711       flag_alt_external_templates = on;
 712       if (on)
 713         flag_external_templates = true;
 714     cp_deprecated:
 715       warning ("switch \"%s\" is deprecated, please see documentation for details", option->opt_text);
 716       break;
 717
 718     case OPT_fasm:
 719       flag_no_asm = !on;
 720       break;
 721
 722     case OPT_fbuiltin:
 723       flag_no_builtin = !on;
 724       break;
 725
 726     case OPT_fbuiltin_:
 727       if (on)
 728         result = 0;
 729       else
 730         disable_builtin_function (arg);
 731       break;
 732
 733     case OPT_fdollars_in_identifiers:
 734       cpp_opts->dollars_in_ident = on;
 735       break;
 736
 737     case OPT_fdump_:
 738       if (!dump_switch_p (option->opt_text + strlen ("f")))
 739         result = 0;
 740       break;
 741
 742     case OPT_ffreestanding:
 743       on = !on;
 744       /* Fall through...  */
 745     case OPT_fhosted:
 746       flag_hosted = on;
 747       flag_no_builtin = !on;
 748       /* warn_main will be 2 if set by -Wall, 1 if set by -Wmain */
 749       if (!on && warn_main == 2)
 750         warn_main = 0;
 751       break;
 752
 753     case OPT_fshort_double:
 754       flag_short_double = on;
 755       break;
 756
 757     case OPT_fshort_enums:
 758       flag_short_enums = on;
 759       break;
 760
 761     case OPT_fshort_wchar:
 762       flag_short_wchar = on;
 763       break;
 764
 765     case OPT_fsigned_bitfields:
 766       flag_signed_bitfields = on;
 767       explicit_flag_signed_bitfields = 1;
 768       break;
 769
 770     case OPT_fsigned_char:
 771       flag_signed_char = on;
 772       break;
 773
 774     case OPT_funsigned_bitfields:
 775       flag_signed_bitfields = !on;
 776       explicit_flag_signed_bitfields = 1;
 777       break;
 778
 779     case OPT_funsigned_char:
 780       flag_signed_char = !on;
 781       break;
 782
 783     case OPT_fcheck_new:
 784       flag_check_new = on;
 785       break;
 786
 787     case OPT_fconserve_space:
 788       flag_conserve_space = on;
 789       break;
 790
 791     case OPT_fconst_strings:
 792       flag_const_strings = on;
 793       break;
 794
 795     case OPT_fconstant_string_class_:
 796       constant_string_class_name = arg;
 797       break;
 798
 799     case OPT_fdefault_inline:
 800       flag_default_inline = on;
 801       break;
 802
 803     case OPT_felide_constructors:
 804       flag_elide_constructors = on;
 805       break;
 806
 807     case OPT_fenforce_eh_specs:
 808       flag_enforce_eh_specs = on;
 809       break;
 810
 811     case OPT_fexternal_templates:
 812       flag_external_templates = on;
 813       goto cp_deprecated;
 814
 815     case OPT_ffixed_form:
 816     case OPT_ffixed_line_length_:
 817       /* Fortran front end options ignored when preprocessing only.  */
 818       if (flag_preprocess_only)
 819         result = -1;
 820       break;
 821
 822     case OPT_ffor_scope:
 823       flag_new_for_scope = on;
 824       break;
 825
 826     case OPT_fgnu_keywords:
 827       flag_no_gnu_keywords = !on;
 828       break;
 829
 830     case OPT_fgnu_runtime:
 831       flag_next_runtime = !on;
 832       break;
 833
 834     case OPT_fhandle_exceptions:
 835       warning ("-fhandle-exceptions has been renamed -fexceptions (and is now on by default)");
 836       flag_exceptions = on;
 837       break;
 838
 839     case OPT_fimplement_inlines:
 840       flag_implement_inlines = on;
 841       break;
 842
 843     case OPT_fimplicit_inline_templates:
 844       flag_implicit_inline_templates = on;
 845       break;
 846
 847     case OPT_fimplicit_templates:
 848       flag_implicit_templates = on;
 849       break;
 850
 851     case OPT_fms_extensions:
 852       flag_ms_extensions = on;
 853       break;
 854
 855     case OPT_fnext_runtime:
 856       flag_next_runtime = on;
 857       break;
 858
 859     case OPT_fnonansi_builtins:
 860       flag_no_nonansi_builtin = !on;
 861       break;
 862
 863     case OPT_foperator_names:
 864       cpp_opts->operator_names = on;
 865       break;
 866
 867     case OPT_foptional_diags:
 868       flag_optional_diags = on;
 869       break;
 870
 871     case OPT_fpch_deps:
 872       cpp_opts->restore_pch_deps = on;
 873       break;
 874
 875     case OPT_fpermissive:
 876       flag_permissive = on;
 877       break;
 878
 879     case OPT_fpreprocessed:
 880       cpp_opts->preprocessed = on;
 881       break;
 882
 883     case OPT_frepo:
 884       flag_use_repository = on;
 885       if (on)
 886         flag_implicit_templates = 0;
 887       break;
 888
 889     case OPT_frtti:
 890       flag_rtti = on;
 891       break;
 892
 893     case OPT_fshow_column:
 894       cpp_opts->show_column = on;
 895       break;
 896
 897     case OPT_fstats:
 898       flag_detailed_statistics = on;
 899       break;
 900
 901     case OPT_ftabstop_:
 902       /* It is documented that we silently ignore silly values.  */
 903         {
 904           char *endptr;
 905           long tabstop = strtol (arg, &endptr, 10);
 906           if (*endptr == '\0' && tabstop >= 1 && tabstop <= 100)
 907             cpp_opts->tabstop = tabstop;
 908         }
 909       break;
 910
 911     case OPT_ftemplate_depth_:
 912       max_tinst_depth = read_integral_parameter (arg, option->opt_text, 0);
 913       break;
 914
 915     case OPT_fvtable_gc:
 916       flag_vtable_gc = on;
 917       break;
 918
 919     case OPT_fuse_cxa_atexit:
 920       flag_use_cxa_atexit = on;
 921       break;
 922
 923     case OPT_fweak:
 924       flag_weak = on;
 925       break;
 926
 927     case OPT_gen_decls:
 928       flag_gen_declaration = 1;
 929       break;
 930
 931     case OPT_idirafter:
 932       add_path (xstrdup (arg), AFTER, 0);
 933       break;
 934
 935     case OPT_imacros:
 936     case OPT_include:
 937       defer_opt (code, arg);
 938       break;
 939
 940     case OPT_iprefix:
 941       iprefix = arg;
 942       break;
 943
 944     case OPT_isysroot:
 945       sysroot = arg;
 946       break;
 947
 948     case OPT_isystem:
 949       add_path (xstrdup (arg), SYSTEM, 0);
 950       break;
 951
 952     case OPT_iwithprefix:
 953       add_prefixed_path (arg, SYSTEM);
 954       break;
 955
 956     case OPT_iwithprefixbefore:
 957       add_prefixed_path (arg, BRACKET);
 958       break;
 959
 960     case OPT_lang_asm:
 961       cpp_set_lang (parse_in, CLK_ASM);
 962       cpp_opts->dollars_in_ident = false;
 963       break;
 964
 965     case OPT_lang_objc:
 966       cpp_opts->objc = 1;
 967       break;
 968
 969     case OPT_nostdinc:
 970       std_inc = false;
 971       break;
 972
 973     case OPT_nostdinc__:
 974       std_cxx_inc = false;
 975       break;
 976
 977     case OPT_o:
 978       if (!out_fname)
 979         out_fname = arg;
 980       else
 981         error ("output filename specified twice");
 982       break;
 983
 984       /* We need to handle the -pedantic switches here, rather than in
 985          c_common_post_options, so that a subsequent -Wno-endif-labels
 986          is not overridden.  */
 987     case OPT_pedantic_errors:
 988       cpp_opts->pedantic_errors = 1;
 989       /* fall through */
 990     case OPT_pedantic:
 991       cpp_opts->pedantic = 1;
 992       cpp_opts->warn_endif_labels = 1;
 993       break;
 994
 995     case OPT_print_objc_runtime_info:
 996       print_struct_values = 1;
 997       break;
 998
 999     case OPT_remap:
1000       cpp_opts->remap = 1;
1001       break;
1002
1003     case OPT_std_c__98:
1004     case OPT_std_gnu__98:
1005       set_std_cxx98 (code == OPT_std_c__98 /* ISO */);
1006       break;
1007
1008     case OPT_std_c89:
1009     case OPT_std_iso9899_1990:
1010     case OPT_std_iso9899_199409:
1011       set_std_c89 (code == OPT_std_iso9899_199409 /* c94 */, true /* ISO */);
1012       break;
1013
1014     case OPT_std_gnu89:
1015       set_std_c89 (false /* c94 */, false /* ISO */);
1016       break;
1017
1018     case OPT_std_c99:
1019     case OPT_std_c9x:
1020     case OPT_std_iso9899_1999:
1021     case OPT_std_iso9899_199x:
1022       set_std_c99 (true /* ISO */);
1023       break;
1024
1025     case OPT_std_gnu99:
1026     case OPT_std_gnu9x:
1027       set_std_c99 (false /* ISO */);
1028       break;
1029
1030     case OPT_trigraphs:
1031       cpp_opts->trigraphs = 1;
1032       break;
1033
1034     case OPT_traditional_cpp:
1035       cpp_opts->traditional = 1;
1036       break;
1037
1038     case OPT_undef:
1039       flag_undef = 1;
1040       break;
1041
1042     case OPT_w:
1043       cpp_opts->inhibit_warnings = 1;
1044       break;
1045
1046     case OPT_v:
1047       verbose = true;
1048       break;
1049     }
1050
1051   return result;
1052 }
1053
1054 /* Post-switch processing.  */
1055 bool
1056 c_common_post_options (pfilename)
1057      const char **pfilename;
1058 {
1059   /* Canonicalize the input and output filenames.  */
1060   if (in_fname == NULL || !strcmp (in_fname, "-"))
1061     in_fname = "";
1062
1063   if (out_fname == NULL || !strcmp (out_fname, "-"))
1064     out_fname = "";
1065
1066   if (cpp_opts->deps.style == DEPS_NONE)
1067     check_deps_environment_vars ();
1068
1069   handle_deferred_opts ();
1070
1071   sanitize_cpp_opts ();
1072
1073   register_include_chains (parse_in, sysroot, iprefix,
1074                            std_inc, std_cxx_inc && c_language == clk_cplusplus,
1075                            verbose);
1076
1077   flag_inline_trees = 1;
1078
1079   /* Use tree inlining if possible.  Function instrumentation is only
1080      done in the RTL level, so we disable tree inlining.  */
1081   if (! flag_instrument_function_entry_exit)
1082     {
1083       if (!flag_no_inline)
1084         flag_no_inline = 1;
1085       if (flag_inline_functions)
1086         {
1087           flag_inline_trees = 2;
1088           flag_inline_functions = 0;
1089         }
1090     }
1091
1092   /* -Wextra implies -Wsign-compare, but not if explicitly
1093       overridden.  */
1094   if (warn_sign_compare == -1)
1095     warn_sign_compare = extra_warnings;
1096
1097   /* Special format checking options don't work without -Wformat; warn if
1098      they are used.  */
1099   if (warn_format_y2k && !warn_format)
1100     warning ("-Wformat-y2k ignored without -Wformat");
1101   if (warn_format_extra_args && !warn_format)
1102     warning ("-Wformat-extra-args ignored without -Wformat");
1103   if (warn_format_zero_length && !warn_format)
1104     warning ("-Wformat-zero-length ignored without -Wformat");
1105   if (warn_format_nonliteral && !warn_format)
1106     warning ("-Wformat-nonliteral ignored without -Wformat");
1107   if (warn_format_security && !warn_format)
1108     warning ("-Wformat-security ignored without -Wformat");
1109   if (warn_missing_format_attribute && !warn_format)
1110     warning ("-Wmissing-format-attribute ignored without -Wformat");
1111
1112   if (flag_preprocess_only)
1113     {
1114       /* Open the output now.  We must do so even if flag_no_output is
1115          on, because there may be other output than from the actual
1116          preprocessing (e.g. from -dM).  */
1117       if (out_fname[0] == '\0')
1118         out_stream = stdout;
1119       else
1120         out_stream = fopen (out_fname, "w");
1121
1122       if (out_stream == NULL)
1123         {
1124           fatal_error ("opening output file %s: %m", out_fname);
1125           return false;
1126         }
1127
1128       init_pp_output (out_stream);
1129     }
1130   else
1131     {
1132       init_c_lex ();
1133
1134       /* Yuk.  WTF is this?  I do know ObjC relies on it somewhere.  */
1135       input_line = 0;
1136     }
1137
1138   cpp_get_callbacks (parse_in)->file_change = cb_file_change;
1139
1140   /* NOTE: we use in_fname here, not the one supplied.  */
1141   *pfilename = cpp_read_main_file (parse_in, in_fname);
1142
1143   saved_lineno = input_line;
1144   input_line = 0;
1145
1146   /* If an error has occurred in cpplib, note it so we fail
1147      immediately.  */
1148   errorcount += cpp_errors (parse_in);
1149
1150   return flag_preprocess_only;
1151 }
1152
1153 /* Front end initialization common to C, ObjC and C++.  */
1154 bool
1155 c_common_init ()
1156 {
1157   input_line = saved_lineno;
1158
1159   /* Set up preprocessor arithmetic.  Must be done after call to
1160      c_common_nodes_and_builtins for type nodes to be good.  */
1161   cpp_opts->precision = TYPE_PRECISION (intmax_type_node);
1162   cpp_opts->char_precision = TYPE_PRECISION (char_type_node);
1163   cpp_opts->int_precision = TYPE_PRECISION (integer_type_node);
1164   cpp_opts->wchar_precision = TYPE_PRECISION (wchar_type_node);
1165   cpp_opts->unsigned_wchar = TREE_UNSIGNED (wchar_type_node);
1166   cpp_opts->EBCDIC = TARGET_EBCDIC;
1167
1168   if (flag_preprocess_only)
1169     {
1170       finish_options ();
1171       preprocess_file (parse_in);
1172       return false;
1173     }
1174
1175   /* Has to wait until now so that cpplib has its hash table.  */
1176   init_pragma ();
1177
1178   return true;
1179 }
1180
1181 /* A thin wrapper around the real parser that initializes the
1182    integrated preprocessor after debug output has been initialized.
1183    Also, make sure the start_source_file debug hook gets called for
1184    the primary source file.  */
1185 void
1186 c_common_parse_file (set_yydebug)
1187      int set_yydebug ATTRIBUTE_UNUSED;
1188 {
1189 #if YYDEBUG != 0
1190   yydebug = set_yydebug;
1191 #else
1192   warning ("YYDEBUG not defined");
1193 #endif
1194
1195   (*debug_hooks->start_source_file) (input_line, input_filename);
1196   finish_options();
1197   pch_init();
1198   yyparse ();
1199   free_parser_stacks ();
1200 }
1201
1202 /* Common finish hook for the C, ObjC and C++ front ends.  */
1203 void
1204 c_common_finish ()
1205 {
1206   FILE *deps_stream = NULL;
1207
1208   if (cpp_opts->deps.style != DEPS_NONE)
1209     {
1210       /* If -M or -MM was seen without -MF, default output to the
1211          output stream.  */
1212       if (!deps_file)
1213         deps_stream = out_stream;
1214       else
1215         {
1216           deps_stream = fopen (deps_file, deps_append ? "a": "w");
1217           if (!deps_stream)
1218             fatal_error ("opening dependency file %s: %m", deps_file);
1219         }
1220     }
1221
1222   /* For performance, avoid tearing down cpplib's internal structures
1223      with cpp_destroy ().  */
1224   errorcount += cpp_finish (parse_in, deps_stream);
1225
1226   if (deps_stream && deps_stream != out_stream
1227       && (ferror (deps_stream) || fclose (deps_stream)))
1228     fatal_error ("closing dependency file %s: %m", deps_file);
1229
1230   if (out_stream && (ferror (out_stream) || fclose (out_stream)))
1231     fatal_error ("when writing output to %s: %m", out_fname);
1232 }
1233
1234 /* Either of two environment variables can specify output of
1235    dependencies.  Their value is either "OUTPUT_FILE" or "OUTPUT_FILE
1236    DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to
1237    and DEPS_TARGET is the target to mention in the deps.  They also
1238    result in dependency information being appended to the output file
1239    rather than overwriting it, and like Sun's compiler
1240    SUNPRO_DEPENDENCIES suppresses the dependency on the main file.  */
1241 static void
1242 check_deps_environment_vars ()
1243 {
1244   char *spec;
1245
1246   GET_ENVIRONMENT (spec, "DEPENDENCIES_OUTPUT");
1247   if (spec)
1248     cpp_opts->deps.style = DEPS_USER;
1249   else
1250     {
1251       GET_ENVIRONMENT (spec, "SUNPRO_DEPENDENCIES");
1252       if (spec)
1253         {
1254           cpp_opts->deps.style = DEPS_SYSTEM;
1255           cpp_opts->deps.ignore_main_file = true;
1256         }
1257     }
1258
1259   if (spec)
1260     {
1261       /* Find the space before the DEPS_TARGET, if there is one.  */
1262       char *s = strchr (spec, ' ');
1263       if (s)
1264         {
1265           /* Let the caller perform MAKE quoting.  */
1266           defer_opt (OPT_MT, s + 1);
1267           *s = '\0';
1268         }
1269
1270       /* Command line -MF overrides environment variables and default.  */
1271       if (!deps_file)
1272         deps_file = spec;
1273
1274       deps_append = 1;
1275     }
1276 }
1277
1278 /* Handle deferred command line switches.  */
1279 static void
1280 handle_deferred_opts ()
1281 {
1282   size_t i;
1283
1284   for (i = 0; i < deferred_count; i++)
1285     {
1286       struct deferred_opt *opt = &deferred_opts[i];
1287
1288       if (opt->code == OPT_MT || opt->code == OPT_MQ)
1289         cpp_add_dependency_target (parse_in, opt->arg, opt->code == OPT_MQ);
1290     }
1291 }
1292
1293 /* These settings are appropriate for GCC, but not necessarily so for
1294    cpplib as a library.  */
1295 static void
1296 sanitize_cpp_opts ()
1297 {
1298   /* If we don't know what style of dependencies to output, complain
1299      if any other dependency switches have been given.  */
1300   if (deps_seen && cpp_opts->deps.style == DEPS_NONE)
1301     error ("to generate dependencies you must specify either -M or -MM");
1302
1303   /* -dM and dependencies suppress normal output; do it here so that
1304      the last -d[MDN] switch overrides earlier ones.  */
1305   if (flag_dump_macros == 'M')
1306     flag_no_output = 1;
1307
1308   /* Disable -dD, -dN and -dI if normal output is suppressed.  Allow
1309      -dM since at least glibc relies on -M -dM to work.  */
1310   if (flag_no_output)
1311     {
1312       if (flag_dump_macros != 'M')
1313         flag_dump_macros = 0;
1314       flag_dump_includes = 0;
1315     }
1316
1317   cpp_opts->unsigned_char = !flag_signed_char;
1318   cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS;
1319
1320   /* We want -Wno-long-long to override -pedantic -std=non-c99
1321      and/or -Wtraditional, whatever the ordering.  */
1322   cpp_opts->warn_long_long
1323     = warn_long_long && ((!flag_isoc99 && pedantic) || warn_traditional);
1324 }
1325
1326 /* Add include path with a prefix at the front of its name.  */
1327 static void
1328 add_prefixed_path (suffix, chain)
1329      const char *suffix;
1330      size_t chain;
1331 {
1332   char *path;
1333   const char *prefix;
1334   size_t prefix_len, suffix_len;
1335
1336   suffix_len = strlen (suffix);
1337   prefix     = iprefix ? iprefix : cpp_GCC_INCLUDE_DIR;
1338   prefix_len = iprefix ? strlen (iprefix) : cpp_GCC_INCLUDE_DIR_len;
1339
1340   path = xmalloc (prefix_len + suffix_len + 1);
1341   memcpy (path, prefix, prefix_len);
1342   memcpy (path + prefix_len, suffix, suffix_len);
1343   path[prefix_len + suffix_len] = '\0';
1344
1345   add_path (path, chain, 0);
1346 }
1347
1348 /* Handle -D, -U, -A, -imacros, and the first -include.  */
1349 static void
1350 finish_options ()
1351 {
1352   if (!cpp_opts->preprocessed)
1353     {
1354       size_t i;
1355
1356       cpp_change_file (parse_in, LC_RENAME, _("<built-in>"));
1357       cpp_init_builtins (parse_in, flag_hosted);
1358       c_cpp_builtins (parse_in);
1359       cpp_change_file (parse_in, LC_RENAME, _("<command line>"));
1360       for (i = 0; i < deferred_count; i++)
1361         {
1362           struct deferred_opt *opt = &deferred_opts[i];
1363
1364           if (opt->code == OPT_D)
1365             cpp_define (parse_in, opt->arg);
1366           else if (opt->code == OPT_U)
1367             cpp_undef (parse_in, opt->arg);
1368           else if (opt->code == OPT_A)
1369             {
1370               if (opt->arg[0] == '-')
1371                 cpp_unassert (parse_in, opt->arg + 1);
1372               else
1373                 cpp_assert (parse_in, opt->arg);
1374             }
1375         }
1376
1377       /* Handle -imacros after -D and -U.  */
1378       for (i = 0; i < deferred_count; i++)
1379         {
1380           struct deferred_opt *opt = &deferred_opts[i];
1381
1382           if (opt->code == OPT_imacros
1383               && cpp_push_include (parse_in, opt->arg))
1384             cpp_scan_nooutput (parse_in);
1385         }
1386     }
1387
1388   push_command_line_include ();
1389 }
1390
1391 /* Give CPP the next file given by -include, if any.  */
1392 static void
1393 push_command_line_include ()
1394 {
1395   if (cpp_opts->preprocessed)
1396     return;
1397
1398   while (include_cursor < deferred_count)
1399     {
1400       struct deferred_opt *opt = &deferred_opts[include_cursor++];
1401
1402       if (opt->code == OPT_include && cpp_push_include (parse_in, opt->arg))
1403         return;
1404     }
1405
1406   if (include_cursor == deferred_count)
1407     {
1408       /* Restore the line map from <command line>.  */
1409       cpp_change_file (parse_in, LC_RENAME, main_input_filename);
1410       /* -Wunused-macros should only warn about macros defined hereafter.  */
1411       cpp_opts->warn_unused_macros = warn_unused_macros;
1412       include_cursor++;
1413     }
1414 }
1415
1416 /* File change callback.  Has to handle -include files.  */
1417 static void
1418 cb_file_change (pfile, new_map)
1419      cpp_reader *pfile ATTRIBUTE_UNUSED;
1420      const struct line_map *new_map;
1421 {
1422   if (flag_preprocess_only)
1423     pp_file_change (new_map);
1424   else
1425     fe_file_change (new_map);
1426
1427   if (new_map->reason == LC_LEAVE && MAIN_FILE_P (new_map))
1428     push_command_line_include ();
1429 }
1430
1431 /* Set the C 89 standard (with 1994 amendments if C94, without GNU
1432    extensions if ISO).  There is no concept of gnu94.  */
1433 static void
1434 set_std_c89 (c94, iso)
1435      int c94, iso;
1436 {
1437   cpp_set_lang (parse_in, c94 ? CLK_STDC94: iso ? CLK_STDC89: CLK_GNUC89);
1438   flag_iso = iso;
1439   flag_no_asm = iso;
1440   flag_no_gnu_keywords = iso;
1441   flag_no_nonansi_builtin = iso;
1442   flag_noniso_default_format_attributes = !iso;
1443   flag_isoc94 = c94;
1444   flag_isoc99 = 0;
1445   flag_writable_strings = 0;
1446 }
1447
1448 /* Set the C 99 standard (without GNU extensions if ISO).  */
1449 static void
1450 set_std_c99 (iso)
1451      int iso;
1452 {
1453   cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99);
1454   flag_no_asm = iso;
1455   flag_no_nonansi_builtin = iso;
1456   flag_noniso_default_format_attributes = !iso;
1457   flag_iso = iso;
1458   flag_isoc99 = 1;
1459   flag_isoc94 = 1;
1460   flag_writable_strings = 0;
1461 }
1462
1463 /* Set the C++ 98 standard (without GNU extensions if ISO).  */
1464 static void
1465 set_std_cxx98 (iso)
1466      int iso;
1467 {
1468   cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX);
1469   flag_no_gnu_keywords = iso;
1470   flag_no_nonansi_builtin = iso;
1471   flag_noniso_default_format_attributes = !iso;
1472   flag_iso = iso;
1473 }
1474
1475 /* Handle setting implicit to ON.  */
1476 static void
1477 set_Wimplicit (on)
1478      int on;
1479 {
1480   warn_implicit = on;
1481   warn_implicit_int = on;
1482   if (on)
1483     {
1484       if (mesg_implicit_function_declaration != 2)
1485         mesg_implicit_function_declaration = 1;
1486     }
1487   else
1488     mesg_implicit_function_declaration = 0;
1489 }
1490
1491 /* Args to -d specify what to dump.  Silently ignore
1492    unrecognized options; they may be aimed at toplev.c.  */
1493 static void
1494 handle_OPT_d (arg)
1495      const char *arg;
1496 {
1497   char c;
1498
1499   while ((c = *arg++) != '\0')
1500     switch (c)
1501       {
1502       case 'M':                 /* Dump macros only.  */
1503       case 'N':                 /* Dump names.  */
1504       case 'D':                 /* Dump definitions.  */
1505         flag_dump_macros = c;
1506         break;
1507
1508       case 'I':
1509         flag_dump_includes = 1;
1510         break;
1511       }
1512 }
1513
1514 /* Write a slash-separated list of languages in FLAGS to BUF.  */
1515 static void
1516 write_langs (buf, flags)
1517      char *buf;
1518      int flags;
1519 {
1520   *buf = '\0';
1521   if (flags & CL_C)
1522     strcat (buf, "C");
1523   if (flags & CL_OBJC)
1524     {
1525       if (*buf)
1526         strcat (buf, "/");
1527       strcat (buf, "ObjC");
1528     }
1529   if (flags & CL_CXX)
1530     {
1531       if (*buf)
1532         strcat (buf, "/");
1533       strcat (buf, "C++");
1534     }
1535 }
1536
1537 /* Complain that switch OPT_INDEX does not apply to this front end.  */
1538 static void
1539 complain_wrong_lang (opt_index)
1540      size_t opt_index;
1541 {
1542   char ok_langs[60], bad_langs[60];
1543   int ok_flags = cl_options[opt_index].flags;
1544
1545   write_langs (ok_langs, ok_flags);
1546   write_langs (bad_langs, ~ok_flags);
1547   /* Eventually this should become a hard error.  */
1548   warning ("\"-%s\" is valid for %s but not for %s",
1549            cl_options[opt_index].opt_text, ok_langs, bad_langs);
1550 }
1551
1552 /* Handle --help output.  */
1553 static void
1554 print_help ()
1555 {
1556   /* To keep the lines from getting too long for some compilers, limit
1557      to about 500 characters (6 lines) per chunk.  */
1558   fputs (_("\
1559 Switches:\n\
1560   -include <file>           Include the contents of <file> before other files\n\
1561   -imacros <file>           Accept definition of macros in <file>\n\
1562   -iprefix <path>           Specify <path> as a prefix for next two options\n\
1563   -iwithprefix <dir>        Add <dir> to the end of the system include path\n\
1564   -iwithprefixbefore <dir>  Add <dir> to the end of the main include path\n\
1565   -isystem <dir>            Add <dir> to the start of the system include path\n\
1566 "), stdout);
1567   fputs (_("\
1568   -idirafter <dir>          Add <dir> to the end of the system include path\n\
1569   -I <dir>                  Add <dir> to the end of the main include path\n\
1570   -I-                       Fine-grained include path control; see info docs\n\
1571   -nostdinc                 Do not search system include directories\n\
1572                              (dirs specified with -isystem will still be used)\n\
1573   -nostdinc++               Do not search system include directories for C++\n\
1574   -o <file>                 Put output into <file>\n\
1575 "), stdout);
1576   fputs (_("\
1577   -trigraphs                Support ISO C trigraphs\n\
1578   -std=<std name>           Specify the conformance standard; one of:\n\
1579                             gnu89, gnu99, c89, c99, iso9899:1990,\n\
1580                             iso9899:199409, iso9899:1999, c++98\n\
1581   -w                        Inhibit warning messages\n\
1582   -W[no-]trigraphs          Warn if trigraphs are encountered\n\
1583   -W[no-]comment{s}         Warn if one comment starts inside another\n\
1584 "), stdout);
1585   fputs (_("\
1586   -W[no-]traditional        Warn about features not present in traditional C\n\
1587   -W[no-]undef              Warn if an undefined macro is used by #if\n\
1588   -W[no-]import             Warn about the use of the #import directive\n\
1589 "), stdout);
1590   fputs (_("\
1591   -W[no-]error              Treat all warnings as errors\n\
1592   -W[no-]system-headers     Do not suppress warnings from system headers\n\
1593   -W[no-]all                Enable most preprocessor warnings\n\
1594 "), stdout);
1595   fputs (_("\
1596   -M                        Generate make dependencies\n\
1597   -MM                       As -M, but ignore system header files\n\
1598   -MD                       Generate make dependencies and compile\n\
1599   -MMD                      As -MD, but ignore system header files\n\
1600   -MF <file>                Write dependency output to the given file\n\
1601   -MG                       Treat missing header file as generated files\n\
1602 "), stdout);
1603   fputs (_("\
1604   -MP                       Generate phony targets for all headers\n\
1605   -MQ <target>              Add a MAKE-quoted target\n\
1606   -MT <target>              Add an unquoted target\n\
1607 "), stdout);
1608   fputs (_("\
1609   -D<macro>                 Define a <macro> with string '1' as its value\n\
1610   -D<macro>=<val>           Define a <macro> with <val> as its value\n\
1611   -A<question>=<answer>     Assert the <answer> to <question>\n\
1612   -A-<question>=<answer>    Disable the <answer> to <question>\n\
1613   -U<macro>                 Undefine <macro> \n\
1614   -v                        Display the version number\n\
1615 "), stdout);
1616   fputs (_("\
1617   -H                        Print the name of header files as they are used\n\
1618   -C                        Do not discard comments\n\
1619   -dM                       Display a list of macro definitions active at end\n\
1620   -dD                       Preserve macro definitions in output\n\
1621   -dN                       As -dD except that only the names are preserved\n\
1622   -dI                       Include #include directives in the output\n\
1623 "), stdout);
1624   fputs (_("\
1625   -f[no-]preprocessed       Treat the input file as already preprocessed\n\
1626   -ftabstop=<number>        Distance between tab stops for column reporting\n\
1627   -isysroot <dir>           Set <dir> to be the system root directory\n\
1628   -P                        Do not generate #line directives\n\
1629   -remap                    Remap file names when including files\n\
1630   --help                    Display this information\n\
1631 "), stdout);
1632 }