OSDN Git Service

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