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