Annotation of embedaddon/rsync/lib/snprintf.c, revision 1.1
1.1 ! misho 1: /*
! 2: * NOTE: If you change this file, please merge it into rsync, samba, etc.
! 3: */
! 4:
! 5: /*
! 6: * Copyright Patrick Powell 1995
! 7: * This code is based on code written by Patrick Powell (papowell@astart.com)
! 8: * It may be used for any purpose as long as this notice remains intact
! 9: * on all source code distributions
! 10: */
! 11:
! 12: /**************************************************************
! 13: * Original:
! 14: * Patrick Powell Tue Apr 11 09:48:21 PDT 1995
! 15: * A bombproof version of doprnt (dopr) included.
! 16: * Sigh. This sort of thing is always nasty do deal with. Note that
! 17: * the version here does not include floating point...
! 18: *
! 19: * snprintf() is used instead of sprintf() as it does limit checks
! 20: * for string length. This covers a nasty loophole.
! 21: *
! 22: * The other functions are there to prevent NULL pointers from
! 23: * causing nast effects.
! 24: *
! 25: * More Recently:
! 26: * Brandon Long <blong@fiction.net> 9/15/96 for mutt 0.43
! 27: * This was ugly. It is still ugly. I opted out of floating point
! 28: * numbers, but the formatter understands just about everything
! 29: * from the normal C string format, at least as far as I can tell from
! 30: * the Solaris 2.5 printf(3S) man page.
! 31: *
! 32: * Brandon Long <blong@fiction.net> 10/22/97 for mutt 0.87.1
! 33: * Ok, added some minimal floating point support, which means this
! 34: * probably requires libm on most operating systems. Don't yet
! 35: * support the exponent (e,E) and sigfig (g,G). Also, fmtint()
! 36: * was pretty badly broken, it just wasn't being exercised in ways
! 37: * which showed it, so that's been fixed. Also, formated the code
! 38: * to mutt conventions, and removed dead code left over from the
! 39: * original. Also, there is now a builtin-test, just compile with:
! 40: * gcc -DTEST_SNPRINTF -o snprintf snprintf.c -lm
! 41: * and run snprintf for results.
! 42: *
! 43: * Thomas Roessler <roessler@guug.de> 01/27/98 for mutt 0.89i
! 44: * The PGP code was using unsigned hexadecimal formats.
! 45: * Unfortunately, unsigned formats simply didn't work.
! 46: *
! 47: * Michael Elkins <me@cs.hmc.edu> 03/05/98 for mutt 0.90.8
! 48: * The original code assumed that both snprintf() and vsnprintf() were
! 49: * missing. Some systems only have snprintf() but not vsnprintf(), so
! 50: * the code is now broken down under HAVE_SNPRINTF and HAVE_VSNPRINTF.
! 51: *
! 52: * Andrew Tridgell (tridge@samba.org) Oct 1998
! 53: * fixed handling of %.0f
! 54: * added test for HAVE_LONG_DOUBLE
! 55: *
! 56: * tridge@samba.org, idra@samba.org, April 2001
! 57: * got rid of fcvt code (twas buggy and made testing harder)
! 58: * added C99 semantics
! 59: *
! 60: * date: 2002/12/19 19:56:31; author: herb; state: Exp; lines: +2 -0
! 61: * actually print args for %g and %e
! 62: *
! 63: * date: 2002/06/03 13:37:52; author: jmcd; state: Exp; lines: +8 -0
! 64: * Since includes.h isn't included here, VA_COPY has to be defined here. I don't
! 65: * see any include file that is guaranteed to be here, so I'm defining it
! 66: * locally. Fixes AIX and Solaris builds.
! 67: *
! 68: * date: 2002/06/03 03:07:24; author: tridge; state: Exp; lines: +5 -13
! 69: * put the ifdef for HAVE_VA_COPY in one place rather than in lots of
! 70: * functions
! 71: *
! 72: * date: 2002/05/17 14:51:22; author: jmcd; state: Exp; lines: +21 -4
! 73: * Fix usage of va_list passed as an arg. Use __va_copy before using it
! 74: * when it exists.
! 75: *
! 76: * date: 2002/04/16 22:38:04; author: idra; state: Exp; lines: +20 -14
! 77: * Fix incorrect zpadlen handling in fmtfp.
! 78: * Thanks to Ollie Oldham <ollie.oldham@metro-optix.com> for spotting it.
! 79: * few mods to make it easier to compile the tests.
! 80: * addedd the "Ollie" test to the floating point ones.
! 81: *
! 82: * Martin Pool (mbp@samba.org) April 2003
! 83: * Remove NO_CONFIG_H so that the test case can be built within a source
! 84: * tree with less trouble.
! 85: * Remove unnecessary SAFE_FREE() definition.
! 86: *
! 87: * Martin Pool (mbp@samba.org) May 2003
! 88: * Put in a prototype for dummy_snprintf() to quiet compiler warnings.
! 89: *
! 90: * Move #endif to make sure VA_COPY, LDOUBLE, etc are defined even
! 91: * if the C library has some snprintf functions already.
! 92: **************************************************************/
! 93:
! 94: #ifndef NO_CONFIG_H
! 95: #include "config.h"
! 96: #else
! 97: #define NULL 0
! 98: #endif
! 99:
! 100: #ifdef TEST_SNPRINTF /* need math library headers for testing */
! 101:
! 102: /* In test mode, we pretend that this system doesn't have any snprintf
! 103: * functions, regardless of what config.h says. */
! 104: # undef HAVE_SNPRINTF
! 105: # undef HAVE_VSNPRINTF
! 106: # undef HAVE_C99_VSNPRINTF
! 107: # undef HAVE_ASPRINTF
! 108: # undef HAVE_VASPRINTF
! 109: # include <math.h>
! 110: #endif /* TEST_SNPRINTF */
! 111:
! 112: #ifdef HAVE_STRING_H
! 113: #include <string.h>
! 114: #endif
! 115:
! 116: #ifdef HAVE_STRINGS_H
! 117: #include <strings.h>
! 118: #endif
! 119: #ifdef HAVE_CTYPE_H
! 120: #include <ctype.h>
! 121: #endif
! 122: #include <sys/types.h>
! 123: #include <stdarg.h>
! 124: #ifdef HAVE_STDLIB_H
! 125: #include <stdlib.h>
! 126: #endif
! 127:
! 128: #if defined(HAVE_SNPRINTF) && defined(HAVE_VSNPRINTF) && defined(HAVE_C99_VSNPRINTF)
! 129: /* only include stdio.h if we are not re-defining snprintf or vsnprintf */
! 130: #include <stdio.h>
! 131: /* make the compiler happy with an empty file */
! 132: void dummy_snprintf(void);
! 133: void dummy_snprintf(void) {}
! 134: #endif /* HAVE_SNPRINTF, etc */
! 135:
! 136: #ifdef HAVE_LONG_DOUBLE
! 137: #define LDOUBLE long double
! 138: #else
! 139: #define LDOUBLE double
! 140: #endif
! 141:
! 142: #if SIZEOF_LONG_LONG
! 143: #define LLONG long long
! 144: #else
! 145: #define LLONG long
! 146: #endif
! 147:
! 148: #ifndef VA_COPY
! 149: #if defined HAVE_VA_COPY || defined va_copy
! 150: #define VA_COPY(dest, src) va_copy(dest, src)
! 151: #else
! 152: #ifdef HAVE___VA_COPY
! 153: #define VA_COPY(dest, src) __va_copy(dest, src)
! 154: #else
! 155: #define VA_COPY(dest, src) (dest) = (src)
! 156: #endif
! 157: #endif
! 158:
! 159: /*
! 160: * dopr(): poor man's version of doprintf
! 161: */
! 162:
! 163: /* format read states */
! 164: #define DP_S_DEFAULT 0
! 165: #define DP_S_FLAGS 1
! 166: #define DP_S_MIN 2
! 167: #define DP_S_DOT 3
! 168: #define DP_S_MAX 4
! 169: #define DP_S_MOD 5
! 170: #define DP_S_CONV 6
! 171: #define DP_S_DONE 7
! 172:
! 173: /* format flags - Bits */
! 174: #define DP_F_MINUS (1 << 0)
! 175: #define DP_F_PLUS (1 << 1)
! 176: #define DP_F_SPACE (1 << 2)
! 177: #define DP_F_NUM (1 << 3)
! 178: #define DP_F_ZERO (1 << 4)
! 179: #define DP_F_UP (1 << 5)
! 180: #define DP_F_UNSIGNED (1 << 6)
! 181:
! 182: /* Conversion Flags */
! 183: #define DP_C_SHORT 1
! 184: #define DP_C_LONG 2
! 185: #define DP_C_LDOUBLE 3
! 186: #define DP_C_LLONG 4
! 187:
! 188: #define char_to_int(p) ((p)- '0')
! 189: #ifndef MAX
! 190: #define MAX(p,q) (((p) >= (q)) ? (p) : (q))
! 191: #endif
! 192:
! 193: /* yes this really must be a ||. Don't muck with this (tridge) */
! 194: #if !defined(HAVE_VSNPRINTF) || !defined(HAVE_C99_VSNPRINTF)
! 195:
! 196: static size_t dopr(char *buffer, size_t maxlen, const char *format,
! 197: va_list args_in);
! 198: static void fmtstr(char *buffer, size_t *currlen, size_t maxlen,
! 199: char *value, int flags, int min, int max);
! 200: static void fmtint(char *buffer, size_t *currlen, size_t maxlen,
! 201: long value, int base, int min, int max, int flags);
! 202: static void fmtfp(char *buffer, size_t *currlen, size_t maxlen,
! 203: LDOUBLE fvalue, int min, int max, int flags);
! 204: static void dopr_outch(char *buffer, size_t *currlen, size_t maxlen, char c);
! 205:
! 206: static size_t dopr(char *buffer, size_t maxlen, const char *format, va_list args_in)
! 207: {
! 208: char ch;
! 209: LLONG value;
! 210: LDOUBLE fvalue;
! 211: char *strvalue;
! 212: int min;
! 213: int max;
! 214: int state;
! 215: int flags;
! 216: int cflags;
! 217: size_t currlen;
! 218: va_list args;
! 219:
! 220: VA_COPY(args, args_in);
! 221:
! 222: state = DP_S_DEFAULT;
! 223: currlen = flags = cflags = min = 0;
! 224: max = -1;
! 225: ch = *format++;
! 226:
! 227: while (state != DP_S_DONE) {
! 228: if (ch == '\0')
! 229: state = DP_S_DONE;
! 230:
! 231: switch(state) {
! 232: case DP_S_DEFAULT:
! 233: if (ch == '%')
! 234: state = DP_S_FLAGS;
! 235: else
! 236: dopr_outch (buffer, &currlen, maxlen, ch);
! 237: ch = *format++;
! 238: break;
! 239: case DP_S_FLAGS:
! 240: switch (ch) {
! 241: case '-':
! 242: flags |= DP_F_MINUS;
! 243: ch = *format++;
! 244: break;
! 245: case '+':
! 246: flags |= DP_F_PLUS;
! 247: ch = *format++;
! 248: break;
! 249: case ' ':
! 250: flags |= DP_F_SPACE;
! 251: ch = *format++;
! 252: break;
! 253: case '#':
! 254: flags |= DP_F_NUM;
! 255: ch = *format++;
! 256: break;
! 257: case '0':
! 258: flags |= DP_F_ZERO;
! 259: ch = *format++;
! 260: break;
! 261: default:
! 262: state = DP_S_MIN;
! 263: break;
! 264: }
! 265: break;
! 266: case DP_S_MIN:
! 267: if (isdigit((unsigned char)ch)) {
! 268: min = 10*min + char_to_int (ch);
! 269: ch = *format++;
! 270: } else if (ch == '*') {
! 271: min = va_arg (args, int);
! 272: ch = *format++;
! 273: state = DP_S_DOT;
! 274: } else {
! 275: state = DP_S_DOT;
! 276: }
! 277: break;
! 278: case DP_S_DOT:
! 279: if (ch == '.') {
! 280: state = DP_S_MAX;
! 281: ch = *format++;
! 282: } else {
! 283: state = DP_S_MOD;
! 284: }
! 285: break;
! 286: case DP_S_MAX:
! 287: if (isdigit((unsigned char)ch)) {
! 288: if (max < 0)
! 289: max = 0;
! 290: max = 10*max + char_to_int (ch);
! 291: ch = *format++;
! 292: } else if (ch == '*') {
! 293: max = va_arg (args, int);
! 294: ch = *format++;
! 295: state = DP_S_MOD;
! 296: } else {
! 297: state = DP_S_MOD;
! 298: }
! 299: break;
! 300: case DP_S_MOD:
! 301: switch (ch) {
! 302: case 'h':
! 303: cflags = DP_C_SHORT;
! 304: ch = *format++;
! 305: break;
! 306: case 'l':
! 307: cflags = DP_C_LONG;
! 308: ch = *format++;
! 309: if (ch == 'l') { /* It's a long long */
! 310: cflags = DP_C_LLONG;
! 311: ch = *format++;
! 312: }
! 313: break;
! 314: case 'L':
! 315: cflags = DP_C_LDOUBLE;
! 316: ch = *format++;
! 317: break;
! 318: default:
! 319: break;
! 320: }
! 321: state = DP_S_CONV;
! 322: break;
! 323: case DP_S_CONV:
! 324: switch (ch) {
! 325: case 'd':
! 326: case 'i':
! 327: if (cflags == DP_C_SHORT)
! 328: value = va_arg (args, int);
! 329: else if (cflags == DP_C_LONG)
! 330: value = va_arg (args, long int);
! 331: else if (cflags == DP_C_LLONG)
! 332: value = va_arg (args, LLONG);
! 333: else
! 334: value = va_arg (args, int);
! 335: fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
! 336: break;
! 337: case 'o':
! 338: flags |= DP_F_UNSIGNED;
! 339: if (cflags == DP_C_SHORT)
! 340: value = va_arg (args, unsigned int);
! 341: else if (cflags == DP_C_LONG)
! 342: value = (long)va_arg (args, unsigned long int);
! 343: else if (cflags == DP_C_LLONG)
! 344: value = (long)va_arg (args, unsigned LLONG);
! 345: else
! 346: value = (long)va_arg (args, unsigned int);
! 347: fmtint (buffer, &currlen, maxlen, value, 8, min, max, flags);
! 348: break;
! 349: case 'u':
! 350: flags |= DP_F_UNSIGNED;
! 351: if (cflags == DP_C_SHORT)
! 352: value = va_arg (args, unsigned int);
! 353: else if (cflags == DP_C_LONG)
! 354: value = (long)va_arg (args, unsigned long int);
! 355: else if (cflags == DP_C_LLONG)
! 356: value = (LLONG)va_arg (args, unsigned LLONG);
! 357: else
! 358: value = (long)va_arg (args, unsigned int);
! 359: fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
! 360: break;
! 361: case 'X':
! 362: flags |= DP_F_UP;
! 363: case 'x':
! 364: flags |= DP_F_UNSIGNED;
! 365: if (cflags == DP_C_SHORT)
! 366: value = va_arg (args, unsigned int);
! 367: else if (cflags == DP_C_LONG)
! 368: value = (long)va_arg (args, unsigned long int);
! 369: else if (cflags == DP_C_LLONG)
! 370: value = (LLONG)va_arg (args, unsigned LLONG);
! 371: else
! 372: value = (long)va_arg (args, unsigned int);
! 373: fmtint (buffer, &currlen, maxlen, value, 16, min, max, flags);
! 374: break;
! 375: case 'f':
! 376: if (cflags == DP_C_LDOUBLE)
! 377: fvalue = va_arg (args, LDOUBLE);
! 378: else
! 379: fvalue = va_arg (args, double);
! 380: /* um, floating point? */
! 381: fmtfp (buffer, &currlen, maxlen, fvalue, min, max, flags);
! 382: break;
! 383: case 'E':
! 384: flags |= DP_F_UP;
! 385: case 'e':
! 386: if (cflags == DP_C_LDOUBLE)
! 387: fvalue = va_arg (args, LDOUBLE);
! 388: else
! 389: fvalue = va_arg (args, double);
! 390: fmtfp (buffer, &currlen, maxlen, fvalue, min, max, flags);
! 391: break;
! 392: case 'G':
! 393: flags |= DP_F_UP;
! 394: case 'g':
! 395: if (cflags == DP_C_LDOUBLE)
! 396: fvalue = va_arg (args, LDOUBLE);
! 397: else
! 398: fvalue = va_arg (args, double);
! 399: fmtfp (buffer, &currlen, maxlen, fvalue, min, max, flags);
! 400: break;
! 401: case 'c':
! 402: dopr_outch (buffer, &currlen, maxlen, va_arg (args, int));
! 403: break;
! 404: case 's':
! 405: strvalue = va_arg (args, char *);
! 406: if (!strvalue) strvalue = "(NULL)";
! 407: if (max == -1) {
! 408: max = strlen(strvalue);
! 409: }
! 410: if (min > 0 && max >= 0 && min > max) max = min;
! 411: fmtstr (buffer, &currlen, maxlen, strvalue, flags, min, max);
! 412: break;
! 413: case 'p':
! 414: strvalue = va_arg (args, void *);
! 415: fmtint (buffer, &currlen, maxlen, (long) strvalue, 16, min, max, flags);
! 416: break;
! 417: case 'n':
! 418: if (cflags == DP_C_SHORT) {
! 419: short int *num;
! 420: num = va_arg (args, short int *);
! 421: *num = currlen;
! 422: } else if (cflags == DP_C_LONG) {
! 423: long int *num;
! 424: num = va_arg (args, long int *);
! 425: *num = (long int)currlen;
! 426: } else if (cflags == DP_C_LLONG) {
! 427: LLONG *num;
! 428: num = va_arg (args, LLONG *);
! 429: *num = (LLONG)currlen;
! 430: } else {
! 431: int *num;
! 432: num = va_arg (args, int *);
! 433: *num = currlen;
! 434: }
! 435: break;
! 436: case '%':
! 437: dopr_outch (buffer, &currlen, maxlen, ch);
! 438: break;
! 439: case 'w':
! 440: /* not supported yet, treat as next char */
! 441: ch = *format++;
! 442: break;
! 443: default:
! 444: /* Unknown, skip */
! 445: break;
! 446: }
! 447: ch = *format++;
! 448: state = DP_S_DEFAULT;
! 449: flags = cflags = min = 0;
! 450: max = -1;
! 451: break;
! 452: case DP_S_DONE:
! 453: break;
! 454: default:
! 455: /* hmm? */
! 456: break; /* some picky compilers need this */
! 457: }
! 458: }
! 459: if (maxlen != 0) {
! 460: if (currlen < maxlen - 1)
! 461: buffer[currlen] = '\0';
! 462: else if (maxlen > 0)
! 463: buffer[maxlen - 1] = '\0';
! 464: }
! 465:
! 466: return currlen;
! 467: }
! 468:
! 469: static void fmtstr(char *buffer, size_t *currlen, size_t maxlen,
! 470: char *value, int flags, int min, int max)
! 471: {
! 472: int padlen, strln; /* amount to pad */
! 473: int cnt = 0;
! 474:
! 475: #ifdef DEBUG_SNPRINTF
! 476: printf("fmtstr min=%d max=%d s=[%s]\n", min, max, value);
! 477: #endif
! 478: if (value == 0) {
! 479: value = "<NULL>";
! 480: }
! 481:
! 482: for (strln = 0; value[strln]; ++strln); /* strlen */
! 483: padlen = min - strln;
! 484: if (padlen < 0)
! 485: padlen = 0;
! 486: if (flags & DP_F_MINUS)
! 487: padlen = -padlen; /* Left Justify */
! 488:
! 489: while ((padlen > 0) && (cnt < max)) {
! 490: dopr_outch (buffer, currlen, maxlen, ' ');
! 491: --padlen;
! 492: ++cnt;
! 493: }
! 494: while (*value && (cnt < max)) {
! 495: dopr_outch (buffer, currlen, maxlen, *value++);
! 496: ++cnt;
! 497: }
! 498: while ((padlen < 0) && (cnt < max)) {
! 499: dopr_outch (buffer, currlen, maxlen, ' ');
! 500: ++padlen;
! 501: ++cnt;
! 502: }
! 503: }
! 504:
! 505: /* Have to handle DP_F_NUM (ie 0x and 0 alternates) */
! 506:
! 507: static void fmtint(char *buffer, size_t *currlen, size_t maxlen,
! 508: long value, int base, int min, int max, int flags)
! 509: {
! 510: int signvalue = 0;
! 511: unsigned long uvalue;
! 512: char convert[20];
! 513: int place = 0;
! 514: int spadlen = 0; /* amount to space pad */
! 515: int zpadlen = 0; /* amount to zero pad */
! 516: int caps = 0;
! 517:
! 518: if (max < 0)
! 519: max = 0;
! 520:
! 521: uvalue = value;
! 522:
! 523: if(!(flags & DP_F_UNSIGNED)) {
! 524: if( value < 0 ) {
! 525: signvalue = '-';
! 526: uvalue = -value;
! 527: } else {
! 528: if (flags & DP_F_PLUS) /* Do a sign (+/i) */
! 529: signvalue = '+';
! 530: else if (flags & DP_F_SPACE)
! 531: signvalue = ' ';
! 532: }
! 533: }
! 534:
! 535: if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
! 536:
! 537: do {
! 538: convert[place++] =
! 539: (caps? "0123456789ABCDEF":"0123456789abcdef")
! 540: [uvalue % (unsigned)base ];
! 541: uvalue = (uvalue / (unsigned)base );
! 542: } while(uvalue && (place < 20));
! 543: if (place == 20) place--;
! 544: convert[place] = 0;
! 545:
! 546: zpadlen = max - place;
! 547: spadlen = min - MAX (max, place) - (signvalue ? 1 : 0);
! 548: if (zpadlen < 0) zpadlen = 0;
! 549: if (spadlen < 0) spadlen = 0;
! 550: if (flags & DP_F_ZERO) {
! 551: zpadlen = MAX(zpadlen, spadlen);
! 552: spadlen = 0;
! 553: }
! 554: if (flags & DP_F_MINUS)
! 555: spadlen = -spadlen; /* Left Justifty */
! 556:
! 557: #ifdef DEBUG_SNPRINTF
! 558: printf("zpad: %d, spad: %d, min: %d, max: %d, place: %d\n",
! 559: zpadlen, spadlen, min, max, place);
! 560: #endif
! 561:
! 562: /* Spaces */
! 563: while (spadlen > 0) {
! 564: dopr_outch (buffer, currlen, maxlen, ' ');
! 565: --spadlen;
! 566: }
! 567:
! 568: /* Sign */
! 569: if (signvalue)
! 570: dopr_outch (buffer, currlen, maxlen, signvalue);
! 571:
! 572: /* Zeros */
! 573: if (zpadlen > 0) {
! 574: while (zpadlen > 0) {
! 575: dopr_outch (buffer, currlen, maxlen, '0');
! 576: --zpadlen;
! 577: }
! 578: }
! 579:
! 580: /* Digits */
! 581: while (place > 0)
! 582: dopr_outch (buffer, currlen, maxlen, convert[--place]);
! 583:
! 584: /* Left Justified spaces */
! 585: while (spadlen < 0) {
! 586: dopr_outch (buffer, currlen, maxlen, ' ');
! 587: ++spadlen;
! 588: }
! 589: }
! 590:
! 591: static LDOUBLE abs_val(LDOUBLE value)
! 592: {
! 593: LDOUBLE result = value;
! 594:
! 595: if (value < 0)
! 596: result = -value;
! 597:
! 598: return result;
! 599: }
! 600:
! 601: static LDOUBLE POW10(int exp)
! 602: {
! 603: LDOUBLE result = 1;
! 604:
! 605: while (exp) {
! 606: result *= 10;
! 607: exp--;
! 608: }
! 609:
! 610: return result;
! 611: }
! 612:
! 613: static LLONG ROUND(LDOUBLE value)
! 614: {
! 615: LLONG intpart;
! 616:
! 617: intpart = (LLONG)value;
! 618: value = value - intpart;
! 619: if (value >= 0.5) intpart++;
! 620:
! 621: return intpart;
! 622: }
! 623:
! 624: /* a replacement for modf that doesn't need the math library. Should
! 625: be portable, but slow */
! 626: static double my_modf(double x0, double *iptr)
! 627: {
! 628: int i;
! 629: long l;
! 630: double x = x0;
! 631: double f = 1.0;
! 632:
! 633: for (i=0;i<100;i++) {
! 634: l = (long)x;
! 635: if (l <= (x+1) && l >= (x-1)) {
! 636: if (i != 0) {
! 637: double i2;
! 638: double ret;
! 639:
! 640: ret = my_modf(x0-l*f, &i2);
! 641: (*iptr) = l*f + i2;
! 642: return ret;
! 643: }
! 644:
! 645: (*iptr) = l;
! 646: return x - (*iptr);
! 647: }
! 648: x *= 0.1;
! 649: f *= 10.0;
! 650: }
! 651:
! 652: /* yikes! the number is beyond what we can handle. What do we do? */
! 653: (*iptr) = 0;
! 654: return 0;
! 655: }
! 656:
! 657:
! 658: static void fmtfp (char *buffer, size_t *currlen, size_t maxlen,
! 659: LDOUBLE fvalue, int min, int max, int flags)
! 660: {
! 661: int signvalue = 0;
! 662: double ufvalue;
! 663: char iconvert[311];
! 664: char fconvert[311];
! 665: int iplace = 0;
! 666: int fplace = 0;
! 667: int padlen = 0; /* amount to pad */
! 668: int zpadlen = 0;
! 669: int caps = 0;
! 670: int idx;
! 671: double intpart;
! 672: double fracpart;
! 673: double temp;
! 674:
! 675: /*
! 676: * AIX manpage says the default is 0, but Solaris says the default
! 677: * is 6, and sprintf on AIX defaults to 6
! 678: */
! 679: if (max < 0)
! 680: max = 6;
! 681:
! 682: ufvalue = abs_val (fvalue);
! 683:
! 684: if (fvalue < 0) {
! 685: signvalue = '-';
! 686: } else {
! 687: if (flags & DP_F_PLUS) { /* Do a sign (+/i) */
! 688: signvalue = '+';
! 689: } else {
! 690: if (flags & DP_F_SPACE)
! 691: signvalue = ' ';
! 692: }
! 693: }
! 694:
! 695: #if 0
! 696: if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
! 697: #endif
! 698:
! 699: #if 0
! 700: if (max == 0) ufvalue += 0.5; /* if max = 0 we must round */
! 701: #endif
! 702:
! 703: /*
! 704: * Sorry, we only support 16 digits past the decimal because of our
! 705: * conversion method
! 706: */
! 707: if (max > 16)
! 708: max = 16;
! 709:
! 710: /* We "cheat" by converting the fractional part to integer by
! 711: * multiplying by a factor of 10
! 712: */
! 713:
! 714: temp = ufvalue;
! 715: my_modf(temp, &intpart);
! 716:
! 717: fracpart = ROUND((POW10(max)) * (ufvalue - intpart));
! 718:
! 719: if (fracpart >= POW10(max)) {
! 720: intpart++;
! 721: fracpart -= POW10(max);
! 722: }
! 723:
! 724:
! 725: /* Convert integer part */
! 726: do {
! 727: temp = intpart*0.1;
! 728: my_modf(temp, &intpart);
! 729: idx = (int) ((temp -intpart +0.05)* 10.0);
! 730: /* idx = (int) (((double)(temp*0.1) -intpart +0.05) *10.0); */
! 731: /* printf ("%llf, %f, %x\n", temp, intpart, idx); */
! 732: iconvert[iplace++] =
! 733: (caps? "0123456789ABCDEF":"0123456789abcdef")[idx];
! 734: } while (intpart && (iplace < 311));
! 735: if (iplace == 311) iplace--;
! 736: iconvert[iplace] = 0;
! 737:
! 738: /* Convert fractional part */
! 739: if (fracpart)
! 740: {
! 741: do {
! 742: temp = fracpart*0.1;
! 743: my_modf(temp, &fracpart);
! 744: idx = (int) ((temp -fracpart +0.05)* 10.0);
! 745: /* idx = (int) ((((temp/10) -fracpart) +0.05) *10); */
! 746: /* printf ("%lf, %lf, %ld\n", temp, fracpart, idx ); */
! 747: fconvert[fplace++] =
! 748: (caps? "0123456789ABCDEF":"0123456789abcdef")[idx];
! 749: } while(fracpart && (fplace < 311));
! 750: if (fplace == 311) fplace--;
! 751: }
! 752: fconvert[fplace] = 0;
! 753:
! 754: /* -1 for decimal point, another -1 if we are printing a sign */
! 755: padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0);
! 756: zpadlen = max - fplace;
! 757: if (zpadlen < 0) zpadlen = 0;
! 758: if (padlen < 0)
! 759: padlen = 0;
! 760: if (flags & DP_F_MINUS)
! 761: padlen = -padlen; /* Left Justifty */
! 762:
! 763: if ((flags & DP_F_ZERO) && (padlen > 0)) {
! 764: if (signvalue) {
! 765: dopr_outch (buffer, currlen, maxlen, signvalue);
! 766: --padlen;
! 767: signvalue = 0;
! 768: }
! 769: while (padlen > 0) {
! 770: dopr_outch (buffer, currlen, maxlen, '0');
! 771: --padlen;
! 772: }
! 773: }
! 774: while (padlen > 0) {
! 775: dopr_outch (buffer, currlen, maxlen, ' ');
! 776: --padlen;
! 777: }
! 778: if (signvalue)
! 779: dopr_outch (buffer, currlen, maxlen, signvalue);
! 780:
! 781: while (iplace > 0)
! 782: dopr_outch (buffer, currlen, maxlen, iconvert[--iplace]);
! 783:
! 784: #ifdef DEBUG_SNPRINTF
! 785: printf("fmtfp: fplace=%d zpadlen=%d\n", fplace, zpadlen);
! 786: #endif
! 787:
! 788: /*
! 789: * Decimal point. This should probably use locale to find the correct
! 790: * char to print out.
! 791: */
! 792: if (max > 0) {
! 793: dopr_outch (buffer, currlen, maxlen, '.');
! 794:
! 795: while (zpadlen > 0) {
! 796: dopr_outch (buffer, currlen, maxlen, '0');
! 797: --zpadlen;
! 798: }
! 799:
! 800: while (fplace > 0)
! 801: dopr_outch (buffer, currlen, maxlen, fconvert[--fplace]);
! 802: }
! 803:
! 804: while (padlen < 0) {
! 805: dopr_outch (buffer, currlen, maxlen, ' ');
! 806: ++padlen;
! 807: }
! 808: }
! 809:
! 810: static void dopr_outch(char *buffer, size_t *currlen, size_t maxlen, char c)
! 811: {
! 812: if (*currlen < maxlen) {
! 813: buffer[(*currlen)] = c;
! 814: }
! 815: (*currlen)++;
! 816: }
! 817:
! 818: int rsync_vsnprintf (char *str, size_t count, const char *fmt, va_list args)
! 819: {
! 820: return dopr(str, count, fmt, args);
! 821: }
! 822: #define vsnprintf rsync_vsnprintf
! 823: #endif
! 824:
! 825: /* yes this really must be a ||. Don't muck with this (tridge)
! 826: *
! 827: * The logic for these two is that we need our own definition if the
! 828: * OS *either* has no definition of *sprintf, or if it does have one
! 829: * that doesn't work properly according to the autoconf test.
! 830: */
! 831: #if !defined(HAVE_SNPRINTF) || !defined(HAVE_C99_VSNPRINTF)
! 832: int rsync_snprintf(char *str,size_t count,const char *fmt,...)
! 833: {
! 834: size_t ret;
! 835: va_list ap;
! 836:
! 837: va_start(ap, fmt);
! 838: ret = vsnprintf(str, count, fmt, ap);
! 839: va_end(ap);
! 840: return ret;
! 841: }
! 842: #define snprintf rsync_snprintf
! 843: #endif
! 844:
! 845: #endif
! 846:
! 847: #ifndef HAVE_VASPRINTF
! 848: int vasprintf(char **ptr, const char *format, va_list ap)
! 849: {
! 850: int ret;
! 851: va_list ap2;
! 852:
! 853: VA_COPY(ap2, ap);
! 854:
! 855: ret = vsnprintf(NULL, 0, format, ap2);
! 856: if (ret <= 0) return ret;
! 857:
! 858: (*ptr) = (char *)malloc(ret+1);
! 859: if (!*ptr) return -1;
! 860:
! 861: VA_COPY(ap2, ap);
! 862:
! 863: ret = vsnprintf(*ptr, ret+1, format, ap2);
! 864:
! 865: return ret;
! 866: }
! 867: #endif
! 868:
! 869:
! 870: #ifndef HAVE_ASPRINTF
! 871: int asprintf(char **ptr, const char *format, ...)
! 872: {
! 873: va_list ap;
! 874: int ret;
! 875:
! 876: *ptr = NULL;
! 877: va_start(ap, format);
! 878: ret = vasprintf(ptr, format, ap);
! 879: va_end(ap);
! 880:
! 881: return ret;
! 882: }
! 883: #endif
! 884:
! 885: #ifdef TEST_SNPRINTF
! 886:
! 887: int sprintf(char *str,const char *fmt,...);
! 888:
! 889: int main (void)
! 890: {
! 891: char buf1[1024];
! 892: char buf2[1024];
! 893: char *fp_fmt[] = {
! 894: "%1.1f",
! 895: "%-1.5f",
! 896: "%1.5f",
! 897: "%123.9f",
! 898: "%10.5f",
! 899: "% 10.5f",
! 900: "%+22.9f",
! 901: "%+4.9f",
! 902: "%01.3f",
! 903: "%4f",
! 904: "%3.1f",
! 905: "%3.2f",
! 906: "%.0f",
! 907: "%f",
! 908: "-16.16f",
! 909: NULL
! 910: };
! 911: double fp_nums[] = { 6442452944.1234, -1.5, 134.21, 91340.2, 341.1234, 203.9, 0.96, 0.996,
! 912: 0.9996, 1.996, 4.136, 5.030201, 0.00205,
! 913: /* END LIST */ 0};
! 914: char *int_fmt[] = {
! 915: "%-1.5d",
! 916: "%1.5d",
! 917: "%123.9d",
! 918: "%5.5d",
! 919: "%10.5d",
! 920: "% 10.5d",
! 921: "%+22.33d",
! 922: "%01.3d",
! 923: "%4d",
! 924: "%d",
! 925: NULL
! 926: };
! 927: long int_nums[] = { -1, 134, 91340, 341, 0203, 0};
! 928: char *str_fmt[] = {
! 929: "10.5s",
! 930: "5.10s",
! 931: "10.1s",
! 932: "0.10s",
! 933: "10.0s",
! 934: "1.10s",
! 935: "%s",
! 936: "%.1s",
! 937: "%.10s",
! 938: "%10s",
! 939: NULL
! 940: };
! 941: char *str_vals[] = {"hello", "a", "", "a longer string", NULL};
! 942: int x, y;
! 943: int fail = 0;
! 944: int num = 0;
! 945:
! 946: printf ("Testing snprintf format codes against system sprintf...\n");
! 947:
! 948: for (x = 0; fp_fmt[x] ; x++) {
! 949: for (y = 0; fp_nums[y] != 0 ; y++) {
! 950: int l1 = snprintf(NULL, 0, fp_fmt[x], fp_nums[y]);
! 951: int l2 = snprintf(buf1, sizeof(buf1), fp_fmt[x], fp_nums[y]);
! 952: sprintf (buf2, fp_fmt[x], fp_nums[y]);
! 953: if (strcmp (buf1, buf2)) {
! 954: printf("snprintf doesn't match Format: %s\n\tsnprintf = [%s]\n\t sprintf = [%s]\n",
! 955: fp_fmt[x], buf1, buf2);
! 956: fail++;
! 957: }
! 958: if (l1 != l2) {
! 959: printf("snprintf l1 != l2 (%d %d) %s\n", l1, l2, fp_fmt[x]);
! 960: fail++;
! 961: }
! 962: num++;
! 963: }
! 964: }
! 965:
! 966: for (x = 0; int_fmt[x] ; x++) {
! 967: for (y = 0; int_nums[y] != 0 ; y++) {
! 968: int l1 = snprintf(NULL, 0, int_fmt[x], int_nums[y]);
! 969: int l2 = snprintf(buf1, sizeof(buf1), int_fmt[x], int_nums[y]);
! 970: sprintf (buf2, int_fmt[x], int_nums[y]);
! 971: if (strcmp (buf1, buf2)) {
! 972: printf("snprintf doesn't match Format: %s\n\tsnprintf = [%s]\n\t sprintf = [%s]\n",
! 973: int_fmt[x], buf1, buf2);
! 974: fail++;
! 975: }
! 976: if (l1 != l2) {
! 977: printf("snprintf l1 != l2 (%d %d) %s\n", l1, l2, int_fmt[x]);
! 978: fail++;
! 979: }
! 980: num++;
! 981: }
! 982: }
! 983:
! 984: for (x = 0; str_fmt[x] ; x++) {
! 985: for (y = 0; str_vals[y] != 0 ; y++) {
! 986: int l1 = snprintf(NULL, 0, str_fmt[x], str_vals[y]);
! 987: int l2 = snprintf(buf1, sizeof(buf1), str_fmt[x], str_vals[y]);
! 988: sprintf (buf2, str_fmt[x], str_vals[y]);
! 989: if (strcmp (buf1, buf2)) {
! 990: printf("snprintf doesn't match Format: %s\n\tsnprintf = [%s]\n\t sprintf = [%s]\n",
! 991: str_fmt[x], buf1, buf2);
! 992: fail++;
! 993: }
! 994: if (l1 != l2) {
! 995: printf("snprintf l1 != l2 (%d %d) %s\n", l1, l2, str_fmt[x]);
! 996: fail++;
! 997: }
! 998: num++;
! 999: }
! 1000: }
! 1001:
! 1002: printf ("%d tests failed out of %d.\n", fail, num);
! 1003:
! 1004: printf("seeing how many digits we support\n");
! 1005: {
! 1006: double v0 = 0.12345678901234567890123456789012345678901;
! 1007: for (x=0; x<100; x++) {
! 1008: double p = pow(10, x);
! 1009: double r = v0*p;
! 1010: snprintf(buf1, sizeof(buf1), "%1.1f", r);
! 1011: sprintf(buf2, "%1.1f", r);
! 1012: if (strcmp(buf1, buf2)) {
! 1013: printf("we seem to support %d digits\n", x-1);
! 1014: break;
! 1015: }
! 1016: }
! 1017: }
! 1018:
! 1019: return 0;
! 1020: }
! 1021: #endif /* TEST_SNPRINTF */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to snprintf.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / rsync / lib