gcc/c-opts.c

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