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 /* If -Wvariadic-macros.  */
  92 static bool warn_variadic_macros = true;
  93
  94 /* Number of deferred options.  */
  95 static size_t deferred_count;
  96
  97 /* Number of deferred options scanned for -include.  */
  98 static size_t include_cursor;
  99
 100 /* Permit Fotran front-end options.  */
 101 static bool permit_fortran_options;
 102
 103 static void set_Wimplicit (int);
 104 static void handle_OPT_d (const char *);
 105 static void set_std_cxx98 (int);
 106 static void set_std_c89 (int, int);
 107 static void set_std_c99 (int);
 108 static void check_deps_environment_vars (void);
 109 static void handle_deferred_opts (void);
 110 static void sanitize_cpp_opts (void);
 111 static void add_prefixed_path (const char *, size_t);
 112 static void push_command_line_include (void);
 113 static void cb_file_change (cpp_reader *, const struct line_map *);
 114 static void cb_dir_change (cpp_reader *, const char *);
 115 static void finish_options (void);
 116
 117 #ifndef STDC_0_IN_SYSTEM_HEADERS
 118 #define STDC_0_IN_SYSTEM_HEADERS 0
 119 #endif
 120
 121 /* Holds switches parsed by c_common_handle_option (), but whose
 122    handling is deferred to c_common_post_options ().  */
 123 static void defer_opt (enum opt_code, const char *);
 124 static struct deferred_opt
 125 {
 126   enum opt_code code;
 127   const char *arg;
 128 } *deferred_opts;
 129
 130 /* Complain that switch CODE expects an argument but none was
 131    provided.  OPT was the command-line option.  Return FALSE to get
 132    the default message in opts.c, TRUE if we provide a specialized
 133    one.  */
 134 bool
 135 c_common_missing_argument (const char *opt, size_t code)
 136 {
 137   switch (code)
 138     {
 139     default:
 140       /* Pick up the default message.  */
 141       return false;
 142
 143     case OPT_fconstant_string_class_:
 144       error ("no class name specified with \"%s\"", opt);
 145       break;
 146
 147     case OPT_A:
 148       error ("assertion missing after \"%s\"", opt);
 149       break;
 150
 151     case OPT_D:
 152     case OPT_U:
 153       error ("macro name missing after \"%s\"", opt);
 154       break;
 155
 156     case OPT_F:
 157     case OPT_I:
 158     case OPT_idirafter:
 159     case OPT_isysroot:
 160     case OPT_isystem:
 161       error ("missing path after \"%s\"", opt);
 162       break;
 163
 164     case OPT_MF:
 165     case OPT_MD:
 166     case OPT_MMD:
 167     case OPT_include:
 168     case OPT_imacros:
 169     case OPT_o:
 170       error ("missing filename after \"%s\"", opt);
 171       break;
 172
 173     case OPT_MQ:
 174     case OPT_MT:
 175       error ("missing makefile target after \"%s\"", opt);
 176       break;
 177     }
 178
 179   return true;
 180 }
 181
 182 /* Defer option CODE with argument ARG.  */
 183 static void
 184 defer_opt (enum opt_code code, const char *arg)
 185 {
 186   deferred_opts[deferred_count].code = code;
 187   deferred_opts[deferred_count].arg = arg;
 188   deferred_count++;
 189 }
 190
 191 /* Common initialization before parsing options.  */
 192 unsigned int
 193 c_common_init_options (unsigned int argc, const char **argv ATTRIBUTE_UNUSED)
 194 {
 195   static const unsigned int lang_flags[] = {CL_C, CL_ObjC, CL_CXX, CL_ObjCXX};
 196   unsigned int result;
 197
 198   /* This is conditionalized only because that is the way the front
 199      ends used to do it.  Maybe this should be unconditional?  */
 200   if (c_dialect_cxx ())
 201     {
 202       /* By default wrap lines at 80 characters.  Is getenv
 203          ("COLUMNS") preferable?  */
 204       diagnostic_line_cutoff (global_dc) = 80;
 205       /* By default, emit location information once for every
 206          diagnostic message.  */
 207       diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
 208     }
 209
 210   parse_in = cpp_create_reader (c_dialect_cxx () ? CLK_GNUCXX: CLK_GNUC89,
 211                                 ident_hash, &line_table);
 212
 213   cpp_opts = cpp_get_options (parse_in);
 214   cpp_opts->dollars_in_ident = DOLLARS_IN_IDENTIFIERS;
 215   cpp_opts->objc = c_dialect_objc ();
 216
 217   /* Reset to avoid warnings on internal definitions.  We set it just
 218      before passing on command-line options to cpplib.  */
 219   cpp_opts->warn_dollars = 0;
 220
 221   flag_const_strings = c_dialect_cxx ();
 222   flag_exceptions = c_dialect_cxx ();
 223   warn_pointer_arith = c_dialect_cxx ();
 224
 225   deferred_opts = xmalloc (argc * sizeof (struct deferred_opt));
 226
 227   result = lang_flags[c_language];
 228
 229   /* If potentially preprocessing Fortran we have to accept its front
 230      end options since the driver passes most of them through.  */
 231 #ifdef CL_F77
 232   if (c_language == clk_c && argc > 2
 233       && !strcmp (argv[2], "-traditional-cpp" ))
 234     {
 235       permit_fortran_options = true;
 236       result |= CL_F77;
 237     }
 238 #endif
 239
 240   return result;
 241 }
 242
 243 /* Handle switch SCODE with argument ARG.  VALUE is true, unless no-
 244    form of an -f or -W option was given.  Returns 0 if the switch was
 245    invalid, a negative number to prevent language-independent
 246    processing in toplev.c (a hack necessary for the short-term).  */
 247 int
 248 c_common_handle_option (size_t scode, const char *arg, int value)
 249 {
 250   const struct cl_option *option = &cl_options[scode];
 251   enum opt_code code = (enum opt_code) scode;
 252   int result = 1;
 253
 254   switch (code)
 255     {
 256     default:
 257       result = permit_fortran_options;
 258       break;
 259
 260     case OPT__output_pch_:
 261       pch_file = arg;
 262       break;
 263
 264     case OPT_A:
 265       defer_opt (code, arg);
 266       break;
 267
 268     case OPT_C:
 269       cpp_opts->discard_comments = 0;
 270       break;
 271
 272     case OPT_CC:
 273       cpp_opts->discard_comments = 0;
 274       cpp_opts->discard_comments_in_macro_exp = 0;
 275       break;
 276
 277     case OPT_D:
 278       defer_opt (code, arg);
 279       break;
 280
 281     case OPT_E:
 282       flag_preprocess_only = 1;
 283       break;
 284
 285     case OPT_H:
 286       cpp_opts->print_include_names = 1;
 287       break;
 288
 289     case OPT_F:
 290       TARGET_OPTF (xstrdup (arg));
 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_Wvariadic_macros:
 658       warn_variadic_macros = value;
 659       break;
 660
 661     case OPT_Wwrite_strings:
 662       if (!c_dialect_cxx ())
 663         flag_const_strings = value;
 664       else
 665         warn_write_strings = value;
 666       break;
 667
 668     case OPT_ansi:
 669       if (!c_dialect_cxx ())
 670         set_std_c89 (false, true);
 671       else
 672         set_std_cxx98 (true);
 673       break;
 674
 675     case OPT_d:
 676       handle_OPT_d (arg);
 677       break;
 678
 679     case OPT_fcond_mismatch:
 680       if (!c_dialect_cxx ())
 681         {
 682           flag_cond_mismatch = value;
 683           break;
 684         }
 685       /* Fall through.  */
 686
 687     case OPT_fall_virtual:
 688     case OPT_falt_external_templates:
 689     case OPT_fenum_int_equiv:
 690     case OPT_fexternal_templates:
 691     case OPT_fguiding_decls:
 692     case OPT_fhonor_std:
 693     case OPT_fhuge_objects:
 694     case OPT_flabels_ok:
 695     case OPT_fname_mangling_version_:
 696     case OPT_fnew_abi:
 697     case OPT_fnonnull_objects:
 698     case OPT_fsquangle:
 699     case OPT_fstrict_prototype:
 700     case OPT_fthis_is_variable:
 701     case OPT_fvtable_thunks:
 702     case OPT_fxref:
 703     case OPT_fvtable_gc:
 704       warning ("switch \"%s\" is no longer supported", option->opt_text);
 705       break;
 706
 707     case OPT_faccess_control:
 708       flag_access_control = value;
 709       break;
 710
 711     case OPT_fasm:
 712       flag_no_asm = !value;
 713       break;
 714
 715     case OPT_fbuiltin:
 716       flag_no_builtin = !value;
 717       break;
 718
 719     case OPT_fbuiltin_:
 720       if (value)
 721         result = 0;
 722       else
 723         disable_builtin_function (arg);
 724       break;
 725
 726     case OPT_fdollars_in_identifiers:
 727       cpp_opts->dollars_in_ident = value;
 728       break;
 729
 730     case OPT_fdump_:
 731       if (!dump_switch_p (arg))
 732         result = 0;
 733       break;
 734
 735     case OPT_ffreestanding:
 736       value = !value;
 737       /* Fall through....  */
 738     case OPT_fhosted:
 739       flag_hosted = value;
 740       flag_no_builtin = !value;
 741       /* warn_main will be 2 if set by -Wall, 1 if set by -Wmain */
 742       if (!value && warn_main == 2)
 743         warn_main = 0;
 744       break;
 745
 746     case OPT_fshort_double:
 747       flag_short_double = value;
 748       break;
 749
 750     case OPT_fshort_enums:
 751       flag_short_enums = value;
 752       break;
 753
 754     case OPT_fshort_wchar:
 755       flag_short_wchar = value;
 756       break;
 757
 758     case OPT_fsigned_bitfields:
 759       flag_signed_bitfields = value;
 760       explicit_flag_signed_bitfields = 1;
 761       break;
 762
 763     case OPT_fsigned_char:
 764       flag_signed_char = value;
 765       break;
 766
 767     case OPT_funsigned_bitfields:
 768       flag_signed_bitfields = !value;
 769       explicit_flag_signed_bitfields = 1;
 770       break;
 771
 772     case OPT_funsigned_char:
 773       flag_signed_char = !value;
 774       break;
 775
 776     case OPT_fcheck_new:
 777       flag_check_new = value;
 778       break;
 779
 780     case OPT_fconserve_space:
 781       flag_conserve_space = value;
 782       break;
 783
 784     case OPT_fconst_strings:
 785       flag_const_strings = value;
 786       break;
 787
 788     case OPT_fconstant_string_class_:
 789       constant_string_class_name = arg;
 790       break;
 791
 792     case OPT_fdefault_inline:
 793       flag_default_inline = value;
 794       break;
 795
 796     case OPT_felide_constructors:
 797       flag_elide_constructors = value;
 798       break;
 799
 800     case OPT_fenforce_eh_specs:
 801       flag_enforce_eh_specs = value;
 802       break;
 803
 804     case OPT_ffixed_form:
 805     case OPT_ffixed_line_length_:
 806       /* Fortran front end options ignored when preprocessing only.  */
 807       if (!flag_preprocess_only)
 808         result = 0;
 809       break;
 810
 811     case OPT_ffor_scope:
 812       flag_new_for_scope = value;
 813       break;
 814
 815     case OPT_fgnu_keywords:
 816       flag_no_gnu_keywords = !value;
 817       break;
 818
 819     case OPT_fgnu_runtime:
 820       flag_next_runtime = !value;
 821       break;
 822
 823     case OPT_fhandle_exceptions:
 824       warning ("-fhandle-exceptions has been renamed -fexceptions (and is now on by default)");
 825       flag_exceptions = value;
 826       break;
 827
 828     case OPT_fimplement_inlines:
 829       flag_implement_inlines = value;
 830       break;
 831
 832     case OPT_fimplicit_inline_templates:
 833       flag_implicit_inline_templates = value;
 834       break;
 835
 836     case OPT_fimplicit_templates:
 837       flag_implicit_templates = value;
 838       break;
 839
 840     case OPT_fms_extensions:
 841       flag_ms_extensions = value;
 842       break;
 843
 844     case OPT_fnext_runtime:
 845       flag_next_runtime = value;
 846       break;
 847
 848     case OPT_fnil_receivers:
 849       flag_nil_receivers = value;
 850       break;
 851
 852     case OPT_fnonansi_builtins:
 853       flag_no_nonansi_builtin = !value;
 854       break;
 855
 856     case OPT_fobjc_exceptions:
 857       flag_objc_exceptions = value;
 858       break;
 859
 860     case OPT_foperator_names:
 861       cpp_opts->operator_names = value;
 862       break;
 863
 864     case OPT_foptional_diags:
 865       flag_optional_diags = value;
 866       break;
 867
 868     case OPT_fpch_deps:
 869       cpp_opts->restore_pch_deps = value;
 870       break;
 871
 872     case OPT_fpermissive:
 873       flag_permissive = value;
 874       break;
 875
 876     case OPT_fpreprocessed:
 877       cpp_opts->preprocessed = value;
 878       break;
 879
 880     case OPT_freplace_objc_classes:
 881       flag_replace_objc_classes = value;
 882       break;
 883
 884     case OPT_frepo:
 885       flag_use_repository = value;
 886       if (value)
 887         flag_implicit_templates = 0;
 888       break;
 889
 890     case OPT_frtti:
 891       flag_rtti = value;
 892       break;
 893
 894     case OPT_fshow_column:
 895       cpp_opts->show_column = value;
 896       break;
 897
 898     case OPT_fstats:
 899       flag_detailed_statistics = value;
 900       break;
 901
 902     case OPT_ftabstop_:
 903       /* It is documented that we silently ignore silly values.  */
 904       if (value >= 1 && value <= 100)
 905         cpp_opts->tabstop = value;
 906       break;
 907
 908     case OPT_fexec_charset_:
 909       cpp_opts->narrow_charset = arg;
 910       break;
 911
 912     case OPT_fwide_exec_charset_:
 913       cpp_opts->wide_charset = arg;
 914       break;
 915
 916     case OPT_finput_charset_:
 917       cpp_opts->input_charset = arg;
 918       break;
 919
 920     case OPT_ftemplate_depth_:
 921       max_tinst_depth = value;
 922       break;
 923
 924     case OPT_fuse_cxa_atexit:
 925       flag_use_cxa_atexit = value;
 926       break;
 927
 928     case OPT_fweak:
 929       flag_weak = value;
 930       break;
 931
 932     case OPT_fzero_link:
 933       flag_zero_link = value;
 934       break;
 935
 936     case OPT_gen_decls:
 937       flag_gen_declaration = 1;
 938       break;
 939
 940     case OPT_idirafter:
 941       add_path (xstrdup (arg), AFTER, 0);
 942       break;
 943
 944     case OPT_imacros:
 945     case OPT_include:
 946       defer_opt (code, arg);
 947       break;
 948
 949     case OPT_iprefix:
 950       iprefix = arg;
 951       break;
 952
 953     case OPT_isysroot:
 954       sysroot = arg;
 955       break;
 956
 957     case OPT_isystem:
 958       add_path (xstrdup (arg), SYSTEM, 0);
 959       break;
 960
 961     case OPT_iwithprefix:
 962       add_prefixed_path (arg, SYSTEM);
 963       break;
 964
 965     case OPT_iwithprefixbefore:
 966       add_prefixed_path (arg, BRACKET);
 967       break;
 968
 969     case OPT_lang_asm:
 970       cpp_set_lang (parse_in, CLK_ASM);
 971       cpp_opts->dollars_in_ident = false;
 972       break;
 973
 974     case OPT_lang_objc:
 975       cpp_opts->objc = 1;
 976       break;
 977
 978     case OPT_nostdinc:
 979       std_inc = false;
 980       break;
 981
 982     case OPT_nostdinc__:
 983       std_cxx_inc = false;
 984       break;
 985
 986     case OPT_o:
 987       if (!out_fname)
 988         out_fname = arg;
 989       else
 990         error ("output filename specified twice");
 991       break;
 992
 993       /* We need to handle the -pedantic switches here, rather than in
 994          c_common_post_options, so that a subsequent -Wno-endif-labels
 995          is not overridden.  */
 996     case OPT_pedantic_errors:
 997       cpp_opts->pedantic_errors = 1;
 998       /* Fall through.  */
 999     case OPT_pedantic:
1000       cpp_opts->pedantic = 1;
1001       cpp_opts->warn_endif_labels = 1;
1002       break;
1003
1004     case OPT_print_objc_runtime_info:
1005       print_struct_values = 1;
1006       break;
1007
1008     case OPT_remap:
1009       cpp_opts->remap = 1;
1010       break;
1011
1012     case OPT_std_c__98:
1013     case OPT_std_gnu__98:
1014       set_std_cxx98 (code == OPT_std_c__98 /* ISO */);
1015       break;
1016
1017     case OPT_std_c89:
1018     case OPT_std_iso9899_1990:
1019     case OPT_std_iso9899_199409:
1020       set_std_c89 (code == OPT_std_iso9899_199409 /* c94 */, true /* ISO */);
1021       break;
1022
1023     case OPT_std_gnu89:
1024       set_std_c89 (false /* c94 */, false /* ISO */);
1025       break;
1026
1027     case OPT_std_c99:
1028     case OPT_std_c9x:
1029     case OPT_std_iso9899_1999:
1030     case OPT_std_iso9899_199x:
1031       set_std_c99 (true /* ISO */);
1032       break;
1033
1034     case OPT_std_gnu99:
1035     case OPT_std_gnu9x:
1036       set_std_c99 (false /* ISO */);
1037       break;
1038
1039     case OPT_trigraphs:
1040       cpp_opts->trigraphs = 1;
1041       break;
1042
1043     case OPT_traditional_cpp:
1044       cpp_opts->traditional = 1;
1045       break;
1046
1047     case OPT_undef:
1048       flag_undef = 1;
1049       break;
1050
1051     case OPT_w:
1052       cpp_opts->inhibit_warnings = 1;
1053       break;
1054
1055     case OPT_v:
1056       verbose = true;
1057       break;
1058     }
1059
1060   return result;
1061 }
1062
1063 /* Post-switch processing.  */
1064 bool
1065 c_common_post_options (const char **pfilename)
1066 {
1067   struct cpp_callbacks *cb;
1068
1069   /* Canonicalize the input and output filenames.  */
1070   if (in_fnames == NULL)
1071     {
1072       in_fnames = xmalloc (sizeof (in_fnames[0]));
1073       in_fnames[0] = "";
1074     }
1075   else if (strcmp (in_fnames[0], "-") == 0)
1076     in_fnames[0] = "";
1077
1078   if (out_fname == NULL || !strcmp (out_fname, "-"))
1079     out_fname = "";
1080
1081   if (cpp_opts->deps.style == DEPS_NONE)
1082     check_deps_environment_vars ();
1083
1084   handle_deferred_opts ();
1085
1086   sanitize_cpp_opts ();
1087
1088   register_include_chains (parse_in, sysroot, iprefix,
1089                            std_inc, std_cxx_inc && c_dialect_cxx (), verbose);
1090
1091   flag_inline_trees = 1;
1092
1093   /* Use tree inlining if possible.  Function instrumentation is only
1094      done in the RTL level, so we disable tree inlining.  */
1095   if (! flag_instrument_function_entry_exit)
1096     {
1097       if (!flag_no_inline)
1098         flag_no_inline = 1;
1099       if (flag_inline_functions)
1100         {
1101           flag_inline_trees = 2;
1102           flag_inline_functions = 0;
1103         }
1104     }
1105
1106   /* -Wextra implies -Wsign-compare, but not if explicitly
1107       overridden.  */
1108   if (warn_sign_compare == -1)
1109     warn_sign_compare = extra_warnings;
1110
1111   /* Special format checking options don't work without -Wformat; warn if
1112      they are used.  */
1113   if (warn_format_y2k && !warn_format)
1114     warning ("-Wformat-y2k ignored without -Wformat");
1115   if (warn_format_extra_args && !warn_format)
1116     warning ("-Wformat-extra-args ignored without -Wformat");
1117   if (warn_format_zero_length && !warn_format)
1118     warning ("-Wformat-zero-length ignored without -Wformat");
1119   if (warn_format_nonliteral && !warn_format)
1120     warning ("-Wformat-nonliteral ignored without -Wformat");
1121   if (warn_format_security && !warn_format)
1122     warning ("-Wformat-security ignored without -Wformat");
1123   if (warn_missing_format_attribute && !warn_format)
1124     warning ("-Wmissing-format-attribute ignored without -Wformat");
1125
1126   if (flag_preprocess_only)
1127     {
1128       /* Open the output now.  We must do so even if flag_no_output is
1129          on, because there may be other output than from the actual
1130          preprocessing (e.g. from -dM).  */
1131       if (out_fname[0] == '\0')
1132         out_stream = stdout;
1133       else
1134         out_stream = fopen (out_fname, "w");
1135
1136       if (out_stream == NULL)
1137         {
1138           fatal_error ("opening output file %s: %m", out_fname);
1139           return false;
1140         }
1141
1142       if (num_in_fnames > 1)
1143         error ("too many filenames given.  Type %s --help for usage",
1144                progname);
1145
1146       init_pp_output (out_stream);
1147     }
1148   else
1149     {
1150       init_c_lex ();
1151
1152       /* Yuk.  WTF is this?  I do know ObjC relies on it somewhere.  */
1153       input_line = 0;
1154     }
1155
1156   cb = cpp_get_callbacks (parse_in);
1157   cb->file_change = cb_file_change;
1158   cb->dir_change = cb_dir_change;
1159   cpp_post_options (parse_in);
1160
1161   saved_lineno = input_line;
1162   input_line = 0;
1163
1164   /* If an error has occurred in cpplib, note it so we fail
1165      immediately.  */
1166   errorcount += cpp_errors (parse_in);
1167
1168   *pfilename = this_input_filename
1169     = cpp_read_main_file (parse_in, in_fnames[0]);
1170   if (this_input_filename == NULL)
1171     return true;
1172
1173   if (flag_working_directory
1174       && flag_preprocess_only && ! flag_no_line_commands)
1175     pp_dir_change (parse_in, get_src_pwd ());
1176
1177   return flag_preprocess_only;
1178 }
1179
1180 /* Front end initialization common to C, ObjC and C++.  */
1181 bool
1182 c_common_init (void)
1183 {
1184   input_line = saved_lineno;
1185
1186   /* Set up preprocessor arithmetic.  Must be done after call to
1187      c_common_nodes_and_builtins for type nodes to be good.  */
1188   cpp_opts->precision = TYPE_PRECISION (intmax_type_node);
1189   cpp_opts->char_precision = TYPE_PRECISION (char_type_node);
1190   cpp_opts->int_precision = TYPE_PRECISION (integer_type_node);
1191   cpp_opts->wchar_precision = TYPE_PRECISION (wchar_type_node);
1192   cpp_opts->unsigned_wchar = TREE_UNSIGNED (wchar_type_node);
1193   cpp_opts->bytes_big_endian = BYTES_BIG_ENDIAN;
1194
1195   /* This can't happen until after wchar_precision and bytes_big_endian
1196      are known.  */
1197   cpp_init_iconv (parse_in);
1198
1199   if (flag_preprocess_only)
1200     {
1201       finish_options ();
1202       preprocess_file (parse_in);
1203       return false;
1204     }
1205
1206   /* Has to wait until now so that cpplib has its hash table.  */
1207   init_pragma ();
1208
1209   return true;
1210 }
1211
1212 /* Initialize the integrated preprocessor after debug output has been
1213    initialized; loop over each input file.  */
1214 void
1215 c_common_parse_file (int set_yydebug ATTRIBUTE_UNUSED)
1216 {
1217   unsigned file_index;
1218
1219 #if YYDEBUG != 0
1220   yydebug = set_yydebug;
1221 #else
1222   warning ("YYDEBUG not defined");
1223 #endif
1224
1225   file_index = 0;
1226
1227   do
1228     {
1229       if (file_index > 0)
1230         {
1231           /* Reset the state of the parser.  */
1232           c_reset_state();
1233
1234           /* Reset cpplib's macros and start a new file.  */
1235           cpp_undef_all (parse_in);
1236           main_input_filename = this_input_filename
1237             = cpp_read_main_file (parse_in, in_fnames[file_index]);
1238           if (this_input_filename == NULL)
1239             break;
1240         }
1241       finish_options ();
1242       if (file_index == 0)
1243         pch_init();
1244       c_parse_file ();
1245
1246       file_index++;
1247     } while (file_index < num_in_fnames);
1248
1249   finish_file ();
1250 }
1251
1252 /* Common finish hook for the C, ObjC and C++ front ends.  */
1253 void
1254 c_common_finish (void)
1255 {
1256   FILE *deps_stream = NULL;
1257
1258   if (cpp_opts->deps.style != DEPS_NONE)
1259     {
1260       /* If -M or -MM was seen without -MF, default output to the
1261          output stream.  */
1262       if (!deps_file)
1263         deps_stream = out_stream;
1264       else
1265         {
1266           deps_stream = fopen (deps_file, deps_append ? "a": "w");
1267           if (!deps_stream)
1268             fatal_error ("opening dependency file %s: %m", deps_file);
1269         }
1270     }
1271
1272   /* For performance, avoid tearing down cpplib's internal structures
1273      with cpp_destroy ().  */
1274   errorcount += cpp_finish (parse_in, deps_stream);
1275
1276   if (deps_stream && deps_stream != out_stream
1277       && (ferror (deps_stream) || fclose (deps_stream)))
1278     fatal_error ("closing dependency file %s: %m", deps_file);
1279
1280   if (out_stream && (ferror (out_stream) || fclose (out_stream)))
1281     fatal_error ("when writing output to %s: %m", out_fname);
1282 }
1283
1284 /* Either of two environment variables can specify output of
1285    dependencies.  Their value is either "OUTPUT_FILE" or "OUTPUT_FILE
1286    DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to
1287    and DEPS_TARGET is the target to mention in the deps.  They also
1288    result in dependency information being appended to the output file
1289    rather than overwriting it, and like Sun's compiler
1290    SUNPRO_DEPENDENCIES suppresses the dependency on the main file.  */
1291 static void
1292 check_deps_environment_vars (void)
1293 {
1294   char *spec;
1295
1296   GET_ENVIRONMENT (spec, "DEPENDENCIES_OUTPUT");
1297   if (spec)
1298     cpp_opts->deps.style = DEPS_USER;
1299   else
1300     {
1301       GET_ENVIRONMENT (spec, "SUNPRO_DEPENDENCIES");
1302       if (spec)
1303         {
1304           cpp_opts->deps.style = DEPS_SYSTEM;
1305           cpp_opts->deps.ignore_main_file = true;
1306         }
1307     }
1308
1309   if (spec)
1310     {
1311       /* Find the space before the DEPS_TARGET, if there is one.  */
1312       char *s = strchr (spec, ' ');
1313       if (s)
1314         {
1315           /* Let the caller perform MAKE quoting.  */
1316           defer_opt (OPT_MT, s + 1);
1317           *s = '\0';
1318         }
1319
1320       /* Command line -MF overrides environment variables and default.  */
1321       if (!deps_file)
1322         deps_file = spec;
1323
1324       deps_append = 1;
1325     }
1326 }
1327
1328 /* Handle deferred command line switches.  */
1329 static void
1330 handle_deferred_opts (void)
1331 {
1332   size_t i;
1333
1334   for (i = 0; i < deferred_count; i++)
1335     {
1336       struct deferred_opt *opt = &deferred_opts[i];
1337
1338       if (opt->code == OPT_MT || opt->code == OPT_MQ)
1339         cpp_add_dependency_target (parse_in, opt->arg, opt->code == OPT_MQ);
1340     }
1341 }
1342
1343 /* These settings are appropriate for GCC, but not necessarily so for
1344    cpplib as a library.  */
1345 static void
1346 sanitize_cpp_opts (void)
1347 {
1348   /* If we don't know what style of dependencies to output, complain
1349      if any other dependency switches have been given.  */
1350   if (deps_seen && cpp_opts->deps.style == DEPS_NONE)
1351     error ("to generate dependencies you must specify either -M or -MM");
1352
1353   /* -dM and dependencies suppress normal output; do it here so that
1354      the last -d[MDN] switch overrides earlier ones.  */
1355   if (flag_dump_macros == 'M')
1356     flag_no_output = 1;
1357
1358   /* Disable -dD, -dN and -dI if normal output is suppressed.  Allow
1359      -dM since at least glibc relies on -M -dM to work.  */
1360   if (flag_no_output)
1361     {
1362       if (flag_dump_macros != 'M')
1363         flag_dump_macros = 0;
1364       flag_dump_includes = 0;
1365     }
1366
1367   cpp_opts->unsigned_char = !flag_signed_char;
1368   cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS;
1369
1370   /* We want -Wno-long-long to override -pedantic -std=non-c99
1371      and/or -Wtraditional, whatever the ordering.  */
1372   cpp_opts->warn_long_long
1373     = warn_long_long && ((!flag_isoc99 && pedantic) || warn_traditional);
1374
1375   /* Similarly with -Wno-variadic-macros.  No check for c99 here, since
1376      this also turns off warnings about GCCs extension.  */
1377   cpp_opts->warn_variadic_macros
1378     = warn_variadic_macros && (pedantic || warn_traditional);
1379
1380   /* If we're generating preprocessor output, emit current directory
1381      if explicitly requested or if debugging information is enabled.
1382      ??? Maybe we should only do it for debugging formats that
1383      actually output the current directory?  */
1384   if (flag_working_directory == -1)
1385     flag_working_directory = (debug_info_level != DINFO_LEVEL_NONE);
1386 }
1387
1388 /* Add include path with a prefix at the front of its name.  */
1389 static void
1390 add_prefixed_path (const char *suffix, size_t chain)
1391 {
1392   char *path;
1393   const char *prefix;
1394   size_t prefix_len, suffix_len;
1395
1396   suffix_len = strlen (suffix);
1397   prefix     = iprefix ? iprefix : cpp_GCC_INCLUDE_DIR;
1398   prefix_len = iprefix ? strlen (iprefix) : cpp_GCC_INCLUDE_DIR_len;
1399
1400   path = xmalloc (prefix_len + suffix_len + 1);
1401   memcpy (path, prefix, prefix_len);
1402   memcpy (path + prefix_len, suffix, suffix_len);
1403   path[prefix_len + suffix_len] = '\0';
1404
1405   add_path (path, chain, 0);
1406 }
1407
1408 /* Handle -D, -U, -A, -imacros, and the first -include.  */
1409 static void
1410 finish_options (void)
1411 {
1412   if (!cpp_opts->preprocessed)
1413     {
1414       size_t i;
1415
1416       cpp_change_file (parse_in, LC_RENAME, _("<built-in>"));
1417       cpp_init_builtins (parse_in, flag_hosted);
1418       c_cpp_builtins (parse_in);
1419
1420       /* We're about to send user input to cpplib, so make it warn for
1421          things that we previously (when we sent it internal definitions)
1422          told it to not warn.
1423
1424          C99 permits implementation-defined characters in identifiers.
1425          The documented meaning of -std= is to turn off extensions that
1426          conflict with the specified standard, and since a strictly
1427          conforming program cannot contain a '$', we do not condition
1428          their acceptance on the -std= setting.  */
1429       cpp_opts->warn_dollars = (cpp_opts->pedantic && !cpp_opts->c99);
1430
1431       cpp_change_file (parse_in, LC_RENAME, _("<command line>"));
1432       for (i = 0; i < deferred_count; i++)
1433         {
1434           struct deferred_opt *opt = &deferred_opts[i];
1435
1436           if (opt->code == OPT_D)
1437             cpp_define (parse_in, opt->arg);
1438           else if (opt->code == OPT_U)
1439             cpp_undef (parse_in, opt->arg);
1440           else if (opt->code == OPT_A)
1441             {
1442               if (opt->arg[0] == '-')
1443                 cpp_unassert (parse_in, opt->arg + 1);
1444               else
1445                 cpp_assert (parse_in, opt->arg);
1446             }
1447         }
1448
1449       /* Handle -imacros after -D and -U.  */
1450       for (i = 0; i < deferred_count; i++)
1451         {
1452           struct deferred_opt *opt = &deferred_opts[i];
1453
1454           if (opt->code == OPT_imacros
1455               && cpp_push_include (parse_in, opt->arg))
1456             {
1457               /* Disable push_command_line_include callback for now.  */
1458               include_cursor = deferred_count + 1;
1459               cpp_scan_nooutput (parse_in);
1460             }
1461         }
1462     }
1463
1464   include_cursor = 0;
1465   push_command_line_include ();
1466 }
1467
1468 /* Give CPP the next file given by -include, if any.  */
1469 static void
1470 push_command_line_include (void)
1471 {
1472   while (include_cursor < deferred_count)
1473     {
1474       struct deferred_opt *opt = &deferred_opts[include_cursor++];
1475
1476       if (! cpp_opts->preprocessed && opt->code == OPT_include
1477           && cpp_push_include (parse_in, opt->arg))
1478         return;
1479     }
1480
1481   if (include_cursor == deferred_count)
1482     {
1483       include_cursor++;
1484       /* -Wunused-macros should only warn about macros defined hereafter.  */
1485       cpp_opts->warn_unused_macros = warn_unused_macros;
1486       /* Restore the line map from <command line>.  */
1487       if (! cpp_opts->preprocessed)
1488         cpp_change_file (parse_in, LC_RENAME, main_input_filename);
1489
1490       /* Set this here so the client can change the option if it wishes,
1491          and after stacking the main file so we don't trace the main file.  */
1492       line_table.trace_includes = cpp_opts->print_include_names;
1493     }
1494 }
1495
1496 /* File change callback.  Has to handle -include files.  */
1497 static void
1498 cb_file_change (cpp_reader *pfile ATTRIBUTE_UNUSED,
1499                 const struct line_map *new_map)
1500 {
1501   if (flag_preprocess_only)
1502     pp_file_change (new_map);
1503   else
1504     fe_file_change (new_map);
1505
1506   if (new_map == 0 || (new_map->reason == LC_LEAVE && MAIN_FILE_P (new_map)))
1507     push_command_line_include ();
1508 }
1509
1510 void
1511 cb_dir_change (cpp_reader *pfile ATTRIBUTE_UNUSED, const char *dir)
1512 {
1513   if (! set_src_pwd (dir))
1514     warning ("too late for # directive to set debug directory");
1515 }
1516
1517 /* Set the C 89 standard (with 1994 amendments if C94, without GNU
1518    extensions if ISO).  There is no concept of gnu94.  */
1519 static void
1520 set_std_c89 (int c94, int iso)
1521 {
1522   cpp_set_lang (parse_in, c94 ? CLK_STDC94: iso ? CLK_STDC89: CLK_GNUC89);
1523   flag_iso = iso;
1524   flag_no_asm = iso;
1525   flag_no_gnu_keywords = iso;
1526   flag_no_nonansi_builtin = iso;
1527   flag_isoc94 = c94;
1528   flag_isoc99 = 0;
1529 }
1530
1531 /* Set the C 99 standard (without GNU extensions if ISO).  */
1532 static void
1533 set_std_c99 (int iso)
1534 {
1535   cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99);
1536   flag_no_asm = iso;
1537   flag_no_nonansi_builtin = iso;
1538   flag_iso = iso;
1539   flag_isoc99 = 1;
1540   flag_isoc94 = 1;
1541 }
1542
1543 /* Set the C++ 98 standard (without GNU extensions if ISO).  */
1544 static void
1545 set_std_cxx98 (int iso)
1546 {
1547   cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX);
1548   flag_no_gnu_keywords = iso;
1549   flag_no_nonansi_builtin = iso;
1550   flag_iso = iso;
1551 }
1552
1553 /* Handle setting implicit to ON.  */
1554 static void
1555 set_Wimplicit (int on)
1556 {
1557   warn_implicit = on;
1558   warn_implicit_int = on;
1559   if (on)
1560     {
1561       if (mesg_implicit_function_declaration != 2)
1562         mesg_implicit_function_declaration = 1;
1563     }
1564   else
1565     mesg_implicit_function_declaration = 0;
1566 }
1567
1568 /* Args to -d specify what to dump.  Silently ignore
1569    unrecognized options; they may be aimed at toplev.c.  */
1570 static void
1571 handle_OPT_d (const char *arg)
1572 {
1573   char c;
1574
1575   while ((c = *arg++) != '\0')
1576     switch (c)
1577       {
1578       case 'M':                 /* Dump macros only.  */
1579       case 'N':                 /* Dump names.  */
1580       case 'D':                 /* Dump definitions.  */
1581         flag_dump_macros = c;
1582         break;
1583
1584       case 'I':
1585         flag_dump_includes = 1;
1586         break;
1587       }
1588 }