snprintf.c

   1 /*
   2  * $Id$
   3  */
   4
   5 /*
   6    Unix snprintf implementation.
   7    Version 1.2
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13    It can be redistribute also under the terms of GNU Library General
  14    Public License.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program; if not, write to the Free Software
  23    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24
  25    Revision History:
  26
  27    1.2:
  28       * put the program under LGPL.
  29    1.1:
  30       *  added changes from Miles Bader
  31       *  corrected a bug with %f
  32       *  added support for %#g
  33       *  added more comments :-)
  34    1.0:
  35       *  supporting must ANSI syntaxic_sugars
  36    0.0:
  37       *  suppot %s %c %d
  38
  39  THANKS(for the patches and ideas):
  40      Miles Bader
  41      Cyrille Rustom
  42      Jacek Slabocewiz
  43      Mike Parker(mouse)
  44
  45 */
  46 #ifdef HAVE_CONFIG_H
  47 # include "config.h"
  48 #endif
  49
  50 #include <stdlib.h>     /* for atoi and for size_t */
  51 #include <string.h>
  52 #include <ctype.h>
  53
  54 #include "snprintf.h"
  55 #include "snprintf-imp.h"
  56
  57 /*
  58  * Find the nth power of 10
  59  */
  60 PRIVATE double
  61 pow_10(int n)
  62 {
  63   int i;
  64   double P;
  65
  66   if (n < 0)
  67     for (i = 1, P = 1., n = -n ; i <= n ; i++) {P *= .1;}
  68   else
  69     for (i = 1, P = 1. ; i <= n ; i++) {P *= 10.0;}
  70   return P;
  71 }
  72
  73 /*
  74  * Find the integral part of the log in base 10
  75  * Note: this not a real log10()
  76          I just need and approximation(integerpart) of x in:
  77           10^x ~= r
  78  * log_10(200) = 2;
  79  * log_10(250) = 2;
  80  */
  81 PRIVATE int
  82 log_10(double r)
  83 {
  84   int i = 0;
  85   double result = 1.;
  86
  87   if (r < 0.)
  88     r = -r;
  89
  90   if (r == 0.0)
  91      return(0);
  92   if (r < 1.) {
  93     while (result >= r) {result *= .1; i++;}
  94     return (-i);
  95   } else {
  96     while (result <= r) {result *= 10.; i++;}
  97     return (i - 1);
  98   }
  99 }
 100
 101 /*
 102  * This function return the fraction part of a double
 103  * and set in ip the integral part.
 104  * In many ways it resemble the modf() found on most Un*x
 105  */
 106 PRIVATE double
 107 integral(double real, double * ip)
 108 {
 109   int j;
 110   double i, s, p;
 111   double real_integral = 0.;
 112
 113 /* take care of the obvious */
 114 /* equal to zero ? */
 115   if (real == 0.) {
 116     *ip = 0.;
 117     return (0.);
 118   }
 119
 120 /* negative number ? */
 121   if (real < 0.)
 122     real = -real;
 123
 124 /* a fraction ? */
 125   if ( real < 1.) {
 126     *ip = 0.;
 127     return real;
 128   }
 129 /* the real work :-) */
 130   for (j = log_10(real); j >= 0; j--) {
 131     p = pow_10(j);
 132     s = (real - real_integral)/p;
 133     i = 0.;
 134     while (i + 1. <= s) {i++;}
 135     real_integral += i*p;
 136   }
 137   *ip = real_integral;
 138   return (real - real_integral);
 139 }
 140
 141 #define PRECISION 1.e-6
 142 /*
 143  * return an ascii representation of the integral part of the number
 144  * and set fract to be an ascii representation of the fraction part
 145  * the container for the fraction and the integral part or staticly
 146  * declare with fix size
 147  */
 148 PRIVATE char *
 149 numtoa(double number, int base, int precision, char ** fract)
 150 {
 151   register int i, j;
 152   double ip, fp; /* integer and fraction part */
 153   double fraction;
 154   int digits = MAX_INT - 1;
 155   static char integral_part[MAX_INT];
 156   static char fraction_part[MAX_FRACT];
 157   double sign;
 158   int ch;
 159
 160 /* taking care of the obvious case: 0.0 */
 161   if (number == 0.) {
 162     integral_part[0] = '0';
 163     integral_part[1] = '\0';
 164     fraction_part[0] = '0';
 165     fraction_part[1] = '\0';
 166     return integral_part;
 167   }
 168
 169 /* for negative numbers */
 170   if ((sign = number) < 0.) {
 171     number = -number;
 172     digits--; /* sign consume one digit */
 173   }
 174
 175   fraction = integral(number, &ip);
 176   number = ip;
 177 /* do the integral part */
 178   if ( ip == 0.) {
 179     integral_part[0] = '0';
 180     i = 1;
 181   } else {
 182     for ( i = 0; i < digits && number != 0.; ++i) {
 183       number /= base;
 184       fp = integral(number, &ip);
 185       ch = (int)((fp + PRECISION)*base); /* force to round */
 186       integral_part[i] = (ch <= 9) ? ch + '0' : ch + 'a' - 10;
 187       if (! isxdigit((unsigned char)integral_part[i])) /* bail out overflow !! */
 188         break;
 189       number = ip;
 190      }
 191   }
 192
 193 /* Oh No !! out of bound, ho well fill it up ! */
 194   if (number != 0.)
 195     for (i = 0; i < digits; ++i)
 196       integral_part[i] = '9';
 197
 198 /* put the sign ? */
 199   if (sign < 0.)
 200     integral_part[i++] = '-';
 201
 202   integral_part[i] = '\0';
 203
 204 /* reverse every thing */
 205   for ( i--, j = 0; j < i; j++, i--)
 206     SWAP_INT(integral_part[i], integral_part[j]);
 207
 208 /* the fractionnal part */
 209   for (i=0, fp=fraction; precision > 0 && i < MAX_FRACT ; i++, precision--      ) {
 210     fraction_part[i] = (int)((fp + PRECISION)*10. + '0');
 211     if (! isdigit((unsigned char)fraction_part[i])) /* underflow ? */
 212       break;
 213     fp = (fp*10.0) - (double)(long)((fp + PRECISION)*10.);
 214   }
 215   fraction_part[i] = '\0';
 216
 217   if (fract != (char **)0)
 218     *fract = fraction_part;
 219
 220   return integral_part;
 221
 222 }
 223
 224 /* for %d and friends, it puts in holder
 225  * the representation with the right padding
 226  */
 227 PRIVATE void
 228 decimal(struct DATA *p, double d)
 229 {
 230   char *tmp;
 231
 232   tmp = itoa(d);
 233   p->width -= strlen(tmp);
 234   PAD_RIGHT(p);
 235   PUT_PLUS(d, p);
 236   PUT_SPACE(d, p);
 237   while (*tmp) { /* the integral */
 238     PUT_CHAR(*tmp, p);
 239     tmp++;
 240   }
 241   PAD_LEFT(p);
 242 }
 243
 244 /* for %o octal representation */
 245 PRIVATE void
 246 octal(struct DATA *p, double d)
 247 {
 248   char *tmp;
 249
 250   tmp = otoa(d);
 251   p->width -= strlen(tmp);
 252   if (p->square == FOUND) /* had prefix '0' for octal */
 253     PUT_CHAR('0', p);
 254   PAD_RIGHT(p);
 255   while (*tmp) { /* octal */
 256     PUT_CHAR(*tmp, p);
 257     tmp++;
 258   }
 259   PAD_LEFT(p);
 260 }
 261
 262 /* for %x %X hexadecimal representation */
 263 PRIVATE void
 264 hexa(struct DATA *p, double d)
 265 {
 266   char *tmp;
 267
 268   tmp = htoa(d);
 269   p->width -= strlen(tmp);
 270   if (p->square == FOUND) { /* prefix '0x' for hexa */
 271     PUT_CHAR('0', p); PUT_CHAR(*p->pf, p);
 272   }
 273   PAD_RIGHT(p);
 274   while (*tmp) { /* hexa */
 275     PUT_CHAR((*p->pf == 'X' ? toupper(*tmp) : *tmp), p);
 276     tmp++;
 277   }
 278   PAD_LEFT(p);
 279 }
 280
 281 /* %s strings */
 282 PRIVATE void
 283 strings(struct DATA *p, char *tmp)
 284 {
 285   int i;
 286
 287   i = strlen(tmp);
 288   if (p->precision != NOT_FOUND) /* the smallest number */
 289     i = (i < p->precision ? i : p->precision);
 290   p->width -= i;
 291   PAD_RIGHT(p);
 292   while (i-- > 0) { /* put the sting */
 293     PUT_CHAR(*tmp, p);
 294     tmp++;
 295   }
 296   PAD_LEFT(p);
 297 }
 298
 299 /* %f or %g  floating point representation */
 300 PRIVATE void
 301 floating(struct DATA *p, double d)
 302 {
 303   char *tmp, *tmp2;
 304   int i;
 305
 306   DEF_PREC(p);
 307   d = ROUND(d, p);
 308   tmp = dtoa(d, p->precision, &tmp2);
 309   /* calculate the padding. 1 for the dot */
 310   p->width = p->width -
 311             ((d > 0. && p->justify == RIGHT) ? 1:0) -
 312             ((p->space == FOUND) ? 1:0) -
 313             strlen(tmp) - p->precision - 1;
 314   PAD_RIGHT(p);
 315   PUT_PLUS(d, p);
 316   PUT_SPACE(d, p);
 317   while (*tmp) { /* the integral */
 318     PUT_CHAR(*tmp, p);
 319     tmp++;
 320   }
 321   if (p->precision != 0 || p->square == FOUND)
 322     PUT_CHAR('.', p);  /* put the '.' */
 323   if (*p->pf == 'g' || *p->pf == 'G') /* smash the trailing zeros */
 324     for (i = strlen(tmp2) - 1; i >= 0 && tmp2[i] == '0'; i--)
 325        tmp2[i] = '\0';
 326   for (; *tmp2; tmp2++)
 327     PUT_CHAR(*tmp2, p); /* the fraction */
 328
 329   PAD_LEFT(p);
 330 }
 331
 332 /* %e %E %g exponent representation */
 333 PRIVATE void
 334 exponent(struct DATA *p, double d)
 335 {
 336   char *tmp, *tmp2;
 337   int j, i;
 338
 339   DEF_PREC(p);
 340   j = log_10(d);
 341   d = d / pow_10(j);  /* get the Mantissa */
 342   d = ROUND(d, p);
 343   tmp = dtoa(d, p->precision, &tmp2);
 344   /* 1 for unit, 1 for the '.', 1 for 'e|E',
 345    * 1 for '+|-', 3 for 'exp' */
 346   /* calculate how much padding need */
 347   p->width = p->width -
 348              ((d > 0. && p->justify == RIGHT) ? 1:0) -
 349              ((p->space == FOUND) ? 1:0) - p->precision - 7;
 350   PAD_RIGHT(p);
 351   PUT_PLUS(d, p);
 352   PUT_SPACE(d, p);
 353   while (*tmp) {/* the integral */
 354     PUT_CHAR(*tmp, p);
 355     tmp++;
 356   }
 357   if (p->precision != 0 || p->square == FOUND)
 358     PUT_CHAR('.', p);  /* the '.' */
 359   if (*p->pf == 'g' || *p->pf == 'G') /* smash the trailing zeros */
 360     for (i = strlen(tmp2) - 1; i >= 0 && tmp2[i] == '0'; i--)
 361        tmp2[i] = '\0';
 362   for (; *tmp2; tmp2++)
 363     PUT_CHAR(*tmp2, p); /* the fraction */
 364
 365   if (*p->pf == 'g' || *p->pf == 'e') { /* the exponent put the 'e|E' */
 366      PUT_CHAR('e', p);
 367    } else
 368      PUT_CHAR('E', p);
 369    if (j > 0) {  /* the sign of the exp */
 370      PUT_CHAR('+', p);
 371    } else {
 372      PUT_CHAR('-', p);
 373      j = -j;
 374    }
 375    tmp = itoa((double)j);
 376    if (j < 9) {  /* need to pad the exponent with 0 '000' */
 377      PUT_CHAR('0', p); PUT_CHAR('0', p);
 378    } else if (j < 99)
 379      PUT_CHAR('0', p);
 380    while (*tmp) { /* the exponent */
 381      PUT_CHAR(*tmp, p);
 382      tmp++;
 383    }
 384    PAD_LEFT(p);
 385 }
 386
 387 /* initialize the conversion specifiers */
 388 PRIVATE void
 389 conv_flag(char * s, struct DATA * p)
 390 {
 391   char number[MAX_FIELD/2];
 392   int i;
 393
 394   p->precision = p->width = NOT_FOUND;
 395   p->star_w = p->star_p = NOT_FOUND;
 396   p->square = p->space = NOT_FOUND;
 397   p->a_long = p->justify = NOT_FOUND;
 398   p->pad = ' ';
 399
 400   for(;s && *s ;s++) {
 401     switch(*s) {
 402       case ' ': p->space = FOUND; break;
 403       case '#': p->square = FOUND; break;
 404       case '*': if (p->width == NOT_FOUND)
 405                   p->width = p->star_w = FOUND;
 406                 else
 407                   p->precision = p->star_p = FOUND;
 408                 break;
 409       case '+': p->justify = RIGHT; break;
 410       case '-': p->justify = LEFT; break;
 411       case '.': if (p->width == NOT_FOUND)
 412                   p->width = 0;
 413                 break;
 414       case '0': p->pad = '0'; break;
 415       case '1': case '2': case '3':
 416       case '4': case '5': case '6':
 417       case '7': case '8': case '9':     /* gob all the digits */
 418         for (i = 0; isdigit((unsigned char)*s); i++, s++)
 419           if (i < MAX_FIELD/2 - 1)
 420             number[i] = *s;
 421         number[i] = '\0';
 422         if (p->width == NOT_FOUND)
 423           p->width = atoi(number);
 424         else
 425           p->precision = atoi(number);
 426         s--;   /* went to far go back */
 427         break;
 428     }
 429   }
 430 }
 431
 432 PUBLIC int
 433 vsnprintf(char *string, size_t length, const char * format, va_list args)
 434 {
 435   struct DATA data;
 436   char conv_field[MAX_FIELD];
 437   double d; /* temporary holder */
 438   int state;
 439   int i;
 440
 441   data.length = length - 1; /* leave room for '\0' */
 442   data.holder = string;
 443   data.pf = format;
 444   data.counter = 0;
 445
 446
 447 /* sanity check, the string must be > 1 */
 448   if (length < 1)
 449     return -1;
 450
 451
 452   for (; *data.pf && (data.counter < data.length); data.pf++) {
 453     if ( *data.pf == '%' ) { /* we got a magic % cookie */
 454       conv_flag((char *)0, &data); /* initialise format flags */
 455       for (state = 1; *data.pf && state;) {
 456         switch (*(++data.pf)) {
 457           case '\0': /* a NULL here ? ? bail out */
 458             *data.holder = '\0';
 459             return data.counter;
 460             break;
 461           case 'f':  /* float, double */
 462             STAR_ARGS(&data);
 463             d = va_arg(args, double);
 464             floating(&data, d);
 465             state = 0;
 466             break;
 467           case 'g':
 468           case 'G':
 469             STAR_ARGS(&data);
 470             DEF_PREC(&data);
 471             d = va_arg(args, double);
 472             i = log_10(d);
 473             /*
 474              * for '%g|%G' ANSI: use f if exponent
 475              * is in the range or [-4,p] exclusively
 476              * else use %e|%E
 477              */
 478             if (-4 < i && i < data.precision)
 479               floating(&data, d);
 480             else
 481               exponent(&data, d);
 482             state = 0;
 483             break;
 484           case 'e':
 485           case 'E':  /* Exponent double */
 486             STAR_ARGS(&data);
 487             d = va_arg(args, double);
 488             exponent(&data, d);
 489             state = 0;
 490             break;
 491           case 'u':  /* unsigned decimal */
 492             STAR_ARGS(&data);
 493             if (data.a_long == FOUND)
 494               d = va_arg(args, unsigned long);
 495             else
 496               d = va_arg(args, unsigned int);
 497             decimal(&data, d);
 498             state = 0;
 499             break;
 500           case 'd':  /* decimal */
 501           case 'i':  /* "integer" (signed decimal) */
 502             STAR_ARGS(&data);
 503             if (data.a_long == FOUND)
 504               d = va_arg(args, long);
 505             else
 506               d = va_arg(args, int);
 507             decimal(&data, d);
 508             state = 0;
 509             break;
 510           case 'o':  /* octal */
 511             STAR_ARGS(&data);
 512             if (data.a_long == FOUND)
 513               d = va_arg(args, unsigned long);
 514             else
 515               d = va_arg(args, unsigned int);
 516             octal(&data, d);
 517             state = 0;
 518             break;
 519           case 'x':
 520           case 'X':  /* hexadecimal */
 521             STAR_ARGS(&data);
 522             if (data.a_long == FOUND)
 523               d = va_arg(args, unsigned long);
 524             else
 525               d = va_arg(args, unsigned int);
 526             hexa(&data, d);
 527             state = 0;
 528             break;
 529           case 'c': /* character */
 530             d = va_arg(args, int);
 531             PUT_CHAR(d, &data);
 532             state = 0;
 533             break;
 534           case 's':  /* string */
 535             STAR_ARGS(&data);
 536             strings(&data, va_arg(args, char *));
 537             state = 0;
 538             break;
 539           case 'n':
 540              *(va_arg(args, int *)) = data.counter; /* what's the count ? */
 541              state = 0;
 542              break;
 543           case 'l':
 544             data.a_long = FOUND;
 545             break;
 546           case 'h':
 547             break;
 548           case '%':  /* nothing just % */
 549             PUT_CHAR('%', &data);
 550             state = 0;
 551             break;
 552           case '#': case ' ': case '+': case '*':
 553           case '-': case '.': case '0': case '1':
 554           case '2': case '3': case '4': case '5':
 555           case '6': case '7': case '8': case '9':
 556            /* initialize width and precision */
 557             for (i = 0; isflag((unsigned char)*data.pf); i++, data.pf++)
 558               if (i < MAX_FIELD - 1)
 559                 conv_field[i] = *data.pf;
 560             conv_field[i] = '\0';
 561             conv_flag(conv_field, &data);
 562             data.pf--;   /* went to far go back */
 563             break;
 564           default:
 565             /* is this an error ? maybe bail out */
 566             state = 0;
 567             break;
 568         } /* end switch */
 569       } /* end of for state */
 570     } else { /* not % */
 571       PUT_CHAR(*data.pf, &data);  /* add the char the string */
 572     }
 573   }
 574
 575   *data.holder = '\0'; /* the end ye ! */
 576
 577   return data.counter;
 578 }
 579
 580 #ifndef HAVE_SNPRINTF
 581
 582 PUBLIC int
 583 snprintf(char *string, size_t length, const char * format, ...)
 584 {
 585   int rval;
 586   va_list args;
 587
 588 #if defined(HAVE_STDARG_H)
 589   va_start(args, format);
 590 #else
 591   va_start(args);
 592 #endif
 593
 594   rval = vsnprintf (string, length, format, args);
 595
 596   va_end(args);
 597
 598   return rval;
 599 }
 600
 601 #endif /* HAVE_SNPRINTF */
 602
 603
 604 #ifdef DRIVER
 605
 606 #include <stdio.h>
 607
 608 /* set of small tests for snprintf() */
 609 void main()
 610 {
 611   char holder[100];
 612   int i;
 613
 614 /*
 615   printf("Suite of test for snprintf:\n");
 616   printf("a_format\n");
 617   printf("printf() format\n");
 618   printf("snprintf() format\n\n");
 619 */
 620 /* Checking the field widths */
 621
 622   printf("/%%d/, 336\n");
 623   snprintf(holder, sizeof holder, "/%d/\n", 336);
 624   printf("/%d/\n", 336);
 625   printf("%s\n", holder);
 626
 627   printf("/%%2d/, 336\n");
 628   snprintf(holder, sizeof holder, "/%2d/\n", 336);
 629   printf("/%2d/\n", 336);
 630   printf("%s\n", holder);
 631
 632   printf("/%%10d/, 336\n");
 633   snprintf(holder, sizeof holder, "/%10d/\n", 336);
 634   printf("/%10d/\n", 336);
 635   printf("%s\n", holder);
 636
 637   printf("/%%-10d/, 336\n");
 638   snprintf(holder, sizeof holder, "/%-10d/\n", 336);
 639   printf("/%-10d/\n", 336);
 640   printf("%s\n", holder);
 641
 642
 643 /* floating points */
 644
 645   printf("/%%f/, 1234.56\n");
 646   snprintf(holder, sizeof holder, "/%f/\n", 1234.56);
 647   printf("/%f/\n", 1234.56);
 648   printf("%s\n", holder);
 649
 650   printf("/%%e/, 1234.56\n");
 651   snprintf(holder, sizeof holder, "/%e/\n", 1234.56);
 652   printf("/%e/\n", 1234.56);
 653   printf("%s\n", holder);
 654
 655   printf("/%%4.2f/, 1234.56\n");
 656   snprintf(holder, sizeof holder, "/%4.2f/\n", 1234.56);
 657   printf("/%4.2f/\n", 1234.56);
 658   printf("%s\n", holder);
 659
 660   printf("/%%3.1f/, 1234.56\n");
 661   snprintf(holder, sizeof holder, "/%3.1f/\n", 1234.56);
 662   printf("/%3.1f/\n", 1234.56);
 663   printf("%s\n", holder);
 664
 665   printf("/%%10.3f/, 1234.56\n");
 666   snprintf(holder, sizeof holder, "/%10.3f/\n", 1234.56);
 667   printf("/%10.3f/\n", 1234.56);
 668   printf("%s\n", holder);
 669
 670   printf("/%%10.3e/, 1234.56\n");
 671   snprintf(holder, sizeof holder, "/%10.3e/\n", 1234.56);
 672   printf("/%10.3e/\n", 1234.56);
 673   printf("%s\n", holder);
 674
 675   printf("/%%+4.2f/, 1234.56\n");
 676   snprintf(holder, sizeof holder, "/%+4.2f/\n", 1234.56);
 677   printf("/%+4.2f/\n", 1234.56);
 678   printf("%s\n", holder);
 679
 680   printf("/%%010.2f/, 1234.56\n");
 681   snprintf(holder, sizeof holder, "/%010.2f/\n", 1234.56);
 682   printf("/%010.2f/\n", 1234.56);
 683   printf("%s\n", holder);
 684
 685 #define BLURB "Outstanding acting !"
 686 /* strings precisions */
 687
 688   printf("/%%2s/, \"%s\"\n", BLURB);
 689   snprintf(holder, sizeof holder, "/%2s/\n", BLURB);
 690   printf("/%2s/\n", BLURB);
 691   printf("%s\n", holder);
 692
 693   printf("/%%22s/ %s\n", BLURB);
 694   snprintf(holder, sizeof holder, "/%22s/\n", BLURB);
 695   printf("/%22s/\n", BLURB);
 696   printf("%s\n", holder);
 697
 698   printf("/%%22.5s/ %s\n", BLURB);
 699   snprintf(holder, sizeof holder, "/%22.5s/\n", BLURB);
 700   printf("/%22.5s/\n", BLURB);
 701   printf("%s\n", holder);
 702
 703   printf("/%%-22.5s/ %s\n", BLURB);
 704   snprintf(holder, sizeof holder, "/%-22.5s/\n", BLURB);
 705   printf("/%-22.5s/\n", BLURB);
 706   printf("%s\n", holder);
 707
 708 /* see some flags */
 709
 710   printf("%%x %%X %%#x, 31, 31, 31\n");
 711   snprintf(holder, sizeof holder, "%x %X %#x\n", 31, 31, 31);
 712   printf("%x %X %#x\n", 31, 31, 31);
 713   printf("%s\n", holder);
 714
 715   printf("**%%d**%% d**%% d**, 42, 42, -42\n");
 716   snprintf(holder, sizeof holder, "**%d**% d**% d**\n", 42, 42, -42);
 717   printf("**%d**% d**% d**\n", 42, 42, -42);
 718   printf("%s\n", holder);
 719
 720 /* other flags */
 721
 722   printf("/%%g/, 31.4\n");
 723   snprintf(holder, sizeof holder, "/%g/\n", 31.4);
 724   printf("/%g/\n", 31.4);
 725   printf("%s\n", holder);
 726
 727   printf("/%%.6g/, 31.4\n");
 728   snprintf(holder, sizeof holder, "/%.6g/\n", 31.4);
 729   printf("/%.6g/\n", 31.4);
 730   printf("%s\n", holder);
 731
 732   printf("/%%.1G/, 31.4\n");
 733   snprintf(holder, sizeof holder, "/%.1G/\n", 31.4);
 734   printf("/%.1G/\n", 31.4);
 735   printf("%s\n", holder);
 736
 737   printf("abc%%n\n");
 738   printf("abc%n", &i); printf("%d\n", i);
 739   snprintf(holder, sizeof holder, "abc%n", &i);
 740   printf("%s", holder); printf("%d\n\n", i);
 741
 742   printf("%%*.*s --> 10.10\n");
 743   snprintf(holder, sizeof holder, "%*.*s\n", 10, 10, BLURB);
 744   printf("%*.*s\n", 10, 10, BLURB);
 745   printf("%s\n", holder);
 746
 747   printf("%%%%%%%%\n");
 748   snprintf(holder, sizeof holder, "%%%%\n");
 749   printf("%%%%\n");
 750   printf("%s\n", holder);
 751
 752 #define BIG "Hello this is a too big string for the buffer"
 753 /*  printf("A buffer to small of 10, trying to put this:\n");*/
 754   printf("<%%>, %s\n", BIG);
 755   i = snprintf(holder, 10, "%s\n", BIG);
 756   printf("<%s>\n", BIG);
 757   printf("<%s>\n", holder);
 758 }
 759 #endif