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