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