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, but not if explicitly
 962       overridden.  */
 963   if (warn_sign_compare == -1)
 964     warn_sign_compare = extra_warnings;
 965
 966   /* Special format checking options don't work without -Wformat; warn if
 967      they are used.  */
 968   if (warn_format_y2k && !warn_format)
 969     warning ("-Wformat-y2k ignored without -Wformat");
 970   if (warn_format_extra_args && !warn_format)
 971     warning ("-Wformat-extra-args ignored without -Wformat");
 972   if (warn_format_zero_length && !warn_format)
 973     warning ("-Wformat-zero-length ignored without -Wformat");
 974   if (warn_format_nonliteral && !warn_format)
 975     warning ("-Wformat-nonliteral ignored without -Wformat");
 976   if (warn_format_security && !warn_format)
 977     warning ("-Wformat-security ignored without -Wformat");
 978   if (warn_missing_format_attribute && !warn_format)
 979     warning ("-Wmissing-format-attribute ignored without -Wformat");
 980
 981   if (flag_preprocess_only)
 982     {
 983       /* Open the output now.  We must do so even if flag_no_output is
 984          on, because there may be other output than from the actual
 985          preprocessing (e.g. from -dM).  */
 986       if (out_fname[0] == '\0')
 987         out_stream = stdout;
 988       else
 989         out_stream = fopen (out_fname, "w");
 990
 991       if (out_stream == NULL)
 992         {
 993           fatal_error ("opening output file %s: %m", out_fname);
 994           return false;
 995         }
 996
 997       if (num_in_fnames > 1)
 998         error ("too many filenames given.  Type %s --help for usage",
 999                progname);
1000
1001       init_pp_output (out_stream);
1002     }
1003   else
1004     {
1005       init_c_lex ();
1006
1007       /* Yuk.  WTF is this?  I do know ObjC relies on it somewhere.  */
1008       input_location = UNKNOWN_LOCATION;
1009     }
1010
1011   cb = cpp_get_callbacks (parse_in);
1012   cb->file_change = cb_file_change;
1013   cb->dir_change = cb_dir_change;
1014   cpp_post_options (parse_in);
1015
1016   input_location = UNKNOWN_LOCATION;
1017
1018   /* If an error has occurred in cpplib, note it so we fail
1019      immediately.  */
1020   errorcount += cpp_errors (parse_in);
1021
1022   *pfilename = this_input_filename
1023     = cpp_read_main_file (parse_in, in_fnames[0]);
1024   /* Don't do any compilation or preprocessing if there is no input file.  */
1025   if (this_input_filename == NULL)
1026     {
1027       errorcount++;
1028       return false;
1029     }
1030
1031   if (flag_working_directory
1032       && flag_preprocess_only && ! flag_no_line_commands)
1033     pp_dir_change (parse_in, get_src_pwd ());
1034
1035   return flag_preprocess_only;
1036 }
1037
1038 /* Front end initialization common to C, ObjC and C++.  */
1039 bool
1040 c_common_init (void)
1041 {
1042   /* Set up preprocessor arithmetic.  Must be done after call to
1043      c_common_nodes_and_builtins for type nodes to be good.  */
1044   cpp_opts->precision = TYPE_PRECISION (intmax_type_node);
1045   cpp_opts->char_precision = TYPE_PRECISION (char_type_node);
1046   cpp_opts->int_precision = TYPE_PRECISION (integer_type_node);
1047   cpp_opts->wchar_precision = TYPE_PRECISION (wchar_type_node);
1048   cpp_opts->unsigned_wchar = TYPE_UNSIGNED (wchar_type_node);
1049   cpp_opts->bytes_big_endian = BYTES_BIG_ENDIAN;
1050
1051   /* This can't happen until after wchar_precision and bytes_big_endian
1052      are known.  */
1053   cpp_init_iconv (parse_in);
1054
1055   if (flag_preprocess_only)
1056     {
1057       finish_options ();
1058       preprocess_file (parse_in);
1059       return false;
1060     }
1061
1062   /* Has to wait until now so that cpplib has its hash table.  */
1063   init_pragma ();
1064
1065   return true;
1066 }
1067
1068 /* Initialize the integrated preprocessor after debug output has been
1069    initialized; loop over each input file.  */
1070 void
1071 c_common_parse_file (int set_yydebug)
1072 {
1073   unsigned int i;
1074
1075   /* Enable parser debugging, if requested and we can.  If requested
1076      and we can't, notify the user.  */
1077 #if YYDEBUG != 0
1078   yydebug = set_yydebug;
1079 #else
1080   if (set_yydebug)
1081     warning ("YYDEBUG was not defined at build time, -dy ignored");
1082 #endif
1083
1084   i = 0;
1085   for (;;)
1086     {
1087       finish_options ();
1088       pch_init ();
1089       push_file_scope ();
1090       c_parse_file ();
1091       finish_file ();
1092       pop_file_scope ();
1093
1094       if (++i >= num_in_fnames)
1095         break;
1096       cpp_undef_all (parse_in);
1097       this_input_filename
1098         = cpp_read_main_file (parse_in, in_fnames[i]);
1099       /* If an input file is missing, abandon further compilation.
1100          cpplib has issued a diagnostic.  */
1101       if (!this_input_filename)
1102         break;
1103     }
1104 }
1105
1106 /* Common finish hook for the C, ObjC and C++ front ends.  */
1107 void
1108 c_common_finish (void)
1109 {
1110   FILE *deps_stream = NULL;
1111
1112   if (cpp_opts->deps.style != DEPS_NONE)
1113     {
1114       /* If -M or -MM was seen without -MF, default output to the
1115          output stream.  */
1116       if (!deps_file)
1117         deps_stream = out_stream;
1118       else
1119         {
1120           deps_stream = fopen (deps_file, deps_append ? "a": "w");
1121           if (!deps_stream)
1122             fatal_error ("opening dependency file %s: %m", deps_file);
1123         }
1124     }
1125
1126   /* For performance, avoid tearing down cpplib's internal structures
1127      with cpp_destroy ().  */
1128   errorcount += cpp_finish (parse_in, deps_stream);
1129
1130   if (deps_stream && deps_stream != out_stream
1131       && (ferror (deps_stream) || fclose (deps_stream)))
1132     fatal_error ("closing dependency file %s: %m", deps_file);
1133
1134   if (out_stream && (ferror (out_stream) || fclose (out_stream)))
1135     fatal_error ("when writing output to %s: %m", out_fname);
1136 }
1137
1138 /* Either of two environment variables can specify output of
1139    dependencies.  Their value is either "OUTPUT_FILE" or "OUTPUT_FILE
1140    DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to
1141    and DEPS_TARGET is the target to mention in the deps.  They also
1142    result in dependency information being appended to the output file
1143    rather than overwriting it, and like Sun's compiler
1144    SUNPRO_DEPENDENCIES suppresses the dependency on the main file.  */
1145 static void
1146 check_deps_environment_vars (void)
1147 {
1148   char *spec;
1149
1150   GET_ENVIRONMENT (spec, "DEPENDENCIES_OUTPUT");
1151   if (spec)
1152     cpp_opts->deps.style = DEPS_USER;
1153   else
1154     {
1155       GET_ENVIRONMENT (spec, "SUNPRO_DEPENDENCIES");
1156       if (spec)
1157         {
1158           cpp_opts->deps.style = DEPS_SYSTEM;
1159           cpp_opts->deps.ignore_main_file = true;
1160         }
1161     }
1162
1163   if (spec)
1164     {
1165       /* Find the space before the DEPS_TARGET, if there is one.  */
1166       char *s = strchr (spec, ' ');
1167       if (s)
1168         {
1169           /* Let the caller perform MAKE quoting.  */
1170           defer_opt (OPT_MT, s + 1);
1171           *s = '\0';
1172         }
1173
1174       /* Command line -MF overrides environment variables and default.  */
1175       if (!deps_file)
1176         deps_file = spec;
1177
1178       deps_append = 1;
1179     }
1180 }
1181
1182 /* Handle deferred command line switches.  */
1183 static void
1184 handle_deferred_opts (void)
1185 {
1186   size_t i;
1187   struct deps *deps;
1188
1189   /* Avoid allocating the deps buffer if we don't need it.
1190      (This flag may be true without there having been -MT or -MQ
1191      options, but we'll still need the deps buffer.)  */
1192   if (!deps_seen)
1193     return;
1194
1195   deps = cpp_get_deps (parse_in);
1196
1197   for (i = 0; i < deferred_count; i++)
1198     {
1199       struct deferred_opt *opt = &deferred_opts[i];
1200
1201       if (opt->code == OPT_MT || opt->code == OPT_MQ)
1202         deps_add_target (deps, opt->arg, opt->code == OPT_MQ);
1203     }
1204 }
1205
1206 /* These settings are appropriate for GCC, but not necessarily so for
1207    cpplib as a library.  */
1208 static void
1209 sanitize_cpp_opts (void)
1210 {
1211   /* If we don't know what style of dependencies to output, complain
1212      if any other dependency switches have been given.  */
1213   if (deps_seen && cpp_opts->deps.style == DEPS_NONE)
1214     error ("to generate dependencies you must specify either -M or -MM");
1215
1216   /* -dM and dependencies suppress normal output; do it here so that
1217      the last -d[MDN] switch overrides earlier ones.  */
1218   if (flag_dump_macros == 'M')
1219     flag_no_output = 1;
1220
1221   /* Disable -dD, -dN and -dI if normal output is suppressed.  Allow
1222      -dM since at least glibc relies on -M -dM to work.  */
1223   if (flag_no_output)
1224     {
1225       if (flag_dump_macros != 'M')
1226         flag_dump_macros = 0;
1227       flag_dump_includes = 0;
1228     }
1229
1230   cpp_opts->unsigned_char = !flag_signed_char;
1231   cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS;
1232
1233   /* We want -Wno-long-long to override -pedantic -std=non-c99
1234      and/or -Wtraditional, whatever the ordering.  */
1235   cpp_opts->warn_long_long
1236     = warn_long_long && ((!flag_isoc99 && pedantic) || warn_traditional);
1237
1238   /* Similarly with -Wno-variadic-macros.  No check for c99 here, since
1239      this also turns off warnings about GCCs extension.  */
1240   cpp_opts->warn_variadic_macros
1241     = warn_variadic_macros && (pedantic || warn_traditional);
1242
1243   /* If we're generating preprocessor output, emit current directory
1244      if explicitly requested or if debugging information is enabled.
1245      ??? Maybe we should only do it for debugging formats that
1246      actually output the current directory?  */
1247   if (flag_working_directory == -1)
1248     flag_working_directory = (debug_info_level != DINFO_LEVEL_NONE);
1249 }
1250
1251 /* Add include path with a prefix at the front of its name.  */
1252 static void
1253 add_prefixed_path (const char *suffix, size_t chain)
1254 {
1255   char *path;
1256   const char *prefix;
1257   size_t prefix_len, suffix_len;
1258
1259   suffix_len = strlen (suffix);
1260   prefix     = iprefix ? iprefix : cpp_GCC_INCLUDE_DIR;
1261   prefix_len = iprefix ? strlen (iprefix) : cpp_GCC_INCLUDE_DIR_len;
1262
1263   path = (char *) xmalloc (prefix_len + suffix_len + 1);
1264   memcpy (path, prefix, prefix_len);
1265   memcpy (path + prefix_len, suffix, suffix_len);
1266   path[prefix_len + suffix_len] = '\0';
1267
1268   add_path (path, chain, 0, false);
1269 }
1270
1271 /* Handle -D, -U, -A, -imacros, and the first -include.  */
1272 static void
1273 finish_options (void)
1274 {
1275   if (!cpp_opts->preprocessed)
1276     {
1277       size_t i;
1278
1279       cpp_change_file (parse_in, LC_RENAME, _("<built-in>"));
1280       cpp_init_builtins (parse_in, flag_hosted);
1281       c_cpp_builtins (parse_in);
1282
1283       /* We're about to send user input to cpplib, so make it warn for
1284          things that we previously (when we sent it internal definitions)
1285          told it to not warn.
1286
1287          C99 permits implementation-defined characters in identifiers.
1288          The documented meaning of -std= is to turn off extensions that
1289          conflict with the specified standard, and since a strictly
1290          conforming program cannot contain a '$', we do not condition
1291          their acceptance on the -std= setting.  */
1292       cpp_opts->warn_dollars = (cpp_opts->pedantic && !cpp_opts->c99);
1293
1294       cpp_change_file (parse_in, LC_RENAME, _("<command line>"));
1295       for (i = 0; i < deferred_count; i++)
1296         {
1297           struct deferred_opt *opt = &deferred_opts[i];
1298
1299           if (opt->code == OPT_D)
1300             cpp_define (parse_in, opt->arg);
1301           else if (opt->code == OPT_U)
1302             cpp_undef (parse_in, opt->arg);
1303           else if (opt->code == OPT_A)
1304             {
1305               if (opt->arg[0] == '-')
1306                 cpp_unassert (parse_in, opt->arg + 1);
1307               else
1308                 cpp_assert (parse_in, opt->arg);
1309             }
1310         }
1311
1312       /* Handle -imacros after -D and -U.  */
1313       for (i = 0; i < deferred_count; i++)
1314         {
1315           struct deferred_opt *opt = &deferred_opts[i];
1316
1317           if (opt->code == OPT_imacros
1318               && cpp_push_include (parse_in, opt->arg))
1319             {
1320               /* Disable push_command_line_include callback for now.  */
1321               include_cursor = deferred_count + 1;
1322               cpp_scan_nooutput (parse_in);
1323             }
1324         }
1325     }
1326
1327   include_cursor = 0;
1328   push_command_line_include ();
1329 }
1330
1331 /* Give CPP the next file given by -include, if any.  */
1332 static void
1333 push_command_line_include (void)
1334 {
1335   while (include_cursor < deferred_count)
1336     {
1337       struct deferred_opt *opt = &deferred_opts[include_cursor++];
1338
1339       if (! cpp_opts->preprocessed && opt->code == OPT_include
1340           && cpp_push_include (parse_in, opt->arg))
1341         return;
1342     }
1343
1344   if (include_cursor == deferred_count)
1345     {
1346       include_cursor++;
1347       /* -Wunused-macros should only warn about macros defined hereafter.  */
1348       cpp_opts->warn_unused_macros = warn_unused_macros;
1349       /* Restore the line map from <command line>.  */
1350       if (! cpp_opts->preprocessed)
1351         cpp_change_file (parse_in, LC_RENAME, main_input_filename);
1352
1353       /* Set this here so the client can change the option if it wishes,
1354          and after stacking the main file so we don't trace the main file.  */
1355       line_table.trace_includes = cpp_opts->print_include_names;
1356     }
1357 }
1358
1359 /* File change callback.  Has to handle -include files.  */
1360 static void
1361 cb_file_change (cpp_reader * ARG_UNUSED (pfile),
1362                 const struct line_map *new_map)
1363 {
1364   if (flag_preprocess_only)
1365     pp_file_change (new_map);
1366   else
1367     fe_file_change (new_map);
1368
1369   if (new_map == 0 || (new_map->reason == LC_LEAVE && MAIN_FILE_P (new_map)))
1370     push_command_line_include ();
1371 }
1372
1373 void
1374 cb_dir_change (cpp_reader * ARG_UNUSED (pfile), const char *dir)
1375 {
1376   if (! set_src_pwd (dir))
1377     warning ("too late for # directive to set debug directory");
1378 }
1379
1380 /* Set the C 89 standard (with 1994 amendments if C94, without GNU
1381    extensions if ISO).  There is no concept of gnu94.  */
1382 static void
1383 set_std_c89 (int c94, int iso)
1384 {
1385   cpp_set_lang (parse_in, c94 ? CLK_STDC94: iso ? CLK_STDC89: CLK_GNUC89);
1386   flag_iso = iso;
1387   flag_no_asm = iso;
1388   flag_no_gnu_keywords = iso;
1389   flag_no_nonansi_builtin = iso;
1390   flag_isoc94 = c94;
1391   flag_isoc99 = 0;
1392 }
1393
1394 /* Set the C 99 standard (without GNU extensions if ISO).  */
1395 static void
1396 set_std_c99 (int iso)
1397 {
1398   cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99);
1399   flag_no_asm = iso;
1400   flag_no_nonansi_builtin = iso;
1401   flag_iso = iso;
1402   flag_isoc99 = 1;
1403   flag_isoc94 = 1;
1404 }
1405
1406 /* Set the C++ 98 standard (without GNU extensions if ISO).  */
1407 static void
1408 set_std_cxx98 (int iso)
1409 {
1410   cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX);
1411   flag_no_gnu_keywords = iso;
1412   flag_no_nonansi_builtin = iso;
1413   flag_iso = iso;
1414 }
1415
1416 /* Handle setting implicit to ON.  */
1417 static void
1418 set_Wimplicit (int on)
1419 {
1420   warn_implicit = on;
1421   warn_implicit_int = on;
1422   if (on)
1423     {
1424       if (mesg_implicit_function_declaration != 2)
1425         mesg_implicit_function_declaration = 1;
1426     }
1427   else
1428     mesg_implicit_function_declaration = 0;
1429 }
1430
1431 /* Args to -d specify what to dump.  Silently ignore
1432    unrecognized options; they may be aimed at toplev.c.  */
1433 static void
1434 handle_OPT_d (const char *arg)
1435 {
1436   char c;
1437
1438   while ((c = *arg++) != '\0')
1439     switch (c)
1440       {
1441       case 'M':                 /* Dump macros only.  */
1442       case 'N':                 /* Dump names.  */
1443       case 'D':                 /* Dump definitions.  */
1444         flag_dump_macros = c;
1445         break;
1446
1447       case 'I':
1448         flag_dump_includes = 1;
1449         break;
1450       }
1451 }