#include "stdarg.h"
#include "stdio.h"
#include "romloader.h"
#include "arcs.h"

#define	EOF		(-1)
#define	LINESIZE	128
#define	SCALABLE	'I'

static int  _Setscalable=0;

void showchar(int);
void sprintn(char *, unsigned, int);
void sprintL(char *, unsigned long long, int);

static void sputs(void (*)(), char *, int, int, char);
static void putstr(void (*)(), const char *);
static void prf(void (*)(), const char *, va_list);
static int  isdigit(int);
static int  isprint(int);

/*
 * pointers used for buffering
 */

static char	*fputbp;
static char	*fputbb;
static int	fputbs;
static int	fputcn;
static int	column;
static char	*sprintf_cp;

/*
 * putchar -- put a single character to enabled console devices
 * handles simple character mappings
 */
int
putchar(int ci)
{
	int *col = &column;
	char c = ci;
	unsigned long cnt;
	unsigned long rc;

	switch (c) {
	case '\n':
		if (putchar('\r') != '\r')
			return EOF;
		*col = 0;
		break;

	case '\t':
		do {
			if (putchar(' ') != ' ')
				return EOF;
		} while (*col % 8);
		return c;

	default:
		if (isprint(c))
			(*col)++;
		break;
	}
	_ArcsWrite(StandardOut, &c, 1, &rc);
	return c;
}

static int
fputflush(void)
{
	char *cp = fputbb;
	unsigned long rc;

	if ( fputbp == fputbb )
		return 0;

	_ArcsWrite(StandardOut, fputbb, fputbp-fputbb, &rc);
	fputbp = fputbb;

	return (EOF);
}

static void
fputchar(int c)
{
	int needflush = 0;

	int *col = &column;

	switch (c) {
		case '\n':
			*fputbp++ = '\n';
			*fputbp++ = '\r';
			*col = 0;
			needflush = 1;
			break;

		case '\t':
			do {
				*fputbp++ = ' ';
			} while ((*col)++ % 8);
			break;

		default:
			if (isprint(c))
				(*col)++;
			*fputbp++ = c;
			break;
	}

	if ( fputbp >= fputbb+fputbs-10 || needflush )
		(void)fputflush();
}

/*
 * puts should add a newline
 */
int
puts(const char *s)
{
	char sbuf[LINESIZE];

	fputbs = sizeof(sbuf);
	fputbb = fputbp = sbuf;
	putstr(fputchar, s);

	return fputflush() == EOF ? EOF : 0;
}

static void
putstr(void (*putcf)(int), const char *s)
{
	register int c;

	if (s == NULL)
		s = "<NULL>";
	while (c = *s++)
		(*putcf)(c);
}


/*
 * Scaled down version of C Library printf.
 *
 * One additional format: %b is supported to decode error registers.
 * Usage is:
 *	printf("reg=%b\n", regval, "<base><arg>*");
 * Where <base> is the output base expressed as a control character,
 * e.g. \10 gives octal; \20 gives hex.  Each arg is a sequence of
 * characters, the first of which gives the bit number to be inspected
 * (origin 1), and the next characters (up to a control character, i.e.
 * a character <= 32), give the name of the register.  Thus
 *	printf("reg=%b\n", 3, "\10\2BITTWO\1BITONE\n");
 * would produce output:
 *	reg=3<BITTWO,BITONE>
 *
 * See comments in stdio.h regarding %r and %R formats
 */
/*VARARGS1*/
int
printf(const char *fmt, ...)
{
	char sbuf[LINESIZE];
	va_list ap;

	fputbs = sizeof(sbuf);
	fputbb = fputbp = sbuf;
	fputcn = 0;

	/*CONSTCOND*/
	va_start(ap,fmt);
	prf(fputchar, fmt, ap);
	va_end(ap);

	return fputflush() == EOF ? EOF : fputcn;
}

/*
 * sa version of libc's vprintf
 *
 * just like printf, except it takes exactly two arguments: the format
 * string and an argument vector.
 *
 */
int
vprintf(const char *fmt, char *ap)
{
	char sbuf[LINESIZE];

	fputbs = sizeof(sbuf);
	fputbb = fputbp = sbuf;
	fputcn = 0;
	prf(fputchar, fmt, (va_list)ap);

	return fputflush() == EOF ? EOF : fputcn;
}

/*
 * 'putcf' function for sprintf
 */
static void
poke(int c)
{
	/* sprintf_cp --> LIBSC_PRIVATE(sprintf_cp) */

	*sprintf_cp++ = c;
}

/*VARARGS2*/
int
sprintf(char *buf, const char *fmt, ...)
{
	va_list ap;

	/*CONSTCOND*/
	va_start(ap,fmt);
	sprintf_cp = buf;
	prf(poke, fmt, ap);
	poke('\0');	/* make sure result string is null terminated */
	va_end(ap);

	return strlen(buf);
}

static void
prf(void (*putcf)(int), const char *fmt, va_list adx)
{
	int b, c, i;
	char *s;
	int any;
	char prbuf[65];	/* paranoia: large enough for base 2 numbers */
	int fw, len, ljust; char fillc;
	char altform;
	int lflag, longflag;

	
loop:
	while ((c = *fmt++) != '%') {
		if(c == '\0')
			return;
		(*putcf)(c);
	}

	fillc = ' ';
	fw = 0;
	len = 0;
	lflag = 0;
	longflag = 0;
	c = *fmt++;
	if (altform = c=='#')
		c = *fmt++;
	if (ljust = c=='-')
		c = *fmt++;
	if (isdigit(c)) {
		i = 0;
		if (c == '0')
			fillc = c;
		while (isdigit(c)) {
			i = i * 10 + c - '0';
			c = *fmt++;
		}
		fw = i;
	}
	else if(c == '*') {	/* precision from arg */
		/*CONSTCOND*/
		fw = va_arg(adx, int);
		c = *fmt++;
	}
	if (c == '.') {
		i = 0;
		c = *fmt++;
		if(c == '*') {	/* precision from arg */
			/*CONSTCOND*/
			i = va_arg(adx, int);
			c = *fmt++;
		}
		else while (isdigit(c)) {
			i = i * 10 + c - '0';
			c = *fmt++;
		}
		len = i;
	}
	if (ljust)
		fw = -fw;

	if (c == 'l'){ 
	    if ((c = *fmt++) == 'l'){
	        lflag = 1;
		c = *fmt++;
	    }
	    else 
		longflag = 1; /* %l? prints Long whatever its size is */
	}

	if (c == SCALABLE ){
	    c = *fmt++; 
	    if (_Setscalable)
		lflag = 1;
	}

	if (c == 'L') { /* Support %Lx also */
		c = *fmt++;
		lflag=1;
	}

	switch (c) {

	case 'x':
	case 'X':
		b = 16;
		if ( altform ) {
			(*putcf)('0');
			(*putcf)('x');
			}
		goto number;

	case 'd':
		b = -10;
		goto number;

	case 'u':
		b = 10;
		goto number;

	case 'o':
		b = 8;
		if ( altform )
			(*putcf)('0');
number:
		/*CONSTCOND*/
		/* use sprintL if longlong OR size of long = 8 bytes */
		if (lflag || (longflag && (sizeof(long) == 8)))
			sprintL(prbuf, va_arg(adx, long long), b);

		else 	sprintn(prbuf, va_arg(adx, int), b);

		sputs(putcf, prbuf, fw, len, fillc);
		break;

	case 'c':
		/*CONSTCOND*/
		b = va_arg(adx, int);
		prbuf[0] = b & 0xFF; prbuf[1] = '\0';
		sputs(putcf, prbuf, fw, len, fillc);
		break;

	case 'b':
		/*CONSTCOND*/
		b = va_arg(adx, int);
		/*CONSTCOND*/
		s = va_arg(adx, char *);
		sprintn(prbuf, (unsigned)b, *s++);
		putstr(putcf, prbuf);
		any = 0;
		if (b) {
			(*putcf)('<');
			while (i = *s++) {
				if (b & (1 << (i-1))) {
					if (any)
						(*putcf)(',');
					any = 1;
					for (; (c = *s) > 32; s++)
						(*putcf)(c);
				} else
					while (*s > 32)
						s++;
			}
			(*putcf)('>');
		}
		break;

	case 'r':
	case 'R':
		/*CONSTCOND*/
		b = va_arg(adx, int);
		/*CONSTCOND*/
		s = va_arg(adx, char *);
		if (c == 'R') {
			putstr(putcf, "0x");
			sprintn(prbuf, b, 16);
			putstr(putcf, prbuf);
		}
		if (c == 'r' || b) {
			register struct reg_desc *rd;
			register struct reg_values *rv;
			unsigned field;

			(*putcf)('<');
			any = 0;
			for (rd = (struct reg_desc *)s; rd->rd_mask; rd++) {
				field = b & rd->rd_mask;
				field = (rd->rd_shift > 0)
				    ? field << rd->rd_shift
				    : field >> -rd->rd_shift;
				if (any &&
				      (rd->rd_format || rd->rd_values
				         || (rd->rd_name && field)
				      )
				)
					(*putcf)(',');
				if (rd->rd_name) {
					if (rd->rd_format || rd->rd_values
					    || field) {
						putstr(putcf, rd->rd_name);
						any = 1;
					}
					if (rd->rd_format || rd->rd_values) {
						(*putcf)('=');
						any = 1;
					}
				}
				if (rd->rd_format) {
					prf(putcf,
					    rd->rd_format,
					    (va_list)&field);
					any = 1;
					if (rd->rd_values)
						(*putcf)(':');
				}
				if (rd->rd_values) {
					any = 1;
					for (rv = rd->rd_values;
					    rv->rv_name;
					    rv++) {
						if (field == rv->rv_value) {
							putstr(putcf, rv->rv_name);
							break;
						}
					}
					if (rv->rv_name == NULL)
						putstr(putcf, "???");
				}
			}
			(*putcf)('>');
		}
		break;

	case 's':
		/*CONSTCOND*/
		s = va_arg(adx, char *);
		sputs(putcf, s, fw, len, fillc);
		break;

	case '%':
		prbuf[0] = '%'; prbuf[1] = '\0';
		sputs(putcf, prbuf, fw, len, fillc);
		break;
	}
	goto loop;

	return;

}

/*
 * sprintL -- output a number n in base b.
 * Works with a 64-bit long long argument.
 */
void
sprintL(char *tgt, unsigned long long n, int b)
{
	char prbuf[65];	/* paranoia: large enough for base 2 numbers */
	register char *cp;

	if (b < 0) {
		b = -b;
		if ((long long)n < 0) {
			*tgt++ = ('-');
			n = (unsigned long long)(-(long long)n);
		}
	}

	cp = prbuf;
	do {
		*cp++ = "0123456789abcdef"[n%b];
		n /= b;
	} while (n);
	do
		*tgt++ = (*--cp);
	while (cp > prbuf);
	*tgt++ = ('\0');
}

/*
 * sprintn -- output a number n in base b.
 */
void
sprintn(char *tgt, unsigned n, int b)
{
	char prbuf[33];	/* paranoia: large enough for base 2 numbers */
	register char *cp;

	if (b < 0) {
		b = -b;
		if ((int)n < 0) {
			*tgt++ = ('-');
			n = (unsigned)(-(int)n);
		}
	}

	cp = prbuf;
	do {
		*cp++ = "0123456789abcdef"[n%b];
		n /= b;
	} while (n);
	do
		*tgt++ = (*--cp);
	while (cp > prbuf);
	*tgt++ = ('\0');
}

/*
 * sputs -- output a string with fill
 */
static void
sputs( void (*putcf)(int), char *s, int fw, int len, char fillc)
{
	register int i;

	if (s == NULL)
		s = "<NULL>";
	if (len <= 0)
		i = strlen(s);
	else
		for (i = 0; i < len; i++)
			if (s[i] == '\0')
				break;
	len = i;

	if (fw > 0)
		for (i = fw - len; --i >= 0;)
			(*putcf)(fillc);
	for (i = len; --i >= 0;)
		(*putcf)(*s++);
	if (fw < 0)
		for (i = -fw - len; --i >= 0;)
			(*putcf)(fillc);
	return;
}

/*
 * showchar -- print character in visible manner
 */
void
showchar(int c)
{
	c &= 0xff;
	if (isprint(c))
		putchar(c);
	else switch (c) {
	case '\b':
		puts("\\b");
		break;
	case '\f':
		puts("\\f");
		break;
	case '\n':
		puts("\\n");
		break;
	case '\r':
		puts("\\r");
		break;
	case '\t':
		puts("\\t");
		break;
	default:
		putchar('\\');
		putchar(((c&0300) >> 6) + '0');
		putchar(((c&070) >> 3) + '0');
		putchar((c&07) + '0');
		break;
	}
}

int
vsprintf(char *buf, const char *fmt, char *ap)
{
	sprintf_cp = buf;
	prf(poke, fmt, (va_list)ap);
	poke('\0');	/* make sure result string is null terminated */

	return strlen(sprintf_cp);
}

static int
isdigit(int c)
{
	return((c >= 48) && (c < 58));
}


static int
isprint(int c)
{
	return((c >= 33) && (c < 127));
}
/*
 * _min -- SIGNED minimum function (C really needs inline functions!
 * macro's screwup when args have side-effects)
 */
int
_min(int a, int b)
{
	return(a < b ? a : b);
}

/*
 * _max -- SIGNED maximum function
 */
int
_max(int a, int b)
{
	return(a > b ? a : b);
}