Go to the source code of this file.
Functions | |
void | dummy_snprintf (void) |
size_t | dopr (char *buffer, size_t maxlen, const char *format, va_list args) |
void | fmtstr (char *buffer, size_t *currlen, size_t maxlen, char *value, int flags, int min, int max) |
void | fmtint (char *buffer, size_t *currlen, size_t maxlen, long value, int base, int min, int max, int flags) |
void | fmtfp (char *buffer, size_t *currlen, size_t maxlen, LDOUBLE fvalue, int min, int max, int flags) |
void | dopr_outch (char *buffer, size_t *currlen, size_t maxlen, char c) |
LDOUBLE | abs_val (LDOUBLE value) |
LDOUBLE | POW10 (int exp) |
LLONG | ROUND (LDOUBLE value) |
double | my_modf (double x0, double *iptr) |
int | vsnprintf (char *str, size_t count, const char *fmt, va_list args) |
int | snprintf (char *str, size_t count, const char *fmt,...) |
int | vasprintf (char **ptr, const char *format, va_list ap) |
int | asprintf (char **ptr, const char *format,...) |
int | sprintf (char *str, const char *fmt,...) |
int | main (void) |
|
Definition at line 82 of file snprintf.c.
00082 {} |
|
Definition at line 141 of file snprintf.c. References dopr_outch(), fmtfp(), fmtint(), fmtstr(), and value. Referenced by vsnprintf().
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') { /* It's a long long */ 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 /* um, floating point? */ 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 /* not supported yet, treat as next char */ 00370 ch = *format++; 00371 break; 00372 default: 00373 /* Unknown, skip */ 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 /* hmm? */ 00385 break; /* some picky compilers need this */ 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 } |
|
Definition at line 398 of file snprintf.c. References dopr_outch(), and value. Referenced by dopr().
00400 { 00401 int padlen, strln; /* amount to pad */ 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); /* strlen */ 00412 padlen = min - strln; 00413 if (padlen < 0) 00414 padlen = 0; 00415 if (flags & DP_F_MINUS) 00416 padlen = -padlen; /* Left Justify */ 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 } |
|
Definition at line 436 of file snprintf.c. References dopr_outch(), and value. Referenced by dopr().
00438 { 00439 int signvalue = 0; 00440 unsigned long uvalue; 00441 char convert[20]; 00442 int place = 0; 00443 int spadlen = 0; /* amount to space pad */ 00444 int zpadlen = 0; /* amount to zero pad */ 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) /* Do a sign (+/i) */ 00458 signvalue = '+'; 00459 else if (flags & DP_F_SPACE) 00460 signvalue = ' '; 00461 } 00462 } 00463 00464 if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */ 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; /* Left Justifty */ 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 /* Spaces */ 00492 while (spadlen > 0) { 00493 dopr_outch (buffer, currlen, maxlen, ' '); 00494 --spadlen; 00495 } 00496 00497 /* Sign */ 00498 if (signvalue) 00499 dopr_outch (buffer, currlen, maxlen, signvalue); 00500 00501 /* Zeros */ 00502 if (zpadlen > 0) { 00503 while (zpadlen > 0) { 00504 dopr_outch (buffer, currlen, maxlen, '0'); 00505 --zpadlen; 00506 } 00507 } 00508 00509 /* Digits */ 00510 while (place > 0) 00511 dopr_outch (buffer, currlen, maxlen, convert[--place]); 00512 00513 /* Left Justified spaces */ 00514 while (spadlen < 0) { 00515 dopr_outch (buffer, currlen, maxlen, ' '); 00516 ++spadlen; 00517 } 00518 } |
|
Definition at line 589 of file snprintf.c. References abs_val(), dopr_outch(), my_modf(), POW10(), and ROUND(). Referenced by dopr().
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; /* amount to pad */ 00599 int zpadlen = 0; 00600 int caps = 0; 00601 int index; 00602 double intpart; 00603 double fracpart; 00604 double temp; 00605 00606 /* 00607 * AIX manpage says the default is 0, but Solaris says the default 00608 * is 6, and sprintf on AIX defaults to 6 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) { /* Do a sign (+/i) */ 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; /* Should characters be upper case? */ 00628 #endif 00629 00630 #if 0 00631 if (max == 0) ufvalue += 0.5; /* if max = 0 we must round */ 00632 #endif 00633 00634 /* 00635 * Sorry, we only support 16 digits past the decimal because of our 00636 * conversion method 00637 */ 00638 if (max > 16) 00639 max = 16; 00640 00641 /* We "cheat" by converting the fractional part to integer by 00642 * multiplying by a factor of 10 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 /* Convert integer part */ 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 /* index = (int) (((double)(temp*0.1) -intpart +0.05) *10.0); */ 00663 /* printf ("%llf, %f, %x\n", temp, intpart, index); */ 00664 iconvert[iplace++] = 00665 (caps? "0123456789ABCDEF":"0123456789abcdef")[index]; 00666 } while (intpart && (iplace < 311)); 00667 if (iplace == 311) iplace--; 00668 iconvert[iplace] = 0; 00669 00670 /* Convert fractional part */ 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 /* index = (int) ((((temp/10) -fracpart) +0.05) *10); */ 00679 /* printf ("%lf, %lf, %ld\n", temp, fracpart, index); */ 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 /* -1 for decimal point, another -1 if we are printing a sign */ 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; /* Left Justifty */ 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 * Decimal point. This should probably use locale to find the correct 00723 * char to print out. 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 } |
|
Definition at line 743 of file snprintf.c. Referenced by dopr(), fmtfp(), fmtint(), and fmtstr().
00744 { 00745 if (*currlen < maxlen) { 00746 buffer[(*currlen)] = c; 00747 } 00748 (*currlen)++; 00749 } |
|
Definition at line 520 of file snprintf.c. References value. Referenced by fmtfp().
|
|
Definition at line 530 of file snprintf.c. Referenced by fmtfp().
00531 { 00532 LDOUBLE result = 1; 00533 00534 while (exp) { 00535 result *= 10; 00536 exp--; 00537 } 00538 00539 return result; 00540 } |
|
Definition at line 542 of file snprintf.c. References value. Referenced by fmtfp().
|
|
Definition at line 555 of file snprintf.c. Referenced by fmtfp().
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 /* yikes! the number is beyond what we can handle. What do we do? */ 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 } |
|
Definition at line 752 of file snprintf.c. References dopr(). Referenced by io_printf(), rprintf(), rsyserr(), snprintf(), and vasprintf().
00753 { 00754 return dopr(str, count, fmt, args); 00755 } |
|
Definition at line 759 of file snprintf.c. References vsnprintf(). Referenced by add_cvs_excludes(), check_refuse_options(), daemon_main(), delete_file(), establish_proxy_connection(), get_tmpname(), keep_backup(), log_formatted(), main(), make_bak_dir(), make_simple_backup(), open_socket_in(), open_socket_out(), parse_arguments(), recv_files(), recv_generator(), rep_inet_ntoa(), server_options(), skip_file(), and write_batch_argvs_file().
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 } |
|
Definition at line 774 of file snprintf.c. References vsnprintf(). Referenced by asprintf().
|
|
Definition at line 791 of file snprintf.c. References vasprintf(). Referenced by _Insure_trap_error(), and glob_expand().
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 } |
|
Referenced by inet_ntop4(), inet_ntop6(), list_file(), main(), robust_unlink(), and rsync_panic_handler(). |
|
Definition at line 808 of file snprintf.c. References snprintf(), and sprintf().
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 } |