parse: prefer bool to int for boolean returns

All of the integer parsing functions in parse.[ch] return an int that is
"0" for failure or "1" for success. Since most of the other functions in
Git use "0" for success and "-1" for failure, this can be confusing.
Let's switch the return types to bool to make it clear that we are using
this other convention. Callers should not need to update at all.

Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/parse.c b/parse.c
index 48313571aab1290924fe2b0019bbeba012898e98..f626846defc67b48a6891769e485ec0e69de0d97 100644 (file)
--- a/parse.c
+++ b/parse.c
@@ -15,7 +15,7 @@ static uintmax_t get_unit_factor(const char *end)
        return 0;
 }
 
-int git_parse_signed(const char *value, intmax_t *ret, intmax_t max)
+bool git_parse_signed(const char *value, intmax_t *ret, intmax_t max)
 {
        if (value && *value) {
                char *end;
@@ -28,30 +28,30 @@ int git_parse_signed(const char *value, intmax_t *ret, intmax_t max)
                errno = 0;
                val = strtoimax(value, &end, 0);
                if (errno == ERANGE)
-                       return 0;
+                       return false;
                if (end == value) {
                        errno = EINVAL;
-                       return 0;
+                       return false;
                }
                factor = get_unit_factor(end);
                if (!factor) {
                        errno = EINVAL;
-                       return 0;
+                       return false;
                }
                if ((val < 0 && (-max - 1) / factor > val) ||
                    (val > 0 && max / factor < val)) {
                        errno = ERANGE;
-                       return 0;
+                       return false;
                }
                val *= factor;
                *ret = val;
-               return 1;
+               return true;
        }
        errno = EINVAL;
-       return 0;
+       return false;
 }
 
-int git_parse_unsigned(const char *value, uintmax_t *ret, uintmax_t max)
+bool git_parse_unsigned(const char *value, uintmax_t *ret, uintmax_t max)
 {
        if (value && *value) {
                char *end;
@@ -61,71 +61,71 @@ int git_parse_unsigned(const char *value, uintmax_t *ret, uintmax_t max)
                /* negative values would be accepted by strtoumax */
                if (strchr(value, '-')) {
                        errno = EINVAL;
-                       return 0;
+                       return false;
                }
                errno = 0;
                val = strtoumax(value, &end, 0);
                if (errno == ERANGE)
-                       return 0;
+                       return false;
                if (end == value) {
                        errno = EINVAL;
-                       return 0;
+                       return false;
                }
                factor = get_unit_factor(end);
                if (!factor) {
                        errno = EINVAL;
-                       return 0;
+                       return false;
                }
                if (unsigned_mult_overflows(factor, val) ||
                    factor * val > max) {
                        errno = ERANGE;
-                       return 0;
+                       return false;
                }
                val *= factor;
                *ret = val;
-               return 1;
+               return true;
        }
        errno = EINVAL;
-       return 0;
+       return false;
 }
 
-int git_parse_int(const char *value, int *ret)
+bool 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;
+               return false;
        *ret = tmp;
-       return 1;
+       return true;
 }
 
-int git_parse_int64(const char *value, int64_t *ret)
+bool 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;
+               return false;
        *ret = tmp;
-       return 1;
+       return true;
 }
 
-int git_parse_ulong(const char *value, unsigned long *ret)
+bool 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;
+               return false;
        *ret = tmp;
-       return 1;
+       return true;
 }
 
-int git_parse_ssize_t(const char *value, ssize_t *ret)
+bool 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;
+               return false;
        *ret = tmp;
-       return 1;
+       return true;
 }
 
-int git_parse_double(const char *value, double *ret)
+bool git_parse_double(const char *value, double *ret)
 {
        char *end;
        double val;
@@ -133,25 +133,25 @@ int git_parse_double(const char *value, double *ret)
 
        if (!value || !*value) {
                errno = EINVAL;
-               return 0;
+               return false;
        }
 
        errno = 0;
        val = strtod(value, &end);
        if (errno == ERANGE)
-               return 0;
+               return false;
        if (end == value) {
                errno = EINVAL;
-               return 0;
+               return false;
        }
        factor = get_unit_factor(end);
        if (!factor) {
                errno = EINVAL;
-               return 0;
+               return false;
        }
        val *= factor;
        *ret = val;
-       return 1;
+       return true;
 }
 
 int git_parse_maybe_bool_text(const char *value)

diff --git a/parse.h b/parse.h
index ea32de9a91fbfbc3cbe4894937852e398e24dde6..f80cc5b9fde9590ae158a4216d07a569412d3af4 100644 (file)
--- a/parse.h
+++ b/parse.h
@@ -1,13 +1,13 @@
 #ifndef PARSE_H
 #define PARSE_H
 
-int git_parse_signed(const char *value, intmax_t *ret, intmax_t max);
-int git_parse_unsigned(const char *value, uintmax_t *ret, uintmax_t max);
-int git_parse_ssize_t(const char *, ssize_t *);
-int git_parse_ulong(const char *, unsigned long *);
-int git_parse_int(const char *value, int *ret);
-int git_parse_int64(const char *value, int64_t *ret);
-int git_parse_double(const char *value, double *ret);
+bool git_parse_signed(const char *value, intmax_t *ret, intmax_t max);
+bool git_parse_unsigned(const char *value, uintmax_t *ret, uintmax_t max);
+bool git_parse_ssize_t(const char *, ssize_t *);
+bool git_parse_ulong(const char *, unsigned long *);
+bool git_parse_int(const char *value, int *ret);
+bool git_parse_int64(const char *value, int64_t *ret);
+bool git_parse_double(const char *value, double *ret);
 
 /**
  * Same as `git_config_bool`, except that it returns -1 on error rather