gcc/c-opts.c

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