]>
Commit | Line | Data |
---|---|---|
0b6f2917 | 1 | /* C/ObjC/C++ command line option handling. |
c75c517d | 2 | Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 |
6ac01510 | 3 | Free Software Foundation, Inc. |
0b6f2917 NB |
4 | Contributed by Neil Booth. |
5 | ||
6 | This file is part of GCC. | |
7 | ||
8 | GCC is free software; you can redistribute it and/or modify it under | |
9 | the terms of the GNU General Public License as published by the Free | |
9dcd6f09 | 10 | Software Foundation; either version 3, or (at your option) any later |
0b6f2917 NB |
11 | version. |
12 | ||
13 | GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
14 | WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
15 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
16 | for more details. | |
17 | ||
18 | You should have received a copy of the GNU General Public License | |
9dcd6f09 NC |
19 | along with GCC; see the file COPYING3. If not see |
20 | <http://www.gnu.org/licenses/>. */ | |
0b6f2917 NB |
21 | |
22 | #include "config.h" | |
23 | #include "system.h" | |
4977bab6 | 24 | #include "coretypes.h" |
0b6f2917 NB |
25 | #include "tree.h" |
26 | #include "c-common.h" | |
27 | #include "c-pragma.h" | |
28 | #include "flags.h" | |
29 | #include "toplev.h" | |
30 | #include "langhooks.h" | |
0b6f2917 | 31 | #include "diagnostic.h" |
4b7091eb | 32 | #include "intl.h" |
5793b276 | 33 | #include "cppdefault.h" |
670637ee | 34 | #include "incpath.h" |
23345bbb | 35 | #include "debug.h" /* For debug_hooks. */ |
2772ef3e | 36 | #include "opts.h" |
d7b42618 | 37 | #include "options.h" |
c6e83800 | 38 | #include "mkdeps.h" |
f4ce02c5 | 39 | #include "target.h" /* For gcc_targetcm. */ |
a4c97feb | 40 | #include "tm_p.h" /* For C_COMMON_OVERRIDE_OPTIONS. */ |
5793b276 | 41 | |
b1822ccc NB |
42 | #ifndef DOLLARS_IN_IDENTIFIERS |
43 | # define DOLLARS_IN_IDENTIFIERS true | |
44 | #endif | |
45 | ||
5793b276 NB |
46 | #ifndef TARGET_SYSTEM_ROOT |
47 | # define TARGET_SYSTEM_ROOT NULL | |
48 | #endif | |
0b6f2917 | 49 | |
7cd60054 AM |
50 | #ifndef TARGET_OPTF |
51 | #define TARGET_OPTF(ARG) | |
52 | #endif | |
53 | ||
f4ff5a69 | 54 | /* CPP's options. */ |
d2e796ad | 55 | cpp_options *cpp_opts; |
18bdccaa | 56 | |
460bd0e3 | 57 | /* Input filename. */ |
89e9faee | 58 | static const char *this_input_filename; |
460bd0e3 | 59 | |
76c3e73e NB |
60 | /* Filename and stream for preprocessed output. */ |
61 | static const char *out_fname; | |
62 | static FILE *out_stream; | |
63 | ||
64 | /* Append dependencies to deps_file. */ | |
65 | static bool deps_append; | |
66 | ||
f4ff5a69 NB |
67 | /* If dependency switches (-MF etc.) have been given. */ |
68 | static bool deps_seen; | |
69 | ||
5793b276 NB |
70 | /* If -v seen. */ |
71 | static bool verbose; | |
72 | ||
f4ff5a69 NB |
73 | /* Dependency output file. */ |
74 | static const char *deps_file; | |
75 | ||
5793b276 NB |
76 | /* The prefix given by -iprefix, if any. */ |
77 | static const char *iprefix; | |
78 | ||
2b6dd222 JM |
79 | /* The multilib directory given by -imultilib, if any. */ |
80 | static const char *imultilib; | |
81 | ||
5793b276 NB |
82 | /* The system root, if any. Overridden by -isysroot. */ |
83 | static const char *sysroot = TARGET_SYSTEM_ROOT; | |
84 | ||
85 | /* Zero disables all standard directories for headers. */ | |
86 | static bool std_inc = true; | |
87 | ||
88 | /* Zero disables the C++-specific standard directories for headers. */ | |
89 | static bool std_cxx_inc = true; | |
90 | ||
91 | /* If the quote chain has been split by -I-. */ | |
92 | static bool quote_chain_split; | |
93 | ||
23345bbb NB |
94 | /* If -Wunused-macros. */ |
95 | static bool warn_unused_macros; | |
96 | ||
e5b79219 RH |
97 | /* If -Wvariadic-macros. */ |
98 | static bool warn_variadic_macros = true; | |
99 | ||
b86f6cd9 NB |
100 | /* Number of deferred options. */ |
101 | static size_t deferred_count; | |
f4ff5a69 | 102 | |
23345bbb NB |
103 | /* Number of deferred options scanned for -include. */ |
104 | static size_t include_cursor; | |
105 | ||
2f6e4e97 AJ |
106 | static void handle_OPT_d (const char *); |
107 | static void set_std_cxx98 (int); | |
966541e3 | 108 | static void set_std_cxx0x (int); |
2f6e4e97 AJ |
109 | static void set_std_c89 (int, int); |
110 | static void set_std_c99 (int); | |
2778d766 | 111 | static void set_std_c1x (int); |
2f6e4e97 AJ |
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 | ||
3734d960 MLI |
134 | |
135 | static const unsigned int | |
136 | c_family_lang_mask = (CL_C | CL_CXX | CL_ObjC | CL_ObjCXX); | |
137 | ||
cb66e385 NB |
138 | /* Complain that switch CODE expects an argument but none was |
139 | provided. OPT was the command-line option. Return FALSE to get | |
140 | the default message in opts.c, TRUE if we provide a specialized | |
141 | one. */ | |
142 | bool | |
143 | c_common_missing_argument (const char *opt, size_t code) | |
4b7091eb | 144 | { |
2772ef3e | 145 | switch (code) |
4b7091eb | 146 | { |
4b7091eb | 147 | default: |
cb66e385 NB |
148 | /* Pick up the default message. */ |
149 | return false; | |
4b7091eb | 150 | |
fef3106c | 151 | case OPT_fconstant_string_class_: |
bda67431 | 152 | error ("no class name specified with %qs", opt); |
4b7091eb | 153 | break; |
b4a93904 | 154 | |
c1bad961 | 155 | case OPT_A: |
bda67431 | 156 | error ("assertion missing after %qs", opt); |
c1bad961 NB |
157 | break; |
158 | ||
159 | case OPT_D: | |
160 | case OPT_U: | |
bda67431 | 161 | error ("macro name missing after %qs", opt); |
c1bad961 NB |
162 | break; |
163 | ||
94d1613b | 164 | case OPT_F: |
5793b276 NB |
165 | case OPT_I: |
166 | case OPT_idirafter: | |
167 | case OPT_isysroot: | |
168 | case OPT_isystem: | |
4bed3787 | 169 | case OPT_iquote: |
bda67431 | 170 | error ("missing path after %qs", opt); |
5793b276 NB |
171 | break; |
172 | ||
f4ff5a69 NB |
173 | case OPT_MF: |
174 | case OPT_MD: | |
175 | case OPT_MMD: | |
255c10b1 NB |
176 | case OPT_include: |
177 | case OPT_imacros: | |
b4a93904 | 178 | case OPT_o: |
bda67431 | 179 | error ("missing filename after %qs", opt); |
f4ff5a69 NB |
180 | break; |
181 | ||
182 | case OPT_MQ: | |
183 | case OPT_MT: | |
bda67431 | 184 | error ("missing makefile target after %qs", opt); |
b4a93904 | 185 | break; |
4b7091eb | 186 | } |
cb66e385 NB |
187 | |
188 | return true; | |
4b7091eb NB |
189 | } |
190 | ||
f4ff5a69 NB |
191 | /* Defer option CODE with argument ARG. */ |
192 | static void | |
2f6e4e97 | 193 | defer_opt (enum opt_code code, const char *arg) |
f4ff5a69 | 194 | { |
f4ff5a69 NB |
195 | deferred_opts[deferred_count].code = code; |
196 | deferred_opts[deferred_count].arg = arg; | |
197 | deferred_count++; | |
198 | } | |
199 | ||
87cf0651 SB |
200 | /* -Werror= may set a warning option to enable a warning that is emitted |
201 | by the preprocessor. Set any corresponding flag in cpp_opts. */ | |
202 | ||
203 | static void | |
204 | warning_as_error_callback (int option_index) | |
205 | { | |
206 | switch (option_index) | |
207 | { | |
208 | default: | |
209 | /* Ignore options not associated with the preprocessor. */ | |
210 | break; | |
211 | ||
212 | case OPT_Wdeprecated: | |
213 | cpp_opts->warn_deprecated = 1; | |
214 | break; | |
215 | ||
216 | case OPT_Wcomment: | |
217 | case OPT_Wcomments: | |
218 | cpp_opts->warn_comments = 1; | |
219 | break; | |
220 | ||
221 | case OPT_Wtrigraphs: | |
222 | cpp_opts->warn_trigraphs = 1; | |
223 | break; | |
224 | ||
225 | case OPT_Wmultichar: | |
226 | cpp_opts->warn_multichar = 1; | |
227 | break; | |
228 | ||
229 | case OPT_Wtraditional: | |
230 | cpp_opts->warn_traditional = 1; | |
231 | break; | |
232 | ||
233 | case OPT_Wlong_long: | |
234 | cpp_opts->warn_long_long = 1; | |
235 | break; | |
236 | ||
237 | case OPT_Wendif_labels: | |
238 | cpp_opts->warn_endif_labels = 1; | |
239 | break; | |
240 | ||
241 | case OPT_Wvariadic_macros: | |
242 | /* Set the local flag that is used later to update cpp_opts. */ | |
243 | warn_variadic_macros = 1; | |
244 | break; | |
245 | ||
246 | case OPT_Wbuiltin_macro_redefined: | |
247 | cpp_opts->warn_builtin_macro_redefined = 1; | |
248 | break; | |
249 | ||
250 | case OPT_Wundef: | |
251 | cpp_opts->warn_undef = 1; | |
252 | break; | |
253 | ||
254 | case OPT_Wunused_macros: | |
255 | /* Set the local flag that is used later to update cpp_opts. */ | |
256 | warn_unused_macros = 1; | |
257 | break; | |
258 | ||
259 | case OPT_Wc___compat: | |
260 | /* Add warnings in the same way as c_common_handle_option below. */ | |
261 | if (warn_enum_compare == -1) | |
262 | warn_enum_compare = 1; | |
263 | if (warn_jump_misses_init == -1) | |
264 | warn_jump_misses_init = 1; | |
265 | cpp_opts->warn_cxx_operator_names = 1; | |
266 | break; | |
267 | ||
268 | case OPT_Wnormalized_: | |
269 | inform (input_location, "-Werror=normalized=: Set -Wnormalized=nfc"); | |
270 | cpp_opts->warn_normalize = normalized_C; | |
271 | break; | |
272 | ||
273 | case OPT_Winvalid_pch: | |
274 | cpp_opts->warn_invalid_pch = 1; | |
275 | break; | |
276 | ||
277 | case OPT_Wcpp: | |
278 | /* Handled by standard diagnostics using the option's associated | |
279 | boolean variable. */ | |
280 | break; | |
281 | } | |
282 | } | |
283 | ||
0b6f2917 | 284 | /* Common initialization before parsing options. */ |
b86f6cd9 | 285 | unsigned int |
afd85c1a | 286 | c_common_init_options (unsigned int argc, const char **argv) |
0b6f2917 | 287 | { |
b86f6cd9 | 288 | static const unsigned int lang_flags[] = {CL_C, CL_ObjC, CL_CXX, CL_ObjCXX}; |
afd85c1a | 289 | unsigned int i, result; |
148e4216 | 290 | struct cpp_callbacks *cb; |
37fa72e9 | 291 | |
87cf0651 SB |
292 | /* Register callback for warnings enabled by -Werror=. */ |
293 | register_warning_as_error_callback (warning_as_error_callback); | |
294 | ||
37fa72e9 NB |
295 | /* This is conditionalized only because that is the way the front |
296 | ends used to do it. Maybe this should be unconditional? */ | |
297 | if (c_dialect_cxx ()) | |
298 | { | |
299 | /* By default wrap lines at 80 characters. Is getenv | |
300 | ("COLUMNS") preferable? */ | |
301 | diagnostic_line_cutoff (global_dc) = 80; | |
302 | /* By default, emit location information once for every | |
303 | diagnostic message. */ | |
304 | diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE; | |
305 | } | |
306 | ||
5f0f4a3b JM |
307 | global_dc->opt_permissive = OPT_fpermissive; |
308 | ||
37fa72e9 | 309 | parse_in = cpp_create_reader (c_dialect_cxx () ? CLK_GNUCXX: CLK_GNUC89, |
5ffeb913 | 310 | ident_hash, line_table); |
148e4216 JM |
311 | cb = cpp_get_callbacks (parse_in); |
312 | cb->error = c_cpp_error; | |
37fa72e9 | 313 | |
18bdccaa | 314 | cpp_opts = cpp_get_options (parse_in); |
b1822ccc | 315 | cpp_opts->dollars_in_ident = DOLLARS_IN_IDENTIFIERS; |
37fa72e9 | 316 | cpp_opts->objc = c_dialect_objc (); |
78b8811a HPN |
317 | |
318 | /* Reset to avoid warnings on internal definitions. We set it just | |
319 | before passing on command-line options to cpplib. */ | |
320 | cpp_opts->warn_dollars = 0; | |
321 | ||
37fa72e9 NB |
322 | flag_exceptions = c_dialect_cxx (); |
323 | warn_pointer_arith = c_dialect_cxx (); | |
d539b114 | 324 | warn_write_strings = c_dialect_cxx(); |
a406865a | 325 | flag_warn_unused_result = true; |
2772ef3e | 326 | |
4ac1edaf PC |
327 | /* By default, C99-like requirements for complex multiply and divide. */ |
328 | flag_complex_method = 2; | |
329 | ||
5d038c4c | 330 | deferred_opts = XNEWVEC (struct deferred_opt, argc); |
b86f6cd9 | 331 | |
33de9573 NB |
332 | result = lang_flags[c_language]; |
333 | ||
afd85c1a | 334 | if (c_language == clk_c) |
33de9573 | 335 | { |
afd85c1a RS |
336 | /* If preprocessing assembly language, accept any of the C-family |
337 | front end options since the driver may pass them through. */ | |
338 | for (i = 1; i < argc; i++) | |
339 | if (! strcmp (argv[i], "-lang-asm")) | |
340 | { | |
341 | result |= CL_C | CL_ObjC | CL_CXX | CL_ObjCXX; | |
342 | break; | |
343 | } | |
33de9573 | 344 | } |
33de9573 NB |
345 | |
346 | return result; | |
0b6f2917 NB |
347 | } |
348 | ||
b20d9f0c | 349 | /* Handle switch SCODE with argument ARG. VALUE is true, unless no- |
2772ef3e NB |
350 | form of an -f or -W option was given. Returns 0 if the switch was |
351 | invalid, a negative number to prevent language-independent | |
352 | processing in toplev.c (a hack necessary for the short-term). */ | |
0b6f2917 | 353 | int |
3734d960 MLI |
354 | c_common_handle_option (size_t scode, const char *arg, int value, |
355 | int kind) | |
0b6f2917 | 356 | { |
2772ef3e NB |
357 | const struct cl_option *option = &cl_options[scode]; |
358 | enum opt_code code = (enum opt_code) scode; | |
f18754d6 | 359 | int result = 1; |
2772ef3e | 360 | |
69723be2 SB |
361 | /* Prevent resetting the language standard to a C dialect when the driver |
362 | has already determined that we're looking at assembler input. */ | |
363 | bool preprocessing_asm_p = (cpp_get_options (parse_in)->lang == CLK_ASM); | |
b8698a0f | 364 | |
fef3106c | 365 | switch (code) |
0b6f2917 | 366 | { |
2772ef3e | 367 | default: |
3734d960 | 368 | if (cl_options[code].flags & c_family_lang_mask) |
1f1d5130 MS |
369 | { |
370 | if ((option->flags & CL_TARGET) | |
371 | && ! targetcm.handle_c_option (scode, arg, value)) | |
372 | result = 0; | |
373 | break; | |
374 | } | |
afd85c1a | 375 | result = 0; |
33de9573 | 376 | break; |
0b6f2917 | 377 | |
fef3106c | 378 | case OPT__output_pch_: |
17211ab5 GK |
379 | pch_file = arg; |
380 | break; | |
381 | ||
c1bad961 NB |
382 | case OPT_A: |
383 | defer_opt (code, arg); | |
384 | break; | |
385 | ||
4b7091eb NB |
386 | case OPT_C: |
387 | cpp_opts->discard_comments = 0; | |
388 | break; | |
389 | ||
390 | case OPT_CC: | |
391 | cpp_opts->discard_comments = 0; | |
392 | cpp_opts->discard_comments_in_macro_exp = 0; | |
393 | break; | |
394 | ||
c1bad961 NB |
395 | case OPT_D: |
396 | defer_opt (code, arg); | |
397 | break; | |
398 | ||
4b7091eb NB |
399 | case OPT_H: |
400 | cpp_opts->print_include_names = 1; | |
401 | break; | |
402 | ||
94d1613b MS |
403 | case OPT_F: |
404 | TARGET_OPTF (xstrdup (arg)); | |
405 | break; | |
406 | ||
5793b276 NB |
407 | case OPT_I: |
408 | if (strcmp (arg, "-")) | |
b02398bd | 409 | add_path (xstrdup (arg), BRACKET, 0, true); |
5793b276 NB |
410 | else |
411 | { | |
412 | if (quote_chain_split) | |
413 | error ("-I- specified twice"); | |
414 | quote_chain_split = true; | |
415 | split_quote_chain (); | |
1f5b3869 | 416 | inform (input_location, "obsolete option -I- used, please use -iquote instead"); |
5793b276 NB |
417 | } |
418 | break; | |
419 | ||
f4ff5a69 NB |
420 | case OPT_M: |
421 | case OPT_MM: | |
422 | /* When doing dependencies with -M or -MM, suppress normal | |
423 | preprocessed output, but still do -dM etc. as software | |
424 | depends on this. Preprocessed output does occur if -MD, -MMD | |
425 | or environment var dependency generation is used. */ | |
426 | cpp_opts->deps.style = (code == OPT_M ? DEPS_SYSTEM: DEPS_USER); | |
63973df3 | 427 | flag_no_output = 1; |
f4ff5a69 NB |
428 | break; |
429 | ||
430 | case OPT_MD: | |
431 | case OPT_MMD: | |
432 | cpp_opts->deps.style = (code == OPT_MD ? DEPS_SYSTEM: DEPS_USER); | |
74dc6a11 | 433 | cpp_opts->deps.need_preprocessor_output = true; |
f4ff5a69 NB |
434 | deps_file = arg; |
435 | break; | |
436 | ||
437 | case OPT_MF: | |
438 | deps_seen = true; | |
439 | deps_file = arg; | |
440 | break; | |
441 | ||
442 | case OPT_MG: | |
443 | deps_seen = true; | |
444 | cpp_opts->deps.missing_files = true; | |
445 | break; | |
446 | ||
447 | case OPT_MP: | |
448 | deps_seen = true; | |
449 | cpp_opts->deps.phony_targets = true; | |
450 | break; | |
451 | ||
452 | case OPT_MQ: | |
453 | case OPT_MT: | |
454 | deps_seen = true; | |
455 | defer_opt (code, arg); | |
456 | break; | |
457 | ||
4b7091eb | 458 | case OPT_P: |
63973df3 | 459 | flag_no_line_commands = 1; |
4b7091eb NB |
460 | break; |
461 | ||
c1bad961 NB |
462 | case OPT_U: |
463 | defer_opt (code, arg); | |
464 | break; | |
465 | ||
0b6f2917 | 466 | case OPT_Wall: |
e73f7547 | 467 | warn_unused = value; |
7b086b11 | 468 | set_Wformat (value); |
3734d960 | 469 | handle_option (OPT_Wimplicit, value, NULL, c_family_lang_mask, kind); |
7b086b11 NB |
470 | warn_char_subscripts = value; |
471 | warn_missing_braces = value; | |
472 | warn_parentheses = value; | |
473 | warn_return_type = value; | |
474 | warn_sequence_point = value; /* Was C only. */ | |
7b086b11 | 475 | warn_switch = value; |
027b740e MLI |
476 | if (warn_strict_aliasing == -1) |
477 | set_Wstrict_aliasing (value); | |
c116cd05 | 478 | warn_address = value; |
027b740e MLI |
479 | if (warn_strict_overflow == -1) |
480 | warn_strict_overflow = value; | |
590b1f2d | 481 | warn_array_bounds = value; |
16302daf | 482 | warn_volatile_register_var = value; |
2f6e4e97 | 483 | |
0b6f2917 | 484 | /* Only warn about unknown pragmas that are not in system |
2f6e4e97 | 485 | headers. */ |
7b086b11 | 486 | warn_unknown_pragmas = value; |
0b6f2917 | 487 | |
62a67c94 | 488 | warn_uninitialized = value; |
0b6f2917 | 489 | |
37fa72e9 | 490 | if (!c_dialect_cxx ()) |
4003301d MLI |
491 | { |
492 | /* We set this to 2 here, but 1 in -Wmain, so -ffreestanding | |
493 | can turn it off only if it's not explicit. */ | |
494 | if (warn_main == -1) | |
495 | warn_main = (value ? 2 : 0); | |
6866c6e8 ILT |
496 | |
497 | /* In C, -Wall turns on -Wenum-compare, which we do here. | |
498 | In C++ it is on by default, which is done in | |
499 | c_common_post_options. */ | |
500 | if (warn_enum_compare == -1) | |
501 | warn_enum_compare = value; | |
4003301d | 502 | } |
0b6f2917 NB |
503 | else |
504 | { | |
505 | /* C++-specific warnings. */ | |
384d3837 | 506 | warn_sign_compare = value; |
7b086b11 | 507 | warn_reorder = value; |
e1f1ee86 | 508 | warn_cxx0x_compat = value; |
0b6f2917 | 509 | } |
18bdccaa | 510 | |
7b086b11 NB |
511 | cpp_opts->warn_trigraphs = value; |
512 | cpp_opts->warn_comments = value; | |
513 | cpp_opts->warn_num_sign_change = value; | |
f4e9414e AO |
514 | |
515 | if (warn_pointer_sign == -1) | |
8c684300 | 516 | warn_pointer_sign = value; |
0b6f2917 NB |
517 | break; |
518 | ||
c047ce93 SB |
519 | case OPT_Wbuiltin_macro_redefined: |
520 | cpp_opts->warn_builtin_macro_redefined = value; | |
521 | break; | |
522 | ||
18bdccaa NB |
523 | case OPT_Wcomment: |
524 | case OPT_Wcomments: | |
7b086b11 | 525 | cpp_opts->warn_comments = value; |
18bdccaa NB |
526 | break; |
527 | ||
6866c6e8 ILT |
528 | case OPT_Wc___compat: |
529 | /* Because -Wenum-compare is the default in C++, -Wc++-compat | |
530 | implies -Wenum-compare. */ | |
531 | if (warn_enum_compare == -1 && value) | |
532 | warn_enum_compare = value; | |
e1b7793c | 533 | /* Because C++ always warns about a goto which misses an |
13ebf17b | 534 | initialization, -Wc++-compat turns on -Wjump-misses-init. */ |
e1b7793c ILT |
535 | if (warn_jump_misses_init == -1 && value) |
536 | warn_jump_misses_init = value; | |
3d8b2a98 | 537 | cpp_opts->warn_cxx_operator_names = value; |
6866c6e8 ILT |
538 | break; |
539 | ||
0b6f2917 | 540 | case OPT_Wdeprecated: |
7b086b11 | 541 | cpp_opts->warn_deprecated = value; |
0b6f2917 NB |
542 | break; |
543 | ||
18bdccaa | 544 | case OPT_Wendif_labels: |
7b086b11 | 545 | cpp_opts->warn_endif_labels = value; |
18bdccaa NB |
546 | break; |
547 | ||
548 | case OPT_Werror: | |
7783b402 | 549 | global_dc->warning_as_error_requested = value; |
18bdccaa NB |
550 | break; |
551 | ||
b8698a0f | 552 | case OPT_Werror_implicit_function_declaration: |
dc90f45b MLI |
553 | /* For backward compatibility, this is the same as |
554 | -Werror=implicit-function-declaration. */ | |
b8698a0f | 555 | enable_warning_as_error ("implicit-function-declaration", value, CL_C | CL_ObjC); |
0b6f2917 NB |
556 | break; |
557 | ||
0b6f2917 | 558 | case OPT_Wformat: |
7b086b11 | 559 | set_Wformat (value); |
0b6f2917 NB |
560 | break; |
561 | ||
fef3106c | 562 | case OPT_Wformat_: |
0b6f2917 NB |
563 | set_Wformat (atoi (arg)); |
564 | break; | |
565 | ||
0b6f2917 | 566 | case OPT_Wimplicit: |
3734d960 MLI |
567 | gcc_assert (value == 0 || value == 1); |
568 | if (warn_implicit_int == -1) | |
569 | handle_option (OPT_Wimplicit_int, value, NULL, | |
570 | c_family_lang_mask, kind); | |
571 | if (warn_implicit_function_declaration == -1) | |
572 | handle_option (OPT_Wimplicit_function_declaration, value, NULL, | |
573 | c_family_lang_mask, kind); | |
0b6f2917 NB |
574 | break; |
575 | ||
18bdccaa | 576 | case OPT_Wimport: |
bf42e45b | 577 | /* Silently ignore for now. */ |
18bdccaa NB |
578 | break; |
579 | ||
17211ab5 | 580 | case OPT_Winvalid_pch: |
7b086b11 | 581 | cpp_opts->warn_invalid_pch = value; |
17211ab5 GK |
582 | break; |
583 | ||
b02398bd BE |
584 | case OPT_Wmissing_include_dirs: |
585 | cpp_opts->warn_missing_include_dirs = value; | |
586 | break; | |
587 | ||
0b6f2917 | 588 | case OPT_Wmultichar: |
7b086b11 | 589 | cpp_opts->warn_multichar = value; |
0b6f2917 NB |
590 | break; |
591 | ||
50668cf6 GK |
592 | case OPT_Wnormalized_: |
593 | if (!value || (arg && strcasecmp (arg, "none") == 0)) | |
594 | cpp_opts->warn_normalize = normalized_none; | |
595 | else if (!arg || strcasecmp (arg, "nfkc") == 0) | |
596 | cpp_opts->warn_normalize = normalized_KC; | |
597 | else if (strcasecmp (arg, "id") == 0) | |
598 | cpp_opts->warn_normalize = normalized_identifier_C; | |
599 | else if (strcasecmp (arg, "nfc") == 0) | |
600 | cpp_opts->warn_normalize = normalized_C; | |
601 | else | |
602 | error ("argument %qs to %<-Wnormalized%> not recognized", arg); | |
603 | break; | |
604 | ||
0b6f2917 | 605 | case OPT_Wreturn_type: |
7b086b11 | 606 | warn_return_type = value; |
0b6f2917 NB |
607 | break; |
608 | ||
0b6f2917 | 609 | case OPT_Wtraditional: |
7b086b11 | 610 | cpp_opts->warn_traditional = value; |
18bdccaa NB |
611 | break; |
612 | ||
613 | case OPT_Wtrigraphs: | |
7b086b11 | 614 | cpp_opts->warn_trigraphs = value; |
18bdccaa NB |
615 | break; |
616 | ||
617 | case OPT_Wundef: | |
7b086b11 | 618 | cpp_opts->warn_undef = value; |
0b6f2917 NB |
619 | break; |
620 | ||
621 | case OPT_Wunknown_pragmas: | |
622 | /* Set to greater than 1, so that even unknown pragmas in | |
2f6e4e97 | 623 | system headers will be warned about. */ |
7b086b11 | 624 | warn_unknown_pragmas = value * 2; |
0b6f2917 NB |
625 | break; |
626 | ||
18bdccaa | 627 | case OPT_Wunused_macros: |
7b086b11 | 628 | warn_unused_macros = value; |
18bdccaa NB |
629 | break; |
630 | ||
e5b79219 RH |
631 | case OPT_Wvariadic_macros: |
632 | warn_variadic_macros = value; | |
633 | break; | |
634 | ||
0b6f2917 | 635 | case OPT_Wwrite_strings: |
cfb10bd3 | 636 | warn_write_strings = value; |
0b6f2917 | 637 | break; |
2f6e4e97 | 638 | |
efee9ded GDR |
639 | case OPT_Weffc__: |
640 | warn_ecpp = value; | |
641 | if (value) | |
642 | warn_nonvdtor = true; | |
643 | break; | |
644 | ||
f749a36b | 645 | case OPT_ansi: |
37fa72e9 | 646 | if (!c_dialect_cxx ()) |
f749a36b NB |
647 | set_std_c89 (false, true); |
648 | else | |
649 | set_std_cxx98 (true); | |
650 | break; | |
0b6f2917 | 651 | |
4b7091eb NB |
652 | case OPT_d: |
653 | handle_OPT_d (arg); | |
654 | break; | |
655 | ||
0b6f2917 | 656 | case OPT_fcond_mismatch: |
37fa72e9 | 657 | if (!c_dialect_cxx ()) |
0b6f2917 | 658 | { |
7b086b11 | 659 | flag_cond_mismatch = value; |
0b6f2917 NB |
660 | break; |
661 | } | |
662 | /* Fall through. */ | |
663 | ||
664 | case OPT_fall_virtual: | |
7813d14c | 665 | case OPT_falt_external_templates: |
0b6f2917 | 666 | case OPT_fenum_int_equiv: |
7813d14c | 667 | case OPT_fexternal_templates: |
0b6f2917 NB |
668 | case OPT_fguiding_decls: |
669 | case OPT_fhonor_std: | |
670 | case OPT_fhuge_objects: | |
671 | case OPT_flabels_ok: | |
fef3106c | 672 | case OPT_fname_mangling_version_: |
0b6f2917 NB |
673 | case OPT_fnew_abi: |
674 | case OPT_fnonnull_objects: | |
675 | case OPT_fsquangle: | |
676 | case OPT_fstrict_prototype: | |
677 | case OPT_fthis_is_variable: | |
678 | case OPT_fvtable_thunks: | |
679 | case OPT_fxref: | |
a0c8285b | 680 | case OPT_fvtable_gc: |
d4ee4d25 | 681 | warning (0, "switch %qs is no longer supported", option->opt_text); |
0b6f2917 NB |
682 | break; |
683 | ||
0b6f2917 | 684 | case OPT_fbuiltin_: |
7b086b11 | 685 | if (value) |
4b7091eb NB |
686 | result = 0; |
687 | else | |
688 | disable_builtin_function (arg); | |
0b6f2917 NB |
689 | break; |
690 | ||
ccfc4c91 | 691 | case OPT_fdirectives_only: |
2710d6d7 | 692 | cpp_opts->directives_only = value; |
ccfc4c91 OW |
693 | break; |
694 | ||
0b6f2917 | 695 | case OPT_fdollars_in_identifiers: |
7b086b11 | 696 | cpp_opts->dollars_in_ident = value; |
0b6f2917 NB |
697 | break; |
698 | ||
0b6f2917 | 699 | case OPT_ffreestanding: |
7b086b11 | 700 | value = !value; |
938d968e | 701 | /* Fall through.... */ |
0b6f2917 | 702 | case OPT_fhosted: |
7b086b11 NB |
703 | flag_hosted = value; |
704 | flag_no_builtin = !value; | |
0b6f2917 NB |
705 | break; |
706 | ||
fef3106c | 707 | case OPT_fconstant_string_class_: |
4b7091eb | 708 | constant_string_class_name = arg; |
0b6f2917 NB |
709 | break; |
710 | ||
711 | case OPT_fdefault_inline: | |
5498f011 | 712 | /* Ignore. */ |
0b6f2917 NB |
713 | break; |
714 | ||
af15a2fe JM |
715 | case OPT_fextended_identifiers: |
716 | cpp_opts->extended_identifiers = value; | |
717 | break; | |
718 | ||
0b6f2917 | 719 | case OPT_fgnu_runtime: |
7b086b11 | 720 | flag_next_runtime = !value; |
0b6f2917 NB |
721 | break; |
722 | ||
723 | case OPT_fhandle_exceptions: | |
d4ee4d25 | 724 | warning (0, "-fhandle-exceptions has been renamed -fexceptions (and is now on by default)"); |
7b086b11 | 725 | flag_exceptions = value; |
0b6f2917 NB |
726 | break; |
727 | ||
0b6f2917 | 728 | case OPT_fnext_runtime: |
7b086b11 | 729 | flag_next_runtime = value; |
0b6f2917 NB |
730 | break; |
731 | ||
18bdccaa | 732 | case OPT_foperator_names: |
7b086b11 | 733 | cpp_opts->operator_names = value; |
18bdccaa NB |
734 | break; |
735 | ||
0b6f2917 | 736 | case OPT_foptional_diags: |
5498f011 | 737 | /* Ignore. */ |
0b6f2917 NB |
738 | break; |
739 | ||
17211ab5 | 740 | case OPT_fpch_deps: |
7b086b11 | 741 | cpp_opts->restore_pch_deps = value; |
17211ab5 GK |
742 | break; |
743 | ||
c0d578e6 GK |
744 | case OPT_fpch_preprocess: |
745 | flag_pch_preprocess = value; | |
746 | break; | |
747 | ||
0b6f2917 | 748 | case OPT_fpermissive: |
0641fa97 RG |
749 | flag_permissive = value; |
750 | global_dc->permissive = value; | |
0b6f2917 NB |
751 | break; |
752 | ||
18bdccaa | 753 | case OPT_fpreprocessed: |
7b086b11 | 754 | cpp_opts->preprocessed = value; |
18bdccaa NB |
755 | break; |
756 | ||
0b6f2917 | 757 | case OPT_frepo: |
7b086b11 NB |
758 | flag_use_repository = value; |
759 | if (value) | |
0b6f2917 NB |
760 | flag_implicit_templates = 0; |
761 | break; | |
762 | ||
fef3106c | 763 | case OPT_ftabstop_: |
18bdccaa | 764 | /* It is documented that we silently ignore silly values. */ |
7b086b11 NB |
765 | if (value >= 1 && value <= 100) |
766 | cpp_opts->tabstop = value; | |
18bdccaa NB |
767 | break; |
768 | ||
e6cc3a24 ZW |
769 | case OPT_fexec_charset_: |
770 | cpp_opts->narrow_charset = arg; | |
771 | break; | |
772 | ||
773 | case OPT_fwide_exec_charset_: | |
774 | cpp_opts->wide_charset = arg; | |
775 | break; | |
776 | ||
16dd5cfe EC |
777 | case OPT_finput_charset_: |
778 | cpp_opts->input_charset = arg; | |
779 | break; | |
780 | ||
fef3106c | 781 | case OPT_ftemplate_depth_: |
124e0d27 MLI |
782 | /* Kept for backwards compatibility. */ |
783 | case OPT_ftemplate_depth_eq: | |
7b086b11 | 784 | max_tinst_depth = value; |
0b6f2917 NB |
785 | break; |
786 | ||
d7afec4b ND |
787 | case OPT_fvisibility_inlines_hidden: |
788 | visibility_options.inlines_hidden = value; | |
789 | break; | |
0b6f2917 | 790 | |
39ef6592 LC |
791 | case OPT_femit_struct_debug_baseonly: |
792 | set_struct_debug_option ("base"); | |
793 | break; | |
794 | ||
795 | case OPT_femit_struct_debug_reduced: | |
796 | set_struct_debug_option ("dir:ord:sys,dir:gen:any,ind:base"); | |
797 | break; | |
798 | ||
799 | case OPT_femit_struct_debug_detailed_: | |
800 | set_struct_debug_option (arg); | |
801 | break; | |
802 | ||
5793b276 | 803 | case OPT_idirafter: |
b02398bd | 804 | add_path (xstrdup (arg), AFTER, 0, true); |
5793b276 NB |
805 | break; |
806 | ||
255c10b1 | 807 | case OPT_imacros: |
23345bbb NB |
808 | case OPT_include: |
809 | defer_opt (code, arg); | |
810 | break; | |
811 | ||
2b6dd222 JM |
812 | case OPT_imultilib: |
813 | imultilib = arg; | |
814 | break; | |
815 | ||
5793b276 NB |
816 | case OPT_iprefix: |
817 | iprefix = arg; | |
818 | break; | |
819 | ||
4bed3787 | 820 | case OPT_iquote: |
b02398bd | 821 | add_path (xstrdup (arg), QUOTE, 0, true); |
4bed3787 MS |
822 | break; |
823 | ||
5793b276 NB |
824 | case OPT_isysroot: |
825 | sysroot = arg; | |
826 | break; | |
827 | ||
828 | case OPT_isystem: | |
b02398bd | 829 | add_path (xstrdup (arg), SYSTEM, 0, true); |
5793b276 NB |
830 | break; |
831 | ||
832 | case OPT_iwithprefix: | |
833 | add_prefixed_path (arg, SYSTEM); | |
834 | break; | |
835 | ||
836 | case OPT_iwithprefixbefore: | |
837 | add_prefixed_path (arg, BRACKET); | |
838 | break; | |
839 | ||
f749a36b NB |
840 | case OPT_lang_asm: |
841 | cpp_set_lang (parse_in, CLK_ASM); | |
170ea7b9 | 842 | cpp_opts->dollars_in_ident = false; |
f749a36b NB |
843 | break; |
844 | ||
4b7091eb | 845 | case OPT_nostdinc: |
5793b276 | 846 | std_inc = false; |
4b7091eb NB |
847 | break; |
848 | ||
fef3106c | 849 | case OPT_nostdinc__: |
5793b276 | 850 | std_cxx_inc = false; |
4b7091eb NB |
851 | break; |
852 | ||
b4a93904 | 853 | case OPT_o: |
76c3e73e NB |
854 | if (!out_fname) |
855 | out_fname = arg; | |
b4a93904 | 856 | else |
f75d3e11 | 857 | error ("output filename specified twice"); |
b4a93904 NB |
858 | break; |
859 | ||
18bdccaa NB |
860 | /* We need to handle the -pedantic switches here, rather than in |
861 | c_common_post_options, so that a subsequent -Wno-endif-labels | |
862 | is not overridden. */ | |
863 | case OPT_pedantic_errors: | |
18bdccaa NB |
864 | case OPT_pedantic: |
865 | cpp_opts->pedantic = 1; | |
866 | cpp_opts->warn_endif_labels = 1; | |
f4e9414e AO |
867 | if (warn_pointer_sign == -1) |
868 | warn_pointer_sign = 1; | |
89a42ac8 ZW |
869 | if (warn_overlength_strings == -1) |
870 | warn_overlength_strings = 1; | |
4003301d MLI |
871 | if (warn_main == -1) |
872 | warn_main = 2; | |
18bdccaa NB |
873 | break; |
874 | ||
0b6f2917 NB |
875 | case OPT_print_objc_runtime_info: |
876 | print_struct_values = 1; | |
877 | break; | |
878 | ||
3fd30b88 GK |
879 | case OPT_print_pch_checksum: |
880 | c_common_print_pch_checksum (stdout); | |
881 | exit_after_options = true; | |
882 | break; | |
883 | ||
b4a93904 NB |
884 | case OPT_remap: |
885 | cpp_opts->remap = 1; | |
0b6f2917 NB |
886 | break; |
887 | ||
fef3106c NB |
888 | case OPT_std_c__98: |
889 | case OPT_std_gnu__98: | |
69723be2 SB |
890 | if (!preprocessing_asm_p) |
891 | set_std_cxx98 (code == OPT_std_c__98 /* ISO */); | |
0b6f2917 NB |
892 | break; |
893 | ||
966541e3 DG |
894 | case OPT_std_c__0x: |
895 | case OPT_std_gnu__0x: | |
896 | if (!preprocessing_asm_p) | |
897 | set_std_cxx0x (code == OPT_std_c__0x /* ISO */); | |
898 | break; | |
899 | ||
0b6f2917 | 900 | case OPT_std_c89: |
7e1542b9 | 901 | case OPT_std_c90: |
0b6f2917 | 902 | case OPT_std_iso9899_1990: |
b4a93904 | 903 | case OPT_std_iso9899_199409: |
69723be2 SB |
904 | if (!preprocessing_asm_p) |
905 | set_std_c89 (code == OPT_std_iso9899_199409 /* c94 */, true /* ISO */); | |
f749a36b NB |
906 | break; |
907 | ||
908 | case OPT_std_gnu89: | |
7e1542b9 | 909 | case OPT_std_gnu90: |
69723be2 SB |
910 | if (!preprocessing_asm_p) |
911 | set_std_c89 (false /* c94 */, false /* ISO */); | |
0b6f2917 NB |
912 | break; |
913 | ||
914 | case OPT_std_c99: | |
915 | case OPT_std_c9x: | |
916 | case OPT_std_iso9899_1999: | |
917 | case OPT_std_iso9899_199x: | |
69723be2 SB |
918 | if (!preprocessing_asm_p) |
919 | set_std_c99 (true /* ISO */); | |
0b6f2917 NB |
920 | break; |
921 | ||
0b6f2917 NB |
922 | case OPT_std_gnu99: |
923 | case OPT_std_gnu9x: | |
69723be2 SB |
924 | if (!preprocessing_asm_p) |
925 | set_std_c99 (false /* ISO */); | |
0b6f2917 NB |
926 | break; |
927 | ||
2778d766 JM |
928 | case OPT_std_c1x: |
929 | if (!preprocessing_asm_p) | |
930 | set_std_c1x (true /* ISO */); | |
931 | break; | |
932 | ||
933 | case OPT_std_gnu1x: | |
934 | if (!preprocessing_asm_p) | |
935 | set_std_c1x (false /* ISO */); | |
936 | break; | |
937 | ||
4b7091eb NB |
938 | case OPT_trigraphs: |
939 | cpp_opts->trigraphs = 1; | |
940 | break; | |
941 | ||
942 | case OPT_traditional_cpp: | |
943 | cpp_opts->traditional = 1; | |
944 | break; | |
945 | ||
4b7091eb | 946 | case OPT_v: |
5793b276 | 947 | verbose = true; |
4b7091eb | 948 | break; |
bce08d50 L |
949 | |
950 | case OPT_Wabi: | |
951 | warn_psabi = value; | |
952 | break; | |
4b7091eb | 953 | } |
0b6f2917 | 954 | |
0b6f2917 NB |
955 | return result; |
956 | } | |
957 | ||
958 | /* Post-switch processing. */ | |
959 | bool | |
8e9ea4d7 | 960 | c_common_post_options (const char **pfilename) |
0b6f2917 | 961 | { |
8e9ea4d7 PB |
962 | struct cpp_callbacks *cb; |
963 | ||
460bd0e3 | 964 | /* Canonicalize the input and output filenames. */ |
d1bd0ded GK |
965 | if (in_fnames == NULL) |
966 | { | |
5d038c4c | 967 | in_fnames = XNEWVEC (const char *, 1); |
d1bd0ded GK |
968 | in_fnames[0] = ""; |
969 | } | |
970 | else if (strcmp (in_fnames[0], "-") == 0) | |
971 | in_fnames[0] = ""; | |
460bd0e3 | 972 | |
76c3e73e NB |
973 | if (out_fname == NULL || !strcmp (out_fname, "-")) |
974 | out_fname = ""; | |
975 | ||
cd79e210 | 976 | if (cpp_opts->deps.style == DEPS_NONE) |
76c3e73e NB |
977 | check_deps_environment_vars (); |
978 | ||
f4ff5a69 | 979 | handle_deferred_opts (); |
76c3e73e | 980 | |
f4ff5a69 | 981 | sanitize_cpp_opts (); |
460bd0e3 | 982 | |
2b6dd222 | 983 | register_include_chains (parse_in, sysroot, iprefix, imultilib, |
37fa72e9 | 984 | std_inc, std_cxx_inc && c_dialect_cxx (), verbose); |
5793b276 | 985 | |
c7b5e395 GK |
986 | #ifdef C_COMMON_OVERRIDE_OPTIONS |
987 | /* Some machines may reject certain combinations of C | |
988 | language-specific options. */ | |
989 | C_COMMON_OVERRIDE_OPTIONS; | |
990 | #endif | |
991 | ||
8ce94e44 JM |
992 | /* Excess precision other than "fast" requires front-end |
993 | support. */ | |
994 | if (c_dialect_cxx ()) | |
995 | { | |
996 | if (flag_excess_precision_cmdline == EXCESS_PRECISION_STANDARD | |
997 | && TARGET_FLT_EVAL_METHOD_NON_DEFAULT) | |
998 | sorry ("-fexcess-precision=standard for C++"); | |
999 | flag_excess_precision_cmdline = EXCESS_PRECISION_FAST; | |
1000 | } | |
1001 | else if (flag_excess_precision_cmdline == EXCESS_PRECISION_DEFAULT) | |
1002 | flag_excess_precision_cmdline = (flag_iso | |
1003 | ? EXCESS_PRECISION_STANDARD | |
1004 | : EXCESS_PRECISION_FAST); | |
1005 | ||
da1c7394 ILT |
1006 | /* By default we use C99 inline semantics in GNU99 or C99 mode. C99 |
1007 | inline semantics are not supported in GNU89 or C89 mode. */ | |
1008 | if (flag_gnu89_inline == -1) | |
1009 | flag_gnu89_inline = !flag_isoc99; | |
1010 | else if (!flag_gnu89_inline && !flag_isoc99) | |
1011 | error ("-fno-gnu89-inline is only supported in GNU99 or C99 mode"); | |
1012 | ||
093c7153 RH |
1013 | /* Default to ObjC sjlj exception handling if NeXT runtime. */ |
1014 | if (flag_objc_sjlj_exceptions < 0) | |
1015 | flag_objc_sjlj_exceptions = flag_next_runtime; | |
1016 | if (flag_objc_exceptions && !flag_objc_sjlj_exceptions) | |
1017 | flag_exceptions = 1; | |
1018 | ||
62a67c94 MLI |
1019 | /* -Wextra implies the following flags |
1020 | unless explicitly overridden. */ | |
f6aa72dd MLI |
1021 | if (warn_type_limits == -1) |
1022 | warn_type_limits = extra_warnings; | |
2b001724 MLI |
1023 | if (warn_clobbered == -1) |
1024 | warn_clobbered = extra_warnings; | |
b3b433c5 MLI |
1025 | if (warn_empty_body == -1) |
1026 | warn_empty_body = extra_warnings; | |
87f85ea0 ZW |
1027 | if (warn_sign_compare == -1) |
1028 | warn_sign_compare = extra_warnings; | |
eaac4679 RS |
1029 | if (warn_missing_field_initializers == -1) |
1030 | warn_missing_field_initializers = extra_warnings; | |
cb4af25a MLI |
1031 | if (warn_missing_parameter_type == -1) |
1032 | warn_missing_parameter_type = extra_warnings; | |
b1ed4cb4 MLI |
1033 | if (warn_old_style_declaration == -1) |
1034 | warn_old_style_declaration = extra_warnings; | |
7ed322d7 JM |
1035 | if (warn_override_init == -1) |
1036 | warn_override_init = extra_warnings; | |
5db2e9ca DK |
1037 | if (warn_ignored_qualifiers == -1) |
1038 | warn_ignored_qualifiers = extra_warnings; | |
87f85ea0 | 1039 | |
e4e624ab | 1040 | /* -Wpointer-sign is disabled by default, but it is enabled if any |
f4e9414e AO |
1041 | of -Wall or -pedantic are given. */ |
1042 | if (warn_pointer_sign == -1) | |
1043 | warn_pointer_sign = 0; | |
1044 | ||
027b740e MLI |
1045 | if (warn_strict_aliasing == -1) |
1046 | warn_strict_aliasing = 0; | |
1047 | if (warn_strict_overflow == -1) | |
1048 | warn_strict_overflow = 0; | |
e1b7793c ILT |
1049 | if (warn_jump_misses_init == -1) |
1050 | warn_jump_misses_init = 0; | |
027b740e | 1051 | |
89a42ac8 ZW |
1052 | /* -Woverlength-strings is off by default, but is enabled by -pedantic. |
1053 | It is never enabled in C++, as the minimum limit is not normative | |
1054 | in that standard. */ | |
1055 | if (warn_overlength_strings == -1 || c_dialect_cxx ()) | |
1056 | warn_overlength_strings = 0; | |
1057 | ||
4003301d MLI |
1058 | /* Wmain is enabled by default in C++ but not in C. */ |
1059 | /* Wmain is disabled by default for -ffreestanding (!flag_hosted), | |
1060 | even if -Wall was given (warn_main will be 2 if set by -Wall, 1 | |
1061 | if set by -Wmain). */ | |
1062 | if (warn_main == -1) | |
1063 | warn_main = (c_dialect_cxx () && flag_hosted) ? 1 : 0; | |
1064 | else if (warn_main == 2) | |
1065 | warn_main = flag_hosted ? 1 : 0; | |
1066 | ||
7060db96 MLI |
1067 | /* In C, -Wconversion enables -Wsign-conversion (unless disabled |
1068 | through -Wno-sign-conversion). While in C++, | |
1069 | -Wsign-conversion needs to be requested explicitly. */ | |
1070 | if (warn_sign_conversion == -1) | |
1071 | warn_sign_conversion = (c_dialect_cxx ()) ? 0 : warn_conversion; | |
1072 | ||
6866c6e8 ILT |
1073 | /* In C, -Wall and -Wc++-compat enable -Wenum-compare, which we do |
1074 | in c_common_handle_option; if it has not yet been set, it is | |
1075 | disabled by default. In C++, it is enabled by default. */ | |
1076 | if (warn_enum_compare == -1) | |
1077 | warn_enum_compare = c_dialect_cxx () ? 1 : 0; | |
1078 | ||
bee6fa6d AN |
1079 | /* -Wpacked-bitfield-compat is on by default for the C languages. The |
1080 | warning is issued in stor-layout.c which is not part of the front-end so | |
1081 | we need to selectively turn it on here. */ | |
1082 | if (warn_packed_bitfield_compat == -1) | |
1083 | warn_packed_bitfield_compat = 1; | |
9b439fe1 | 1084 | |
0b6f2917 NB |
1085 | /* Special format checking options don't work without -Wformat; warn if |
1086 | they are used. */ | |
44c21c7f DD |
1087 | if (!warn_format) |
1088 | { | |
1089 | warning (OPT_Wformat_y2k, | |
1090 | "-Wformat-y2k ignored without -Wformat"); | |
1091 | warning (OPT_Wformat_extra_args, | |
1092 | "-Wformat-extra-args ignored without -Wformat"); | |
1093 | warning (OPT_Wformat_zero_length, | |
1094 | "-Wformat-zero-length ignored without -Wformat"); | |
1095 | warning (OPT_Wformat_nonliteral, | |
1096 | "-Wformat-nonliteral ignored without -Wformat"); | |
ca178f85 BK |
1097 | warning (OPT_Wformat_contains_nul, |
1098 | "-Wformat-contains-nul ignored without -Wformat"); | |
44c21c7f DD |
1099 | warning (OPT_Wformat_security, |
1100 | "-Wformat-security ignored without -Wformat"); | |
44c21c7f | 1101 | } |
0b6f2917 | 1102 | |
3734d960 MLI |
1103 | if (warn_implicit == -1) |
1104 | warn_implicit = 0; | |
1105 | ||
1106 | if (warn_implicit_int == -1) | |
1107 | warn_implicit_int = 0; | |
1108 | ||
dc90f45b | 1109 | /* -Wimplicit-function-declaration is enabled by default for C99. */ |
b8698a0f | 1110 | if (warn_implicit_function_declaration == -1) |
dc90f45b | 1111 | warn_implicit_function_declaration = flag_isoc99; |
c7463669 | 1112 | |
beeffe36 DG |
1113 | /* If we're allowing C++0x constructs, don't warn about C++0x |
1114 | compatibility problems. */ | |
c1ae8be5 | 1115 | if (cxx_dialect == cxx0x) |
beeffe36 DG |
1116 | warn_cxx0x_compat = 0; |
1117 | ||
460bd0e3 NB |
1118 | if (flag_preprocess_only) |
1119 | { | |
63973df3 NB |
1120 | /* Open the output now. We must do so even if flag_no_output is |
1121 | on, because there may be other output than from the actual | |
1122 | preprocessing (e.g. from -dM). */ | |
1123 | if (out_fname[0] == '\0') | |
1124 | out_stream = stdout; | |
1125 | else | |
1126 | out_stream = fopen (out_fname, "w"); | |
1127 | ||
1128 | if (out_stream == NULL) | |
9d10c9a9 | 1129 | { |
fa6ef813 | 1130 | fatal_error ("opening output file %s: %m", out_fname); |
c366ade5 | 1131 | return false; |
9d10c9a9 | 1132 | } |
63973df3 | 1133 | |
d1bd0ded GK |
1134 | if (num_in_fnames > 1) |
1135 | error ("too many filenames given. Type %s --help for usage", | |
1136 | progname); | |
1137 | ||
9d10c9a9 | 1138 | init_pp_output (out_stream); |
460bd0e3 | 1139 | } |
9d10c9a9 NB |
1140 | else |
1141 | { | |
1142 | init_c_lex (); | |
460bd0e3 | 1143 | |
9d10c9a9 | 1144 | /* Yuk. WTF is this? I do know ObjC relies on it somewhere. */ |
3c20847b | 1145 | input_location = UNKNOWN_LOCATION; |
9d10c9a9 | 1146 | } |
63973df3 | 1147 | |
8e9ea4d7 PB |
1148 | cb = cpp_get_callbacks (parse_in); |
1149 | cb->file_change = cb_file_change; | |
1150 | cb->dir_change = cb_dir_change; | |
4169c321 | 1151 | cpp_post_options (parse_in); |
23345bbb | 1152 | |
3c20847b | 1153 | input_location = UNKNOWN_LOCATION; |
4bfec483 | 1154 | |
8e9ea4d7 PB |
1155 | *pfilename = this_input_filename |
1156 | = cpp_read_main_file (parse_in, in_fnames[0]); | |
540554f4 | 1157 | /* Don't do any compilation or preprocessing if there is no input file. */ |
8e9ea4d7 | 1158 | if (this_input_filename == NULL) |
540554f4 JW |
1159 | { |
1160 | errorcount++; | |
1161 | return false; | |
1162 | } | |
8e9ea4d7 | 1163 | |
8a4baa83 | 1164 | if (flag_working_directory |
3f75a254 | 1165 | && flag_preprocess_only && !flag_no_line_commands) |
8e9ea4d7 PB |
1166 | pp_dir_change (parse_in, get_src_pwd ()); |
1167 | ||
4bfec483 NB |
1168 | return flag_preprocess_only; |
1169 | } | |
1170 | ||
1171 | /* Front end initialization common to C, ObjC and C++. */ | |
1172 | bool | |
2f6e4e97 | 1173 | c_common_init (void) |
4bfec483 | 1174 | { |
4bfec483 NB |
1175 | /* Set up preprocessor arithmetic. Must be done after call to |
1176 | c_common_nodes_and_builtins for type nodes to be good. */ | |
1177 | cpp_opts->precision = TYPE_PRECISION (intmax_type_node); | |
1178 | cpp_opts->char_precision = TYPE_PRECISION (char_type_node); | |
1179 | cpp_opts->int_precision = TYPE_PRECISION (integer_type_node); | |
1180 | cpp_opts->wchar_precision = TYPE_PRECISION (wchar_type_node); | |
8df83eae | 1181 | cpp_opts->unsigned_wchar = TYPE_UNSIGNED (wchar_type_node); |
e6cc3a24 ZW |
1182 | cpp_opts->bytes_big_endian = BYTES_BIG_ENDIAN; |
1183 | ||
1184 | /* This can't happen until after wchar_precision and bytes_big_endian | |
1185 | are known. */ | |
1186 | cpp_init_iconv (parse_in); | |
460bd0e3 | 1187 | |
3fd30b88 GK |
1188 | if (version_flag) |
1189 | c_common_print_pch_checksum (stderr); | |
1190 | ||
a25a8f3b JJ |
1191 | /* Has to wait until now so that cpplib has its hash table. */ |
1192 | init_pragma (); | |
1193 | ||
9d10c9a9 NB |
1194 | if (flag_preprocess_only) |
1195 | { | |
8e9ea4d7 PB |
1196 | finish_options (); |
1197 | preprocess_file (parse_in); | |
4bfec483 | 1198 | return false; |
9d10c9a9 NB |
1199 | } |
1200 | ||
4bfec483 | 1201 | return true; |
76c3e73e NB |
1202 | } |
1203 | ||
d1bd0ded GK |
1204 | /* Initialize the integrated preprocessor after debug output has been |
1205 | initialized; loop over each input file. */ | |
23345bbb | 1206 | void |
f75fbaf7 | 1207 | c_common_parse_file (int set_yydebug) |
23345bbb | 1208 | { |
9affb2c7 ZW |
1209 | unsigned int i; |
1210 | ||
f75fbaf7 | 1211 | if (set_yydebug) |
566c6181 ZW |
1212 | switch (c_language) |
1213 | { | |
1214 | case clk_c: | |
1215 | warning(0, "The C parser does not support -dy, option ignored"); | |
1216 | break; | |
1217 | case clk_objc: | |
1218 | warning(0, | |
1219 | "The Objective-C parser does not support -dy, option ignored"); | |
1220 | break; | |
1221 | case clk_cxx: | |
1222 | warning(0, "The C++ parser does not support -dy, option ignored"); | |
1223 | break; | |
1224 | case clk_objcxx: | |
1225 | warning(0, | |
1226 | "The Objective-C++ parser does not support -dy, option ignored"); | |
1227 | break; | |
1228 | default: | |
1229 | gcc_unreachable (); | |
1230 | } | |
23345bbb | 1231 | |
9affb2c7 ZW |
1232 | i = 0; |
1233 | for (;;) | |
1234 | { | |
1235 | finish_options (); | |
1236 | pch_init (); | |
1237 | push_file_scope (); | |
1238 | c_parse_file (); | |
1239 | finish_file (); | |
1240 | pop_file_scope (); | |
9e9945c5 DB |
1241 | /* And end the main input file, if the debug writer wants it */ |
1242 | if (debug_hooks->start_end_main_source_file) | |
1243 | (*debug_hooks->end_source_file) (0); | |
9affb2c7 ZW |
1244 | if (++i >= num_in_fnames) |
1245 | break; | |
1246 | cpp_undef_all (parse_in); | |
97f6bd40 | 1247 | cpp_clear_file_cache (parse_in); |
9affb2c7 ZW |
1248 | this_input_filename |
1249 | = cpp_read_main_file (parse_in, in_fnames[i]); | |
1250 | /* If an input file is missing, abandon further compilation. | |
c22cacf3 | 1251 | cpplib has issued a diagnostic. */ |
9affb2c7 ZW |
1252 | if (!this_input_filename) |
1253 | break; | |
1254 | } | |
23345bbb NB |
1255 | } |
1256 | ||
76c3e73e NB |
1257 | /* Common finish hook for the C, ObjC and C++ front ends. */ |
1258 | void | |
2f6e4e97 | 1259 | c_common_finish (void) |
76c3e73e NB |
1260 | { |
1261 | FILE *deps_stream = NULL; | |
1262 | ||
148e4216 | 1263 | /* Don't write the deps file if there are errors. */ |
1da2ed5f | 1264 | if (cpp_opts->deps.style != DEPS_NONE && !seen_error ()) |
76c3e73e NB |
1265 | { |
1266 | /* If -M or -MM was seen without -MF, default output to the | |
1267 | output stream. */ | |
f4ff5a69 | 1268 | if (!deps_file) |
76c3e73e NB |
1269 | deps_stream = out_stream; |
1270 | else | |
1271 | { | |
f4ff5a69 | 1272 | deps_stream = fopen (deps_file, deps_append ? "a": "w"); |
76c3e73e | 1273 | if (!deps_stream) |
fa6ef813 | 1274 | fatal_error ("opening dependency file %s: %m", deps_file); |
76c3e73e NB |
1275 | } |
1276 | } | |
1277 | ||
1278 | /* For performance, avoid tearing down cpplib's internal structures | |
1279 | with cpp_destroy (). */ | |
148e4216 | 1280 | cpp_finish (parse_in, deps_stream); |
76c3e73e NB |
1281 | |
1282 | if (deps_stream && deps_stream != out_stream | |
1283 | && (ferror (deps_stream) || fclose (deps_stream))) | |
fa6ef813 | 1284 | fatal_error ("closing dependency file %s: %m", deps_file); |
76c3e73e NB |
1285 | |
1286 | if (out_stream && (ferror (out_stream) || fclose (out_stream))) | |
fa6ef813 | 1287 | fatal_error ("when writing output to %s: %m", out_fname); |
76c3e73e NB |
1288 | } |
1289 | ||
76c3e73e NB |
1290 | /* Either of two environment variables can specify output of |
1291 | dependencies. Their value is either "OUTPUT_FILE" or "OUTPUT_FILE | |
1292 | DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to | |
1293 | and DEPS_TARGET is the target to mention in the deps. They also | |
1294 | result in dependency information being appended to the output file | |
182d89a3 NB |
1295 | rather than overwriting it, and like Sun's compiler |
1296 | SUNPRO_DEPENDENCIES suppresses the dependency on the main file. */ | |
76c3e73e | 1297 | static void |
2f6e4e97 | 1298 | check_deps_environment_vars (void) |
76c3e73e NB |
1299 | { |
1300 | char *spec; | |
1301 | ||
1302 | GET_ENVIRONMENT (spec, "DEPENDENCIES_OUTPUT"); | |
1303 | if (spec) | |
f4ff5a69 | 1304 | cpp_opts->deps.style = DEPS_USER; |
76c3e73e NB |
1305 | else |
1306 | { | |
1307 | GET_ENVIRONMENT (spec, "SUNPRO_DEPENDENCIES"); | |
1308 | if (spec) | |
182d89a3 NB |
1309 | { |
1310 | cpp_opts->deps.style = DEPS_SYSTEM; | |
1311 | cpp_opts->deps.ignore_main_file = true; | |
1312 | } | |
76c3e73e NB |
1313 | } |
1314 | ||
1315 | if (spec) | |
1316 | { | |
1317 | /* Find the space before the DEPS_TARGET, if there is one. */ | |
1318 | char *s = strchr (spec, ' '); | |
1319 | if (s) | |
1320 | { | |
1321 | /* Let the caller perform MAKE quoting. */ | |
f4ff5a69 | 1322 | defer_opt (OPT_MT, s + 1); |
76c3e73e NB |
1323 | *s = '\0'; |
1324 | } | |
1325 | ||
1326 | /* Command line -MF overrides environment variables and default. */ | |
f4ff5a69 NB |
1327 | if (!deps_file) |
1328 | deps_file = spec; | |
76c3e73e | 1329 | |
f4ff5a69 | 1330 | deps_append = 1; |
1b3c8f46 | 1331 | deps_seen = true; |
f4ff5a69 NB |
1332 | } |
1333 | } | |
1334 | ||
1335 | /* Handle deferred command line switches. */ | |
1336 | static void | |
2f6e4e97 | 1337 | handle_deferred_opts (void) |
f4ff5a69 NB |
1338 | { |
1339 | size_t i; | |
c6e83800 ZW |
1340 | struct deps *deps; |
1341 | ||
1342 | /* Avoid allocating the deps buffer if we don't need it. | |
1343 | (This flag may be true without there having been -MT or -MQ | |
1344 | options, but we'll still need the deps buffer.) */ | |
1345 | if (!deps_seen) | |
1346 | return; | |
1347 | ||
1348 | deps = cpp_get_deps (parse_in); | |
f4ff5a69 NB |
1349 | |
1350 | for (i = 0; i < deferred_count; i++) | |
1351 | { | |
1352 | struct deferred_opt *opt = &deferred_opts[i]; | |
1353 | ||
c1bad961 | 1354 | if (opt->code == OPT_MT || opt->code == OPT_MQ) |
c6e83800 | 1355 | deps_add_target (deps, opt->arg, opt->code == OPT_MQ); |
f4ff5a69 | 1356 | } |
f4ff5a69 NB |
1357 | } |
1358 | ||
1359 | /* These settings are appropriate for GCC, but not necessarily so for | |
1360 | cpplib as a library. */ | |
1361 | static void | |
2f6e4e97 | 1362 | sanitize_cpp_opts (void) |
f4ff5a69 NB |
1363 | { |
1364 | /* If we don't know what style of dependencies to output, complain | |
1365 | if any other dependency switches have been given. */ | |
1366 | if (deps_seen && cpp_opts->deps.style == DEPS_NONE) | |
1367 | error ("to generate dependencies you must specify either -M or -MM"); | |
1368 | ||
1369 | /* -dM and dependencies suppress normal output; do it here so that | |
1370 | the last -d[MDN] switch overrides earlier ones. */ | |
63973df3 NB |
1371 | if (flag_dump_macros == 'M') |
1372 | flag_no_output = 1; | |
f4ff5a69 | 1373 | |
ccfc4c91 OW |
1374 | /* By default, -fdirectives-only implies -dD. This allows subsequent phases |
1375 | to perform proper macro expansion. */ | |
1376 | if (cpp_opts->directives_only && !cpp_opts->preprocessed && !flag_dump_macros) | |
1377 | flag_dump_macros = 'D'; | |
1378 | ||
f4ff5a69 NB |
1379 | /* Disable -dD, -dN and -dI if normal output is suppressed. Allow |
1380 | -dM since at least glibc relies on -M -dM to work. */ | |
6c6cfbfd | 1381 | /* Also, flag_no_output implies flag_no_line_commands, always. */ |
63973df3 | 1382 | if (flag_no_output) |
f4ff5a69 | 1383 | { |
63973df3 NB |
1384 | if (flag_dump_macros != 'M') |
1385 | flag_dump_macros = 0; | |
1386 | flag_dump_includes = 0; | |
f9c65623 | 1387 | flag_no_line_commands = 1; |
76c3e73e | 1388 | } |
4822e563 TT |
1389 | else if (cpp_opts->deps.missing_files) |
1390 | error ("-MG may only be used with -M or -MM"); | |
f4ff5a69 NB |
1391 | |
1392 | cpp_opts->unsigned_char = !flag_signed_char; | |
1393 | cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS; | |
1394 | ||
9c650d90 MLI |
1395 | /* Wlong-long is disabled by default. It is enabled by: |
1396 | [-pedantic | -Wtraditional] -std=[gnu|c]++98 ; or | |
b8698a0f | 1397 | [-pedantic | -Wtraditional] -std=non-c99 . |
9c650d90 MLI |
1398 | |
1399 | Either -Wlong-long or -Wno-long-long override any other settings. */ | |
1400 | if (warn_long_long == -1) | |
1401 | warn_long_long = ((pedantic || warn_traditional) | |
1402 | && (c_dialect_cxx () ? cxx_dialect == cxx98 : !flag_isoc99)); | |
1403 | cpp_opts->warn_long_long = warn_long_long; | |
b20d9f0c | 1404 | |
e5b79219 RH |
1405 | /* Similarly with -Wno-variadic-macros. No check for c99 here, since |
1406 | this also turns off warnings about GCCs extension. */ | |
1407 | cpp_opts->warn_variadic_macros | |
1408 | = warn_variadic_macros && (pedantic || warn_traditional); | |
1409 | ||
b20d9f0c AO |
1410 | /* If we're generating preprocessor output, emit current directory |
1411 | if explicitly requested or if debugging information is enabled. | |
1412 | ??? Maybe we should only do it for debugging formats that | |
1413 | actually output the current directory? */ | |
1414 | if (flag_working_directory == -1) | |
1415 | flag_working_directory = (debug_info_level != DINFO_LEVEL_NONE); | |
ccfc4c91 OW |
1416 | |
1417 | if (cpp_opts->directives_only) | |
1418 | { | |
1419 | if (warn_unused_macros) | |
1420 | error ("-fdirectives-only is incompatible with -Wunused_macros"); | |
1421 | if (cpp_opts->traditional) | |
1422 | error ("-fdirectives-only is incompatible with -traditional"); | |
1423 | } | |
f4ff5a69 NB |
1424 | } |
1425 | ||
5793b276 NB |
1426 | /* Add include path with a prefix at the front of its name. */ |
1427 | static void | |
2f6e4e97 | 1428 | add_prefixed_path (const char *suffix, size_t chain) |
5793b276 | 1429 | { |
52999738 | 1430 | char *path; |
5793b276 | 1431 | const char *prefix; |
52999738 | 1432 | size_t prefix_len, suffix_len; |
5793b276 | 1433 | |
52999738 ZW |
1434 | suffix_len = strlen (suffix); |
1435 | prefix = iprefix ? iprefix : cpp_GCC_INCLUDE_DIR; | |
1436 | prefix_len = iprefix ? strlen (iprefix) : cpp_GCC_INCLUDE_DIR_len; | |
1437 | ||
5d038c4c | 1438 | path = (char *) xmalloc (prefix_len + suffix_len + 1); |
52999738 ZW |
1439 | memcpy (path, prefix, prefix_len); |
1440 | memcpy (path + prefix_len, suffix, suffix_len); | |
1441 | path[prefix_len + suffix_len] = '\0'; | |
1442 | ||
b02398bd | 1443 | add_path (path, chain, 0, false); |
5793b276 NB |
1444 | } |
1445 | ||
8e9ea4d7 PB |
1446 | /* Handle -D, -U, -A, -imacros, and the first -include. */ |
1447 | static void | |
1448 | finish_options (void) | |
255c10b1 | 1449 | { |
255c10b1 NB |
1450 | if (!cpp_opts->preprocessed) |
1451 | { | |
c1bad961 NB |
1452 | size_t i; |
1453 | ||
1fb2fbeb | 1454 | cb_file_change (parse_in, |
5ffeb913 | 1455 | linemap_add (line_table, LC_RENAME, 0, |
1fb2fbeb PB |
1456 | _("<built-in>"), 0)); |
1457 | ||
6e270179 | 1458 | cpp_init_builtins (parse_in, flag_hosted); |
c1bad961 | 1459 | c_cpp_builtins (parse_in); |
78b8811a HPN |
1460 | |
1461 | /* We're about to send user input to cpplib, so make it warn for | |
1462 | things that we previously (when we sent it internal definitions) | |
1463 | told it to not warn. | |
1464 | ||
1465 | C99 permits implementation-defined characters in identifiers. | |
1466 | The documented meaning of -std= is to turn off extensions that | |
1467 | conflict with the specified standard, and since a strictly | |
1468 | conforming program cannot contain a '$', we do not condition | |
1469 | their acceptance on the -std= setting. */ | |
1470 | cpp_opts->warn_dollars = (cpp_opts->pedantic && !cpp_opts->c99); | |
1471 | ||
112598f4 | 1472 | cb_file_change (parse_in, |
5ffeb913 | 1473 | linemap_add (line_table, LC_RENAME, 0, |
112598f4 PB |
1474 | _("<command-line>"), 0)); |
1475 | ||
c1bad961 NB |
1476 | for (i = 0; i < deferred_count; i++) |
1477 | { | |
1478 | struct deferred_opt *opt = &deferred_opts[i]; | |
1479 | ||
1480 | if (opt->code == OPT_D) | |
1481 | cpp_define (parse_in, opt->arg); | |
1482 | else if (opt->code == OPT_U) | |
1483 | cpp_undef (parse_in, opt->arg); | |
1484 | else if (opt->code == OPT_A) | |
1485 | { | |
1486 | if (opt->arg[0] == '-') | |
1487 | cpp_unassert (parse_in, opt->arg + 1); | |
1488 | else | |
1489 | cpp_assert (parse_in, opt->arg); | |
1490 | } | |
1491 | } | |
255c10b1 | 1492 | |
9d000e83 JJ |
1493 | /* Start the main input file, if the debug writer wants it. */ |
1494 | if (debug_hooks->start_end_main_source_file | |
1495 | && !flag_preprocess_only) | |
1496 | (*debug_hooks->start_source_file) (0, this_input_filename); | |
1497 | ||
c1bad961 | 1498 | /* Handle -imacros after -D and -U. */ |
255c10b1 NB |
1499 | for (i = 0; i < deferred_count; i++) |
1500 | { | |
1501 | struct deferred_opt *opt = &deferred_opts[i]; | |
1502 | ||
1503 | if (opt->code == OPT_imacros | |
1504 | && cpp_push_include (parse_in, opt->arg)) | |
9b49a0aa | 1505 | { |
6614fd40 | 1506 | /* Disable push_command_line_include callback for now. */ |
9b49a0aa PB |
1507 | include_cursor = deferred_count + 1; |
1508 | cpp_scan_nooutput (parse_in); | |
1509 | } | |
255c10b1 NB |
1510 | } |
1511 | } | |
9d000e83 JJ |
1512 | else |
1513 | { | |
1514 | if (cpp_opts->directives_only) | |
1515 | cpp_init_special_builtins (parse_in); | |
1516 | ||
1517 | /* Start the main input file, if the debug writer wants it. */ | |
1518 | if (debug_hooks->start_end_main_source_file | |
1519 | && !flag_preprocess_only) | |
1520 | (*debug_hooks->start_source_file) (0, this_input_filename); | |
1521 | } | |
255c10b1 | 1522 | |
e6ebd07b | 1523 | include_cursor = 0; |
255c10b1 NB |
1524 | push_command_line_include (); |
1525 | } | |
1526 | ||
23345bbb NB |
1527 | /* Give CPP the next file given by -include, if any. */ |
1528 | static void | |
2f6e4e97 | 1529 | push_command_line_include (void) |
23345bbb | 1530 | { |
23345bbb NB |
1531 | while (include_cursor < deferred_count) |
1532 | { | |
1533 | struct deferred_opt *opt = &deferred_opts[include_cursor++]; | |
2f6e4e97 | 1534 | |
3f75a254 | 1535 | if (!cpp_opts->preprocessed && opt->code == OPT_include |
31703a61 | 1536 | && cpp_push_include (parse_in, opt->arg)) |
23345bbb NB |
1537 | return; |
1538 | } | |
1539 | ||
1540 | if (include_cursor == deferred_count) | |
1541 | { | |
31703a61 | 1542 | include_cursor++; |
23345bbb NB |
1543 | /* -Wunused-macros should only warn about macros defined hereafter. */ |
1544 | cpp_opts->warn_unused_macros = warn_unused_macros; | |
8e9ea4d7 | 1545 | /* Restore the line map from <command line>. */ |
3f75a254 | 1546 | if (!cpp_opts->preprocessed) |
3e6da82b | 1547 | cpp_change_file (parse_in, LC_RENAME, this_input_filename); |
8e9ea4d7 PB |
1548 | |
1549 | /* Set this here so the client can change the option if it wishes, | |
1550 | and after stacking the main file so we don't trace the main file. */ | |
5ffeb913 | 1551 | line_table->trace_includes = cpp_opts->print_include_names; |
23345bbb NB |
1552 | } |
1553 | } | |
1554 | ||
1555 | /* File change callback. Has to handle -include files. */ | |
1556 | static void | |
e18476eb | 1557 | cb_file_change (cpp_reader * ARG_UNUSED (pfile), |
2f6e4e97 | 1558 | const struct line_map *new_map) |
23345bbb NB |
1559 | { |
1560 | if (flag_preprocess_only) | |
1561 | pp_file_change (new_map); | |
1562 | else | |
1563 | fe_file_change (new_map); | |
1564 | ||
31703a61 | 1565 | if (new_map == 0 || (new_map->reason == LC_LEAVE && MAIN_FILE_P (new_map))) |
23345bbb NB |
1566 | push_command_line_include (); |
1567 | } | |
1568 | ||
8e9ea4d7 | 1569 | void |
e18476eb | 1570 | cb_dir_change (cpp_reader * ARG_UNUSED (pfile), const char *dir) |
8e9ea4d7 | 1571 | { |
3f75a254 | 1572 | if (!set_src_pwd (dir)) |
d4ee4d25 | 1573 | warning (0, "too late for # directive to set debug directory"); |
8e9ea4d7 PB |
1574 | } |
1575 | ||
f4ff5a69 NB |
1576 | /* Set the C 89 standard (with 1994 amendments if C94, without GNU |
1577 | extensions if ISO). There is no concept of gnu94. */ | |
1578 | static void | |
2f6e4e97 | 1579 | set_std_c89 (int c94, int iso) |
f4ff5a69 NB |
1580 | { |
1581 | cpp_set_lang (parse_in, c94 ? CLK_STDC94: iso ? CLK_STDC89: CLK_GNUC89); | |
1582 | flag_iso = iso; | |
1583 | flag_no_asm = iso; | |
1584 | flag_no_gnu_keywords = iso; | |
1585 | flag_no_nonansi_builtin = iso; | |
f4ff5a69 NB |
1586 | flag_isoc94 = c94; |
1587 | flag_isoc99 = 0; | |
2778d766 | 1588 | flag_isoc1x = 0; |
76c3e73e NB |
1589 | } |
1590 | ||
b4a93904 NB |
1591 | /* Set the C 99 standard (without GNU extensions if ISO). */ |
1592 | static void | |
2f6e4e97 | 1593 | set_std_c99 (int iso) |
b4a93904 NB |
1594 | { |
1595 | cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99); | |
1596 | flag_no_asm = iso; | |
1597 | flag_no_nonansi_builtin = iso; | |
b4a93904 | 1598 | flag_iso = iso; |
2778d766 JM |
1599 | flag_isoc1x = 0; |
1600 | flag_isoc99 = 1; | |
1601 | flag_isoc94 = 1; | |
1602 | } | |
1603 | ||
1604 | /* Set the C 1X standard draft (without GNU extensions if ISO). */ | |
1605 | static void | |
1606 | set_std_c1x (int iso) | |
1607 | { | |
1608 | cpp_set_lang (parse_in, iso ? CLK_STDC1X: CLK_GNUC1X); | |
1609 | flag_no_asm = iso; | |
1610 | flag_no_nonansi_builtin = iso; | |
1611 | flag_iso = iso; | |
1612 | flag_isoc1x = 1; | |
b4a93904 NB |
1613 | flag_isoc99 = 1; |
1614 | flag_isoc94 = 1; | |
b4a93904 NB |
1615 | } |
1616 | ||
f749a36b NB |
1617 | /* Set the C++ 98 standard (without GNU extensions if ISO). */ |
1618 | static void | |
2f6e4e97 | 1619 | set_std_cxx98 (int iso) |
f749a36b NB |
1620 | { |
1621 | cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX); | |
1622 | flag_no_gnu_keywords = iso; | |
1623 | flag_no_nonansi_builtin = iso; | |
f749a36b | 1624 | flag_iso = iso; |
c1ae8be5 | 1625 | cxx_dialect = cxx98; |
f749a36b NB |
1626 | } |
1627 | ||
966541e3 DG |
1628 | /* Set the C++ 0x working draft "standard" (without GNU extensions if ISO). */ |
1629 | static void | |
1630 | set_std_cxx0x (int iso) | |
1631 | { | |
1632 | cpp_set_lang (parse_in, iso ? CLK_CXX0X: CLK_GNUCXX0X); | |
1633 | flag_no_gnu_keywords = iso; | |
1634 | flag_no_nonansi_builtin = iso; | |
1635 | flag_iso = iso; | |
c1ae8be5 | 1636 | cxx_dialect = cxx0x; |
966541e3 DG |
1637 | } |
1638 | ||
4b7091eb | 1639 | /* Args to -d specify what to dump. Silently ignore |
05713b80 | 1640 | unrecognized options; they may be aimed at toplev.c. */ |
0b6f2917 | 1641 | static void |
2f6e4e97 | 1642 | handle_OPT_d (const char *arg) |
0b6f2917 | 1643 | { |
4b7091eb NB |
1644 | char c; |
1645 | ||
1646 | while ((c = *arg++) != '\0') | |
1647 | switch (c) | |
1648 | { | |
63973df3 NB |
1649 | case 'M': /* Dump macros only. */ |
1650 | case 'N': /* Dump names. */ | |
1651 | case 'D': /* Dump definitions. */ | |
93d45d9e | 1652 | case 'U': /* Dump used macros. */ |
63973df3 | 1653 | flag_dump_macros = c; |
4b7091eb NB |
1654 | break; |
1655 | ||
1656 | case 'I': | |
63973df3 | 1657 | flag_dump_includes = 1; |
4b7091eb NB |
1658 | break; |
1659 | } | |
0b6f2917 | 1660 | } |