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