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