gcc/c-family/c-opts.c

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