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