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