← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/my_getopt.c

  • Committer: Brian Aker
  • Date: 2008-07-13 21:20:24 UTC
  • Revision ID: brian@tangent.org-20080713212024-o6263c1vha7yxdeu
More bool removal. More cow bell!

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/my_getopt.c
13
13
   along with this program; if not, write to the Free Software
14
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
 
#include "mysys_priv.h"
17
 
#include <libdrizzle/gettext.h>
18
 
 
19
 
#include <mystrings/m_string.h>
 
16
#include <my_global.h>
 
17
#include <m_string.h>
20
18
#include <stdlib.h>
21
19
#include <my_sys.h>
22
20
#include <mysys_err.h>
24
22
#include <errno.h>
25
23
 
26
24
typedef void (*init_func_p)(const struct my_option *option, char **variable,
27
 
                            int64_t value);
 
25
                            longlong value);
28
26
 
29
27
static void default_reporter(enum loglevel level, const char *format, ...);
30
28
my_error_reporter my_getopt_error_reporter= &default_reporter;
31
29
 
32
 
static int findopt(char *optpat, uint32_t length,
 
30
static int findopt(char *optpat, uint length,
33
31
                   const struct my_option **opt_res,
34
32
                   char **ffname);
35
 
static int64_t getopt_ll(char *arg, const struct my_option *optp, int *err);
36
 
static uint64_t getopt_ull(char *arg, const struct my_option *optp,
 
33
static longlong getopt_ll(char *arg, const struct my_option *optp, int *err);
 
34
static ulonglong getopt_ull(char *arg, const struct my_option *optp,
37
35
                            int *err);
38
36
static double getopt_double(char *arg, const struct my_option *optp, int *err);
39
37
static void init_variables(const struct my_option *options,
40
38
                           init_func_p init_one_value);
41
39
static void init_one_value(const struct my_option *option, char **variable,
42
 
                           int64_t value);
 
40
                           longlong value);
43
41
static void fini_one_value(const struct my_option *option, char **variable,
44
 
                           int64_t value);
 
42
                           longlong value);
45
43
static int setval(const struct my_option *opts, char* *value, char *argument,
46
44
                  bool set_maximum_value);
47
45
static char *check_struct_option(char *cur_arg, char *key_name);
52
50
*/
53
51
static const char *special_opt_prefix[]=
54
52
{"skip", "disable", "enable", "maximum", "loose", 0};
55
 
static const uint32_t special_opt_prefix_lengths[]=
 
53
static const uint special_opt_prefix_lengths[]=
56
54
{ 4,      7,         6,        7,         5,      0};
57
55
enum enum_special_opt
58
56
{ OPT_SKIP, OPT_DISABLE, OPT_ENABLE, OPT_MAXIMUM, OPT_LOOSE};
80
78
  va_list args;
81
79
  va_start(args, format);
82
80
  if (level == WARNING_LEVEL)
83
 
    fprintf(stderr, "%s", _("Warning: "));
 
81
    fprintf(stderr, "%s", "Warning: ");
84
82
  else if (level == INFORMATION_LEVEL)
85
 
    fprintf(stderr, "%s", _("Info: "));
 
83
    fprintf(stderr, "%s", "Info: ");
86
84
  vfprintf(stderr, format, args);
87
85
  va_end(args);
88
86
  fputc('\n', stderr);
111
109
                   const struct my_option *longopts,
112
110
                   my_get_one_option get_one_option)
113
111
{
114
 
  uint32_t opt_found, argvpos= 0, length;
115
 
  bool end_of_options= 0, must_be_var, set_maximum_value=false,
 
112
  uint opt_found, argvpos= 0, length;
 
113
  bool end_of_options= 0, must_be_var, set_maximum_value,
116
114
          option_is_loose;
117
115
  char **pos, **pos_end, *optend, *prev_found=NULL,
118
116
       *opt_str, key_name[FN_REFLEN];
121
119
  int error, i;
122
120
 
123
121
  /* handle_options() assumes arg0 (program name) always exists */
124
 
  assert(argc && *argc >= 1);
125
 
  assert(argv && *argv);
 
122
  DBUG_ASSERT(argc && *argc >= 1);
 
123
  DBUG_ASSERT(argv && *argv);
126
124
  (*argc)--; /* Skip the program name */
127
125
  (*argv)++; /*      --- || ----      */
128
126
  init_variables(longopts, init_one_value);
203
201
          }
204
202
        }
205
203
        opt_str= check_struct_option(cur_arg, key_name);
206
 
        optend= strrchr(opt_str, '=');
207
 
        if (optend != NULL)
208
 
        {
209
 
          length= (uint) (optend - opt_str);
 
204
        optend= strcend(opt_str, '=');
 
205
        length= (uint) (optend - opt_str);
 
206
        if (*optend == '=')
210
207
          optend++;
211
 
        }
212
208
        else
213
 
        {
214
 
          length= strlen(opt_str);
215
209
          optend= 0;
216
 
        }
217
210
 
218
211
        /*
219
212
          Find first the right option. Return error in case of an ambiguous,
261
254
                  case OPT_DISABLE: /* fall through */
262
255
                    /*
263
256
                      double negation is actually enable again,
264
 
                      for example: --skip-option=0 -> option = true
 
257
                      for example: --skip-option=0 -> option = TRUE
265
258
                    */
266
259
                    optend= (optend && *optend == '0' && !(*(optend + 1))) ?
267
260
                      (char*) "1" : disabled_my_option;
271
264
                      disabled_my_option : (char*) "1";
272
265
                    break;
273
266
                  case OPT_MAXIMUM:
274
 
                    set_maximum_value= true;
275
 
                    must_be_var= true;
 
267
                    set_maximum_value= 1;
 
268
                    must_be_var= 1;
276
269
                    break;
277
270
                  }
278
271
                  break; /* break from the inner loop, main loop continues */
347
340
        {
348
341
          if (my_getopt_print_errors)
349
342
            fprintf(stderr,
350
 
                    _("%s: %s: Option '%s' used, but is disabled\n"), my_progname,
351
 
                    option_is_loose ? _("WARNING") : _("ERROR"), opt_str);
 
343
                    "%s: %s: Option '%s' used, but is disabled\n", my_progname,
 
344
                    option_is_loose ? "WARNING" : "ERROR", opt_str);
352
345
          if (option_is_loose)
353
346
          {
354
347
            (*argc)--;
386
379
              */
387
380
            (*argc)--;
388
381
            if (!optend || *optend == '1' ||
389
 
                !my_strcasecmp(&my_charset_utf8_general_ci, optend, "true"))
 
382
                !my_strcasecmp(&my_charset_latin1, optend, "true"))
390
383
              *((bool*) value)= (bool) 1;
391
384
            else if (*optend == '0' ||
392
 
                     !my_strcasecmp(&my_charset_utf8_general_ci, optend, "false"))
 
385
                     !my_strcasecmp(&my_charset_latin1, optend, "false"))
393
386
              *((bool*) value)= (bool) 0;
394
387
            else
395
388
            {
443
436
          opt_found= 0;
444
437
          for (optp= longopts; optp->id; optp++)
445
438
          {
446
 
            if (optp->id == (int) (unsigned char) *optend)
 
439
            if (optp->id == (int) (uchar) *optend)
447
440
            {
448
441
              /* Option recognized. Find next what to do with it */
449
442
              opt_found= 1;
451
444
              {
452
445
                if (my_getopt_print_errors)
453
446
                  fprintf(stderr,
454
 
                          _("%s: ERROR: Option '-%c' used, but is disabled\n"),
 
447
                          "%s: ERROR: Option '-%c' used, but is disabled\n",
455
448
                          my_progname, optp->id);
456
449
                return EXIT_OPTION_DISABLED;
457
450
              }
496
489
                }
497
490
              }
498
491
              if ((error= setval(optp, optp->value, argument,
499
 
                                 set_maximum_value)))
500
 
              {
 
492
                                 set_maximum_value)))
 
493
              {
501
494
                my_getopt_error_reporter(ERROR_LEVEL,
502
495
                                         "%s: Error while setting value '%s' to '%s'",
503
496
                                         my_progname, argument, optp->name);
504
 
                return error;
505
 
              }
506
 
              get_one_option(optp->id, optp, argument);
507
 
              break;
508
 
            }
509
 
          }
510
 
          if (!opt_found)
511
 
          {
512
 
            if (my_getopt_print_errors)
 
497
                return error;
 
498
              }
 
499
              get_one_option(optp->id, optp, argument);
 
500
              break;
 
501
            }
 
502
          }
 
503
          if (!opt_found)
 
504
          {
 
505
            if (my_getopt_print_errors)
513
506
              my_getopt_error_reporter(ERROR_LEVEL,
514
507
                                       "%s: unknown option '-%c'", 
515
508
                                       my_progname, *optend);
516
 
            return EXIT_UNKNOWN_OPTION;
517
 
          }
518
 
        }
519
 
        (*argc)--; /* option handled (short), decrease argument count */
520
 
        continue;
 
509
            return EXIT_UNKNOWN_OPTION;
 
510
          }
 
511
        }
 
512
        (*argc)--; /* option handled (short), decrease argument count */
 
513
        continue;
521
514
      }
522
515
      if ((error= setval(optp, value, argument, set_maximum_value)))
523
516
      {
524
517
        my_getopt_error_reporter(ERROR_LEVEL,
525
518
                                 "%s: Error while setting value '%s' to '%s'",
526
519
                                 my_progname, argument, optp->name);
527
 
        return error;
 
520
        return error;
528
521
      }
529
522
      get_one_option(optp->id, optp, argument);
530
523
 
562
555
{
563
556
  char *ptr, *end;
564
557
 
565
 
  ptr= strrchr(cur_arg + 1, '.'); /* Skip the first character */
566
 
  end= strrchr(cur_arg, '=');
 
558
  ptr= strcend(cur_arg + 1, '.'); /* Skip the first character */
 
559
  end= strcend(cur_arg, '=');
567
560
 
568
561
  /* 
569
562
     If the first dot is after an equal sign, then it is part
572
565
     NULL, or the character right before equal sign is the first
573
566
     dot found, the option is not a struct option.
574
567
  */
575
 
  if ((ptr != NULL) && (end != NULL) && (end - ptr > 1))
 
568
  if (end - ptr > 1)
576
569
  {
577
 
    uint32_t len= (uint) (ptr - cur_arg);
 
570
    uint len= (uint) (ptr - cur_arg);
578
571
    set_if_smaller(len, FN_REFLEN-1);
579
572
    strmake(key_name, cur_arg, len);
580
573
    return ++ptr;
593
586
  Will set the option value to given value
594
587
*/
595
588
 
596
 
static int setval(const struct my_option *opts, char **value, char *argument,
597
 
                  bool set_maximum_value)
 
589
static int setval(const struct my_option *opts, char* *value, char *argument,
 
590
                  bool set_maximum_value)
598
591
{
599
592
  int err= 0;
600
593
 
623
616
      *((long*) result_pos)= (long) getopt_ull(argument, opts, &err);
624
617
      break;
625
618
    case GET_LL:
626
 
      *((int64_t*) result_pos)= getopt_ll(argument, opts, &err);
 
619
      *((longlong*) result_pos)= getopt_ll(argument, opts, &err);
627
620
      break;
628
621
    case GET_ULL:
629
 
      *((uint64_t*) result_pos)= getopt_ull(argument, opts, &err);
 
622
      *((ulonglong*) result_pos)= getopt_ull(argument, opts, &err);
630
623
      break;
631
624
    case GET_DOUBLE:
632
625
      *((double*) result_pos)= getopt_double(argument, opts, &err);
636
629
      break;
637
630
    case GET_STR_ALLOC:
638
631
      if ((*((char**) result_pos)))
639
 
        free((*(char**) result_pos));
 
632
        my_free((*(char**) result_pos), MYF(MY_WME | MY_FAE));
640
633
      if (!(*((char**) result_pos)= my_strdup(argument, MYF(MY_WME))))
641
634
        return EXIT_OUT_OF_MEMORY;
642
635
      break;
645
638
        return EXIT_ARGUMENT_INVALID;
646
639
      break;
647
640
    case GET_SET:
648
 
      *((uint64_t*)result_pos)= find_typeset(argument, opts->typelib, &err);
 
641
      *((ulonglong*)result_pos)= find_typeset(argument, opts->typelib, &err);
649
642
      if (err)
650
643
        return EXIT_ARGUMENT_INVALID;
651
644
      break;
681
674
        ffname points to first matching option
682
675
*/
683
676
 
684
 
static int findopt(char *optpat, uint32_t length,
 
677
static int findopt(char *optpat, uint length,
685
678
                   const struct my_option **opt_res,
686
679
                   char **ffname)
687
680
{
688
 
  uint32_t count;
 
681
  uint count;
689
682
  struct my_option *opt= (struct my_option *) *opt_res;
690
683
 
691
684
  for (count= 0; opt->name; opt++)
722
715
*/
723
716
 
724
717
bool getopt_compare_strings(register const char *s, register const char *t,
725
 
                               uint32_t length)
 
718
                               uint length)
726
719
{
727
720
  char const *end= s + length;
728
721
  for (;s != end ; s++, t++)
740
733
  be k|K for kilo, m|M for mega or g|G for giga.
741
734
*/
742
735
 
743
 
static int64_t eval_num_suffix(char *argument, int *error, char *option_name)
 
736
static longlong eval_num_suffix(char *argument, int *error, char *option_name)
744
737
{
745
738
  char *endchar;
746
 
  int64_t num;
 
739
  longlong num;
747
740
  
748
741
  *error= 0;
749
742
  errno= 0;
764
757
  else if (*endchar)
765
758
  {
766
759
    fprintf(stderr,
767
 
            _("Unknown suffix '%c' used for variable '%s' (value '%s')\n"),
 
760
            "Unknown suffix '%c' used for variable '%s' (value '%s')\n",
768
761
            *endchar, option_name, argument);
769
762
    *error= 1;
770
763
    return 0;
783
776
  In case of an error, set error value in *err.
784
777
*/
785
778
 
786
 
static int64_t getopt_ll(char *arg, const struct my_option *optp, int *err)
 
779
static longlong getopt_ll(char *arg, const struct my_option *optp, int *err)
787
780
{
788
 
  int64_t num=eval_num_suffix(arg, err, (char*) optp->name);
 
781
  longlong num=eval_num_suffix(arg, err, (char*) optp->name);
789
782
  return getopt_ll_limit_value(num, optp, NULL);
790
783
}
791
784
 
796
789
  Returns "fixed" value.
797
790
*/
798
791
 
799
 
int64_t getopt_ll_limit_value(int64_t num, const struct my_option *optp,
 
792
longlong getopt_ll_limit_value(longlong num, const struct my_option *optp,
800
793
                               bool *fix)
801
794
{
802
 
  int64_t old= num;
803
 
  bool adjusted= false;
 
795
  longlong old= num;
 
796
  bool adjusted= FALSE;
804
797
  char buf1[255], buf2[255];
805
 
  uint64_t block_size= (optp->block_size ? (uint64_t) optp->block_size : 1L);
 
798
  ulonglong block_size= (optp->block_size ? (ulonglong) optp->block_size : 1L);
806
799
 
807
 
  if (num > 0 && ((uint64_t) num > (uint64_t) optp->max_value) &&
 
800
  if (num > 0 && ((ulonglong) num > (ulonglong) optp->max_value) &&
808
801
      optp->max_value) /* if max value is not set -> no upper limit */
809
802
  {
810
 
    num= (uint64_t) optp->max_value;
811
 
    adjusted= true;
 
803
    num= (ulonglong) optp->max_value;
 
804
    adjusted= TRUE;
812
805
  }
813
806
 
814
807
  switch ((optp->var_type & GET_TYPE_MASK)) {
815
808
  case GET_INT:
816
 
    if (num > (int64_t) INT_MAX)
 
809
    if (num > (longlong) INT_MAX)
817
810
    {
818
 
      num= ((int64_t) INT_MAX);
819
 
      adjusted= true;
 
811
      num= ((longlong) INT_MAX);
 
812
      adjusted= TRUE;
820
813
    }
821
814
    break;
822
815
  case GET_LONG:
823
 
    if (num > (int64_t) INT32_MAX)
 
816
#if SIZEOF_LONG < SIZEOF_LONG_LONG
 
817
    if (num > (longlong) LONG_MAX)
824
818
    {
825
 
      num= ((int64_t) INT32_MAX);
826
 
      adjusted= true;
 
819
      num= ((longlong) LONG_MAX);
 
820
      adjusted= TRUE;
827
821
    }
 
822
#endif
828
823
    break;
829
824
  default:
830
 
    assert((optp->var_type & GET_TYPE_MASK) == GET_LL);
 
825
    DBUG_ASSERT((optp->var_type & GET_TYPE_MASK) == GET_LL);
831
826
    break;
832
827
  }
833
828
 
834
829
  num= ((num - optp->sub_size) / block_size);
835
 
  num= (int64_t) (num * block_size);
 
830
  num= (longlong) (num * block_size);
836
831
 
837
832
  if (num < optp->min_value)
838
833
  {
839
834
    num= optp->min_value;
840
 
    adjusted= true;
 
835
    adjusted= TRUE;
841
836
  }
842
837
 
843
838
  if (fix)
852
847
/*
853
848
  function: getopt_ull
854
849
 
855
 
  This is the same as getopt_ll, but is meant for uint64_t
 
850
  This is the same as getopt_ll, but is meant for unsigned long long
856
851
  values.
857
852
*/
858
853
 
859
 
static uint64_t getopt_ull(char *arg, const struct my_option *optp, int *err)
 
854
static ulonglong getopt_ull(char *arg, const struct my_option *optp, int *err)
860
855
{
861
 
  uint64_t num= eval_num_suffix(arg, err, (char*) optp->name);
 
856
  ulonglong num= eval_num_suffix(arg, err, (char*) optp->name);
862
857
  return getopt_ull_limit_value(num, optp, NULL);
863
858
}
864
859
 
865
860
 
866
 
uint64_t getopt_ull_limit_value(uint64_t num, const struct my_option *optp,
 
861
ulonglong getopt_ull_limit_value(ulonglong num, const struct my_option *optp,
867
862
                                 bool *fix)
868
863
{
869
 
  bool adjusted= false;
870
 
  uint64_t old= num;
 
864
  bool adjusted= FALSE;
 
865
  ulonglong old= num;
871
866
  char buf1[255], buf2[255];
872
867
 
873
 
  if ((uint64_t) num > (uint64_t) optp->max_value &&
 
868
  if ((ulonglong) num > (ulonglong) optp->max_value &&
874
869
      optp->max_value) /* if max value is not set -> no upper limit */
875
870
  {
876
 
    num= (uint64_t) optp->max_value;
877
 
    adjusted= true;
 
871
    num= (ulonglong) optp->max_value;
 
872
    adjusted= TRUE;
878
873
  }
879
874
 
880
875
  switch ((optp->var_type & GET_TYPE_MASK)) {
881
876
  case GET_UINT:
882
 
    if (num > (uint64_t) UINT_MAX)
 
877
    if (num > (ulonglong) UINT_MAX)
883
878
    {
884
 
      num= ((uint64_t) UINT_MAX);
885
 
      adjusted= true;
 
879
      num= ((ulonglong) UINT_MAX);
 
880
      adjusted= TRUE;
886
881
    }
887
882
    break;
888
883
  case GET_ULONG:
889
 
    if (num > (uint64_t) UINT32_MAX)
 
884
#if SIZEOF_LONG < SIZEOF_LONG_LONG
 
885
    if (num > (ulonglong) ULONG_MAX)
890
886
    {
891
 
      num= ((uint64_t) UINT32_MAX);
892
 
      adjusted= true;
 
887
      num= ((ulonglong) ULONG_MAX);
 
888
      adjusted= TRUE;
893
889
    }
 
890
#endif
894
891
    break;
895
892
  default:
896
 
    assert((optp->var_type & GET_TYPE_MASK) == GET_ULL);
 
893
    DBUG_ASSERT((optp->var_type & GET_TYPE_MASK) == GET_ULL);
897
894
    break;
898
895
  }
899
896
 
900
897
  if (optp->block_size > 1)
901
898
  {
902
 
    num/= (uint64_t) optp->block_size;
903
 
    num*= (uint64_t) optp->block_size;
 
899
    num/= (ulonglong) optp->block_size;
 
900
    num*= (ulonglong) optp->block_size;
904
901
  }
905
902
 
906
 
  if (num < (uint64_t) optp->min_value)
 
903
  if (num < (ulonglong) optp->min_value)
907
904
  {
908
 
    num= (uint64_t) optp->min_value;
909
 
    adjusted= true;
 
905
    num= (ulonglong) optp->min_value;
 
906
    adjusted= TRUE;
910
907
  }
911
908
 
912
909
  if (fix)
941
938
  if (end[0] != 0 || error)
942
939
  {
943
940
    fprintf(stderr,
944
 
            _("%s: ERROR: Invalid decimal value for option '%s'\n"),
 
941
            "%s: ERROR: Invalid decimal value for option '%s'\n",
945
942
            my_progname, optp->name);
946
943
    *err= EXIT_ARGUMENT_INVALID;
947
944
    return 0.0;
948
945
  }
949
946
  if (optp->max_value && num > (double) optp->max_value)
950
947
    num= (double) optp->max_value;
951
 
  return cmax(num, (double) optp->min_value);
 
948
  return max(num, (double) optp->min_value);
952
949
}
953
950
 
954
951
/*
961
958
*/
962
959
 
963
960
static void init_one_value(const struct my_option *option, char** variable,
964
 
                           int64_t value)
 
961
                           longlong value)
965
962
{
 
963
  DBUG_ENTER("init_one_value");
966
964
  switch ((option->var_type & GET_TYPE_MASK)) {
967
965
  case GET_BOOL:
968
966
    *((bool*) variable)= (bool) value;
978
976
    *((long*) variable)= (long) value;
979
977
    break;
980
978
  case GET_ULONG:
981
 
    *((uint32_t*) variable)= (uint32_t) value;
 
979
    *((ulong*) variable)= (ulong) value;
982
980
    break;
983
981
  case GET_LL:
984
 
    *((int64_t*) variable)= (int64_t) value;
 
982
    *((longlong*) variable)= (longlong) value;
985
983
    break;
986
984
  case GET_ULL:
987
985
  case GET_SET:
988
 
    *((uint64_t*) variable)=  (uint64_t) value;
 
986
    *((ulonglong*) variable)=  (ulonglong) value;
989
987
    break;
990
988
  case GET_DOUBLE:
991
989
    *((double*) variable)=  (double) value;
994
992
    /*
995
993
      Do not clear variable value if it has no default value.
996
994
      The default value may already be set.
997
 
      NOTE: To avoid compiler warnings, we first cast int64_t to intptr_t,
 
995
      NOTE: To avoid compiler warnings, we first cast longlong to intptr,
998
996
      so that the value has the same size as a pointer.
999
997
    */
1000
 
    if ((char*) (intptr_t) value)
1001
 
      *((char**) variable)= (char*) (intptr_t) value;
 
998
    if ((char*) (intptr) value)
 
999
      *((char**) variable)= (char*) (intptr) value;
1002
1000
    break;
1003
1001
  case GET_STR_ALLOC:
1004
1002
    /*
1005
1003
      Do not clear variable value if it has no default value.
1006
1004
      The default value may already be set.
1007
 
      NOTE: To avoid compiler warnings, we first cast int64_t to intptr_t,
 
1005
      NOTE: To avoid compiler warnings, we first cast longlong to intptr,
1008
1006
      so that the value has the same size as a pointer.
1009
1007
    */
1010
 
    if ((char*) (intptr_t) value)
 
1008
    if ((char*) (intptr) value)
1011
1009
    {
1012
 
      free((*(char**) variable));
1013
 
      *((char**) variable)= my_strdup((char*) (intptr_t) value, MYF(MY_WME));
 
1010
      my_free((*(char**) variable), MYF(MY_ALLOW_ZERO_PTR));
 
1011
      *((char**) variable)= my_strdup((char*) (intptr) value, MYF(MY_WME));
1014
1012
    }
1015
1013
    break;
1016
1014
  default: /* dummy default to avoid compiler warnings */
1017
1015
    break;
1018
1016
  }
1019
 
  return;
 
1017
  DBUG_VOID_RETURN;
1020
1018
}
1021
1019
 
1022
1020
 
1030
1028
*/
1031
1029
 
1032
1030
static void fini_one_value(const struct my_option *option, char **variable,
1033
 
                           int64_t value __attribute__ ((unused)))
 
1031
                           longlong value __attribute__ ((unused)))
1034
1032
{
 
1033
  DBUG_ENTER("fini_one_value");
1035
1034
  switch ((option->var_type & GET_TYPE_MASK)) {
1036
1035
  case GET_STR_ALLOC:
1037
 
    free((*(char**) variable));
 
1036
    my_free((*(char**) variable), MYF(MY_ALLOW_ZERO_PTR));
1038
1037
    *((char**) variable)= NULL;
1039
1038
    break;
1040
1039
  default: /* dummy default to avoid compiler warnings */
1041
1040
    break;
1042
1041
  }
1043
 
  return;
 
1042
  DBUG_VOID_RETURN;
1044
1043
}
1045
1044
 
1046
1045
 
1066
1065
static void init_variables(const struct my_option *options,
1067
1066
                           init_func_p init_one_value)
1068
1067
{
 
1068
  DBUG_ENTER("init_variables");
1069
1069
  for (; options->name; options++)
1070
1070
  {
1071
1071
    char* *variable;
 
1072
    DBUG_PRINT("options", ("name: '%s'", options->name));
1072
1073
    /*
1073
1074
      We must set u_max_value first as for some variables
1074
1075
      options->u_max_value == options->value and in this case we want to
1082
1083
        (variable= (*getopt_get_addr)("", 0, options)))
1083
1084
      init_one_value(options, variable, options->def_value);
1084
1085
  }
1085
 
  return;
 
1086
  DBUG_VOID_RETURN;
1086
1087
}
1087
1088
 
1088
1089
 
1092
1093
  Print help for all options and variables.
1093
1094
*/
1094
1095
 
 
1096
#include <help_start.h>
 
1097
 
1095
1098
void my_print_help(const struct my_option *options)
1096
1099
{
1097
 
  uint32_t col, name_space= 22, comment_space= 57;
 
1100
  uint col, name_space= 22, comment_space= 57;
1098
1101
  const char *line_end;
1099
1102
  const struct my_option *optp;
1100
1103
 
1143
1146
      putchar(' ');
1144
1147
    if (optp->comment && *optp->comment)
1145
1148
    {
1146
 
      const char *comment= _(optp->comment), *end= strchr(comment, '\0');
 
1149
      const char *comment= optp->comment, *end= strend(comment);
1147
1150
 
1148
1151
      while ((uint) (end - comment) > comment_space)
1149
1152
      {
1163
1166
    {
1164
1167
      if (optp->def_value != 0)
1165
1168
      {
1166
 
        printf(_("%*s(Defaults to on; use --skip-%s to disable.)\n"), name_space, "", optp->name);
 
1169
        printf("%*s(Defaults to on; use --skip-%s to disable.)\n", name_space, "", optp->name);
1167
1170
      }
1168
1171
    }
1169
1172
  }
1178
1181
 
1179
1182
void my_print_variables(const struct my_option *options)
1180
1183
{
1181
 
  uint32_t name_space= 34, length, nr;
1182
 
  uint64_t bit, llvalue;
 
1184
  uint name_space= 34, length, nr;
 
1185
  ulonglong bit, llvalue;
1183
1186
  char buff[255];
1184
1187
  const struct my_option *optp;
1185
1188
 
1186
 
  printf(_("\nVariables (--variable-name=value)\n"
1187
 
         "and boolean options {false|true}  Value (after reading options)\n"
1188
 
         "--------------------------------- -----------------------------\n"));
 
1189
  printf("\nVariables (--variable-name=value)\n");
 
1190
  printf("and boolean options {FALSE|TRUE}  Value (after reading options)\n");
 
1191
  printf("--------------------------------- -----------------------------\n");
1189
1192
  for (optp= options; optp->id; optp++)
1190
1193
  {
1191
1194
    char* *value= (optp->var_type & GET_ASK_ADDR ?
1198
1201
        putchar(' ');
1199
1202
      switch ((optp->var_type & GET_TYPE_MASK)) {
1200
1203
      case GET_SET:
1201
 
        if (!(llvalue= *(uint64_t*) value))
1202
 
          printf("%s\n", _("(No default value)"));
 
1204
        if (!(llvalue= *(ulonglong*) value))
 
1205
          printf("%s\n", "(No default value)");
1203
1206
        else
1204
1207
        for (nr= 0, bit= 1; llvalue && nr < optp->typelib->count; nr++, bit<<=1)
1205
1208
        {
1215
1218
      case GET_STR:
1216
1219
      case GET_STR_ALLOC:                    /* fall through */
1217
1220
        printf("%s\n", *((char**) value) ? *((char**) value) :
1218
 
               _("(No default value)"));
 
1221
               "(No default value)");
1219
1222
        break;
1220
1223
      case GET_BOOL:
1221
 
        printf("%s\n", *((bool*) value) ? _("true") : _("false"));
 
1224
        printf("%s\n", *((bool*) value) ? "TRUE" : "FALSE");
1222
1225
        break;
1223
1226
      case GET_INT:
1224
1227
        printf("%d\n", *((int*) value));
1230
1233
        printf("%ld\n", *((long*) value));
1231
1234
        break;
1232
1235
      case GET_ULONG:
1233
 
        printf("%u\n", *((uint32_t*) value));
 
1236
        printf("%lu\n", *((ulong*) value));
1234
1237
        break;
1235
1238
      case GET_LL:
1236
 
        printf("%s\n", llstr(*((int64_t*) value), buff));
 
1239
        printf("%s\n", llstr(*((longlong*) value), buff));
1237
1240
        break;
1238
1241
      case GET_ULL:
1239
 
        int64_t2str(*((uint64_t*) value), buff, 10);
 
1242
        longlong2str(*((ulonglong*) value), buff, 10);
1240
1243
        printf("%s\n", buff);
1241
1244
        break;
1242
1245
      case GET_DOUBLE:
1243
1246
        printf("%g\n", *(double*) value);
1244
1247
        break;
1245
1248
      default:
1246
 
        printf(_("(Disabled)\n"));
 
1249
        printf("(Disabled)\n");
1247
1250
        break;
1248
1251
      }
1249
1252
    }
1250
1253
  }
1251
1254
}
 
1255
 
 
1256
#include <help_end.h>