OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [bootloaders/] [orpmon/] [coremark/] [ee_printf.c] - Diff between revs 355 and 406

Show entire file | Details | Blame | View Log

Rev 355 Rev 406
Line 59... Line 59... 
}
 
}
 
 
 
 
 
static int skip_atoi(const char **s)
 
static int skip_atoi(const char **s)
 
{
 
{
 
  int i = 0;
 
  int i = 0;
 
  while (is_digit(**s)) i = i*10 + *((*s)++) - '0';
 
        while (is_digit(**s))
 
 
 
                i = i * 10 + *((*s)++) - '0';
 
  return i;
 
  return i;
 
}
 
}
 
 
 
 
 
static char *number(char *str, long num, int base, int size, int precision, int type)
 
static char *number(char *str, long num, int base, int size, int precision,
 
 
 
                    int type)
 
{
 
{
 
  char c, sign, tmp[66];
 
  char c, sign, tmp[66];
 
  char *dig = digits;
 
  char *dig = digits;
 
  int i;
 
  int i;
 
 
 
 
 
  if (type & UPPERCASE)  dig = upper_digits;
 
        if (type & UPPERCASE)
 
  if (type & LEFT) type &= ~ZEROPAD;
 
                dig = upper_digits;
 
  if (base < 2 || base > 36) return 0;
 
        if (type & LEFT)
 
 
 
                type &= ~ZEROPAD;
 
 
 
        if (base < 2 || base > 36)
 
 
 
                return 0;
 
 
 
 
 
  c = (type & ZEROPAD) ? '0' : ' ';
 
  c = (type & ZEROPAD) ? '0' : ' ';
 
  sign = 0;
 
  sign = 0;
 
  if (type & SIGN)
 
        if (type & SIGN) {
 
  {
 
                if (num < 0) {
 
    if (num < 0)
 
 
 
    {
 
 
 
      sign = '-';
 
      sign = '-';
 
      num = -num;
 
      num = -num;
 
      size--;
 
      size--;
 
    }
 
                } else if (type & PLUS) {
 
    else if (type & PLUS)
 
 
 
    {
 
 
 
      sign = '+';
 
      sign = '+';
 
      size--;
 
      size--;
 
    }
 
                } else if (type & SPACE) {
 
    else if (type & SPACE)
 
 
 
    {
 
 
 
      sign = ' ';
 
      sign = ' ';
 
      size--;
 
      size--;
 
    }
 
    }
 
  }
 
  }
 
 
 
 
 
  if (type & HEX_PREP)
 
        if (type & HEX_PREP) {
 
  {
 
 
 
    if (base == 16)
 
    if (base == 16)
 
      size -= 2;
 
      size -= 2;
 
    else if (base == 8)
 
    else if (base == 8)
 
      size--;
 
      size--;
 
  }
 
  }
 
 
 
 
 
  i = 0;
 
  i = 0;
 
 
 
 
 
  if (num == 0)
 
  if (num == 0)
 
    tmp[i++] = '0';
 
    tmp[i++] = '0';
 
  else
 
        else {
 
  {
 
                while (num != 0) {
 
    while (num != 0)
 
 
 
    {
 
 
 
      tmp[i++] = dig[((unsigned long) num) % (unsigned) base];
 
      tmp[i++] = dig[((unsigned long) num) % (unsigned) base];
 
      num = ((unsigned long) num) / (unsigned) base;
 
      num = ((unsigned long) num) / (unsigned) base;
 
    }
 
    }
 
  }
 
  }
 
 
 
 
 
  if (i > precision) precision = i;
 
        if (i > precision)
 
 
 
                precision = i;
 
  size -= precision;
 
  size -= precision;
 
  if (!(type & (ZEROPAD | LEFT))) while (size-- > 0) *str++ = ' ';
 
        if (!(type & (ZEROPAD | LEFT)))
 
  if (sign) *str++ = sign;
 
                while (size-- > 0)
 
 
 
                        *str++ = ' ';
 
 
 
        if (sign)
 
 
 
                *str++ = sign;
 
 
 
 
 
  if (type & HEX_PREP)
 
        if (type & HEX_PREP) {
 
  {
 
 
 
    if (base == 8)
 
    if (base == 8)
 
      *str++ = '0';
 
      *str++ = '0';
 
    else if (base == 16)
 
                else if (base == 16) {
 
    {
 
 
 
      *str++ = '0';
 
      *str++ = '0';
 
      *str++ = digits[33];
 
      *str++ = digits[33];
 
    }
 
    }
 
  }
 
  }
 
 
 
 
 
  if (!(type & LEFT)) while (size-- > 0) *str++ = c;
 
        if (!(type & LEFT))
 
  while (i < precision--) *str++ = '0';
 
                while (size-- > 0)
 
  while (i-- > 0) *str++ = tmp[i];
 
                        *str++ = c;
 
  while (size-- > 0) *str++ = ' ';
 
        while (i < precision--)
 
 
 
                *str++ = '0';
 
 
 
        while (i-- > 0)
 
 
 
                *str++ = tmp[i];
 
 
 
        while (size-- > 0)
 
 
 
                *str++ = ' ';
 
 
 
 
 
  return str;
 
  return str;
 
}
 
}
 
 
 
 
 
static char *eaddr(char *str, unsigned char *addr, int size, int precision, int type)
 
static char *eaddr(char *str, unsigned char *addr, int size, int precision,
 
 
 
                   int type)
 
{
 
{
 
  char tmp[24];
 
  char tmp[24];
 
  char *dig = digits;
 
  char *dig = digits;
 
  int i, len;
 
  int i, len;
 
 
 
 
 
  if (type & UPPERCASE)  dig = upper_digits;
 
        if (type & UPPERCASE)
 
 
 
                dig = upper_digits;
 
  len = 0;
 
  len = 0;
 
  for (i = 0; i < 6; i++)
 
        for (i = 0; i < 6; i++) {
 
  {
 
                if (i != 0)
 
    if (i != 0) tmp[len++] = ':';
 
                        tmp[len++] = ':';
 
    tmp[len++] = dig[addr[i] >> 4];
 
    tmp[len++] = dig[addr[i] >> 4];
 
    tmp[len++] = dig[addr[i] & 0x0F];
 
    tmp[len++] = dig[addr[i] & 0x0F];
 
  }
 
  }
 
 
 
 
 
  if (!(type & LEFT)) while (len < size--) *str++ = ' ';
 
        if (!(type & LEFT))
 
  for (i = 0; i < len; ++i) *str++ = tmp[i];
 
                while (len < size--)
 
  while (len < size--) *str++ = ' ';
 
                        *str++ = ' ';
 
 
 
        for (i = 0; i < len; ++i)
 
 
 
                *str++ = tmp[i];
 
 
 
        while (len < size--)
 
 
 
                *str++ = ' ';
 
 
 
 
 
  return str;
 
  return str;
 
}
 
}
 
 
 
 
 
static char *iaddr(char *str, unsigned char *addr, int size, int precision, int type)
 
static char *iaddr(char *str, unsigned char *addr, int size, int precision,
 
 
 
                   int type)
 
{
 
{
 
  char tmp[24];
 
  char tmp[24];
 
  int i, n, len;
 
  int i, n, len;
 
 
 
 
 
  len = 0;
 
  len = 0;
 
  for (i = 0; i < 4; i++)
 
        for (i = 0; i < 4; i++) {
 
  {
 
                if (i != 0)
 
    if (i != 0) tmp[len++] = '.';
 
                        tmp[len++] = '.';
 
    n = addr[i];
 
    n = addr[i];
 
 
 
 
 
    if (n == 0)
 
    if (n == 0)
 
      tmp[len++] = digits[0];
 
      tmp[len++] = digits[0];
 
    else
 
                else {
 
    {
 
                        if (n >= 100) {
 
      if (n >= 100)
 
 
 
      {
 
 
 
        tmp[len++] = digits[n / 100];
 
        tmp[len++] = digits[n / 100];
 
        n = n % 100;
 
        n = n % 100;
 
        tmp[len++] = digits[n / 10];
 
        tmp[len++] = digits[n / 10];
 
        n = n % 10;
 
        n = n % 10;
 
      }
 
                        } else if (n >= 10) {
 
      else if (n >= 10)
 
 
 
      {
 
 
 
        tmp[len++] = digits[n / 10];
 
        tmp[len++] = digits[n / 10];
 
        n = n % 10;
 
        n = n % 10;
 
      }
 
      }
 
 
 
 
 
      tmp[len++] = digits[n];
 
      tmp[len++] = digits[n];
 
    }
 
    }
 
  }
 
  }
 
 
 
 
 
  if (!(type & LEFT)) while (len < size--) *str++ = ' ';
 
        if (!(type & LEFT))
 
  for (i = 0; i < len; ++i) *str++ = tmp[i];
 
                while (len < size--)
 
  while (len < size--) *str++ = ' ';
 
                        *str++ = ' ';
 
 
 
        for (i = 0; i < len; ++i)
 
 
 
                *str++ = tmp[i];
 
 
 
        while (len < size--)
 
 
 
                *str++ = ' ';
 
 
 
 
 
  return str;
 
  return str;
 
}
 
}
 
 
 
 
 
#ifdef HAS_FLOAT
 
#ifdef HAS_FLOAT
 
 
 
 
 
char *ecvtbuf(double arg, int ndigits, int *decpt, int *sign, char *buf);
 
char *ecvtbuf(double arg, int ndigits, int *decpt, int *sign, char *buf);
 
char *fcvtbuf(double arg, int ndigits, int *decpt, int *sign, char *buf);
 
char *fcvtbuf(double arg, int ndigits, int *decpt, int *sign, char *buf);
 
static void ee_bufcpy(char *d, char *s, int count);
 
static void ee_bufcpy(char *d, char *s, int count);
 
 
 
 
 
void ee_bufcpy(char *pd, char *ps, int count) {
 
void ee_bufcpy(char *pd, char *ps, int count)
 
 
 
{
 
        char *pe=ps+count;
 
        char *pe=ps+count;
 
        while (ps!=pe)
 
        while (ps!=pe)
 
                *pd++=*ps++;
 
                *pd++ = *ps++;
 
}
 
}
 
 
 
 
 
static void parse_float(double value, char *buffer, char fmt, int precision)
 
static void parse_float(double value, char *buffer, char fmt, int precision)
 
{
 
{
 
  int decpt, sign, exp, pos;
 
  int decpt, sign, exp, pos;
 
  char *digits = NULL;
 
  char *digits = NULL;
 
  char cvtbuf[80];
 
  char cvtbuf[80];
 
  int capexp = 0;
 
  int capexp = 0;
 
  int magnitude;
 
  int magnitude;
 
 
 
 
 
  if (fmt == 'G' || fmt == 'E')
 
        if (fmt == 'G' || fmt == 'E') {
 
  {
 
 
 
    capexp = 1;
 
    capexp = 1;
 
    fmt += 'a' - 'A';
 
    fmt += 'a' - 'A';
 
  }
 
  }
 
 
 
 
 
  if (fmt == 'g')
 
        if (fmt == 'g') {
 
  {
 
 
 
    digits = ecvtbuf(value, precision, &decpt, &sign, cvtbuf);
 
    digits = ecvtbuf(value, precision, &decpt, &sign, cvtbuf);
 
    magnitude = decpt - 1;
 
    magnitude = decpt - 1;
 
    if (magnitude < -4  ||  magnitude > precision - 1)
 
                if (magnitude < -4 || magnitude > precision - 1) {
 
    {
 
 
 
      fmt = 'e';
 
      fmt = 'e';
 
      precision -= 1;
 
      precision -= 1;
 
    }
 
                } else {
 
    else
 
 
 
    {
 
 
 
      fmt = 'f';
 
      fmt = 'f';
 
      precision -= decpt;
 
      precision -= decpt;
 
    }
 
    }
 
  }
 
  }
 
 
 
 
 
  if (fmt == 'e')
 
        if (fmt == 'e') {
 
  {
 
 
 
    digits = ecvtbuf(value, precision + 1, &decpt, &sign, cvtbuf);
 
    digits = ecvtbuf(value, precision + 1, &decpt, &sign, cvtbuf);
 
 
 
 
 
    if (sign) *buffer++ = '-';
 
                if (sign)
 
 
 
                        *buffer++ = '-';
 
    *buffer++ = *digits;
 
    *buffer++ = *digits;
 
    if (precision > 0) *buffer++ = '.';
 
                if (precision > 0)
 
 
 
                        *buffer++ = '.';
 
    ee_bufcpy(buffer, digits + 1, precision);
 
    ee_bufcpy(buffer, digits + 1, precision);
 
    buffer += precision;
 
    buffer += precision;
 
    *buffer++ = capexp ? 'E' : 'e';
 
    *buffer++ = capexp ? 'E' : 'e';
 
 
 
 
 
    if (decpt == 0)
 
                if (decpt == 0) {
 
    {
 
 
 
      if (value == 0.0)
 
      if (value == 0.0)
 
        exp = 0;
 
        exp = 0;
 
      else
 
      else
 
        exp = -1;
 
        exp = -1;
 
    }
 
                } else
 
    else
 
 
 
      exp = decpt - 1;
 
      exp = decpt - 1;
 
 
 
 
 
    if (exp < 0)
 
                if (exp < 0) {
 
    {
 
 
 
      *buffer++ = '-';
 
      *buffer++ = '-';
 
      exp = -exp;
 
      exp = -exp;
 
    }
 
                } else
 
    else
 
 
 
      *buffer++ = '+';
 
      *buffer++ = '+';
 
 
 
 
 
    buffer[2] = (exp % 10) + '0';
 
    buffer[2] = (exp % 10) + '0';
 
    exp = exp / 10;
 
    exp = exp / 10;
 
    buffer[1] = (exp % 10) + '0';
 
    buffer[1] = (exp % 10) + '0';
 
    exp = exp / 10;
 
    exp = exp / 10;
 
    buffer[0] = (exp % 10) + '0';
 
    buffer[0] = (exp % 10) + '0';
 
    buffer += 3;
 
    buffer += 3;
 
  }
 
        } else if (fmt == 'f') {
 
  else if (fmt == 'f')
 
 
 
  {
 
 
 
    digits = fcvtbuf(value, precision, &decpt, &sign, cvtbuf);
 
    digits = fcvtbuf(value, precision, &decpt, &sign, cvtbuf);
 
    if (sign) *buffer++ = '-';
 
                if (sign)
 
    if (*digits)
 
                        *buffer++ = '-';
 
    {
 
                if (*digits) {
 
      if (decpt <= 0)
 
                        if (decpt <= 0) {
 
      {
 
 
 
        *buffer++ = '0';
 
        *buffer++ = '0';
 
        *buffer++ = '.';
 
        *buffer++ = '.';
 
        for (pos = 0; pos < -decpt; pos++) *buffer++ = '0';
 
                                for (pos = 0; pos < -decpt; pos++)
 
        while (*digits) *buffer++ = *digits++;
 
                                        *buffer++ = '0';
 
      }
 
 
 
      else
 
 
 
      {
 
 
 
        pos = 0;
 
 
 
        while (*digits)
 
        while (*digits)
 
        {
 
                                        *buffer++ = *digits++;
 
          if (pos++ == decpt) *buffer++ = '.';
 
                        } else {
 
 
 
                                pos = 0;
 
 
 
                                while (*digits) {
 
 
 
                                        if (pos++ == decpt)
 
 
 
                                                *buffer++ = '.';
 
          *buffer++ = *digits++;
 
          *buffer++ = *digits++;
 
        }
 
        }
 
      }
 
      }
 
    }
 
                } else {
 
    else
 
 
 
    {
 
 
 
      *buffer++ = '0';
 
      *buffer++ = '0';
 
      if (precision > 0)
 
                        if (precision > 0) {
 
      {
 
 
 
        *buffer++ = '.';
 
        *buffer++ = '.';
 
        for (pos = 0; pos < precision; pos++) *buffer++ = '0';
 
                                for (pos = 0; pos < precision; pos++)
 
 
 
                                        *buffer++ = '0';
 
      }
 
      }
 
    }
 
    }
 
  }
 
  }
 
 
 
 
 
  *buffer = '\0';
 
  *buffer = '\0';
 
}
 
}
 
 
 
 
 
static void decimal_point(char *buffer)
 
static void decimal_point(char *buffer)
 
{
 
{
 
  while (*buffer)
 
        while (*buffer) {
 
  {
 
                if (*buffer == '.')
 
    if (*buffer == '.') return;
 
                        return;
 
    if (*buffer == 'e' || *buffer == 'E') break;
 
                if (*buffer == 'e' || *buffer == 'E')
 
 
 
                        break;
 
    buffer++;
 
    buffer++;
 
  }
 
  }
 
 
 
 
 
  if (*buffer)
 
        if (*buffer) {
 
  {
 
 
 
    int n = strnlen(buffer,256);
 
    int n = strnlen(buffer,256);
 
    while (n > 0)
 
                while (n > 0) {
 
    {
 
 
 
      buffer[n + 1] = buffer[n];
 
      buffer[n + 1] = buffer[n];
 
      n--;
 
      n--;
 
    }
 
    }
 
 
 
 
 
    *buffer = '.';
 
    *buffer = '.';
 
  }
 
        } else {
 
  else
 
 
 
  {
 
 
 
    *buffer++ = '.';
 
    *buffer++ = '.';
 
    *buffer = '\0';
 
    *buffer = '\0';
 
  }
 
  }
 
}
 
}
 
 
 
 
 
static void cropzeros(char *buffer)
 
static void cropzeros(char *buffer)
 
{
 
{
 
  char *stop;
 
  char *stop;
 
 
 
 
 
  while (*buffer && *buffer != '.') buffer++;
 
        while (*buffer && *buffer != '.')
 
  if (*buffer++)
 
                buffer++;
 
  {
 
        if (*buffer++) {
 
    while (*buffer && *buffer != 'e' && *buffer != 'E') buffer++;
 
                while (*buffer && *buffer != 'e' && *buffer != 'E')
 
 
 
                        buffer++;
 
    stop = buffer--;
 
    stop = buffer--;
 
    while (*buffer == '0') buffer--;
 
                while (*buffer == '0')
 
    if (*buffer == '.') buffer--;
 
                        buffer--;
 
 
 
                if (*buffer == '.')
 
 
 
                        buffer--;
 
    while (buffer!=stop)
 
    while (buffer!=stop)
 
                *++buffer=0;
 
                *++buffer=0;
 
  }
 
  }
 
}
 
}
 
 
 
 
 
static char *flt(char *str, double num, int size, int precision, char fmt, int flags)
 
static char *flt(char *str, double num, int size, int precision, char fmt,
 
 
 
                 int flags)
 
{
 
{
 
  char tmp[80];
 
  char tmp[80];
 
  char c, sign;
 
  char c, sign;
 
  int n, i;
 
  int n, i;
 
 
 
 
 
  // Left align means no zero padding
 
  // Left align means no zero padding
 
  if (flags & LEFT) flags &= ~ZEROPAD;
 
        if (flags & LEFT)
 
 
 
                flags &= ~ZEROPAD;
 
 
 
 
 
  // Determine padding and sign char
 
  // Determine padding and sign char
 
  c = (flags & ZEROPAD) ? '0' : ' ';
 
  c = (flags & ZEROPAD) ? '0' : ' ';
 
  sign = 0;
 
  sign = 0;
 
  if (flags & SIGN)
 
        if (flags & SIGN) {
 
  {
 
                if (num < 0.0) {
 
    if (num < 0.0)
 
 
 
    {
 
 
 
      sign = '-';
 
      sign = '-';
 
      num = -num;
 
      num = -num;
 
      size--;
 
      size--;
 
    }
 
                } else if (flags & PLUS) {
 
    else if (flags & PLUS)
 
 
 
    {
 
 
 
      sign = '+';
 
      sign = '+';
 
      size--;
 
      size--;
 
    }
 
                } else if (flags & SPACE) {
 
    else if (flags & SPACE)
 
 
 
    {
 
 
 
      sign = ' ';
 
      sign = ' ';
 
      size--;
 
      size--;
 
    }
 
    }
 
  }
 
  }
 
 
 
 
 
  // Compute the precision value
 
  // Compute the precision value
 
  if (precision < 0)
 
  if (precision < 0)
 
    precision = 6; // Default precision: 6
 
    precision = 6; // Default precision: 6
 
 
 
 
 
  // Convert floating point number to text
 
  // Convert floating point number to text
 
  parse_float(num, tmp, fmt, precision);
 
  parse_float(num, tmp, fmt, precision);
 
 
 
 
 
  if ((flags & HEX_PREP) && precision == 0) decimal_point(tmp);
 
        if ((flags & HEX_PREP) && precision == 0)
 
  if (fmt == 'g' && !(flags & HEX_PREP)) cropzeros(tmp);
 
                decimal_point(tmp);
 
 
 
        if (fmt == 'g' && !(flags & HEX_PREP))
 
 
 
                cropzeros(tmp);
 
 
 
 
 
  n = strnlen(tmp,256);
 
  n = strnlen(tmp,256);
 
 
 
 
 
  // Output number with alignment and padding
 
  // Output number with alignment and padding
 
  size -= n;
 
  size -= n;
 
  if (!(flags & (ZEROPAD | LEFT))) while (size-- > 0) *str++ = ' ';
 
        if (!(flags & (ZEROPAD | LEFT)))
 
  if (sign) *str++ = sign;
 
                while (size-- > 0)
 
  if (!(flags & LEFT)) while (size-- > 0) *str++ = c;
 
                        *str++ = ' ';
 
  for (i = 0; i < n; i++) *str++ = tmp[i];
 
        if (sign)
 
  while (size-- > 0) *str++ = ' ';
 
                *str++ = sign;
 
 
 
        if (!(flags & LEFT))
 
 
 
                while (size-- > 0)
 
 
 
                        *str++ = c;
 
 
 
        for (i = 0; i < n; i++)
 
 
 
                *str++ = tmp[i];
 
 
 
        while (size-- > 0)
 
 
 
                *str++ = ' ';
 
 
 
 
 
  return str;
 
  return str;
 
}
 
}
 
 
 
 
 
#endif
 
#endif
Line 430... Line 432... 
 
 
 
 
  int field_width;      // Width of output field
 
  int field_width;      // Width of output field
 
  int precision;        // Min. # of digits for integers; max number of chars for from string
 
  int precision;        // Min. # of digits for integers; max number of chars for from string
 
  int qualifier;        // 'h', 'l', or 'L' for integer fields
 
  int qualifier;        // 'h', 'l', or 'L' for integer fields
 
 
 
 
 
  for (str = buf; *fmt; fmt++)
 
        for (str = buf; *fmt; fmt++) {
 
  {
 
                if (*fmt != '%') {
 
    if (*fmt != '%')
 
 
 
    {
 
 
 
      *str++ = *fmt;
 
      *str++ = *fmt;
 
      continue;
 
      continue;
 
    }
 
    }
 
 
 
 
 
    // Process flags
 
    // Process flags
 
    flags = 0;
 
    flags = 0;
 
repeat:
 
repeat:
 
    fmt++; // This also skips first '%'
 
    fmt++; // This also skips first '%'
 
    switch (*fmt)
 
                switch (*fmt) {
 
    {
 
                case '-':
 
      case '-': flags |= LEFT; goto repeat;
 
                        flags |= LEFT;
 
      case '+': flags |= PLUS; goto repeat;
 
                        goto repeat;
 
      case ' ': flags |= SPACE; goto repeat;
 
                case '+':
 
      case '#': flags |= HEX_PREP; goto repeat;
 
                        flags |= PLUS;
 
      case '0': flags |= ZEROPAD; goto repeat;
 
                        goto repeat;
 
 
 
                case ' ':
 
 
 
                        flags |= SPACE;
 
 
 
                        goto repeat;
 
 
 
                case '#':
 
 
 
                        flags |= HEX_PREP;
 
 
 
                        goto repeat;
 
 
 
                case '0':
 
 
 
                        flags |= ZEROPAD;
 
 
 
                        goto repeat;
 
    }
 
    }
 
 
 
 
 
    // Get field width
 
    // Get field width
 
    field_width = -1;
 
    field_width = -1;
 
    if (is_digit(*fmt))
 
    if (is_digit(*fmt))
 
      field_width = skip_atoi(&fmt);
 
      field_width = skip_atoi(&fmt);
 
    else if (*fmt == '*')
 
                else if (*fmt == '*') {
 
    {
 
 
 
      fmt++;
 
      fmt++;
 
      field_width = va_arg(args, int);
 
      field_width = va_arg(args, int);
 
      if (field_width < 0)
 
                        if (field_width < 0) {
 
      {
 
 
 
        field_width = -field_width;
 
        field_width = -field_width;
 
        flags |= LEFT;
 
        flags |= LEFT;
 
      }
 
      }
 
    }
 
    }
 
 
 
 
 
    // Get the precision
 
    // Get the precision
 
    precision = -1;
 
    precision = -1;
 
    if (*fmt == '.')
 
                if (*fmt == '.') {
 
    {
 
 
 
      ++fmt;
 
      ++fmt;
 
      if (is_digit(*fmt))
 
      if (is_digit(*fmt))
 
        precision = skip_atoi(&fmt);
 
        precision = skip_atoi(&fmt);
 
      else if (*fmt == '*')
 
                        else if (*fmt == '*') {
 
      {
 
 
 
        ++fmt;
 
        ++fmt;
 
        precision = va_arg(args, int);
 
        precision = va_arg(args, int);
 
      }
 
      }
 
      if (precision < 0) precision = 0;
 
                        if (precision < 0)
 
 
 
                                precision = 0;
 
    }
 
    }
 
 
 
 
 
    // Get the conversion qualifier
 
    // Get the conversion qualifier
 
    qualifier = -1;
 
    qualifier = -1;
 
    if (*fmt == 'l' || *fmt == 'L')
 
                if (*fmt == 'l' || *fmt == 'L') {
 
    {
 
 
 
      qualifier = *fmt;
 
      qualifier = *fmt;
 
      fmt++;
 
      fmt++;
 
    }
 
    }
 
 
 
 
 
    // Default base
 
    // Default base
 
    base = 10;
 
    base = 10;
 
 
 
 
 
    switch (*fmt)
 
                switch (*fmt) {
 
    {
 
 
 
      case 'c':
 
      case 'c':
 
        if (!(flags & LEFT)) while (--field_width > 0) *str++ = ' ';
 
                        if (!(flags & LEFT))
 
 
 
                                while (--field_width > 0)
 
 
 
                                        *str++ = ' ';
 
        *str++ = (unsigned char) va_arg(args, int);
 
        *str++ = (unsigned char) va_arg(args, int);
 
        while (--field_width > 0) *str++ = ' ';
 
                        while (--field_width > 0)
 
 
 
                                *str++ = ' ';
 
        continue;
 
        continue;
 
 
 
 
 
      case 's':
 
      case 's':
 
        s = va_arg(args, char *);
 
        s = va_arg(args, char *);
 
        if (!s) s = "<NULL>";
 
                        if (!s)
 
 
 
                                s = "<NULL>";
 
        len = strnlen(s, precision);
 
        len = strnlen(s, precision);
 
        if (!(flags & LEFT)) while (len < field_width--) *str++ = ' ';
 
                        if (!(flags & LEFT))
 
        for (i = 0; i < len; ++i) *str++ = *s++;
 
                                while (len < field_width--)
 
        while (len < field_width--) *str++ = ' ';
 
                                        *str++ = ' ';
 
 
 
                        for (i = 0; i < len; ++i)
 
 
 
                                *str++ = *s++;
 
 
 
                        while (len < field_width--)
 
 
 
                                *str++ = ' ';
 
        continue;
 
        continue;
 
 
 
 
 
      case 'p':
 
      case 'p':
 
        if (field_width == -1)
 
                        if (field_width == -1) {
 
        {
 
 
 
          field_width = 2 * sizeof(void *);
 
          field_width = 2 * sizeof(void *);
 
          flags |= ZEROPAD;
 
          flags |= ZEROPAD;
 
        }
 
        }
 
        str = number(str, (unsigned long) va_arg(args, void *), 16, field_width, precision, flags);
 
                        str =
 
 
 
                            number(str, (unsigned long)va_arg(args, void *), 16,
 
 
 
                                   field_width, precision, flags);
 
        continue;
 
        continue;
 
 
 
 
 
      case 'A':
 
      case 'A':
 
        flags |= UPPERCASE;
 
        flags |= UPPERCASE;
 
 
 
 
 
      case 'a':
 
      case 'a':
 
        if (qualifier == 'l')
 
        if (qualifier == 'l')
 
          str = eaddr(str, va_arg(args, unsigned char *), field_width, precision, flags);
 
                                str =
 
        else
 
                                    eaddr(str, va_arg(args, unsigned char *),
 
          str = iaddr(str, va_arg(args, unsigned char *), field_width, precision, flags);
 
                                          field_width, precision, flags);
 
 
 
                        else
 
 
 
                                str =
 
 
 
                                    iaddr(str, va_arg(args, unsigned char *),
 
 
 
                                          field_width, precision, flags);
 
        continue;
 
        continue;
 
 
 
 
 
      // Integer number formats - set up the flags and "break"
 
      // Integer number formats - set up the flags and "break"
 
      case 'o':
 
      case 'o':
 
        base = 8;
 
        base = 8;
Line 550... Line 563... 
        break;
 
        break;
 
 
 
 
 
#ifdef HAS_FLOAT
 
#ifdef HAS_FLOAT
 
 
 
 
 
      case 'f':
 
      case 'f':
 
        str = flt(str, va_arg(args, double), field_width, precision, *fmt, flags | SIGN);
 
                        str =
 
 
 
                            flt(str, va_arg(args, double), field_width,
 
 
 
                                precision, *fmt, flags | SIGN);
 
        continue;
 
        continue;
 
 
 
 
 
#endif
 
#endif
 
 
 
 
 
      default:
 
      default:
 
        if (*fmt != '%') *str++ = '%';
 
                        if (*fmt != '%')
 
 
 
                                *str++ = '%';
 
        if (*fmt)
 
        if (*fmt)
 
          *str++ = *fmt;
 
          *str++ = *fmt;
 
        else
 
        else
 
          --fmt;
 
          --fmt;
 
        continue;
 
        continue;
Line 578... Line 594... 
 
 
 
 
  *str = '\0';
 
  *str = '\0';
 
  return str - buf;
 
  return str - buf;
 
}
 
}
 
 
 
 
 
void uart_send_char(char c) {
 
void uart_send_char(char c)
 
 
 
{
 
 
 
 
 
  uart_putc(c);
 
  uart_putc(c);
 
 
 
 
 
}
 
}
 
 
 
 
 
int ee_printf(const char *fmt, ...)
 
int ee_printf(const char *fmt, ...)
 
{
 
{
 
  char buf[256],*p;
 
        char buf[256], *p;
 
  va_list args;
 
  va_list args;
 
  int n=0;
 
  int n=0;
 
 
 
 
 
  va_start(args, fmt);
 
  va_start(args, fmt);
 
  ee_vsprintf(buf, fmt, args);
 
  ee_vsprintf(buf, fmt, args);
Line 603... Line 620... 
  }
 
  }
 
 
 
 
 
  return n;
 
  return n;
 
}
 
}
 
 
 
 
 
 
 
 
 
 No newline at end of file
 
 No newline at end of file

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.