contrib/gcc-4.4/gcc/c-opts.c

   1 /* C/ObjC/C++ command line option handling.
   2    Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
   3    Free Software Foundation, Inc.
   4    Contributed by Neil Booth.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "tree.h"
  27 #include "c-common.h"
  28 #include "c-pragma.h"
  29 #include "flags.h"
  30 #include "toplev.h"
  31 #include "langhooks.h"
  32 #include "tree-inline.h"
  33 #include "diagnostic.h"
  34 #include "intl.h"
  35 #include "cppdefault.h"
  36 #include "incpath.h"
  37 #include "debug.h"              /* For debug_hooks.  */
  38 #include "opts.h"
  39 #include "options.h"
  40 #include "mkdeps.h"
  41 #include "target.h"
  42 #include "tm_p.h"
  43
  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 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 (input_location, "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       warn_unused = 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         {
 408           /* We set this to 2 here, but 1 in -Wmain, so -ffreestanding
 409              can turn it off only if it's not explicit.  */
 410           if (warn_main == -1)
 411             warn_main = (value ? 2 : 0);
 412         }
 413       else
 414         {
 415           /* C++-specific warnings.  */
 416           warn_sign_compare = value;
 417           warn_reorder = value;
 418           warn_cxx0x_compat = value;
 419         }
 420
 421       cpp_opts->warn_trigraphs = value;
 422       cpp_opts->warn_comments = value;
 423       cpp_opts->warn_num_sign_change = value;
 424
 425       if (warn_pointer_sign == -1)
 426         warn_pointer_sign = value;
 427       break;
 428
 429     case OPT_Wbuiltin_macro_redefined:
 430       cpp_opts->warn_builtin_macro_redefined = value;
 431       break;
 432
 433     case OPT_Wcomment:
 434     case OPT_Wcomments:
 435       cpp_opts->warn_comments = value;
 436       break;
 437
 438     case OPT_Wdeprecated:
 439       cpp_opts->warn_deprecated = value;
 440       break;
 441
 442     case OPT_Wendif_labels:
 443       cpp_opts->warn_endif_labels = value;
 444       break;
 445
 446     case OPT_Werror:
 447       cpp_opts->warnings_are_errors = value;
 448       global_dc->warning_as_error_requested = value;
 449       break;
 450
 451     case OPT_Werror_implicit_function_declaration:
 452       /* For backward compatibility, this is the same as
 453          -Werror=implicit-function-declaration.  */
 454       enable_warning_as_error ("implicit-function-declaration", value, CL_C | CL_ObjC);
 455       break;
 456
 457     case OPT_Wformat:
 458       set_Wformat (value);
 459       break;
 460
 461     case OPT_Wformat_:
 462       set_Wformat (atoi (arg));
 463       break;
 464
 465     case OPT_Wimplicit:
 466       set_Wimplicit (value);
 467       break;
 468
 469     case OPT_Wimport:
 470       /* Silently ignore for now.  */
 471       break;
 472
 473     case OPT_Winvalid_pch:
 474       cpp_opts->warn_invalid_pch = value;
 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       break;
 619
 620     case OPT_fshort_double:
 621       flag_short_double = value;
 622       break;
 623
 624     case OPT_fshort_enums:
 625       flag_short_enums = value;
 626       break;
 627
 628     case OPT_fshort_wchar:
 629       flag_short_wchar = value;
 630       break;
 631
 632     case OPT_fsigned_bitfields:
 633       flag_signed_bitfields = value;
 634       break;
 635
 636     case OPT_fsigned_char:
 637       flag_signed_char = value;
 638       break;
 639
 640     case OPT_funsigned_bitfields:
 641       flag_signed_bitfields = !value;
 642       break;
 643
 644     case OPT_funsigned_char:
 645       flag_signed_char = !value;
 646       break;
 647
 648     case OPT_fcheck_new:
 649       flag_check_new = value;
 650       break;
 651
 652     case OPT_fconserve_space:
 653       flag_conserve_space = value;
 654       break;
 655
 656     case OPT_fconstant_string_class_:
 657       constant_string_class_name = arg;
 658       break;
 659
 660     case OPT_fdefault_inline:
 661       flag_default_inline = value;
 662       break;
 663
 664     case OPT_felide_constructors:
 665       flag_elide_constructors = value;
 666       break;
 667
 668     case OPT_fenforce_eh_specs:
 669       flag_enforce_eh_specs = value;
 670       break;
 671
 672     case OPT_fextended_identifiers:
 673       cpp_opts->extended_identifiers = value;
 674       break;
 675
 676     case OPT_ffor_scope:
 677       flag_new_for_scope = value;
 678       break;
 679
 680     case OPT_fgnu_keywords:
 681       flag_no_gnu_keywords = !value;
 682       break;
 683
 684     case OPT_fgnu_runtime:
 685       flag_next_runtime = !value;
 686       break;
 687
 688     case OPT_fhandle_exceptions:
 689       warning (0, "-fhandle-exceptions has been renamed -fexceptions (and is now on by default)");
 690       flag_exceptions = value;
 691       break;
 692
 693     case OPT_fimplement_inlines:
 694       flag_implement_inlines = value;
 695       break;
 696
 697     case OPT_fimplicit_inline_templates:
 698       flag_implicit_inline_templates = value;
 699       break;
 700
 701     case OPT_fimplicit_templates:
 702       flag_implicit_templates = value;
 703       break;
 704
 705     case OPT_flax_vector_conversions:
 706       flag_lax_vector_conversions = value;
 707       break;
 708
 709     case OPT_fms_extensions:
 710       flag_ms_extensions = value;
 711       break;
 712
 713     case OPT_fnext_runtime:
 714       flag_next_runtime = value;
 715       break;
 716
 717     case OPT_fnil_receivers:
 718       flag_nil_receivers = value;
 719       break;
 720
 721     case OPT_fnonansi_builtins:
 722       flag_no_nonansi_builtin = !value;
 723       break;
 724
 725     case OPT_foperator_names:
 726       cpp_opts->operator_names = value;
 727       break;
 728
 729     case OPT_foptional_diags:
 730       flag_optional_diags = value;
 731       break;
 732
 733     case OPT_fpch_deps:
 734       cpp_opts->restore_pch_deps = value;
 735       break;
 736
 737     case OPT_fpch_preprocess:
 738       flag_pch_preprocess = value;
 739       break;
 740
 741     case OPT_fpermissive:
 742       flag_permissive = value;
 743       break;
 744
 745     case OPT_fpreprocessed:
 746       cpp_opts->preprocessed = value;
 747       break;
 748
 749     case OPT_freplace_objc_classes:
 750       flag_replace_objc_classes = value;
 751       break;
 752
 753     case OPT_frepo:
 754       flag_use_repository = value;
 755       if (value)
 756         flag_implicit_templates = 0;
 757       break;
 758
 759     case OPT_frtti:
 760       flag_rtti = value;
 761       break;
 762
 763     case OPT_fshow_column:
 764       cpp_opts->show_column = value;
 765       break;
 766
 767     case OPT_fstats:
 768       flag_detailed_statistics = value;
 769       break;
 770
 771     case OPT_ftabstop_:
 772       /* It is documented that we silently ignore silly values.  */
 773       if (value >= 1 && value <= 100)
 774         cpp_opts->tabstop = value;
 775       break;
 776
 777     case OPT_fexec_charset_:
 778       cpp_opts->narrow_charset = arg;
 779       break;
 780
 781     case OPT_fwide_exec_charset_:
 782       cpp_opts->wide_charset = arg;
 783       break;
 784
 785     case OPT_finput_charset_:
 786       cpp_opts->input_charset = arg;
 787       break;
 788
 789     case OPT_ftemplate_depth_:
 790       max_tinst_depth = value;
 791       break;
 792
 793     case OPT_fuse_cxa_atexit:
 794       flag_use_cxa_atexit = value;
 795       break;
 796
 797     case OPT_fuse_cxa_get_exception_ptr:
 798       flag_use_cxa_get_exception_ptr = value;
 799       break;
 800
 801     case OPT_fvisibility_inlines_hidden:
 802       visibility_options.inlines_hidden = value;
 803       break;
 804
 805     case OPT_fweak:
 806       flag_weak = value;
 807       break;
 808
 809     case OPT_fthreadsafe_statics:
 810       flag_threadsafe_statics = value;
 811       break;
 812
 813     case OPT_fzero_link:
 814       flag_zero_link = value;
 815       break;
 816
 817     case OPT_gen_decls:
 818       flag_gen_declaration = 1;
 819       break;
 820
 821     case OPT_femit_struct_debug_baseonly:
 822       set_struct_debug_option ("base");
 823       break;
 824
 825     case OPT_femit_struct_debug_reduced:
 826       set_struct_debug_option ("dir:ord:sys,dir:gen:any,ind:base");
 827       break;
 828
 829     case OPT_femit_struct_debug_detailed_:
 830       set_struct_debug_option (arg);
 831       break;
 832
 833     case OPT_idirafter:
 834       add_path (xstrdup (arg), AFTER, 0, true);
 835       break;
 836
 837     case OPT_imacros:
 838     case OPT_include:
 839       defer_opt (code, arg);
 840       break;
 841
 842     case OPT_imultilib:
 843       imultilib = arg;
 844       break;
 845
 846     case OPT_iprefix:
 847       iprefix = arg;
 848       break;
 849
 850     case OPT_iquote:
 851       add_path (xstrdup (arg), QUOTE, 0, true);
 852       break;
 853
 854     case OPT_isysroot:
 855       sysroot = arg;
 856       break;
 857
 858     case OPT_isystem:
 859       add_path (xstrdup (arg), SYSTEM, 0, true);
 860       break;
 861
 862     case OPT_iwithprefix:
 863       add_prefixed_path (arg, SYSTEM);
 864       break;
 865
 866     case OPT_iwithprefixbefore:
 867       add_prefixed_path (arg, BRACKET);
 868       break;
 869
 870     case OPT_lang_asm:
 871       cpp_set_lang (parse_in, CLK_ASM);
 872       cpp_opts->dollars_in_ident = false;
 873       break;
 874
 875     case OPT_lang_objc:
 876       cpp_opts->objc = 1;
 877       break;
 878
 879     case OPT_nostdinc:
 880       std_inc = false;
 881       break;
 882
 883     case OPT_nostdinc__:
 884       std_cxx_inc = false;
 885       break;
 886
 887     case OPT_o:
 888       if (!out_fname)
 889         out_fname = arg;
 890       else
 891         error ("output filename specified twice");
 892       break;
 893
 894       /* We need to handle the -pedantic switches here, rather than in
 895          c_common_post_options, so that a subsequent -Wno-endif-labels
 896          is not overridden.  */
 897     case OPT_pedantic_errors:
 898       cpp_opts->pedantic_errors = 1;
 899       /* Fall through.  */
 900     case OPT_pedantic:
 901       cpp_opts->pedantic = 1;
 902       cpp_opts->warn_endif_labels = 1;
 903       if (warn_pointer_sign == -1)
 904         warn_pointer_sign = 1;
 905       if (warn_overlength_strings == -1)
 906         warn_overlength_strings = 1;
 907       if (warn_main == -1)
 908         warn_main = 2;
 909       break;
 910
 911     case OPT_print_objc_runtime_info:
 912       print_struct_values = 1;
 913       break;
 914
 915     case OPT_print_pch_checksum:
 916       c_common_print_pch_checksum (stdout);
 917       exit_after_options = true;
 918       break;
 919
 920     case OPT_remap:
 921       cpp_opts->remap = 1;
 922       break;
 923
 924     case OPT_std_c__98:
 925     case OPT_std_gnu__98:
 926       if (!preprocessing_asm_p)
 927         set_std_cxx98 (code == OPT_std_c__98 /* ISO */);
 928       break;
 929
 930     case OPT_std_c__0x:
 931     case OPT_std_gnu__0x:
 932       if (!preprocessing_asm_p)
 933         set_std_cxx0x (code == OPT_std_c__0x /* ISO */);
 934       break;
 935
 936     case OPT_std_c89:
 937     case OPT_std_iso9899_1990:
 938     case OPT_std_iso9899_199409:
 939       if (!preprocessing_asm_p)
 940         set_std_c89 (code == OPT_std_iso9899_199409 /* c94 */, true /* ISO */);
 941       break;
 942
 943     case OPT_std_gnu89:
 944       if (!preprocessing_asm_p)
 945         set_std_c89 (false /* c94 */, false /* ISO */);
 946       break;
 947
 948     case OPT_std_c99:
 949     case OPT_std_c9x:
 950     case OPT_std_iso9899_1999:
 951     case OPT_std_iso9899_199x:
 952       if (!preprocessing_asm_p)
 953         set_std_c99 (true /* ISO */);
 954       break;
 955
 956     case OPT_std_gnu99:
 957     case OPT_std_gnu9x:
 958       if (!preprocessing_asm_p)
 959         set_std_c99 (false /* ISO */);
 960       break;
 961
 962     case OPT_trigraphs:
 963       cpp_opts->trigraphs = 1;
 964       break;
 965
 966     case OPT_traditional_cpp:
 967       cpp_opts->traditional = 1;
 968       break;
 969
 970     case OPT_undef:
 971       flag_undef = 1;
 972       break;
 973
 974     case OPT_w:
 975       cpp_opts->inhibit_warnings = 1;
 976       break;
 977
 978     case OPT_v:
 979       verbose = true;
 980       break;
 981
 982     case OPT_Wabi:
 983       warn_psabi = value;
 984       break;
 985     }
 986
 987   return result;
 988 }
 989
 990 /* Post-switch processing.  */
 991 bool
 992 c_common_post_options (const char **pfilename)
 993 {
 994   struct cpp_callbacks *cb;
 995
 996   /* Canonicalize the input and output filenames.  */
 997   if (in_fnames == NULL)
 998     {
 999       in_fnames = XNEWVEC (const char *, 1);
1000       in_fnames[0] = "";
1001     }
1002   else if (strcmp (in_fnames[0], "-") == 0)
1003     in_fnames[0] = "";
1004
1005   if (out_fname == NULL || !strcmp (out_fname, "-"))
1006     out_fname = "";
1007
1008   if (cpp_opts->deps.style == DEPS_NONE)
1009     check_deps_environment_vars ();
1010
1011   handle_deferred_opts ();
1012
1013   sanitize_cpp_opts ();
1014
1015   register_include_chains (parse_in, sysroot, iprefix, imultilib,
1016                            std_inc, std_cxx_inc && c_dialect_cxx (), verbose);
1017
1018 #ifdef C_COMMON_OVERRIDE_OPTIONS
1019   /* Some machines may reject certain combinations of C
1020      language-specific options.  */
1021   C_COMMON_OVERRIDE_OPTIONS;
1022 #endif
1023
1024   /* By default we use C99 inline semantics in GNU99 or C99 mode.  C99
1025      inline semantics are not supported in GNU89 or C89 mode.  */
1026   if (flag_gnu89_inline == -1)
1027     flag_gnu89_inline = !flag_isoc99;
1028   else if (!flag_gnu89_inline && !flag_isoc99)
1029     error ("-fno-gnu89-inline is only supported in GNU99 or C99 mode");
1030
1031   /* Default to ObjC sjlj exception handling if NeXT runtime.  */
1032   if (flag_objc_sjlj_exceptions < 0)
1033     flag_objc_sjlj_exceptions = flag_next_runtime;
1034   if (flag_objc_exceptions && !flag_objc_sjlj_exceptions)
1035     flag_exceptions = 1;
1036
1037   /* -Wextra implies -Wtype-limits, -Wclobbered,
1038      -Wempty-body, -Wsign-compare,
1039      -Wmissing-field-initializers, -Wmissing-parameter-type
1040      -Wold-style-declaration, -Woverride-init and -Wignored-qualifiers
1041      but not if explicitly overridden.  */
1042   if (warn_type_limits == -1)
1043     warn_type_limits = extra_warnings;
1044   if (warn_clobbered == -1)
1045     warn_clobbered = extra_warnings;
1046   if (warn_empty_body == -1)
1047     warn_empty_body = extra_warnings;
1048   if (warn_sign_compare == -1)
1049     warn_sign_compare = extra_warnings;
1050   if (warn_missing_field_initializers == -1)
1051     warn_missing_field_initializers = extra_warnings;
1052   if (warn_missing_parameter_type == -1)
1053     warn_missing_parameter_type = extra_warnings;
1054   if (warn_old_style_declaration == -1)
1055     warn_old_style_declaration = extra_warnings;
1056   if (warn_override_init == -1)
1057     warn_override_init = extra_warnings;
1058   if (warn_ignored_qualifiers == -1)
1059     warn_ignored_qualifiers = extra_warnings;
1060
1061   /* -Wpointer-sign is disabled by default, but it is enabled if any
1062      of -Wall or -pedantic are given.  */
1063   if (warn_pointer_sign == -1)
1064     warn_pointer_sign = 0;
1065
1066   if (warn_strict_aliasing == -1)
1067     warn_strict_aliasing = 0;
1068   if (warn_strict_overflow == -1)
1069     warn_strict_overflow = 0;
1070
1071   /* -Woverlength-strings is off by default, but is enabled by -pedantic.
1072      It is never enabled in C++, as the minimum limit is not normative
1073      in that standard.  */
1074   if (warn_overlength_strings == -1 || c_dialect_cxx ())
1075     warn_overlength_strings = 0;
1076
1077   /* Wmain is enabled by default in C++ but not in C.  */
1078   /* Wmain is disabled by default for -ffreestanding (!flag_hosted),
1079      even if -Wall was given (warn_main will be 2 if set by -Wall, 1
1080      if set by -Wmain).  */
1081   if (warn_main == -1)
1082     warn_main = (c_dialect_cxx () && flag_hosted) ? 1 : 0;
1083   else if (warn_main == 2)
1084     warn_main = flag_hosted ? 1 : 0;
1085
1086   /* In C, -Wconversion enables -Wsign-conversion (unless disabled
1087      through -Wno-sign-conversion). While in C++,
1088      -Wsign-conversion needs to be requested explicitly.  */
1089   if (warn_sign_conversion == -1)
1090     warn_sign_conversion =  (c_dialect_cxx ()) ? 0 : warn_conversion;
1091
1092   /* -Wpacked-bitfield-compat is on by default for the C languages.  The
1093      warning is issued in stor-layout.c which is not part of the front-end so
1094      we need to selectively turn it on here.  */
1095   if (warn_packed_bitfield_compat == -1)
1096     warn_packed_bitfield_compat = 1;
1097
1098   /* Special format checking options don't work without -Wformat; warn if
1099      they are used.  */
1100   if (!warn_format)
1101     {
1102       warning (OPT_Wformat_y2k,
1103                "-Wformat-y2k ignored without -Wformat");
1104       warning (OPT_Wformat_extra_args,
1105                "-Wformat-extra-args ignored without -Wformat");
1106       warning (OPT_Wformat_zero_length,
1107                "-Wformat-zero-length ignored without -Wformat");
1108       warning (OPT_Wformat_nonliteral,
1109                "-Wformat-nonliteral ignored without -Wformat");
1110       warning (OPT_Wformat_contains_nul,
1111                "-Wformat-contains-nul ignored without -Wformat");
1112       warning (OPT_Wformat_security,
1113                "-Wformat-security ignored without -Wformat");
1114     }
1115
1116   /* -Wimplicit-function-declaration is enabled by default for C99.  */
1117   if (warn_implicit_function_declaration == -1)
1118     warn_implicit_function_declaration = flag_isoc99;
1119
1120   /* If we're allowing C++0x constructs, don't warn about C++0x
1121      compatibility problems.  */
1122   if (cxx_dialect == cxx0x)
1123     warn_cxx0x_compat = 0;
1124
1125   if (flag_preprocess_only)
1126     {
1127       /* Open the output now.  We must do so even if flag_no_output is
1128          on, because there may be other output than from the actual
1129          preprocessing (e.g. from -dM).  */
1130       if (out_fname[0] == '\0')
1131         out_stream = stdout;
1132       else
1133         out_stream = fopen (out_fname, "w");
1134
1135       if (out_stream == NULL)
1136         {
1137           fatal_error ("opening output file %s: %m", out_fname);
1138           return false;
1139         }
1140
1141       if (num_in_fnames > 1)
1142         error ("too many filenames given.  Type %s --help for usage",
1143                progname);
1144
1145       init_pp_output (out_stream);
1146     }
1147   else
1148     {
1149       init_c_lex ();
1150
1151       /* Yuk.  WTF is this?  I do know ObjC relies on it somewhere.  */
1152       input_location = UNKNOWN_LOCATION;
1153     }
1154
1155   cb = cpp_get_callbacks (parse_in);
1156   cb->file_change = cb_file_change;
1157   cb->dir_change = cb_dir_change;
1158   cpp_post_options (parse_in);
1159
1160   input_location = UNKNOWN_LOCATION;
1161
1162   /* If an error has occurred in cpplib, note it so we fail
1163      immediately.  */
1164   errorcount += cpp_errors (parse_in);
1165
1166   *pfilename = this_input_filename
1167     = cpp_read_main_file (parse_in, in_fnames[0]);
1168   /* Don't do any compilation or preprocessing if there is no input file.  */
1169   if (this_input_filename == NULL)
1170     {
1171       errorcount++;
1172       return false;
1173     }
1174
1175   if (flag_working_directory
1176       && flag_preprocess_only && !flag_no_line_commands)
1177     pp_dir_change (parse_in, get_src_pwd ());
1178
1179   return flag_preprocess_only;
1180 }
1181
1182 /* Front end initialization common to C, ObjC and C++.  */
1183 bool
1184 c_common_init (void)
1185 {
1186   /* Set up preprocessor arithmetic.  Must be done after call to
1187      c_common_nodes_and_builtins for type nodes to be good.  */
1188   cpp_opts->precision = TYPE_PRECISION (intmax_type_node);
1189   cpp_opts->char_precision = TYPE_PRECISION (char_type_node);
1190   cpp_opts->int_precision = TYPE_PRECISION (integer_type_node);
1191   cpp_opts->wchar_precision = TYPE_PRECISION (wchar_type_node);
1192   cpp_opts->unsigned_wchar = TYPE_UNSIGNED (wchar_type_node);
1193   cpp_opts->bytes_big_endian = BYTES_BIG_ENDIAN;
1194
1195   /* This can't happen until after wchar_precision and bytes_big_endian
1196      are known.  */
1197   cpp_init_iconv (parse_in);
1198
1199   if (version_flag)
1200     c_common_print_pch_checksum (stderr);
1201
1202   /* Has to wait until now so that cpplib has its hash table.  */
1203   init_pragma ();
1204
1205   if (flag_preprocess_only)
1206     {
1207       finish_options ();
1208       preprocess_file (parse_in);
1209       return false;
1210     }
1211
1212   return true;
1213 }
1214
1215 /* Initialize the integrated preprocessor after debug output has been
1216    initialized; loop over each input file.  */
1217 void
1218 c_common_parse_file (int set_yydebug)
1219 {
1220   unsigned int i;
1221
1222   if (set_yydebug)
1223     switch (c_language)
1224       {
1225       case clk_c:
1226         warning(0, "The C parser does not support -dy, option ignored");
1227         break;
1228       case clk_objc:
1229         warning(0,
1230                 "The Objective-C parser does not support -dy, option ignored");
1231         break;
1232       case clk_cxx:
1233         warning(0, "The C++ parser does not support -dy, option ignored");
1234         break;
1235       case clk_objcxx:
1236         warning(0,
1237             "The Objective-C++ parser does not support -dy, option ignored");
1238         break;
1239       default:
1240         gcc_unreachable ();
1241     }
1242
1243   i = 0;
1244   for (;;)
1245     {
1246       /* Start the main input file, if the debug writer wants it. */
1247       if (debug_hooks->start_end_main_source_file)
1248         (*debug_hooks->start_source_file) (0, this_input_filename);
1249       finish_options ();
1250       pch_init ();
1251       push_file_scope ();
1252       c_parse_file ();
1253       finish_file ();
1254       pop_file_scope ();
1255       /* And end the main input file, if the debug writer wants it  */
1256       if (debug_hooks->start_end_main_source_file)
1257         (*debug_hooks->end_source_file) (0);
1258       if (++i >= num_in_fnames)
1259         break;
1260       cpp_undef_all (parse_in);
1261       cpp_clear_file_cache (parse_in);
1262       this_input_filename
1263         = cpp_read_main_file (parse_in, in_fnames[i]);
1264       /* If an input file is missing, abandon further compilation.
1265          cpplib has issued a diagnostic.  */
1266       if (!this_input_filename)
1267         break;
1268     }
1269 }
1270
1271 /* Common finish hook for the C, ObjC and C++ front ends.  */
1272 void
1273 c_common_finish (void)
1274 {
1275   FILE *deps_stream = NULL;
1276
1277   if (cpp_opts->deps.style != DEPS_NONE)
1278     {
1279       /* If -M or -MM was seen without -MF, default output to the
1280          output stream.  */
1281       if (!deps_file)
1282         deps_stream = out_stream;
1283       else
1284         {
1285           deps_stream = fopen (deps_file, deps_append ? "a": "w");
1286           if (!deps_stream)
1287             fatal_error ("opening dependency file %s: %m", deps_file);
1288         }
1289     }
1290
1291   /* For performance, avoid tearing down cpplib's internal structures
1292      with cpp_destroy ().  */
1293   errorcount += cpp_finish (parse_in, deps_stream);
1294
1295   if (deps_stream && deps_stream != out_stream
1296       && (ferror (deps_stream) || fclose (deps_stream)))
1297     fatal_error ("closing dependency file %s: %m", deps_file);
1298
1299   if (out_stream && (ferror (out_stream) || fclose (out_stream)))
1300     fatal_error ("when writing output to %s: %m", out_fname);
1301 }
1302
1303 /* Either of two environment variables can specify output of
1304    dependencies.  Their value is either "OUTPUT_FILE" or "OUTPUT_FILE
1305    DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to
1306    and DEPS_TARGET is the target to mention in the deps.  They also
1307    result in dependency information being appended to the output file
1308    rather than overwriting it, and like Sun's compiler
1309    SUNPRO_DEPENDENCIES suppresses the dependency on the main file.  */
1310 static void
1311 check_deps_environment_vars (void)
1312 {
1313   char *spec;
1314
1315   GET_ENVIRONMENT (spec, "DEPENDENCIES_OUTPUT");
1316   if (spec)
1317     cpp_opts->deps.style = DEPS_USER;
1318   else
1319     {
1320       GET_ENVIRONMENT (spec, "SUNPRO_DEPENDENCIES");
1321       if (spec)
1322         {
1323           cpp_opts->deps.style = DEPS_SYSTEM;
1324           cpp_opts->deps.ignore_main_file = true;
1325         }
1326     }
1327
1328   if (spec)
1329     {
1330       /* Find the space before the DEPS_TARGET, if there is one.  */
1331       char *s = strchr (spec, ' ');
1332       if (s)
1333         {
1334           /* Let the caller perform MAKE quoting.  */
1335           defer_opt (OPT_MT, s + 1);
1336           *s = '\0';
1337         }
1338
1339       /* Command line -MF overrides environment variables and default.  */
1340       if (!deps_file)
1341         deps_file = spec;
1342
1343       deps_append = 1;
1344       deps_seen = true;
1345     }
1346 }
1347
1348 /* Handle deferred command line switches.  */
1349 static void
1350 handle_deferred_opts (void)
1351 {
1352   size_t i;
1353   struct deps *deps;
1354
1355   /* Avoid allocating the deps buffer if we don't need it.
1356      (This flag may be true without there having been -MT or -MQ
1357      options, but we'll still need the deps buffer.)  */
1358   if (!deps_seen)
1359     return;
1360
1361   deps = cpp_get_deps (parse_in);
1362
1363   for (i = 0; i < deferred_count; i++)
1364     {
1365       struct deferred_opt *opt = &deferred_opts[i];
1366
1367       if (opt->code == OPT_MT || opt->code == OPT_MQ)
1368         deps_add_target (deps, opt->arg, opt->code == OPT_MQ);
1369     }
1370 }
1371
1372 /* These settings are appropriate for GCC, but not necessarily so for
1373    cpplib as a library.  */
1374 static void
1375 sanitize_cpp_opts (void)
1376 {
1377   /* If we don't know what style of dependencies to output, complain
1378      if any other dependency switches have been given.  */
1379   if (deps_seen && cpp_opts->deps.style == DEPS_NONE)
1380     error ("to generate dependencies you must specify either -M or -MM");
1381
1382   /* -dM and dependencies suppress normal output; do it here so that
1383      the last -d[MDN] switch overrides earlier ones.  */
1384   if (flag_dump_macros == 'M')
1385     flag_no_output = 1;
1386
1387   /* By default, -fdirectives-only implies -dD.  This allows subsequent phases
1388      to perform proper macro expansion.  */
1389   if (cpp_opts->directives_only && !cpp_opts->preprocessed && !flag_dump_macros)
1390     flag_dump_macros = 'D';
1391
1392   /* Disable -dD, -dN and -dI if normal output is suppressed.  Allow
1393      -dM since at least glibc relies on -M -dM to work.  */
1394   /* Also, flag_no_output implies flag_no_line_commands, always.  */
1395   if (flag_no_output)
1396     {
1397       if (flag_dump_macros != 'M')
1398         flag_dump_macros = 0;
1399       flag_dump_includes = 0;
1400       flag_no_line_commands = 1;
1401     }
1402   else if (cpp_opts->deps.missing_files)
1403     error ("-MG may only be used with -M or -MM");
1404
1405   cpp_opts->unsigned_char = !flag_signed_char;
1406   cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS;
1407
1408   /* We want -Wno-long-long to override -pedantic -std=non-c99
1409      and/or -Wtraditional, whatever the ordering.  */
1410   cpp_opts->warn_long_long
1411     = warn_long_long && ((pedantic
1412                           && (c_dialect_cxx ()
1413                               ? cxx_dialect == cxx98
1414                               : !flag_isoc99))
1415                          || warn_traditional);
1416
1417   /* Similarly with -Wno-variadic-macros.  No check for c99 here, since
1418      this also turns off warnings about GCCs extension.  */
1419   cpp_opts->warn_variadic_macros
1420     = warn_variadic_macros && (pedantic || warn_traditional);
1421
1422   /* If we're generating preprocessor output, emit current directory
1423      if explicitly requested or if debugging information is enabled.
1424      ??? Maybe we should only do it for debugging formats that
1425      actually output the current directory?  */
1426   if (flag_working_directory == -1)
1427     flag_working_directory = (debug_info_level != DINFO_LEVEL_NONE);
1428
1429   if (cpp_opts->directives_only)
1430     {
1431       if (warn_unused_macros)
1432         error ("-fdirectives-only is incompatible with -Wunused_macros");
1433       if (cpp_opts->traditional)
1434         error ("-fdirectives-only is incompatible with -traditional");
1435     }
1436 }
1437
1438 /* Add include path with a prefix at the front of its name.  */
1439 static void
1440 add_prefixed_path (const char *suffix, size_t chain)
1441 {
1442   char *path;
1443   const char *prefix;
1444   size_t prefix_len, suffix_len;
1445
1446   suffix_len = strlen (suffix);
1447   prefix     = iprefix ? iprefix : cpp_GCC_INCLUDE_DIR;
1448   prefix_len = iprefix ? strlen (iprefix) : cpp_GCC_INCLUDE_DIR_len;
1449
1450   path = (char *) xmalloc (prefix_len + suffix_len + 1);
1451   memcpy (path, prefix, prefix_len);
1452   memcpy (path + prefix_len, suffix, suffix_len);
1453   path[prefix_len + suffix_len] = '\0';
1454
1455   add_path (path, chain, 0, false);
1456 }
1457
1458 /* Handle -D, -U, -A, -imacros, and the first -include.  */
1459 static void
1460 finish_options (void)
1461 {
1462   if (!cpp_opts->preprocessed)
1463     {
1464       size_t i;
1465
1466       cb_file_change (parse_in,
1467                       linemap_add (line_table, LC_RENAME, 0,
1468                                    _("<built-in>"), 0));
1469
1470       cpp_init_builtins (parse_in, flag_hosted);
1471       c_cpp_builtins (parse_in);
1472
1473       /* We're about to send user input to cpplib, so make it warn for
1474          things that we previously (when we sent it internal definitions)
1475          told it to not warn.
1476
1477          C99 permits implementation-defined characters in identifiers.
1478          The documented meaning of -std= is to turn off extensions that
1479          conflict with the specified standard, and since a strictly
1480          conforming program cannot contain a '$', we do not condition
1481          their acceptance on the -std= setting.  */
1482       cpp_opts->warn_dollars = (cpp_opts->pedantic && !cpp_opts->c99);
1483
1484       cb_file_change (parse_in,
1485                       linemap_add (line_table, LC_RENAME, 0,
1486                                    _("<command-line>"), 0));
1487
1488       for (i = 0; i < deferred_count; i++)
1489         {
1490           struct deferred_opt *opt = &deferred_opts[i];
1491
1492           if (opt->code == OPT_D)
1493             cpp_define (parse_in, opt->arg);
1494           else if (opt->code == OPT_U)
1495             cpp_undef (parse_in, opt->arg);
1496           else if (opt->code == OPT_A)
1497             {
1498               if (opt->arg[0] == '-')
1499                 cpp_unassert (parse_in, opt->arg + 1);
1500               else
1501                 cpp_assert (parse_in, opt->arg);
1502             }
1503         }
1504
1505       /* Handle -imacros after -D and -U.  */
1506       for (i = 0; i < deferred_count; i++)
1507         {
1508           struct deferred_opt *opt = &deferred_opts[i];
1509
1510           if (opt->code == OPT_imacros
1511               && cpp_push_include (parse_in, opt->arg))
1512             {
1513               /* Disable push_command_line_include callback for now.  */
1514               include_cursor = deferred_count + 1;
1515               cpp_scan_nooutput (parse_in);
1516             }
1517         }
1518     }
1519   else if (cpp_opts->directives_only)
1520     cpp_init_special_builtins (parse_in);
1521
1522   include_cursor = 0;
1523   push_command_line_include ();
1524 }
1525
1526 /* Give CPP the next file given by -include, if any.  */
1527 static void
1528 push_command_line_include (void)
1529 {
1530   while (include_cursor < deferred_count)
1531     {
1532       struct deferred_opt *opt = &deferred_opts[include_cursor++];
1533
1534       if (!cpp_opts->preprocessed && opt->code == OPT_include
1535           && cpp_push_include (parse_in, opt->arg))
1536         return;
1537     }
1538
1539   if (include_cursor == deferred_count)
1540     {
1541       include_cursor++;
1542       /* -Wunused-macros should only warn about macros defined hereafter.  */
1543       cpp_opts->warn_unused_macros = warn_unused_macros;
1544       /* Restore the line map from <command line>.  */
1545       if (!cpp_opts->preprocessed)
1546         cpp_change_file (parse_in, LC_RENAME, this_input_filename);
1547
1548       /* Set this here so the client can change the option if it wishes,
1549          and after stacking the main file so we don't trace the main file.  */
1550       line_table->trace_includes = cpp_opts->print_include_names;
1551     }
1552 }
1553
1554 /* File change callback.  Has to handle -include files.  */
1555 static void
1556 cb_file_change (cpp_reader * ARG_UNUSED (pfile),
1557                 const struct line_map *new_map)
1558 {
1559   if (flag_preprocess_only)
1560     pp_file_change (new_map);
1561   else
1562     fe_file_change (new_map);
1563
1564   if (new_map == 0 || (new_map->reason == LC_LEAVE && MAIN_FILE_P (new_map)))
1565     push_command_line_include ();
1566 }
1567
1568 void
1569 cb_dir_change (cpp_reader * ARG_UNUSED (pfile), const char *dir)
1570 {
1571   if (!set_src_pwd (dir))
1572     warning (0, "too late for # directive to set debug directory");
1573 }
1574
1575 /* Set the C 89 standard (with 1994 amendments if C94, without GNU
1576    extensions if ISO).  There is no concept of gnu94.  */
1577 static void
1578 set_std_c89 (int c94, int iso)
1579 {
1580   cpp_set_lang (parse_in, c94 ? CLK_STDC94: iso ? CLK_STDC89: CLK_GNUC89);
1581   flag_iso = iso;
1582   flag_no_asm = iso;
1583   flag_no_gnu_keywords = iso;
1584   flag_no_nonansi_builtin = iso;
1585   flag_isoc94 = c94;
1586   flag_isoc99 = 0;
1587 }
1588
1589 /* Set the C 99 standard (without GNU extensions if ISO).  */
1590 static void
1591 set_std_c99 (int iso)
1592 {
1593   cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99);
1594   flag_no_asm = iso;
1595   flag_no_nonansi_builtin = iso;
1596   flag_iso = iso;
1597   flag_isoc99 = 1;
1598   flag_isoc94 = 1;
1599 }
1600
1601 /* Set the C++ 98 standard (without GNU extensions if ISO).  */
1602 static void
1603 set_std_cxx98 (int iso)
1604 {
1605   cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX);
1606   flag_no_gnu_keywords = iso;
1607   flag_no_nonansi_builtin = iso;
1608   flag_iso = iso;
1609   cxx_dialect = cxx98;
1610 }
1611
1612 /* Set the C++ 0x working draft "standard" (without GNU extensions if ISO).  */
1613 static void
1614 set_std_cxx0x (int iso)
1615 {
1616   cpp_set_lang (parse_in, iso ? CLK_CXX0X: CLK_GNUCXX0X);
1617   flag_no_gnu_keywords = iso;
1618   flag_no_nonansi_builtin = iso;
1619   flag_iso = iso;
1620   cxx_dialect = cxx0x;
1621 }
1622
1623 /* Handle setting implicit to ON.  */
1624 static void
1625 set_Wimplicit (int on)
1626 {
1627   warn_implicit = on;
1628   warn_implicit_int = on;
1629   warn_implicit_function_declaration = on;
1630 }
1631
1632 /* Args to -d specify what to dump.  Silently ignore
1633    unrecognized options; they may be aimed at toplev.c.  */
1634 static void
1635 handle_OPT_d (const char *arg)
1636 {
1637   char c;
1638
1639   while ((c = *arg++) != '\0')
1640     switch (c)
1641       {
1642       case 'M':                 /* Dump macros only.  */
1643       case 'N':                 /* Dump names.  */
1644       case 'D':                 /* Dump definitions.  */
1645       case 'U':                 /* Dump used macros.  */
1646         flag_dump_macros = c;
1647         break;
1648
1649       case 'I':
1650         flag_dump_includes = 1;
1651         break;
1652       }
1653 }