gcc/c-opts.c

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