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