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