parse.c

   1 #include "git-compat-util.h"
   2 #include "gettext.h"
   3 #include "parse.h"
   4
   5 static uintmax_t get_unit_factor(const char *end)
   6 {
   7         if (!*end)
   8                 return 1;
   9         else if (!strcasecmp(end, "k"))
  10                 return 1024;
  11         else if (!strcasecmp(end, "m"))
  12                 return 1024 * 1024;
  13         else if (!strcasecmp(end, "g"))
  14                 return 1024 * 1024 * 1024;
  15         return 0;
  16 }
  17
  18 int git_parse_signed(const char *value, intmax_t *ret, intmax_t max)
  19 {
  20         if (value && *value) {
  21                 char *end;
  22                 intmax_t val;
  23                 intmax_t factor;
  24
  25                 if (max < 0)
  26                         BUG("max must be a positive integer");
  27
  28                 errno = 0;
  29                 val = strtoimax(value, &end, 0);
  30                 if (errno == ERANGE)
  31                         return 0;
  32                 if (end == value) {
  33                         errno = EINVAL;
  34                         return 0;
  35                 }
  36                 factor = get_unit_factor(end);
  37                 if (!factor) {
  38                         errno = EINVAL;
  39                         return 0;
  40                 }
  41                 if ((val < 0 && -max / factor > val) ||
  42                     (val > 0 && max / factor < val)) {
  43                         errno = ERANGE;
  44                         return 0;
  45                 }
  46                 val *= factor;
  47                 *ret = val;
  48                 return 1;
  49         }
  50         errno = EINVAL;
  51         return 0;
  52 }
  53
  54 static int git_parse_unsigned(const char *value, uintmax_t *ret, uintmax_t max)
  55 {
  56         if (value && *value) {
  57                 char *end;
  58                 uintmax_t val;
  59                 uintmax_t factor;
  60
  61                 /* negative values would be accepted by strtoumax */
  62                 if (strchr(value, '-')) {
  63                         errno = EINVAL;
  64                         return 0;
  65                 }
  66                 errno = 0;
  67                 val = strtoumax(value, &end, 0);
  68                 if (errno == ERANGE)
  69                         return 0;
  70                 if (end == value) {
  71                         errno = EINVAL;
  72                         return 0;
  73                 }
  74                 factor = get_unit_factor(end);
  75                 if (!factor) {
  76                         errno = EINVAL;
  77                         return 0;
  78                 }
  79                 if (unsigned_mult_overflows(factor, val) ||
  80                     factor * val > max) {
  81                         errno = ERANGE;
  82                         return 0;
  83                 }
  84                 val *= factor;
  85                 *ret = val;
  86                 return 1;
  87         }
  88         errno = EINVAL;
  89         return 0;
  90 }
  91
  92 int git_parse_int(const char *value, int *ret)
  93 {
  94         intmax_t tmp;
  95         if (!git_parse_signed(value, &tmp, maximum_signed_value_of_type(int)))
  96                 return 0;
  97         *ret = tmp;
  98         return 1;
  99 }
 100
 101 int git_parse_int64(const char *value, int64_t *ret)
 102 {
 103         intmax_t tmp;
 104         if (!git_parse_signed(value, &tmp, maximum_signed_value_of_type(int64_t)))
 105                 return 0;
 106         *ret = tmp;
 107         return 1;
 108 }
 109
 110 int git_parse_ulong(const char *value, unsigned long *ret)
 111 {
 112         uintmax_t tmp;
 113         if (!git_parse_unsigned(value, &tmp, maximum_unsigned_value_of_type(long)))
 114                 return 0;
 115         *ret = tmp;
 116         return 1;
 117 }
 118
 119 int git_parse_ssize_t(const char *value, ssize_t *ret)
 120 {
 121         intmax_t tmp;
 122         if (!git_parse_signed(value, &tmp, maximum_signed_value_of_type(ssize_t)))
 123                 return 0;
 124         *ret = tmp;
 125         return 1;
 126 }
 127
 128 int git_parse_double(const char *value, double *ret)
 129 {
 130         char *end;
 131         double val;
 132         uintmax_t factor;
 133
 134         if (!value || !*value) {
 135                 errno = EINVAL;
 136                 return 0;
 137         }
 138
 139         errno = 0;
 140         val = strtod(value, &end);
 141         if (errno == ERANGE)
 142                 return 0;
 143         if (end == value) {
 144                 errno = EINVAL;
 145                 return 0;
 146         }
 147         factor = get_unit_factor(end);
 148         if (!factor) {
 149                 errno = EINVAL;
 150                 return 0;
 151         }
 152         val *= factor;
 153         *ret = val;
 154         return 1;
 155 }
 156
 157 int git_parse_maybe_bool_text(const char *value)
 158 {
 159         if (!value)
 160                 return 1;
 161         if (!*value)
 162                 return 0;
 163         if (!strcasecmp(value, "true")
 164             || !strcasecmp(value, "yes")
 165             || !strcasecmp(value, "on"))
 166                 return 1;
 167         if (!strcasecmp(value, "false")
 168             || !strcasecmp(value, "no")
 169             || !strcasecmp(value, "off"))
 170                 return 0;
 171         return -1;
 172 }
 173
 174 int git_parse_maybe_bool(const char *value)
 175 {
 176         int v = git_parse_maybe_bool_text(value);
 177         if (0 <= v)
 178                 return v;
 179         if (git_parse_int(value, &v))
 180                 return !!v;
 181         return -1;
 182 }
 183
 184 /*
 185  * Parse environment variable 'k' as a boolean (in various
 186  * possible spellings); if missing, use the default value 'def'.
 187  */
 188 int git_env_bool(const char *k, int def)
 189 {
 190         const char *v = getenv(k);
 191         int val;
 192         if (!v)
 193                 return def;
 194         val = git_parse_maybe_bool(v);
 195         if (val < 0)
 196                 die(_("bad boolean environment value '%s' for '%s'"),
 197                     v, k);
 198         return val;
 199 }
 200
 201 /*
 202  * Parse environment variable 'k' as ulong with possibly a unit
 203  * suffix; if missing, use the default value 'val'.
 204  */
 205 unsigned long git_env_ulong(const char *k, unsigned long val)
 206 {
 207         const char *v = getenv(k);
 208         if (v && !git_parse_ulong(v, &val))
 209                 die(_("failed to parse %s"), k);
 210         return val;
 211 }