gcc/c-family/c-opts.c

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