#include "stdout.h"

#ifdef STDOUT_put_string
  void stdout_put_string(void (*putc)(char c), const char* s)
  {
    register unsigned char c;
    while ((c=*s++))
      putc(c);
  }
#endif

#ifdef STDOUT_put_uint
  void stdout_put_uint(void (*putc)(const char c), int n)
  {
    unsigned char i;
    for(i=0; _devisor_ten[i]>n; i++);
    int c=0;
    for(; i<sizeof(_devisor_ten) / sizeof(int); i++)
    {
      for(c=0; (n - _devisor_ten[i]) < n; c++)
        n -= _devisor_ten[i];
      putc('0' + c);
    }
    /// // if processor has can devide this might be better:
    /// register unsigned int d=1;
    /// for(; d<n; d*=10);
    /// for(d /= 10; d>0; n %= d, d /= 10)
      /// putc('0' + (n / d));
  }
#endif

#ifdef STDOUT_reverse_bits
  char stdout_reverse_bits(unsigned char v)
  {
    unsigned char s = sizeof(v) * CHAR_BIT; // bit size; must be power of 2
    unsigned char mask = ~0;
    while ((s >>= 1) > 0)
    {
      mask ^= (mask << s);
      v = ((v >> s) & mask) | ((v << s) & ~mask);
    }
    return v;
  }
#endif

#ifdef STDOUT_put_binary
  void stdout_put_binary(void (*putc)(const char c), const unsigned char data)
  {
    char i;
    for(i=CHAR_BIT-1; i>=0; i--)
    {
      if(data & (1<<i))
        putc('1');
      else
        putc('0');
    }
  }
#endif

#ifdef STDOUT_putf
void stdout_putf(void (*putc)(const char c), const char* format, ...)
{
  va_list vl;
  va_start(vl, format);

  typedef union
  {
    char as_char         : (sizeof(char) * CHAR_BIT);
    int as_int           : (sizeof(int) * CHAR_BIT);
    uint32_t as_uint     : (sizeof(int) * CHAR_BIT);
  } va_data;
  va_data data;

  do
  {
    if(format[0] != '%')
      putc(format[0]);
    else
    {
      char f = '\0'; // fill-char for fixed width numbers (\0 means OFF)
      switch((++format)[0])
      {
        case '%':
          putc('%');
        break;
        case 'c':
          putc(va_arg(vl, int));
        break;
        case '0':
          if(f == '\0')
            f = '0';
        case '-':
          if(f == '\0')
            f = ' ';
        case ' ':
        case 'd':
        {
          int width = 0;
          data.as_int = va_arg(vl, unsigned int);

          if(data.as_int < 0)
          {
            putc('-');
            width        = -1;
            data.as_int *= -1;
          }
          else if(format[0] == ' ')
              putc(' ');

          if(f != '\0')
          {
            // translate string with user-requested fixed length...
            static const int _potences[] = {1, 10, 100, 1000};

            int s     = 0;
            while((++format)[1] !='d' && format[0] >='0' && format[0] <='9')
              s++;
            for(; s>=0; --s)
              width += _potences[sizeof(_potences) - s] * (format[-s] - '0');

            // count numbers width in decimal-system...
            for(s=10; s<data.as_int; s*=10, --width);

            // remove trailing numbers and append spacechar if wanted...
            for(; width>1; width--, putc(f)); // prepend whitespace-character[space]
          }

          stdout_put_uint(putc, data.as_uint);
          if(format[0] != 'd')
            ++format;
        }
        break;
        case 's':
          #ifdef STDOUT_put_string
            stdout_put_string(putc, va_arg(vl, char*));
          #else
            va_arg(vl, int); // remove next argument
          #endif
        break;
        case 'b':
          #ifdef STDOUT_put_binary
            data.as_int = va_arg(vl, int);
            stdout_put_binary(putc, data.as_uint);
          #else
            va_arg(vl, int); // remove next argument
          #endif
        break;
      }
    }
  }
  while((++format)[0] != '\0');
  return;
}
#endif