gcc/c-opts.c

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