contrib/gcc-4.1/gcc/c-opts.c

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