mirror of
https://github.com/git/git.git
synced 2024-12-18 22:33:34 +08:00
5831f8ac41
Future commits will want to parse a double-precision floating point value from configuration, but we have no way to parse such a value prior to this patch. The core of the routine is implemented in git_parse_double(). Unlike git_parse_unsigned() and git_parse_signed(), however, the function implemented here only works on type "double", and not related types like "float", or "long double". This is because "float" and "long double" use different functions to convert from ASCII strings to floating point values (strtof() and strtold(), respectively). Likewise, there is no pointer type that can assign to any of these values (except for "void *"), so the only way to define this trio of functions would be with a macro expansion that is parameterized over the floating point type and conversion function. That is all doable, but likely to be overkill given our current needs, which is only to parse double-precision floats. Signed-off-by: Taylor Blau <me@ttaylorr.com> Signed-off-by: Junio C Hamano <gitster@pobox.com>
212 lines
3.9 KiB
C
212 lines
3.9 KiB
C
#include "git-compat-util.h"
|
|
#include "gettext.h"
|
|
#include "parse.h"
|
|
|
|
static uintmax_t get_unit_factor(const char *end)
|
|
{
|
|
if (!*end)
|
|
return 1;
|
|
else if (!strcasecmp(end, "k"))
|
|
return 1024;
|
|
else if (!strcasecmp(end, "m"))
|
|
return 1024 * 1024;
|
|
else if (!strcasecmp(end, "g"))
|
|
return 1024 * 1024 * 1024;
|
|
return 0;
|
|
}
|
|
|
|
int git_parse_signed(const char *value, intmax_t *ret, intmax_t max)
|
|
{
|
|
if (value && *value) {
|
|
char *end;
|
|
intmax_t val;
|
|
intmax_t factor;
|
|
|
|
if (max < 0)
|
|
BUG("max must be a positive integer");
|
|
|
|
errno = 0;
|
|
val = strtoimax(value, &end, 0);
|
|
if (errno == ERANGE)
|
|
return 0;
|
|
if (end == value) {
|
|
errno = EINVAL;
|
|
return 0;
|
|
}
|
|
factor = get_unit_factor(end);
|
|
if (!factor) {
|
|
errno = EINVAL;
|
|
return 0;
|
|
}
|
|
if ((val < 0 && -max / factor > val) ||
|
|
(val > 0 && max / factor < val)) {
|
|
errno = ERANGE;
|
|
return 0;
|
|
}
|
|
val *= factor;
|
|
*ret = val;
|
|
return 1;
|
|
}
|
|
errno = EINVAL;
|
|
return 0;
|
|
}
|
|
|
|
static int git_parse_unsigned(const char *value, uintmax_t *ret, uintmax_t max)
|
|
{
|
|
if (value && *value) {
|
|
char *end;
|
|
uintmax_t val;
|
|
uintmax_t factor;
|
|
|
|
/* negative values would be accepted by strtoumax */
|
|
if (strchr(value, '-')) {
|
|
errno = EINVAL;
|
|
return 0;
|
|
}
|
|
errno = 0;
|
|
val = strtoumax(value, &end, 0);
|
|
if (errno == ERANGE)
|
|
return 0;
|
|
if (end == value) {
|
|
errno = EINVAL;
|
|
return 0;
|
|
}
|
|
factor = get_unit_factor(end);
|
|
if (!factor) {
|
|
errno = EINVAL;
|
|
return 0;
|
|
}
|
|
if (unsigned_mult_overflows(factor, val) ||
|
|
factor * val > max) {
|
|
errno = ERANGE;
|
|
return 0;
|
|
}
|
|
val *= factor;
|
|
*ret = val;
|
|
return 1;
|
|
}
|
|
errno = EINVAL;
|
|
return 0;
|
|
}
|
|
|
|
int git_parse_int(const char *value, int *ret)
|
|
{
|
|
intmax_t tmp;
|
|
if (!git_parse_signed(value, &tmp, maximum_signed_value_of_type(int)))
|
|
return 0;
|
|
*ret = tmp;
|
|
return 1;
|
|
}
|
|
|
|
int git_parse_int64(const char *value, int64_t *ret)
|
|
{
|
|
intmax_t tmp;
|
|
if (!git_parse_signed(value, &tmp, maximum_signed_value_of_type(int64_t)))
|
|
return 0;
|
|
*ret = tmp;
|
|
return 1;
|
|
}
|
|
|
|
int git_parse_ulong(const char *value, unsigned long *ret)
|
|
{
|
|
uintmax_t tmp;
|
|
if (!git_parse_unsigned(value, &tmp, maximum_unsigned_value_of_type(long)))
|
|
return 0;
|
|
*ret = tmp;
|
|
return 1;
|
|
}
|
|
|
|
int git_parse_ssize_t(const char *value, ssize_t *ret)
|
|
{
|
|
intmax_t tmp;
|
|
if (!git_parse_signed(value, &tmp, maximum_signed_value_of_type(ssize_t)))
|
|
return 0;
|
|
*ret = tmp;
|
|
return 1;
|
|
}
|
|
|
|
int git_parse_double(const char *value, double *ret)
|
|
{
|
|
char *end;
|
|
double val;
|
|
uintmax_t factor;
|
|
|
|
if (!value || !*value) {
|
|
errno = EINVAL;
|
|
return 0;
|
|
}
|
|
|
|
errno = 0;
|
|
val = strtod(value, &end);
|
|
if (errno == ERANGE)
|
|
return 0;
|
|
if (end == value) {
|
|
errno = EINVAL;
|
|
return 0;
|
|
}
|
|
factor = get_unit_factor(end);
|
|
if (!factor) {
|
|
errno = EINVAL;
|
|
return 0;
|
|
}
|
|
val *= factor;
|
|
*ret = val;
|
|
return 1;
|
|
}
|
|
|
|
int git_parse_maybe_bool_text(const char *value)
|
|
{
|
|
if (!value)
|
|
return 1;
|
|
if (!*value)
|
|
return 0;
|
|
if (!strcasecmp(value, "true")
|
|
|| !strcasecmp(value, "yes")
|
|
|| !strcasecmp(value, "on"))
|
|
return 1;
|
|
if (!strcasecmp(value, "false")
|
|
|| !strcasecmp(value, "no")
|
|
|| !strcasecmp(value, "off"))
|
|
return 0;
|
|
return -1;
|
|
}
|
|
|
|
int git_parse_maybe_bool(const char *value)
|
|
{
|
|
int v = git_parse_maybe_bool_text(value);
|
|
if (0 <= v)
|
|
return v;
|
|
if (git_parse_int(value, &v))
|
|
return !!v;
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
* Parse environment variable 'k' as a boolean (in various
|
|
* possible spellings); if missing, use the default value 'def'.
|
|
*/
|
|
int git_env_bool(const char *k, int def)
|
|
{
|
|
const char *v = getenv(k);
|
|
int val;
|
|
if (!v)
|
|
return def;
|
|
val = git_parse_maybe_bool(v);
|
|
if (val < 0)
|
|
die(_("bad boolean environment value '%s' for '%s'"),
|
|
v, k);
|
|
return val;
|
|
}
|
|
|
|
/*
|
|
* Parse environment variable 'k' as ulong with possibly a unit
|
|
* suffix; if missing, use the default value 'val'.
|
|
*/
|
|
unsigned long git_env_ulong(const char *k, unsigned long val)
|
|
{
|
|
const char *v = getenv(k);
|
|
if (v && !git_parse_ulong(v, &val))
|
|
die(_("failed to parse %s"), k);
|
|
return val;
|
|
}
|