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