string.h

Go to the documentation of this file.

#ifndef _STRING_H
#define _STRING_H
 
#include <core/system.h>
 
/* The kernel's own string and memory functions, as the C library's. */
 
/* Formats a string into a buffer (core/snprintf.c). */
int snprintf(char *s, size_t n, const char *fmt, ...);

static inline void *memmove(void *dest, const void *src, size_t n)
{
    void *_dest = dest;
 
    if ((uintptr_t) dest < (uintptr_t) src) {
        while (n-- != 0)
            *(char *) dest++ = *(char *) src++;
    } else if ((uintptr_t) dest > (uintptr_t) src) {
        while (n != 0) {
            --n;
            *((char *) dest + n) = *((char *) src + n);
        }
    }
 
    return _dest;
}

static inline void *memcpy(void *dest, const void *src, size_t n)
{
    void *_dest = dest;
    while (n-- != 0)
        *(char *) dest++ = *(char *) src++;
 
    return _dest;
}

static inline void *memset(void *s, int c, size_t n)
{
    void *_s = s;
 
    while (n-- != 0) {
        *(char *) s++ = (char) c;
    }
 
    return _s;
}

static inline int memcmp(const void *s1, const void *s2, size_t n)
{
    const unsigned char *a = s1, *b = s2;
 
    for (; n; --n, ++a, ++b)
        if (*a != *b)
            return *a - *b;
 
    return 0;
}

static inline int strcmp(const char *s1, const char *s2)
{
    while (*s1 != '\0' && *s2 != '\0' && *s1 == *s2) {s1++; s2++;}
 
    return (int)(*s1 - *s2);
}

static inline int strncmp(const char *s1, const char *s2, size_t n)
{
    for (; n != 0; --n, ++s1, ++s2) {
        if (*s1 != *s2)
            return (int) *(const unsigned char *) s1 - (int) *(const unsigned char *) s2;
 
        if (*s1 == '\0')
            break;
    }
 
    return 0;
}

static inline int strlen(const char *s)
{
    const char *_s = s;
    while (*_s) _s++;
    return _s - s;
}

static inline size_t strnlen(const char *s, size_t max)
{
    size_t n = 0;
    while (n < max && s[n]) n++;
    return n;
}

static inline char *strdup(const char *s)
{
    int len = strlen(s);
    char *ret = kmalloc(len + 1, &M_BUFFER, 0);
 
    if (!ret)
        return NULL;
 
    (void) memcpy(ret, s, len + 1);
    return ret;
}

static inline char *strcpy(char *dst, const char *src)
{
    char *retval = dst;
    
    while (*src != '\0')
        *dst++ = *src++;
 
    *dst = *src;    /* the NUL */
 
    return retval;
}

static inline char *stpcpy(char *dst, const char *src)
{
    while ((*dst = *src++))
        ++dst;
 
    return dst;
}

static inline char **tokenize(const char *s, char c)
{
    if (s == NULL || *s == '\0')
        return NULL;
 
    while (*s == c)
        ++s;
 
    char *tokens = strdup(s);
 
    if (tokens == NULL)
        return NULL;
 
    int len = strlen(s);
 
    if (!len) {
        /* nothing but separators: no pieces */
        kfree(tokens);
 
        char **ret = kmalloc(sizeof(char *), &M_BUFFER, 0);
 
        if (ret)
            *ret = NULL;
 
        return ret;
    }
 
    int i, count = 0;
    for (i = 0; i < len; ++i) {
        if (tokens[i] == c) {
            tokens[i] = 0;
            ++count;
        }
    }
 
    if (s[len-1] != c)
        ++count;
    
    char **ret = kmalloc(sizeof(char *) * (count + 1), &M_BUFFER, 0);
 
    if (!ret) {
        kfree(tokens);
        return NULL;
    }
 
    int j = 0;
    ret[j++] = tokens;
 
    for (i = 0; i < strlen(s) - 1; ++i)
        if (tokens[i] == 0)
            ret[j++] = &tokens[i+1];
 
    ret[j] = NULL;
 
    return ret;
}

static inline void free_tokens(char **ptr)
{
    if (!ptr) return;
    if (*ptr)
        kfree(*ptr);
    kfree(ptr);
}
 
#endif /* !_STRING_H */