OSDN Git Service

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