← 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-14 22:40:46 UTC
  • Revision ID: brian@tangent.org-20080714224046-x183907w9wp1txwv
Removed sql_manager. Ever heard of just setting up the OS to sync when you
want it to?

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>
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
33
static int64_t getopt_ll(char *arg, const struct my_option *optp, int *err);
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
 
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;
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++)
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;
800
793
                               bool *fix)
801
794
{
802
795
  int64_t old= num;
803
 
  bool adjusted= false;
 
796
  bool adjusted= FALSE;
804
797
  char buf1[255], buf2[255];
805
798
  uint64_t block_size= (optp->block_size ? (uint64_t) optp->block_size : 1L);
806
799
 
808
801
      optp->max_value) /* if max value is not set -> no upper limit */
809
802
  {
810
803
    num= (uint64_t) optp->max_value;
811
 
    adjusted= true;
 
804
    adjusted= TRUE;
812
805
  }
813
806
 
814
807
  switch ((optp->var_type & GET_TYPE_MASK)) {
816
809
    if (num > (int64_t) INT_MAX)
817
810
    {
818
811
      num= ((int64_t) INT_MAX);
819
 
      adjusted= true;
 
812
      adjusted= TRUE;
820
813
    }
821
814
    break;
822
815
  case GET_LONG:
824
817
    if (num > (int64_t) LONG_MAX)
825
818
    {
826
819
      num= ((int64_t) LONG_MAX);
827
 
      adjusted= true;
 
820
      adjusted= TRUE;
828
821
    }
829
822
#endif
830
823
    break;
831
824
  default:
832
 
    assert((optp->var_type & GET_TYPE_MASK) == GET_LL);
 
825
    DBUG_ASSERT((optp->var_type & GET_TYPE_MASK) == GET_LL);
833
826
    break;
834
827
  }
835
828
 
839
832
  if (num < optp->min_value)
840
833
  {
841
834
    num= optp->min_value;
842
 
    adjusted= true;
 
835
    adjusted= TRUE;
843
836
  }
844
837
 
845
838
  if (fix)
868
861
uint64_t getopt_ull_limit_value(uint64_t num, const struct my_option *optp,
869
862
                                 bool *fix)
870
863
{
871
 
  bool adjusted= false;
 
864
  bool adjusted= FALSE;
872
865
  uint64_t old= num;
873
866
  char buf1[255], buf2[255];
874
867
 
876
869
      optp->max_value) /* if max value is not set -> no upper limit */
877
870
  {
878
871
    num= (uint64_t) optp->max_value;
879
 
    adjusted= true;
 
872
    adjusted= TRUE;
880
873
  }
881
874
 
882
875
  switch ((optp->var_type & GET_TYPE_MASK)) {
884
877
    if (num > (uint64_t) UINT_MAX)
885
878
    {
886
879
      num= ((uint64_t) UINT_MAX);
887
 
      adjusted= true;
 
880
      adjusted= TRUE;
888
881
    }
889
882
    break;
890
883
  case GET_ULONG:
892
885
    if (num > (uint64_t) ULONG_MAX)
893
886
    {
894
887
      num= ((uint64_t) ULONG_MAX);
895
 
      adjusted= true;
 
888
      adjusted= TRUE;
896
889
    }
897
890
#endif
898
891
    break;
899
892
  default:
900
 
    assert((optp->var_type & GET_TYPE_MASK) == GET_ULL);
 
893
    DBUG_ASSERT((optp->var_type & GET_TYPE_MASK) == GET_ULL);
901
894
    break;
902
895
  }
903
896
 
910
903
  if (num < (uint64_t) optp->min_value)
911
904
  {
912
905
    num= (uint64_t) optp->min_value;
913
 
    adjusted= true;
 
906
    adjusted= TRUE;
914
907
  }
915
908
 
916
909
  if (fix)
945
938
  if (end[0] != 0 || error)
946
939
  {
947
940
    fprintf(stderr,
948
 
            _("%s: ERROR: Invalid decimal value for option '%s'\n"),
 
941
            "%s: ERROR: Invalid decimal value for option '%s'\n",
949
942
            my_progname, optp->name);
950
943
    *err= EXIT_ARGUMENT_INVALID;
951
944
    return 0.0;
952
945
  }
953
946
  if (optp->max_value && num > (double) optp->max_value)
954
947
    num= (double) optp->max_value;
955
 
  return cmax(num, (double) optp->min_value);
 
948
  return max(num, (double) optp->min_value);
956
949
}
957
950
 
958
951
/*
967
960
static void init_one_value(const struct my_option *option, char** variable,
968
961
                           int64_t value)
969
962
{
 
963
  DBUG_ENTER("init_one_value");
970
964
  switch ((option->var_type & GET_TYPE_MASK)) {
971
965
  case GET_BOOL:
972
966
    *((bool*) variable)= (bool) value;
982
976
    *((long*) variable)= (long) value;
983
977
    break;
984
978
  case GET_ULONG:
985
 
    *((uint32_t*) variable)= (uint32_t) value;
 
979
    *((ulong*) variable)= (ulong) value;
986
980
    break;
987
981
  case GET_LL:
988
982
    *((int64_t*) variable)= (int64_t) value;
1013
1007
    */
1014
1008
    if ((char*) (intptr_t) value)
1015
1009
    {
1016
 
      free((*(char**) variable));
 
1010
      my_free((*(char**) variable), MYF(MY_ALLOW_ZERO_PTR));
1017
1011
      *((char**) variable)= my_strdup((char*) (intptr_t) value, MYF(MY_WME));
1018
1012
    }
1019
1013
    break;
1020
1014
  default: /* dummy default to avoid compiler warnings */
1021
1015
    break;
1022
1016
  }
1023
 
  return;
 
1017
  DBUG_VOID_RETURN;
1024
1018
}
1025
1019
 
1026
1020
 
1036
1030
static void fini_one_value(const struct my_option *option, char **variable,
1037
1031
                           int64_t value __attribute__ ((unused)))
1038
1032
{
 
1033
  DBUG_ENTER("fini_one_value");
1039
1034
  switch ((option->var_type & GET_TYPE_MASK)) {
1040
1035
  case GET_STR_ALLOC:
1041
 
    free((*(char**) variable));
 
1036
    my_free((*(char**) variable), MYF(MY_ALLOW_ZERO_PTR));
1042
1037
    *((char**) variable)= NULL;
1043
1038
    break;
1044
1039
  default: /* dummy default to avoid compiler warnings */
1045
1040
    break;
1046
1041
  }
1047
 
  return;
 
1042
  DBUG_VOID_RETURN;
1048
1043
}
1049
1044
 
1050
1045
 
1070
1065
static void init_variables(const struct my_option *options,
1071
1066
                           init_func_p init_one_value)
1072
1067
{
 
1068
  DBUG_ENTER("init_variables");
1073
1069
  for (; options->name; options++)
1074
1070
  {
1075
1071
    char* *variable;
 
1072
    DBUG_PRINT("options", ("name: '%s'", options->name));
1076
1073
    /*
1077
1074
      We must set u_max_value first as for some variables
1078
1075
      options->u_max_value == options->value and in this case we want to
1086
1083
        (variable= (*getopt_get_addr)("", 0, options)))
1087
1084
      init_one_value(options, variable, options->def_value);
1088
1085
  }
1089
 
  return;
 
1086
  DBUG_VOID_RETURN;
1090
1087
}
1091
1088
 
1092
1089
 
1096
1093
  Print help for all options and variables.
1097
1094
*/
1098
1095
 
 
1096
#include <help_start.h>
 
1097
 
1099
1098
void my_print_help(const struct my_option *options)
1100
1099
{
1101
 
  uint32_t col, name_space= 22, comment_space= 57;
 
1100
  uint col, name_space= 22, comment_space= 57;
1102
1101
  const char *line_end;
1103
1102
  const struct my_option *optp;
1104
1103
 
1147
1146
      putchar(' ');
1148
1147
    if (optp->comment && *optp->comment)
1149
1148
    {
1150
 
      const char *comment= _(optp->comment), *end= strchr(comment, '\0');
 
1149
      const char *comment= optp->comment, *end= strend(comment);
1151
1150
 
1152
1151
      while ((uint) (end - comment) > comment_space)
1153
1152
      {
1167
1166
    {
1168
1167
      if (optp->def_value != 0)
1169
1168
      {
1170
 
        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);
1171
1170
      }
1172
1171
    }
1173
1172
  }
1182
1181
 
1183
1182
void my_print_variables(const struct my_option *options)
1184
1183
{
1185
 
  uint32_t name_space= 34, length, nr;
 
1184
  uint name_space= 34, length, nr;
1186
1185
  uint64_t bit, llvalue;
1187
1186
  char buff[255];
1188
1187
  const struct my_option *optp;
1189
1188
 
1190
 
  printf(_("\nVariables (--variable-name=value)\n"
1191
 
         "and boolean options {false|true}  Value (after reading options)\n"
1192
 
         "--------------------------------- -----------------------------\n"));
 
1189
  printf("\nVariables (--variable-name=value)\n");
 
1190
  printf("and boolean options {FALSE|TRUE}  Value (after reading options)\n");
 
1191
  printf("--------------------------------- -----------------------------\n");
1193
1192
  for (optp= options; optp->id; optp++)
1194
1193
  {
1195
1194
    char* *value= (optp->var_type & GET_ASK_ADDR ?
1203
1202
      switch ((optp->var_type & GET_TYPE_MASK)) {
1204
1203
      case GET_SET:
1205
1204
        if (!(llvalue= *(uint64_t*) value))
1206
 
          printf("%s\n", _("(No default value)"));
 
1205
          printf("%s\n", "(No default value)");
1207
1206
        else
1208
1207
        for (nr= 0, bit= 1; llvalue && nr < optp->typelib->count; nr++, bit<<=1)
1209
1208
        {
1219
1218
      case GET_STR:
1220
1219
      case GET_STR_ALLOC:                    /* fall through */
1221
1220
        printf("%s\n", *((char**) value) ? *((char**) value) :
1222
 
               _("(No default value)"));
 
1221
               "(No default value)");
1223
1222
        break;
1224
1223
      case GET_BOOL:
1225
 
        printf("%s\n", *((bool*) value) ? _("true") : _("false"));
 
1224
        printf("%s\n", *((bool*) value) ? "TRUE" : "FALSE");
1226
1225
        break;
1227
1226
      case GET_INT:
1228
1227
        printf("%d\n", *((int*) value));
1234
1233
        printf("%ld\n", *((long*) value));
1235
1234
        break;
1236
1235
      case GET_ULONG:
1237
 
        printf("%u\n", *((uint32_t*) value));
 
1236
        printf("%lu\n", *((ulong*) value));
1238
1237
        break;
1239
1238
      case GET_LL:
1240
1239
        printf("%s\n", llstr(*((int64_t*) value), buff));
1247
1246
        printf("%g\n", *(double*) value);
1248
1247
        break;
1249
1248
      default:
1250
 
        printf(_("(Disabled)\n"));
 
1249
        printf("(Disabled)\n");
1251
1250
        break;
1252
1251
      }
1253
1252
    }
1254
1253
  }
1255
1254
}
 
1255
 
 
1256
#include <help_end.h>