gcc/c-opts.c

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