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