contrib/gcc-3.4/gcc/c-opts.c

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