OSDN Git Service

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