/* $Id$ */
/* Copyright (c) 2004-2019 Pierre Pronchery <khorben@defora.org> */
/* This file is part of DeforaOS System libc */
/* All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */



#include "stdlib.h"
#include "stdio.h"
#include "string.h"
#include "errno.h"

#ifndef max
# define max(a, b) ((a) > (b) ? (a) : (b))
#endif


/* memchr */
void * memchr(void const * s, int c, size_t n)
{
	unsigned char const * ls;
	unsigned char lc = c;

	for(ls = s; n--; ls++)
		if(*ls == lc)
			return (void *)ls;
	return NULL;
}


/* memcmp */
int memcmp(void const * s1, void const * s2, size_t n)
{
	unsigned char const * u1 = s1;
	unsigned char const * u2 = s2;

	if(n == 0)
		return 0;
	while(--n && *u1 == *u2)
	{
		u1++;
		u2++;
	}
	return *u1 - *u2;
}


/* memcpy */
void * memcpy(void * dest, void const * src, size_t n)
{
	char * d = dest;
	char const * s = src;

	while(n--)
		*d++ = *s++;
	return dest;
}


/* memmove */
void * memmove(void * dest, void const * src, size_t n)
{
	char * d = dest;
	char const * s = src;

	if(n == 0 || dest == src)
		return dest;
	if(d + n < s || d > s + n)
		return memcpy(dest, src, n);
	if(s < d)
	{
		d += n - 1;
		s += n - 1;
		while(n--)
			*d-- = *s--;
		return dest;
	}
	return memcpy(dest, src, n);
}


/* memset */
void * memset(void * dest, int c, size_t n)
{
	unsigned char * d = dest;

	while(n--)
		*d++ = c;
	return dest;
}


/* strcat */
char * strcat(char * dest, char const * src)
{
	char * ret = dest;
	
	for(; *dest; dest++);
	while(*src)
		*(dest++) = *(src++);
	*dest = '\0';
	return ret;
}


/* strchr */
char * strchr(char const * s, int c)
{
	unsigned char const * ls;
	unsigned char lc = c;

	for(ls = (unsigned char const *)s; *ls != '\0'; ls++)
		if(*ls == lc)
			return (char *)ls;
	return (lc == '\0') ? (char *)ls : NULL;
}


/* strcmp */
int strcmp(char const * s1, char const * s2)
{
	unsigned char const * u1;
	unsigned char const * u2;

	u1 = (unsigned char const *)s1;
	u2 = (unsigned char const *)s2;
	while(*u1 && *u2 && *u1 == *u2)
	{
		u1++;
		u2++;
	}
	return *u1 - *u2;
}


/* strcoll */
int strcoll(char const * s1, char const * s2)
{
	return strcmp(s1, s2);
}


/* strcpy */
char * strcpy(char * dest, char const * src)
{
	char * ret = dest;

	while((*dest++ = *src++));
	return ret;
}


/* strcspn */
size_t strcspn(char const * s1, char const * s2)
{
	unsigned int ret = 0;
	unsigned int len = 0;
	unsigned int i;

	for(; *s1 != '\0'; s1++)
	{
		len++;
		for(i = 0; s2[i] != '\0'; i++)
			if(*s1 == s2[i])
			{
				ret = max(ret, len);
				len = -1;
				break;
			}
	}
	return ret;
}


/* strdup */
char * strdup(char const * s)
{
	size_t len;
	char * str;

	if((len = strlen(s) + 1) == 0)
	{
		errno = ENOMEM;
		return NULL;
	}
	if((str = malloc(sizeof(char) * len)) == NULL)
		return NULL;
	strcpy(str, s);
	return str;
}


/* strerror */
char * strerror(int errnum)
{
	static char ret[256];

	if(strerror_r(errnum, ret, sizeof(ret)) != 0)
		errno = EINVAL;
	return ret;
}


/* strerror_r */
int strerror_r(int errnum, char * strerrbuf, size_t buflen)
{
	static const struct
	{
		const int errnum;
		const char * errmsg;
	} err[] =
	{
		{ 0,		"Success"				},
		{ E2BIG,	"Argument list too long"		},
		{ EACCES,	"Permission denied"			},
		{ EAGAIN,	"Resource temporarily unavailable"	},
		{ EBADF,	"Bad file descriptor"			},
		{ EBUSY,	"Device or resource busy"		},
		{ ECHILD,	"No child processes"			},
		{ EEXIST,	"File exists"				},
		{ EFAULT,	"Bad address"				},
		{ EINTR,	"Interrupted system call"		},
		{ EINVAL,	"Invalid argument"			},
		{ EISDIR,	"Is a directory"			},
		{ ENOBUFS,	"No buffer space available"		},
		{ ENODEV,	"No such device"			},
		{ ENOENT,	"No such file or directory"		},
		{ ENOEXEC,	"Exec format error"			},
		{ ENOMEM,	"Not enough memory"			},
		{ ENOSYS,	"Not implemented"			},
		{ ENOTDIR,	"Not a directory"			},
		{ ENOTSUP,	"Operation not supported"		},
		{ ENOTTY,	"Inappropriate ioctl for device"	},
		{ ENXIO,	"Device not configured"			},
		{ EPERM,	"Permission denied"			},
		{ EPIPE,	"Broken pipe"				},
		{ ERANGE,	"Result too large or too small"		},
		{ EROFS,	"Read-only filesystem"			},
#ifdef ESRCH
		{ ESRCH,	"No such process"			},
#endif
		{ EXDEV,	"Cross-device link"			},
		{ -1,		NULL					}
	};
	unsigned int i;
	int j;

	for(i = 0; err[i].errmsg != NULL; i++)
		if(err[i].errnum == errnum)
		{
			strncpy(strerrbuf, err[i].errmsg, buflen - 1);
			strerrbuf[buflen - 1] = '\0';
			j = snprintf(strerrbuf, buflen, "%s", err[i].errmsg);
			if(j < 0 || (unsigned)j >= buflen)
				return ERANGE;
			return 0;
		}
	j = snprintf(strerrbuf, buflen, "%s%d", "Unknown error: ", errnum);
	if(j < 0 || (unsigned)j >= buflen)
		return ERANGE;
	return EINVAL;
}


/* strlen */
size_t strlen(char const * s)
{
	size_t len = 0;

	while(*s++)
		len++;
	return len;
}


/* strncat */
char * strncat(char * dest, char const * src, size_t n)
{
	char * ret = dest;

	for(; *dest; dest++);
	while(n-- && *src)
		*(dest)++ = *(src++);
	*dest = '\0';
	return ret;
}


/* strncmp */
int strncmp(char const * s1, char const * s2, size_t n)
{
	unsigned char const * u1;
	unsigned char const * u2;

	u1 = (unsigned char const *)s1;
	u2 = (unsigned char const *)s2;
	while(--n && *u1 && *u2 && *u1 == *u2)
	{
		u1++;
		u2++;
	}
	return *u1 - *u2;
}


/* strncpy */
char * strncpy(char * dest, char const * src, size_t n)
{
	char * d;

	for(d = dest; n > 0; n--)
		if(*src != '\0')
			*(d++) = *(src++);
		else
			/* pad the remainder of dest */
			*(d++) = '\0';
	return dest;
}


/* strnlen */
size_t strnlen(char const * s, size_t max)
{
	size_t len = 0;

	while(*(s++) && len < max)
		len++;
	return len;
}


/* strpbrk */
char * strpbrk(char const * s1, char const * s2)
{
	char const * p;
	char const * q;

	for(p = s1; *p != '\0'; p++)
		for(q = s2; *q != '\0'; q++)
			if(*p == *q)
				return (char *)p;
	return NULL;
}


/* strrchr */
char * strrchr(char const * s, int c)
{
	unsigned char const * ret = NULL;
	unsigned char const * ls;
	unsigned char lc = c;

	for(ls = (unsigned char const *)s; *ls != '\0'; ls++)
		if(*ls == lc)
			ret = ls;
	return (char *)((lc == '\0') ? ls : ret);
}


/* strspn */
size_t strspn(char const * s1, char const * s2)
	/* FIXME not tested */
{
	size_t i;
	char const * p;

	for(i = 0;; i++)
	{
		for(p = s2; *p != '\0' && s1[i] != *p; p++);
		if(*p == '\0')
			break;
	}
	return i;
}


/* strstr */
char * strstr(char const * s1, char const * s2)
{
	size_t len1 = strlen(s1);
	size_t len2 = strlen(s2);
	size_t i;

	if(len2 == 0)
		return (char *)s1; /* XXX */
	if(len1 < len2)
		return NULL;
	for(i = 0; i <= len1 - len2; i++)
		if(strncmp(&s1[i], s2, len2) == 0)
			return (char *)s1 + i; /* XXX */
	return NULL;
}


/* strtok */
char * strtok(char * s1, char const * s2)
{
	static char * s = NULL;
	unsigned int i;
	unsigned int j;

	if(s1 != NULL)
		s = s1;
	for(i = 0; s[i] != '\0'; i++)
	{
		for(j = 0; s2[j] != '\0'; j++)
		{
			if(s[i] == s2[j])
			{
				s+=(i + 1);
				return s - i - 1;
			}
		}
	}
	return NULL;
}


/* strxfrm */
size_t strxfrm(char * s1, char const * s2, size_t n)
{
	int res;

	/* XXX return a copy of the original string */
	if((res = snprintf(s1, n, "%s", s2)) < 0)
		return n;
	return res;
}