一个小型的printf实现

[kenlsoft]

就是比较费栈[

/* LICENSE_PLACEHODLER */
#include <stdarg.h>
#include <stdbool.h>
#include <svcnum.h>

/* Staging buffer in stack for collecting formated string */
#define STAGING_BUFFER_SIZE 16
struct staging_buffer_t {
char buf[STAGING_BUFFER_SIZE];
unsigned int pos;
unsigned int total;
};

/*

• Embedded assembler function can't be inline or the mixed code

• would be chaos, especially with high optimization level.
  */
  attribute ((noinline))
  static void flush_stgbuf(struct staging_buffer_t *p_stgbuf)
  {
  __asm volatile (
  "mov r0, %0 \n"
  "mov r1, %1 \n"
  "svc %2 \n"
  ::"r" (p_stgbuf->buf),
  "r" (p_stgbuf->pos),
  "I" (SVC_LOGGING_SAFE));

  p_stgbuf->pos = 0;
  }

attribute ((noinline))
static void putchar_to_stgbuf(const char ch, struct staging_buffer_t *p_stgbuf)
{
p_stgbuf->buf[p_stgbuf->pos++] = ch;
p_stgbuf->total++;
if (p_stgbuf->pos == sizeof(p_stgbuf->buf)) {
flush_stgbuf(p_stgbuf);
}
}

static const char hex_digits_lo[] = { '0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
static const char hex_digits_hi[] = { '0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
attribute ((noinline))
static int output_digits(struct staging_buffer_t *out,
unsigned int number,
bool zero_padding,
bool is_decimal,
bool is_signed,
int visible_digits,
const char *digits_char_tbl)
{
unsigned int the_digit, max_dec_div = 1000000000;
int pos, max_digits, valid_digits = 0;

/* Return if no visual */
if (visible_digits != 0 && zero_padding == false && number == 0) {
	putchar_to_stgbuf('0', out);
	return 1;
}

/* Set as hex length first - len('0xffffffff') = 8 */
max_digits = 8;
if (is_decimal) {
	/* len('4294967295') = 10 */
	max_digits = 10;

	if (visible_digits != 0 && is_signed && (number & 0x80000000)) {
		putchar_to_stgbuf('-', out);
		number &= ~0x80000000;
		number = (0x7fffffff - number) + 1;
	}
}

if (visible_digits > max_digits) {
	visible_digits = max_digits;
}

for (pos = 0; pos < max_digits; pos++)
{
	if (is_decimal) {
		the_digit = number / max_dec_div;
		number -= the_digit * max_dec_div;
		max_dec_div /= 10;
	}
	else {
		the_digit = (number & 0xf0000000) >> 28;
		number <<= 4;
	}

	if (zero_padding || (the_digit != 0 || valid_digits != 0)) {
		if (pos + visible_digits >= max_digits) {
			if (is_decimal) {
				putchar_to_stgbuf('0' + the_digit, out);
			}
			else {
				putchar_to_stgbuf(digits_char_tbl[the_digit], out);
			}
		}
		valid_digits++;
	}
}

return valid_digits;

}

int printf(const char *fmt, ...)
{
va_list vl;
bool escaped = false;
bool zero_padding = false;
bool is_decimal = false;
bool is_signed = false;
struct staging_buffer_t staging_buf;
int visible_digits = sizeof(staging_buf.buf);
const char *str_indicator = hex_digits_hi;

staging_buf.pos = 0;
staging_buf.total = 0;

va_start(vl, fmt);

--fmt;

while (*(++fmt) != '\0')
{
	if (escaped == false && *fmt != '%') {
		putchar_to_stgbuf(*fmt, &staging_buf);
		continue;
	} else if (escaped == false  && *fmt == '%') {
		escaped = true;
		continue;
	}

	switch (*fmt) {
	case '%':
		putchar_to_stgbuf(*fmt, &staging_buf);
		escaped = false;
		break;
	case 'd':
		is_signed = true;
	case 'u':
		is_decimal = true;
	case 'x':
		str_indicator = hex_digits_lo;
	case 'X':
		(void)output_digits(&staging_buf, va_arg(vl, unsigned int),
							zero_padding, is_decimal, is_signed, visible_digits,
							str_indicator);			
		visible_digits = sizeof(staging_buf.buf);
		str_indicator = hex_digits_hi;
		zero_padding = false;
		is_decimal = false;
		is_signed = false;
		escaped = false;
		break;
	case '0':
		zero_padding = true;
		break;
	case 'c':
		putchar_to_stgbuf((const char)va_arg(vl, int), &staging_buf);
		escaped = false;
		break;
	case 's':
		str_indicator = va_arg(vl, char*);
		while (*str_indicator != '\0') {
			putchar_to_stgbuf(*str_indicator, &staging_buf);
			str_indicator++;
		}
		str_indicator = hex_digits_hi;
		escaped = false;
		break;
	default:
		if (*fmt > '0' && *fmt < '9') {
			visible_digits = *fmt - '0';
		} else {
			escaped = false;
			putchar_to_stgbuf(*fmt, &staging_buf);
			putchar_to_stgbuf('?', &staging_buf);
		}
		break;
	}
}

va_end(vl);

flush_stgbuf(&staging_buf);

/* The total characters can't be negitive but std printf wants an int */
return (int)staging_buf.total;

}