#include "memory.h"
#include <lib.h>
#include <stddef.h>

int memcmp(const void *restrict vl, const void *restrict vr, unsigned long n) {
	const unsigned char *l = vl, *r = vr;
	for (; n && *l == *r; n--, l++, r++);
	return n ? *l-*r : 0;
}

void *memcpy(void *restrict dest, const void *restrict src, unsigned long n) {
	char *d = dest;
	const char *s = src;
	for (; n; n--) *d++ = *s++;
	return dest;
}

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

	if (d==s) return d;

	if (d<s) {
		for (; n; n--) *d++ = *s++;
	} else {
		while (n) n--, d[n] = s[n];
	}

	return dest;
}

void *memset(void *restrict dest, int c, unsigned long n) {

	unsigned char *d = dest;
	for (; n; n--) *d++ = c;
	return dest;
}

int strncmp(const char *restrict lhs, const char *restrict rhs, unsigned long n) {
	const unsigned char *l=(void *)lhs, *r=(void *)rhs;
	if (!n--) return 0;
	for (; *l && *r && n && *l == *r ; l++, r++, n--);
	return *l - *r;
}

char *strcpy(char *restrict dest, const char *restrict src) {
	for(; (*dest = *src); dest++, src++);
	return dest;
}

char *strncpy(char *restrict dest, const char *restrict src, unsigned long n) {
	for(; (*dest = *src) && n; dest++, src++, n--);
	memset(dest, 0, n);
	return dest;
}

size_t strlen(const char *str) {
	const char *p;
	for(p = str; *p != 0; p++) {}
	return p - str;
}

char *strcat(char *restrict dst, const char *restrict src) {
	strcpy(dst + strlen(dst), src);
	return dst;
}

int isspace(int c) {
	switch (c) {
		case ' ':
		case '\t':
		case '\v':
		case '\f':
		case '\r':
		case '\n':
			return 1;
		default:
			return 0;
	}
}

int isdigit(int c) {
	return c - '0' > -1 && c - '0' < 10;
}


#define ATOX(name, type) \
	type name(const char* s) { \
		for(; isspace(*s); s++); \
		int neg = 0; \
		switch (*s) { \
			case '-': \
				neg = 1; \
				/* FALLTHRU */ \
			case '+': \
				s++; \
				break; \
		} \
		type num = 0; \
		for (; *s == '0'; s++); \
		for (; isdigit(*s); s++) { \
			num *= 10; \
			num += *s - '0'; \
		} \
		return num * (neg ? -1 : 1); \
	}

ATOX(atoi, int)
ATOX(atol, long int)
ATOX(atoll, long long int)

char itoc(int i) {
	if(i < 10) {
		return '0' + i;
	} else {
		return 'a' + (i - 10);
	}
}

int ctoi(char c) {
	if(c < 'A') {
		return c - '0';
	} else if(c < 'a') {
		return c - 'A' + 10;
	} else {
		return c - 'a' + 10;
	}
}

#define UXTOA(type, name) \
	char *name(unsigned type n, char *buffer, int radix) { \
		if (n == 0) { \
			buffer[0] = '0'; \
			buffer[1] = '\0'; \
			return buffer; \
		} \
		char *start = buffer; \
		for (; n; n /= radix) { \
			*buffer++ = itoc(n % radix); \
		} \
		*buffer-- = '\0'; \
		while(buffer > start) { \
			char tmp = *start; \
			*start++ = *buffer; \
			*buffer-- = tmp; \
		} \
		return buffer; \
	}

UXTOA(int, utoa)
UXTOA(long int, ultoa)
UXTOA(long long int, ulltoa)

#define XTOA(type, name) \
	char *name(type n, char* buffer, int radix) { \
		if (n == 0) { \
			buffer[0] = '0'; \
			buffer[1] = '\0'; \
			return buffer; \
		} \
		if (n < 0) { \
			*buffer++ = '-'; \
			n = -n; \
		} \
		char *start = buffer; \
		for (; n; n /= radix) { \
			*buffer++ = itoc(n % radix); \
		} \
		*buffer-- = '\0'; \
		while(buffer > start) { \
			char tmp = *start; \
			*start++ = *buffer; \
			*buffer-- = tmp; \
		} \
		return buffer; \
	}

XTOA(int, itoa)
XTOA(long int, ltoa)
XTOA(long long int, lltoa)

#define STRTOX(name, type) \
	type name(const char *s, char **endptr, int radix) { \
		*endptr = NULL; \
		for(; isspace(*s); s++); \
		int neg = 0; \
		switch (*s) { \
			case '-': \
				neg = 1; \
				/* FALLTHRU */ \
			case '+': \
				s++; \
				break; \
		} \
		if (!radix) { \
			if (*s == '0') { \
				s++; \
				if (*s == 'x' || *s == 'X') { \
					s++; \
					radix = 16; \
				} else { \
					radix = 8; \
				} \
			} else { \
				radix = 10; \
			} \
		} \
		for (; *s == '0'; s++, *endptr = (void*) s); \
		type num = 0; \
		for (; isdigit(*s); s++, *endptr = (void*) s) { \
			num *= radix; \
			num += *s - '0'; \
		} \
		return num * (neg ? -1 : 1); \
	}

STRTOX(strtoi, int)
STRTOX(strtol, long int)
STRTOX(strtoll, long long int)