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