gcc/c-opts.c

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