gcc/c-opts.c

   1 /* C/ObjC/C++ command line option handling.
   2    Copyright (C) 2002 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 "tree.h"
  25 #include "c-common.h"
  26 #include "c-pragma.h"
  27 #include "flags.h"
  28 #include "toplev.h"
  29 #include "langhooks.h"
  30 #include "tree-inline.h"
  31 #include "diagnostic.h"
  32 #include "intl.h"
  33
  34 /* CPP's options.  */
  35 static cpp_options *cpp_opts;
  36
  37 /* Input filename.  */
  38 static const char *in_fname;
  39
  40 /* Filename and stream for preprocessed output.  */
  41 static const char *out_fname;
  42 static FILE *out_stream;
  43
  44 /* Append dependencies to deps_file.  */
  45 static bool deps_append;
  46
  47 /* If dependency switches (-MF etc.) have been given.  */
  48 static bool deps_seen;
  49
  50 /* Dependency output file.  */
  51 static const char *deps_file;
  52
  53 /* Number of deferred options, deferred options array size.  */
  54 static size_t deferred_count, deferred_size;
  55
  56 static void missing_arg PARAMS ((size_t));
  57 static size_t find_opt PARAMS ((const char *, int));
  58 static void set_Wimplicit PARAMS ((int));
  59 static void complain_wrong_lang PARAMS ((size_t));
  60 static void write_langs PARAMS ((char *, int));
  61 static void print_help PARAMS ((void));
  62 static void handle_OPT_d PARAMS ((const char *));
  63 static void set_std_cxx98 PARAMS ((int));
  64 static void set_std_c89 PARAMS ((int, int));
  65 static void set_std_c99 PARAMS ((int));
  66 static void check_deps_environment_vars PARAMS ((void));
  67 static void preprocess_file PARAMS ((void));
  68 static void handle_deferred_opts PARAMS ((void));
  69 static void sanitize_cpp_opts PARAMS ((void));
  70
  71 #ifndef STDC_0_IN_SYSTEM_HEADERS
  72 #define STDC_0_IN_SYSTEM_HEADERS 0
  73 #endif
  74
  75 #define CL_C_ONLY       (1 << 0) /* Only C.  */
  76 #define CL_OBJC_ONLY    (1 << 1) /* Only ObjC.  */
  77 #define CL_CXX_ONLY     (1 << 2) /* Only C++.  */
  78 #define CL_OBJCXX_ONLY  (1 << 3) /* Only ObjC++.  */
  79 #define CL_JOINED       (1 << 4) /* If takes joined argument.  */
  80 #define CL_SEPARATE     (1 << 5) /* If takes a separate argument.  */
  81
  82 #define CL_ARG          (CL_JOINED | CL_SEPARATE)
  83 #define CL_C            (CL_C_ONLY | CL_OBJC_ONLY)
  84 #define CL_OBJC         (CL_OBJC_ONLY | CL_OBJCXX_ONLY)
  85 #define CL_CXX          (CL_CXX_ONLY | CL_OBJCXX_ONLY)
  86 #define CL_ALL          (CL_C | CL_CXX)
  87
  88 /* This is the list of all command line options, with the leading "-"
  89    removed.  It must be sorted in ASCII collating order.  All options
  90    beginning with "f" or "W" are implicitly assumed to take a "no-"
  91    form; this form should not be listed.  The variable "on" is true if
  92    the positive form is given, otherwise it is false.  If you don't
  93    want to allow a "no-" form, your handler should reject "on" being
  94    false by returning zero.  See, for example, the handling of
  95    -ftabstop=.
  96
  97    If the user gives an option to a front end that doesn't support it,
  98    an error is output, mentioning which front ends the option is valid
  99    for.  If you don't want this, you must accept it for all front
 100    ends, and test for the front end in the option handler.  See, for
 101    example, the handling of -Wno-strict-prototypes for C++.
 102
 103    If you request an argument with CL_JOINED, CL_SEPARATE or their
 104    combination CL_ARG, it is stored in the variable "arg", which is
 105    guaranteed to be non-NULL and to not be an empty string.  It points
 106    to the argument either within the argv[] vector or within one of
 107    that vector's strings, and so the text is permanent and copies need
 108    not be made.  Be sure to add an error message in missing_arg() if
 109    the default is not appropriate.  */
 110
 111 #define COMMAND_LINE_OPTIONS                                                 \
 112   OPT("-help",                  CL_ALL,   OPT__help)                         \
 113   OPT("C",                      CL_ALL,   OPT_C)                             \
 114   OPT("CC",                     CL_ALL,   OPT_CC)                            \
 115   OPT("E",                      CL_ALL,   OPT_E)                             \
 116   OPT("H",                      CL_ALL,   OPT_H)                             \
 117   OPT("M",                      CL_ALL,   OPT_M)                             \
 118   OPT("MD",                     CL_ALL | CL_SEPARATE, OPT_MD)                \
 119   OPT("MF",                     CL_ALL | CL_ARG, OPT_MF)                     \
 120   OPT("MG",                     CL_ALL,   OPT_MG)                            \
 121   OPT("MM",                     CL_ALL,   OPT_MM)                            \
 122   OPT("MMD",                    CL_ALL | CL_SEPARATE, OPT_MMD)               \
 123   OPT("MP",                     CL_ALL,   OPT_MP)                            \
 124   OPT("MQ",                     CL_ALL | CL_ARG, OPT_MQ)                     \
 125   OPT("MT",                     CL_ALL | CL_ARG, OPT_MT)                     \
 126   OPT("P",                      CL_ALL,   OPT_P)                             \
 127   OPT("Wabi",                   CL_CXX,   OPT_Wabi)                          \
 128   OPT("Wall",                   CL_ALL,   OPT_Wall)                          \
 129   OPT("Wbad-function-cast",     CL_C,     OPT_Wbad_function_cast)            \
 130   OPT("Wcast-qual",             CL_ALL,   OPT_Wcast_qual)                    \
 131   OPT("Wchar-subscripts",       CL_ALL,   OPT_Wchar_subscripts)              \
 132   OPT("Wcomment",               CL_ALL,   OPT_Wcomment)                      \
 133   OPT("Wcomments",              CL_ALL,   OPT_Wcomments)                     \
 134   OPT("Wconversion",            CL_ALL,   OPT_Wconversion)                   \
 135   OPT("Wctor-dtor-privacy",     CL_CXX,   OPT_Wctor_dtor_privacy)            \
 136   OPT("Wdeprecated",            CL_CXX,   OPT_Wdeprecated)                   \
 137   OPT("Wdiv-by-zero",           CL_C,     OPT_Wdiv_by_zero)                  \
 138   OPT("Weffc++",                CL_CXX,   OPT_Weffcxx)                       \
 139   OPT("Wendif-labels",          CL_ALL,   OPT_Wendif_labels)                 \
 140   OPT("Werror",                 CL_ALL,   OPT_Werror)                        \
 141   OPT("Werror-implicit-function-declaration",                                \
 142                                 CL_C,     OPT_Werror_implicit_function_decl) \
 143   OPT("Wfloat-equal",           CL_ALL,   OPT_Wfloat_equal)                  \
 144   OPT("Wformat",                CL_ALL,   OPT_Wformat)                       \
 145   OPT("Wformat-extra-args",     CL_ALL,   OPT_Wformat_extra_args)            \
 146   OPT("Wformat-nonliteral",     CL_ALL,   OPT_Wformat_nonliteral)            \
 147   OPT("Wformat-security",       CL_ALL,   OPT_Wformat_security)              \
 148   OPT("Wformat-y2k",            CL_ALL,   OPT_Wformat_y2k)                   \
 149   OPT("Wformat-zero-length",    CL_C,     OPT_Wformat_zero_length)           \
 150   OPT("Wformat=",               CL_ALL | CL_JOINED, OPT_Wformat_eq)          \
 151   OPT("Wimplicit",              CL_CXX,   OPT_Wimplicit)                     \
 152   OPT("Wimplicit-function-declaration", CL_C, OPT_Wimplicit_function_decl)   \
 153   OPT("Wimplicit-int",          CL_C,     OPT_Wimplicit_int)                 \
 154   OPT("Wimport",                CL_ALL,   OPT_Wimport)                       \
 155   OPT("Wlong-long",             CL_ALL,   OPT_Wlong_long)                    \
 156   OPT("Wmain",                  CL_C,     OPT_Wmain)                         \
 157   OPT("Wmissing-braces",        CL_ALL,   OPT_Wmissing_braces)               \
 158   OPT("Wmissing-declarations",  CL_C,     OPT_Wmissing_declarations)         \
 159   OPT("Wmissing-format-attribute",CL_ALL, OPT_Wmissing_format_attribute)     \
 160   OPT("Wmissing-prototypes",    CL_ALL,   OPT_Wmissing_prototypes)           \
 161   OPT("Wmultichar",             CL_ALL,   OPT_Wmultichar)                    \
 162   OPT("Wnested-externs",        CL_C,     OPT_Wnested_externs)               \
 163   OPT("Wnon-template-friend",   CL_CXX,   OPT_Wnon_template_friend)          \
 164   OPT("Wnon-virtual-dtor",      CL_CXX,   OPT_Wnon_virtual_dtor)             \
 165   OPT("Wnonnull",               CL_C,     OPT_Wnonnull)                      \
 166   OPT("Wold-style-cast",        CL_CXX,   OPT_Wold_style_cast)               \
 167   OPT("Woverloaded-virtual",    CL_CXX,   OPT_Woverloaded_virtual)           \
 168   OPT("Wparentheses",           CL_ALL,   OPT_Wparentheses)                  \
 169   OPT("Wpmf-conversions",       CL_CXX,   OPT_Wpmf_conversions)              \
 170   OPT("Wpointer-arith",         CL_ALL,   OPT_Wpointer_arith)                \
 171   OPT("Wprotocol",              CL_OBJC,  OPT_Wprotocol)                     \
 172   OPT("Wredundant-decls",       CL_ALL,   OPT_Wredundant_decls)              \
 173   OPT("Wreorder",               CL_CXX,   OPT_Wreorder)                      \
 174   OPT("Wreturn-type",           CL_ALL,   OPT_Wreturn_type)                  \
 175   OPT("Wselector",              CL_OBJC,  OPT_Wselector)                     \
 176   OPT("Wsequence-point",        CL_C,     OPT_Wsequence_point)               \
 177   OPT("Wsign-compare",          CL_ALL,   OPT_Wsign_compare)                 \
 178   OPT("Wsign-promo",            CL_CXX,   OPT_Wsign_promo)                   \
 179   OPT("Wstrict-prototypes",     CL_ALL,   OPT_Wstrict_prototypes)            \
 180   OPT("Wsynth",                 CL_CXX,   OPT_Wsynth)                        \
 181   OPT("Wsystem-headers",        CL_ALL,   OPT_Wsystem_headers)               \
 182   OPT("Wtraditional",           CL_C,     OPT_Wtraditional)                  \
 183   OPT("Wtrigraphs",             CL_ALL,   OPT_Wtrigraphs)                    \
 184   OPT("Wundeclared-selector",   CL_OBJC,  OPT_Wundeclared_selector)          \
 185   OPT("Wundef",                 CL_ALL,   OPT_Wundef)                        \
 186   OPT("Wunknown-pragmas",       CL_ALL,   OPT_Wunknown_pragmas)              \
 187   OPT("Wunused-macros",         CL_ALL,   OPT_Wunused_macros)                \
 188   OPT("Wwrite-strings",         CL_ALL,   OPT_Wwrite_strings)                \
 189   OPT("ansi",                   CL_ALL,   OPT_ansi)                          \
 190   OPT("d",                      CL_ALL | CL_JOINED, OPT_d)                   \
 191   OPT("fabi-version=",          CL_CXX | CL_JOINED, OPT_fabi_version)        \
 192   OPT("faccess-control",        CL_CXX,   OPT_faccess_control)               \
 193   OPT("fall-virtual",           CL_CXX,   OPT_fall_virtual)                  \
 194   OPT("falt-external-templates",CL_CXX,   OPT_falt_external_templates)       \
 195   OPT("fasm",                   CL_ALL,   OPT_fasm)                          \
 196   OPT("fbuiltin",               CL_ALL,   OPT_fbuiltin)                      \
 197   OPT("fbuiltin-",              CL_ALL | CL_JOINED, OPT_fbuiltin_)           \
 198   OPT("fcheck-new",             CL_CXX,   OPT_fcheck_new)                    \
 199   OPT("fcond-mismatch",         CL_ALL,   OPT_fcond_mismatch)                \
 200   OPT("fconserve-space",        CL_CXX,   OPT_fconserve_space)               \
 201   OPT("fconst-strings",         CL_CXX,   OPT_fconst_strings)                \
 202   OPT("fconstant-string-class=", CL_OBJC | CL_JOINED,                        \
 203                                           OPT_fconstant_string_class)        \
 204   OPT("fdefault-inline",        CL_CXX,   OPT_fdefault_inline)               \
 205   OPT("fdollars-in-identifiers",CL_ALL,   OPT_fdollars_in_identifiers)       \
 206   OPT("fdump-",                 CL_ALL | CL_JOINED, OPT_fdump)               \
 207   OPT("felide-constructors",    CL_CXX,   OPT_felide_constructors)           \
 208   OPT("fenforce-eh-specs",      CL_CXX,   OPT_fenforce_eh_specs)             \
 209   OPT("fenum-int-equiv",        CL_CXX,   OPT_fenum_int_equiv)               \
 210   OPT("fexternal-templates",    CL_CXX,   OPT_fexternal_templates)           \
 211   OPT("ffor-scope",             CL_CXX,   OPT_ffor_scope)                    \
 212   OPT("ffreestanding",          CL_C,     OPT_ffreestanding)                 \
 213   OPT("fgnu-keywords",          CL_CXX,   OPT_fgnu_keywords)                 \
 214   OPT("fgnu-runtime",           CL_OBJC,  OPT_fgnu_runtime)                  \
 215   OPT("fguiding-decls",         CL_CXX,   OPT_fguiding_decls)                \
 216   OPT("fhandle-exceptions",     CL_CXX,   OPT_fhandle_exceptions)            \
 217   OPT("fhonor-std",             CL_CXX,   OPT_fhonor_std)                    \
 218   OPT("fhosted",                CL_C,     OPT_fhosted)                       \
 219   OPT("fhuge-objects",          CL_CXX,   OPT_fhuge_objects)                 \
 220   OPT("fimplement-inlines",     CL_CXX,   OPT_fimplement_inlines)            \
 221   OPT("fimplicit-inline-templates", CL_CXX, OPT_fimplicit_inline_templates)  \
 222   OPT("fimplicit-templates",    CL_CXX,   OPT_fimplicit_templates)           \
 223   OPT("flabels-ok",             CL_CXX,   OPT_flabels_ok)                    \
 224   OPT("fms-extensions",         CL_ALL,   OPT_fms_extensions)                \
 225   OPT("fname-mangling-version-",CL_CXX | CL_JOINED, OPT_fname_mangling)      \
 226   OPT("fnew-abi",               CL_CXX,   OPT_fnew_abi)                      \
 227   OPT("fnext-runtime",          CL_OBJC,  OPT_fnext_runtime)                 \
 228   OPT("fnonansi-builtins",      CL_CXX,   OPT_fnonansi_builtins)             \
 229   OPT("fnonnull-objects",       CL_CXX,   OPT_fnonnull_objects)              \
 230   OPT("foperator-names",        CL_CXX,   OPT_foperator_names)               \
 231   OPT("foptional-diags",        CL_CXX,   OPT_foptional_diags)               \
 232   OPT("fpermissive",            CL_CXX,   OPT_fpermissive)                   \
 233   OPT("fpreprocessed",          CL_ALL,   OPT_fpreprocessed)                 \
 234   OPT("frepo",                  CL_CXX,   OPT_frepo)                         \
 235   OPT("frtti",                  CL_CXX,   OPT_frtti)                         \
 236   OPT("fshort-double",          CL_ALL,   OPT_fshort_double)                 \
 237   OPT("fshort-enums",           CL_ALL,   OPT_fshort_enums)                  \
 238   OPT("fshort-wchar",           CL_ALL,   OPT_fshort_wchar)                  \
 239   OPT("fshow-column",           CL_ALL,   OPT_fshow_column)                  \
 240   OPT("fsigned-bitfields",      CL_ALL,   OPT_fsigned_bitfields)             \
 241   OPT("fsigned-char",           CL_ALL,   OPT_fsigned_char)                  \
 242   OPT("fsquangle",              CL_CXX,   OPT_fsquangle)                     \
 243   OPT("fstats",                 CL_CXX,   OPT_fstats)                        \
 244   OPT("fstrict-prototype",      CL_CXX,   OPT_fstrict_prototype)             \
 245   OPT("ftabstop=",              CL_ALL | CL_JOINED, OPT_ftabstop)            \
 246   OPT("ftemplate-depth-",       CL_CXX | CL_JOINED, OPT_ftemplate_depth)     \
 247   OPT("fthis-is-variable",      CL_CXX,   OPT_fthis_is_variable)             \
 248   OPT("funsigned-bitfields",    CL_ALL,   OPT_funsigned_bitfields)           \
 249   OPT("funsigned-char",         CL_ALL,   OPT_funsigned_char)                \
 250   OPT("fuse-cxa-atexit",        CL_CXX,   OPT_fuse_cxa_atexit)               \
 251   OPT("fvtable-gc",             CL_CXX,   OPT_fvtable_gc)                    \
 252   OPT("fvtable-thunks",         CL_CXX,   OPT_fvtable_thunks)                \
 253   OPT("fweak",                  CL_CXX,   OPT_fweak)                         \
 254   OPT("fxref",                  CL_CXX,   OPT_fxref)                         \
 255   OPT("gen-decls",              CL_OBJC,  OPT_gen_decls)                     \
 256   OPT("lang-asm",               CL_C_ONLY, OPT_lang_asm)                     \
 257   OPT("lang-objc",              CL_ALL,   OPT_lang_objc)                     \
 258   OPT("nostdinc",               CL_ALL,   OPT_nostdinc)                      \
 259   OPT("nostdinc++",             CL_ALL,   OPT_nostdincplusplus)              \
 260   OPT("o",                      CL_ALL | CL_ARG, OPT_o)                      \
 261   OPT("pedantic",               CL_ALL,   OPT_pedantic)                      \
 262   OPT("pedantic-errors",        CL_ALL,   OPT_pedantic_errors)               \
 263   OPT("print-objc-runtime-info", CL_OBJC, OPT_print_objc_runtime_info)       \
 264   OPT("remap",                  CL_ALL,   OPT_remap)                         \
 265   OPT("std=c++98",              CL_CXX,   OPT_std_cplusplus98)               \
 266   OPT("std=c89",                CL_C,     OPT_std_c89)                       \
 267   OPT("std=c99",                CL_C,     OPT_std_c99)                       \
 268   OPT("std=c9x",                CL_C,     OPT_std_c9x)                       \
 269   OPT("std=gnu++98",            CL_CXX,   OPT_std_gnuplusplus98)             \
 270   OPT("std=gnu89",              CL_C,     OPT_std_gnu89)                     \
 271   OPT("std=gnu99",              CL_C,     OPT_std_gnu99)                     \
 272   OPT("std=gnu9x",              CL_C,     OPT_std_gnu9x)                     \
 273   OPT("std=iso9899:1990",       CL_C,     OPT_std_iso9899_1990)              \
 274   OPT("std=iso9899:199409",     CL_C,     OPT_std_iso9899_199409)            \
 275   OPT("std=iso9899:1999",       CL_C,     OPT_std_iso9899_1999)              \
 276   OPT("std=iso9899:199x",       CL_C,     OPT_std_iso9899_199x)              \
 277   OPT("traditional-cpp",        CL_ALL,   OPT_traditional_cpp)               \
 278   OPT("trigraphs",              CL_ALL,   OPT_trigraphs)                     \
 279   OPT("undef",                  CL_ALL,   OPT_undef)                         \
 280   OPT("v",                      CL_ALL,   OPT_v)                             \
 281   OPT("w",                      CL_ALL,   OPT_w)
 282
 283 #define OPT(text, flags, code) code,
 284 enum opt_code
 285 {
 286   COMMAND_LINE_OPTIONS
 287   N_OPTS
 288 };
 289 #undef OPT
 290
 291 struct cl_option
 292 {
 293   const char *opt_text;
 294   unsigned char opt_len;
 295   unsigned char flags;
 296   ENUM_BITFIELD (opt_code) opt_code : 2 * CHAR_BIT;
 297 };
 298
 299 #define OPT(text, flags, code) { text, sizeof(text) - 1, flags, code },
 300 #ifdef HOST_EBCDIC
 301 static struct cl_option cl_options[] =
 302 #else
 303 static const struct cl_option cl_options[] =
 304 #endif
 305 {
 306   COMMAND_LINE_OPTIONS
 307 };
 308 #undef OPT
 309 #undef COMMAND_LINE_OPTIONS
 310
 311 /* Holds switches parsed by c_common_decode_option (), but whose
 312    handling is deffered to c_common_post_options ().  */
 313 static void defer_opt PARAMS ((enum opt_code, const char *));
 314 static struct deferred_opt
 315 {
 316   enum opt_code code;
 317   const char *arg;
 318 } *deferred_opts;
 319
 320
 321 #ifdef HOST_EBCDIC
 322 static int opt_comp PARAMS ((const void *, const void *));
 323
 324 /* Run-time sorting of options array.  */
 325 static int
 326 opt_comp (p1, p2)
 327      const void *p1, *p2;
 328 {
 329   return strcmp (((struct cl_option *) p1)->opt_text,
 330                  ((struct cl_option *) p2)->opt_text);
 331 }
 332 #endif
 333
 334 /* Complain that switch OPT_INDEX expects an argument but none was
 335    provided.  */
 336 static void
 337 missing_arg (opt_index)
 338      size_t opt_index;
 339 {
 340   const char *opt_text = cl_options[opt_index].opt_text;
 341
 342   switch (opt_index)
 343     {
 344     case OPT_Wformat_eq:
 345     case OPT_d:
 346     case OPT_fabi_version:
 347     case OPT_fbuiltin_:
 348     case OPT_fdump:
 349     case OPT_fname_mangling:
 350     case OPT_ftabstop:
 351     case OPT_ftemplate_depth:
 352     default:
 353       error ("missing argument to \"-%s\"", opt_text);
 354       break;
 355
 356     case OPT_fconstant_string_class:
 357       error ("no class name specified with \"-%s\"", opt_text);
 358       break;
 359
 360     case OPT_MF:
 361     case OPT_MD:
 362     case OPT_MMD:
 363     case OPT_o:
 364       error ("missing filename after \"-%s\"", opt_text);
 365       break;
 366
 367     case OPT_MQ:
 368     case OPT_MT:
 369       error ("missing target after \"-%s\"", opt_text);
 370       break;
 371     }
 372 }
 373
 374 /* Perform a binary search to find which option the command-line INPUT
 375    matches.  Returns its index in the option array, and N_OPTS on
 376    failure.
 377
 378    Complications arise since some options can be suffixed with an
 379    argument, and multiple complete matches can occur, e.g. -pedantic
 380    and -pedantic-errors.  Also, some options are only accepted by some
 381    languages.  If a switch matches for a different language and
 382    doesn't match any alternatives for the true front end, the index of
 383    the matched switch is returned anyway.  The caller should check for
 384    this case.  */
 385 static size_t
 386 find_opt (input, lang_flag)
 387      const char *input;
 388      int lang_flag;
 389 {
 390   size_t md, mn, mx;
 391   size_t opt_len;
 392   size_t result = N_OPTS;
 393   int comp;
 394
 395   mn = 0;
 396   mx = N_OPTS;
 397
 398   while (mx > mn)
 399     {
 400       md = (mn + mx) / 2;
 401
 402       opt_len = cl_options[md].opt_len;
 403       comp = memcmp (input, cl_options[md].opt_text, opt_len);
 404
 405       if (comp < 0)
 406         mx = md;
 407       else if (comp > 0)
 408         mn = md + 1;
 409       else
 410         {
 411           /* The switch matches.  It it an exact match?  */
 412           if (input[opt_len] == '\0')
 413             return md;
 414           else
 415             {
 416               mn = md + 1;
 417
 418               /* If the switch takes no arguments this is not a proper
 419                  match, so we continue the search (e.g. input="stdc++"
 420                  match was "stdc").  */
 421               if (!(cl_options[md].flags & CL_JOINED))
 422                 continue;
 423
 424               /* Is this switch valid for this front end?  */
 425               if (!(cl_options[md].flags & lang_flag))
 426                 {
 427                   /* If subsequently we don't find a better match,
 428                      return this and let the caller report it as a bad
 429                      match.  */
 430                   result = md;
 431                   continue;
 432                 }
 433
 434               /* Two scenarios remain: we have the switch's argument,
 435                  or we match a longer option.  This can happen with
 436                  -iwithprefix and -withprefixbefore.  The longest
 437                  possible option match succeeds.
 438
 439                  Scan forwards, and return an exact match.  Otherwise
 440                  return the longest valid option-accepting match (mx).
 441                  This loops at most twice with current options.  */
 442               mx = md;
 443               for (md = md + 1; md < (size_t) N_OPTS; md++)
 444                 {
 445                   opt_len = cl_options[md].opt_len;
 446                   if (memcmp (input, cl_options[md].opt_text, opt_len))
 447                     break;
 448                   if (input[opt_len] == '\0')
 449                     return md;
 450                   if (cl_options[md].flags & lang_flag
 451                       && cl_options[md].flags & CL_JOINED)
 452                     mx = md;
 453                 }
 454
 455               return mx;
 456             }
 457         }
 458     }
 459
 460   return result;
 461 }
 462
 463 /* Defer option CODE with argument ARG.  */
 464 static void
 465 defer_opt (code, arg)
 466      enum opt_code code;
 467      const char *arg;
 468 {
 469   /* FIXME: this should be in c_common_init_options, which should take
 470      argc and argv.  */
 471   if (!deferred_opts)
 472     {
 473       extern int save_argc;
 474       deferred_size = save_argc;
 475       deferred_opts = (struct deferred_opt *)
 476         xmalloc (deferred_size * sizeof (struct deferred_opt));
 477     }
 478
 479   if (deferred_count == deferred_size)
 480     abort ();
 481
 482   deferred_opts[deferred_count].code = code;
 483   deferred_opts[deferred_count].arg = arg;
 484   deferred_count++;
 485 }
 486
 487 /* Common initialization before parsing options.  */
 488 void
 489 c_common_init_options (lang)
 490      enum c_language_kind lang;
 491 {
 492 #ifdef HOST_EBCDIC
 493   /* For non-ASCII hosts, the cl_options array needs to be sorted at
 494      runtime.  */
 495   qsort (cl_options, N_OPTS, sizeof (struct cl_option), opt_comp);
 496 #endif
 497 #if ENABLE_CHECKING
 498  {
 499   size_t i;
 500
 501   for (i = 1; i < N_OPTS; i++)
 502     if (strcmp (cl_options[i - 1].opt_text, cl_options[i].opt_text) >= 0)
 503       error ("options array incorrectly sorted: %s is before %s",
 504              cl_options[i - 1].opt_text, cl_options[i].opt_text);
 505  }
 506 #endif
 507
 508   c_language = lang;
 509   parse_in = cpp_create_reader (lang == clk_c ? CLK_GNUC89 : CLK_GNUCXX);
 510   cpp_opts = cpp_get_options (parse_in);
 511   if (flag_objc)
 512     cpp_opts->objc = 1;
 513
 514   flag_const_strings = (lang == clk_cplusplus);
 515   warn_pointer_arith = (lang == clk_cplusplus);
 516   if (lang == clk_c)
 517     warn_sign_compare = -1;
 518
 519   /* Mark as "unspecified" (see c_common_post_options).  */
 520   flag_bounds_check = -1;
 521 }
 522
 523 /* Handle one command-line option in (argc, argv).
 524    Can be called multiple times, to handle multiple sets of options.
 525    Returns number of strings consumed.  */
 526 int
 527 c_common_decode_option (argc, argv)
 528      int argc;
 529      char **argv;
 530 {
 531   static const int lang_flags[] = {CL_C_ONLY, CL_C, CL_CXX_ONLY, CL_CXX};
 532   size_t opt_index;
 533   const char *opt, *arg = 0;
 534   char *dup = 0;
 535   bool on = true;
 536   int result, lang_flag;
 537   const struct cl_option *option;
 538   enum opt_code code;
 539
 540   opt = argv[0];
 541
 542   /* Interpret "-" or a non-switch as a file name.  */
 543   if (opt[0] != '-' || opt[1] == '\0')
 544     {
 545       if (!in_fname)
 546         in_fname = opt;
 547       else if (!out_fname)
 548         out_fname = opt;
 549       else
 550         {
 551           error ("too many filenames given.  Type %s --help for usage",
 552                  progname);
 553           return argc;
 554         }
 555
 556       return 1;
 557     }
 558
 559   /* Drop the "no-" from negative switches.  */
 560   if ((opt[1] == 'W' || opt[1] == 'f')
 561       && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-')
 562     {
 563       size_t len = strlen (opt) - 3;
 564
 565       dup = xmalloc (len + 1);
 566       dup[0] = '-';
 567       dup[1] = opt[1];
 568       memcpy (dup + 2, opt + 5, len - 2 + 1);
 569       opt = dup;
 570       on = false;
 571     }
 572
 573   result = cpp_handle_option (parse_in, argc, argv);
 574
 575   /* Skip over '-'.  */
 576   lang_flag = lang_flags[(c_language << 1) + flag_objc];
 577   opt_index = find_opt (opt + 1, lang_flag);
 578   if (opt_index == N_OPTS)
 579     goto done;
 580
 581   result = 1;
 582   option = &cl_options[opt_index];
 583
 584   /* Sort out any argument the switch takes.  */
 585   if (option->flags & CL_ARG)
 586     {
 587       if (option->flags & CL_JOINED)
 588         {
 589           /* Have arg point to the original switch.  This is because
 590              some code, such as disable_builtin_function, expects its
 591              argument to be persistent until the program exits.  */
 592           arg = argv[0] + cl_options[opt_index].opt_len + 1;
 593           if (!on)
 594             arg += strlen ("no-");
 595         }
 596
 597       /* If we don't have an argument, and CL_SEPARATE, try the next
 598          argument in the vector.  */
 599       if (!arg || (*arg == '\0' && option->flags & CL_SEPARATE))
 600         {
 601           arg = argv[1];
 602           result = 2;
 603         }
 604
 605       if (!arg || *arg == '\0')
 606         {
 607           missing_arg (opt_index);
 608           result = argc;
 609           goto done;
 610         }
 611     }
 612
 613   /* Complain about the wrong language after we've swallowed any
 614      necessary extra argument.  Eventually make this a hard error
 615      after the call to find_opt, and return argc.  */
 616   if (!(cl_options[opt_index].flags & lang_flag))
 617     {
 618       complain_wrong_lang (opt_index);
 619       goto done;
 620     }
 621
 622   switch (code = option->opt_code)
 623     {
 624     case N_OPTS: /* Shut GCC up.  */
 625       break;
 626
 627     case OPT__help:
 628       print_help ();
 629       break;
 630
 631     case OPT_C:
 632       cpp_opts->discard_comments = 0;
 633       break;
 634
 635     case OPT_CC:
 636       cpp_opts->discard_comments = 0;
 637       cpp_opts->discard_comments_in_macro_exp = 0;
 638       break;
 639
 640     case OPT_E:
 641       flag_preprocess_only = 1;
 642       break;
 643
 644     case OPT_H:
 645       cpp_opts->print_include_names = 1;
 646       break;
 647
 648     case OPT_M:
 649     case OPT_MM:
 650       /* When doing dependencies with -M or -MM, suppress normal
 651          preprocessed output, but still do -dM etc. as software
 652          depends on this.  Preprocessed output does occur if -MD, -MMD
 653          or environment var dependency generation is used.  */
 654       cpp_opts->deps.style = (code == OPT_M ? DEPS_SYSTEM: DEPS_USER);
 655       cpp_opts->no_output = 1;
 656       cpp_opts->inhibit_warnings = 1;
 657       break;
 658
 659     case OPT_MD:
 660     case OPT_MMD:
 661       cpp_opts->deps.style = (code == OPT_MD ? DEPS_SYSTEM: DEPS_USER);
 662       deps_file = arg;
 663       break;
 664
 665     case OPT_MF:
 666       deps_seen = true;
 667       deps_file = arg;
 668       break;
 669
 670     case OPT_MG:
 671       deps_seen = true;
 672       cpp_opts->deps.missing_files = true;
 673       break;
 674
 675     case OPT_MP:
 676       deps_seen = true;
 677       cpp_opts->deps.phony_targets = true;
 678       break;
 679
 680     case OPT_MQ:
 681     case OPT_MT:
 682       deps_seen = true;
 683       defer_opt (code, arg);
 684       break;
 685
 686     case OPT_P:
 687       cpp_opts->no_line_commands = 1;
 688       break;
 689
 690     case OPT_Wabi:
 691       warn_abi = on;
 692       break;
 693
 694     case OPT_Wall:
 695       set_Wunused (on);
 696       set_Wformat (on);
 697       set_Wimplicit (on);
 698       warn_char_subscripts = on;
 699       warn_missing_braces = on;
 700       warn_parentheses = on;
 701       warn_return_type = on;
 702       warn_sequence_point = on; /* Was C only.  */
 703       warn_sign_compare = on;   /* Was C++ only.  */
 704       warn_switch = on;
 705
 706       /* Only warn about unknown pragmas that are not in system
 707          headers.  */
 708       warn_unknown_pragmas = on;
 709
 710       /* We save the value of warn_uninitialized, since if they put
 711          -Wuninitialized on the command line, we need to generate a
 712          warning about not using it without also specifying -O.  */
 713       if (warn_uninitialized != 1)
 714         warn_uninitialized = (on ? 2 : 0);
 715
 716       if (c_language == clk_c)
 717         /* We set this to 2 here, but 1 in -Wmain, so -ffreestanding
 718            can turn it off only if it's not explicit.  */
 719         warn_main = on * 2;
 720       else
 721         {
 722           /* C++-specific warnings.  */
 723           warn_ctor_dtor_privacy = on;
 724           warn_nonvdtor = on;
 725           warn_reorder = on;
 726           warn_nontemplate_friend = on;
 727         }
 728
 729       cpp_opts->warn_trigraphs = on;
 730       cpp_opts->warn_comments = on;
 731       cpp_opts->warn_num_sign_change = on;
 732       cpp_opts->warn_multichar = on;    /* Was C++ only.  */
 733       break;
 734
 735     case OPT_Wbad_function_cast:
 736       warn_bad_function_cast = on;
 737       break;
 738
 739     case OPT_Wcast_qual:
 740       warn_cast_qual = on;
 741       break;
 742
 743     case OPT_Wchar_subscripts:
 744       warn_char_subscripts = on;
 745       break;
 746
 747     case OPT_Wcomment:
 748     case OPT_Wcomments:
 749       cpp_opts->warn_comments = on;
 750       break;
 751
 752     case OPT_Wconversion:
 753       warn_conversion = on;
 754       break;
 755
 756     case OPT_Wctor_dtor_privacy:
 757       warn_ctor_dtor_privacy = on;
 758       break;
 759
 760     case OPT_Wdeprecated:
 761       warn_deprecated = on;
 762       break;
 763
 764     case OPT_Wdiv_by_zero:
 765       warn_div_by_zero = on;
 766       break;
 767
 768     case OPT_Weffcxx:
 769       warn_ecpp = on;
 770       break;
 771
 772     case OPT_Wendif_labels:
 773       cpp_opts->warn_endif_labels = on;
 774       break;
 775
 776     case OPT_Werror:
 777       cpp_opts->warnings_are_errors = on;
 778       break;
 779
 780     case OPT_Werror_implicit_function_decl:
 781       if (!on)
 782         result = 0;
 783       else
 784         mesg_implicit_function_declaration = 2;
 785       break;
 786
 787     case OPT_Wfloat_equal:
 788       warn_float_equal = on;
 789       break;
 790
 791     case OPT_Wformat:
 792       set_Wformat (on);
 793       break;
 794
 795     case OPT_Wformat_eq:
 796       set_Wformat (atoi (arg));
 797       break;
 798
 799     case OPT_Wformat_extra_args:
 800       warn_format_extra_args = on;
 801       break;
 802
 803     case OPT_Wformat_nonliteral:
 804       warn_format_nonliteral = on;
 805       break;
 806
 807     case OPT_Wformat_security:
 808       warn_format_security = on;
 809       break;
 810
 811     case OPT_Wformat_y2k:
 812       warn_format_y2k = on;
 813       break;
 814
 815     case OPT_Wformat_zero_length:
 816       warn_format_zero_length = on;
 817       break;
 818
 819     case OPT_Wimplicit:
 820       set_Wimplicit (on);
 821       break;
 822
 823     case OPT_Wimplicit_function_decl:
 824       mesg_implicit_function_declaration = on;
 825       break;
 826
 827     case OPT_Wimplicit_int:
 828       warn_implicit_int = on;
 829       break;
 830
 831     case OPT_Wimport:
 832       cpp_opts->warn_import = on;
 833       break;
 834
 835     case OPT_Wlong_long:
 836       warn_long_long = on;
 837       break;
 838
 839     case OPT_Wmain:
 840       if (on)
 841         warn_main = 1;
 842       else
 843         warn_main = -1;
 844       break;
 845
 846     case OPT_Wmissing_braces:
 847       warn_missing_braces = on;
 848       break;
 849
 850     case OPT_Wmissing_declarations:
 851       warn_missing_declarations = on;
 852       break;
 853
 854     case OPT_Wmissing_format_attribute:
 855       warn_missing_format_attribute = on;
 856       break;
 857
 858     case OPT_Wmissing_prototypes:
 859       warn_missing_prototypes = on;
 860       break;
 861
 862     case OPT_Wmultichar:
 863       cpp_opts->warn_multichar = on;
 864       break;
 865
 866     case OPT_Wnested_externs:
 867       warn_nested_externs = on;
 868       break;
 869
 870     case OPT_Wnon_template_friend:
 871       warn_nontemplate_friend = on;
 872       break;
 873
 874     case OPT_Wnon_virtual_dtor:
 875       warn_nonvdtor = on;
 876       break;
 877
 878     case OPT_Wnonnull:
 879       warn_nonnull = on;
 880       break;
 881
 882     case OPT_Wold_style_cast:
 883       warn_old_style_cast = on;
 884       break;
 885
 886     case OPT_Woverloaded_virtual:
 887       warn_overloaded_virtual = on;
 888       break;
 889
 890     case OPT_Wparentheses:
 891       warn_parentheses = on;
 892       break;
 893
 894     case OPT_Wpmf_conversions:
 895       warn_pmf2ptr = on;
 896       break;
 897
 898     case OPT_Wpointer_arith:
 899       warn_pointer_arith = on;
 900       break;
 901
 902     case OPT_Wprotocol:
 903       warn_protocol = on;
 904       break;
 905
 906     case OPT_Wselector:
 907       warn_selector = on;
 908       break;
 909
 910     case OPT_Wredundant_decls:
 911       warn_redundant_decls = on;
 912       break;
 913
 914     case OPT_Wreorder:
 915       warn_reorder = on;
 916       break;
 917
 918     case OPT_Wreturn_type:
 919       warn_return_type = on;
 920       break;
 921
 922     case OPT_Wsequence_point:
 923       warn_sequence_point = on;
 924       break;
 925
 926     case OPT_Wsign_compare:
 927       warn_sign_compare = on;
 928       break;
 929
 930     case OPT_Wsign_promo:
 931       warn_sign_promo = on;
 932       break;
 933
 934     case OPT_Wstrict_prototypes:
 935       if (!on && c_language == clk_cplusplus)
 936         warning ("-Wno-strict-prototypes is not supported in C++");
 937       else
 938         warn_strict_prototypes = on;
 939       break;
 940
 941     case OPT_Wsynth:
 942       warn_synth = on;
 943       break;
 944
 945     case OPT_Wsystem_headers:
 946       cpp_opts->warn_system_headers = on;
 947       break;
 948
 949     case OPT_Wtraditional:
 950       warn_traditional = on;
 951       cpp_opts->warn_traditional = on;
 952       break;
 953
 954     case OPT_Wtrigraphs:
 955       cpp_opts->warn_trigraphs = on;
 956       break;
 957
 958     case OPT_Wundeclared_selector:
 959       warn_undeclared_selector = on;
 960       break;
 961
 962     case OPT_Wundef:
 963       cpp_opts->warn_undef = on;
 964       break;
 965
 966     case OPT_Wunknown_pragmas:
 967       /* Set to greater than 1, so that even unknown pragmas in
 968          system headers will be warned about.  */
 969       warn_unknown_pragmas = on * 2;
 970       break;
 971
 972     case OPT_Wunused_macros:
 973       cpp_opts->warn_unused_macros = on;
 974       break;
 975
 976     case OPT_Wwrite_strings:
 977       if (c_language == clk_c)
 978         flag_const_strings = on;
 979       else
 980         warn_write_strings = on;
 981       break;
 982
 983     case OPT_ansi:
 984       if (c_language == clk_c)
 985         set_std_c89 (false, true);
 986       else
 987         set_std_cxx98 (true);
 988       break;
 989
 990     case OPT_d:
 991       handle_OPT_d (arg);
 992       break;
 993
 994     case OPT_fcond_mismatch:
 995       if (c_language == clk_c)
 996         {
 997           flag_cond_mismatch = on;
 998           break;
 999         }
1000       /* Fall through.  */
1001
1002     case OPT_fall_virtual:
1003     case OPT_fenum_int_equiv:
1004     case OPT_fguiding_decls:
1005     case OPT_fhonor_std:
1006     case OPT_fhuge_objects:
1007     case OPT_flabels_ok:
1008     case OPT_fname_mangling:
1009     case OPT_fnew_abi:
1010     case OPT_fnonnull_objects:
1011     case OPT_fsquangle:
1012     case OPT_fstrict_prototype:
1013     case OPT_fthis_is_variable:
1014     case OPT_fvtable_thunks:
1015     case OPT_fxref:
1016       warning ("switch \"%s\" is no longer supported", argv[0]);
1017       break;
1018
1019     case OPT_fabi_version:
1020       flag_abi_version = read_integral_parameter (arg, argv[0], 1);
1021       break;
1022
1023     case OPT_faccess_control:
1024       flag_access_control = on;
1025       break;
1026
1027     case OPT_falt_external_templates:
1028       flag_alt_external_templates = on;
1029       if (on)
1030         flag_external_templates = true;
1031     cp_deprecated:
1032       warning ("switch \"%s\" is deprecated, please see documentation for details", argv[0]);
1033       break;
1034
1035     case OPT_fasm:
1036       flag_no_asm = !on;
1037       break;
1038
1039     case OPT_fbuiltin:
1040       flag_no_builtin = !on;
1041       break;
1042
1043     case OPT_fbuiltin_:
1044       if (on)
1045         result = 0;
1046       else
1047         disable_builtin_function (arg);
1048       break;
1049
1050     case OPT_fdollars_in_identifiers:
1051       dollars_in_ident = on;
1052       break;
1053
1054     case OPT_fdump:
1055       if (!on || !dump_switch_p (argv[0] + strlen ("-f")))
1056         result = 0;
1057       break;
1058
1059     case OPT_ffreestanding:
1060       on = !on;
1061       /* Fall through...  */
1062     case OPT_fhosted:
1063       flag_hosted = on;
1064       flag_no_builtin = !on;
1065       /* warn_main will be 2 if set by -Wall, 1 if set by -Wmain */
1066       if (!on && warn_main == 2)
1067         warn_main = 0;
1068       break;
1069
1070     case OPT_fshort_double:
1071       flag_short_double = on;
1072       break;
1073
1074     case OPT_fshort_enums:
1075       flag_short_enums = on;
1076       break;
1077
1078     case OPT_fshort_wchar:
1079       flag_short_wchar = on;
1080       break;
1081
1082     case OPT_fsigned_bitfields:
1083       flag_signed_bitfields = on;
1084       explicit_flag_signed_bitfields = 1;
1085       break;
1086
1087     case OPT_fsigned_char:
1088       flag_signed_char = on;
1089       break;
1090
1091     case OPT_funsigned_bitfields:
1092       flag_signed_bitfields = !on;
1093       explicit_flag_signed_bitfields = 1;
1094       break;
1095
1096     case OPT_funsigned_char:
1097       flag_signed_char = !on;
1098       break;
1099
1100     case OPT_fcheck_new:
1101       flag_check_new = on;
1102       break;
1103
1104     case OPT_fconserve_space:
1105       flag_conserve_space = on;
1106       break;
1107
1108     case OPT_fconst_strings:
1109       flag_const_strings = on;
1110       break;
1111
1112     case OPT_fconstant_string_class:
1113       constant_string_class_name = arg;
1114       break;
1115
1116     case OPT_fdefault_inline:
1117       flag_default_inline = on;
1118       break;
1119
1120     case OPT_felide_constructors:
1121       flag_elide_constructors = on;
1122       break;
1123
1124     case OPT_fenforce_eh_specs:
1125       flag_enforce_eh_specs = on;
1126       break;
1127
1128     case OPT_fexternal_templates:
1129       flag_external_templates = on;
1130       goto cp_deprecated;
1131
1132     case OPT_ffor_scope:
1133       flag_new_for_scope = on;
1134       break;
1135
1136     case OPT_fgnu_keywords:
1137       flag_no_gnu_keywords = !on;
1138       break;
1139
1140     case OPT_fgnu_runtime:
1141       flag_next_runtime = !on;
1142       break;
1143
1144     case OPT_fhandle_exceptions:
1145       warning ("-fhandle-exceptions has been renamed to -fexceptions (and is now on by default)");
1146       flag_exceptions = on;
1147       break;
1148
1149     case OPT_fimplement_inlines:
1150       flag_implement_inlines = on;
1151       break;
1152
1153     case OPT_fimplicit_inline_templates:
1154       flag_implicit_inline_templates = on;
1155       break;
1156
1157     case OPT_fimplicit_templates:
1158       flag_implicit_templates = on;
1159       break;
1160
1161     case OPT_fms_extensions:
1162       flag_ms_extensions = on;
1163       break;
1164
1165     case OPT_fnext_runtime:
1166       flag_next_runtime = on;
1167       break;
1168
1169     case OPT_fnonansi_builtins:
1170       flag_no_nonansi_builtin = !on;
1171       break;
1172
1173     case OPT_foperator_names:
1174       cpp_opts->operator_names = on;
1175       break;
1176
1177     case OPT_foptional_diags:
1178       flag_optional_diags = on;
1179       break;
1180
1181     case OPT_fpermissive:
1182       flag_permissive = on;
1183       break;
1184
1185     case OPT_fpreprocessed:
1186       cpp_opts->preprocessed = on;
1187       break;
1188
1189     case OPT_frepo:
1190       flag_use_repository = on;
1191       if (on)
1192         flag_implicit_templates = 0;
1193       break;
1194
1195     case OPT_frtti:
1196       flag_rtti = on;
1197       break;
1198
1199     case OPT_fshow_column:
1200       cpp_opts->show_column = on;
1201       break;
1202
1203     case OPT_fstats:
1204       flag_detailed_statistics = on;
1205       break;
1206
1207     case OPT_ftabstop:
1208       /* Don't recognize -fno-tabstop=.  */
1209       if (!on)
1210         return 0;
1211
1212       /* It is documented that we silently ignore silly values.  */
1213         {
1214           char *endptr;
1215           long tabstop = strtol (arg, &endptr, 10);
1216           if (*endptr == '\0' && tabstop >= 1 && tabstop <= 100)
1217             cpp_opts->tabstop = tabstop;
1218         }
1219       break;
1220
1221     case OPT_ftemplate_depth:
1222       max_tinst_depth = read_integral_parameter (arg, argv[0], 0);
1223       break;
1224
1225     case OPT_fvtable_gc:
1226       flag_vtable_gc = on;
1227       break;
1228
1229     case OPT_fuse_cxa_atexit:
1230       flag_use_cxa_atexit = on;
1231       break;
1232
1233     case OPT_fweak:
1234       flag_weak = on;
1235       break;
1236
1237     case OPT_gen_decls:
1238       flag_gen_declaration = 1;
1239       break;
1240
1241     case OPT_lang_asm:
1242       cpp_set_lang (parse_in, CLK_ASM);
1243       break;
1244
1245     case OPT_lang_objc:
1246       cpp_opts->objc = 1;
1247       break;
1248
1249     case OPT_nostdinc:
1250       /* No default include directories.  You must specify all
1251          include-file directories with -I.  */
1252       cpp_opts->no_standard_includes = 1;
1253       break;
1254
1255     case OPT_nostdincplusplus:
1256       /* No default C++-specific include directories.  */
1257       cpp_opts->no_standard_cplusplus_includes = 1;
1258       break;
1259
1260     case OPT_o:
1261       if (!out_fname)
1262         out_fname = arg;
1263       else
1264         {
1265           error ("output filename specified twice");
1266           result = argc;
1267         }
1268       break;
1269
1270       /* We need to handle the -pedantic switches here, rather than in
1271          c_common_post_options, so that a subsequent -Wno-endif-labels
1272          is not overridden.  */
1273     case OPT_pedantic_errors:
1274       cpp_opts->pedantic_errors = 1;
1275       /* fall through */
1276     case OPT_pedantic:
1277       cpp_opts->pedantic = 1;
1278       cpp_opts->warn_endif_labels = 1;
1279       break;
1280
1281     case OPT_print_objc_runtime_info:
1282       print_struct_values = 1;
1283       break;
1284
1285     case OPT_remap:
1286       cpp_opts->remap = 1;
1287       break;
1288
1289     case OPT_std_cplusplus98:
1290     case OPT_std_gnuplusplus98:
1291       set_std_cxx98 (code == OPT_std_cplusplus98 /* ISO */);
1292       break;
1293
1294     case OPT_std_c89:
1295     case OPT_std_iso9899_1990:
1296     case OPT_std_iso9899_199409:
1297       set_std_c89 (code == OPT_std_iso9899_199409 /* c94 */, true /* ISO */);
1298       break;
1299
1300     case OPT_std_gnu89:
1301       set_std_c89 (false /* c94 */, false /* ISO */);
1302       break;
1303
1304     case OPT_std_c99:
1305     case OPT_std_c9x:
1306     case OPT_std_iso9899_1999:
1307     case OPT_std_iso9899_199x:
1308       set_std_c99 (true /* ISO */);
1309       break;
1310
1311     case OPT_std_gnu99:
1312     case OPT_std_gnu9x:
1313       set_std_c99 (false /* ISO */);
1314       break;
1315
1316     case OPT_trigraphs:
1317       cpp_opts->trigraphs = 1;
1318       break;
1319
1320     case OPT_traditional_cpp:
1321       cpp_opts->traditional = 1;
1322       break;
1323
1324     case OPT_undef:
1325       flag_undef = 1;
1326       break;
1327
1328     case OPT_w:
1329       cpp_opts->inhibit_warnings = 1;
1330       break;
1331
1332     case OPT_v:
1333       cpp_opts->verbose = 1;
1334       break;
1335     }
1336
1337  done:
1338   if (dup)
1339     free (dup);
1340   return result;
1341 }
1342
1343 /* Post-switch processing.  */
1344 bool
1345 c_common_post_options ()
1346 {
1347   /* Canonicalize the input and output filenames.  */
1348   if (in_fname == NULL || !strcmp (in_fname, "-"))
1349     in_fname = "";
1350
1351   if (out_fname == NULL || !strcmp (out_fname, "-"))
1352     out_fname = "";
1353
1354   if (cpp_opts->deps.style == DEPS_NONE)
1355     check_deps_environment_vars ();
1356
1357   handle_deferred_opts ();
1358
1359   sanitize_cpp_opts ();
1360
1361   flag_inline_trees = 1;
1362
1363   /* Use tree inlining if possible.  Function instrumentation is only
1364      done in the RTL level, so we disable tree inlining.  */
1365   if (! flag_instrument_function_entry_exit)
1366     {
1367       if (!flag_no_inline)
1368         flag_no_inline = 1;
1369       if (flag_inline_functions)
1370         {
1371           flag_inline_trees = 2;
1372           flag_inline_functions = 0;
1373         }
1374     }
1375
1376   /* If still "unspecified", make it match -fbounded-pointers.  */
1377   if (flag_bounds_check == -1)
1378     flag_bounds_check = flag_bounded_pointers;
1379
1380   /* Special format checking options don't work without -Wformat; warn if
1381      they are used.  */
1382   if (warn_format_y2k && !warn_format)
1383     warning ("-Wformat-y2k ignored without -Wformat");
1384   if (warn_format_extra_args && !warn_format)
1385     warning ("-Wformat-extra-args ignored without -Wformat");
1386   if (warn_format_zero_length && !warn_format)
1387     warning ("-Wformat-zero-length ignored without -Wformat");
1388   if (warn_format_nonliteral && !warn_format)
1389     warning ("-Wformat-nonliteral ignored without -Wformat");
1390   if (warn_format_security && !warn_format)
1391     warning ("-Wformat-security ignored without -Wformat");
1392   if (warn_missing_format_attribute && !warn_format)
1393     warning ("-Wmissing-format-attribute ignored without -Wformat");
1394
1395   /* If an error has occurred in cpplib, note it so we fail
1396      immediately.  */
1397   errorcount += cpp_errors (parse_in);
1398
1399   return flag_preprocess_only;
1400 }
1401
1402 /* Preprocess the input file to out_stream.  */
1403 static void
1404 preprocess_file ()
1405 {
1406   /* Open the output now.  We must do so even if no_output is on,
1407      because there may be other output than from the actual
1408      preprocessing (e.g. from -dM).  */
1409   if (out_fname[0] == '\0')
1410     out_stream = stdout;
1411   else
1412     out_stream = fopen (out_fname, "w");
1413
1414   if (out_stream == NULL)
1415     fatal_io_error ("opening output file %s", out_fname);
1416   else
1417     cpp_preprocess_file (parse_in, in_fname, out_stream);
1418 }
1419
1420 /* Front end initialization common to C, ObjC and C++.  */
1421 const char *
1422 c_common_init (filename)
1423      const char *filename;
1424 {
1425   /* Set up preprocessor arithmetic.  Must be done after call to
1426      c_common_nodes_and_builtins for type nodes to be good.  */
1427   cpp_opts->precision = TYPE_PRECISION (intmax_type_node);
1428   cpp_opts->char_precision = TYPE_PRECISION (char_type_node);
1429   cpp_opts->int_precision = TYPE_PRECISION (integer_type_node);
1430   cpp_opts->wchar_precision = TYPE_PRECISION (wchar_type_node);
1431   cpp_opts->unsigned_wchar = TREE_UNSIGNED (wchar_type_node);
1432
1433   /* Register preprocessor built-ins before calls to
1434      cpp_main_file.  */
1435   cpp_get_callbacks (parse_in)->register_builtins = cb_register_builtins;
1436
1437   /* NULL is passed up to toplev.c and we exit quickly.  */
1438   if (flag_preprocess_only)
1439     {
1440       preprocess_file ();
1441       return NULL;
1442     }
1443
1444   /* Do this before initializing pragmas, as then cpplib's hash table
1445      has been set up.  NOTE: we are using our own file name here, not
1446      the one supplied.  */
1447   filename = init_c_lex (in_fname);
1448
1449   init_pragma ();
1450
1451   return filename;
1452 }
1453
1454 /* Common finish hook for the C, ObjC and C++ front ends.  */
1455 void
1456 c_common_finish ()
1457 {
1458   FILE *deps_stream = NULL;
1459
1460   if (cpp_opts->deps.style != DEPS_NONE)
1461     {
1462       /* If -M or -MM was seen without -MF, default output to the
1463          output stream.  */
1464       if (!deps_file)
1465         deps_stream = out_stream;
1466       else
1467         {
1468           deps_stream = fopen (deps_file, deps_append ? "a": "w");
1469           if (!deps_stream)
1470             fatal_io_error ("opening dependency file %s", deps_file);
1471         }
1472     }
1473
1474   /* For performance, avoid tearing down cpplib's internal structures
1475      with cpp_destroy ().  */
1476   errorcount += cpp_finish (parse_in, deps_stream);
1477
1478   if (deps_stream && deps_stream != out_stream
1479       && (ferror (deps_stream) || fclose (deps_stream)))
1480     fatal_io_error ("closing dependency file %s", deps_file);
1481
1482   if (out_stream && (ferror (out_stream) || fclose (out_stream)))
1483     fatal_io_error ("when writing output to %s", out_fname);
1484 }
1485
1486 /* Either of two environment variables can specify output of
1487    dependencies.  Their value is either "OUTPUT_FILE" or "OUTPUT_FILE
1488    DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to
1489    and DEPS_TARGET is the target to mention in the deps.  They also
1490    result in dependency information being appended to the output file
1491    rather than overwriting it, and like Sun's compiler
1492    SUNPRO_DEPENDENCIES suppresses the dependency on the main file.  */
1493 static void
1494 check_deps_environment_vars ()
1495 {
1496   char *spec;
1497
1498   GET_ENVIRONMENT (spec, "DEPENDENCIES_OUTPUT");
1499   if (spec)
1500     cpp_opts->deps.style = DEPS_USER;
1501   else
1502     {
1503       GET_ENVIRONMENT (spec, "SUNPRO_DEPENDENCIES");
1504       if (spec)
1505         {
1506           cpp_opts->deps.style = DEPS_SYSTEM;
1507           cpp_opts->deps.ignore_main_file = true;
1508         }
1509     }
1510
1511   if (spec)
1512     {
1513       /* Find the space before the DEPS_TARGET, if there is one.  */
1514       char *s = strchr (spec, ' ');
1515       if (s)
1516         {
1517           /* Let the caller perform MAKE quoting.  */
1518           defer_opt (OPT_MT, s + 1);
1519           *s = '\0';
1520         }
1521
1522       /* Command line -MF overrides environment variables and default.  */
1523       if (!deps_file)
1524         deps_file = spec;
1525
1526       deps_append = 1;
1527     }
1528 }
1529
1530 /* Handle deferred command line switches.  */
1531 static void
1532 handle_deferred_opts ()
1533 {
1534   size_t i;
1535
1536   for (i = 0; i < deferred_count; i++)
1537     {
1538       struct deferred_opt *opt = &deferred_opts[i];
1539
1540       switch (opt->code)
1541         {
1542         case OPT_MT:
1543         case OPT_MQ:
1544           cpp_add_dependency_target (parse_in, opt->arg, opt->code == OPT_MQ);
1545           break;
1546
1547         default:
1548           abort ();
1549         }
1550     }
1551
1552   free (deferred_opts);
1553 }
1554
1555 /* These settings are appropriate for GCC, but not necessarily so for
1556    cpplib as a library.  */
1557 static void
1558 sanitize_cpp_opts ()
1559 {
1560   /* If we don't know what style of dependencies to output, complain
1561      if any other dependency switches have been given.  */
1562   if (deps_seen && cpp_opts->deps.style == DEPS_NONE)
1563     error ("to generate dependencies you must specify either -M or -MM");
1564
1565   /* -dM and dependencies suppress normal output; do it here so that
1566      the last -d[MDN] switch overrides earlier ones.  */
1567   if (cpp_opts->dump_macros == dump_only)
1568     cpp_opts->no_output = 1;
1569
1570   /* Disable -dD, -dN and -dI if normal output is suppressed.  Allow
1571      -dM since at least glibc relies on -M -dM to work.  */
1572   if (cpp_opts->no_output)
1573     {
1574       if (cpp_opts->dump_macros != dump_only)
1575         cpp_opts->dump_macros = dump_none;
1576       cpp_opts->dump_includes = 0;
1577     }
1578
1579   cpp_opts->unsigned_char = !flag_signed_char;
1580   cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS;
1581
1582   /* We want -Wno-long-long to override -pedantic -std=non-c99
1583      and/or -Wtraditional, whatever the ordering.  */
1584   cpp_opts->warn_long_long
1585     = warn_long_long && ((!flag_isoc99 && pedantic) || warn_traditional);
1586 }
1587
1588 /* Set the C 89 standard (with 1994 amendments if C94, without GNU
1589    extensions if ISO).  There is no concept of gnu94.  */
1590 static void
1591 set_std_c89 (c94, iso)
1592      int c94, iso;
1593 {
1594   cpp_set_lang (parse_in, c94 ? CLK_STDC94: iso ? CLK_STDC89: CLK_GNUC89);
1595   flag_iso = iso;
1596   flag_no_asm = iso;
1597   flag_no_gnu_keywords = iso;
1598   flag_no_nonansi_builtin = iso;
1599   flag_noniso_default_format_attributes = !iso;
1600   flag_isoc94 = c94;
1601   flag_isoc99 = 0;
1602   flag_writable_strings = 0;
1603 }
1604
1605 /* Set the C 99 standard (without GNU extensions if ISO).  */
1606 static void
1607 set_std_c99 (iso)
1608      int iso;
1609 {
1610   cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99);
1611   flag_no_asm = iso;
1612   flag_no_nonansi_builtin = iso;
1613   flag_noniso_default_format_attributes = !iso;
1614   flag_iso = iso;
1615   flag_isoc99 = 1;
1616   flag_isoc94 = 1;
1617   flag_writable_strings = 0;
1618 }
1619
1620 /* Set the C++ 98 standard (without GNU extensions if ISO).  */
1621 static void
1622 set_std_cxx98 (iso)
1623      int iso;
1624 {
1625   cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX);
1626   flag_no_gnu_keywords = iso;
1627   flag_no_nonansi_builtin = iso;
1628   flag_noniso_default_format_attributes = !iso;
1629   flag_iso = iso;
1630 }
1631
1632 /* Handle setting implicit to ON.  */
1633 static void
1634 set_Wimplicit (on)
1635      int on;
1636 {
1637   warn_implicit = on;
1638   warn_implicit_int = on;
1639   if (on)
1640     {
1641       if (mesg_implicit_function_declaration != 2)
1642         mesg_implicit_function_declaration = 1;
1643     }
1644   else
1645     mesg_implicit_function_declaration = 0;
1646 }
1647
1648 /* Args to -d specify what to dump.  Silently ignore
1649    unrecognized options; they may be aimed at toplev.c.  */
1650 static void
1651 handle_OPT_d (arg)
1652      const char *arg;
1653 {
1654   char c;
1655
1656   while ((c = *arg++) != '\0')
1657     switch (c)
1658       {
1659       case 'M':
1660         cpp_opts->dump_macros = dump_only;
1661         break;
1662
1663       case 'N':
1664         cpp_opts->dump_macros = dump_names;
1665         break;
1666
1667       case 'D':
1668         cpp_opts->dump_macros = dump_definitions;
1669         break;
1670
1671       case 'I':
1672         cpp_opts->dump_includes = 1;
1673         break;
1674       }
1675 }
1676
1677 /* Write a slash-separated list of languages in FLAGS to BUF.  */
1678 static void
1679 write_langs (buf, flags)
1680      char *buf;
1681      int flags;
1682 {
1683   *buf = '\0';
1684   if (flags & CL_C_ONLY)
1685     strcat (buf, "C");
1686   if (flags & CL_OBJC_ONLY)
1687     {
1688       if (*buf)
1689         strcat (buf, "/");
1690       strcat (buf, "ObjC");
1691     }
1692   if (flags & CL_CXX_ONLY)
1693     {
1694       if (*buf)
1695         strcat (buf, "/");
1696       strcat (buf, "C++");
1697     }
1698 }
1699
1700 /* Complain that switch OPT_INDEX does not apply to this front end.  */
1701 static void
1702 complain_wrong_lang (opt_index)
1703      size_t opt_index;
1704 {
1705   char ok_langs[60], bad_langs[60];
1706   int ok_flags = cl_options[opt_index].flags;
1707
1708   write_langs (ok_langs, ok_flags);
1709   write_langs (bad_langs, ~ok_flags);
1710   warning ("\"-%s\" is valid for %s but not for %s",
1711            cl_options[opt_index].opt_text, ok_langs, bad_langs);
1712 }
1713
1714 /* Handle --help output.  */
1715 static void
1716 print_help ()
1717 {
1718   /* To keep the lines from getting too long for some compilers, limit
1719      to about 500 characters (6 lines) per chunk.  */
1720   fputs (_("\
1721 Switches:\n\
1722   -include <file>           Include the contents of <file> before other files\n\
1723   -imacros <file>           Accept definition of macros in <file>\n\
1724   -iprefix <path>           Specify <path> as a prefix for next two options\n\
1725   -iwithprefix <dir>        Add <dir> to the end of the system include path\n\
1726   -iwithprefixbefore <dir>  Add <dir> to the end of the main include path\n\
1727   -isystem <dir>            Add <dir> to the start of the system include path\n\
1728 "), stdout);
1729   fputs (_("\
1730   -idirafter <dir>          Add <dir> to the end of the system include path\n\
1731   -I <dir>                  Add <dir> to the end of the main include path\n\
1732   -I-                       Fine-grained include path control; see info docs\n\
1733   -nostdinc                 Do not search system include directories\n\
1734                              (dirs specified with -isystem will still be used)\n\
1735   -nostdinc++               Do not search system include directories for C++\n\
1736   -o <file>                 Put output into <file>\n\
1737 "), stdout);
1738   fputs (_("\
1739   -trigraphs                Support ISO C trigraphs\n\
1740   -std=<std name>           Specify the conformance standard; one of:\n\
1741                             gnu89, gnu99, c89, c99, iso9899:1990,\n\
1742                             iso9899:199409, iso9899:1999, c++98\n\
1743   -w                        Inhibit warning messages\n\
1744   -W[no-]trigraphs          Warn if trigraphs are encountered\n\
1745   -W[no-]comment{s}         Warn if one comment starts inside another\n\
1746 "), stdout);
1747   fputs (_("\
1748   -W[no-]traditional        Warn about features not present in traditional C\n\
1749   -W[no-]undef              Warn if an undefined macro is used by #if\n\
1750   -W[no-]import             Warn about the use of the #import directive\n\
1751 "), stdout);
1752   fputs (_("\
1753   -W[no-]error              Treat all warnings as errors\n\
1754   -W[no-]system-headers     Do not suppress warnings from system headers\n\
1755   -W[no-]all                Enable most preprocessor warnings\n\
1756 "), stdout);
1757   fputs (_("\
1758   -M                        Generate make dependencies\n\
1759   -MM                       As -M, but ignore system header files\n\
1760   -MD                       Generate make dependencies and compile\n\
1761   -MMD                      As -MD, but ignore system header files\n\
1762   -MF <file>                Write dependency output to the given file\n\
1763   -MG                       Treat missing header file as generated files\n\
1764 "), stdout);
1765   fputs (_("\
1766   -MP                       Generate phony targets for all headers\n\
1767   -MQ <target>              Add a MAKE-quoted target\n\
1768   -MT <target>              Add an unquoted target\n\
1769 "), stdout);
1770   fputs (_("\
1771   -D<macro>                 Define a <macro> with string '1' as its value\n\
1772   -D<macro>=<val>           Define a <macro> with <val> as its value\n\
1773   -A<question>=<answer>     Assert the <answer> to <question>\n\
1774   -A-<question>=<answer>    Disable the <answer> to <question>\n\
1775   -U<macro>                 Undefine <macro> \n\
1776   -v                        Display the version number\n\
1777 "), stdout);
1778   fputs (_("\
1779   -H                        Print the name of header files as they are used\n\
1780   -C                        Do not discard comments\n\
1781   -dM                       Display a list of macro definitions active at end\n\
1782   -dD                       Preserve macro definitions in output\n\
1783   -dN                       As -dD except that only the names are preserved\n\
1784   -dI                       Include #include directives in the output\n\
1785 "), stdout);
1786   fputs (_("\
1787   -f[no-]preprocessed       Treat the input file as already preprocessed\n\
1788   -ftabstop=<number>        Distance between tab stops for column reporting\n\
1789   -P                        Do not generate #line directives\n\
1790   -remap                    Remap file names when including files\n\
1791   --help                    Display this information\n\
1792 "), stdout);
1793 }