[CMAKE]
[reactos.git] / lib / rtl / sprintf.c
1
2 #ifndef USE_NEW_SPRINTF
3 /*
4 * PROGRAMMERS: David Welch
5 * Eric Kohl
6 *
7 * TODO:
8 * - Verify the implementation of '%Z'.
9 */
10
11 /*
12 * linux/lib/vsprintf.c
13 *
14 * Copyright (C) 1991, 1992 Linus Torvalds
15 */
16
17 /* vsprintf.c -- Lars Wirzenius & Linus Torvalds. */
18 /*
19 * Wirzenius wrote this portably, Torvalds fucked it up :-)
20 */
21
22 #include <rtl.h>
23
24 #define ZEROPAD 1 /* pad with zero */
25 #define SIGN 2 /* unsigned/signed long */
26 #define PLUS 4 /* show plus */
27 #define SPACE 8 /* space if plus */
28 #define LEFT 16 /* left justified */
29 #define SPECIAL 32 /* 0x */
30 #define LARGE 64 /* use 'ABCDEF' instead of 'abcdef' */
31 #define REMOVEHEX 256 /* use 256 as remve 0x frim BASE 16 */
32 typedef struct {
33 unsigned int mantissal:32;
34 unsigned int mantissah:20;
35 unsigned int exponent:11;
36 unsigned int sign:1;
37 } double_t;
38
39 static
40 __inline
41 int
42 _isinf(double __x)
43 {
44 union
45 {
46 double* __x;
47 double_t* x;
48 } x;
49
50 x.__x = &__x;
51 return ( x.x->exponent == 0x7ff && ( x.x->mantissah == 0 && x.x->mantissal == 0 ));
52 }
53
54 static
55 __inline
56 int
57 _isnan(double __x)
58 {
59 union
60 {
61 double* __x;
62 double_t* x;
63 } x;
64 x.__x = &__x;
65 return ( x.x->exponent == 0x7ff && ( x.x->mantissah != 0 || x.x->mantissal != 0 ));
66 }
67
68
69 static
70 __inline
71 int
72 do_div(long long *n, int base)
73 {
74 int a;
75 a = ((unsigned long long) *n) % (unsigned) base;
76 *n = ((unsigned long long) *n) / (unsigned) base;
77 return a;
78 }
79
80
81 static int skip_atoi(const char **s)
82 {
83 int i=0;
84
85 while (isdigit(**s))
86 i = i*10 + *((*s)++) - '0';
87 return i;
88 }
89
90
91 static char *
92 number(char * buf, char * end, long long num, int base, int size, int precision, int type)
93 {
94 char c,sign,tmp[66];
95 const char *digits;
96 const char *small_digits = "0123456789abcdefghijklmnopqrstuvwxyz";
97 const char *large_digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
98 int i;
99
100 digits = (type & LARGE) ? large_digits : small_digits;
101 if (type & LEFT)
102 type &= ~ZEROPAD;
103 if (base < 2 || base > 36)
104 return 0;
105 c = (type & ZEROPAD) ? '0' : ' ';
106 sign = 0;
107 if (type & SIGN) {
108 if (num < 0) {
109 sign = '-';
110 num = -num;
111 size--;
112 } else if (type & PLUS) {
113 sign = '+';
114 size--;
115 } else if (type & SPACE) {
116 sign = ' ';
117 size--;
118 }
119 }
120
121 if ((type & SPECIAL) && ((type & REMOVEHEX) == 0)) {
122 if (base == 16)
123 size -= 2;
124
125 }
126 i = 0;
127 if ((num == 0) && (precision !=0))
128 tmp[i++] = '0';
129 else while (num != 0)
130 tmp[i++] = digits[do_div(&num,base)];
131 if (i > precision)
132 precision = i;
133 size -= precision;
134 if (!(type&(ZEROPAD+LEFT))) {
135 while(size-->0) {
136 if (buf <= end)
137 *buf = ' ';
138 ++buf;
139 }
140 }
141 if (sign) {
142 if (buf <= end)
143 *buf = sign;
144 ++buf;
145 }
146
147 if ((type & SPECIAL) && ((type & REMOVEHEX) == 0)) {
148 if (base==16) {
149 if (buf <= end)
150 *buf = '0';
151 ++buf;
152 if (buf <= end)
153 *buf = digits[33];
154 ++buf;
155 }
156 }
157
158 if (!(type & LEFT)) {
159 while (size-- > 0) {
160 if (buf <= end)
161 *buf = c;
162 ++buf;
163 }
164 }
165 while (i < precision--) {
166 if (buf <= end)
167 *buf = '0';
168 ++buf;
169 }
170 while (i-- > 0) {
171 if (buf <= end)
172 *buf = tmp[i];
173 ++buf;
174 }
175 while (size-- > 0) {
176 if (buf <= end)
177 *buf = ' ';
178 ++buf;
179 }
180
181 return buf;
182 }
183
184 static char *
185 numberf(char * buf, char * end, double num, int base, int size, int precision, int type)
186 {
187 char c,sign,tmp[66];
188 const char *digits;
189 const char *small_digits = "0123456789abcdefghijklmnopqrstuvwxyz";
190 const char *large_digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
191 int i;
192 long long x;
193
194 /* FIXME
195 the float version of number is direcly copy of number
196 */
197
198 digits = (type & LARGE) ? large_digits : small_digits;
199 if (type & LEFT)
200 type &= ~ZEROPAD;
201 if (base < 2 || base > 36)
202 return 0;
203 c = (type & ZEROPAD) ? '0' : ' ';
204 sign = 0;
205 if (type & SIGN) {
206 if (num < 0) {
207 sign = '-';
208 num = -num;
209 size--;
210 } else if (type & PLUS) {
211 sign = '+';
212 size--;
213 } else if (type & SPACE) {
214 sign = ' ';
215 size--;
216 }
217 }
218 if (type & SPECIAL) {
219 if (base == 16)
220 size -= 2;
221 else if (base == 8)
222 size--;
223 }
224 i = 0;
225 if (num == 0)
226 tmp[i++] = '0';
227 else while (num != 0)
228 {
229 x = num;
230 tmp[i++] = digits[do_div(&x,base)];
231 #ifndef _M_ARM // Missing __floatdidf in CeGCC 0.55 -- GCC 4.4
232 num=x;
233 #endif
234 }
235 if (i > precision)
236 precision = i;
237 size -= precision;
238 if (!(type&(ZEROPAD+LEFT))) {
239 while(size-->0) {
240 if (buf <= end)
241 *buf = ' ';
242 ++buf;
243 }
244 }
245 if (sign) {
246 if (buf <= end)
247 *buf = sign;
248 ++buf;
249 }
250 if (type & SPECIAL) {
251 if (base==8) {
252 if (buf <= end)
253 *buf = '0';
254 ++buf;
255 } else if (base==16) {
256 if (buf <= end)
257 *buf = '0';
258 ++buf;
259 if (buf <= end)
260 *buf = digits[33];
261 ++buf;
262 }
263 }
264 if (!(type & LEFT)) {
265 while (size-- > 0) {
266 if (buf <= end)
267 *buf = c;
268 ++buf;
269 }
270 }
271 while (i < precision--) {
272 if (buf <= end)
273 *buf = '0';
274 ++buf;
275 }
276 while (i-- > 0) {
277 if (buf <= end)
278 *buf = tmp[i];
279 ++buf;
280 }
281 while (size-- > 0) {
282 if (buf <= end)
283 *buf = ' ';
284 ++buf;
285 }
286 return buf;
287 }
288
289 static char*
290 string(char* buf, char* end, const char* s, int len, int field_width, int precision, int flags)
291 {
292 int i;
293 char c;
294
295 c = (flags & ZEROPAD) ? '0' : ' ';
296
297 if (s == NULL)
298 {
299 s = "<NULL>";
300 len = 6;
301 }
302 else
303 {
304 if (len == -1)
305 {
306 len = 0;
307 while ((unsigned int)len < (unsigned int)precision && s[len])
308 len++;
309 }
310 else
311 {
312 if ((unsigned int)len > (unsigned int)precision)
313 len = precision;
314 }
315 }
316 if (!(flags & LEFT))
317 while (len < field_width--)
318 {
319 if (buf <= end)
320 *buf = c;
321 ++buf;
322 }
323 for (i = 0; i < len; ++i)
324 {
325 if (buf <= end)
326 *buf = *s++;
327 ++buf;
328 }
329 while (len < field_width--)
330 {
331 if (buf <= end)
332 *buf = ' ';
333 ++buf;
334 }
335 return buf;
336 }
337
338 static char*
339 stringw(char* buf, char* end, const wchar_t* sw, int len, int field_width, int precision, int flags)
340 {
341 int i;
342 char c;
343
344 c = (flags & ZEROPAD) ? '0' : ' ';
345
346 if (sw == NULL)
347 {
348 sw = L"<NULL>";
349 len = 6;
350 }
351 else
352 {
353 if (len == -1)
354 {
355 len = 0;
356 while ((unsigned int)len < (unsigned int)precision && sw[len])
357 len++;
358 }
359 else
360 {
361 if ((unsigned int)len > (unsigned int)precision)
362 len = precision;
363 }
364 }
365 if (!(flags & LEFT))
366 while (len < field_width--)
367 {
368 if (buf <= end)
369 *buf = c;
370 buf++;
371 }
372 for (i = 0; i < len; ++i)
373 {
374 if (buf <= end)
375 *buf = (unsigned char)(*sw++);
376 buf++;
377 }
378 while (len < field_width--)
379 {
380 if (buf <= end)
381 *buf = ' ';
382 buf++;
383 }
384 return buf;
385 }
386
387 /*
388 * @implemented
389 */
390 int __cdecl _vsnprintf(char *buf, size_t cnt, const char *fmt, va_list args)
391 {
392 int len;
393 unsigned long long num;
394 double _double;
395
396 int base;
397 char *str, *end;
398 const char *s;
399 const wchar_t *sw;
400
401 int flags; /* flags to number() */
402
403 int field_width; /* width of output field */
404 int precision; /* min. # of digits for integers; max
405 number of chars for from string */
406 int qualifier; /* 'h', 'l', 'L', 'I' or 'w' for integer fields */
407
408 /* clear the string buffer with zero so we do not need NULL terment it at end */
409
410 str = buf;
411 end = buf + cnt - 1;
412 if (end < buf - 1) {
413 end = ((char *) -1);
414 cnt = end - buf + 1;
415 }
416
417 for ( ; *fmt ; ++fmt) {
418 if (*fmt != '%') {
419 if (str <= end)
420 *str = *fmt;
421 ++str;
422 continue;
423 }
424
425 /* process flags */
426 flags = 0;
427 repeat:
428 ++fmt; /* this also skips first '%' */
429 switch (*fmt) {
430 case '-': flags |= LEFT; goto repeat;
431 case '+': flags |= PLUS; goto repeat;
432 case ' ': flags |= SPACE; goto repeat;
433 case '#': flags |= SPECIAL; goto repeat;
434 case '0': flags |= ZEROPAD; goto repeat;
435 }
436
437 /* get field width */
438 field_width = -1;
439 if (isdigit(*fmt))
440 field_width = skip_atoi(&fmt);
441 else if (*fmt == '*') {
442 ++fmt;
443 /* it's the next argument */
444 field_width = va_arg(args, int);
445 if (field_width < 0) {
446 field_width = -field_width;
447 flags |= LEFT;
448 }
449 }
450
451 /* get the precision */
452 precision = -1;
453 if (*fmt == '.') {
454 ++fmt;
455 if (isdigit(*fmt))
456 precision = skip_atoi(&fmt);
457 else if (*fmt == '*') {
458 ++fmt;
459 /* it's the next argument */
460 precision = va_arg(args, int);
461 }
462 if (precision < 0)
463 precision = 0;
464 }
465
466 /* get the conversion qualifier */
467 qualifier = -1;
468 if (*fmt == 'l' && *(fmt+1) == 'l') {
469 qualifier = 'I';
470 fmt += 2;
471 } else if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' || *fmt == 'w') {
472 qualifier = *fmt;
473 ++fmt;
474 } else if (*fmt == 'I' && *(fmt+1) == '6' && *(fmt+2) == '4') {
475 qualifier = *fmt;
476 fmt += 3;
477 } else if (*fmt == 'I' && *(fmt+1) == '3' && *(fmt+2) == '2') {
478 qualifier = 'l';
479 fmt += 3;
480 } else if (*fmt == 'F' && *(fmt+1) == 'p') {
481 fmt += 1;
482 flags |= REMOVEHEX;
483 }
484
485 /* default base */
486 base = 10;
487
488 switch (*fmt) {
489 case 'c': /* finished */
490 if (qualifier == 'l' || qualifier == 'w') {
491 wchar_t sw1[2];
492 /* print unicode string */
493 sw1[0] = (wchar_t) va_arg(args, int);
494 sw1[1] = 0;
495 str = stringw(str, end, (wchar_t *)&sw1, -1, field_width, precision, flags);
496 } else {
497 char s1[2];
498 /* print ascii string */
499 s1[0] = ( unsigned char) va_arg(args, int);
500 s1[1] = 0;
501 str = string(str, end, (char *)&s1, -1, field_width, precision, flags);
502 }
503 continue;
504
505 case 'C': /* finished */
506 if (!(flags & LEFT))
507 while (--field_width > 0) {
508 if (str <= end)
509 *str = ' ';
510 ++str;
511 }
512 if (qualifier == 'h') {
513 if (str <= end)
514 *str = (unsigned char) va_arg(args, int);
515 ++str;
516 } else {
517 if (str <= end)
518 *str = (unsigned char)(wchar_t) va_arg(args, int);
519 ++str;
520 }
521 while (--field_width > 0) {
522 if (str <= end)
523 *str = ' ';
524 ++str;
525 }
526 continue;
527
528 case 's': /* finished */
529 if (qualifier == 'l' || qualifier == 'w') {
530 /* print unicode string */
531 sw = va_arg(args, wchar_t *);
532 str = stringw(str, end, sw, -1, field_width, precision, flags);
533 } else {
534 /* print ascii string */
535 s = va_arg(args, char *);
536 str = string(str, end, s, -1, field_width, precision, flags);
537 }
538 continue;
539
540 case 'S':
541 if (qualifier == 'h') {
542 /* print ascii string */
543 s = va_arg(args, char *);
544 str = string(str, end, s, -1, field_width, precision, flags);
545 } else {
546 /* print unicode string */
547 sw = va_arg(args, wchar_t *);
548 str = stringw(str, end, sw, -1, field_width, precision, flags);
549 }
550 continue;
551
552 case 'Z':
553 if (qualifier == 'w') {
554 /* print counted unicode string */
555 PUNICODE_STRING pus = va_arg(args, PUNICODE_STRING);
556 if ((pus == NULL) || (pus->Buffer == NULL)) {
557 sw = NULL;
558 len = -1;
559 } else {
560 sw = pus->Buffer;
561 len = pus->Length / sizeof(WCHAR);
562 }
563 str = stringw(str, end, sw, len, field_width, precision, flags);
564 } else {
565 /* print counted ascii string */
566 PANSI_STRING pus = va_arg(args, PANSI_STRING);
567 if ((pus == NULL) || (pus->Buffer == NULL)) {
568 s = NULL;
569 len = -1;
570 } else {
571 s = pus->Buffer;
572 len = pus->Length;
573 }
574 str = string(str, end, s, len, field_width, precision, flags);
575 }
576 continue;
577
578 case 'p':
579 if ((flags & LARGE) == 0)
580 flags |= LARGE;
581
582 if (field_width == -1) {
583 field_width = 2 * sizeof(void *);
584 flags |= ZEROPAD;
585 }
586 str = number(str, end,
587 (ULONG_PTR) va_arg(args, void *), 16,
588 field_width, precision, flags);
589 continue;
590
591 case 'n':
592 /* FIXME: What does C99 say about the overflow case here? */
593 if (qualifier == 'l') {
594 long * ip = va_arg(args, long *);
595 *ip = (str - buf);
596 } else {
597 int * ip = va_arg(args, int *);
598 *ip = (str - buf);
599 }
600 continue;
601
602 /* float number formats - set up the flags and "break" */
603 case 'e':
604 case 'E':
605 case 'f':
606 case 'g':
607 case 'G':
608 _double = (double)va_arg(args, double);
609 if ( _isnan(_double) ) {
610 s = "Nan";
611 len = 3;
612 while ( len > 0 ) {
613 if (str <= end)
614 *str = *s++;
615 ++str;
616 len --;
617 }
618 } else if ( _isinf(_double) < 0 ) {
619 s = "-Inf";
620 len = 4;
621 while ( len > 0 ) {
622 if (str <= end)
623 *str = *s++;
624 ++str;
625 len --;
626 }
627 } else if ( _isinf(_double) > 0 ) {
628 s = "+Inf";
629 len = 4;
630 while ( len > 0 ) {
631 if (str <= end)
632 *str = *s++;
633 ++str;
634 len --;
635 }
636 } else {
637 if ( precision == -1 )
638 precision = 6;
639 str = numberf(str, end, (int)_double, base, field_width, precision, flags);
640 }
641
642 continue;
643
644
645 /* integer number formats - set up the flags and "break" */
646 case 'o':
647 base = 8;
648 break;
649
650 case 'b':
651 base = 2;
652 break;
653
654 case 'X':
655 flags |= LARGE;
656 case 'x':
657 base = 16;
658 break;
659
660 case 'd':
661 case 'i':
662 flags |= SIGN;
663 case 'u':
664 break;
665
666 default:
667 if (*fmt) {
668 if (str <= end)
669 *str = *fmt;
670 ++str;
671 } else
672 --fmt;
673 continue;
674 }
675
676 if (qualifier == 'I')
677 num = va_arg(args, unsigned long long);
678 else if (qualifier == 'l') {
679 if (flags & SIGN)
680 num = va_arg(args, long);
681 else
682 num = va_arg(args, unsigned long);
683 }
684 else if (qualifier == 'h') {
685 if (flags & SIGN)
686 num = va_arg(args, int);
687 else
688 num = va_arg(args, unsigned int);
689 }
690 else {
691 if (flags & SIGN)
692 num = va_arg(args, int);
693 else
694 num = va_arg(args, unsigned int);
695 }
696 str = number(str, end, num, base, field_width, precision, flags);
697 }
698 if (str <= end)
699 *str = '\0';
700 else if (cnt > 0)
701 /* don't write out a null byte if the buf size is zero */
702 *end = '\0';
703 return str-buf;
704 }
705
706
707 /*
708 * @implemented
709 */
710 int sprintf(char * buf, const char *fmt, ...)
711 {
712 va_list args;
713 int i;
714
715 va_start(args, fmt);
716 i=_vsnprintf(buf,MAXLONG,fmt,args);
717 va_end(args);
718 return i;
719 }
720
721
722 /*
723 * @implemented
724 */
725 int _snprintf(char * buf, size_t cnt, const char *fmt, ...)
726 {
727 va_list args;
728 int i;
729
730 va_start(args, fmt);
731 i=_vsnprintf(buf,cnt,fmt,args);
732 va_end(args);
733 return i;
734 }
735
736
737 /*
738 * @implemented
739 */
740 int __cdecl vsprintf(char *buf, const char *fmt, va_list args)
741 {
742 return _vsnprintf(buf,MAXLONG,fmt,args);
743 }
744
745 /* EOF */
746 #endif
747