path: root/projects/libhal-test/printf.c

/*****************************************************************************
Stripped-down printf()
Chris Giese <geezer@execpc.com>	http://my.execpc.com/~geezer
Release date: Dec 12, 2003
This code is public domain (no copyright).
You can do whatever you want with it.

Revised Dec 12, 2003
- fixed vsprintf() and sprintf() in test code

Revised Jan 28, 2002
- changes to make characters 0x80-0xFF display properly

Revised June 10, 2001
- changes to make vsprintf() terminate string with '\0'

Revised May 12, 2000
- math in DO_NUM is now unsigned, as it should be
- %0 flag (pad left with zeroes) now works
- actually did some TESTING, maybe fixed some other bugs

%[flag][width][.prec][mod][conv]
flag:	-	left justify, pad right w/ blanks	DONE
	0	pad left w/ 0 for numerics		DONE
	+	always print sign, + or -		no
	' '	(blank)					no
	#	(???)					no

width:		(field width)				DONE

prec:		(precision)				DONE

conv:	d,i	decimal int				DONE
	u	decimal unsigned			DONE
	o	octal					DONE
	x,X	hex					DONE
	f,e,g,E,G float					no
	c	char					DONE
	s	string					DONE
	p	ptr					DONE

mod:	N	near ptr				DONE
	F	far ptr					no
	h	short (16-bit) int			DONE
	l	long (32-bit) int			DONE
	L/ll	long long (64-bit) int			no
*****************************************************************************/
#include <string.h> /* strlen() */
#include <stdio.h> /* stdout, putchar(), fputs() (but not printf() :) */
#undef putchar

#include <stdarg.h> /* va_list, va_start(), va_arg(), va_end() */

/* flags used in processing format string */
#define	PR_LJ	0x01	/* left justify */
#define	PR_CA	0x02	/* use A-F instead of a-f for hex */
#define	PR_SG	0x04	/* signed numeric conversion (%d vs. %u) */
#define	PR_32	0x08	/* long (32-bit) numeric conversion */
#define	PR_16	0x10	/* short (16-bit) numeric conversion */
#define	PR_WS	0x20	/* PR_SG set and num was < 0 */
#define	PR_LZ	0x40	/* pad left with '0' instead of ' ' */
#define	PR_FP	0x80	/* pointers are far */
/* largest number handled is 2^64-1, lowest radix handled is 8.
2^64-1 in base 8 has 22 digits (add 2 for trailing NUL and for slop) */
#define	PR_BUFLEN	24

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

typedef int (*fnptr_t)(unsigned c, void **helper);
/*****************************************************************************
name:	do_printf
action:	minimal subfunction for ?printf, calls function
	'fn' with arg 'ptr' for each character to be output
returns:total number of characters output
*****************************************************************************/
int do_printf(const char *fmt, va_list args, fnptr_t fn, void *ptr)
{
        unsigned flags, length, count, width, precision;
	unsigned char *where, buf[PR_BUFLEN];
	unsigned char state, radix;
	long num;

	state = flags = count = width = precision = 0;
/* begin scanning format specifier list */
	for(; *fmt; fmt++)
	{
		switch(state)
		{
/* STATE 0: AWAITING % */
		case 0:
			if(*fmt != '%')	/* not %... */
			{
				fn(*fmt, &ptr);	/* ...just echo it */
				count++;
				break;
			}
/* found %, get next char and advance state to check if next char is a flag */
			state++;
			fmt++;
			/* FALL THROUGH */
/* STATE 1: AWAITING FLAGS (%-0) */
		case 1:
			if(*fmt == '%')	/* %% */
			{
				fn(*fmt, &ptr);
				count++;
				state = flags = width = precision = 0;
				break;
			}
			if(*fmt == '-')
			{
				if(flags & PR_LJ)/* %-- is illegal */
					state = flags = width = precision = 0;
				else
					flags |= PR_LJ;
				break;
			}
/* not a flag char: advance state to check if it's field width */
			state++;
/* check now for '%0...' */
			if(*fmt == '0')
			{
				flags |= PR_LZ;
				fmt++;
			}
			/* FALL THROUGH */
/* STATE 2: AWAITING (NUMERIC) FIELD WIDTH */
		case 2:
			if(*fmt >= '0' && *fmt <= '9')
			{
				width = 10 * width + (*fmt - '0');
				break;
			}
/* not a field width: advance state to check if it's field precision */
			state++;
			/* FALL THROUGH */
/* STATE 3: AWAITING (NUMERIC) FIELD PRECISION */
		case 3:
			if(*fmt == '.')
				++fmt;
			if(*fmt >= '0' && *fmt <= '9')
			{
				precision = 10 * precision + (*fmt - '0');
				break;
			}
/* not field precision: advance state to check if it's a modifier */
			state++;
			/* FALL THROUGH */
/* STATE 4: AWAITING MODIFIER CHARS (FNlh) */
		case 4:
			if(*fmt == 'F')
			{
				flags |= PR_FP;
				break;
			}
			if(*fmt == 'N')
				break;
			if(*fmt == 'l')
			{
				flags |= PR_32;
				break;
			}
			if(*fmt == 'h')
			{
				flags |= PR_16;
				break;
			}
/* not modifier: advance state to check if it's a conversion char */
			state++;
			/* FALL THROUGH */
/* STATE 5: AWAITING CONVERSION CHARS (Xxpndiuocs) */
		case 5:
			where = buf + PR_BUFLEN - 1;
			*where = '\0';
			switch(*fmt)
			{
			case 'X':
				flags |= PR_CA;
				/* FALL THROUGH */
/* xxx - far pointers (%Fp, %Fn) not yet supported */
			case 'x':
			case 'p':
			case 'n':
				radix = 16;
				goto DO_NUM;
			case 'd':
			case 'i':
				flags |= PR_SG;
				/* FALL THROUGH */
			case 'u':
				radix = 10;
				goto DO_NUM;
			case 'o':
				radix = 8;
/* load the value to be printed. l=long=32 bits: */
DO_NUM:				if(flags & PR_32)
					num = va_arg(args, unsigned long);
/* h=short=16 bits (signed or unsigned) */
				else if(flags & PR_16)
				{
					num = va_arg(args, int);
					if(flags & PR_SG)
					    num = (short) num;
					else
					    num = (unsigned short) num;
				}
/* no h nor l: sizeof(int) bits (signed or unsigned) */
				else
				{
					if(flags & PR_SG)
						num = va_arg(args, int);
					else
						num = va_arg(args, unsigned int);
				}
/* take care of sign */
				if(flags & PR_SG)
				{
					if(num < 0)
					{
						flags |= PR_WS;
						num = -num;
					}
				}
/* convert binary to octal/decimal/hex ASCII
OK, I found my mistake. The math here is _always_ unsigned */
				do
				{
					unsigned long temp;

					temp = (unsigned long)num % radix;
					where--;
					if(temp < 10)
						*where = temp + '0';
					else if(flags & PR_CA)
						*where = temp - 10 + 'A';
					else
						*where = temp - 10 + 'a';
					num = (unsigned long)num / radix;
				}
				while(num != 0);
/* for integers, precision functions like width, but pads with zeros */
				if (precision != 0)
				{
					width = max(width, precision);
					if (precision > strlen((const char *)where))
						flags |= PR_LZ;
					precision = 0;
				}
				goto EMIT;
			case 'c':
/* disallow pad-left-with-zeroes for %c */
				flags &= ~PR_LZ;
				where--;
				*where = (unsigned char)va_arg(args, int);
				length = 1;
				goto EMIT2;
			case 's':
/* disallow pad-left-with-zeroes for %s */
				flags &= ~PR_LZ;
				where = va_arg(args, unsigned char *);
EMIT:
				length = strlen((const char *)where);
/* if string is longer than precision, truncate */
				if ((precision != 0) && (precision < length))
				{
					length = precision;
					precision = 0;
				}
				if(flags & PR_WS)
					length++;
/* if we pad left with ZEROES, do the sign now */
				if((flags & (PR_WS | PR_LZ)) ==
					(PR_WS | PR_LZ))
				{
					fn('-', &ptr);
					count++;
				}
/* pad on left with spaces or zeroes (for right justify) */
EMIT2:				if((flags & PR_LJ) == 0)
				{
					while(width > length)
					{
						fn(flags & PR_LZ ?
							'0' : ' ', &ptr);
						count++;
						width--;
					}
				}
/* if we pad left with SPACES, do the sign now */
				if((flags & (PR_WS | PR_LZ)) == PR_WS)
				{
					fn('-', &ptr);
					count++;
				}
/* emit string/char/converted number */
				for(unsigned i = (flags & PR_WS) ? 1 : 0;
				    i < length; ++i)
				{
					fn(*where++, &ptr);
					count++;
				}
/* pad on right with spaces (for left justify) */
				if(width < length)
					width = 0;
				else width -= length;
				for(; width; width--)
				{
					fn(' ', &ptr);
					count++;
				}
				break;
			default:
				break;
			}
		default:
			state = flags = width = precision = 0;
			break;
		}
	}
	return count;
}

/*****************************************************************************
SPRINTF
*****************************************************************************/
static int vsprintf_help(unsigned c, void **ptr)
{
	char *dst;

	dst = *ptr;
	*dst++ = (char)c;
	*ptr = dst;
	return 0 ;
}
/*****************************************************************************
*****************************************************************************/
int vsprintf(char *buf, const char *fmt, va_list args)
{
	int rv;

	rv = do_printf(fmt, args, vsprintf_help, (void *)buf);
	buf[rv] = '\0';
	return rv;
}
/*****************************************************************************
*****************************************************************************/
int sprintf(char *buf, const char *fmt, ...)
{
	va_list args;
	int rv;

	va_start(args, fmt);
	rv = vsprintf(buf, fmt, args);
	va_end(args);
	return rv;
}
/*****************************************************************************
PRINTF
You must write your own putchar()
*****************************************************************************/
int vprintf_help(unsigned c, void **ptr)
{
	putchar(c);
	return 0 ;
}
/*****************************************************************************
*****************************************************************************/
int vprintf(const char *fmt, va_list args)
{
	return do_printf(fmt, args, vprintf_help, NULL);
}
/*****************************************************************************
*****************************************************************************/
int printf(const char *fmt, ...)
{
	va_list args;
	int rv;

	va_start(args, fmt);
	rv = vprintf(fmt, args);
	va_end(args);
	return rv;
}

#if 0 /* testing */
/*****************************************************************************
*****************************************************************************/
int main(void)
{
	char buf[64];

	sprintf(buf, "%lu score and %i years ago...\n", 4L, -7);
	fputs(buf, stdout); /* puts() adds newline */

	sprintf(buf, "-1L == 0x%lX == octal %lo\n", -1L, -1L);
	fputs(buf, stdout); /* puts() adds newline */

	printf("<%-8s> and <%8s> justified strings\n", "left", "right");

	printf("short signed: %hd, short unsigned: %hu\n\n", -1, -1);

    char str[] = "abcdefghijklmnopqrstuvwxyz";
    printf("%8s\n", str);	/* abcdefghijklmnopqrstuvwxyz */
    printf("%8.32s\n", str);	/* abcdefghijklmnopqrstuvwxyz */
    printf("%8.16s\n", str);	/* abcdefghijklmnop */
    printf("%8.8s\n", str);	/* abcdefgh */
    printf("%8.4s\n", str);	/*     abcd */
    printf("%4.8s\n", str);	/* abcdefgh */
    printf("%.8s\n", str);	/* abcdefgh */
    printf("%8s\n", "abcd");	/*     abcd */
    printf("%8.8s\n", "abcd");	/*     abcd */
    printf("%4.8s\n", "abcd");	/* abcd */
    printf("%.8s\n", "abcd");	/* abcd */
    printf("%.0s\n", str);	/* */
    printf("\n");

    int num = 123456;
    printf("%016d\n", num);	/* 0000000000123456 */
    printf("%16d\n", num);	/*           123456 */
    printf("%8d\n", num);	/*   123456 */
    printf("%8.16d\n", num);	/* 0000000000123456 */
    printf("%8.8d\n", num);	/* 00123456 */
    printf("%8.4d\n", num);	/*   123456 */
    printf("%4.4d\n", num);	/* 123456 */
    printf("%.16d\n", num);	/* 0000000000123456 */ 
    printf("%.8d\n", num);	/* 00123456 */
    printf("%.4d\n", num);	/* 123456 */

	return 0;
}
#else

/*****************************************************************************
2015-10-29 pselkirk for cryptech
*****************************************************************************/
/* gcc decides that a plain string with no formatting is best handled by puts() */
int puts(const char *s)
{
    return printf("%s\n", s);
}

/* transmit characters to the uart */
#include "stm-uart.h"
int putchar(int c)
{
    if (c == '\n')
	uart_send_char('\r');
    uart_send_char((uint8_t) c);
    return c;
}
#endif