gcc/c-opts.c

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