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