#include "ficl.h"

/*
 * a l i g n P t r
 * Aligns the given pointer to FICL_ALIGN address units.
 * Returns the aligned pointer value.
 */
void *
ficlAlignPointer(void *ptr)
{
#if FICL_PLATFORM_ALIGNMENT > 1
	intptr_t p = (intptr_t)ptr;

	if (p & (FICL_PLATFORM_ALIGNMENT - 1))
		ptr = (void *)((p & ~(FICL_PLATFORM_ALIGNMENT - 1)) +
		    FICL_PLATFORM_ALIGNMENT);
#endif
	return (ptr);
}

/*
 * s t r r e v
 */
char *
ficlStringReverse(char *string)
{
	int i = strlen(string);
	char *p1 = string;		/* first char of string */
	char *p2 = string + i - 1;	/* last non-NULL char of string */
	char c;

	if (i > 1) {
		while (p1 < p2) {
			c = *p2;
			*p2 = *p1;
			*p1 = c;
			p1++; p2--;
		}
	}

	return (string);
}

/*
 * d i g i t _ t o _ c h a r
 */
static char digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";

char
ficlDigitToCharacter(int value)
{
	return (digits[value]);
}

/*
 * i s P o w e r O f T w o
 * Tests whether supplied argument is an integer power of 2 (2**n)
 * where 32 > n > 1, and returns n if so. Otherwise returns zero.
 */
int
ficlIsPowerOfTwo(ficlUnsigned u)
{
	int i = 1;
	ficlUnsigned t = 2;

	for (; ((t <= u) && (t != 0)); i++, t <<= 1) {
		if (u == t)
			return (i);
	}

	return (0);
}

/*
 * l t o a
 */
char *
ficlLtoa(ficlInteger value, char *string, int radix)
{
	char *cp = string;
	int sign = ((radix == 10) && (value < 0));
	int pwr;

	FICL_ASSERT(NULL, radix > 1);
	FICL_ASSERT(NULL, radix < 37);
	FICL_ASSERT(NULL, string);

	pwr = ficlIsPowerOfTwo((ficlUnsigned)radix);

	if (sign)
		value = -value;

	if (value == 0)
		*cp++ = '0';
	else if (pwr != 0) {
		ficlUnsigned v = (ficlUnsigned) value;
		ficlUnsigned mask = (ficlUnsigned) ~(-1 << pwr);
		while (v) {
			*cp++ = digits[v & mask];
			v >>= pwr;
		}
	} else {
		ficl2UnsignedQR result;
		ficl2Unsigned v;
		FICL_UNSIGNED_TO_2UNSIGNED((ficlUnsigned)value, v);
		while (FICL_2UNSIGNED_NOT_ZERO(v)) {
			result = ficl2UnsignedDivide(v, (ficlUnsigned)radix);
			*cp++ = digits[result.remainder];
			v = result.quotient;
		}
	}

	if (sign)
		*cp++ = '-';

	*cp++ = '\0';

	return (ficlStringReverse(string));
}

/*
 * u l t o a
 */
char *
ficlUltoa(ficlUnsigned value, char *string, int radix)
{
	char *cp = string;
	ficl2Unsigned ud;
	ficl2UnsignedQR result;

	FICL_ASSERT(NULL, radix > 1);
	FICL_ASSERT(NULL, radix < 37);
	FICL_ASSERT(NULL, string);

	if (value == 0)
		*cp++ = '0';
	else {
		FICL_UNSIGNED_TO_2UNSIGNED(value, ud);
		while (FICL_2UNSIGNED_NOT_ZERO(ud)) {
			result = ficl2UnsignedDivide(ud, (ficlUnsigned)radix);
			ud = result.quotient;
			*cp++ = digits[result.remainder];
		}
	}

	*cp++ = '\0';

	return (ficlStringReverse(string));
}

/*
 * c a s e F o l d
 * Case folds a NULL terminated string in place. All characters
 * get converted to lower case.
 */
char *
ficlStringCaseFold(char *cp)
{
	char *oldCp = cp;

	while (*cp) {
		if (isupper((unsigned char)*cp))
			*cp = (char)tolower((unsigned char)*cp);
		cp++;
	}

	return (oldCp);
}

/*
 * s t r i n c m p
 * (jws) simplified the code a bit in hopes of appeasing Purify
 */
int
ficlStrincmp(char *cp1, char *cp2, ficlUnsigned count)
{
	int i = 0;

	for (; 0 < count; ++cp1, ++cp2, --count) {
		i = tolower((unsigned char)*cp1) - tolower((unsigned char)*cp2);
		if (i != 0)
			return (i);
		else if (*cp1 == '\0')
			return (0);
	}
	return (0);
}

/*
 * s k i p S p a c e
 * Given a string pointer, returns a pointer to the first non-space
 * char of the string, or to the NULL terminator if no such char found.
 * If the pointer reaches "end" first, stop there. Pass NULL to
 * suppress this behavior.
 */
char *
ficlStringSkipSpace(char *cp, char *end)
{
	FICL_ASSERT(NULL, cp);

	while ((cp != end) && isspace((unsigned char)*cp))
		cp++;

	return (cp);
}

void
ficlCompatibilityTextOutCallback(ficlCallback *callback, char *text,
    ficlCompatibilityOutputFunction outputFunction)
{
	char buffer[256];
	char *bufferStop = buffer + sizeof (buffer) - 1;

	if (text == NULL) {
		outputFunction(callback->vm, NULL, 0 /* false */);
		return;
	}

	while (*text) {
		int newline = 0 /* false */;
		char *trace = buffer;
		while ((*text) && (trace < bufferStop)) {
			switch (*text) {
			/* throw away \r */
			case '\r':
				text++;
			continue;
			case '\n':
				text++;
				newline = !0 /* true */;
			break;
			default:
				*trace++ = *text++;
			break;
			}
		}

		*trace = 0;
		(outputFunction)(callback->vm, buffer, newline);
	}
}