vsprintf参考代码

/*

* linux/lib/vsprintf.c

*

* Copyright (C) 1991, 1992 Linus Torvalds

*/

/* vsprintf.c -- Lars Wirzenius & Linus Torvalds. */

/*

* Wirzenius wrote this portably, Torvalds fucked it up :-)

*/

#include

#include

#include

#include

#include

#if !defined (CONFIG_PANIC_HANG)

#include

/*cmd_boot.c*/

extern int do_reset (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]); #endif

#ifdef CONFIG_SYS_64BIT_VSPRINTF

#include

# define NUM_TYPE long long

#else

# define NUM_TYPE long

#define do_div(n, base) ({ \

unsigned int __res; \

__res = ((unsigned NUM_TYPE) n) % base; \

n = ((unsigned NUM_TYPE) n) / base; \

__res; \

})

#endif

#define noinline __attribute__((noinline))

const char hex_asc[] = "0123456789abcdef";

#define hex_asc_lo(x) hex_asc[((x) & 0x0f)]

#define hex_asc_hi(x) hex_asc[((x) & 0xf0) >> 4]

static inline char *pack_hex_byte(char *buf, u8 byte)

{

*buf++ = hex_asc_hi(byte);

*buf++ = hex_asc_lo(byte);

return buf;

}

// 此函数有以下几点值得注意：

// 1、第一个参数中的const。一般在函数的形参中，如果我们只是希望调用者使用该参数，而不会去改变该

// 参数内容（一般是指针指向的内容），则可以声明为const。

// 2、第二个参数。C语言中函数只能有一个返回值，但是有时候我们希望从函数中得到不止一个返回内容怎

// 么办呢？只能通过参数了。一般的参数是用来向函数输入信息的，但是指针型参数可以间接用来从函数

// 输出信息。使用时用户只需传入一个相应的指针，函数中会把需要输出的信息地址传给这个指针，这样

// 在函数调用完成后，用户即可到endp指针处去取函数传出的值了。这就是用参数实现返回值的方式。但是

// 要注意，在函数中千万不可把局部变量的地址传给输出型指针，因为局部变量存在栈里，函数调用结束后

// 即释放了，传出的指针指向的内容是栈上已经被释放的部分，因此是无效的。（PS：高级语言中

// 譬如C#有ref，out关键字，以明确指明该引用为输出型）

// 3、第三个参数base。要注意这个base的机制，本函数中是按照这样的理念来设计的。即如果str中有0x

// 开头且接下来是数字则忽略用户调用时输入的base，强制为16进制。如果str不是上面情况然后才看用户

// 输入的base。用户输入非0则使用用户指定的base，若用户输入0则自动判断是8进制还是10进制。

// 需要强调的是：使用习惯决定理念，理念决定代码逻辑。

// 4、注意if(endp)这里，在输出型参数使用中，函数内首先判断endp是否为NULL，并以此来决定是否输出

// 这个机制来自于一个理念：这个输出参数有可能是用户关注的，也有可能是用户不在意的。这样处理可以

// 给用户自由，即用户如果在意就传一个有效指针过来接收；如果不在意调用时直接给个NULL就行。提供

// 服务但不强迫，这样很好。在OS的API中很多时候都有类似的技巧，请注意体会。unsigned long simple_strtoul(const char *cp,char **endp,unsigned int base)

{

unsigned long result = 0,value;

// 对于base，首先如果*cp以0x开头且下来是数字，则一定为16进制。

// 然后如果用户指定了一个非0的进制，则遵循用户输入的进制。如果用户输入了0进制，则根据是否0开头来

// 确定是8进制还是10进制

if (*cp == '0') {

cp++;

if ((*cp == 'x') && isxdigit(cp[1])) {

base = 16; // 如果cp是0x开头的，下面一个又是数字，那么base 一定为16.此时即使

cp++; // 用户输入了一个base，也忽略这个base而强制其为16

}

if (!base) {

base = 8; // 如果用户输入base为0，cp是0开头，接下来不是x，} // 那么强制为8进制

}

if (!base) {

base = 10; // 如果用户输入base为0，cp是非0开头，则使用10进制。

}

// while循环里value

// 数字的字母。这个字母的范围取决于base，譬如如果是16进制那么f也算是数字。而如果是8进制那么

// 9都不算是数字了。因此解析结束的范围只能和base比较来限定。

while (isxdigit(*cp) && (value = isdigit(*cp) ? *cp-'0' : (islower(*cp)

? toupper(*cp) : *cp)-'A'+10) < base) {

result = result*base + value;

cp++;

}

if (endp) // 此处if判断的作用是：用户在使用这个函数时，如果不关心endp则可以直接使用

*endp = (char *)cp; // null,而不必担心程序运行会出错。这种处理技巧很实用，用户可以

return result; // 自行决定是否使用这个函数提供的参数式返回值。

}

long simple_strtol(const char *cp,char **endp,unsigned int base)

{

if(*cp=='-')

return -simple_strtoul(cp+1,endp,base);

return simple_strtoul(cp,endp,base);

}

// 这个函数中需要注意的是switch case中的一个特性：case中如果没有break，那么从前往后

// 第一个匹配的case项，之后每一个项目（不管case是否匹配）都会完全执行，直到遇到break

// 以前只知道没有break会延续下去，还以为延续的下面还需要case匹配才能执行。

int ustrtoul(const char *cp, char **endp, unsigned int base)

{

unsigned long result = simple_strtoul(cp, endp, base);

switch (**endp) {

case 'G' :

result *= 1024;

/* fall through */

case 'M':

result *= 1024;

/* fall through */

case 'K':

case 'k':

result *= 1024;

if ((*endp)[1] == 'i') {

if ((*endp)[2] == 'B')

(*endp) += 3;

else

(*endp) += 2;

}

}

return result;

}

#ifdef CONFIG_SYS_64BIT_STRTOUL

unsigned long long simple_strtoull (const char *cp, char **endp, unsigned int base) {

unsigned long long result = 0, value;

if (*cp == '0') {

cp++;

if ((*cp == 'x') && isxdigit (cp[1])) {

base = 16;

cp++;

}

if (!base) {

base = 8;

}

}

if (!base) {

base = 10;

}

while (isxdigit (*cp) && (value = isdigit (*cp)

? *cp - '0'

: (islower (*cp) ? toupper (*cp) : *cp) - 'A' + 10) < base) {

result = result * base + value;

cp++;

}

if (endp)

*endp = (char *) cp;

return result;

}

#endif /* CONFIG_SYS_64BIT_STRTOUL */

/* 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;

}

/* Decimal conversion is by far the most typical, and is used

* for /proc and /sys data. This directly impacts e.g. top performance

* with many processes running. We optimize it for speed

* using code from

* https://www.360docs.net/doc/ce17659434.html,/~jones/bcd/decimal.html

* (with permission from the author, Douglas W. Jones). */

/* Formats correctly any integer in [0,99999].

* Outputs from one to five digits depending on input.

* On i386 gcc 4.1.2 -O2: ~250 bytes of code. */

// 把q按照十进制格式化成字符串，然后依次存入buf中。注意q的// 十进制最低位在buf[0]中。例如q=1234时，buf[0]=4,buf[3]=1

// 其实用除非也可以很容易得到结果，但是除法太耗周期，效率低// 这里的算法实际上是高效优化后的代码

// 使用范围为0

{

unsigned d3, d2, d1, d0;

d1 = (q>>4) & 0xf;

d2 = (q>>8) & 0xf;

d3 = (q>>12);

d0 = 6*(d3 + d2 + d1) + (q & 0xf);

q = (d0 * 0xcd) >> 11;

d0 = d0 - 10*q;

*buf++ = d0 + '0'; /* least significant digit */

d1 = q + 9*d3 + 5*d2 + d1;

if (d1 != 0) {

q = (d1 * 0xcd) >> 11;

d1 = d1 - 10*q;

*buf++ = d1 + '0'; /* next digit */

d2 = q + 2*d2;

if ((d2 != 0) || (d3 != 0)) {

q = (d2 * 0xd) >> 7;

d2 = d2 - 10*q;

*buf++ = d2 + '0'; /* next digit */

d3 = q + 4*d3;

if (d3 != 0) {

q = (d3 * 0xcd) >> 11;

d3 = d3 - 10*q;

*buf++ = d3 + '0'; /* next digit */

if (q != 0)

*buf++ = q + '0'; /* most sign. digit */

}

}

}

return buf;

}

/* Same with if's removed. Always emits five digits */

// 这里是个5位的整数适用的方法

static char* put_dec_full(char *buf, unsigned q)

{

/* BTW, if q is in [0,9999], 8-bit ints will be enough, */

/* but anyway, gcc produces better code with full-sized ints */

unsigned d3, d2, d1, d0;

d1 = (q>>4) & 0xf;

d2 = (q>>8) & 0xf;

d3 = (q>>12);

/*

* Possible ways to approx. divide by 10

* gcc -O2 replaces multiply with shifts and adds

* (x * 0xcd) >> 11: 11001101 - shorter code than * 0x67 (on i386)

* (x * 0x67) >> 10: 1100111

* (x * 0x34) >> 9: 110100 - same

* (x * 0x1a) >> 8: 11010 - same

* (x * 0x0d) >> 7: 1101 - same, shortest code (on i386)

*/

d0 = 6*(d3 + d2 + d1) + (q & 0xf);

q = (d0 * 0xcd) >> 11;

d0 = d0 - 10*q;

*buf++ = d0 + '0';

d1 = q + 9*d3 + 5*d2 + d1;

q = (d1 * 0xcd) >> 11;

d1 = d1 - 10*q;

*buf++ = d1 + '0';

d2 = q + 2*d2;

q = (d2 * 0xd) >> 7;

d2 = d2 - 10*q;

*buf++ = d2 + '0';

d3 = q + 4*d3;

q = (d3 * 0xcd) >> 11; /* - shorter code */

/* q = (d3 * 0x67) >> 10; - would also work */

d3 = d3 - 10*q;

*buf++ = d3 + '0';

*buf++ = q + '0';

return buf;

}

/* No inlining helps gcc to use registers better */

static noinline char* put_dec(char *buf, unsigned NUM_TYPE num)

{

while (1) {

unsigned rem;

if (num < 100000)

return put_dec_trunc(buf, num);

rem = do_div(num, 100000);

buf = put_dec_full(buf, rem);

}

}

#define ZEROPAD 1 /* pad with zero 输出前补0填充满宽度*/

#define SIGN 2 /* unsigned/signed long 有符号数，默认为无符号*/

#define PLUS 4 /* show plus 在数字前显示+-号表示正负*/

#define SPACE 8 /* space if plus 输出为正时用空格，为负时用负号*/

#define LEFT 16 /* left justified 左对齐，右边填充空格*/

#define SMALL 32 /* Must be 32 == 0x20 字母为小写*/

#define SPECIAL 64 /* 0x 即在type为o x X时前面加上0 0x 0X */

// 格式化数字num到buf中

static char *number(char *buf, unsigned NUM_TYPE num, int base, int size, int precision, int type)

{

/* we are called with base 8, 10 or 16, only, thus don't need "G..." */

static const char digits[16] = "0123456789ABCDEF"; /* "GHIJKLMNOPQRSTUVWXYZ"; */

char tmp[66];

char sign;

char locase;

int need_pfx = ((type & SPECIAL) && base != 10);

int i;

/* locase = 0 or 0x20. ORing digits or letters with 'locase'

* produces same digits or (maybe lowercased) letters */

locase = (type & SMALL);

if (type & LEFT)

type &= ~ZEROPAD;

sign = 0;

if (type & SIGN) {

if ((signed NUM_TYPE) num < 0) {

sign = '-';

num = - (signed NUM_TYPE) num;

size--;

} else if (type & PLUS) {

sign = '+';

size--;

} else if (type & SPACE) {

sign = ' ';

size--;

}

}

if (need_pfx) {

size--;

if (base == 16)

size--;

}

/* generate full string in tmp[], in reverse order */

i = 0;

if (num == 0)

tmp[i++] = '0';

/* Generic code, for any base:

else do {

tmp[i++] = (digits[do_div(num,base)] | locase);

} while (num != 0);

*/

else if (base != 10) { /* 8 or 16 */

int mask = base - 1;

int shift = 3;

if (base == 16) shift = 4;

do {

tmp[i++] = (digits[((unsigned char)num) & mask] | locase);

num >>= shift;

} while (num);

} else { /* base 10 */

i = put_dec(tmp, num) - tmp;

}

/* printing 100 using %2d gives "100", not "00" */

if (i > precision)

precision = i;

/* leading space padding */

size -= precision;

if (!(type & (ZEROPAD+LEFT)))

while(--size >= 0)

*buf++ = ' ';

/* sign */

if (sign)

*buf++ = sign;

/* "0x" / "0" prefix */

if (need_pfx) {

*buf++ = '0';

if (base == 16)

*buf++ = ('X' | locase);

}

/* zero or space padding */

if (!(type & LEFT)) {

char c = (type & ZEROPAD) ? '0' : ' ';

while (--size >= 0)

*buf++ = c;

}

/* hmm even more zero padding? */

while (i <= --precision)

*buf++ = '0';

/* actual digits of result */

while (--i >= 0)

*buf++ = tmp[i];

/* trailing space padding */

while (--size >= 0)

*buf++ = ' ';

return buf;

}

// 格式化字符串s到buf中

static char *string(char *buf, char *s, int field_width, int precision, int flags)

{

int len, i;

if (s == 0)

s = "";

len = strnlen(s, precision);

if (!(flags & LEFT))

while (len < field_width--)

*buf++ = ' ';

for (i = 0; i < len; ++i)

*buf++ = *s++;

while (len < field_width--)

*buf++ = ' ';

return buf;

}

#ifdef CONFIG_CMD_NET

// 格式化addr指向的数字格式的u8数组装着的mac地址到buf中，用来打印static char *mac_address_string(char *buf, u8 *addr, int field_width,

int precision, int flags)

{

char mac_addr[6 * 3]; /* (6 * 2 hex digits), 5 colons and trailing zero */

char *p = mac_addr;

int i;

for (i = 0; i < 6; i++) {

p = pack_hex_byte(p, addr[i]);

if (!(flags & SPECIAL) && i != 5)

*p++ = ':';

}

*p = '\0';

return string(buf, mac_addr, field_width, precision, flags & ~SPECIAL); }

// 格式化ipv6的IP地址到buf中，源IP地址为u8数组

static char *ip6_addr_string(char *buf, u8 *addr, int field_width,

int precision, int flags)

{

char ip6_addr[8 * 5]; /* (8 * 4 hex digits), 7 colons and trailing zero */ char *p = ip6_addr;

int i;

for (i = 0; i < 8; i++) {

p = pack_hex_byte(p, addr[2 * i]);

p = pack_hex_byte(p, addr[2 * i + 1]);

if (!(flags & SPECIAL) && i != 7)

*p++ = ':';

}

*p = '\0';

return string(buf, ip6_addr, field_width, precision, flags & ~SPECIAL); }

// 格式化ipv4的IP地址到buf中

static char *ip4_addr_string(char *buf, u8 *addr, int field_width,

int precision, int flags)

{

char ip4_addr[4 * 4]; /* (4 * 3 decimal digits), 3 dots and trailing zero */ char temp[3]; /* hold each IP quad in reverse order */

char *p = ip4_addr;

int i, digits;

for (i = 0; i < 4; i++) {

digits = put_dec_trunc(temp, addr[i]) - temp;

/* reverse the digits in the quad */

while (digits--)

*p++ = temp[digits];

if (i != 3)

*p++ = '.';

}

*p = '\0';

return string(buf, ip4_addr, field_width, precision, flags & ~SPECIAL);

}

#endif

/*

* Show a '%p' thing. A kernel extension is that the '%p' is followed

* by an extra set of alphanumeric characters that are extended format

* specifiers.

*

* Right now we handle:

*

* - 'M' For a 6-byte MAC address, it prints the address in the

* usual colon-separated hex notation

* - 'I' [46] for IPv4/IPv6 addresses printed in the usual way (dot-separated

* decimal for v4 and colon separated network-order 16 bit hex for v6)

* - 'i' [46] for 'raw' IPv4/IPv6 addresses, IPv6 omits the colons, IPv4 is

* currently the same

*

* Note: The difference between 'S' and 'F' is that on ia64 and ppc64

* function pointers are really function descriptors, which contain a

* pointer to the real address.

*/

static char *pointer(const char *fmt, char *buf, void *ptr, int field_width, int precision, int flags) {

if (!ptr)

return string(buf, "(null)", field_width, precision, flags);

#ifdef CONFIG_CMD_NET

switch (*fmt) {

case 'm':

flags |= SPECIAL;

/* Fallthrough */

case 'M':

return mac_address_string(buf, ptr, field_width, precision, flags);

case 'i':

flags |= SPECIAL;

/* Fallthrough */

case 'I':

if (fmt[1] == '6')

return ip6_addr_string(buf, ptr, field_width, precision, flags);

if (fmt[1] == '4')

return ip4_addr_string(buf, ptr, field_width, precision, flags);

flags &= ~SPECIAL;

break;

}

#endif

flags |= SMALL;

if (field_width == -1) {

field_width = 2*sizeof(void *);

flags |= ZEROPAD;

}

return number(buf, (unsigned long) ptr, 16, field_width, precision, flags); }

/**

* vsprintf - Format a string and place it in a buffer

* @buf: The buffer to place the result into

* @fmt: The format string to use

* @args: Arguments for the format string

*

* This function follows C99 vsprintf, but has some extensions:

* %pS output the name of a text symbol

* %pF output the name of a function pointer

* %pR output the address range in a struct resource

*

* The function returns the number of characters written

* into @buf.

*

* Call this function if you are already dealing with a va_list.

* You probably want sprintf() instead.

*/

int vsprintf(char *buf, const char *fmt, va_list args)

{

unsigned NUM_TYPE num;

int base;

char *str;

int flags; /* flags to number() */

int field_width; /* width of output field */

int precision; /* min. # of digits for integers; max 小数点后位数

number of chars for from string */

int qualifier; /* 'h', 'l', or 'L' for integer fields */

/* 'z' support added 23/7/1999 S.H. */

/* 'z' changed to 'Z' --davidm 1/25/99 */

/* 't' added for ptrdiff_t */

str = buf;

for (; *fmt ; ++fmt) {

if (*fmt != '%') {

*str++ = *fmt;

continue;

}

/* 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;

}

/* get field width */

field_width = -1;

if (is_digit(*fmt)) // 如果是数字，则计算连续是数字的字母，将其转为int即是

field_width = skip_atoi(&fmt);

else if (*fmt == '*') { // *表示格式列表中，下一个参数还是width

++fmt;

/* it's the next argument */

field_width = va_arg(args, int);

if (field_width < 0) {

field_width = -field_width;

flags |= LEFT;

}

}

/* get the precision */

precision = -1;

if (*fmt == '.') {

++fmt;

if (is_digit(*fmt))

precision = skip_atoi(&fmt);

else if (*fmt == '*') { // *表示下一个格式参数还是precision

++fmt;

/* it's the next argument */

precision = va_arg(args, int);

}

if (precision < 0)

precision = 0;

}

/* get the conversion qualifier */

qualifier = -1;

if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' || // h 代表int

*fmt == 'Z' || *fmt == 'z' || *fmt == 't') { // l 代表long / float

qualifier = *fmt; // L 代表long long / double

++fmt; // Z /z 代表size_t

if (qualifier == 'l' && *fmt == 'l') { // t 代表ptrdiff_t

qualifier = 'L';

++fmt;

}

}

/* default base */

base = 10;

switch (*fmt) {

case 'c': // c 打印单个字符

if (!(flags & LEFT))

while (--field_width > 0)

*str++ = ' ';

*str++ = (unsigned char) va_arg(args, int);

while (--field_width > 0)

*str++ = ' ';

continue;

case 's': // s 打印字符串

str = string(str, va_arg(args, char *), field_width, precision, flags);

continue;

case 'p': // p 打印指针，即该指针变量本身地址，pm或者pM 打印MAC地址，

str = pointer(fmt+1, str, // pi4(pI4)打印IPV4地址，pi6(PI6)打印IPV6地址

va_arg(args, void *),

field_width, precision, flags);

/* Skip all alphanumeric pointer suffixes */

while (isalnum(fmt[1]))

fmt++;

continue;

case 'n':

if (qualifier == 'l') {

long * ip = va_arg(args, long *);

*ip = (str - buf); // 将已写字符的个数放入%n相连的指针内。这个指针是int

} else { // 还是long取决于qualifier

int * ip = va_arg(args, int *);

*ip = (str - buf);

}

continue;

case '%':

*str++ = '%';

continue;

/* integer number formats - set up the flags and "break" */

case 'o':

base = 8; // o 8进制无符号

break;

case 'x':

flags |= SMALL; // x 无符号16进制，且a~f为小写

case 'X':

base = 16; // X 无符号16进制，且A~F为大写

break;

case 'd':

case 'i':

flags |= SIGN; // d,i 有符号十进制整数

case 'u': // u 无符号十进制整数

break;

default: // f(浮点数)，e(科学计数法表示的浮点数)这些这里没做支持

*str++ = '%';

if (*fmt)

*str++ = *fmt;

else

--fmt;

continue;

}

#ifdef CONFIG_SYS_64BIT_VSPRINTF

if (qualifier == 'L') /* "quad" for 64 bit variables */

num = va_arg(args, unsigned long long);

else

#endif

if (qualifier == 'l') {

num = va_arg(args, unsigned long);

if (flags & SIGN)

num = (signed long) num;

} else if (qualifier == 'Z' || qualifier == 'z') {

num = va_arg(args, size_t);

} else if (qualifier == 't') {

num = va_arg(args, ptrdiff_t);

} else if (qualifier == 'h') {

num = (unsigned short) va_arg(args, int);

if (flags & SIGN)

num = (signed short) num;

} else {

num = va_arg(args, unsigned int);

if (flags & SIGN)

num = (signed int) num;

}

str = number(str, num, base, field_width, precision, flags);

}

*str = '\0';

return str-buf;

}

/**

* sprintf - Format a string and place it in a buffer

* @buf: The buffer to place the result into

* @fmt: The format string to use

* @...: Arguments for the format string

*

* The function returns the number of characters written

* into @buf.

*

* See the vsprintf() documentation for format string extensions over C99. */

int sprintf(char * buf, const char *fmt, ...)

{

va_list args;

int i;

va_start(args, fmt);

i=vsprintf(buf,fmt,args);

va_end(args);

return i;

}

void panic(const char *fmt, ...)

{

va_list args;

va_start(args, fmt);

vprintf(fmt, args);

putc('\n');

va_end(args);

#if defined (CONFIG_PANIC_HANG)

hang();

#else

udelay (100000); /* allow messages to go out */ do_reset (NULL, 0, 0, NULL);

#endif

}