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_const_strings = c_dialect_cxx ();
 229   flag_exceptions = c_dialect_cxx ();
 230   warn_pointer_arith = c_dialect_cxx ();
 231
 232   deferred_opts = XNEWVEC (struct deferred_opt, argc);
 233
 234   result = lang_flags[c_language];
 235
 236   if (c_language == clk_c)
 237     {
 238       /* If preprocessing assembly language, accept any of the C-family
 239          front end options since the driver may pass them through.  */
 240       for (i = 1; i < argc; i++)
 241         if (! strcmp (argv[i], "-lang-asm"))
 242           {
 243             result |= CL_C | CL_ObjC | CL_CXX | CL_ObjCXX;
 244             break;
 245           }
 246
 247 #ifdef CL_Fortran
 248       for (i = 1; i < argc; i++)
 249         if (! strcmp (argv[i], "-lang-fortran"))
 250         {
 251             result |= CL_Fortran;
 252             break;
 253         }
 254 #endif
 255     }
 256
 257   return result;
 258 }
 259
 260 /* Handle switch SCODE with argument ARG.  VALUE is true, unless no-
 261    form of an -f or -W option was given.  Returns 0 if the switch was
 262    invalid, a negative number to prevent language-independent
 263    processing in toplev.c (a hack necessary for the short-term).  */
 264 int
 265 c_common_handle_option (size_t scode, const char *arg, int value)
 266 {
 267   const struct cl_option *option = &cl_options[scode];
 268   enum opt_code code = (enum opt_code) scode;
 269   int result = 1;
 270
 271   switch (code)
 272     {
 273     default:
 274       if (cl_options[code].flags & (CL_C | CL_CXX | CL_ObjC | CL_ObjCXX))
 275         break;
 276 #ifdef CL_Fortran
 277       if (lang_fortran && (cl_options[code].flags & (CL_Fortran)))
 278         break;
 279 #endif
 280       result = 0;
 281       break;
 282
 283     case OPT__output_pch_:
 284       pch_file = arg;
 285       break;
 286
 287     case OPT_A:
 288       defer_opt (code, arg);
 289       break;
 290
 291     case OPT_C:
 292       cpp_opts->discard_comments = 0;
 293       break;
 294
 295     case OPT_CC:
 296       cpp_opts->discard_comments = 0;
 297       cpp_opts->discard_comments_in_macro_exp = 0;
 298       break;
 299
 300     case OPT_D:
 301       defer_opt (code, arg);
 302       break;
 303
 304     case OPT_E:
 305       flag_preprocess_only = 1;
 306       break;
 307
 308     case OPT_H:
 309       cpp_opts->print_include_names = 1;
 310       break;
 311
 312     case OPT_F:
 313       TARGET_OPTF (xstrdup (arg));
 314       break;
 315
 316     case OPT_I:
 317       if (strcmp (arg, "-"))
 318         add_path (xstrdup (arg), BRACKET, 0, true);
 319       else
 320         {
 321           if (quote_chain_split)
 322             error ("-I- specified twice");
 323           quote_chain_split = true;
 324           split_quote_chain ();
 325           inform ("obsolete option -I- used, please use -iquote instead");
 326         }
 327       break;
 328
 329     case OPT_M:
 330     case OPT_MM:
 331       /* When doing dependencies with -M or -MM, suppress normal
 332          preprocessed output, but still do -dM etc. as software
 333          depends on this.  Preprocessed output does occur if -MD, -MMD
 334          or environment var dependency generation is used.  */
 335       cpp_opts->deps.style = (code == OPT_M ? DEPS_SYSTEM: DEPS_USER);
 336       flag_no_output = 1;
 337       cpp_opts->inhibit_warnings = 1;
 338       break;
 339
 340     case OPT_MD:
 341     case OPT_MMD:
 342       cpp_opts->deps.style = (code == OPT_MD ? DEPS_SYSTEM: DEPS_USER);
 343       deps_file = arg;
 344       break;
 345
 346     case OPT_MF:
 347       deps_seen = true;
 348       deps_file = arg;
 349       break;
 350
 351     case OPT_MG:
 352       deps_seen = true;
 353       cpp_opts->deps.missing_files = true;
 354       break;
 355
 356     case OPT_MP:
 357       deps_seen = true;
 358       cpp_opts->deps.phony_targets = true;
 359       break;
 360
 361     case OPT_MQ:
 362     case OPT_MT:
 363       deps_seen = true;
 364       defer_opt (code, arg);
 365       break;
 366
 367     case OPT_P:
 368       flag_no_line_commands = 1;
 369       break;
 370
 371     case OPT_fworking_directory:
 372       flag_working_directory = value;
 373       break;
 374
 375     case OPT_U:
 376       defer_opt (code, arg);
 377       break;
 378
 379     case OPT_Wall:
 380       set_Wunused (value);
 381       set_Wformat (value);
 382       set_Wimplicit (value);
 383       warn_char_subscripts = value;
 384       warn_missing_braces = value;
 385       warn_parentheses = value;
 386       warn_return_type = value;
 387       warn_sequence_point = value;      /* Was C only.  */
 388       if (c_dialect_cxx ())
 389         warn_sign_compare = value;
 390       warn_switch = value;
 391       warn_strict_aliasing = value;
 392       warn_string_literal_comparison = value;
 393       warn_always_true = value;
 394
 395       /* Only warn about unknown pragmas that are not in system
 396          headers.  */
 397       warn_unknown_pragmas = value;
 398
 399       /* We save the value of warn_uninitialized, since if they put
 400          -Wuninitialized on the command line, we need to generate a
 401          warning about not using it without also specifying -O.  */
 402       if (warn_uninitialized != 1)
 403         warn_uninitialized = (value ? 2 : 0);
 404
 405       if (!c_dialect_cxx ())
 406         /* We set this to 2 here, but 1 in -Wmain, so -ffreestanding
 407            can turn it off only if it's not explicit.  */
 408         warn_main = value * 2;
 409       else
 410         {
 411           /* C++-specific warnings.  */
 412           warn_nonvdtor = value;
 413           warn_reorder = value;
 414           warn_nontemplate_friend = value;
 415         }
 416
 417       cpp_opts->warn_trigraphs = value;
 418       cpp_opts->warn_comments = value;
 419       cpp_opts->warn_num_sign_change = value;
 420       cpp_opts->warn_multichar = value; /* Was C++ only.  */
 421       break;
 422
 423     case OPT_Wcomment:
 424     case OPT_Wcomments:
 425       cpp_opts->warn_comments = value;
 426       break;
 427
 428     case OPT_Wdeprecated:
 429       cpp_opts->warn_deprecated = value;
 430       break;
 431
 432     case OPT_Wdiv_by_zero:
 433       warn_div_by_zero = value;
 434       break;
 435
 436     case OPT_Wendif_labels:
 437       cpp_opts->warn_endif_labels = value;
 438       break;
 439
 440     case OPT_Werror:
 441       cpp_opts->warnings_are_errors = value;
 442       global_dc->warning_as_error_requested = value;
 443       break;
 444
 445     case OPT_Werror_implicit_function_declaration:
 446       mesg_implicit_function_declaration = 2;
 447       break;
 448
 449     case OPT_Wformat:
 450       set_Wformat (value);
 451       break;
 452
 453     case OPT_Wformat_:
 454       set_Wformat (atoi (arg));
 455       break;
 456
 457     case OPT_Wimplicit:
 458       set_Wimplicit (value);
 459       break;
 460
 461     case OPT_Wimport:
 462       /* Silently ignore for now.  */
 463       break;
 464
 465     case OPT_Winvalid_pch:
 466       cpp_opts->warn_invalid_pch = value;
 467       break;
 468
 469     case OPT_Wmain:
 470       if (value)
 471         warn_main = 1;
 472       else
 473         warn_main = -1;
 474       break;
 475
 476     case OPT_Wmissing_include_dirs:
 477       cpp_opts->warn_missing_include_dirs = value;
 478       break;
 479
 480     case OPT_Wmultichar:
 481       cpp_opts->warn_multichar = value;
 482       break;
 483
 484     case OPT_Wnormalized_:
 485       if (!value || (arg && strcasecmp (arg, "none") == 0))
 486         cpp_opts->warn_normalize = normalized_none;
 487       else if (!arg || strcasecmp (arg, "nfkc") == 0)
 488         cpp_opts->warn_normalize = normalized_KC;
 489       else if (strcasecmp (arg, "id") == 0)
 490         cpp_opts->warn_normalize = normalized_identifier_C;
 491       else if (strcasecmp (arg, "nfc") == 0)
 492         cpp_opts->warn_normalize = normalized_C;
 493       else
 494         error ("argument %qs to %<-Wnormalized%> not recognized", arg);
 495       break;
 496
 497     case OPT_Wreturn_type:
 498       warn_return_type = value;
 499       break;
 500
 501     case OPT_Wstrict_null_sentinel:
 502       warn_strict_null_sentinel = value;
 503       break;
 504
 505     case OPT_Wsystem_headers:
 506       cpp_opts->warn_system_headers = value;
 507       break;
 508
 509     case OPT_Wtraditional:
 510       cpp_opts->warn_traditional = value;
 511       break;
 512
 513     case OPT_Wtrigraphs:
 514       cpp_opts->warn_trigraphs = value;
 515       break;
 516
 517     case OPT_Wundef:
 518       cpp_opts->warn_undef = value;
 519       break;
 520
 521     case OPT_Wunknown_pragmas:
 522       /* Set to greater than 1, so that even unknown pragmas in
 523          system headers will be warned about.  */
 524       warn_unknown_pragmas = value * 2;
 525       break;
 526
 527     case OPT_Wunused_macros:
 528       warn_unused_macros = value;
 529       break;
 530
 531     case OPT_Wvariadic_macros:
 532       warn_variadic_macros = value;
 533       break;
 534
 535     case OPT_Wwrite_strings:
 536       if (!c_dialect_cxx ())
 537         flag_const_strings = value;
 538       else
 539         warn_write_strings = value;
 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_fconst_strings:
 652       flag_const_strings = value;
 653       break;
 654
 655     case OPT_fconstant_string_class_:
 656       constant_string_class_name = arg;
 657       break;
 658
 659     case OPT_fdefault_inline:
 660       flag_default_inline = value;
 661       break;
 662
 663     case OPT_felide_constructors:
 664       flag_elide_constructors = value;
 665       break;
 666
 667     case OPT_fenforce_eh_specs:
 668       flag_enforce_eh_specs = value;
 669       break;
 670
 671     case OPT_fextended_identifiers:
 672       cpp_opts->extended_identifiers = value;
 673       break;
 674
 675     case OPT_ffor_scope:
 676       flag_new_for_scope = value;
 677       break;
 678
 679     case OPT_fgnu_keywords:
 680       flag_no_gnu_keywords = !value;
 681       break;
 682
 683     case OPT_fgnu_runtime:
 684       flag_next_runtime = !value;
 685       break;
 686
 687     case OPT_fhandle_exceptions:
 688       warning (0, "-fhandle-exceptions has been renamed -fexceptions (and is now on by default)");
 689       flag_exceptions = value;
 690       break;
 691
 692     case OPT_fimplement_inlines:
 693       flag_implement_inlines = value;
 694       break;
 695
 696     case OPT_fimplicit_inline_templates:
 697       flag_implicit_inline_templates = value;
 698       break;
 699
 700     case OPT_fimplicit_templates:
 701       flag_implicit_templates = value;
 702       break;
 703
 704     case OPT_fms_extensions:
 705       flag_ms_extensions = value;
 706       break;
 707
 708     case OPT_fnext_runtime:
 709       flag_next_runtime = value;
 710       break;
 711
 712     case OPT_fnil_receivers:
 713       flag_nil_receivers = value;
 714       break;
 715
 716     case OPT_fnonansi_builtins:
 717       flag_no_nonansi_builtin = !value;
 718       break;
 719
 720     case OPT_foperator_names:
 721       cpp_opts->operator_names = value;
 722       break;
 723
 724     case OPT_foptional_diags:
 725       flag_optional_diags = value;
 726       break;
 727
 728     case OPT_fpch_deps:
 729       cpp_opts->restore_pch_deps = value;
 730       break;
 731
 732     case OPT_fpch_preprocess:
 733       flag_pch_preprocess = value;
 734       break;
 735
 736     case OPT_fpermissive:
 737       flag_permissive = value;
 738       break;
 739
 740     case OPT_fpreprocessed:
 741       cpp_opts->preprocessed = value;
 742       break;
 743
 744     case OPT_freplace_objc_classes:
 745       flag_replace_objc_classes = value;
 746       break;
 747
 748     case OPT_frepo:
 749       flag_use_repository = value;
 750       if (value)
 751         flag_implicit_templates = 0;
 752       break;
 753
 754     case OPT_frtti:
 755       flag_rtti = value;
 756       break;
 757
 758     case OPT_fshow_column:
 759       cpp_opts->show_column = value;
 760       break;
 761
 762     case OPT_fstats:
 763       flag_detailed_statistics = value;
 764       break;
 765
 766     case OPT_ftabstop_:
 767       /* It is documented that we silently ignore silly values.  */
 768       if (value >= 1 && value <= 100)
 769         cpp_opts->tabstop = value;
 770       break;
 771
 772     case OPT_fexec_charset_:
 773       cpp_opts->narrow_charset = arg;
 774       break;
 775
 776     case OPT_fwide_exec_charset_:
 777       cpp_opts->wide_charset = arg;
 778       break;
 779
 780     case OPT_finput_charset_:
 781       cpp_opts->input_charset = arg;
 782       break;
 783
 784     case OPT_ftemplate_depth_:
 785       max_tinst_depth = value;
 786       break;
 787
 788     case OPT_fuse_cxa_atexit:
 789       flag_use_cxa_atexit = value;
 790       break;
 791
 792     case OPT_fvisibility_inlines_hidden:
 793       visibility_options.inlines_hidden = value;
 794       break;
 795
 796     case OPT_fweak:
 797       flag_weak = value;
 798       break;
 799
 800     case OPT_fthreadsafe_statics:
 801       flag_threadsafe_statics = value;
 802       break;
 803
 804     case OPT_fzero_link:
 805       flag_zero_link = value;
 806       break;
 807
 808     case OPT_gen_decls:
 809       flag_gen_declaration = 1;
 810       break;
 811
 812     case OPT_idirafter:
 813       add_path (xstrdup (arg), AFTER, 0, true);
 814       break;
 815
 816     case OPT_imacros:
 817     case OPT_include:
 818       defer_opt (code, arg);
 819       break;
 820
 821     case OPT_imultilib:
 822       imultilib = arg;
 823       break;
 824
 825     case OPT_iprefix:
 826       iprefix = arg;
 827       break;
 828
 829     case OPT_iquote:
 830       add_path (xstrdup (arg), QUOTE, 0, true);
 831       break;
 832
 833     case OPT_isysroot:
 834       sysroot = arg;
 835       break;
 836
 837     case OPT_isystem:
 838       add_path (xstrdup (arg), SYSTEM, 0, true);
 839       break;
 840
 841     case OPT_iwithprefix:
 842       add_prefixed_path (arg, SYSTEM);
 843       break;
 844
 845     case OPT_iwithprefixbefore:
 846       add_prefixed_path (arg, BRACKET);
 847       break;
 848
 849     case OPT_lang_asm:
 850       cpp_set_lang (parse_in, CLK_ASM);
 851       cpp_opts->dollars_in_ident = false;
 852       break;
 853
 854     case OPT_lang_fortran:
 855       lang_fortran = true;
 856       break;
 857
 858     case OPT_lang_objc:
 859       cpp_opts->objc = 1;
 860       break;
 861
 862     case OPT_nostdinc:
 863       std_inc = false;
 864       break;
 865
 866     case OPT_nostdinc__:
 867       std_cxx_inc = false;
 868       break;
 869
 870     case OPT_o:
 871       if (!out_fname)
 872         out_fname = arg;
 873       else
 874         error ("output filename specified twice");
 875       break;
 876
 877       /* We need to handle the -pedantic switches here, rather than in
 878          c_common_post_options, so that a subsequent -Wno-endif-labels
 879          is not overridden.  */
 880     case OPT_pedantic_errors:
 881       cpp_opts->pedantic_errors = 1;
 882       /* Fall through.  */
 883     case OPT_pedantic:
 884       cpp_opts->pedantic = 1;
 885       cpp_opts->warn_endif_labels = 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   /* Special format checking options don't work without -Wformat; warn if
1007      they are used.  */
1008   if (!warn_format)
1009     {
1010       warning (OPT_Wformat_y2k,
1011                "-Wformat-y2k ignored without -Wformat");
1012       warning (OPT_Wformat_extra_args,
1013                "-Wformat-extra-args ignored without -Wformat");
1014       warning (OPT_Wformat_zero_length,
1015                "-Wformat-zero-length ignored without -Wformat");
1016       warning (OPT_Wformat_nonliteral,
1017                "-Wformat-nonliteral ignored without -Wformat");
1018       warning (OPT_Wformat_security,
1019                "-Wformat-security ignored without -Wformat");
1020     }
1021
1022   /* C99 requires special handling of complex multiplication and division;
1023      -ffast-math and -fcx-limited-range are handled in process_options.  */
1024   if (flag_isoc99)
1025     flag_complex_method = 2;
1026
1027   if (flag_preprocess_only)
1028     {
1029       /* Open the output now.  We must do so even if flag_no_output is
1030          on, because there may be other output than from the actual
1031          preprocessing (e.g. from -dM).  */
1032       if (out_fname[0] == '\0')
1033         out_stream = stdout;
1034       else
1035         out_stream = fopen (out_fname, "w");
1036
1037       if (out_stream == NULL)
1038         {
1039           fatal_error ("opening output file %s: %m", out_fname);
1040           return false;
1041         }
1042
1043       if (num_in_fnames > 1)
1044         error ("too many filenames given.  Type %s --help for usage",
1045                progname);
1046
1047       init_pp_output (out_stream);
1048     }
1049   else
1050     {
1051       init_c_lex ();
1052
1053       /* Yuk.  WTF is this?  I do know ObjC relies on it somewhere.  */
1054       input_location = UNKNOWN_LOCATION;
1055     }
1056
1057   cb = cpp_get_callbacks (parse_in);
1058   cb->file_change = cb_file_change;
1059   cb->dir_change = cb_dir_change;
1060   cpp_post_options (parse_in);
1061
1062   input_location = UNKNOWN_LOCATION;
1063
1064   /* If an error has occurred in cpplib, note it so we fail
1065      immediately.  */
1066   errorcount += cpp_errors (parse_in);
1067
1068   *pfilename = this_input_filename
1069     = cpp_read_main_file (parse_in, in_fnames[0]);
1070   /* Don't do any compilation or preprocessing if there is no input file.  */
1071   if (this_input_filename == NULL)
1072     {
1073       errorcount++;
1074       return false;
1075     }
1076
1077   if (flag_working_directory
1078       && flag_preprocess_only && !flag_no_line_commands)
1079     pp_dir_change (parse_in, get_src_pwd ());
1080
1081   return flag_preprocess_only;
1082 }
1083
1084 /* Front end initialization common to C, ObjC and C++.  */
1085 bool
1086 c_common_init (void)
1087 {
1088   /* Set up preprocessor arithmetic.  Must be done after call to
1089      c_common_nodes_and_builtins for type nodes to be good.  */
1090   cpp_opts->precision = TYPE_PRECISION (intmax_type_node);
1091   cpp_opts->char_precision = TYPE_PRECISION (char_type_node);
1092   cpp_opts->int_precision = TYPE_PRECISION (integer_type_node);
1093   cpp_opts->wchar_precision = TYPE_PRECISION (wchar_type_node);
1094   cpp_opts->unsigned_wchar = TYPE_UNSIGNED (wchar_type_node);
1095   cpp_opts->bytes_big_endian = BYTES_BIG_ENDIAN;
1096
1097   /* This can't happen until after wchar_precision and bytes_big_endian
1098      are known.  */
1099   cpp_init_iconv (parse_in);
1100
1101   if (version_flag)
1102     c_common_print_pch_checksum (stderr);
1103
1104   if (flag_preprocess_only)
1105     {
1106       finish_options ();
1107       preprocess_file (parse_in);
1108       return false;
1109     }
1110
1111   /* Has to wait until now so that cpplib has its hash table.  */
1112   init_pragma ();
1113
1114   return true;
1115 }
1116
1117 /* Initialize the integrated preprocessor after debug output has been
1118    initialized; loop over each input file.  */
1119 void
1120 c_common_parse_file (int set_yydebug)
1121 {
1122   unsigned int i;
1123
1124   /* Enable parser debugging, if requested and we can.  If requested
1125      and we can't, notify the user.  */
1126 #if YYDEBUG != 0
1127   yydebug = set_yydebug;
1128 #else
1129   if (set_yydebug)
1130     warning (0, "YYDEBUG was not defined at build time, -dy ignored");
1131 #endif
1132
1133   i = 0;
1134   for (;;)
1135     {
1136       /* Start the main input file, if the debug writer wants it. */
1137       if (debug_hooks->start_end_main_source_file)
1138         (*debug_hooks->start_source_file) (0, this_input_filename);
1139       finish_options ();
1140       pch_init ();
1141       push_file_scope ();
1142       c_parse_file ();
1143       finish_file ();
1144       pop_file_scope ();
1145       /* And end the main input file, if the debug writer wants it  */
1146       if (debug_hooks->start_end_main_source_file)
1147         (*debug_hooks->end_source_file) (0);
1148       if (++i >= num_in_fnames)
1149         break;
1150       cpp_undef_all (parse_in);
1151       this_input_filename
1152         = cpp_read_main_file (parse_in, in_fnames[i]);
1153       /* If an input file is missing, abandon further compilation.
1154          cpplib has issued a diagnostic.  */
1155       if (!this_input_filename)
1156         break;
1157     }
1158 }
1159
1160 /* Common finish hook for the C, ObjC and C++ front ends.  */
1161 void
1162 c_common_finish (void)
1163 {
1164   FILE *deps_stream = NULL;
1165
1166   if (cpp_opts->deps.style != DEPS_NONE)
1167     {
1168       /* If -M or -MM was seen without -MF, default output to the
1169          output stream.  */
1170       if (!deps_file)
1171         deps_stream = out_stream;
1172       else
1173         {
1174           deps_stream = fopen (deps_file, deps_append ? "a": "w");
1175           if (!deps_stream)
1176             fatal_error ("opening dependency file %s: %m", deps_file);
1177         }
1178     }
1179
1180   /* For performance, avoid tearing down cpplib's internal structures
1181      with cpp_destroy ().  */
1182   errorcount += cpp_finish (parse_in, deps_stream);
1183
1184   if (deps_stream && deps_stream != out_stream
1185       && (ferror (deps_stream) || fclose (deps_stream)))
1186     fatal_error ("closing dependency file %s: %m", deps_file);
1187
1188   if (out_stream && (ferror (out_stream) || fclose (out_stream)))
1189     fatal_error ("when writing output to %s: %m", out_fname);
1190 }
1191
1192 /* Either of two environment variables can specify output of
1193    dependencies.  Their value is either "OUTPUT_FILE" or "OUTPUT_FILE
1194    DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to
1195    and DEPS_TARGET is the target to mention in the deps.  They also
1196    result in dependency information being appended to the output file
1197    rather than overwriting it, and like Sun's compiler
1198    SUNPRO_DEPENDENCIES suppresses the dependency on the main file.  */
1199 static void
1200 check_deps_environment_vars (void)
1201 {
1202   char *spec;
1203
1204   GET_ENVIRONMENT (spec, "DEPENDENCIES_OUTPUT");
1205   if (spec)
1206     cpp_opts->deps.style = DEPS_USER;
1207   else
1208     {
1209       GET_ENVIRONMENT (spec, "SUNPRO_DEPENDENCIES");
1210       if (spec)
1211         {
1212           cpp_opts->deps.style = DEPS_SYSTEM;
1213           cpp_opts->deps.ignore_main_file = true;
1214         }
1215     }
1216
1217   if (spec)
1218     {
1219       /* Find the space before the DEPS_TARGET, if there is one.  */
1220       char *s = strchr (spec, ' ');
1221       if (s)
1222         {
1223           /* Let the caller perform MAKE quoting.  */
1224           defer_opt (OPT_MT, s + 1);
1225           *s = '\0';
1226         }
1227
1228       /* Command line -MF overrides environment variables and default.  */
1229       if (!deps_file)
1230         deps_file = spec;
1231
1232       deps_append = 1;
1233       deps_seen = true;
1234     }
1235 }
1236
1237 /* Handle deferred command line switches.  */
1238 static void
1239 handle_deferred_opts (void)
1240 {
1241   size_t i;
1242   struct deps *deps;
1243
1244   /* Avoid allocating the deps buffer if we don't need it.
1245      (This flag may be true without there having been -MT or -MQ
1246      options, but we'll still need the deps buffer.)  */
1247   if (!deps_seen)
1248     return;
1249
1250   deps = cpp_get_deps (parse_in);
1251
1252   for (i = 0; i < deferred_count; i++)
1253     {
1254       struct deferred_opt *opt = &deferred_opts[i];
1255
1256       if (opt->code == OPT_MT || opt->code == OPT_MQ)
1257         deps_add_target (deps, opt->arg, opt->code == OPT_MQ);
1258     }
1259 }
1260
1261 /* These settings are appropriate for GCC, but not necessarily so for
1262    cpplib as a library.  */
1263 static void
1264 sanitize_cpp_opts (void)
1265 {
1266   /* If we don't know what style of dependencies to output, complain
1267      if any other dependency switches have been given.  */
1268   if (deps_seen && cpp_opts->deps.style == DEPS_NONE)
1269     error ("to generate dependencies you must specify either -M or -MM");
1270
1271   /* -dM and dependencies suppress normal output; do it here so that
1272      the last -d[MDN] switch overrides earlier ones.  */
1273   if (flag_dump_macros == 'M')
1274     flag_no_output = 1;
1275
1276   /* Disable -dD, -dN and -dI if normal output is suppressed.  Allow
1277      -dM since at least glibc relies on -M -dM to work.  */
1278   /* Also, flag_no_output implies flag_no_line_commands, always.  */
1279   if (flag_no_output)
1280     {
1281       if (flag_dump_macros != 'M')
1282         flag_dump_macros = 0;
1283       flag_dump_includes = 0;
1284       flag_no_line_commands = 1;
1285     }
1286
1287   cpp_opts->unsigned_char = !flag_signed_char;
1288   cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS;
1289
1290   /* We want -Wno-long-long to override -pedantic -std=non-c99
1291      and/or -Wtraditional, whatever the ordering.  */
1292   cpp_opts->warn_long_long
1293     = warn_long_long && ((!flag_isoc99 && pedantic) || warn_traditional);
1294
1295   /* Similarly with -Wno-variadic-macros.  No check for c99 here, since
1296      this also turns off warnings about GCCs extension.  */
1297   cpp_opts->warn_variadic_macros
1298     = warn_variadic_macros && (pedantic || warn_traditional);
1299
1300   /* If we're generating preprocessor output, emit current directory
1301      if explicitly requested or if debugging information is enabled.
1302      ??? Maybe we should only do it for debugging formats that
1303      actually output the current directory?  */
1304   if (flag_working_directory == -1)
1305     flag_working_directory = (debug_info_level != DINFO_LEVEL_NONE);
1306 }
1307
1308 /* Add include path with a prefix at the front of its name.  */
1309 static void
1310 add_prefixed_path (const char *suffix, size_t chain)
1311 {
1312   char *path;
1313   const char *prefix;
1314   size_t prefix_len, suffix_len;
1315
1316   suffix_len = strlen (suffix);
1317   prefix     = iprefix ? iprefix : cpp_GCC_INCLUDE_DIR;
1318   prefix_len = iprefix ? strlen (iprefix) : cpp_GCC_INCLUDE_DIR_len;
1319
1320   path = (char *) xmalloc (prefix_len + suffix_len + 1);
1321   memcpy (path, prefix, prefix_len);
1322   memcpy (path + prefix_len, suffix, suffix_len);
1323   path[prefix_len + suffix_len] = '\0';
1324
1325   add_path (path, chain, 0, false);
1326 }
1327
1328 /* Handle -D, -U, -A, -imacros, and the first -include.  */
1329 static void
1330 finish_options (void)
1331 {
1332   if (!cpp_opts->preprocessed)
1333     {
1334       size_t i;
1335
1336       cb_file_change (parse_in,
1337                       linemap_add (&line_table, LC_RENAME, 0,
1338                                    _("<built-in>"), 0));
1339
1340       cpp_init_builtins (parse_in, flag_hosted);
1341       c_cpp_builtins (parse_in);
1342
1343       /* We're about to send user input to cpplib, so make it warn for
1344          things that we previously (when we sent it internal definitions)
1345          told it to not warn.
1346
1347          C99 permits implementation-defined characters in identifiers.
1348          The documented meaning of -std= is to turn off extensions that
1349          conflict with the specified standard, and since a strictly
1350          conforming program cannot contain a '$', we do not condition
1351          their acceptance on the -std= setting.  */
1352       cpp_opts->warn_dollars = (cpp_opts->pedantic && !cpp_opts->c99);
1353
1354       cpp_change_file (parse_in, LC_RENAME, _("<command line>"));
1355       for (i = 0; i < deferred_count; i++)
1356         {
1357           struct deferred_opt *opt = &deferred_opts[i];
1358
1359           if (opt->code == OPT_D)
1360             cpp_define (parse_in, opt->arg);
1361           else if (opt->code == OPT_U)
1362             cpp_undef (parse_in, opt->arg);
1363           else if (opt->code == OPT_A)
1364             {
1365               if (opt->arg[0] == '-')
1366                 cpp_unassert (parse_in, opt->arg + 1);
1367               else
1368                 cpp_assert (parse_in, opt->arg);
1369             }
1370         }
1371
1372       /* Handle -imacros after -D and -U.  */
1373       for (i = 0; i < deferred_count; i++)
1374         {
1375           struct deferred_opt *opt = &deferred_opts[i];
1376
1377           if (opt->code == OPT_imacros
1378               && cpp_push_include (parse_in, opt->arg))
1379             {
1380               /* Disable push_command_line_include callback for now.  */
1381               include_cursor = deferred_count + 1;
1382               cpp_scan_nooutput (parse_in);
1383             }
1384         }
1385     }
1386
1387   include_cursor = 0;
1388   push_command_line_include ();
1389 }
1390
1391 /* Give CPP the next file given by -include, if any.  */
1392 static void
1393 push_command_line_include (void)
1394 {
1395   while (include_cursor < deferred_count)
1396     {
1397       struct deferred_opt *opt = &deferred_opts[include_cursor++];
1398
1399       if (!cpp_opts->preprocessed && opt->code == OPT_include
1400           && cpp_push_include (parse_in, opt->arg))
1401         return;
1402     }
1403
1404   if (include_cursor == deferred_count)
1405     {
1406       include_cursor++;
1407       /* -Wunused-macros should only warn about macros defined hereafter.  */
1408       cpp_opts->warn_unused_macros = warn_unused_macros;
1409       /* Restore the line map from <command line>.  */
1410       if (!cpp_opts->preprocessed)
1411         cpp_change_file (parse_in, LC_RENAME, this_input_filename);
1412
1413       /* Set this here so the client can change the option if it wishes,
1414          and after stacking the main file so we don't trace the main file.  */
1415       line_table.trace_includes = cpp_opts->print_include_names;
1416     }
1417 }
1418
1419 /* File change callback.  Has to handle -include files.  */
1420 static void
1421 cb_file_change (cpp_reader * ARG_UNUSED (pfile),
1422                 const struct line_map *new_map)
1423 {
1424   if (flag_preprocess_only)
1425     pp_file_change (new_map);
1426   else
1427     fe_file_change (new_map);
1428
1429   if (new_map == 0 || (new_map->reason == LC_LEAVE && MAIN_FILE_P (new_map)))
1430     push_command_line_include ();
1431 }
1432
1433 void
1434 cb_dir_change (cpp_reader * ARG_UNUSED (pfile), const char *dir)
1435 {
1436   if (!set_src_pwd (dir))
1437     warning (0, "too late for # directive to set debug directory");
1438 }
1439
1440 /* Set the C 89 standard (with 1994 amendments if C94, without GNU
1441    extensions if ISO).  There is no concept of gnu94.  */
1442 static void
1443 set_std_c89 (int c94, int iso)
1444 {
1445   cpp_set_lang (parse_in, c94 ? CLK_STDC94: iso ? CLK_STDC89: CLK_GNUC89);
1446   flag_iso = iso;
1447   flag_no_asm = iso;
1448   flag_no_gnu_keywords = iso;
1449   flag_no_nonansi_builtin = iso;
1450   flag_isoc94 = c94;
1451   flag_isoc99 = 0;
1452 }
1453
1454 /* Set the C 99 standard (without GNU extensions if ISO).  */
1455 static void
1456 set_std_c99 (int iso)
1457 {
1458   cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99);
1459   flag_no_asm = iso;
1460   flag_no_nonansi_builtin = iso;
1461   flag_iso = iso;
1462   flag_isoc99 = 1;
1463   flag_isoc94 = 1;
1464 }
1465
1466 /* Set the C++ 98 standard (without GNU extensions if ISO).  */
1467 static void
1468 set_std_cxx98 (int iso)
1469 {
1470   cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX);
1471   flag_no_gnu_keywords = iso;
1472   flag_no_nonansi_builtin = iso;
1473   flag_iso = iso;
1474 }
1475
1476 /* Handle setting implicit to ON.  */
1477 static void
1478 set_Wimplicit (int on)
1479 {
1480   warn_implicit = on;
1481   warn_implicit_int = on;
1482   if (on)
1483     {
1484       if (mesg_implicit_function_declaration != 2)
1485         mesg_implicit_function_declaration = 1;
1486     }
1487   else
1488     mesg_implicit_function_declaration = 0;
1489 }
1490
1491 /* Args to -d specify what to dump.  Silently ignore
1492    unrecognized options; they may be aimed at toplev.c.  */
1493 static void
1494 handle_OPT_d (const char *arg)
1495 {
1496   char c;
1497
1498   while ((c = *arg++) != '\0')
1499     switch (c)
1500       {
1501       case 'M':                 /* Dump macros only.  */
1502       case 'N':                 /* Dump names.  */
1503       case 'D':                 /* Dump definitions.  */
1504         flag_dump_macros = c;
1505         break;
1506
1507       case 'I':
1508         flag_dump_includes = 1;
1509         break;
1510       }
1511 }