vsprintf.c

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
/* vsprintf.c -- Lars Wirzenius & Linus Torvalds. */
/*
 * Wirzenius wrote this portably, Torvalds fucked it up :-)
 */
 
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/assert.h"
#include "pedigree/kernel/utilities/utility.h"
 
#include <stdarg.h>
 
#ifdef __clang__
#pragma GCC diagnostic ignored "-Wgnu-statement-expression"
#endif
 
/* we use this so that we can do without the ctype library */
#define is_digit(c) ((c) >= '0' && (c) <= '9')
 
static int skip_atoi(const char** s) {
  int i = 0;
 
  while (is_digit(**s))
    i = i * 10 + *((*s)++) - '0';
  return i;
}
 
#define ZEROPAD 1  /* pad with zero */
#define SIGN 2     /* unsigned/signed long */
#define PLUS 4     /* show plus */
#define SPACE 8    /* space if plus */
#define LEFT 16    /* left justified */
#define SPECIAL 32 /* 0x */
#define SMALL 64   /* use 'abcdef' instead of 'ABCDEF' */
 
static char* number(char* str, int64_t num, int base, int size, int precision, int type) {
  char c, sign, tmp[36];
  const char* digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
  uint64_t magnitude = (uint64_t)num;
  int i;
 
  if (type & SMALL)
    digits = "0123456789abcdefghijklmnopqrstuvwxyz";
  if (type & LEFT)
    type &= ~ZEROPAD;
  if (base < 2 || base > 36)
    return 0;
  c = (type & ZEROPAD) ? '0' : ' ';
  if (type & SIGN && num < 0) {
    sign = '-';
    // Unsigned subtraction also handles the magnitude of INT64_MIN.
    magnitude = (uint64_t)0 - magnitude;
  } else
    sign = (type & PLUS) ? '+' : ((type & SPACE) ? ' ' : 0);
  if (sign)
    size--;
  if (type & SPECIAL) {
    if (base == 16)
      size -= 2;
    else if (base == 8)
      size--;
  }
  i = 0;
  if (magnitude == 0) {
    tmp[i++] = '0';
  } else {
    while (magnitude != 0) {
      int d = (int)(magnitude % (uint64_t)base);
      magnitude /= (uint64_t)base;
      tmp[i++] = digits[d];
      assert(i < 36);
    }
  }
  if (i > precision)
    precision = i;
  size -= precision;
  if (!(type & (ZEROPAD + LEFT)))
    while (size-- > 0)
      *str++ = ' ';
  if (sign)
    *str++ = sign;
  if (type & SPECIAL) {
    if (base == 8)
      *str++ = '0';
    else if (base == 16) {
      *str++ = '0';
      *str++ = digits[33];
    }
  }
  if (!(type & LEFT))
    while (size-- > 0)
      *str++ = c;
  while (i < precision--)
    *str++ = '0';
  while (i-- > 0)
    *str++ = tmp[i];
  while (size-- > 0)
    *str++ = ' ';
  return str;
}
 
int VStringFormat(char* buf, const char* fmt, va_list args) {
  int len;
  int i;
  char* str;
  char* s;
  int* ip;
 
  int flags; /* flags to number() */
 
  int field_width; /* width of output field */
  int precision;   /* min. # of digits for integers; max
                      number of chars for from string */
  int qualifier;   /* 'h', 'l', or 'L' for integer fields */
 
  for (str = buf; *fmt; ++fmt) {
    if (*fmt != '%') {
      *str++ = *fmt;
      continue;
    }
 
    /* process flags */
    flags = 0;
  repeat:
    ++fmt; /* this also skips first '%' */
    switch (*fmt) {
      case '-':
        flags |= LEFT;
        goto repeat;
      case '+':
        flags |= PLUS;
        goto repeat;
      case ' ':
        flags |= SPACE;
        goto repeat;
      case '#':
        flags |= SPECIAL;
        goto repeat;
      case '0':
        flags |= ZEROPAD;
        goto repeat;
    }
 
    /* get field width */
    field_width = -1;
    if (is_digit(*fmt))
      field_width = skip_atoi(&fmt);
    else if (*fmt == '*') {
      /* it's the next argument */
      field_width = va_arg(args, int);
      if (field_width < 0) {
        field_width = -field_width;
        flags |= LEFT;
      }
    }
 
    /* get the precision */
    precision = -1;
    if (*fmt == '.') {
      ++fmt;
      if (is_digit(*fmt))
        precision = skip_atoi(&fmt);
      else if (*fmt == '*') {
        /* it's the next argument */
        precision = va_arg(args, int);
      }
      if (precision < 0)
        precision = 0;
    }
 
    /* get the conversion qualifier */
    qualifier = -1;
    if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L') {
      qualifier = *fmt;
      ++fmt;
    }
 
    switch (*fmt) {
      case 'c':
        if (!(flags & LEFT))
          while (--field_width > 0)
            *str++ = ' ';
        *str++ = (unsigned char)va_arg(args, int);
        while (--field_width > 0)
          *str++ = ' ';
        break;
 
      case 's':
        s = va_arg(args, char*);
        len = StringLength(s);
        if (precision < 0)
          precision = len;
        else if (len > precision)
          len = precision;
 
        if (!(flags & LEFT))
          while (len < field_width--)
            *str++ = ' ';
        for (i = 0; i < len; ++i)
          *str++ = *s++;
        while (len < field_width--)
          *str++ = ' ';
        break;
 
      case 'o':
        str = number(str, va_arg(args, unsigned long), 8, field_width, precision, flags);
        break;
 
      case 'p':
        if (field_width == -1) {
          field_width = sizeof(void*) * 2;
          flags |= ZEROPAD;
        }
        str = number(str, (uintptr_t)va_arg(args, void*), 16, field_width, precision, flags);
        break;
 
      case 'x':
        flags |= SMALL;
        FALLSTHROUGH
      case 'X':
        str = number(str, va_arg(args, unsigned long), 16, field_width, precision, flags);
        break;
 
      case 'd':
      case 'i':
        flags |= SIGN;
        FALLSTHROUGH
      case 'u':
        str = number(str, va_arg(args, unsigned long), 10, field_width, precision, flags);
        break;
 
      case 'n':
        ip = va_arg(args, int*);
        *ip = (str - buf);
        break;
 
      default:
        if (*fmt != '%')
          *str++ = '%';
        if (*fmt)
          *str++ = *fmt;
        else
          --fmt;
        break;
    }
  }
  *str = '\0';
  return str - buf;
}