00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058 #ifndef NO_CONFIG_H
00059 #include "config.h"
00060 #endif
00061
00062 #ifdef HAVE_STRING_H
00063 #include <string.h>
00064 #endif
00065
00066 #ifdef HAVE_STRINGS_H
00067 #include <strings.h>
00068 #endif
00069 #ifdef HAVE_CTYPE_H
00070 #include <ctype.h>
00071 #endif
00072 #include <sys/types.h>
00073 #include <stdarg.h>
00074 #ifdef HAVE_STDLIB_H
00075 #include <stdlib.h>
00076 #endif
00077
00078 #if defined(HAVE_SNPRINTF) && defined(HAVE_VSNPRINTF) && defined(HAVE_C99_VSNPRINTF)
00079
00080 #include <stdio.h>
00081
00082 void dummy_snprintf(void) {}
00083 #else
00084
00085 #ifdef HAVE_LONG_DOUBLE
00086 #define LDOUBLE long double
00087 #else
00088 #define LDOUBLE double
00089 #endif
00090
00091 #ifdef HAVE_LONG_LONG
00092 #define LLONG long long
00093 #else
00094 #define LLONG long
00095 #endif
00096
00097 static size_t dopr(char *buffer, size_t maxlen, const char *format,
00098 va_list args);
00099 static void fmtstr(char *buffer, size_t *currlen, size_t maxlen,
00100 char *value, int flags, int min, int max);
00101 static void fmtint(char *buffer, size_t *currlen, size_t maxlen,
00102 long value, int base, int min, int max, int flags);
00103 static void fmtfp(char *buffer, size_t *currlen, size_t maxlen,
00104 LDOUBLE fvalue, int min, int max, int flags);
00105 static void dopr_outch(char *buffer, size_t *currlen, size_t maxlen, char c);
00106
00107
00108
00109
00110
00111
00112 #define DP_S_DEFAULT 0
00113 #define DP_S_FLAGS 1
00114 #define DP_S_MIN 2
00115 #define DP_S_DOT 3
00116 #define DP_S_MAX 4
00117 #define DP_S_MOD 5
00118 #define DP_S_CONV 6
00119 #define DP_S_DONE 7
00120
00121
00122 #define DP_F_MINUS (1 << 0)
00123 #define DP_F_PLUS (1 << 1)
00124 #define DP_F_SPACE (1 << 2)
00125 #define DP_F_NUM (1 << 3)
00126 #define DP_F_ZERO (1 << 4)
00127 #define DP_F_UP (1 << 5)
00128 #define DP_F_UNSIGNED (1 << 6)
00129
00130
00131 #define DP_C_SHORT 1
00132 #define DP_C_LONG 2
00133 #define DP_C_LDOUBLE 3
00134 #define DP_C_LLONG 4
00135
00136 #define char_to_int(p) ((p)- '0')
00137 #ifndef MAX
00138 #define MAX(p,q) (((p) >= (q)) ? (p) : (q))
00139 #endif
00140
00141 static size_t dopr(char *buffer, size_t maxlen, const char *format, va_list args)
00142 {
00143 char ch;
00144 LLONG value;
00145 LDOUBLE fvalue;
00146 char *strvalue;
00147 int min;
00148 int max;
00149 int state;
00150 int flags;
00151 int cflags;
00152 size_t currlen;
00153
00154 state = DP_S_DEFAULT;
00155 currlen = flags = cflags = min = 0;
00156 max = -1;
00157 ch = *format++;
00158
00159 while (state != DP_S_DONE) {
00160 if (ch == '\0')
00161 state = DP_S_DONE;
00162
00163 switch(state) {
00164 case DP_S_DEFAULT:
00165 if (ch == '%')
00166 state = DP_S_FLAGS;
00167 else
00168 dopr_outch (buffer, &currlen, maxlen, ch);
00169 ch = *format++;
00170 break;
00171 case DP_S_FLAGS:
00172 switch (ch) {
00173 case '-':
00174 flags |= DP_F_MINUS;
00175 ch = *format++;
00176 break;
00177 case '+':
00178 flags |= DP_F_PLUS;
00179 ch = *format++;
00180 break;
00181 case ' ':
00182 flags |= DP_F_SPACE;
00183 ch = *format++;
00184 break;
00185 case '#':
00186 flags |= DP_F_NUM;
00187 ch = *format++;
00188 break;
00189 case '0':
00190 flags |= DP_F_ZERO;
00191 ch = *format++;
00192 break;
00193 default:
00194 state = DP_S_MIN;
00195 break;
00196 }
00197 break;
00198 case DP_S_MIN:
00199 if (isdigit((unsigned char)ch)) {
00200 min = 10*min + char_to_int (ch);
00201 ch = *format++;
00202 } else if (ch == '*') {
00203 min = va_arg (args, int);
00204 ch = *format++;
00205 state = DP_S_DOT;
00206 } else {
00207 state = DP_S_DOT;
00208 }
00209 break;
00210 case DP_S_DOT:
00211 if (ch == '.') {
00212 state = DP_S_MAX;
00213 ch = *format++;
00214 } else {
00215 state = DP_S_MOD;
00216 }
00217 break;
00218 case DP_S_MAX:
00219 if (isdigit((unsigned char)ch)) {
00220 if (max < 0)
00221 max = 0;
00222 max = 10*max + char_to_int (ch);
00223 ch = *format++;
00224 } else if (ch == '*') {
00225 max = va_arg (args, int);
00226 ch = *format++;
00227 state = DP_S_MOD;
00228 } else {
00229 state = DP_S_MOD;
00230 }
00231 break;
00232 case DP_S_MOD:
00233 switch (ch) {
00234 case 'h':
00235 cflags = DP_C_SHORT;
00236 ch = *format++;
00237 break;
00238 case 'l':
00239 cflags = DP_C_LONG;
00240 ch = *format++;
00241 if (ch == 'l') {
00242 cflags = DP_C_LLONG;
00243 ch = *format++;
00244 }
00245 break;
00246 case 'L':
00247 cflags = DP_C_LDOUBLE;
00248 ch = *format++;
00249 break;
00250 default:
00251 break;
00252 }
00253 state = DP_S_CONV;
00254 break;
00255 case DP_S_CONV:
00256 switch (ch) {
00257 case 'd':
00258 case 'i':
00259 if (cflags == DP_C_SHORT)
00260 value = va_arg (args, int);
00261 else if (cflags == DP_C_LONG)
00262 value = va_arg (args, long int);
00263 else if (cflags == DP_C_LLONG)
00264 value = va_arg (args, LLONG);
00265 else
00266 value = va_arg (args, int);
00267 fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
00268 break;
00269 case 'o':
00270 flags |= DP_F_UNSIGNED;
00271 if (cflags == DP_C_SHORT)
00272 value = va_arg (args, unsigned int);
00273 else if (cflags == DP_C_LONG)
00274 value = (long)va_arg (args, unsigned long int);
00275 else if (cflags == DP_C_LLONG)
00276 value = (long)va_arg (args, unsigned LLONG);
00277 else
00278 value = (long)va_arg (args, unsigned int);
00279 fmtint (buffer, &currlen, maxlen, value, 8, min, max, flags);
00280 break;
00281 case 'u':
00282 flags |= DP_F_UNSIGNED;
00283 if (cflags == DP_C_SHORT)
00284 value = va_arg (args, unsigned int);
00285 else if (cflags == DP_C_LONG)
00286 value = (long)va_arg (args, unsigned long int);
00287 else if (cflags == DP_C_LLONG)
00288 value = (LLONG)va_arg (args, unsigned LLONG);
00289 else
00290 value = (long)va_arg (args, unsigned int);
00291 fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
00292 break;
00293 case 'X':
00294 flags |= DP_F_UP;
00295 case 'x':
00296 flags |= DP_F_UNSIGNED;
00297 if (cflags == DP_C_SHORT)
00298 value = va_arg (args, unsigned int);
00299 else if (cflags == DP_C_LONG)
00300 value = (long)va_arg (args, unsigned long int);
00301 else if (cflags == DP_C_LLONG)
00302 value = (LLONG)va_arg (args, unsigned LLONG);
00303 else
00304 value = (long)va_arg (args, unsigned int);
00305 fmtint (buffer, &currlen, maxlen, value, 16, min, max, flags);
00306 break;
00307 case 'f':
00308 if (cflags == DP_C_LDOUBLE)
00309 fvalue = va_arg (args, LDOUBLE);
00310 else
00311 fvalue = va_arg (args, double);
00312
00313 fmtfp (buffer, &currlen, maxlen, fvalue, min, max, flags);
00314 break;
00315 case 'E':
00316 flags |= DP_F_UP;
00317 case 'e':
00318 if (cflags == DP_C_LDOUBLE)
00319 fvalue = va_arg (args, LDOUBLE);
00320 else
00321 fvalue = va_arg (args, double);
00322 break;
00323 case 'G':
00324 flags |= DP_F_UP;
00325 case 'g':
00326 if (cflags == DP_C_LDOUBLE)
00327 fvalue = va_arg (args, LDOUBLE);
00328 else
00329 fvalue = va_arg (args, double);
00330 break;
00331 case 'c':
00332 dopr_outch (buffer, &currlen, maxlen, va_arg (args, int));
00333 break;
00334 case 's':
00335 strvalue = va_arg (args, char *);
00336 if (max == -1) {
00337 max = strlen(strvalue);
00338 }
00339 if (min > 0 && max >= 0 && min > max) max = min;
00340 fmtstr (buffer, &currlen, maxlen, strvalue, flags, min, max);
00341 break;
00342 case 'p':
00343 strvalue = va_arg (args, void *);
00344 fmtint (buffer, &currlen, maxlen, (long) strvalue, 16, min, max, flags);
00345 break;
00346 case 'n':
00347 if (cflags == DP_C_SHORT) {
00348 short int *num;
00349 num = va_arg (args, short int *);
00350 *num = currlen;
00351 } else if (cflags == DP_C_LONG) {
00352 long int *num;
00353 num = va_arg (args, long int *);
00354 *num = (long int)currlen;
00355 } else if (cflags == DP_C_LLONG) {
00356 LLONG *num;
00357 num = va_arg (args, LLONG *);
00358 *num = (LLONG)currlen;
00359 } else {
00360 int *num;
00361 num = va_arg (args, int *);
00362 *num = currlen;
00363 }
00364 break;
00365 case '%':
00366 dopr_outch (buffer, &currlen, maxlen, ch);
00367 break;
00368 case 'w':
00369
00370 ch = *format++;
00371 break;
00372 default:
00373
00374 break;
00375 }
00376 ch = *format++;
00377 state = DP_S_DEFAULT;
00378 flags = cflags = min = 0;
00379 max = -1;
00380 break;
00381 case DP_S_DONE:
00382 break;
00383 default:
00384
00385 break;
00386 }
00387 }
00388 if (maxlen != 0) {
00389 if (currlen < maxlen - 1)
00390 buffer[currlen] = '\0';
00391 else if (maxlen > 0)
00392 buffer[maxlen - 1] = '\0';
00393 }
00394
00395 return currlen;
00396 }
00397
00398 static void fmtstr(char *buffer, size_t *currlen, size_t maxlen,
00399 char *value, int flags, int min, int max)
00400 {
00401 int padlen, strln;
00402 int cnt = 0;
00403
00404 #ifdef DEBUG_SNPRINTF
00405 printf("fmtstr min=%d max=%d s=[%s]\n", min, max, value);
00406 #endif
00407 if (value == 0) {
00408 value = "<NULL>";
00409 }
00410
00411 for (strln = 0; value[strln]; ++strln);
00412 padlen = min - strln;
00413 if (padlen < 0)
00414 padlen = 0;
00415 if (flags & DP_F_MINUS)
00416 padlen = -padlen;
00417
00418 while ((padlen > 0) && (cnt < max)) {
00419 dopr_outch (buffer, currlen, maxlen, ' ');
00420 --padlen;
00421 ++cnt;
00422 }
00423 while (*value && (cnt < max)) {
00424 dopr_outch (buffer, currlen, maxlen, *value++);
00425 ++cnt;
00426 }
00427 while ((padlen < 0) && (cnt < max)) {
00428 dopr_outch (buffer, currlen, maxlen, ' ');
00429 ++padlen;
00430 ++cnt;
00431 }
00432 }
00433
00434
00435
00436 static void fmtint(char *buffer, size_t *currlen, size_t maxlen,
00437 long value, int base, int min, int max, int flags)
00438 {
00439 int signvalue = 0;
00440 unsigned long uvalue;
00441 char convert[20];
00442 int place = 0;
00443 int spadlen = 0;
00444 int zpadlen = 0;
00445 int caps = 0;
00446
00447 if (max < 0)
00448 max = 0;
00449
00450 uvalue = value;
00451
00452 if(!(flags & DP_F_UNSIGNED)) {
00453 if( value < 0 ) {
00454 signvalue = '-';
00455 uvalue = -value;
00456 } else {
00457 if (flags & DP_F_PLUS)
00458 signvalue = '+';
00459 else if (flags & DP_F_SPACE)
00460 signvalue = ' ';
00461 }
00462 }
00463
00464 if (flags & DP_F_UP) caps = 1;
00465
00466 do {
00467 convert[place++] =
00468 (caps? "0123456789ABCDEF":"0123456789abcdef")
00469 [uvalue % (unsigned)base ];
00470 uvalue = (uvalue / (unsigned)base );
00471 } while(uvalue && (place < 20));
00472 if (place == 20) place--;
00473 convert[place] = 0;
00474
00475 zpadlen = max - place;
00476 spadlen = min - MAX (max, place) - (signvalue ? 1 : 0);
00477 if (zpadlen < 0) zpadlen = 0;
00478 if (spadlen < 0) spadlen = 0;
00479 if (flags & DP_F_ZERO) {
00480 zpadlen = MAX(zpadlen, spadlen);
00481 spadlen = 0;
00482 }
00483 if (flags & DP_F_MINUS)
00484 spadlen = -spadlen;
00485
00486 #ifdef DEBUG_SNPRINTF
00487 printf("zpad: %d, spad: %d, min: %d, max: %d, place: %d\n",
00488 zpadlen, spadlen, min, max, place);
00489 #endif
00490
00491
00492 while (spadlen > 0) {
00493 dopr_outch (buffer, currlen, maxlen, ' ');
00494 --spadlen;
00495 }
00496
00497
00498 if (signvalue)
00499 dopr_outch (buffer, currlen, maxlen, signvalue);
00500
00501
00502 if (zpadlen > 0) {
00503 while (zpadlen > 0) {
00504 dopr_outch (buffer, currlen, maxlen, '0');
00505 --zpadlen;
00506 }
00507 }
00508
00509
00510 while (place > 0)
00511 dopr_outch (buffer, currlen, maxlen, convert[--place]);
00512
00513
00514 while (spadlen < 0) {
00515 dopr_outch (buffer, currlen, maxlen, ' ');
00516 ++spadlen;
00517 }
00518 }
00519
00520 static LDOUBLE abs_val(LDOUBLE value)
00521 {
00522 LDOUBLE result = value;
00523
00524 if (value < 0)
00525 result = -value;
00526
00527 return result;
00528 }
00529
00530 static LDOUBLE POW10(int exp)
00531 {
00532 LDOUBLE result = 1;
00533
00534 while (exp) {
00535 result *= 10;
00536 exp--;
00537 }
00538
00539 return result;
00540 }
00541
00542 static LLONG ROUND(LDOUBLE value)
00543 {
00544 LLONG intpart;
00545
00546 intpart = (LLONG)value;
00547 value = value - intpart;
00548 if (value >= 0.5) intpart++;
00549
00550 return intpart;
00551 }
00552
00553
00554
00555 static double my_modf(double x0, double *iptr)
00556 {
00557 int i;
00558 long l;
00559 double x = x0;
00560 double f = 1.0;
00561
00562 for (i=0;i<100;i++) {
00563 l = (long)x;
00564 if (l <= (x+1) && l >= (x-1)) break;
00565 x *= 0.1;
00566 f *= 10.0;
00567 }
00568
00569 if (i == 100) {
00570
00571 (*iptr) = 0;
00572 return 0;
00573 }
00574
00575 if (i != 0) {
00576 double i2;
00577 double ret;
00578
00579 ret = my_modf(x0-l*f, &i2);
00580 (*iptr) = l*f + i2;
00581 return ret;
00582 }
00583
00584 (*iptr) = l;
00585 return x - (*iptr);
00586 }
00587
00588
00589 static void fmtfp (char *buffer, size_t *currlen, size_t maxlen,
00590 LDOUBLE fvalue, int min, int max, int flags)
00591 {
00592 int signvalue = 0;
00593 double ufvalue;
00594 char iconvert[311];
00595 char fconvert[311];
00596 int iplace = 0;
00597 int fplace = 0;
00598 int padlen = 0;
00599 int zpadlen = 0;
00600 int caps = 0;
00601 int index;
00602 double intpart;
00603 double fracpart;
00604 double temp;
00605
00606
00607
00608
00609
00610 if (max < 0)
00611 max = 6;
00612
00613 ufvalue = abs_val (fvalue);
00614
00615 if (fvalue < 0) {
00616 signvalue = '-';
00617 } else {
00618 if (flags & DP_F_PLUS) {
00619 signvalue = '+';
00620 } else {
00621 if (flags & DP_F_SPACE)
00622 signvalue = ' ';
00623 }
00624 }
00625
00626 #if 0
00627 if (flags & DP_F_UP) caps = 1;
00628 #endif
00629
00630 #if 0
00631 if (max == 0) ufvalue += 0.5;
00632 #endif
00633
00634
00635
00636
00637
00638 if (max > 16)
00639 max = 16;
00640
00641
00642
00643
00644
00645 temp = ufvalue;
00646 my_modf(temp, &intpart);
00647
00648 fracpart = ROUND((POW10(max)) * (ufvalue - intpart));
00649
00650 if (fracpart >= POW10(max)) {
00651 intpart++;
00652 fracpart -= POW10(max);
00653 }
00654
00655
00656
00657 do {
00658 temp = intpart;
00659 my_modf(intpart*0.1, &intpart);
00660 temp = temp*0.1;
00661 index = (int) ((temp -intpart +0.05)* 10.0);
00662
00663
00664 iconvert[iplace++] =
00665 (caps? "0123456789ABCDEF":"0123456789abcdef")[index];
00666 } while (intpart && (iplace < 311));
00667 if (iplace == 311) iplace--;
00668 iconvert[iplace] = 0;
00669
00670
00671 if (fracpart)
00672 {
00673 do {
00674 temp = fracpart;
00675 my_modf(fracpart*0.1, &fracpart);
00676 temp = temp*0.1;
00677 index = (int) ((temp -fracpart +0.05)* 10.0);
00678
00679
00680 fconvert[fplace++] =
00681 (caps? "0123456789ABCDEF":"0123456789abcdef")[index];
00682 } while(fracpart && (fplace < 311));
00683 if (fplace == 311) fplace--;
00684 }
00685 fconvert[fplace] = 0;
00686
00687
00688 padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0);
00689 zpadlen = max - fplace;
00690 if (zpadlen < 0) zpadlen = 0;
00691 if (padlen < 0)
00692 padlen = 0;
00693 if (flags & DP_F_MINUS)
00694 padlen = -padlen;
00695
00696 if ((flags & DP_F_ZERO) && (padlen > 0)) {
00697 if (signvalue) {
00698 dopr_outch (buffer, currlen, maxlen, signvalue);
00699 --padlen;
00700 signvalue = 0;
00701 }
00702 while (padlen > 0) {
00703 dopr_outch (buffer, currlen, maxlen, '0');
00704 --padlen;
00705 }
00706 }
00707 while (padlen > 0) {
00708 dopr_outch (buffer, currlen, maxlen, ' ');
00709 --padlen;
00710 }
00711 if (signvalue)
00712 dopr_outch (buffer, currlen, maxlen, signvalue);
00713
00714 while (iplace > 0)
00715 dopr_outch (buffer, currlen, maxlen, iconvert[--iplace]);
00716
00717 #ifdef DEBUG_SNPRINTF
00718 printf("fmtfp: fplace=%d zpadlen=%d\n", fplace, zpadlen);
00719 #endif
00720
00721
00722
00723
00724
00725 if (max > 0) {
00726 dopr_outch (buffer, currlen, maxlen, '.');
00727
00728 while (fplace > 0)
00729 dopr_outch (buffer, currlen, maxlen, fconvert[--fplace]);
00730 }
00731
00732 while (zpadlen > 0) {
00733 dopr_outch (buffer, currlen, maxlen, '0');
00734 --zpadlen;
00735 }
00736
00737 while (padlen < 0) {
00738 dopr_outch (buffer, currlen, maxlen, ' ');
00739 ++padlen;
00740 }
00741 }
00742
00743 static void dopr_outch(char *buffer, size_t *currlen, size_t maxlen, char c)
00744 {
00745 if (*currlen < maxlen) {
00746 buffer[(*currlen)] = c;
00747 }
00748 (*currlen)++;
00749 }
00750
00751 #if !defined(HAVE_VSNPRINTF) || !defined(HAVE_C99_VSNPRINTF)
00752 int vsnprintf (char *str, size_t count, const char *fmt, va_list args)
00753 {
00754 return dopr(str, count, fmt, args);
00755 }
00756 #endif
00757
00758 #if !defined(HAVE_SNPRINTF) || !defined(HAVE_C99_VSNPRINTF)
00759 int snprintf(char *str,size_t count,const char *fmt,...)
00760 {
00761 size_t ret;
00762 va_list ap;
00763
00764 va_start(ap, fmt);
00765 ret = vsnprintf(str, count, fmt, ap);
00766 va_end(ap);
00767 return ret;
00768 }
00769 #endif
00770
00771 #endif
00772
00773 #ifndef HAVE_VASPRINTF
00774 int vasprintf(char **ptr, const char *format, va_list ap)
00775 {
00776 int ret;
00777
00778 ret = vsnprintf(NULL, 0, format, ap);
00779 if (ret <= 0) return ret;
00780
00781 (*ptr) = (char *)malloc(ret+1);
00782 if (!*ptr) return -1;
00783 ret = vsnprintf(*ptr, ret+1, format, ap);
00784
00785 return ret;
00786 }
00787 #endif
00788
00789
00790 #ifndef HAVE_ASPRINTF
00791 int asprintf(char **ptr, const char *format, ...)
00792 {
00793 va_list ap;
00794 int ret;
00795
00796 va_start(ap, format);
00797 ret = vasprintf(ptr, format, ap);
00798 va_end(ap);
00799
00800 return ret;
00801 }
00802 #endif
00803
00804 #ifdef TEST_SNPRINTF
00805
00806 int sprintf(char *str,const char *fmt,...);
00807
00808 int main (void)
00809 {
00810 char buf1[1024];
00811 char buf2[1024];
00812 char *fp_fmt[] = {
00813 "%1.1f",
00814 "%-1.5f",
00815 "%1.5f",
00816 "%123.9f",
00817 "%10.5f",
00818 "% 10.5f",
00819 "%+22.9f",
00820 "%+4.9f",
00821 "%01.3f",
00822 "%4f",
00823 "%3.1f",
00824 "%3.2f",
00825 "%.0f",
00826 "%f",
00827 "-16.16f",
00828 NULL
00829 };
00830 double fp_nums[] = { 6442452944.1234, -1.5, 134.21, 91340.2, 341.1234, 0203.9, 0.96, 0.996,
00831 0.9996, 1.996, 4.136, 0};
00832 char *int_fmt[] = {
00833 "%-1.5d",
00834 "%1.5d",
00835 "%123.9d",
00836 "%5.5d",
00837 "%10.5d",
00838 "% 10.5d",
00839 "%+22.33d",
00840 "%01.3d",
00841 "%4d",
00842 "%d",
00843 NULL
00844 };
00845 long int_nums[] = { -1, 134, 91340, 341, 0203, 0};
00846 char *str_fmt[] = {
00847 "10.5s",
00848 "5.10s",
00849 "10.1s",
00850 "0.10s",
00851 "10.0s",
00852 "1.10s",
00853 "%s",
00854 "%.1s",
00855 "%.10s",
00856 "%10s",
00857 NULL
00858 };
00859 char *str_vals[] = {"hello", "a", "", "a longer string", NULL};
00860 int x, y;
00861 int fail = 0;
00862 int num = 0;
00863
00864 printf ("Testing snprintf format codes against system sprintf...\n");
00865
00866 for (x = 0; fp_fmt[x] ; x++) {
00867 for (y = 0; fp_nums[y] != 0 ; y++) {
00868 int l1 = snprintf(NULL, 0, fp_fmt[x], fp_nums[y]);
00869 int l2 = snprintf(buf1, sizeof(buf1), fp_fmt[x], fp_nums[y]);
00870 sprintf (buf2, fp_fmt[x], fp_nums[y]);
00871 if (strcmp (buf1, buf2)) {
00872 printf("snprintf doesn't match Format: %s\n\tsnprintf = [%s]\n\t sprintf = [%s]\n",
00873 fp_fmt[x], buf1, buf2);
00874 fail++;
00875 }
00876 if (l1 != l2) {
00877 printf("snprintf l1 != l2 (%d %d) %s\n", l1, l2, fp_fmt[x]);
00878 fail++;
00879 }
00880 num++;
00881 }
00882 }
00883
00884 for (x = 0; int_fmt[x] ; x++) {
00885 for (y = 0; int_nums[y] != 0 ; y++) {
00886 int l1 = snprintf(NULL, 0, int_fmt[x], int_nums[y]);
00887 int l2 = snprintf(buf1, sizeof(buf1), int_fmt[x], int_nums[y]);
00888 sprintf (buf2, int_fmt[x], int_nums[y]);
00889 if (strcmp (buf1, buf2)) {
00890 printf("snprintf doesn't match Format: %s\n\tsnprintf = [%s]\n\t sprintf = [%s]\n",
00891 int_fmt[x], buf1, buf2);
00892 fail++;
00893 }
00894 if (l1 != l2) {
00895 printf("snprintf l1 != l2 (%d %d) %s\n", l1, l2, int_fmt[x]);
00896 fail++;
00897 }
00898 num++;
00899 }
00900 }
00901
00902 for (x = 0; str_fmt[x] ; x++) {
00903 for (y = 0; str_vals[y] != 0 ; y++) {
00904 int l1 = snprintf(NULL, 0, str_fmt[x], str_vals[y]);
00905 int l2 = snprintf(buf1, sizeof(buf1), str_fmt[x], str_vals[y]);
00906 sprintf (buf2, str_fmt[x], str_vals[y]);
00907 if (strcmp (buf1, buf2)) {
00908 printf("snprintf doesn't match Format: %s\n\tsnprintf = [%s]\n\t sprintf = [%s]\n",
00909 str_fmt[x], buf1, buf2);
00910 fail++;
00911 }
00912 if (l1 != l2) {
00913 printf("snprintf l1 != l2 (%d %d) %s\n", l1, l2, str_fmt[x]);
00914 fail++;
00915 }
00916 num++;
00917 }
00918 }
00919
00920 printf ("%d tests failed out of %d.\n", fail, num);
00921
00922 printf("seeing how many digits we support\n");
00923 {
00924 double v0 = 0.12345678901234567890123456789012345678901;
00925 for (x=0; x<100; x++) {
00926 snprintf(buf1, sizeof(buf1), "%1.1f", v0*pow(10, x));
00927 sprintf(buf2, "%1.1f", v0*pow(10, x));
00928 if (strcmp(buf1, buf2)) {
00929 printf("we seem to support %d digits\n", x-1);
00930 break;
00931 }
00932 }
00933 }
00934
00935 return 0;
00936 }
00937 #endif