gcc/c-opts.c

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