Adding upstream version 1:10.5.12.upstream/1%10.5.12upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1710 insertions, 0 deletions

diff --git a/mysys/my_getopt.c b/mysys/my_getopt.c
new file mode 100644
index 00000000..9747ee42
--- /dev/null
+++ b/mysys/my_getopt.c
@@ -0,0 +1,1710 @@
+/*
+   Copyright (c) 2002, 2013, Oracle and/or its affiliates
+   Copyright (c) 2009, 2020, MariaDB
+
+   This program 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; version 2 of the License.
+
+   This program 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 this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1335  USA */
+
+#include <mysys_priv.h>
+#include <my_default.h>
+#include <m_string.h>
+#include <stdlib.h>
+#include <mysys_err.h>
+#include <my_getopt.h>
+#include <errno.h>
+
+my_bool is_file_marker(const char* arg);
+typedef void (*init_func_p)(const struct my_option *option, void *variable,
+                            longlong value);
+
+static void default_reporter(enum loglevel level, const char *format, ...);
+my_error_reporter my_getopt_error_reporter= &default_reporter;
+
+static int findopt(char *, uint, const struct my_option **, const char **);
+static my_bool getopt_compare_strings(const char *, const char *, uint);
+static longlong getopt_ll(char *arg, const struct my_option *optp, int *err);
+static ulonglong getopt_ull(char *, const struct my_option *, int *);
+static double getopt_double(char *arg, const struct my_option *optp, int *err);
+static void init_variables(const struct my_option *, init_func_p);
+static void init_one_value(const struct my_option *, void *, longlong);
+static void fini_one_value(const struct my_option *, void *, longlong);
+static int setval(const struct my_option *, void *, char *, my_bool);
+static char *check_struct_option(char *cur_arg, char *key_name);
+
+/*
+  The following three variables belong to same group and the number and
+  order of their arguments must correspond to each other.
+*/
+static const char *special_opt_prefix[]=
+{"skip", "disable", "enable", "maximum", "loose", "autoset", 0};
+static const uint special_opt_prefix_lengths[]=
+{ 4,      7,         6,        7,         5,       7,        0};
+enum enum_special_opt
+{ OPT_SKIP, OPT_DISABLE, OPT_ENABLE, OPT_MAXIMUM, OPT_LOOSE, OPT_AUTOSET};
+
+char *disabled_my_option= (char*) "0";
+char *enabled_my_option= (char*) "1";
+char *autoset_my_option= (char*) "auto";
+
+/*
+   This is a flag that can be set in client programs. 0 means that
+   my_getopt will not print error messages, but the client should do
+   it by itself
+*/
+
+my_bool my_getopt_print_errors= 1;
+
+/*
+   This is a flag that can be set in client programs. 1 means that
+   my_getopt will skip over options it does not know how to handle.
+*/
+
+my_bool my_getopt_skip_unknown= 0;
+
+
+/*
+   This is a flag that can be set in client programs. 1 means that
+   my_getopt will reconize command line options by their unambiguous
+   prefixes. 0 means an option must be always specified in full.
+*/
+my_bool my_getopt_prefix_matching= 1;
+
+/*
+   This is a flag that can be set in client programs. 1 means that
+   handle_options()  will not initialize options to default values.
+*/
+my_bool my_handle_options_init_variables = 1;
+
+my_getopt_value my_getopt_get_addr= 0;
+
+static void default_reporter(enum loglevel level, const char *format, ...)
+{
+  va_list args;
+  DBUG_ENTER("default_reporter");
+
+  va_start(args, format);
+  if (level == WARNING_LEVEL)
+    fprintf(stderr, "%s", "Warning: ");
+  else if (level == INFORMATION_LEVEL)
+    fprintf(stderr, "%s", "Info: ");
+  vfprintf(stderr, format, args);
+  va_end(args);
+  fputc('\n', stderr);
+  fflush(stderr);
+  DBUG_VOID_RETURN;
+}
+
+union ull_dbl
+{
+  ulonglong ull;
+  double dbl;
+};
+
+/**
+  Returns an ulonglong value containing a raw
+  representation of the given double value.
+*/
+ulonglong getopt_double2ulonglong(double v)
+{
+  union ull_dbl u;
+  u.dbl= v;
+  compile_time_assert(sizeof(ulonglong) >= sizeof(double));
+  return u.ull;
+}
+
+/**
+  Returns the double value which corresponds to
+  the given raw representation.
+*/
+double getopt_ulonglong2double(ulonglong v)
+{
+  union ull_dbl u;
+  u.ull= v;
+  return u.dbl;
+}
+
+/**
+  Handle command line options.
+  Sort options.
+  Put options first, until special end of options (--),
+  or until the end of argv. Parse options, check that the given option
+  matches with one of the options in struct 'my_option'.
+  Check that option was given an argument if it requires one
+  Call the 'get_one_option()' function once for each option.
+
+  Note that handle_options() can be invoked multiple times to
+  parse a command line in several steps.
+  In this case, use the global flag @c my_getopt_skip_unknown to indicate
+  that options unknown in the current step should be preserved in the
+  command line for later parsing in subsequent steps.
+
+  For 'long' options (--a_long_option), @c my_getopt_skip_unknown is
+  fully supported. Command line parameters such as:
+  - "--a_long_option"
+  - "--a_long_option=value"
+  - "--a_long_option value"
+  will be preserved as is when the option is not known.
+
+  For 'short' options (-S), support for @c my_getopt_skip_unknown
+  comes with some limitation, because several short options
+  can also be specified together in the same command line argument,
+  as in "-XYZ".
+
+  The first use case supported is: all short options are declared.
+  handle_options() will be able to interpret "-XYZ" as one of:
+  - an unknown X option
+  - "-X -Y -Z", three short options with no arguments
+  - "-X -YZ", where Y is a short option with argument Z
+  - "-XYZ", where X is a short option with argument YZ
+  based on the full short options specifications.
+
+  The second use case supported is: no short option is declared.
+  handle_options() will reject "-XYZ" as unknown, to be parsed later.
+
+  The use case that is explicitly not supported is to provide
+  only a partial list of short options to handle_options().
+  This function can not be expected to extract some option Y
+  in the middle of the string "-XYZ" in these conditions,
+  without knowing if X will be declared an option later.
+
+  Note that this limitation only impacts parsing of several
+  short options from the same command line argument,
+  as in "mysqld -anW5".
+  When each short option is properly separated out in the command line
+  argument, for example in "mysqld -a -n -w5", the code would actually
+  work even with partial options specs given at each stage.
+
+  @param [in, out] argc      command line options (count)
+  @param [in, out] argv      command line options (values)
+  @param [in] longopts       descriptor of all valid options
+  @param [in] get_one_option callback function to process each option
+  @return error in case of ambiguous or unknown options,
+          0 on success.
+*/
+int handle_options(int *argc, char ***argv, const struct my_option *longopts,
+                   my_get_one_option get_one_option)
+{
+  uint UNINIT_VAR(opt_found), argvpos= 0, length;
+  my_bool end_of_options= 0, must_be_var, set_maximum_value,
+          option_is_loose, option_is_autoset;
+  char **pos, **pos_end, *optend, *opt_str, key_name[FN_REFLEN];
+  char *filename= (char*)"";
+  const char *UNINIT_VAR(prev_found);
+  const struct my_option *optp;
+  void *value;
+  int error, i;
+  my_bool is_cmdline_arg= 1;
+  DBUG_ENTER("handle_options");
+
+  /* handle_options() assumes arg0 (program name) always exists */
+  DBUG_ASSERT(*argc >= 1);
+  DBUG_ASSERT(*argv);
+  (*argc)--; /* Skip the program name */
+  (*argv)++; /*      --- || ----      */
+  if (my_handle_options_init_variables)
+    init_variables(longopts, init_one_value);
+
+  is_cmdline_arg= !is_file_marker(**argv);
+
+  for (pos= *argv, pos_end=pos+ *argc; pos != pos_end ; pos++)
+  {
+    char **first= pos;
+    char *cur_arg= *pos;
+    opt_found= 0;
+    if (!is_cmdline_arg)
+    {
+      if (is_file_marker(cur_arg))
+      {
+        pos++;
+        filename= *pos;
+        is_cmdline_arg= *filename == 0; /* empty file name = command line */
+        if (my_getopt_skip_unknown)
+        {
+          (*argv)[argvpos++]= cur_arg;
+          (*argv)[argvpos++]= filename;
+        }
+        else
+          (*argc)-= 2;
+        continue;
+      }
+    }
+    if (cur_arg[0] == '-' && cur_arg[1] && !end_of_options) /* must be opt */
+    {
+      char *argument=    0;
+      must_be_var=       0;
+      set_maximum_value= 0;
+      option_is_loose=   0;
+      option_is_autoset= 0;
+
+      cur_arg++;		/* skip '-' */
+      if (*cur_arg == '-')      /* check for long option, */
+      {
+        if (!*++cur_arg)	/* skip the double dash */
+        {
+          /* '--' means end of options, look no further */
+          end_of_options= 1;
+          (*argc)--;
+          continue;
+        }
+	opt_str= check_struct_option(cur_arg, key_name);
+	optend= strcend(opt_str, '=');
+	length= (uint) (optend - opt_str);
+	if (*optend == '=')
+	  optend++;
+	else
+	  optend= 0;
+
+	/*
+	  Find first the right option. Return error in case of an ambiguous,
+	  or unknown option
+	*/
+	optp= longopts;
+	if (!(opt_found= findopt(opt_str, length, &optp, &prev_found)))
+	{
+	  /*
+	    Didn't find any matching option. Let's see if someone called
+	    option with a special option prefix
+	  */
+	  if (!must_be_var)
+	  {
+	    if (optend)
+	      must_be_var= 1; /* option is followed by an argument */
+	    for (i= 0; special_opt_prefix[i]; i++)
+	    {
+	      if (!getopt_compare_strings(special_opt_prefix[i], opt_str,
+					  special_opt_prefix_lengths[i]) &&
+		  (opt_str[special_opt_prefix_lengths[i]] == '-' ||
+		   opt_str[special_opt_prefix_lengths[i]] == '_'))
+	      {
+		/*
+		  We were called with a special prefix, we can reuse opt_found
+		*/
+		opt_str+= special_opt_prefix_lengths[i] + 1;
+                length-= special_opt_prefix_lengths[i] + 1;
+		if (i == OPT_LOOSE)
+		  option_is_loose= 1;
+		else if (i == OPT_AUTOSET)
+		  option_is_autoset= 1;
+		if ((opt_found= findopt(opt_str, length, &optp, &prev_found)))
+		{
+		  if (opt_found > 1)
+		  {
+		    if (my_getopt_print_errors)
+                      my_getopt_error_reporter(ERROR_LEVEL,
+                                               "%s: ambiguous option '--%s-%s' (--%s-%s)",
+                                               my_progname, special_opt_prefix[i],
+                                               opt_str, special_opt_prefix[i],
+                                               prev_found);
+		    DBUG_RETURN(EXIT_AMBIGUOUS_OPTION);
+		  }
+		  switch (i) {
+		  case OPT_SKIP:
+		  case OPT_DISABLE: /* fall through */
+		    /*
+		      double negation is actually enable again,
+		      for example: --skip-option=0 -> option = TRUE
+		    */
+		    optend= (optend && *optend == '0' && !(*(optend + 1))) ?
+		      enabled_my_option : disabled_my_option;
+		    break;
+		  case OPT_ENABLE:
+		    optend= (optend && *optend == '0' && !(*(optend + 1))) ?
+                      disabled_my_option : enabled_my_option;
+		    break;
+		  case OPT_MAXIMUM:
+		    set_maximum_value= 1;
+		    must_be_var= 1;
+		    break;
+		  }
+		  break; /* break from the inner loop, main loop continues */
+		}
+                i= -1; /* restart the loop */
+	      }
+	    }
+	  }
+	  if (!opt_found)
+	  {
+            if (my_getopt_skip_unknown)
+            {
+              /* Preserve all the components of this unknown option. */
+              do {
+                (*argv)[argvpos++]= *first++;
+              } while (first <= pos);
+              continue;
+            }
+	    if (must_be_var)
+	    {
+	      if (my_getopt_print_errors)
+                my_getopt_error_reporter(option_is_loose ? 
+                                           WARNING_LEVEL : ERROR_LEVEL,
+                                         "%s: unknown variable '%s'",
+                                         my_progname, cur_arg);
+	      if (!option_is_loose)
+		DBUG_RETURN(EXIT_UNKNOWN_VARIABLE);
+	    }
+	    else
+	    {
+	      if (my_getopt_print_errors)
+                my_getopt_error_reporter(option_is_loose ? 
+                                           WARNING_LEVEL : ERROR_LEVEL,
+                                         "%s: unknown option '--%s'", 
+                                         my_progname, cur_arg);
+	      if (!option_is_loose)
+		DBUG_RETURN(EXIT_UNKNOWN_OPTION);
+	    }
+	    if (option_is_loose)
+	    {
+	      (*argc)--;
+	      continue;
+	    }
+	  }
+	}
+	if (opt_found > 1)
+	{
+	  if (must_be_var)
+	  {
+	    if (my_getopt_print_errors)
+              my_getopt_error_reporter(ERROR_LEVEL,
+                                       "%s: variable prefix '%s' is not unique",
+                                       my_progname, opt_str);
+	    DBUG_RETURN(EXIT_VAR_PREFIX_NOT_UNIQUE);
+	  }
+	  else
+	  {
+	    if (my_getopt_print_errors)
+              my_getopt_error_reporter(ERROR_LEVEL,
+                                       "%s: ambiguous option '--%s' (%s, %s)",
+                                       my_progname, opt_str, prev_found, 
+                                       optp->name);
+	    DBUG_RETURN(EXIT_AMBIGUOUS_OPTION);
+	  }
+	}
+	if ((optp->var_type & GET_TYPE_MASK) == GET_DISABLED)
+	{
+	  if (my_getopt_print_errors)
+	    fprintf(stderr,
+		    "%s: %s: Option '%s' used, but is disabled\n", my_progname,
+		    option_is_loose ? "WARNING" : "ERROR", opt_str);
+	  if (option_is_loose)
+	  {
+	    (*argc)--;
+	    continue;
+	  }
+	  DBUG_RETURN(EXIT_OPTION_DISABLED);
+	}
+        error= 0;
+	value= optp->var_type & GET_ASK_ADDR
+          ? (*my_getopt_get_addr)(key_name, (uint)strlen(key_name), optp, &error)
+          : optp->value;
+        if (error)
+          DBUG_RETURN(error);
+
+	if (optp->arg_type == NO_ARG)
+	{
+	  /*
+	    Due to historical reasons GET_BOOL var_types still accepts arguments
+	    despite the NO_ARG arg_type attribute. This can seems a bit unintuitive
+	    and care should be taken when refactoring this code.
+	  */
+	  if (optend && (optp->var_type & GET_TYPE_MASK) != GET_BOOL)
+	  {
+	    if (my_getopt_print_errors)
+              my_getopt_error_reporter(ERROR_LEVEL,
+                                       "%s: option '--%s' cannot take an argument",
+                                       my_progname, optp->name);
+	    DBUG_RETURN(EXIT_NO_ARGUMENT_ALLOWED);
+	  }
+	  if ((optp->var_type & GET_TYPE_MASK) == GET_BOOL)
+	  {
+	    /*
+	      Set bool to 1 if no argument or if the user has used
+	      --enable-'option-name'.
+	      *optend was set to '0' if one used --disable-option
+	    */
+	    (*argc)--;
+	    if (!optend || *optend == '1' ||
+		!my_strcasecmp(&my_charset_latin1, optend, "true") ||
+		!my_strcasecmp(&my_charset_latin1, optend, "on"))
+	      *((my_bool*) value)= (my_bool) 1;
+	    else if (*optend == '0' ||
+		     !my_strcasecmp(&my_charset_latin1, optend, "false") ||
+                     !my_strcasecmp(&my_charset_latin1, optend, "off"))
+	      *((my_bool*) value)= (my_bool) 0;
+	    else
+	    {
+	      my_getopt_error_reporter(WARNING_LEVEL,
+				       "%s: ignoring option '--%s' "
+                                       "due to invalid value '%s'",
+				       my_progname, optp->name, optend);
+	      continue;
+	    }
+            if (get_one_option(optp, *((my_bool*) value) ?
+                               enabled_my_option : disabled_my_option,
+                               filename))
+              DBUG_RETURN(EXIT_ARGUMENT_INVALID);
+	    continue;
+	  }
+	  argument= optend;
+	}
+	else if (option_is_autoset)
+	{
+	  if (optend)
+	  {
+	    my_getopt_error_reporter(ERROR_LEVEL,
+                                     "%s: automatically set "
+                                     "option '--%s' cannot take an argument",
+                                     my_progname, optp->name);
+
+	    DBUG_RETURN(EXIT_NO_ARGUMENT_ALLOWED);
+	  }
+	  if (!(optp->var_type & GET_AUTO))
+	  {
+	    my_getopt_error_reporter(option_is_loose ?
+				     WARNING_LEVEL : ERROR_LEVEL,
+                                     "%s: automatic setup request is "
+				     "unsupported by option '--%s'",
+                                     my_progname, optp->name);
+	    if (!option_is_loose)
+	      DBUG_RETURN(EXIT_ARGUMENT_INVALID);
+	    continue;
+	  }
+	  else
+            argument= autoset_my_option;
+	}
+	else if (optp->arg_type == REQUIRED_ARG && !optend)
+	{
+          /*
+            Check if there are more arguments after this one,
+            Note: options loaded from config file that requires value
+            should always be in the form '--option=value'.
+          */
+	  if (!is_cmdline_arg || !*++pos)
+	  {
+	    if (my_getopt_print_errors)
+              my_getopt_error_reporter(ERROR_LEVEL,
+                                       "%s: option '--%s' requires an argument",
+                                       my_progname, optp->name);
+	    DBUG_RETURN(EXIT_ARGUMENT_REQUIRED);
+	  }
+	  argument= *pos;
+	  (*argc)--;
+	}
+	else
+	  argument= optend;
+      }
+      else  /* must be short option */
+      {
+	for (optend= cur_arg; *optend; optend++)
+	{
+	  opt_found= 0;
+	  for (optp= longopts; optp->name; optp++)
+	  {
+	    if (optp->id && optp->id == (int) (uchar) *optend)
+	    {
+	      /* Option recognized. Find next what to do with it */
+	      opt_found= 1;
+	      if ((optp->var_type & GET_TYPE_MASK) == GET_DISABLED)
+	      {
+		if (my_getopt_print_errors)
+		  fprintf(stderr,
+			  "%s: ERROR: Option '-%c' used, but is disabled\n",
+			  my_progname, optp->id);
+		DBUG_RETURN(EXIT_OPTION_DISABLED);
+	      }
+	      if ((optp->var_type & GET_TYPE_MASK) == GET_BOOL &&
+		  optp->arg_type == NO_ARG)
+	      {
+		*((my_bool*) optp->value)= (my_bool) 1;
+                if (get_one_option(optp, argument, filename))
+                  DBUG_RETURN(EXIT_UNSPECIFIED_ERROR);
+		continue;
+	      }
+	      else if (optp->arg_type == REQUIRED_ARG ||
+		       optp->arg_type == OPT_ARG)
+	      {
+		if (*(optend + 1))
+		{
+		  /* The rest of the option is option argument */
+		  argument= optend + 1;
+		  /* This is in effect a jump out of the outer loop */
+		  optend= (char*) " ";
+		}
+		else
+		{
+                  if (optp->arg_type == OPT_ARG)
+                  {
+                    if (optp->var_type == GET_BOOL)
+                      *((my_bool*) optp->value)= (my_bool) 1;
+                    if (get_one_option(optp, argument, filename))
+                      DBUG_RETURN(EXIT_UNSPECIFIED_ERROR);
+                    continue;
+                  }
+		  /* Check if there are more arguments after this one */
+		  if (!pos[1])
+		  {
+                    if (my_getopt_print_errors)
+                      my_getopt_error_reporter(ERROR_LEVEL,
+                                               "%s: option '-%c' requires an argument",
+                                               my_progname, optp->id);
+                    DBUG_RETURN(EXIT_ARGUMENT_REQUIRED);
+		  }
+		  argument= *++pos;
+		  (*argc)--;
+		  /* the other loop will break, because *optend + 1 == 0 */
+		}
+	      }
+	      if ((error= setval(optp, optp->value, argument,
+				 set_maximum_value)))
+		DBUG_RETURN(error);
+              if (get_one_option(optp, argument, filename))
+                DBUG_RETURN(EXIT_UNSPECIFIED_ERROR);
+	      break;
+	    }
+	  }
+	  if (!opt_found)
+	  {
+            if (my_getopt_skip_unknown)
+            {
+              /*
+                We are currently parsing a single argv[] argument
+                of the form "-XYZ".
+                One or the argument found (say Y) is not an option.
+                Hack the string "-XYZ" to make a "-YZ" substring in it,
+                and push that to the output as an unrecognized parameter.
+              */
+              DBUG_ASSERT(optend > *pos);
+              DBUG_ASSERT(optend >= cur_arg);
+              DBUG_ASSERT(optend <= *pos + strlen(*pos));
+              DBUG_ASSERT(*optend);
+              optend--;
+              optend[0]= '-'; /* replace 'X' or '-' by '-' */
+              (*argv)[argvpos++]= optend;
+              /*
+                Do not continue to parse at the current "-XYZ" argument,
+                skip to the next argv[] argument instead.
+              */
+              optend= (char*) " ";
+            }
+            else
+            {
+              if (my_getopt_print_errors)
+                my_getopt_error_reporter(ERROR_LEVEL,
+                                         "%s: unknown option '-%c'",
+                                         my_progname, *optend);
+              DBUG_RETURN(EXIT_UNKNOWN_OPTION);
+            }
+	  }
+	}
+        if (opt_found)
+          (*argc)--; /* option handled (short), decrease argument count */
+	continue;
+      }
+      if ((!option_is_autoset) &&
+	  ((error= setval(optp, value, argument, set_maximum_value))) &&
+          !option_is_loose)
+	DBUG_RETURN(error);
+      if (get_one_option(optp, argument, filename))
+        DBUG_RETURN(EXIT_UNSPECIFIED_ERROR);
+
+      (*argc)--; /* option handled (long), decrease argument count */
+    }
+    else /* non-option found */
+      (*argv)[argvpos++]= cur_arg;
+  }
+  /*
+    Destroy the first, already handled option, so that programs that look
+    for arguments in 'argv', without checking 'argc', know when to stop.
+    Items in argv, before the destroyed one, are all non-option -arguments
+    to the program, yet to be (possibly) handled.
+  */
+  (*argv)[argvpos]= 0;
+  DBUG_RETURN(0);
+}
+
+
+/*
+  function: check_struct_option
+
+  Arguments: Current argument under processing from argv and a variable
+  where to store the possible key name.
+
+  Return value: In case option is a struct option, returns a pointer to
+  the current argument at the position where the struct option (key_name)
+  ends, the next character after the dot. In case argument is not a struct
+  option, returns a pointer to the argument.
+
+  key_name will hold the name of the key, or 0 if not found.
+*/
+
+static char *check_struct_option(char *cur_arg, char *key_name)
+{
+  char *ptr, *end;
+  DBUG_ENTER("check_struct_option");
+
+  ptr= strcend(cur_arg + 1, '.'); /* Skip the first character */
+  end= strcend(cur_arg, '=');
+
+  /* 
+     If the first dot is after an equal sign, then it is part
+     of a variable value and the option is not a struct option.
+     Also, if the last character in the string before the ending
+     NULL, or the character right before equal sign is the first
+     dot found, the option is not a struct option.
+  */
+  if (end - ptr > 1)
+  {
+    uint len= (uint) (ptr - cur_arg);
+    set_if_smaller(len, FN_REFLEN-1);
+    strmake(key_name, cur_arg, len);
+    DBUG_RETURN(++ptr);
+  }
+  else
+  {
+    key_name[0]= 0;
+    DBUG_RETURN(cur_arg);
+  }
+}
+
+/**
+   Parse a boolean command line argument
+
+   "ON", "TRUE" and "1" will return true,
+   other values will return false.
+
+   @param[in] argument The value argument
+   @return boolean value
+*/
+static my_bool get_bool_argument(const struct my_option *opts,
+                                 const char *argument)
+{
+  DBUG_ENTER("get_bool_argument");
+
+  if (!my_strcasecmp(&my_charset_latin1, argument, "true") ||
+      !my_strcasecmp(&my_charset_latin1, argument, "on") ||
+      !my_strcasecmp(&my_charset_latin1, argument, "1"))
+    DBUG_RETURN(1);
+  else if (!my_strcasecmp(&my_charset_latin1, argument, "false") ||
+      !my_strcasecmp(&my_charset_latin1, argument, "off") ||
+      !my_strcasecmp(&my_charset_latin1, argument, "0"))
+    DBUG_RETURN(0);
+  my_getopt_error_reporter(WARNING_LEVEL,
+      "option '%s': boolean value '%s' wasn't recognized. Set to OFF.",
+      opts->name, argument);
+  DBUG_RETURN(0);
+}
+
+/*
+  function: setval
+
+  Arguments: opts, argument
+  Will set the option value to given value
+*/
+
+static int setval(const struct my_option *opts, void *value, char *argument,
+		  my_bool set_maximum_value)
+{
+  int err= 0, res= 0;
+  DBUG_ENTER("setval");
+
+  if (!argument)
+    argument= enabled_my_option;
+
+  if (value)
+  {
+    if (set_maximum_value && !(value= opts->u_max_value))
+    {
+      my_getopt_error_reporter(ERROR_LEVEL,
+                               "%s: Maximum value of '%s' cannot be set",
+                               my_progname, opts->name);
+      DBUG_RETURN(EXIT_NO_PTR_TO_VARIABLE);
+    }
+
+    switch ((opts->var_type & GET_TYPE_MASK)) {
+    case GET_BOOL: /* If argument differs from 0, enable option, else disable */
+      *((my_bool*) value)= get_bool_argument(opts, argument);
+      break;
+    case GET_INT:
+      *((int*) value)= (int) getopt_ll(argument, opts, &err);
+      break;
+    case GET_UINT:
+      *((uint*) value)= (uint) getopt_ull(argument, opts, &err);
+      break;
+    case GET_LONG:
+      *((long*) value)= (long) getopt_ll(argument, opts, &err);
+      break;
+    case GET_ULONG:
+      *((long*) value)= (long) getopt_ull(argument, opts, &err);
+      break;
+    case GET_LL:
+      *((longlong*) value)= getopt_ll(argument, opts, &err);
+      break;
+    case GET_ULL:
+      *((ulonglong*) value)= getopt_ull(argument, opts, &err);
+      break;
+    case GET_DOUBLE:
+      *((double*) value)= getopt_double(argument, opts, &err);
+      break;
+    case GET_STR:
+      /* If no argument or --enable-string-option, set string to "" */
+      *((char**) value)= argument == enabled_my_option ? (char*) "" : argument;
+      break;
+    case GET_STR_ALLOC:
+      my_free(*((char**) value));
+      if (!(*((char**) value)= my_strdup(key_memory_defaults,
+                                         argument == enabled_my_option ? "" :
+                                         argument, MYF(MY_WME))))
+      {
+        res= EXIT_OUT_OF_MEMORY;
+        goto ret;
+      };
+      break;
+    case GET_ENUM:
+      {
+        int type= find_type(argument, opts->typelib, FIND_TYPE_BASIC);
+        if (type == 0)
+        {
+          /*
+            Accept an integer representation of the enumerated item.
+          */
+          char *endptr;
+          ulong arg= strtoul(argument, &endptr, 10);
+          if (*endptr || arg >= opts->typelib->count)
+          {
+            res= EXIT_ARGUMENT_INVALID;
+            goto ret;
+          }
+          *(ulong*)value= arg;
+        }
+        else if (type < 0)
+        {
+          res= EXIT_AMBIGUOUS_OPTION;
+          goto ret;
+        }
+        else
+          *(ulong*)value= type - 1;
+      }
+      break;
+    case GET_SET:
+      *((ulonglong*)value)= find_typeset(argument, opts->typelib, &err);
+      if (err)
+      {
+        /* Accept an integer representation of the set */
+        char *endptr;
+        ulonglong arg= (ulonglong) strtol(argument, &endptr, 10);
+        if (*endptr || (arg >> 1) >= (1ULL << (opts->typelib->count-1)))
+        {
+          res= EXIT_ARGUMENT_INVALID;
+          goto ret;
+        };
+        *(ulonglong*)value= arg;
+        err= 0;
+      }
+      break;
+    case GET_FLAGSET:
+      {
+        char *error;
+        uint error_len;
+
+        *((ulonglong*)value)=
+              find_set_from_flags(opts->typelib, opts->typelib->count, 
+                                  *(ulonglong *)value, opts->def_value,
+                                  argument, (uint)strlen(argument),
+                                  &error, &error_len);
+        if (error)
+        {
+          res= EXIT_ARGUMENT_INVALID;
+          goto ret;
+        };
+      }
+      break;
+    case GET_BIT:
+    {
+      uint tmp;
+      ulonglong bit= (opts->block_size >= 0 ?
+                      opts->block_size :
+                      -opts->block_size);
+      /*
+        This sets a bit stored in a longlong.
+        The bit to set is stored in block_size. If block_size is positive
+        then setting the bit means value is true. If block_size is negatitive,
+        then setting the bit means value is false.
+      */
+      tmp= get_bool_argument(opts, argument);
+      if (opts->block_size < 0)
+        tmp= !tmp;
+      if (tmp)
+        (*(ulonglong*)value)|= bit;
+      else
+        (*(ulonglong*)value)&= ~bit;
+      break;
+    }
+    case GET_NO_ARG: /* get_one_option has taken care of the value already */
+    default:         /* dummy default to avoid compiler warnings */
+      break;
+    }
+    if (err)
+    {
+      res= EXIT_UNKNOWN_SUFFIX;
+      goto ret;
+    };
+  }
+  DBUG_RETURN(0);
+
+ret:
+  my_getopt_error_reporter(ERROR_LEVEL,
+                           "%s: Error while setting value '%s' to '%s'",
+                           my_progname, argument, opts->name);
+  DBUG_RETURN(res);
+}
+
+
+/* 
+  Find option
+
+  SYNOPSIS
+    findopt()
+    optpat	Prefix of option to find (with - or _)
+    length	Length of optpat
+    opt_res	Options
+    ffname	Place for pointer to first found name
+
+  IMPLEMENTATION
+    Go through all options in the my_option struct. Return number
+    of options found that match the pattern and in the argument
+    list the option found, if any. In case of ambiguous option, store
+    the name in ffname argument
+
+    RETURN
+    0    No matching options
+    #   Number of matching options
+        ffname points to first matching option
+*/
+
+static int findopt(char *optpat, uint length,
+		   const struct my_option **opt_res,
+		   const char **ffname)
+{
+  uint count;
+  const struct my_option *opt= *opt_res;
+  DBUG_ENTER("findopt");
+
+  for (count= 0; opt->name; opt++)
+  {
+    if (!getopt_compare_strings(opt->name, optpat, length)) /* match found */
+    {
+      (*opt_res)= opt;
+      if (!opt->name[length])		/* Exact match */
+	DBUG_RETURN(1);
+
+      if (!my_getopt_prefix_matching)
+        continue;
+
+      if (!count)
+      {
+        /* We only need to know one prev */
+	count= 1;
+	*ffname= opt->name;
+      }
+      else if (strcmp(*ffname, opt->name))
+      {
+	/*
+	  The above test is to not count same option twice
+	  (see mysql.cc, option "help")
+	*/
+	count++;
+      }
+    }
+  }
+
+  if (count == 1)
+    my_getopt_error_reporter(INFORMATION_LEVEL,
+                             "Using unique option prefix '%.*s' is error-prone "
+                             "and can break in the future. "
+                             "Please use the full name '%s' instead.",
+                             length, optpat, *ffname);
+
+  DBUG_RETURN(count);
+}
+
+
+/* 
+  function: compare_strings
+
+  Works like strncmp, other than 1.) considers '-' and '_' the same.
+  2.) Returns -1 if strings differ, 0 if they are equal
+*/
+
+my_bool getopt_compare_strings(register const char *s, register const char *t,
+			       uint length)
+{
+  char const *end= s + length;
+  DBUG_ENTER("getopt_compare_strings");
+
+  for (;s != end ; s++, t++)
+  {
+    if ((*s != '-' ? *s : '_') != (*t != '-' ? *t : '_'))
+      DBUG_RETURN(1);
+  }
+  DBUG_RETURN(0);
+}
+
+/*
+  function: eval_num_suffix
+
+  Transforms suffix like k/m/g/t/p/e to their real value.
+*/
+
+static inline ulonglong eval_num_suffix(char *suffix, int *error)
+{
+  switch (*suffix) {
+  case '\0':
+    return 1ULL;
+  case 'k':
+  case 'K':
+    return 1ULL << 10;
+  case 'm':
+  case 'M':
+    return 1ULL << 20;
+  case 'g':
+  case 'G':
+    return 1ULL << 30;
+  case 't':
+  case 'T':
+    return 1ULL << 40;
+  case 'p':
+  case 'P':
+    return 1ULL << 50;
+  case 'e':
+  case 'E':
+    return 1ULL << 60;
+  default:
+    *error= 1;
+    return 0ULL;
+  }
+}
+
+/*
+  function: eval_num_suffix_ll
+
+  Transforms a number with a suffix to real number. Suffix can
+  be k|K for kilo, m|M for mega, etc.
+*/
+
+static longlong eval_num_suffix_ll(char *argument,
+                                   int *error, char *option_name)
+{
+  char *endchar;
+  longlong num;
+  DBUG_ENTER("eval_num_suffix_ll");
+
+  
+  *error= 0;
+  errno= 0;
+  num= strtoll(argument, &endchar, 10);
+  if (errno == ERANGE)
+  {
+    my_getopt_error_reporter(ERROR_LEVEL,
+                             "Incorrect integer value: '%s'", argument);
+    *error= 1;
+    DBUG_RETURN(0);
+  }
+  num*= eval_num_suffix(endchar, error);
+  if (*error)
+    fprintf(stderr,
+	    "Unknown suffix '%c' used for variable '%s' (value '%s')\n",
+	    *endchar, option_name, argument);
+  DBUG_RETURN(num);
+}
+
+/*
+  function: eval_num_suffix_ull
+
+  Transforms a number with a suffix to positive Integer. Suffix can
+  be k|K for kilo, m|M for mega, etc.
+*/
+
+static ulonglong eval_num_suffix_ull(char *argument,
+                                     int *error, char *option_name)
+{
+  char *endchar;
+  ulonglong num;
+  DBUG_ENTER("eval_num_suffix_ull");
+
+  *error= 0;
+  errno= 0;
+  num= strtoull(argument, &endchar, 10);
+  if (errno == ERANGE)
+  {
+    my_getopt_error_reporter(ERROR_LEVEL,
+                             "Incorrect integer value: '%s'", argument);
+    *error= 1;
+    DBUG_RETURN(0);
+  }
+  num*= eval_num_suffix(endchar, error);
+  if (*error)
+    fprintf(stderr,
+	    "Unknown suffix '%c' used for variable '%s' (value '%s')\n",
+	    *endchar, option_name, argument);
+  DBUG_RETURN(num);
+}
+
+
+/*
+  function: getopt_ll
+
+  Evaluates and returns the value that user gave as an argument
+  to a variable. Recognizes (case insensitive) K as KILO, M as MEGA
+  and G as GIGA bytes. Some values must be in certain blocks, as
+  defined in the given my_option struct, this function will check
+  that those values are honored.
+  In case of an error, set error value in *err.
+*/
+
+static longlong getopt_ll(char *arg, const struct my_option *optp, int *err)
+{
+  longlong num=eval_num_suffix_ll(arg, err, (char*) optp->name);
+  return getopt_ll_limit_value(num, optp, NULL);
+}
+
+/*
+  function: getopt_ll_limit_value
+
+  Applies min/max/block_size to a numeric value of an option.
+  Returns "fixed" value.
+*/
+
+longlong getopt_ll_limit_value(longlong num, const struct my_option *optp,
+                               my_bool *fix)
+{
+  longlong old= num;
+  my_bool adjusted= FALSE;
+  char buf1[255], buf2[255];
+  ulonglong block_size= (optp->block_size ? (ulonglong) optp->block_size : 1L);
+  DBUG_ENTER("getopt_ll_limit_value");
+
+  if (num > 0 && ((ulonglong) num > (ulonglong) optp->max_value) &&
+      optp->max_value) /* if max value is not set -> no upper limit */
+  {
+    num= (ulonglong) optp->max_value;
+    adjusted= TRUE;
+  }
+
+  switch ((optp->var_type & GET_TYPE_MASK)) {
+  case GET_INT:
+    if (num > (longlong) INT_MAX)
+    {
+      num= ((longlong) INT_MAX);
+      adjusted= TRUE;
+    }
+    break;
+  case GET_LONG:
+#if SIZEOF_LONG < SIZEOF_LONG_LONG
+    if (num > (longlong) LONG_MAX)
+    {
+      num= ((longlong) LONG_MAX);
+      adjusted= TRUE;
+    }
+#endif
+    break;
+  default:
+    DBUG_ASSERT((optp->var_type & GET_TYPE_MASK) == GET_LL);
+    break;
+  }
+
+  num= (num / block_size);
+  num= (longlong) (num * block_size);
+
+  if (num < optp->min_value)
+  {
+    num= optp->min_value;
+    if (old < optp->min_value)
+      adjusted= TRUE;
+  }
+
+  if (fix)
+    *fix= old != num;
+  else if (adjusted)
+    my_getopt_error_reporter(WARNING_LEVEL,
+                             "option '%s': signed value %s adjusted to %s",
+                             optp->name, llstr(old, buf1), llstr(num, buf2));
+  DBUG_RETURN(num);
+}
+
+/*
+  function: getopt_ull
+
+  This is the same as getopt_ll, but is meant for unsigned long long
+  values.
+*/
+
+static ulonglong getopt_ull(char *arg, const struct my_option *optp, int *err)
+{
+  ulonglong num= eval_num_suffix_ull(arg, err, (char*) optp->name);
+  return getopt_ull_limit_value(num, optp, NULL);
+}
+
+
+ulonglong getopt_ull_limit_value(ulonglong num, const struct my_option *optp,
+                                 my_bool *fix)
+{
+  my_bool adjusted= FALSE;
+  ulonglong old= num;
+  char buf1[255], buf2[255];
+  DBUG_ENTER("getopt_ull_limit_value");
+
+  if ((ulonglong) num > (ulonglong) optp->max_value &&
+      optp->max_value) /* if max value is not set -> no upper limit */
+  {
+    num= (ulonglong) optp->max_value;
+    adjusted= TRUE;
+  }
+
+  switch ((optp->var_type & GET_TYPE_MASK)) {
+  case GET_UINT:
+    if (num > (ulonglong) UINT_MAX)
+    {
+      num= ((ulonglong) UINT_MAX);
+      adjusted= TRUE;
+    }
+    break;
+  case GET_ULONG:
+#if SIZEOF_LONG < SIZEOF_LONG_LONG
+    if (num > (ulonglong) ULONG_MAX)
+    {
+      num= ((ulonglong) ULONG_MAX);
+      adjusted= TRUE;
+    }
+#endif
+    break;
+  default:
+    DBUG_ASSERT((optp->var_type & GET_TYPE_MASK) == GET_ULL);
+    break;
+  }
+
+  if (optp->block_size > 1)
+  {
+    num/= (ulonglong) optp->block_size;
+    num*= (ulonglong) optp->block_size;
+  }
+
+  if (num < (ulonglong) optp->min_value)
+  {
+    num= (ulonglong) optp->min_value;
+    if (old < (ulonglong) optp->min_value)
+      adjusted= TRUE;
+  }
+
+  if (fix)
+    *fix= old != num;
+  else if (adjusted)
+    my_getopt_error_reporter(WARNING_LEVEL,
+                             "option '%s': unsigned value %s adjusted to %s",
+                             optp->name, ullstr(old, buf1), ullstr(num, buf2));
+
+  DBUG_RETURN(num);
+}
+
+double getopt_double_limit_value(double num, const struct my_option *optp,
+                                 my_bool *fix)
+{
+  my_bool adjusted= FALSE;
+  double old= num;
+  double min, max;
+  DBUG_ENTER("getopt_double_limit_value");
+
+  max= getopt_ulonglong2double(optp->max_value);
+  min= getopt_ulonglong2double(optp->min_value);
+  if (max && num > max)
+  {
+    num= max;
+    adjusted= TRUE;
+  }
+  if (num < min)
+  {
+    num= min;
+    adjusted= TRUE;
+  }
+  if (fix)
+    *fix= adjusted;
+  else if (adjusted)
+    my_getopt_error_reporter(WARNING_LEVEL,
+                             "option '%s': value %g adjusted to %g",
+                             optp->name, old, num);
+  DBUG_RETURN(num);
+}
+
+/*
+  Get double value withing ranges
+
+  Evaluates and returns the value that user gave as an argument to a variable.
+
+  RETURN
+    decimal value of arg
+
+    In case of an error, prints an error message and sets *err to
+    EXIT_ARGUMENT_INVALID.  Otherwise err is not touched
+*/
+
+static double getopt_double(char *arg, const struct my_option *optp, int *err)
+{
+  double num;
+  int error;
+  char *end= arg + 1000;                     /* Big enough as *arg is \0 terminated */
+  num= my_strtod(arg, &end, &error);
+  if (end[0] != 0 || error)
+  {
+    my_getopt_error_reporter(ERROR_LEVEL,
+            "Invalid decimal value for option '%s'\n", optp->name);
+    *err= EXIT_ARGUMENT_INVALID;
+    return 0.0;
+  }
+  return getopt_double_limit_value(num, optp, NULL);
+}
+
+/*
+  Init one value to it's default values
+
+  SYNOPSIS
+    init_one_value()
+    option              Option to initialize
+    value               Pointer to variable
+*/
+
+static void init_one_value(const struct my_option *option, void *variable,
+			   longlong value)
+{
+  DBUG_ENTER("init_one_value");
+  switch ((option->var_type & GET_TYPE_MASK)) {
+  case GET_BOOL:
+    *((my_bool*) variable)= (my_bool) value;
+    break;
+  case GET_INT:
+    *((int*) variable)= (int) getopt_ll_limit_value((int) value, option, NULL);
+    break;
+  case GET_ENUM:
+    *((ulong*) variable)= (ulong) value;
+    break;
+  case GET_UINT:
+    *((uint*) variable)= (uint) getopt_ull_limit_value((uint) value, option, NULL);
+    break;
+  case GET_LONG:
+    *((long*) variable)= (long) getopt_ll_limit_value((long) value, option, NULL);
+    break;
+  case GET_ULONG:
+    *((ulong*) variable)= (ulong) getopt_ull_limit_value((ulong) value, option, NULL);
+    break;
+  case GET_LL:
+    *((longlong*) variable)= (longlong) getopt_ll_limit_value((longlong) value, option, NULL);
+    break;
+  case GET_ULL:
+    *((ulonglong*) variable)= (ulonglong) getopt_ull_limit_value((ulonglong) value, option, NULL);
+    break;
+  case GET_SET:
+  case GET_FLAGSET:
+    *((ulonglong*) variable)= (ulonglong) value;
+    break;
+  case GET_BIT:
+  {
+    ulonglong bit= (option->block_size >= 0 ?
+                    option->block_size :
+                    -option->block_size);
+    if (option->block_size < 0)
+      value= !value;
+    if (value)
+      (*(ulonglong*)variable)|= bit;
+    else
+      (*(ulonglong*)variable)&= ~bit;
+    break;
+  }
+  case GET_DOUBLE:
+    *((double*) variable)= getopt_ulonglong2double(value);
+    break;
+  case GET_STR:
+    /*
+      Do not clear variable value if it has no default value.
+      The default value may already be set.
+      NOTE: To avoid compiler warnings, we first cast longlong to intptr,
+      so that the value has the same size as a pointer.
+    */
+    if ((char*) (intptr) value)
+      *((char**) variable)= (char*) (intptr) value;
+    break;
+  case GET_STR_ALLOC:
+    /*
+      Do not clear variable value if it has no default value.
+      The default value may already be set.
+      NOTE: To avoid compiler warnings, we first cast longlong to intptr,
+      so that the value has the same size as a pointer.
+    */
+    if ((char*) (intptr) value)
+    {
+      char **pstr= (char **) variable;
+      my_free(*pstr);
+      *pstr= my_strdup(key_memory_defaults, (char*) (intptr) value, MYF(MY_WME));
+    }
+    break;
+  default: /* dummy default to avoid compiler warnings */
+    break;
+  }
+  DBUG_VOID_RETURN;
+}
+
+
+/*
+  Init one value to it's default values
+
+  SYNOPSIS
+    init_one_value()
+    option		Option to initialize
+    value		Pointer to variable
+*/
+
+static void fini_one_value(const struct my_option *option, void *variable,
+			   longlong value __attribute__ ((unused)))
+{
+  DBUG_ENTER("fini_one_value");
+  switch ((option->var_type & GET_TYPE_MASK)) {
+  case GET_STR_ALLOC:
+    my_free(*((char**) variable));
+    *((char**) variable)= NULL;
+    break;
+  default: /* dummy default to avoid compiler warnings */
+    break;
+  }
+  DBUG_VOID_RETURN;
+}
+
+
+void my_cleanup_options(const struct my_option *options)
+{
+  DBUG_ENTER("my_cleanup_options");
+  init_variables(options, fini_one_value);
+  DBUG_VOID_RETURN;
+}
+
+
+/*
+  initialize all variables to their default values
+
+  SYNOPSIS
+    init_variables()
+    options              Array of options
+    func_init_one_value  Call this function to init the variable
+
+  NOTES
+    We will initialize the value that is pointed to by options->value.
+    If the value is of type GET_ASK_ADDR, we will ask for the address
+    for a value and initialize.
+*/
+
+static void init_variables(const struct my_option *options,
+                           init_func_p func_init_one_value)
+{
+  DBUG_ENTER("init_variables");
+  for (; options->name; options++)
+  {
+    void *value;
+    DBUG_PRINT("options", ("name: '%s'", options->name));
+    /*
+      We must set u_max_value first as for some variables
+      options->u_max_value == options->value and in this case we want to
+      set the value to default value.
+    */
+    if (options->u_max_value)
+      func_init_one_value(options, options->u_max_value, options->max_value);
+    value= options->var_type & GET_ASK_ADDR ?
+		  (*my_getopt_get_addr)("", 0, options, 0) : options->value;
+    if (value)
+      func_init_one_value(options, value, options->def_value);
+  }
+  DBUG_VOID_RETURN;
+}
+
+/** Prints variable or option name, replacing _ with - */
+static uint print_name(const struct my_option *optp)
+{
+  const char *s= optp->name;
+
+  for (;*s;s++)
+    putchar(*s == '_' ? '-' : *s);
+  return (uint)(s - optp->name);
+}
+
+/** prints option comment with indentation and wrapping.
+
+  The comment column starts at startpos, and has width of width
+  Current cursor position is curpos, returns new cursor position
+
+  @note can print one character beyond width!
+*/
+static uint print_comment(const char *comment,
+                          int curpos, int startpos, int width)
+{
+  const char *end= strend(comment);
+  int endpos= startpos + width;
+
+  for (; curpos < startpos; curpos++)
+    putchar(' ');
+
+  if (*comment == '.' || *comment == ',')
+  {
+    putchar(*comment);
+    comment++;
+    curpos++;
+  }
+
+  while (end - comment > endpos - curpos)
+  {
+    const char *line_end;
+    for (line_end= comment + endpos - curpos;
+         line_end > comment && *line_end != ' ';
+         line_end--);
+    for (; comment < line_end; comment++)
+      putchar(*comment);
+    while (*comment == ' ')
+      comment++; /* skip the space, as a newline will take it's place now */
+    putchar('\n');
+    for (curpos= 0; curpos < startpos; curpos++)
+      putchar(' ');
+  }
+  printf("%s", comment);
+  return curpos + (int)(end - comment);
+}
+
+
+/*
+  function: my_print_options
+
+  Print help for all options and variables.
+*/
+
+void my_print_help(const struct my_option *options)
+{
+  uint col, name_space= 22, comment_space= 57;
+  const struct my_option *optp;
+  DBUG_ENTER("my_print_help");
+
+  for (optp= options; optp->name; optp++)
+  {
+    const char *typelib_help= 0;
+    if (!optp->comment)
+      continue;
+    if (optp->id && optp->id < 256)
+    {
+      printf("  -%c%s", optp->id, strlen(optp->name) ? ", " : "  ");
+      col= 6;
+    }
+    else
+    {
+      printf("  ");
+      col= 2;
+    }
+    if (strlen(optp->name))
+    {
+      printf("--");
+      col+= 2 + print_name(optp);
+      if (optp->arg_type == NO_ARG ||
+	  (optp->var_type & GET_TYPE_MASK) == GET_BOOL ||
+          (optp->var_type & GET_TYPE_MASK) == GET_BIT)
+      {
+	putchar(' ');
+	col++;
+      }
+      else if ((optp->var_type & GET_TYPE_MASK) == GET_STR       ||
+               (optp->var_type & GET_TYPE_MASK) == GET_STR_ALLOC ||
+               (optp->var_type & GET_TYPE_MASK) == GET_ENUM      ||
+               (optp->var_type & GET_TYPE_MASK) == GET_SET       ||
+               (optp->var_type & GET_TYPE_MASK) == GET_FLAGSET    )
+      {
+	printf("%s=name%s ", optp->arg_type == OPT_ARG ? "[" : "",
+	       optp->arg_type == OPT_ARG ? "]" : "");
+	col+= (optp->arg_type == OPT_ARG) ? 8 : 6;
+      }
+      else
+      {
+	printf("%s=#%s ", optp->arg_type == OPT_ARG ? "[" : "",
+	       optp->arg_type == OPT_ARG ? "]" : "");
+	col+= (optp->arg_type == OPT_ARG) ? 5 : 3;
+      }
+    }
+    if (optp->comment && *optp->comment)
+    {
+      uint count;
+
+      if (col > name_space)
+      {
+	putchar('\n');
+	col= 0;
+      }
+
+      col= print_comment(optp->comment, col, name_space, comment_space);
+      if (optp->var_type & GET_AUTO)
+      {
+        col= print_comment(" (Automatically configured unless set explicitly)",
+                           col, name_space, comment_space);
+      }
+
+      switch (optp->var_type & GET_TYPE_MASK) {
+      case GET_ENUM:
+        typelib_help= ". One of: ";
+        count= optp->typelib->count;
+        break;
+      case GET_SET: 
+        typelib_help= ". Any combination of: ";
+        count= optp->typelib->count;
+        break;
+      case GET_FLAGSET:
+        typelib_help= ". Takes a comma-separated list of option=value pairs, "
+          "where value is on, off, or default, and options are: ";
+        count= optp->typelib->count - 1;
+        break;
+      }
+      if (typelib_help &&
+          strstr(optp->comment, optp->typelib->type_names[0]) == NULL)
+      {
+        uint i;
+        col= print_comment(typelib_help, col, name_space, comment_space);
+        col= print_comment(optp->typelib->type_names[0], col, name_space, comment_space);
+        for (i= 1; i < count; i++)
+        {
+          col= print_comment(", ", col, name_space, comment_space);
+          col= print_comment(optp->typelib->type_names[i], col, name_space, comment_space);
+        }
+      }
+    }
+    putchar('\n');
+    if ((optp->var_type & GET_TYPE_MASK) == GET_BOOL)
+    {
+      if (optp->def_value != 0)
+      {
+        printf("%*s(Defaults to on; use --skip-", name_space, "");
+        print_name(optp);
+        printf(" to disable.)\n");
+      }
+    }
+  }
+  DBUG_VOID_RETURN;
+}
+
+
+/*
+  function: my_print_options
+
+  Print variables.
+*/
+
+void my_print_variables(const struct my_option *options)
+{
+  uint name_space= 34, length, nr;
+  ulonglong llvalue;
+  char buff[255];
+  const struct my_option *optp;
+  DBUG_ENTER("my_print_variables");
+
+  for (optp= options; optp->name; optp++)
+  {
+    length= (uint)strlen(optp->name)+1;
+    if (length > name_space)
+      name_space= length;
+  }
+
+  printf("\nVariables (--variable-name=value)\n");
+  printf("%-*s%s", name_space, "and boolean options {FALSE|TRUE}",
+         "Value (after reading options)\n");
+  for (length=1; length < 75; length++)
+    putchar(length == name_space ? ' ' : '-');
+  putchar('\n');
+  
+  for (optp= options; optp->name; optp++)
+  {
+    void *value= optp->var_type & GET_ASK_ADDR ?
+		  (*my_getopt_get_addr)("", 0, optp, 0) : optp->value;
+    if (value)
+    {
+      length= print_name(optp);
+      for (; length < name_space; length++)
+	putchar(' ');
+      switch ((optp->var_type & GET_TYPE_MASK)) {
+      case GET_SET:
+        if (!(llvalue= *(ulonglong*) value))
+	  printf("%s\n", "");
+	else
+        for (nr= 0; llvalue && nr < optp->typelib->count; nr++, llvalue >>=1)
+	{
+	  if (llvalue & 1)
+            printf( llvalue > 1 ? "%s," : "%s\n", get_type(optp->typelib, nr));
+	}
+	break;
+      case GET_FLAGSET:
+        llvalue= *(ulonglong*) value;
+        for (nr= 0; llvalue && nr < optp->typelib->count; nr++, llvalue >>=1)
+	{
+          printf("%s%s=", (nr ? "," : ""), get_type(optp->typelib, nr));
+	  printf(llvalue & 1 ? "on" : "off");
+	}
+        printf("\n");
+	break;
+      case GET_ENUM:
+        printf("%s\n", get_type(optp->typelib, *(ulong*) value));
+	break;
+      case GET_STR:
+      case GET_STR_ALLOC:                    /* fall through */
+	printf("%s\n", *((char**) value) ? *((char**) value) :
+	       "(No default value)");
+	break;
+      case GET_BOOL:
+	printf("%s\n", *((my_bool*) value) ? "TRUE" : "FALSE");
+	break;
+      case GET_BIT:
+      {
+        ulonglong bit= (optp->block_size >= 0 ?
+                        optp->block_size :
+                        -optp->block_size);
+        my_bool reverse= optp->block_size < 0;
+	printf("%s\n", ((*((ulonglong*) value) & bit) != 0) ^ reverse ?
+               "TRUE" : "FALSE");
+	break;
+      }
+      case GET_INT:
+	printf("%d\n", *((int*) value));
+	break;
+      case GET_UINT:
+	printf("%u\n", *((uint*) value));
+	break;
+      case GET_LONG:
+	printf("%ld\n", *((long*) value));
+	break;
+      case GET_ULONG:
+	printf("%lu\n", *((ulong*) value));
+	break;
+      case GET_LL:
+	printf("%s\n", llstr(*((longlong*) value), buff));
+	break;
+      case GET_ULL:
+	longlong10_to_str(*((ulonglong*) value), buff, 10);
+	printf("%s\n", buff);
+	break;
+      case GET_DOUBLE:
+	printf("%g\n", *(double*) value);
+	break;
+      case GET_NO_ARG:
+	printf("(No default value)\n");
+	break;
+      default:
+	printf("(Disabled)\n");
+	break;
+      }
+    }
+  }
+  DBUG_VOID_RETURN;
+}