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