gcc/c-opts.c

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