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