contrib/gcc/c-opts.c

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