gcc/c-family/c-opts.c

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