gcc/c-opts.c

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