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