contrib/gcc/c-opts.c

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