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_fshow_column:
 763       cpp_opts->show_column = value;
 764       break;
 765
 766     case OPT_ftabstop_:
 767       /* It is documented that we silently ignore silly values.  */
 768       if (value >= 1 && value <= 100)
 769         cpp_opts->tabstop = value;
 770       break;
 771
 772     case OPT_fexec_charset_:
 773       cpp_opts->narrow_charset = arg;
 774       break;
 775
 776     case OPT_fwide_exec_charset_:
 777       cpp_opts->wide_charset = arg;
 778       break;
 779
 780     case OPT_finput_charset_:
 781       cpp_opts->input_charset = arg;
 782       break;
 783
 784     case OPT_ftemplate_depth_:
 785       /* Kept for backwards compatibility.  */
 786     case OPT_ftemplate_depth_eq:
 787       max_tinst_depth = value;
 788       break;
 789
 790     case OPT_fvisibility_inlines_hidden:
 791       visibility_options.inlines_hidden = value;
 792       break;
 793
 794     case OPT_femit_struct_debug_baseonly:
 795       set_struct_debug_option ("base");
 796       break;
 797
 798     case OPT_femit_struct_debug_reduced:
 799       set_struct_debug_option ("dir:ord:sys,dir:gen:any,ind:base");
 800       break;
 801
 802     case OPT_femit_struct_debug_detailed_:
 803       set_struct_debug_option (arg);
 804       break;
 805
 806     case OPT_idirafter:
 807       add_path (xstrdup (arg), AFTER, 0, true);
 808       break;
 809
 810     case OPT_imacros:
 811     case OPT_include:
 812       defer_opt (code, arg);
 813       break;
 814
 815     case OPT_imultilib:
 816       imultilib = arg;
 817       break;
 818
 819     case OPT_iprefix:
 820       iprefix = arg;
 821       break;
 822
 823     case OPT_iquote:
 824       add_path (xstrdup (arg), QUOTE, 0, true);
 825       break;
 826
 827     case OPT_isysroot:
 828       sysroot = arg;
 829       break;
 830
 831     case OPT_isystem:
 832       add_path (xstrdup (arg), SYSTEM, 0, true);
 833       break;
 834
 835     case OPT_iwithprefix:
 836       add_prefixed_path (arg, SYSTEM);
 837       break;
 838
 839     case OPT_iwithprefixbefore:
 840       add_prefixed_path (arg, BRACKET);
 841       break;
 842
 843     case OPT_lang_asm:
 844       cpp_set_lang (parse_in, CLK_ASM);
 845       cpp_opts->dollars_in_ident = false;
 846       break;
 847
 848     case OPT_lang_objc:
 849       cpp_opts->objc = 1;
 850       break;
 851
 852     case OPT_nostdinc:
 853       std_inc = false;
 854       break;
 855
 856     case OPT_nostdinc__:
 857       std_cxx_inc = false;
 858       break;
 859
 860     case OPT_o:
 861       if (!out_fname)
 862         out_fname = arg;
 863       else
 864         error ("output filename specified twice");
 865       break;
 866
 867       /* We need to handle the -pedantic switches here, rather than in
 868          c_common_post_options, so that a subsequent -Wno-endif-labels
 869          is not overridden.  */
 870     case OPT_pedantic_errors:
 871     case OPT_pedantic:
 872       cpp_opts->pedantic = 1;
 873       cpp_opts->warn_endif_labels = 1;
 874       if (warn_pointer_sign == -1)
 875         warn_pointer_sign = 1;
 876       if (warn_overlength_strings == -1)
 877         warn_overlength_strings = 1;
 878       if (warn_main == -1)
 879         warn_main = 2;
 880       break;
 881
 882     case OPT_print_objc_runtime_info:
 883       print_struct_values = 1;
 884       break;
 885
 886     case OPT_print_pch_checksum:
 887       c_common_print_pch_checksum (stdout);
 888       exit_after_options = true;
 889       break;
 890
 891     case OPT_remap:
 892       cpp_opts->remap = 1;
 893       break;
 894
 895     case OPT_std_c__98:
 896     case OPT_std_gnu__98:
 897       if (!preprocessing_asm_p)
 898         set_std_cxx98 (code == OPT_std_c__98 /* ISO */);
 899       break;
 900
 901     case OPT_std_c__0x:
 902     case OPT_std_gnu__0x:
 903       if (!preprocessing_asm_p)
 904         set_std_cxx0x (code == OPT_std_c__0x /* ISO */);
 905       break;
 906
 907     case OPT_std_c89:
 908     case OPT_std_c90:
 909     case OPT_std_iso9899_1990:
 910     case OPT_std_iso9899_199409:
 911       if (!preprocessing_asm_p)
 912         set_std_c89 (code == OPT_std_iso9899_199409 /* c94 */, true /* ISO */);
 913       break;
 914
 915     case OPT_std_gnu89:
 916     case OPT_std_gnu90:
 917       if (!preprocessing_asm_p)
 918         set_std_c89 (false /* c94 */, false /* ISO */);
 919       break;
 920
 921     case OPT_std_c99:
 922     case OPT_std_c9x:
 923     case OPT_std_iso9899_1999:
 924     case OPT_std_iso9899_199x:
 925       if (!preprocessing_asm_p)
 926         set_std_c99 (true /* ISO */);
 927       break;
 928
 929     case OPT_std_gnu99:
 930     case OPT_std_gnu9x:
 931       if (!preprocessing_asm_p)
 932         set_std_c99 (false /* ISO */);
 933       break;
 934
 935     case OPT_std_c1x:
 936       if (!preprocessing_asm_p)
 937         set_std_c1x (true /* ISO */);
 938       break;
 939
 940     case OPT_std_gnu1x:
 941       if (!preprocessing_asm_p)
 942         set_std_c1x (false /* ISO */);
 943       break;
 944
 945     case OPT_trigraphs:
 946       cpp_opts->trigraphs = 1;
 947       break;
 948
 949     case OPT_traditional_cpp:
 950       cpp_opts->traditional = 1;
 951       break;
 952
 953     case OPT_v:
 954       verbose = true;
 955       break;
 956
 957     case OPT_Wabi:
 958       warn_psabi = value;
 959       break;
 960     }
 961
 962   return result;
 963 }
 964
 965 /* Post-switch processing.  */
 966 bool
 967 c_common_post_options (const char **pfilename)
 968 {
 969   struct cpp_callbacks *cb;
 970
 971   /* Canonicalize the input and output filenames.  */
 972   if (in_fnames == NULL)
 973     {
 974       in_fnames = XNEWVEC (const char *, 1);
 975       in_fnames[0] = "";
 976     }
 977   else if (strcmp (in_fnames[0], "-") == 0)
 978     in_fnames[0] = "";
 979
 980   if (out_fname == NULL || !strcmp (out_fname, "-"))
 981     out_fname = "";
 982
 983   if (cpp_opts->deps.style == DEPS_NONE)
 984     check_deps_environment_vars ();
 985
 986   handle_deferred_opts ();
 987
 988   sanitize_cpp_opts ();
 989
 990   register_include_chains (parse_in, sysroot, iprefix, imultilib,
 991                            std_inc, std_cxx_inc && c_dialect_cxx (), verbose);
 992
 993 #ifdef C_COMMON_OVERRIDE_OPTIONS
 994   /* Some machines may reject certain combinations of C
 995      language-specific options.  */
 996   C_COMMON_OVERRIDE_OPTIONS;
 997 #endif
 998
 999   /* Excess precision other than "fast" requires front-end
1000      support.  */
1001   if (c_dialect_cxx ())
1002     {
1003       if (flag_excess_precision_cmdline == EXCESS_PRECISION_STANDARD
1004           && TARGET_FLT_EVAL_METHOD_NON_DEFAULT)
1005         sorry ("-fexcess-precision=standard for C++");
1006       flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
1007     }
1008   else if (flag_excess_precision_cmdline == EXCESS_PRECISION_DEFAULT)
1009     flag_excess_precision_cmdline = (flag_iso
1010                                      ? EXCESS_PRECISION_STANDARD
1011                                      : EXCESS_PRECISION_FAST);
1012
1013   /* By default we use C99 inline semantics in GNU99 or C99 mode.  C99
1014      inline semantics are not supported in GNU89 or C89 mode.  */
1015   if (flag_gnu89_inline == -1)
1016     flag_gnu89_inline = !flag_isoc99;
1017   else if (!flag_gnu89_inline && !flag_isoc99)
1018     error ("-fno-gnu89-inline is only supported in GNU99 or C99 mode");
1019
1020   /* Default to ObjC sjlj exception handling if NeXT runtime.  */
1021   if (flag_objc_sjlj_exceptions < 0)
1022     flag_objc_sjlj_exceptions = flag_next_runtime;
1023   if (flag_objc_exceptions && !flag_objc_sjlj_exceptions)
1024     flag_exceptions = 1;
1025
1026   /* -Wextra implies the following flags
1027      unless explicitly overridden.  */
1028   if (warn_type_limits == -1)
1029     warn_type_limits = extra_warnings;
1030   if (warn_clobbered == -1)
1031     warn_clobbered = extra_warnings;
1032   if (warn_empty_body == -1)
1033     warn_empty_body = extra_warnings;
1034   if (warn_sign_compare == -1)
1035     warn_sign_compare = extra_warnings;
1036   if (warn_missing_field_initializers == -1)
1037     warn_missing_field_initializers = extra_warnings;
1038   if (warn_missing_parameter_type == -1)
1039     warn_missing_parameter_type = extra_warnings;
1040   if (warn_old_style_declaration == -1)
1041     warn_old_style_declaration = extra_warnings;
1042   if (warn_override_init == -1)
1043     warn_override_init = extra_warnings;
1044   if (warn_ignored_qualifiers == -1)
1045     warn_ignored_qualifiers = extra_warnings;
1046
1047   /* -Wpointer-sign is disabled by default, but it is enabled if any
1048      of -Wall or -pedantic are given.  */
1049   if (warn_pointer_sign == -1)
1050     warn_pointer_sign = 0;
1051
1052   if (warn_strict_aliasing == -1)
1053     warn_strict_aliasing = 0;
1054   if (warn_strict_overflow == -1)
1055     warn_strict_overflow = 0;
1056   if (warn_jump_misses_init == -1)
1057     warn_jump_misses_init = 0;
1058
1059   /* -Woverlength-strings is off by default, but is enabled by -pedantic.
1060      It is never enabled in C++, as the minimum limit is not normative
1061      in that standard.  */
1062   if (warn_overlength_strings == -1 || c_dialect_cxx ())
1063     warn_overlength_strings = 0;
1064
1065   /* Wmain is enabled by default in C++ but not in C.  */
1066   /* Wmain is disabled by default for -ffreestanding (!flag_hosted),
1067      even if -Wall was given (warn_main will be 2 if set by -Wall, 1
1068      if set by -Wmain).  */
1069   if (warn_main == -1)
1070     warn_main = (c_dialect_cxx () && flag_hosted) ? 1 : 0;
1071   else if (warn_main == 2)
1072     warn_main = flag_hosted ? 1 : 0;
1073
1074   /* In C, -Wconversion enables -Wsign-conversion (unless disabled
1075      through -Wno-sign-conversion). While in C++,
1076      -Wsign-conversion needs to be requested explicitly.  */
1077   if (warn_sign_conversion == -1)
1078     warn_sign_conversion =  (c_dialect_cxx ()) ? 0 : warn_conversion;
1079
1080   /* In C, -Wall and -Wc++-compat enable -Wenum-compare, which we do
1081      in c_common_handle_option; if it has not yet been set, it is
1082      disabled by default.  In C++, it is enabled by default.  */
1083   if (warn_enum_compare == -1)
1084     warn_enum_compare = c_dialect_cxx () ? 1 : 0;
1085
1086   /* -Wpacked-bitfield-compat is on by default for the C languages.  The
1087      warning is issued in stor-layout.c which is not part of the front-end so
1088      we need to selectively turn it on here.  */
1089   if (warn_packed_bitfield_compat == -1)
1090     warn_packed_bitfield_compat = 1;
1091
1092   /* Special format checking options don't work without -Wformat; warn if
1093      they are used.  */
1094   if (!warn_format)
1095     {
1096       warning (OPT_Wformat_y2k,
1097                "-Wformat-y2k ignored without -Wformat");
1098       warning (OPT_Wformat_extra_args,
1099                "-Wformat-extra-args ignored without -Wformat");
1100       warning (OPT_Wformat_zero_length,
1101                "-Wformat-zero-length ignored without -Wformat");
1102       warning (OPT_Wformat_nonliteral,
1103                "-Wformat-nonliteral ignored without -Wformat");
1104       warning (OPT_Wformat_contains_nul,
1105                "-Wformat-contains-nul ignored without -Wformat");
1106       warning (OPT_Wformat_security,
1107                "-Wformat-security ignored without -Wformat");
1108     }
1109
1110   if (warn_implicit == -1)
1111     warn_implicit = 0;
1112
1113   if (warn_implicit_int == -1)
1114     warn_implicit_int = 0;
1115
1116   /* -Wimplicit-function-declaration is enabled by default for C99.  */
1117   if (warn_implicit_function_declaration == -1)
1118     warn_implicit_function_declaration = flag_isoc99;
1119
1120   /* If we're allowing C++0x constructs, don't warn about C++0x
1121      compatibility problems.  */
1122   if (cxx_dialect == cxx0x)
1123     warn_cxx0x_compat = 0;
1124
1125   if (flag_preprocess_only)
1126     {
1127       /* Open the output now.  We must do so even if flag_no_output is
1128          on, because there may be other output than from the actual
1129          preprocessing (e.g. from -dM).  */
1130       if (out_fname[0] == '\0')
1131         out_stream = stdout;
1132       else
1133         out_stream = fopen (out_fname, "w");
1134
1135       if (out_stream == NULL)
1136         {
1137           fatal_error ("opening output file %s: %m", out_fname);
1138           return false;
1139         }
1140
1141       if (num_in_fnames > 1)
1142         error ("too many filenames given.  Type %s --help for usage",
1143                progname);
1144
1145       init_pp_output (out_stream);
1146     }
1147   else
1148     {
1149       init_c_lex ();
1150
1151       /* Yuk.  WTF is this?  I do know ObjC relies on it somewhere.  */
1152       input_location = UNKNOWN_LOCATION;
1153     }
1154
1155   cb = cpp_get_callbacks (parse_in);
1156   cb->file_change = cb_file_change;
1157   cb->dir_change = cb_dir_change;
1158   cpp_post_options (parse_in);
1159
1160   input_location = UNKNOWN_LOCATION;
1161
1162   *pfilename = this_input_filename
1163     = cpp_read_main_file (parse_in, in_fnames[0]);
1164   /* Don't do any compilation or preprocessing if there is no input file.  */
1165   if (this_input_filename == NULL)
1166     {
1167       errorcount++;
1168       return false;
1169     }
1170
1171   if (flag_working_directory
1172       && flag_preprocess_only && !flag_no_line_commands)
1173     pp_dir_change (parse_in, get_src_pwd ());
1174
1175   return flag_preprocess_only;
1176 }
1177
1178 /* Front end initialization common to C, ObjC and C++.  */
1179 bool
1180 c_common_init (void)
1181 {
1182   /* Set up preprocessor arithmetic.  Must be done after call to
1183      c_common_nodes_and_builtins for type nodes to be good.  */
1184   cpp_opts->precision = TYPE_PRECISION (intmax_type_node);
1185   cpp_opts->char_precision = TYPE_PRECISION (char_type_node);
1186   cpp_opts->int_precision = TYPE_PRECISION (integer_type_node);
1187   cpp_opts->wchar_precision = TYPE_PRECISION (wchar_type_node);
1188   cpp_opts->unsigned_wchar = TYPE_UNSIGNED (wchar_type_node);
1189   cpp_opts->bytes_big_endian = BYTES_BIG_ENDIAN;
1190
1191   /* This can't happen until after wchar_precision and bytes_big_endian
1192      are known.  */
1193   cpp_init_iconv (parse_in);
1194
1195   if (version_flag)
1196     c_common_print_pch_checksum (stderr);
1197
1198   /* Has to wait until now so that cpplib has its hash table.  */
1199   init_pragma ();
1200
1201   if (flag_preprocess_only)
1202     {
1203       finish_options ();
1204       preprocess_file (parse_in);
1205       return false;
1206     }
1207
1208   return true;
1209 }
1210
1211 /* Initialize the integrated preprocessor after debug output has been
1212    initialized; loop over each input file.  */
1213 void
1214 c_common_parse_file (int set_yydebug)
1215 {
1216   unsigned int i;
1217
1218   if (set_yydebug)
1219     switch (c_language)
1220       {
1221       case clk_c:
1222         warning(0, "The C parser does not support -dy, option ignored");
1223         break;
1224       case clk_objc:
1225         warning(0,
1226                 "The Objective-C parser does not support -dy, option ignored");
1227         break;
1228       case clk_cxx:
1229         warning(0, "The C++ parser does not support -dy, option ignored");
1230         break;
1231       case clk_objcxx:
1232         warning(0,
1233             "The Objective-C++ parser does not support -dy, option ignored");
1234         break;
1235       default:
1236         gcc_unreachable ();
1237     }
1238
1239   i = 0;
1240   for (;;)
1241     {
1242       finish_options ();
1243       pch_init ();
1244       push_file_scope ();
1245       c_parse_file ();
1246       finish_file ();
1247       pop_file_scope ();
1248       /* And end the main input file, if the debug writer wants it  */
1249       if (debug_hooks->start_end_main_source_file)
1250         (*debug_hooks->end_source_file) (0);
1251       if (++i >= num_in_fnames)
1252         break;
1253       cpp_undef_all (parse_in);
1254       cpp_clear_file_cache (parse_in);
1255       this_input_filename
1256         = cpp_read_main_file (parse_in, in_fnames[i]);
1257       /* If an input file is missing, abandon further compilation.
1258          cpplib has issued a diagnostic.  */
1259       if (!this_input_filename)
1260         break;
1261     }
1262 }
1263
1264 /* Common finish hook for the C, ObjC and C++ front ends.  */
1265 void
1266 c_common_finish (void)
1267 {
1268   FILE *deps_stream = NULL;
1269
1270   /* Don't write the deps file if there are errors.  */
1271   if (cpp_opts->deps.style != DEPS_NONE && !seen_error ())
1272     {
1273       /* If -M or -MM was seen without -MF, default output to the
1274          output stream.  */
1275       if (!deps_file)
1276         deps_stream = out_stream;
1277       else
1278         {
1279           deps_stream = fopen (deps_file, deps_append ? "a": "w");
1280           if (!deps_stream)
1281             fatal_error ("opening dependency file %s: %m", deps_file);
1282         }
1283     }
1284
1285   /* For performance, avoid tearing down cpplib's internal structures
1286      with cpp_destroy ().  */
1287   cpp_finish (parse_in, deps_stream);
1288
1289   if (deps_stream && deps_stream != out_stream
1290       && (ferror (deps_stream) || fclose (deps_stream)))
1291     fatal_error ("closing dependency file %s: %m", deps_file);
1292
1293   if (out_stream && (ferror (out_stream) || fclose (out_stream)))
1294     fatal_error ("when writing output to %s: %m", out_fname);
1295 }
1296
1297 /* Either of two environment variables can specify output of
1298    dependencies.  Their value is either "OUTPUT_FILE" or "OUTPUT_FILE
1299    DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to
1300    and DEPS_TARGET is the target to mention in the deps.  They also
1301    result in dependency information being appended to the output file
1302    rather than overwriting it, and like Sun's compiler
1303    SUNPRO_DEPENDENCIES suppresses the dependency on the main file.  */
1304 static void
1305 check_deps_environment_vars (void)
1306 {
1307   char *spec;
1308
1309   GET_ENVIRONMENT (spec, "DEPENDENCIES_OUTPUT");
1310   if (spec)
1311     cpp_opts->deps.style = DEPS_USER;
1312   else
1313     {
1314       GET_ENVIRONMENT (spec, "SUNPRO_DEPENDENCIES");
1315       if (spec)
1316         {
1317           cpp_opts->deps.style = DEPS_SYSTEM;
1318           cpp_opts->deps.ignore_main_file = true;
1319         }
1320     }
1321
1322   if (spec)
1323     {
1324       /* Find the space before the DEPS_TARGET, if there is one.  */
1325       char *s = strchr (spec, ' ');
1326       if (s)
1327         {
1328           /* Let the caller perform MAKE quoting.  */
1329           defer_opt (OPT_MT, s + 1);
1330           *s = '\0';
1331         }
1332
1333       /* Command line -MF overrides environment variables and default.  */
1334       if (!deps_file)
1335         deps_file = spec;
1336
1337       deps_append = 1;
1338       deps_seen = true;
1339     }
1340 }
1341
1342 /* Handle deferred command line switches.  */
1343 static void
1344 handle_deferred_opts (void)
1345 {
1346   size_t i;
1347   struct deps *deps;
1348
1349   /* Avoid allocating the deps buffer if we don't need it.
1350      (This flag may be true without there having been -MT or -MQ
1351      options, but we'll still need the deps buffer.)  */
1352   if (!deps_seen)
1353     return;
1354
1355   deps = cpp_get_deps (parse_in);
1356
1357   for (i = 0; i < deferred_count; i++)
1358     {
1359       struct deferred_opt *opt = &deferred_opts[i];
1360
1361       if (opt->code == OPT_MT || opt->code == OPT_MQ)
1362         deps_add_target (deps, opt->arg, opt->code == OPT_MQ);
1363     }
1364 }
1365
1366 /* These settings are appropriate for GCC, but not necessarily so for
1367    cpplib as a library.  */
1368 static void
1369 sanitize_cpp_opts (void)
1370 {
1371   /* If we don't know what style of dependencies to output, complain
1372      if any other dependency switches have been given.  */
1373   if (deps_seen && cpp_opts->deps.style == DEPS_NONE)
1374     error ("to generate dependencies you must specify either -M or -MM");
1375
1376   /* -dM and dependencies suppress normal output; do it here so that
1377      the last -d[MDN] switch overrides earlier ones.  */
1378   if (flag_dump_macros == 'M')
1379     flag_no_output = 1;
1380
1381   /* By default, -fdirectives-only implies -dD.  This allows subsequent phases
1382      to perform proper macro expansion.  */
1383   if (cpp_opts->directives_only && !cpp_opts->preprocessed && !flag_dump_macros)
1384     flag_dump_macros = 'D';
1385
1386   /* Disable -dD, -dN and -dI if normal output is suppressed.  Allow
1387      -dM since at least glibc relies on -M -dM to work.  */
1388   /* Also, flag_no_output implies flag_no_line_commands, always.  */
1389   if (flag_no_output)
1390     {
1391       if (flag_dump_macros != 'M')
1392         flag_dump_macros = 0;
1393       flag_dump_includes = 0;
1394       flag_no_line_commands = 1;
1395     }
1396   else if (cpp_opts->deps.missing_files)
1397     error ("-MG may only be used with -M or -MM");
1398
1399   cpp_opts->unsigned_char = !flag_signed_char;
1400   cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS;
1401
1402   /* Wlong-long is disabled by default. It is enabled by:
1403       [-pedantic | -Wtraditional] -std=[gnu|c]++98 ; or
1404       [-pedantic | -Wtraditional] -std=non-c99 .
1405
1406       Either -Wlong-long or -Wno-long-long override any other settings.  */
1407   if (warn_long_long == -1)
1408     warn_long_long = ((pedantic || warn_traditional)
1409                       && (c_dialect_cxx () ? cxx_dialect == cxx98 : !flag_isoc99));
1410   cpp_opts->warn_long_long = warn_long_long;
1411
1412   /* Similarly with -Wno-variadic-macros.  No check for c99 here, since
1413      this also turns off warnings about GCCs extension.  */
1414   cpp_opts->warn_variadic_macros
1415     = warn_variadic_macros && (pedantic || warn_traditional);
1416
1417   /* If we're generating preprocessor output, emit current directory
1418      if explicitly requested or if debugging information is enabled.
1419      ??? Maybe we should only do it for debugging formats that
1420      actually output the current directory?  */
1421   if (flag_working_directory == -1)
1422     flag_working_directory = (debug_info_level != DINFO_LEVEL_NONE);
1423
1424   if (cpp_opts->directives_only)
1425     {
1426       if (warn_unused_macros)
1427         error ("-fdirectives-only is incompatible with -Wunused_macros");
1428       if (cpp_opts->traditional)
1429         error ("-fdirectives-only is incompatible with -traditional");
1430     }
1431 }
1432
1433 /* Add include path with a prefix at the front of its name.  */
1434 static void
1435 add_prefixed_path (const char *suffix, size_t chain)
1436 {
1437   char *path;
1438   const char *prefix;
1439   size_t prefix_len, suffix_len;
1440
1441   suffix_len = strlen (suffix);
1442   prefix     = iprefix ? iprefix : cpp_GCC_INCLUDE_DIR;
1443   prefix_len = iprefix ? strlen (iprefix) : cpp_GCC_INCLUDE_DIR_len;
1444
1445   path = (char *) xmalloc (prefix_len + suffix_len + 1);
1446   memcpy (path, prefix, prefix_len);
1447   memcpy (path + prefix_len, suffix, suffix_len);
1448   path[prefix_len + suffix_len] = '\0';
1449
1450   add_path (path, chain, 0, false);
1451 }
1452
1453 /* Handle -D, -U, -A, -imacros, and the first -include.  */
1454 static void
1455 finish_options (void)
1456 {
1457   if (!cpp_opts->preprocessed)
1458     {
1459       size_t i;
1460
1461       cb_file_change (parse_in,
1462                       linemap_add (line_table, LC_RENAME, 0,
1463                                    _("<built-in>"), 0));
1464
1465       cpp_init_builtins (parse_in, flag_hosted);
1466       c_cpp_builtins (parse_in);
1467
1468       /* We're about to send user input to cpplib, so make it warn for
1469          things that we previously (when we sent it internal definitions)
1470          told it to not warn.
1471
1472          C99 permits implementation-defined characters in identifiers.
1473          The documented meaning of -std= is to turn off extensions that
1474          conflict with the specified standard, and since a strictly
1475          conforming program cannot contain a '$', we do not condition
1476          their acceptance on the -std= setting.  */
1477       cpp_opts->warn_dollars = (cpp_opts->pedantic && !cpp_opts->c99);
1478
1479       cb_file_change (parse_in,
1480                       linemap_add (line_table, LC_RENAME, 0,
1481                                    _("<command-line>"), 0));
1482
1483       for (i = 0; i < deferred_count; i++)
1484         {
1485           struct deferred_opt *opt = &deferred_opts[i];
1486
1487           if (opt->code == OPT_D)
1488             cpp_define (parse_in, opt->arg);
1489           else if (opt->code == OPT_U)
1490             cpp_undef (parse_in, opt->arg);
1491           else if (opt->code == OPT_A)
1492             {
1493               if (opt->arg[0] == '-')
1494                 cpp_unassert (parse_in, opt->arg + 1);
1495               else
1496                 cpp_assert (parse_in, opt->arg);
1497             }
1498         }
1499
1500       /* Start the main input file, if the debug writer wants it. */
1501       if (debug_hooks->start_end_main_source_file
1502           && !flag_preprocess_only)
1503         (*debug_hooks->start_source_file) (0, this_input_filename);
1504
1505       /* Handle -imacros after -D and -U.  */
1506       for (i = 0; i < deferred_count; i++)
1507         {
1508           struct deferred_opt *opt = &deferred_opts[i];
1509
1510           if (opt->code == OPT_imacros
1511               && cpp_push_include (parse_in, opt->arg))
1512             {
1513               /* Disable push_command_line_include callback for now.  */
1514               include_cursor = deferred_count + 1;
1515               cpp_scan_nooutput (parse_in);
1516             }
1517         }
1518     }
1519   else
1520     {
1521       if (cpp_opts->directives_only)
1522         cpp_init_special_builtins (parse_in);
1523
1524       /* Start the main input file, if the debug writer wants it. */
1525       if (debug_hooks->start_end_main_source_file
1526           && !flag_preprocess_only)
1527         (*debug_hooks->start_source_file) (0, this_input_filename);
1528     }
1529
1530   include_cursor = 0;
1531   push_command_line_include ();
1532 }
1533
1534 /* Give CPP the next file given by -include, if any.  */
1535 static void
1536 push_command_line_include (void)
1537 {
1538   while (include_cursor < deferred_count)
1539     {
1540       struct deferred_opt *opt = &deferred_opts[include_cursor++];
1541
1542       if (!cpp_opts->preprocessed && opt->code == OPT_include
1543           && cpp_push_include (parse_in, opt->arg))
1544         return;
1545     }
1546
1547   if (include_cursor == deferred_count)
1548     {
1549       include_cursor++;
1550       /* -Wunused-macros should only warn about macros defined hereafter.  */
1551       cpp_opts->warn_unused_macros = warn_unused_macros;
1552       /* Restore the line map from <command line>.  */
1553       if (!cpp_opts->preprocessed)
1554         cpp_change_file (parse_in, LC_RENAME, this_input_filename);
1555
1556       /* Set this here so the client can change the option if it wishes,
1557          and after stacking the main file so we don't trace the main file.  */
1558       line_table->trace_includes = cpp_opts->print_include_names;
1559     }
1560 }
1561
1562 /* File change callback.  Has to handle -include files.  */
1563 static void
1564 cb_file_change (cpp_reader * ARG_UNUSED (pfile),
1565                 const struct line_map *new_map)
1566 {
1567   if (flag_preprocess_only)
1568     pp_file_change (new_map);
1569   else
1570     fe_file_change (new_map);
1571
1572   if (new_map == 0 || (new_map->reason == LC_LEAVE && MAIN_FILE_P (new_map)))
1573     push_command_line_include ();
1574 }
1575
1576 void
1577 cb_dir_change (cpp_reader * ARG_UNUSED (pfile), const char *dir)
1578 {
1579   if (!set_src_pwd (dir))
1580     warning (0, "too late for # directive to set debug directory");
1581 }
1582
1583 /* Set the C 89 standard (with 1994 amendments if C94, without GNU
1584    extensions if ISO).  There is no concept of gnu94.  */
1585 static void
1586 set_std_c89 (int c94, int iso)
1587 {
1588   cpp_set_lang (parse_in, c94 ? CLK_STDC94: iso ? CLK_STDC89: CLK_GNUC89);
1589   flag_iso = iso;
1590   flag_no_asm = iso;
1591   flag_no_gnu_keywords = iso;
1592   flag_no_nonansi_builtin = iso;
1593   flag_isoc94 = c94;
1594   flag_isoc99 = 0;
1595   flag_isoc1x = 0;
1596 }
1597
1598 /* Set the C 99 standard (without GNU extensions if ISO).  */
1599 static void
1600 set_std_c99 (int iso)
1601 {
1602   cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99);
1603   flag_no_asm = iso;
1604   flag_no_nonansi_builtin = iso;
1605   flag_iso = iso;
1606   flag_isoc1x = 0;
1607   flag_isoc99 = 1;
1608   flag_isoc94 = 1;
1609 }
1610
1611 /* Set the C 1X standard draft (without GNU extensions if ISO).  */
1612 static void
1613 set_std_c1x (int iso)
1614 {
1615   cpp_set_lang (parse_in, iso ? CLK_STDC1X: CLK_GNUC1X);
1616   flag_no_asm = iso;
1617   flag_no_nonansi_builtin = iso;
1618   flag_iso = iso;
1619   flag_isoc1x = 1;
1620   flag_isoc99 = 1;
1621   flag_isoc94 = 1;
1622 }
1623
1624 /* Set the C++ 98 standard (without GNU extensions if ISO).  */
1625 static void
1626 set_std_cxx98 (int iso)
1627 {
1628   cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX);
1629   flag_no_gnu_keywords = iso;
1630   flag_no_nonansi_builtin = iso;
1631   flag_iso = iso;
1632   cxx_dialect = cxx98;
1633 }
1634
1635 /* Set the C++ 0x working draft "standard" (without GNU extensions if ISO).  */
1636 static void
1637 set_std_cxx0x (int iso)
1638 {
1639   cpp_set_lang (parse_in, iso ? CLK_CXX0X: CLK_GNUCXX0X);
1640   flag_no_gnu_keywords = iso;
1641   flag_no_nonansi_builtin = iso;
1642   flag_iso = iso;
1643   cxx_dialect = cxx0x;
1644 }
1645
1646 /* Args to -d specify what to dump.  Silently ignore
1647    unrecognized options; they may be aimed at toplev.c.  */
1648 static void
1649 handle_OPT_d (const char *arg)
1650 {
1651   char c;
1652
1653   while ((c = *arg++) != '\0')
1654     switch (c)
1655       {
1656       case 'M':                 /* Dump macros only.  */
1657       case 'N':                 /* Dump names.  */
1658       case 'D':                 /* Dump definitions.  */
1659       case 'U':                 /* Dump used macros.  */
1660         flag_dump_macros = c;
1661         break;
1662
1663       case 'I':
1664         flag_dump_includes = 1;
1665         break;
1666       }
1667 }