gcc/c-opts.c

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