238 lines
6.5 KiB
C
238 lines
6.5 KiB
C
/* Command line option handling.
|
|
Copyright (C) 2006 Free Software Foundation, Inc.
|
|
|
|
This file is part of GCC.
|
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
|
the terms of the GNU General Public License as published by the Free
|
|
Software Foundation; either version 2, or (at your option) any later
|
|
version.
|
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GCC; see the file COPYING. If not, write to the Free
|
|
Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
|
|
02110-1301, USA. */
|
|
|
|
#include "config.h"
|
|
#include "system.h"
|
|
#include "intl.h"
|
|
#include "coretypes.h"
|
|
#include "opts.h"
|
|
|
|
/* Perform a binary search to find which option the command-line INPUT
|
|
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. */
|
|
size_t
|
|
find_opt (const char *input, int lang_mask)
|
|
{
|
|
size_t mn, mx, md, opt_len;
|
|
size_t match_wrong_lang;
|
|
int comp;
|
|
|
|
mn = 0;
|
|
mx = cl_options_count;
|
|
|
|
/* 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 + 1, opt_len);
|
|
|
|
if (comp < 0)
|
|
mx = md;
|
|
else
|
|
mn = md;
|
|
}
|
|
|
|
/* 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;
|
|
|
|
/* 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];
|
|
|
|
/* Is the input either an exact match or a prefix that takes a
|
|
joined argument? */
|
|
if (!strncmp (input, opt->opt_text + 1, opt->opt_len)
|
|
&& (input[opt->opt_len] == '\0' || (opt->flags & CL_JOINED)))
|
|
{
|
|
/* If language is OK, return it. */
|
|
if (opt->flags & lang_mask)
|
|
return mn;
|
|
|
|
/* 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 the best wrong match, or cl_options_count if none. */
|
|
return match_wrong_lang;
|
|
}
|
|
|
|
/* Return true if NEXT_OPT_IDX cancels OPT_IDX. Return false if the
|
|
next one is the same as ORIG_NEXT_OPT_IDX. */
|
|
|
|
static bool
|
|
cancel_option (int opt_idx, int next_opt_idx, int orig_next_opt_idx)
|
|
{
|
|
/* An option can be canceled by the same option or an option with
|
|
Negative. */
|
|
if (cl_options [next_opt_idx].neg_index == opt_idx)
|
|
return true;
|
|
|
|
if (cl_options [next_opt_idx].neg_index != orig_next_opt_idx)
|
|
return cancel_option (opt_idx, cl_options [next_opt_idx].neg_index,
|
|
orig_next_opt_idx);
|
|
|
|
return false;
|
|
}
|
|
|
|
/* Filter out options canceled by the ones after them. */
|
|
|
|
void
|
|
prune_options (int *argcp, char ***argvp)
|
|
{
|
|
int argc = *argcp;
|
|
int *options = xmalloc (argc * sizeof (*options));
|
|
char **argv = xmalloc (argc * sizeof (char *));
|
|
int i, arg_count, need_prune = 0;
|
|
const struct cl_option *option;
|
|
size_t opt_index;
|
|
|
|
/* Scan all arguments. */
|
|
for (i = 1; i < argc; i++)
|
|
{
|
|
int value = 1;
|
|
const char *opt = (*argvp) [i];
|
|
|
|
opt_index = find_opt (opt + 1, -1);
|
|
if (opt_index == cl_options_count
|
|
&& (opt[1] == 'W' || opt[1] == 'f' || opt[1] == 'm')
|
|
&& opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-')
|
|
{
|
|
char *dup;
|
|
|
|
/* Drop the "no-" from negative switches. */
|
|
size_t len = strlen (opt) - 3;
|
|
|
|
dup = XNEWVEC (char, 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, -1);
|
|
free (dup);
|
|
}
|
|
|
|
if (opt_index == cl_options_count)
|
|
{
|
|
cont:
|
|
options [i] = 0;
|
|
continue;
|
|
}
|
|
|
|
option = &cl_options[opt_index];
|
|
if (option->neg_index < 0)
|
|
goto cont;
|
|
|
|
/* Skip joined switches. */
|
|
if ((option->flags & CL_JOINED))
|
|
goto cont;
|
|
|
|
/* Reject negative form of switches that don't take negatives as
|
|
unrecognized. */
|
|
if (!value && (option->flags & CL_REJECT_NEGATIVE))
|
|
goto cont;
|
|
|
|
options [i] = (int) opt_index;
|
|
need_prune |= options [i];
|
|
}
|
|
|
|
if (!need_prune)
|
|
goto done;
|
|
|
|
/* Remove arguments which are negated by others after them. */
|
|
argv [0] = (*argvp) [0];
|
|
arg_count = 1;
|
|
for (i = 1; i < argc; i++)
|
|
{
|
|
int j, opt_idx;
|
|
|
|
opt_idx = options [i];
|
|
if (opt_idx)
|
|
{
|
|
int next_opt_idx;
|
|
for (j = i + 1; j < argc; j++)
|
|
{
|
|
next_opt_idx = options [j];
|
|
if (next_opt_idx
|
|
&& cancel_option (opt_idx, next_opt_idx,
|
|
next_opt_idx))
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
goto keep;
|
|
|
|
if (j == argc)
|
|
{
|
|
keep:
|
|
argv [arg_count] = (*argvp) [i];
|
|
arg_count++;
|
|
}
|
|
}
|
|
|
|
if (arg_count != argc)
|
|
{
|
|
*argcp = arg_count;
|
|
*argvp = argv;
|
|
}
|
|
else
|
|
{
|
|
done:
|
|
free (argv);
|
|
}
|
|
|
|
free (options);
|
|
}
|