Main Page   Alphabetical List   Data Structures   File List   Data Fields   Globals   Related Pages  

snprintf.c File Reference

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)


Function Documentation

void dummy_snprintf void   
 

Definition at line 82 of file snprintf.c.

00082 {} 

size_t dopr char *    buffer,
size_t    maxlen,
const char *    format,
va_list    args
[static]
 

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 }

void fmtstr char *    buffer,
size_t *    currlen,
size_t    maxlen,
char *    value,
int    flags,
int    min,
int    max
[static]
 

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 }

void fmtint char *    buffer,
size_t *    currlen,
size_t    maxlen,
long    value,
int    base,
int    min,
int    max,
int    flags
[static]
 

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 }

void fmtfp char *    buffer,
size_t *    currlen,
size_t    maxlen,
LDOUBLE    fvalue,
int    min,
int    max,
int    flags
[static]
 

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 }

void dopr_outch char *    buffer,
size_t *    currlen,
size_t    maxlen,
char    c
[static]
 

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 }

LDOUBLE abs_val LDOUBLE    value [static]
 

Definition at line 520 of file snprintf.c.

References value.

Referenced by fmtfp().

00521 {
00522         LDOUBLE result = value;
00523 
00524         if (value < 0)
00525                 result = -value;
00526         
00527         return result;
00528 }

LDOUBLE POW10 int    exp [static]
 

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 }

LLONG ROUND LDOUBLE    value [static]
 

Definition at line 542 of file snprintf.c.

References value.

Referenced by fmtfp().

00543 {
00544         LLONG intpart;
00545 
00546         intpart = (LLONG)value;
00547         value = value - intpart;
00548         if (value >= 0.5) intpart++;
00549         
00550         return intpart;
00551 }

double my_modf double    x0,
double *    iptr
[static]
 

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 }

int vsnprintf char *    str,
size_t    count,
const char *    fmt,
va_list    args
 

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 }

int snprintf char *    str,
size_t    count,
const char *    fmt,
...   
 

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 }

int vasprintf char **    ptr,
const char *    format,
va_list    ap
 

Definition at line 774 of file snprintf.c.

References vsnprintf().

Referenced by asprintf().

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 }

int asprintf char **    ptr,
const char *    format,
...   
 

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 }

int sprintf char *    str,
const char *    fmt,
...   
 

Referenced by inet_ntop4(), inet_ntop6(), list_file(), main(), robust_unlink(), and rsync_panic_handler().

int main void   
 

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 }


Generated on Tue Apr 16 12:37:39 2002 for rsync by doxygen1.2.15