]>
Commit | Line | Data |
---|---|---|
428a5a4e | 1 | /* C/ObjC/C++ command line option handling. |
8d67b0c7 | 2 | Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 |
add6ee5e | 3 | Free Software Foundation, Inc. |
428a5a4e | 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 | |
8c4c00c1 | 10 | Software Foundation; either version 3, or (at your option) any later |
428a5a4e | 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 | |
8c4c00c1 | 19 | along with GCC; see the file COPYING3. If not see |
20 | <http://www.gnu.org/licenses/>. */ | |
428a5a4e | 21 | |
22 | #include "config.h" | |
23 | #include "system.h" | |
805e22b2 | 24 | #include "coretypes.h" |
428a5a4e | 25 | #include "tree.h" |
26 | #include "c-common.h" | |
27 | #include "c-pragma.h" | |
28 | #include "flags.h" | |
29 | #include "toplev.h" | |
30 | #include "langhooks.h" | |
428a5a4e | 31 | #include "diagnostic.h" |
45c365b1 | 32 | #include "intl.h" |
e69f4d0e | 33 | #include "cppdefault.h" |
2ecc6bc5 | 34 | #include "incpath.h" |
b717e161 | 35 | #include "debug.h" /* For debug_hooks. */ |
5457b645 | 36 | #include "opts.h" |
3272db82 | 37 | #include "options.h" |
3eb3f293 | 38 | #include "mkdeps.h" |
c94b1d0e | 39 | #include "c-target.h" |
40 | #include "tm.h" /* For BYTES_BIG_ENDIAN, | |
41 | DOLLARS_IN_IDENTIFIERS, | |
42 | STDC_0_IN_SYSTEM_HEADERS, | |
43 | TARGET_FLT_EVAL_METHOD_NON_DEFAULT and | |
44 | TARGET_OPTF. */ | |
9e7c2572 | 45 | #include "tm_p.h" /* For C_COMMON_OVERRIDE_OPTIONS. */ |
e69f4d0e | 46 | |
14e33bb6 | 47 | #ifndef DOLLARS_IN_IDENTIFIERS |
48 | # define DOLLARS_IN_IDENTIFIERS true | |
49 | #endif | |
50 | ||
e69f4d0e | 51 | #ifndef TARGET_SYSTEM_ROOT |
52 | # define TARGET_SYSTEM_ROOT NULL | |
53 | #endif | |
428a5a4e | 54 | |
d6f6a4e9 | 55 | #ifndef TARGET_OPTF |
56 | #define TARGET_OPTF(ARG) | |
57 | #endif | |
58 | ||
61191376 | 59 | /* CPP's options. */ |
caefd295 | 60 | cpp_options *cpp_opts; |
72db3845 | 61 | |
79cf3ec1 | 62 | /* Input filename. */ |
9f8e7348 | 63 | static const char *this_input_filename; |
79cf3ec1 | 64 | |
6019c708 | 65 | /* Filename and stream for preprocessed output. */ |
66 | static const char *out_fname; | |
67 | static FILE *out_stream; | |
68 | ||
69 | /* Append dependencies to deps_file. */ | |
70 | static bool deps_append; | |
71 | ||
61191376 | 72 | /* If dependency switches (-MF etc.) have been given. */ |
73 | static bool deps_seen; | |
74 | ||
e69f4d0e | 75 | /* If -v seen. */ |
76 | static bool verbose; | |
77 | ||
61191376 | 78 | /* Dependency output file. */ |
79 | static const char *deps_file; | |
80 | ||
e69f4d0e | 81 | /* The prefix given by -iprefix, if any. */ |
82 | static const char *iprefix; | |
83 | ||
72779020 | 84 | /* The multilib directory given by -imultilib, if any. */ |
85 | static const char *imultilib; | |
86 | ||
e69f4d0e | 87 | /* The system root, if any. Overridden by -isysroot. */ |
88 | static const char *sysroot = TARGET_SYSTEM_ROOT; | |
89 | ||
90 | /* Zero disables all standard directories for headers. */ | |
91 | static bool std_inc = true; | |
92 | ||
93 | /* Zero disables the C++-specific standard directories for headers. */ | |
94 | static bool std_cxx_inc = true; | |
95 | ||
96 | /* If the quote chain has been split by -I-. */ | |
97 | static bool quote_chain_split; | |
98 | ||
b717e161 | 99 | /* If -Wunused-macros. */ |
100 | static bool warn_unused_macros; | |
101 | ||
05d51900 | 102 | /* If -Wvariadic-macros. */ |
103 | static bool warn_variadic_macros = true; | |
104 | ||
4838a8b6 | 105 | /* Number of deferred options. */ |
106 | static size_t deferred_count; | |
61191376 | 107 | |
b717e161 | 108 | /* Number of deferred options scanned for -include. */ |
109 | static size_t include_cursor; | |
110 | ||
2b30d46c | 111 | static void handle_OPT_d (const char *); |
112 | static void set_std_cxx98 (int); | |
0d84dc2d | 113 | static void set_std_cxx11 (int); |
543efdbe | 114 | static void set_std_cxx1y (int); |
2b30d46c | 115 | static void set_std_c89 (int, int); |
116 | static void set_std_c99 (int); | |
32074525 | 117 | static void set_std_c11 (int); |
2b30d46c | 118 | static void check_deps_environment_vars (void); |
119 | static void handle_deferred_opts (void); | |
120 | static void sanitize_cpp_opts (void); | |
121 | static void add_prefixed_path (const char *, size_t); | |
122 | static void push_command_line_include (void); | |
123 | static void cb_file_change (cpp_reader *, const struct line_map *); | |
d732fcf0 | 124 | static void cb_dir_change (cpp_reader *, const char *); |
79396169 | 125 | static void c_finish_options (void); |
79cf3ec1 | 126 | |
127 | #ifndef STDC_0_IN_SYSTEM_HEADERS | |
128 | #define STDC_0_IN_SYSTEM_HEADERS 0 | |
129 | #endif | |
428a5a4e | 130 | |
5457b645 | 131 | /* Holds switches parsed by c_common_handle_option (), but whose |
d716ce75 | 132 | handling is deferred to c_common_post_options (). */ |
2b30d46c | 133 | static void defer_opt (enum opt_code, const char *); |
61191376 | 134 | static struct deferred_opt |
135 | { | |
136 | enum opt_code code; | |
137 | const char *arg; | |
138 | } *deferred_opts; | |
139 | ||
1f3db819 | 140 | |
c123f04d | 141 | extern const unsigned int |
1f3db819 | 142 | c_family_lang_mask = (CL_C | CL_CXX | CL_ObjC | CL_ObjCXX); |
143 | ||
61191376 | 144 | /* Defer option CODE with argument ARG. */ |
145 | static void | |
2b30d46c | 146 | defer_opt (enum opt_code code, const char *arg) |
61191376 | 147 | { |
61191376 | 148 | deferred_opts[deferred_count].code = code; |
149 | deferred_opts[deferred_count].arg = arg; | |
150 | deferred_count++; | |
151 | } | |
152 | ||
e88d34f6 | 153 | /* Return language mask for option parsing. */ |
4838a8b6 | 154 | unsigned int |
e88d34f6 | 155 | c_common_option_lang_mask (void) |
428a5a4e | 156 | { |
4838a8b6 | 157 | static const unsigned int lang_flags[] = {CL_C, CL_ObjC, CL_CXX, CL_ObjCXX}; |
c0f19401 | 158 | |
e88d34f6 | 159 | return lang_flags[c_language]; |
160 | } | |
161 | ||
162 | /* Common diagnostics initialization. */ | |
163 | void | |
164 | c_common_initialize_diagnostics (diagnostic_context *context) | |
165 | { | |
c0f19401 | 166 | /* This is conditionalized only because that is the way the front |
167 | ends used to do it. Maybe this should be unconditional? */ | |
168 | if (c_dialect_cxx ()) | |
169 | { | |
170 | /* By default wrap lines at 80 characters. Is getenv | |
171 | ("COLUMNS") preferable? */ | |
e88d34f6 | 172 | diagnostic_line_cutoff (context) = 80; |
c0f19401 | 173 | /* By default, emit location information once for every |
174 | diagnostic message. */ | |
e88d34f6 | 175 | diagnostic_prefixing_rule (context) = DIAGNOSTICS_SHOW_PREFIX_ONCE; |
c0f19401 | 176 | } |
177 | ||
e88d34f6 | 178 | context->opt_permissive = OPT_fpermissive; |
179 | } | |
180 | ||
181 | /* Whether options from all C-family languages should be accepted | |
182 | quietly. */ | |
183 | static bool accept_all_c_family_options = false; | |
184 | ||
185 | /* Return whether to complain about a wrong-language option. */ | |
186 | bool | |
187 | c_common_complain_wrong_lang_p (const struct cl_option *option) | |
188 | { | |
189 | if (accept_all_c_family_options | |
190 | && (option->flags & c_family_lang_mask)) | |
191 | return false; | |
192 | ||
193 | return true; | |
194 | } | |
195 | ||
f3f006ad | 196 | /* Initialize options structure OPTS. */ |
197 | void | |
198 | c_common_init_options_struct (struct gcc_options *opts) | |
199 | { | |
200 | opts->x_flag_exceptions = c_dialect_cxx (); | |
201 | opts->x_warn_pointer_arith = c_dialect_cxx (); | |
202 | opts->x_warn_write_strings = c_dialect_cxx (); | |
203 | opts->x_flag_warn_unused_result = true; | |
204 | ||
205 | /* By default, C99-like requirements for complex multiply and divide. */ | |
206 | opts->x_flag_complex_method = 2; | |
207 | } | |
208 | ||
e88d34f6 | 209 | /* Common initialization before calling option handlers. */ |
210 | void | |
211 | c_common_init_options (unsigned int decoded_options_count, | |
212 | struct cl_decoded_option *decoded_options) | |
213 | { | |
214 | unsigned int i; | |
215 | struct cpp_callbacks *cb; | |
3c6a9715 | 216 | |
c0f19401 | 217 | parse_in = cpp_create_reader (c_dialect_cxx () ? CLK_GNUCXX: CLK_GNUC89, |
931b0a0f | 218 | ident_hash, line_table); |
7f5f3953 | 219 | cb = cpp_get_callbacks (parse_in); |
220 | cb->error = c_cpp_error; | |
c0f19401 | 221 | |
72db3845 | 222 | cpp_opts = cpp_get_options (parse_in); |
14e33bb6 | 223 | cpp_opts->dollars_in_ident = DOLLARS_IN_IDENTIFIERS; |
c0f19401 | 224 | cpp_opts->objc = c_dialect_objc (); |
f0c2775b | 225 | |
226 | /* Reset to avoid warnings on internal definitions. We set it just | |
227 | before passing on command-line options to cpplib. */ | |
228 | cpp_opts->warn_dollars = 0; | |
229 | ||
e88d34f6 | 230 | deferred_opts = XNEWVEC (struct deferred_opt, decoded_options_count); |
b95a705c | 231 | |
9278f8d3 | 232 | if (c_language == clk_c) |
b95a705c | 233 | { |
9278f8d3 | 234 | /* If preprocessing assembly language, accept any of the C-family |
235 | front end options since the driver may pass them through. */ | |
e88d34f6 | 236 | for (i = 1; i < decoded_options_count; i++) |
237 | if (decoded_options[i].opt_index == OPT_lang_asm) | |
9278f8d3 | 238 | { |
e88d34f6 | 239 | accept_all_c_family_options = true; |
9278f8d3 | 240 | break; |
241 | } | |
b95a705c | 242 | } |
428a5a4e | 243 | } |
244 | ||
e7aa92b2 | 245 | /* Handle switch SCODE with argument ARG. VALUE is true, unless no- |
b78351e5 | 246 | form of an -f or -W option was given. Returns false if the switch was |
247 | invalid, true if valid. Use HANDLERS in recursive handle_option calls. */ | |
248 | bool | |
1f3db819 | 249 | c_common_handle_option (size_t scode, const char *arg, int value, |
3c6c0e40 | 250 | int kind, location_t loc, |
251 | const struct cl_option_handlers *handlers) | |
428a5a4e | 252 | { |
5457b645 | 253 | const struct cl_option *option = &cl_options[scode]; |
254 | enum opt_code code = (enum opt_code) scode; | |
b78351e5 | 255 | bool result = true; |
5457b645 | 256 | |
bc7ab021 | 257 | /* Prevent resetting the language standard to a C dialect when the driver |
258 | has already determined that we're looking at assembler input. */ | |
259 | bool preprocessing_asm_p = (cpp_get_options (parse_in)->lang == CLK_ASM); | |
48e1416a | 260 | |
803894d2 | 261 | switch (code) |
428a5a4e | 262 | { |
5457b645 | 263 | default: |
1f3db819 | 264 | if (cl_options[code].flags & c_family_lang_mask) |
b9fc964a | 265 | { |
266 | if ((option->flags & CL_TARGET) | |
267 | && ! targetcm.handle_c_option (scode, arg, value)) | |
b78351e5 | 268 | result = false; |
b9fc964a | 269 | break; |
270 | } | |
b78351e5 | 271 | result = false; |
b95a705c | 272 | break; |
428a5a4e | 273 | |
803894d2 | 274 | case OPT__output_pch_: |
573aba85 | 275 | pch_file = arg; |
276 | break; | |
277 | ||
fc3c7720 | 278 | case OPT_A: |
279 | defer_opt (code, arg); | |
280 | break; | |
281 | ||
45c365b1 | 282 | case OPT_C: |
283 | cpp_opts->discard_comments = 0; | |
284 | break; | |
285 | ||
286 | case OPT_CC: | |
287 | cpp_opts->discard_comments = 0; | |
288 | cpp_opts->discard_comments_in_macro_exp = 0; | |
289 | break; | |
290 | ||
fc3c7720 | 291 | case OPT_D: |
292 | defer_opt (code, arg); | |
293 | break; | |
294 | ||
45c365b1 | 295 | case OPT_H: |
296 | cpp_opts->print_include_names = 1; | |
297 | break; | |
298 | ||
065e625b | 299 | case OPT_F: |
300 | TARGET_OPTF (xstrdup (arg)); | |
301 | break; | |
302 | ||
e69f4d0e | 303 | case OPT_I: |
304 | if (strcmp (arg, "-")) | |
06fd18c9 | 305 | add_path (xstrdup (arg), BRACKET, 0, true); |
e69f4d0e | 306 | else |
307 | { | |
308 | if (quote_chain_split) | |
309 | error ("-I- specified twice"); | |
310 | quote_chain_split = true; | |
311 | split_quote_chain (); | |
5bcc316e | 312 | inform (input_location, "obsolete option -I- used, please use -iquote instead"); |
e69f4d0e | 313 | } |
314 | break; | |
315 | ||
61191376 | 316 | case OPT_M: |
317 | case OPT_MM: | |
318 | /* When doing dependencies with -M or -MM, suppress normal | |
319 | preprocessed output, but still do -dM etc. as software | |
320 | depends on this. Preprocessed output does occur if -MD, -MMD | |
321 | or environment var dependency generation is used. */ | |
322 | cpp_opts->deps.style = (code == OPT_M ? DEPS_SYSTEM: DEPS_USER); | |
f7070933 | 323 | flag_no_output = 1; |
61191376 | 324 | break; |
325 | ||
89c69892 | 326 | case OPT_MD: |
327 | case OPT_MMD: | |
328 | cpp_opts->deps.style = (code == OPT_MD ? DEPS_SYSTEM: DEPS_USER); | |
c25f2689 | 329 | cpp_opts->deps.need_preprocessor_output = true; |
61191376 | 330 | deps_file = arg; |
331 | break; | |
332 | ||
333 | case OPT_MF: | |
334 | deps_seen = true; | |
335 | deps_file = arg; | |
336 | break; | |
337 | ||
338 | case OPT_MG: | |
339 | deps_seen = true; | |
340 | cpp_opts->deps.missing_files = true; | |
341 | break; | |
342 | ||
343 | case OPT_MP: | |
344 | deps_seen = true; | |
345 | cpp_opts->deps.phony_targets = true; | |
346 | break; | |
347 | ||
348 | case OPT_MQ: | |
349 | case OPT_MT: | |
350 | deps_seen = true; | |
351 | defer_opt (code, arg); | |
352 | break; | |
353 | ||
45c365b1 | 354 | case OPT_P: |
f7070933 | 355 | flag_no_line_commands = 1; |
45c365b1 | 356 | break; |
357 | ||
fc3c7720 | 358 | case OPT_U: |
359 | defer_opt (code, arg); | |
360 | break; | |
361 | ||
428a5a4e | 362 | case OPT_Wall: |
fbb6fbd8 | 363 | handle_generated_option (&global_options, &global_options_set, |
364 | OPT_Wunused, NULL, value, | |
365 | c_family_lang_mask, kind, loc, | |
366 | handlers, global_dc); | |
837277ab | 367 | set_Wformat (value); |
f83b64ca | 368 | handle_generated_option (&global_options, &global_options_set, |
369 | OPT_Wimplicit, NULL, value, | |
3c6c0e40 | 370 | c_family_lang_mask, kind, loc, |
371 | handlers, global_dc); | |
837277ab | 372 | warn_char_subscripts = value; |
373 | warn_missing_braces = value; | |
374 | warn_parentheses = value; | |
375 | warn_return_type = value; | |
376 | warn_sequence_point = value; /* Was C only. */ | |
837277ab | 377 | warn_switch = value; |
a54ab330 | 378 | if (warn_strict_aliasing == -1) |
6bd9d862 | 379 | set_Wstrict_aliasing (&global_options, value); |
ede5a481 | 380 | warn_address = value; |
a54ab330 | 381 | if (warn_strict_overflow == -1) |
382 | warn_strict_overflow = value; | |
5bc96398 | 383 | warn_array_bounds = value; |
75130fc7 | 384 | warn_volatile_register_var = value; |
2b30d46c | 385 | |
428a5a4e | 386 | /* Only warn about unknown pragmas that are not in system |
2b30d46c | 387 | headers. */ |
837277ab | 388 | warn_unknown_pragmas = value; |
428a5a4e | 389 | |
a0ded67b | 390 | warn_uninitialized = value; |
8c3e8d68 | 391 | warn_maybe_uninitialized = value; |
428a5a4e | 392 | |
c0f19401 | 393 | if (!c_dialect_cxx ()) |
23efcc02 | 394 | { |
395 | /* We set this to 2 here, but 1 in -Wmain, so -ffreestanding | |
396 | can turn it off only if it's not explicit. */ | |
397 | if (warn_main == -1) | |
398 | warn_main = (value ? 2 : 0); | |
841fdaa6 | 399 | |
d3b7ee7c | 400 | /* In C, -Wall and -Wc++-compat turns on -Wenum-compare, |
401 | which we do here. In C++ it is on by default, which is | |
402 | done in c_common_post_options. */ | |
841fdaa6 | 403 | if (warn_enum_compare == -1) |
404 | warn_enum_compare = value; | |
23efcc02 | 405 | } |
428a5a4e | 406 | else |
407 | { | |
408 | /* C++-specific warnings. */ | |
410b80b2 | 409 | warn_sign_compare = value; |
7e783eb3 | 410 | warn_narrowing = value; |
428a5a4e | 411 | } |
72db3845 | 412 | |
837277ab | 413 | cpp_opts->warn_trigraphs = value; |
414 | cpp_opts->warn_comments = value; | |
415 | cpp_opts->warn_num_sign_change = value; | |
06bc8842 | 416 | |
417 | if (warn_pointer_sign == -1) | |
1d86d4d7 | 418 | warn_pointer_sign = value; |
428a5a4e | 419 | break; |
420 | ||
2ad0b097 | 421 | case OPT_Wbuiltin_macro_redefined: |
422 | cpp_opts->warn_builtin_macro_redefined = value; | |
423 | break; | |
424 | ||
72db3845 | 425 | case OPT_Wcomment: |
837277ab | 426 | cpp_opts->warn_comments = value; |
72db3845 | 427 | break; |
428 | ||
841fdaa6 | 429 | case OPT_Wc___compat: |
430 | /* Because -Wenum-compare is the default in C++, -Wc++-compat | |
431 | implies -Wenum-compare. */ | |
432 | if (warn_enum_compare == -1 && value) | |
433 | warn_enum_compare = value; | |
2a6a6991 | 434 | cpp_opts->warn_cxx_operator_names = value; |
841fdaa6 | 435 | break; |
436 | ||
7e783eb3 | 437 | case OPT_Wc__0x_compat: |
438 | warn_narrowing = value; | |
439 | break; | |
440 | ||
428a5a4e | 441 | case OPT_Wdeprecated: |
5ae82d58 | 442 | cpp_opts->cpp_warn_deprecated = value; |
428a5a4e | 443 | break; |
444 | ||
72db3845 | 445 | case OPT_Wendif_labels: |
837277ab | 446 | cpp_opts->warn_endif_labels = value; |
72db3845 | 447 | break; |
448 | ||
428a5a4e | 449 | case OPT_Wformat: |
837277ab | 450 | set_Wformat (value); |
428a5a4e | 451 | break; |
452 | ||
803894d2 | 453 | case OPT_Wformat_: |
428a5a4e | 454 | set_Wformat (atoi (arg)); |
455 | break; | |
456 | ||
428a5a4e | 457 | case OPT_Wimplicit: |
1f3db819 | 458 | gcc_assert (value == 0 || value == 1); |
459 | if (warn_implicit_int == -1) | |
f83b64ca | 460 | handle_generated_option (&global_options, &global_options_set, |
461 | OPT_Wimplicit_int, NULL, value, | |
3c6c0e40 | 462 | c_family_lang_mask, kind, loc, handlers, |
24ca3b4e | 463 | global_dc); |
1f3db819 | 464 | if (warn_implicit_function_declaration == -1) |
f83b64ca | 465 | handle_generated_option (&global_options, &global_options_set, |
2c5d2e39 | 466 | OPT_Wimplicit_function_declaration, NULL, |
3c6c0e40 | 467 | value, c_family_lang_mask, kind, loc, |
468 | handlers, global_dc); | |
428a5a4e | 469 | break; |
470 | ||
573aba85 | 471 | case OPT_Winvalid_pch: |
837277ab | 472 | cpp_opts->warn_invalid_pch = value; |
573aba85 | 473 | break; |
474 | ||
76d340ac | 475 | case OPT_Wliteral_suffix: |
476 | cpp_opts->warn_literal_suffix = value; | |
477 | break; | |
478 | ||
c123f04d | 479 | case OPT_Wlong_long: |
480 | cpp_opts->cpp_warn_long_long = value; | |
481 | break; | |
482 | ||
06fd18c9 | 483 | case OPT_Wmissing_include_dirs: |
484 | cpp_opts->warn_missing_include_dirs = value; | |
485 | break; | |
486 | ||
428a5a4e | 487 | case OPT_Wmultichar: |
837277ab | 488 | cpp_opts->warn_multichar = value; |
428a5a4e | 489 | break; |
490 | ||
bce47149 | 491 | case OPT_Wnormalized_: |
19ec5c9e | 492 | if (kind == DK_ERROR) |
493 | { | |
494 | gcc_assert (!arg); | |
495 | inform (input_location, "-Werror=normalized=: set -Wnormalized=nfc"); | |
496 | cpp_opts->warn_normalize = normalized_C; | |
497 | } | |
bce47149 | 498 | else |
19ec5c9e | 499 | { |
500 | if (!value || (arg && strcasecmp (arg, "none") == 0)) | |
501 | cpp_opts->warn_normalize = normalized_none; | |
502 | else if (!arg || strcasecmp (arg, "nfkc") == 0) | |
503 | cpp_opts->warn_normalize = normalized_KC; | |
504 | else if (strcasecmp (arg, "id") == 0) | |
505 | cpp_opts->warn_normalize = normalized_identifier_C; | |
506 | else if (strcasecmp (arg, "nfc") == 0) | |
507 | cpp_opts->warn_normalize = normalized_C; | |
508 | else | |
509 | error ("argument %qs to %<-Wnormalized%> not recognized", arg); | |
510 | break; | |
511 | } | |
bce47149 | 512 | |
428a5a4e | 513 | case OPT_Wtraditional: |
5ae82d58 | 514 | cpp_opts->cpp_warn_traditional = value; |
72db3845 | 515 | break; |
516 | ||
517 | case OPT_Wtrigraphs: | |
837277ab | 518 | cpp_opts->warn_trigraphs = value; |
72db3845 | 519 | break; |
520 | ||
521 | case OPT_Wundef: | |
837277ab | 522 | cpp_opts->warn_undef = value; |
428a5a4e | 523 | break; |
524 | ||
525 | case OPT_Wunknown_pragmas: | |
526 | /* Set to greater than 1, so that even unknown pragmas in | |
2b30d46c | 527 | system headers will be warned about. */ |
837277ab | 528 | warn_unknown_pragmas = value * 2; |
428a5a4e | 529 | break; |
530 | ||
72db3845 | 531 | case OPT_Wunused_macros: |
837277ab | 532 | warn_unused_macros = value; |
72db3845 | 533 | break; |
534 | ||
05d51900 | 535 | case OPT_Wvariadic_macros: |
536 | warn_variadic_macros = value; | |
537 | break; | |
538 | ||
bece0d7d | 539 | case OPT_Weffc__: |
bece0d7d | 540 | if (value) |
541 | warn_nonvdtor = true; | |
542 | break; | |
543 | ||
3ae4c9f3 | 544 | case OPT_ansi: |
c0f19401 | 545 | if (!c_dialect_cxx ()) |
3ae4c9f3 | 546 | set_std_c89 (false, true); |
547 | else | |
548 | set_std_cxx98 (true); | |
549 | break; | |
428a5a4e | 550 | |
45c365b1 | 551 | case OPT_d: |
552 | handle_OPT_d (arg); | |
553 | break; | |
554 | ||
428a5a4e | 555 | case OPT_fcond_mismatch: |
c0f19401 | 556 | if (!c_dialect_cxx ()) |
428a5a4e | 557 | { |
837277ab | 558 | flag_cond_mismatch = value; |
428a5a4e | 559 | break; |
560 | } | |
c3ceba8e | 561 | warning (0, "switch %qs is no longer supported", option->opt_text); |
428a5a4e | 562 | break; |
563 | ||
428a5a4e | 564 | case OPT_fbuiltin_: |
837277ab | 565 | if (value) |
b78351e5 | 566 | result = false; |
45c365b1 | 567 | else |
568 | disable_builtin_function (arg); | |
428a5a4e | 569 | break; |
570 | ||
fcde64dc | 571 | case OPT_fdirectives_only: |
8d3e018c | 572 | cpp_opts->directives_only = value; |
fcde64dc | 573 | break; |
574 | ||
428a5a4e | 575 | case OPT_fdollars_in_identifiers: |
837277ab | 576 | cpp_opts->dollars_in_ident = value; |
428a5a4e | 577 | break; |
578 | ||
428a5a4e | 579 | case OPT_ffreestanding: |
837277ab | 580 | value = !value; |
b4b174c3 | 581 | /* Fall through.... */ |
428a5a4e | 582 | case OPT_fhosted: |
837277ab | 583 | flag_hosted = value; |
584 | flag_no_builtin = !value; | |
428a5a4e | 585 | break; |
586 | ||
803894d2 | 587 | case OPT_fconstant_string_class_: |
45c365b1 | 588 | constant_string_class_name = arg; |
428a5a4e | 589 | break; |
590 | ||
865c4e44 | 591 | case OPT_fextended_identifiers: |
592 | cpp_opts->extended_identifiers = value; | |
593 | break; | |
594 | ||
72db3845 | 595 | case OPT_foperator_names: |
837277ab | 596 | cpp_opts->operator_names = value; |
72db3845 | 597 | break; |
598 | ||
573aba85 | 599 | case OPT_fpch_deps: |
837277ab | 600 | cpp_opts->restore_pch_deps = value; |
573aba85 | 601 | break; |
602 | ||
d718b525 | 603 | case OPT_fpch_preprocess: |
604 | flag_pch_preprocess = value; | |
605 | break; | |
606 | ||
428a5a4e | 607 | case OPT_fpermissive: |
3a283672 | 608 | flag_permissive = value; |
609 | global_dc->permissive = value; | |
428a5a4e | 610 | break; |
611 | ||
72db3845 | 612 | case OPT_fpreprocessed: |
837277ab | 613 | cpp_opts->preprocessed = value; |
72db3845 | 614 | break; |
615 | ||
62db153a | 616 | case OPT_fdebug_cpp: |
617 | cpp_opts->debug = 1; | |
618 | break; | |
619 | ||
ce70f433 | 620 | case OPT_ftrack_macro_expansion: |
621 | if (value) | |
622 | value = 2; | |
623 | /* Fall Through. */ | |
624 | ||
625 | case OPT_ftrack_macro_expansion_: | |
626 | if (arg && *arg != '\0') | |
627 | cpp_opts->track_macro_expansion = value; | |
628 | else | |
629 | cpp_opts->track_macro_expansion = 2; | |
630 | break; | |
631 | ||
428a5a4e | 632 | case OPT_frepo: |
837277ab | 633 | flag_use_repository = value; |
634 | if (value) | |
428a5a4e | 635 | flag_implicit_templates = 0; |
636 | break; | |
637 | ||
803894d2 | 638 | case OPT_ftabstop_: |
72db3845 | 639 | /* It is documented that we silently ignore silly values. */ |
837277ab | 640 | if (value >= 1 && value <= 100) |
641 | cpp_opts->tabstop = value; | |
72db3845 | 642 | break; |
643 | ||
ebc03810 | 644 | case OPT_fexec_charset_: |
645 | cpp_opts->narrow_charset = arg; | |
646 | break; | |
647 | ||
648 | case OPT_fwide_exec_charset_: | |
649 | cpp_opts->wide_charset = arg; | |
650 | break; | |
651 | ||
57ba96e9 | 652 | case OPT_finput_charset_: |
653 | cpp_opts->input_charset = arg; | |
654 | break; | |
655 | ||
803894d2 | 656 | case OPT_ftemplate_depth_: |
837277ab | 657 | max_tinst_depth = value; |
428a5a4e | 658 | break; |
659 | ||
b212f378 | 660 | case OPT_fvisibility_inlines_hidden: |
661 | visibility_options.inlines_hidden = value; | |
662 | break; | |
428a5a4e | 663 | |
0e4744ac | 664 | case OPT_femit_struct_debug_baseonly: |
9faf44d6 | 665 | set_struct_debug_option (&global_options, loc, "base"); |
0e4744ac | 666 | break; |
667 | ||
668 | case OPT_femit_struct_debug_reduced: | |
9faf44d6 | 669 | set_struct_debug_option (&global_options, loc, |
d7175aef | 670 | "dir:ord:sys,dir:gen:any,ind:base"); |
0e4744ac | 671 | break; |
672 | ||
673 | case OPT_femit_struct_debug_detailed_: | |
9faf44d6 | 674 | set_struct_debug_option (&global_options, loc, arg); |
0e4744ac | 675 | break; |
676 | ||
e69f4d0e | 677 | case OPT_idirafter: |
06fd18c9 | 678 | add_path (xstrdup (arg), AFTER, 0, true); |
e69f4d0e | 679 | break; |
680 | ||
d41b6698 | 681 | case OPT_imacros: |
b717e161 | 682 | case OPT_include: |
683 | defer_opt (code, arg); | |
684 | break; | |
685 | ||
72779020 | 686 | case OPT_imultilib: |
687 | imultilib = arg; | |
688 | break; | |
689 | ||
e69f4d0e | 690 | case OPT_iprefix: |
691 | iprefix = arg; | |
692 | break; | |
693 | ||
a55b2364 | 694 | case OPT_iquote: |
06fd18c9 | 695 | add_path (xstrdup (arg), QUOTE, 0, true); |
a55b2364 | 696 | break; |
697 | ||
e69f4d0e | 698 | case OPT_isysroot: |
699 | sysroot = arg; | |
700 | break; | |
701 | ||
702 | case OPT_isystem: | |
06fd18c9 | 703 | add_path (xstrdup (arg), SYSTEM, 0, true); |
e69f4d0e | 704 | break; |
705 | ||
706 | case OPT_iwithprefix: | |
707 | add_prefixed_path (arg, SYSTEM); | |
708 | break; | |
709 | ||
710 | case OPT_iwithprefixbefore: | |
711 | add_prefixed_path (arg, BRACKET); | |
712 | break; | |
713 | ||
3ae4c9f3 | 714 | case OPT_lang_asm: |
715 | cpp_set_lang (parse_in, CLK_ASM); | |
d7518d5f | 716 | cpp_opts->dollars_in_ident = false; |
3ae4c9f3 | 717 | break; |
718 | ||
45c365b1 | 719 | case OPT_nostdinc: |
e69f4d0e | 720 | std_inc = false; |
45c365b1 | 721 | break; |
722 | ||
803894d2 | 723 | case OPT_nostdinc__: |
e69f4d0e | 724 | std_cxx_inc = false; |
45c365b1 | 725 | break; |
726 | ||
dfeeca46 | 727 | case OPT_o: |
6019c708 | 728 | if (!out_fname) |
729 | out_fname = arg; | |
dfeeca46 | 730 | else |
2f423865 | 731 | error ("output filename specified twice"); |
dfeeca46 | 732 | break; |
733 | ||
db490cb6 | 734 | /* We need to handle the -Wpedantic switch here, rather than in |
72db3845 | 735 | c_common_post_options, so that a subsequent -Wno-endif-labels |
736 | is not overridden. */ | |
29438999 | 737 | case OPT_Wpedantic: |
5ae82d58 | 738 | cpp_opts->cpp_pedantic = 1; |
72db3845 | 739 | cpp_opts->warn_endif_labels = 1; |
06bc8842 | 740 | if (warn_pointer_sign == -1) |
741 | warn_pointer_sign = 1; | |
1d752508 | 742 | if (warn_overlength_strings == -1) |
743 | warn_overlength_strings = 1; | |
23efcc02 | 744 | if (warn_main == -1) |
745 | warn_main = 2; | |
72db3845 | 746 | break; |
747 | ||
428a5a4e | 748 | case OPT_print_objc_runtime_info: |
749 | print_struct_values = 1; | |
750 | break; | |
751 | ||
dfeeca46 | 752 | case OPT_remap: |
753 | cpp_opts->remap = 1; | |
428a5a4e | 754 | break; |
755 | ||
803894d2 | 756 | case OPT_std_c__98: |
757 | case OPT_std_gnu__98: | |
bc7ab021 | 758 | if (!preprocessing_asm_p) |
759 | set_std_cxx98 (code == OPT_std_c__98 /* ISO */); | |
428a5a4e | 760 | break; |
761 | ||
0d84dc2d | 762 | case OPT_std_c__11: |
763 | case OPT_std_gnu__11: | |
0fe6eeac | 764 | if (!preprocessing_asm_p) |
0d84dc2d | 765 | set_std_cxx11 (code == OPT_std_c__11 /* ISO */); |
0fe6eeac | 766 | break; |
767 | ||
543efdbe | 768 | case OPT_std_c__1y: |
769 | case OPT_std_gnu__1y: | |
770 | if (!preprocessing_asm_p) | |
771 | set_std_cxx1y (code == OPT_std_c__11 /* ISO */); | |
772 | break; | |
773 | ||
32f1f35b | 774 | case OPT_std_c90: |
dfeeca46 | 775 | case OPT_std_iso9899_199409: |
bc7ab021 | 776 | if (!preprocessing_asm_p) |
777 | set_std_c89 (code == OPT_std_iso9899_199409 /* c94 */, true /* ISO */); | |
3ae4c9f3 | 778 | break; |
779 | ||
32f1f35b | 780 | case OPT_std_gnu90: |
bc7ab021 | 781 | if (!preprocessing_asm_p) |
782 | set_std_c89 (false /* c94 */, false /* ISO */); | |
428a5a4e | 783 | break; |
784 | ||
785 | case OPT_std_c99: | |
bc7ab021 | 786 | if (!preprocessing_asm_p) |
787 | set_std_c99 (true /* ISO */); | |
428a5a4e | 788 | break; |
789 | ||
428a5a4e | 790 | case OPT_std_gnu99: |
bc7ab021 | 791 | if (!preprocessing_asm_p) |
792 | set_std_c99 (false /* ISO */); | |
428a5a4e | 793 | break; |
794 | ||
32074525 | 795 | case OPT_std_c11: |
39012afb | 796 | if (!preprocessing_asm_p) |
32074525 | 797 | set_std_c11 (true /* ISO */); |
39012afb | 798 | break; |
799 | ||
32074525 | 800 | case OPT_std_gnu11: |
39012afb | 801 | if (!preprocessing_asm_p) |
32074525 | 802 | set_std_c11 (false /* ISO */); |
39012afb | 803 | break; |
804 | ||
45c365b1 | 805 | case OPT_trigraphs: |
806 | cpp_opts->trigraphs = 1; | |
807 | break; | |
808 | ||
809 | case OPT_traditional_cpp: | |
810 | cpp_opts->traditional = 1; | |
811 | break; | |
812 | ||
45c365b1 | 813 | case OPT_v: |
e69f4d0e | 814 | verbose = true; |
45c365b1 | 815 | break; |
58beda63 | 816 | |
817 | case OPT_Wabi: | |
818 | warn_psabi = value; | |
819 | break; | |
45c365b1 | 820 | } |
428a5a4e | 821 | |
d3b7ee7c | 822 | switch (c_language) |
823 | { | |
824 | case clk_c: | |
825 | C_handle_option_auto (&global_options, &global_options_set, | |
826 | scode, arg, value, | |
827 | c_family_lang_mask, kind, | |
828 | loc, handlers, global_dc); | |
829 | break; | |
830 | ||
831 | case clk_objc: | |
832 | ObjC_handle_option_auto (&global_options, &global_options_set, | |
833 | scode, arg, value, | |
834 | c_family_lang_mask, kind, | |
835 | loc, handlers, global_dc); | |
836 | break; | |
837 | ||
838 | case clk_cxx: | |
839 | CXX_handle_option_auto (&global_options, &global_options_set, | |
840 | scode, arg, value, | |
841 | c_family_lang_mask, kind, | |
842 | loc, handlers, global_dc); | |
843 | break; | |
844 | ||
845 | case clk_objcxx: | |
846 | ObjCXX_handle_option_auto (&global_options, &global_options_set, | |
847 | scode, arg, value, | |
848 | c_family_lang_mask, kind, | |
849 | loc, handlers, global_dc); | |
850 | break; | |
851 | ||
852 | default: | |
853 | gcc_unreachable (); | |
854 | } | |
855 | ||
428a5a4e | 856 | return result; |
857 | } | |
858 | ||
c94b1d0e | 859 | /* Default implementation of TARGET_HANDLE_C_OPTION. */ |
860 | ||
861 | bool | |
862 | default_handle_c_option (size_t code ATTRIBUTE_UNUSED, | |
863 | const char *arg ATTRIBUTE_UNUSED, | |
864 | int value ATTRIBUTE_UNUSED) | |
865 | { | |
866 | return false; | |
867 | } | |
868 | ||
428a5a4e | 869 | /* Post-switch processing. */ |
870 | bool | |
d732fcf0 | 871 | c_common_post_options (const char **pfilename) |
428a5a4e | 872 | { |
d732fcf0 | 873 | struct cpp_callbacks *cb; |
874 | ||
79cf3ec1 | 875 | /* Canonicalize the input and output filenames. */ |
40109983 | 876 | if (in_fnames == NULL) |
877 | { | |
9318f22c | 878 | in_fnames = XNEWVEC (const char *, 1); |
40109983 | 879 | in_fnames[0] = ""; |
880 | } | |
881 | else if (strcmp (in_fnames[0], "-") == 0) | |
882 | in_fnames[0] = ""; | |
79cf3ec1 | 883 | |
6019c708 | 884 | if (out_fname == NULL || !strcmp (out_fname, "-")) |
885 | out_fname = ""; | |
886 | ||
eb0921ba | 887 | if (cpp_opts->deps.style == DEPS_NONE) |
6019c708 | 888 | check_deps_environment_vars (); |
889 | ||
61191376 | 890 | handle_deferred_opts (); |
6019c708 | 891 | |
61191376 | 892 | sanitize_cpp_opts (); |
79cf3ec1 | 893 | |
72779020 | 894 | register_include_chains (parse_in, sysroot, iprefix, imultilib, |
c0f19401 | 895 | std_inc, std_cxx_inc && c_dialect_cxx (), verbose); |
e69f4d0e | 896 | |
3bf418bd | 897 | #ifdef C_COMMON_OVERRIDE_OPTIONS |
898 | /* Some machines may reject certain combinations of C | |
899 | language-specific options. */ | |
900 | C_COMMON_OVERRIDE_OPTIONS; | |
901 | #endif | |
902 | ||
c6418a4e | 903 | /* Excess precision other than "fast" requires front-end |
904 | support. */ | |
905 | if (c_dialect_cxx ()) | |
906 | { | |
907 | if (flag_excess_precision_cmdline == EXCESS_PRECISION_STANDARD | |
908 | && TARGET_FLT_EVAL_METHOD_NON_DEFAULT) | |
909 | sorry ("-fexcess-precision=standard for C++"); | |
910 | flag_excess_precision_cmdline = EXCESS_PRECISION_FAST; | |
911 | } | |
912 | else if (flag_excess_precision_cmdline == EXCESS_PRECISION_DEFAULT) | |
913 | flag_excess_precision_cmdline = (flag_iso | |
914 | ? EXCESS_PRECISION_STANDARD | |
915 | : EXCESS_PRECISION_FAST); | |
916 | ||
11950bdd | 917 | /* By default we use C99 inline semantics in GNU99 or C99 mode. C99 |
918 | inline semantics are not supported in GNU89 or C89 mode. */ | |
919 | if (flag_gnu89_inline == -1) | |
920 | flag_gnu89_inline = !flag_isoc99; | |
921 | else if (!flag_gnu89_inline && !flag_isoc99) | |
922 | error ("-fno-gnu89-inline is only supported in GNU99 or C99 mode"); | |
923 | ||
e24e8df7 | 924 | /* Default to ObjC sjlj exception handling if NeXT runtime. */ |
925 | if (flag_objc_sjlj_exceptions < 0) | |
926 | flag_objc_sjlj_exceptions = flag_next_runtime; | |
927 | if (flag_objc_exceptions && !flag_objc_sjlj_exceptions) | |
928 | flag_exceptions = 1; | |
929 | ||
a0ded67b | 930 | /* -Wextra implies the following flags |
931 | unless explicitly overridden. */ | |
70059cea | 932 | |
933 | /* Wsign-compare is also enabled by -Wall in C++. */ | |
5125036e | 934 | if (warn_sign_compare == -1) |
935 | warn_sign_compare = extra_warnings; | |
936 | ||
71ee8477 | 937 | /* -Wpointer-sign is disabled by default, but it is enabled if any |
29438999 | 938 | of -Wall or -Wpedantic are given. */ |
06bc8842 | 939 | if (warn_pointer_sign == -1) |
940 | warn_pointer_sign = 0; | |
941 | ||
a54ab330 | 942 | if (warn_strict_aliasing == -1) |
943 | warn_strict_aliasing = 0; | |
944 | if (warn_strict_overflow == -1) | |
945 | warn_strict_overflow = 0; | |
946 | ||
29438999 | 947 | /* -Woverlength-strings is off by default, but is enabled by -Wpedantic. |
1d752508 | 948 | It is never enabled in C++, as the minimum limit is not normative |
949 | in that standard. */ | |
950 | if (warn_overlength_strings == -1 || c_dialect_cxx ()) | |
951 | warn_overlength_strings = 0; | |
952 | ||
23efcc02 | 953 | /* Wmain is enabled by default in C++ but not in C. */ |
954 | /* Wmain is disabled by default for -ffreestanding (!flag_hosted), | |
955 | even if -Wall was given (warn_main will be 2 if set by -Wall, 1 | |
956 | if set by -Wmain). */ | |
957 | if (warn_main == -1) | |
958 | warn_main = (c_dialect_cxx () && flag_hosted) ? 1 : 0; | |
959 | else if (warn_main == 2) | |
960 | warn_main = flag_hosted ? 1 : 0; | |
961 | ||
7ee0d227 | 962 | /* In C, -Wconversion enables -Wsign-conversion (unless disabled |
963 | through -Wno-sign-conversion). While in C++, | |
964 | -Wsign-conversion needs to be requested explicitly. */ | |
965 | if (warn_sign_conversion == -1) | |
966 | warn_sign_conversion = (c_dialect_cxx ()) ? 0 : warn_conversion; | |
967 | ||
841fdaa6 | 968 | /* In C, -Wall and -Wc++-compat enable -Wenum-compare, which we do |
969 | in c_common_handle_option; if it has not yet been set, it is | |
970 | disabled by default. In C++, it is enabled by default. */ | |
971 | if (warn_enum_compare == -1) | |
972 | warn_enum_compare = c_dialect_cxx () ? 1 : 0; | |
973 | ||
7a6a48c9 | 974 | /* -Wpacked-bitfield-compat is on by default for the C languages. The |
975 | warning is issued in stor-layout.c which is not part of the front-end so | |
976 | we need to selectively turn it on here. */ | |
977 | if (warn_packed_bitfield_compat == -1) | |
978 | warn_packed_bitfield_compat = 1; | |
aa509316 | 979 | |
428a5a4e | 980 | /* Special format checking options don't work without -Wformat; warn if |
981 | they are used. */ | |
8b6866af | 982 | if (!warn_format) |
983 | { | |
984 | warning (OPT_Wformat_y2k, | |
985 | "-Wformat-y2k ignored without -Wformat"); | |
986 | warning (OPT_Wformat_extra_args, | |
987 | "-Wformat-extra-args ignored without -Wformat"); | |
988 | warning (OPT_Wformat_zero_length, | |
989 | "-Wformat-zero-length ignored without -Wformat"); | |
990 | warning (OPT_Wformat_nonliteral, | |
991 | "-Wformat-nonliteral ignored without -Wformat"); | |
0e9b4e74 | 992 | warning (OPT_Wformat_contains_nul, |
993 | "-Wformat-contains-nul ignored without -Wformat"); | |
8b6866af | 994 | warning (OPT_Wformat_security, |
995 | "-Wformat-security ignored without -Wformat"); | |
8b6866af | 996 | } |
428a5a4e | 997 | |
1f3db819 | 998 | if (warn_implicit == -1) |
999 | warn_implicit = 0; | |
1000 | ||
1001 | if (warn_implicit_int == -1) | |
1002 | warn_implicit_int = 0; | |
1003 | ||
3ba510aa | 1004 | /* -Wimplicit-function-declaration is enabled by default for C99. */ |
48e1416a | 1005 | if (warn_implicit_function_declaration == -1) |
3ba510aa | 1006 | warn_implicit_function_declaration = flag_isoc99; |
45b9d334 | 1007 | |
543efdbe | 1008 | if (cxx_dialect >= cxx0x) |
7e783eb3 | 1009 | { |
1010 | /* If we're allowing C++0x constructs, don't warn about C++98 | |
1011 | identifiers which are keywords in C++0x. */ | |
1012 | warn_cxx0x_compat = 0; | |
1013 | ||
1014 | if (warn_narrowing == -1) | |
1015 | warn_narrowing = 1; | |
1016 | } | |
1017 | else if (warn_narrowing == -1) | |
1018 | warn_narrowing = 0; | |
e1db7b20 | 1019 | |
79cf3ec1 | 1020 | if (flag_preprocess_only) |
1021 | { | |
f7070933 | 1022 | /* Open the output now. We must do so even if flag_no_output is |
1023 | on, because there may be other output than from the actual | |
1024 | preprocessing (e.g. from -dM). */ | |
1025 | if (out_fname[0] == '\0') | |
1026 | out_stream = stdout; | |
1027 | else | |
1028 | out_stream = fopen (out_fname, "w"); | |
1029 | ||
1030 | if (out_stream == NULL) | |
e920deaf | 1031 | { |
d07c9932 | 1032 | fatal_error ("opening output file %s: %m", out_fname); |
fcc56321 | 1033 | return false; |
e920deaf | 1034 | } |
f7070933 | 1035 | |
40109983 | 1036 | if (num_in_fnames > 1) |
1037 | error ("too many filenames given. Type %s --help for usage", | |
1038 | progname); | |
1039 | ||
e920deaf | 1040 | init_pp_output (out_stream); |
79cf3ec1 | 1041 | } |
e920deaf | 1042 | else |
1043 | { | |
1044 | init_c_lex (); | |
8d67b0c7 | 1045 | |
1046 | /* When writing a PCH file, avoid reading some other PCH file, | |
1047 | because the default address space slot then can't be used | |
1048 | for the output PCH file. */ | |
1049 | if (pch_file) | |
1050 | c_common_no_more_pch (); | |
79cf3ec1 | 1051 | |
e920deaf | 1052 | /* Yuk. WTF is this? I do know ObjC relies on it somewhere. */ |
9a6486a6 | 1053 | input_location = UNKNOWN_LOCATION; |
e920deaf | 1054 | } |
f7070933 | 1055 | |
d732fcf0 | 1056 | cb = cpp_get_callbacks (parse_in); |
1057 | cb->file_change = cb_file_change; | |
1058 | cb->dir_change = cb_dir_change; | |
c7f96907 | 1059 | cpp_post_options (parse_in); |
b717e161 | 1060 | |
9a6486a6 | 1061 | input_location = UNKNOWN_LOCATION; |
03bde601 | 1062 | |
d732fcf0 | 1063 | *pfilename = this_input_filename |
1064 | = cpp_read_main_file (parse_in, in_fnames[0]); | |
75d034d9 | 1065 | /* Don't do any compilation or preprocessing if there is no input file. */ |
d732fcf0 | 1066 | if (this_input_filename == NULL) |
75d034d9 | 1067 | { |
1068 | errorcount++; | |
1069 | return false; | |
1070 | } | |
d732fcf0 | 1071 | |
c796cff1 | 1072 | if (flag_working_directory |
84166705 | 1073 | && flag_preprocess_only && !flag_no_line_commands) |
d732fcf0 | 1074 | pp_dir_change (parse_in, get_src_pwd ()); |
1075 | ||
c779d8cc | 1076 | /* Disable LTO output when outputting a precompiled header. */ |
1077 | if (pch_file && flag_lto) | |
1078 | { | |
1079 | flag_lto = 0; | |
1080 | flag_generate_lto = 0; | |
1081 | } | |
1082 | ||
03bde601 | 1083 | return flag_preprocess_only; |
1084 | } | |
1085 | ||
1086 | /* Front end initialization common to C, ObjC and C++. */ | |
1087 | bool | |
2b30d46c | 1088 | c_common_init (void) |
03bde601 | 1089 | { |
03bde601 | 1090 | /* Set up preprocessor arithmetic. Must be done after call to |
1091 | c_common_nodes_and_builtins for type nodes to be good. */ | |
1092 | cpp_opts->precision = TYPE_PRECISION (intmax_type_node); | |
1093 | cpp_opts->char_precision = TYPE_PRECISION (char_type_node); | |
1094 | cpp_opts->int_precision = TYPE_PRECISION (integer_type_node); | |
1095 | cpp_opts->wchar_precision = TYPE_PRECISION (wchar_type_node); | |
78a8ed03 | 1096 | cpp_opts->unsigned_wchar = TYPE_UNSIGNED (wchar_type_node); |
ebc03810 | 1097 | cpp_opts->bytes_big_endian = BYTES_BIG_ENDIAN; |
1098 | ||
1099 | /* This can't happen until after wchar_precision and bytes_big_endian | |
1100 | are known. */ | |
1101 | cpp_init_iconv (parse_in); | |
79cf3ec1 | 1102 | |
f1035767 | 1103 | if (version_flag) |
1104 | c_common_print_pch_checksum (stderr); | |
1105 | ||
146a4308 | 1106 | /* Has to wait until now so that cpplib has its hash table. */ |
1107 | init_pragma (); | |
1108 | ||
e920deaf | 1109 | if (flag_preprocess_only) |
1110 | { | |
79396169 | 1111 | c_finish_options (); |
d732fcf0 | 1112 | preprocess_file (parse_in); |
03bde601 | 1113 | return false; |
e920deaf | 1114 | } |
1115 | ||
03bde601 | 1116 | return true; |
6019c708 | 1117 | } |
1118 | ||
40109983 | 1119 | /* Initialize the integrated preprocessor after debug output has been |
1120 | initialized; loop over each input file. */ | |
b717e161 | 1121 | void |
b8ba44e7 | 1122 | c_common_parse_file (void) |
b717e161 | 1123 | { |
b3e83e1e | 1124 | unsigned int i; |
1125 | ||
b3e83e1e | 1126 | i = 0; |
1127 | for (;;) | |
1128 | { | |
79396169 | 1129 | c_finish_options (); |
b3e83e1e | 1130 | pch_init (); |
1131 | push_file_scope (); | |
1132 | c_parse_file (); | |
b3e83e1e | 1133 | pop_file_scope (); |
7a4afb3f | 1134 | /* And end the main input file, if the debug writer wants it */ |
1135 | if (debug_hooks->start_end_main_source_file) | |
1136 | (*debug_hooks->end_source_file) (0); | |
b3e83e1e | 1137 | if (++i >= num_in_fnames) |
1138 | break; | |
1139 | cpp_undef_all (parse_in); | |
64cb8c90 | 1140 | cpp_clear_file_cache (parse_in); |
b3e83e1e | 1141 | this_input_filename |
1142 | = cpp_read_main_file (parse_in, in_fnames[i]); | |
1143 | /* If an input file is missing, abandon further compilation. | |
a0c938f0 | 1144 | cpplib has issued a diagnostic. */ |
b3e83e1e | 1145 | if (!this_input_filename) |
1146 | break; | |
1147 | } | |
b717e161 | 1148 | } |
1149 | ||
6019c708 | 1150 | /* Common finish hook for the C, ObjC and C++ front ends. */ |
1151 | void | |
2b30d46c | 1152 | c_common_finish (void) |
6019c708 | 1153 | { |
1154 | FILE *deps_stream = NULL; | |
1155 | ||
7f5f3953 | 1156 | /* Don't write the deps file if there are errors. */ |
852f689e | 1157 | if (cpp_opts->deps.style != DEPS_NONE && !seen_error ()) |
6019c708 | 1158 | { |
1159 | /* If -M or -MM was seen without -MF, default output to the | |
1160 | output stream. */ | |
61191376 | 1161 | if (!deps_file) |
6019c708 | 1162 | deps_stream = out_stream; |
1163 | else | |
1164 | { | |
61191376 | 1165 | deps_stream = fopen (deps_file, deps_append ? "a": "w"); |
6019c708 | 1166 | if (!deps_stream) |
d07c9932 | 1167 | fatal_error ("opening dependency file %s: %m", deps_file); |
6019c708 | 1168 | } |
1169 | } | |
1170 | ||
1171 | /* For performance, avoid tearing down cpplib's internal structures | |
1172 | with cpp_destroy (). */ | |
7f5f3953 | 1173 | cpp_finish (parse_in, deps_stream); |
6019c708 | 1174 | |
1175 | if (deps_stream && deps_stream != out_stream | |
1176 | && (ferror (deps_stream) || fclose (deps_stream))) | |
d07c9932 | 1177 | fatal_error ("closing dependency file %s: %m", deps_file); |
6019c708 | 1178 | |
1179 | if (out_stream && (ferror (out_stream) || fclose (out_stream))) | |
d07c9932 | 1180 | fatal_error ("when writing output to %s: %m", out_fname); |
6019c708 | 1181 | } |
1182 | ||
6019c708 | 1183 | /* Either of two environment variables can specify output of |
1184 | dependencies. Their value is either "OUTPUT_FILE" or "OUTPUT_FILE | |
1185 | DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to | |
1186 | and DEPS_TARGET is the target to mention in the deps. They also | |
1187 | result in dependency information being appended to the output file | |
3c556f04 | 1188 | rather than overwriting it, and like Sun's compiler |
1189 | SUNPRO_DEPENDENCIES suppresses the dependency on the main file. */ | |
6019c708 | 1190 | static void |
2b30d46c | 1191 | check_deps_environment_vars (void) |
6019c708 | 1192 | { |
1193 | char *spec; | |
1194 | ||
967958e4 | 1195 | spec = getenv ("DEPENDENCIES_OUTPUT"); |
6019c708 | 1196 | if (spec) |
61191376 | 1197 | cpp_opts->deps.style = DEPS_USER; |
6019c708 | 1198 | else |
1199 | { | |
967958e4 | 1200 | spec = getenv ("SUNPRO_DEPENDENCIES"); |
6019c708 | 1201 | if (spec) |
3c556f04 | 1202 | { |
1203 | cpp_opts->deps.style = DEPS_SYSTEM; | |
1204 | cpp_opts->deps.ignore_main_file = true; | |
1205 | } | |
6019c708 | 1206 | } |
1207 | ||
1208 | if (spec) | |
1209 | { | |
1210 | /* Find the space before the DEPS_TARGET, if there is one. */ | |
1211 | char *s = strchr (spec, ' '); | |
1212 | if (s) | |
1213 | { | |
1214 | /* Let the caller perform MAKE quoting. */ | |
61191376 | 1215 | defer_opt (OPT_MT, s + 1); |
6019c708 | 1216 | *s = '\0'; |
1217 | } | |
1218 | ||
1219 | /* Command line -MF overrides environment variables and default. */ | |
61191376 | 1220 | if (!deps_file) |
1221 | deps_file = spec; | |
6019c708 | 1222 | |
61191376 | 1223 | deps_append = 1; |
33b4f63d | 1224 | deps_seen = true; |
61191376 | 1225 | } |
1226 | } | |
1227 | ||
1228 | /* Handle deferred command line switches. */ | |
1229 | static void | |
2b30d46c | 1230 | handle_deferred_opts (void) |
61191376 | 1231 | { |
1232 | size_t i; | |
3eb3f293 | 1233 | struct deps *deps; |
1234 | ||
1235 | /* Avoid allocating the deps buffer if we don't need it. | |
1236 | (This flag may be true without there having been -MT or -MQ | |
1237 | options, but we'll still need the deps buffer.) */ | |
1238 | if (!deps_seen) | |
1239 | return; | |
1240 | ||
1241 | deps = cpp_get_deps (parse_in); | |
61191376 | 1242 | |
1243 | for (i = 0; i < deferred_count; i++) | |
1244 | { | |
1245 | struct deferred_opt *opt = &deferred_opts[i]; | |
1246 | ||
fc3c7720 | 1247 | if (opt->code == OPT_MT || opt->code == OPT_MQ) |
3eb3f293 | 1248 | deps_add_target (deps, opt->arg, opt->code == OPT_MQ); |
61191376 | 1249 | } |
61191376 | 1250 | } |
1251 | ||
1252 | /* These settings are appropriate for GCC, but not necessarily so for | |
1253 | cpplib as a library. */ | |
1254 | static void | |
2b30d46c | 1255 | sanitize_cpp_opts (void) |
61191376 | 1256 | { |
1257 | /* If we don't know what style of dependencies to output, complain | |
1258 | if any other dependency switches have been given. */ | |
1259 | if (deps_seen && cpp_opts->deps.style == DEPS_NONE) | |
1260 | error ("to generate dependencies you must specify either -M or -MM"); | |
1261 | ||
1262 | /* -dM and dependencies suppress normal output; do it here so that | |
1263 | the last -d[MDN] switch overrides earlier ones. */ | |
f7070933 | 1264 | if (flag_dump_macros == 'M') |
1265 | flag_no_output = 1; | |
61191376 | 1266 | |
fcde64dc | 1267 | /* By default, -fdirectives-only implies -dD. This allows subsequent phases |
1268 | to perform proper macro expansion. */ | |
1269 | if (cpp_opts->directives_only && !cpp_opts->preprocessed && !flag_dump_macros) | |
1270 | flag_dump_macros = 'D'; | |
1271 | ||
61191376 | 1272 | /* Disable -dD, -dN and -dI if normal output is suppressed. Allow |
1273 | -dM since at least glibc relies on -M -dM to work. */ | |
f7f07c95 | 1274 | /* Also, flag_no_output implies flag_no_line_commands, always. */ |
f7070933 | 1275 | if (flag_no_output) |
61191376 | 1276 | { |
f7070933 | 1277 | if (flag_dump_macros != 'M') |
1278 | flag_dump_macros = 0; | |
1279 | flag_dump_includes = 0; | |
22119a94 | 1280 | flag_no_line_commands = 1; |
6019c708 | 1281 | } |
14984eca | 1282 | else if (cpp_opts->deps.missing_files) |
1283 | error ("-MG may only be used with -M or -MM"); | |
61191376 | 1284 | |
1285 | cpp_opts->unsigned_char = !flag_signed_char; | |
1286 | cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS; | |
1287 | ||
9ab71c6b | 1288 | /* Wlong-long is disabled by default. It is enabled by: |
29438999 | 1289 | [-Wpedantic | -Wtraditional] -std=[gnu|c]++98 ; or |
1290 | [-Wpedantic | -Wtraditional] -std=non-c99 . | |
9ab71c6b | 1291 | |
1292 | Either -Wlong-long or -Wno-long-long override any other settings. */ | |
1293 | if (warn_long_long == -1) | |
1294 | warn_long_long = ((pedantic || warn_traditional) | |
1295 | && (c_dialect_cxx () ? cxx_dialect == cxx98 : !flag_isoc99)); | |
5ae82d58 | 1296 | cpp_opts->cpp_warn_long_long = warn_long_long; |
e7aa92b2 | 1297 | |
05d51900 | 1298 | /* Similarly with -Wno-variadic-macros. No check for c99 here, since |
1299 | this also turns off warnings about GCCs extension. */ | |
1300 | cpp_opts->warn_variadic_macros | |
1301 | = warn_variadic_macros && (pedantic || warn_traditional); | |
1302 | ||
e7aa92b2 | 1303 | /* If we're generating preprocessor output, emit current directory |
1304 | if explicitly requested or if debugging information is enabled. | |
1305 | ??? Maybe we should only do it for debugging formats that | |
1306 | actually output the current directory? */ | |
1307 | if (flag_working_directory == -1) | |
1308 | flag_working_directory = (debug_info_level != DINFO_LEVEL_NONE); | |
fcde64dc | 1309 | |
1310 | if (cpp_opts->directives_only) | |
1311 | { | |
1312 | if (warn_unused_macros) | |
1313 | error ("-fdirectives-only is incompatible with -Wunused_macros"); | |
1314 | if (cpp_opts->traditional) | |
1315 | error ("-fdirectives-only is incompatible with -traditional"); | |
1316 | } | |
61191376 | 1317 | } |
1318 | ||
e69f4d0e | 1319 | /* Add include path with a prefix at the front of its name. */ |
1320 | static void | |
2b30d46c | 1321 | add_prefixed_path (const char *suffix, size_t chain) |
e69f4d0e | 1322 | { |
181a72b4 | 1323 | char *path; |
e69f4d0e | 1324 | const char *prefix; |
181a72b4 | 1325 | size_t prefix_len, suffix_len; |
e69f4d0e | 1326 | |
181a72b4 | 1327 | suffix_len = strlen (suffix); |
1328 | prefix = iprefix ? iprefix : cpp_GCC_INCLUDE_DIR; | |
1329 | prefix_len = iprefix ? strlen (iprefix) : cpp_GCC_INCLUDE_DIR_len; | |
1330 | ||
9318f22c | 1331 | path = (char *) xmalloc (prefix_len + suffix_len + 1); |
181a72b4 | 1332 | memcpy (path, prefix, prefix_len); |
1333 | memcpy (path + prefix_len, suffix, suffix_len); | |
1334 | path[prefix_len + suffix_len] = '\0'; | |
1335 | ||
06fd18c9 | 1336 | add_path (path, chain, 0, false); |
e69f4d0e | 1337 | } |
1338 | ||
d732fcf0 | 1339 | /* Handle -D, -U, -A, -imacros, and the first -include. */ |
1340 | static void | |
79396169 | 1341 | c_finish_options (void) |
d41b6698 | 1342 | { |
d41b6698 | 1343 | if (!cpp_opts->preprocessed) |
1344 | { | |
fc3c7720 | 1345 | size_t i; |
1346 | ||
6ea2c7a3 | 1347 | { |
1348 | /* Make sure all of the builtins about to be declared have | |
1349 | BUILTINS_LOCATION has their source_location. */ | |
1350 | source_location builtins_loc = BUILTINS_LOCATION; | |
1351 | cpp_force_token_locations (parse_in, &builtins_loc); | |
0f027989 | 1352 | |
6ea2c7a3 | 1353 | cpp_init_builtins (parse_in, flag_hosted); |
1354 | c_cpp_builtins (parse_in); | |
1355 | ||
1356 | cpp_stop_forcing_token_locations (parse_in); | |
1357 | } | |
f0c2775b | 1358 | |
1359 | /* We're about to send user input to cpplib, so make it warn for | |
1360 | things that we previously (when we sent it internal definitions) | |
1361 | told it to not warn. | |
1362 | ||
1363 | C99 permits implementation-defined characters in identifiers. | |
1364 | The documented meaning of -std= is to turn off extensions that | |
1365 | conflict with the specified standard, and since a strictly | |
1366 | conforming program cannot contain a '$', we do not condition | |
1367 | their acceptance on the -std= setting. */ | |
5ae82d58 | 1368 | cpp_opts->warn_dollars = (cpp_opts->cpp_pedantic && !cpp_opts->c99); |
f0c2775b | 1369 | |
2e1e73b6 | 1370 | cb_file_change (parse_in, |
931b0a0f | 1371 | linemap_add (line_table, LC_RENAME, 0, |
2e1e73b6 | 1372 | _("<command-line>"), 0)); |
1373 | ||
fc3c7720 | 1374 | for (i = 0; i < deferred_count; i++) |
1375 | { | |
1376 | struct deferred_opt *opt = &deferred_opts[i]; | |
1377 | ||
1378 | if (opt->code == OPT_D) | |
1379 | cpp_define (parse_in, opt->arg); | |
1380 | else if (opt->code == OPT_U) | |
1381 | cpp_undef (parse_in, opt->arg); | |
1382 | else if (opt->code == OPT_A) | |
1383 | { | |
1384 | if (opt->arg[0] == '-') | |
1385 | cpp_unassert (parse_in, opt->arg + 1); | |
1386 | else | |
1387 | cpp_assert (parse_in, opt->arg); | |
1388 | } | |
1389 | } | |
d41b6698 | 1390 | |
dd690367 | 1391 | /* Start the main input file, if the debug writer wants it. */ |
1392 | if (debug_hooks->start_end_main_source_file | |
1393 | && !flag_preprocess_only) | |
1394 | (*debug_hooks->start_source_file) (0, this_input_filename); | |
1395 | ||
fc3c7720 | 1396 | /* Handle -imacros after -D and -U. */ |
d41b6698 | 1397 | for (i = 0; i < deferred_count; i++) |
1398 | { | |
1399 | struct deferred_opt *opt = &deferred_opts[i]; | |
1400 | ||
1401 | if (opt->code == OPT_imacros | |
1402 | && cpp_push_include (parse_in, opt->arg)) | |
5980b792 | 1403 | { |
8b332087 | 1404 | /* Disable push_command_line_include callback for now. */ |
5980b792 | 1405 | include_cursor = deferred_count + 1; |
1406 | cpp_scan_nooutput (parse_in); | |
1407 | } | |
d41b6698 | 1408 | } |
1409 | } | |
dd690367 | 1410 | else |
1411 | { | |
1412 | if (cpp_opts->directives_only) | |
1413 | cpp_init_special_builtins (parse_in); | |
1414 | ||
1415 | /* Start the main input file, if the debug writer wants it. */ | |
1416 | if (debug_hooks->start_end_main_source_file | |
1417 | && !flag_preprocess_only) | |
1418 | (*debug_hooks->start_source_file) (0, this_input_filename); | |
1419 | } | |
d41b6698 | 1420 | |
26670692 | 1421 | include_cursor = 0; |
d41b6698 | 1422 | push_command_line_include (); |
1423 | } | |
1424 | ||
b717e161 | 1425 | /* Give CPP the next file given by -include, if any. */ |
1426 | static void | |
2b30d46c | 1427 | push_command_line_include (void) |
b717e161 | 1428 | { |
b717e161 | 1429 | while (include_cursor < deferred_count) |
1430 | { | |
1431 | struct deferred_opt *opt = &deferred_opts[include_cursor++]; | |
2b30d46c | 1432 | |
84166705 | 1433 | if (!cpp_opts->preprocessed && opt->code == OPT_include |
e2df3e75 | 1434 | && cpp_push_include (parse_in, opt->arg)) |
b717e161 | 1435 | return; |
1436 | } | |
1437 | ||
1438 | if (include_cursor == deferred_count) | |
1439 | { | |
e2df3e75 | 1440 | include_cursor++; |
b717e161 | 1441 | /* -Wunused-macros should only warn about macros defined hereafter. */ |
1442 | cpp_opts->warn_unused_macros = warn_unused_macros; | |
d732fcf0 | 1443 | /* Restore the line map from <command line>. */ |
84166705 | 1444 | if (!cpp_opts->preprocessed) |
860e5532 | 1445 | cpp_change_file (parse_in, LC_RENAME, this_input_filename); |
d732fcf0 | 1446 | |
1447 | /* Set this here so the client can change the option if it wishes, | |
1448 | and after stacking the main file so we don't trace the main file. */ | |
931b0a0f | 1449 | line_table->trace_includes = cpp_opts->print_include_names; |
b717e161 | 1450 | } |
1451 | } | |
1452 | ||
1453 | /* File change callback. Has to handle -include files. */ | |
1454 | static void | |
9a03a746 | 1455 | cb_file_change (cpp_reader * ARG_UNUSED (pfile), |
2b30d46c | 1456 | const struct line_map *new_map) |
b717e161 | 1457 | { |
1458 | if (flag_preprocess_only) | |
1459 | pp_file_change (new_map); | |
1460 | else | |
1461 | fe_file_change (new_map); | |
1462 | ||
e2df3e75 | 1463 | if (new_map == 0 || (new_map->reason == LC_LEAVE && MAIN_FILE_P (new_map))) |
b717e161 | 1464 | push_command_line_include (); |
1465 | } | |
1466 | ||
d732fcf0 | 1467 | void |
9a03a746 | 1468 | cb_dir_change (cpp_reader * ARG_UNUSED (pfile), const char *dir) |
d732fcf0 | 1469 | { |
84166705 | 1470 | if (!set_src_pwd (dir)) |
c3ceba8e | 1471 | warning (0, "too late for # directive to set debug directory"); |
d732fcf0 | 1472 | } |
1473 | ||
61191376 | 1474 | /* Set the C 89 standard (with 1994 amendments if C94, without GNU |
1475 | extensions if ISO). There is no concept of gnu94. */ | |
1476 | static void | |
2b30d46c | 1477 | set_std_c89 (int c94, int iso) |
61191376 | 1478 | { |
1479 | cpp_set_lang (parse_in, c94 ? CLK_STDC94: iso ? CLK_STDC89: CLK_GNUC89); | |
1480 | flag_iso = iso; | |
1481 | flag_no_asm = iso; | |
1482 | flag_no_gnu_keywords = iso; | |
1483 | flag_no_nonansi_builtin = iso; | |
61191376 | 1484 | flag_isoc94 = c94; |
1485 | flag_isoc99 = 0; | |
32074525 | 1486 | flag_isoc11 = 0; |
6019c708 | 1487 | } |
1488 | ||
dfeeca46 | 1489 | /* Set the C 99 standard (without GNU extensions if ISO). */ |
1490 | static void | |
2b30d46c | 1491 | set_std_c99 (int iso) |
dfeeca46 | 1492 | { |
1493 | cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99); | |
1494 | flag_no_asm = iso; | |
1495 | flag_no_nonansi_builtin = iso; | |
dfeeca46 | 1496 | flag_iso = iso; |
32074525 | 1497 | flag_isoc11 = 0; |
39012afb | 1498 | flag_isoc99 = 1; |
1499 | flag_isoc94 = 1; | |
1500 | } | |
1501 | ||
32074525 | 1502 | /* Set the C 11 standard (without GNU extensions if ISO). */ |
39012afb | 1503 | static void |
32074525 | 1504 | set_std_c11 (int iso) |
39012afb | 1505 | { |
32074525 | 1506 | cpp_set_lang (parse_in, iso ? CLK_STDC11: CLK_GNUC11); |
39012afb | 1507 | flag_no_asm = iso; |
1508 | flag_no_nonansi_builtin = iso; | |
1509 | flag_iso = iso; | |
32074525 | 1510 | flag_isoc11 = 1; |
dfeeca46 | 1511 | flag_isoc99 = 1; |
1512 | flag_isoc94 = 1; | |
dfeeca46 | 1513 | } |
1514 | ||
3ae4c9f3 | 1515 | /* Set the C++ 98 standard (without GNU extensions if ISO). */ |
1516 | static void | |
2b30d46c | 1517 | set_std_cxx98 (int iso) |
3ae4c9f3 | 1518 | { |
1519 | cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX); | |
1520 | flag_no_gnu_keywords = iso; | |
1521 | flag_no_nonansi_builtin = iso; | |
3ae4c9f3 | 1522 | flag_iso = iso; |
6dcdb5de | 1523 | cxx_dialect = cxx98; |
3ae4c9f3 | 1524 | } |
1525 | ||
0d84dc2d | 1526 | /* Set the C++ 2011 standard (without GNU extensions if ISO). */ |
0fe6eeac | 1527 | static void |
0d84dc2d | 1528 | set_std_cxx11 (int iso) |
0fe6eeac | 1529 | { |
0d84dc2d | 1530 | cpp_set_lang (parse_in, iso ? CLK_CXX11: CLK_GNUCXX11); |
0fe6eeac | 1531 | flag_no_gnu_keywords = iso; |
1532 | flag_no_nonansi_builtin = iso; | |
1533 | flag_iso = iso; | |
0d84dc2d | 1534 | /* C++11 includes the C99 standard library. */ |
dc251364 | 1535 | flag_isoc94 = 1; |
1536 | flag_isoc99 = 1; | |
0d84dc2d | 1537 | cxx_dialect = cxx11; |
0fe6eeac | 1538 | } |
1539 | ||
543efdbe | 1540 | /* Set the C++ 201y draft standard (without GNU extensions if ISO). */ |
1541 | static void | |
1542 | set_std_cxx1y (int iso) | |
1543 | { | |
1544 | cpp_set_lang (parse_in, iso ? CLK_CXX11: CLK_GNUCXX11); | |
1545 | flag_no_gnu_keywords = iso; | |
1546 | flag_no_nonansi_builtin = iso; | |
1547 | flag_iso = iso; | |
1548 | /* C++11 includes the C99 standard library. */ | |
1549 | flag_isoc94 = 1; | |
1550 | flag_isoc99 = 1; | |
1551 | cxx_dialect = cxx1y; | |
1552 | } | |
1553 | ||
45c365b1 | 1554 | /* Args to -d specify what to dump. Silently ignore |
a2f10574 | 1555 | unrecognized options; they may be aimed at toplev.c. */ |
428a5a4e | 1556 | static void |
2b30d46c | 1557 | handle_OPT_d (const char *arg) |
428a5a4e | 1558 | { |
45c365b1 | 1559 | char c; |
1560 | ||
1561 | while ((c = *arg++) != '\0') | |
1562 | switch (c) | |
1563 | { | |
f7070933 | 1564 | case 'M': /* Dump macros only. */ |
1565 | case 'N': /* Dump names. */ | |
1566 | case 'D': /* Dump definitions. */ | |
34c3de48 | 1567 | case 'U': /* Dump used macros. */ |
f7070933 | 1568 | flag_dump_macros = c; |
45c365b1 | 1569 | break; |
1570 | ||
1571 | case 'I': | |
f7070933 | 1572 | flag_dump_includes = 1; |
45c365b1 | 1573 | break; |
1574 | } | |
428a5a4e | 1575 | } |