OSDN Git Service

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