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