|
0
|
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 }
|
