1 /* C/ObjC/C++ command line option handling.
2 Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
3 Contributed by Neil Booth.
5 This file is part of GCC.
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
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
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
24 #include "coretypes.h"
31 #include "langhooks.h"
32 #include "tree-inline.h"
33 #include "diagnostic.h"
35 #include "cppdefault.h"
36 #include "c-incpath.h"
37 #include "debug.h" /* For debug_hooks. */
41 #ifndef DOLLARS_IN_IDENTIFIERS
42 # define DOLLARS_IN_IDENTIFIERS true
45 #ifndef TARGET_SYSTEM_ROOT
46 # define TARGET_SYSTEM_ROOT NULL
49 static int saved_lineno;
52 static cpp_options *cpp_opts;
55 static const char *this_input_filename;
57 /* Filename and stream for preprocessed output. */
58 static const char *out_fname;
59 static FILE *out_stream;
61 /* Append dependencies to deps_file. */
62 static bool deps_append;
64 /* If dependency switches (-MF etc.) have been given. */
65 static bool deps_seen;
70 /* Dependency output file. */
71 static const char *deps_file;
73 /* The prefix given by -iprefix, if any. */
74 static const char *iprefix;
76 /* The system root, if any. Overridden by -isysroot. */
77 static const char *sysroot = TARGET_SYSTEM_ROOT;
79 /* Zero disables all standard directories for headers. */
80 static bool std_inc = true;
82 /* Zero disables the C++-specific standard directories for headers. */
83 static bool std_cxx_inc = true;
85 /* If the quote chain has been split by -I-. */
86 static bool quote_chain_split;
88 /* If -Wunused-macros. */
89 static bool warn_unused_macros;
91 /* If -Wvariadic-macros. */
92 static bool warn_variadic_macros = true;
94 /* Number of deferred options. */
95 static size_t deferred_count;
97 /* Number of deferred options scanned for -include. */
98 static size_t include_cursor;
100 /* Permit Fotran front-end options. */
101 static bool permit_fortran_options;
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);
117 #ifndef STDC_0_IN_SYSTEM_HEADERS
118 #define STDC_0_IN_SYSTEM_HEADERS 0
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
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
135 c_common_missing_argument (const char *opt, size_t code)
140 /* Pick up the default message. */
143 case OPT_fconstant_string_class_:
144 error ("no class name specified with \"%s\"", opt);
148 error ("assertion missing after \"%s\"", opt);
153 error ("macro name missing after \"%s\"", opt);
161 error ("missing path after \"%s\"", opt);
170 error ("missing filename after \"%s\"", opt);
175 error ("missing makefile target after \"%s\"", opt);
182 /* Defer option CODE with argument ARG. */
184 defer_opt (enum opt_code code, const char *arg)
186 deferred_opts[deferred_count].code = code;
187 deferred_opts[deferred_count].arg = arg;
191 /* Common initialization before parsing options. */
193 c_common_init_options (unsigned int argc, const char **argv ATTRIBUTE_UNUSED)
195 static const unsigned int lang_flags[] = {CL_C, CL_ObjC, CL_CXX, CL_ObjCXX};
198 /* This is conditionalized only because that is the way the front
199 ends used to do it. Maybe this should be unconditional? */
200 if (c_dialect_cxx ())
202 /* By default wrap lines at 80 characters. Is getenv
203 ("COLUMNS") preferable? */
204 diagnostic_line_cutoff (global_dc) = 80;
205 /* By default, emit location information once for every
206 diagnostic message. */
207 diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
210 parse_in = cpp_create_reader (c_dialect_cxx () ? CLK_GNUCXX: CLK_GNUC89,
211 ident_hash, &line_table);
213 cpp_opts = cpp_get_options (parse_in);
214 cpp_opts->dollars_in_ident = DOLLARS_IN_IDENTIFIERS;
215 cpp_opts->objc = c_dialect_objc ();
217 /* Reset to avoid warnings on internal definitions. We set it just
218 before passing on command-line options to cpplib. */
219 cpp_opts->warn_dollars = 0;
221 flag_const_strings = c_dialect_cxx ();
222 flag_exceptions = c_dialect_cxx ();
223 warn_pointer_arith = c_dialect_cxx ();
225 deferred_opts = xmalloc (argc * sizeof (struct deferred_opt));
227 result = lang_flags[c_language];
229 /* If potentially preprocessing Fortran we have to accept its front
230 end options since the driver passes most of them through. */
232 if (c_language == clk_c && argc > 2
233 && !strcmp (argv[2], "-traditional-cpp" ))
235 permit_fortran_options = true;
243 /* Handle switch SCODE with argument ARG. VALUE is true, unless no-
244 form of an -f or -W option was given. Returns 0 if the switch was
245 invalid, a negative number to prevent language-independent
246 processing in toplev.c (a hack necessary for the short-term). */
248 c_common_handle_option (size_t scode, const char *arg, int value)
250 const struct cl_option *option = &cl_options[scode];
251 enum opt_code code = (enum opt_code) scode;
257 result = permit_fortran_options;
260 case OPT__output_pch_:
265 defer_opt (code, arg);
269 cpp_opts->discard_comments = 0;
273 cpp_opts->discard_comments = 0;
274 cpp_opts->discard_comments_in_macro_exp = 0;
278 defer_opt (code, arg);
282 flag_preprocess_only = 1;
286 cpp_opts->print_include_names = 1;
290 TARGET_OPTF (xstrdup (arg));
294 if (strcmp (arg, "-"))
295 add_path (xstrdup (arg), BRACKET, 0);
298 if (quote_chain_split)
299 error ("-I- specified twice");
300 quote_chain_split = true;
301 split_quote_chain ();
307 /* When doing dependencies with -M or -MM, suppress normal
308 preprocessed output, but still do -dM etc. as software
309 depends on this. Preprocessed output does occur if -MD, -MMD
310 or environment var dependency generation is used. */
311 cpp_opts->deps.style = (code == OPT_M ? DEPS_SYSTEM: DEPS_USER);
313 cpp_opts->inhibit_warnings = 1;
318 cpp_opts->deps.style = (code == OPT_MD ? DEPS_SYSTEM: DEPS_USER);
329 cpp_opts->deps.missing_files = true;
334 cpp_opts->deps.phony_targets = true;
340 defer_opt (code, arg);
344 flag_no_line_commands = 1;
347 case OPT_fworking_directory:
348 flag_working_directory = value;
352 defer_opt (code, arg);
362 set_Wimplicit (value);
363 warn_char_subscripts = value;
364 warn_missing_braces = value;
365 warn_parentheses = value;
366 warn_return_type = value;
367 warn_sequence_point = value; /* Was C only. */
368 if (c_dialect_cxx ())
369 warn_sign_compare = value;
371 warn_strict_aliasing = value;
373 /* Only warn about unknown pragmas that are not in system
375 warn_unknown_pragmas = value;
377 /* We save the value of warn_uninitialized, since if they put
378 -Wuninitialized on the command line, we need to generate a
379 warning about not using it without also specifying -O. */
380 if (warn_uninitialized != 1)
381 warn_uninitialized = (value ? 2 : 0);
383 if (!c_dialect_cxx ())
384 /* We set this to 2 here, but 1 in -Wmain, so -ffreestanding
385 can turn it off only if it's not explicit. */
386 warn_main = value * 2;
389 /* C++-specific warnings. */
390 warn_nonvdtor = value;
391 warn_reorder = value;
392 warn_nontemplate_friend = value;
395 cpp_opts->warn_trigraphs = value;
396 cpp_opts->warn_comments = value;
397 cpp_opts->warn_num_sign_change = value;
398 cpp_opts->warn_multichar = value; /* Was C++ only. */
401 case OPT_Wbad_function_cast:
402 warn_bad_function_cast = value;
406 warn_cast_qual = value;
409 case OPT_Wchar_subscripts:
410 warn_char_subscripts = value;
415 cpp_opts->warn_comments = value;
418 case OPT_Wconversion:
419 warn_conversion = value;
422 case OPT_Wctor_dtor_privacy:
423 warn_ctor_dtor_privacy = value;
426 case OPT_Wdeclaration_after_statement:
427 warn_declaration_after_statement = value;
430 case OPT_Wdeprecated:
431 warn_deprecated = value;
432 cpp_opts->warn_deprecated = value;
435 case OPT_Wdiv_by_zero:
436 warn_div_by_zero = value;
443 case OPT_Wendif_labels:
444 cpp_opts->warn_endif_labels = value;
448 cpp_opts->warnings_are_errors = value;
451 case OPT_Werror_implicit_function_declaration:
452 mesg_implicit_function_declaration = 2;
455 case OPT_Wfloat_equal:
456 warn_float_equal = value;
464 set_Wformat (atoi (arg));
467 case OPT_Wformat_extra_args:
468 warn_format_extra_args = value;
471 case OPT_Wformat_nonliteral:
472 warn_format_nonliteral = value;
475 case OPT_Wformat_security:
476 warn_format_security = value;
479 case OPT_Wformat_y2k:
480 warn_format_y2k = value;
483 case OPT_Wformat_zero_length:
484 warn_format_zero_length = value;
488 warn_init_self = value;
492 set_Wimplicit (value);
495 case OPT_Wimplicit_function_declaration:
496 mesg_implicit_function_declaration = value;
499 case OPT_Wimplicit_int:
500 warn_implicit_int = value;
504 /* Silently ignore for now. */
507 case OPT_Winvalid_offsetof:
508 warn_invalid_offsetof = value;
511 case OPT_Winvalid_pch:
512 cpp_opts->warn_invalid_pch = value;
516 warn_long_long = value;
526 case OPT_Wmissing_braces:
527 warn_missing_braces = value;
530 case OPT_Wmissing_declarations:
531 warn_missing_declarations = value;
534 case OPT_Wmissing_format_attribute:
535 warn_missing_format_attribute = value;
538 case OPT_Wmissing_prototypes:
539 warn_missing_prototypes = value;
543 cpp_opts->warn_multichar = value;
546 case OPT_Wnested_externs:
547 warn_nested_externs = value;
550 case OPT_Wnon_template_friend:
551 warn_nontemplate_friend = value;
554 case OPT_Wnon_virtual_dtor:
555 warn_nonvdtor = value;
559 warn_nonnull = value;
562 case OPT_Wold_style_definition:
563 warn_old_style_definition = value;
566 case OPT_Wold_style_cast:
567 warn_old_style_cast = value;
570 case OPT_Woverloaded_virtual:
571 warn_overloaded_virtual = value;
574 case OPT_Wparentheses:
575 warn_parentheses = value;
578 case OPT_Wpmf_conversions:
579 warn_pmf2ptr = value;
582 case OPT_Wpointer_arith:
583 warn_pointer_arith = value;
587 warn_protocol = value;
591 warn_selector = value;
594 case OPT_Wredundant_decls:
595 warn_redundant_decls = value;
599 warn_reorder = value;
602 case OPT_Wreturn_type:
603 warn_return_type = value;
606 case OPT_Wsequence_point:
607 warn_sequence_point = value;
610 case OPT_Wsign_compare:
611 warn_sign_compare = value;
614 case OPT_Wsign_promo:
615 warn_sign_promo = value;
618 case OPT_Wstrict_prototypes:
619 warn_strict_prototypes = value;
626 case OPT_Wsystem_headers:
627 cpp_opts->warn_system_headers = value;
630 case OPT_Wtraditional:
631 warn_traditional = value;
632 cpp_opts->warn_traditional = value;
636 cpp_opts->warn_trigraphs = value;
639 case OPT_Wundeclared_selector:
640 warn_undeclared_selector = value;
644 cpp_opts->warn_undef = value;
647 case OPT_Wunknown_pragmas:
648 /* Set to greater than 1, so that even unknown pragmas in
649 system headers will be warned about. */
650 warn_unknown_pragmas = value * 2;
653 case OPT_Wunused_macros:
654 warn_unused_macros = value;
657 case OPT_Wvariadic_macros:
658 warn_variadic_macros = value;
661 case OPT_Wwrite_strings:
662 if (!c_dialect_cxx ())
663 flag_const_strings = value;
665 warn_write_strings = value;
669 if (!c_dialect_cxx ())
670 set_std_c89 (false, true);
672 set_std_cxx98 (true);
679 case OPT_fcond_mismatch:
680 if (!c_dialect_cxx ())
682 flag_cond_mismatch = value;
687 case OPT_fall_virtual:
688 case OPT_falt_external_templates:
689 case OPT_fenum_int_equiv:
690 case OPT_fexternal_templates:
691 case OPT_fguiding_decls:
693 case OPT_fhuge_objects:
695 case OPT_fname_mangling_version_:
697 case OPT_fnonnull_objects:
699 case OPT_fstrict_prototype:
700 case OPT_fthis_is_variable:
701 case OPT_fvtable_thunks:
704 warning ("switch \"%s\" is no longer supported", option->opt_text);
707 case OPT_faccess_control:
708 flag_access_control = value;
712 flag_no_asm = !value;
716 flag_no_builtin = !value;
723 disable_builtin_function (arg);
726 case OPT_fdollars_in_identifiers:
727 cpp_opts->dollars_in_ident = value;
731 if (!dump_switch_p (arg))
735 case OPT_ffreestanding:
737 /* Fall through.... */
740 flag_no_builtin = !value;
741 /* warn_main will be 2 if set by -Wall, 1 if set by -Wmain */
742 if (!value && warn_main == 2)
746 case OPT_fshort_double:
747 flag_short_double = value;
750 case OPT_fshort_enums:
751 flag_short_enums = value;
754 case OPT_fshort_wchar:
755 flag_short_wchar = value;
758 case OPT_fsigned_bitfields:
759 flag_signed_bitfields = value;
760 explicit_flag_signed_bitfields = 1;
763 case OPT_fsigned_char:
764 flag_signed_char = value;
767 case OPT_funsigned_bitfields:
768 flag_signed_bitfields = !value;
769 explicit_flag_signed_bitfields = 1;
772 case OPT_funsigned_char:
773 flag_signed_char = !value;
777 flag_check_new = value;
780 case OPT_fconserve_space:
781 flag_conserve_space = value;
784 case OPT_fconst_strings:
785 flag_const_strings = value;
788 case OPT_fconstant_string_class_:
789 constant_string_class_name = arg;
792 case OPT_fdefault_inline:
793 flag_default_inline = value;
796 case OPT_felide_constructors:
797 flag_elide_constructors = value;
800 case OPT_fenforce_eh_specs:
801 flag_enforce_eh_specs = value;
804 case OPT_ffixed_form:
805 case OPT_ffixed_line_length_:
806 /* Fortran front end options ignored when preprocessing only. */
807 if (!flag_preprocess_only)
812 flag_new_for_scope = value;
815 case OPT_fgnu_keywords:
816 flag_no_gnu_keywords = !value;
819 case OPT_fgnu_runtime:
820 flag_next_runtime = !value;
823 case OPT_fhandle_exceptions:
824 warning ("-fhandle-exceptions has been renamed -fexceptions (and is now on by default)");
825 flag_exceptions = value;
828 case OPT_fimplement_inlines:
829 flag_implement_inlines = value;
832 case OPT_fimplicit_inline_templates:
833 flag_implicit_inline_templates = value;
836 case OPT_fimplicit_templates:
837 flag_implicit_templates = value;
840 case OPT_fms_extensions:
841 flag_ms_extensions = value;
844 case OPT_fnext_runtime:
845 flag_next_runtime = value;
848 case OPT_fnil_receivers:
849 flag_nil_receivers = value;
852 case OPT_fnonansi_builtins:
853 flag_no_nonansi_builtin = !value;
856 case OPT_fobjc_exceptions:
857 flag_objc_exceptions = value;
860 case OPT_foperator_names:
861 cpp_opts->operator_names = value;
864 case OPT_foptional_diags:
865 flag_optional_diags = value;
869 cpp_opts->restore_pch_deps = value;
872 case OPT_fpermissive:
873 flag_permissive = value;
876 case OPT_fpreprocessed:
877 cpp_opts->preprocessed = value;
880 case OPT_freplace_objc_classes:
881 flag_replace_objc_classes = value;
885 flag_use_repository = value;
887 flag_implicit_templates = 0;
894 case OPT_fshow_column:
895 cpp_opts->show_column = value;
899 flag_detailed_statistics = value;
903 /* It is documented that we silently ignore silly values. */
904 if (value >= 1 && value <= 100)
905 cpp_opts->tabstop = value;
908 case OPT_fexec_charset_:
909 cpp_opts->narrow_charset = arg;
912 case OPT_fwide_exec_charset_:
913 cpp_opts->wide_charset = arg;
916 case OPT_finput_charset_:
917 cpp_opts->input_charset = arg;
920 case OPT_ftemplate_depth_:
921 max_tinst_depth = value;
924 case OPT_fuse_cxa_atexit:
925 flag_use_cxa_atexit = value;
933 flag_zero_link = value;
937 flag_gen_declaration = 1;
941 add_path (xstrdup (arg), AFTER, 0);
946 defer_opt (code, arg);
958 add_path (xstrdup (arg), SYSTEM, 0);
961 case OPT_iwithprefix:
962 add_prefixed_path (arg, SYSTEM);
965 case OPT_iwithprefixbefore:
966 add_prefixed_path (arg, BRACKET);
970 cpp_set_lang (parse_in, CLK_ASM);
971 cpp_opts->dollars_in_ident = false;
990 error ("output filename specified twice");
993 /* We need to handle the -pedantic switches here, rather than in
994 c_common_post_options, so that a subsequent -Wno-endif-labels
995 is not overridden. */
996 case OPT_pedantic_errors:
997 cpp_opts->pedantic_errors = 1;
1000 cpp_opts->pedantic = 1;
1001 cpp_opts->warn_endif_labels = 1;
1004 case OPT_print_objc_runtime_info:
1005 print_struct_values = 1;
1009 cpp_opts->remap = 1;
1013 case OPT_std_gnu__98:
1014 set_std_cxx98 (code == OPT_std_c__98 /* ISO */);
1018 case OPT_std_iso9899_1990:
1019 case OPT_std_iso9899_199409:
1020 set_std_c89 (code == OPT_std_iso9899_199409 /* c94 */, true /* ISO */);
1024 set_std_c89 (false /* c94 */, false /* ISO */);
1029 case OPT_std_iso9899_1999:
1030 case OPT_std_iso9899_199x:
1031 set_std_c99 (true /* ISO */);
1036 set_std_c99 (false /* ISO */);
1040 cpp_opts->trigraphs = 1;
1043 case OPT_traditional_cpp:
1044 cpp_opts->traditional = 1;
1052 cpp_opts->inhibit_warnings = 1;
1063 /* Post-switch processing. */
1065 c_common_post_options (const char **pfilename)
1067 struct cpp_callbacks *cb;
1069 /* Canonicalize the input and output filenames. */
1070 if (in_fnames == NULL)
1072 in_fnames = xmalloc (sizeof (in_fnames[0]));
1075 else if (strcmp (in_fnames[0], "-") == 0)
1078 if (out_fname == NULL || !strcmp (out_fname, "-"))
1081 if (cpp_opts->deps.style == DEPS_NONE)
1082 check_deps_environment_vars ();
1084 handle_deferred_opts ();
1086 sanitize_cpp_opts ();
1088 register_include_chains (parse_in, sysroot, iprefix,
1089 std_inc, std_cxx_inc && c_dialect_cxx (), verbose);
1091 flag_inline_trees = 1;
1093 /* Use tree inlining if possible. Function instrumentation is only
1094 done in the RTL level, so we disable tree inlining. */
1095 if (! flag_instrument_function_entry_exit)
1097 if (!flag_no_inline)
1099 if (flag_inline_functions)
1101 flag_inline_trees = 2;
1102 flag_inline_functions = 0;
1106 /* -Wextra implies -Wsign-compare, but not if explicitly
1108 if (warn_sign_compare == -1)
1109 warn_sign_compare = extra_warnings;
1111 /* Special format checking options don't work without -Wformat; warn if
1113 if (warn_format_y2k && !warn_format)
1114 warning ("-Wformat-y2k ignored without -Wformat");
1115 if (warn_format_extra_args && !warn_format)
1116 warning ("-Wformat-extra-args ignored without -Wformat");
1117 if (warn_format_zero_length && !warn_format)
1118 warning ("-Wformat-zero-length ignored without -Wformat");
1119 if (warn_format_nonliteral && !warn_format)
1120 warning ("-Wformat-nonliteral ignored without -Wformat");
1121 if (warn_format_security && !warn_format)
1122 warning ("-Wformat-security ignored without -Wformat");
1123 if (warn_missing_format_attribute && !warn_format)
1124 warning ("-Wmissing-format-attribute ignored without -Wformat");
1126 if (flag_preprocess_only)
1128 /* Open the output now. We must do so even if flag_no_output is
1129 on, because there may be other output than from the actual
1130 preprocessing (e.g. from -dM). */
1131 if (out_fname[0] == '\0')
1132 out_stream = stdout;
1134 out_stream = fopen (out_fname, "w");
1136 if (out_stream == NULL)
1138 fatal_error ("opening output file %s: %m", out_fname);
1142 if (num_in_fnames > 1)
1143 error ("too many filenames given. Type %s --help for usage",
1146 init_pp_output (out_stream);
1152 /* Yuk. WTF is this? I do know ObjC relies on it somewhere. */
1156 cb = cpp_get_callbacks (parse_in);
1157 cb->file_change = cb_file_change;
1158 cb->dir_change = cb_dir_change;
1159 cpp_post_options (parse_in);
1161 saved_lineno = input_line;
1164 /* If an error has occurred in cpplib, note it so we fail
1166 errorcount += cpp_errors (parse_in);
1168 *pfilename = this_input_filename
1169 = cpp_read_main_file (parse_in, in_fnames[0]);
1170 if (this_input_filename == NULL)
1173 if (flag_working_directory
1174 && flag_preprocess_only && ! flag_no_line_commands)
1175 pp_dir_change (parse_in, get_src_pwd ());
1177 return flag_preprocess_only;
1180 /* Front end initialization common to C, ObjC and C++. */
1182 c_common_init (void)
1184 input_line = saved_lineno;
1186 /* Set up preprocessor arithmetic. Must be done after call to
1187 c_common_nodes_and_builtins for type nodes to be good. */
1188 cpp_opts->precision = TYPE_PRECISION (intmax_type_node);
1189 cpp_opts->char_precision = TYPE_PRECISION (char_type_node);
1190 cpp_opts->int_precision = TYPE_PRECISION (integer_type_node);
1191 cpp_opts->wchar_precision = TYPE_PRECISION (wchar_type_node);
1192 cpp_opts->unsigned_wchar = TREE_UNSIGNED (wchar_type_node);
1193 cpp_opts->bytes_big_endian = BYTES_BIG_ENDIAN;
1195 /* This can't happen until after wchar_precision and bytes_big_endian
1197 cpp_init_iconv (parse_in);
1199 if (flag_preprocess_only)
1202 preprocess_file (parse_in);
1206 /* Has to wait until now so that cpplib has its hash table. */
1212 /* Initialize the integrated preprocessor after debug output has been
1213 initialized; loop over each input file. */
1215 c_common_parse_file (int set_yydebug ATTRIBUTE_UNUSED)
1217 unsigned file_index;
1220 yydebug = set_yydebug;
1222 warning ("YYDEBUG not defined");
1231 /* Reset the state of the parser. */
1234 /* Reset cpplib's macros and start a new file. */
1235 cpp_undef_all (parse_in);
1236 main_input_filename = this_input_filename
1237 = cpp_read_main_file (parse_in, in_fnames[file_index]);
1238 if (this_input_filename == NULL)
1242 if (file_index == 0)
1247 } while (file_index < num_in_fnames);
1252 /* Common finish hook for the C, ObjC and C++ front ends. */
1254 c_common_finish (void)
1256 FILE *deps_stream = NULL;
1258 if (cpp_opts->deps.style != DEPS_NONE)
1260 /* If -M or -MM was seen without -MF, default output to the
1263 deps_stream = out_stream;
1266 deps_stream = fopen (deps_file, deps_append ? "a": "w");
1268 fatal_error ("opening dependency file %s: %m", deps_file);
1272 /* For performance, avoid tearing down cpplib's internal structures
1273 with cpp_destroy (). */
1274 errorcount += cpp_finish (parse_in, deps_stream);
1276 if (deps_stream && deps_stream != out_stream
1277 && (ferror (deps_stream) || fclose (deps_stream)))
1278 fatal_error ("closing dependency file %s: %m", deps_file);
1280 if (out_stream && (ferror (out_stream) || fclose (out_stream)))
1281 fatal_error ("when writing output to %s: %m", out_fname);
1284 /* Either of two environment variables can specify output of
1285 dependencies. Their value is either "OUTPUT_FILE" or "OUTPUT_FILE
1286 DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to
1287 and DEPS_TARGET is the target to mention in the deps. They also
1288 result in dependency information being appended to the output file
1289 rather than overwriting it, and like Sun's compiler
1290 SUNPRO_DEPENDENCIES suppresses the dependency on the main file. */
1292 check_deps_environment_vars (void)
1296 GET_ENVIRONMENT (spec, "DEPENDENCIES_OUTPUT");
1298 cpp_opts->deps.style = DEPS_USER;
1301 GET_ENVIRONMENT (spec, "SUNPRO_DEPENDENCIES");
1304 cpp_opts->deps.style = DEPS_SYSTEM;
1305 cpp_opts->deps.ignore_main_file = true;
1311 /* Find the space before the DEPS_TARGET, if there is one. */
1312 char *s = strchr (spec, ' ');
1315 /* Let the caller perform MAKE quoting. */
1316 defer_opt (OPT_MT, s + 1);
1320 /* Command line -MF overrides environment variables and default. */
1328 /* Handle deferred command line switches. */
1330 handle_deferred_opts (void)
1334 for (i = 0; i < deferred_count; i++)
1336 struct deferred_opt *opt = &deferred_opts[i];
1338 if (opt->code == OPT_MT || opt->code == OPT_MQ)
1339 cpp_add_dependency_target (parse_in, opt->arg, opt->code == OPT_MQ);
1343 /* These settings are appropriate for GCC, but not necessarily so for
1344 cpplib as a library. */
1346 sanitize_cpp_opts (void)
1348 /* If we don't know what style of dependencies to output, complain
1349 if any other dependency switches have been given. */
1350 if (deps_seen && cpp_opts->deps.style == DEPS_NONE)
1351 error ("to generate dependencies you must specify either -M or -MM");
1353 /* -dM and dependencies suppress normal output; do it here so that
1354 the last -d[MDN] switch overrides earlier ones. */
1355 if (flag_dump_macros == 'M')
1358 /* Disable -dD, -dN and -dI if normal output is suppressed. Allow
1359 -dM since at least glibc relies on -M -dM to work. */
1362 if (flag_dump_macros != 'M')
1363 flag_dump_macros = 0;
1364 flag_dump_includes = 0;
1367 cpp_opts->unsigned_char = !flag_signed_char;
1368 cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS;
1370 /* We want -Wno-long-long to override -pedantic -std=non-c99
1371 and/or -Wtraditional, whatever the ordering. */
1372 cpp_opts->warn_long_long
1373 = warn_long_long && ((!flag_isoc99 && pedantic) || warn_traditional);
1375 /* Similarly with -Wno-variadic-macros. No check for c99 here, since
1376 this also turns off warnings about GCCs extension. */
1377 cpp_opts->warn_variadic_macros
1378 = warn_variadic_macros && (pedantic || warn_traditional);
1380 /* If we're generating preprocessor output, emit current directory
1381 if explicitly requested or if debugging information is enabled.
1382 ??? Maybe we should only do it for debugging formats that
1383 actually output the current directory? */
1384 if (flag_working_directory == -1)
1385 flag_working_directory = (debug_info_level != DINFO_LEVEL_NONE);
1388 /* Add include path with a prefix at the front of its name. */
1390 add_prefixed_path (const char *suffix, size_t chain)
1394 size_t prefix_len, suffix_len;
1396 suffix_len = strlen (suffix);
1397 prefix = iprefix ? iprefix : cpp_GCC_INCLUDE_DIR;
1398 prefix_len = iprefix ? strlen (iprefix) : cpp_GCC_INCLUDE_DIR_len;
1400 path = xmalloc (prefix_len + suffix_len + 1);
1401 memcpy (path, prefix, prefix_len);
1402 memcpy (path + prefix_len, suffix, suffix_len);
1403 path[prefix_len + suffix_len] = '\0';
1405 add_path (path, chain, 0);
1408 /* Handle -D, -U, -A, -imacros, and the first -include. */
1410 finish_options (void)
1412 if (!cpp_opts->preprocessed)
1416 cpp_change_file (parse_in, LC_RENAME, _("<built-in>"));
1417 cpp_init_builtins (parse_in, flag_hosted);
1418 c_cpp_builtins (parse_in);
1420 /* We're about to send user input to cpplib, so make it warn for
1421 things that we previously (when we sent it internal definitions)
1422 told it to not warn.
1424 C99 permits implementation-defined characters in identifiers.
1425 The documented meaning of -std= is to turn off extensions that
1426 conflict with the specified standard, and since a strictly
1427 conforming program cannot contain a '$', we do not condition
1428 their acceptance on the -std= setting. */
1429 cpp_opts->warn_dollars = (cpp_opts->pedantic && !cpp_opts->c99);
1431 cpp_change_file (parse_in, LC_RENAME, _("<command line>"));
1432 for (i = 0; i < deferred_count; i++)
1434 struct deferred_opt *opt = &deferred_opts[i];
1436 if (opt->code == OPT_D)
1437 cpp_define (parse_in, opt->arg);
1438 else if (opt->code == OPT_U)
1439 cpp_undef (parse_in, opt->arg);
1440 else if (opt->code == OPT_A)
1442 if (opt->arg[0] == '-')
1443 cpp_unassert (parse_in, opt->arg + 1);
1445 cpp_assert (parse_in, opt->arg);
1449 /* Handle -imacros after -D and -U. */
1450 for (i = 0; i < deferred_count; i++)
1452 struct deferred_opt *opt = &deferred_opts[i];
1454 if (opt->code == OPT_imacros
1455 && cpp_push_include (parse_in, opt->arg))
1457 /* Disable push_command_line_include callback for now. */
1458 include_cursor = deferred_count + 1;
1459 cpp_scan_nooutput (parse_in);
1465 push_command_line_include ();
1468 /* Give CPP the next file given by -include, if any. */
1470 push_command_line_include (void)
1472 while (include_cursor < deferred_count)
1474 struct deferred_opt *opt = &deferred_opts[include_cursor++];
1476 if (! cpp_opts->preprocessed && opt->code == OPT_include
1477 && cpp_push_include (parse_in, opt->arg))
1481 if (include_cursor == deferred_count)
1484 /* -Wunused-macros should only warn about macros defined hereafter. */
1485 cpp_opts->warn_unused_macros = warn_unused_macros;
1486 /* Restore the line map from <command line>. */
1487 if (! cpp_opts->preprocessed)
1488 cpp_change_file (parse_in, LC_RENAME, main_input_filename);
1490 /* Set this here so the client can change the option if it wishes,
1491 and after stacking the main file so we don't trace the main file. */
1492 line_table.trace_includes = cpp_opts->print_include_names;
1496 /* File change callback. Has to handle -include files. */
1498 cb_file_change (cpp_reader *pfile ATTRIBUTE_UNUSED,
1499 const struct line_map *new_map)
1501 if (flag_preprocess_only)
1502 pp_file_change (new_map);
1504 fe_file_change (new_map);
1506 if (new_map == 0 || (new_map->reason == LC_LEAVE && MAIN_FILE_P (new_map)))
1507 push_command_line_include ();
1511 cb_dir_change (cpp_reader *pfile ATTRIBUTE_UNUSED, const char *dir)
1513 if (! set_src_pwd (dir))
1514 warning ("too late for # directive to set debug directory");
1517 /* Set the C 89 standard (with 1994 amendments if C94, without GNU
1518 extensions if ISO). There is no concept of gnu94. */
1520 set_std_c89 (int c94, int iso)
1522 cpp_set_lang (parse_in, c94 ? CLK_STDC94: iso ? CLK_STDC89: CLK_GNUC89);
1525 flag_no_gnu_keywords = iso;
1526 flag_no_nonansi_builtin = iso;
1531 /* Set the C 99 standard (without GNU extensions if ISO). */
1533 set_std_c99 (int iso)
1535 cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99);
1537 flag_no_nonansi_builtin = iso;
1543 /* Set the C++ 98 standard (without GNU extensions if ISO). */
1545 set_std_cxx98 (int iso)
1547 cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX);
1548 flag_no_gnu_keywords = iso;
1549 flag_no_nonansi_builtin = iso;
1553 /* Handle setting implicit to ON. */
1555 set_Wimplicit (int on)
1558 warn_implicit_int = on;
1561 if (mesg_implicit_function_declaration != 2)
1562 mesg_implicit_function_declaration = 1;
1565 mesg_implicit_function_declaration = 0;
1568 /* Args to -d specify what to dump. Silently ignore
1569 unrecognized options; they may be aimed at toplev.c. */
1571 handle_OPT_d (const char *arg)
1575 while ((c = *arg++) != '\0')
1578 case 'M': /* Dump macros only. */
1579 case 'N': /* Dump names. */
1580 case 'D': /* Dump definitions. */
1581 flag_dump_macros = c;
1585 flag_dump_includes = 1;