Changes in / [b401b33:83b64a59] in mainline

Files:

• kernel/Makefile (modified) (1 diff)
• kernel/generic/src/lib/str.c (modified) (1 diff)
• kernel/generic/src/lib/strtol.c (deleted)
• uspace/lib/c/generic/ctype.c (modified) (1 diff)
• uspace/lib/c/generic/str.c (modified) (1 diff)
• uspace/lib/c/generic/strtol.c (modified) (11 diffs)
• uspace/lib/c/include/str.h (modified) (1 diff)
• uspace/lib/c/test/strtol.c (modified) (5 diffs)

kernel/Makefile

@@ -207 +207 @@
         generic/src/lib/gsort.c \
         generic/src/lib/str.c \
-        generic/src/lib/strtol.c \
         generic/src/lib/str_error.c \
         generic/src/lib/elf.c \

kernel/generic/src/lib/str.c

@@ -789 +789 @@
         str_ncpy(dest, size + 1, src, size);
         return dest;
+}
+
+/** Convert string to uint64_t (internal variant).
+ *
+ * @param nptr   Pointer to string.
+ * @param endptr Pointer to the first invalid character is stored here.
+ * @param base   Zero or number between 2 and 36 inclusive.
+ * @param neg    Indication of unary minus is stored here.
+ * @apram result Result of the conversion.
+ *
+ * @return EOK if conversion was successful.
+ *
+ */
+static errno_t str_uint(const char *nptr, char **endptr, unsigned int base,
+    bool *neg, uint64_t *result)
+{
+        assert(endptr != NULL);
+        assert(neg != NULL);
+        assert(result != NULL);
+
+        *neg = false;
+        const char *str = nptr;
+
+        /* Ignore leading whitespace */
+        while (isspace(*str))
+                str++;
+
+        if (*str == '-') {
+                *neg = true;
+                str++;
+        } else if (*str == '+')
+                str++;
+
+        if (base == 0) {
+                /* Decode base if not specified */
+                base = 10;
+
+                if (*str == '0') {
+                        base = 8;
+                        str++;
+
+                        switch (*str) {
+                        case 'b':
+                        case 'B':
+                                base = 2;
+                                str++;
+                                break;
+                        case 'o':
+                        case 'O':
+                                base = 8;
+                                str++;
+                                break;
+                        case 'd':
+                        case 'D':
+                        case 't':
+                        case 'T':
+                                base = 10;
+                                str++;
+                                break;
+                        case 'x':
+                        case 'X':
+                                base = 16;
+                                str++;
+                                break;
+                        default:
+                                str--;
+                        }
+                }
+        } else {
+                /* Check base range */
+                if ((base < 2) || (base > 36)) {
+                        *endptr = (char *) str;
+                        return EINVAL;
+                }
+        }
+
+        *result = 0;
+        const char *startstr = str;
+
+        while (*str != 0) {
+                unsigned int digit;
+
+                if ((*str >= 'a') && (*str <= 'z'))
+                        digit = *str - 'a' + 10;
+                else if ((*str >= 'A') && (*str <= 'Z'))
+                        digit = *str - 'A' + 10;
+                else if ((*str >= '0') && (*str <= '9'))
+                        digit = *str - '0';
+                else
+                        break;
+
+                if (digit >= base)
+                        break;
+
+                uint64_t prev = *result;
+                *result = (*result) * base + digit;
+
+                if (*result < prev) {
+                        /* Overflow */
+                        *endptr = (char *) str;
+                        return EOVERFLOW;
+                }
+
+                str++;
+        }
+
+        if (str == startstr) {
+                /*
+                 * No digits were decoded => first invalid character is
+                 * the first character of the string.
+                 */
+                str = nptr;
+        }
+
+        *endptr = (char *) str;
+
+        if (str == nptr)
+                return EINVAL;
+
+        return EOK;
+}
+
+/** Convert string to uint64_t.
+ *
+ * @param nptr   Pointer to string.
+ * @param endptr If not NULL, pointer to the first invalid character
+ *               is stored here.
+ * @param base   Zero or number between 2 and 36 inclusive.
+ * @param strict Do not allow any trailing characters.
+ * @param result Result of the conversion.
+ *
+ * @return EOK if conversion was successful.
+ *
+ */
+errno_t str_uint64_t(const char *nptr, char **endptr, unsigned int base,
+    bool strict, uint64_t *result)
+{
+        assert(result != NULL);
+
+        bool neg;
+        char *lendptr;
+        errno_t ret = str_uint(nptr, &lendptr, base, &neg, result);
+
+        if (endptr != NULL)
+                *endptr = (char *) lendptr;
+
+        if (ret != EOK)
+                return ret;
+
+        /* Do not allow negative values */
+        if (neg)
+                return EINVAL;
+
+        /*
+         * Check whether we are at the end of
+         * the string in strict mode
+         */
+        if ((strict) && (*lendptr != 0))
+                return EINVAL;
+
+        return EOK;
 }
 

uspace/lib/c/generic/ctype.c

@@ -90 +90 @@
         case '\v':
                 return 1;
+                break;
         default:
                 return 0;

uspace/lib/c/generic/str.c

@@ -1471 +1471 @@
         *end = '\0';
         return start;
+}
+
+/** Convert string to uint64_t (internal variant).
+ *
+ * @param nptr   Pointer to string.
+ * @param endptr Pointer to the first invalid character is stored here.
+ * @param base   Zero or number between 2 and 36 inclusive.
+ * @param neg    Indication of unary minus is stored here.
+ * @apram result Result of the conversion.
+ *
+ * @return EOK if conversion was successful.
+ *
+ */
+static errno_t str_uint(const char *nptr, char **endptr, unsigned int base,
+    bool *neg, uint64_t *result)
+{
+        assert(endptr != NULL);
+        assert(neg != NULL);
+        assert(result != NULL);
+
+        *neg = false;
+        const char *str = nptr;
+
+        /* Ignore leading whitespace */
+        while (isspace(*str))
+                str++;
+
+        if (*str == '-') {
+                *neg = true;
+                str++;
+        } else if (*str == '+')
+                str++;
+
+        if (base == 0) {
+                /* Decode base if not specified */
+                base = 10;
+
+                if (*str == '0') {
+                        base = 8;
+                        str++;
+
+                        switch (*str) {
+                        case 'b':
+                        case 'B':
+                                base = 2;
+                                str++;
+                                break;
+                        case 'o':
+                        case 'O':
+                                base = 8;
+                                str++;
+                                break;
+                        case 'd':
+                        case 'D':
+                        case 't':
+                        case 'T':
+                                base = 10;
+                                str++;
+                                break;
+                        case 'x':
+                        case 'X':
+                                base = 16;
+                                str++;
+                                break;
+                        default:
+                                str--;
+                        }
+                }
+        } else {
+                /* Check base range */
+                if ((base < 2) || (base > 36)) {
+                        *endptr = (char *) str;
+                        return EINVAL;
+                }
+        }
+
+        *result = 0;
+        const char *startstr = str;
+
+        while (*str != 0) {
+                unsigned int digit;
+
+                if ((*str >= 'a') && (*str <= 'z'))
+                        digit = *str - 'a' + 10;
+                else if ((*str >= 'A') && (*str <= 'Z'))
+                        digit = *str - 'A' + 10;
+                else if ((*str >= '0') && (*str <= '9'))
+                        digit = *str - '0';
+                else
+                        break;
+
+                if (digit >= base)
+                        break;
+
+                uint64_t prev = *result;
+                *result = (*result) * base + digit;
+
+                if (*result < prev) {
+                        /* Overflow */
+                        *endptr = (char *) str;
+                        return EOVERFLOW;
+                }
+
+                str++;
+        }
+
+        if (str == startstr) {
+                /*
+                 * No digits were decoded => first invalid character is
+                 * the first character of the string.
+                 */
+                str = nptr;
+        }
+
+        *endptr = (char *) str;
+
+        if (str == nptr)
+                return EINVAL;
+
+        return EOK;
+}
+
+/** Convert string to uint8_t.
+ *
+ * @param nptr   Pointer to string.
+ * @param endptr If not NULL, pointer to the first invalid character
+ *               is stored here.
+ * @param base   Zero or number between 2 and 36 inclusive.
+ * @param strict Do not allow any trailing characters.
+ * @param result Result of the conversion.
+ *
+ * @return EOK if conversion was successful.
+ *
+ */
+errno_t str_uint8_t(const char *nptr, const char **endptr, unsigned int base,
+    bool strict, uint8_t *result)
+{
+        assert(result != NULL);
+
+        bool neg;
+        char *lendptr;
+        uint64_t res;
+        errno_t ret = str_uint(nptr, &lendptr, base, &neg, &res);
+
+        if (endptr != NULL)
+                *endptr = (char *) lendptr;
+
+        if (ret != EOK)
+                return ret;
+
+        /* Do not allow negative values */
+        if (neg)
+                return EINVAL;
+
+        /*
+         * Check whether we are at the end of
+         * the string in strict mode
+         */
+        if ((strict) && (*lendptr != 0))
+                return EINVAL;
+
+        /* Check for overflow */
+        uint8_t _res = (uint8_t) res;
+        if (_res != res)
+                return EOVERFLOW;
+
+        *result = _res;
+
+        return EOK;
+}
+
+/** Convert string to uint16_t.
+ *
+ * @param nptr   Pointer to string.
+ * @param endptr If not NULL, pointer to the first invalid character
+ *               is stored here.
+ * @param base   Zero or number between 2 and 36 inclusive.
+ * @param strict Do not allow any trailing characters.
+ * @param result Result of the conversion.
+ *
+ * @return EOK if conversion was successful.
+ *
+ */
+errno_t str_uint16_t(const char *nptr, const char **endptr, unsigned int base,
+    bool strict, uint16_t *result)
+{
+        assert(result != NULL);
+
+        bool neg;
+        char *lendptr;
+        uint64_t res;
+        errno_t ret = str_uint(nptr, &lendptr, base, &neg, &res);
+
+        if (endptr != NULL)
+                *endptr = (char *) lendptr;
+
+        if (ret != EOK)
+                return ret;
+
+        /* Do not allow negative values */
+        if (neg)
+                return EINVAL;
+
+        /*
+         * Check whether we are at the end of
+         * the string in strict mode
+         */
+        if ((strict) && (*lendptr != 0))
+                return EINVAL;
+
+        /* Check for overflow */
+        uint16_t _res = (uint16_t) res;
+        if (_res != res)
+                return EOVERFLOW;
+
+        *result = _res;
+
+        return EOK;
+}
+
+/** Convert string to uint32_t.
+ *
+ * @param nptr   Pointer to string.
+ * @param endptr If not NULL, pointer to the first invalid character
+ *               is stored here.
+ * @param base   Zero or number between 2 and 36 inclusive.
+ * @param strict Do not allow any trailing characters.
+ * @param result Result of the conversion.
+ *
+ * @return EOK if conversion was successful.
+ *
+ */
+errno_t str_uint32_t(const char *nptr, const char **endptr, unsigned int base,
+    bool strict, uint32_t *result)
+{
+        assert(result != NULL);
+
+        bool neg;
+        char *lendptr;
+        uint64_t res;
+        errno_t ret = str_uint(nptr, &lendptr, base, &neg, &res);
+
+        if (endptr != NULL)
+                *endptr = (char *) lendptr;
+
+        if (ret != EOK)
+                return ret;
+
+        /* Do not allow negative values */
+        if (neg)
+                return EINVAL;
+
+        /*
+         * Check whether we are at the end of
+         * the string in strict mode
+         */
+        if ((strict) && (*lendptr != 0))
+                return EINVAL;
+
+        /* Check for overflow */
+        uint32_t _res = (uint32_t) res;
+        if (_res != res)
+                return EOVERFLOW;
+
+        *result = _res;
+
+        return EOK;
+}
+
+/** Convert string to uint64_t.
+ *
+ * @param nptr   Pointer to string.
+ * @param endptr If not NULL, pointer to the first invalid character
+ *               is stored here.
+ * @param base   Zero or number between 2 and 36 inclusive.
+ * @param strict Do not allow any trailing characters.
+ * @param result Result of the conversion.
+ *
+ * @return EOK if conversion was successful.
+ *
+ */
+errno_t str_uint64_t(const char *nptr, const char **endptr, unsigned int base,
+    bool strict, uint64_t *result)
+{
+        assert(result != NULL);
+
+        bool neg;
+        char *lendptr;
+        errno_t ret = str_uint(nptr, &lendptr, base, &neg, result);
+
+        if (endptr != NULL)
+                *endptr = (char *) lendptr;
+
+        if (ret != EOK)
+                return ret;
+
+        /* Do not allow negative values */
+        if (neg)
+                return EINVAL;
+
+        /*
+         * Check whether we are at the end of
+         * the string in strict mode
+         */
+        if ((strict) && (*lendptr != 0))
+                return EINVAL;
+
+        return EOK;
+}
+
+/** Convert string to int64_t.
+ *
+ * @param nptr   Pointer to string.
+ * @param endptr If not NULL, pointer to the first invalid character
+ *               is stored here.
+ * @param base   Zero or number between 2 and 36 inclusive.
+ * @param strict Do not allow any trailing characters.
+ * @param result Result of the conversion.
+ *
+ * @return EOK if conversion was successful.
+ *
+ */
+int str_int64_t(const char *nptr, const char **endptr, unsigned int base,
+    bool strict, int64_t *result)
+{
+        assert(result != NULL);
+
+        bool neg;
+        char *lendptr;
+        uint64_t unsigned_result;
+        int ret = str_uint(nptr, &lendptr, base, &neg, &unsigned_result);
+
+        if (endptr != NULL)
+                *endptr = (char *) lendptr;
+
+        if (ret != EOK)
+                return ret;
+
+        /* Do not allow negative values */
+        if (neg) {
+                if (unsigned_result == UINT64_MAX)
+                        return EINVAL;
+
+                *result = -(int64_t) unsigned_result;
+        } else
+                *result = unsigned_result;
+
+        /*
+         * Check whether we are at the end of
+         * the string in strict mode
+         */
+        if ((strict) && (*lendptr != 0))
+                return EINVAL;
+
+        return EOK;
+}
+
+/** Convert string to size_t.
+ *
+ * @param nptr   Pointer to string.
+ * @param endptr If not NULL, pointer to the first invalid character
+ *               is stored here.
+ * @param base   Zero or number between 2 and 36 inclusive.
+ * @param strict Do not allow any trailing characters.
+ * @param result Result of the conversion.
+ *
+ * @return EOK if conversion was successful.
+ *
+ */
+errno_t str_size_t(const char *nptr, const char **endptr, unsigned int base,
+    bool strict, size_t *result)
+{
+        assert(result != NULL);
+
+        bool neg;
+        char *lendptr;
+        uint64_t res;
+        errno_t ret = str_uint(nptr, &lendptr, base, &neg, &res);
+
+        if (endptr != NULL)
+                *endptr = (char *) lendptr;
+
+        if (ret != EOK)
+                return ret;
+
+        /* Do not allow negative values */
+        if (neg)
+                return EINVAL;
+
+        /*
+         * Check whether we are at the end of
+         * the string in strict mode
+         */
+        if ((strict) && (*lendptr != 0))
+                return EINVAL;
+
+        /* Check for overflow */
+        size_t _res = (size_t) res;
+        if (_res != res)
+                return EOVERFLOW;
+
+        *result = _res;
+
+        return EOK;
 }
 

uspace/lib/c/generic/strtol.c

@@ -44 +44 @@
 #include <stdbool.h>
 #include <stdlib.h>
-#include <str.h>
-
-// FIXME: The original HelenOS functions return EOVERFLOW instead
-//        of ERANGE. It's a pointless distinction from standard functions,
-//        so we should change that. Beware the callers though.
-
-// TODO: more unit tests
+
+// TODO: unit tests
 
 static inline int _digit_value(int c)
@@ -74 +69 @@
 }
 
-static inline int _prefixbase(const char *restrict *nptrptr, bool nonstd)
-{
-        const char *nptr = *nptrptr;
-
-        if (nptr[0] != '0')
-                return 10;
-
-        if (nptr[1] == 'x' || nptr[1] == 'X') {
-                if (_digit_value(nptr[2]) < 16) {
-                        *nptrptr += 2;
-                        return 16;
-                }
-        }
-
-        if (nonstd) {
-                switch (nptr[1]) {
-                case 'b':
-                case 'B':
-                        if (_digit_value(nptr[2]) < 2) {
-                                *nptrptr += 2;
-                                return 2;
-                        }
-                        break;
-                case 'o':
-                case 'O':
-                        if (_digit_value(nptr[2]) < 8) {
-                                *nptrptr += 2;
-                                return 8;
-                        }
-                        break;
-                case 'd':
-                case 'D':
-                case 't':
-                case 'T':
-                        if (_digit_value(nptr[2]) < 10) {
-                                *nptrptr += 2;
-                                return 10;
-                        }
-                        break;
-                }
-        }
-
-        return 8;
-}
-
 static inline uintmax_t _strtoumax(
     const char *restrict nptr, char **restrict endptr, int base,
-    bool *restrict sgn, errno_t *err, bool nonstd)
+    bool *restrict sgn)
 {
         assert(nptr != NULL);
         assert(sgn != NULL);
-
-        const char *first = nptr;
 
         /* Skip leading whitespace. */
@@ -148 +96 @@
         /* Figure out the base. */
 
-        if (base == 0)
-                base = _prefixbase(&nptr, nonstd);
-
-        if (base == 16 && !nonstd) {
-                /*
-                 * Standard strto* functions allow hexadecimal prefix to be
-                 * present when base is explicitly set to 16.
-                 * Our nonstandard str_* functions don't allow it.
-                 * I don't know if that is intended, just matching the original
-                 * functionality here.
-                 */
-
-                if (nptr[0] == '0' && (nptr[1] == 'x' || nptr[1] == 'X') &&
-                    _digit_value(nptr[2]) < base)
+        if (base == 0) {
+                if (*nptr == '0') {
+                        if (tolower(nptr[1]) == 'x') {
+                                /* 0x... is hex. */
+                                base = 16;
+                                nptr += 2;
+                        } else {
+                                /* 0... is octal. */
+                                base = 8;
+                        }
+                } else {
+                        /* Anything else is decimal by default. */
+                        base = 10;
+                }
+        } else if (base == 16) {
+                /* Allow hex number to be prefixed with "0x". */
+                if (nptr[0] == '0' && tolower(nptr[1]) == 'x') {
                         nptr += 2;
-        }
-
-        if (base < 2 || base > 36) {
-                *err = EINVAL;
+                }
+        } else if (base < 0 || base == 1 || base > 36) {
+                errno = EINVAL;
                 return 0;
         }
 
-        /* Must be at least one digit. */
-
-        if (_digit_value(*nptr) >= base) {
-                /* No digits on input. */
-                if (endptr != NULL)
-                        *endptr = (char *) first;
-                return 0;
-        }
-
-        /* Read the value.  */
+        /* Read the value. */
 
         uintmax_t result = 0;
@@ -186 +127 @@
 
         while (digit = _digit_value(*nptr), digit < base) {
+
                 if (result > max ||
                     __builtin_add_overflow(result * base, digit, &result)) {
 
-                        *err = nonstd ? EOVERFLOW : ERANGE;
+                        errno = ERANGE;
                         result = UINTMAX_MAX;
                         break;
@@ -203 +145 @@
                  * Move the pointer to the end of the number,
                  * in case it isn't there already.
-                 * This can happen when the number has legal formatting,
-                 * but is out of range of the target type.
                  */
                 while (_digit_value(*nptr) < base) {
@@ -217 +157 @@
 
 static inline intmax_t _strtosigned(const char *nptr, char **endptr, int base,
-    intmax_t min, intmax_t max, errno_t *err, bool nonstd)
+    intmax_t min, intmax_t max)
 {
         bool sgn = false;
-        uintmax_t number = _strtoumax(nptr, endptr, base, &sgn, err, nonstd);
+        uintmax_t number = _strtoumax(nptr, endptr, base, &sgn);
 
         if (number > (uintmax_t) max) {
@@ -227 +167 @@
                 }
 
-                *err = nonstd ? EOVERFLOW : ERANGE;
+                errno = ERANGE;
                 return (sgn ? min : max);
         }
@@ -235 +175 @@
 
 static inline uintmax_t _strtounsigned(const char *nptr, char **endptr, int base,
-    uintmax_t max, errno_t *err, bool nonstd)
+    uintmax_t max)
 {
         bool sgn = false;
-        uintmax_t number = _strtoumax(nptr, endptr, base, &sgn, err, nonstd);
-
-        if (nonstd && sgn) {
-                /* Do not allow negative values */
-                *err = EINVAL;
-                return 0;
+        uintmax_t number = _strtoumax(nptr, endptr, base, &sgn);
+
+        if (sgn) {
+                if (number == 0) {
+                        return 0;
+                } else {
+                        errno = ERANGE;
+                        return max;
+                }
         }
 
         if (number > max) {
-                *err = nonstd ? EOVERFLOW : ERANGE;
+                errno = ERANGE;
                 return max;
         }
 
-        return (sgn ? -number : number);
+        return number;
 }
 
@@ -269 +212 @@
 long strtol(const char *nptr, char **endptr, int base)
 {
-        return _strtosigned(nptr, endptr, base, LONG_MIN, LONG_MAX, &errno, false);
+        return _strtosigned(nptr, endptr, base, LONG_MIN, LONG_MAX);
 }
 
@@ -287 +230 @@
 unsigned long strtoul(const char *nptr, char **endptr, int base)
 {
-        return _strtounsigned(nptr, endptr, base, ULONG_MAX, &errno, false);
+        return _strtounsigned(nptr, endptr, base, ULONG_MAX);
 }
 
 long long strtoll(const char *nptr, char **endptr, int base)
 {
-        return _strtosigned(nptr, endptr, base, LLONG_MIN, LLONG_MAX, &errno, false);
+        return _strtosigned(nptr, endptr, base, LLONG_MIN, LLONG_MAX);
 }
 
 unsigned long long strtoull(const char *nptr, char **endptr, int base)
 {
-        return _strtounsigned(nptr, endptr, base, ULLONG_MAX, &errno, false);
+        return _strtounsigned(nptr, endptr, base, ULLONG_MAX);
 }
 
 intmax_t strtoimax(const char *nptr, char **endptr, int base)
 {
-        return _strtosigned(nptr, endptr, base, INTMAX_MIN, INTMAX_MAX, &errno, false);
+        return _strtosigned(nptr, endptr, base, INTMAX_MIN, INTMAX_MAX);
 }
 
 uintmax_t strtoumax(const char *nptr, char **endptr, int base)
 {
-        return _strtounsigned(nptr, endptr, base, UINTMAX_MAX, &errno, false);
+        return _strtounsigned(nptr, endptr, base, UINTMAX_MAX);
 }
 
@@ -325 +268 @@
 }
 
-/** Convert string to uint8_t.
- *
- * @param nptr   Pointer to string.
- * @param endptr If not NULL, pointer to the first invalid character
- *               is stored here.
- * @param base   Zero or number between 2 and 36 inclusive.
- * @param strict Do not allow any trailing characters.
- * @param result Result of the conversion.
- *
- * @return EOK if conversion was successful.
- *
- */
-errno_t str_uint8_t(const char *nptr, const char **endptr, unsigned int base,
-    bool strict, uint8_t *result)
-{
-        assert(result != NULL);
-
-        errno_t rc = EOK;
-        char *lendptr = (char *) nptr;
-
-        uintmax_t r = _strtounsigned(nptr, &lendptr, base, UINT8_MAX, &rc, true);
-
-        if (endptr)
-                *endptr = lendptr;
-
-        if (rc != EOK)
-                return rc;
-
-        if (strict && *lendptr != '\0')
-                return EINVAL;
-
-        *result = r;
-        return EOK;
-}
-
-/** Convert string to uint16_t.
- *
- * @param nptr   Pointer to string.
- * @param endptr If not NULL, pointer to the first invalid character
- *               is stored here.
- * @param base   Zero or number between 2 and 36 inclusive.
- * @param strict Do not allow any trailing characters.
- * @param result Result of the conversion.
- *
- * @return EOK if conversion was successful.
- *
- */
-errno_t str_uint16_t(const char *nptr, const char **endptr, unsigned int base,
-    bool strict, uint16_t *result)
-{
-        assert(result != NULL);
-
-        errno_t rc = EOK;
-        char *lendptr = (char *) nptr;
-
-        uintmax_t r = _strtounsigned(nptr, &lendptr, base, UINT16_MAX, &rc, true);
-
-        if (endptr)
-                *endptr = lendptr;
-
-        if (rc != EOK)
-                return rc;
-
-        if (strict && *lendptr != '\0')
-                return EINVAL;
-
-        *result = r;
-        return EOK;
-}
-
-/** Convert string to uint32_t.
- *
- * @param nptr   Pointer to string.
- * @param endptr If not NULL, pointer to the first invalid character
- *               is stored here.
- * @param base   Zero or number between 2 and 36 inclusive.
- * @param strict Do not allow any trailing characters.
- * @param result Result of the conversion.
- *
- * @return EOK if conversion was successful.
- *
- */
-errno_t str_uint32_t(const char *nptr, const char **endptr, unsigned int base,
-    bool strict, uint32_t *result)
-{
-        assert(result != NULL);
-
-        errno_t rc = EOK;
-        char *lendptr = (char *) nptr;
-
-        uintmax_t r = _strtounsigned(nptr, &lendptr, base, UINT32_MAX, &rc, true);
-
-        if (endptr)
-                *endptr = lendptr;
-
-        if (rc != EOK)
-                return rc;
-
-        if (strict && *lendptr != '\0')
-                return EINVAL;
-
-        *result = r;
-        return EOK;
-}
-
-/** Convert string to uint64_t.
- *
- * @param nptr   Pointer to string.
- * @param endptr If not NULL, pointer to the first invalid character
- *               is stored here.
- * @param base   Zero or number between 2 and 36 inclusive.
- * @param strict Do not allow any trailing characters.
- * @param result Result of the conversion.
- *
- * @return EOK if conversion was successful.
- *
- */
-errno_t str_uint64_t(const char *nptr, const char **endptr, unsigned int base,
-    bool strict, uint64_t *result)
-{
-        assert(result != NULL);
-
-        errno_t rc = EOK;
-        char *lendptr = (char *) nptr;
-
-        uintmax_t r = _strtounsigned(nptr, &lendptr, base, UINT64_MAX, &rc, true);
-
-        if (endptr)
-                *endptr = lendptr;
-
-        if (rc != EOK)
-                return rc;
-
-        if (strict && *lendptr != '\0')
-                return EINVAL;
-
-        *result = r;
-        return EOK;
-}
-
-/** Convert string to int64_t.
- *
- * @param nptr   Pointer to string.
- * @param endptr If not NULL, pointer to the first invalid character
- *               is stored here.
- * @param base   Zero or number between 2 and 36 inclusive.
- * @param strict Do not allow any trailing characters.
- * @param result Result of the conversion.
- *
- * @return EOK if conversion was successful.
- *
- */
-errno_t str_int64_t(const char *nptr, const char **endptr, unsigned int base,
-    bool strict, int64_t *result)
-{
-        assert(result != NULL);
-
-        errno_t rc = EOK;
-        char *lendptr = (char *) nptr;
-
-        intmax_t r = _strtosigned(nptr, &lendptr, base, INT64_MIN, INT64_MAX, &rc, true);
-
-        if (endptr)
-                *endptr = lendptr;
-
-        if (rc != EOK)
-                return rc;
-
-        if (strict && *lendptr != '\0')
-                return EINVAL;
-
-        *result = r;
-        return EOK;
-}
-
-/** Convert string to size_t.
- *
- * @param nptr   Pointer to string.
- * @param endptr If not NULL, pointer to the first invalid character
- *               is stored here.
- * @param base   Zero or number between 2 and 36 inclusive.
- * @param strict Do not allow any trailing characters.
- * @param result Result of the conversion.
- *
- * @return EOK if conversion was successful.
- *
- */
-errno_t str_size_t(const char *nptr, const char **endptr, unsigned int base,
-    bool strict, size_t *result)
-{
-        assert(result != NULL);
-
-        errno_t rc = EOK;
-        char *lendptr = (char *) nptr;
-
-        uintmax_t r = _strtounsigned(nptr, &lendptr, base, SIZE_MAX, &rc, true);
-
-        if (endptr)
-                *endptr = lendptr;
-
-        if (rc != EOK)
-                return rc;
-
-        if (strict && *lendptr != '\0')
-                return EINVAL;
-
-        *result = r;
-        return EOK;
-}
-
 /** @}
  */

uspace/lib/c/include/str.h

@@ -137 +137 @@
 extern errno_t str_size_t(const char *, const char **, unsigned int, bool,
     size_t *);
-extern errno_t str_int64_t(const char *, const char **, unsigned int, bool,
+extern int str_int64_t(const char *, const char **, unsigned int, bool,
     int64_t *);
 

uspace/lib/c/test/strtol.c

@@ -38 +38 @@
 #include <stdlib.h>
 #include <str.h>
-#include <limits.h>
 
 PCUT_INIT;
@@ -218 +217 @@
         /* Correct result. */
         PCUT_ASSERT_INT_EQUALS(EOVERFLOW, rc);
+        PCUT_ASSERT_UINT_EQUALS(UINT64_MAX, result);
 #endif
 
@@ -245 +245 @@
         /* Correct result. */
         PCUT_ASSERT_INT_EQUALS(EOVERFLOW, rc);
+        PCUT_ASSERT_UINT_EQUALS(UINT64_MAX, result);
 #endif
-}
-
-PCUT_TEST(strtoul_negative_wraparound)
-{
-        long output;
-        char *endp;
-        char *endp_unchanged = (char *) "endp_unchanged unique pointer";
-        int errno_unchanged = -1;
-        const char *input;
-        int base;
-
-        /*
-         * N2176 7.22.1.4 The strtol, strtoll, strtoul, and strtoull functions
-         *
-         * "If the subject sequence begins with a minus sign, the value
-         * resulting from the conversion is negated (in the return type)."
-         */
-
-        endp = endp_unchanged;
-        errno = errno_unchanged;
-        output = strtoul(input = "-10", &endp, base = 0);
-        PCUT_ASSERT_INT_EQUALS(errno_unchanged, errno);
-        PCUT_ASSERT_PTR_EQUALS(input + 3, endp);
-        PCUT_ASSERT_UINT_EQUALS(-(10ul), output);
 }
 
@@ -427 +404 @@
         endp = endp_unchanged;
         errno = errno_unchanged;
-        output = strtol(input = "    0xg", &endp, base = 0);
-        PCUT_ASSERT_INT_EQUALS(errno_unchanged, errno);
-        PCUT_ASSERT_PTR_EQUALS(input + 5, endp);
-        PCUT_ASSERT_INT_EQUALS(0, output);
-
-        endp = endp_unchanged;
-        errno = errno_unchanged;
         output = strtol(input = "    0x1", &endp, base = 0);
         PCUT_ASSERT_INT_EQUALS(errno_unchanged, errno);
@@ -448 +418 @@
         endp = endp_unchanged;
         errno = errno_unchanged;
-        output = strtol(input = "    0xg", &endp, base = 16);
-        PCUT_ASSERT_INT_EQUALS(errno_unchanged, errno);
-        PCUT_ASSERT_PTR_EQUALS(input + 5, endp);
-        PCUT_ASSERT_INT_EQUALS(0, output);
-
-        endp = endp_unchanged;
-        errno = errno_unchanged;
-        output = strtol(input = "    g", &endp, base = 16);
-        PCUT_ASSERT_INT_EQUALS(errno_unchanged, errno);
-        PCUT_ASSERT_PTR_EQUALS(input, endp);
-        PCUT_ASSERT_INT_EQUALS(0, output);
-
-        endp = endp_unchanged;
-        errno = errno_unchanged;
         output = strtol(input = "    0x1", &endp, base = 16);
         PCUT_ASSERT_INT_EQUALS(errno_unchanged, errno);
         PCUT_ASSERT_PTR_EQUALS(input + 7, endp);
         PCUT_ASSERT_INT_EQUALS(1, output);
-
-        endp = endp_unchanged;
-        errno = errno_unchanged;
-        output = strtol(input = "    +", &endp, base = 0);
-        PCUT_ASSERT_INT_EQUALS(errno_unchanged, errno);
-        PCUT_ASSERT_PTR_EQUALS(input, endp);
-        PCUT_ASSERT_INT_EQUALS(0, output);
-
-        endp = endp_unchanged;
-        errno = errno_unchanged;
-        output = strtol(input = "    -", &endp, base = 0);
-        PCUT_ASSERT_INT_EQUALS(errno_unchanged, errno);
-        PCUT_ASSERT_PTR_EQUALS(input, endp);
-        PCUT_ASSERT_INT_EQUALS(0, output);
-
-        endp = endp_unchanged;
-        errno = errno_unchanged;
-        output = strtol(input = "    +", &endp, base = 10);
-        PCUT_ASSERT_INT_EQUALS(errno_unchanged, errno);
-        PCUT_ASSERT_PTR_EQUALS(input, endp);
-        PCUT_ASSERT_INT_EQUALS(0, output);
-
-        endp = endp_unchanged;
-        errno = errno_unchanged;
-        output = strtol(input = "    -", &endp, base = 10);
-        PCUT_ASSERT_INT_EQUALS(errno_unchanged, errno);
-        PCUT_ASSERT_PTR_EQUALS(input, endp);
-        PCUT_ASSERT_INT_EQUALS(0, output);
-
-        endp = endp_unchanged;
-        errno = errno_unchanged;
-        output = strtol(input = "+", &endp, base = 0);
-        PCUT_ASSERT_INT_EQUALS(errno_unchanged, errno);
-        PCUT_ASSERT_PTR_EQUALS(input, endp);
-        PCUT_ASSERT_INT_EQUALS(0, output);
-
-        endp = endp_unchanged;
-        errno = errno_unchanged;
-        output = strtol(input = "-", &endp, base = 0);
-        PCUT_ASSERT_INT_EQUALS(errno_unchanged, errno);
-        PCUT_ASSERT_PTR_EQUALS(input, endp);
-        PCUT_ASSERT_INT_EQUALS(0, output);
-
-        endp = endp_unchanged;
-        errno = errno_unchanged;
-        output = strtol(input = "+", &endp, base = 10);
-        PCUT_ASSERT_INT_EQUALS(errno_unchanged, errno);
-        PCUT_ASSERT_PTR_EQUALS(input, endp);
-        PCUT_ASSERT_INT_EQUALS(0, output);
-
-        endp = endp_unchanged;
-        errno = errno_unchanged;
-        output = strtol(input = "-", &endp, base = 10);
-        PCUT_ASSERT_INT_EQUALS(errno_unchanged, errno);
-        PCUT_ASSERT_PTR_EQUALS(input, endp);
-        PCUT_ASSERT_INT_EQUALS(0, output);
 }