#include "config.h"
#include "system.h"
+#include "intl.h"
#include "coretypes.h"
#include "tm.h"
#include "tree.h"
+#include "rtl.h"
+#include "ggc.h"
+#include "output.h"
#include "langhooks.h"
#include "opts.h"
#include "options.h"
#include "flags.h"
#include "toplev.h"
+#include "params.h"
+#include "diagnostic.h"
+#include "tm_p.h" /* For OPTIMIZATION_OPTIONS. */
+#include "insn-attr.h" /* For INSN_SCHEDULING. */
/* Value of the -G xx switch, and whether it was passed or not. */
unsigned HOST_WIDE_INT g_switch_value;
/* If -version. */
bool version_flag;
+/* Print various extra warnings. -W/-Wextra. */
+bool extra_warnings;
+
+/* Don't print warning messages. -w. */
+bool inhibit_warnings;
+
+/* Treat warnings as errors. -Werror. */
+bool warnings_are_errors;
+
+/* Warn if a function returns an aggregate, since there are often
+ incompatible calling conventions for doing this. */
+bool warn_aggregate_return;
+
+/* Nonzero means warn about pointer casts that increase the required
+ alignment of the target type (and might therefore lead to a crash
+ due to a misaligned access). */
+bool warn_cast_align;
+
+/* Nonzero means warn about uses of __attribute__((deprecated))
+ declarations. */
+bool warn_deprecated_decl = true;
+
+/* Warn when an optimization pass is disabled. */
+bool warn_disabled_optimization;
+
+/* Nonzero means warn if inline function is too large. */
+bool warn_inline;
+
+/* True to warn about any objects definitions whose size is larger
+ than N bytes. Also want about function definitions whose returned
+ values are larger than N bytes, where N is `larger_than_size'. */
+bool warn_larger_than;
+HOST_WIDE_INT larger_than_size;
+
+/* Warn about functions which might be candidates for attribute noreturn. */
+bool warn_missing_noreturn;
+
+/* True to warn about code which is never reached. */
+bool warn_notreached;
+
+/* Warn if packed attribute on struct is unnecessary and inefficient. */
+bool warn_packed;
+
+/* Warn when gcc pads a structure to an alignment boundary. */
+bool warn_padded;
+
+/* True means warn about all declarations which shadow others. */
+bool warn_shadow;
+
+/* Nonzero means warn about constructs which might not be
+ strict-aliasing safe. */
+bool warn_strict_aliasing;
+
+/* True to warn if a switch on an enum, that does not have a default
+ case, fails to have a case for every enum value. */
+bool warn_switch;
+
+/* Warn if a switch does not have a default case. */
+bool warn_switch_default;
+
+/* Warn if a switch on an enum fails to have a case for every enum
+ value (regardless of the presence or otherwise of a default case). */
+bool warn_switch_enum;
+
+/* Don't suppress warnings from system headers. -Wsystem-headers. */
+bool warn_system_headers;
+
+/* True to warn about variables used before they are initialized. */
+int warn_uninitialized;
+
+/* True to warn about unused variables, functions et.al. */
+bool warn_unused_function;
+bool warn_unused_label;
+bool warn_unused_parameter;
+bool warn_unused_variable;
+bool warn_unused_value;
+
+/* Hack for cooperation between set_Wunused and set_Wextra. */
+static bool maybe_warn_unused_parameter;
+
+/* Type(s) of debugging information we are producing (if any). See
+ flags.h for the definitions of the different possible types of
+ debugging information. */
+enum debug_info_type write_symbols = NO_DEBUG;
+
+/* Level of debugging information we are producing. See flags.h for
+ the definitions of the different possible levels. */
+enum debug_info_level debug_info_level = DINFO_LEVEL_NONE;
+
+/* Nonzero means use GNU-only extensions in the generated symbolic
+ debugging information. Currently, this only has an effect when
+ write_symbols is set to DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG. */
+bool use_gnu_debug_info_extensions;
+
+/* Columns of --help display. */
+static unsigned int columns = 80;
+
+/* What to print when a switch has no documentation. */
+static const char undocumented_msg[] = N_("This switch lacks documentation");
+
+/* Input file names. */
+const char **in_fnames;
+unsigned num_in_fnames;
+
static size_t find_opt (const char *, int);
static int common_handle_option (size_t scode, const char *arg, int value);
+static void handle_param (const char *);
+static void set_Wextra (int);
+static unsigned int handle_option (const char **argv, unsigned int lang_mask);
+static char *write_langs (unsigned int lang_mask);
+static void complain_wrong_lang (const char *, const struct cl_option *,
+ unsigned int lang_mask);
+static void handle_options (unsigned int, const char **, unsigned int);
+static void wrap_help (const char *help, const char *item, unsigned int);
+static void print_help (void);
+static void print_param_help (void);
+static void print_filtered_help (unsigned int flag);
+static unsigned int print_switch (const char *text, unsigned int indent);
+static void set_debug_level (enum debug_info_type type, int extended,
+ const char *arg);
/* Perform a binary search to find which option the command-line INPUT
- matches. Returns its index in the option array, and N_OPTS on
- failure.
-
- Complications arise since some options can be suffixed with an
- argument, and multiple complete matches can occur, e.g. -pedantic
- and -pedantic-errors. Also, some options are only accepted by some
- languages. If a switch matches for a different language and
- doesn't match any alternatives for the true front end, the index of
- the matched switch is returned anyway. The caller should check for
- this case. */
+ matches. Returns its index in the option array, and N_OPTS
+ (cl_options_count) on failure.
+
+ This routine is quite subtle. A normal binary search is not good
+ enough because some options can be suffixed with an argument, and
+ multiple sub-matches can occur, e.g. input of "-pedantic" matching
+ the initial substring of "-pedantic-errors".
+
+ A more complicated example is -gstabs. It should match "-g" with
+ an argument of "stabs". Suppose, however, that the number and list
+ of switches are such that the binary search tests "-gen-decls"
+ before having tested "-g". This doesn't match, and as "-gen-decls"
+ is less than "-gstabs", it will become the lower bound of the
+ binary search range, and "-g" will never be seen. To resolve this
+ issue, opts.sh makes "-gen-decls" point, via the back_chain member,
+ to "-g" so that failed searches that end between "-gen-decls" and
+ the lexicographically subsequent switch know to go back and see if
+ "-g" causes a match (which it does in this example).
+
+ This search is done in such a way that the longest match for the
+ front end in question wins. If there is no match for the current
+ front end, the longest match for a different front end is returned
+ (or N_OPTS if none) and the caller emits an error message. */
static size_t
find_opt (const char *input, int lang_mask)
{
- size_t md, mn, mx;
- size_t opt_len;
- size_t result = cl_options_count;
+ size_t mn, mx, md, opt_len;
+ size_t match_wrong_lang;
int comp;
mn = 0;
mx = cl_options_count;
- while (mx > mn)
+ /* Find mn such this lexicographical inequality holds:
+ cl_options[mn] <= input < cl_options[mn + 1]. */
+ while (mx - mn > 1)
{
md = (mn + mx) / 2;
-
opt_len = cl_options[md].opt_len;
- comp = strncmp (input, cl_options[md].opt_text, opt_len);
+ comp = strncmp (input, cl_options[md].opt_text + 1, opt_len);
if (comp < 0)
mx = md;
- else if (comp > 0)
- mn = md + 1;
else
- {
- /* The switch matches. It it an exact match? */
- if (input[opt_len] == '\0')
- return md;
- else
- {
- mn = md + 1;
-
- /* If the switch takes no arguments this is not a proper
- match, so we continue the search (e.g. input="stdc++"
- match was "stdc"). */
- if (!(cl_options[md].flags & CL_JOINED))
- continue;
+ mn = md;
+ }
- /* Is this switch valid for this front end? */
- if (!(cl_options[md].flags & lang_mask))
- {
- /* If subsequently we don't find a better match,
- return this and let the caller report it as a bad
- match. */
- result = md;
- continue;
- }
+ /* This is the switch that is the best match but for a different
+ front end, or cl_options_count if there is no match at all. */
+ match_wrong_lang = cl_options_count;
- /* Two scenarios remain: we have the switch's argument,
- or we match a longer option. This can happen with
- -iwithprefix and -withprefixbefore. The longest
- possible option match succeeds.
+ /* Backtrace the chain of possible matches, returning the longest
+ one, if any, that fits best. With current GCC switches, this
+ loop executes at most twice. */
+ do
+ {
+ const struct cl_option *opt = &cl_options[mn];
- Scan forwards, and return an exact match. Otherwise
- return the longest valid option-accepting match (mx).
- This loops at most twice with current options. */
- mx = md;
- for (md = md + 1; md < cl_options_count; md++)
- {
- opt_len = cl_options[md].opt_len;
- if (strncmp (input, cl_options[md].opt_text, opt_len))
- break;
- if (input[opt_len] == '\0')
- return md;
- if (cl_options[md].flags & lang_mask
- && cl_options[md].flags & CL_JOINED)
- mx = md;
- }
+ /* Is this switch a prefix of the input? */
+ if (!strncmp (input, opt->opt_text + 1, opt->opt_len))
+ {
+ /* If language is OK, and the match is exact or the switch
+ takes a joined argument, return it. */
+ if ((opt->flags & lang_mask)
+ && (input[opt->opt_len] == '\0' || (opt->flags & CL_JOINED)))
+ return mn;
- return mx;
- }
+ /* If we haven't remembered a prior match, remember this
+ one. Any prior match is necessarily better. */
+ if (match_wrong_lang == cl_options_count)
+ match_wrong_lang = mn;
}
+
+ /* Try the next possibility. This is cl_options_count if there
+ are no more. */
+ mn = opt->back_chain;
}
+ while (mn != cl_options_count);
- return result;
+ /* Return the best wrong match, or cl_options_count if none. */
+ return match_wrong_lang;
}
-/* If ARG is a postive integer made up solely of digits, return its
+/* If ARG is a non-negative integer made up solely of digits, return its
value, otherwise return -1. */
static int
integral_argument (const char *arg)
return -1;
}
-/* Handle the switch beginning at ARGV, with ARGC remaining. */
-int
-handle_option (int argc ATTRIBUTE_UNUSED, char **argv, int lang_mask)
+/* Return a malloced slash-separated list of languages in MASK. */
+static char *
+write_langs (unsigned int mask)
+{
+ unsigned int n = 0, len = 0;
+ const char *lang_name;
+ char *result;
+
+ for (n = 0; (lang_name = lang_names[n]) != 0; n++)
+ if (mask & (1U << n))
+ len += strlen (lang_name) + 1;
+
+ result = xmalloc (len);
+ len = 0;
+ for (n = 0; (lang_name = lang_names[n]) != 0; n++)
+ if (mask & (1U << n))
+ {
+ if (len)
+ result[len++] = '/';
+ strcpy (result + len, lang_name);
+ len += strlen (lang_name);
+ }
+
+ result[len] = 0;
+
+ return result;
+}
+
+/* Complain that switch OPT_INDEX does not apply to this front end. */
+static void
+complain_wrong_lang (const char *text, const struct cl_option *option,
+ unsigned int lang_mask)
+{
+ char *ok_langs, *bad_lang;
+
+ ok_langs = write_langs (option->flags);
+ bad_lang = write_langs (lang_mask);
+
+ /* Eventually this should become a hard error IMO. */
+ warning ("command line option \"%s\" is valid for %s but not for %s",
+ text, ok_langs, bad_lang);
+
+ free (ok_langs);
+ free (bad_lang);
+}
+
+/* Handle the switch beginning at ARGV for the language indicated by
+ LANG_MASK. Returns the number of switches consumed. */
+static unsigned int
+handle_option (const char **argv, unsigned int lang_mask)
{
size_t opt_index;
const char *opt, *arg = 0;
char *dup = 0;
int value = 1;
- int result = 0, temp;
+ unsigned int result = 0;
const struct cl_option *option;
opt = argv[0];
- /* Interpret "-" or a non-switch as a file name. */
- if (opt[0] != '-' || opt[1] == '\0')
+ /* Drop the "no-" from negative switches. */
+ if ((opt[1] == 'W' || opt[1] == 'f')
+ && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-')
{
- opt_index = cl_options_count;
- arg = opt;
- main_input_filename = opt;
- result = (*lang_hooks.handle_option) (opt_index, arg, value);
+ size_t len = strlen (opt) - 3;
+
+ dup = xmalloc (len + 1);
+ dup[0] = '-';
+ dup[1] = opt[1];
+ memcpy (dup + 2, opt + 5, len - 2 + 1);
+ opt = dup;
+ value = 0;
}
- else
- {
- /* Drop the "no-" from negative switches. */
- if ((opt[1] == 'W' || opt[1] == 'f')
- && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-')
- {
- size_t len = strlen (opt) - 3;
-
- dup = xmalloc (len + 1);
- dup[0] = '-';
- dup[1] = opt[1];
- memcpy (dup + 2, opt + 5, len - 2 + 1);
- opt = dup;
- value = 0;
- }
- opt_index = find_opt (opt + 1, lang_mask | CL_COMMON);
- if (opt_index == cl_options_count)
- goto done;
+ opt_index = find_opt (opt + 1, lang_mask | CL_COMMON);
+ if (opt_index == cl_options_count)
+ goto done;
+
+ option = &cl_options[opt_index];
- option = &cl_options[opt_index];
+ /* Reject negative form of switches that don't take negatives as
+ unrecognized. */
+ if (!value && (option->flags & CL_REJECT_NEGATIVE))
+ goto done;
- /* Reject negative form of switches that don't take negatives. */
- if (!value && (option->flags & CL_REJECT_NEGATIVE))
- goto done;
+ /* We've recognized this switch. */
+ result = 1;
- /* We've recognized this switch. */
- result = 1;
+ /* Sort out any argument the switch takes. */
+ if (option->flags & CL_JOINED)
+ {
+ /* Have arg point to the original switch. This is because
+ some code, such as disable_builtin_function, expects its
+ argument to be persistent until the program exits. */
+ arg = argv[0] + cl_options[opt_index].opt_len + 1;
+ if (!value)
+ arg += strlen ("no-");
- /* Sort out any argument the switch takes. */
- if (option->flags & CL_JOINED)
+ if (*arg == '\0' && !(option->flags & CL_MISSING_OK))
{
- /* Have arg point to the original switch. This is because
- some code, such as disable_builtin_function, expects its
- argument to be persistent until the program exits. */
- arg = argv[0] + cl_options[opt_index].opt_len + 1;
- if (!value)
- arg += strlen ("no-");
-
- if (*arg == '\0' && !(option->flags & CL_MISSING_OK))
+ if (option->flags & CL_SEPARATE)
{
- if (option->flags & CL_SEPARATE)
- {
- arg = argv[1];
- result = 2;
- }
- else
- /* Missing argument. */
- arg = NULL;
+ arg = argv[1];
+ result = 2;
}
+ else
+ /* Missing argument. */
+ arg = NULL;
}
- else if (option->flags & CL_SEPARATE)
+ }
+ else if (option->flags & CL_SEPARATE)
+ {
+ arg = argv[1];
+ result = 2;
+ }
+
+ /* Now we've swallowed any potential argument, complain if this
+ is a switch for a different front end. */
+ if (!(option->flags & (lang_mask | CL_COMMON)))
+ {
+ complain_wrong_lang (argv[0], option, lang_mask);
+ goto done;
+ }
+
+ if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE)))
+ {
+ if (!(*lang_hooks.missing_argument) (opt, opt_index))
+ error ("missing argument to \"%s\"", opt);
+ goto done;
+ }
+
+ /* If the switch takes an integer, convert it. */
+ if (arg && (option->flags & CL_UINTEGER))
+ {
+ value = integral_argument (arg);
+ if (value == -1)
{
- arg = argv[1];
- result = 2;
+ error ("argument to \"%s\" should be a non-negative integer",
+ option->opt_text);
+ goto done;
}
+ }
+
+ if (option->flags & lang_mask)
+ if ((*lang_hooks.handle_option) (opt_index, arg, value) == 0)
+ result = 0;
+
+ if (result && (option->flags & CL_COMMON))
+ if (common_handle_option (opt_index, arg, value) == 0)
+ result = 0;
+
+ done:
+ if (dup)
+ free (dup);
+ return result;
+}
+
+/* Decode and handle the vector of command line options. LANG_MASK
+ contains has a single bit set representing the current
+ language. */
+static void
+handle_options (unsigned int argc, const char **argv, unsigned int lang_mask)
+{
+ unsigned int n, i;
+
+ for (i = 1; i < argc; i += n)
+ {
+ const char *opt = argv[i];
- /* If the switch takes an integer, convert it. */
- if (arg && (option->flags & CL_UINTEGER))
+ /* Interpret "-" or a non-switch as a file name. */
+ if (opt[0] != '-' || opt[1] == '\0')
{
- value = integral_argument (arg);
- if (value == -1)
- {
- error ("argument to \"-%s\" should be a non-negative integer",
- option->opt_text);
- goto done;
- }
+ main_input_filename = opt;
+ add_input_filename (opt);
+ n = 1;
+ continue;
}
- if (option->flags & lang_mask)
+ n = handle_option (argv + i, lang_mask);
+
+ if (!n)
{
- temp = (*lang_hooks.handle_option) (opt_index, arg, value);
- if (temp <= 0)
- result = temp;
+ n = 1;
+ error ("unrecognized command line option \"%s\"", opt);
}
+ }
+}
+
+/* Handle FILENAME from the command line. */
+void
+add_input_filename (const char *filename)
+{
+ num_in_fnames++;
+ in_fnames = xrealloc (in_fnames, num_in_fnames * sizeof (in_fnames[0]));
+ in_fnames[num_in_fnames - 1] = filename;
+}
+
+/* Parse command line options and set default flag values. Do minimal
+ options processing. */
+void
+decode_options (unsigned int argc, const char **argv)
+{
+ unsigned int i, lang_mask;
+
+ /* Perform language-specific options initialization. */
+ lang_mask = (*lang_hooks.init_options) (argc, argv);
- if (result > 0 && (option->flags & CL_COMMON))
+ lang_hooks.initialize_diagnostics (global_dc);
+
+ /* Scan to see what optimization level has been specified. That will
+ determine the default value of many flags. */
+ for (i = 1; i < argc; i++)
+ {
+ if (!strcmp (argv[i], "-O"))
+ {
+ optimize = 1;
+ optimize_size = 0;
+ }
+ else if (argv[i][0] == '-' && argv[i][1] == 'O')
{
- if (common_handle_option (opt_index, arg, value) == 0)
- result = 0;
+ /* Handle -Os, -O2, -O3, -O69, ... */
+ const char *p = &argv[i][2];
+
+ if ((p[0] == 's') && (p[1] == 0))
+ {
+ optimize_size = 1;
+
+ /* Optimizing for size forces optimize to be 2. */
+ optimize = 2;
+ }
+ else
+ {
+ const int optimize_val = read_integral_parameter (p, p - 2, -1);
+ if (optimize_val != -1)
+ {
+ optimize = optimize_val;
+ optimize_size = 0;
+ }
+ }
}
}
- done:
- if (dup)
- free (dup);
- return result;
+ if (!optimize)
+ {
+ flag_merge_constants = 0;
+ }
+
+ if (optimize >= 1)
+ {
+ flag_defer_pop = 1;
+ flag_thread_jumps = 1;
+#ifdef DELAY_SLOTS
+ flag_delayed_branch = 1;
+#endif
+#ifdef CAN_DEBUG_WITHOUT_FP
+ flag_omit_frame_pointer = 1;
+#endif
+ flag_guess_branch_prob = 1;
+ flag_cprop_registers = 1;
+ flag_loop_optimize = 1;
+ flag_crossjumping = 1;
+ flag_if_conversion = 1;
+ flag_if_conversion2 = 1;
+ }
+
+ if (optimize >= 2)
+ {
+ flag_optimize_sibling_calls = 1;
+ flag_cse_follow_jumps = 1;
+ flag_cse_skip_blocks = 1;
+ flag_gcse = 1;
+ flag_expensive_optimizations = 1;
+ flag_strength_reduce = 1;
+ flag_rerun_cse_after_loop = 1;
+ flag_rerun_loop_opt = 1;
+ flag_caller_saves = 1;
+ flag_force_mem = 1;
+ flag_peephole2 = 1;
+#ifdef INSN_SCHEDULING
+ flag_schedule_insns = 1;
+ flag_schedule_insns_after_reload = 1;
+#endif
+ flag_regmove = 1;
+ flag_strict_aliasing = 1;
+ flag_delete_null_pointer_checks = 1;
+ flag_reorder_blocks = 1;
+ flag_reorder_functions = 1;
+ }
+
+ if (optimize >= 3)
+ {
+ flag_inline_functions = 1;
+ flag_rename_registers = 1;
+ flag_unswitch_loops = 1;
+ flag_unit_at_a_time = 1;
+ }
+
+ if (optimize < 2 || optimize_size)
+ {
+ align_loops = 1;
+ align_jumps = 1;
+ align_labels = 1;
+ align_functions = 1;
+
+ /* Don't reorder blocks when optimizing for size because extra
+ jump insns may be created; also barrier may create extra padding.
+
+ More correctly we should have a block reordering mode that tried
+ to minimize the combined size of all the jumps. This would more
+ or less automatically remove extra jumps, but would also try to
+ use more short jumps instead of long jumps. */
+ flag_reorder_blocks = 0;
+ }
+
+ /* Initialize whether `char' is signed. */
+ flag_signed_char = DEFAULT_SIGNED_CHAR;
+#ifdef DEFAULT_SHORT_ENUMS
+ /* Initialize how much space enums occupy, by default. */
+ flag_short_enums = DEFAULT_SHORT_ENUMS;
+#endif
+
+ /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
+ modify it. */
+ target_flags = 0;
+ set_target_switch ("");
+
+ /* Unwind tables are always present in an ABI-conformant IA-64
+ object file, so the default should be ON. */
+#ifdef IA64_UNWIND_INFO
+ flag_unwind_tables = IA64_UNWIND_INFO;
+#endif
+
+#ifdef OPTIMIZATION_OPTIONS
+ /* Allow default optimizations to be specified on a per-machine basis. */
+ OPTIMIZATION_OPTIONS (optimize, optimize_size);
+#endif
+
+ handle_options (argc, argv, lang_mask);
+
+ if (flag_pie)
+ flag_pic = flag_pie;
+ if (flag_pic && !flag_pie)
+ flag_shlib = 1;
+
+ if (flag_no_inline == 2)
+ flag_no_inline = 0;
+ else
+ flag_really_no_inline = flag_no_inline;
+
+ /* Set flag_no_inline before the post_options () hook. The C front
+ ends use it to determine tree inlining defaults. FIXME: such
+ code should be lang-independent when all front ends use tree
+ inlining, in which case it, and this condition, should be moved
+ to the top of process_options() instead. */
+ if (optimize == 0)
+ {
+ /* Inlining does not work if not optimizing,
+ so force it not to be done. */
+ flag_no_inline = 1;
+ warn_inline = 0;
+
+ /* The c_decode_option function and decode_option hook set
+ this to `2' if -Wall is used, so we can avoid giving out
+ lots of errors for people who don't realize what -Wall does. */
+ if (warn_uninitialized == 1)
+ warning ("-Wuninitialized is not supported without -O");
+ }
+
+ if (flag_really_no_inline == 2)
+ flag_really_no_inline = flag_no_inline;
}
/* Handle target- and language-independent options. Return zero to
common_handle_option (size_t scode, const char *arg,
int value ATTRIBUTE_UNUSED)
{
- const struct cl_option *option = &cl_options[scode];
enum opt_code code = (enum opt_code) scode;
- if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE)))
- {
- error ("missing argument to \"-%s\"", option->opt_text);
- return 1;
- }
-
switch (code)
{
default:
abort ();
case OPT__help:
- display_help ();
+ print_help ();
exit_after_options = true;
break;
+ case OPT__param:
+ handle_param (arg);
+ break;
+
case OPT__target_help:
display_target_options ();
exit_after_options = true;
g_switch_set = true;
break;
+ case OPT_O:
+ case OPT_Os:
+ /* Currently handled in a prescan. */
+ break;
+
+ case OPT_W:
+ /* For backward compatibility, -W is the same as -Wextra. */
+ set_Wextra (value);
+ break;
+
+ case OPT_Waggregate_return:
+ warn_aggregate_return = value;
+ break;
+
+ case OPT_Wcast_align:
+ warn_cast_align = value;
+ break;
+
+ case OPT_Wdeprecated_declarations:
+ warn_deprecated_decl = value;
+ break;
+
+ case OPT_Wdisabled_optimization:
+ warn_disabled_optimization = value;
+ break;
+
+ case OPT_Werror:
+ warnings_are_errors = value;
+ break;
+
+ case OPT_Wextra:
+ set_Wextra (value);
+ break;
+
+ case OPT_Winline:
+ warn_inline = value;
+ break;
+
+ case OPT_Wlarger_than_:
+ larger_than_size = value;
+ warn_larger_than = value != -1;
+ break;
+
+ case OPT_Wmissing_noreturn:
+ warn_missing_noreturn = value;
+ break;
+
+ case OPT_Wpacked:
+ warn_packed = value;
+ break;
+
+ case OPT_Wpadded:
+ warn_padded = value;
+ break;
+
+ case OPT_Wshadow:
+ warn_shadow = value;
+ break;
+
+ case OPT_Wstrict_aliasing:
+ warn_strict_aliasing = value;
+ break;
+
+ case OPT_Wswitch:
+ warn_switch = value;
+ break;
+
+ case OPT_Wswitch_default:
+ warn_switch_default = value;
+ break;
+
+ case OPT_Wswitch_enum:
+ warn_switch_enum = value;
+ break;
+
+ case OPT_Wsystem_headers:
+ warn_system_headers = value;
+ break;
+
+ case OPT_Wuninitialized:
+ warn_uninitialized = value;
+ break;
+
+ case OPT_Wunreachable_code:
+ warn_notreached = value;
+ break;
+
+ case OPT_Wunused:
+ set_Wunused (value);
+ break;
+
+ case OPT_Wunused_function:
+ warn_unused_function = value;
+ break;
+
+ case OPT_Wunused_label:
+ warn_unused_label = value;
+ break;
+
+ case OPT_Wunused_parameter:
+ warn_unused_parameter = value;
+ break;
+
+ case OPT_Wunused_value:
+ warn_unused_value = value;
+ break;
+
+ case OPT_Wunused_variable:
+ warn_unused_variable = value;
+ break;
+
case OPT_aux_info:
case OPT_aux_info_:
aux_info_file_name = arg;
dump_base_name = arg;
break;
- case OPT_o:
- asm_file_name = arg;
+ case OPT_fPIC:
+ flag_pic = value + value;
break;
- case OPT_p:
- profile_flag = 1;
+ case OPT_fPIE:
+ flag_pie = value + value;
break;
- case OPT_pedantic:
- pedantic = 1;
+ case OPT_falign_functions:
+ align_functions = !value;
break;
- case OPT_pedantic_errors:
- flag_pedantic_errors = pedantic = 1;
+ case OPT_falign_functions_:
+ align_functions = value;
break;
- case OPT_quiet:
- quiet_flag = 1;
+ case OPT_falign_jumps:
+ align_jumps = !value;
break;
- case OPT_version:
- version_flag = 1;
+ case OPT_falign_jumps_:
+ align_jumps = value;
break;
- case OPT_w:
- inhibit_warnings = 1;
- break;
- }
+ case OPT_falign_labels:
+ align_labels = !value;
+ break;
- return 1;
+ case OPT_falign_labels_:
+ align_labels = value;
+ break;
+
+ case OPT_falign_loops:
+ align_loops = !value;
+ break;
+
+ case OPT_falign_loops_:
+ align_loops = value;
+ break;
+
+ case OPT_fargument_alias:
+ flag_argument_noalias = !value;
+ break;
+
+ case OPT_fargument_noalias:
+ flag_argument_noalias = value;
+ break;
+
+ case OPT_fargument_noalias_global:
+ flag_argument_noalias = value + value;
+ break;
+
+ case OPT_fasynchronous_unwind_tables:
+ flag_asynchronous_unwind_tables = value;
+ break;
+
+ case OPT_fbounds_check:
+ flag_bounds_check = value;
+ break;
+
+ case OPT_fbranch_count_reg:
+ flag_branch_on_count_reg = value;
+ break;
+
+ case OPT_fbranch_probabilities:
+ flag_branch_probabilities = value;
+ break;
+
+ case OPT_fbranch_target_load_optimize:
+ flag_branch_target_load_optimize = value;
+ break;
+
+ case OPT_fbranch_target_load_optimize2:
+ flag_branch_target_load_optimize2 = value;
+ break;
+
+ case OPT_fcall_used_:
+ fix_register (arg, 0, 1);
+ break;
+
+ case OPT_fcall_saved_:
+ fix_register (arg, 0, 0);
+ break;
+
+ case OPT_fcaller_saves:
+ flag_caller_saves = value;
+ break;
+
+ case OPT_fcommon:
+ flag_no_common = !value;
+ break;
+
+ case OPT_fcprop_registers:
+ flag_cprop_registers = value;
+ break;
+
+ case OPT_fcrossjumping:
+ flag_crossjumping = value;
+ break;
+
+ case OPT_fcse_follow_jumps:
+ flag_cse_follow_jumps = value;
+ break;
+
+ case OPT_fcse_skip_blocks:
+ flag_cse_skip_blocks = value;
+ break;
+
+ case OPT_fdata_sections:
+ flag_data_sections = value;
+ break;
+
+ case OPT_fdefer_pop:
+ flag_defer_pop = value;
+ break;
+
+ case OPT_fdelayed_branch:
+ flag_delayed_branch = value;
+ break;
+
+ case OPT_fdelete_null_pointer_checks:
+ flag_delete_null_pointer_checks = value;
+ break;
+
+ case OPT_fdiagnostics_show_location_:
+ if (!strcmp (arg, "once"))
+ diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
+ else if (!strcmp (arg, "every-line"))
+ diagnostic_prefixing_rule (global_dc)
+ = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
+ else
+ return 0;
+ break;
+
+ case OPT_fdump_unnumbered:
+ flag_dump_unnumbered = value;
+ break;
+
+ case OPT_feliminate_dwarf2_dups:
+ flag_eliminate_dwarf2_dups = value;
+ break;
+
+ case OPT_feliminate_unused_debug_types:
+ flag_eliminate_unused_debug_types = value;
+ break;
+
+ case OPT_feliminate_unused_debug_symbols:
+ flag_debug_only_used_symbols = value;
+ break;
+
+ case OPT_fexceptions:
+ flag_exceptions = value;
+ break;
+
+ case OPT_fexpensive_optimizations:
+ flag_expensive_optimizations = value;
+ break;
+
+ case OPT_ffast_math:
+ set_fast_math_flags (value);
+ break;
+
+ case OPT_ffinite_math_only:
+ flag_finite_math_only = value;
+ break;
+
+ case OPT_ffixed_:
+ fix_register (arg, 1, 1);
+ break;
+
+ case OPT_ffunction_cse:
+ flag_no_function_cse = !value;
+ break;
+
+ case OPT_ffloat_store:
+ flag_float_store = value;
+ break;
+
+ case OPT_fforce_addr:
+ flag_force_addr = value;
+ break;
+
+ case OPT_fforce_mem:
+ flag_force_mem = value;
+ break;
+
+ case OPT_ffunction_sections:
+ flag_function_sections = value;
+ break;
+
+ case OPT_fgcse:
+ flag_gcse = value;
+ break;
+
+ case OPT_fgcse_lm:
+ flag_gcse_lm = value;
+ break;
+
+ case OPT_fgcse_sm:
+ flag_gcse_sm = value;
+ break;
+
+ case OPT_fgnu_linker:
+ flag_gnu_linker = value;
+ break;
+
+ case OPT_fguess_branch_probability:
+ flag_guess_branch_prob = value;
+ break;
+
+ case OPT_fident:
+ flag_no_ident = !value;
+ break;
+
+ case OPT_fif_conversion:
+ flag_if_conversion = value;
+ break;
+
+ case OPT_fif_conversion2:
+ flag_if_conversion2 = value;
+ break;
+
+ case OPT_finhibit_size_directive:
+ flag_inhibit_size_directive = value;
+ break;
+
+ case OPT_finline:
+ flag_no_inline = !value;
+ break;
+
+ case OPT_finline_functions:
+ flag_inline_functions = value;
+ break;
+
+ case OPT_finline_limit_:
+ case OPT_finline_limit_eq:
+ set_param_value ("max-inline-insns", value);
+ set_param_value ("max-inline-insns-single", value / 2);
+ set_param_value ("max-inline-insns-auto", value / 2);
+ set_param_value ("max-inline-insns-rtl", value);
+ if (value / 4 < MIN_INLINE_INSNS)
+ {
+ if (value / 4 > 10)
+ set_param_value ("min-inline-insns", value / 4);
+ else
+ set_param_value ("min-inline-insns", 10);
+ }
+ break;
+
+ case OPT_finstrument_functions:
+ flag_instrument_function_entry_exit = value;
+ break;
+
+ case OPT_fkeep_inline_functions:
+ flag_keep_inline_functions =value;
+ break;
+
+ case OPT_fkeep_static_consts:
+ flag_keep_static_consts = value;
+ break;
+
+ case OPT_fleading_underscore:
+ flag_leading_underscore = value;
+ break;
+
+ case OPT_floop_optimize:
+ flag_loop_optimize = value;
+ break;
+
+ case OPT_fmath_errno:
+ flag_errno_math = value;
+ break;
+
+ case OPT_fmem_report:
+ mem_report = value;
+ break;
+
+ case OPT_fmerge_all_constants:
+ flag_merge_constants = value + value;
+ break;
+
+ case OPT_fmerge_constants:
+ flag_merge_constants = value;
+ break;
+
+ case OPT_fmessage_length_:
+ pp_set_line_maximum_length (global_dc->printer, value);
+ break;
+
+ case OPT_fmove_all_movables:
+ flag_move_all_movables = value;
+ break;
+
+ case OPT_fnew_ra:
+ flag_new_regalloc = value;
+ break;
+
+ case OPT_fnon_call_exceptions:
+ flag_non_call_exceptions = value;
+ break;
+
+ case OPT_fold_unroll_all_loops:
+ flag_old_unroll_all_loops = value;
+ break;
+
+ case OPT_fold_unroll_loops:
+ flag_old_unroll_loops = value;
+ break;
+
+ case OPT_fomit_frame_pointer:
+ flag_omit_frame_pointer = value;
+ break;
+
+ case OPT_foptimize_register_move:
+ flag_regmove = value;
+ break;
+
+ case OPT_foptimize_sibling_calls:
+ flag_optimize_sibling_calls = value;
+ break;
+
+ case OPT_fpack_struct:
+ flag_pack_struct = value;
+ break;
+
+ case OPT_fpeel_loops:
+ flag_peel_loops = value;
+ break;
+
+ case OPT_fpcc_struct_return:
+ flag_pcc_struct_return = value;
+ break;
+
+ case OPT_fpeephole:
+ flag_no_peephole = !value;
+ break;
+
+ case OPT_fpeephole2:
+ flag_peephole2 = value;
+ break;
+
+ case OPT_fpic:
+ flag_pic = value;
+ break;
+
+ case OPT_fpie:
+ flag_pie = value;
+ break;
+
+ case OPT_fprefetch_loop_arrays:
+ flag_prefetch_loop_arrays = value;
+ break;
+
+ case OPT_fprofile:
+ profile_flag = value;
+ break;
+
+ case OPT_fprofile_arcs:
+ profile_arc_flag = value;
+ break;
+
+ case OPT_frandom_seed:
+ /* The real switch is -fno-random-seed. */
+ if (value)
+ return 0;
+ flag_random_seed = NULL;
+ break;
+
+ case OPT_frandom_seed_:
+ flag_random_seed = arg;
+ break;
+
+ case OPT_freduce_all_givs:
+ flag_reduce_all_givs = value;
+ break;
+
+ case OPT_freg_struct_return:
+ flag_pcc_struct_return = !value;
+ break;
+
+ case OPT_fregmove:
+ flag_regmove = value;
+ break;
+
+ case OPT_frename_registers:
+ flag_rename_registers = value;
+ break;
+
+ case OPT_freorder_blocks:
+ flag_reorder_blocks = value;
+ break;
+
+ case OPT_freorder_functions:
+ flag_reorder_functions = value;
+ break;
+
+ case OPT_frerun_cse_after_loop:
+ flag_rerun_cse_after_loop = value;
+ break;
+
+ case OPT_frerun_loop_opt:
+ flag_rerun_loop_opt = value;
+ break;
+
+ case OPT_fsched_interblock:
+ flag_schedule_interblock= value;
+ break;
+
+ case OPT_fsched_spec:
+ flag_schedule_speculative = value;
+ break;
+
+ case OPT_fsched_spec_load:
+ flag_schedule_speculative_load = value;
+ break;
+
+ case OPT_fsched_spec_load_dangerous:
+ flag_schedule_speculative_load_dangerous = value;
+ break;
+
+ case OPT_fsched_verbose_:
+#ifdef INSN_SCHEDULING
+ fix_sched_param ("verbose", arg);
+ break;
+#else
+ return 0;
+#endif
+
+ case OPT_fsched2_use_superblocks:
+ flag_sched2_use_superblocks = value;
+ break;
+
+ case OPT_fsched2_use_traces:
+ flag_sched2_use_traces = value;
+ break;
+
+ case OPT_fschedule_insns:
+ flag_schedule_insns = value;
+ break;
+
+ case OPT_fschedule_insns2:
+ flag_schedule_insns_after_reload = value;
+ break;
+
+ case OPT_fshared_data:
+ flag_shared_data = value;
+ break;
+
+ case OPT_fsignaling_nans:
+ flag_signaling_nans = value;
+ break;
+
+ case OPT_fsingle_precision_constant:
+ flag_single_precision_constant = value;
+ break;
+
+ case OPT_fssa:
+ flag_ssa = value;
+ break;
+
+ case OPT_fssa_ccp:
+ flag_ssa_ccp = value;
+ break;
+
+ case OPT_fssa_dce:
+ flag_ssa_dce = value;
+ break;
+
+ case OPT_fstack_check:
+ flag_stack_check = value;
+ break;
+
+ case OPT_fstack_limit:
+ /* The real switch is -fno-stack-limit. */
+ if (value)
+ return 0;
+ stack_limit_rtx = NULL_RTX;
+ break;
+
+ case OPT_fstack_limit_register_:
+ {
+ int reg = decode_reg_name (arg);
+ if (reg < 0)
+ error ("unrecognized register name \"%s\"", arg);
+ else
+ stack_limit_rtx = gen_rtx_REG (Pmode, reg);
+ }
+ break;
+
+ case OPT_fstack_limit_symbol_:
+ stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
+ break;
+
+ case OPT_fstrength_reduce:
+ flag_strength_reduce = value;
+ break;
+
+ case OPT_fstrict_aliasing:
+ flag_strict_aliasing = value;
+ break;
+
+ case OPT_fsyntax_only:
+ flag_syntax_only = value;
+ break;
+
+ case OPT_ftest_coverage:
+ flag_test_coverage = value;
+ break;
+
+ case OPT_fthread_jumps:
+ flag_thread_jumps = value;
+ break;
+
+ case OPT_ftime_report:
+ time_report = value;
+ break;
+
+ case OPT_ftls_model_:
+ if (!strcmp (arg, "global-dynamic"))
+ flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
+ else if (!strcmp (arg, "local-dynamic"))
+ flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
+ else if (!strcmp (arg, "initial-exec"))
+ flag_tls_default = TLS_MODEL_INITIAL_EXEC;
+ else if (!strcmp (arg, "local-exec"))
+ flag_tls_default = TLS_MODEL_LOCAL_EXEC;
+ else
+ warning ("unknown tls-model \"%s\"", arg);
+ break;
+
+ case OPT_ftracer:
+ flag_tracer = value;
+ break;
+
+ case OPT_ftrapping_math:
+ flag_trapping_math = value;
+ break;
+
+ case OPT_ftrapv:
+ flag_trapv = value;
+ break;
+
+ case OPT_funit_at_a_time:
+ flag_unit_at_a_time = value;
+ break;
+
+ case OPT_funroll_all_loops:
+ flag_unroll_all_loops = value;
+ break;
+
+ case OPT_funroll_loops:
+ flag_unroll_loops = value;
+ break;
+
+ case OPT_funsafe_math_optimizations:
+ flag_unsafe_math_optimizations = value;
+ break;
+
+ case OPT_funswitch_loops:
+ flag_unswitch_loops = value;
+ break;
+
+ case OPT_funwind_tables:
+ flag_unwind_tables = value;
+ break;
+
+ case OPT_fverbose_asm:
+ flag_verbose_asm = value;
+ break;
+
+ case OPT_fwrapv:
+ flag_wrapv = value;
+ break;
+
+ case OPT_fwritable_strings:
+ flag_writable_strings = value;
+ break;
+
+ case OPT_fzero_initialized_in_bss:
+ flag_zero_initialized_in_bss = value;
+ break;
+
+ case OPT_g:
+ set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
+ break;
+
+ case OPT_gcoff:
+ set_debug_level (SDB_DEBUG, false, arg);
+ break;
+
+ case OPT_gdwarf:
+ if (*arg)
+ {
+ error ("use -gdwarf -gN for DWARF v1 level N, "
+ "and -gdwarf-2 for DWARF v2" );
+ break;
+ }
+
+ /* Fall through. */
+ case OPT_gdwarf_:
+ set_debug_level (DWARF_DEBUG, code == OPT_gdwarf_, arg);
+ break;
+
+ case OPT_gdwarf_2:
+ set_debug_level (DWARF2_DEBUG, false, arg);
+ break;
+
+ case OPT_ggdb:
+ set_debug_level (NO_DEBUG, 2, arg);
+ break;
+
+ case OPT_gstabs:
+ case OPT_gstabs_:
+ set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
+ break;
+
+ case OPT_gvms:
+ set_debug_level (VMS_DEBUG, false, arg);
+ break;
+
+ case OPT_gxcoff:
+ case OPT_gxcoff_:
+ set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
+ break;
+
+ case OPT_m:
+ set_target_switch (arg);
+ break;
+
+ case OPT_o:
+ asm_file_name = arg;
+ break;
+
+ case OPT_p:
+ profile_flag = 1;
+ break;
+
+ case OPT_pedantic:
+ pedantic = 1;
+ break;
+
+ case OPT_pedantic_errors:
+ flag_pedantic_errors = pedantic = 1;
+ break;
+
+ case OPT_quiet:
+ quiet_flag = 1;
+ break;
+
+ case OPT_version:
+ version_flag = 1;
+ break;
+
+ case OPT_w:
+ inhibit_warnings = true;
+ break;
+ }
+
+ return 1;
+}
+
+/* Handle --param NAME=VALUE. */
+static void
+handle_param (const char *carg)
+{
+ char *equal, *arg;
+ int value;
+
+ arg = xstrdup (carg);
+ equal = strchr (arg, '=');
+ if (!equal)
+ error ("%s: --param arguments should be of the form NAME=VALUE", arg);
+ else
+ {
+ value = integral_argument (equal + 1);
+ if (value == -1)
+ error ("invalid --param value `%s'", equal + 1);
+ else
+ {
+ *equal = '\0';
+ set_param_value (arg, value);
+ }
+ }
+
+ free (arg);
+}
+
+/* Handle -W and -Wextra. */
+static void
+set_Wextra (int setting)
+{
+ extra_warnings = setting;
+ warn_unused_value = setting;
+ warn_unused_parameter = (setting && maybe_warn_unused_parameter);
+
+ /* We save the value of warn_uninitialized, since if they put
+ -Wuninitialized on the command line, we need to generate a
+ warning about not using it without also specifying -O. */
+ if (setting == 0)
+ warn_uninitialized = 0;
+ else if (warn_uninitialized != 1)
+ warn_uninitialized = 2;
+}
+
+/* Initialize unused warning flags. */
+void
+set_Wunused (int setting)
+{
+ warn_unused_function = setting;
+ warn_unused_label = setting;
+ /* Unused function parameter warnings are reported when either
+ ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified.
+ Thus, if -Wextra has already been seen, set warn_unused_parameter;
+ otherwise set maybe_warn_extra_parameter, which will be picked up
+ by set_Wextra. */
+ maybe_warn_unused_parameter = setting;
+ warn_unused_parameter = (setting && extra_warnings);
+ warn_unused_variable = setting;
+ warn_unused_value = setting;
+}
+
+/* The following routines are useful in setting all the flags that
+ -ffast-math and -fno-fast-math imply. */
+void
+set_fast_math_flags (int set)
+{
+ flag_trapping_math = !set;
+ flag_unsafe_math_optimizations = set;
+ flag_finite_math_only = set;
+ flag_errno_math = !set;
+ if (set)
+ flag_signaling_nans = 0;
+}
+
+/* Return true iff flags are set as if -ffast-math. */
+bool
+fast_math_flags_set_p (void)
+{
+ return (!flag_trapping_math
+ && flag_unsafe_math_optimizations
+ && flag_finite_math_only
+ && !flag_errno_math);
+}
+
+/* Handle a debug output -g switch. EXTENDED is true or false to support
+ extended output (2 is special and means "-ggdb" was given). */
+static void
+set_debug_level (enum debug_info_type type, int extended, const char *arg)
+{
+ static bool type_explicit;
+
+ use_gnu_debug_info_extensions = extended;
+
+ if (type == NO_DEBUG)
+ {
+ if (write_symbols == NO_DEBUG)
+ {
+ write_symbols = PREFERRED_DEBUGGING_TYPE;
+
+ if (extended == 2)
+ {
+#ifdef DWARF2_DEBUGGING_INFO
+ write_symbols = DWARF2_DEBUG;
+#elif defined DBX_DEBUGGING_INFO
+ write_symbols = DBX_DEBUG;
+#endif
+ }
+
+ if (write_symbols == NO_DEBUG)
+ warning ("target system does not support debug output");
+ }
+ }
+ else
+ {
+ /* Does it conflict with an already selected type? */
+ if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
+ error ("debug format \"%s\" conflicts with prior selection",
+ debug_type_names[type]);
+ write_symbols = type;
+ type_explicit = true;
+ }
+
+ /* A debug flag without a level defaults to level 2. */
+ if (*arg == '\0')
+ {
+ if (!debug_info_level)
+ debug_info_level = 2;
+ }
+ else
+ {
+ debug_info_level = integral_argument (arg);
+ if (debug_info_level == (unsigned int) -1)
+ error ("unrecognised debug output level \"%s\"", arg);
+ else if (debug_info_level > 3)
+ error ("debug output level %s is too high", arg);
+ }
+}
+
+/* Output --help text. */
+static void
+print_help (void)
+{
+ size_t i;
+ const char *p;
+
+ GET_ENVIRONMENT (p, "COLUMNS");
+ if (p)
+ {
+ int value = atoi (p);
+ if (value > 0)
+ columns = value;
+ }
+
+ puts (_("The following options are language-independent:\n"));
+
+ print_filtered_help (CL_COMMON);
+ print_param_help ();
+
+ for (i = 0; lang_names[i]; i++)
+ {
+ printf (_("The %s front end recognizes the following options:\n\n"),
+ lang_names[i]);
+ print_filtered_help (1U << i);
+ }
+
+ display_target_options ();
+}
+
+/* Print the help for --param. */
+static void
+print_param_help (void)
+{
+ size_t i;
+
+ puts (_("The --param option recognizes the following as parameters:\n"));
+
+ for (i = 0; i < LAST_PARAM; i++)
+ {
+ const char *help = compiler_params[i].help;
+ const char *param = compiler_params[i].option;
+
+ if (help == NULL || *help == '\0')
+ help = undocumented_msg;
+
+ /* Get the translation. */
+ help = _(help);
+
+ wrap_help (help, param, strlen (param));
+ }
+
+ putchar ('\n');
+}
+
+/* Print help for a specific front-end, etc. */
+static void
+print_filtered_help (unsigned int flag)
+{
+ unsigned int i, len, filter, indent = 0;
+ bool duplicates = false;
+ const char *help, *opt, *tab;
+ static char *printed;
+
+ if (flag == CL_COMMON)
+ {
+ filter = flag;
+ if (!printed)
+ printed = xmalloc (cl_options_count);
+ memset (printed, 0, cl_options_count);
+ }
+ else
+ {
+ /* Don't print COMMON options twice. */
+ filter = flag | CL_COMMON;
+
+ for (i = 0; i < cl_options_count; i++)
+ {
+ if ((cl_options[i].flags & filter) != flag)
+ continue;
+
+ /* Skip help for internal switches. */
+ if (cl_options[i].flags & CL_UNDOCUMENTED)
+ continue;
+
+ /* Skip switches that have already been printed, mark them to be
+ listed later. */
+ if (printed[i])
+ {
+ duplicates = true;
+ indent = print_switch (cl_options[i].opt_text, indent);
+ }
+ }
+
+ if (duplicates)
+ {
+ putchar ('\n');
+ putchar ('\n');
+ }
+ }
+
+ for (i = 0; i < cl_options_count; i++)
+ {
+ if ((cl_options[i].flags & filter) != flag)
+ continue;
+
+ /* Skip help for internal switches. */
+ if (cl_options[i].flags & CL_UNDOCUMENTED)
+ continue;
+
+ /* Skip switches that have already been printed. */
+ if (printed[i])
+ continue;
+
+ printed[i] = true;
+
+ help = cl_options[i].help;
+ if (!help)
+ help = undocumented_msg;
+
+ /* Get the translation. */
+ help = _(help);
+
+ tab = strchr (help, '\t');
+ if (tab)
+ {
+ len = tab - help;
+ opt = help;
+ help = tab + 1;
+ }
+ else
+ {
+ opt = cl_options[i].opt_text;
+ len = strlen (opt);
+ }
+
+ wrap_help (help, opt, len);
+ }
+
+ putchar ('\n');
+}
+
+/* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
+ word-wrapped HELP in a second column. */
+static unsigned int
+print_switch (const char *text, unsigned int indent)
+{
+ unsigned int len = strlen (text) + 1; /* trailing comma */
+
+ if (indent)
+ {
+ putchar (',');
+ if (indent + len > columns)
+ {
+ putchar ('\n');
+ putchar (' ');
+ indent = 1;
+ }
+ }
+ else
+ putchar (' ');
+
+ putchar (' ');
+ fputs (text, stdout);
+
+ return indent + len + 1;
+}
+
+/* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
+ word-wrapped HELP in a second column. */
+static void
+wrap_help (const char *help, const char *item, unsigned int item_width)
+{
+ unsigned int col_width = 27;
+ unsigned int remaining, room, len;
+
+ remaining = strlen (help);
+
+ do
+ {
+ room = columns - 3 - MAX (col_width, item_width);
+ if (room > columns)
+ room = 0;
+ len = remaining;
+
+ if (room < len)
+ {
+ unsigned int i;
+
+ for (i = 0; help[i]; i++)
+ {
+ if (i >= room && len != remaining)
+ break;
+ if (help[i] == ' ')
+ len = i;
+ else if ((help[i] == '-' || help[i] == '/')
+ && help[i + 1] != ' '
+ && ISALPHA (help[i - 1]))
+ len = i + 1;
+ }
+ }
+
+ printf( " %-*.*s %.*s\n", col_width, item_width, item, len, help);
+ item_width = 0;
+ while (help[len] == ' ')
+ len++;
+ help += len;
+ remaining -= len;
+ }
+ while (remaining);
}
OSDN Git Service
