Přidány další funkce pro práci se stringem

include/string.h

@@ -22,4 +22,14 @@ int aster_strncmp(const char *a, const char *b, usize n);
 void *aster_memcpy(void *dst, const void *src, usize n);
 void *aster_memset(void *dst, int v, usize n);
 
+char *aster_strstr(const char *haystack, const char *needle);
+char *aster_trim(char *str);
+int aster_substring(char *dst, usize dstsize, const char *src, usize start, usize length);
+char *aster_remove(char *str, const char *substr);
+int aster_split(char *str, const char *delim, char **tokens, usize max_tokens);
+int aster_contains(const char *str, const char *substr);
+int aster_starts_with(const char *str, const char *prefix);
+int aster_ends_with(const char *str, const char *suffix);
+char *aster_strcpy(char *dst, const char *src);
+
 #endif

kernel/string.c

@@ -13,6 +13,15 @@
 
 #include "string.h"
 
+#ifndef NULL
+#define NULL ((void *)0)
+#endif
+
+static inline int aster_isspace(char c) {
+    return (c == ' ' || c == '\t' || c == '\n' ||
+            c == '\r' || c == '\v' || c == '\f');
+}
+
 usize aster_strlen(const char *s) {
     usize n = 0;
     while (s && s[n]) {
@@ -63,3 +72,163 @@ void *aster_memset(void *dst, int v, usize n) {
 
     return dst;
 }
+
+char *aster_strcpy(char *dst, const char *src) {
+    char *d = dst;
+    while ((*d++ = *src++) != '\0')
+        ;
+    return dst;
+}
+
+char *aster_strstr(const char *haystack, const char *needle) {
+    if (!*needle)
+        return (char *)haystack;
+
+    while (*haystack) {
+        const char *h = haystack;
+        const char *n = needle;
+        while (*h && *n && (*h == *n)) {
+            ++h;
+            ++n;
+        }
+        if (!*n)
+            return (char *)haystack;
+        ++haystack;
+    }
+    return NULL;
+}
+
+char *aster_trim(char *str) {
+    if (!str)
+        return NULL;
+
+    while (*str && aster_isspace(*str))
+        ++str;
+
+    char *end = str;
+    while (*end)
+        ++end;
+    while (end > str && aster_isspace(*(end - 1)))
+        --end;
+    *end = '\0';
+
+    return str;
+}
+
+int aster_substring(char *dst, usize dstsize, const char *src,
+                    usize start, usize length) {
+    if (!dst || dstsize == 0 || !src)
+        return -1;
+
+    usize srclen = aster_strlen(src);
+    if (start >= srclen) {
+        dst[0] = '\0';
+        return 0;
+    }
+
+    usize max_copy = srclen - start;
+    if (length > max_copy)
+        length = max_copy;
+    if (length >= dstsize)
+        length = dstsize - 1;
+
+    for (usize i = 0; i < length; ++i)
+        dst[i] = src[start + i];
+    dst[length] = '\0';
+    return (int)length;
+}
+
+char *aster_remove(char *str, const char *substr) {
+    if (!str || !substr || !*substr)
+        return str;
+
+    usize sublen = aster_strlen(substr);
+    char *src = str;
+    char *dst = str;
+
+    while (*src) {
+        const char *s = src;
+        const char *sub = substr;
+        while (*s && *sub && (*s == *sub)) {
+            ++s;
+            ++sub;
+        }
+        if (!*sub) {
+            src += sublen;
+        } else {
+            *dst++ = *src++;
+        }
+    }
+    *dst = '\0';
+    return str;
+}
+
+int aster_split(char *str, const char *delim, char **tokens, usize max_tokens) {
+    if (!str || !delim || !*delim)
+        return -1;
+
+    usize delim_len = aster_strlen(delim);
+    int count = 0;
+    char *scan = str;
+
+    if (!tokens) {
+        if (*scan == '\0')
+            return 0;
+        while (*scan) {
+            if (count == 0) {
+                ++count;
+            }
+            char *found = aster_strstr(scan, delim);
+            if (found) {
+                ++count;
+                scan = found + delim_len;
+            } else {
+                break;
+            }
+        }
+        return count;
+    }
+
+    while (*scan && (usize)count < max_tokens) {
+        tokens[count++] = scan;
+        char *found = aster_strstr(scan, delim);
+        if (found) {
+            *found = '\0';
+            scan = found + delim_len;
+        } else {
+            break;
+        }
+    }
+
+    if (*scan && (usize)count < max_tokens) {
+        tokens[count++] = scan;
+    }
+
+    return count;
+}
+
+int aster_contains(const char *str, const char *substr) {
+    return aster_strstr(str, substr) != NULL;
+}
+
+int aster_starts_with(const char *str, const char *prefix) {
+    if (!str || !prefix)
+        return 0;
+    while (*prefix) {
+        if (*str != *prefix)
+            return 0;
+        ++str;
+        ++prefix;
+    }
+    return 1;
+}
+
+int aster_ends_with(const char *str, const char *suffix) {
+    if (!str || !suffix)
+        return 0;
+    usize str_len = aster_strlen(str);
+    usize suffix_len = aster_strlen(suffix);
+    if (suffix_len > str_len)
+        return 0;
+    return aster_strcmp(str + str_len - suffix_len, suffix) == 0;
+}