gcc/c-opts.c

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