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