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