Changes in kernel/generic/src/lib/str.c [42e91ae:aafed15] in mainline

File:

• kernel/generic/src/lib/str.c (modified) (4 diffs)

kernel/generic/src/lib/str.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2001-2004 Jakub Jermar
- * Copyright (c) 2005 Martin Decky
- * Copyright (c) 2008 Jiri Svoboda
- * Copyright (c) 2011 Martin Sucha
- * Copyright (c) 2011 Oleg Romanenko
  * All rights reserved.
  *
@@ -107 +103 @@
 
 #include <str.h>
-
+#include <cpu.h>
+#include <arch/asm.h>
+#include <arch.h>
+#include <errno.h>
+#include <align.h>
 #include <assert.h>
-#include <errno.h>
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
+#include <macros.h>
 #include <stdlib.h>
-
-#include <align.h>
-#include <macros.h>
 
 /** Check the condition if wchar_t is signed */
@@ -622 +616 @@
 }
 
-/** Convert wide string to string.
- *
- * Convert wide string @a src to string. The output is written to the buffer
- * specified by @a dest and @a size. @a size must be non-zero and the string
- * written will always be well-formed.
- *
- * @param dest  Destination buffer.
- * @param size  Size of the destination buffer.
- * @param src   Source wide string.
- */
-void wstr_to_str(char *dest, size_t size, const wchar_t *src)
-{
-        wchar_t ch;
-        size_t src_idx;
-        size_t dest_off;
-
-        /* There must be space for a null terminator in the buffer. */
-        assert(size > 0);
-
-        src_idx = 0;
-        dest_off = 0;
-
-        while ((ch = src[src_idx++]) != 0) {
-                if (chr_encode(ch, dest, &dest_off, size - 1) != EOK)
-                        break;
-        }
-
-        dest[dest_off] = '\0';
-}
-
-/** Find first occurence of character in string.
- *
- * @param str String to search.
- * @param ch  Character to look for.
- *
- * @return Pointer to character in @a str or NULL if not found.
- */
-char *str_chr(const char *str, wchar_t ch)
-{
-        wchar_t acc;
-        size_t off = 0;
-        size_t last = 0;
-
-        while ((acc = str_decode(str, &off, STR_NO_LIMIT)) != 0) {
-                if (acc == ch)
-                        return (char *) (str + last);
-                last = off;
-        }
-
-        return NULL;
-}
-
-/** Insert a wide character into a wide string.
- *
- * Insert a wide character into a wide string at position
- * @a pos. The characters after the position are shifted.
- *
- * @param str     String to insert to.
- * @param ch      Character to insert to.
- * @param pos     Character index where to insert.
- * @param max_pos Characters in the buffer.
- *
- * @return True if the insertion was sucessful, false if the position
- *         is out of bounds.
- *
- */
-bool wstr_linsert(wchar_t *str, wchar_t ch, size_t pos, size_t max_pos)
-{
-        size_t len = wstr_length(str);
-
-        if ((pos > len) || (pos + 1 > max_pos))
-                return false;
-
-        size_t i;
-        for (i = len; i + 1 > pos; i--)
-                str[i + 1] = str[i];
-
-        str[pos] = ch;
-
-        return true;
-}
-
-/** Remove a wide character from a wide string.
- *
- * Remove a wide character from a wide string at position
- * @a pos. The characters after the position are shifted.
- *
- * @param str String to remove from.
- * @param pos Character index to remove.
- *
- * @return True if the removal was sucessful, false if the position
- *         is out of bounds.
- *
- */
-bool wstr_remove(wchar_t *str, size_t pos)
-{
-        size_t len = wstr_length(str);
-
-        if (pos >= len)
-                return false;
-
-        size_t i;
-        for (i = pos + 1; i <= len; i++)
-                str[i - 1] = str[i];
-
-        return true;
-}
-
 /** Duplicate string.
  *
@@ -789 +675 @@
         str_ncpy(dest, size + 1, src, size);
         return dest;
+}
+
+/** Convert wide string to string.
+ *
+ * Convert wide string @a src to string. The output is written to the buffer
+ * specified by @a dest and @a size. @a size must be non-zero and the string
+ * written will always be well-formed.
+ *
+ * @param dest  Destination buffer.
+ * @param size  Size of the destination buffer.
+ * @param src   Source wide string.
+ */
+void wstr_to_str(char *dest, size_t size, const wchar_t *src)
+{
+        wchar_t ch;
+        size_t src_idx;
+        size_t dest_off;
+
+        /* There must be space for a null terminator in the buffer. */
+        assert(size > 0);
+
+        src_idx = 0;
+        dest_off = 0;
+
+        while ((ch = src[src_idx++]) != 0) {
+                if (chr_encode(ch, dest, &dest_off, size - 1) != EOK)
+                        break;
+        }
+
+        dest[dest_off] = '\0';
+}
+
+/** Find first occurence of character in string.
+ *
+ * @param str String to search.
+ * @param ch  Character to look for.
+ *
+ * @return Pointer to character in @a str or NULL if not found.
+ *
+ */
+char *str_chr(const char *str, wchar_t ch)
+{
+        wchar_t acc;
+        size_t off = 0;
+        size_t last = 0;
+
+        while ((acc = str_decode(str, &off, STR_NO_LIMIT)) != 0) {
+                if (acc == ch)
+                        return (char *) (str + last);
+                last = off;
+        }
+
+        return NULL;
+}
+
+/** Insert a wide character into a wide string.
+ *
+ * Insert a wide character into a wide string at position
+ * @a pos. The characters after the position are shifted.
+ *
+ * @param str     String to insert to.
+ * @param ch      Character to insert to.
+ * @param pos     Character index where to insert.
+ * @param max_pos Characters in the buffer.
+ *
+ * @return True if the insertion was sucessful, false if the position
+ *         is out of bounds.
+ *
+ */
+bool wstr_linsert(wchar_t *str, wchar_t ch, size_t pos, size_t max_pos)
+{
+        size_t len = wstr_length(str);
+
+        if ((pos > len) || (pos + 1 > max_pos))
+                return false;
+
+        size_t i;
+        for (i = len; i + 1 > pos; i--)
+                str[i + 1] = str[i];
+
+        str[pos] = ch;
+
+        return true;
+}
+
+/** Remove a wide character from a wide string.
+ *
+ * Remove a wide character from a wide string at position
+ * @a pos. The characters after the position are shifted.
+ *
+ * @param str String to remove from.
+ * @param pos Character index to remove.
+ *
+ * @return True if the removal was sucessful, false if the position
+ *         is out of bounds.
+ *
+ */
+bool wstr_remove(wchar_t *str, size_t pos)
+{
+        size_t len = wstr_length(str);
+
+        if (pos >= len)
+                return false;
+
+        size_t i;
+        for (i = pos + 1; i <= len; i++)
+                str[i - 1] = str[i];
+
+        return true;
+}
+
+/** 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;
 }