Home | History | Annotate | Line # | Download | only in compat 
      1 /*
      2  * Copyright (c) 1995-2001 Kungliga Tekniska Hgskolan
      3  * (Royal Institute of Technology, Stockholm, Sweden).
      4  * All rights reserved.
      5  *
      6  * Redistribution and use in source and binary forms, with or without
      7  * modification, are permitted provided that the following conditions
      8  * are met:
      9  *
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  *
     13  * 2. Redistributions in binary form must reproduce the above copyright
     14  *    notice, this list of conditions and the following disclaimer in the
     15  *    documentation and/or other materials provided with the distribution.
     16  *
     17  * 3. Neither the name of the Institute nor the names of its contributors
     18  *    may be used to endorse or promote products derived from this software
     19  *    without specific prior written permission.
     20  *
     21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
     22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
     25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     31  * SUCH DAMAGE.
     32  */
     33 
     34 /* From heimdal lib/roken/snprintf.c. */
     35 
     36 #if HAVE_NBTOOL_CONFIG_H
     37 #include "nbtool_config.h"
     38 #endif
     39 
     40 #if 0
     41 RCSID("$Id: snprintf.c,v 1.3 2003/10/27 00:12:43 lukem Exp $");
     42 #endif
     43 #include <stdio.h>
     44 #include <stdarg.h>
     45 #include <stdlib.h>
     46 #include <string.h>
     47 #include <ctype.h>
     48 #if 0
     49 #include <roken.h>
     50 #endif
     51 
     52 #undef min
     53 #define min(a,b) ((a) < (b) ? (a) : (b))
     54 #undef max
     55 #define max(a,b) ((a) > (b) ? (a) : (b))
     56 
     57 enum format_flags {
     58     minus_flag     =  1,
     59     plus_flag      =  2,
     60     space_flag     =  4,
     61     alternate_flag =  8,
     62     zero_flag      = 16
     63 };
     64 
     65 /*
     66  * Common state
     67  */
     68 
     69 struct state {
     70   unsigned char *str;
     71   unsigned char *s;
     72   unsigned char *theend;
     73   size_t sz;
     74   size_t max_sz;
     75   void (*append_char)(struct state *, unsigned char);
     76   /* XXX - methods */
     77 };
     78 
     79 #if TEST_SNPRINTF
     80 #include "snprintf-test.h"
     81 #endif /* TEST_SNPRINTF */
     82 
     83 #if !defined(HAVE_VSNPRINTF) || defined(TEST_SNPRINTF)
     84 static int
     85 sn_reserve (struct state *state, size_t n)
     86 {
     87   return state->s + n > state->theend;
     88 }
     89 
     90 static void
     91 sn_append_char (struct state *state, unsigned char c)
     92 {
     93   if (!sn_reserve (state, 1))
     94     *state->s++ = c;
     95 }
     96 #endif
     97 
     98 static int
     99 as_reserve (struct state *state, size_t n)
    100 {
    101   if (state->s + n > state->theend) {
    102     int off = state->s - state->str;
    103     unsigned char *tmp;
    104 
    105     if (state->max_sz && state->sz >= state->max_sz)
    106       return 1;
    107 
    108     state->sz = max(state->sz * 2, state->sz + n);
    109     if (state->max_sz)
    110       state->sz = min(state->sz, state->max_sz);
    111     tmp = realloc (state->str, state->sz);
    112     if (tmp == NULL)
    113       return 1;
    114     state->str = tmp;
    115     state->s = state->str + off;
    116     state->theend = state->str + state->sz - 1;
    117   }
    118   return 0;
    119 }
    120 
    121 static void
    122 as_append_char (struct state *state, unsigned char c)
    123 {
    124   if(!as_reserve (state, 1))
    125     *state->s++ = c;
    126 }
    127 
    128 /* longest integer types */
    129 
    130 #ifdef HAVE_LONG_LONG
    131 typedef unsigned long long u_longest;
    132 typedef long long longest;
    133 #else
    134 typedef unsigned long u_longest;
    135 typedef long longest;
    136 #endif
    137 
    138 /*
    139  * is # supposed to do anything?
    140  */
    141 
    142 static int
    143 use_alternative (int flags, u_longest num, unsigned base)
    144 {
    145   return flags & alternate_flag && (base == 16 || base == 8) && num != 0;
    146 }
    147 
    148 static int
    149 append_number(struct state *state,
    150 	      u_longest num, unsigned base, char *rep,
    151 	      int width, int prec, int flags, int minusp)
    152 {
    153   int len = 0;
    154   int i;
    155   u_longest n = num;
    156 
    157   /* given precision, ignore zero flag */
    158   if(prec != -1)
    159     flags &= ~zero_flag;
    160   else
    161     prec = 1;
    162   /* zero value with zero precision -> "" */
    163   if(prec == 0 && n == 0)
    164     return 0;
    165   do{
    166     (*state->append_char)(state, rep[n % base]);
    167     ++len;
    168     n /= base;
    169   } while(n);
    170   prec -= len;
    171   /* pad with prec zeros */
    172   while(prec-- > 0){
    173     (*state->append_char)(state, '0');
    174     ++len;
    175   }
    176   /* add length of alternate prefix (added later) to len */
    177   if(use_alternative(flags, num, base))
    178     len += base / 8;
    179   /* pad with zeros */
    180   if(flags & zero_flag){
    181     width -= len;
    182     if(minusp || (flags & space_flag) || (flags & plus_flag))
    183       width--;
    184     while(width-- > 0){
    185       (*state->append_char)(state, '0');
    186       len++;
    187     }
    188   }
    189   /* add alternate prefix */
    190   if(use_alternative(flags, num, base)){
    191     if(base == 16)
    192       (*state->append_char)(state, rep[10] + 23); /* XXX */
    193     (*state->append_char)(state, '0');
    194   }
    195   /* add sign */
    196   if(minusp){
    197     (*state->append_char)(state, '-');
    198     ++len;
    199   } else if(flags & plus_flag) {
    200     (*state->append_char)(state, '+');
    201     ++len;
    202   } else if(flags & space_flag) {
    203     (*state->append_char)(state, ' ');
    204     ++len;
    205   }
    206   if(flags & minus_flag)
    207     /* swap before padding with spaces */
    208     for(i = 0; i < len / 2; i++){
    209       char c = state->s[-i-1];
    210       state->s[-i-1] = state->s[-len+i];
    211       state->s[-len+i] = c;
    212     }
    213   width -= len;
    214   while(width-- > 0){
    215     (*state->append_char)(state,  ' ');
    216     ++len;
    217   }
    218   if(!(flags & minus_flag))
    219     /* swap after padding with spaces */
    220     for(i = 0; i < len / 2; i++){
    221       char c = state->s[-i-1];
    222       state->s[-i-1] = state->s[-len+i];
    223       state->s[-len+i] = c;
    224     }
    225   return len;
    226 }
    227 
    228 /*
    229  * return length
    230  */
    231 
    232 static int
    233 append_string (struct state *state,
    234 	       const unsigned char *arg,
    235 	       int width,
    236 	       int prec,
    237 	       int flags)
    238 {
    239     int len = 0;
    240 
    241     if(arg == NULL)
    242 	arg = (const unsigned char*)"(null)";
    243 
    244     if(prec != -1)
    245 	width -= prec;
    246     else
    247 	width -= strlen((const char *)arg);
    248     if(!(flags & minus_flag))
    249 	while(width-- > 0) {
    250 	    (*state->append_char) (state, ' ');
    251 	    ++len;
    252 	}
    253     if (prec != -1) {
    254 	while (*arg && prec--) {
    255 	    (*state->append_char) (state, *arg++);
    256 	    ++len;
    257 	}
    258     } else {
    259 	while (*arg) {
    260 	    (*state->append_char) (state, *arg++);
    261 	    ++len;
    262 	}
    263     }
    264     if(flags & minus_flag)
    265 	while(width-- > 0) {
    266 	    (*state->append_char) (state, ' ');
    267 	    ++len;
    268 	}
    269     return len;
    270 }
    271 
    272 static int
    273 append_char(struct state *state,
    274 	    unsigned char arg,
    275 	    int width,
    276 	    int flags)
    277 {
    278   int len = 0;
    279 
    280   while(!(flags & minus_flag) && --width > 0) {
    281     (*state->append_char) (state, ' ')    ;
    282     ++len;
    283   }
    284   (*state->append_char) (state, arg);
    285   ++len;
    286   while((flags & minus_flag) && --width > 0) {
    287     (*state->append_char) (state, ' ');
    288     ++len;
    289   }
    290   return 0;
    291 }
    292 
    293 /*
    294  * This can't be made into a function...
    295  */
    296 
    297 #ifdef HAVE_LONG_LONG
    298 
    299 #define PARSE_INT_FORMAT(res, arg, unsig) \
    300 if (long_long_flag) \
    301      res = (unsig long long)va_arg(arg, unsig long long); \
    302 else if (long_flag) \
    303      res = (unsig long)va_arg(arg, unsig long); \
    304 else if (short_flag) \
    305      res = (unsig short)va_arg(arg, unsig int); \
    306 else \
    307      res = (unsig int)va_arg(arg, unsig int)
    308 
    309 #else
    310 
    311 #define PARSE_INT_FORMAT(res, arg, unsig) \
    312 if (long_flag) \
    313      res = (unsig long)va_arg(arg, unsig long); \
    314 else if (short_flag) \
    315      res = (unsig short)va_arg(arg, unsig int); \
    316 else \
    317      res = (unsig int)va_arg(arg, unsig int)
    318 
    319 #endif
    320 
    321 /*
    322  * zyxprintf - return length, as snprintf
    323  */
    324 
    325 static int
    326 xyzprintf (struct state *state, const char *char_format, va_list ap)
    327 {
    328   const unsigned char *format = (const unsigned char *)char_format;
    329   unsigned char c;
    330   int len = 0;
    331 
    332   while((c = *format++)) {
    333     if (c == '%') {
    334       int flags          = 0;
    335       int width          = 0;
    336       int prec           = -1;
    337       int long_long_flag = 0;
    338       int long_flag      = 0;
    339       int short_flag     = 0;
    340 
    341       /* flags */
    342       while((c = *format++)){
    343 	if(c == '-')
    344 	  flags |= minus_flag;
    345 	else if(c == '+')
    346 	  flags |= plus_flag;
    347 	else if(c == ' ')
    348 	  flags |= space_flag;
    349 	else if(c == '#')
    350 	  flags |= alternate_flag;
    351 	else if(c == '0')
    352 	  flags |= zero_flag;
    353 	else
    354 	  break;
    355       }
    356 
    357       if((flags & space_flag) && (flags & plus_flag))
    358 	flags ^= space_flag;
    359 
    360       if((flags & minus_flag) && (flags & zero_flag))
    361 	flags ^= zero_flag;
    362 
    363       /* width */
    364       if (isdigit(c))
    365 	do {
    366 	  width = width * 10 + c - '0';
    367 	  c = *format++;
    368 	} while(isdigit(c));
    369       else if(c == '*') {
    370 	width = va_arg(ap, int);
    371 	c = *format++;
    372       }
    373 
    374       /* precision */
    375       if (c == '.') {
    376 	prec = 0;
    377 	c = *format++;
    378 	if (isdigit(c))
    379 	  do {
    380 	    prec = prec * 10 + c - '0';
    381 	    c = *format++;
    382 	  } while(isdigit(c));
    383 	else if (c == '*') {
    384 	  prec = va_arg(ap, int);
    385 	  c = *format++;
    386 	}
    387       }
    388 
    389       /* size */
    390 
    391       if (c == 'h') {
    392 	short_flag = 1;
    393 	c = *format++;
    394       } else if (c == 'l') {
    395 	long_flag = 1;
    396 	c = *format++;
    397 	if (c == 'l') {
    398 	    long_long_flag = 1;
    399 	    c = *format++;
    400 	}
    401       }
    402 
    403       switch (c) {
    404       case 'c' :
    405 	append_char(state, va_arg(ap, int), width, flags);
    406 	++len;
    407 	break;
    408       case 's' :
    409 	len += append_string(state,
    410 			     va_arg(ap, unsigned char*),
    411 			     width,
    412 			     prec,
    413 			     flags);
    414 	break;
    415       case 'd' :
    416       case 'i' : {
    417 	longest arg;
    418 	u_longest num;
    419 	int minusp = 0;
    420 
    421 	PARSE_INT_FORMAT(arg, ap, signed);
    422 
    423 	if (arg < 0) {
    424 	  minusp = 1;
    425 	  num = -arg;
    426 	} else
    427 	  num = arg;
    428 
    429 	len += append_number (state, num, 10, "0123456789",
    430 			      width, prec, flags, minusp);
    431 	break;
    432       }
    433       case 'u' : {
    434 	u_longest arg;
    435 
    436 	PARSE_INT_FORMAT(arg, ap, unsigned);
    437 
    438 	len += append_number (state, arg, 10, "0123456789",
    439 			      width, prec, flags, 0);
    440 	break;
    441       }
    442       case 'o' : {
    443 	u_longest arg;
    444 
    445 	PARSE_INT_FORMAT(arg, ap, unsigned);
    446 
    447 	len += append_number (state, arg, 010, "01234567",
    448 			      width, prec, flags, 0);
    449 	break;
    450       }
    451       case 'x' : {
    452 	u_longest arg;
    453 
    454 	PARSE_INT_FORMAT(arg, ap, unsigned);
    455 
    456 	len += append_number (state, arg, 0x10, "0123456789abcdef",
    457 			      width, prec, flags, 0);
    458 	break;
    459       }
    460       case 'X' :{
    461 	u_longest arg;
    462 
    463 	PARSE_INT_FORMAT(arg, ap, unsigned);
    464 
    465 	len += append_number (state, arg, 0x10, "0123456789ABCDEF",
    466 			      width, prec, flags, 0);
    467 	break;
    468       }
    469       case 'p' : {
    470 	unsigned long arg = (unsigned long)va_arg(ap, void*);
    471 
    472 	len += append_number (state, arg, 0x10, "0123456789ABCDEF",
    473 			      width, prec, flags, 0);
    474 	break;
    475       }
    476       case 'n' : {
    477 	int *arg = va_arg(ap, int*);
    478 	*arg = state->s - state->str;
    479 	break;
    480       }
    481       case '\0' :
    482 	  --format;
    483 	  /* FALLTHROUGH */
    484       case '%' :
    485 	(*state->append_char)(state, c);
    486 	++len;
    487 	break;
    488       default :
    489 	(*state->append_char)(state, '%');
    490 	(*state->append_char)(state, c);
    491 	len += 2;
    492 	break;
    493       }
    494     } else {
    495       (*state->append_char) (state, c);
    496       ++len;
    497     }
    498   }
    499   return len;
    500 }
    501 
    502 #if !defined(HAVE_SNPRINTF) || defined(TEST_SNPRINTF)
    503 int
    504 snprintf (char *str, size_t sz, const char *format, ...)
    505 {
    506   va_list args;
    507   int ret;
    508 
    509   va_start(args, format);
    510   ret = vsnprintf (str, sz, format, args);
    511   va_end(args);
    512 
    513 #ifdef PARANOIA
    514   {
    515     int ret2;
    516     char *tmp;
    517 
    518     tmp = malloc (sz);
    519     if (tmp == NULL)
    520       abort ();
    521 
    522     va_start(args, format);
    523     ret2 = vsprintf (tmp, format, args);
    524     va_end(args);
    525     if (ret != ret2 || strcmp(str, tmp))
    526       abort ();
    527     free (tmp);
    528   }
    529 #endif
    530 
    531   return ret;
    532 }
    533 #endif
    534 
    535 #if !defined(HAVE_ASPRINTF) || defined(TEST_SNPRINTF)
    536 int
    537 asprintf (char **ret, const char *format, ...)
    538 {
    539   va_list args;
    540   int val;
    541 
    542   va_start(args, format);
    543   val = vasprintf (ret, format, args);
    544 
    545 #ifdef PARANOIA
    546   {
    547     int ret2;
    548     char *tmp;
    549     tmp = malloc (val + 1);
    550     if (tmp == NULL)
    551       abort ();
    552 
    553     ret2 = vsprintf (tmp, format, args);
    554     if (val != ret2 || strcmp(*ret, tmp))
    555       abort ();
    556     free (tmp);
    557   }
    558 #endif
    559 
    560   va_end(args);
    561   return val;
    562 }
    563 #endif
    564 
    565 #if !defined(HAVE_ASNPRINTF) || defined(TEST_SNPRINTF)
    566 int
    567 asnprintf (char **ret, size_t max_sz, const char *format, ...)
    568 {
    569   va_list args;
    570   int val;
    571 
    572   va_start(args, format);
    573   val = vasnprintf (ret, max_sz, format, args);
    574 
    575 #ifdef PARANOIA
    576   {
    577     int ret2;
    578     char *tmp;
    579     tmp = malloc (val + 1);
    580     if (tmp == NULL)
    581       abort ();
    582 
    583     ret2 = vsprintf (tmp, format, args);
    584     if (val != ret2 || strcmp(*ret, tmp))
    585       abort ();
    586     free (tmp);
    587   }
    588 #endif
    589 
    590   va_end(args);
    591   return val;
    592 }
    593 #endif
    594 
    595 #if !defined(HAVE_VASPRINTF) || defined(TEST_SNPRINTF)
    596 int
    597 vasprintf (char **ret, const char *format, va_list args)
    598 {
    599   return vasnprintf (ret, 0, format, args);
    600 }
    601 #endif
    602 
    603 
    604 #if !defined(HAVE_VASNPRINTF) || defined(TEST_SNPRINTF)
    605 int
    606 vasnprintf (char **ret, size_t max_sz, const char *format, va_list args)
    607 {
    608   int st;
    609   struct state state;
    610 
    611   state.max_sz = max_sz;
    612   state.sz     = 1;
    613   state.str    = malloc(state.sz);
    614   if (state.str == NULL) {
    615     *ret = NULL;
    616     return -1;
    617   }
    618   state.s = state.str;
    619   state.theend = state.s + state.sz - 1;
    620   state.append_char = as_append_char;
    621 
    622   st = xyzprintf (&state, format, args);
    623   if (st > state.sz) {
    624     free (state.str);
    625     *ret = NULL;
    626     return -1;
    627   } else {
    628     char *tmp;
    629 
    630     *state.s = '\0';
    631     tmp = realloc (state.str, st+1);
    632     if (tmp == NULL) {
    633       free (state.str);
    634       *ret = NULL;
    635       return -1;
    636     }
    637     *ret = tmp;
    638     return st;
    639   }
    640 }
    641 #endif
    642 
    643 #if !defined(HAVE_VSNPRINTF) || defined(TEST_SNPRINTF)
    644 int
    645 vsnprintf (char *str, size_t sz, const char *format, va_list args)
    646 {
    647   struct state state;
    648   int ret;
    649   unsigned char *ustr = (unsigned char *)str;
    650 
    651   state.max_sz = 0;
    652   state.sz     = sz;
    653   state.str    = ustr;
    654   state.s      = ustr;
    655   state.theend = ustr + sz - (sz > 0);
    656   state.append_char = sn_append_char;
    657 
    658   ret = xyzprintf (&state, format, args);
    659   if (state.s != NULL)
    660     *state.s = '\0';
    661   return ret;
    662 }
    663 #endif
    664