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_strict_overflow = value;
 399       warn_string_literal_comparison = value;
 400       warn_always_true = value;
 401       warn_array_bounds = value;
 402
 403       /* Only warn about unknown pragmas that are not in system
 404          headers.  */
 405       warn_unknown_pragmas = value;
 406
 407       /* We save the value of warn_uninitialized, since if they put
 408          -Wuninitialized on the command line, we need to generate a
 409          warning about not using it without also specifying -O.  */
 410       if (warn_uninitialized != 1)
 411         warn_uninitialized = (value ? 2 : 0);
 412
 413       if (!c_dialect_cxx ())
 414         /* We set this to 2 here, but 1 in -Wmain, so -ffreestanding
 415            can turn it off only if it's not explicit.  */
 416         warn_main = value * 2;
 417       else
 418         {
 419           /* C++-specific warnings.  */
 420           warn_reorder = value;
 421           warn_nontemplate_friend = value;
 422           warn_cxx0x_compat = value;
 423           if (value > 0)
 424             warn_write_strings = true;
 425         }
 426
 427       cpp_opts->warn_trigraphs = value;
 428       cpp_opts->warn_comments = value;
 429       cpp_opts->warn_num_sign_change = value;
 430       cpp_opts->warn_multichar = value; /* Was C++ only.  */
 431
 432       if (warn_pointer_sign == -1)
 433         warn_pointer_sign = 1;
 434       break;
 435
 436     case OPT_Wcomment:
 437     case OPT_Wcomments:
 438       cpp_opts->warn_comments = value;
 439       break;
 440
 441     case OPT_Wdeprecated:
 442       cpp_opts->warn_deprecated = value;
 443       break;
 444
 445     case OPT_Wendif_labels:
 446       cpp_opts->warn_endif_labels = value;
 447       break;
 448
 449     case OPT_Werror:
 450       cpp_opts->warnings_are_errors = value;
 451       global_dc->warning_as_error_requested = value;
 452       break;
 453
 454     case OPT_Werror_implicit_function_declaration:
 455       /* For backward compatibility, this is the same as
 456          -Werror=implicit-function-declaration.  */
 457       enable_warning_as_error ("implicit-function-declaration", value, CL_C | CL_ObjC);
 458       break;
 459
 460     case OPT_Wformat:
 461       set_Wformat (value);
 462       break;
 463
 464     case OPT_Wformat_:
 465       set_Wformat (atoi (arg));
 466       break;
 467
 468     case OPT_Wimplicit:
 469       set_Wimplicit (value);
 470       break;
 471
 472     case OPT_Wimport:
 473       /* Silently ignore for now.  */
 474       break;
 475
 476     case OPT_Winvalid_pch:
 477       cpp_opts->warn_invalid_pch = value;
 478       break;
 479
 480     case OPT_Wmain:
 481       if (value)
 482         warn_main = 1;
 483       else
 484         warn_main = -1;
 485       break;
 486
 487     case OPT_Wmissing_include_dirs:
 488       cpp_opts->warn_missing_include_dirs = value;
 489       break;
 490
 491     case OPT_Wmultichar:
 492       cpp_opts->warn_multichar = value;
 493       break;
 494
 495     case OPT_Wnormalized_:
 496       if (!value || (arg && strcasecmp (arg, "none") == 0))
 497         cpp_opts->warn_normalize = normalized_none;
 498       else if (!arg || strcasecmp (arg, "nfkc") == 0)
 499         cpp_opts->warn_normalize = normalized_KC;
 500       else if (strcasecmp (arg, "id") == 0)
 501         cpp_opts->warn_normalize = normalized_identifier_C;
 502       else if (strcasecmp (arg, "nfc") == 0)
 503         cpp_opts->warn_normalize = normalized_C;
 504       else
 505         error ("argument %qs to %<-Wnormalized%> not recognized", arg);
 506       break;
 507
 508     case OPT_Wreturn_type:
 509       warn_return_type = value;
 510       break;
 511
 512     case OPT_Wstrict_null_sentinel:
 513       warn_strict_null_sentinel = value;
 514       break;
 515
 516     case OPT_Wsystem_headers:
 517       cpp_opts->warn_system_headers = value;
 518       break;
 519
 520     case OPT_Wtraditional:
 521       cpp_opts->warn_traditional = value;
 522       break;
 523
 524     case OPT_Wtrigraphs:
 525       cpp_opts->warn_trigraphs = value;
 526       break;
 527
 528     case OPT_Wundef:
 529       cpp_opts->warn_undef = value;
 530       break;
 531
 532     case OPT_Wunknown_pragmas:
 533       /* Set to greater than 1, so that even unknown pragmas in
 534          system headers will be warned about.  */
 535       warn_unknown_pragmas = value * 2;
 536       break;
 537
 538     case OPT_Wunused_macros:
 539       warn_unused_macros = value;
 540       break;
 541
 542     case OPT_Wvariadic_macros:
 543       warn_variadic_macros = value;
 544       break;
 545
 546     case OPT_Wwrite_strings:
 547       warn_write_strings = value;
 548       break;
 549
 550     case OPT_Weffc__:
 551       warn_ecpp = value;
 552       if (value)
 553         warn_nonvdtor = true;
 554       break;
 555
 556     case OPT_ansi:
 557       if (!c_dialect_cxx ())
 558         set_std_c89 (false, true);
 559       else
 560         set_std_cxx98 (true);
 561       break;
 562
 563     case OPT_d:
 564       handle_OPT_d (arg);
 565       break;
 566
 567     case OPT_fcond_mismatch:
 568       if (!c_dialect_cxx ())
 569         {
 570           flag_cond_mismatch = value;
 571           break;
 572         }
 573       /* Fall through.  */
 574
 575     case OPT_fall_virtual:
 576     case OPT_falt_external_templates:
 577     case OPT_fenum_int_equiv:
 578     case OPT_fexternal_templates:
 579     case OPT_fguiding_decls:
 580     case OPT_fhonor_std:
 581     case OPT_fhuge_objects:
 582     case OPT_flabels_ok:
 583     case OPT_fname_mangling_version_:
 584     case OPT_fnew_abi:
 585     case OPT_fnonnull_objects:
 586     case OPT_fsquangle:
 587     case OPT_fstrict_prototype:
 588     case OPT_fthis_is_variable:
 589     case OPT_fvtable_thunks:
 590     case OPT_fxref:
 591     case OPT_fvtable_gc:
 592       warning (0, "switch %qs is no longer supported", option->opt_text);
 593       break;
 594
 595     case OPT_faccess_control:
 596       flag_access_control = value;
 597       break;
 598
 599     case OPT_fasm:
 600       flag_no_asm = !value;
 601       break;
 602
 603     case OPT_fbuiltin:
 604       flag_no_builtin = !value;
 605       break;
 606
 607     case OPT_fbuiltin_:
 608       if (value)
 609         result = 0;
 610       else
 611         disable_builtin_function (arg);
 612       break;
 613
 614     case OPT_fdollars_in_identifiers:
 615       cpp_opts->dollars_in_ident = value;
 616       break;
 617
 618     case OPT_ffreestanding:
 619       value = !value;
 620       /* Fall through....  */
 621     case OPT_fhosted:
 622       flag_hosted = value;
 623       flag_no_builtin = !value;
 624       /* warn_main will be 2 if set by -Wall, 1 if set by -Wmain */
 625       if (!value && warn_main == 2)
 626         warn_main = 0;
 627       break;
 628
 629     case OPT_fshort_double:
 630       flag_short_double = value;
 631       break;
 632
 633     case OPT_fshort_enums:
 634       flag_short_enums = value;
 635       break;
 636
 637     case OPT_fshort_wchar:
 638       flag_short_wchar = value;
 639       break;
 640
 641     case OPT_fsigned_bitfields:
 642       flag_signed_bitfields = value;
 643       break;
 644
 645     case OPT_fsigned_char:
 646       flag_signed_char = value;
 647       break;
 648
 649     case OPT_funsigned_bitfields:
 650       flag_signed_bitfields = !value;
 651       break;
 652
 653     case OPT_funsigned_char:
 654       flag_signed_char = !value;
 655       break;
 656
 657     case OPT_fcheck_new:
 658       flag_check_new = value;
 659       break;
 660
 661     case OPT_fconserve_space:
 662       flag_conserve_space = value;
 663       break;
 664
 665     case OPT_fconstant_string_class_:
 666       constant_string_class_name = arg;
 667       break;
 668
 669     case OPT_fdefault_inline:
 670       flag_default_inline = value;
 671       break;
 672
 673     case OPT_felide_constructors:
 674       flag_elide_constructors = value;
 675       break;
 676
 677     case OPT_fenforce_eh_specs:
 678       flag_enforce_eh_specs = value;
 679       break;
 680
 681     case OPT_fextended_identifiers:
 682       cpp_opts->extended_identifiers = value;
 683       break;
 684
 685     case OPT_ffor_scope:
 686       flag_new_for_scope = value;
 687       break;
 688
 689     case OPT_fgnu_keywords:
 690       flag_no_gnu_keywords = !value;
 691       break;
 692
 693     case OPT_fgnu_runtime:
 694       flag_next_runtime = !value;
 695       break;
 696
 697     case OPT_fhandle_exceptions:
 698       warning (0, "-fhandle-exceptions has been renamed -fexceptions (and is now on by default)");
 699       flag_exceptions = value;
 700       break;
 701
 702     case OPT_fimplement_inlines:
 703       flag_implement_inlines = value;
 704       break;
 705
 706     case OPT_fimplicit_inline_templates:
 707       flag_implicit_inline_templates = value;
 708       break;
 709
 710     case OPT_fimplicit_templates:
 711       flag_implicit_templates = value;
 712       break;
 713
 714     case OPT_flax_vector_conversions:
 715       flag_lax_vector_conversions = value;
 716       break;
 717
 718     case OPT_fms_extensions:
 719       flag_ms_extensions = value;
 720       break;
 721
 722     case OPT_fnext_runtime:
 723       flag_next_runtime = value;
 724       break;
 725
 726     case OPT_fnil_receivers:
 727       flag_nil_receivers = value;
 728       break;
 729
 730     case OPT_fnonansi_builtins:
 731       flag_no_nonansi_builtin = !value;
 732       break;
 733
 734     case OPT_foperator_names:
 735       cpp_opts->operator_names = value;
 736       break;
 737
 738     case OPT_foptional_diags:
 739       flag_optional_diags = value;
 740       break;
 741
 742     case OPT_fpch_deps:
 743       cpp_opts->restore_pch_deps = value;
 744       break;
 745
 746     case OPT_fpch_preprocess:
 747       flag_pch_preprocess = value;
 748       break;
 749
 750     case OPT_fpermissive:
 751       flag_permissive = value;
 752       break;
 753
 754     case OPT_fpreprocessed:
 755       cpp_opts->preprocessed = value;
 756       break;
 757
 758     case OPT_freplace_objc_classes:
 759       flag_replace_objc_classes = value;
 760       break;
 761
 762     case OPT_frepo:
 763       flag_use_repository = value;
 764       if (value)
 765         flag_implicit_templates = 0;
 766       break;
 767
 768     case OPT_frtti:
 769       flag_rtti = value;
 770       break;
 771
 772     case OPT_fshow_column:
 773       cpp_opts->show_column = value;
 774       break;
 775
 776     case OPT_fstats:
 777       flag_detailed_statistics = value;
 778       break;
 779
 780     case OPT_ftabstop_:
 781       /* It is documented that we silently ignore silly values.  */
 782       if (value >= 1 && value <= 100)
 783         cpp_opts->tabstop = value;
 784       break;
 785
 786     case OPT_fexec_charset_:
 787       cpp_opts->narrow_charset = arg;
 788       break;
 789
 790     case OPT_fwide_exec_charset_:
 791       cpp_opts->wide_charset = arg;
 792       break;
 793
 794     case OPT_finput_charset_:
 795       cpp_opts->input_charset = arg;
 796       break;
 797
 798     case OPT_ftemplate_depth_:
 799       max_tinst_depth = value;
 800       break;
 801
 802     case OPT_fuse_cxa_atexit:
 803       flag_use_cxa_atexit = value;
 804       break;
 805
 806     case OPT_fuse_cxa_get_exception_ptr:
 807       flag_use_cxa_get_exception_ptr = value;
 808       break;
 809
 810     case OPT_fvisibility_inlines_hidden:
 811       visibility_options.inlines_hidden = value;
 812       break;
 813
 814     case OPT_fweak:
 815       flag_weak = value;
 816       break;
 817
 818     case OPT_fthreadsafe_statics:
 819       flag_threadsafe_statics = value;
 820       break;
 821
 822     case OPT_fzero_link:
 823       flag_zero_link = value;
 824       break;
 825
 826     case OPT_gen_decls:
 827       flag_gen_declaration = 1;
 828       break;
 829
 830     case OPT_idirafter:
 831       add_path (xstrdup (arg), AFTER, 0, true);
 832       break;
 833
 834     case OPT_imacros:
 835     case OPT_include:
 836       defer_opt (code, arg);
 837       break;
 838
 839     case OPT_imultilib:
 840       imultilib = arg;
 841       break;
 842
 843     case OPT_iprefix:
 844       iprefix = arg;
 845       break;
 846
 847     case OPT_iquote:
 848       add_path (xstrdup (arg), QUOTE, 0, true);
 849       break;
 850
 851     case OPT_isysroot:
 852       sysroot = arg;
 853       break;
 854
 855     case OPT_isystem:
 856       add_path (xstrdup (arg), SYSTEM, 0, true);
 857       break;
 858
 859     case OPT_iwithprefix:
 860       add_prefixed_path (arg, SYSTEM);
 861       break;
 862
 863     case OPT_iwithprefixbefore:
 864       add_prefixed_path (arg, BRACKET);
 865       break;
 866
 867     case OPT_lang_asm:
 868       cpp_set_lang (parse_in, CLK_ASM);
 869       cpp_opts->dollars_in_ident = false;
 870       break;
 871
 872     case OPT_lang_fortran:
 873       lang_fortran = true;
 874       break;
 875
 876     case OPT_lang_objc:
 877       cpp_opts->objc = 1;
 878       break;
 879
 880     case OPT_nostdinc:
 881       std_inc = false;
 882       break;
 883
 884     case OPT_nostdinc__:
 885       std_cxx_inc = false;
 886       break;
 887
 888     case OPT_o:
 889       if (!out_fname)
 890         out_fname = arg;
 891       else
 892         error ("output filename specified twice");
 893       break;
 894
 895       /* We need to handle the -pedantic switches here, rather than in
 896          c_common_post_options, so that a subsequent -Wno-endif-labels
 897          is not overridden.  */
 898     case OPT_pedantic_errors:
 899       cpp_opts->pedantic_errors = 1;
 900       /* Fall through.  */
 901     case OPT_pedantic:
 902       cpp_opts->pedantic = 1;
 903       cpp_opts->warn_endif_labels = 1;
 904       if (warn_pointer_sign == -1)
 905         warn_pointer_sign = 1;
 906       if (warn_overlength_strings == -1)
 907         warn_overlength_strings = 1;
 908       break;
 909
 910     case OPT_print_objc_runtime_info:
 911       print_struct_values = 1;
 912       break;
 913
 914     case OPT_print_pch_checksum:
 915       c_common_print_pch_checksum (stdout);
 916       exit_after_options = true;
 917       break;
 918
 919     case OPT_remap:
 920       cpp_opts->remap = 1;
 921       break;
 922
 923     case OPT_std_c__98:
 924     case OPT_std_gnu__98:
 925       if (!preprocessing_asm_p)
 926         set_std_cxx98 (code == OPT_std_c__98 /* ISO */);
 927       break;
 928
 929     case OPT_std_c__0x:
 930     case OPT_std_gnu__0x:
 931       if (!preprocessing_asm_p)
 932         set_std_cxx0x (code == OPT_std_c__0x /* ISO */);
 933       break;
 934
 935     case OPT_std_c89:
 936     case OPT_std_iso9899_1990:
 937     case OPT_std_iso9899_199409:
 938       if (!preprocessing_asm_p)
 939         set_std_c89 (code == OPT_std_iso9899_199409 /* c94 */, true /* ISO */);
 940       break;
 941
 942     case OPT_std_gnu89:
 943       if (!preprocessing_asm_p)
 944         set_std_c89 (false /* c94 */, false /* ISO */);
 945       break;
 946
 947     case OPT_std_c99:
 948     case OPT_std_c9x:
 949     case OPT_std_iso9899_1999:
 950     case OPT_std_iso9899_199x:
 951       if (!preprocessing_asm_p)
 952         set_std_c99 (true /* ISO */);
 953       break;
 954
 955     case OPT_std_gnu99:
 956     case OPT_std_gnu9x:
 957       if (!preprocessing_asm_p)
 958         set_std_c99 (false /* ISO */);
 959       break;
 960
 961     case OPT_trigraphs:
 962       cpp_opts->trigraphs = 1;
 963       break;
 964
 965     case OPT_traditional_cpp:
 966       cpp_opts->traditional = 1;
 967       break;
 968
 969     case OPT_undef:
 970       flag_undef = 1;
 971       break;
 972
 973     case OPT_w:
 974       cpp_opts->inhibit_warnings = 1;
 975       break;
 976
 977     case OPT_v:
 978       verbose = true;
 979       break;
 980     }
 981
 982   return result;
 983 }
 984
 985 /* Post-switch processing.  */
 986 bool
 987 c_common_post_options (const char **pfilename)
 988 {
 989   struct cpp_callbacks *cb;
 990
 991   /* Canonicalize the input and output filenames.  */
 992   if (in_fnames == NULL)
 993     {
 994       in_fnames = XNEWVEC (const char *, 1);
 995       in_fnames[0] = "";
 996     }
 997   else if (strcmp (in_fnames[0], "-") == 0)
 998     in_fnames[0] = "";
 999
1000   if (out_fname == NULL || !strcmp (out_fname, "-"))
1001     out_fname = "";
1002
1003   if (cpp_opts->deps.style == DEPS_NONE)
1004     check_deps_environment_vars ();
1005
1006   handle_deferred_opts ();
1007
1008   sanitize_cpp_opts ();
1009
1010   register_include_chains (parse_in, sysroot, iprefix, imultilib,
1011                            std_inc, std_cxx_inc && c_dialect_cxx (), verbose);
1012
1013 #ifdef C_COMMON_OVERRIDE_OPTIONS
1014   /* Some machines may reject certain combinations of C
1015      language-specific options.  */
1016   C_COMMON_OVERRIDE_OPTIONS;
1017 #endif
1018
1019   flag_inline_trees = 1;
1020
1021   /* Use tree inlining.  */
1022   if (!flag_no_inline)
1023     flag_no_inline = 1;
1024   if (flag_inline_functions)
1025     flag_inline_trees = 2;
1026
1027   /* If we are given more than one input file, we must use
1028      unit-at-a-time mode.  */
1029   if (num_in_fnames > 1)
1030     flag_unit_at_a_time = 1;
1031
1032   /* Default to ObjC sjlj exception handling if NeXT runtime.  */
1033   if (flag_objc_sjlj_exceptions < 0)
1034     flag_objc_sjlj_exceptions = flag_next_runtime;
1035   if (flag_objc_exceptions && !flag_objc_sjlj_exceptions)
1036     flag_exceptions = 1;
1037
1038   /* -Wextra implies -Wclobbered, -Wempty-body, -Wsign-compare,
1039      -Wmissing-field-initializers, -Wmissing-parameter-type
1040      -Wold-style-declaration, and -Woverride-init,
1041      but not if explicitly overridden.  */
1042   if (warn_clobbered == -1)
1043     warn_clobbered = extra_warnings;
1044   if (warn_empty_body == -1)
1045     warn_empty_body = extra_warnings;
1046   if (warn_sign_compare == -1)
1047     warn_sign_compare = extra_warnings;
1048   if (warn_missing_field_initializers == -1)
1049     warn_missing_field_initializers = extra_warnings;
1050   if (warn_missing_parameter_type == -1)
1051     warn_missing_parameter_type = extra_warnings;
1052   if (warn_old_style_declaration == -1)
1053     warn_old_style_declaration = extra_warnings;
1054   if (warn_override_init == -1)
1055     warn_override_init = extra_warnings;
1056
1057   /* -Wpointer_sign is disabled by default, but it is enabled if any
1058      of -Wall or -pedantic are given.  */
1059   if (warn_pointer_sign == -1)
1060     warn_pointer_sign = 0;
1061
1062   /* -Woverlength-strings is off by default, but is enabled by -pedantic.
1063      It is never enabled in C++, as the minimum limit is not normative
1064      in that standard.  */
1065   if (warn_overlength_strings == -1 || c_dialect_cxx ())
1066     warn_overlength_strings = 0;
1067
1068   /* Special format checking options don't work without -Wformat; warn if
1069      they are used.  */
1070   if (!warn_format)
1071     {
1072       warning (OPT_Wformat_y2k,
1073                "-Wformat-y2k ignored without -Wformat");
1074       warning (OPT_Wformat_extra_args,
1075                "-Wformat-extra-args ignored without -Wformat");
1076       warning (OPT_Wformat_zero_length,
1077                "-Wformat-zero-length ignored without -Wformat");
1078       warning (OPT_Wformat_nonliteral,
1079                "-Wformat-nonliteral ignored without -Wformat");
1080       warning (OPT_Wformat_security,
1081                "-Wformat-security ignored without -Wformat");
1082     }
1083
1084   /* -Wimplicit-function-declaration is enabled by default for C99.  */
1085   if (warn_implicit_function_declaration == -1)
1086     warn_implicit_function_declaration = flag_isoc99;
1087
1088   /* C99 requires special handling of complex multiplication and division;
1089      -ffast-math and -fcx-limited-range are handled in process_options.  */
1090   if (flag_isoc99)
1091     flag_complex_method = 2;
1092
1093   /* If we're allowing C++0x constructs, don't warn about C++0x
1094      compatibility problems.  */
1095   if (flag_cpp0x)
1096     warn_cxx0x_compat = 0;
1097
1098   if (flag_preprocess_only)
1099     {
1100       /* Open the output now.  We must do so even if flag_no_output is
1101          on, because there may be other output than from the actual
1102          preprocessing (e.g. from -dM).  */
1103       if (out_fname[0] == '\0')
1104         out_stream = stdout;
1105       else
1106         out_stream = fopen (out_fname, "w");
1107
1108       if (out_stream == NULL)
1109         {
1110           fatal_error ("opening output file %s: %m", out_fname);
1111           return false;
1112         }
1113
1114       if (num_in_fnames > 1)
1115         error ("too many filenames given.  Type %s --help for usage",
1116                progname);
1117
1118       init_pp_output (out_stream);
1119     }
1120   else
1121     {
1122       init_c_lex ();
1123
1124       /* Yuk.  WTF is this?  I do know ObjC relies on it somewhere.  */
1125       input_location = UNKNOWN_LOCATION;
1126     }
1127
1128   cb = cpp_get_callbacks (parse_in);
1129   cb->file_change = cb_file_change;
1130   cb->dir_change = cb_dir_change;
1131   cpp_post_options (parse_in);
1132
1133   input_location = UNKNOWN_LOCATION;
1134
1135   /* If an error has occurred in cpplib, note it so we fail
1136      immediately.  */
1137   errorcount += cpp_errors (parse_in);
1138
1139   *pfilename = this_input_filename
1140     = cpp_read_main_file (parse_in, in_fnames[0]);
1141   /* Don't do any compilation or preprocessing if there is no input file.  */
1142   if (this_input_filename == NULL)
1143     {
1144       errorcount++;
1145       return false;
1146     }
1147
1148   if (flag_working_directory
1149       && flag_preprocess_only && !flag_no_line_commands)
1150     pp_dir_change (parse_in, get_src_pwd ());
1151
1152   return flag_preprocess_only;
1153 }
1154
1155 /* Front end initialization common to C, ObjC and C++.  */
1156 bool
1157 c_common_init (void)
1158 {
1159   /* Set up preprocessor arithmetic.  Must be done after call to
1160      c_common_nodes_and_builtins for type nodes to be good.  */
1161   cpp_opts->precision = TYPE_PRECISION (intmax_type_node);
1162   cpp_opts->char_precision = TYPE_PRECISION (char_type_node);
1163   cpp_opts->int_precision = TYPE_PRECISION (integer_type_node);
1164   cpp_opts->wchar_precision = TYPE_PRECISION (wchar_type_node);
1165   cpp_opts->unsigned_wchar = TYPE_UNSIGNED (wchar_type_node);
1166   cpp_opts->bytes_big_endian = BYTES_BIG_ENDIAN;
1167
1168   /* This can't happen until after wchar_precision and bytes_big_endian
1169      are known.  */
1170   cpp_init_iconv (parse_in);
1171
1172   if (version_flag)
1173     c_common_print_pch_checksum (stderr);
1174
1175   if (flag_preprocess_only)
1176     {
1177       finish_options ();
1178       preprocess_file (parse_in);
1179       return false;
1180     }
1181
1182   /* Has to wait until now so that cpplib has its hash table.  */
1183   init_pragma ();
1184
1185   return true;
1186 }
1187
1188 /* Initialize the integrated preprocessor after debug output has been
1189    initialized; loop over each input file.  */
1190 void
1191 c_common_parse_file (int set_yydebug)
1192 {
1193   unsigned int i;
1194
1195   if (set_yydebug)
1196     switch (c_language)
1197       {
1198       case clk_c:
1199         warning(0, "The C parser does not support -dy, option ignored");
1200         break;
1201       case clk_objc:
1202         warning(0,
1203                 "The Objective-C parser does not support -dy, option ignored");
1204         break;
1205       case clk_cxx:
1206         warning(0, "The C++ parser does not support -dy, option ignored");
1207         break;
1208       case clk_objcxx:
1209         warning(0,
1210             "The Objective-C++ parser does not support -dy, option ignored");
1211         break;
1212       default:
1213         gcc_unreachable ();
1214     }
1215
1216   i = 0;
1217   for (;;)
1218     {
1219       /* Start the main input file, if the debug writer wants it. */
1220       if (debug_hooks->start_end_main_source_file)
1221         (*debug_hooks->start_source_file) (0, this_input_filename);
1222       finish_options ();
1223       pch_init ();
1224       push_file_scope ();
1225       c_parse_file ();
1226       finish_file ();
1227       pop_file_scope ();
1228       /* And end the main input file, if the debug writer wants it  */
1229       if (debug_hooks->start_end_main_source_file)
1230         (*debug_hooks->end_source_file) (0);
1231       if (++i >= num_in_fnames)
1232         break;
1233       cpp_undef_all (parse_in);
1234       this_input_filename
1235         = cpp_read_main_file (parse_in, in_fnames[i]);
1236       /* If an input file is missing, abandon further compilation.
1237          cpplib has issued a diagnostic.  */
1238       if (!this_input_filename)
1239         break;
1240     }
1241 }
1242
1243 /* Common finish hook for the C, ObjC and C++ front ends.  */
1244 void
1245 c_common_finish (void)
1246 {
1247   FILE *deps_stream = NULL;
1248
1249   if (cpp_opts->deps.style != DEPS_NONE)
1250     {
1251       /* If -M or -MM was seen without -MF, default output to the
1252          output stream.  */
1253       if (!deps_file)
1254         deps_stream = out_stream;
1255       else
1256         {
1257           deps_stream = fopen (deps_file, deps_append ? "a": "w");
1258           if (!deps_stream)
1259             fatal_error ("opening dependency file %s: %m", deps_file);
1260         }
1261     }
1262
1263   /* For performance, avoid tearing down cpplib's internal structures
1264      with cpp_destroy ().  */
1265   errorcount += cpp_finish (parse_in, deps_stream);
1266
1267   if (deps_stream && deps_stream != out_stream
1268       && (ferror (deps_stream) || fclose (deps_stream)))
1269     fatal_error ("closing dependency file %s: %m", deps_file);
1270
1271   if (out_stream && (ferror (out_stream) || fclose (out_stream)))
1272     fatal_error ("when writing output to %s: %m", out_fname);
1273 }
1274
1275 /* Either of two environment variables can specify output of
1276    dependencies.  Their value is either "OUTPUT_FILE" or "OUTPUT_FILE
1277    DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to
1278    and DEPS_TARGET is the target to mention in the deps.  They also
1279    result in dependency information being appended to the output file
1280    rather than overwriting it, and like Sun's compiler
1281    SUNPRO_DEPENDENCIES suppresses the dependency on the main file.  */
1282 static void
1283 check_deps_environment_vars (void)
1284 {
1285   char *spec;
1286
1287   GET_ENVIRONMENT (spec, "DEPENDENCIES_OUTPUT");
1288   if (spec)
1289     cpp_opts->deps.style = DEPS_USER;
1290   else
1291     {
1292       GET_ENVIRONMENT (spec, "SUNPRO_DEPENDENCIES");
1293       if (spec)
1294         {
1295           cpp_opts->deps.style = DEPS_SYSTEM;
1296           cpp_opts->deps.ignore_main_file = true;
1297         }
1298     }
1299
1300   if (spec)
1301     {
1302       /* Find the space before the DEPS_TARGET, if there is one.  */
1303       char *s = strchr (spec, ' ');
1304       if (s)
1305         {
1306           /* Let the caller perform MAKE quoting.  */
1307           defer_opt (OPT_MT, s + 1);
1308           *s = '\0';
1309         }
1310
1311       /* Command line -MF overrides environment variables and default.  */
1312       if (!deps_file)
1313         deps_file = spec;
1314
1315       deps_append = 1;
1316       deps_seen = true;
1317     }
1318 }
1319
1320 /* Handle deferred command line switches.  */
1321 static void
1322 handle_deferred_opts (void)
1323 {
1324   size_t i;
1325   struct deps *deps;
1326
1327   /* Avoid allocating the deps buffer if we don't need it.
1328      (This flag may be true without there having been -MT or -MQ
1329      options, but we'll still need the deps buffer.)  */
1330   if (!deps_seen)
1331     return;
1332
1333   deps = cpp_get_deps (parse_in);
1334
1335   for (i = 0; i < deferred_count; i++)
1336     {
1337       struct deferred_opt *opt = &deferred_opts[i];
1338
1339       if (opt->code == OPT_MT || opt->code == OPT_MQ)
1340         deps_add_target (deps, opt->arg, opt->code == OPT_MQ);
1341     }
1342 }
1343
1344 /* These settings are appropriate for GCC, but not necessarily so for
1345    cpplib as a library.  */
1346 static void
1347 sanitize_cpp_opts (void)
1348 {
1349   /* If we don't know what style of dependencies to output, complain
1350      if any other dependency switches have been given.  */
1351   if (deps_seen && cpp_opts->deps.style == DEPS_NONE)
1352     error ("to generate dependencies you must specify either -M or -MM");
1353
1354   /* -dM and dependencies suppress normal output; do it here so that
1355      the last -d[MDN] switch overrides earlier ones.  */
1356   if (flag_dump_macros == 'M')
1357     flag_no_output = 1;
1358
1359   /* Disable -dD, -dN and -dI if normal output is suppressed.  Allow
1360      -dM since at least glibc relies on -M -dM to work.  */
1361   /* Also, flag_no_output implies flag_no_line_commands, always.  */
1362   if (flag_no_output)
1363     {
1364       if (flag_dump_macros != 'M')
1365         flag_dump_macros = 0;
1366       flag_dump_includes = 0;
1367       flag_no_line_commands = 1;
1368     }
1369
1370   cpp_opts->unsigned_char = !flag_signed_char;
1371   cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS;
1372
1373   /* We want -Wno-long-long to override -pedantic -std=non-c99
1374      and/or -Wtraditional, whatever the ordering.  */
1375   cpp_opts->warn_long_long
1376     = warn_long_long && ((!flag_isoc99 && pedantic) || warn_traditional);
1377
1378   /* Similarly with -Wno-variadic-macros.  No check for c99 here, since
1379      this also turns off warnings about GCCs extension.  */
1380   cpp_opts->warn_variadic_macros
1381     = warn_variadic_macros && (pedantic || warn_traditional);
1382
1383   /* If we're generating preprocessor output, emit current directory
1384      if explicitly requested or if debugging information is enabled.
1385      ??? Maybe we should only do it for debugging formats that
1386      actually output the current directory?  */
1387   if (flag_working_directory == -1)
1388     flag_working_directory = (debug_info_level != DINFO_LEVEL_NONE);
1389 }
1390
1391 /* Add include path with a prefix at the front of its name.  */
1392 static void
1393 add_prefixed_path (const char *suffix, size_t chain)
1394 {
1395   char *path;
1396   const char *prefix;
1397   size_t prefix_len, suffix_len;
1398
1399   suffix_len = strlen (suffix);
1400   prefix     = iprefix ? iprefix : cpp_GCC_INCLUDE_DIR;
1401   prefix_len = iprefix ? strlen (iprefix) : cpp_GCC_INCLUDE_DIR_len;
1402
1403   path = (char *) xmalloc (prefix_len + suffix_len + 1);
1404   memcpy (path, prefix, prefix_len);
1405   memcpy (path + prefix_len, suffix, suffix_len);
1406   path[prefix_len + suffix_len] = '\0';
1407
1408   add_path (path, chain, 0, false);
1409 }
1410
1411 /* Handle -D, -U, -A, -imacros, and the first -include.  */
1412 static void
1413 finish_options (void)
1414 {
1415   if (!cpp_opts->preprocessed)
1416     {
1417       size_t i;
1418
1419       cb_file_change (parse_in,
1420                       linemap_add (&line_table, LC_RENAME, 0,
1421                                    _("<built-in>"), 0));
1422
1423       cpp_init_builtins (parse_in, flag_hosted);
1424       c_cpp_builtins (parse_in);
1425
1426       /* We're about to send user input to cpplib, so make it warn for
1427          things that we previously (when we sent it internal definitions)
1428          told it to not warn.
1429
1430          C99 permits implementation-defined characters in identifiers.
1431          The documented meaning of -std= is to turn off extensions that
1432          conflict with the specified standard, and since a strictly
1433          conforming program cannot contain a '$', we do not condition
1434          their acceptance on the -std= setting.  */
1435       cpp_opts->warn_dollars = (cpp_opts->pedantic && !cpp_opts->c99);
1436
1437       cb_file_change (parse_in,
1438                       linemap_add (&line_table, LC_RENAME, 0,
1439                                    _("<command-line>"), 0));
1440
1441       for (i = 0; i < deferred_count; i++)
1442         {
1443           struct deferred_opt *opt = &deferred_opts[i];
1444
1445           if (opt->code == OPT_D)
1446             cpp_define (parse_in, opt->arg);
1447           else if (opt->code == OPT_U)
1448             cpp_undef (parse_in, opt->arg);
1449           else if (opt->code == OPT_A)
1450             {
1451               if (opt->arg[0] == '-')
1452                 cpp_unassert (parse_in, opt->arg + 1);
1453               else
1454                 cpp_assert (parse_in, opt->arg);
1455             }
1456         }
1457
1458       /* Handle -imacros after -D and -U.  */
1459       for (i = 0; i < deferred_count; i++)
1460         {
1461           struct deferred_opt *opt = &deferred_opts[i];
1462
1463           if (opt->code == OPT_imacros
1464               && cpp_push_include (parse_in, opt->arg))
1465             {
1466               /* Disable push_command_line_include callback for now.  */
1467               include_cursor = deferred_count + 1;
1468               cpp_scan_nooutput (parse_in);
1469             }
1470         }
1471     }
1472
1473   include_cursor = 0;
1474   push_command_line_include ();
1475 }
1476
1477 /* Give CPP the next file given by -include, if any.  */
1478 static void
1479 push_command_line_include (void)
1480 {
1481   while (include_cursor < deferred_count)
1482     {
1483       struct deferred_opt *opt = &deferred_opts[include_cursor++];
1484
1485       if (!cpp_opts->preprocessed && opt->code == OPT_include
1486           && cpp_push_include (parse_in, opt->arg))
1487         return;
1488     }
1489
1490   if (include_cursor == deferred_count)
1491     {
1492       include_cursor++;
1493       /* -Wunused-macros should only warn about macros defined hereafter.  */
1494       cpp_opts->warn_unused_macros = warn_unused_macros;
1495       /* Restore the line map from <command line>.  */
1496       if (!cpp_opts->preprocessed)
1497         cpp_change_file (parse_in, LC_RENAME, this_input_filename);
1498
1499       /* Set this here so the client can change the option if it wishes,
1500          and after stacking the main file so we don't trace the main file.  */
1501       line_table.trace_includes = cpp_opts->print_include_names;
1502     }
1503 }
1504
1505 /* File change callback.  Has to handle -include files.  */
1506 static void
1507 cb_file_change (cpp_reader * ARG_UNUSED (pfile),
1508                 const struct line_map *new_map)
1509 {
1510   if (flag_preprocess_only)
1511     pp_file_change (new_map);
1512   else
1513     fe_file_change (new_map);
1514
1515   if (new_map == 0 || (new_map->reason == LC_LEAVE && MAIN_FILE_P (new_map)))
1516     push_command_line_include ();
1517 }
1518
1519 void
1520 cb_dir_change (cpp_reader * ARG_UNUSED (pfile), const char *dir)
1521 {
1522   if (!set_src_pwd (dir))
1523     warning (0, "too late for # directive to set debug directory");
1524 }
1525
1526 /* Set the C 89 standard (with 1994 amendments if C94, without GNU
1527    extensions if ISO).  There is no concept of gnu94.  */
1528 static void
1529 set_std_c89 (int c94, int iso)
1530 {
1531   cpp_set_lang (parse_in, c94 ? CLK_STDC94: iso ? CLK_STDC89: CLK_GNUC89);
1532   flag_iso = iso;
1533   flag_no_asm = iso;
1534   flag_no_gnu_keywords = iso;
1535   flag_no_nonansi_builtin = iso;
1536   flag_isoc94 = c94;
1537   flag_isoc99 = 0;
1538 }
1539
1540 /* Set the C 99 standard (without GNU extensions if ISO).  */
1541 static void
1542 set_std_c99 (int iso)
1543 {
1544   cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99);
1545   flag_no_asm = iso;
1546   flag_no_nonansi_builtin = iso;
1547   flag_iso = iso;
1548   flag_isoc99 = 1;
1549   flag_isoc94 = 1;
1550 }
1551
1552 /* Set the C++ 98 standard (without GNU extensions if ISO).  */
1553 static void
1554 set_std_cxx98 (int iso)
1555 {
1556   cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX);
1557   flag_no_gnu_keywords = iso;
1558   flag_no_nonansi_builtin = iso;
1559   flag_iso = iso;
1560 }
1561
1562 /* Set the C++ 0x working draft "standard" (without GNU extensions if ISO).  */
1563 static void
1564 set_std_cxx0x (int iso)
1565 {
1566   cpp_set_lang (parse_in, iso ? CLK_CXX0X: CLK_GNUCXX0X);
1567   flag_no_gnu_keywords = iso;
1568   flag_no_nonansi_builtin = iso;
1569   flag_iso = iso;
1570   flag_cpp0x = 1;
1571 }
1572
1573 /* Handle setting implicit to ON.  */
1574 static void
1575 set_Wimplicit (int on)
1576 {
1577   warn_implicit = on;
1578   warn_implicit_int = on;
1579   warn_implicit_function_declaration = on;
1580 }
1581
1582 /* Args to -d specify what to dump.  Silently ignore
1583    unrecognized options; they may be aimed at toplev.c.  */
1584 static void
1585 handle_OPT_d (const char *arg)
1586 {
1587   char c;
1588
1589   while ((c = *arg++) != '\0')
1590     switch (c)
1591       {
1592       case 'M':                 /* Dump macros only.  */
1593       case 'N':                 /* Dump names.  */
1594       case 'D':                 /* Dump definitions.  */
1595         flag_dump_macros = c;
1596         break;
1597
1598       case 'I':
1599         flag_dump_includes = 1;
1600         break;
1601       }
1602 }