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