gcc/c-opts.c

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