gcc/c-opts.c

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