#include "pch.h"
#include "str.h"

/*
 * Copyright (c) 1998, 2015 Todd C. Miller <millert@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
/*
 * strlcpy implementation
 *
 * Copies string src to buffer dest of size n.  At most n-1 chars will be
 * copied.  Always NUL terminates (unless n == 0).
 *
 * Returns strlen(src).  If retval >= n, then truncation occurred.
 */
size_t
str_copy(char *restrict dest, const char *restrict src, size_t n)
{
    const char *osrc;
    size_t nleft;

    osrc = src;
    nleft = n;

    /* Copy as many bytes as will fit. */
    if (nleft != 0)
    {
        while (--nleft != 0)
        {
            if ((*dest++ = *src++) == '\0')
                break;
        }
    }

    /* Not enough room in dest, add NUL and traverse rest of src. */
    if (nleft == 0)
    {
        if (n != 0)
            *dest = '\0'; /* NUL-terminate dest */

        while (*src++)
            ;
    }

    return (src - osrc - 1); /* Returned count does not include NUL */
}

/* strlcpy adapted to be similar to stpncpy
 *
 * Returns pointer to the null-termination character. */
char *
str_pcopy(char *restrict dest, const char *restrict src, size_t n)
{
    const char *osrc;
    size_t nleft;

    osrc = src;
    nleft = n;

    /* Copy as many bytes as will fit. */
    if (nleft != 0)
    {
        while (--nleft != 0)
        {
            if ((*dest++ = *src++) == '\0')
                break;
        }
    }

    /* Not enough room in dest, add NUL and traverse rest of src. */
    if (nleft == 0)
    {
        if (n != 0)
            *dest = '\0'; /* NUL-terminate dest */

        while (*src++)
            ;
    }

    return dest;
}

/* Calculates length (in bytes) of initial segment of s up to n bytes which
 * consists entirely of bytes in accept */
size_t
str_spn(const char *restrict s, const char *restrict accept, size_t n)
{
    ASSERT(accept[0] != '\0' && "stupid use of str_spn");

    const char *a;
    size_t count;
    bool found;

    for (count = 0; count < n && *s != '\0'; ++count)
    {
        found = false;

        for (a = accept; *a != '\0'; ++a)
        {
            if (s[count] == *a)
            {
                found = true; /* found an accepted char */
                break;
            }
        }

        if (!found)
            break;
    }

    return count;
}

/* Calculates length (in bytes) of initial segment of s up to n bytes which
 * consists entirely of bytes not in reject */
size_t
str_cspn(const char *restrict s, const char *restrict reject, size_t n)
{
    ASSERT(reject[0] != '\0' && "stupid use of str_cspn");
    ASSERT(reject[1] != '\0' && "consider str_ichr instead");

    const char *r;
    size_t count;
    bool found;

    for (count = 0; count < n && *s != '\0'; ++count)
    {
        found = false;

        for (r = reject; *r != '\0'; ++r)
        {
            if (s[count] != *r)
            {
                found = true; /* found a rejected char */
                break;
            }
        }

        if (!found)
            break;
    }

    return count;
}

int
strz_ichr(const char *s, char c)
{
    int count;

    for (count = 0; s[count] != c; ++count)
        ;

    return count;
}

char *
strz_chr(char *s, char c)
{
    for (; *s != c; ++s)
        ;

    return s;
}

int
str_ichr(const char *s, char c, size_t n)
{
    int count;

    for (count = 0; count < n && s[count] != c; ++count)
        ;

    return count;
}

char *
str_chr(char *s, char c, size_t n)
{
    int count;

    for (count = 0; count < n && s[count] != c; ++count)
        ;

    return s + count;
}

long
str_tol(const char *buf, size_t n) /* spaces, signs, and digits */
{
    /* https://stackoverflow.com/a/17002450 */

    long x = 0, sign = +1;

    /* Move over any preceding spaces */
    for (; n > 0 && isspace(*buf); --n, ++buf);

    /* Parse sign */
    if (n > 0)
    {
        switch(*buf)
        {
        case '-':
            sign = -1;
            /* fall through */
        case '+':
            --n;
            ++buf;
        }
    }

    /* Parse digits */
    for (; n && isdigit(*buf); --n, ++buf)
        x = x * 10 + *buf - '0';

    return x * sign;
}