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