Linux0.11内核完全注释--vsprintf函数

参考：《Linux内核完全注释：基于0.11内核》
该书下载地址：http://www.oldlinux.org/download/clk011c-3.0.pdf

#include<stdarg.h>
#include<stdio.h>
#include<string.h>

#define ZEROPAD	1		/* pad with zero */
#define SIGN	2		/* unsigned/signed long */
#define PLUS	4		/* show plus */
#define SPACE	8		/* space if plus */
#define LEFT	16		/* left justified */
#define SPECIAL	32		/* 0x */
#define SMALL	64		/* use 'abcdef' instead of 'ABCDEF' */

// 除操作
// 输入：n为被除数，base为除数
// 输出：n为商
// 返回值__res为余数
#define do_div(n,base) ({ \
int __res; \
__asm__("divl %4":"=a" (n),"=d" (__res):"0" (n),"1" (0),"r" (base)); \
__res; })

// 将整数转换为指定进制的字符串
// 输入：num为要转换的数字，base为进制，size为字符串长度，precision为数字长度（精度），type为类型选项
// 输出：str字符串指针
static char * number(char * str, int num, int base, int size, int precision
	,int type)
{
	char c,sign,tmp[36];
	const char *digits="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
	int i;

    // 如果类型指出用小写字母，则定义小写字母集
	if (type&SMALL) digits="0123456789abcdefghijklmnopqrstuvwxyz";
	// 如果是左对齐，就不能使用零填充
    if (type&LEFT) type &= ~ZEROPAD;
	if (base<2 || base>36)
		return 0;
	// c保存用于填充的字符
    c = (type & ZEROPAD) ? '0' : ' ' ;
	// 数字是有符号数且为负，符号为‘-’，数字取绝对值
    if (type&SIGN && num<0) {
		sign='-';
		num = -num;
	} else
        // 是否显示‘+’符号。显示则sign为‘+’
        // 如果不显示，是否显示为空格。如果是显示为空格，否则字符sign置0
		sign=(type&PLUS) ? '+' : ((type&SPACE) ? ' ' : 0);
	// 如果符号不是0，则占用1个宽度，所以size-1
    if (sign) size--;
	// 如果显示16进制，需要2位存放“0x”或者“0X”，size-2
    // 如果显示8进制，需要1位存放“0”，size-1
    if (type&SPECIAL)
		if (base==16) size -= 2;
		else if (base==8) size--;
	i=0;
    // 如果num为0，tmp[0]=0。此时tmp存储的数字长度（数值字符个数）i为1
	if (num==0)
		tmp[i++]='0';
    // 如果数字不为0，进行进制转换并存入tmp数组
	else while (num!=0)
		tmp[i++]=digits[do_div(num,base)];
	// 如果数值字符个数大于精度值，则精度值扩展为数字字符个数
    if (i>precision) precision=i;
	// 宽度size减去精度值
    size -= precision;
	// 如果不是零填充且不是左对齐，转换后的字符串str首先填充剩余宽度值个空格
    if (!(type&(ZEROPAD+LEFT)))
		while(size-->0)
			*str++ = ' ';
	// 如果符号不为空，str填充符号
    if (sign)
		*str++ = sign;
	// 对于8进制，填充‘0’
    // 对于16进制，填充“0x”或“0X”。具体填充哪一个取决于选大写还是小写
    if (type&SPECIAL)
		if (base==8)
			*str++ = '0';
		else if (base==16) {
			*str++ = '0';
			*str++ = digits[33];
		}
	// 前面已经处理了不是零填充且不是左对齐的情况
    // 这里如果不是左对齐，那就只能是零填充了。零填充的字符c前面已经定义了
    if (!(type&LEFT))
		while(size-->0)
			*str++ = c;
	// i中存放的是数字字符个数，如果小于精度值，则str中放入（精度值-i）个‘0’
    while(i<precision--)
		*str++ = '0';
	// 将转换好的数字存入str中
    while(i-->0)
		*str++ = tmp[i];
	// 若宽度size仍大于0，则表明是左对齐。剩余宽度用空格填充
    while(size-->0)
		*str++ = ' ';
	return str;
}


/* we use this so that we can do without the ctype library */
#define is_digit(c)	((c) >= '0' && (c) <= '9')

// 该函数将字符串转换成整数
static int skip_atoi(const char **s)
{
	int i=0;

	while (is_digit(**s))
		i = i*10 + *((*s)++) - '0';
	return i;
}


/*
 * 这里就是linux 0.11版本内核的vsprintf的实现了。为了调用这个函数，我们把名字改成my_vsprintf
 * 
 * 输入：fmt是格式字符串，args是个数变化的值
 * 输出：buf是输出字符串缓冲区
 */
int my_vsprintf(char *buf, const char *fmt, va_list args)
{
	int len;
	int i;
    // str用于存放转换过程中的字符串
	char * str;
	char *s;
	int *ip;

    // number()函数使用的标志
	int flags;		/* flags to number() */

    // 输出字段宽度
	int field_width;	/* width of output field */
	// min.整数数字个数；max.字符串中字符个数
    int precision;		/* min. # of digits for integers; max
				   number of chars for from string */
	// ‘h’、‘l’或‘L’用于整数字段
    int qualifier;		/* 'h', 'l', or 'L' for integer fields */

    // 首先将字符指针指向buf，然后扫描格式字符串，对各个格式转换指示进行相应的处理
	for (str=buf ; *fmt ; ++fmt) {
        // 格式转换指示字符均以‘%’开始，这里从fmt格式字符串中扫描‘%’，寻找格式转换字符串的开始
        // 一般字符直接存入str
		if (*fmt != '%') {
			*str++ = *fmt;
			continue;
		}

        // 下面取得格式指示字符串中的标志域，并将标志常量放入flags变量中
		/* process flags */
		flags = 0;
		repeat:
			++fmt;		/* this also skips first '%' */
			switch (*fmt) {
                // 左对齐标志
				case '-': flags |= LEFT; goto repeat;
				// 放加号
                case '+': flags |= PLUS; goto repeat;
				// 放空格
                case ' ': flags |= SPACE; goto repeat;
				// 特殊转换
                case '#': flags |= SPECIAL; goto repeat;
				// 零填充
                case '0': flags |= ZEROPAD; goto repeat;
				}
		
        // 取当前参数字段宽度域值，放入field_width变量中
        // 如果宽度域中是数值则直接取其为宽度值
        // 如果宽度域中是字符‘*’，表示下一个参数指定宽度。因此调用va_arg取宽度值
        // 若此时宽度值小于0，则该负数表示其带有标志域‘-’标志，需在标志标志变量中添加左对齐，并将字段宽度取为其绝对值
		/* get field width */
		field_width = -1;
		if (is_digit(*fmt))
			field_width = skip_atoi(&fmt);
		else if (*fmt == '*') {
			/* it's the next argument */
			++fmt;
            field_width = va_arg(args, int);
			if (field_width < 0) {
				field_width = -field_width;
				flags |= LEFT;
			}
		}

        // 取格式化串的精度域，并放入precision变量中。精度域开始的标志是‘.’。其处理过程与上面宽度域的类似。
        // 如果精度域中是数值，则直接取其数值
        // 如果精度域中是符号‘*’，表示下一个参数指定精度。因此调用va_arg取精度值
        // // 如果此时精度值小于0，则将精度值取0
		/* get the precision */
		precision = -1;
		if (*fmt == '.') {
			++fmt;	
			if (is_digit(*fmt))
				precision = skip_atoi(&fmt);
			else if (*fmt == '*') {
				/* it's the next argument */
				precision = va_arg(args, int);
			}
			if (precision < 0)
				precision = 0;
		}

        // 分析长度修饰符，并将其存入qualifier变量
		/* get the conversion qualifier */
		qualifier = -1;
		if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L') {
			qualifier = *fmt;
			++fmt;
		}

        // 下面分析转换指示符
		switch (*fmt) {
        // 如果指示符是‘c’，则表明对应参数应是字符
        // 此时如果标志域不是左对齐，则该字段前面放入‘宽度域值-1’个空格字符
        // 然后再放入参数字符
        // 如果宽度还是大于0，则表示为左对齐，则在参数字符后面添加‘宽度域值-1’个空格字符
		case 'c':
			if (!(flags & LEFT))
				while (--field_width > 0)
					*str++ = ' ';
			*str++ = (unsigned char) va_arg(args, int);
			while (--field_width > 0)
				*str++ = ' ';
			break;

        // 如果转换指示符是‘s’，则表示对应参数是字符串
        // 首先取参数字符串的长度，若其超过了精度域值，则扩展精度域值=字符串长度
        // 此时如果标志域不是左对齐，则该字段放入‘宽度值-字符传长度’个空格字符
        // 然后再放入参数字符串
        // 如果宽度还是大于0，则表示为左对齐，则在参数字符串后面添加‘宽度值-字符串长度’个字符
		case 's':
			s = va_arg(args, char *);
			len = strlen(s);
			if (precision < 0)
				precision = len;
			else if (len > precision)
				len = precision;

			if (!(flags & LEFT))
				while (len < field_width--)
					*str++ = ' ';
			for (i = 0; i < len; ++i)
				*str++ = *s++;
			while (len < field_width--)
				*str++ = ' ';
			break;

		// 如果格式转换符是‘o’，表示需要将对应的参数转换成八进制
        // 转换可以调用number()函数处理
        case 'o':
			str = number(str, va_arg(args, unsigned long), 8,
				field_width, precision, flags);
			break;

        // 如果格式转换符是‘p’，表示对应参数是一个指针类型。此时若该参数没有设置宽度域，则默认长度是8，并且需要填充0。然后调用number()函数实现
		case 'p':
			if (field_width == -1) {
				field_width = 8;
				flags |= ZEROPAD;
			}
			str = number(str,
				(unsigned long) va_arg(args, void *), 16,
				field_width, precision, flags);
			break;

        // 若格式转换指示符是‘x’或‘X’，则表示对应参数需要打印成十六进制输出
		case 'x':
			flags |= SMALL;
		case 'X':
			str = number(str, va_arg(args, unsigned long), 16,
				field_width, precision, flags);
			break;

        // 如果格式转换字符是‘d’、‘i’或‘u’，则表示对应参数是整数
        // ‘d’、‘i’代表符号整数，因此需要加上符号标志
        // ‘u’代表无符号整数
		case 'd':
		case 'i':
			flags |= SIGN;
		case 'u':
			str = number(str, va_arg(args, unsigned long), 10,
				field_width, precision, flags);
			break;

        // 若格式转换符是‘n’，则表示要把目前为止转换输出字符数保存到对应参数指针指定的位置
        // 首先利用va_arg取得该参数指针，然后将已经转换好的字符数存入该指针所指的位置
		case 'n':
			ip = va_arg(args, int *);
			*ip = (str - buf);
			break;

        // 若格式转换符不是‘%’，则表示格式字符串有错，直接将一个‘%’写入输出串中
        // 如果格式转换符的位置处还有字符，则也直接将该字符写入输出串中，并返回前面for循环继续处理格式字符串
        // 否则表示已经处理到格式字符串的结尾处，则退出循环
		default:
			if (*fmt != '%')
				*str++ = '%';
			if (*fmt)
				*str++ = *fmt;
			else
				--fmt;
			break;
		}
	}
	*str = '\0';
	return str-buf;
}


char array[50];

void test_func(char *format, ...)
{
    va_list ap;
    va_start(ap, format);
    my_vsprintf(array, format, ap);
    va_end(ap);
}



int main()
{
    test_func("%10d\n%s\n%-10d\n%-d\n%d\n", 123456, "asdf", 123456, 12345, 45678);
    printf("%s\n", array);
    
    // 测试宽度域
    printf("\n\n测试宽度域:\n");
    test_func("%*d\n", 10, 12345);
    printf("%s\n", array);
   

    // 测试精度
    printf("\n\n测试精度:\n");
    test_func("%2.8s\n", "1234.12345678");
    printf("%s", array);
    test_func("%2.10s\n", "1234.12345678");
    printf("%s", array);


    return 0;
}

运行截图：