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