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_const_strings = c_dialect_cxx ();
 229   flag_exceptions = c_dialect_cxx ();
 230   warn_pointer_arith = 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       if (!c_dialect_cxx ())
 535         flag_const_strings = value;
 536       else
 537         warn_write_strings = value;
 538       break;
 539
 540     case OPT_Weffc__:
 541       warn_ecpp = value;
 542       if (value)
 543         warn_nonvdtor = true;
 544       break;
 545
 546     case OPT_ansi:
 547       if (!c_dialect_cxx ())
 548         set_std_c89 (false, true);
 549       else
 550         set_std_cxx98 (true);
 551       break;
 552
 553     case OPT_d:
 554       handle_OPT_d (arg);
 555       break;
 556
 557     case OPT_fcond_mismatch:
 558       if (!c_dialect_cxx ())
 559         {
 560           flag_cond_mismatch = value;
 561           break;
 562         }
 563       /* Fall through.  */
 564
 565     case OPT_fall_virtual:
 566     case OPT_falt_external_templates:
 567     case OPT_fenum_int_equiv:
 568     case OPT_fexternal_templates:
 569     case OPT_fguiding_decls:
 570     case OPT_fhonor_std:
 571     case OPT_fhuge_objects:
 572     case OPT_flabels_ok:
 573     case OPT_fname_mangling_version_:
 574     case OPT_fnew_abi:
 575     case OPT_fnonnull_objects:
 576     case OPT_fsquangle:
 577     case OPT_fstrict_prototype:
 578     case OPT_fthis_is_variable:
 579     case OPT_fvtable_thunks:
 580     case OPT_fxref:
 581     case OPT_fvtable_gc:
 582       warning (0, "switch %qs is no longer supported", option->opt_text);
 583       break;
 584
 585     case OPT_faccess_control:
 586       flag_access_control = value;
 587       break;
 588
 589     case OPT_fasm:
 590       flag_no_asm = !value;
 591       break;
 592
 593     case OPT_fbuiltin:
 594       flag_no_builtin = !value;
 595       break;
 596
 597     case OPT_fbuiltin_:
 598       if (value)
 599         result = 0;
 600       else
 601         disable_builtin_function (arg);
 602       break;
 603
 604     case OPT_fdollars_in_identifiers:
 605       cpp_opts->dollars_in_ident = value;
 606       break;
 607
 608     case OPT_ffreestanding:
 609       value = !value;
 610       /* Fall through....  */
 611     case OPT_fhosted:
 612       flag_hosted = value;
 613       flag_no_builtin = !value;
 614       /* warn_main will be 2 if set by -Wall, 1 if set by -Wmain */
 615       if (!value && warn_main == 2)
 616         warn_main = 0;
 617       break;
 618
 619     case OPT_fshort_double:
 620       flag_short_double = value;
 621       break;
 622
 623     case OPT_fshort_enums:
 624       flag_short_enums = value;
 625       break;
 626
 627     case OPT_fshort_wchar:
 628       flag_short_wchar = value;
 629       break;
 630
 631     case OPT_fsigned_bitfields:
 632       flag_signed_bitfields = value;
 633       break;
 634
 635     case OPT_fsigned_char:
 636       flag_signed_char = value;
 637       break;
 638
 639     case OPT_funsigned_bitfields:
 640       flag_signed_bitfields = !value;
 641       break;
 642
 643     case OPT_funsigned_char:
 644       flag_signed_char = !value;
 645       break;
 646
 647     case OPT_fcheck_new:
 648       flag_check_new = value;
 649       break;
 650
 651     case OPT_fconserve_space:
 652       flag_conserve_space = value;
 653       break;
 654
 655     case OPT_fconst_strings:
 656       flag_const_strings = value;
 657       break;
 658
 659     case OPT_fconstant_string_class_:
 660       constant_string_class_name = arg;
 661       break;
 662
 663     case OPT_fdefault_inline:
 664       flag_default_inline = value;
 665       break;
 666
 667     case OPT_felide_constructors:
 668       flag_elide_constructors = value;
 669       break;
 670
 671     case OPT_fenforce_eh_specs:
 672       flag_enforce_eh_specs = value;
 673       break;
 674
 675     case OPT_fextended_identifiers:
 676       cpp_opts->extended_identifiers = value;
 677       break;
 678
 679     case OPT_ffor_scope:
 680       flag_new_for_scope = value;
 681       break;
 682
 683     case OPT_fgnu_keywords:
 684       flag_no_gnu_keywords = !value;
 685       break;
 686
 687     case OPT_fgnu_runtime:
 688       flag_next_runtime = !value;
 689       break;
 690
 691     case OPT_fhandle_exceptions:
 692       warning (0, "-fhandle-exceptions has been renamed -fexceptions (and is now on by default)");
 693       flag_exceptions = value;
 694       break;
 695
 696     case OPT_fimplement_inlines:
 697       flag_implement_inlines = value;
 698       break;
 699
 700     case OPT_fimplicit_inline_templates:
 701       flag_implicit_inline_templates = value;
 702       break;
 703
 704     case OPT_fimplicit_templates:
 705       flag_implicit_templates = value;
 706       break;
 707
 708     case OPT_fms_extensions:
 709       flag_ms_extensions = value;
 710       break;
 711
 712     case OPT_fnext_runtime:
 713       flag_next_runtime = value;
 714       break;
 715
 716     case OPT_fnil_receivers:
 717       flag_nil_receivers = value;
 718       break;
 719
 720     case OPT_fnonansi_builtins:
 721       flag_no_nonansi_builtin = !value;
 722       break;
 723
 724     case OPT_foperator_names:
 725       cpp_opts->operator_names = value;
 726       break;
 727
 728     case OPT_foptional_diags:
 729       flag_optional_diags = value;
 730       break;
 731
 732     case OPT_fpch_deps:
 733       cpp_opts->restore_pch_deps = value;
 734       break;
 735
 736     case OPT_fpch_preprocess:
 737       flag_pch_preprocess = value;
 738       break;
 739
 740     case OPT_fpermissive:
 741       flag_permissive = value;
 742       break;
 743
 744     case OPT_fpreprocessed:
 745       cpp_opts->preprocessed = value;
 746       break;
 747
 748     case OPT_freplace_objc_classes:
 749       flag_replace_objc_classes = value;
 750       break;
 751
 752     case OPT_frepo:
 753       flag_use_repository = value;
 754       if (value)
 755         flag_implicit_templates = 0;
 756       break;
 757
 758     case OPT_frtti:
 759       flag_rtti = value;
 760       break;
 761
 762     case OPT_fshow_column:
 763       cpp_opts->show_column = value;
 764       break;
 765
 766     case OPT_fstats:
 767       flag_detailed_statistics = value;
 768       break;
 769
 770     case OPT_ftabstop_:
 771       /* It is documented that we silently ignore silly values.  */
 772       if (value >= 1 && value <= 100)
 773         cpp_opts->tabstop = value;
 774       break;
 775
 776     case OPT_fexec_charset_:
 777       cpp_opts->narrow_charset = arg;
 778       break;
 779
 780     case OPT_fwide_exec_charset_:
 781       cpp_opts->wide_charset = arg;
 782       break;
 783
 784     case OPT_finput_charset_:
 785       cpp_opts->input_charset = arg;
 786       break;
 787
 788     case OPT_ftemplate_depth_:
 789       max_tinst_depth = value;
 790       break;
 791
 792     case OPT_fuse_cxa_atexit:
 793       flag_use_cxa_atexit = value;
 794       break;
 795
 796     case OPT_fvisibility_inlines_hidden:
 797       visibility_options.inlines_hidden = value;
 798       break;
 799
 800     case OPT_fweak:
 801       flag_weak = value;
 802       break;
 803
 804     case OPT_fthreadsafe_statics:
 805       flag_threadsafe_statics = value;
 806       break;
 807
 808     case OPT_fzero_link:
 809       flag_zero_link = value;
 810       break;
 811
 812     case OPT_gen_decls:
 813       flag_gen_declaration = 1;
 814       break;
 815
 816     case OPT_idirafter:
 817       add_path (xstrdup (arg), AFTER, 0, true);
 818       break;
 819
 820     case OPT_imacros:
 821     case OPT_include:
 822       defer_opt (code, arg);
 823       break;
 824
 825     case OPT_imultilib:
 826       imultilib = arg;
 827       break;
 828
 829     case OPT_iprefix:
 830       iprefix = arg;
 831       break;
 832
 833     case OPT_iquote:
 834       add_path (xstrdup (arg), QUOTE, 0, true);
 835       break;
 836
 837     case OPT_isysroot:
 838       sysroot = arg;
 839       break;
 840
 841     case OPT_isystem:
 842       add_path (xstrdup (arg), SYSTEM, 0, true);
 843       break;
 844
 845     case OPT_iwithprefix:
 846       add_prefixed_path (arg, SYSTEM);
 847       break;
 848
 849     case OPT_iwithprefixbefore:
 850       add_prefixed_path (arg, BRACKET);
 851       break;
 852
 853     case OPT_lang_asm:
 854       cpp_set_lang (parse_in, CLK_ASM);
 855       cpp_opts->dollars_in_ident = false;
 856       break;
 857
 858     case OPT_lang_fortran:
 859       lang_fortran = true;
 860       break;
 861
 862     case OPT_lang_objc:
 863       cpp_opts->objc = 1;
 864       break;
 865
 866     case OPT_nostdinc:
 867       std_inc = false;
 868       break;
 869
 870     case OPT_nostdinc__:
 871       std_cxx_inc = false;
 872       break;
 873
 874     case OPT_o:
 875       if (!out_fname)
 876         out_fname = arg;
 877       else
 878         error ("output filename specified twice");
 879       break;
 880
 881       /* We need to handle the -pedantic switches here, rather than in
 882          c_common_post_options, so that a subsequent -Wno-endif-labels
 883          is not overridden.  */
 884     case OPT_pedantic_errors:
 885       cpp_opts->pedantic_errors = 1;
 886       /* Fall through.  */
 887     case OPT_pedantic:
 888       cpp_opts->pedantic = 1;
 889       cpp_opts->warn_endif_labels = 1;
 890       if (warn_pointer_sign == -1)
 891         warn_pointer_sign = 1;
 892       if (warn_overlength_strings == -1)
 893         warn_overlength_strings = 1;
 894       break;
 895
 896     case OPT_print_objc_runtime_info:
 897       print_struct_values = 1;
 898       break;
 899
 900     case OPT_print_pch_checksum:
 901       c_common_print_pch_checksum (stdout);
 902       exit_after_options = true;
 903       break;
 904
 905     case OPT_remap:
 906       cpp_opts->remap = 1;
 907       break;
 908
 909     case OPT_std_c__98:
 910     case OPT_std_gnu__98:
 911       set_std_cxx98 (code == OPT_std_c__98 /* ISO */);
 912       break;
 913
 914     case OPT_std_c89:
 915     case OPT_std_iso9899_1990:
 916     case OPT_std_iso9899_199409:
 917       set_std_c89 (code == OPT_std_iso9899_199409 /* c94 */, true /* ISO */);
 918       break;
 919
 920     case OPT_std_gnu89:
 921       set_std_c89 (false /* c94 */, false /* ISO */);
 922       break;
 923
 924     case OPT_std_c99:
 925     case OPT_std_c9x:
 926     case OPT_std_iso9899_1999:
 927     case OPT_std_iso9899_199x:
 928       set_std_c99 (true /* ISO */);
 929       break;
 930
 931     case OPT_std_gnu99:
 932     case OPT_std_gnu9x:
 933       set_std_c99 (false /* ISO */);
 934       break;
 935
 936     case OPT_trigraphs:
 937       cpp_opts->trigraphs = 1;
 938       break;
 939
 940     case OPT_traditional_cpp:
 941       cpp_opts->traditional = 1;
 942       break;
 943
 944     case OPT_undef:
 945       flag_undef = 1;
 946       break;
 947
 948     case OPT_w:
 949       cpp_opts->inhibit_warnings = 1;
 950       break;
 951
 952     case OPT_v:
 953       verbose = true;
 954       break;
 955     }
 956
 957   return result;
 958 }
 959
 960 /* Post-switch processing.  */
 961 bool
 962 c_common_post_options (const char **pfilename)
 963 {
 964   struct cpp_callbacks *cb;
 965
 966   /* Canonicalize the input and output filenames.  */
 967   if (in_fnames == NULL)
 968     {
 969       in_fnames = XNEWVEC (const char *, 1);
 970       in_fnames[0] = "";
 971     }
 972   else if (strcmp (in_fnames[0], "-") == 0)
 973     in_fnames[0] = "";
 974
 975   if (out_fname == NULL || !strcmp (out_fname, "-"))
 976     out_fname = "";
 977
 978   if (cpp_opts->deps.style == DEPS_NONE)
 979     check_deps_environment_vars ();
 980
 981   handle_deferred_opts ();
 982
 983   sanitize_cpp_opts ();
 984
 985   register_include_chains (parse_in, sysroot, iprefix, imultilib,
 986                            std_inc, std_cxx_inc && c_dialect_cxx (), verbose);
 987
 988   flag_inline_trees = 1;
 989
 990   /* Use tree inlining.  */
 991   if (!flag_no_inline)
 992     flag_no_inline = 1;
 993   if (flag_inline_functions)
 994     flag_inline_trees = 2;
 995
 996   /* If we are given more than one input file, we must use
 997      unit-at-a-time mode.  */
 998   if (num_in_fnames > 1)
 999     flag_unit_at_a_time = 1;
1000
1001   /* Default to ObjC sjlj exception handling if NeXT runtime.  */
1002   if (flag_objc_sjlj_exceptions < 0)
1003     flag_objc_sjlj_exceptions = flag_next_runtime;
1004   if (flag_objc_exceptions && !flag_objc_sjlj_exceptions)
1005     flag_exceptions = 1;
1006
1007   /* -Wextra implies -Wsign-compare and -Wmissing-field-initializers,
1008      but not if explicitly overridden.  */
1009   if (warn_sign_compare == -1)
1010     warn_sign_compare = extra_warnings;
1011   if (warn_missing_field_initializers == -1)
1012     warn_missing_field_initializers = extra_warnings;
1013
1014   /* -Wpointer_sign is disabled by default, but it is enabled if any
1015      of -Wall or -pedantic are given.  */
1016   if (warn_pointer_sign == -1)
1017     warn_pointer_sign = 0;
1018
1019   /* -Woverlength-strings is off by default, but is enabled by -pedantic.
1020      It is never enabled in C++, as the minimum limit is not normative
1021      in that standard.  */
1022   if (warn_overlength_strings == -1 || c_dialect_cxx ())
1023     warn_overlength_strings = 0;
1024
1025   /* Special format checking options don't work without -Wformat; warn if
1026      they are used.  */
1027   if (!warn_format)
1028     {
1029       warning (OPT_Wformat_y2k,
1030                "-Wformat-y2k ignored without -Wformat");
1031       warning (OPT_Wformat_extra_args,
1032                "-Wformat-extra-args ignored without -Wformat");
1033       warning (OPT_Wformat_zero_length,
1034                "-Wformat-zero-length ignored without -Wformat");
1035       warning (OPT_Wformat_nonliteral,
1036                "-Wformat-nonliteral ignored without -Wformat");
1037       warning (OPT_Wformat_security,
1038                "-Wformat-security ignored without -Wformat");
1039     }
1040
1041   /* C99 requires special handling of complex multiplication and division;
1042      -ffast-math and -fcx-limited-range are handled in process_options.  */
1043   if (flag_isoc99)
1044     flag_complex_method = 2;
1045
1046   if (flag_preprocess_only)
1047     {
1048       /* Open the output now.  We must do so even if flag_no_output is
1049          on, because there may be other output than from the actual
1050          preprocessing (e.g. from -dM).  */
1051       if (out_fname[0] == '\0')
1052         out_stream = stdout;
1053       else
1054         out_stream = fopen (out_fname, "w");
1055
1056       if (out_stream == NULL)
1057         {
1058           fatal_error ("opening output file %s: %m", out_fname);
1059           return false;
1060         }
1061
1062       if (num_in_fnames > 1)
1063         error ("too many filenames given.  Type %s --help for usage",
1064                progname);
1065
1066       init_pp_output (out_stream);
1067     }
1068   else
1069     {
1070       init_c_lex ();
1071
1072       /* Yuk.  WTF is this?  I do know ObjC relies on it somewhere.  */
1073       input_location = UNKNOWN_LOCATION;
1074     }
1075
1076   cb = cpp_get_callbacks (parse_in);
1077   cb->file_change = cb_file_change;
1078   cb->dir_change = cb_dir_change;
1079   cpp_post_options (parse_in);
1080
1081   input_location = UNKNOWN_LOCATION;
1082
1083   /* If an error has occurred in cpplib, note it so we fail
1084      immediately.  */
1085   errorcount += cpp_errors (parse_in);
1086
1087   *pfilename = this_input_filename
1088     = cpp_read_main_file (parse_in, in_fnames[0]);
1089   /* Don't do any compilation or preprocessing if there is no input file.  */
1090   if (this_input_filename == NULL)
1091     {
1092       errorcount++;
1093       return false;
1094     }
1095
1096   if (flag_working_directory
1097       && flag_preprocess_only && !flag_no_line_commands)
1098     pp_dir_change (parse_in, get_src_pwd ());
1099
1100   return flag_preprocess_only;
1101 }
1102
1103 /* Front end initialization common to C, ObjC and C++.  */
1104 bool
1105 c_common_init (void)
1106 {
1107   /* Set up preprocessor arithmetic.  Must be done after call to
1108      c_common_nodes_and_builtins for type nodes to be good.  */
1109   cpp_opts->precision = TYPE_PRECISION (intmax_type_node);
1110   cpp_opts->char_precision = TYPE_PRECISION (char_type_node);
1111   cpp_opts->int_precision = TYPE_PRECISION (integer_type_node);
1112   cpp_opts->wchar_precision = TYPE_PRECISION (wchar_type_node);
1113   cpp_opts->unsigned_wchar = TYPE_UNSIGNED (wchar_type_node);
1114   cpp_opts->bytes_big_endian = BYTES_BIG_ENDIAN;
1115
1116   /* This can't happen until after wchar_precision and bytes_big_endian
1117      are known.  */
1118   cpp_init_iconv (parse_in);
1119
1120   if (version_flag)
1121     c_common_print_pch_checksum (stderr);
1122
1123   if (flag_preprocess_only)
1124     {
1125       finish_options ();
1126       preprocess_file (parse_in);
1127       return false;
1128     }
1129
1130   /* Has to wait until now so that cpplib has its hash table.  */
1131   init_pragma ();
1132
1133   return true;
1134 }
1135
1136 /* Initialize the integrated preprocessor after debug output has been
1137    initialized; loop over each input file.  */
1138 void
1139 c_common_parse_file (int set_yydebug)
1140 {
1141   unsigned int i;
1142
1143   /* Enable parser debugging, if requested and we can.  If requested
1144      and we can't, notify the user.  */
1145 #if YYDEBUG != 0
1146   yydebug = set_yydebug;
1147 #else
1148   if (set_yydebug)
1149     warning (0, "YYDEBUG was not defined at build time, -dy ignored");
1150 #endif
1151
1152   i = 0;
1153   for (;;)
1154     {
1155       /* Start the main input file, if the debug writer wants it. */
1156       if (debug_hooks->start_end_main_source_file)
1157         (*debug_hooks->start_source_file) (0, this_input_filename);
1158       finish_options ();
1159       pch_init ();
1160       push_file_scope ();
1161       c_parse_file ();
1162       finish_file ();
1163       pop_file_scope ();
1164       /* And end the main input file, if the debug writer wants it  */
1165       if (debug_hooks->start_end_main_source_file)
1166         (*debug_hooks->end_source_file) (0);
1167       if (++i >= num_in_fnames)
1168         break;
1169       cpp_undef_all (parse_in);
1170       this_input_filename
1171         = cpp_read_main_file (parse_in, in_fnames[i]);
1172       /* If an input file is missing, abandon further compilation.
1173          cpplib has issued a diagnostic.  */
1174       if (!this_input_filename)
1175         break;
1176     }
1177 }
1178
1179 /* Common finish hook for the C, ObjC and C++ front ends.  */
1180 void
1181 c_common_finish (void)
1182 {
1183   FILE *deps_stream = NULL;
1184
1185   if (cpp_opts->deps.style != DEPS_NONE)
1186     {
1187       /* If -M or -MM was seen without -MF, default output to the
1188          output stream.  */
1189       if (!deps_file)
1190         deps_stream = out_stream;
1191       else
1192         {
1193           deps_stream = fopen (deps_file, deps_append ? "a": "w");
1194           if (!deps_stream)
1195             fatal_error ("opening dependency file %s: %m", deps_file);
1196         }
1197     }
1198
1199   /* For performance, avoid tearing down cpplib's internal structures
1200      with cpp_destroy ().  */
1201   errorcount += cpp_finish (parse_in, deps_stream);
1202
1203   if (deps_stream && deps_stream != out_stream
1204       && (ferror (deps_stream) || fclose (deps_stream)))
1205     fatal_error ("closing dependency file %s: %m", deps_file);
1206
1207   if (out_stream && (ferror (out_stream) || fclose (out_stream)))
1208     fatal_error ("when writing output to %s: %m", out_fname);
1209 }
1210
1211 /* Either of two environment variables can specify output of
1212    dependencies.  Their value is either "OUTPUT_FILE" or "OUTPUT_FILE
1213    DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to
1214    and DEPS_TARGET is the target to mention in the deps.  They also
1215    result in dependency information being appended to the output file
1216    rather than overwriting it, and like Sun's compiler
1217    SUNPRO_DEPENDENCIES suppresses the dependency on the main file.  */
1218 static void
1219 check_deps_environment_vars (void)
1220 {
1221   char *spec;
1222
1223   GET_ENVIRONMENT (spec, "DEPENDENCIES_OUTPUT");
1224   if (spec)
1225     cpp_opts->deps.style = DEPS_USER;
1226   else
1227     {
1228       GET_ENVIRONMENT (spec, "SUNPRO_DEPENDENCIES");
1229       if (spec)
1230         {
1231           cpp_opts->deps.style = DEPS_SYSTEM;
1232           cpp_opts->deps.ignore_main_file = true;
1233         }
1234     }
1235
1236   if (spec)
1237     {
1238       /* Find the space before the DEPS_TARGET, if there is one.  */
1239       char *s = strchr (spec, ' ');
1240       if (s)
1241         {
1242           /* Let the caller perform MAKE quoting.  */
1243           defer_opt (OPT_MT, s + 1);
1244           *s = '\0';
1245         }
1246
1247       /* Command line -MF overrides environment variables and default.  */
1248       if (!deps_file)
1249         deps_file = spec;
1250
1251       deps_append = 1;
1252       deps_seen = true;
1253     }
1254 }
1255
1256 /* Handle deferred command line switches.  */
1257 static void
1258 handle_deferred_opts (void)
1259 {
1260   size_t i;
1261   struct deps *deps;
1262
1263   /* Avoid allocating the deps buffer if we don't need it.
1264      (This flag may be true without there having been -MT or -MQ
1265      options, but we'll still need the deps buffer.)  */
1266   if (!deps_seen)
1267     return;
1268
1269   deps = cpp_get_deps (parse_in);
1270
1271   for (i = 0; i < deferred_count; i++)
1272     {
1273       struct deferred_opt *opt = &deferred_opts[i];
1274
1275       if (opt->code == OPT_MT || opt->code == OPT_MQ)
1276         deps_add_target (deps, opt->arg, opt->code == OPT_MQ);
1277     }
1278 }
1279
1280 /* These settings are appropriate for GCC, but not necessarily so for
1281    cpplib as a library.  */
1282 static void
1283 sanitize_cpp_opts (void)
1284 {
1285   /* If we don't know what style of dependencies to output, complain
1286      if any other dependency switches have been given.  */
1287   if (deps_seen && cpp_opts->deps.style == DEPS_NONE)
1288     error ("to generate dependencies you must specify either -M or -MM");
1289
1290   /* -dM and dependencies suppress normal output; do it here so that
1291      the last -d[MDN] switch overrides earlier ones.  */
1292   if (flag_dump_macros == 'M')
1293     flag_no_output = 1;
1294
1295   /* Disable -dD, -dN and -dI if normal output is suppressed.  Allow
1296      -dM since at least glibc relies on -M -dM to work.  */
1297   /* Also, flag_no_output implies flag_no_line_commands, always.  */
1298   if (flag_no_output)
1299     {
1300       if (flag_dump_macros != 'M')
1301         flag_dump_macros = 0;
1302       flag_dump_includes = 0;
1303       flag_no_line_commands = 1;
1304     }
1305
1306   cpp_opts->unsigned_char = !flag_signed_char;
1307   cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS;
1308
1309   /* We want -Wno-long-long to override -pedantic -std=non-c99
1310      and/or -Wtraditional, whatever the ordering.  */
1311   cpp_opts->warn_long_long
1312     = warn_long_long && ((!flag_isoc99 && pedantic) || warn_traditional);
1313
1314   /* Similarly with -Wno-variadic-macros.  No check for c99 here, since
1315      this also turns off warnings about GCCs extension.  */
1316   cpp_opts->warn_variadic_macros
1317     = warn_variadic_macros && (pedantic || warn_traditional);
1318
1319   /* If we're generating preprocessor output, emit current directory
1320      if explicitly requested or if debugging information is enabled.
1321      ??? Maybe we should only do it for debugging formats that
1322      actually output the current directory?  */
1323   if (flag_working_directory == -1)
1324     flag_working_directory = (debug_info_level != DINFO_LEVEL_NONE);
1325 }
1326
1327 /* Add include path with a prefix at the front of its name.  */
1328 static void
1329 add_prefixed_path (const char *suffix, size_t chain)
1330 {
1331   char *path;
1332   const char *prefix;
1333   size_t prefix_len, suffix_len;
1334
1335   suffix_len = strlen (suffix);
1336   prefix     = iprefix ? iprefix : cpp_GCC_INCLUDE_DIR;
1337   prefix_len = iprefix ? strlen (iprefix) : cpp_GCC_INCLUDE_DIR_len;
1338
1339   path = (char *) xmalloc (prefix_len + suffix_len + 1);
1340   memcpy (path, prefix, prefix_len);
1341   memcpy (path + prefix_len, suffix, suffix_len);
1342   path[prefix_len + suffix_len] = '\0';
1343
1344   add_path (path, chain, 0, false);
1345 }
1346
1347 /* Handle -D, -U, -A, -imacros, and the first -include.  */
1348 static void
1349 finish_options (void)
1350 {
1351   if (!cpp_opts->preprocessed)
1352     {
1353       size_t i;
1354
1355       cb_file_change (parse_in,
1356                       linemap_add (&line_table, LC_RENAME, 0,
1357                                    _("<built-in>"), 0));
1358
1359       cpp_init_builtins (parse_in, flag_hosted);
1360       c_cpp_builtins (parse_in);
1361
1362       /* We're about to send user input to cpplib, so make it warn for
1363          things that we previously (when we sent it internal definitions)
1364          told it to not warn.
1365
1366          C99 permits implementation-defined characters in identifiers.
1367          The documented meaning of -std= is to turn off extensions that
1368          conflict with the specified standard, and since a strictly
1369          conforming program cannot contain a '$', we do not condition
1370          their acceptance on the -std= setting.  */
1371       cpp_opts->warn_dollars = (cpp_opts->pedantic && !cpp_opts->c99);
1372
1373       cpp_change_file (parse_in, LC_RENAME, _("<command line>"));
1374       for (i = 0; i < deferred_count; i++)
1375         {
1376           struct deferred_opt *opt = &deferred_opts[i];
1377
1378           if (opt->code == OPT_D)
1379             cpp_define (parse_in, opt->arg);
1380           else if (opt->code == OPT_U)
1381             cpp_undef (parse_in, opt->arg);
1382           else if (opt->code == OPT_A)
1383             {
1384               if (opt->arg[0] == '-')
1385                 cpp_unassert (parse_in, opt->arg + 1);
1386               else
1387                 cpp_assert (parse_in, opt->arg);
1388             }
1389         }
1390
1391       /* Handle -imacros after -D and -U.  */
1392       for (i = 0; i < deferred_count; i++)
1393         {
1394           struct deferred_opt *opt = &deferred_opts[i];
1395
1396           if (opt->code == OPT_imacros
1397               && cpp_push_include (parse_in, opt->arg))
1398             {
1399               /* Disable push_command_line_include callback for now.  */
1400               include_cursor = deferred_count + 1;
1401               cpp_scan_nooutput (parse_in);
1402             }
1403         }
1404     }
1405
1406   include_cursor = 0;
1407   push_command_line_include ();
1408 }
1409
1410 /* Give CPP the next file given by -include, if any.  */
1411 static void
1412 push_command_line_include (void)
1413 {
1414   while (include_cursor < deferred_count)
1415     {
1416       struct deferred_opt *opt = &deferred_opts[include_cursor++];
1417
1418       if (!cpp_opts->preprocessed && opt->code == OPT_include
1419           && cpp_push_include (parse_in, opt->arg))
1420         return;
1421     }
1422
1423   if (include_cursor == deferred_count)
1424     {
1425       include_cursor++;
1426       /* -Wunused-macros should only warn about macros defined hereafter.  */
1427       cpp_opts->warn_unused_macros = warn_unused_macros;
1428       /* Restore the line map from <command line>.  */
1429       if (!cpp_opts->preprocessed)
1430         cpp_change_file (parse_in, LC_RENAME, this_input_filename);
1431
1432       /* Set this here so the client can change the option if it wishes,
1433          and after stacking the main file so we don't trace the main file.  */
1434       line_table.trace_includes = cpp_opts->print_include_names;
1435     }
1436 }
1437
1438 /* File change callback.  Has to handle -include files.  */
1439 static void
1440 cb_file_change (cpp_reader * ARG_UNUSED (pfile),
1441                 const struct line_map *new_map)
1442 {
1443   if (flag_preprocess_only)
1444     pp_file_change (new_map);
1445   else
1446     fe_file_change (new_map);
1447
1448   if (new_map == 0 || (new_map->reason == LC_LEAVE && MAIN_FILE_P (new_map)))
1449     push_command_line_include ();
1450 }
1451
1452 void
1453 cb_dir_change (cpp_reader * ARG_UNUSED (pfile), const char *dir)
1454 {
1455   if (!set_src_pwd (dir))
1456     warning (0, "too late for # directive to set debug directory");
1457 }
1458
1459 /* Set the C 89 standard (with 1994 amendments if C94, without GNU
1460    extensions if ISO).  There is no concept of gnu94.  */
1461 static void
1462 set_std_c89 (int c94, int iso)
1463 {
1464   cpp_set_lang (parse_in, c94 ? CLK_STDC94: iso ? CLK_STDC89: CLK_GNUC89);
1465   flag_iso = iso;
1466   flag_no_asm = iso;
1467   flag_no_gnu_keywords = iso;
1468   flag_no_nonansi_builtin = iso;
1469   flag_isoc94 = c94;
1470   flag_isoc99 = 0;
1471 }
1472
1473 /* Set the C 99 standard (without GNU extensions if ISO).  */
1474 static void
1475 set_std_c99 (int iso)
1476 {
1477   cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99);
1478   flag_no_asm = iso;
1479   flag_no_nonansi_builtin = iso;
1480   flag_iso = iso;
1481   flag_isoc99 = 1;
1482   flag_isoc94 = 1;
1483 }
1484
1485 /* Set the C++ 98 standard (without GNU extensions if ISO).  */
1486 static void
1487 set_std_cxx98 (int iso)
1488 {
1489   cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX);
1490   flag_no_gnu_keywords = iso;
1491   flag_no_nonansi_builtin = iso;
1492   flag_iso = iso;
1493 }
1494
1495 /* Handle setting implicit to ON.  */
1496 static void
1497 set_Wimplicit (int on)
1498 {
1499   warn_implicit = on;
1500   warn_implicit_int = on;
1501   if (on)
1502     {
1503       if (mesg_implicit_function_declaration != 2)
1504         mesg_implicit_function_declaration = 1;
1505     }
1506   else
1507     mesg_implicit_function_declaration = 0;
1508 }
1509
1510 /* Args to -d specify what to dump.  Silently ignore
1511    unrecognized options; they may be aimed at toplev.c.  */
1512 static void
1513 handle_OPT_d (const char *arg)
1514 {
1515   char c;
1516
1517   while ((c = *arg++) != '\0')
1518     switch (c)
1519       {
1520       case 'M':                 /* Dump macros only.  */
1521       case 'N':                 /* Dump names.  */
1522       case 'D':                 /* Dump definitions.  */
1523         flag_dump_macros = c;
1524         break;
1525
1526       case 'I':
1527         flag_dump_includes = 1;
1528         break;
1529       }
1530 }