[people/ms/u-boot.git] / lib / tiny-printf.c

/*
 * Tiny printf version for SPL
 *
 * Copied from:
 * http://www.sparetimelabs.com/printfrevisited/printfrevisited.php
 *
 * Copyright (C) 2004,2008  Kustaa Nyholm
 *
 * SPDX-License-Identifier:	LGPL-2.1+
 */

#include <common.h>
#include <stdarg.h>
#include <serial.h>

static char *bf;
static char zs;

/* Current position in sprintf() output string */
static char *outstr;

static void out(char c)
{
	*bf++ = c;
}

static void out_dgt(char dgt)
{
	out(dgt + (dgt < 10 ? '0' : 'a' - 10));
	zs = 1;
}

static void div_out(unsigned int *num, unsigned int div)
{
	unsigned char dgt = 0;

	while (*num >= div) {
		*num -= div;
		dgt++;
	}

	if (zs || dgt > 0)
		out_dgt(dgt);
}

int _vprintf(const char *fmt, va_list va, void (*putc)(const char ch))
{
	char ch;
	char *p;
	unsigned int num;
	char buf[12];
	unsigned int div;

	while ((ch = *(fmt++))) {
		if (ch != '%') {
			putc(ch);
		} else {
			bool lz = false;
			int width = 0;

			ch = *(fmt++);
			if (ch == '0') {
				ch = *(fmt++);
				lz = 1;
			}

			if (ch >= '0' && ch <= '9') {
				width = 0;
				while (ch >= '0' && ch <= '9') {
					width = (width * 10) + ch - '0';
					ch = *fmt++;
				}
			}
			bf = buf;
			p = bf;
			zs = 0;

			switch (ch) {
			case '\0':
				goto abort;
			case 'u':
			case 'd':
				num = va_arg(va, unsigned int);
				if (ch == 'd' && (int)num < 0) {
					num = -(int)num;
					out('-');
				}
				if (!num) {
					out_dgt(0);
				} else {
					for (div = 1000000000; div; div /= 10)
						div_out(&num, div);
				}
				break;
			case 'x':
				num = va_arg(va, unsigned int);
				if (!num) {
					out_dgt(0);
				} else {
					for (div = 0x10000000; div; div /= 0x10)
						div_out(&num, div);
				}
				break;
			case 'c':
				out((char)(va_arg(va, int)));
				break;
			case 's':
				p = va_arg(va, char*);
				break;
			case '%':
				out('%');
			default:
				break;
			}

			*bf = 0;
			bf = p;
			while (*bf++ && width > 0)
				width--;
			while (width-- > 0)
				putc(lz ? '0' : ' ');
			if (p) {
				while ((ch = *p++))
					putc(ch);
			}
		}
	}

abort:
	return 0;
}

int vprintf(const char *fmt, va_list va)
{
	return _vprintf(fmt, va, putc);
}

int printf(const char *fmt, ...)
{
	va_list va;
	int ret;

	va_start(va, fmt);
	ret = _vprintf(fmt, va, putc);
	va_end(va);

	return ret;
}

static void putc_outstr(char ch)
{
	*outstr++ = ch;
}

int sprintf(char *buf, const char *fmt, ...)
{
	va_list va;
	int ret;

	va_start(va, fmt);
	outstr = buf;
	ret = _vprintf(fmt, va, putc_outstr);
	va_end(va);
	*outstr = '\0';

	return ret;
}

/* Note that size is ignored */
int snprintf(char *buf, size_t size, const char *fmt, ...)
{
	va_list va;
	int ret;

	va_start(va, fmt);
	outstr = buf;
	ret = _vprintf(fmt, va, putc_outstr);
	va_end(va);
	*outstr = '\0';

	return ret;
}
Commit	Line	Data
7d9cde10 SR	1	/*
	2	* Tiny printf version for SPL
	3	*
	4	* Copied from:
	5	* http://www.sparetimelabs.com/printfrevisited/printfrevisited.php
	6	*
	7	* Copyright (C) 2004,2008 Kustaa Nyholm
	8	*
	9	* SPDX-License-Identifier: LGPL-2.1+
	10	*/
	11
	12	#include <common.h>
	13	#include <stdarg.h>
	14	#include <serial.h>
	15
	16	static char *bf;
7d9cde10 SR	17	static char zs;
7d9cde10 SR	18
5c411d88 SG	19	/* Current position in sprintf() output string */
	20	static char *outstr;
	21
7d9cde10 SR	22	static void out(char c)
	23	{
	24	*bf++ = c;
	25	}
	26
	27	static void out_dgt(char dgt)
	28	{
a5ecdd08	29	out(dgt + (dgt < 10 ? '0' : 'a' - 10));
7d9cde10 SR	30	zs = 1;
	31	}
	32
a5ecdd08	33	static void div_out(unsigned int *num, unsigned int div)
7d9cde10 SR	34	{
	35	unsigned char dgt = 0;
	36
a5ecdd08 SR	37	while (*num >= div) {
a5ecdd08 SR	38	*num -= div;
7d9cde10 SR	39	dgt++;
	40	}
	41
	42	if (zs \|\| dgt > 0)
	43	out_dgt(dgt);
	44	}
	45
5c411d88	46	int _vprintf(const char fmt, va_list va, void (putc)(const char ch))
7d9cde10	47	{
7d9cde10 SR	48	char ch;
7d9cde10 SR	49	char *p;
a5ecdd08 SR	50	unsigned int num;
	51	char buf[12];
	52	unsigned int div;
7d9cde10	53
7d9cde10 SR	54	while ((ch = *(fmt++))) {
	55	if (ch != '%') {
	56	putc(ch);
	57	} else {
1fb67608 SG	58	bool lz = false;
1fb67608 SG	59	int width = 0;
7d9cde10 SR	60
	61	ch = *(fmt++);
	62	if (ch == '0') {
	63	ch = *(fmt++);
	64	lz = 1;
	65	}
	66
	67	if (ch >= '0' && ch <= '9') {
1fb67608	68	width = 0;
7d9cde10	69	while (ch >= '0' && ch <= '9') {
1fb67608	70	width = (width * 10) + ch - '0';
7d9cde10 SR	71	ch = *fmt++;
	72	}
	73	}
	74	bf = buf;
	75	p = bf;
	76	zs = 0;
	77
	78	switch (ch) {
1fb67608	79	case '\0':
7d9cde10 SR	80	goto abort;
	81	case 'u':
	82	case 'd':
	83	num = va_arg(va, unsigned int);
	84	if (ch == 'd' && (int)num < 0) {
	85	num = -(int)num;
	86	out('-');
	87	}
74b1320a SG	88	if (!num) {
	89	out_dgt(0);
	90	} else {
	91	for (div = 1000000000; div; div /= 10)
	92	div_out(&num, div);
	93	}
7d9cde10 SR	94	break;
7d9cde10 SR	95	case 'x':
7d9cde10	96	num = va_arg(va, unsigned int);
74b1320a SG	97	if (!num) {
	98	out_dgt(0);
	99	} else {
	100	for (div = 0x10000000; div; div /= 0x10)
	101	div_out(&num, div);
	102	}
7d9cde10 SR	103	break;
	104	case 'c':
	105	out((char)(va_arg(va, int)));
	106	break;
	107	case 's':
	108	p = va_arg(va, char*);
	109	break;
	110	case '%':
	111	out('%');
	112	default:
	113	break;
	114	}
	115
	116	*bf = 0;
	117	bf = p;
1fb67608 SG	118	while (*bf++ && width > 0)
	119	width--;
	120	while (width-- > 0)
7d9cde10	121	putc(lz ? '0' : ' ');
8e31681c SG	122	if (p) {
	123	while ((ch = *p++))
	124	putc(ch);
	125	}
7d9cde10 SR	126	}
	127	}
	128
	129	abort:
7d9cde10 SR	130	return 0;
7d9cde10 SR	131	}
962a43cc	132
da70b4d1 HG	133	int vprintf(const char *fmt, va_list va)
	134	{
	135	return _vprintf(fmt, va, putc);
	136	}
	137
962a43cc SS	138	int printf(const char *fmt, ...)
	139	{
	140	va_list va;
	141	int ret;
	142
	143	va_start(va, fmt);
5c411d88 SG	144	ret = _vprintf(fmt, va, putc);
	145	va_end(va);
	146
	147	return ret;
	148	}
	149
	150	static void putc_outstr(char ch)
	151	{
	152	*outstr++ = ch;
	153	}
	154
abeb272d	155	int sprintf(char buf, const char fmt, ...)
5c411d88 SG	156	{
	157	va_list va;
	158	int ret;
	159
	160	va_start(va, fmt);
	161	outstr = buf;
	162	ret = _vprintf(fmt, va, putc_outstr);
962a43cc	163	va_end(va);
5c411d88	164	*outstr = '\0';
962a43cc SS	165
	166	return ret;
	167	}
abeb272d MV	168
	169	/* Note that size is ignored */
	170	int snprintf(char buf, size_t size, const char fmt, ...)
	171	{
	172	va_list va;
	173	int ret;
	174
	175	va_start(va, fmt);
3191d840 SG	176	outstr = buf;
3191d840 SG	177	ret = _vprintf(fmt, va, putc_outstr);
abeb272d	178	va_end(va);
3191d840	179	*outstr = '\0';
abeb272d MV	180
	181	return ret;
	182	}