gcc/c-opts.c

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