gcc/c-opts.c

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