格式化数组： bprintf 和 bscan

点击(此处)折叠或打开

1. *****************************************************************************/
   
2. * Contact information:
   * sites: mailan7749.blog.chinaunix.net
   *      
   * e-mail:  [email protected]
   *****************************************************************************/
   
   
3. 
   
4. #include <stdarg.h>
   
5. #include <stdio.h>
   
6. 
   
7. typedef unsigned char    INT8U;
   
8. typedef unsigned short    INT16U;
   
9. typedef unsigned int    INT32U;
   
10. 
    
11. /**
    
12.  * @brief 类printf，将变量按指定的格式fmt，存放在buf中。
    
13.  *
    
14.  * @param buf：存放被格式化的数据
    
15.  * @param fmt：格式化字符串
    
16.  *
    
17.  */
    
18. char bprintf(INT8U * buf, const char * fmt, ...)
    
19. {
    
20.     char len;
    
21.     char type;
    
22.     INT8U data_8;
    
23.     INT16U data_16;
    
24.     INT32U data_32;
    
25.     va_list argp;
    
26. 
    
27.     if ( (buf == NULL) || (fmt == NULL) )
    
28.         return -1;
    
29. 
    
30.     va_start(argp, fmt);
    
31.     while(*fmt != 0)
    
32.     {
    
33.         if (*fmt == ' ')
    
34.         {
    
35.             fmt ++;
    
36.         }
    
37.         else if (*fmt == '%')
    
38.         {
    
39.             len = fmt[1] ;
    
40.             type = fmt[2];
    
41.             if ( type != 'x' )
    
42.                 return -1;
    
43.             switch(len)
    
44.             {
    
45.             case '1':
    
46.                 data_8 = va_arg(argp, INT8U);
    
47.                 *buf++ = data_8;
    
48.                 break;
    
49.             case '2':
    
50.                 data_16 = va_arg(argp, INT16U);
    
51.                 *buf++ = (data_16 >> 8) & 0xFF;
    
52.                 *buf++ = data_16 & 0xFF;
    
53.                 break;
    
54.             case '4':
    
55.                 data_32 = va_arg(argp, INT32U);
    
56.                 *buf++ = (data_32 >> 24) & 0xFF;
    
57.                 *buf++ = (data_32 >> 16) & 0xFF;
    
58.                 *buf++ = (data_32 >> 8) & 0xFF;
    
59.                 *buf++ = data_32 & 0xFF;
    
60.                 break;
    
61.             default:
    
62.                 return -1;
    
63.                 break;
    
64.             }
    
65.             fmt += 3;
    
66.         }        
    
67.         else
    
68.         {
    
69.             *buf = (INT8U)( (fmt[0] - '0') << 4 ) + ( fmt[1] - '0' );
    
70.             fmt += 2;
    
71.             buf ++;
    
72.         }        
    
73.     }
    
74.     va_end(argp);
    
75.     return 0;
    
76. }
    
77. 
    
78. /**
    
79.  * @brief 类scan，将buf中的数据按指定的格式fmt，存放在变量中。
    
80.  *
    
81.  * @param buf：存放被格式化的数据
    
82.  * @param fmt：格式化字符串
    
83.  *
    
84.  */
    
85. char bscan(INT8U * buf, const char *fmt, ...)
    
86. {
    
87.     void * p;
    
88.     char len;
    
89.     char type;
    
90.     va_list argp;
    
91. 
    
92.     if ( (buf == NULL) || (fmt == NULL) )
    
93.         return -1;
    
94. 
    
95.     va_start(argp, fmt);
    
96.     while(*fmt != 0)
    
97.     {
    
98.         if (*fmt == ' ')
    
99.         {
    
100.             fmt ++;
     
101.         }
     
102.         else if (*fmt == '%')
     
103.         {
     
104.             len = fmt[1] ;
     
105.             type = fmt[2];
     
106.             if ( type != 'x' )
     
107.                 return -1;
     
108.             switch(len)
     
109.             {
     
110.             case '1':
     
111.                 p = va_arg(argp, void *);
     
112.                 *(INT8U *)(p) = *(INT8U *)buf++;
     
113.                 break;
     
114.             case '2':
     
115.                 p = va_arg(argp, void *);
     
116.                 *(INT16U *)(p) = *(INT16U *)buf;
     
117.                 buf += 2;
     
118.                 break;
     
119.             case '4':
     
120.                 p = va_arg(argp, void *);
     
121.                 *(INT32U *)(p) = *(INT32U *)buf;
     
122.                 buf += 4;
     
123.                 break;
     
124.             default:
     
125.                 return -1;
     
126.                 break;
     
127.             }
     
128.             fmt += 3;
     
129.         }        
     
130.         else
     
131.         {            
     
132.             fmt += 2;
     
133.             buf ++;
     
134.         }        
     
135.     }
     
136.     va_end(argp);
     
137.     return 0;
     
138. }
     
139. 
     
140. void main( void )
     
141. {
     
142.    INT8U buf[20];
     
143.    INT8U a = 1;
     
144.    INT32U b = 2;
     
145.    INT32U c1;
     
146.    INT8U c2;
     
147.    INT8U c3;
     
148.    bprintf(buf, "12 34 56 78 %1x %1x 55", a, b);
     
149.    bscan(buf, "%4x %1x %1x", &c1, &c2, &c3);
     
150. }