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

Subversion Repositories openrisc_me

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

Go to most recent revision | 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.