gcc/c-opts.c

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