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