gcc/c-opts.c

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