![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vsprintf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / libc|
Return to vsprintf.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / libc |
1.1 root 1: /*
2: * String functions for logger.
3: */
4:
5: /*
6: * linux/lib/vsprintf.c
7: *
8: * Copyright (C) 1991, 1992 Linus Torvalds
9: */
10:
11: /* vsprintf.c -- Lars Wirzenius & Linus Torvalds. */
12: /*
13: * Wirzenius wrote this portably, Torvalds fucked it up :-)
14: */
15:
16: /*
17: * Fri Jul 13 2001 Crutcher Dunnavant <[email protected]>
18: * - changed to provide snprintf and vsnprintf functions
19: */
20:
21: #include "config.h"
22: #include "libc/string.h"
23: #include "libc/vsprintf.h"
24:
25: static int skip_atoi(const char **s)
26: {
27: int i=0;
28:
29: while (isdigit(**s))
30: i = i*10 + *((*s)++) - '0';
31: return i;
32: }
33:
34: #define ZEROPAD 1 /* pad with zero */
35: #define SIGN 2 /* unsigned/signed long */
36: #define PLUS 4 /* show plus */
37: #define SPACE 8 /* space if plus */
38: #define LEFT 16 /* left justified */
39: #define SPECIAL 32 /* 0x */
40: #define LARGE 64 /* use 'ABCDEF' instead of 'abcdef' */
41:
42: #define do_div(n,base) ({ \
43: int __res; \
44: __res = ((unsigned long long) n) % (unsigned) base; \
45: n = ((unsigned long long) n) / (unsigned) base; \
46: __res; })
47:
48: static int mstrlen( const char *str );
49:
50: #ifndef PAGE_SIZE
51: #define PAGE_SIZE 4096
52: #endif
53:
54: static char * number(char * buf, char * end, long long num, int base, int size, int precision, int type)
55: {
56: char c,sign,tmp[66];
57: const char *digits;
58: static const char small_digits[] = "0123456789abcdefghijklmnopqrstuvwxyz";
59: static const char large_digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
60: int i;
61:
62: digits = (type & LARGE) ? large_digits : small_digits;
63: if (type & LEFT)
64: type &= ~ZEROPAD;
65: if (base < 2 || base > 36)
66: return NULL;
67: c = (type & ZEROPAD) ? '0' : ' ';
68: sign = 0;
69: if (type & SIGN) {
70: if (num < 0) {
71: sign = '-';
72: num = -num;
73: size--;
74: } else if (type & PLUS) {
75: sign = '+';
76: size--;
77: } else if (type & SPACE) {
78: sign = ' ';
79: size--;
80: }
81: }
82: if (type & SPECIAL) {
83: if (base == 16)
84: size -= 2;
85: else if (base == 8)
86: size--;
87: }
88: i = 0;
89: if (num == 0)
90: tmp[i++]='0';
91: else while (num != 0)
92: tmp[i++] = digits[do_div(num,base)];
93: if (i > precision)
94: precision = i;
95: size -= precision;
96: if (!(type&(ZEROPAD+LEFT))) {
97: while(size-->0) {
98: if (buf <= end)
99: *buf = ' ';
100: ++buf;
101: }
102: }
103: if (sign) {
104: if (buf <= end)
105: *buf = sign;
106: ++buf;
107: }
108: if (type & SPECIAL) {
109: if (base==8) {
110: if (buf <= end)
111: *buf = '0';
112: ++buf;
113: } else if (base==16) {
114: if (buf <= end)
115: *buf = '0';
116: ++buf;
117: if (buf <= end)
118: *buf = digits[33];
119: ++buf;
120: }
121: }
122: if (!(type & LEFT)) {
123: while (size-- > 0) {
124: if (buf <= end)
125: *buf = c;
126: ++buf;
127: }
128: }
129: while (i < precision--) {
130: if (buf <= end)
131: *buf = '0';
132: ++buf;
133: }
134: while (i-- > 0) {
135: if (buf <= end)
136: *buf = tmp[i];
137: ++buf;
138: }
139: while (size-- > 0) {
140: if (buf <= end)
141: *buf = ' ';
142: ++buf;
143: }
144: return buf;
145: }
146:
147: /**
148: * vsnprintf - Format a string and place it in a buffer
149: * @buf: The buffer to place the result into
150: * @size: The size of the buffer, including the trailing null space
151: * @fmt: The format string to use
152: * @args: Arguments for the format string
153: *
154: * Call this function if you are already dealing with a va_list.
155: * You probably want snprintf instead.
156: */
157: int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
158: {
159: int len;
160: unsigned long long num;
161: int i, base;
162: char *str, *end, c;
163: const char *s;
164:
165: int flags; /* flags to number() */
166:
167: int field_width; /* width of output field */
168: int precision; /* min. # of digits for integers; max
169: number of chars for from string */
170: int qualifier; /* 'h', 'l', or 'L' for integer fields */
171: /* 'z' support added 23/7/1999 S.H. */
172: /* 'z' changed to 'Z' --davidm 1/25/99 */
173:
174: str = buf;
175: end = buf + size - 1;
176:
177: if (end < buf - 1) {
178: end = ((void *) -1);
179: size = end - buf + 1;
180: }
181:
182: for (; *fmt ; ++fmt) {
183: if (*fmt != '%') {
184: if (str <= end)
185: *str = *fmt;
186: ++str;
187: continue;
188: }
189:
190: /* process flags */
191: flags = 0;
192: repeat:
193: ++fmt; /* this also skips first '%' */
194: switch (*fmt) {
195: case '-': flags |= LEFT; goto repeat;
196: case '+': flags |= PLUS; goto repeat;
197: case ' ': flags |= SPACE; goto repeat;
198: case '#': flags |= SPECIAL; goto repeat;
199: case '0': flags |= ZEROPAD; goto repeat;
200: }
201:
202: /* get field width */
203: field_width = -1;
204: if (isdigit(*fmt))
205: field_width = skip_atoi(&fmt);
206: else if (*fmt == '*') {
207: ++fmt;
208: /* it's the next argument */
209: field_width = va_arg(args, int);
210: if (field_width < 0) {
211: field_width = -field_width;
212: flags |= LEFT;
213: }
214: }
215:
216: /* get the precision */
217: precision = -1;
218: if (*fmt == '.') {
219: ++fmt;
220: if (isdigit(*fmt))
221: precision = skip_atoi(&fmt);
222: else if (*fmt == '*') {
223: ++fmt;
224: /* it's the next argument */
225: precision = va_arg(args, int);
226: }
227: if (precision < 0)
228: precision = 0;
229: }
230:
231: /* get the conversion qualifier */
232: qualifier = -1;
233: if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' ||
234: *fmt =='Z' || *fmt == 'z') {
235: qualifier = *fmt;
236: ++fmt;
237: if (qualifier == 'l' && *fmt == 'l') {
238: qualifier = 'L';
239: ++fmt;
240: }
241: }
242:
243: /* default base */
244: base = 10;
245:
246: switch (*fmt) {
247: case 'c':
248: if (!(flags & LEFT)) {
249: while (--field_width > 0) {
250: if (str <= end)
251: *str = ' ';
252: ++str;
253: }
254: }
255: c = (unsigned char) va_arg(args, int);
256: if (str <= end)
257: *str = c;
258: ++str;
259: while (--field_width > 0) {
260: if (str <= end)
261: *str = ' ';
262: ++str;
263: }
264: continue;
265:
266: case 's':
267: s = va_arg(args, char *);
268: if ((unsigned long)s < PAGE_SIZE)
269: s = "<NULL>";
270:
271: #if 0
272: len = strnlen(s, precision);
273: #else
274: len = mstrlen(s);
275: if( precision > len )
276: len = precision;
277: #endif
278: if (!(flags & LEFT)) {
279: while (len < field_width--) {
280: if (str <= end)
281: *str = ' ';
282: ++str;
283: }
284: }
285: for (i = 0; i < len; ++i) {
286: if (str <= end)
287: *str = *s;
288: ++str; ++s;
289: }
290: while (len < field_width--) {
291: if (str <= end)
292: *str = ' ';
293: ++str;
294: }
295: continue;
296:
297: case 'p':
298: if (field_width == -1) {
299: field_width = 2*sizeof(void *);
300: flags |= ZEROPAD;
301: }
302: str = number(str, end,
303: (unsigned long) va_arg(args, void *),
304: 16, field_width, precision, flags);
305: continue;
306:
307:
308: case 'n':
309: /* FIXME:
310: * What does C99 say about the overflow case here? */
311: if (qualifier == 'l') {
312: long * ip = va_arg(args, long *);
313: *ip = (str - buf);
314: } else if (qualifier == 'Z' || qualifier == 'z') {
315: size_t * ip = va_arg(args, size_t *);
316: *ip = (str - buf);
317: } else {
318: int * ip = va_arg(args, int *);
319: *ip = (str - buf);
320: }
321: continue;
322:
323: case '%':
324: if (str <= end)
325: *str = '%';
326: ++str;
327: continue;
328:
329: /* integer number formats - set up the flags and "break" */
330: case 'o':
331: base = 8;
332: break;
333:
334: case 'X':
335: flags |= LARGE;
336: case 'x':
337: base = 16;
338: break;
339:
340: case 'd':
341: case 'i':
342: flags |= SIGN;
343: case 'u':
344: break;
345:
346: default:
347: if (str <= end)
348: *str = '%';
349: ++str;
350: if (*fmt) {
351: if (str <= end)
352: *str = *fmt;
353: ++str;
354: } else {
355: --fmt;
356: }
357: continue;
358: }
359: if (qualifier == 'L')
360: num = va_arg(args, long long);
361: else if (qualifier == 'l') {
362: num = va_arg(args, unsigned long);
363: if (flags & SIGN)
364: num = (signed long) num;
365: } else if (qualifier == 'Z' || qualifier == 'z') {
366: num = va_arg(args, size_t);
367: } else if (qualifier == 'h') {
368: num = (unsigned short) va_arg(args, int);
369: if (flags & SIGN)
370: num = (signed short) num;
371: } else {
372: num = va_arg(args, unsigned int);
373: if (flags & SIGN)
374: num = (signed int) num;
375: }
376: str = number(str, end, num, base,
377: field_width, precision, flags);
378: }
379: if (str <= end)
380: *str = '\0';
381: else if (size > 0)
382: /* don't write out a null byte if the buf size is zero */
383: *end = '\0';
384: /* the trailing null byte doesn't count towards the total
385: * ++str;
386: */
387: return str-buf;
388: }
389:
390: /**
391: * snprintf - Format a string and place it in a buffer
392: * @buf: The buffer to place the result into
393: * @size: The size of the buffer, including the trailing null space
394: * @fmt: The format string to use
395: * @...: Arguments for the format string
396: */
397: int snprintf(char * buf, size_t size, const char *fmt, ...)
398: {
399: va_list args;
400: int i;
401:
402: va_start(args, fmt);
403: i=vsnprintf(buf,size,fmt,args);
404: va_end(args);
405: return i;
406: }
407:
408: /**
409: * vsprintf - Format a string and place it in a buffer
410: * @buf: The buffer to place the result into
411: * @fmt: The format string to use
412: * @args: Arguments for the format string
413: *
414: * Call this function if you are already dealing with a va_list.
415: * You probably want sprintf instead.
416: */
417: int vsprintf(char *buf, const char *fmt, va_list args)
418: {
419: return vsnprintf(buf, (~0U)>>1, fmt, args);
420: }
421:
422:
423: /**
424: * sprintf - Format a string and place it in a buffer
425: * @buf: The buffer to place the result into
426: * @fmt: The format string to use
427: * @...: Arguments for the format string
428: */
429: int sprintf(char * buf, const char *fmt, ...)
430: {
431: va_list args;
432: int i;
433:
434: va_start(args, fmt);
435: i=vsprintf(buf,fmt,args);
436: va_end(args);
437: return i;
438: }
439:
440: static int mstrlen( const char *str )
441: {
442: int i=0;
443: if( str == NULL )
444: return 0;
445: while( *str++ )
446: i++;
447: return i;
448: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.