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