gcc/c-opts.c

   1 /* C/ObjC/C++ command line option handling.
   2    Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
   3    Contributed by Neil Booth.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "tree.h"
  27 #include "c-common.h"
  28 #include "c-pragma.h"
  29 #include "flags.h"
  30 #include "toplev.h"
  31 #include "langhooks.h"
  32 #include "tree-inline.h"
  33 #include "diagnostic.h"
  34 #include "intl.h"
  35 #include "cppdefault.h"
  36 #include "c-incpath.h"
  37 #include "debug.h"              /* For debug_hooks.  */
  38 #include "opts.h"
  39 #include "options.h"
  40 #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_Wreturn_type:
 464       warn_return_type = value;
 465       break;
 466
 467     case OPT_Wsystem_headers:
 468       cpp_opts->warn_system_headers = value;
 469       break;
 470
 471     case OPT_Wtraditional:
 472       cpp_opts->warn_traditional = value;
 473       break;
 474
 475     case OPT_Wtrigraphs:
 476       cpp_opts->warn_trigraphs = value;
 477       break;
 478
 479     case OPT_Wundef:
 480       cpp_opts->warn_undef = value;
 481       break;
 482
 483     case OPT_Wunknown_pragmas:
 484       /* Set to greater than 1, so that even unknown pragmas in
 485          system headers will be warned about.  */
 486       warn_unknown_pragmas = value * 2;
 487       break;
 488
 489     case OPT_Wunused_macros:
 490       warn_unused_macros = value;
 491       break;
 492
 493     case OPT_Wvariadic_macros:
 494       warn_variadic_macros = value;
 495       break;
 496
 497     case OPT_Wwrite_strings:
 498       if (!c_dialect_cxx ())
 499         flag_const_strings = value;
 500       else
 501         warn_write_strings = value;
 502       break;
 503
 504     case OPT_ansi:
 505       if (!c_dialect_cxx ())
 506         set_std_c89 (false, true);
 507       else
 508         set_std_cxx98 (true);
 509       break;
 510
 511     case OPT_d:
 512       handle_OPT_d (arg);
 513       break;
 514
 515     case OPT_fcond_mismatch:
 516       if (!c_dialect_cxx ())
 517         {
 518           flag_cond_mismatch = value;
 519           break;
 520         }
 521       /* Fall through.  */
 522
 523     case OPT_fall_virtual:
 524     case OPT_falt_external_templates:
 525     case OPT_fenum_int_equiv:
 526     case OPT_fexternal_templates:
 527     case OPT_fguiding_decls:
 528     case OPT_fhonor_std:
 529     case OPT_fhuge_objects:
 530     case OPT_flabels_ok:
 531     case OPT_fname_mangling_version_:
 532     case OPT_fnew_abi:
 533     case OPT_fnonnull_objects:
 534     case OPT_fsquangle:
 535     case OPT_fstrict_prototype:
 536     case OPT_fthis_is_variable:
 537     case OPT_fvtable_thunks:
 538     case OPT_fxref:
 539     case OPT_fvtable_gc:
 540       warning ("switch %qs is no longer supported", option->opt_text);
 541       break;
 542
 543     case OPT_faccess_control:
 544       flag_access_control = value;
 545       break;
 546
 547     case OPT_fasm:
 548       flag_no_asm = !value;
 549       break;
 550
 551     case OPT_fbuiltin:
 552       flag_no_builtin = !value;
 553       break;
 554
 555     case OPT_fbuiltin_:
 556       if (value)
 557         result = 0;
 558       else
 559         disable_builtin_function (arg);
 560       break;
 561
 562     case OPT_fdollars_in_identifiers:
 563       cpp_opts->dollars_in_ident = value;
 564       break;
 565
 566     case OPT_ffreestanding:
 567       value = !value;
 568       /* Fall through....  */
 569     case OPT_fhosted:
 570       flag_hosted = value;
 571       flag_no_builtin = !value;
 572       /* warn_main will be 2 if set by -Wall, 1 if set by -Wmain */
 573       if (!value && warn_main == 2)
 574         warn_main = 0;
 575       break;
 576
 577     case OPT_fshort_double:
 578       flag_short_double = value;
 579       break;
 580
 581     case OPT_fshort_enums:
 582       flag_short_enums = value;
 583       break;
 584
 585     case OPT_fshort_wchar:
 586       flag_short_wchar = value;
 587       break;
 588
 589     case OPT_fsigned_bitfields:
 590       flag_signed_bitfields = value;
 591       explicit_flag_signed_bitfields = 1;
 592       break;
 593
 594     case OPT_fsigned_char:
 595       flag_signed_char = value;
 596       break;
 597
 598     case OPT_funsigned_bitfields:
 599       flag_signed_bitfields = !value;
 600       explicit_flag_signed_bitfields = 1;
 601       break;
 602
 603     case OPT_funsigned_char:
 604       flag_signed_char = !value;
 605       break;
 606
 607     case OPT_fcheck_new:
 608       flag_check_new = value;
 609       break;
 610
 611     case OPT_fconserve_space:
 612       flag_conserve_space = value;
 613       break;
 614
 615     case OPT_fconst_strings:
 616       flag_const_strings = value;
 617       break;
 618
 619     case OPT_fconstant_string_class_:
 620       constant_string_class_name = arg;
 621       break;
 622
 623     case OPT_fdefault_inline:
 624       flag_default_inline = value;
 625       break;
 626
 627     case OPT_felide_constructors:
 628       flag_elide_constructors = value;
 629       break;
 630
 631     case OPT_fenforce_eh_specs:
 632       flag_enforce_eh_specs = value;
 633       break;
 634
 635     case OPT_ffixed_form:
 636     case OPT_ffixed_line_length_:
 637       /* Fortran front end options ignored when preprocessing only.  */
 638       if (!flag_preprocess_only)
 639         result = 0;
 640       break;
 641
 642     case OPT_ffor_scope:
 643       flag_new_for_scope = value;
 644       break;
 645
 646     case OPT_fgnu_keywords:
 647       flag_no_gnu_keywords = !value;
 648       break;
 649
 650     case OPT_fgnu_runtime:
 651       flag_next_runtime = !value;
 652       break;
 653
 654     case OPT_fhandle_exceptions:
 655       warning ("-fhandle-exceptions has been renamed -fexceptions (and is now on by default)");
 656       flag_exceptions = value;
 657       break;
 658
 659     case OPT_fimplement_inlines:
 660       flag_implement_inlines = value;
 661       break;
 662
 663     case OPT_fimplicit_inline_templates:
 664       flag_implicit_inline_templates = value;
 665       break;
 666
 667     case OPT_fimplicit_templates:
 668       flag_implicit_templates = value;
 669       break;
 670
 671     case OPT_fms_extensions:
 672       flag_ms_extensions = value;
 673       break;
 674
 675     case OPT_fnext_runtime:
 676       flag_next_runtime = value;
 677       break;
 678
 679     case OPT_fnil_receivers:
 680       flag_nil_receivers = value;
 681       break;
 682
 683     case OPT_fnonansi_builtins:
 684       flag_no_nonansi_builtin = !value;
 685       break;
 686
 687     case OPT_fobjc_exceptions:
 688       flag_objc_exceptions = value;
 689       break;
 690
 691     case OPT_fobjc_sjlj_exceptions:
 692       flag_objc_sjlj_exceptions = value;
 693       break;
 694
 695     case OPT_foperator_names:
 696       cpp_opts->operator_names = value;
 697       break;
 698
 699     case OPT_foptional_diags:
 700       flag_optional_diags = value;
 701       break;
 702
 703     case OPT_fpch_deps:
 704       cpp_opts->restore_pch_deps = value;
 705       break;
 706
 707     case OPT_fpch_preprocess:
 708       flag_pch_preprocess = value;
 709       break;
 710
 711     case OPT_fpermissive:
 712       flag_permissive = value;
 713       break;
 714
 715     case OPT_fpreprocessed:
 716       cpp_opts->preprocessed = value;
 717       break;
 718
 719     case OPT_freplace_objc_classes:
 720       flag_replace_objc_classes = value;
 721       break;
 722
 723     case OPT_frepo:
 724       flag_use_repository = value;
 725       if (value)
 726         flag_implicit_templates = 0;
 727       break;
 728
 729     case OPT_frtti:
 730       flag_rtti = value;
 731       break;
 732
 733     case OPT_fshow_column:
 734       cpp_opts->show_column = value;
 735       break;
 736
 737     case OPT_fstats:
 738       flag_detailed_statistics = value;
 739       break;
 740
 741     case OPT_ftabstop_:
 742       /* It is documented that we silently ignore silly values.  */
 743       if (value >= 1 && value <= 100)
 744         cpp_opts->tabstop = value;
 745       break;
 746
 747     case OPT_fexec_charset_:
 748       cpp_opts->narrow_charset = arg;
 749       break;
 750
 751     case OPT_fwide_exec_charset_:
 752       cpp_opts->wide_charset = arg;
 753       break;
 754
 755     case OPT_finput_charset_:
 756       cpp_opts->input_charset = arg;
 757       break;
 758
 759     case OPT_ftemplate_depth_:
 760       max_tinst_depth = value;
 761       break;
 762
 763     case OPT_fuse_cxa_atexit:
 764       flag_use_cxa_atexit = value;
 765       break;
 766
 767     case OPT_fvisibility_inlines_hidden:
 768       visibility_options.inlines_hidden = value;
 769       break;
 770
 771     case OPT_fweak:
 772       flag_weak = value;
 773       break;
 774
 775     case OPT_fthreadsafe_statics:
 776       flag_threadsafe_statics = value;
 777       break;
 778
 779     case OPT_fzero_link:
 780       flag_zero_link = value;
 781       break;
 782
 783     case OPT_gen_decls:
 784       flag_gen_declaration = 1;
 785       break;
 786
 787     case OPT_idirafter:
 788       add_path (xstrdup (arg), AFTER, 0, true);
 789       break;
 790
 791     case OPT_imacros:
 792     case OPT_include:
 793       defer_opt (code, arg);
 794       break;
 795
 796     case OPT_iprefix:
 797       iprefix = arg;
 798       break;
 799
 800     case OPT_iquote:
 801       add_path (xstrdup (arg), QUOTE, 0, true);
 802       break;
 803
 804     case OPT_isysroot:
 805       sysroot = arg;
 806       break;
 807
 808     case OPT_isystem:
 809       add_path (xstrdup (arg), SYSTEM, 0, true);
 810       break;
 811
 812     case OPT_iwithprefix:
 813       add_prefixed_path (arg, SYSTEM);
 814       break;
 815
 816     case OPT_iwithprefixbefore:
 817       add_prefixed_path (arg, BRACKET);
 818       break;
 819
 820     case OPT_lang_asm:
 821       cpp_set_lang (parse_in, CLK_ASM);
 822       cpp_opts->dollars_in_ident = false;
 823       break;
 824
 825     case OPT_lang_objc:
 826       cpp_opts->objc = 1;
 827       break;
 828
 829     case OPT_nostdinc:
 830       std_inc = false;
 831       break;
 832
 833     case OPT_nostdinc__:
 834       std_cxx_inc = false;
 835       break;
 836
 837     case OPT_o:
 838       if (!out_fname)
 839         out_fname = arg;
 840       else
 841         error ("output filename specified twice");
 842       break;
 843
 844       /* We need to handle the -pedantic switches here, rather than in
 845          c_common_post_options, so that a subsequent -Wno-endif-labels
 846          is not overridden.  */
 847     case OPT_pedantic_errors:
 848       cpp_opts->pedantic_errors = 1;
 849       /* Fall through.  */
 850     case OPT_pedantic:
 851       cpp_opts->pedantic = 1;
 852       cpp_opts->warn_endif_labels = 1;
 853       break;
 854
 855     case OPT_print_objc_runtime_info:
 856       print_struct_values = 1;
 857       break;
 858
 859     case OPT_remap:
 860       cpp_opts->remap = 1;
 861       break;
 862
 863     case OPT_std_c__98:
 864     case OPT_std_gnu__98:
 865       set_std_cxx98 (code == OPT_std_c__98 /* ISO */);
 866       break;
 867
 868     case OPT_std_c89:
 869     case OPT_std_iso9899_1990:
 870     case OPT_std_iso9899_199409:
 871       set_std_c89 (code == OPT_std_iso9899_199409 /* c94 */, true /* ISO */);
 872       break;
 873
 874     case OPT_std_gnu89:
 875       set_std_c89 (false /* c94 */, false /* ISO */);
 876       break;
 877
 878     case OPT_std_c99:
 879     case OPT_std_c9x:
 880     case OPT_std_iso9899_1999:
 881     case OPT_std_iso9899_199x:
 882       set_std_c99 (true /* ISO */);
 883       break;
 884
 885     case OPT_std_gnu99:
 886     case OPT_std_gnu9x:
 887       set_std_c99 (false /* ISO */);
 888       break;
 889
 890     case OPT_trigraphs:
 891       cpp_opts->trigraphs = 1;
 892       break;
 893
 894     case OPT_traditional_cpp:
 895       cpp_opts->traditional = 1;
 896       break;
 897
 898     case OPT_undef:
 899       flag_undef = 1;
 900       break;
 901
 902     case OPT_w:
 903       cpp_opts->inhibit_warnings = 1;
 904       break;
 905
 906     case OPT_v:
 907       verbose = true;
 908       break;
 909     }
 910
 911   return result;
 912 }
 913
 914 /* Post-switch processing.  */
 915 bool
 916 c_common_post_options (const char **pfilename)
 917 {
 918   struct cpp_callbacks *cb;
 919
 920   /* Canonicalize the input and output filenames.  */
 921   if (in_fnames == NULL)
 922     {
 923       in_fnames = XNEWVEC (const char *, 1);
 924       in_fnames[0] = "";
 925     }
 926   else if (strcmp (in_fnames[0], "-") == 0)
 927     in_fnames[0] = "";
 928
 929   if (out_fname == NULL || !strcmp (out_fname, "-"))
 930     out_fname = "";
 931
 932   if (cpp_opts->deps.style == DEPS_NONE)
 933     check_deps_environment_vars ();
 934
 935   handle_deferred_opts ();
 936
 937   sanitize_cpp_opts ();
 938
 939   register_include_chains (parse_in, sysroot, iprefix,
 940                            std_inc, std_cxx_inc && c_dialect_cxx (), verbose);
 941
 942   flag_inline_trees = 1;
 943
 944   /* Use tree inlining.  */
 945   if (!flag_no_inline)
 946     flag_no_inline = 1;
 947   if (flag_inline_functions)
 948     flag_inline_trees = 2;
 949
 950   /* If we are given more than one input file, we must use
 951      unit-at-a-time mode.  */
 952   if (num_in_fnames > 1)
 953     flag_unit_at_a_time = 1;
 954
 955   /* Default to ObjC sjlj exception handling if NeXT runtime.  */
 956   if (flag_objc_sjlj_exceptions < 0)
 957     flag_objc_sjlj_exceptions = flag_next_runtime;
 958   if (flag_objc_exceptions && !flag_objc_sjlj_exceptions)
 959     flag_exceptions = 1;
 960
 961   /* -Wextra implies -Wsign-compare and -Wmissing-field-initializers,
 962      but not if explicitly overridden.  */
 963   if (warn_sign_compare == -1)
 964     warn_sign_compare = extra_warnings;
 965   if (warn_missing_field_initializers == -1)
 966     warn_missing_field_initializers = extra_warnings;
 967
 968   /* Special format checking options don't work without -Wformat; warn if
 969      they are used.  */
 970   if (warn_format_y2k && !warn_format)
 971     warning ("-Wformat-y2k ignored without -Wformat");
 972   if (warn_format_extra_args && !warn_format)
 973     warning ("-Wformat-extra-args ignored without -Wformat");
 974   if (warn_format_zero_length && !warn_format)
 975     warning ("-Wformat-zero-length ignored without -Wformat");
 976   if (warn_format_nonliteral && !warn_format)
 977     warning ("-Wformat-nonliteral ignored without -Wformat");
 978   if (warn_format_security && !warn_format)
 979     warning ("-Wformat-security ignored without -Wformat");
 980   if (warn_missing_format_attribute && !warn_format)
 981     warning ("-Wmissing-format-attribute ignored without -Wformat");
 982
 983   if (flag_preprocess_only)
 984     {
 985       /* Open the output now.  We must do so even if flag_no_output is
 986          on, because there may be other output than from the actual
 987          preprocessing (e.g. from -dM).  */
 988       if (out_fname[0] == '\0')
 989         out_stream = stdout;
 990       else
 991         out_stream = fopen (out_fname, "w");
 992
 993       if (out_stream == NULL)
 994         {
 995           fatal_error ("opening output file %s: %m", out_fname);
 996           return false;
 997         }
 998
 999       if (num_in_fnames > 1)
1000         error ("too many filenames given.  Type %s --help for usage",
1001                progname);
1002
1003       init_pp_output (out_stream);
1004     }
1005   else
1006     {
1007       init_c_lex ();
1008
1009       /* Yuk.  WTF is this?  I do know ObjC relies on it somewhere.  */
1010       input_location = UNKNOWN_LOCATION;
1011     }
1012
1013   cb = cpp_get_callbacks (parse_in);
1014   cb->file_change = cb_file_change;
1015   cb->dir_change = cb_dir_change;
1016   cpp_post_options (parse_in);
1017
1018   input_location = UNKNOWN_LOCATION;
1019
1020   /* If an error has occurred in cpplib, note it so we fail
1021      immediately.  */
1022   errorcount += cpp_errors (parse_in);
1023
1024   *pfilename = this_input_filename
1025     = cpp_read_main_file (parse_in, in_fnames[0]);
1026   /* Don't do any compilation or preprocessing if there is no input file.  */
1027   if (this_input_filename == NULL)
1028     {
1029       errorcount++;
1030       return false;
1031     }
1032
1033   if (flag_working_directory
1034       && flag_preprocess_only && !flag_no_line_commands)
1035     pp_dir_change (parse_in, get_src_pwd ());
1036
1037   return flag_preprocess_only;
1038 }
1039
1040 /* Front end initialization common to C, ObjC and C++.  */
1041 bool
1042 c_common_init (void)
1043 {
1044   /* Set up preprocessor arithmetic.  Must be done after call to
1045      c_common_nodes_and_builtins for type nodes to be good.  */
1046   cpp_opts->precision = TYPE_PRECISION (intmax_type_node);
1047   cpp_opts->char_precision = TYPE_PRECISION (char_type_node);
1048   cpp_opts->int_precision = TYPE_PRECISION (integer_type_node);
1049   cpp_opts->wchar_precision = TYPE_PRECISION (wchar_type_node);
1050   cpp_opts->unsigned_wchar = TYPE_UNSIGNED (wchar_type_node);
1051   cpp_opts->bytes_big_endian = BYTES_BIG_ENDIAN;
1052
1053   /* This can't happen until after wchar_precision and bytes_big_endian
1054      are known.  */
1055   cpp_init_iconv (parse_in);
1056
1057   if (flag_preprocess_only)
1058     {
1059       finish_options ();
1060       preprocess_file (parse_in);
1061       return false;
1062     }
1063
1064   /* Has to wait until now so that cpplib has its hash table.  */
1065   init_pragma ();
1066
1067   return true;
1068 }
1069
1070 /* Initialize the integrated preprocessor after debug output has been
1071    initialized; loop over each input file.  */
1072 void
1073 c_common_parse_file (int set_yydebug)
1074 {
1075   unsigned int i;
1076
1077   /* Enable parser debugging, if requested and we can.  If requested
1078      and we can't, notify the user.  */
1079 #if YYDEBUG != 0
1080   yydebug = set_yydebug;
1081 #else
1082   if (set_yydebug)
1083     warning ("YYDEBUG was not defined at build time, -dy ignored");
1084 #endif
1085
1086   i = 0;
1087   for (;;)
1088     {
1089       finish_options ();
1090       pch_init ();
1091       push_file_scope ();
1092       c_parse_file ();
1093       finish_file ();
1094       pop_file_scope ();
1095
1096       if (++i >= num_in_fnames)
1097         break;
1098       cpp_undef_all (parse_in);
1099       this_input_filename
1100         = cpp_read_main_file (parse_in, in_fnames[i]);
1101       /* If an input file is missing, abandon further compilation.
1102          cpplib has issued a diagnostic.  */
1103       if (!this_input_filename)
1104         break;
1105     }
1106 }
1107
1108 /* Common finish hook for the C, ObjC and C++ front ends.  */
1109 void
1110 c_common_finish (void)
1111 {
1112   FILE *deps_stream = NULL;
1113
1114   if (cpp_opts->deps.style != DEPS_NONE)
1115     {
1116       /* If -M or -MM was seen without -MF, default output to the
1117          output stream.  */
1118       if (!deps_file)
1119         deps_stream = out_stream;
1120       else
1121         {
1122           deps_stream = fopen (deps_file, deps_append ? "a": "w");
1123           if (!deps_stream)
1124             fatal_error ("opening dependency file %s: %m", deps_file);
1125         }
1126     }
1127
1128   /* For performance, avoid tearing down cpplib's internal structures
1129      with cpp_destroy ().  */
1130   errorcount += cpp_finish (parse_in, deps_stream);
1131
1132   if (deps_stream && deps_stream != out_stream
1133       && (ferror (deps_stream) || fclose (deps_stream)))
1134     fatal_error ("closing dependency file %s: %m", deps_file);
1135
1136   if (out_stream && (ferror (out_stream) || fclose (out_stream)))
1137     fatal_error ("when writing output to %s: %m", out_fname);
1138 }
1139
1140 /* Either of two environment variables can specify output of
1141    dependencies.  Their value is either "OUTPUT_FILE" or "OUTPUT_FILE
1142    DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to
1143    and DEPS_TARGET is the target to mention in the deps.  They also
1144    result in dependency information being appended to the output file
1145    rather than overwriting it, and like Sun's compiler
1146    SUNPRO_DEPENDENCIES suppresses the dependency on the main file.  */
1147 static void
1148 check_deps_environment_vars (void)
1149 {
1150   char *spec;
1151
1152   GET_ENVIRONMENT (spec, "DEPENDENCIES_OUTPUT");
1153   if (spec)
1154     cpp_opts->deps.style = DEPS_USER;
1155   else
1156     {
1157       GET_ENVIRONMENT (spec, "SUNPRO_DEPENDENCIES");
1158       if (spec)
1159         {
1160           cpp_opts->deps.style = DEPS_SYSTEM;
1161           cpp_opts->deps.ignore_main_file = true;
1162         }
1163     }
1164
1165   if (spec)
1166     {
1167       /* Find the space before the DEPS_TARGET, if there is one.  */
1168       char *s = strchr (spec, ' ');
1169       if (s)
1170         {
1171           /* Let the caller perform MAKE quoting.  */
1172           defer_opt (OPT_MT, s + 1);
1173           *s = '\0';
1174         }
1175
1176       /* Command line -MF overrides environment variables and default.  */
1177       if (!deps_file)
1178         deps_file = spec;
1179
1180       deps_append = 1;
1181       deps_seen = true;
1182     }
1183 }
1184
1185 /* Handle deferred command line switches.  */
1186 static void
1187 handle_deferred_opts (void)
1188 {
1189   size_t i;
1190   struct deps *deps;
1191
1192   /* Avoid allocating the deps buffer if we don't need it.
1193      (This flag may be true without there having been -MT or -MQ
1194      options, but we'll still need the deps buffer.)  */
1195   if (!deps_seen)
1196     return;
1197
1198   deps = cpp_get_deps (parse_in);
1199
1200   for (i = 0; i < deferred_count; i++)
1201     {
1202       struct deferred_opt *opt = &deferred_opts[i];
1203
1204       if (opt->code == OPT_MT || opt->code == OPT_MQ)
1205         deps_add_target (deps, opt->arg, opt->code == OPT_MQ);
1206     }
1207 }
1208
1209 /* These settings are appropriate for GCC, but not necessarily so for
1210    cpplib as a library.  */
1211 static void
1212 sanitize_cpp_opts (void)
1213 {
1214   /* If we don't know what style of dependencies to output, complain
1215      if any other dependency switches have been given.  */
1216   if (deps_seen && cpp_opts->deps.style == DEPS_NONE)
1217     error ("to generate dependencies you must specify either -M or -MM");
1218
1219   /* -dM and dependencies suppress normal output; do it here so that
1220      the last -d[MDN] switch overrides earlier ones.  */
1221   if (flag_dump_macros == 'M')
1222     flag_no_output = 1;
1223
1224   /* Disable -dD, -dN and -dI if normal output is suppressed.  Allow
1225      -dM since at least glibc relies on -M -dM to work.  */
1226   /* Also, flag_no_output implies flag_no_line_commands, always. */
1227   if (flag_no_output)
1228     {
1229       if (flag_dump_macros != 'M')
1230         flag_dump_macros = 0;
1231       flag_dump_includes = 0;
1232       flag_no_line_commands = 1;
1233     }
1234
1235   cpp_opts->unsigned_char = !flag_signed_char;
1236   cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS;
1237
1238   /* We want -Wno-long-long to override -pedantic -std=non-c99
1239      and/or -Wtraditional, whatever the ordering.  */
1240   cpp_opts->warn_long_long
1241     = warn_long_long && ((!flag_isoc99 && pedantic) || warn_traditional);
1242
1243   /* Similarly with -Wno-variadic-macros.  No check for c99 here, since
1244      this also turns off warnings about GCCs extension.  */
1245   cpp_opts->warn_variadic_macros
1246     = warn_variadic_macros && (pedantic || warn_traditional);
1247
1248   /* If we're generating preprocessor output, emit current directory
1249      if explicitly requested or if debugging information is enabled.
1250      ??? Maybe we should only do it for debugging formats that
1251      actually output the current directory?  */
1252   if (flag_working_directory == -1)
1253     flag_working_directory = (debug_info_level != DINFO_LEVEL_NONE);
1254 }
1255
1256 /* Add include path with a prefix at the front of its name.  */
1257 static void
1258 add_prefixed_path (const char *suffix, size_t chain)
1259 {
1260   char *path;
1261   const char *prefix;
1262   size_t prefix_len, suffix_len;
1263
1264   suffix_len = strlen (suffix);
1265   prefix     = iprefix ? iprefix : cpp_GCC_INCLUDE_DIR;
1266   prefix_len = iprefix ? strlen (iprefix) : cpp_GCC_INCLUDE_DIR_len;
1267
1268   path = (char *) xmalloc (prefix_len + suffix_len + 1);
1269   memcpy (path, prefix, prefix_len);
1270   memcpy (path + prefix_len, suffix, suffix_len);
1271   path[prefix_len + suffix_len] = '\0';
1272
1273   add_path (path, chain, 0, false);
1274 }
1275
1276 /* Handle -D, -U, -A, -imacros, and the first -include.  */
1277 static void
1278 finish_options (void)
1279 {
1280   if (!cpp_opts->preprocessed)
1281     {
1282       size_t i;
1283
1284       cpp_change_file (parse_in, LC_RENAME, _("<built-in>"));
1285       cpp_init_builtins (parse_in, flag_hosted);
1286       c_cpp_builtins (parse_in);
1287
1288       /* We're about to send user input to cpplib, so make it warn for
1289          things that we previously (when we sent it internal definitions)
1290          told it to not warn.
1291
1292          C99 permits implementation-defined characters in identifiers.
1293          The documented meaning of -std= is to turn off extensions that
1294          conflict with the specified standard, and since a strictly
1295          conforming program cannot contain a '$', we do not condition
1296          their acceptance on the -std= setting.  */
1297       cpp_opts->warn_dollars = (cpp_opts->pedantic && !cpp_opts->c99);
1298
1299       cpp_change_file (parse_in, LC_RENAME, _("<command line>"));
1300       for (i = 0; i < deferred_count; i++)
1301         {
1302           struct deferred_opt *opt = &deferred_opts[i];
1303
1304           if (opt->code == OPT_D)
1305             cpp_define (parse_in, opt->arg);
1306           else if (opt->code == OPT_U)
1307             cpp_undef (parse_in, opt->arg);
1308           else if (opt->code == OPT_A)
1309             {
1310               if (opt->arg[0] == '-')
1311                 cpp_unassert (parse_in, opt->arg + 1);
1312               else
1313                 cpp_assert (parse_in, opt->arg);
1314             }
1315         }
1316
1317       /* Handle -imacros after -D and -U.  */
1318       for (i = 0; i < deferred_count; i++)
1319         {
1320           struct deferred_opt *opt = &deferred_opts[i];
1321
1322           if (opt->code == OPT_imacros
1323               && cpp_push_include (parse_in, opt->arg))
1324             {
1325               /* Disable push_command_line_include callback for now.  */
1326               include_cursor = deferred_count + 1;
1327               cpp_scan_nooutput (parse_in);
1328             }
1329         }
1330     }
1331
1332   include_cursor = 0;
1333   push_command_line_include ();
1334 }
1335
1336 /* Give CPP the next file given by -include, if any.  */
1337 static void
1338 push_command_line_include (void)
1339 {
1340   while (include_cursor < deferred_count)
1341     {
1342       struct deferred_opt *opt = &deferred_opts[include_cursor++];
1343
1344       if (!cpp_opts->preprocessed && opt->code == OPT_include
1345           && cpp_push_include (parse_in, opt->arg))
1346         return;
1347     }
1348
1349   if (include_cursor == deferred_count)
1350     {
1351       include_cursor++;
1352       /* -Wunused-macros should only warn about macros defined hereafter.  */
1353       cpp_opts->warn_unused_macros = warn_unused_macros;
1354       /* Restore the line map from <command line>.  */
1355       if (!cpp_opts->preprocessed)
1356         cpp_change_file (parse_in, LC_RENAME, this_input_filename);
1357
1358       /* Set this here so the client can change the option if it wishes,
1359          and after stacking the main file so we don't trace the main file.  */
1360       line_table.trace_includes = cpp_opts->print_include_names;
1361     }
1362 }
1363
1364 /* File change callback.  Has to handle -include files.  */
1365 static void
1366 cb_file_change (cpp_reader * ARG_UNUSED (pfile),
1367                 const struct line_map *new_map)
1368 {
1369   if (flag_preprocess_only)
1370     pp_file_change (new_map);
1371   else
1372     fe_file_change (new_map);
1373
1374   if (new_map == 0 || (new_map->reason == LC_LEAVE && MAIN_FILE_P (new_map)))
1375     push_command_line_include ();
1376 }
1377
1378 void
1379 cb_dir_change (cpp_reader * ARG_UNUSED (pfile), const char *dir)
1380 {
1381   if (!set_src_pwd (dir))
1382     warning ("too late for # directive to set debug directory");
1383 }
1384
1385 /* Set the C 89 standard (with 1994 amendments if C94, without GNU
1386    extensions if ISO).  There is no concept of gnu94.  */
1387 static void
1388 set_std_c89 (int c94, int iso)
1389 {
1390   cpp_set_lang (parse_in, c94 ? CLK_STDC94: iso ? CLK_STDC89: CLK_GNUC89);
1391   flag_iso = iso;
1392   flag_no_asm = iso;
1393   flag_no_gnu_keywords = iso;
1394   flag_no_nonansi_builtin = iso;
1395   flag_isoc94 = c94;
1396   flag_isoc99 = 0;
1397 }
1398
1399 /* Set the C 99 standard (without GNU extensions if ISO).  */
1400 static void
1401 set_std_c99 (int iso)
1402 {
1403   cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99);
1404   flag_no_asm = iso;
1405   flag_no_nonansi_builtin = iso;
1406   flag_iso = iso;
1407   flag_isoc99 = 1;
1408   flag_isoc94 = 1;
1409 }
1410
1411 /* Set the C++ 98 standard (without GNU extensions if ISO).  */
1412 static void
1413 set_std_cxx98 (int iso)
1414 {
1415   cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX);
1416   flag_no_gnu_keywords = iso;
1417   flag_no_nonansi_builtin = iso;
1418   flag_iso = iso;
1419 }
1420
1421 /* Handle setting implicit to ON.  */
1422 static void
1423 set_Wimplicit (int on)
1424 {
1425   warn_implicit = on;
1426   warn_implicit_int = on;
1427   if (on)
1428     {
1429       if (mesg_implicit_function_declaration != 2)
1430         mesg_implicit_function_declaration = 1;
1431     }
1432   else
1433     mesg_implicit_function_declaration = 0;
1434 }
1435
1436 /* Args to -d specify what to dump.  Silently ignore
1437    unrecognized options; they may be aimed at toplev.c.  */
1438 static void
1439 handle_OPT_d (const char *arg)
1440 {
1441   char c;
1442
1443   while ((c = *arg++) != '\0')
1444     switch (c)
1445       {
1446       case 'M':                 /* Dump macros only.  */
1447       case 'N':                 /* Dump names.  */
1448       case 'D':                 /* Dump definitions.  */
1449         flag_dump_macros = c;
1450         break;
1451
1452       case 'I':
1453         flag_dump_includes = 1;
1454         break;
1455       }
1456 }