#include <stdlib.h>
#include <windows.h>


int isspace(int c) {
	if ((c >= 0x09) && (c <= 0x0D)) return 1;
	else if (c == 0x20) return 1;
	return 0;
}

int isdigit(int c) {
	if ((c >= '0') && (c <= '9')) return 1;
	else return 0;
}

int isxdigit(int c) {
	if ((c >= '0') && (c <= '9')) return 1;
	else if ((c >= 'a') && (c <= 'f')) return 1;
	else if ((c >= 'A') && (c <= 'F')) return 1;
	else return 0;
}

int isalpha(int c) {
	if ((c >= 'a') && (c <= 'z')) return 1;
	else if ((c >= 'A') && (c <= 'Z')) return 1;
	else return 0;
}

int isalnum(int c) {
	if ((c >= '0') && (c <= '9')) return 1;
	else if ((c >= 'a') && (c <= 'z')) return 1;
	else if ((c >= 'A') && (c <= 'Z')) return 1;
	else return 0;
}

static int checkDigit(char ch, int base) {
	int n;

	if (ch >= '0' && ch <= '9') n = ch - '0';
	else if (ch >= 'a' && ch <= 'z') n = ch + 10 - 'a';
	else if (ch >= 'A' && ch <= 'Z') n = ch + 10 - 'A';
	else return -1;

	return n >= base ? -1 : n;
}

long strtol(const char *s, char **endptr, int base) {
	const char *sc;
	char sign;
	int actualbase;
	double result;

	/* if the base is illegal, then return 0; */
	if (! (base >= 2 && base <= 36) ){
		if (endptr) *endptr = (char *)s;
		return 0;
	}

	/* skip leading spaces */
 	for (sc = s; *sc == ' '; ++sc);

	/* parse the sign */
	if (*sc == '-' || *sc == '+') {
		sign = *sc;
		sc++;
	}
	else {
		sign = '+';
	}

	/* the default base = 10 */
	actualbase = base == 0 ? 10 : base;

	/* if base is undefined, and number starts '0x', then we have base 16 */
	if (base == 0 && sc[0] == '0' && (sc[1] == 'x' || sc[1] == 'X')) { actualbase = 16; sc += 2; }

	/* else if base is undefined, and number starts '0', then we have base 8 */
	else if (base == 0 && sc[0] == '0') actualbase = 8;

	/* else if base == 16, then skip any leading '0x' */
	else if (base == 16 && sc[0] == '0' && (sc[1] == 'x' || sc[1] == 'X')) sc += 2;

	/* skip leading zeroes */
	for (; *sc == '0'; ++sc);

	/* the result so far is 0. We are going to work with doubles because these give 52 bits of accuracy */
	result = 0.0;

	/* sc now points to the first unprocessed digit. Keep processing until first non digit or overflow */
	for (;;) {
		int d = checkDigit(*sc, actualbase);

		/* if the digit was illegal, then we have terminated */
		if (d < 0) {
			if (endptr) *endptr = (char *)sc;
			return sign == '-' ? -(long)result : (long)result;
		}

		/* roll in the new digit */
		result = result * actualbase + d;

		/* check for overflow */
		if (sign == '+' && result > (double)LONG_MAX) {
			if (endptr) *endptr = (char *)(sc+1);
			return LONG_MAX;
		}
		if (sign == '-' && result > -(double)LONG_MIN) {
			if (endptr) *endptr = (char *)(sc+1);
			return LONG_MIN;
		}

		/* go on to the next character */
		sc++;
	}
}

/*
 *  Implement rename and unlink in win32 procedures. This is complicated
 *  by the fact that these procedures take wide chars.
 */

#define MAX_FILENAME_LEN           128

int rename(const char *oldname, const char *newname) {
	int succ;
	short soldname[MAX_FILENAME_LEN];
	short snewname[MAX_FILENAME_LEN];

	MultiByteToWideChar(CP_ACP, 0, oldname, strlen(oldname)+1, soldname, MAX_FILENAME_LEN);
	MultiByteToWideChar(CP_ACP, 0, newname, strlen(newname)+1, snewname, MAX_FILENAME_LEN);
	succ = MoveFile(soldname, snewname);
	return !succ;
}

int unlink(char *name) {
	int succ;
	short wname[MAX_FILENAME_LEN];

	MultiByteToWideChar(CP_ACP, 0, name, strlen(name)+1, wname, MAX_FILENAME_LEN);

	succ = DeleteFile(wname);
	return !succ;
}

void *calloc(size_t nelem, size_t size) {
	const size_t n = nelem*size;
	char *p = malloc(n);

	if (p) memset(p, '\0', n);
	return p;
}