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   /* Default to ObjC sjlj exception handling if NeXT runtime.  */
 947   if (flag_objc_sjlj_exceptions < 0)
 948     flag_objc_sjlj_exceptions = flag_next_runtime;
 949   if (flag_objc_exceptions && !flag_objc_sjlj_exceptions)
 950     flag_exceptions = 1;
 951
 952   /* -Wextra implies -Wsign-compare, but not if explicitly
 953       overridden.  */
 954   if (warn_sign_compare == -1)
 955     warn_sign_compare = extra_warnings;
 956
 957   /* Special format checking options don't work without -Wformat; warn if
 958      they are used.  */
 959   if (warn_format_y2k && !warn_format)
 960     warning ("-Wformat-y2k ignored without -Wformat");
 961   if (warn_format_extra_args && !warn_format)
 962     warning ("-Wformat-extra-args ignored without -Wformat");
 963   if (warn_format_zero_length && !warn_format)
 964     warning ("-Wformat-zero-length ignored without -Wformat");
 965   if (warn_format_nonliteral && !warn_format)
 966     warning ("-Wformat-nonliteral ignored without -Wformat");
 967   if (warn_format_security && !warn_format)
 968     warning ("-Wformat-security ignored without -Wformat");
 969   if (warn_missing_format_attribute && !warn_format)
 970     warning ("-Wmissing-format-attribute ignored without -Wformat");
 971
 972   if (flag_preprocess_only)
 973     {
 974       /* Open the output now.  We must do so even if flag_no_output is
 975          on, because there may be other output than from the actual
 976          preprocessing (e.g. from -dM).  */
 977       if (out_fname[0] == '\0')
 978         out_stream = stdout;
 979       else
 980         out_stream = fopen (out_fname, "w");
 981
 982       if (out_stream == NULL)
 983         {
 984           fatal_error ("opening output file %s: %m", out_fname);
 985           return false;
 986         }
 987
 988       if (num_in_fnames > 1)
 989         error ("too many filenames given.  Type %s --help for usage",
 990                progname);
 991
 992       init_pp_output (out_stream);
 993     }
 994   else
 995     {
 996       init_c_lex ();
 997
 998       /* Yuk.  WTF is this?  I do know ObjC relies on it somewhere.  */
 999       input_location = UNKNOWN_LOCATION;
1000     }
1001
1002   cb = cpp_get_callbacks (parse_in);
1003   cb->file_change = cb_file_change;
1004   cb->dir_change = cb_dir_change;
1005   cpp_post_options (parse_in);
1006
1007   input_location = UNKNOWN_LOCATION;
1008
1009   /* If an error has occurred in cpplib, note it so we fail
1010      immediately.  */
1011   errorcount += cpp_errors (parse_in);
1012
1013   *pfilename = this_input_filename
1014     = cpp_read_main_file (parse_in, in_fnames[0]);
1015   /* Don't do any compilation or preprocessing if there is no input file.  */
1016   if (this_input_filename == NULL)
1017     {
1018       errorcount++;
1019       return false;
1020     }
1021
1022   if (flag_working_directory
1023       && flag_preprocess_only && ! flag_no_line_commands)
1024     pp_dir_change (parse_in, get_src_pwd ());
1025
1026   return flag_preprocess_only;
1027 }
1028
1029 /* Front end initialization common to C, ObjC and C++.  */
1030 bool
1031 c_common_init (void)
1032 {
1033   /* Set up preprocessor arithmetic.  Must be done after call to
1034      c_common_nodes_and_builtins for type nodes to be good.  */
1035   cpp_opts->precision = TYPE_PRECISION (intmax_type_node);
1036   cpp_opts->char_precision = TYPE_PRECISION (char_type_node);
1037   cpp_opts->int_precision = TYPE_PRECISION (integer_type_node);
1038   cpp_opts->wchar_precision = TYPE_PRECISION (wchar_type_node);
1039   cpp_opts->unsigned_wchar = TYPE_UNSIGNED (wchar_type_node);
1040   cpp_opts->bytes_big_endian = BYTES_BIG_ENDIAN;
1041
1042   /* This can't happen until after wchar_precision and bytes_big_endian
1043      are known.  */
1044   cpp_init_iconv (parse_in);
1045
1046   if (flag_preprocess_only)
1047     {
1048       finish_options ();
1049       preprocess_file (parse_in);
1050       return false;
1051     }
1052
1053   /* Has to wait until now so that cpplib has its hash table.  */
1054   init_pragma ();
1055
1056   return true;
1057 }
1058
1059 /* Initialize the integrated preprocessor after debug output has been
1060    initialized; loop over each input file.  */
1061 void
1062 c_common_parse_file (int set_yydebug)
1063 {
1064 #if YYDEBUG != 0
1065   yydebug = set_yydebug;
1066 #else
1067   if (set_yydebug)
1068     warning ("YYDEBUG not defined");
1069 #endif
1070
1071   if (num_in_fnames > 1)
1072     fatal_error ("sorry, inter-module analysis temporarily out of commission");
1073
1074   finish_options ();
1075   pch_init ();
1076   push_file_scope ();
1077   c_parse_file ();
1078   finish_file ();
1079   pop_file_scope ();
1080 }
1081
1082 /* Common finish hook for the C, ObjC and C++ front ends.  */
1083 void
1084 c_common_finish (void)
1085 {
1086   FILE *deps_stream = NULL;
1087
1088   if (cpp_opts->deps.style != DEPS_NONE)
1089     {
1090       /* If -M or -MM was seen without -MF, default output to the
1091          output stream.  */
1092       if (!deps_file)
1093         deps_stream = out_stream;
1094       else
1095         {
1096           deps_stream = fopen (deps_file, deps_append ? "a": "w");
1097           if (!deps_stream)
1098             fatal_error ("opening dependency file %s: %m", deps_file);
1099         }
1100     }
1101
1102   /* For performance, avoid tearing down cpplib's internal structures
1103      with cpp_destroy ().  */
1104   errorcount += cpp_finish (parse_in, deps_stream);
1105
1106   if (deps_stream && deps_stream != out_stream
1107       && (ferror (deps_stream) || fclose (deps_stream)))
1108     fatal_error ("closing dependency file %s: %m", deps_file);
1109
1110   if (out_stream && (ferror (out_stream) || fclose (out_stream)))
1111     fatal_error ("when writing output to %s: %m", out_fname);
1112 }
1113
1114 /* Either of two environment variables can specify output of
1115    dependencies.  Their value is either "OUTPUT_FILE" or "OUTPUT_FILE
1116    DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to
1117    and DEPS_TARGET is the target to mention in the deps.  They also
1118    result in dependency information being appended to the output file
1119    rather than overwriting it, and like Sun's compiler
1120    SUNPRO_DEPENDENCIES suppresses the dependency on the main file.  */
1121 static void
1122 check_deps_environment_vars (void)
1123 {
1124   char *spec;
1125
1126   GET_ENVIRONMENT (spec, "DEPENDENCIES_OUTPUT");
1127   if (spec)
1128     cpp_opts->deps.style = DEPS_USER;
1129   else
1130     {
1131       GET_ENVIRONMENT (spec, "SUNPRO_DEPENDENCIES");
1132       if (spec)
1133         {
1134           cpp_opts->deps.style = DEPS_SYSTEM;
1135           cpp_opts->deps.ignore_main_file = true;
1136         }
1137     }
1138
1139   if (spec)
1140     {
1141       /* Find the space before the DEPS_TARGET, if there is one.  */
1142       char *s = strchr (spec, ' ');
1143       if (s)
1144         {
1145           /* Let the caller perform MAKE quoting.  */
1146           defer_opt (OPT_MT, s + 1);
1147           *s = '\0';
1148         }
1149
1150       /* Command line -MF overrides environment variables and default.  */
1151       if (!deps_file)
1152         deps_file = spec;
1153
1154       deps_append = 1;
1155     }
1156 }
1157
1158 /* Handle deferred command line switches.  */
1159 static void
1160 handle_deferred_opts (void)
1161 {
1162   size_t i;
1163   struct deps *deps;
1164
1165   /* Avoid allocating the deps buffer if we don't need it.
1166      (This flag may be true without there having been -MT or -MQ
1167      options, but we'll still need the deps buffer.)  */
1168   if (!deps_seen)
1169     return;
1170
1171   deps = cpp_get_deps (parse_in);
1172
1173   for (i = 0; i < deferred_count; i++)
1174     {
1175       struct deferred_opt *opt = &deferred_opts[i];
1176
1177       if (opt->code == OPT_MT || opt->code == OPT_MQ)
1178         deps_add_target (deps, opt->arg, opt->code == OPT_MQ);
1179     }
1180 }
1181
1182 /* These settings are appropriate for GCC, but not necessarily so for
1183    cpplib as a library.  */
1184 static void
1185 sanitize_cpp_opts (void)
1186 {
1187   /* If we don't know what style of dependencies to output, complain
1188      if any other dependency switches have been given.  */
1189   if (deps_seen && cpp_opts->deps.style == DEPS_NONE)
1190     error ("to generate dependencies you must specify either -M or -MM");
1191
1192   /* -dM and dependencies suppress normal output; do it here so that
1193      the last -d[MDN] switch overrides earlier ones.  */
1194   if (flag_dump_macros == 'M')
1195     flag_no_output = 1;
1196
1197   /* Disable -dD, -dN and -dI if normal output is suppressed.  Allow
1198      -dM since at least glibc relies on -M -dM to work.  */
1199   if (flag_no_output)
1200     {
1201       if (flag_dump_macros != 'M')
1202         flag_dump_macros = 0;
1203       flag_dump_includes = 0;
1204     }
1205
1206   cpp_opts->unsigned_char = !flag_signed_char;
1207   cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS;
1208
1209   /* We want -Wno-long-long to override -pedantic -std=non-c99
1210      and/or -Wtraditional, whatever the ordering.  */
1211   cpp_opts->warn_long_long
1212     = warn_long_long && ((!flag_isoc99 && pedantic) || warn_traditional);
1213
1214   /* Similarly with -Wno-variadic-macros.  No check for c99 here, since
1215      this also turns off warnings about GCCs extension.  */
1216   cpp_opts->warn_variadic_macros
1217     = warn_variadic_macros && (pedantic || warn_traditional);
1218
1219   /* If we're generating preprocessor output, emit current directory
1220      if explicitly requested or if debugging information is enabled.
1221      ??? Maybe we should only do it for debugging formats that
1222      actually output the current directory?  */
1223   if (flag_working_directory == -1)
1224     flag_working_directory = (debug_info_level != DINFO_LEVEL_NONE);
1225 }
1226
1227 /* Add include path with a prefix at the front of its name.  */
1228 static void
1229 add_prefixed_path (const char *suffix, size_t chain)
1230 {
1231   char *path;
1232   const char *prefix;
1233   size_t prefix_len, suffix_len;
1234
1235   suffix_len = strlen (suffix);
1236   prefix     = iprefix ? iprefix : cpp_GCC_INCLUDE_DIR;
1237   prefix_len = iprefix ? strlen (iprefix) : cpp_GCC_INCLUDE_DIR_len;
1238
1239   path = xmalloc (prefix_len + suffix_len + 1);
1240   memcpy (path, prefix, prefix_len);
1241   memcpy (path + prefix_len, suffix, suffix_len);
1242   path[prefix_len + suffix_len] = '\0';
1243
1244   add_path (path, chain, 0, false);
1245 }
1246
1247 /* Handle -D, -U, -A, -imacros, and the first -include.  */
1248 static void
1249 finish_options (void)
1250 {
1251   if (!cpp_opts->preprocessed)
1252     {
1253       size_t i;
1254
1255       cpp_change_file (parse_in, LC_RENAME, _("<built-in>"));
1256       cpp_init_builtins (parse_in, flag_hosted);
1257       c_cpp_builtins (parse_in);
1258
1259       /* We're about to send user input to cpplib, so make it warn for
1260          things that we previously (when we sent it internal definitions)
1261          told it to not warn.
1262
1263          C99 permits implementation-defined characters in identifiers.
1264          The documented meaning of -std= is to turn off extensions that
1265          conflict with the specified standard, and since a strictly
1266          conforming program cannot contain a '$', we do not condition
1267          their acceptance on the -std= setting.  */
1268       cpp_opts->warn_dollars = (cpp_opts->pedantic && !cpp_opts->c99);
1269
1270       cpp_change_file (parse_in, LC_RENAME, _("<command line>"));
1271       for (i = 0; i < deferred_count; i++)
1272         {
1273           struct deferred_opt *opt = &deferred_opts[i];
1274
1275           if (opt->code == OPT_D)
1276             cpp_define (parse_in, opt->arg);
1277           else if (opt->code == OPT_U)
1278             cpp_undef (parse_in, opt->arg);
1279           else if (opt->code == OPT_A)
1280             {
1281               if (opt->arg[0] == '-')
1282                 cpp_unassert (parse_in, opt->arg + 1);
1283               else
1284                 cpp_assert (parse_in, opt->arg);
1285             }
1286         }
1287
1288       /* Handle -imacros after -D and -U.  */
1289       for (i = 0; i < deferred_count; i++)
1290         {
1291           struct deferred_opt *opt = &deferred_opts[i];
1292
1293           if (opt->code == OPT_imacros
1294               && cpp_push_include (parse_in, opt->arg))
1295             {
1296               /* Disable push_command_line_include callback for now.  */
1297               include_cursor = deferred_count + 1;
1298               cpp_scan_nooutput (parse_in);
1299             }
1300         }
1301     }
1302
1303   include_cursor = 0;
1304   push_command_line_include ();
1305 }
1306
1307 /* Give CPP the next file given by -include, if any.  */
1308 static void
1309 push_command_line_include (void)
1310 {
1311   while (include_cursor < deferred_count)
1312     {
1313       struct deferred_opt *opt = &deferred_opts[include_cursor++];
1314
1315       if (! cpp_opts->preprocessed && opt->code == OPT_include
1316           && cpp_push_include (parse_in, opt->arg))
1317         return;
1318     }
1319
1320   if (include_cursor == deferred_count)
1321     {
1322       include_cursor++;
1323       /* -Wunused-macros should only warn about macros defined hereafter.  */
1324       cpp_opts->warn_unused_macros = warn_unused_macros;
1325       /* Restore the line map from <command line>.  */
1326       if (! cpp_opts->preprocessed)
1327         cpp_change_file (parse_in, LC_RENAME, main_input_filename);
1328
1329       /* Set this here so the client can change the option if it wishes,
1330          and after stacking the main file so we don't trace the main file.  */
1331       line_table.trace_includes = cpp_opts->print_include_names;
1332     }
1333 }
1334
1335 /* File change callback.  Has to handle -include files.  */
1336 static void
1337 cb_file_change (cpp_reader *pfile ATTRIBUTE_UNUSED,
1338                 const struct line_map *new_map)
1339 {
1340   if (flag_preprocess_only)
1341     pp_file_change (new_map);
1342   else
1343     fe_file_change (new_map);
1344
1345   if (new_map == 0 || (new_map->reason == LC_LEAVE && MAIN_FILE_P (new_map)))
1346     push_command_line_include ();
1347 }
1348
1349 void
1350 cb_dir_change (cpp_reader *pfile ATTRIBUTE_UNUSED, const char *dir)
1351 {
1352   if (! set_src_pwd (dir))
1353     warning ("too late for # directive to set debug directory");
1354 }
1355
1356 /* Set the C 89 standard (with 1994 amendments if C94, without GNU
1357    extensions if ISO).  There is no concept of gnu94.  */
1358 static void
1359 set_std_c89 (int c94, int iso)
1360 {
1361   cpp_set_lang (parse_in, c94 ? CLK_STDC94: iso ? CLK_STDC89: CLK_GNUC89);
1362   flag_iso = iso;
1363   flag_no_asm = iso;
1364   flag_no_gnu_keywords = iso;
1365   flag_no_nonansi_builtin = iso;
1366   flag_isoc94 = c94;
1367   flag_isoc99 = 0;
1368 }
1369
1370 /* Set the C 99 standard (without GNU extensions if ISO).  */
1371 static void
1372 set_std_c99 (int iso)
1373 {
1374   cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99);
1375   flag_no_asm = iso;
1376   flag_no_nonansi_builtin = iso;
1377   flag_iso = iso;
1378   flag_isoc99 = 1;
1379   flag_isoc94 = 1;
1380 }
1381
1382 /* Set the C++ 98 standard (without GNU extensions if ISO).  */
1383 static void
1384 set_std_cxx98 (int iso)
1385 {
1386   cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX);
1387   flag_no_gnu_keywords = iso;
1388   flag_no_nonansi_builtin = iso;
1389   flag_iso = iso;
1390 }
1391
1392 /* Handle setting implicit to ON.  */
1393 static void
1394 set_Wimplicit (int on)
1395 {
1396   warn_implicit = on;
1397   warn_implicit_int = on;
1398   if (on)
1399     {
1400       if (mesg_implicit_function_declaration != 2)
1401         mesg_implicit_function_declaration = 1;
1402     }
1403   else
1404     mesg_implicit_function_declaration = 0;
1405 }
1406
1407 /* Args to -d specify what to dump.  Silently ignore
1408    unrecognized options; they may be aimed at toplev.c.  */
1409 static void
1410 handle_OPT_d (const char *arg)
1411 {
1412   char c;
1413
1414   while ((c = *arg++) != '\0')
1415     switch (c)
1416       {
1417       case 'M':                 /* Dump macros only.  */
1418       case 'N':                 /* Dump names.  */
1419       case 'D':                 /* Dump definitions.  */
1420         flag_dump_macros = c;
1421         break;
1422
1423       case 'I':
1424         flag_dump_includes = 1;
1425         break;
1426       }
1427 }