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