OSDN Git Service

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