gcc/c-opts.c

   1 /* C/ObjC/C++ command line option handling.
   2    Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   3    Free Software Foundation, Inc.
   4    Contributed by Neil Booth.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  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 "incpath.h"
  37 #include "debug.h"              /* For debug_hooks.  */
  38 #include "opts.h"
  39 #include "options.h"
  40 #include "mkdeps.h"
  41 #include "target.h"
  42 #include "tm_p.h"
  43 #include "c-tree.h"             /* For c_cpp_error.  */
  44
  45 #ifndef DOLLARS_IN_IDENTIFIERS
  46 # define DOLLARS_IN_IDENTIFIERS true
  47 #endif
  48
  49 #ifndef TARGET_SYSTEM_ROOT
  50 # define TARGET_SYSTEM_ROOT NULL
  51 #endif
  52
  53 #ifndef TARGET_OPTF
  54 #define TARGET_OPTF(ARG)
  55 #endif
  56
  57 /* CPP's options.  */
  58 cpp_options *cpp_opts;
  59
  60 /* Input filename.  */
  61 static const char *this_input_filename;
  62
  63 /* Filename and stream for preprocessed output.  */
  64 static const char *out_fname;
  65 static FILE *out_stream;
  66
  67 /* Append dependencies to deps_file.  */
  68 static bool deps_append;
  69
  70 /* If dependency switches (-MF etc.) have been given.  */
  71 static bool deps_seen;
  72
  73 /* If -v seen.  */
  74 static bool verbose;
  75
  76 /* Dependency output file.  */
  77 static const char *deps_file;
  78
  79 /* The prefix given by -iprefix, if any.  */
  80 static const char *iprefix;
  81
  82 /* The multilib directory given by -imultilib, if any.  */
  83 static const char *imultilib;
  84
  85 /* The system root, if any.  Overridden by -isysroot.  */
  86 static const char *sysroot = TARGET_SYSTEM_ROOT;
  87
  88 /* Zero disables all standard directories for headers.  */
  89 static bool std_inc = true;
  90
  91 /* Zero disables the C++-specific standard directories for headers.  */
  92 static bool std_cxx_inc = true;
  93
  94 /* If the quote chain has been split by -I-.  */
  95 static bool quote_chain_split;
  96
  97 /* If -Wunused-macros.  */
  98 static bool warn_unused_macros;
  99
 100 /* If -Wvariadic-macros.  */
 101 static bool warn_variadic_macros = true;
 102
 103 /* Number of deferred options.  */
 104 static size_t deferred_count;
 105
 106 /* Number of deferred options scanned for -include.  */
 107 static size_t include_cursor;
 108
 109 static void handle_OPT_d (const char *);
 110 static void set_std_cxx98 (int);
 111 static void set_std_cxx0x (int);
 112 static void set_std_c89 (int, int);
 113 static void set_std_c99 (int);
 114 static void set_std_c1x (int);
 115 static void check_deps_environment_vars (void);
 116 static void handle_deferred_opts (void);
 117 static void sanitize_cpp_opts (void);
 118 static void add_prefixed_path (const char *, size_t);
 119 static void push_command_line_include (void);
 120 static void cb_file_change (cpp_reader *, const struct line_map *);
 121 static void cb_dir_change (cpp_reader *, const char *);
 122 static void finish_options (void);
 123
 124 #ifndef STDC_0_IN_SYSTEM_HEADERS
 125 #define STDC_0_IN_SYSTEM_HEADERS 0
 126 #endif
 127
 128 /* Holds switches parsed by c_common_handle_option (), but whose
 129    handling is deferred to c_common_post_options ().  */
 130 static void defer_opt (enum opt_code, const char *);
 131 static struct deferred_opt
 132 {
 133   enum opt_code code;
 134   const char *arg;
 135 } *deferred_opts;
 136
 137
 138 static const unsigned int
 139 c_family_lang_mask = (CL_C | CL_CXX | CL_ObjC | CL_ObjCXX);
 140
 141 /* Complain that switch CODE expects an argument but none was
 142    provided.  OPT was the command-line option.  Return FALSE to get
 143    the default message in opts.c, TRUE if we provide a specialized
 144    one.  */
 145 bool
 146 c_common_missing_argument (const char *opt, size_t code)
 147 {
 148   switch (code)
 149     {
 150     default:
 151       /* Pick up the default message.  */
 152       return false;
 153
 154     case OPT_fconstant_string_class_:
 155       error ("no class name specified with %qs", opt);
 156       break;
 157
 158     case OPT_A:
 159       error ("assertion missing after %qs", opt);
 160       break;
 161
 162     case OPT_D:
 163     case OPT_U:
 164       error ("macro name missing after %qs", opt);
 165       break;
 166
 167     case OPT_F:
 168     case OPT_I:
 169     case OPT_idirafter:
 170     case OPT_isysroot:
 171     case OPT_isystem:
 172     case OPT_iquote:
 173       error ("missing path after %qs", opt);
 174       break;
 175
 176     case OPT_MF:
 177     case OPT_MD:
 178     case OPT_MMD:
 179     case OPT_include:
 180     case OPT_imacros:
 181     case OPT_o:
 182       error ("missing filename after %qs", opt);
 183       break;
 184
 185     case OPT_MQ:
 186     case OPT_MT:
 187       error ("missing makefile target after %qs", opt);
 188       break;
 189     }
 190
 191   return true;
 192 }
 193
 194 /* Defer option CODE with argument ARG.  */
 195 static void
 196 defer_opt (enum opt_code code, const char *arg)
 197 {
 198   deferred_opts[deferred_count].code = code;
 199   deferred_opts[deferred_count].arg = arg;
 200   deferred_count++;
 201 }
 202
 203 /* -Werror= may set a warning option to enable a warning that is emitted
 204    by the preprocessor.  Set any corresponding flag in cpp_opts.  */
 205
 206 static void
 207 warning_as_error_callback (int option_index)
 208 {
 209   switch (option_index)
 210     {
 211       default:
 212         /* Ignore options not associated with the preprocessor.  */
 213         break;
 214
 215       case OPT_Wdeprecated:
 216         cpp_opts->warn_deprecated = 1;
 217         break;
 218
 219       case OPT_Wcomment:
 220       case OPT_Wcomments:
 221         cpp_opts->warn_comments = 1;
 222         break;
 223
 224       case OPT_Wtrigraphs:
 225         cpp_opts->warn_trigraphs = 1;
 226         break;
 227
 228       case OPT_Wmultichar:
 229         cpp_opts->warn_multichar = 1;
 230         break;
 231
 232       case OPT_Wtraditional:
 233         cpp_opts->warn_traditional = 1;
 234         break;
 235
 236       case OPT_Wlong_long:
 237         cpp_opts->warn_long_long = 1;
 238         break;
 239
 240       case OPT_Wendif_labels:
 241         cpp_opts->warn_endif_labels = 1;
 242         break;
 243
 244       case OPT_Wvariadic_macros:
 245         /* Set the local flag that is used later to update cpp_opts.  */
 246         warn_variadic_macros = 1;
 247         break;
 248
 249       case OPT_Wbuiltin_macro_redefined:
 250         cpp_opts->warn_builtin_macro_redefined = 1;
 251         break;
 252
 253       case OPT_Wundef:
 254         cpp_opts->warn_undef = 1;
 255         break;
 256
 257       case OPT_Wunused_macros:
 258         /* Set the local flag that is used later to update cpp_opts.  */
 259         warn_unused_macros = 1;
 260         break;
 261
 262       case OPT_Wc___compat:
 263         /* Add warnings in the same way as c_common_handle_option below.  */
 264         if (warn_enum_compare == -1)
 265           warn_enum_compare = 1;
 266         if (warn_jump_misses_init == -1)
 267           warn_jump_misses_init = 1;
 268         cpp_opts->warn_cxx_operator_names = 1;
 269         break;
 270
 271       case OPT_Wnormalized_:
 272         inform (input_location, "-Werror=normalized=: Set -Wnormalized=nfc");
 273         cpp_opts->warn_normalize = normalized_C;
 274         break;
 275
 276       case OPT_Winvalid_pch:
 277         cpp_opts->warn_invalid_pch = 1;
 278         break;
 279
 280       case OPT_Wcpp:
 281         /* Handled by standard diagnostics using the option's associated
 282            boolean variable.  */
 283         break;
 284     }
 285 }
 286
 287 /* Common initialization before parsing options.  */
 288 unsigned int
 289 c_common_init_options (unsigned int argc, const char **argv)
 290 {
 291   static const unsigned int lang_flags[] = {CL_C, CL_ObjC, CL_CXX, CL_ObjCXX};
 292   unsigned int i, result;
 293   struct cpp_callbacks *cb;
 294
 295   /* Register callback for warnings enabled by -Werror=.  */
 296   register_warning_as_error_callback (warning_as_error_callback);
 297
 298   /* This is conditionalized only because that is the way the front
 299      ends used to do it.  Maybe this should be unconditional?  */
 300   if (c_dialect_cxx ())
 301     {
 302       /* By default wrap lines at 80 characters.  Is getenv
 303          ("COLUMNS") preferable?  */
 304       diagnostic_line_cutoff (global_dc) = 80;
 305       /* By default, emit location information once for every
 306          diagnostic message.  */
 307       diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
 308     }
 309
 310   parse_in = cpp_create_reader (c_dialect_cxx () ? CLK_GNUCXX: CLK_GNUC89,
 311                                 ident_hash, line_table);
 312   cb = cpp_get_callbacks (parse_in);
 313   cb->error = c_cpp_error;
 314
 315   cpp_opts = cpp_get_options (parse_in);
 316   cpp_opts->dollars_in_ident = DOLLARS_IN_IDENTIFIERS;
 317   cpp_opts->objc = c_dialect_objc ();
 318
 319   /* Reset to avoid warnings on internal definitions.  We set it just
 320      before passing on command-line options to cpplib.  */
 321   cpp_opts->warn_dollars = 0;
 322
 323   flag_exceptions = c_dialect_cxx ();
 324   warn_pointer_arith = c_dialect_cxx ();
 325   warn_write_strings = c_dialect_cxx();
 326   flag_warn_unused_result = true;
 327
 328   /* By default, C99-like requirements for complex multiply and divide.  */
 329   flag_complex_method = 2;
 330
 331   deferred_opts = XNEWVEC (struct deferred_opt, argc);
 332
 333   result = lang_flags[c_language];
 334
 335   if (c_language == clk_c)
 336     {
 337       /* If preprocessing assembly language, accept any of the C-family
 338          front end options since the driver may pass them through.  */
 339       for (i = 1; i < argc; i++)
 340         if (! strcmp (argv[i], "-lang-asm"))
 341           {
 342             result |= CL_C | CL_ObjC | CL_CXX | CL_ObjCXX;
 343             break;
 344           }
 345     }
 346
 347   return result;
 348 }
 349
 350 /* Handle switch SCODE with argument ARG.  VALUE is true, unless no-
 351    form of an -f or -W option was given.  Returns 0 if the switch was
 352    invalid, a negative number to prevent language-independent
 353    processing in toplev.c (a hack necessary for the short-term).  */
 354 int
 355 c_common_handle_option (size_t scode, const char *arg, int value,
 356                         int kind)
 357 {
 358   const struct cl_option *option = &cl_options[scode];
 359   enum opt_code code = (enum opt_code) scode;
 360   int result = 1;
 361
 362   /* Prevent resetting the language standard to a C dialect when the driver
 363      has already determined that we're looking at assembler input.  */
 364   bool preprocessing_asm_p = (cpp_get_options (parse_in)->lang == CLK_ASM);
 365
 366   switch (code)
 367     {
 368     default:
 369       if (cl_options[code].flags & c_family_lang_mask)
 370         {
 371           if ((option->flags & CL_TARGET)
 372               && ! targetcm.handle_c_option (scode, arg, value))
 373             result = 0;
 374           break;
 375         }
 376       result = 0;
 377       break;
 378
 379     case OPT__output_pch_:
 380       pch_file = arg;
 381       break;
 382
 383     case OPT_A:
 384       defer_opt (code, arg);
 385       break;
 386
 387     case OPT_C:
 388       cpp_opts->discard_comments = 0;
 389       break;
 390
 391     case OPT_CC:
 392       cpp_opts->discard_comments = 0;
 393       cpp_opts->discard_comments_in_macro_exp = 0;
 394       break;
 395
 396     case OPT_D:
 397       defer_opt (code, arg);
 398       break;
 399
 400     case OPT_E:
 401       flag_preprocess_only = 1;
 402       break;
 403
 404     case OPT_H:
 405       cpp_opts->print_include_names = 1;
 406       break;
 407
 408     case OPT_F:
 409       TARGET_OPTF (xstrdup (arg));
 410       break;
 411
 412     case OPT_I:
 413       if (strcmp (arg, "-"))
 414         add_path (xstrdup (arg), BRACKET, 0, true);
 415       else
 416         {
 417           if (quote_chain_split)
 418             error ("-I- specified twice");
 419           quote_chain_split = true;
 420           split_quote_chain ();
 421           inform (input_location, "obsolete option -I- used, please use -iquote instead");
 422         }
 423       break;
 424
 425     case OPT_M:
 426     case OPT_MM:
 427       /* When doing dependencies with -M or -MM, suppress normal
 428          preprocessed output, but still do -dM etc. as software
 429          depends on this.  Preprocessed output does occur if -MD, -MMD
 430          or environment var dependency generation is used.  */
 431       cpp_opts->deps.style = (code == OPT_M ? DEPS_SYSTEM: DEPS_USER);
 432       flag_no_output = 1;
 433       break;
 434
 435     case OPT_MD:
 436     case OPT_MMD:
 437       cpp_opts->deps.style = (code == OPT_MD ? DEPS_SYSTEM: DEPS_USER);
 438       cpp_opts->deps.need_preprocessor_output = true;
 439       deps_file = arg;
 440       break;
 441
 442     case OPT_MF:
 443       deps_seen = true;
 444       deps_file = arg;
 445       break;
 446
 447     case OPT_MG:
 448       deps_seen = true;
 449       cpp_opts->deps.missing_files = true;
 450       break;
 451
 452     case OPT_MP:
 453       deps_seen = true;
 454       cpp_opts->deps.phony_targets = true;
 455       break;
 456
 457     case OPT_MQ:
 458     case OPT_MT:
 459       deps_seen = true;
 460       defer_opt (code, arg);
 461       break;
 462
 463     case OPT_P:
 464       flag_no_line_commands = 1;
 465       break;
 466
 467     case OPT_fworking_directory:
 468       flag_working_directory = value;
 469       break;
 470
 471     case OPT_U:
 472       defer_opt (code, arg);
 473       break;
 474
 475     case OPT_Wall:
 476       warn_unused = value;
 477       set_Wformat (value);
 478       handle_option (OPT_Wimplicit, value, NULL, c_family_lang_mask, kind);
 479       warn_char_subscripts = value;
 480       warn_missing_braces = value;
 481       warn_parentheses = value;
 482       warn_return_type = value;
 483       warn_sequence_point = value;      /* Was C only.  */
 484       warn_switch = value;
 485       if (warn_strict_aliasing == -1)
 486         set_Wstrict_aliasing (value);
 487       warn_address = value;
 488       if (warn_strict_overflow == -1)
 489         warn_strict_overflow = value;
 490       warn_array_bounds = value;
 491       warn_volatile_register_var = value;
 492
 493       /* Only warn about unknown pragmas that are not in system
 494          headers.  */
 495       warn_unknown_pragmas = value;
 496
 497       warn_uninitialized = value;
 498
 499       if (!c_dialect_cxx ())
 500         {
 501           /* We set this to 2 here, but 1 in -Wmain, so -ffreestanding
 502              can turn it off only if it's not explicit.  */
 503           if (warn_main == -1)
 504             warn_main = (value ? 2 : 0);
 505
 506           /* In C, -Wall turns on -Wenum-compare, which we do here.
 507              In C++ it is on by default, which is done in
 508              c_common_post_options.  */
 509           if (warn_enum_compare == -1)
 510             warn_enum_compare = value;
 511         }
 512       else
 513         {
 514           /* C++-specific warnings.  */
 515           warn_sign_compare = value;
 516           warn_reorder = value;
 517           warn_cxx0x_compat = value;
 518         }
 519
 520       cpp_opts->warn_trigraphs = value;
 521       cpp_opts->warn_comments = value;
 522       cpp_opts->warn_num_sign_change = value;
 523
 524       if (warn_pointer_sign == -1)
 525         warn_pointer_sign = value;
 526       break;
 527
 528     case OPT_Wbuiltin_macro_redefined:
 529       cpp_opts->warn_builtin_macro_redefined = value;
 530       break;
 531
 532     case OPT_Wcomment:
 533     case OPT_Wcomments:
 534       cpp_opts->warn_comments = value;
 535       break;
 536
 537     case OPT_Wc___compat:
 538       /* Because -Wenum-compare is the default in C++, -Wc++-compat
 539          implies -Wenum-compare.  */
 540       if (warn_enum_compare == -1 && value)
 541         warn_enum_compare = value;
 542       /* Because C++ always warns about a goto which misses an
 543          initialization, -Wc++-compat turns on -Wjump-misses-init.  */
 544       if (warn_jump_misses_init == -1 && value)
 545         warn_jump_misses_init = value;
 546       cpp_opts->warn_cxx_operator_names = value;
 547       break;
 548
 549     case OPT_Wdeprecated:
 550       cpp_opts->warn_deprecated = value;
 551       break;
 552
 553     case OPT_Wendif_labels:
 554       cpp_opts->warn_endif_labels = value;
 555       break;
 556
 557     case OPT_Werror:
 558       global_dc->warning_as_error_requested = value;
 559       break;
 560
 561     case OPT_Werror_implicit_function_declaration:
 562       /* For backward compatibility, this is the same as
 563          -Werror=implicit-function-declaration.  */
 564       enable_warning_as_error ("implicit-function-declaration", value, CL_C | CL_ObjC);
 565       break;
 566
 567     case OPT_Wformat:
 568       set_Wformat (value);
 569       break;
 570
 571     case OPT_Wformat_:
 572       set_Wformat (atoi (arg));
 573       break;
 574
 575     case OPT_Wimplicit:
 576       gcc_assert (value == 0 || value == 1);
 577       if (warn_implicit_int == -1)
 578         handle_option (OPT_Wimplicit_int, value, NULL,
 579                        c_family_lang_mask, kind);
 580       if (warn_implicit_function_declaration == -1)
 581         handle_option (OPT_Wimplicit_function_declaration, value, NULL,
 582                        c_family_lang_mask, kind);
 583       break;
 584
 585     case OPT_Wimport:
 586       /* Silently ignore for now.  */
 587       break;
 588
 589     case OPT_Winvalid_pch:
 590       cpp_opts->warn_invalid_pch = value;
 591       break;
 592
 593     case OPT_Wmissing_include_dirs:
 594       cpp_opts->warn_missing_include_dirs = value;
 595       break;
 596
 597     case OPT_Wmultichar:
 598       cpp_opts->warn_multichar = value;
 599       break;
 600
 601     case OPT_Wnormalized_:
 602       if (!value || (arg && strcasecmp (arg, "none") == 0))
 603         cpp_opts->warn_normalize = normalized_none;
 604       else if (!arg || strcasecmp (arg, "nfkc") == 0)
 605         cpp_opts->warn_normalize = normalized_KC;
 606       else if (strcasecmp (arg, "id") == 0)
 607         cpp_opts->warn_normalize = normalized_identifier_C;
 608       else if (strcasecmp (arg, "nfc") == 0)
 609         cpp_opts->warn_normalize = normalized_C;
 610       else
 611         error ("argument %qs to %<-Wnormalized%> not recognized", arg);
 612       break;
 613
 614     case OPT_Wreturn_type:
 615       warn_return_type = value;
 616       break;
 617
 618     case OPT_Wstrict_null_sentinel:
 619       warn_strict_null_sentinel = value;
 620       break;
 621
 622     case OPT_Wtraditional:
 623       cpp_opts->warn_traditional = value;
 624       break;
 625
 626     case OPT_Wtrigraphs:
 627       cpp_opts->warn_trigraphs = value;
 628       break;
 629
 630     case OPT_Wundef:
 631       cpp_opts->warn_undef = value;
 632       break;
 633
 634     case OPT_Wunknown_pragmas:
 635       /* Set to greater than 1, so that even unknown pragmas in
 636          system headers will be warned about.  */
 637       warn_unknown_pragmas = value * 2;
 638       break;
 639
 640     case OPT_Wunused_macros:
 641       warn_unused_macros = value;
 642       break;
 643
 644     case OPT_Wvariadic_macros:
 645       warn_variadic_macros = value;
 646       break;
 647
 648     case OPT_Wwrite_strings:
 649       warn_write_strings = value;
 650       break;
 651
 652     case OPT_Weffc__:
 653       warn_ecpp = value;
 654       if (value)
 655         warn_nonvdtor = true;
 656       break;
 657
 658     case OPT_ansi:
 659       if (!c_dialect_cxx ())
 660         set_std_c89 (false, true);
 661       else
 662         set_std_cxx98 (true);
 663       break;
 664
 665     case OPT_d:
 666       handle_OPT_d (arg);
 667       break;
 668
 669     case OPT_fcond_mismatch:
 670       if (!c_dialect_cxx ())
 671         {
 672           flag_cond_mismatch = value;
 673           break;
 674         }
 675       /* Fall through.  */
 676
 677     case OPT_fall_virtual:
 678     case OPT_falt_external_templates:
 679     case OPT_fenum_int_equiv:
 680     case OPT_fexternal_templates:
 681     case OPT_fguiding_decls:
 682     case OPT_fhonor_std:
 683     case OPT_fhuge_objects:
 684     case OPT_flabels_ok:
 685     case OPT_fname_mangling_version_:
 686     case OPT_fnew_abi:
 687     case OPT_fnonnull_objects:
 688     case OPT_fsquangle:
 689     case OPT_fstrict_prototype:
 690     case OPT_fthis_is_variable:
 691     case OPT_fvtable_thunks:
 692     case OPT_fxref:
 693     case OPT_fvtable_gc:
 694       warning (0, "switch %qs is no longer supported", option->opt_text);
 695       break;
 696
 697     case OPT_faccess_control:
 698       flag_access_control = value;
 699       break;
 700
 701     case OPT_fasm:
 702       flag_no_asm = !value;
 703       break;
 704
 705     case OPT_fbuiltin:
 706       flag_no_builtin = !value;
 707       break;
 708
 709     case OPT_fbuiltin_:
 710       if (value)
 711         result = 0;
 712       else
 713         disable_builtin_function (arg);
 714       break;
 715
 716     case OPT_fdirectives_only:
 717       cpp_opts->directives_only = value;
 718       break;
 719
 720     case OPT_fdollars_in_identifiers:
 721       cpp_opts->dollars_in_ident = value;
 722       break;
 723
 724     case OPT_ffreestanding:
 725       value = !value;
 726       /* Fall through....  */
 727     case OPT_fhosted:
 728       flag_hosted = value;
 729       flag_no_builtin = !value;
 730       break;
 731
 732     case OPT_fshort_double:
 733       flag_short_double = value;
 734       break;
 735
 736     case OPT_fshort_enums:
 737       flag_short_enums = value;
 738       break;
 739
 740     case OPT_fshort_wchar:
 741       flag_short_wchar = value;
 742       break;
 743
 744     case OPT_fsigned_bitfields:
 745       flag_signed_bitfields = value;
 746       break;
 747
 748     case OPT_fsigned_char:
 749       flag_signed_char = value;
 750       break;
 751
 752     case OPT_funsigned_bitfields:
 753       flag_signed_bitfields = !value;
 754       break;
 755
 756     case OPT_funsigned_char:
 757       flag_signed_char = !value;
 758       break;
 759
 760     case OPT_fcheck_new:
 761       flag_check_new = value;
 762       break;
 763
 764     case OPT_fconserve_space:
 765       flag_conserve_space = value;
 766       break;
 767
 768     case OPT_fconstant_string_class_:
 769       constant_string_class_name = arg;
 770       break;
 771
 772     case OPT_fdefault_inline:
 773       flag_default_inline = value;
 774       break;
 775
 776     case OPT_felide_constructors:
 777       flag_elide_constructors = value;
 778       break;
 779
 780     case OPT_fenforce_eh_specs:
 781       flag_enforce_eh_specs = value;
 782       break;
 783
 784     case OPT_fextended_identifiers:
 785       cpp_opts->extended_identifiers = value;
 786       break;
 787
 788     case OPT_ffor_scope:
 789       flag_new_for_scope = value;
 790       break;
 791
 792     case OPT_fgnu_keywords:
 793       flag_no_gnu_keywords = !value;
 794       break;
 795
 796     case OPT_fgnu_runtime:
 797       flag_next_runtime = !value;
 798       break;
 799
 800     case OPT_fhandle_exceptions:
 801       warning (0, "-fhandle-exceptions has been renamed -fexceptions (and is now on by default)");
 802       flag_exceptions = value;
 803       break;
 804
 805     case OPT_fimplement_inlines:
 806       flag_implement_inlines = value;
 807       break;
 808
 809     case OPT_fimplicit_inline_templates:
 810       flag_implicit_inline_templates = value;
 811       break;
 812
 813     case OPT_fimplicit_templates:
 814       flag_implicit_templates = value;
 815       break;
 816
 817     case OPT_flax_vector_conversions:
 818       flag_lax_vector_conversions = value;
 819       break;
 820
 821     case OPT_fms_extensions:
 822       flag_ms_extensions = value;
 823       break;
 824
 825     case OPT_fnext_runtime:
 826       flag_next_runtime = value;
 827       break;
 828
 829     case OPT_fnil_receivers:
 830       flag_nil_receivers = value;
 831       break;
 832
 833     case OPT_fnonansi_builtins:
 834       flag_no_nonansi_builtin = !value;
 835       break;
 836
 837     case OPT_foperator_names:
 838       cpp_opts->operator_names = value;
 839       break;
 840
 841     case OPT_foptional_diags:
 842       flag_optional_diags = value;
 843       break;
 844
 845     case OPT_fpch_deps:
 846       cpp_opts->restore_pch_deps = value;
 847       break;
 848
 849     case OPT_fpch_preprocess:
 850       flag_pch_preprocess = value;
 851       break;
 852
 853     case OPT_fpermissive:
 854       flag_permissive = value;
 855       break;
 856
 857     case OPT_fpreprocessed:
 858       cpp_opts->preprocessed = value;
 859       break;
 860
 861     case OPT_freplace_objc_classes:
 862       flag_replace_objc_classes = value;
 863       break;
 864
 865     case OPT_frepo:
 866       flag_use_repository = value;
 867       if (value)
 868         flag_implicit_templates = 0;
 869       break;
 870
 871     case OPT_frtti:
 872       flag_rtti = value;
 873       break;
 874
 875     case OPT_fshow_column:
 876       cpp_opts->show_column = value;
 877       break;
 878
 879     case OPT_fstats:
 880       flag_detailed_statistics = value;
 881       break;
 882
 883     case OPT_ftabstop_:
 884       /* It is documented that we silently ignore silly values.  */
 885       if (value >= 1 && value <= 100)
 886         cpp_opts->tabstop = value;
 887       break;
 888
 889     case OPT_fexec_charset_:
 890       cpp_opts->narrow_charset = arg;
 891       break;
 892
 893     case OPT_fwide_exec_charset_:
 894       cpp_opts->wide_charset = arg;
 895       break;
 896
 897     case OPT_finput_charset_:
 898       cpp_opts->input_charset = arg;
 899       break;
 900
 901     case OPT_ftemplate_depth_:
 902       /* Kept for backwards compatibility.  */
 903     case OPT_ftemplate_depth_eq:
 904       max_tinst_depth = value;
 905       break;
 906
 907     case OPT_fuse_cxa_atexit:
 908       flag_use_cxa_atexit = value;
 909       break;
 910
 911     case OPT_fuse_cxa_get_exception_ptr:
 912       flag_use_cxa_get_exception_ptr = value;
 913       break;
 914
 915     case OPT_fvisibility_inlines_hidden:
 916       visibility_options.inlines_hidden = value;
 917       break;
 918
 919     case OPT_fweak:
 920       flag_weak = value;
 921       break;
 922
 923     case OPT_fthreadsafe_statics:
 924       flag_threadsafe_statics = value;
 925       break;
 926
 927     case OPT_fpretty_templates:
 928       flag_pretty_templates = value;
 929       break;
 930
 931     case OPT_fzero_link:
 932       flag_zero_link = value;
 933       break;
 934
 935     case OPT_gen_decls:
 936       flag_gen_declaration = 1;
 937       break;
 938
 939     case OPT_femit_struct_debug_baseonly:
 940       set_struct_debug_option ("base");
 941       break;
 942
 943     case OPT_femit_struct_debug_reduced:
 944       set_struct_debug_option ("dir:ord:sys,dir:gen:any,ind:base");
 945       break;
 946
 947     case OPT_femit_struct_debug_detailed_:
 948       set_struct_debug_option (arg);
 949       break;
 950
 951     case OPT_idirafter:
 952       add_path (xstrdup (arg), AFTER, 0, true);
 953       break;
 954
 955     case OPT_imacros:
 956     case OPT_include:
 957       defer_opt (code, arg);
 958       break;
 959
 960     case OPT_imultilib:
 961       imultilib = arg;
 962       break;
 963
 964     case OPT_iprefix:
 965       iprefix = arg;
 966       break;
 967
 968     case OPT_iquote:
 969       add_path (xstrdup (arg), QUOTE, 0, true);
 970       break;
 971
 972     case OPT_isysroot:
 973       sysroot = arg;
 974       break;
 975
 976     case OPT_isystem:
 977       add_path (xstrdup (arg), SYSTEM, 0, true);
 978       break;
 979
 980     case OPT_iwithprefix:
 981       add_prefixed_path (arg, SYSTEM);
 982       break;
 983
 984     case OPT_iwithprefixbefore:
 985       add_prefixed_path (arg, BRACKET);
 986       break;
 987
 988     case OPT_lang_asm:
 989       cpp_set_lang (parse_in, CLK_ASM);
 990       cpp_opts->dollars_in_ident = false;
 991       break;
 992
 993     case OPT_lang_objc:
 994       cpp_opts->objc = 1;
 995       break;
 996
 997     case OPT_nostdinc:
 998       std_inc = false;
 999       break;
1000
1001     case OPT_nostdinc__:
1002       std_cxx_inc = false;
1003       break;
1004
1005     case OPT_o:
1006       if (!out_fname)
1007         out_fname = arg;
1008       else
1009         error ("output filename specified twice");
1010       break;
1011
1012       /* We need to handle the -pedantic switches here, rather than in
1013          c_common_post_options, so that a subsequent -Wno-endif-labels
1014          is not overridden.  */
1015     case OPT_pedantic_errors:
1016     case OPT_pedantic:
1017       cpp_opts->pedantic = 1;
1018       cpp_opts->warn_endif_labels = 1;
1019       if (warn_pointer_sign == -1)
1020         warn_pointer_sign = 1;
1021       if (warn_overlength_strings == -1)
1022         warn_overlength_strings = 1;
1023       if (warn_main == -1)
1024         warn_main = 2;
1025       break;
1026
1027     case OPT_print_objc_runtime_info:
1028       print_struct_values = 1;
1029       break;
1030
1031     case OPT_print_pch_checksum:
1032       c_common_print_pch_checksum (stdout);
1033       exit_after_options = true;
1034       break;
1035
1036     case OPT_remap:
1037       cpp_opts->remap = 1;
1038       break;
1039
1040     case OPT_std_c__98:
1041     case OPT_std_gnu__98:
1042       if (!preprocessing_asm_p)
1043         set_std_cxx98 (code == OPT_std_c__98 /* ISO */);
1044       break;
1045
1046     case OPT_std_c__0x:
1047     case OPT_std_gnu__0x:
1048       if (!preprocessing_asm_p)
1049         set_std_cxx0x (code == OPT_std_c__0x /* ISO */);
1050       break;
1051
1052     case OPT_std_c89:
1053     case OPT_std_c90:
1054     case OPT_std_iso9899_1990:
1055     case OPT_std_iso9899_199409:
1056       if (!preprocessing_asm_p)
1057         set_std_c89 (code == OPT_std_iso9899_199409 /* c94 */, true /* ISO */);
1058       break;
1059
1060     case OPT_std_gnu89:
1061     case OPT_std_gnu90:
1062       if (!preprocessing_asm_p)
1063         set_std_c89 (false /* c94 */, false /* ISO */);
1064       break;
1065
1066     case OPT_std_c99:
1067     case OPT_std_c9x:
1068     case OPT_std_iso9899_1999:
1069     case OPT_std_iso9899_199x:
1070       if (!preprocessing_asm_p)
1071         set_std_c99 (true /* ISO */);
1072       break;
1073
1074     case OPT_std_gnu99:
1075     case OPT_std_gnu9x:
1076       if (!preprocessing_asm_p)
1077         set_std_c99 (false /* ISO */);
1078       break;
1079
1080     case OPT_std_c1x:
1081       if (!preprocessing_asm_p)
1082         set_std_c1x (true /* ISO */);
1083       break;
1084
1085     case OPT_std_gnu1x:
1086       if (!preprocessing_asm_p)
1087         set_std_c1x (false /* ISO */);
1088       break;
1089
1090     case OPT_trigraphs:
1091       cpp_opts->trigraphs = 1;
1092       break;
1093
1094     case OPT_traditional_cpp:
1095       cpp_opts->traditional = 1;
1096       break;
1097
1098     case OPT_undef:
1099       flag_undef = 1;
1100       break;
1101
1102     case OPT_v:
1103       verbose = true;
1104       break;
1105
1106     case OPT_Wabi:
1107       warn_psabi = value;
1108       break;
1109     }
1110
1111   return result;
1112 }
1113
1114 /* Post-switch processing.  */
1115 bool
1116 c_common_post_options (const char **pfilename)
1117 {
1118   struct cpp_callbacks *cb;
1119
1120   /* Canonicalize the input and output filenames.  */
1121   if (in_fnames == NULL)
1122     {
1123       in_fnames = XNEWVEC (const char *, 1);
1124       in_fnames[0] = "";
1125     }
1126   else if (strcmp (in_fnames[0], "-") == 0)
1127     in_fnames[0] = "";
1128
1129   if (out_fname == NULL || !strcmp (out_fname, "-"))
1130     out_fname = "";
1131
1132   if (cpp_opts->deps.style == DEPS_NONE)
1133     check_deps_environment_vars ();
1134
1135   handle_deferred_opts ();
1136
1137   sanitize_cpp_opts ();
1138
1139   register_include_chains (parse_in, sysroot, iprefix, imultilib,
1140                            std_inc, std_cxx_inc && c_dialect_cxx (), verbose);
1141
1142 #ifdef C_COMMON_OVERRIDE_OPTIONS
1143   /* Some machines may reject certain combinations of C
1144      language-specific options.  */
1145   C_COMMON_OVERRIDE_OPTIONS;
1146 #endif
1147
1148   /* Excess precision other than "fast" requires front-end
1149      support.  */
1150   if (c_dialect_cxx ())
1151     {
1152       if (flag_excess_precision_cmdline == EXCESS_PRECISION_STANDARD
1153           && TARGET_FLT_EVAL_METHOD_NON_DEFAULT)
1154         sorry ("-fexcess-precision=standard for C++");
1155       flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
1156     }
1157   else if (flag_excess_precision_cmdline == EXCESS_PRECISION_DEFAULT)
1158     flag_excess_precision_cmdline = (flag_iso
1159                                      ? EXCESS_PRECISION_STANDARD
1160                                      : EXCESS_PRECISION_FAST);
1161
1162   /* By default we use C99 inline semantics in GNU99 or C99 mode.  C99
1163      inline semantics are not supported in GNU89 or C89 mode.  */
1164   if (flag_gnu89_inline == -1)
1165     flag_gnu89_inline = !flag_isoc99;
1166   else if (!flag_gnu89_inline && !flag_isoc99)
1167     error ("-fno-gnu89-inline is only supported in GNU99 or C99 mode");
1168
1169   /* Default to ObjC sjlj exception handling if NeXT runtime.  */
1170   if (flag_objc_sjlj_exceptions < 0)
1171     flag_objc_sjlj_exceptions = flag_next_runtime;
1172   if (flag_objc_exceptions && !flag_objc_sjlj_exceptions)
1173     flag_exceptions = 1;
1174
1175   /* -Wextra implies the following flags
1176      unless explicitly overridden.  */
1177   if (warn_type_limits == -1)
1178     warn_type_limits = extra_warnings;
1179   if (warn_clobbered == -1)
1180     warn_clobbered = extra_warnings;
1181   if (warn_empty_body == -1)
1182     warn_empty_body = extra_warnings;
1183   if (warn_sign_compare == -1)
1184     warn_sign_compare = extra_warnings;
1185   if (warn_missing_field_initializers == -1)
1186     warn_missing_field_initializers = extra_warnings;
1187   if (warn_missing_parameter_type == -1)
1188     warn_missing_parameter_type = extra_warnings;
1189   if (warn_old_style_declaration == -1)
1190     warn_old_style_declaration = extra_warnings;
1191   if (warn_override_init == -1)
1192     warn_override_init = extra_warnings;
1193   if (warn_ignored_qualifiers == -1)
1194     warn_ignored_qualifiers = extra_warnings;
1195
1196   /* -Wpointer-sign is disabled by default, but it is enabled if any
1197      of -Wall or -pedantic are given.  */
1198   if (warn_pointer_sign == -1)
1199     warn_pointer_sign = 0;
1200
1201   if (warn_strict_aliasing == -1)
1202     warn_strict_aliasing = 0;
1203   if (warn_strict_overflow == -1)
1204     warn_strict_overflow = 0;
1205   if (warn_jump_misses_init == -1)
1206     warn_jump_misses_init = 0;
1207
1208   /* -Woverlength-strings is off by default, but is enabled by -pedantic.
1209      It is never enabled in C++, as the minimum limit is not normative
1210      in that standard.  */
1211   if (warn_overlength_strings == -1 || c_dialect_cxx ())
1212     warn_overlength_strings = 0;
1213
1214   /* Wmain is enabled by default in C++ but not in C.  */
1215   /* Wmain is disabled by default for -ffreestanding (!flag_hosted),
1216      even if -Wall was given (warn_main will be 2 if set by -Wall, 1
1217      if set by -Wmain).  */
1218   if (warn_main == -1)
1219     warn_main = (c_dialect_cxx () && flag_hosted) ? 1 : 0;
1220   else if (warn_main == 2)
1221     warn_main = flag_hosted ? 1 : 0;
1222
1223   /* In C, -Wconversion enables -Wsign-conversion (unless disabled
1224      through -Wno-sign-conversion). While in C++,
1225      -Wsign-conversion needs to be requested explicitly.  */
1226   if (warn_sign_conversion == -1)
1227     warn_sign_conversion =  (c_dialect_cxx ()) ? 0 : warn_conversion;
1228
1229   /* In C, -Wall and -Wc++-compat enable -Wenum-compare, which we do
1230      in c_common_handle_option; if it has not yet been set, it is
1231      disabled by default.  In C++, it is enabled by default.  */
1232   if (warn_enum_compare == -1)
1233     warn_enum_compare = c_dialect_cxx () ? 1 : 0;
1234
1235   /* -Wpacked-bitfield-compat is on by default for the C languages.  The
1236      warning is issued in stor-layout.c which is not part of the front-end so
1237      we need to selectively turn it on here.  */
1238   if (warn_packed_bitfield_compat == -1)
1239     warn_packed_bitfield_compat = 1;
1240
1241   /* Special format checking options don't work without -Wformat; warn if
1242      they are used.  */
1243   if (!warn_format)
1244     {
1245       warning (OPT_Wformat_y2k,
1246                "-Wformat-y2k ignored without -Wformat");
1247       warning (OPT_Wformat_extra_args,
1248                "-Wformat-extra-args ignored without -Wformat");
1249       warning (OPT_Wformat_zero_length,
1250                "-Wformat-zero-length ignored without -Wformat");
1251       warning (OPT_Wformat_nonliteral,
1252                "-Wformat-nonliteral ignored without -Wformat");
1253       warning (OPT_Wformat_contains_nul,
1254                "-Wformat-contains-nul ignored without -Wformat");
1255       warning (OPT_Wformat_security,
1256                "-Wformat-security ignored without -Wformat");
1257     }
1258
1259   if (warn_implicit == -1)
1260     warn_implicit = 0;
1261
1262   if (warn_implicit_int == -1)
1263     warn_implicit_int = 0;
1264
1265   /* -Wimplicit-function-declaration is enabled by default for C99.  */
1266   if (warn_implicit_function_declaration == -1)
1267     warn_implicit_function_declaration = flag_isoc99;
1268
1269   /* If we're allowing C++0x constructs, don't warn about C++0x
1270      compatibility problems.  */
1271   if (cxx_dialect == cxx0x)
1272     warn_cxx0x_compat = 0;
1273
1274   if (flag_preprocess_only)
1275     {
1276       /* Open the output now.  We must do so even if flag_no_output is
1277          on, because there may be other output than from the actual
1278          preprocessing (e.g. from -dM).  */
1279       if (out_fname[0] == '\0')
1280         out_stream = stdout;
1281       else
1282         out_stream = fopen (out_fname, "w");
1283
1284       if (out_stream == NULL)
1285         {
1286           fatal_error ("opening output file %s: %m", out_fname);
1287           return false;
1288         }
1289
1290       if (num_in_fnames > 1)
1291         error ("too many filenames given.  Type %s --help for usage",
1292                progname);
1293
1294       init_pp_output (out_stream);
1295     }
1296   else
1297     {
1298       init_c_lex ();
1299
1300       /* Yuk.  WTF is this?  I do know ObjC relies on it somewhere.  */
1301       input_location = UNKNOWN_LOCATION;
1302     }
1303
1304   cb = cpp_get_callbacks (parse_in);
1305   cb->file_change = cb_file_change;
1306   cb->dir_change = cb_dir_change;
1307   cpp_post_options (parse_in);
1308
1309   input_location = UNKNOWN_LOCATION;
1310
1311   *pfilename = this_input_filename
1312     = cpp_read_main_file (parse_in, in_fnames[0]);
1313   /* Don't do any compilation or preprocessing if there is no input file.  */
1314   if (this_input_filename == NULL)
1315     {
1316       errorcount++;
1317       return false;
1318     }
1319
1320   if (flag_working_directory
1321       && flag_preprocess_only && !flag_no_line_commands)
1322     pp_dir_change (parse_in, get_src_pwd ());
1323
1324   return flag_preprocess_only;
1325 }
1326
1327 /* Front end initialization common to C, ObjC and C++.  */
1328 bool
1329 c_common_init (void)
1330 {
1331   /* Set up preprocessor arithmetic.  Must be done after call to
1332      c_common_nodes_and_builtins for type nodes to be good.  */
1333   cpp_opts->precision = TYPE_PRECISION (intmax_type_node);
1334   cpp_opts->char_precision = TYPE_PRECISION (char_type_node);
1335   cpp_opts->int_precision = TYPE_PRECISION (integer_type_node);
1336   cpp_opts->wchar_precision = TYPE_PRECISION (wchar_type_node);
1337   cpp_opts->unsigned_wchar = TYPE_UNSIGNED (wchar_type_node);
1338   cpp_opts->bytes_big_endian = BYTES_BIG_ENDIAN;
1339
1340   /* This can't happen until after wchar_precision and bytes_big_endian
1341      are known.  */
1342   cpp_init_iconv (parse_in);
1343
1344   if (version_flag)
1345     c_common_print_pch_checksum (stderr);
1346
1347   /* Has to wait until now so that cpplib has its hash table.  */
1348   init_pragma ();
1349
1350   if (flag_preprocess_only)
1351     {
1352       finish_options ();
1353       preprocess_file (parse_in);
1354       return false;
1355     }
1356
1357   return true;
1358 }
1359
1360 /* Initialize the integrated preprocessor after debug output has been
1361    initialized; loop over each input file.  */
1362 void
1363 c_common_parse_file (int set_yydebug)
1364 {
1365   unsigned int i;
1366
1367   if (set_yydebug)
1368     switch (c_language)
1369       {
1370       case clk_c:
1371         warning(0, "The C parser does not support -dy, option ignored");
1372         break;
1373       case clk_objc:
1374         warning(0,
1375                 "The Objective-C parser does not support -dy, option ignored");
1376         break;
1377       case clk_cxx:
1378         warning(0, "The C++ parser does not support -dy, option ignored");
1379         break;
1380       case clk_objcxx:
1381         warning(0,
1382             "The Objective-C++ parser does not support -dy, option ignored");
1383         break;
1384       default:
1385         gcc_unreachable ();
1386     }
1387
1388   i = 0;
1389   for (;;)
1390     {
1391       /* Start the main input file, if the debug writer wants it. */
1392       if (debug_hooks->start_end_main_source_file)
1393         (*debug_hooks->start_source_file) (0, this_input_filename);
1394       finish_options ();
1395       pch_init ();
1396       push_file_scope ();
1397       c_parse_file ();
1398       finish_file ();
1399       pop_file_scope ();
1400       /* And end the main input file, if the debug writer wants it  */
1401       if (debug_hooks->start_end_main_source_file)
1402         (*debug_hooks->end_source_file) (0);
1403       if (++i >= num_in_fnames)
1404         break;
1405       cpp_undef_all (parse_in);
1406       cpp_clear_file_cache (parse_in);
1407       this_input_filename
1408         = cpp_read_main_file (parse_in, in_fnames[i]);
1409       /* If an input file is missing, abandon further compilation.
1410          cpplib has issued a diagnostic.  */
1411       if (!this_input_filename)
1412         break;
1413     }
1414 }
1415
1416 /* Common finish hook for the C, ObjC and C++ front ends.  */
1417 void
1418 c_common_finish (void)
1419 {
1420   FILE *deps_stream = NULL;
1421
1422   /* Don't write the deps file if there are errors.  */
1423   if (cpp_opts->deps.style != DEPS_NONE && errorcount == 0)
1424     {
1425       /* If -M or -MM was seen without -MF, default output to the
1426          output stream.  */
1427       if (!deps_file)
1428         deps_stream = out_stream;
1429       else
1430         {
1431           deps_stream = fopen (deps_file, deps_append ? "a": "w");
1432           if (!deps_stream)
1433             fatal_error ("opening dependency file %s: %m", deps_file);
1434         }
1435     }
1436
1437   /* For performance, avoid tearing down cpplib's internal structures
1438      with cpp_destroy ().  */
1439   cpp_finish (parse_in, deps_stream);
1440
1441   if (deps_stream && deps_stream != out_stream
1442       && (ferror (deps_stream) || fclose (deps_stream)))
1443     fatal_error ("closing dependency file %s: %m", deps_file);
1444
1445   if (out_stream && (ferror (out_stream) || fclose (out_stream)))
1446     fatal_error ("when writing output to %s: %m", out_fname);
1447 }
1448
1449 /* Either of two environment variables can specify output of
1450    dependencies.  Their value is either "OUTPUT_FILE" or "OUTPUT_FILE
1451    DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to
1452    and DEPS_TARGET is the target to mention in the deps.  They also
1453    result in dependency information being appended to the output file
1454    rather than overwriting it, and like Sun's compiler
1455    SUNPRO_DEPENDENCIES suppresses the dependency on the main file.  */
1456 static void
1457 check_deps_environment_vars (void)
1458 {
1459   char *spec;
1460
1461   GET_ENVIRONMENT (spec, "DEPENDENCIES_OUTPUT");
1462   if (spec)
1463     cpp_opts->deps.style = DEPS_USER;
1464   else
1465     {
1466       GET_ENVIRONMENT (spec, "SUNPRO_DEPENDENCIES");
1467       if (spec)
1468         {
1469           cpp_opts->deps.style = DEPS_SYSTEM;
1470           cpp_opts->deps.ignore_main_file = true;
1471         }
1472     }
1473
1474   if (spec)
1475     {
1476       /* Find the space before the DEPS_TARGET, if there is one.  */
1477       char *s = strchr (spec, ' ');
1478       if (s)
1479         {
1480           /* Let the caller perform MAKE quoting.  */
1481           defer_opt (OPT_MT, s + 1);
1482           *s = '\0';
1483         }
1484
1485       /* Command line -MF overrides environment variables and default.  */
1486       if (!deps_file)
1487         deps_file = spec;
1488
1489       deps_append = 1;
1490       deps_seen = true;
1491     }
1492 }
1493
1494 /* Handle deferred command line switches.  */
1495 static void
1496 handle_deferred_opts (void)
1497 {
1498   size_t i;
1499   struct deps *deps;
1500
1501   /* Avoid allocating the deps buffer if we don't need it.
1502      (This flag may be true without there having been -MT or -MQ
1503      options, but we'll still need the deps buffer.)  */
1504   if (!deps_seen)
1505     return;
1506
1507   deps = cpp_get_deps (parse_in);
1508
1509   for (i = 0; i < deferred_count; i++)
1510     {
1511       struct deferred_opt *opt = &deferred_opts[i];
1512
1513       if (opt->code == OPT_MT || opt->code == OPT_MQ)
1514         deps_add_target (deps, opt->arg, opt->code == OPT_MQ);
1515     }
1516 }
1517
1518 /* These settings are appropriate for GCC, but not necessarily so for
1519    cpplib as a library.  */
1520 static void
1521 sanitize_cpp_opts (void)
1522 {
1523   /* If we don't know what style of dependencies to output, complain
1524      if any other dependency switches have been given.  */
1525   if (deps_seen && cpp_opts->deps.style == DEPS_NONE)
1526     error ("to generate dependencies you must specify either -M or -MM");
1527
1528   /* -dM and dependencies suppress normal output; do it here so that
1529      the last -d[MDN] switch overrides earlier ones.  */
1530   if (flag_dump_macros == 'M')
1531     flag_no_output = 1;
1532
1533   /* By default, -fdirectives-only implies -dD.  This allows subsequent phases
1534      to perform proper macro expansion.  */
1535   if (cpp_opts->directives_only && !cpp_opts->preprocessed && !flag_dump_macros)
1536     flag_dump_macros = 'D';
1537
1538   /* Disable -dD, -dN and -dI if normal output is suppressed.  Allow
1539      -dM since at least glibc relies on -M -dM to work.  */
1540   /* Also, flag_no_output implies flag_no_line_commands, always.  */
1541   if (flag_no_output)
1542     {
1543       if (flag_dump_macros != 'M')
1544         flag_dump_macros = 0;
1545       flag_dump_includes = 0;
1546       flag_no_line_commands = 1;
1547     }
1548   else if (cpp_opts->deps.missing_files)
1549     error ("-MG may only be used with -M or -MM");
1550
1551   cpp_opts->unsigned_char = !flag_signed_char;
1552   cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS;
1553
1554   /* Wlong-long is disabled by default. It is enabled by:
1555       [-pedantic | -Wtraditional] -std=[gnu|c]++98 ; or
1556       [-pedantic | -Wtraditional] -std=non-c99 .
1557
1558       Either -Wlong-long or -Wno-long-long override any other settings.  */
1559   if (warn_long_long == -1)
1560     warn_long_long = ((pedantic || warn_traditional)
1561                       && (c_dialect_cxx () ? cxx_dialect == cxx98 : !flag_isoc99));
1562   cpp_opts->warn_long_long = warn_long_long;
1563
1564   /* Similarly with -Wno-variadic-macros.  No check for c99 here, since
1565      this also turns off warnings about GCCs extension.  */
1566   cpp_opts->warn_variadic_macros
1567     = warn_variadic_macros && (pedantic || warn_traditional);
1568
1569   /* If we're generating preprocessor output, emit current directory
1570      if explicitly requested or if debugging information is enabled.
1571      ??? Maybe we should only do it for debugging formats that
1572      actually output the current directory?  */
1573   if (flag_working_directory == -1)
1574     flag_working_directory = (debug_info_level != DINFO_LEVEL_NONE);
1575
1576   if (cpp_opts->directives_only)
1577     {
1578       if (warn_unused_macros)
1579         error ("-fdirectives-only is incompatible with -Wunused_macros");
1580       if (cpp_opts->traditional)
1581         error ("-fdirectives-only is incompatible with -traditional");
1582     }
1583 }
1584
1585 /* Add include path with a prefix at the front of its name.  */
1586 static void
1587 add_prefixed_path (const char *suffix, size_t chain)
1588 {
1589   char *path;
1590   const char *prefix;
1591   size_t prefix_len, suffix_len;
1592
1593   suffix_len = strlen (suffix);
1594   prefix     = iprefix ? iprefix : cpp_GCC_INCLUDE_DIR;
1595   prefix_len = iprefix ? strlen (iprefix) : cpp_GCC_INCLUDE_DIR_len;
1596
1597   path = (char *) xmalloc (prefix_len + suffix_len + 1);
1598   memcpy (path, prefix, prefix_len);
1599   memcpy (path + prefix_len, suffix, suffix_len);
1600   path[prefix_len + suffix_len] = '\0';
1601
1602   add_path (path, chain, 0, false);
1603 }
1604
1605 /* Handle -D, -U, -A, -imacros, and the first -include.  */
1606 static void
1607 finish_options (void)
1608 {
1609   if (!cpp_opts->preprocessed)
1610     {
1611       size_t i;
1612
1613       cb_file_change (parse_in,
1614                       linemap_add (line_table, LC_RENAME, 0,
1615                                    _("<built-in>"), 0));
1616
1617       cpp_init_builtins (parse_in, flag_hosted);
1618       c_cpp_builtins (parse_in);
1619
1620       /* We're about to send user input to cpplib, so make it warn for
1621          things that we previously (when we sent it internal definitions)
1622          told it to not warn.
1623
1624          C99 permits implementation-defined characters in identifiers.
1625          The documented meaning of -std= is to turn off extensions that
1626          conflict with the specified standard, and since a strictly
1627          conforming program cannot contain a '$', we do not condition
1628          their acceptance on the -std= setting.  */
1629       cpp_opts->warn_dollars = (cpp_opts->pedantic && !cpp_opts->c99);
1630
1631       cb_file_change (parse_in,
1632                       linemap_add (line_table, LC_RENAME, 0,
1633                                    _("<command-line>"), 0));
1634
1635       for (i = 0; i < deferred_count; i++)
1636         {
1637           struct deferred_opt *opt = &deferred_opts[i];
1638
1639           if (opt->code == OPT_D)
1640             cpp_define (parse_in, opt->arg);
1641           else if (opt->code == OPT_U)
1642             cpp_undef (parse_in, opt->arg);
1643           else if (opt->code == OPT_A)
1644             {
1645               if (opt->arg[0] == '-')
1646                 cpp_unassert (parse_in, opt->arg + 1);
1647               else
1648                 cpp_assert (parse_in, opt->arg);
1649             }
1650         }
1651
1652       /* Handle -imacros after -D and -U.  */
1653       for (i = 0; i < deferred_count; i++)
1654         {
1655           struct deferred_opt *opt = &deferred_opts[i];
1656
1657           if (opt->code == OPT_imacros
1658               && cpp_push_include (parse_in, opt->arg))
1659             {
1660               /* Disable push_command_line_include callback for now.  */
1661               include_cursor = deferred_count + 1;
1662               cpp_scan_nooutput (parse_in);
1663             }
1664         }
1665     }
1666   else if (cpp_opts->directives_only)
1667     cpp_init_special_builtins (parse_in);
1668
1669   include_cursor = 0;
1670   push_command_line_include ();
1671 }
1672
1673 /* Give CPP the next file given by -include, if any.  */
1674 static void
1675 push_command_line_include (void)
1676 {
1677   while (include_cursor < deferred_count)
1678     {
1679       struct deferred_opt *opt = &deferred_opts[include_cursor++];
1680
1681       if (!cpp_opts->preprocessed && opt->code == OPT_include
1682           && cpp_push_include (parse_in, opt->arg))
1683         return;
1684     }
1685
1686   if (include_cursor == deferred_count)
1687     {
1688       include_cursor++;
1689       /* -Wunused-macros should only warn about macros defined hereafter.  */
1690       cpp_opts->warn_unused_macros = warn_unused_macros;
1691       /* Restore the line map from <command line>.  */
1692       if (!cpp_opts->preprocessed)
1693         cpp_change_file (parse_in, LC_RENAME, this_input_filename);
1694
1695       /* Set this here so the client can change the option if it wishes,
1696          and after stacking the main file so we don't trace the main file.  */
1697       line_table->trace_includes = cpp_opts->print_include_names;
1698     }
1699 }
1700
1701 /* File change callback.  Has to handle -include files.  */
1702 static void
1703 cb_file_change (cpp_reader * ARG_UNUSED (pfile),
1704                 const struct line_map *new_map)
1705 {
1706   if (flag_preprocess_only)
1707     pp_file_change (new_map);
1708   else
1709     fe_file_change (new_map);
1710
1711   if (new_map == 0 || (new_map->reason == LC_LEAVE && MAIN_FILE_P (new_map)))
1712     push_command_line_include ();
1713 }
1714
1715 void
1716 cb_dir_change (cpp_reader * ARG_UNUSED (pfile), const char *dir)
1717 {
1718   if (!set_src_pwd (dir))
1719     warning (0, "too late for # directive to set debug directory");
1720 }
1721
1722 /* Set the C 89 standard (with 1994 amendments if C94, without GNU
1723    extensions if ISO).  There is no concept of gnu94.  */
1724 static void
1725 set_std_c89 (int c94, int iso)
1726 {
1727   cpp_set_lang (parse_in, c94 ? CLK_STDC94: iso ? CLK_STDC89: CLK_GNUC89);
1728   flag_iso = iso;
1729   flag_no_asm = iso;
1730   flag_no_gnu_keywords = iso;
1731   flag_no_nonansi_builtin = iso;
1732   flag_isoc94 = c94;
1733   flag_isoc99 = 0;
1734   flag_isoc1x = 0;
1735 }
1736
1737 /* Set the C 99 standard (without GNU extensions if ISO).  */
1738 static void
1739 set_std_c99 (int iso)
1740 {
1741   cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99);
1742   flag_no_asm = iso;
1743   flag_no_nonansi_builtin = iso;
1744   flag_iso = iso;
1745   flag_isoc1x = 0;
1746   flag_isoc99 = 1;
1747   flag_isoc94 = 1;
1748 }
1749
1750 /* Set the C 1X standard draft (without GNU extensions if ISO).  */
1751 static void
1752 set_std_c1x (int iso)
1753 {
1754   cpp_set_lang (parse_in, iso ? CLK_STDC1X: CLK_GNUC1X);
1755   flag_no_asm = iso;
1756   flag_no_nonansi_builtin = iso;
1757   flag_iso = iso;
1758   flag_isoc1x = 1;
1759   flag_isoc99 = 1;
1760   flag_isoc94 = 1;
1761 }
1762
1763 /* Set the C++ 98 standard (without GNU extensions if ISO).  */
1764 static void
1765 set_std_cxx98 (int iso)
1766 {
1767   cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX);
1768   flag_no_gnu_keywords = iso;
1769   flag_no_nonansi_builtin = iso;
1770   flag_iso = iso;
1771   cxx_dialect = cxx98;
1772 }
1773
1774 /* Set the C++ 0x working draft "standard" (without GNU extensions if ISO).  */
1775 static void
1776 set_std_cxx0x (int iso)
1777 {
1778   cpp_set_lang (parse_in, iso ? CLK_CXX0X: CLK_GNUCXX0X);
1779   flag_no_gnu_keywords = iso;
1780   flag_no_nonansi_builtin = iso;
1781   flag_iso = iso;
1782   cxx_dialect = cxx0x;
1783 }
1784
1785 /* Args to -d specify what to dump.  Silently ignore
1786    unrecognized options; they may be aimed at toplev.c.  */
1787 static void
1788 handle_OPT_d (const char *arg)
1789 {
1790   char c;
1791
1792   while ((c = *arg++) != '\0')
1793     switch (c)
1794       {
1795       case 'M':                 /* Dump macros only.  */
1796       case 'N':                 /* Dump names.  */
1797       case 'D':                 /* Dump definitions.  */
1798       case 'U':                 /* Dump used macros.  */
1799         flag_dump_macros = c;
1800         break;
1801
1802       case 'I':
1803         flag_dump_includes = 1;
1804         break;
1805       }
1806 }