]>
Commit | Line | Data |
---|---|---|
0b6f2917 | 1 | /* C/ObjC/C++ command line option handling. |
d9221e01 | 2 | Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc. |
0b6f2917 NB |
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" | |
4977bab6 ZW |
24 | #include "coretypes.h" |
25 | #include "tm.h" | |
0b6f2917 NB |
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" | |
4b7091eb | 34 | #include "intl.h" |
5793b276 NB |
35 | #include "cppdefault.h" |
36 | #include "c-incpath.h" | |
23345bbb | 37 | #include "debug.h" /* For debug_hooks. */ |
2772ef3e | 38 | #include "opts.h" |
d7b42618 | 39 | #include "options.h" |
5793b276 | 40 | |
b1822ccc NB |
41 | #ifndef DOLLARS_IN_IDENTIFIERS |
42 | # define DOLLARS_IN_IDENTIFIERS true | |
43 | #endif | |
44 | ||
5793b276 NB |
45 | #ifndef TARGET_SYSTEM_ROOT |
46 | # define TARGET_SYSTEM_ROOT NULL | |
47 | #endif | |
0b6f2917 | 48 | |
7cd60054 AM |
49 | #ifndef TARGET_OPTF |
50 | #define TARGET_OPTF(ARG) | |
51 | #endif | |
52 | ||
4bfec483 NB |
53 | static int saved_lineno; |
54 | ||
f4ff5a69 | 55 | /* CPP's options. */ |
18bdccaa NB |
56 | static cpp_options *cpp_opts; |
57 | ||
460bd0e3 | 58 | /* Input filename. */ |
89e9faee | 59 | static const char *this_input_filename; |
460bd0e3 | 60 | |
76c3e73e NB |
61 | /* Filename and stream for preprocessed output. */ |
62 | static const char *out_fname; | |
63 | static FILE *out_stream; | |
64 | ||
65 | /* Append dependencies to deps_file. */ | |
66 | static bool deps_append; | |
67 | ||
f4ff5a69 NB |
68 | /* If dependency switches (-MF etc.) have been given. */ |
69 | static bool deps_seen; | |
70 | ||
5793b276 NB |
71 | /* If -v seen. */ |
72 | static bool verbose; | |
73 | ||
f4ff5a69 NB |
74 | /* Dependency output file. */ |
75 | static const char *deps_file; | |
76 | ||
5793b276 NB |
77 | /* The prefix given by -iprefix, if any. */ |
78 | static const char *iprefix; | |
79 | ||
80 | /* The system root, if any. Overridden by -isysroot. */ | |
81 | static const char *sysroot = TARGET_SYSTEM_ROOT; | |
82 | ||
83 | /* Zero disables all standard directories for headers. */ | |
84 | static bool std_inc = true; | |
85 | ||
86 | /* Zero disables the C++-specific standard directories for headers. */ | |
87 | static bool std_cxx_inc = true; | |
88 | ||
89 | /* If the quote chain has been split by -I-. */ | |
90 | static bool quote_chain_split; | |
91 | ||
23345bbb NB |
92 | /* If -Wunused-macros. */ |
93 | static bool warn_unused_macros; | |
94 | ||
e5b79219 RH |
95 | /* If -Wvariadic-macros. */ |
96 | static bool warn_variadic_macros = true; | |
97 | ||
b86f6cd9 NB |
98 | /* Number of deferred options. */ |
99 | static size_t deferred_count; | |
f4ff5a69 | 100 | |
23345bbb NB |
101 | /* Number of deferred options scanned for -include. */ |
102 | static size_t include_cursor; | |
103 | ||
1ae58c30 | 104 | /* Permit Fortran front-end options. */ |
33de9573 NB |
105 | static bool permit_fortran_options; |
106 | ||
2f6e4e97 | 107 | static void set_Wimplicit (int); |
2f6e4e97 AJ |
108 | static void handle_OPT_d (const char *); |
109 | static void set_std_cxx98 (int); | |
110 | static void set_std_c89 (int, int); | |
111 | static void set_std_c99 (int); | |
112 | static void check_deps_environment_vars (void); | |
113 | static void handle_deferred_opts (void); | |
114 | static void sanitize_cpp_opts (void); | |
115 | static void add_prefixed_path (const char *, size_t); | |
116 | static void push_command_line_include (void); | |
117 | static void cb_file_change (cpp_reader *, const struct line_map *); | |
8e9ea4d7 PB |
118 | static void cb_dir_change (cpp_reader *, const char *); |
119 | static void finish_options (void); | |
460bd0e3 NB |
120 | |
121 | #ifndef STDC_0_IN_SYSTEM_HEADERS | |
122 | #define STDC_0_IN_SYSTEM_HEADERS 0 | |
123 | #endif | |
0b6f2917 | 124 | |
2772ef3e | 125 | /* Holds switches parsed by c_common_handle_option (), but whose |
95bd1dd7 | 126 | handling is deferred to c_common_post_options (). */ |
2f6e4e97 | 127 | static void defer_opt (enum opt_code, const char *); |
f4ff5a69 NB |
128 | static struct deferred_opt |
129 | { | |
130 | enum opt_code code; | |
131 | const char *arg; | |
132 | } *deferred_opts; | |
133 | ||
cb66e385 NB |
134 | /* Complain that switch CODE expects an argument but none was |
135 | provided. OPT was the command-line option. Return FALSE to get | |
136 | the default message in opts.c, TRUE if we provide a specialized | |
137 | one. */ | |
138 | bool | |
139 | c_common_missing_argument (const char *opt, size_t code) | |
4b7091eb | 140 | { |
2772ef3e | 141 | switch (code) |
4b7091eb | 142 | { |
4b7091eb | 143 | default: |
cb66e385 NB |
144 | /* Pick up the default message. */ |
145 | return false; | |
4b7091eb | 146 | |
fef3106c | 147 | case OPT_fconstant_string_class_: |
cb66e385 | 148 | error ("no class name specified with \"%s\"", opt); |
4b7091eb | 149 | break; |
b4a93904 | 150 | |
c1bad961 | 151 | case OPT_A: |
cb66e385 | 152 | error ("assertion missing after \"%s\"", opt); |
c1bad961 NB |
153 | break; |
154 | ||
155 | case OPT_D: | |
156 | case OPT_U: | |
cb66e385 | 157 | error ("macro name missing after \"%s\"", opt); |
c1bad961 NB |
158 | break; |
159 | ||
94d1613b | 160 | case OPT_F: |
5793b276 NB |
161 | case OPT_I: |
162 | case OPT_idirafter: | |
163 | case OPT_isysroot: | |
164 | case OPT_isystem: | |
4bed3787 | 165 | case OPT_iquote: |
cb66e385 | 166 | error ("missing path after \"%s\"", opt); |
5793b276 NB |
167 | break; |
168 | ||
f4ff5a69 NB |
169 | case OPT_MF: |
170 | case OPT_MD: | |
171 | case OPT_MMD: | |
255c10b1 NB |
172 | case OPT_include: |
173 | case OPT_imacros: | |
b4a93904 | 174 | case OPT_o: |
cb66e385 | 175 | error ("missing filename after \"%s\"", opt); |
f4ff5a69 NB |
176 | break; |
177 | ||
178 | case OPT_MQ: | |
179 | case OPT_MT: | |
cb66e385 | 180 | error ("missing makefile target after \"%s\"", opt); |
b4a93904 | 181 | break; |
4b7091eb | 182 | } |
cb66e385 NB |
183 | |
184 | return true; | |
4b7091eb NB |
185 | } |
186 | ||
f4ff5a69 NB |
187 | /* Defer option CODE with argument ARG. */ |
188 | static void | |
2f6e4e97 | 189 | defer_opt (enum opt_code code, const char *arg) |
f4ff5a69 | 190 | { |
f4ff5a69 NB |
191 | deferred_opts[deferred_count].code = code; |
192 | deferred_opts[deferred_count].arg = arg; | |
193 | deferred_count++; | |
194 | } | |
195 | ||
0b6f2917 | 196 | /* Common initialization before parsing options. */ |
b86f6cd9 NB |
197 | unsigned int |
198 | c_common_init_options (unsigned int argc, const char **argv ATTRIBUTE_UNUSED) | |
0b6f2917 | 199 | { |
b86f6cd9 | 200 | static const unsigned int lang_flags[] = {CL_C, CL_ObjC, CL_CXX, CL_ObjCXX}; |
33de9573 | 201 | unsigned int result; |
37fa72e9 NB |
202 | |
203 | /* This is conditionalized only because that is the way the front | |
204 | ends used to do it. Maybe this should be unconditional? */ | |
205 | if (c_dialect_cxx ()) | |
206 | { | |
207 | /* By default wrap lines at 80 characters. Is getenv | |
208 | ("COLUMNS") preferable? */ | |
209 | diagnostic_line_cutoff (global_dc) = 80; | |
210 | /* By default, emit location information once for every | |
211 | diagnostic message. */ | |
212 | diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE; | |
213 | } | |
214 | ||
215 | parse_in = cpp_create_reader (c_dialect_cxx () ? CLK_GNUCXX: CLK_GNUC89, | |
50f59cd7 | 216 | ident_hash, &line_table); |
37fa72e9 | 217 | |
18bdccaa | 218 | cpp_opts = cpp_get_options (parse_in); |
b1822ccc | 219 | cpp_opts->dollars_in_ident = DOLLARS_IN_IDENTIFIERS; |
37fa72e9 | 220 | cpp_opts->objc = c_dialect_objc (); |
78b8811a HPN |
221 | |
222 | /* Reset to avoid warnings on internal definitions. We set it just | |
223 | before passing on command-line options to cpplib. */ | |
224 | cpp_opts->warn_dollars = 0; | |
225 | ||
37fa72e9 NB |
226 | flag_const_strings = c_dialect_cxx (); |
227 | flag_exceptions = c_dialect_cxx (); | |
228 | warn_pointer_arith = c_dialect_cxx (); | |
2772ef3e | 229 | |
703ad42b | 230 | deferred_opts = xmalloc (argc * sizeof (struct deferred_opt)); |
b86f6cd9 | 231 | |
33de9573 NB |
232 | result = lang_flags[c_language]; |
233 | ||
234 | /* If potentially preprocessing Fortran we have to accept its front | |
235 | end options since the driver passes most of them through. */ | |
236 | #ifdef CL_F77 | |
237 | if (c_language == clk_c && argc > 2 | |
238 | && !strcmp (argv[2], "-traditional-cpp" )) | |
239 | { | |
240 | permit_fortran_options = true; | |
241 | result |= CL_F77; | |
242 | } | |
243 | #endif | |
244 | ||
245 | return result; | |
0b6f2917 NB |
246 | } |
247 | ||
b20d9f0c | 248 | /* Handle switch SCODE with argument ARG. VALUE is true, unless no- |
2772ef3e NB |
249 | form of an -f or -W option was given. Returns 0 if the switch was |
250 | invalid, a negative number to prevent language-independent | |
251 | processing in toplev.c (a hack necessary for the short-term). */ | |
0b6f2917 | 252 | int |
7b086b11 | 253 | c_common_handle_option (size_t scode, const char *arg, int value) |
0b6f2917 | 254 | { |
2772ef3e NB |
255 | const struct cl_option *option = &cl_options[scode]; |
256 | enum opt_code code = (enum opt_code) scode; | |
f18754d6 | 257 | int result = 1; |
2772ef3e | 258 | |
fef3106c | 259 | switch (code) |
0b6f2917 | 260 | { |
2772ef3e | 261 | default: |
33de9573 NB |
262 | result = permit_fortran_options; |
263 | break; | |
0b6f2917 | 264 | |
fef3106c | 265 | case OPT__output_pch_: |
17211ab5 GK |
266 | pch_file = arg; |
267 | break; | |
268 | ||
c1bad961 NB |
269 | case OPT_A: |
270 | defer_opt (code, arg); | |
271 | break; | |
272 | ||
4b7091eb NB |
273 | case OPT_C: |
274 | cpp_opts->discard_comments = 0; | |
275 | break; | |
276 | ||
277 | case OPT_CC: | |
278 | cpp_opts->discard_comments = 0; | |
279 | cpp_opts->discard_comments_in_macro_exp = 0; | |
280 | break; | |
281 | ||
c1bad961 NB |
282 | case OPT_D: |
283 | defer_opt (code, arg); | |
284 | break; | |
285 | ||
0b6f2917 NB |
286 | case OPT_E: |
287 | flag_preprocess_only = 1; | |
288 | break; | |
289 | ||
4b7091eb NB |
290 | case OPT_H: |
291 | cpp_opts->print_include_names = 1; | |
292 | break; | |
293 | ||
94d1613b MS |
294 | case OPT_F: |
295 | TARGET_OPTF (xstrdup (arg)); | |
296 | break; | |
297 | ||
5793b276 NB |
298 | case OPT_I: |
299 | if (strcmp (arg, "-")) | |
300 | add_path (xstrdup (arg), BRACKET, 0); | |
301 | else | |
302 | { | |
303 | if (quote_chain_split) | |
304 | error ("-I- specified twice"); | |
305 | quote_chain_split = true; | |
306 | split_quote_chain (); | |
4bed3787 | 307 | inform ("obsolete option -I- used, please use -iquote instead"); |
5793b276 NB |
308 | } |
309 | break; | |
310 | ||
f4ff5a69 NB |
311 | case OPT_M: |
312 | case OPT_MM: | |
313 | /* When doing dependencies with -M or -MM, suppress normal | |
314 | preprocessed output, but still do -dM etc. as software | |
315 | depends on this. Preprocessed output does occur if -MD, -MMD | |
316 | or environment var dependency generation is used. */ | |
317 | cpp_opts->deps.style = (code == OPT_M ? DEPS_SYSTEM: DEPS_USER); | |
63973df3 | 318 | flag_no_output = 1; |
f4ff5a69 NB |
319 | cpp_opts->inhibit_warnings = 1; |
320 | break; | |
321 | ||
322 | case OPT_MD: | |
323 | case OPT_MMD: | |
324 | cpp_opts->deps.style = (code == OPT_MD ? DEPS_SYSTEM: DEPS_USER); | |
325 | deps_file = arg; | |
326 | break; | |
327 | ||
328 | case OPT_MF: | |
329 | deps_seen = true; | |
330 | deps_file = arg; | |
331 | break; | |
332 | ||
333 | case OPT_MG: | |
334 | deps_seen = true; | |
335 | cpp_opts->deps.missing_files = true; | |
336 | break; | |
337 | ||
338 | case OPT_MP: | |
339 | deps_seen = true; | |
340 | cpp_opts->deps.phony_targets = true; | |
341 | break; | |
342 | ||
343 | case OPT_MQ: | |
344 | case OPT_MT: | |
345 | deps_seen = true; | |
346 | defer_opt (code, arg); | |
347 | break; | |
348 | ||
4b7091eb | 349 | case OPT_P: |
63973df3 | 350 | flag_no_line_commands = 1; |
4b7091eb NB |
351 | break; |
352 | ||
b20d9f0c AO |
353 | case OPT_fworking_directory: |
354 | flag_working_directory = value; | |
355 | break; | |
356 | ||
c1bad961 NB |
357 | case OPT_U: |
358 | defer_opt (code, arg); | |
359 | break; | |
360 | ||
eca7f13c | 361 | case OPT_Wabi: |
7b086b11 | 362 | warn_abi = value; |
eca7f13c MM |
363 | break; |
364 | ||
0b6f2917 | 365 | case OPT_Wall: |
7b086b11 NB |
366 | set_Wunused (value); |
367 | set_Wformat (value); | |
368 | set_Wimplicit (value); | |
369 | warn_char_subscripts = value; | |
370 | warn_missing_braces = value; | |
371 | warn_parentheses = value; | |
372 | warn_return_type = value; | |
373 | warn_sequence_point = value; /* Was C only. */ | |
37fa72e9 | 374 | if (c_dialect_cxx ()) |
7b086b11 NB |
375 | warn_sign_compare = value; |
376 | warn_switch = value; | |
377 | warn_strict_aliasing = value; | |
2f6e4e97 | 378 | |
0b6f2917 | 379 | /* Only warn about unknown pragmas that are not in system |
2f6e4e97 | 380 | headers. */ |
7b086b11 | 381 | warn_unknown_pragmas = value; |
0b6f2917 NB |
382 | |
383 | /* We save the value of warn_uninitialized, since if they put | |
384 | -Wuninitialized on the command line, we need to generate a | |
385 | warning about not using it without also specifying -O. */ | |
386 | if (warn_uninitialized != 1) | |
7b086b11 | 387 | warn_uninitialized = (value ? 2 : 0); |
0b6f2917 | 388 | |
37fa72e9 | 389 | if (!c_dialect_cxx ()) |
0b6f2917 NB |
390 | /* We set this to 2 here, but 1 in -Wmain, so -ffreestanding |
391 | can turn it off only if it's not explicit. */ | |
7b086b11 | 392 | warn_main = value * 2; |
0b6f2917 NB |
393 | else |
394 | { | |
395 | /* C++-specific warnings. */ | |
7b086b11 NB |
396 | warn_nonvdtor = value; |
397 | warn_reorder = value; | |
398 | warn_nontemplate_friend = value; | |
0b6f2917 | 399 | } |
18bdccaa | 400 | |
7b086b11 NB |
401 | cpp_opts->warn_trigraphs = value; |
402 | cpp_opts->warn_comments = value; | |
403 | cpp_opts->warn_num_sign_change = value; | |
404 | cpp_opts->warn_multichar = value; /* Was C++ only. */ | |
0b6f2917 NB |
405 | break; |
406 | ||
407 | case OPT_Wbad_function_cast: | |
7b086b11 | 408 | warn_bad_function_cast = value; |
0b6f2917 NB |
409 | break; |
410 | ||
411 | case OPT_Wcast_qual: | |
7b086b11 | 412 | warn_cast_qual = value; |
0b6f2917 NB |
413 | break; |
414 | ||
415 | case OPT_Wchar_subscripts: | |
7b086b11 | 416 | warn_char_subscripts = value; |
0b6f2917 NB |
417 | break; |
418 | ||
18bdccaa NB |
419 | case OPT_Wcomment: |
420 | case OPT_Wcomments: | |
7b086b11 | 421 | cpp_opts->warn_comments = value; |
18bdccaa NB |
422 | break; |
423 | ||
0b6f2917 | 424 | case OPT_Wconversion: |
7b086b11 | 425 | warn_conversion = value; |
0b6f2917 NB |
426 | break; |
427 | ||
428 | case OPT_Wctor_dtor_privacy: | |
7b086b11 | 429 | warn_ctor_dtor_privacy = value; |
0b6f2917 NB |
430 | break; |
431 | ||
85617eba HPN |
432 | case OPT_Wdeclaration_after_statement: |
433 | warn_declaration_after_statement = value; | |
434 | break; | |
435 | ||
0b6f2917 | 436 | case OPT_Wdeprecated: |
7b086b11 NB |
437 | warn_deprecated = value; |
438 | cpp_opts->warn_deprecated = value; | |
0b6f2917 NB |
439 | break; |
440 | ||
441 | case OPT_Wdiv_by_zero: | |
7b086b11 | 442 | warn_div_by_zero = value; |
0b6f2917 NB |
443 | break; |
444 | ||
fef3106c | 445 | case OPT_Weffc__: |
7b086b11 | 446 | warn_ecpp = value; |
0b6f2917 NB |
447 | break; |
448 | ||
18bdccaa | 449 | case OPT_Wendif_labels: |
7b086b11 | 450 | cpp_opts->warn_endif_labels = value; |
18bdccaa NB |
451 | break; |
452 | ||
453 | case OPT_Werror: | |
7b086b11 | 454 | cpp_opts->warnings_are_errors = value; |
18bdccaa NB |
455 | break; |
456 | ||
fef3106c | 457 | case OPT_Werror_implicit_function_declaration: |
c83857ff | 458 | mesg_implicit_function_declaration = 2; |
0b6f2917 NB |
459 | break; |
460 | ||
461 | case OPT_Wfloat_equal: | |
7b086b11 | 462 | warn_float_equal = value; |
0b6f2917 NB |
463 | break; |
464 | ||
465 | case OPT_Wformat: | |
7b086b11 | 466 | set_Wformat (value); |
0b6f2917 NB |
467 | break; |
468 | ||
fef3106c | 469 | case OPT_Wformat_: |
0b6f2917 NB |
470 | set_Wformat (atoi (arg)); |
471 | break; | |
472 | ||
473 | case OPT_Wformat_extra_args: | |
7b086b11 | 474 | warn_format_extra_args = value; |
0b6f2917 NB |
475 | break; |
476 | ||
477 | case OPT_Wformat_nonliteral: | |
7b086b11 | 478 | warn_format_nonliteral = value; |
0b6f2917 NB |
479 | break; |
480 | ||
481 | case OPT_Wformat_security: | |
7b086b11 | 482 | warn_format_security = value; |
0b6f2917 NB |
483 | break; |
484 | ||
485 | case OPT_Wformat_y2k: | |
7b086b11 | 486 | warn_format_y2k = value; |
0b6f2917 NB |
487 | break; |
488 | ||
489 | case OPT_Wformat_zero_length: | |
7b086b11 | 490 | warn_format_zero_length = value; |
0b6f2917 NB |
491 | break; |
492 | ||
3390f9c9 AP |
493 | case OPT_Winit_self: |
494 | warn_init_self = value; | |
495 | break; | |
496 | ||
0b6f2917 | 497 | case OPT_Wimplicit: |
7b086b11 | 498 | set_Wimplicit (value); |
0b6f2917 NB |
499 | break; |
500 | ||
fef3106c | 501 | case OPT_Wimplicit_function_declaration: |
7b086b11 | 502 | mesg_implicit_function_declaration = value; |
0b6f2917 NB |
503 | break; |
504 | ||
505 | case OPT_Wimplicit_int: | |
7b086b11 | 506 | warn_implicit_int = value; |
0b6f2917 NB |
507 | break; |
508 | ||
18bdccaa | 509 | case OPT_Wimport: |
bf42e45b | 510 | /* Silently ignore for now. */ |
18bdccaa NB |
511 | break; |
512 | ||
a01fff59 | 513 | case OPT_Winvalid_offsetof: |
7b086b11 | 514 | warn_invalid_offsetof = value; |
a01fff59 MA |
515 | break; |
516 | ||
17211ab5 | 517 | case OPT_Winvalid_pch: |
7b086b11 | 518 | cpp_opts->warn_invalid_pch = value; |
17211ab5 GK |
519 | break; |
520 | ||
0b6f2917 | 521 | case OPT_Wlong_long: |
7b086b11 | 522 | warn_long_long = value; |
0b6f2917 NB |
523 | break; |
524 | ||
525 | case OPT_Wmain: | |
7b086b11 | 526 | if (value) |
0b6f2917 NB |
527 | warn_main = 1; |
528 | else | |
529 | warn_main = -1; | |
530 | break; | |
531 | ||
532 | case OPT_Wmissing_braces: | |
7b086b11 | 533 | warn_missing_braces = value; |
0b6f2917 NB |
534 | break; |
535 | ||
536 | case OPT_Wmissing_declarations: | |
7b086b11 | 537 | warn_missing_declarations = value; |
0b6f2917 NB |
538 | break; |
539 | ||
540 | case OPT_Wmissing_format_attribute: | |
7b086b11 | 541 | warn_missing_format_attribute = value; |
0b6f2917 NB |
542 | break; |
543 | ||
544 | case OPT_Wmissing_prototypes: | |
7b086b11 | 545 | warn_missing_prototypes = value; |
0b6f2917 NB |
546 | break; |
547 | ||
548 | case OPT_Wmultichar: | |
7b086b11 | 549 | cpp_opts->warn_multichar = value; |
0b6f2917 NB |
550 | break; |
551 | ||
552 | case OPT_Wnested_externs: | |
7b086b11 | 553 | warn_nested_externs = value; |
0b6f2917 NB |
554 | break; |
555 | ||
556 | case OPT_Wnon_template_friend: | |
7b086b11 | 557 | warn_nontemplate_friend = value; |
0b6f2917 NB |
558 | break; |
559 | ||
560 | case OPT_Wnon_virtual_dtor: | |
7b086b11 | 561 | warn_nonvdtor = value; |
0b6f2917 NB |
562 | break; |
563 | ||
564 | case OPT_Wnonnull: | |
7b086b11 | 565 | warn_nonnull = value; |
0b6f2917 NB |
566 | break; |
567 | ||
c034f121 AJ |
568 | case OPT_Wold_style_definition: |
569 | warn_old_style_definition = value; | |
570 | break; | |
571 | ||
0b6f2917 | 572 | case OPT_Wold_style_cast: |
7b086b11 | 573 | warn_old_style_cast = value; |
0b6f2917 NB |
574 | break; |
575 | ||
576 | case OPT_Woverloaded_virtual: | |
7b086b11 | 577 | warn_overloaded_virtual = value; |
0b6f2917 NB |
578 | break; |
579 | ||
580 | case OPT_Wparentheses: | |
7b086b11 | 581 | warn_parentheses = value; |
0b6f2917 NB |
582 | break; |
583 | ||
584 | case OPT_Wpmf_conversions: | |
7b086b11 | 585 | warn_pmf2ptr = value; |
0b6f2917 NB |
586 | break; |
587 | ||
588 | case OPT_Wpointer_arith: | |
7b086b11 | 589 | warn_pointer_arith = value; |
0b6f2917 NB |
590 | break; |
591 | ||
592 | case OPT_Wprotocol: | |
7b086b11 | 593 | warn_protocol = value; |
0b6f2917 NB |
594 | break; |
595 | ||
596 | case OPT_Wselector: | |
7b086b11 | 597 | warn_selector = value; |
0b6f2917 NB |
598 | break; |
599 | ||
600 | case OPT_Wredundant_decls: | |
7b086b11 | 601 | warn_redundant_decls = value; |
0b6f2917 NB |
602 | break; |
603 | ||
604 | case OPT_Wreorder: | |
7b086b11 | 605 | warn_reorder = value; |
0b6f2917 NB |
606 | break; |
607 | ||
608 | case OPT_Wreturn_type: | |
7b086b11 | 609 | warn_return_type = value; |
0b6f2917 NB |
610 | break; |
611 | ||
612 | case OPT_Wsequence_point: | |
7b086b11 | 613 | warn_sequence_point = value; |
0b6f2917 NB |
614 | break; |
615 | ||
616 | case OPT_Wsign_compare: | |
7b086b11 | 617 | warn_sign_compare = value; |
0b6f2917 NB |
618 | break; |
619 | ||
620 | case OPT_Wsign_promo: | |
7b086b11 | 621 | warn_sign_promo = value; |
0b6f2917 NB |
622 | break; |
623 | ||
624 | case OPT_Wstrict_prototypes: | |
7b086b11 | 625 | warn_strict_prototypes = value; |
0b6f2917 NB |
626 | break; |
627 | ||
628 | case OPT_Wsynth: | |
7b086b11 | 629 | warn_synth = value; |
0b6f2917 NB |
630 | break; |
631 | ||
18bdccaa | 632 | case OPT_Wsystem_headers: |
7b086b11 | 633 | cpp_opts->warn_system_headers = value; |
18bdccaa NB |
634 | break; |
635 | ||
0b6f2917 | 636 | case OPT_Wtraditional: |
7b086b11 NB |
637 | warn_traditional = value; |
638 | cpp_opts->warn_traditional = value; | |
18bdccaa NB |
639 | break; |
640 | ||
641 | case OPT_Wtrigraphs: | |
7b086b11 | 642 | cpp_opts->warn_trigraphs = value; |
18bdccaa NB |
643 | break; |
644 | ||
ece4ce85 | 645 | case OPT_Wundeclared_selector: |
7b086b11 | 646 | warn_undeclared_selector = value; |
ece4ce85 NP |
647 | break; |
648 | ||
18bdccaa | 649 | case OPT_Wundef: |
7b086b11 | 650 | cpp_opts->warn_undef = value; |
0b6f2917 NB |
651 | break; |
652 | ||
653 | case OPT_Wunknown_pragmas: | |
654 | /* Set to greater than 1, so that even unknown pragmas in | |
2f6e4e97 | 655 | system headers will be warned about. */ |
7b086b11 | 656 | warn_unknown_pragmas = value * 2; |
0b6f2917 NB |
657 | break; |
658 | ||
18bdccaa | 659 | case OPT_Wunused_macros: |
7b086b11 | 660 | warn_unused_macros = value; |
18bdccaa NB |
661 | break; |
662 | ||
e5b79219 RH |
663 | case OPT_Wvariadic_macros: |
664 | warn_variadic_macros = value; | |
665 | break; | |
666 | ||
0b6f2917 | 667 | case OPT_Wwrite_strings: |
37fa72e9 | 668 | if (!c_dialect_cxx ()) |
7b086b11 | 669 | flag_const_strings = value; |
0b6f2917 | 670 | else |
7b086b11 | 671 | warn_write_strings = value; |
0b6f2917 | 672 | break; |
2f6e4e97 | 673 | |
f749a36b | 674 | case OPT_ansi: |
37fa72e9 | 675 | if (!c_dialect_cxx ()) |
f749a36b NB |
676 | set_std_c89 (false, true); |
677 | else | |
678 | set_std_cxx98 (true); | |
679 | break; | |
0b6f2917 | 680 | |
4b7091eb NB |
681 | case OPT_d: |
682 | handle_OPT_d (arg); | |
683 | break; | |
684 | ||
0b6f2917 | 685 | case OPT_fcond_mismatch: |
37fa72e9 | 686 | if (!c_dialect_cxx ()) |
0b6f2917 | 687 | { |
7b086b11 | 688 | flag_cond_mismatch = value; |
0b6f2917 NB |
689 | break; |
690 | } | |
691 | /* Fall through. */ | |
692 | ||
693 | case OPT_fall_virtual: | |
7813d14c | 694 | case OPT_falt_external_templates: |
0b6f2917 | 695 | case OPT_fenum_int_equiv: |
7813d14c | 696 | case OPT_fexternal_templates: |
0b6f2917 NB |
697 | case OPT_fguiding_decls: |
698 | case OPT_fhonor_std: | |
699 | case OPT_fhuge_objects: | |
700 | case OPT_flabels_ok: | |
fef3106c | 701 | case OPT_fname_mangling_version_: |
0b6f2917 NB |
702 | case OPT_fnew_abi: |
703 | case OPT_fnonnull_objects: | |
704 | case OPT_fsquangle: | |
705 | case OPT_fstrict_prototype: | |
706 | case OPT_fthis_is_variable: | |
707 | case OPT_fvtable_thunks: | |
708 | case OPT_fxref: | |
a0c8285b | 709 | case OPT_fvtable_gc: |
cf03fd63 | 710 | warning ("switch \"%s\" is no longer supported", option->opt_text); |
0b6f2917 NB |
711 | break; |
712 | ||
713 | case OPT_faccess_control: | |
7b086b11 | 714 | flag_access_control = value; |
0b6f2917 NB |
715 | break; |
716 | ||
0b6f2917 | 717 | case OPT_fasm: |
7b086b11 | 718 | flag_no_asm = !value; |
0b6f2917 NB |
719 | break; |
720 | ||
721 | case OPT_fbuiltin: | |
7b086b11 | 722 | flag_no_builtin = !value; |
0b6f2917 NB |
723 | break; |
724 | ||
725 | case OPT_fbuiltin_: | |
7b086b11 | 726 | if (value) |
4b7091eb NB |
727 | result = 0; |
728 | else | |
729 | disable_builtin_function (arg); | |
0b6f2917 NB |
730 | break; |
731 | ||
732 | case OPT_fdollars_in_identifiers: | |
7b086b11 | 733 | cpp_opts->dollars_in_ident = value; |
0b6f2917 NB |
734 | break; |
735 | ||
fef3106c | 736 | case OPT_fdump_: |
f3f735eb | 737 | if (!dump_switch_p (arg)) |
4b7091eb | 738 | result = 0; |
0b6f2917 NB |
739 | break; |
740 | ||
741 | case OPT_ffreestanding: | |
7b086b11 | 742 | value = !value; |
938d968e | 743 | /* Fall through.... */ |
0b6f2917 | 744 | case OPT_fhosted: |
7b086b11 NB |
745 | flag_hosted = value; |
746 | flag_no_builtin = !value; | |
0b6f2917 | 747 | /* warn_main will be 2 if set by -Wall, 1 if set by -Wmain */ |
7b086b11 | 748 | if (!value && warn_main == 2) |
0b6f2917 NB |
749 | warn_main = 0; |
750 | break; | |
751 | ||
752 | case OPT_fshort_double: | |
7b086b11 | 753 | flag_short_double = value; |
0b6f2917 NB |
754 | break; |
755 | ||
756 | case OPT_fshort_enums: | |
7b086b11 | 757 | flag_short_enums = value; |
0b6f2917 NB |
758 | break; |
759 | ||
760 | case OPT_fshort_wchar: | |
7b086b11 | 761 | flag_short_wchar = value; |
0b6f2917 NB |
762 | break; |
763 | ||
764 | case OPT_fsigned_bitfields: | |
7b086b11 | 765 | flag_signed_bitfields = value; |
0b6f2917 NB |
766 | explicit_flag_signed_bitfields = 1; |
767 | break; | |
768 | ||
769 | case OPT_fsigned_char: | |
7b086b11 | 770 | flag_signed_char = value; |
0b6f2917 NB |
771 | break; |
772 | ||
773 | case OPT_funsigned_bitfields: | |
7b086b11 | 774 | flag_signed_bitfields = !value; |
0b6f2917 NB |
775 | explicit_flag_signed_bitfields = 1; |
776 | break; | |
777 | ||
778 | case OPT_funsigned_char: | |
7b086b11 | 779 | flag_signed_char = !value; |
0b6f2917 NB |
780 | break; |
781 | ||
782 | case OPT_fcheck_new: | |
7b086b11 | 783 | flag_check_new = value; |
0b6f2917 NB |
784 | break; |
785 | ||
786 | case OPT_fconserve_space: | |
7b086b11 | 787 | flag_conserve_space = value; |
0b6f2917 NB |
788 | break; |
789 | ||
790 | case OPT_fconst_strings: | |
7b086b11 | 791 | flag_const_strings = value; |
0b6f2917 NB |
792 | break; |
793 | ||
fef3106c | 794 | case OPT_fconstant_string_class_: |
4b7091eb | 795 | constant_string_class_name = arg; |
0b6f2917 NB |
796 | break; |
797 | ||
798 | case OPT_fdefault_inline: | |
7b086b11 | 799 | flag_default_inline = value; |
0b6f2917 NB |
800 | break; |
801 | ||
802 | case OPT_felide_constructors: | |
7b086b11 | 803 | flag_elide_constructors = value; |
0b6f2917 NB |
804 | break; |
805 | ||
806 | case OPT_fenforce_eh_specs: | |
7b086b11 | 807 | flag_enforce_eh_specs = value; |
0b6f2917 NB |
808 | break; |
809 | ||
1c2de642 | 810 | case OPT_ffixed_form: |
fef3106c | 811 | case OPT_ffixed_line_length_: |
1c2de642 | 812 | /* Fortran front end options ignored when preprocessing only. */ |
058de654 NB |
813 | if (!flag_preprocess_only) |
814 | result = 0; | |
1c2de642 TM |
815 | break; |
816 | ||
0b6f2917 | 817 | case OPT_ffor_scope: |
7b086b11 | 818 | flag_new_for_scope = value; |
0b6f2917 NB |
819 | break; |
820 | ||
821 | case OPT_fgnu_keywords: | |
7b086b11 | 822 | flag_no_gnu_keywords = !value; |
0b6f2917 NB |
823 | break; |
824 | ||
825 | case OPT_fgnu_runtime: | |
7b086b11 | 826 | flag_next_runtime = !value; |
0b6f2917 NB |
827 | break; |
828 | ||
829 | case OPT_fhandle_exceptions: | |
f75d3e11 | 830 | warning ("-fhandle-exceptions has been renamed -fexceptions (and is now on by default)"); |
7b086b11 | 831 | flag_exceptions = value; |
0b6f2917 NB |
832 | break; |
833 | ||
834 | case OPT_fimplement_inlines: | |
7b086b11 | 835 | flag_implement_inlines = value; |
0b6f2917 NB |
836 | break; |
837 | ||
838 | case OPT_fimplicit_inline_templates: | |
7b086b11 | 839 | flag_implicit_inline_templates = value; |
0b6f2917 NB |
840 | break; |
841 | ||
842 | case OPT_fimplicit_templates: | |
7b086b11 | 843 | flag_implicit_templates = value; |
0b6f2917 NB |
844 | break; |
845 | ||
846 | case OPT_fms_extensions: | |
7b086b11 | 847 | flag_ms_extensions = value; |
0b6f2917 NB |
848 | break; |
849 | ||
850 | case OPT_fnext_runtime: | |
7b086b11 | 851 | flag_next_runtime = value; |
0b6f2917 NB |
852 | break; |
853 | ||
264fa2db ZL |
854 | case OPT_fnil_receivers: |
855 | flag_nil_receivers = value; | |
856 | break; | |
857 | ||
0b6f2917 | 858 | case OPT_fnonansi_builtins: |
7b086b11 | 859 | flag_no_nonansi_builtin = !value; |
0b6f2917 NB |
860 | break; |
861 | ||
264fa2db ZL |
862 | case OPT_fobjc_exceptions: |
863 | flag_objc_exceptions = value; | |
864 | break; | |
865 | ||
18bdccaa | 866 | case OPT_foperator_names: |
7b086b11 | 867 | cpp_opts->operator_names = value; |
18bdccaa NB |
868 | break; |
869 | ||
0b6f2917 | 870 | case OPT_foptional_diags: |
7b086b11 | 871 | flag_optional_diags = value; |
0b6f2917 NB |
872 | break; |
873 | ||
17211ab5 | 874 | case OPT_fpch_deps: |
7b086b11 | 875 | cpp_opts->restore_pch_deps = value; |
17211ab5 GK |
876 | break; |
877 | ||
0b6f2917 | 878 | case OPT_fpermissive: |
7b086b11 | 879 | flag_permissive = value; |
0b6f2917 NB |
880 | break; |
881 | ||
18bdccaa | 882 | case OPT_fpreprocessed: |
7b086b11 | 883 | cpp_opts->preprocessed = value; |
18bdccaa NB |
884 | break; |
885 | ||
264fa2db ZL |
886 | case OPT_freplace_objc_classes: |
887 | flag_replace_objc_classes = value; | |
888 | break; | |
889 | ||
0b6f2917 | 890 | case OPT_frepo: |
7b086b11 NB |
891 | flag_use_repository = value; |
892 | if (value) | |
0b6f2917 NB |
893 | flag_implicit_templates = 0; |
894 | break; | |
895 | ||
896 | case OPT_frtti: | |
7b086b11 | 897 | flag_rtti = value; |
0b6f2917 NB |
898 | break; |
899 | ||
18bdccaa | 900 | case OPT_fshow_column: |
7b086b11 | 901 | cpp_opts->show_column = value; |
18bdccaa NB |
902 | break; |
903 | ||
0b6f2917 | 904 | case OPT_fstats: |
7b086b11 | 905 | flag_detailed_statistics = value; |
0b6f2917 NB |
906 | break; |
907 | ||
fef3106c | 908 | case OPT_ftabstop_: |
18bdccaa | 909 | /* It is documented that we silently ignore silly values. */ |
7b086b11 NB |
910 | if (value >= 1 && value <= 100) |
911 | cpp_opts->tabstop = value; | |
18bdccaa NB |
912 | break; |
913 | ||
e6cc3a24 ZW |
914 | case OPT_fexec_charset_: |
915 | cpp_opts->narrow_charset = arg; | |
916 | break; | |
917 | ||
918 | case OPT_fwide_exec_charset_: | |
919 | cpp_opts->wide_charset = arg; | |
920 | break; | |
921 | ||
16dd5cfe EC |
922 | case OPT_finput_charset_: |
923 | cpp_opts->input_charset = arg; | |
924 | break; | |
925 | ||
fef3106c | 926 | case OPT_ftemplate_depth_: |
7b086b11 | 927 | max_tinst_depth = value; |
0b6f2917 NB |
928 | break; |
929 | ||
0b6f2917 | 930 | case OPT_fuse_cxa_atexit: |
7b086b11 | 931 | flag_use_cxa_atexit = value; |
0b6f2917 NB |
932 | break; |
933 | ||
934 | case OPT_fweak: | |
7b086b11 | 935 | flag_weak = value; |
0b6f2917 | 936 | break; |
264fa2db ZL |
937 | |
938 | case OPT_fzero_link: | |
939 | flag_zero_link = value; | |
940 | break; | |
0b6f2917 NB |
941 | |
942 | case OPT_gen_decls: | |
943 | flag_gen_declaration = 1; | |
944 | break; | |
945 | ||
5793b276 NB |
946 | case OPT_idirafter: |
947 | add_path (xstrdup (arg), AFTER, 0); | |
948 | break; | |
949 | ||
255c10b1 | 950 | case OPT_imacros: |
23345bbb NB |
951 | case OPT_include: |
952 | defer_opt (code, arg); | |
953 | break; | |
954 | ||
5793b276 NB |
955 | case OPT_iprefix: |
956 | iprefix = arg; | |
957 | break; | |
958 | ||
4bed3787 MS |
959 | case OPT_iquote: |
960 | add_path (xstrdup (arg), QUOTE, 0); | |
961 | break; | |
962 | ||
5793b276 NB |
963 | case OPT_isysroot: |
964 | sysroot = arg; | |
965 | break; | |
966 | ||
967 | case OPT_isystem: | |
968 | add_path (xstrdup (arg), SYSTEM, 0); | |
969 | break; | |
970 | ||
971 | case OPT_iwithprefix: | |
972 | add_prefixed_path (arg, SYSTEM); | |
973 | break; | |
974 | ||
975 | case OPT_iwithprefixbefore: | |
976 | add_prefixed_path (arg, BRACKET); | |
977 | break; | |
978 | ||
f749a36b NB |
979 | case OPT_lang_asm: |
980 | cpp_set_lang (parse_in, CLK_ASM); | |
42ad6c9e | 981 | cpp_opts->dollars_in_ident = false; |
f749a36b NB |
982 | break; |
983 | ||
984 | case OPT_lang_objc: | |
985 | cpp_opts->objc = 1; | |
986 | break; | |
987 | ||
4b7091eb | 988 | case OPT_nostdinc: |
5793b276 | 989 | std_inc = false; |
4b7091eb NB |
990 | break; |
991 | ||
fef3106c | 992 | case OPT_nostdinc__: |
5793b276 | 993 | std_cxx_inc = false; |
4b7091eb NB |
994 | break; |
995 | ||
b4a93904 | 996 | case OPT_o: |
76c3e73e NB |
997 | if (!out_fname) |
998 | out_fname = arg; | |
b4a93904 | 999 | else |
f75d3e11 | 1000 | error ("output filename specified twice"); |
b4a93904 NB |
1001 | break; |
1002 | ||
18bdccaa NB |
1003 | /* We need to handle the -pedantic switches here, rather than in |
1004 | c_common_post_options, so that a subsequent -Wno-endif-labels | |
1005 | is not overridden. */ | |
1006 | case OPT_pedantic_errors: | |
1007 | cpp_opts->pedantic_errors = 1; | |
938d968e | 1008 | /* Fall through. */ |
18bdccaa NB |
1009 | case OPT_pedantic: |
1010 | cpp_opts->pedantic = 1; | |
1011 | cpp_opts->warn_endif_labels = 1; | |
1012 | break; | |
1013 | ||
0b6f2917 NB |
1014 | case OPT_print_objc_runtime_info: |
1015 | print_struct_values = 1; | |
1016 | break; | |
1017 | ||
b4a93904 NB |
1018 | case OPT_remap: |
1019 | cpp_opts->remap = 1; | |
0b6f2917 NB |
1020 | break; |
1021 | ||
fef3106c NB |
1022 | case OPT_std_c__98: |
1023 | case OPT_std_gnu__98: | |
1024 | set_std_cxx98 (code == OPT_std_c__98 /* ISO */); | |
0b6f2917 NB |
1025 | break; |
1026 | ||
1027 | case OPT_std_c89: | |
1028 | case OPT_std_iso9899_1990: | |
b4a93904 NB |
1029 | case OPT_std_iso9899_199409: |
1030 | set_std_c89 (code == OPT_std_iso9899_199409 /* c94 */, true /* ISO */); | |
f749a36b NB |
1031 | break; |
1032 | ||
1033 | case OPT_std_gnu89: | |
1034 | set_std_c89 (false /* c94 */, false /* ISO */); | |
0b6f2917 NB |
1035 | break; |
1036 | ||
1037 | case OPT_std_c99: | |
1038 | case OPT_std_c9x: | |
1039 | case OPT_std_iso9899_1999: | |
1040 | case OPT_std_iso9899_199x: | |
b4a93904 | 1041 | set_std_c99 (true /* ISO */); |
0b6f2917 NB |
1042 | break; |
1043 | ||
0b6f2917 NB |
1044 | case OPT_std_gnu99: |
1045 | case OPT_std_gnu9x: | |
b4a93904 | 1046 | set_std_c99 (false /* ISO */); |
0b6f2917 NB |
1047 | break; |
1048 | ||
4b7091eb NB |
1049 | case OPT_trigraphs: |
1050 | cpp_opts->trigraphs = 1; | |
1051 | break; | |
1052 | ||
1053 | case OPT_traditional_cpp: | |
1054 | cpp_opts->traditional = 1; | |
1055 | break; | |
1056 | ||
0b6f2917 NB |
1057 | case OPT_undef: |
1058 | flag_undef = 1; | |
1059 | break; | |
0b6f2917 | 1060 | |
4b7091eb NB |
1061 | case OPT_w: |
1062 | cpp_opts->inhibit_warnings = 1; | |
1063 | break; | |
1064 | ||
1065 | case OPT_v: | |
5793b276 | 1066 | verbose = true; |
4b7091eb NB |
1067 | break; |
1068 | } | |
0b6f2917 | 1069 | |
0b6f2917 NB |
1070 | return result; |
1071 | } | |
1072 | ||
1073 | /* Post-switch processing. */ | |
1074 | bool | |
8e9ea4d7 | 1075 | c_common_post_options (const char **pfilename) |
0b6f2917 | 1076 | { |
8e9ea4d7 PB |
1077 | struct cpp_callbacks *cb; |
1078 | ||
460bd0e3 | 1079 | /* Canonicalize the input and output filenames. */ |
d1bd0ded GK |
1080 | if (in_fnames == NULL) |
1081 | { | |
1082 | in_fnames = xmalloc (sizeof (in_fnames[0])); | |
1083 | in_fnames[0] = ""; | |
1084 | } | |
1085 | else if (strcmp (in_fnames[0], "-") == 0) | |
1086 | in_fnames[0] = ""; | |
460bd0e3 | 1087 | |
76c3e73e NB |
1088 | if (out_fname == NULL || !strcmp (out_fname, "-")) |
1089 | out_fname = ""; | |
1090 | ||
cd79e210 | 1091 | if (cpp_opts->deps.style == DEPS_NONE) |
76c3e73e NB |
1092 | check_deps_environment_vars (); |
1093 | ||
f4ff5a69 | 1094 | handle_deferred_opts (); |
76c3e73e | 1095 | |
f4ff5a69 | 1096 | sanitize_cpp_opts (); |
460bd0e3 | 1097 | |
5793b276 | 1098 | register_include_chains (parse_in, sysroot, iprefix, |
37fa72e9 | 1099 | std_inc, std_cxx_inc && c_dialect_cxx (), verbose); |
5793b276 | 1100 | |
0b6f2917 NB |
1101 | flag_inline_trees = 1; |
1102 | ||
1103 | /* Use tree inlining if possible. Function instrumentation is only | |
1104 | done in the RTL level, so we disable tree inlining. */ | |
1105 | if (! flag_instrument_function_entry_exit) | |
1106 | { | |
1107 | if (!flag_no_inline) | |
1108 | flag_no_inline = 1; | |
1109 | if (flag_inline_functions) | |
1110 | { | |
1111 | flag_inline_trees = 2; | |
1112 | flag_inline_functions = 0; | |
1113 | } | |
1114 | } | |
1115 | ||
87f85ea0 ZW |
1116 | /* -Wextra implies -Wsign-compare, but not if explicitly |
1117 | overridden. */ | |
1118 | if (warn_sign_compare == -1) | |
1119 | warn_sign_compare = extra_warnings; | |
1120 | ||
0b6f2917 NB |
1121 | /* Special format checking options don't work without -Wformat; warn if |
1122 | they are used. */ | |
1123 | if (warn_format_y2k && !warn_format) | |
1124 | warning ("-Wformat-y2k ignored without -Wformat"); | |
1125 | if (warn_format_extra_args && !warn_format) | |
1126 | warning ("-Wformat-extra-args ignored without -Wformat"); | |
1127 | if (warn_format_zero_length && !warn_format) | |
1128 | warning ("-Wformat-zero-length ignored without -Wformat"); | |
1129 | if (warn_format_nonliteral && !warn_format) | |
1130 | warning ("-Wformat-nonliteral ignored without -Wformat"); | |
1131 | if (warn_format_security && !warn_format) | |
1132 | warning ("-Wformat-security ignored without -Wformat"); | |
1133 | if (warn_missing_format_attribute && !warn_format) | |
1134 | warning ("-Wmissing-format-attribute ignored without -Wformat"); | |
1135 | ||
460bd0e3 NB |
1136 | if (flag_preprocess_only) |
1137 | { | |
63973df3 NB |
1138 | /* Open the output now. We must do so even if flag_no_output is |
1139 | on, because there may be other output than from the actual | |
1140 | preprocessing (e.g. from -dM). */ | |
1141 | if (out_fname[0] == '\0') | |
1142 | out_stream = stdout; | |
1143 | else | |
1144 | out_stream = fopen (out_fname, "w"); | |
1145 | ||
1146 | if (out_stream == NULL) | |
9d10c9a9 | 1147 | { |
fa6ef813 | 1148 | fatal_error ("opening output file %s: %m", out_fname); |
c366ade5 | 1149 | return false; |
9d10c9a9 | 1150 | } |
63973df3 | 1151 | |
d1bd0ded GK |
1152 | if (num_in_fnames > 1) |
1153 | error ("too many filenames given. Type %s --help for usage", | |
1154 | progname); | |
1155 | ||
9d10c9a9 | 1156 | init_pp_output (out_stream); |
460bd0e3 | 1157 | } |
9d10c9a9 NB |
1158 | else |
1159 | { | |
1160 | init_c_lex (); | |
460bd0e3 | 1161 | |
9d10c9a9 | 1162 | /* Yuk. WTF is this? I do know ObjC relies on it somewhere. */ |
d479d37f | 1163 | input_line = 0; |
9d10c9a9 | 1164 | } |
63973df3 | 1165 | |
8e9ea4d7 PB |
1166 | cb = cpp_get_callbacks (parse_in); |
1167 | cb->file_change = cb_file_change; | |
1168 | cb->dir_change = cb_dir_change; | |
4169c321 | 1169 | cpp_post_options (parse_in); |
23345bbb | 1170 | |
d479d37f NS |
1171 | saved_lineno = input_line; |
1172 | input_line = 0; | |
4bfec483 NB |
1173 | |
1174 | /* If an error has occurred in cpplib, note it so we fail | |
1175 | immediately. */ | |
1176 | errorcount += cpp_errors (parse_in); | |
1177 | ||
8e9ea4d7 PB |
1178 | *pfilename = this_input_filename |
1179 | = cpp_read_main_file (parse_in, in_fnames[0]); | |
540554f4 | 1180 | /* Don't do any compilation or preprocessing if there is no input file. */ |
8e9ea4d7 | 1181 | if (this_input_filename == NULL) |
540554f4 JW |
1182 | { |
1183 | errorcount++; | |
1184 | return false; | |
1185 | } | |
8e9ea4d7 | 1186 | |
8a4baa83 PB |
1187 | if (flag_working_directory |
1188 | && flag_preprocess_only && ! flag_no_line_commands) | |
8e9ea4d7 PB |
1189 | pp_dir_change (parse_in, get_src_pwd ()); |
1190 | ||
4bfec483 NB |
1191 | return flag_preprocess_only; |
1192 | } | |
1193 | ||
1194 | /* Front end initialization common to C, ObjC and C++. */ | |
1195 | bool | |
2f6e4e97 | 1196 | c_common_init (void) |
4bfec483 | 1197 | { |
d479d37f | 1198 | input_line = saved_lineno; |
4bfec483 NB |
1199 | |
1200 | /* Set up preprocessor arithmetic. Must be done after call to | |
1201 | c_common_nodes_and_builtins for type nodes to be good. */ | |
1202 | cpp_opts->precision = TYPE_PRECISION (intmax_type_node); | |
1203 | cpp_opts->char_precision = TYPE_PRECISION (char_type_node); | |
1204 | cpp_opts->int_precision = TYPE_PRECISION (integer_type_node); | |
1205 | cpp_opts->wchar_precision = TYPE_PRECISION (wchar_type_node); | |
8df83eae | 1206 | cpp_opts->unsigned_wchar = TYPE_UNSIGNED (wchar_type_node); |
e6cc3a24 ZW |
1207 | cpp_opts->bytes_big_endian = BYTES_BIG_ENDIAN; |
1208 | ||
1209 | /* This can't happen until after wchar_precision and bytes_big_endian | |
1210 | are known. */ | |
1211 | cpp_init_iconv (parse_in); | |
460bd0e3 | 1212 | |
9d10c9a9 NB |
1213 | if (flag_preprocess_only) |
1214 | { | |
8e9ea4d7 PB |
1215 | finish_options (); |
1216 | preprocess_file (parse_in); | |
4bfec483 | 1217 | return false; |
9d10c9a9 NB |
1218 | } |
1219 | ||
63973df3 | 1220 | /* Has to wait until now so that cpplib has its hash table. */ |
460bd0e3 NB |
1221 | init_pragma (); |
1222 | ||
4bfec483 | 1223 | return true; |
76c3e73e NB |
1224 | } |
1225 | ||
d1bd0ded GK |
1226 | /* Initialize the integrated preprocessor after debug output has been |
1227 | initialized; loop over each input file. */ | |
23345bbb | 1228 | void |
f75fbaf7 | 1229 | c_common_parse_file (int set_yydebug) |
23345bbb NB |
1230 | { |
1231 | #if YYDEBUG != 0 | |
1232 | yydebug = set_yydebug; | |
1233 | #else | |
f75fbaf7 ZW |
1234 | if (set_yydebug) |
1235 | warning ("YYDEBUG not defined"); | |
23345bbb NB |
1236 | #endif |
1237 | ||
f75fbaf7 ZW |
1238 | if (num_in_fnames > 1) |
1239 | fatal_error ("sorry, inter-module analysis temporarily out of commission"); | |
d1bd0ded | 1240 | |
f75fbaf7 ZW |
1241 | finish_options (); |
1242 | pch_init (); | |
1243 | push_file_scope (); | |
1244 | c_parse_file (); | |
d1bd0ded | 1245 | finish_file (); |
f75fbaf7 | 1246 | pop_file_scope (); |
23345bbb NB |
1247 | } |
1248 | ||
76c3e73e NB |
1249 | /* Common finish hook for the C, ObjC and C++ front ends. */ |
1250 | void | |
2f6e4e97 | 1251 | c_common_finish (void) |
76c3e73e NB |
1252 | { |
1253 | FILE *deps_stream = NULL; | |
1254 | ||
f4ff5a69 | 1255 | if (cpp_opts->deps.style != DEPS_NONE) |
76c3e73e NB |
1256 | { |
1257 | /* If -M or -MM was seen without -MF, default output to the | |
1258 | output stream. */ | |
f4ff5a69 | 1259 | if (!deps_file) |
76c3e73e NB |
1260 | deps_stream = out_stream; |
1261 | else | |
1262 | { | |
f4ff5a69 | 1263 | deps_stream = fopen (deps_file, deps_append ? "a": "w"); |
76c3e73e | 1264 | if (!deps_stream) |
fa6ef813 | 1265 | fatal_error ("opening dependency file %s: %m", deps_file); |
76c3e73e NB |
1266 | } |
1267 | } | |
1268 | ||
1269 | /* For performance, avoid tearing down cpplib's internal structures | |
1270 | with cpp_destroy (). */ | |
1271 | errorcount += cpp_finish (parse_in, deps_stream); | |
1272 | ||
1273 | if (deps_stream && deps_stream != out_stream | |
1274 | && (ferror (deps_stream) || fclose (deps_stream))) | |
fa6ef813 | 1275 | fatal_error ("closing dependency file %s: %m", deps_file); |
76c3e73e NB |
1276 | |
1277 | if (out_stream && (ferror (out_stream) || fclose (out_stream))) | |
fa6ef813 | 1278 | fatal_error ("when writing output to %s: %m", out_fname); |
76c3e73e NB |
1279 | } |
1280 | ||
76c3e73e NB |
1281 | /* Either of two environment variables can specify output of |
1282 | dependencies. Their value is either "OUTPUT_FILE" or "OUTPUT_FILE | |
1283 | DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to | |
1284 | and DEPS_TARGET is the target to mention in the deps. They also | |
1285 | result in dependency information being appended to the output file | |
182d89a3 NB |
1286 | rather than overwriting it, and like Sun's compiler |
1287 | SUNPRO_DEPENDENCIES suppresses the dependency on the main file. */ | |
76c3e73e | 1288 | static void |
2f6e4e97 | 1289 | check_deps_environment_vars (void) |
76c3e73e NB |
1290 | { |
1291 | char *spec; | |
1292 | ||
1293 | GET_ENVIRONMENT (spec, "DEPENDENCIES_OUTPUT"); | |
1294 | if (spec) | |
f4ff5a69 | 1295 | cpp_opts->deps.style = DEPS_USER; |
76c3e73e NB |
1296 | else |
1297 | { | |
1298 | GET_ENVIRONMENT (spec, "SUNPRO_DEPENDENCIES"); | |
1299 | if (spec) | |
182d89a3 NB |
1300 | { |
1301 | cpp_opts->deps.style = DEPS_SYSTEM; | |
1302 | cpp_opts->deps.ignore_main_file = true; | |
1303 | } | |
76c3e73e NB |
1304 | } |
1305 | ||
1306 | if (spec) | |
1307 | { | |
1308 | /* Find the space before the DEPS_TARGET, if there is one. */ | |
1309 | char *s = strchr (spec, ' '); | |
1310 | if (s) | |
1311 | { | |
1312 | /* Let the caller perform MAKE quoting. */ | |
f4ff5a69 | 1313 | defer_opt (OPT_MT, s + 1); |
76c3e73e NB |
1314 | *s = '\0'; |
1315 | } | |
1316 | ||
1317 | /* Command line -MF overrides environment variables and default. */ | |
f4ff5a69 NB |
1318 | if (!deps_file) |
1319 | deps_file = spec; | |
76c3e73e | 1320 | |
f4ff5a69 NB |
1321 | deps_append = 1; |
1322 | } | |
1323 | } | |
1324 | ||
1325 | /* Handle deferred command line switches. */ | |
1326 | static void | |
2f6e4e97 | 1327 | handle_deferred_opts (void) |
f4ff5a69 NB |
1328 | { |
1329 | size_t i; | |
1330 | ||
1331 | for (i = 0; i < deferred_count; i++) | |
1332 | { | |
1333 | struct deferred_opt *opt = &deferred_opts[i]; | |
1334 | ||
c1bad961 NB |
1335 | if (opt->code == OPT_MT || opt->code == OPT_MQ) |
1336 | cpp_add_dependency_target (parse_in, opt->arg, opt->code == OPT_MQ); | |
f4ff5a69 | 1337 | } |
f4ff5a69 NB |
1338 | } |
1339 | ||
1340 | /* These settings are appropriate for GCC, but not necessarily so for | |
1341 | cpplib as a library. */ | |
1342 | static void | |
2f6e4e97 | 1343 | sanitize_cpp_opts (void) |
f4ff5a69 NB |
1344 | { |
1345 | /* If we don't know what style of dependencies to output, complain | |
1346 | if any other dependency switches have been given. */ | |
1347 | if (deps_seen && cpp_opts->deps.style == DEPS_NONE) | |
1348 | error ("to generate dependencies you must specify either -M or -MM"); | |
1349 | ||
1350 | /* -dM and dependencies suppress normal output; do it here so that | |
1351 | the last -d[MDN] switch overrides earlier ones. */ | |
63973df3 NB |
1352 | if (flag_dump_macros == 'M') |
1353 | flag_no_output = 1; | |
f4ff5a69 NB |
1354 | |
1355 | /* Disable -dD, -dN and -dI if normal output is suppressed. Allow | |
1356 | -dM since at least glibc relies on -M -dM to work. */ | |
63973df3 | 1357 | if (flag_no_output) |
f4ff5a69 | 1358 | { |
63973df3 NB |
1359 | if (flag_dump_macros != 'M') |
1360 | flag_dump_macros = 0; | |
1361 | flag_dump_includes = 0; | |
76c3e73e | 1362 | } |
f4ff5a69 NB |
1363 | |
1364 | cpp_opts->unsigned_char = !flag_signed_char; | |
1365 | cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS; | |
1366 | ||
1367 | /* We want -Wno-long-long to override -pedantic -std=non-c99 | |
1368 | and/or -Wtraditional, whatever the ordering. */ | |
1369 | cpp_opts->warn_long_long | |
1370 | = warn_long_long && ((!flag_isoc99 && pedantic) || warn_traditional); | |
b20d9f0c | 1371 | |
e5b79219 RH |
1372 | /* Similarly with -Wno-variadic-macros. No check for c99 here, since |
1373 | this also turns off warnings about GCCs extension. */ | |
1374 | cpp_opts->warn_variadic_macros | |
1375 | = warn_variadic_macros && (pedantic || warn_traditional); | |
1376 | ||
b20d9f0c AO |
1377 | /* If we're generating preprocessor output, emit current directory |
1378 | if explicitly requested or if debugging information is enabled. | |
1379 | ??? Maybe we should only do it for debugging formats that | |
1380 | actually output the current directory? */ | |
1381 | if (flag_working_directory == -1) | |
1382 | flag_working_directory = (debug_info_level != DINFO_LEVEL_NONE); | |
f4ff5a69 NB |
1383 | } |
1384 | ||
5793b276 NB |
1385 | /* Add include path with a prefix at the front of its name. */ |
1386 | static void | |
2f6e4e97 | 1387 | add_prefixed_path (const char *suffix, size_t chain) |
5793b276 | 1388 | { |
52999738 | 1389 | char *path; |
5793b276 | 1390 | const char *prefix; |
52999738 | 1391 | size_t prefix_len, suffix_len; |
5793b276 | 1392 | |
52999738 ZW |
1393 | suffix_len = strlen (suffix); |
1394 | prefix = iprefix ? iprefix : cpp_GCC_INCLUDE_DIR; | |
1395 | prefix_len = iprefix ? strlen (iprefix) : cpp_GCC_INCLUDE_DIR_len; | |
1396 | ||
1397 | path = xmalloc (prefix_len + suffix_len + 1); | |
1398 | memcpy (path, prefix, prefix_len); | |
1399 | memcpy (path + prefix_len, suffix, suffix_len); | |
1400 | path[prefix_len + suffix_len] = '\0'; | |
1401 | ||
1402 | add_path (path, chain, 0); | |
5793b276 NB |
1403 | } |
1404 | ||
8e9ea4d7 PB |
1405 | /* Handle -D, -U, -A, -imacros, and the first -include. */ |
1406 | static void | |
1407 | finish_options (void) | |
255c10b1 | 1408 | { |
255c10b1 NB |
1409 | if (!cpp_opts->preprocessed) |
1410 | { | |
c1bad961 NB |
1411 | size_t i; |
1412 | ||
8e9ea4d7 | 1413 | cpp_change_file (parse_in, LC_RENAME, _("<built-in>")); |
6e270179 | 1414 | cpp_init_builtins (parse_in, flag_hosted); |
c1bad961 | 1415 | c_cpp_builtins (parse_in); |
78b8811a HPN |
1416 | |
1417 | /* We're about to send user input to cpplib, so make it warn for | |
1418 | things that we previously (when we sent it internal definitions) | |
1419 | told it to not warn. | |
1420 | ||
1421 | C99 permits implementation-defined characters in identifiers. | |
1422 | The documented meaning of -std= is to turn off extensions that | |
1423 | conflict with the specified standard, and since a strictly | |
1424 | conforming program cannot contain a '$', we do not condition | |
1425 | their acceptance on the -std= setting. */ | |
1426 | cpp_opts->warn_dollars = (cpp_opts->pedantic && !cpp_opts->c99); | |
1427 | ||
b4e46cea | 1428 | cpp_change_file (parse_in, LC_RENAME, _("<command line>")); |
c1bad961 NB |
1429 | for (i = 0; i < deferred_count; i++) |
1430 | { | |
1431 | struct deferred_opt *opt = &deferred_opts[i]; | |
1432 | ||
1433 | if (opt->code == OPT_D) | |
1434 | cpp_define (parse_in, opt->arg); | |
1435 | else if (opt->code == OPT_U) | |
1436 | cpp_undef (parse_in, opt->arg); | |
1437 | else if (opt->code == OPT_A) | |
1438 | { | |
1439 | if (opt->arg[0] == '-') | |
1440 | cpp_unassert (parse_in, opt->arg + 1); | |
1441 | else | |
1442 | cpp_assert (parse_in, opt->arg); | |
1443 | } | |
1444 | } | |
255c10b1 | 1445 | |
c1bad961 | 1446 | /* Handle -imacros after -D and -U. */ |
255c10b1 NB |
1447 | for (i = 0; i < deferred_count; i++) |
1448 | { | |
1449 | struct deferred_opt *opt = &deferred_opts[i]; | |
1450 | ||
1451 | if (opt->code == OPT_imacros | |
1452 | && cpp_push_include (parse_in, opt->arg)) | |
9b49a0aa | 1453 | { |
6614fd40 | 1454 | /* Disable push_command_line_include callback for now. */ |
9b49a0aa PB |
1455 | include_cursor = deferred_count + 1; |
1456 | cpp_scan_nooutput (parse_in); | |
1457 | } | |
255c10b1 NB |
1458 | } |
1459 | } | |
1460 | ||
e6ebd07b | 1461 | include_cursor = 0; |
255c10b1 NB |
1462 | push_command_line_include (); |
1463 | } | |
1464 | ||
23345bbb NB |
1465 | /* Give CPP the next file given by -include, if any. */ |
1466 | static void | |
2f6e4e97 | 1467 | push_command_line_include (void) |
23345bbb | 1468 | { |
23345bbb NB |
1469 | while (include_cursor < deferred_count) |
1470 | { | |
1471 | struct deferred_opt *opt = &deferred_opts[include_cursor++]; | |
2f6e4e97 | 1472 | |
31703a61 PB |
1473 | if (! cpp_opts->preprocessed && opt->code == OPT_include |
1474 | && cpp_push_include (parse_in, opt->arg)) | |
23345bbb NB |
1475 | return; |
1476 | } | |
1477 | ||
1478 | if (include_cursor == deferred_count) | |
1479 | { | |
31703a61 | 1480 | include_cursor++; |
23345bbb NB |
1481 | /* -Wunused-macros should only warn about macros defined hereafter. */ |
1482 | cpp_opts->warn_unused_macros = warn_unused_macros; | |
8e9ea4d7 PB |
1483 | /* Restore the line map from <command line>. */ |
1484 | if (! cpp_opts->preprocessed) | |
1485 | cpp_change_file (parse_in, LC_RENAME, main_input_filename); | |
1486 | ||
1487 | /* Set this here so the client can change the option if it wishes, | |
1488 | and after stacking the main file so we don't trace the main file. */ | |
1489 | line_table.trace_includes = cpp_opts->print_include_names; | |
23345bbb NB |
1490 | } |
1491 | } | |
1492 | ||
1493 | /* File change callback. Has to handle -include files. */ | |
1494 | static void | |
2f6e4e97 AJ |
1495 | cb_file_change (cpp_reader *pfile ATTRIBUTE_UNUSED, |
1496 | const struct line_map *new_map) | |
23345bbb NB |
1497 | { |
1498 | if (flag_preprocess_only) | |
1499 | pp_file_change (new_map); | |
1500 | else | |
1501 | fe_file_change (new_map); | |
1502 | ||
31703a61 | 1503 | if (new_map == 0 || (new_map->reason == LC_LEAVE && MAIN_FILE_P (new_map))) |
23345bbb NB |
1504 | push_command_line_include (); |
1505 | } | |
1506 | ||
8e9ea4d7 PB |
1507 | void |
1508 | cb_dir_change (cpp_reader *pfile ATTRIBUTE_UNUSED, const char *dir) | |
1509 | { | |
1510 | if (! set_src_pwd (dir)) | |
1511 | warning ("too late for # directive to set debug directory"); | |
1512 | } | |
1513 | ||
f4ff5a69 NB |
1514 | /* Set the C 89 standard (with 1994 amendments if C94, without GNU |
1515 | extensions if ISO). There is no concept of gnu94. */ | |
1516 | static void | |
2f6e4e97 | 1517 | set_std_c89 (int c94, int iso) |
f4ff5a69 NB |
1518 | { |
1519 | cpp_set_lang (parse_in, c94 ? CLK_STDC94: iso ? CLK_STDC89: CLK_GNUC89); | |
1520 | flag_iso = iso; | |
1521 | flag_no_asm = iso; | |
1522 | flag_no_gnu_keywords = iso; | |
1523 | flag_no_nonansi_builtin = iso; | |
f4ff5a69 NB |
1524 | flag_isoc94 = c94; |
1525 | flag_isoc99 = 0; | |
76c3e73e NB |
1526 | } |
1527 | ||
b4a93904 NB |
1528 | /* Set the C 99 standard (without GNU extensions if ISO). */ |
1529 | static void | |
2f6e4e97 | 1530 | set_std_c99 (int iso) |
b4a93904 NB |
1531 | { |
1532 | cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99); | |
1533 | flag_no_asm = iso; | |
1534 | flag_no_nonansi_builtin = iso; | |
b4a93904 NB |
1535 | flag_iso = iso; |
1536 | flag_isoc99 = 1; | |
1537 | flag_isoc94 = 1; | |
b4a93904 NB |
1538 | } |
1539 | ||
f749a36b NB |
1540 | /* Set the C++ 98 standard (without GNU extensions if ISO). */ |
1541 | static void | |
2f6e4e97 | 1542 | set_std_cxx98 (int iso) |
f749a36b NB |
1543 | { |
1544 | cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX); | |
1545 | flag_no_gnu_keywords = iso; | |
1546 | flag_no_nonansi_builtin = iso; | |
f749a36b NB |
1547 | flag_iso = iso; |
1548 | } | |
1549 | ||
0b6f2917 NB |
1550 | /* Handle setting implicit to ON. */ |
1551 | static void | |
2f6e4e97 | 1552 | set_Wimplicit (int on) |
0b6f2917 NB |
1553 | { |
1554 | warn_implicit = on; | |
1555 | warn_implicit_int = on; | |
1556 | if (on) | |
1557 | { | |
1558 | if (mesg_implicit_function_declaration != 2) | |
1559 | mesg_implicit_function_declaration = 1; | |
1560 | } | |
1561 | else | |
1562 | mesg_implicit_function_declaration = 0; | |
1563 | } | |
1564 | ||
4b7091eb | 1565 | /* Args to -d specify what to dump. Silently ignore |
05713b80 | 1566 | unrecognized options; they may be aimed at toplev.c. */ |
0b6f2917 | 1567 | static void |
2f6e4e97 | 1568 | handle_OPT_d (const char *arg) |
0b6f2917 | 1569 | { |
4b7091eb NB |
1570 | char c; |
1571 | ||
1572 | while ((c = *arg++) != '\0') | |
1573 | switch (c) | |
1574 | { | |
63973df3 NB |
1575 | case 'M': /* Dump macros only. */ |
1576 | case 'N': /* Dump names. */ | |
1577 | case 'D': /* Dump definitions. */ | |
1578 | flag_dump_macros = c; | |
4b7091eb NB |
1579 | break; |
1580 | ||
1581 | case 'I': | |
63973df3 | 1582 | flag_dump_includes = 1; |
4b7091eb NB |
1583 | break; |
1584 | } | |
0b6f2917 | 1585 | } |