gcc/c-opts.c

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