gcc/c-opts.c

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