src/tests/snprintf.c

   1 /*
   2  * Copyright (c) 1995-2000 Kungliga Tekniska Högskolan
   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 #include <afsconfig.h>
  35 #ifdef HAVE_CONFIG_H
  36 #include <config.h>
  37 #endif
  38 #include <stdio.h>
  39 #include <stdarg.h>
  40 #include <stdlib.h>
  41 #include <string.h>
  42 #include <ctype.h>
  43
  44 #ifndef HAVE_VASNPRINTF
  45 int vasnprintf(char **ret, size_t max_sz, const char *format, va_list args);
  46 #endif
  47 #ifndef HAVE_VASPRINTF
  48 int vasprintf(char**ret, const char *format, va_list args);
  49 #endif
  50
  51 #ifndef min
  52 #define min(a, b)               ((a) > (b) ? (b) : (a))
  53 #endif
  54 #ifndef max
  55 #define max(a, b)               ((a) < (b) ? (b) : (a))
  56 #endif
  57
  58 enum format_flags {
  59     minus_flag = 1,
  60     plus_flag = 2,
  61     space_flag = 4,
  62     alternate_flag = 8,
  63     zero_flag = 16
  64 };
  65
  66 /*
  67  * Common state
  68  */
  69
  70 struct state {
  71     unsigned char *str;
  72     unsigned char *s;
  73     unsigned char *theend;
  74     size_t sz;
  75     size_t max_sz;
  76     int (*append_char) (struct state *, unsigned char);
  77     int (*reserve) (struct state *, size_t);
  78     /* XXX - methods */
  79 };
  80
  81 #ifndef HAVE_VSNPRINTF
  82 static int
  83 sn_reserve(struct state *state, size_t n)
  84 {
  85     return state->s + n > state->theend;
  86 }
  87
  88 static int
  89 sn_append_char(struct state *state, unsigned char c)
  90 {
  91     if (sn_reserve(state, 1)) {
  92         return 1;
  93     } else {
  94         *state->s++ = c;
  95         return 0;
  96     }
  97 }
  98 #endif
  99
 100 static int
 101 as_reserve(struct state *state, size_t n)
 102 {
 103     if (state->s + n > state->theend) {
 104         int off = state->s - state->str;
 105         unsigned char *tmp;
 106
 107         if (state->max_sz && state->sz >= state->max_sz)
 108             return 1;
 109
 110         state->sz = max(state->sz * 2, state->sz + n);
 111         if (state->max_sz)
 112             state->sz = min(state->sz, state->max_sz);
 113         tmp = realloc(state->str, state->sz);
 114         if (tmp == NULL)
 115             return 1;
 116         state->str = tmp;
 117         state->s = state->str + off;
 118         state->theend = state->str + state->sz - 1;
 119     }
 120     return 0;
 121 }
 122
 123 static int
 124 as_append_char(struct state *state, unsigned char c)
 125 {
 126     if (as_reserve(state, 1))
 127         return 1;
 128     else {
 129         *state->s++ = c;
 130         return 0;
 131     }
 132 }
 133
 134 static int
 135 append_number(struct state *state, unsigned long num, unsigned base,
 136               char *rep, int width, int prec, int flags, int minusp)
 137 {
 138     int len = 0;
 139     int i;
 140
 141     /* given precision, ignore zero flag */
 142     if (prec != -1)
 143         flags &= ~zero_flag;
 144     else
 145         prec = 1;
 146     /* zero value with zero precision -> "" */
 147     if (prec == 0 && num == 0)
 148         return 0;
 149     do {
 150         if ((*state->append_char) (state, rep[num % base]))
 151             return 1;
 152         len++;
 153         num /= base;
 154     } while (num);
 155     prec -= len;
 156     /* pad with prec zeros */
 157     while (prec-- > 0) {
 158         if ((*state->append_char) (state, '0'))
 159             return 1;
 160         len++;
 161     }
 162     /* add length of alternate prefix (added later) to len */
 163     if (flags & alternate_flag && (base == 16 || base == 8))
 164         len += base / 8;
 165     /* pad with zeros */
 166     if (flags & zero_flag) {
 167         width -= len;
 168         if (minusp || (flags & space_flag) || (flags & plus_flag))
 169             width--;
 170         while (width-- > 0) {
 171             if ((*state->append_char) (state, '0'))
 172                 return 1;
 173             len++;
 174         }
 175     }
 176     /* add alternate prefix */
 177     if (flags & alternate_flag && (base == 16 || base == 8)) {
 178         if (base == 16)
 179             if ((*state->append_char) (state, rep[10] + 23))    /* XXX */
 180                 return 1;
 181         if ((*state->append_char) (state, '0'))
 182             return 1;
 183     }
 184     /* add sign */
 185     if (minusp) {
 186         if ((*state->append_char) (state, '-'))
 187             return 1;
 188         len++;
 189     } else if (flags & plus_flag) {
 190         if ((*state->append_char) (state, '+'))
 191             return 1;
 192         len++;
 193     } else if (flags & space_flag) {
 194         if ((*state->append_char) (state, ' '))
 195             return 1;
 196         len++;
 197     }
 198     if (flags & minus_flag)
 199         /* swap before padding with spaces */
 200         for (i = 0; i < len / 2; i++) {
 201             char c = state->s[-i - 1];
 202             state->s[-i - 1] = state->s[-len + i];
 203             state->s[-len + i] = c;
 204         }
 205     width -= len;
 206     while (width-- > 0) {
 207         if ((*state->append_char) (state, ' '))
 208             return 1;
 209         len++;
 210     }
 211     if (!(flags & minus_flag))
 212         /* swap after padding with spaces */
 213         for (i = 0; i < len / 2; i++) {
 214             char c = state->s[-i - 1];
 215             state->s[-i - 1] = state->s[-len + i];
 216             state->s[-len + i] = c;
 217         }
 218
 219     return 0;
 220 }
 221
 222 static int
 223 append_string(struct state *state, unsigned char *arg, int width, int prec,
 224               int flags)
 225 {
 226     if (arg == NULL)
 227         arg = (unsigned char *)"(null)";
 228
 229     if (prec != -1)
 230         width -= prec;
 231     else
 232         width -= strlen((char *)arg);
 233     if (!(flags & minus_flag))
 234         while (width-- > 0)
 235             if ((*state->append_char) (state, ' '))
 236                 return 1;
 237     if (prec != -1) {
 238         while (*arg && prec--)
 239             if ((*state->append_char) (state, *arg++))
 240                 return 1;
 241     } else {
 242         while (*arg)
 243             if ((*state->append_char) (state, *arg++))
 244                 return 1;
 245     }
 246     if (flags & minus_flag)
 247         while (width-- > 0)
 248             if ((*state->append_char) (state, ' '))
 249                 return 1;
 250     return 0;
 251 }
 252
 253 static int
 254 append_char(struct state *state, unsigned char arg, int width, int flags)
 255 {
 256     while (!(flags & minus_flag) && --width > 0)
 257         if ((*state->append_char) (state, ' '))
 258             return 1;
 259
 260     if ((*state->append_char) (state, arg))
 261         return 1;
 262     while ((flags & minus_flag) && --width > 0)
 263         if ((*state->append_char) (state, ' '))
 264             return 1;
 265
 266     return 0;
 267 }
 268
 269 /*
 270  * This can't be made into a function...
 271  */
 272
 273 #define PARSE_INT_FORMAT(res, arg, unsig) \
 274 if (long_flag) \
 275      res = (unsig long)va_arg(arg, unsig long); \
 276 else if (short_flag) \
 277      res = (unsig short)va_arg(arg, unsig int); \
 278 else \
 279      res = (unsig int)va_arg(arg, unsig int)
 280
 281 /*
 282  * zyxprintf - return 0 or -1
 283  */
 284
 285 static int
 286 xyzprintf(struct state *state, const char *char_format, va_list ap)
 287 {
 288     const unsigned char *format = (const unsigned char *)char_format;
 289     unsigned char c;
 290
 291     while ((c = *format++)) {
 292         if (c == '%') {
 293             int flags = 0;
 294             int width = 0;
 295             int prec = -1;
 296             int long_flag = 0;
 297             int short_flag = 0;
 298
 299             /* flags */
 300             while ((c = *format++)) {
 301                 if (c == '-')
 302                     flags |= minus_flag;
 303                 else if (c == '+')
 304                     flags |= plus_flag;
 305                 else if (c == ' ')
 306                     flags |= space_flag;
 307                 else if (c == '#')
 308                     flags |= alternate_flag;
 309                 else if (c == '0')
 310                     flags |= zero_flag;
 311                 else
 312                     break;
 313             }
 314
 315             if ((flags & space_flag) && (flags & plus_flag))
 316                 flags ^= space_flag;
 317
 318             if ((flags & minus_flag) && (flags & zero_flag))
 319                 flags ^= zero_flag;
 320
 321             /* width */
 322             if (isdigit(c))
 323                 do {
 324                     width = width * 10 + c - '0';
 325                     c = *format++;
 326                 } while (isdigit(c));
 327             else if (c == '*') {
 328                 width = va_arg(ap, int);
 329                 c = *format++;
 330             }
 331
 332             /* precision */
 333             if (c == '.') {
 334                 prec = 0;
 335                 c = *format++;
 336                 if (isdigit(c))
 337                     do {
 338                         prec = prec * 10 + c - '0';
 339                         c = *format++;
 340                     } while (isdigit(c));
 341                 else if (c == '*') {
 342                     prec = va_arg(ap, int);
 343                     c = *format++;
 344                 }
 345             }
 346
 347             /* size */
 348
 349             if (c == 'h') {
 350                 short_flag = 1;
 351                 c = *format++;
 352             } else if (c == 'l') {
 353                 long_flag = 1;
 354                 c = *format++;
 355             }
 356
 357             switch (c) {
 358             case 'c':
 359                 if (append_char(state, va_arg(ap, int), width, flags))
 360                       return -1;
 361                 break;
 362             case 's':
 363                 if (append_string
 364                     (state, va_arg(ap, unsigned char *), width, prec, flags))
 365                       return -1;
 366                 break;
 367             case 'd':
 368             case 'i':{
 369                     long arg;
 370                     unsigned long num;
 371                     int minusp = 0;
 372
 373                     PARSE_INT_FORMAT(arg, ap, signed);
 374
 375                     if (arg < 0) {
 376                         minusp = 1;
 377                         num = -arg;
 378                     } else
 379                         num = arg;
 380
 381                     if (append_number
 382                         (state, num, 10, "0123456789", width, prec, flags,
 383                          minusp))
 384                         return -1;
 385                     break;
 386                 }
 387             case 'u':{
 388                     unsigned long arg;
 389
 390                     PARSE_INT_FORMAT(arg, ap, unsigned);
 391
 392                     if (append_number
 393                         (state, arg, 10, "0123456789", width, prec, flags, 0))
 394                         return -1;
 395                     break;
 396                 }
 397             case 'o':{
 398                     unsigned long arg;
 399
 400                     PARSE_INT_FORMAT(arg, ap, unsigned);
 401
 402                     if (append_number
 403                         (state, arg, 010, "01234567", width, prec, flags, 0))
 404                         return -1;
 405                     break;
 406                 }
 407             case 'x':{
 408                     unsigned long arg;
 409
 410                     PARSE_INT_FORMAT(arg, ap, unsigned);
 411
 412                     if (append_number
 413                         (state, arg, 0x10, "0123456789abcdef", width, prec,
 414                          flags, 0))
 415                         return -1;
 416                     break;
 417                 }
 418             case 'X':{
 419                     unsigned long arg;
 420
 421                     PARSE_INT_FORMAT(arg, ap, unsigned);
 422
 423                     if (append_number
 424                         (state, arg, 0x10, "0123456789ABCDEF", width, prec,
 425                          flags, 0))
 426                         return -1;
 427                     break;
 428                 }
 429             case 'p':{
 430                     unsigned long arg = (unsigned long)va_arg(ap, void *);
 431
 432                     if (append_number
 433                         (state, arg, 0x10, "0123456789ABCDEF", width, prec,
 434                          flags, 0))
 435                         return -1;
 436                     break;
 437                 }
 438             case 'n':{
 439                     int *arg = va_arg(ap, int *);
 440                     *arg = state->s - state->str;
 441                     break;
 442                 }
 443             case '\0':
 444                 --format;
 445                 /* FALLTHROUGH */
 446             case '%':
 447                 if ((*state->append_char) (state, c))
 448                     return -1;
 449                 break;
 450             default:
 451                 if ((*state->append_char) (state, '%')
 452                     || (*state->append_char) (state, c))
 453                     return -1;
 454                 break;
 455             }
 456         } else if ((*state->append_char) (state, c))
 457             return -1;
 458     }
 459     return 0;
 460 }
 461
 462 #ifndef HAVE_SNPRINTF
 463 int
 464 snprintf(char *str, size_t sz, const char *format, ...)
 465 {
 466     va_list args;
 467     int ret;
 468
 469     va_start(args, format);
 470     ret = vsnprintf(str, sz, format, args);
 471
 472 #ifdef PARANOIA
 473     {
 474         int ret2;
 475         char *tmp;
 476
 477         tmp = malloc(sz);
 478         if (tmp == NULL)
 479             abort();
 480
 481         ret2 = vsprintf(tmp, format, args);
 482         if (ret != ret2 || strcmp(str, tmp))
 483             abort();
 484         free(tmp);
 485     }
 486 #endif
 487
 488     va_end(args);
 489     return ret;
 490 }
 491 #endif
 492
 493 #ifndef HAVE_ASPRINTF
 494 int
 495 asprintf(char **ret, const char *format, ...)
 496 {
 497     va_list args;
 498     int val;
 499
 500     va_start(args, format);
 501     val = vasprintf(ret, format, args);
 502
 503 #ifdef PARANOIA
 504     {
 505         int ret2;
 506         char *tmp;
 507         tmp = malloc(val + 1);
 508         if (tmp == NULL)
 509             abort();
 510
 511         ret2 = vsprintf(tmp, format, args);
 512         if (val != ret2 || strcmp(*ret, tmp))
 513             abort();
 514         free(tmp);
 515     }
 516 #endif
 517
 518     va_end(args);
 519     return val;
 520 }
 521 #endif
 522
 523 #ifndef HAVE_ASNPRINTF
 524 int
 525 asnprintf(char **ret, size_t max_sz, const char *format, ...)
 526 {
 527     va_list args;
 528     int val;
 529
 530     va_start(args, format);
 531     val = vasnprintf(ret, max_sz, format, args);
 532
 533 #ifdef PARANOIA
 534     {
 535         int ret2;
 536         char *tmp;
 537         tmp = malloc(val + 1);
 538         if (tmp == NULL)
 539             abort();
 540
 541         ret2 = vsprintf(tmp, format, args);
 542         if (val != ret2 || strcmp(*ret, tmp))
 543             abort();
 544         free(tmp);
 545     }
 546 #endif
 547
 548     va_end(args);
 549     return val;
 550 }
 551 #endif
 552
 553 #ifndef HAVE_VASPRINTF
 554 int
 555 vasprintf(char **ret, const char *format, va_list args)
 556 {
 557     return vasnprintf(ret, 0, format, args);
 558 }
 559 #endif
 560
 561
 562 #ifndef HAVE_VASNPRINTF
 563 int
 564 vasnprintf(char **ret, size_t max_sz, const char *format, va_list args)
 565 {
 566     int st;
 567     size_t len;
 568     struct state state;
 569
 570     state.max_sz = max_sz;
 571     state.sz = 1;
 572     state.str = malloc(state.sz);
 573     if (state.str == NULL) {
 574         *ret = NULL;
 575         return -1;
 576     }
 577     state.s = state.str;
 578     state.theend = state.s + state.sz - 1;
 579     state.append_char = as_append_char;
 580     state.reserve = as_reserve;
 581
 582     st = xyzprintf(&state, format, args);
 583     if (st) {
 584         free(state.str);
 585         *ret = NULL;
 586         return -1;
 587     } else {
 588         char *tmp;
 589
 590         *state.s = '\0';
 591         len = state.s - state.str;
 592         tmp = realloc(state.str, len + 1);
 593         if (tmp == NULL) {
 594             free(state.str);
 595             *ret = NULL;
 596             return -1;
 597         }
 598         *ret = tmp;
 599         return len;
 600     }
 601 }
 602 #endif
 603
 604 #ifndef HAVE_VSNPRINTF
 605 int
 606 vsnprintf(char *str, size_t sz, const char *format, va_list args)
 607 {
 608     struct state state;
 609     int ret;
 610     unsigned char *ustr = (unsigned char *)str;
 611
 612     state.max_sz = 0;
 613     state.sz = sz;
 614     state.str = ustr;
 615     state.s = ustr;
 616     state.theend = ustr + sz - 1;
 617     state.append_char = sn_append_char;
 618     state.reserve = sn_reserve;
 619
 620     ret = xyzprintf(&state, format, args);
 621     *state.s = '\0';
 622     if (ret)
 623         return sz;
 624     else
 625         return state.s - state.str;
 626 }
 627 #endif