OSDN Git Service

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