gcc/c-opts.c

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