碼上歡樂
相關內容    簡體    繁體

嵌入式操作系統---打印函數（printf/sprintf）的實現

本文轉載自   查看原文   2019-01-08 09:22   798    編程語法

https://blog.csdn.net/u010961173/article/details/79769747

格式化輸出函數：printf/sprintf/fprintf/snprintf等等

一、打印函數簡介

作用：將“給定的內容”按照“指定的格式”輸出到“指定目標內”。

打印函數的基本格式：

 

char print_buf[BUF_SIZE];
void printf(const char *fmt, ...)
{
    va_list ap;//定義一個指針變量
    unsigned int i;
 
    va_start (ap, fmt);
    i = vsprintf (print_buf, sizeof(print_buf),fmt, ap);
    va_end (args);
 
    __put_char (print_buf,i);
}

 

printf(const char *fmt,...)是一個可變參數函數，第一個參數為字符串，后面是格式化輸出參數列表。

c語言中函數的參數都是壓進棧里的，可變參數函數必須有一個參數表示參數的個數，才能讓編譯器知道要壓進棧多少參數，以及函數返回時彈出多少參數，printf（char *fmt,...）實現這個功能的是fmt字符串，里面有多少'%'，就代表后面有多少個參數，所以我們必須提取出fmt字符串中'%'的個數，以及針對'%'后面不同的字符來處理參數。

 

const char *fmt定義了一個只讀字符指針；“...”表示printf的參數是可變的；

 

va_list ap：定義一個字符型指針變量

 

va_start(argv,i)：初始化argv

 

c=va_arg(argv,int)：在已知變量的情況下，獲得下一個變參變量

 

va_end(argv)：結束變參變量操作

 

其中，__put_char()將字符逐個打印到串口輸出寄存器中。

void __put_char(char *p,int num){
while(*p&&num--){
*(volatile unsigned int *)0xd0000020=*p++;
};
}

 

二、打印函數的實現

 

1、變參函數的實現（宏定義）

（1）va_list

typedef char * va_list;
va_list       ap;        //定義一個指針類型

（2）va_start(ap,fmt) 

#define va_start(ap,fmt) ( ap = (va_list)&fmt + _INTSIZEOF(fmt) )

ap指向函數棧中變參列表第一個參數的首地址；

____________________________

|___________________________|

|                      argn                              |

|                      ........                              |

|                      arg0                              |<----ap(sizeof(int)大小對齊)

|                      fmt                                 |

|                      pc                                  |

|___________________________|

 

注意：傳給宏va_start的參數fmt是可變參數列表中的前一個參數，ap指向變參列表中第一個參數地址。

注意：函數參數壓棧時，參數的入棧順序是從右向左，出棧時是從左向右。函數調用時，先把若干個參數都壓入棧中，再壓fmt，最后壓pc，這樣一來，棧頂指針偏移便找到了fmt，通過fmt中的%占位符，取得后面參數的個數，從而正確取得所有參數。

 

#define _INTSIZEOF(n)   ((sizeof(n)+sizeof(int)-1)&~(sizeof(int) - 1) )

 

計算int類型按4字節（int占4字節）對齊后的結果。通過使用_INTSIZEOF(n)，可以根據一個變量的類型計算變量在內存中占用的字節數，從而正確定位參數在內存的位置。

對於short、char類型的數據，因為不滿一個int類型的內存空間，所以按照int類型對齊；

（3）va_arg(ap,type)

#define va_arg(ap,type) ( *(type *)((ap += _INTSIZEOF(type)) - _INTSIZEOF(type)) )

指針變量ap本身指向變參列表中的下一個參數地址，va_arg取出的是當前參數的值

（4）va_end(ap)

#define va_end(ap)    ( ap = (va_list)0 )

ap指向空

2、vsprintf(char *buf, const char *fmt, va_list args)函數實現

函數功能：將變量列表args中的參數按照fmt中規定的格式保存到臨時緩存buf中。

int vsprintf(char *buf, canst char *fmt, va_list args) 
{
    unsigned NUM_TYPE num;
    int base;
    char*str;
    int flags;
    int field_width;
    int Precision;
    int qualifier;
    str = bUf;
 
    for (; *fmt ; ++fmt) 
    {
        if (* fmt ! = ' % ' )
        {
            *str++ = *fmt;
            continue;
        }
 
        /* process flags */
        flags = 0;
        repeat:
        ++fmt;/* skip first "%" */
 
        switch(*fmt)
        {
            case '- ' : flags |= LEFT;goto repeat;
            case '+ ' : flags |= PLUS;goto repeat;
            ...
        }
        ...
        base = 10;
 
        switch (*fmt){
        case 'c':
            ...
            *str++ (unsigned char)va_arg(args,int);
            ...
        continue;
 
 
        case 's':
            str = string(str,va_arg(args, char *),field_width,precision,flags);
        continue;
        ...
 
        case ' X ' :
            base = 16;
        break;
 
        case 'd':
 
 
        case ' i '
            flags |= SIGN;
 
        case 'u':
            break;
 
        default:
            * str++ ='%';
        if (*fmt)
            *str++ = *fmt;
        else
            --fmt ;
            continue;
        }
        str = number (str, num, base, field_width, precision, flags) ;
 
    }
    *str == '\0';
 
    return str-buf;
}

 

三、實現自己的打印函數

int vsnprintf(char *buf, int size, const char *fmt, va_list args){
    int num;
    char *str, *end, c,*s;
    int read;
    unsigned int spec=0;

    str = buf;//臨時緩存buf首地址
    end = buf + size;//臨時緩存buff結束地址

    if (end < buf) {
        end = ((void *)-1);
        size = end - buf;
    }

    while (*fmt) {
        const char *old_fmt = fmt;//保存原來fmt的格式的首地址

        read = <strong><span style="color:#ff0000;">format_decode</span></strong>(fmt, &spec);//判斷參數的格式，保存到spec中，read為當前參數在字符串中的指針偏移
        fmt += read;//指針偏移到本參數格式的下一位字符的地址

        if((FORMAT_TYPE(spec))==FORMAT_TYPE_NONE){
            int copy = read;
            if (str < end) {
                if (copy > end - str)//防止buff空間不足越界
                    copy = end - str;
                    memcpy(str, old_fmt, copy);//原樣拷貝到buff中
            }
            str += read;//更新字符偏移


        }else if(spec&FORMAT_FLAG_WIDTH){
            //do nothing
        }else if(FORMAT_TYPE(spec)==FORMAT_TYPE_CHAR){//字符類型，直接拷貝
            c = (unsigned char) va_arg(args, int);
            if (str < end)
                *str = c;
            ++str;
        }else if(FORMAT_TYPE(spec)==FORMAT_TYPE_STR){//字符串類型，直接拷貝
            s = (char *) va_arg(args, char *);
            while(str<end&&*s!='\0'){
                *str++=*s++;
            }
        }else{//數值型，進行轉換
            if(FORMAT_TYPE(spec)==FORMAT_TYPE_INT){
                num = va_arg(args, int);
            }else if(FORMAT_TYPE(spec)==FORMAT_TYPE_ULONG){
                num = va_arg(args, unsigned long);
            }else if(FORMAT_TYPE(spec)==FORMAT_TYPE_LONG){
                num = va_arg(args, long);
            }else if(FORMAT_TYPE(spec)==FORMAT_TYPE_SIZE_T){
                num = va_arg(args, int);
            }else if(FORMAT_TYPE(spec)==FORMAT_TYPE_USHORT){
                num = (unsigned short) va_arg(args, int);
            }else if(FORMAT_TYPE(spec)==FORMAT_TYPE_SHORT){
                num = (short) va_arg(args, int);
            }else{
                num = va_arg(args, unsigned int);
            }
                str=<strong><span style="color:#ff0000;">number</span></strong>(str,num,spec&FORMAT_BASE_MASK,spec);
        }
    }
    if (size > 0) {
        if (str < end)
            *str = '\0';
        else
            end[-1] = '\0';
    }
    return str-buf;
}

format_decode(fmt, &spec);//判斷參數的格式，保存到spec中，read為當前參數在字符串中的指針偏移
		fmt += read;//指針偏移到本參數格式的下一位字符的地址

		if((FORMAT_TYPE(spec))==FORMAT_TYPE_NONE){
			int copy = read;
			if (str < end) {
				if (copy > end - str)//防止buff空間不足越界
					copy = end - str;
					memcpy(str, old_fmt, copy);//原樣拷貝到buff中
			}
			str += read;//更新字符偏移


		}else if(spec&FORMAT_FLAG_WIDTH){
			//do nothing
		}else if(FORMAT_TYPE(spec)==FORMAT_TYPE_CHAR){//字符類型，直接拷貝
			c = (unsigned char) va_arg(args, int);
			if (str < end)
				*str = c;
			++str;
		}else if(FORMAT_TYPE(spec)==FORMAT_TYPE_STR){//字符串類型，直接拷貝
			s = (char *) va_arg(args, char *);
			while(str<end&&*s!='\0'){
				*str++=*s++;
			}
		}else{//數值型，進行轉換
			if(FORMAT_TYPE(spec)==FORMAT_TYPE_INT){
				num = va_arg(args, int);
			}else if(FORMAT_TYPE(spec)==FORMAT_TYPE_ULONG){
				num = va_arg(args, unsigned long);
			}else if(FORMAT_TYPE(spec)==FORMAT_TYPE_LONG){
				num = va_arg(args, long);
			}else if(FORMAT_TYPE(spec)==FORMAT_TYPE_SIZE_T){
				num = va_arg(args, int);
			}else if(FORMAT_TYPE(spec)==FORMAT_TYPE_USHORT){
				num = (unsigned short) va_arg(args, int);
			}else if(FORMAT_TYPE(spec)==FORMAT_TYPE_SHORT){
				num = (short) va_arg(args, int);
			}else{
				num = va_arg(args, unsigned int);
			}
				str=number(str,num,spec&FORMAT_BASE_MASK,spec);
		}
	}
	if (size > 0) {
		if (str < end)
			*str = '\0';
		else
			end[-1] = '\0';
	}
	return str-buf;
}

 

（1）format_decode函數

作用：判斷格式化的符號及類型；

flags：第0字節：若為數值，作為數值基數；
           第1字節：格式類型，字符，整形，長整型，短整型等；
           第2字節：若為數值，表示數值符號；

int format_decode(const char *fmt,unsigned int *flags){
    const char *start = fmt;
 
    *flags &= ~FORMAT_TYPE_MASK;
    *flags |= FORMAT_TYPE_NONE;
    for (; *fmt ; ++fmt) {
        if (*fmt == '%')
        break;
    }
 
    if (fmt != start || !*fmt)
        return fmt - start;
 
    do{
        fmt++;
        switch(*fmt){
            case 'l':
                SET_FORMAT_FLAG(*flags,FORMAT_FLAG_WIDTH);
                break;
            default:
                break;
        }
    }while(0);
    
    SET_FORMAT_BASE(*flags,FORMAT_BASE_D);
    switch (*fmt) {
        case 'c':
            SET_FORMAT_TYPE(*flags,FORMAT_TYPE_CHAR);
            break;
 
        case 's':
            SET_FORMAT_TYPE(*flags,FORMAT_TYPE_STR);
            break;
 
        case 'o':
            SET_FORMAT_BASE(*flags,FORMAT_BASE_O);
            SET_FORMAT_TYPE(*flags,FORMAT_TYPE_UINT);
            break;
 
        case 'x':
        case 'X':
            SET_FORMAT_BASE(*flags,FORMAT_BASE_X);
            SET_FORMAT_TYPE(*flags,FORMAT_TYPE_UINT);
            break;
 
        case 'd':
        case 'i':
            SET_FORMAT_TYPE(*flags,FORMAT_TYPE_INT);
            SET_FORMAT_BASE(*flags,FORMAT_BASE_D);
            break;
        case 'u':
            SET_FORMAT_TYPE(*flags,FORMAT_TYPE_UINT);
            SET_FORMAT_BASE(*flags,FORMAT_BASE_D);
            break;
 
    default:
        break;
    }
    return ++fmt-start;//參數偏移的字節數
}
SET_FORMAT_FLAG(*flags,FORMAT_FLAG_WIDTH);
                break;
            default:
                break;
        }
    }while(0);
    
    SET_FORMAT_BASE(*flags,FORMAT_BASE_D);
    switch (*fmt) {
        case 'c':
            SET_FORMAT_TYPE(*flags,FORMAT_TYPE_CHAR);
            break;

        case 's':
            SET_FORMAT_TYPE(*flags,FORMAT_TYPE_STR);
            break;

        case 'o':
            SET_FORMAT_BASE(*flags,FORMAT_BASE_O);
            SET_FORMAT_TYPE(*flags,FORMAT_TYPE_UINT);
            break;

        case 'x':
        case 'X':
            SET_FORMAT_BASE(*flags,FORMAT_BASE_X);
            SET_FORMAT_TYPE(*flags,FORMAT_TYPE_UINT);
            break;

        case 'd':
        case 'i':
            SET_FORMAT_TYPE(*flags,FORMAT_TYPE_INT);
            SET_FORMAT_BASE(*flags,FORMAT_BASE_D);
            break;
        case 'u':
            SET_FORMAT_TYPE(*flags,FORMAT_TYPE_UINT);
            SET_FORMAT_BASE(*flags,FORMAT_BASE_D);
            break;

    default:
        break;
    }
    return ++fmt-start;//參數偏移的字節數
}

SET_FORMAT_FLAG(*flags,FORMAT_FLAG_WIDTH);
				break;
			default:
				break;
		}
	}while(0);
	
	SET_FORMAT_BASE(*flags,FORMAT_BASE_D);
	switch (*fmt) {
		case 'c':
			SET_FORMAT_TYPE(*flags,FORMAT_TYPE_CHAR);
			break;

		case 's':
			SET_FORMAT_TYPE(*flags,FORMAT_TYPE_STR);
			break;

		case 'o':
			SET_FORMAT_BASE(*flags,FORMAT_BASE_O);
			SET_FORMAT_TYPE(*flags,FORMAT_TYPE_UINT);
			break;

		case 'x':
		case 'X':
			SET_FORMAT_BASE(*flags,FORMAT_BASE_X);
			SET_FORMAT_TYPE(*flags,FORMAT_TYPE_UINT);
			break;

		case 'd':
		case 'i':
			SET_FORMAT_TYPE(*flags,FORMAT_TYPE_INT);
			SET_FORMAT_BASE(*flags,FORMAT_BASE_D);
			break;
		case 'u':
			SET_FORMAT_TYPE(*flags,FORMAT_TYPE_UINT);
			SET_FORMAT_BASE(*flags,FORMAT_BASE_D);
			break;

	default:
		break;
	}
	return ++fmt-start;//參數偏移的字節數
}

（2）number函數

函數功能：根據類型進行數值轉換

char *number(char *str, int num,int base,unsigned int flags){
    int i=0;
    int sign=0;
 
    if(FORMAT_SIGNED(flags)&&(signed int)num<0){
        sign=1;
        num=~num+1;
    }
 
    do{
        numbers[i++]=digits[do_div(num,base)];
    }while(num!=0);
    
 
    if(FORMAT_BASE(flags)==FORMAT_BASE_O){
        numbers[i++]='0';
    }else if(FORMAT_BASE(flags)==FORMAT_BASE_X){
        numbers[i++]='x';
        numbers[i++]='0';
    }else if(FORMAT_BASE(flags)==FORMAT_BASE_B){
        numbers[i++]='b';
        numbers[i++]='0';
    }
    if(sign)
        numbers[i++]='-';
 
    while (i-- > 0)
            *str++ = numbers[i];
    return str;
}

 

嵌入式操作系統---打印函數（printf/sprintf）的實現

2018年03月31日 23:22:28    閱讀數：553
 
 版權聲明：本文為博主原創文章，未經博主允許不得轉載。 https://blog.csdn.net/u010961173/article/details/79769747

格式化輸出函數：printf/sprintf/fprintf/snprintf等等

一、打印函數簡介

作用：將“給定的內容”按照“指定的格式”輸出到“指定目標內”。

打印函數的基本格式：

  1.  
    char print_buf[BUF_SIZE];
  2.  
    void printf(const char *fmt, ...)
  3.  
    {
  4.  
    va_list ap; //定義一個指針變量
  5.  
    unsigned int i;
  6.  
     
  7.  
    va_start (ap, fmt);
  8.  
    i = vsprintf (print_buf, sizeof(print_buf),fmt, ap);
  9.  
    va_end (args);
  10.  
     
  11.  
    __put_char (print_buf,i);
  12.  
    }

printf(const char *fmt,...)是一個可變參數函數，第一個參數為字符串，后面是格式化輸出參數列表。
c語言中函數的參數都是壓進棧里的，可變參數函數必須有一個參數表示參數的個數，才能讓編譯器知道要壓進棧多少參數，以及函數返回時彈出多少參數，printf（char *fmt,...）實現這個功能的是fmt字符串，里面有多少'%'，就代表后面有多少個參數，所以我們必須提取出fmt字符串中'%'的個數，以及針對'%'后面不同的字符來處理參數。

const char *fmt定義了一個只讀字符指針；“...”表示printf的參數是可變的；

va_list ap：定義一個字符型指針變量

va_start(argv,i)：初始化argv

c=va_arg(argv,int)：在已知變量的情況下，獲得下一個變參變量

va_end(argv)：結束變參變量操作

其中，__put_char()將字符逐個打印到串口輸出寄存器中。

void __put_char(char *p,int num){
while(*p&&num--){
*(volatile unsigned int *)0xd0000020=*p++;
};
}

二、打印函數的實現

1、變參函數的實現（宏定義）

（1）va_list

  1.  
    typedef char * va_list;
  2.  
    va_list ap; //定義一個指針類型

（2）va_start(ap,fmt) 

#define va_start(ap,fmt) ( ap = (va_list)&fmt + _INTSIZEOF(fmt) )

ap指向函數棧中變參列表第一個參數的首地址；

____________________________
|___________________________|
|                      argn                              |
|                      ........                              |
|                      arg0                              |<----ap(sizeof(int)大小對齊)
|                      fmt                                 |
|                      pc                                  |
|___________________________|

注意：傳給宏va_start的參數fmt是可變參數列表中的前一個參數，ap指向變參列表中第一個參數地址。
注意：函數參數壓棧時，參數的入棧順序是從右向左，出棧時是從左向右。函數調用時，先把若干個參數都壓入棧中，再壓fmt，最后壓pc，這樣一來，棧頂指針偏移便找到了fmt，通過fmt中的%占位符，取得后面參數的個數，從而正確取得所有參數。

#define _INTSIZEOF(n) ((sizeof(n)+sizeof(int)-1)&~(sizeof(int) - 1) )

計算int類型按4字節（int占4字節）對齊后的結果。通過使用_INTSIZEOF(n)，可以根據一個變量的類型計算變量在內存中占用的字節數，從而正確定位參數在內存的位置。

對於short、char類型的數據，因為不滿一個int類型的內存空間，所以按照int類型對齊；

（3）va_arg(ap,type)

#define va_arg(ap,type) ( *(type *)((ap += _INTSIZEOF(type)) - _INTSIZEOF(type)) )

指針變量ap本身指向變參列表中的下一個參數地址，va_arg取出的是當前參數的值

（4）va_end(ap)

#define va_end(ap) ( ap = (va_list)0 )

ap指向空

 

2、vsprintf(char *buf, const char *fmt, va_list args)函數實現

函數功能：將變量列表args中的參數按照fmt中規定的格式保存到臨時緩存buf中。

  1.  
    int vsprintf(char *buf, canst char *fmt, va_list args)
  2.  
    {
  3.  
    unsigned NUM_TYPE num;
  4.  
    int base;
  5.  
    char*str;
  6.  
    int flags;
  7.  
    int field_width;
  8.  
    int Precision;
  9.  
    int qualifier;
  10.  
    str = bUf;
  11.  
     
  12.  
    for (; *fmt ; ++fmt)
  13.  
    {
  14.  
    if (* fmt ! = ' % ' )
  15.  
    {
  16.  
    *str++ = *fmt;
  17.  
    continue;
  18.  
    }
  19.  
     
  20.  
    /* process flags */
  21.  
    flags = 0;
  22.  
    repeat:
  23.  
    ++fmt; /* skip first "%" */
  24.  
     
  25.  
    switch(*fmt)
  26.  
    {
  27.  
    case '- ' : flags |= LEFT; goto repeat;
  28.  
    case '+ ' : flags |= PLUS; goto repeat;
  29.  
    ...
  30.  
    }
  31.  
    ...
  32.  
    base = 10;
  33.  
     
  34.  
    switch (*fmt){
  35.  
    case 'c':
  36.  
    ...
  37.  
    *str++ ( unsigned char)va_arg(args, int);
  38.  
    ...
  39.  
    continue;
  40.  
     
  41.  
     
  42.  
    case 's':
  43.  
    str = string(str,va_arg(args, char *),field_width,precision,flags);
  44.  
    continue;
  45.  
    ...
  46.  
     
  47.  
    case ' X ' :
  48.  
    base = 16;
  49.  
    break;
  50.  
     
  51.  
    case 'd':
  52.  
     
  53.  
     
  54.  
    case ' i '
  55.  
    flags |= SIGN;
  56.  
     
  57.  
    case 'u':
  58.  
    break;
  59.  
     
  60.  
    default:
  61.  
    * str++ = '%';
  62.  
    if (*fmt)
  63.  
    *str++ = *fmt;
  64.  
    else
  65.  
    --fmt ;
  66.  
    continue;
  67.  
    }
  68.  
    str = number (str, num, base, field_width, precision, flags) ;
  69.  
     
  70.  
    }
  71.  
    *str == '\0';
  72.  
     
  73.  
    return str-buf;
  74.  
    }

三、實現自己的打印函數

int vsnprintf(char *buf, int size, const char *fmt, va_list args){
	int num;
	char *str, *end, c,*s;
	int read;
	unsigned int spec=0;

	str = buf;//臨時緩存buf首地址
	end = buf + size;//臨時緩存buff結束地址

	if (end < buf) {
		end = ((void *)-1);
		size = end - buf;
	}

	while (*fmt) {
		const char *old_fmt = fmt;//保存原來fmt的格式的首地址

		read = <strong><span style="color:#ff0000;">format_decode</span></strong>(fmt, &spec);//判斷參數的格式，保存到spec中，read為當前參數在字符串中的指針偏移
		fmt += read;//指針偏移到本參數格式的下一位字符的地址

		if((FORMAT_TYPE(spec))==FORMAT_TYPE_NONE){
			int copy = read;
			if (str < end) {
				if (copy > end - str)//防止buff空間不足越界
					copy = end - str;
					memcpy(str, old_fmt, copy);//原樣拷貝到buff中
			}
			str += read;//更新字符偏移


		}else if(spec&FORMAT_FLAG_WIDTH){
			//do nothing
		}else if(FORMAT_TYPE(spec)==FORMAT_TYPE_CHAR){//字符類型，直接拷貝
			c = (unsigned char) va_arg(args, int);
			if (str < end)
				*str = c;
			++str;
		}else if(FORMAT_TYPE(spec)==FORMAT_TYPE_STR){//字符串類型，直接拷貝
			s = (char *) va_arg(args, char *);
			while(str<end&&*s!='\0'){
				*str++=*s++;
			}
		}else{//數值型，進行轉換
			if(FORMAT_TYPE(spec)==FORMAT_TYPE_INT){
				num = va_arg(args, int);
			}else if(FORMAT_TYPE(spec)==FORMAT_TYPE_ULONG){
				num = va_arg(args, unsigned long);
			}else if(FORMAT_TYPE(spec)==FORMAT_TYPE_LONG){
				num = va_arg(args, long);
			}else if(FORMAT_TYPE(spec)==FORMAT_TYPE_SIZE_T){
				num = va_arg(args, int);
			}else if(FORMAT_TYPE(spec)==FORMAT_TYPE_USHORT){
				num = (unsigned short) va_arg(args, int);
			}else if(FORMAT_TYPE(spec)==FORMAT_TYPE_SHORT){
				num = (short) va_arg(args, int);
			}else{
				num = va_arg(args, unsigned int);
			}
				str=<strong><span style="color:#ff0000;">number</span></strong>(str,num,spec&FORMAT_BASE_MASK,spec);
		}
	}
	if (size > 0) {
		if (str < end)
			*str = '\0';
		else
			end[-1] = '\0';
	}
	return str-buf;
}format_decode(fmt, &spec);//判斷參數的格式，保存到spec中，read為當前參數在字符串中的指針偏移
		fmt += read;//指針偏移到本參數格式的下一位字符的地址

		if((FORMAT_TYPE(spec))==FORMAT_TYPE_NONE){
			int copy = read;
			if (str < end) {
				if (copy > end - str)//防止buff空間不足越界
					copy = end - str;
					memcpy(str, old_fmt, copy);//原樣拷貝到buff中
			}
			str += read;//更新字符偏移


		}else if(spec&FORMAT_FLAG_WIDTH){
			//do nothing
		}else if(FORMAT_TYPE(spec)==FORMAT_TYPE_CHAR){//字符類型，直接拷貝
			c = (unsigned char) va_arg(args, int);
			if (str < end)
				*str = c;
			++str;
		}else if(FORMAT_TYPE(spec)==FORMAT_TYPE_STR){//字符串類型，直接拷貝
			s = (char *) va_arg(args, char *);
			while(str<end&&*s!='\0'){
				*str++=*s++;
			}
		}else{//數值型，進行轉換
			if(FORMAT_TYPE(spec)==FORMAT_TYPE_INT){
				num = va_arg(args, int);
			}else if(FORMAT_TYPE(spec)==FORMAT_TYPE_ULONG){
				num = va_arg(args, unsigned long);
			}else if(FORMAT_TYPE(spec)==FORMAT_TYPE_LONG){
				num = va_arg(args, long);
			}else if(FORMAT_TYPE(spec)==FORMAT_TYPE_SIZE_T){
				num = va_arg(args, int);
			}else if(FORMAT_TYPE(spec)==FORMAT_TYPE_USHORT){
				num = (unsigned short) va_arg(args, int);
			}else if(FORMAT_TYPE(spec)==FORMAT_TYPE_SHORT){
				num = (short) va_arg(args, int);
			}else{
				num = va_arg(args, unsigned int);
			}
				str=number(str,num,spec&FORMAT_BASE_MASK,spec);
		}
	}
	if (size > 0) {
		if (str < end)
			*str = '\0';
		else
			end[-1] = '\0';
	}
	return str-buf;
}

（1）format_decode函數

作用：判斷格式化的符號及類型；

flags：第0字節：若為數值，作為數值基數；
           第1字節：格式類型，字符，整形，長整型，短整型等；
           第2字節：若為數值，表示數值符號；

  1.  
    int format_decode(const char *fmt,unsigned int *flags){
  2.  
    const char *start = fmt;
  3.  
     
  4.  
    *flags &= ~FORMAT_TYPE_MASK;
  5.  
    *flags |= FORMAT_TYPE_NONE;
  6.  
    for (; *fmt ; ++fmt) {
  7.  
    if (*fmt == '%')
  8.  
    break;
  9.  
    }
  10.  
     
  11.  
    if (fmt != start || !*fmt)
  12.  
    return fmt - start;
  13.  
     
  14.  
    do{
  15.  
    fmt++;
  16.  
    switch(*fmt){
  17.  
    case 'l':
  18.  
    SET_FORMAT_FLAG(*flags,FORMAT_FLAG_WIDTH);
  19.  
    break;
  20.  
    default:
  21.  
    break;
  22.  
    }
  23.  
    } while( 0);
  24.  
     
  25.  
    SET_FORMAT_BASE(*flags,FORMAT_BASE_D);
  26.  
    switch (*fmt) {
  27.  
    case 'c':
  28.  
    SET_FORMAT_TYPE(*flags,FORMAT_TYPE_CHAR);
  29.  
    break;
  30.  
     
  31.  
    case 's':
  32.  
    SET_FORMAT_TYPE(*flags,FORMAT_TYPE_STR);
  33.  
    break;
  34.  
     
  35.  
    case 'o':
  36.  
    SET_FORMAT_BASE(*flags,FORMAT_BASE_O);
  37.  
    SET_FORMAT_TYPE(*flags,FORMAT_TYPE_UINT);
  38.  
    break;
  39.  
     
  40.  
    case 'x':
  41.  
    case 'X':
  42.  
    SET_FORMAT_BASE(*flags,FORMAT_BASE_X);
  43.  
    SET_FORMAT_TYPE(*flags,FORMAT_TYPE_UINT);
  44.  
    break;
  45.  
     
  46.  
    case 'd':
  47.  
    case 'i':
  48.  
    SET_FORMAT_TYPE(*flags,FORMAT_TYPE_INT);
  49.  
    SET_FORMAT_BASE(*flags,FORMAT_BASE_D);
  50.  
    break;
  51.  
    case 'u':
  52.  
    SET_FORMAT_TYPE(*flags,FORMAT_TYPE_UINT);
  53.  
    SET_FORMAT_BASE(*flags,FORMAT_BASE_D);
  54.  
    break;
  55.  
     
  56.  
    default:
  57.  
    break;
  58.  
    }
  59.  
    return ++fmt-start; //參數偏移的字節數
  60.  
    } 
SET_FORMAT_FLAG(*flags,FORMAT_FLAG_WIDTH);
				break;
			default:
				break;
		}
	}while(0);
	
	SET_FORMAT_BASE(*flags,FORMAT_BASE_D);
	switch (*fmt) {
		case 'c':
			SET_FORMAT_TYPE(*flags,FORMAT_TYPE_CHAR);
			break;

		case 's':
			SET_FORMAT_TYPE(*flags,FORMAT_TYPE_STR);
			break;

		case 'o':
			SET_FORMAT_BASE(*flags,FORMAT_BASE_O);
			SET_FORMAT_TYPE(*flags,FORMAT_TYPE_UINT);
			break;

		case 'x':
		case 'X':
			SET_FORMAT_BASE(*flags,FORMAT_BASE_X);
			SET_FORMAT_TYPE(*flags,FORMAT_TYPE_UINT);
			break;

		case 'd':
		case 'i':
			SET_FORMAT_TYPE(*flags,FORMAT_TYPE_INT);
			SET_FORMAT_BASE(*flags,FORMAT_BASE_D);
			break;
		case 'u':
			SET_FORMAT_TYPE(*flags,FORMAT_TYPE_UINT);
			SET_FORMAT_BASE(*flags,FORMAT_BASE_D);
			break;

	default:
		break;
	}
	return ++fmt-start;//參數偏移的字節數
}

 

 

 

（2）number函數

函數功能：根據類型進行數值轉換

  1.  
    char *number(char *str, int num,int base,unsigned int flags){
  2.  
    int i= 0;
  3.  
    int sign= 0;
  4.  
     
  5.  
    if(FORMAT_SIGNED(flags)&&( signed int)num< 0){
  6.  
    sign= 1;
  7.  
    num=~num+ 1;
  8.  
    }
  9.  
     
  10.  
    do{
  11.  
    numbers[i++]=digits[do_div(num,base)];
  12.  
    } while(num!= 0);
  13.  
     
  14.  
     
  15.  
    if(FORMAT_BASE(flags)==FORMAT_BASE_O){
  16.  
    numbers[i++]= '0';
  17.  
    } else if(FORMAT_BASE(flags)==FORMAT_BASE_X){
  18.  
    numbers[i++]= 'x';
  19.  
    numbers[i++]= '0';
  20.  
    } else if(FORMAT_BASE(flags)==FORMAT_BASE_B){
  21.  
    numbers[i++]= 'b';
  22.  
    numbers[i++]= '0';
  23.  
    }
  24.  
    if(sign)
  25.  
    numbers[i++]= '-';
  26.  
     
  27.  
    while (i-- > 0)
  28.  
    *str++ = numbers[i];
  29.  
    return str;
  30.  
    }

 


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 嵌入式 printf的實現 嵌入式系統與嵌入式操作系統的關系 PC端操作系統、移動端操作系統、嵌入式操作系統 關於嵌入式實時操作系統的實時性 一個C++版的嵌入式操作系統 嵌入式操作系統的主要特點都有哪些 嵌入式為什么要用Linux操作系統 嵌入式開發之sylixos---大型實時國產操作系統，可媲美鴻蒙的國產優秀操作系統 三個打印函數printf()/sprintf()/snprintf()區別 嵌入式開發之操作系統---華為鴻蒙及方舟編譯器、liteos物聯網
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM