Subversion Repositories openrisc

/* Command line option handling.

   Copyright (C) 2006, 2007, 2008, 2010, 2011 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 3, 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 COPYING3.  If not see

<http://www.gnu.org/licenses/>.  */

#include "config.h"

#include "system.h"

#include "intl.h"

#include "coretypes.h"

#include "opts.h"

#include "flags.h"

#include "diagnostic.h"

static void prune_options (struct cl_decoded_option **, unsigned int *);

/* Perform a binary search to find which option the command-line INPUT

   matches.  Returns its index in the option array, and

   OPT_SPECIAL_unknown 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, 'optc-gen.awk' 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, unsigned int lang_mask)

{

  size_t mn, mn_orig, 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;

    }

  mn_orig = mn;

  /* This is the switch that is the best match but for a different

     front end, or OPT_SPECIAL_unknown if there is no match at all.  */

  match_wrong_lang = OPT_SPECIAL_unknown;

  /* 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 == OPT_SPECIAL_unknown)

            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);

  if (match_wrong_lang == OPT_SPECIAL_unknown && input[0] == '-')

    {

      /* Long options, starting "--", may be abbreviated if the

         abbreviation is unambiguous.  This only applies to options

         not taking a joined argument, and abbreviations of "--option"

         are permitted even if there is a variant "--option=".  */

      size_t mnc = mn_orig + 1;

      size_t cmp_len = strlen (input);

      while (mnc < cl_options_count

             && strncmp (input, cl_options[mnc].opt_text + 1, cmp_len) == 0)

        {

          /* Option matching this abbreviation.  OK if it is the first

             match and that does not take a joined argument, or the

             second match, taking a joined argument and with only '='

             added to the first match; otherwise considered

             ambiguous.  */

          if (mnc == mn_orig + 1

              && !(cl_options[mnc].flags & CL_JOINED))

            match_wrong_lang = mnc;

          else if (mnc == mn_orig + 2

                   && match_wrong_lang == mn_orig + 1

                   && (cl_options[mnc].flags & CL_JOINED)

                   && (cl_options[mnc].opt_len

                       == cl_options[mn_orig + 1].opt_len + 1)

                   && strncmp (cl_options[mnc].opt_text + 1,

                               cl_options[mn_orig + 1].opt_text + 1,

                               cl_options[mn_orig + 1].opt_len) == 0)

            ; /* OK, as long as there are no more matches.  */

          else

            return OPT_SPECIAL_unknown;

          mnc++;

        }

    }

  /* Return the best wrong match, or OPT_SPECIAL_unknown if none.  */

  return match_wrong_lang;

}

/* If ARG is a non-negative integer made up solely of digits, return its

   value, otherwise return -1.  */

int

integral_argument (const char *arg)

{

  const char *p = arg;

  while (*p && ISDIGIT (*p))

    p++;

  if (*p == '\0')

    return atoi (arg);

  return -1;

}

/* Return whether OPTION is OK for the language given by

   LANG_MASK.  */

static bool

option_ok_for_language (const struct cl_option *option,

                        unsigned int lang_mask)

{

  if (!(option->flags & lang_mask))

    return false;

  else if ((option->flags & CL_TARGET)

           && (option->flags & (CL_LANG_ALL | CL_DRIVER))

           && !(option->flags & (lang_mask & ~CL_COMMON & ~CL_TARGET)))

    /* Complain for target flag language mismatches if any languages

       are specified.  */

    return false;

  return true;

}

/* Return whether ENUM_ARG is OK for the language given by

   LANG_MASK.  */

static bool

enum_arg_ok_for_language (const struct cl_enum_arg *enum_arg,

                          unsigned int lang_mask)

{

  return (lang_mask & CL_DRIVER) || !(enum_arg->flags & CL_ENUM_DRIVER_ONLY);

}

/* Look up ARG in ENUM_ARGS for language LANG_MASK, returning true and

   storing the value in *VALUE if found, and returning false without

   modifying *VALUE if not found.  */

static bool

enum_arg_to_value (const struct cl_enum_arg *enum_args,

                   const char *arg, int *value, unsigned int lang_mask)

{

  unsigned int i;

  for (i = 0; enum_args[i].arg != NULL; i++)

    if (strcmp (arg, enum_args[i].arg) == 0

        && enum_arg_ok_for_language (&enum_args[i], lang_mask))

      {

        *value = enum_args[i].value;

        return true;

      }

  return false;

}

/* Look up ARG in the enum used by option OPT_INDEX for language

   LANG_MASK, returning true and storing the value in *VALUE if found,

   and returning false without modifying *VALUE if not found.  */

bool

opt_enum_arg_to_value (size_t opt_index, const char *arg, int *value,

                       unsigned int lang_mask)

{

  const struct cl_option *option = &cl_options[opt_index];

  gcc_assert (option->var_type == CLVC_ENUM);

  return enum_arg_to_value (cl_enums[option->var_enum].values, arg,

                            value, lang_mask);

}

/* Look of VALUE in ENUM_ARGS for language LANG_MASK and store the

   corresponding string in *ARGP, returning true if the found string

   was marked as canonical, false otherwise.  If VALUE is not found

   (which may be the case for uninitialized values if the relevant

   option has not been passed), set *ARGP to NULL and return

   false.  */

bool

enum_value_to_arg (const struct cl_enum_arg *enum_args,

                   const char **argp, int value, unsigned int lang_mask)

{

  unsigned int i;

  for (i = 0; enum_args[i].arg != NULL; i++)

    if (enum_args[i].value == value

        && (enum_args[i].flags & CL_ENUM_CANONICAL)

        && enum_arg_ok_for_language (&enum_args[i], lang_mask))

      {

        *argp = enum_args[i].arg;

        return true;

      }

  for (i = 0; enum_args[i].arg != NULL; i++)

    if (enum_args[i].value == value

        && enum_arg_ok_for_language (&enum_args[i], lang_mask))

      {

        *argp = enum_args[i].arg;

        return false;

      }

  *argp = NULL;

  return false;

}

/* Fill in the canonical option part of *DECODED with an option

   described by OPT_INDEX, ARG and VALUE.  */

static void

generate_canonical_option (size_t opt_index, const char *arg, int value,

                           struct cl_decoded_option *decoded)

{

  const struct cl_option *option = &cl_options[opt_index];

  const char *opt_text = option->opt_text;

  if (value == 0

      && !option->cl_reject_negative

      && (opt_text[1] == 'W' || opt_text[1] == 'f' || opt_text[1] == 'm'))

    {

      char *t = XNEWVEC (char, option->opt_len + 5);

      t[0] = '-';

      t[1] = opt_text[1];

      t[2] = 'n';

      t[3] = 'o';

      t[4] = '-';

      memcpy (t + 5, opt_text + 2, option->opt_len);

      opt_text = t;

    }

  decoded->canonical_option[2] = NULL;

  decoded->canonical_option[3] = NULL;

  if (arg)

    {

      if ((option->flags & CL_SEPARATE)

          && !option->cl_separate_alias)

        {

          decoded->canonical_option[0] = opt_text;

          decoded->canonical_option[1] = arg;

          decoded->canonical_option_num_elements = 2;

        }

      else

        {

          gcc_assert (option->flags & CL_JOINED);

          decoded->canonical_option[0] = concat (opt_text, arg, NULL);

          decoded->canonical_option[1] = NULL;

          decoded->canonical_option_num_elements = 1;

          if (opt_text != option->opt_text)

            free (CONST_CAST (char *, opt_text));

        }

    }

  else

    {

      decoded->canonical_option[0] = opt_text;

      decoded->canonical_option[1] = NULL;

      decoded->canonical_option_num_elements = 1;

    }

}

/* Structure describing mappings from options on the command line to

   options to look up with find_opt.  */

struct option_map

{

  /* Prefix of the option on the command line.  */

  const char *opt0;

  /* If two argv elements are considered to be merged into one option,

     prefix for the second element, otherwise NULL.  */

  const char *opt1;

  /* The new prefix to map to.  */

  const char *new_prefix;

  /* Whether at least one character is needed following opt1 or opt0

     for this mapping to be used.  (--optimize= is valid for -O, but

     --warn- is not valid for -W.)  */

  bool another_char_needed;

  /* Whether the original option is a negated form of the option

     resulting from this map.  */

  bool negated;

};

static const struct option_map option_map[] =

  {

    { "-Wno-", NULL, "-W", false, true },

    { "-fno-", NULL, "-f", false, true },

    { "-mno-", NULL, "-m", false, true },

    { "--debug=", NULL, "-g", false, false },

    { "--machine-", NULL, "-m", true, false },

    { "--machine-no-", NULL, "-m", false, true },

    { "--machine=", NULL, "-m", false, false },

    { "--machine=no-", NULL, "-m", false, true },

    { "--machine", "", "-m", false, false },

    { "--machine", "no-", "-m", false, true },

    { "--optimize=", NULL, "-O", false, false },

    { "--std=", NULL, "-std=", false, false },

    { "--std", "", "-std=", false, false },

    { "--warn-", NULL, "-W", true, false },

    { "--warn-no-", NULL, "-W", false, true },

    { "--", NULL, "-f", true, false },

    { "--no-", NULL, "-f", false, true }

  };

/* Decode the switch beginning at ARGV for the language indicated by

   LANG_MASK (including CL_COMMON and CL_TARGET if applicable), into

   the structure *DECODED.  Returns the number of switches

   consumed.  */

static unsigned int

decode_cmdline_option (const char **argv, unsigned int lang_mask,

                       struct cl_decoded_option *decoded)

{

  size_t opt_index;

  const char *arg = 0;

  int value = 1;

  unsigned int result = 1, i, extra_args, separate_args = 0;

  int adjust_len = 0;

  size_t total_len;

  char *p;

  const struct cl_option *option;

  int errors = 0;

  const char *warn_message = NULL;

  bool separate_arg_flag;

  bool joined_arg_flag;

  bool have_separate_arg = false;

  extra_args = 0;

  opt_index = find_opt (argv[0] + 1, lang_mask);

  i = 0;

  while (opt_index == OPT_SPECIAL_unknown

         && i < ARRAY_SIZE (option_map))

    {

      const char *opt0 = option_map[i].opt0;

      const char *opt1 = option_map[i].opt1;

      const char *new_prefix = option_map[i].new_prefix;

      bool another_char_needed = option_map[i].another_char_needed;

      size_t opt0_len = strlen (opt0);

      size_t opt1_len = (opt1 == NULL ? 0 : strlen (opt1));

      size_t optn_len = (opt1 == NULL ? opt0_len : opt1_len);

      size_t new_prefix_len = strlen (new_prefix);

      extra_args = (opt1 == NULL ? 0 : 1);

      value = !option_map[i].negated;

      if (strncmp (argv[0], opt0, opt0_len) == 0

          && (opt1 == NULL

              || (argv[1] != NULL && strncmp (argv[1], opt1, opt1_len) == 0))

          && (!another_char_needed

              || argv[extra_args][optn_len] != 0))

        {

          size_t arglen = strlen (argv[extra_args]);

          char *dup;

          adjust_len = (int) optn_len - (int) new_prefix_len;

          dup = XNEWVEC (char, arglen + 1 - adjust_len);

          memcpy (dup, new_prefix, new_prefix_len);

          memcpy (dup + new_prefix_len, argv[extra_args] + optn_len,

                  arglen - optn_len + 1);

          opt_index = find_opt (dup + 1, lang_mask);

          free (dup);

        }

      i++;

    }

  if (opt_index == OPT_SPECIAL_unknown)

    {

      arg = argv[0];

      extra_args = 0;

      value = 1;

      goto done;

    }

  option = &cl_options[opt_index];

  /* Reject negative form of switches that don't take negatives as

     unrecognized.  */

  if (!value && option->cl_reject_negative)

    {

      opt_index = OPT_SPECIAL_unknown;

      errors |= CL_ERR_NEGATIVE;

      arg = argv[0];

      goto done;

    }

  result = extra_args + 1;

  warn_message = option->warn_message;

  /* Check to see if the option is disabled for this configuration.  */

  if (option->cl_disabled)

    errors |= CL_ERR_DISABLED;

  /* Determine whether there may be a separate argument based on

     whether this option is being processed for the driver, and, if

     so, how many such arguments.  */

  separate_arg_flag = ((option->flags & CL_SEPARATE)

                       && !(option->cl_no_driver_arg

                            && (lang_mask & CL_DRIVER)));

  separate_args = (separate_arg_flag

                   ? option->cl_separate_nargs + 1

                   : 0);

  joined_arg_flag = (option->flags & CL_JOINED) != 0;

  /* Sort out any argument the switch takes.  */

  if (joined_arg_flag)

    {

      /* 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[extra_args] + cl_options[opt_index].opt_len + 1 + adjust_len;

      if (*arg == '\0' && !option->cl_missing_ok)

        {

          if (separate_arg_flag)

            {

              arg = argv[extra_args + 1];

              result = extra_args + 2;

              if (arg == NULL)

                result = extra_args + 1;

              else

                have_separate_arg = true;

            }

          else

            /* Missing argument.  */

            arg = NULL;

        }

    }

  else if (separate_arg_flag)

    {

      arg = argv[extra_args + 1];

      for (i = 0; i < separate_args; i++)

        if (argv[extra_args + 1 + i] == NULL)

          {

            errors |= CL_ERR_MISSING_ARG;

            break;

          }

      result = extra_args + 1 + i;

      if (arg != NULL)

        have_separate_arg = true;

    }

  if (arg == NULL && (separate_arg_flag || joined_arg_flag))

    errors |= CL_ERR_MISSING_ARG;

  /* Is this option an alias (or an ignored option, marked as an alias

     of OPT_SPECIAL_ignore)?  */

  if (option->alias_target != N_OPTS

      && (!option->cl_separate_alias || have_separate_arg))

    {

      size_t new_opt_index = option->alias_target;

      if (new_opt_index == OPT_SPECIAL_ignore)

        {

          gcc_assert (option->alias_arg == NULL);

          gcc_assert (option->neg_alias_arg == NULL);

          opt_index = new_opt_index;

          arg = NULL;

          value = 1;

        }

      else

        {

          const struct cl_option *new_option = &cl_options[new_opt_index];

          /* The new option must not be an alias itself.  */

          gcc_assert (new_option->alias_target == N_OPTS

                      || new_option->cl_separate_alias);

          if (option->neg_alias_arg)

            {

              gcc_assert (option->alias_arg != NULL);

              gcc_assert (arg == NULL);

              gcc_assert (!option->cl_negative_alias);

              if (value)

                arg = option->alias_arg;

              else

                arg = option->neg_alias_arg;

              value = 1;

            }

          else if (option->alias_arg)

            {

              gcc_assert (value == 1);

              gcc_assert (arg == NULL);

              gcc_assert (!option->cl_negative_alias);

              arg = option->alias_arg;

            }

          if (option->cl_negative_alias)

            value = !value;

          opt_index = new_opt_index;

          option = new_option;

          if (value == 0)

            gcc_assert (!option->cl_reject_negative);

          /* Recompute what arguments are allowed.  */

          separate_arg_flag = ((option->flags & CL_SEPARATE)

                               && !(option->cl_no_driver_arg

                                    && (lang_mask & CL_DRIVER)));

          joined_arg_flag = (option->flags & CL_JOINED) != 0;

          if (separate_args > 1 || option->cl_separate_nargs)

            gcc_assert (separate_args

                        == (unsigned int) option->cl_separate_nargs + 1);

          if (!(errors & CL_ERR_MISSING_ARG))

            {

              if (separate_arg_flag || joined_arg_flag)

                {

                  if (option->cl_missing_ok && arg == NULL)

                    arg = "";

                  gcc_assert (arg != NULL);

                }

              else

                gcc_assert (arg == NULL);

            }

          /* Recheck for warnings and disabled options.  */

          if (option->warn_message)

            {

              gcc_assert (warn_message == NULL);

              warn_message = option->warn_message;

            }

          if (option->cl_disabled)

            errors |= CL_ERR_DISABLED;

        }

    }

  /* Check if this is a switch for a different front end.  */

  if (!option_ok_for_language (option, lang_mask))

    errors |= CL_ERR_WRONG_LANG;

  /* Convert the argument to lowercase if appropriate.  */

  if (arg && option->cl_tolower)

    {

      size_t j;

      size_t len = strlen (arg);

      char *arg_lower = XNEWVEC (char, len + 1);

      for (j = 0; j < len; j++)

        arg_lower[j] = TOLOWER ((unsigned char) arg[j]);

      arg_lower[len] = 0;

      arg = arg_lower;

    }

  /* If the switch takes an integer, convert it.  */

  if (arg && option->cl_uinteger)

    {

      value = integral_argument (arg);

      if (value == -1)

        errors |= CL_ERR_UINT_ARG;

    }

  /* If the switch takes an enumerated argument, convert it.  */

  if (arg && (option->var_type == CLVC_ENUM))

    {

      const struct cl_enum *e = &cl_enums[option->var_enum];

      gcc_assert (value == 1);

      if (enum_arg_to_value (e->values, arg, &value, lang_mask))

        {

          const char *carg = NULL;

          if (enum_value_to_arg (e->values, &carg, value, lang_mask))

            arg = carg;

          gcc_assert (carg != NULL);

        }

      else

        errors |= CL_ERR_ENUM_ARG;

    }

 done:

  decoded->opt_index = opt_index;

  decoded->arg = arg;

  decoded->value = value;

  decoded->errors = errors;

  decoded->warn_message = warn_message;

  if (opt_index == OPT_SPECIAL_unknown)

    gcc_assert (result == 1);

  gcc_assert (result >= 1 && result <= ARRAY_SIZE (decoded->canonical_option));

  decoded->canonical_option_num_elements = result;

  total_len = 0;

  for (i = 0; i < ARRAY_SIZE (decoded->canonical_option); i++)

    {

      if (i < result)

        {

          size_t len;

          if (opt_index == OPT_SPECIAL_unknown)

            decoded->canonical_option[i] = argv[i];

          else

            decoded->canonical_option[i] = NULL;

          len = strlen (argv[i]);

          /* If the argument is an empty string, we will print it as "" in