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 }
|
1.2.15