contrib/gcc/c-opts.c

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