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