gcc/c-opts.c

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