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