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