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