Changes in uspace/lib/c/generic/str.c [1c9bf292:09ab0a9a] in mainline

File:

• uspace/lib/c/generic/str.c (modified) (6 diffs)

uspace/lib/c/generic/str.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2001-2004 Jakub Jermar
  * Copyright (c) 2005 Martin Decky
  * Copyright (c) 2008 Jiri Svoboda
@@ -34 +33 @@
  * @{
  */
-
-/**
- * @file
- * @brief String functions.
- *
- * Strings and characters use the Universal Character Set (UCS). The standard
- * strings, called just strings are encoded in UTF-8. Wide strings (encoded
- * in UTF-32) are supported to a limited degree. A single character is
- * represented as wchar_t.@n
- *
- * Overview of the terminology:@n
- *
- *  Term                  Meaning
- *  --------------------  ----------------------------------------------------
- *  byte                  8 bits stored in uint8_t (unsigned 8 bit integer)
- *
- *  character             UTF-32 encoded Unicode character, stored in wchar_t
- *                        (signed 32 bit integer), code points 0 .. 1114111
- *                        are valid
- *
- *  ASCII character       7 bit encoded ASCII character, stored in char
- *                        (usually signed 8 bit integer), code points 0 .. 127
- *                        are valid
- *
- *  string                UTF-8 encoded NULL-terminated Unicode string, char *
- *
- *  wide string           UTF-32 encoded NULL-terminated Unicode string,
- *                        wchar_t *
- *
- *  [wide] string size    number of BYTES in a [wide] string (excluding
- *                        the NULL-terminator), size_t
- *
- *  [wide] string length  number of CHARACTERS in a [wide] string (excluding
- *                        the NULL-terminator), size_t
- *
- *  [wide] string width   number of display cells on a monospace display taken
- *                        by a [wide] string, size_t
- *
- *
- * Overview of string metrics:@n
- *
- *  Metric  Abbrev.  Type     Meaning
- *  ------  ------   ------   -------------------------------------------------
- *  size    n        size_t   number of BYTES in a string (excluding the
- *                            NULL-terminator)
- *
- *  length  l        size_t   number of CHARACTERS in a string (excluding the
- *                            null terminator)
- *
- *  width  w         size_t   number of display cells on a monospace display
- *                            taken by a string
- *
- *
- * Function naming prefixes:@n
- *
- *  chr_    operate on characters
- *  ascii_  operate on ASCII characters
- *  str_    operate on strings
- *  wstr_   operate on wide strings
- *
- *  [w]str_[n|l|w]  operate on a prefix limited by size, length
- *                  or width
- *
- *
- * A specific character inside a [wide] string can be referred to by:@n
- *
- *  pointer (char *, wchar_t *)
- *  byte offset (size_t)
- *  character index (size_t)
- *
+/** @file
  */
 
 #include <str.h>
-
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
 #include <assert.h>
 #include <ctype.h>
 #include <errno.h>
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <stdlib.h>
-
 #include <align.h>
 #include <mem.h>
+#include <limits.h>
 
 /** Check the condition if wchar_t is signed */
@@ -819 +747 @@
         /* There must be space for a null terminator in the buffer. */
         assert(size > 0);
-        assert(src != NULL);
 
         size_t src_off = 0;
@@ -1384 +1311 @@
 {
         size_t size = str_size(src) + 1;
-        char *dest = malloc(size);
-        if (!dest)
-                return NULL;
+        char *dest = (char *) malloc(size);
+        if (dest == NULL)
+                return (char *) NULL;
 
         str_cpy(dest, size, src);
@@ -1418 +1345 @@
                 size = n;
 
-        char *dest = malloc(size + 1);
-        if (!dest)
-                return NULL;
+        char *dest = (char *) malloc(size + 1);
+        if (dest == NULL)
+                return (char *) NULL;
 
         str_ncpy(dest, size + 1, src, size);
@@ -1471 +1398 @@
         *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;
 }