gcc/c-opts.c

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