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