gcc/c-opts.c

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