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