gcc/c-opts.c

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