#include "milkwayint.h"

#include <stdlib.h>
#include <stdarg.h>

char*
mw_strdup(const char *s)
{
    char *r;

    if (!s)
	return NULL;

    r = malloc(strlen(s) + 1);
    if (!r)
	return NULL;

    return strcpy(r, s);
}

char *
mw_stpcpy (char * dst, const char * src)
{
    do {
        *dst++ = *src;
    } while (*src++);

    return dst - 1;
}

int
mw_strnlen (const char * s, mw_size_t max)
{
    const char * p = s;

    while (max && *p) {
        ++p;
        --max;
    }

    return p - s;
}

char *
mw_strndup (char * src, mw_size_t size)
{
    char * new;
    mw_size_t len;

    len = mw_strnlen (src, size);
    new = malloc (len + 1);
    if (!new)
        return NULL;

    memcpy (new, src, len);
    new[len] = '\0';
    return new;
}

size_t
mw_strlcpy (char        * dst,
           const char  * src,
           mw_size_t      size)
{
    char * d = dst;
    const char * s = src;
    mw_size_t n = size;

    if (!dst || !src)
        return 0;

    if (n && --n) {
        do {
            char c = *s++;

            *d++ = c;
            if (c == '\0')
                break;
        } while (--n);
    }

    if (!n) {
        if (size)
            *d = 0;
        while (*s++)
            ;
    }

    return s - src - 1;
}

size_t
mw_strlcat (char       * dst,
           const char * src,
           mw_size_t     size)
{
    char * d = dst;
    const char * s = src;
    mw_size_t left = size;
    mw_size_t dlen;

    if (!dst || ! src)
        return 0;

    while (*d && left--)
        d++;
    dlen = d - dst;
    left = size - dlen;

    if (!left)
        return dlen + strlen (s);

    while (*s) {
        if (left != 1) {
            *d++ = *s;
            left--;
        }
        s++;
    }
    *d = 0;

    return dlen + (s - src);
}

int
mw_strcmp (const char * s1, const char * s2)
{
#if defined(HAVE_STRCMP)
    return strcmp (s1, s2);
#else
    for (; *s1 && *s2; s1++, s2++) {
        if (*s1 != *s2)
            return *s1 - *s2;
    }

    return (int)(s1 - s2);
#endif
}

int
mw_strcasecmp (const char * s1, const char * s2)
{
#if defined(HAVE_STRCASECMP)
    return strcasecmp (s1, s2);
#elif defined(HAVE_STRICMP)
    return stricmp (s1, s2);
#else
    for (; *s1 && *s2; s1++, s2++) {
        mw_int_t c1;
        mw_int_t c2;

        c1 = mw_tolower (*s1);
        c2 = mw_tolower (*s2);
        if (c1 != c2)
            return c1 - c2;
    }

    return (int)(s1 - s2);
#endif
}

char *
mw_strbuild (const char * s, ...)
{
    va_list args;
    mw_size_t len;
    char * next;
    char * new;
    char * result;

    if (!s)
        return NULL;

    len = strlen (s) + 1;
    va_start (args, s);
    for (next = va_arg (args, char *); next;
         next = va_arg (args, char *))
        len += strlen (next);
    va_end (args);

    new = malloc (len);
    if (!new)
        return NULL;

    result = mw_stpcpy (new, s);
    va_start (args, s);
    for (next = va_arg (args, char *); next;
         next = va_arg (args, char *))
        result = mw_stpcpy (result, next);
    va_end (args);

    return new;
}

mw_bool_t
mw_str_equal (const mw_pointer_t s1, const mw_pointer_t s2)
{
    return !strcmp (s1, s2);
}

mw_uint_t
mw_str_hash (const mw_pointer_t s)
{
    return mw_mem_hash (s, strlen (s));
}

mw_uint_t
mw_mem_hash (const mw_pointer_t ptr, mw_size_t n)
{
    const mw_uint8_t * key = ptr;
    mw_uint_t hash = 0;
    mw_size_t i;

    for (i = 0; i < n; i++) {
        hash += key[i];
        hash += (hash << 10);
        hash ^= (hash >> 6);
    }

    hash += (hash << 3);
    hash ^= (hash >> 11);
    hash += (hash << 15);
    return hash;
}

void *
mw_memcpy (void * dst, const void * src, mw_size_t n)
{
#ifdef HAVE_MEMCPY
    return memcpy (dst, src, n);
#else
    char * d = dst;
    const char * s = src;

    if (!n)
        return dst;

    while (--n)
        *d++ = *s++;

    return dst;
#endif
}

void *
mw_memmove (void * dst, const void * src, mw_size_t n)
{
#ifdef HAVE_MEMMOVE
    return memmove (dst, src, n);
#else
    char * d = dst;
    const char * s = src;

    if (!n)
        return dst;

    if (dst > src) {
        while (--n)
            *d++ = *s++;
    } else {
        d += n;
        s += n;

        while (--n)
            *d-- = *s--;
    }

    return dst;
#endif
}

mw_bool_t
mw_is_alpha (mw_int_t c)
{
    return (c >= 'a' && c <= 'z') ||
        (c >= 'A' && c <= 'Z');
}

mw_bool_t
mw_is_upper (mw_int_t c)
{
    return c >= 'A' && c <= 'Z';
}

mw_bool_t
mw_is_lower (mw_int_t c)
{
    return c >= 'a' && c <= 'z';
}

mw_bool_t
mw_is_digit (mw_int_t c)
{
    return c >= '0' && c <= '9';
}

mw_bool_t
mw_is_alnum (mw_int_t c)
{
    return mw_is_alpha (c) || mw_is_digit (c);
}

mw_int_t
mw_tolower (mw_int_t c)
{
    if (c >= 'A' && c <= 'Z')
        return 'a' + c - 'A';
    return c;
}

mw_int_t
mw_toupper (mw_int_t c)
{
    if (c >= 'a' && c <= 'z')
        return 'A' + c - 'a';
    return c;
}