gcc/c-opts.c

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