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