__printf.c

/*
 * Copyright (c) 1997, 1998, 2000, 2001, 2002, 2003, 2004, 2005, 2008, 2009
 *	The President and Fellows of Harvard College.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE UNIVERSITY OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

/*
 * Guts of printf.
 *
 * This file is used in both libc and the kernel and needs to work in both
 * contexts. This makes a few things a bit awkward.
 *
 * This is a slightly simplified version of the real-life printf
 * originally used in the VINO kernel.
 */

#ifdef _KERNEL
#include <types.h>
#include <lib.h>
#define assert KASSERT
#else

#include <sys/types.h>
#include <assert.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#endif

#include <stdarg.h>


/* 
 * Do we want to support "long long" types with %lld?
 *
 * Using 64-bit types with gcc causes gcc to emit calls to functions
 * like __moddi3 and __divdi3. These need to be provided at link time,
 * which can be a hassle; this switch is provided to help avoid
 * needing them.
 */
#define USE_LONGLONG

/*
 * Define a type that holds the longest signed integer we intend to support.
 */
#ifdef USE_LONGLONG
#define INTTYPE  long long
#else
#define INTTYPE  long
#endif


/* 
 * Space for a long long in base 8, plus a NUL, plus one 
 * character extra for slop. 
 *
 * CHAR_BIT is the number of bits in a char; thus sizeof(long long)*CHAR_BIT
 * is the number of bits in a long long. Each octal digit prints 3 bits.
 * Values printed in larger bases will be shorter strings.
 */
#define NUMBER_BUF_SIZE ((sizeof(INTTYPE) * CHAR_BIT) / 3 + 2)

/*
 * Structure holding the state for printf.
 */
typedef struct {
	/* Callback for sending printed string data */
	void (*sendfunc)(void *clientdata, const char *str, size_t len);
	void *clientdata;

	/* The varargs argument pointer */
	va_list ap;

	/* Total count of characters printed */
	int charcount;

	/* Flag that's true if we are currently looking in a %-format */
	int in_pct;

	/* Size of the integer argument to retrieve */
	enum { 
		INTSZ, 
		LONGSZ, 
#ifdef USE_LONGLONG
		LLONGSZ,
#endif
	} size;

	/* The value of the integer argument retrieved */
	unsigned INTTYPE num;

	/* Sign of the integer argument (0 = positive; -1 = negative) */
	int sign;

	/* Field width (number of spaces) */
	int spacing;

	/* Flag: align to left in field instead of right */
	int rightspc;

	/* Character to pad to field size with (space or 0) */
	int fillchar;

	/* Number base to print the integer argument in (8, 10, 16) */
	int base;

	/* Flag: if set, print 0x before hex and 0 before octal numbers */
	int baseprefix;

	/* Flag: alternative output format selected with %#... */
	int altformat;
} PF;

/*
 * Send some text onward to the output.
 *
 * We count the total length we send out so we can return it from __vprintf,
 * since that's what most printf-like functions want to return.
 */
static
void
__pf_print(PF *pf, const char *txt, size_t len)
{
	pf->sendfunc(pf->clientdata, txt, len);
	pf->charcount += len;
}

/*
 * Reset the state for the next %-field.
 */
static
void
__pf_endfield(PF *pf)
{
	pf->in_pct = 0;
	pf->size = INTSZ;
	pf->num = 0;
	pf->sign = 0;
	pf->spacing = 0;
	pf->rightspc = 0;
	pf->fillchar = ' ';
	pf->base = 0;
	pf->baseprefix = 0;
	pf->altformat = 0;
}

/*
 * Process modifier chars (between the % and the type specifier)
 *    #           use "alternate display format"
 *    -           left align in field instead of right align
 *    l           value is long (ll = long long)
 *    0-9         field width
 *    leading 0   pad with zeros instead of spaces
 */
static
void
__pf_modifier(PF *pf, int ch)
{
	switch (ch) {
	case '#':
		pf->altformat = 1;
		break;
	case '-':
		pf->rightspc = 1;
		break;
	case 'l': 
		if (pf->size==LONGSZ) {
#ifdef USE_LONGLONG
			pf->size = LLONGSZ;
#endif
		}
		else {
			pf->size = LONGSZ;
		}
		break;
	case '0': 
		if (pf->spacing>0) {
			/*
			 * Already seen some digits; this is part of the
			 * field size.
			 */
			pf->spacing = pf->spacing*10;
		}
		else {
			/*
			 * Leading zero; set the padding character to 0.
			 */
			pf->fillchar = '0';
		}
		break;
	default:
		/*
		 * Invalid characters should be filtered out by a
		 * higher-level function, so if this assert goes off
		 * it's our fault.
		 */
		assert(ch>'0' && ch<='9');

		/*
		 * Got a digit; accumulate the field size.
		 */
		pf->spacing = pf->spacing*10 + (ch-'0');
		break;
	}
}

/*
 * Retrieve a numeric argument from the argument list and store it
 * in pf->num, according to the size recorded in pf->size and using
 * the numeric type specified by ch.
 */
static
void
__pf_getnum(PF *pf, int ch)
{
	if (ch=='p') {
		/* 
		 * Pointer.
		 *
		 * uintptr_t is a C99 standard type that's an unsigned
		 * integer the same size as a pointer.
		 */
		pf->num = (uintptr_t) va_arg(pf->ap, void *);
	}
	else if (ch=='d') {
		/* signed integer */
		INTTYPE signednum=0;
		switch (pf->size) {
		case INTSZ:
			/* %d */
			signednum = va_arg(pf->ap, int);
			break;
		case LONGSZ:
			/* %ld */
			signednum = va_arg(pf->ap, long);
			break;
#ifdef USE_LONGLONG
		case LLONGSZ:
			/* %lld */
			signednum = va_arg(pf->ap, long long);
			break;
#endif
		}

		/*
		 * Check for negative numbers.
		 */
		if (signednum < 0) {
			pf->sign = -1;
			pf->num = -signednum;
		}
		else {
			pf->num = signednum;
		}
	}
	else {
		/* unsigned integer */
		switch (pf->size) {
		case INTSZ:
			/* %u (or %o, %x) */
			pf->num = va_arg(pf->ap, unsigned int);
			break;
		case LONGSZ:
			/* %lu (or %lo, %lx) */
			pf->num = va_arg(pf->ap, unsigned long);
			break;
#ifdef USE_LONGLONG
		case LLONGSZ:
			/* %llu, %llo, %llx */
			pf->num = va_arg(pf->ap, unsigned long long);
			break;
#endif
		}
	}
}

/*
 * Set the printing base based on the numeric type specified in ch.
 *     %o     octal
 *     %d,%u  decimal
 *     %x     hex
 *     %p     pointer (print as hex)
 *
 * If the "alternate format" was requested, or always for pointers,
 * note to print the C prefix for the type.
 */
static
void
__pf_setbase(PF *pf, int ch)
{
	switch (ch) {
	case 'd':
	case 'u':
		pf->base = 10;
		break;
	case 'x':
	case 'p':
		pf->base = 16;
		break;
	case 'o':
		pf->base = 8;
		break;
	}
	if (pf->altformat || ch=='p') {
		pf->baseprefix = 1;
	}
}

/*
 * Function to print "spc" instances of the fill character.
 */
static
void
__pf_fill(PF *pf, int spc)
{
	char f = pf->fillchar;
	int i;
	for (i=0; i<spc; i++) {
		__pf_print(pf, &f, 1);
	}
}

/*
 * General printing function. Prints the string "stuff".
 * The two prefixes (in practice one is a type prefix, such as "0x",
 * and the other is the sign) get printed *after* space padding but
 * *before* zero padding, if padding is on the left.
 */
static
void
__pf_printstuff(PF *pf,
		const char *prefix, const char *prefix2,
		const char *stuff)
{
	/* Total length to print. */
	int len = strlen(prefix)+strlen(prefix2)+strlen(stuff);

	/* Get field width and compute amount of padding in "spc". */
	int spc = pf->spacing;
	if (spc > len) {
		spc -= len;
	}
	else {
		spc = 0;
	}

	/* If padding on left and the fill char is not 0, pad first. */
	if (spc > 0 && pf->rightspc==0 && pf->fillchar!='0') {
		__pf_fill(pf, spc);
	}

	/* Print the prefixes. */
	__pf_print(pf, prefix, strlen(prefix));
	__pf_print(pf, prefix2, strlen(prefix2));

	/* If padding on left and the fill char *is* 0, pad here. */
	if (spc > 0 && pf->rightspc==0 && pf->fillchar=='0') {
		__pf_fill(pf, spc);
	}

	/* Print the actual string. */
	__pf_print(pf, stuff, strlen(stuff));

	/* If padding on the right, pad afterwards. */
	if (spc > 0 && pf->rightspc!=0) {
		__pf_fill(pf, spc);
	}
}

/*
 * Function to convert a number to ascii and then print it.
 *
 * Works from right to left in a buffer of NUMBER_BUF_SIZE bytes.
 * NUMBER_BUF_SIZE is set so that the longest number string we can 
 * generate (a long long printed in octal) will fit. See above.
 */
static
void
__pf_printnum(PF *pf)
{
	/* Digits to print with. */
	const char *const digits = "0123456789abcdef";

	char buf[NUMBER_BUF_SIZE];   /* Accumulation buffer for string. */
	char *x;                     /* Current pointer into buf. */ 
	unsigned INTTYPE xnum;       /* Current value to print. */
	const char *bprefix;         /* Base prefix (0, 0x, or nothing) */
	const char *sprefix;         /* Sign prefix (- or nothing) */

	/* Start in the last slot of the buffer. */
	x = buf+sizeof(buf)-1;

	/* Insert null terminator. */
	*x-- = 0;

	/* Initialize value. */
	xnum = pf->num;

	/* 
	 * Convert a single digit.
	 * Do this loop at least once - that way 0 prints as 0 and not "". 
	 */
	do {
		/* 
		 * Get the digit character for the least significant
		 * part of xnum.
		 */
		*x = digits[xnum % pf->base];
		
		/*
		 * Back up the pointer to point to the next space to the left.
		 */
		x--;

		/*
		 * Drop the value of the digit we just printed from xnum.
		 */
		xnum = xnum / pf->base;

		/*
		 * If xnum hits 0 there's no more number left.
		 */
	} while (xnum > 0);

	/*
	 * x points to the *next* slot in the buffer to use.
	 * However, we're done printing the number. So it's pointing
	 * one slot *before* the start of the actual number text.
	 * So advance it by one so it actually points at the number.
	 */
	x++;

	/*
	 * If a base prefix was requested, select it.
	 */
	if (pf->baseprefix && pf->base==16) {
		bprefix = "0x";
	}
	else if (pf->baseprefix && pf->base==8) {
		bprefix = "0";
	}
	else {
		bprefix = "";
	}

	/*
	 * Choose the sign prefix.
	 */
	sprefix = pf->sign ? "-" : "";

	/*
	 * Now actually print the string we just generated.
	 */
	__pf_printstuff(pf, sprefix, bprefix, x);
}

/*
 * Process a single character out of the format string.
 */
static
void
__pf_send(PF *pf, int ch)
{
	/* Cannot get NULs here. */
	assert(ch!=0);

	if (pf->in_pct==0 && ch!='%') {
		/*
		 * Not currently in a format, and not a %. Just send
		 * the character on through.
		 */
		char c = ch;
		__pf_print(pf, &c, 1);
	}
	else if (pf->in_pct==0) {
		/*
		 * Not in a format, but got a %. Start a format.
		 */
		pf->in_pct = 1;
	}
	else if (strchr("#-l0123456789", ch)) {
		/*
		 * These are the modifier characters we recognize.
		 * (These are the characters between the % and the type.)
		 */
		__pf_modifier(pf, ch);
	}
	else if (strchr("doupx", ch)) {
		/*
		 * Integer types.
		 * Fetch the number, set the base, print it, then
		 * reset for the next format.
		 */
		__pf_getnum(pf, ch);
		__pf_setbase(pf, ch);
		__pf_printnum(pf);
		__pf_endfield(pf);
	}
	else if (ch=='s') {
		/*
		 * Print a string.
		 */
		const char *str = va_arg(pf->ap, const char *);
		if (str==NULL) {
			str = "(null)";
		}
		__pf_printstuff(pf, "", "", str);
		__pf_endfield(pf);
	}
	else {
		/* 
		 * %%, %c, or illegal character. 
		 * Illegal characters are printed like %%.
		 * for example, %5k prints "    k".
		 */
		char x[2];
		if (ch=='c') {
			x[0] = va_arg(pf->ap, int);
		}
		else {
			x[0] = ch;
		}
		x[1] = 0;
		__pf_printstuff(pf, "", "", x);
		__pf_endfield(pf);
	}
}

/*
 * Do a whole printf session.
 * Create and initialize a printf state object,
 * then send it each character from the format string.
 */
int
__vprintf(void (*func)(void *clientdata, const char *str, size_t len), 
	  void *clientdata, const char *format, va_list ap)
{
	PF pf;
	int i;

	pf.sendfunc = func;
	pf.clientdata = clientdata;
	pf.ap = ap;
	pf.charcount = 0;
	__pf_endfield(&pf);

	for (i=0; format[i]; i++) {
		__pf_send(&pf, format[i]);
	}

	return pf.charcount;
}