vsprintf.c源代码

研究可变参数的时候，在网上搜到这篇源代码，放进博客慢慢学习^_^

1. // vsprintf.c  
2. //  
3. // Print formatting routines  
4. //  
5. // Copyright (C) 2002 Michael Ringgaard. All rights reserved.  
6. //  
7. // Redistribution and use in source and binary forms, with or without  
8. // modification, are permitted provided that the following conditions  
9. // are met:  
10. //   
11. // 1. Redistributions of source code must retain the above copyright   
12. //    notice, this list of conditions and the following disclaimer.    
13. // 2. Redistributions in binary form must reproduce the above copyright  
14. //    notice, this list of conditions and the following disclaimer in the  
15. //    documentation and/or other materials provided with the distribution.    
16. // 3. Neither the name of the project nor the names of its contributors  
17. //    may be used to endorse or promote products derived from this software  
18. //    without specific prior written permission.   
19. //   
20. // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND  
21. // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE  
22. // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE  
23. // ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE  
24. // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL  
25. // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS  
26. // OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)  
27. // HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT  
28. // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY  
29. // OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF   
30. // SUCH DAMAGE.  
31. //   
33. #include   
34. #include   
35. #include   
37. #ifdef KERNEL  
38. #define NOFLOAT  
39. #endif  
41. #define ZEROPAD 1               // Pad with zero  
42. #define SIGN    2               // Unsigned/signed long  
43. #define PLUS    4               // Show plus  
44. #define SPACE   8               // Space if plus  
45. #define LEFT    16              // Left justified  
46. #define SPECIAL 32              // 0x  
47. #define LARGE   64              // Use 'ABCDEF' instead of 'abcdef'  
49. #define is_digit(c) ((c) >= '0' && (c) <= '9')  
51. static char *digits = "0123456789abcdefghijklmnopqrstuvwxyz";
52. static char *upper_digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
54. static size_t strnlen(const char *s, size_t count)
55. {
56.   const char *sc;
57.   for (sc = s; *sc != '/0' && count--; ++sc);
58.   return sc - s;
59. }
61. static int skip_atoi(const char **s)
62. {
63.   int i = 0;
64.   while (is_digit(**s)) i = i*10 + *((*s)++) - '0';
65.   return i;
66. }
68. static char *number(char *str, long num, int base, int size, int precision, int type)
69. {
70.   char c, sign, tmp[66];
71.   char *dig = digits;
72.   int i;
74.   if (type & LARGE)  dig = upper_digits;
75.   if (type & LEFT) type &= ~ZEROPAD;
76.   if (base < 2 || base > 36) return 0;
77.   
78.   c = (type & ZEROPAD) ? '0' : ' ';
79.   sign = 0;
80.   if (type & SIGN)
81.   {
82.     if (num < 0)
83.     {
84.       sign = '-';
85.       num = -num;
86.       size--;
87.     }
88.     else if (type & PLUS)
89.     {
90.       sign = '+';
91.       size--;
92.     }
93.     else if (type & SPACE)
94.     {
95.       sign = ' ';
96.       size--;
97.     }
98.   }
100.   if (type & SPECIAL)
101.   {
102.     if (base == 16)
103.       size -= 2;
104.     else if (base == 8)
105.       size--;
106.   }
108.   i = 0;
110.   if (num == 0)
111.     tmp[i++] = '0';
112.   else
113.   {
114.     while (num != 0)
115.     {
116.       tmp[i++] = dig[((unsigned long) num) % (unsigned) base];
117.       num = ((unsigned long) num) / (unsigned) base;
118.     }
119.   }
121.   if (i > precision) precision = i;
122.   size -= precision;
123.   if (!(type & (ZEROPAD | LEFT))) while (size-- > 0) *str++ = ' ';
124.   if (sign) *str++ = sign;
125.   
126.   if (type & SPECIAL)
127.   {
128.     if (base == 8)
129.       *str++ = '0';
130.     else if (base == 16)
131.     {
132.       *str++ = '0';
133.       *str++ = digits[33];
134.     }
135.   }
137.   if (!(type & LEFT)) while (size-- > 0) *str++ = c;
138.   while (i < precision--) *str++ = '0';
139.   while (i-- > 0) *str++ = tmp[i];
140.   while (size-- > 0) *str++ = ' ';
142.   return str;
143. }
145. static char *eaddr(char *str, unsigned char *addr, int size, int precision, int type)
146. {
147.   char tmp[24];
148.   char *dig = digits;
149.   int i, len;
151.   if (type & LARGE)  dig = upper_digits;
152.   len = 0;
153.   for (i = 0; i < 6; i++)
154.   {
155.     if (i != 0) tmp[len++] = ':';
156.     tmp[len++] = dig[addr[i] >> 4];
157.     tmp[len++] = dig[addr[i] & 0x0F];
158.   }
160.   if (!(type & LEFT)) while (len < size--) *str++ = ' ';
161.   for (i = 0; i < len; ++i) *str++ = tmp[i];
162.   while (len < size--) *str++ = ' ';
164.   return str;
165. }
167. static char *iaddr(char *str, unsigned char *addr, int size, int precision, int type)
168. {
169.   char tmp[24];
170.   int i, n, len;
172.   len = 0;
173.   for (i = 0; i < 4; i++)
174.   {
175.     if (i != 0) tmp[len++] = '.';
176.     n = addr[i];
177.     
178.     if (n == 0)
179.       tmp[len++] = digits[0];
180.     else
181.     {
182.       if (n >= 100) 
183.       {
184.         tmp[len++] = digits[n / 100];
185.         n = n % 100;
186.         tmp[len++] = digits[n / 10];
187.         n = n % 10;
188.       }
189.       else if (n >= 10) 
190.       {
191.         tmp[len++] = digits[n / 10];
192.         n = n % 10;
193.       }
195.       tmp[len++] = digits[n];
196.     }
197.   }
199.   if (!(type & LEFT)) while (len < size--) *str++ = ' ';
200.   for (i = 0; i < len; ++i) *str++ = tmp[i];
201.   while (len < size--) *str++ = ' ';
203.   return str;
204. } 
206. #ifndef NOFLOAT  
208. char *ecvtbuf(double arg, int ndigits, int *decpt, int *sign, char *buf);
209. char *fcvtbuf(double arg, int ndigits, int *decpt, int *sign, char *buf);
211. static void cfltcvt(double value, char *buffer, char fmt, int precision)
212. {
213.   int decpt, sign, exp, pos;
214.   char *digits = NULL;
215.   char cvtbuf[80];
216.   int capexp = 0;
217.   int magnitude;
219.   if (fmt == 'G' || fmt == 'E')
220.   {
221.     capexp = 1;
222.     fmt += 'a' - 'A';
223.   }
225.   if (fmt == 'g')
226.   {
227.     digits = ecvtbuf(value, precision, &decpt, &sign, cvtbuf);
228.     magnitude = decpt - 1;
229.     if (magnitude < -4  ||  magnitude > precision - 1)
230.     {
231.       fmt = 'e';
232.       precision -= 1;
233.     }
234.     else
235.     {
236.       fmt = 'f';
237.       precision -= decpt;
238.     }
239.   }
241.   if (fmt == 'e')
242.   {
243.     digits = ecvtbuf(value, precision + 1, &decpt, &sign, cvtbuf);
245.     if (sign) *buffer++ = '-';
246.     *buffer++ = *digits;
247.     if (precision > 0) *buffer++ = '.';
248.     memcpy(buffer, digits + 1, precision);
249.     buffer += precision;
250.     *buffer++ = capexp ? 'E' : 'e';
252.     if (decpt == 0)
253.     {
254.       if (value == 0.0)
255.         exp = 0;
256.       else
257.         exp = -1;
258.     }
259.     else
260.       exp = decpt - 1;
262.     if (exp < 0)
263.     {
264.       *buffer++ = '-';
265.       exp = -exp;
266.     }
267.     else
268.       *buffer++ = '+';
270.     buffer[2] = (exp % 10) + '0';
271.     exp = exp / 10;
272.     buffer[1] = (exp % 10) + '0';
273.     exp = exp / 10;
274.     buffer[0] = (exp % 10) + '0';
275.     buffer += 3;
276.   }
277.   else if (fmt == 'f')
278.   {
279.     digits = fcvtbuf(value, precision, &decpt, &sign, cvtbuf);
280.     if (sign) *buffer++ = '-';
281.     if (*digits)
282.     {
283.       if (decpt <= 0)
284.       {
285.         *buffer++ = '0';
286.         *buffer++ = '.';
287.         for (pos = 0; pos < -decpt; pos++) *buffer++ = '0';
288.         while (*digits) *buffer++ = *digits++;
289.       }
290.       else
291.       {
292.         pos = 0;
293.         while (*digits)
294.         {
295.           if (pos++ == decpt) *buffer++ = '.';
296.           *buffer++ = *digits++;
297.         }
298.       }
299.     }
300.     else
301.     {
302.       *buffer++ = '0';
303.       if (precision > 0)
304.       {
305.         *buffer++ = '.';
306.         for (pos = 0; pos < precision; pos++) *buffer++ = '0';
307.       }
308.     }
309.   }
311.   *buffer = '/0';
312. }
314. static void forcdecpt(char *buffer)
315. {
316.   while (*buffer)
317.   {
318.     if (*buffer == '.') return;
319.     if (*buffer == 'e' || *buffer == 'E') break;
320.     buffer++;
321.   }
323.   if (*buffer)
324.   {
325.     int n = strlen(buffer);
326.     while (n > 0) 
327.     {
328.       buffer[n + 1] = buffer[n];
329.       n--;
330.     }
332.     *buffer = '.';
333.   }
334.   else
335.   {
336.     *buffer++ = '.';
337.     *buffer = '/0';
338.   }
339. }
341. static void cropzeros(char *buffer)
342. {
343.   char *stop;
345.   while (*buffer && *buffer != '.') buffer++;
346.   if (*buffer++)
347.   {
348.     while (*buffer && *buffer != 'e' && *buffer != 'E') buffer++;
349.     stop = buffer--;
350.     while (*buffer == '0') buffer--;
351.     if (*buffer == '.') buffer--;
352.     while (*++buffer = *stop++);
353.   }
354. }
356. static char *flt(char *str, double num, int size, int precision, char fmt, int flags)
357. {
358.   char tmp[80];
359.   char c, sign;
360.   int n, i;
362.   // Left align means no zero padding  
363.   if (flags & LEFT) flags &= ~ZEROPAD;
365.   // Determine padding and sign char  
366.   c = (flags & ZEROPAD) ? '0' : ' ';
367.   sign = 0;
368.   if (flags & SIGN)
369.   {
370.     if (num < 0.0)
371.     {
372.       sign = '-';
373.       num = -num;
374.       size--;
375.     }
376.     else if (flags & PLUS)
377.     {
378.       sign = '+';
379.       size--;
380.     }
381.     else if (flags & SPACE)
382.     {
383.       sign = ' ';
384.       size--;
385.     }
386.   }
388.   // Compute the precision value  
389.   if (precision < 0)
390.     precision = 6; // Default precision: 6  
391.   else if (precision == 0 && fmt == 'g')
392.     precision = 1; // ANSI specified  
394.   // Convert floating point number to text  
395.   cfltcvt(num, tmp, fmt, precision);
397.   // '#' and precision == 0 means force a decimal point  
398.   if ((flags & SPECIAL) && precision == 0) forcdecpt(tmp);
400.   // 'g' format means crop zero unless '#' given  
401.   if (fmt == 'g' && !(flags & SPECIAL)) cropzeros(tmp);
403.   n = strlen(tmp);
405.   // Output number with alignment and padding  
406.   size -= n;
407.   if (!(flags & (ZEROPAD | LEFT))) while (size-- > 0) *str++ = ' ';
408.   if (sign) *str++ = sign;
409.   if (!(flags & LEFT)) while (size-- > 0) *str++ = c;
410.   for (i = 0; i < n; i++) *str++ = tmp[i];
411.   while (size-- > 0) *str++ = ' ';
413.   return str;
414. } 
416. #endif  
418. int vsprintf(char *buf, const char *fmt, va_list args)
419. {
420.   int len;
421.   unsigned long num;
422.   int i, base;
423.   char *str;
424.   char *s;
426.   int flags;            // Flags to number()  
428.   int field_width;      // Width of output field  
429.   int precision;        // Min. # of digits for integers; max number of chars for from string  
430.   int qualifier;        // 'h', 'l', or 'L' for integer fields  
432.   for (str = buf; *fmt; fmt++)
433.   {
434.     if (*fmt != '%')
435.     {
436.       *str++ = *fmt;
437.       continue;
438.     }
439.                   
440.     // Process flags  
441.     flags = 0;
442. repeat:
443.     fmt++; // This also skips first '%'  
444.     switch (*fmt)
445.     {
446.       case '-': flags |= LEFT; goto repeat;
447.       case '+': flags |= PLUS; goto repeat;
448.       case ' ': flags |= SPACE; goto repeat;
449.       case '#': flags |= SPECIAL; goto repeat;
450.       case '0': flags |= ZEROPAD; goto repeat;
451.     }
452.           
453.     // Get field width  
454.     field_width = -1;
455.     if (is_digit(*fmt))
456.       field_width = skip_atoi(&fmt);
457.     else if (*fmt == '*')
458.     {
459.       fmt++;
460.       field_width = va_arg(args, int);
461.       if (field_width < 0)
462.       {
463.         field_width = -field_width;
464.         flags |= LEFT;
465.       }
466.     }
468.     // Get the precision  
469.     precision = -1;
470.     if (*fmt == '.')
471.     {
472.       ++fmt;    
473.       if (is_digit(*fmt))
474.         precision = skip_atoi(&fmt);
475.       else if (*fmt == '*')
476.       {
477.         ++fmt;
478.         precision = va_arg(args, int);
479.       }
480.       if (precision < 0) precision = 0;
481.     }
483.     // Get the conversion qualifier  
484.     qualifier = -1;
485.     if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L')
486.     {
487.       qualifier = *fmt;
488.       fmt++;
489.     }
491.     // Default base  
492.     base = 10;
494.     switch (*fmt)
495.     {
496.       case 'c':
497.         if (!(flags & LEFT)) while (--field_width > 0) *str++ = ' ';
498.         *str++ = (unsigned char) va_arg(args, int);
499.         while (--field_width > 0) *str++ = ' ';
500.         continue;
502.       case 's':
503.         s = va_arg(args, char *);
504.         if (!s) s = "";
505.         len = strnlen(s, precision);
506.         if (!(flags & LEFT)) while (len < field_width--) *str++ = ' ';
507.         for (i = 0; i < len; ++i) *str++ = *s++;
508.         while (len < field_width--) *str++ = ' ';
509.         continue;
511.       case 'p':
512.         if (field_width == -1)
513.         {
514.           field_width = 2 * sizeof(void *);
515.           flags |= ZEROPAD;
516.         }
517.         str = number(str, (unsigned long) va_arg(args, void *), 16, field_width, precision, flags);
518.         continue;
520.       case 'n':
521.         if (qualifier == 'l')
522.         {
523.           long *ip = va_arg(args, long *);
524.           *ip = (str - buf);
525.         }
526.         else
527.         {
528.           int *ip = va_arg(args, int *);
529.           *ip = (str - buf);
530.         }
531.         continue;
533.       case 'A':
534.         flags |= LARGE;
536.       case 'a':
537.         if (qualifier == 'l')
538.           str = eaddr(str, va_arg(args, unsigned char *), field_width, precision, flags);
539.         else
540.           str = iaddr(str, va_arg(args, unsigned char *), field_width, precision, flags);
541.         continue;
543.       // Integer number formats - set up the flags and "break"  
544.       case 'o':
545.         base = 8;
546.         break;
548.       case 'X':
549.         flags |= LARGE;
551.       case 'x':
552.         base = 16;
553.         break;
555.       case 'd':
556.       case 'i':
557.         flags |= SIGN;
559.       case 'u':
560.         break; 
562. #ifndef NOFLOAT  
564.       case 'E':
565.       case 'G':
566.       case 'e':
567.       case 'f':
568.       case 'g':
569.         str = flt(str, va_arg(args, double), field_width, precision, *fmt, flags | SIGN);
570.         continue; 
572. #endif  
574.       default:
575.         if (*fmt != '%') *str++ = '%';
576.         if (*fmt)
577.           *str++ = *fmt;
578.         else
579.           --fmt;
580.         continue;
581.     }
583.     if (qualifier == 'l')
584.       num = va_arg(args, unsigned long);
585.     else if (qualifier == 'h')
586.     {
587.       if (flags & SIGN)
588.         num = va_arg(args, short);
589.       else
590.         num = va_arg(args, unsigned short);
591.     }
592.     else if (flags & SIGN)
593.       num = va_arg(args, int);
594.     else
595.       num = va_arg(args, unsigned int);
597.     str = number(str, num, base, field_width, precision, flags);
598.   }
600.   *str = '/0';
601.   return str - buf;
602. }
604. int sprintf(char *buf, const char *fmt, ...)
605. {
606.   va_list args;
607.   int n;
609.   va_start(args, fmt);
610.   n = vsprintf(buf, fmt, args);
611.   va_end(args);
613.   return n;
614. }