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 we're allowing C++0x constructs, don't warn about C++0x
1086      compatibility problems.  */
1087   if (flag_cpp0x)
1088     warn_cxx0x_compat = 0;
1089
1090   if (flag_preprocess_only)
1091     {
1092       /* Open the output now.  We must do so even if flag_no_output is
1093          on, because there may be other output than from the actual
1094          preprocessing (e.g. from -dM).  */
1095       if (out_fname[0] == '\0')
1096         out_stream = stdout;
1097       else
1098         out_stream = fopen (out_fname, "w");
1099
1100       if (out_stream == NULL)
1101         {
1102           fatal_error ("opening output file %s: %m", out_fname);
1103           return false;
1104         }
1105
1106       if (num_in_fnames > 1)
1107         error ("too many filenames given.  Type %s --help for usage",
1108                progname);
1109
1110       init_pp_output (out_stream);
1111     }
1112   else
1113     {
1114       init_c_lex ();
1115
1116       /* Yuk.  WTF is this?  I do know ObjC relies on it somewhere.  */
1117       input_location = UNKNOWN_LOCATION;
1118     }
1119
1120   cb = cpp_get_callbacks (parse_in);
1121   cb->file_change = cb_file_change;
1122   cb->dir_change = cb_dir_change;
1123   cpp_post_options (parse_in);
1124
1125   input_location = UNKNOWN_LOCATION;
1126
1127   /* If an error has occurred in cpplib, note it so we fail
1128      immediately.  */
1129   errorcount += cpp_errors (parse_in);
1130
1131   *pfilename = this_input_filename
1132     = cpp_read_main_file (parse_in, in_fnames[0]);
1133   /* Don't do any compilation or preprocessing if there is no input file.  */
1134   if (this_input_filename == NULL)
1135     {
1136       errorcount++;
1137       return false;
1138     }
1139
1140   if (flag_working_directory
1141       && flag_preprocess_only && !flag_no_line_commands)
1142     pp_dir_change (parse_in, get_src_pwd ());
1143
1144   return flag_preprocess_only;
1145 }
1146
1147 /* Front end initialization common to C, ObjC and C++.  */
1148 bool
1149 c_common_init (void)
1150 {
1151   /* Set up preprocessor arithmetic.  Must be done after call to
1152      c_common_nodes_and_builtins for type nodes to be good.  */
1153   cpp_opts->precision = TYPE_PRECISION (intmax_type_node);
1154   cpp_opts->char_precision = TYPE_PRECISION (char_type_node);
1155   cpp_opts->int_precision = TYPE_PRECISION (integer_type_node);
1156   cpp_opts->wchar_precision = TYPE_PRECISION (wchar_type_node);
1157   cpp_opts->unsigned_wchar = TYPE_UNSIGNED (wchar_type_node);
1158   cpp_opts->bytes_big_endian = BYTES_BIG_ENDIAN;
1159
1160   /* This can't happen until after wchar_precision and bytes_big_endian
1161      are known.  */
1162   cpp_init_iconv (parse_in);
1163
1164   if (version_flag)
1165     c_common_print_pch_checksum (stderr);
1166
1167   if (flag_preprocess_only)
1168     {
1169       finish_options ();
1170       preprocess_file (parse_in);
1171       return false;
1172     }
1173
1174   /* Has to wait until now so that cpplib has its hash table.  */
1175   init_pragma ();
1176
1177   return true;
1178 }
1179
1180 /* Initialize the integrated preprocessor after debug output has been
1181    initialized; loop over each input file.  */
1182 void
1183 c_common_parse_file (int set_yydebug)
1184 {
1185   unsigned int i;
1186
1187   if (set_yydebug)
1188     switch (c_language)
1189       {
1190       case clk_c:
1191         warning(0, "The C parser does not support -dy, option ignored");
1192         break;
1193       case clk_objc:
1194         warning(0,
1195                 "The Objective-C parser does not support -dy, option ignored");
1196         break;
1197       case clk_cxx:
1198         warning(0, "The C++ parser does not support -dy, option ignored");
1199         break;
1200       case clk_objcxx:
1201         warning(0,
1202             "The Objective-C++ parser does not support -dy, option ignored");
1203         break;
1204       default:
1205         gcc_unreachable ();
1206     }
1207
1208   i = 0;
1209   for (;;)
1210     {
1211       /* Start the main input file, if the debug writer wants it. */
1212       if (debug_hooks->start_end_main_source_file)
1213         (*debug_hooks->start_source_file) (0, this_input_filename);
1214       finish_options ();
1215       pch_init ();
1216       push_file_scope ();
1217       c_parse_file ();
1218       finish_file ();
1219       pop_file_scope ();
1220       /* And end the main input file, if the debug writer wants it  */
1221       if (debug_hooks->start_end_main_source_file)
1222         (*debug_hooks->end_source_file) (0);
1223       if (++i >= num_in_fnames)
1224         break;
1225       cpp_undef_all (parse_in);
1226       this_input_filename
1227         = cpp_read_main_file (parse_in, in_fnames[i]);
1228       /* If an input file is missing, abandon further compilation.
1229          cpplib has issued a diagnostic.  */
1230       if (!this_input_filename)
1231         break;
1232     }
1233 }
1234
1235 /* Common finish hook for the C, ObjC and C++ front ends.  */
1236 void
1237 c_common_finish (void)
1238 {
1239   FILE *deps_stream = NULL;
1240
1241   if (cpp_opts->deps.style != DEPS_NONE)
1242     {
1243       /* If -M or -MM was seen without -MF, default output to the
1244          output stream.  */
1245       if (!deps_file)
1246         deps_stream = out_stream;
1247       else
1248         {
1249           deps_stream = fopen (deps_file, deps_append ? "a": "w");
1250           if (!deps_stream)
1251             fatal_error ("opening dependency file %s: %m", deps_file);
1252         }
1253     }
1254
1255   /* For performance, avoid tearing down cpplib's internal structures
1256      with cpp_destroy ().  */
1257   errorcount += cpp_finish (parse_in, deps_stream);
1258
1259   if (deps_stream && deps_stream != out_stream
1260       && (ferror (deps_stream) || fclose (deps_stream)))
1261     fatal_error ("closing dependency file %s: %m", deps_file);
1262
1263   if (out_stream && (ferror (out_stream) || fclose (out_stream)))
1264     fatal_error ("when writing output to %s: %m", out_fname);
1265 }
1266
1267 /* Either of two environment variables can specify output of
1268    dependencies.  Their value is either "OUTPUT_FILE" or "OUTPUT_FILE
1269    DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to
1270    and DEPS_TARGET is the target to mention in the deps.  They also
1271    result in dependency information being appended to the output file
1272    rather than overwriting it, and like Sun's compiler
1273    SUNPRO_DEPENDENCIES suppresses the dependency on the main file.  */
1274 static void
1275 check_deps_environment_vars (void)
1276 {
1277   char *spec;
1278
1279   GET_ENVIRONMENT (spec, "DEPENDENCIES_OUTPUT");
1280   if (spec)
1281     cpp_opts->deps.style = DEPS_USER;
1282   else
1283     {
1284       GET_ENVIRONMENT (spec, "SUNPRO_DEPENDENCIES");
1285       if (spec)
1286         {
1287           cpp_opts->deps.style = DEPS_SYSTEM;
1288           cpp_opts->deps.ignore_main_file = true;
1289         }
1290     }
1291
1292   if (spec)
1293     {
1294       /* Find the space before the DEPS_TARGET, if there is one.  */
1295       char *s = strchr (spec, ' ');
1296       if (s)
1297         {
1298           /* Let the caller perform MAKE quoting.  */
1299           defer_opt (OPT_MT, s + 1);
1300           *s = '\0';
1301         }
1302
1303       /* Command line -MF overrides environment variables and default.  */
1304       if (!deps_file)
1305         deps_file = spec;
1306
1307       deps_append = 1;
1308       deps_seen = true;
1309     }
1310 }
1311
1312 /* Handle deferred command line switches.  */
1313 static void
1314 handle_deferred_opts (void)
1315 {
1316   size_t i;
1317   struct deps *deps;
1318
1319   /* Avoid allocating the deps buffer if we don't need it.
1320      (This flag may be true without there having been -MT or -MQ
1321      options, but we'll still need the deps buffer.)  */
1322   if (!deps_seen)
1323     return;
1324
1325   deps = cpp_get_deps (parse_in);
1326
1327   for (i = 0; i < deferred_count; i++)
1328     {
1329       struct deferred_opt *opt = &deferred_opts[i];
1330
1331       if (opt->code == OPT_MT || opt->code == OPT_MQ)
1332         deps_add_target (deps, opt->arg, opt->code == OPT_MQ);
1333     }
1334 }
1335
1336 /* These settings are appropriate for GCC, but not necessarily so for
1337    cpplib as a library.  */
1338 static void
1339 sanitize_cpp_opts (void)
1340 {
1341   /* If we don't know what style of dependencies to output, complain
1342      if any other dependency switches have been given.  */
1343   if (deps_seen && cpp_opts->deps.style == DEPS_NONE)
1344     error ("to generate dependencies you must specify either -M or -MM");
1345
1346   /* -dM and dependencies suppress normal output; do it here so that
1347      the last -d[MDN] switch overrides earlier ones.  */
1348   if (flag_dump_macros == 'M')
1349     flag_no_output = 1;
1350
1351   /* Disable -dD, -dN and -dI if normal output is suppressed.  Allow
1352      -dM since at least glibc relies on -M -dM to work.  */
1353   /* Also, flag_no_output implies flag_no_line_commands, always.  */
1354   if (flag_no_output)
1355     {
1356       if (flag_dump_macros != 'M')
1357         flag_dump_macros = 0;
1358       flag_dump_includes = 0;
1359       flag_no_line_commands = 1;
1360     }
1361
1362   cpp_opts->unsigned_char = !flag_signed_char;
1363   cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS;
1364
1365   /* We want -Wno-long-long to override -pedantic -std=non-c99
1366      and/or -Wtraditional, whatever the ordering.  */
1367   cpp_opts->warn_long_long
1368     = warn_long_long && ((!flag_isoc99 && pedantic) || warn_traditional);
1369
1370   /* Similarly with -Wno-variadic-macros.  No check for c99 here, since
1371      this also turns off warnings about GCCs extension.  */
1372   cpp_opts->warn_variadic_macros
1373     = warn_variadic_macros && (pedantic || warn_traditional);
1374
1375   /* If we're generating preprocessor output, emit current directory
1376      if explicitly requested or if debugging information is enabled.
1377      ??? Maybe we should only do it for debugging formats that
1378      actually output the current directory?  */
1379   if (flag_working_directory == -1)
1380     flag_working_directory = (debug_info_level != DINFO_LEVEL_NONE);
1381 }
1382
1383 /* Add include path with a prefix at the front of its name.  */
1384 static void
1385 add_prefixed_path (const char *suffix, size_t chain)
1386 {
1387   char *path;
1388   const char *prefix;
1389   size_t prefix_len, suffix_len;
1390
1391   suffix_len = strlen (suffix);
1392   prefix     = iprefix ? iprefix : cpp_GCC_INCLUDE_DIR;
1393   prefix_len = iprefix ? strlen (iprefix) : cpp_GCC_INCLUDE_DIR_len;
1394
1395   path = (char *) xmalloc (prefix_len + suffix_len + 1);
1396   memcpy (path, prefix, prefix_len);
1397   memcpy (path + prefix_len, suffix, suffix_len);
1398   path[prefix_len + suffix_len] = '\0';
1399
1400   add_path (path, chain, 0, false);
1401 }
1402
1403 /* Handle -D, -U, -A, -imacros, and the first -include.  */
1404 static void
1405 finish_options (void)
1406 {
1407   if (!cpp_opts->preprocessed)
1408     {
1409       size_t i;
1410
1411       cb_file_change (parse_in,
1412                       linemap_add (&line_table, LC_RENAME, 0,
1413                                    _("<built-in>"), 0));
1414
1415       cpp_init_builtins (parse_in, flag_hosted);
1416       c_cpp_builtins (parse_in);
1417
1418       /* We're about to send user input to cpplib, so make it warn for
1419          things that we previously (when we sent it internal definitions)
1420          told it to not warn.
1421
1422          C99 permits implementation-defined characters in identifiers.
1423          The documented meaning of -std= is to turn off extensions that
1424          conflict with the specified standard, and since a strictly
1425          conforming program cannot contain a '$', we do not condition
1426          their acceptance on the -std= setting.  */
1427       cpp_opts->warn_dollars = (cpp_opts->pedantic && !cpp_opts->c99);
1428
1429       cb_file_change (parse_in,
1430                       linemap_add (&line_table, LC_RENAME, 0,
1431                                    _("<command-line>"), 0));
1432
1433       for (i = 0; i < deferred_count; i++)
1434         {
1435           struct deferred_opt *opt = &deferred_opts[i];
1436
1437           if (opt->code == OPT_D)
1438             cpp_define (parse_in, opt->arg);
1439           else if (opt->code == OPT_U)
1440             cpp_undef (parse_in, opt->arg);
1441           else if (opt->code == OPT_A)
1442             {
1443               if (opt->arg[0] == '-')
1444                 cpp_unassert (parse_in, opt->arg + 1);
1445               else
1446                 cpp_assert (parse_in, opt->arg);
1447             }
1448         }
1449
1450       /* Handle -imacros after -D and -U.  */
1451       for (i = 0; i < deferred_count; i++)
1452         {
1453           struct deferred_opt *opt = &deferred_opts[i];
1454
1455           if (opt->code == OPT_imacros
1456               && cpp_push_include (parse_in, opt->arg))
1457             {
1458               /* Disable push_command_line_include callback for now.  */
1459               include_cursor = deferred_count + 1;
1460               cpp_scan_nooutput (parse_in);
1461             }
1462         }
1463     }
1464
1465   include_cursor = 0;
1466   push_command_line_include ();
1467 }
1468
1469 /* Give CPP the next file given by -include, if any.  */
1470 static void
1471 push_command_line_include (void)
1472 {
1473   while (include_cursor < deferred_count)
1474     {
1475       struct deferred_opt *opt = &deferred_opts[include_cursor++];
1476
1477       if (!cpp_opts->preprocessed && opt->code == OPT_include
1478           && cpp_push_include (parse_in, opt->arg))
1479         return;
1480     }
1481
1482   if (include_cursor == deferred_count)
1483     {
1484       include_cursor++;
1485       /* -Wunused-macros should only warn about macros defined hereafter.  */
1486       cpp_opts->warn_unused_macros = warn_unused_macros;
1487       /* Restore the line map from <command line>.  */
1488       if (!cpp_opts->preprocessed)
1489         cpp_change_file (parse_in, LC_RENAME, this_input_filename);
1490
1491       /* Set this here so the client can change the option if it wishes,
1492          and after stacking the main file so we don't trace the main file.  */
1493       line_table.trace_includes = cpp_opts->print_include_names;
1494     }
1495 }
1496
1497 /* File change callback.  Has to handle -include files.  */
1498 static void
1499 cb_file_change (cpp_reader * ARG_UNUSED (pfile),
1500                 const struct line_map *new_map)
1501 {
1502   if (flag_preprocess_only)
1503     pp_file_change (new_map);
1504   else
1505     fe_file_change (new_map);
1506
1507   if (new_map == 0 || (new_map->reason == LC_LEAVE && MAIN_FILE_P (new_map)))
1508     push_command_line_include ();
1509 }
1510
1511 void
1512 cb_dir_change (cpp_reader * ARG_UNUSED (pfile), const char *dir)
1513 {
1514   if (!set_src_pwd (dir))
1515     warning (0, "too late for # directive to set debug directory");
1516 }
1517
1518 /* Set the C 89 standard (with 1994 amendments if C94, without GNU
1519    extensions if ISO).  There is no concept of gnu94.  */
1520 static void
1521 set_std_c89 (int c94, int iso)
1522 {
1523   cpp_set_lang (parse_in, c94 ? CLK_STDC94: iso ? CLK_STDC89: CLK_GNUC89);
1524   flag_iso = iso;
1525   flag_no_asm = iso;
1526   flag_no_gnu_keywords = iso;
1527   flag_no_nonansi_builtin = iso;
1528   flag_isoc94 = c94;
1529   flag_isoc99 = 0;
1530 }
1531
1532 /* Set the C 99 standard (without GNU extensions if ISO).  */
1533 static void
1534 set_std_c99 (int iso)
1535 {
1536   cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99);
1537   flag_no_asm = iso;
1538   flag_no_nonansi_builtin = iso;
1539   flag_iso = iso;
1540   flag_isoc99 = 1;
1541   flag_isoc94 = 1;
1542 }
1543
1544 /* Set the C++ 98 standard (without GNU extensions if ISO).  */
1545 static void
1546 set_std_cxx98 (int iso)
1547 {
1548   cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX);
1549   flag_no_gnu_keywords = iso;
1550   flag_no_nonansi_builtin = iso;
1551   flag_iso = iso;
1552 }
1553
1554 /* Set the C++ 0x working draft "standard" (without GNU extensions if ISO).  */
1555 static void
1556 set_std_cxx0x (int iso)
1557 {
1558   cpp_set_lang (parse_in, iso ? CLK_CXX0X: CLK_GNUCXX0X);
1559   flag_no_gnu_keywords = iso;
1560   flag_no_nonansi_builtin = iso;
1561   flag_iso = iso;
1562   flag_cpp0x = 1;
1563 }
1564
1565 /* Handle setting implicit to ON.  */
1566 static void
1567 set_Wimplicit (int on)
1568 {
1569   warn_implicit = on;
1570   warn_implicit_int = on;
1571   if (on)
1572     {
1573       if (mesg_implicit_function_declaration != 2)
1574         mesg_implicit_function_declaration = 1;
1575     }
1576   else
1577     mesg_implicit_function_declaration = 0;
1578 }
1579
1580 /* Args to -d specify what to dump.  Silently ignore
1581    unrecognized options; they may be aimed at toplev.c.  */
1582 static void
1583 handle_OPT_d (const char *arg)
1584 {
1585   char c;
1586
1587   while ((c = *arg++) != '\0')
1588     switch (c)
1589       {
1590       case 'M':                 /* Dump macros only.  */
1591       case 'N':                 /* Dump names.  */
1592       case 'D':                 /* Dump definitions.  */
1593         flag_dump_macros = c;
1594         break;
1595
1596       case 'I':
1597         flag_dump_includes = 1;
1598         break;
1599       }
1600 }