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