gcc/c-opts.c

   1 /* C/ObjC/C++ command line option handling.
   2    Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
   3    Contributed by Neil Booth.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "tree.h"
  27 #include "c-common.h"
  28 #include "c-pragma.h"
  29 #include "flags.h"
  30 #include "toplev.h"
  31 #include "langhooks.h"
  32 #include "tree-inline.h"
  33 #include "diagnostic.h"
  34 #include "intl.h"
  35 #include "cppdefault.h"
  36 #include "c-incpath.h"
  37 #include "debug.h"              /* For debug_hooks.  */
  38 #include "opts.h"
  39 #include "options.h"
  40 #include "mkdeps.h"
  41
  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 static 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 system root, if any.  Overridden by -isysroot.  */
  80 static const char *sysroot = TARGET_SYSTEM_ROOT;
  81
  82 /* Zero disables all standard directories for headers.  */
  83 static bool std_inc = true;
  84
  85 /* Zero disables the C++-specific standard directories for headers.  */
  86 static bool std_cxx_inc = true;
  87
  88 /* If the quote chain has been split by -I-.  */
  89 static bool quote_chain_split;
  90
  91 /* If -Wunused-macros.  */
  92 static bool warn_unused_macros;
  93
  94 /* If -Wvariadic-macros.  */
  95 static bool warn_variadic_macros = true;
  96
  97 /* Number of deferred options.  */
  98 static size_t deferred_count;
  99
 100 /* Number of deferred options scanned for -include.  */
 101 static size_t include_cursor;
 102
 103 /* Permit Fortran front-end options.  */
 104 static bool permit_fortran_options;
 105
 106 static void set_Wimplicit (int);
 107 static void handle_OPT_d (const char *);
 108 static void set_std_cxx98 (int);
 109 static void set_std_c89 (int, int);
 110 static void set_std_c99 (int);
 111 static void check_deps_environment_vars (void);
 112 static void handle_deferred_opts (void);
 113 static void sanitize_cpp_opts (void);
 114 static void add_prefixed_path (const char *, size_t);
 115 static void push_command_line_include (void);
 116 static void cb_file_change (cpp_reader *, const struct line_map *);
 117 static void cb_dir_change (cpp_reader *, const char *);
 118 static void finish_options (void);
 119
 120 #ifndef STDC_0_IN_SYSTEM_HEADERS
 121 #define STDC_0_IN_SYSTEM_HEADERS 0
 122 #endif
 123
 124 /* Holds switches parsed by c_common_handle_option (), but whose
 125    handling is deferred to c_common_post_options ().  */
 126 static void defer_opt (enum opt_code, const char *);
 127 static struct deferred_opt
 128 {
 129   enum opt_code code;
 130   const char *arg;
 131 } *deferred_opts;
 132
 133 /* Complain that switch CODE expects an argument but none was
 134    provided.  OPT was the command-line option.  Return FALSE to get
 135    the default message in opts.c, TRUE if we provide a specialized
 136    one.  */
 137 bool
 138 c_common_missing_argument (const char *opt, size_t code)
 139 {
 140   switch (code)
 141     {
 142     default:
 143       /* Pick up the default message.  */
 144       return false;
 145
 146     case OPT_fconstant_string_class_:
 147       error ("no class name specified with \"%s\"", opt);
 148       break;
 149
 150     case OPT_A:
 151       error ("assertion missing after \"%s\"", opt);
 152       break;
 153
 154     case OPT_D:
 155     case OPT_U:
 156       error ("macro name missing after \"%s\"", opt);
 157       break;
 158
 159     case OPT_F:
 160     case OPT_I:
 161     case OPT_idirafter:
 162     case OPT_isysroot:
 163     case OPT_isystem:
 164     case OPT_iquote:
 165       error ("missing path after \"%s\"", opt);
 166       break;
 167
 168     case OPT_MF:
 169     case OPT_MD:
 170     case OPT_MMD:
 171     case OPT_include:
 172     case OPT_imacros:
 173     case OPT_o:
 174       error ("missing filename after \"%s\"", opt);
 175       break;
 176
 177     case OPT_MQ:
 178     case OPT_MT:
 179       error ("missing makefile target after \"%s\"", opt);
 180       break;
 181     }
 182
 183   return true;
 184 }
 185
 186 /* Defer option CODE with argument ARG.  */
 187 static void
 188 defer_opt (enum opt_code code, const char *arg)
 189 {
 190   deferred_opts[deferred_count].code = code;
 191   deferred_opts[deferred_count].arg = arg;
 192   deferred_count++;
 193 }
 194
 195 /* Common initialization before parsing options.  */
 196 unsigned int
 197 c_common_init_options (unsigned int argc, const char **argv ATTRIBUTE_UNUSED)
 198 {
 199   static const unsigned int lang_flags[] = {CL_C, CL_ObjC, CL_CXX, CL_ObjCXX};
 200   unsigned int result;
 201
 202   /* This is conditionalized only because that is the way the front
 203      ends used to do it.  Maybe this should be unconditional?  */
 204   if (c_dialect_cxx ())
 205     {
 206       /* By default wrap lines at 80 characters.  Is getenv
 207          ("COLUMNS") preferable?  */
 208       diagnostic_line_cutoff (global_dc) = 80;
 209       /* By default, emit location information once for every
 210          diagnostic message.  */
 211       diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
 212     }
 213
 214   parse_in = cpp_create_reader (c_dialect_cxx () ? CLK_GNUCXX: CLK_GNUC89,
 215                                 ident_hash, &line_table);
 216
 217   cpp_opts = cpp_get_options (parse_in);
 218   cpp_opts->dollars_in_ident = DOLLARS_IN_IDENTIFIERS;
 219   cpp_opts->objc = c_dialect_objc ();
 220
 221   /* Reset to avoid warnings on internal definitions.  We set it just
 222      before passing on command-line options to cpplib.  */
 223   cpp_opts->warn_dollars = 0;
 224
 225   flag_const_strings = c_dialect_cxx ();
 226   flag_exceptions = c_dialect_cxx ();
 227   warn_pointer_arith = c_dialect_cxx ();
 228
 229   deferred_opts = xmalloc (argc * sizeof (struct deferred_opt));
 230
 231   result = lang_flags[c_language];
 232
 233   /* If potentially preprocessing Fortran we have to accept its front
 234      end options since the driver passes most of them through.  */
 235 #ifdef CL_F77
 236   if (c_language == clk_c && argc > 2
 237       && !strcmp (argv[2], "-traditional-cpp" ))
 238     {
 239       permit_fortran_options = true;
 240       result |= CL_F77;
 241     }
 242 #endif
 243
 244   return result;
 245 }
 246
 247 /* Handle switch SCODE with argument ARG.  VALUE is true, unless no-
 248    form of an -f or -W option was given.  Returns 0 if the switch was
 249    invalid, a negative number to prevent language-independent
 250    processing in toplev.c (a hack necessary for the short-term).  */
 251 int
 252 c_common_handle_option (size_t scode, const char *arg, int value)
 253 {
 254   const struct cl_option *option = &cl_options[scode];
 255   enum opt_code code = (enum opt_code) scode;
 256   int result = 1;
 257
 258   switch (code)
 259     {
 260     default:
 261       if (cl_options[code].flags & (CL_C | CL_CXX | CL_ObjC | CL_ObjCXX))
 262         break;
 263       result = permit_fortran_options;
 264       break;
 265
 266     case OPT__output_pch_:
 267       pch_file = arg;
 268       break;
 269
 270     case OPT_A:
 271       defer_opt (code, arg);
 272       break;
 273
 274     case OPT_C:
 275       cpp_opts->discard_comments = 0;
 276       break;
 277
 278     case OPT_CC:
 279       cpp_opts->discard_comments = 0;
 280       cpp_opts->discard_comments_in_macro_exp = 0;
 281       break;
 282
 283     case OPT_D:
 284       defer_opt (code, arg);
 285       break;
 286
 287     case OPT_E:
 288       flag_preprocess_only = 1;
 289       break;
 290
 291     case OPT_H:
 292       cpp_opts->print_include_names = 1;
 293       break;
 294
 295     case OPT_F:
 296       TARGET_OPTF (xstrdup (arg));
 297       break;
 298
 299     case OPT_I:
 300       if (strcmp (arg, "-"))
 301         add_path (xstrdup (arg), BRACKET, 0, true);
 302       else
 303         {
 304           if (quote_chain_split)
 305             error ("-I- specified twice");
 306           quote_chain_split = true;
 307           split_quote_chain ();
 308           inform ("obsolete option -I- used, please use -iquote instead");
 309         }
 310       break;
 311
 312     case OPT_M:
 313     case OPT_MM:
 314       /* When doing dependencies with -M or -MM, suppress normal
 315          preprocessed output, but still do -dM etc. as software
 316          depends on this.  Preprocessed output does occur if -MD, -MMD
 317          or environment var dependency generation is used.  */
 318       cpp_opts->deps.style = (code == OPT_M ? DEPS_SYSTEM: DEPS_USER);
 319       flag_no_output = 1;
 320       cpp_opts->inhibit_warnings = 1;
 321       break;
 322
 323     case OPT_MD:
 324     case OPT_MMD:
 325       cpp_opts->deps.style = (code == OPT_MD ? DEPS_SYSTEM: DEPS_USER);
 326       deps_file = arg;
 327       break;
 328
 329     case OPT_MF:
 330       deps_seen = true;
 331       deps_file = arg;
 332       break;
 333
 334     case OPT_MG:
 335       deps_seen = true;
 336       cpp_opts->deps.missing_files = true;
 337       break;
 338
 339     case OPT_MP:
 340       deps_seen = true;
 341       cpp_opts->deps.phony_targets = true;
 342       break;
 343
 344     case OPT_MQ:
 345     case OPT_MT:
 346       deps_seen = true;
 347       defer_opt (code, arg);
 348       break;
 349
 350     case OPT_P:
 351       flag_no_line_commands = 1;
 352       break;
 353
 354     case OPT_fworking_directory:
 355       flag_working_directory = value;
 356       break;
 357
 358     case OPT_U:
 359       defer_opt (code, arg);
 360       break;
 361
 362     case OPT_Wall:
 363       set_Wunused (value);
 364       set_Wformat (value);
 365       set_Wimplicit (value);
 366       warn_char_subscripts = value;
 367       warn_missing_braces = value;
 368       warn_parentheses = value;
 369       warn_return_type = value;
 370       warn_sequence_point = value;      /* Was C only.  */
 371       if (c_dialect_cxx ())
 372         warn_sign_compare = value;
 373       warn_switch = value;
 374       warn_strict_aliasing = value;
 375
 376       /* Only warn about unknown pragmas that are not in system
 377          headers.  */
 378       warn_unknown_pragmas = value;
 379
 380       /* We save the value of warn_uninitialized, since if they put
 381          -Wuninitialized on the command line, we need to generate a
 382          warning about not using it without also specifying -O.  */
 383       if (warn_uninitialized != 1)
 384         warn_uninitialized = (value ? 2 : 0);
 385
 386       if (!c_dialect_cxx ())
 387         /* We set this to 2 here, but 1 in -Wmain, so -ffreestanding
 388            can turn it off only if it's not explicit.  */
 389         warn_main = value * 2;
 390       else
 391         {
 392           /* C++-specific warnings.  */
 393           warn_nonvdtor = value;
 394           warn_reorder = value;
 395           warn_nontemplate_friend = value;
 396         }
 397
 398       cpp_opts->warn_trigraphs = value;
 399       cpp_opts->warn_comments = value;
 400       cpp_opts->warn_num_sign_change = value;
 401       cpp_opts->warn_multichar = value; /* Was C++ only.  */
 402       break;
 403
 404     case OPT_Wcomment:
 405     case OPT_Wcomments:
 406       cpp_opts->warn_comments = value;
 407       break;
 408
 409     case OPT_Wdeprecated:
 410       cpp_opts->warn_deprecated = value;
 411       break;
 412
 413     case OPT_Wdiv_by_zero:
 414       warn_div_by_zero = value;
 415       break;
 416
 417     case OPT_Wendif_labels:
 418       cpp_opts->warn_endif_labels = value;
 419       break;
 420
 421     case OPT_Werror:
 422       cpp_opts->warnings_are_errors = value;
 423       break;
 424
 425     case OPT_Werror_implicit_function_declaration:
 426       mesg_implicit_function_declaration = 2;
 427       break;
 428
 429     case OPT_Wformat:
 430       set_Wformat (value);
 431       break;
 432
 433     case OPT_Wformat_:
 434       set_Wformat (atoi (arg));
 435       break;
 436
 437     case OPT_Wimplicit:
 438       set_Wimplicit (value);
 439       break;
 440
 441     case OPT_Wimport:
 442       /* Silently ignore for now.  */
 443       break;
 444
 445     case OPT_Winvalid_pch:
 446       cpp_opts->warn_invalid_pch = value;
 447       break;
 448
 449     case OPT_Wmain:
 450       if (value)
 451         warn_main = 1;
 452       else
 453         warn_main = -1;
 454       break;
 455
 456     case OPT_Wmissing_include_dirs:
 457       cpp_opts->warn_missing_include_dirs = value;
 458       break;
 459
 460     case OPT_Wmultichar:
 461       cpp_opts->warn_multichar = value;
 462       break;
 463
 464     case OPT_Wreturn_type:
 465       warn_return_type = value;
 466       break;
 467
 468     case OPT_Wsystem_headers:
 469       cpp_opts->warn_system_headers = value;
 470       break;
 471
 472     case OPT_Wtraditional:
 473       cpp_opts->warn_traditional = value;
 474       break;
 475
 476     case OPT_Wtrigraphs:
 477       cpp_opts->warn_trigraphs = value;
 478       break;
 479
 480     case OPT_Wundef:
 481       cpp_opts->warn_undef = value;
 482       break;
 483
 484     case OPT_Wunknown_pragmas:
 485       /* Set to greater than 1, so that even unknown pragmas in
 486          system headers will be warned about.  */
 487       warn_unknown_pragmas = value * 2;
 488       break;
 489
 490     case OPT_Wunused_macros:
 491       warn_unused_macros = value;
 492       break;
 493
 494     case OPT_Wvariadic_macros:
 495       warn_variadic_macros = value;
 496       break;
 497
 498     case OPT_Wwrite_strings:
 499       if (!c_dialect_cxx ())
 500         flag_const_strings = value;
 501       else
 502         warn_write_strings = value;
 503       break;
 504
 505     case OPT_ansi:
 506       if (!c_dialect_cxx ())
 507         set_std_c89 (false, true);
 508       else
 509         set_std_cxx98 (true);
 510       break;
 511
 512     case OPT_d:
 513       handle_OPT_d (arg);
 514       break;
 515
 516     case OPT_fcond_mismatch:
 517       if (!c_dialect_cxx ())
 518         {
 519           flag_cond_mismatch = value;
 520           break;
 521         }
 522       /* Fall through.  */
 523
 524     case OPT_fall_virtual:
 525     case OPT_falt_external_templates:
 526     case OPT_fenum_int_equiv:
 527     case OPT_fexternal_templates:
 528     case OPT_fguiding_decls:
 529     case OPT_fhonor_std:
 530     case OPT_fhuge_objects:
 531     case OPT_flabels_ok:
 532     case OPT_fname_mangling_version_:
 533     case OPT_fnew_abi:
 534     case OPT_fnonnull_objects:
 535     case OPT_fsquangle:
 536     case OPT_fstrict_prototype:
 537     case OPT_fthis_is_variable:
 538     case OPT_fvtable_thunks:
 539     case OPT_fxref:
 540     case OPT_fvtable_gc:
 541       warning ("switch \"%s\" is no longer supported", option->opt_text);
 542       break;
 543
 544     case OPT_faccess_control:
 545       flag_access_control = value;
 546       break;
 547
 548     case OPT_fasm:
 549       flag_no_asm = !value;
 550       break;
 551
 552     case OPT_fbuiltin:
 553       flag_no_builtin = !value;
 554       break;
 555
 556     case OPT_fbuiltin_:
 557       if (value)
 558         result = 0;
 559       else
 560         disable_builtin_function (arg);
 561       break;
 562
 563     case OPT_fdollars_in_identifiers:
 564       cpp_opts->dollars_in_ident = value;
 565       break;
 566
 567     case OPT_ffreestanding:
 568       value = !value;
 569       /* Fall through....  */
 570     case OPT_fhosted:
 571       flag_hosted = value;
 572       flag_no_builtin = !value;
 573       /* warn_main will be 2 if set by -Wall, 1 if set by -Wmain */
 574       if (!value && warn_main == 2)
 575         warn_main = 0;
 576       break;
 577
 578     case OPT_fshort_double:
 579       flag_short_double = value;
 580       break;
 581
 582     case OPT_fshort_enums:
 583       flag_short_enums = value;
 584       break;
 585
 586     case OPT_fshort_wchar:
 587       flag_short_wchar = value;
 588       break;
 589
 590     case OPT_fsigned_bitfields:
 591       flag_signed_bitfields = value;
 592       explicit_flag_signed_bitfields = 1;
 593       break;
 594
 595     case OPT_fsigned_char:
 596       flag_signed_char = value;
 597       break;
 598
 599     case OPT_funsigned_bitfields:
 600       flag_signed_bitfields = !value;
 601       explicit_flag_signed_bitfields = 1;
 602       break;
 603
 604     case OPT_funsigned_char:
 605       flag_signed_char = !value;
 606       break;
 607
 608     case OPT_fcheck_new:
 609       flag_check_new = value;
 610       break;
 611
 612     case OPT_fconserve_space:
 613       flag_conserve_space = value;
 614       break;
 615
 616     case OPT_fconst_strings:
 617       flag_const_strings = value;
 618       break;
 619
 620     case OPT_fconstant_string_class_:
 621       constant_string_class_name = arg;
 622       break;
 623
 624     case OPT_fdefault_inline:
 625       flag_default_inline = value;
 626       break;
 627
 628     case OPT_felide_constructors:
 629       flag_elide_constructors = value;
 630       break;
 631
 632     case OPT_fenforce_eh_specs:
 633       flag_enforce_eh_specs = value;
 634       break;
 635
 636     case OPT_ffixed_form:
 637     case OPT_ffixed_line_length_:
 638       /* Fortran front end options ignored when preprocessing only.  */
 639       if (!flag_preprocess_only)
 640         result = 0;
 641       break;
 642
 643     case OPT_ffor_scope:
 644       flag_new_for_scope = value;
 645       break;
 646
 647     case OPT_fgnu_keywords:
 648       flag_no_gnu_keywords = !value;
 649       break;
 650
 651     case OPT_fgnu_runtime:
 652       flag_next_runtime = !value;
 653       break;
 654
 655     case OPT_fhandle_exceptions:
 656       warning ("-fhandle-exceptions has been renamed -fexceptions (and is now on by default)");
 657       flag_exceptions = value;
 658       break;
 659
 660     case OPT_fimplement_inlines:
 661       flag_implement_inlines = value;
 662       break;
 663
 664     case OPT_fimplicit_inline_templates:
 665       flag_implicit_inline_templates = value;
 666       break;
 667
 668     case OPT_fimplicit_templates:
 669       flag_implicit_templates = value;
 670       break;
 671
 672     case OPT_fms_extensions:
 673       flag_ms_extensions = value;
 674       break;
 675
 676     case OPT_fnext_runtime:
 677       flag_next_runtime = value;
 678       break;
 679
 680     case OPT_fnil_receivers:
 681       flag_nil_receivers = value;
 682       break;
 683
 684     case OPT_fnonansi_builtins:
 685       flag_no_nonansi_builtin = !value;
 686       break;
 687
 688     case OPT_fobjc_exceptions:
 689       flag_objc_exceptions = value;
 690       break;
 691
 692     case OPT_fobjc_sjlj_exceptions:
 693       flag_objc_sjlj_exceptions = value;
 694       break;
 695
 696     case OPT_foperator_names:
 697       cpp_opts->operator_names = value;
 698       break;
 699
 700     case OPT_foptional_diags:
 701       flag_optional_diags = value;
 702       break;
 703
 704     case OPT_fpch_deps:
 705       cpp_opts->restore_pch_deps = value;
 706       break;
 707
 708     case OPT_fpch_preprocess:
 709       flag_pch_preprocess = value;
 710       break;
 711
 712     case OPT_fpermissive:
 713       flag_permissive = value;
 714       break;
 715
 716     case OPT_fpreprocessed:
 717       cpp_opts->preprocessed = value;
 718       break;
 719
 720     case OPT_freplace_objc_classes:
 721       flag_replace_objc_classes = value;
 722       break;
 723
 724     case OPT_frepo:
 725       flag_use_repository = value;
 726       if (value)
 727         flag_implicit_templates = 0;
 728       break;
 729
 730     case OPT_frtti:
 731       flag_rtti = value;
 732       break;
 733
 734     case OPT_fshow_column:
 735       cpp_opts->show_column = value;
 736       break;
 737
 738     case OPT_fstats:
 739       flag_detailed_statistics = value;
 740       break;
 741
 742     case OPT_ftabstop_:
 743       /* It is documented that we silently ignore silly values.  */
 744       if (value >= 1 && value <= 100)
 745         cpp_opts->tabstop = value;
 746       break;
 747
 748     case OPT_fexec_charset_:
 749       cpp_opts->narrow_charset = arg;
 750       break;
 751
 752     case OPT_fwide_exec_charset_:
 753       cpp_opts->wide_charset = arg;
 754       break;
 755
 756     case OPT_finput_charset_:
 757       cpp_opts->input_charset = arg;
 758       break;
 759
 760     case OPT_ftemplate_depth_:
 761       max_tinst_depth = value;
 762       break;
 763
 764     case OPT_fuse_cxa_atexit:
 765       flag_use_cxa_atexit = value;
 766       break;
 767
 768     case OPT_fweak:
 769       flag_weak = value;
 770       break;
 771
 772     case OPT_fzero_link:
 773       flag_zero_link = value;
 774       break;
 775
 776     case OPT_gen_decls:
 777       flag_gen_declaration = 1;
 778       break;
 779
 780     case OPT_idirafter:
 781       add_path (xstrdup (arg), AFTER, 0, true);
 782       break;
 783
 784     case OPT_imacros:
 785     case OPT_include:
 786       defer_opt (code, arg);
 787       break;
 788
 789     case OPT_iprefix:
 790       iprefix = arg;
 791       break;
 792
 793     case OPT_iquote:
 794       add_path (xstrdup (arg), QUOTE, 0, true);
 795       break;
 796
 797     case OPT_isysroot:
 798       sysroot = arg;
 799       break;
 800
 801     case OPT_isystem:
 802       add_path (xstrdup (arg), SYSTEM, 0, true);
 803       break;
 804
 805     case OPT_iwithprefix:
 806       add_prefixed_path (arg, SYSTEM);
 807       break;
 808
 809     case OPT_iwithprefixbefore:
 810       add_prefixed_path (arg, BRACKET);
 811       break;
 812
 813     case OPT_lang_asm:
 814       cpp_set_lang (parse_in, CLK_ASM);
 815       cpp_opts->dollars_in_ident = false;
 816       break;
 817
 818     case OPT_lang_objc:
 819       cpp_opts->objc = 1;
 820       break;
 821
 822     case OPT_nostdinc:
 823       std_inc = false;
 824       break;
 825
 826     case OPT_nostdinc__:
 827       std_cxx_inc = false;
 828       break;
 829
 830     case OPT_o:
 831       if (!out_fname)
 832         out_fname = arg;
 833       else
 834         error ("output filename specified twice");
 835       break;
 836
 837       /* We need to handle the -pedantic switches here, rather than in
 838          c_common_post_options, so that a subsequent -Wno-endif-labels
 839          is not overridden.  */
 840     case OPT_pedantic_errors:
 841       cpp_opts->pedantic_errors = 1;
 842       /* Fall through.  */
 843     case OPT_pedantic:
 844       cpp_opts->pedantic = 1;
 845       cpp_opts->warn_endif_labels = 1;
 846       break;
 847
 848     case OPT_print_objc_runtime_info:
 849       print_struct_values = 1;
 850       break;
 851
 852     case OPT_remap:
 853       cpp_opts->remap = 1;
 854       break;
 855
 856     case OPT_std_c__98:
 857     case OPT_std_gnu__98:
 858       set_std_cxx98 (code == OPT_std_c__98 /* ISO */);
 859       break;
 860
 861     case OPT_std_c89:
 862     case OPT_std_iso9899_1990:
 863     case OPT_std_iso9899_199409:
 864       set_std_c89 (code == OPT_std_iso9899_199409 /* c94 */, true /* ISO */);
 865       break;
 866
 867     case OPT_std_gnu89:
 868       set_std_c89 (false /* c94 */, false /* ISO */);
 869       break;
 870
 871     case OPT_std_c99:
 872     case OPT_std_c9x:
 873     case OPT_std_iso9899_1999:
 874     case OPT_std_iso9899_199x:
 875       set_std_c99 (true /* ISO */);
 876       break;
 877
 878     case OPT_std_gnu99:
 879     case OPT_std_gnu9x:
 880       set_std_c99 (false /* ISO */);
 881       break;
 882
 883     case OPT_trigraphs:
 884       cpp_opts->trigraphs = 1;
 885       break;
 886
 887     case OPT_traditional_cpp:
 888       cpp_opts->traditional = 1;
 889       break;
 890
 891     case OPT_undef:
 892       flag_undef = 1;
 893       break;
 894
 895     case OPT_w:
 896       cpp_opts->inhibit_warnings = 1;
 897       break;
 898
 899     case OPT_v:
 900       verbose = true;
 901       break;
 902     }
 903
 904   return result;
 905 }
 906
 907 /* Post-switch processing.  */
 908 bool
 909 c_common_post_options (const char **pfilename)
 910 {
 911   struct cpp_callbacks *cb;
 912
 913   /* Canonicalize the input and output filenames.  */
 914   if (in_fnames == NULL)
 915     {
 916       in_fnames = xmalloc (sizeof (in_fnames[0]));
 917       in_fnames[0] = "";
 918     }
 919   else if (strcmp (in_fnames[0], "-") == 0)
 920     in_fnames[0] = "";
 921
 922   if (out_fname == NULL || !strcmp (out_fname, "-"))
 923     out_fname = "";
 924
 925   if (cpp_opts->deps.style == DEPS_NONE)
 926     check_deps_environment_vars ();
 927
 928   handle_deferred_opts ();
 929
 930   sanitize_cpp_opts ();
 931
 932   register_include_chains (parse_in, sysroot, iprefix,
 933                            std_inc, std_cxx_inc && c_dialect_cxx (), verbose);
 934
 935   flag_inline_trees = 1;
 936
 937   /* Use tree inlining.  */
 938   if (!flag_no_inline)
 939     flag_no_inline = 1;
 940   if (flag_inline_functions)
 941     {
 942       flag_inline_trees = 2;
 943       flag_inline_functions = 0;
 944     }
 945
 946   /* If we are given more than one input file, we must use
 947      unit-at-a-time mode.  */
 948   if (num_in_fnames > 1)
 949     flag_unit_at_a_time = 1;
 950
 951   /* Default to ObjC sjlj exception handling if NeXT runtime.  */
 952   if (flag_objc_sjlj_exceptions < 0)
 953     flag_objc_sjlj_exceptions = flag_next_runtime;
 954   if (flag_objc_exceptions && !flag_objc_sjlj_exceptions)
 955     flag_exceptions = 1;
 956
 957   /* -Wextra implies -Wsign-compare, but not if explicitly
 958       overridden.  */
 959   if (warn_sign_compare == -1)
 960     warn_sign_compare = extra_warnings;
 961
 962   /* Special format checking options don't work without -Wformat; warn if
 963      they are used.  */
 964   if (warn_format_y2k && !warn_format)
 965     warning ("-Wformat-y2k ignored without -Wformat");
 966   if (warn_format_extra_args && !warn_format)
 967     warning ("-Wformat-extra-args ignored without -Wformat");
 968   if (warn_format_zero_length && !warn_format)
 969     warning ("-Wformat-zero-length ignored without -Wformat");
 970   if (warn_format_nonliteral && !warn_format)
 971     warning ("-Wformat-nonliteral ignored without -Wformat");
 972   if (warn_format_security && !warn_format)
 973     warning ("-Wformat-security ignored without -Wformat");
 974   if (warn_missing_format_attribute && !warn_format)
 975     warning ("-Wmissing-format-attribute ignored without -Wformat");
 976
 977   if (flag_preprocess_only)
 978     {
 979       /* Open the output now.  We must do so even if flag_no_output is
 980          on, because there may be other output than from the actual
 981          preprocessing (e.g. from -dM).  */
 982       if (out_fname[0] == '\0')
 983         out_stream = stdout;
 984       else
 985         out_stream = fopen (out_fname, "w");
 986
 987       if (out_stream == NULL)
 988         {
 989           fatal_error ("opening output file %s: %m", out_fname);
 990           return false;
 991         }
 992
 993       if (num_in_fnames > 1)
 994         error ("too many filenames given.  Type %s --help for usage",
 995                progname);
 996
 997       init_pp_output (out_stream);
 998     }
 999   else
1000     {
1001       init_c_lex ();
1002
1003       /* Yuk.  WTF is this?  I do know ObjC relies on it somewhere.  */
1004       input_location = UNKNOWN_LOCATION;
1005     }
1006
1007   cb = cpp_get_callbacks (parse_in);
1008   cb->file_change = cb_file_change;
1009   cb->dir_change = cb_dir_change;
1010   cpp_post_options (parse_in);
1011
1012   input_location = UNKNOWN_LOCATION;
1013
1014   /* If an error has occurred in cpplib, note it so we fail
1015      immediately.  */
1016   errorcount += cpp_errors (parse_in);
1017
1018   *pfilename = this_input_filename
1019     = cpp_read_main_file (parse_in, in_fnames[0]);
1020   /* Don't do any compilation or preprocessing if there is no input file.  */
1021   if (this_input_filename == NULL)
1022     {
1023       errorcount++;
1024       return false;
1025     }
1026
1027   if (flag_working_directory
1028       && flag_preprocess_only && ! flag_no_line_commands)
1029     pp_dir_change (parse_in, get_src_pwd ());
1030
1031   return flag_preprocess_only;
1032 }
1033
1034 /* Front end initialization common to C, ObjC and C++.  */
1035 bool
1036 c_common_init (void)
1037 {
1038   /* Set up preprocessor arithmetic.  Must be done after call to
1039      c_common_nodes_and_builtins for type nodes to be good.  */
1040   cpp_opts->precision = TYPE_PRECISION (intmax_type_node);
1041   cpp_opts->char_precision = TYPE_PRECISION (char_type_node);
1042   cpp_opts->int_precision = TYPE_PRECISION (integer_type_node);
1043   cpp_opts->wchar_precision = TYPE_PRECISION (wchar_type_node);
1044   cpp_opts->unsigned_wchar = TYPE_UNSIGNED (wchar_type_node);
1045   cpp_opts->bytes_big_endian = BYTES_BIG_ENDIAN;
1046
1047   /* This can't happen until after wchar_precision and bytes_big_endian
1048      are known.  */
1049   cpp_init_iconv (parse_in);
1050
1051   if (flag_preprocess_only)
1052     {
1053       finish_options ();
1054       preprocess_file (parse_in);
1055       return false;
1056     }
1057
1058   /* Has to wait until now so that cpplib has its hash table.  */
1059   init_pragma ();
1060
1061   return true;
1062 }
1063
1064 /* Initialize the integrated preprocessor after debug output has been
1065    initialized; loop over each input file.  */
1066 void
1067 c_common_parse_file (int set_yydebug)
1068 {
1069   unsigned int i;
1070
1071   /* Enable parser debugging, if requested and we can.  If requested
1072      and we can't, notify the user.  */
1073 #if YYDEBUG != 0
1074   yydebug = set_yydebug;
1075 #else
1076   if (set_yydebug)
1077     warning ("YYDEBUG was not defined at build time, -dy ignored");
1078 #endif
1079
1080   i = 0;
1081   for (;;)
1082     {
1083       finish_options ();
1084       pch_init ();
1085       push_file_scope ();
1086       c_parse_file ();
1087       finish_file ();
1088       pop_file_scope ();
1089
1090       if (++i >= num_in_fnames)
1091         break;
1092       cpp_undef_all (parse_in);
1093       this_input_filename
1094         = cpp_read_main_file (parse_in, in_fnames[i]);
1095       /* If an input file is missing, abandon further compilation.
1096          cpplib has issued a diagnostic.  */
1097       if (!this_input_filename)
1098         break;
1099     }
1100 }
1101
1102 /* Common finish hook for the C, ObjC and C++ front ends.  */
1103 void
1104 c_common_finish (void)
1105 {
1106   FILE *deps_stream = NULL;
1107
1108   if (cpp_opts->deps.style != DEPS_NONE)
1109     {
1110       /* If -M or -MM was seen without -MF, default output to the
1111          output stream.  */
1112       if (!deps_file)
1113         deps_stream = out_stream;
1114       else
1115         {
1116           deps_stream = fopen (deps_file, deps_append ? "a": "w");
1117           if (!deps_stream)
1118             fatal_error ("opening dependency file %s: %m", deps_file);
1119         }
1120     }
1121
1122   /* For performance, avoid tearing down cpplib's internal structures
1123      with cpp_destroy ().  */
1124   errorcount += cpp_finish (parse_in, deps_stream);
1125
1126   if (deps_stream && deps_stream != out_stream
1127       && (ferror (deps_stream) || fclose (deps_stream)))
1128     fatal_error ("closing dependency file %s: %m", deps_file);
1129
1130   if (out_stream && (ferror (out_stream) || fclose (out_stream)))
1131     fatal_error ("when writing output to %s: %m", out_fname);
1132 }
1133
1134 /* Either of two environment variables can specify output of
1135    dependencies.  Their value is either "OUTPUT_FILE" or "OUTPUT_FILE
1136    DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to
1137    and DEPS_TARGET is the target to mention in the deps.  They also
1138    result in dependency information being appended to the output file
1139    rather than overwriting it, and like Sun's compiler
1140    SUNPRO_DEPENDENCIES suppresses the dependency on the main file.  */
1141 static void
1142 check_deps_environment_vars (void)
1143 {
1144   char *spec;
1145
1146   GET_ENVIRONMENT (spec, "DEPENDENCIES_OUTPUT");
1147   if (spec)
1148     cpp_opts->deps.style = DEPS_USER;
1149   else
1150     {
1151       GET_ENVIRONMENT (spec, "SUNPRO_DEPENDENCIES");
1152       if (spec)
1153         {
1154           cpp_opts->deps.style = DEPS_SYSTEM;
1155           cpp_opts->deps.ignore_main_file = true;
1156         }
1157     }
1158
1159   if (spec)
1160     {
1161       /* Find the space before the DEPS_TARGET, if there is one.  */
1162       char *s = strchr (spec, ' ');
1163       if (s)
1164         {
1165           /* Let the caller perform MAKE quoting.  */
1166           defer_opt (OPT_MT, s + 1);
1167           *s = '\0';
1168         }
1169
1170       /* Command line -MF overrides environment variables and default.  */
1171       if (!deps_file)
1172         deps_file = spec;
1173
1174       deps_append = 1;
1175     }
1176 }
1177
1178 /* Handle deferred command line switches.  */
1179 static void
1180 handle_deferred_opts (void)
1181 {
1182   size_t i;
1183   struct deps *deps;
1184
1185   /* Avoid allocating the deps buffer if we don't need it.
1186      (This flag may be true without there having been -MT or -MQ
1187      options, but we'll still need the deps buffer.)  */
1188   if (!deps_seen)
1189     return;
1190
1191   deps = cpp_get_deps (parse_in);
1192
1193   for (i = 0; i < deferred_count; i++)
1194     {
1195       struct deferred_opt *opt = &deferred_opts[i];
1196
1197       if (opt->code == OPT_MT || opt->code == OPT_MQ)
1198         deps_add_target (deps, opt->arg, opt->code == OPT_MQ);
1199     }
1200 }
1201
1202 /* These settings are appropriate for GCC, but not necessarily so for
1203    cpplib as a library.  */
1204 static void
1205 sanitize_cpp_opts (void)
1206 {
1207   /* If we don't know what style of dependencies to output, complain
1208      if any other dependency switches have been given.  */
1209   if (deps_seen && cpp_opts->deps.style == DEPS_NONE)
1210     error ("to generate dependencies you must specify either -M or -MM");
1211
1212   /* -dM and dependencies suppress normal output; do it here so that
1213      the last -d[MDN] switch overrides earlier ones.  */
1214   if (flag_dump_macros == 'M')
1215     flag_no_output = 1;
1216
1217   /* Disable -dD, -dN and -dI if normal output is suppressed.  Allow
1218      -dM since at least glibc relies on -M -dM to work.  */
1219   if (flag_no_output)
1220     {
1221       if (flag_dump_macros != 'M')
1222         flag_dump_macros = 0;
1223       flag_dump_includes = 0;
1224     }
1225
1226   cpp_opts->unsigned_char = !flag_signed_char;
1227   cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS;
1228
1229   /* We want -Wno-long-long to override -pedantic -std=non-c99
1230      and/or -Wtraditional, whatever the ordering.  */
1231   cpp_opts->warn_long_long
1232     = warn_long_long && ((!flag_isoc99 && pedantic) || warn_traditional);
1233
1234   /* Similarly with -Wno-variadic-macros.  No check for c99 here, since
1235      this also turns off warnings about GCCs extension.  */
1236   cpp_opts->warn_variadic_macros
1237     = warn_variadic_macros && (pedantic || warn_traditional);
1238
1239   /* If we're generating preprocessor output, emit current directory
1240      if explicitly requested or if debugging information is enabled.
1241      ??? Maybe we should only do it for debugging formats that
1242      actually output the current directory?  */
1243   if (flag_working_directory == -1)
1244     flag_working_directory = (debug_info_level != DINFO_LEVEL_NONE);
1245 }
1246
1247 /* Add include path with a prefix at the front of its name.  */
1248 static void
1249 add_prefixed_path (const char *suffix, size_t chain)
1250 {
1251   char *path;
1252   const char *prefix;
1253   size_t prefix_len, suffix_len;
1254
1255   suffix_len = strlen (suffix);
1256   prefix     = iprefix ? iprefix : cpp_GCC_INCLUDE_DIR;
1257   prefix_len = iprefix ? strlen (iprefix) : cpp_GCC_INCLUDE_DIR_len;
1258
1259   path = xmalloc (prefix_len + suffix_len + 1);
1260   memcpy (path, prefix, prefix_len);
1261   memcpy (path + prefix_len, suffix, suffix_len);
1262   path[prefix_len + suffix_len] = '\0';
1263
1264   add_path (path, chain, 0, false);
1265 }
1266
1267 /* Handle -D, -U, -A, -imacros, and the first -include.  */
1268 static void
1269 finish_options (void)
1270 {
1271   if (!cpp_opts->preprocessed)
1272     {
1273       size_t i;
1274
1275       cpp_change_file (parse_in, LC_RENAME, _("<built-in>"));
1276       cpp_init_builtins (parse_in, flag_hosted);
1277       c_cpp_builtins (parse_in);
1278
1279       /* We're about to send user input to cpplib, so make it warn for
1280          things that we previously (when we sent it internal definitions)
1281          told it to not warn.
1282
1283          C99 permits implementation-defined characters in identifiers.
1284          The documented meaning of -std= is to turn off extensions that
1285          conflict with the specified standard, and since a strictly
1286          conforming program cannot contain a '$', we do not condition
1287          their acceptance on the -std= setting.  */
1288       cpp_opts->warn_dollars = (cpp_opts->pedantic && !cpp_opts->c99);
1289
1290       cpp_change_file (parse_in, LC_RENAME, _("<command line>"));
1291       for (i = 0; i < deferred_count; i++)
1292         {
1293           struct deferred_opt *opt = &deferred_opts[i];
1294
1295           if (opt->code == OPT_D)
1296             cpp_define (parse_in, opt->arg);
1297           else if (opt->code == OPT_U)
1298             cpp_undef (parse_in, opt->arg);
1299           else if (opt->code == OPT_A)
1300             {
1301               if (opt->arg[0] == '-')
1302                 cpp_unassert (parse_in, opt->arg + 1);
1303               else
1304                 cpp_assert (parse_in, opt->arg);
1305             }
1306         }
1307
1308       /* Handle -imacros after -D and -U.  */
1309       for (i = 0; i < deferred_count; i++)
1310         {
1311           struct deferred_opt *opt = &deferred_opts[i];
1312
1313           if (opt->code == OPT_imacros
1314               && cpp_push_include (parse_in, opt->arg))
1315             {
1316               /* Disable push_command_line_include callback for now.  */
1317               include_cursor = deferred_count + 1;
1318               cpp_scan_nooutput (parse_in);
1319             }
1320         }
1321     }
1322
1323   include_cursor = 0;
1324   push_command_line_include ();
1325 }
1326
1327 /* Give CPP the next file given by -include, if any.  */
1328 static void
1329 push_command_line_include (void)
1330 {
1331   while (include_cursor < deferred_count)
1332     {
1333       struct deferred_opt *opt = &deferred_opts[include_cursor++];
1334
1335       if (! cpp_opts->preprocessed && opt->code == OPT_include
1336           && cpp_push_include (parse_in, opt->arg))
1337         return;
1338     }
1339
1340   if (include_cursor == deferred_count)
1341     {
1342       include_cursor++;
1343       /* -Wunused-macros should only warn about macros defined hereafter.  */
1344       cpp_opts->warn_unused_macros = warn_unused_macros;
1345       /* Restore the line map from <command line>.  */
1346       if (! cpp_opts->preprocessed)
1347         cpp_change_file (parse_in, LC_RENAME, main_input_filename);
1348
1349       /* Set this here so the client can change the option if it wishes,
1350          and after stacking the main file so we don't trace the main file.  */
1351       line_table.trace_includes = cpp_opts->print_include_names;
1352     }
1353 }
1354
1355 /* File change callback.  Has to handle -include files.  */
1356 static void
1357 cb_file_change (cpp_reader *pfile ATTRIBUTE_UNUSED,
1358                 const struct line_map *new_map)
1359 {
1360   if (flag_preprocess_only)
1361     pp_file_change (new_map);
1362   else
1363     fe_file_change (new_map);
1364
1365   if (new_map == 0 || (new_map->reason == LC_LEAVE && MAIN_FILE_P (new_map)))
1366     push_command_line_include ();
1367 }
1368
1369 void
1370 cb_dir_change (cpp_reader *pfile ATTRIBUTE_UNUSED, const char *dir)
1371 {
1372   if (! set_src_pwd (dir))
1373     warning ("too late for # directive to set debug directory");
1374 }
1375
1376 /* Set the C 89 standard (with 1994 amendments if C94, without GNU
1377    extensions if ISO).  There is no concept of gnu94.  */
1378 static void
1379 set_std_c89 (int c94, int iso)
1380 {
1381   cpp_set_lang (parse_in, c94 ? CLK_STDC94: iso ? CLK_STDC89: CLK_GNUC89);
1382   flag_iso = iso;
1383   flag_no_asm = iso;
1384   flag_no_gnu_keywords = iso;
1385   flag_no_nonansi_builtin = iso;
1386   flag_isoc94 = c94;
1387   flag_isoc99 = 0;
1388 }
1389
1390 /* Set the C 99 standard (without GNU extensions if ISO).  */
1391 static void
1392 set_std_c99 (int iso)
1393 {
1394   cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99);
1395   flag_no_asm = iso;
1396   flag_no_nonansi_builtin = iso;
1397   flag_iso = iso;
1398   flag_isoc99 = 1;
1399   flag_isoc94 = 1;
1400 }
1401
1402 /* Set the C++ 98 standard (without GNU extensions if ISO).  */
1403 static void
1404 set_std_cxx98 (int iso)
1405 {
1406   cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX);
1407   flag_no_gnu_keywords = iso;
1408   flag_no_nonansi_builtin = iso;
1409   flag_iso = iso;
1410 }
1411
1412 /* Handle setting implicit to ON.  */
1413 static void
1414 set_Wimplicit (int on)
1415 {
1416   warn_implicit = on;
1417   warn_implicit_int = on;
1418   if (on)
1419     {
1420       if (mesg_implicit_function_declaration != 2)
1421         mesg_implicit_function_declaration = 1;
1422     }
1423   else
1424     mesg_implicit_function_declaration = 0;
1425 }
1426
1427 /* Args to -d specify what to dump.  Silently ignore
1428    unrecognized options; they may be aimed at toplev.c.  */
1429 static void
1430 handle_OPT_d (const char *arg)
1431 {
1432   char c;
1433
1434   while ((c = *arg++) != '\0')
1435     switch (c)
1436       {
1437       case 'M':                 /* Dump macros only.  */
1438       case 'N':                 /* Dump names.  */
1439       case 'D':                 /* Dump definitions.  */
1440         flag_dump_macros = c;
1441         break;
1442
1443       case 'I':
1444         flag_dump_includes = 1;
1445         break;
1446       }
1447 }