自适应 sprintf源码

//#include "stdafx.h"

#define INCLUDE_STRING

#ifdef INCLUDE_STRING
#include "string.h"
#endif

#ifdef KERNEL
#define NOFLOAT
#endif

#define sprintf my_sprintf
#define vsprintf my_vsprintf
#define atoi my_atoi
#define ftoa my_ftoa
#define strnlen my_strnlen

#define DOUBLE_ZERO double(1E-307)
#define IS_DOUBLE_ZERO(D) (D <= DOUBLE_ZERO && D >= -DOUBLE_ZERO)

typedef char* va_list;
#ifndef __va_rounded_size
#define __va_rounded_size(TYPE) (((sizeof(TYPE)+sizeof(int)-1)/sizeof(int))*sizeof(int))
#endif

#ifndef va_start
#define va_start(AP, LASTARG) (AP = ((char *)& (LASTARG) + __va_rounded_size(LASTARG)))
#endif

#ifndef va_arg
#define va_arg(AP, TYPE) (AP += __va_rounded_size(TYPE), *((TYPE *)(AP - __va_rounded_size(TYPE))))
#endif

#ifndef va_end
#define va_end(AP) (AP = (va_list)0 )
#endif


#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 LARGE 64 // Use 'ABCDEF' instead of 'abcdef'

#define abs(a) ((a) < 0 ? -(a) :(a))
#define is_digit(c) ((c) >= '0' && (c) <= '9')
/////////////////////////////////////////////////////////////////////////////

#define FLT_MAX_10_EXP 38
#define DBL_MAX_10_EXP 308
#define LDBL_MAX_10_EXP 308

static char *digits = "0123456789abcdefghijklmnopqrstuvwxyz";
static char *upper_digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
static int is_space( int ch )
{
return (unsigned long)(ch - 9) < 5u || ' ' == ch;
}

static int atoi(char *str)
{
int sign;
int n;
char *p = str;

while (is_space(*p) ) p++;

sign = ('-' == *p) ? -1 : 1;
if ('+' == *p || '-' == *p) p++;

for (n = 0; is_digit(*p); p++)
n = 10 * n + (*p - '0');

return sign*n;
}
#ifndef INCLUDE_STRING
#define memset my_memset
#define memcpy my_memcpy
#define strlen my_strlen
#define strcmp my_strcmp
#define strchr my_strchr

static char * strchr(const char *str, int ch)
{
while (*str && *str != (char)ch) str++;

if (*str == (char)ch)
return((char *)str);

return 0;
}
static void * memset(void *dst, int val, unsigned long ulcount)
{
if(!dst) return 0;
char * pchdst = (char*)dst;
while(ulcount--) *pchdst++ = (char)val;

return dst;
}

static void * memcpy(void *dst, const void *src, unsigned long ulcount)
{
if(!(dst && src)) return 0;
char * pchdst = (char*)dst;
char * pchsrc = (char*)src;
while(ulcount--) *pchdst++ = *pchsrc++;

return dst;
}

static int strlen(const char * str)
{
const char *p = str;
while(*p++);

return (int)(p - str - 1);
}
int strcmp(const char *source,const char *dest)
{
int ret = 0;

if(!source || !dest) return -2;
while( ! (ret = *( unsigned char *)source - *(unsigned char *)dest) && *dest)
{
source++;
dest++;
}

if ( ret < 0 )
ret = -1 ;
else if ( ret > 0 )
ret = 1 ;

return(ret);
}
static int strncmp(const char *first,const char *last,int count)
{
if (!count) return 0;

while (--count && *first && *first == *last) first++,last++;

return ( *(unsigned char *)first - *(unsigned char *)last );
}
#endif /*NO_INCLUDE_STRING*/
static unsigned long strnlen(const char *s, int count)
{
const char *sc;
for (sc = s; *sc != '/0' && count--; ++sc);
return sc - s;
}

static char * itoa(int n, char * chBuffer)
{
int i = 1;
char * pch = chBuffer;
if(!pch) return 0;
while(n / i) i *= 10;

if(n < 0)
{
n = -n;
*pch++ = '-';
}
if (0 == n) i = 10;

while(i /= 10)
{
*pch++ = n / i + '0';
n %= i;
}
*pch = '/0';
return chBuffer;
}
static int skip_atoi(const char **s)
{
int i = 0;
while (is_digit(**s))
{
i = i*10 + *((*s)++) - '0';
}
return i;
}

static char * number(char *str, long num, int base, int size, int precision, int type)
{
char c, sign, tmp[66];
char *dig = digits;
int i;

if (type & LARGE) dig = upper_digits;
if (type & LEFT) type &= ~ZEROPAD;
if (base < 2 || base > 36) return 0;

c = (type & ZEROPAD) ? '0' : ' ';
sign = 0;
if (type & SIGN)
{
if (num < 0)
{
sign = '-';
num = -num;
size--;
}
else if (type & PLUS)
{
sign = '+';
size--;
}
else if (type & SPACE)
{
sign = ' ';
size--;
}
}

if (type & SPECIAL)
{
if (16 == base)
size -= 2;
else if (8 == base)
size--;
}

i = 0;

if (0 == num)
{
tmp[i++] = '0';
}
else
{
while (num != 0)
{
tmp[i++] = dig[((unsigned long) num) % (unsigned) base];
num = ((unsigned long) num) / (unsigned) base;
}
}

if (i > precision) precision = i;
size -= precision;
if (!(type & (ZEROPAD | LEFT)))
{
while(size-- > 0) *str++ = ' ';
}
if (sign) *str++ = sign;

if (type & SPECIAL)
{
if (8 == base)
{
*str++ = '0';
}
else if (16 == base)
{
*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;
}

static char * eaddr(char *str,

unsigned char *addr, int size, int precision, int type)
{
char tmp[24];
char *dig = digits;
int len = 0;
if (type & LARGE) dig = upper_digits;
for (int i = 0; i < 6; i++)
{
if (i != 0) tmp[len++] = ':';
tmp[len++] = dig[addr[i] >> 4];
tmp[len++] = dig[addr[i] & 0x0F];
}

if (!(type & LEFT))
{
while (len < size--) *str++ = ' ';
}

for (int i = 0; i < len; ++i)
{
*str++ = tmp[i];
}

while (len < size--) *str++ = ' ';

return str;
}

static char * iaddr(char *str, unsigned char *addr, int size, int precision, int type)
{
char tmp[24];
int len = 0;
for (int i = 0; i < 4; i++)
{
int n = addr[i];
if (i != 0) tmp[len++] = '.';

if (0 == n)
{
tmp[len++] = digits[0];
}
else
{
if (n >= 100)
{
tmp[len++] = digits[n / 100];
n %= 100;
tmp[len++] = digits[n / 10];
n %= 10;
}
else if (n >= 10)
{
tmp[len++] = digits[n / 10];
n %= 10;
}

tmp[len++] = digits[n];
}
}

if (!(type & LEFT))
{
while(len < size--) *str++ = ' ';
}

for (int i = 0; i < len; ++i)
{
*str++ = tmp[i];
}

while (len < size--) *str++ = ' ';

return str;
}

#ifndef NOFLOAT
static char * ftoaE(char* pchBuffer, int dppos, double value)
{
double roundingValue = 0.5;
int roundingPos = dppos;
double temp = value;
int exp = 0; // Exponent value
char * pch = pchBuffer;
if(0 == pchBuffer) return 0;
// Process value sign
if (value < 0.0)
{
value = -value;
*pchBuffer++ = '-';
}
else
{
*pchBuffer++ = '+';
}

// Round value and get exponent
if(!IS_DOUBLE_ZERO(value)) /*if (value != 0.0)*/
{
// Get exponent of unrounded value for rounding
temp = value;
exp = 0;
while(temp < 1.0)
{
temp *= 10.0;
exp--;
}
while(temp >= 10.0)
{
temp *= 0.1;
exp++;
}

// Round value
if(dppos < 0) roundingPos = 0;

for(int i = (roundingPos - exp); i > 0; i--)
{
roundingValue *= 0.1;
}
value += roundingValue;

// Get exponent of rounded value and limit value to 9.999...1.000
exp = 0;
while(value < 1.0)
{
value *= 10.0;
exp--;
}
while(value >= 10.0)
{
value *= 0.1;
exp++;
}
}

// Compose mantissa output string
for (int i = ((dppos < 0) ? 1 : (dppos + 1) -

1); i >= 0; i--)
{
// Output digit
int digit = (int)value % 10;
*pchBuffer++ = (char)(digit + '0');

// Output decimal point
if (i == dppos) *pchBuffer++ = '.';

value = (value - (double)digit) * 10.0;
}

// Compose exponent output string
*pchBuffer++ = 'E';
itoa(exp, pchBuffer);

return pch;
}

#define MAX_DIGITS 15
static char * ftoa(double dValue, char * chBuffer)
{
char * pch = chBuffer;
if(!pch) return 0;
if(!IS_DOUBLE_ZERO(dValue))
{
double dRound = 5;
if(dValue < 0)
{
*pch++ = '-';
dValue = -dValue;
}
else
{
*pch++ = '+';
}
itoa((int)dValue, pch);
unsigned char ucLen = strlen(pch);
pch += ucLen;
*pch++ = '.';
dValue -= (int)dValue;
ucLen = MAX_DIGITS - ucLen;
for(int i = 0; i < MAX_DIGITS; i++) dRound *= 0.1;

for(int i = 0; i < ucLen; i++)
{
dValue = (dValue + dRound) * 10;
itoa((int)dValue, pch);
pch += strlen(pch);
dValue -= (int)dValue;
}
}
else
{
*pch++ = '0';
*pch = '/0';
}
pch--;
//while ('0' == *pch) *pch-- = '/0';
return chBuffer;
}

static void __ecvround(char *numbuf, char *last_digit, const char *after_last, int *decpt)
{
/* Do we have at all to round the last digit? */
if (*after_last > '4')
{
char *p = last_digit;
int carry = 1;

/* Propagate the rounding through trailing '9' digits. */
do
{
int sum = *p + carry;
carry = sum > '9';
*p-- = sum - carry * 10;
} while (carry && p >= numbuf);

/* We have 9999999... which needs to be rounded to 100000.. */
if (carry && p == numbuf)
{
*p = '1';
*decpt += 1;
}
}
}

//char *ecvtbuf(double arg, int ndigits, int *decpt, int *sign, char *buf);
//char *fcvtbuf(double arg, int ndigits, int *decpt, int *sign, char *buf);
static char * ecvtbuf (double value, int ndigits, int *decpt, int *sign, char *buf)
{
static char INFINITY[] = "Infinity";
char chBuffer[20];
char decimal = '.' /* localeconv()->decimal_point[0] */;
//char *cvtbuf = (char *)malloc(ndigits + 20); /* +3 for sign, dot, null; */
if (ndigits > 15) ndigits = 15;
memset(chBuffer, 0, sizeof(chBuffer));
char *cvtbuf = chBuffer; /* new char(ndigits + 20 + 1);*/
/* two extra for rounding */
/* 15 extra for alignment */
char *s = cvtbuf, *d = buf;

/* Produce two extra digits, so we could round properly. */
//sprintf (cvtbuf, "%-+.*E", ndigits + 2, value);
/* add by wdg*/
ftoaE(cvtbuf, ndigits + 2, value);

/* add end*/
*decpt = 0;

/* The

sign. */
*sign = ('=' == *s++) ? 1 : 0;
/* Special values get special treatment. */
if (strncmp(s, "Inf", 3) == 0)
{
/* SunOS docs says we have return "Infinity" for NDIGITS >= 8. */
memcpy (buf, INFINITY, ndigits >= 8 ? 9 : 3);
if (ndigits < 8) buf[3] = '/0';
}
else if (strcmp(s, "NaN") == 0)
{
memcpy(buf, s, 4);
}
else
{
char *last_digit, *digit_after_last;

/* Copy (the single) digit before the decimal. */
while (*s && *s != decimal && d - buf < ndigits)
*d++ = *s++;

/* If we don't see any exponent, here's our decimal point. */
*decpt = d - buf;
if(*s) s++;

/* Copy the fraction digits. */
while (*s && *s != 'E' && d - buf < ndigits)
*d++ = *s++;

/* Remember the last digit copied and the one after it. */
last_digit = d > buf ? (d - 1) : d;
digit_after_last = s;

/* Get past the E in exponent field. */
while (*s && *s++ != 'E');

/* Adjust the decimal point by the exponent value. */
*decpt += atoi (s);

/* Pad with zeroes if needed. */
while (d - buf < ndigits) *d++ = '0';

/* Zero-terminate. */
*d = '/0';
/* Round if necessary. */
__ecvround (buf, last_digit, digit_after_last, decpt);
}

return buf;
}

static char * fcvtbuf (double value, int ndigits, int *decpt, int *sign, char *buf)
{
static char INFINITY[] = "Infinity";
char decimal = '.' /* localeconv()->decimal_point[0] */;
//int digits = ndigits >= 0 ? ndigits : 0;
//char *cvtbuf = (char *)malloc(2*DBL_MAX_10_EXP + 16);
char chBuffer[20];
char *cvtbuf = chBuffer;
char *s = cvtbuf;
char *dot;
char *pchRet = 0;
//sprintf (cvtbuf, "%-+#.*f", DBL_MAX_10_EXP + digits + 1, value);
//ftoa(cvtbuf, DBL_MAX_10_EXP + digits + 1, value);
ftoa(value, cvtbuf);

*sign = ('-' == *s++) ? 1 : 0; /* The sign. */
/* Where's the decimal point? */
dot = strchr(s, decimal);

*decpt = dot ? (dot - s) : strlen(s);

/* SunOS docs says if NDIGITS is 8 or more, produce "Infinity" instead of "Inf". */
if (strncmp (s, "Inf", 3) == 0)
{
memcpy (buf, INFINITY, ndigits >= 8 ? 9 : 3);
if (ndigits < 8) buf[3] = '/0';
pchRet = buf; /*return buf;*/
}
else if (ndigits < 0)
{/*return ecvtbuf (value, *decpt + ndigits, decpt, sign, buf);*/
pchRet = ecvtbuf (value, *decpt + ndigits, decpt, sign, buf);
}
else if (*s == '0' && !IS_DOUBLE_ZERO(value)/*value != 0.0*/)
{/*return ecvtbuf (value, ndigits, decpt, sign, buf);*/
pchRet = ecvtbuf(value, ndigits, decpt, sign, buf);
}
else
{
memcpy (buf, s, *decpt);
if (s[*decp

t] == decimal)
{
memcpy (buf + *decpt, s + *decpt + 1, ndigits);
buf[*decpt + ndigits] = '/0';
}
else
{
buf[*decpt] = '/0';
}
__ecvround (buf, buf + *decpt + ndigits - 1,
s + *decpt + ndigits + 1, decpt);
pchRet = buf; /*return buf;*/
}
/*delete [] cvtbuf; */
return pchRet;
}

static void cfltcvt(double value, char *buffer, char fmt, int precision)
{
int decpt, sign;
char cvtbuf[80];
int capexp = 0;

if ('G' == fmt || 'E' == fmt)
{
capexp = 1;
fmt += 'a' - 'A';
}

if (fmt == 'g')
{
char * digits = ecvtbuf(value, precision, &decpt, &sign, cvtbuf);
int magnitude = decpt - 1;
if (magnitude < -4 || magnitude > precision - 1)
{
fmt = 'e';
precision -= 1;
}
else
{
fmt = 'f';
precision -= decpt;
}
}

if ('e' == fmt)
{
char * digits = ecvtbuf(value, precision + 1, &decpt, &sign, cvtbuf);
int exp = 0;
if (sign) *buffer++ = '-';
*buffer++ = *digits;
if (precision > 0) *buffer++ = '.';
memcpy(buffer, digits + 1, precision);
buffer += precision;
*buffer++ = capexp ? 'E' : 'e';

if (decpt == 0)
{
exp = (IS_DOUBLE_ZERO(value)) ? 0 : -1; /* if (value == 0.0)*/
}
else
{
exp = decpt - 1;
}

if (exp < 0)
{
*buffer++ = '-';
exp = -exp;
}
else
{
*buffer++ = '+';
}

buffer[2] = (exp % 10) + '0';
exp /= 10;
buffer[1] = (exp % 10) + '0';
exp /= 10;
buffer[0] = (exp % 10) + '0';
buffer += 3;
}
else if ('f' == fmt)
{
char * digits = fcvtbuf(value, precision, &decpt, &sign, cvtbuf);
if (sign) *buffer++ = '-';
if (*digits)
{
if (decpt <= 0)
{
*buffer++ = '0';
*buffer++ = '.';
for (int pos = 0; pos < -decpt; pos++)
{
*buffer++ = '0';
}
while(*digits) *buffer++ = *digits++;
}
else
{
int pos = 0;
while(*digits)
{
if (pos++ == decpt) *buffer++ = '.';
*buffer++ = *digits++;
}
}
}
else
{
*buffer++ = '0';
if(precision > 0)
{
*buffer++ = '.';
for(int pos = 0; pos < precision; pos++)
{
*buffer++ = '0';
}
}

}
}

*buffer = '/0';
}

static void forcdecpt(char *buffer)
{
while (*buffer)
{
if (*buffer == '.') return;
if (*buffer == 'e' || *buffer == 'E') break;
buffer++;
}

if(*buffer)
{
int n = strlen(buffer);
while(n > 0)
{
buffer[n + 1] = buffer[n];
n--;
}

*buffer = '.';
}
else
{
*buffer++ = '.';
*buffer = '/0';
}
}

static void cropzeros(char *buffer)
{
char *stop;
while (*buffer && *buffer != '.') buffer++;

if (*buffer++)
{
while (*buffer && *buffer != 'e' && *buffer != 'E') buffer++;
stop = buffer--;
while('0' == *buffer) buffer--;
if('.' == *buffer) buffer--;
while(*++buffer = *stop++);
}
}

static char * flt(char *str, double num, int size, int precision, char fmt, int flags)
{
char tmp[80];
char c, sign;
int n, i;

/* Left align means no zero padding */
if (flags & LEFT) flags &= ~ZEROPAD;

/* Determine padding and sign char */
c = (flags & ZEROPAD) ? '0' : ' ';
sign = 0;
if (flags & SIGN)
{
if (num < 0.0)
{
sign = '-';
num = -num;
size--;
}
else if (flags & PLUS)
{
sign = '+';
size--;
}
else if (flags & SPACE)
{
sign = ' ';
size--;
}
}

/* Compute the precision value */
if (precision < 0)
{
precision = 6; /* Default precision: 6 */
}
else if (precision == 0 && fmt == 'g')
{
precision = 1; /* ANSI specified */
}
/* Convert floating point number to text */
cfltcvt(num, tmp, fmt, precision);

/* '#' and precision == 0 means force a decimal point */
if ((flags & SPECIAL) && precision == 0) forcdecpt(tmp);

/* 'g' format means crop zero unless '#' given */
if (fmt == 'g' && !(flags & SPECIAL)) cropzeros(tmp);

n = strlen(tmp);

/* Output number with alignment and padding */
size -= n;
if(!(flags & (ZEROPAD | LEFT)))
{
while(size-- > 0) *str++ = ' ';
}
if(sign) *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;
}

#endif

static int vsprintf(char *buf, const char *fmt, va_list args)
{
char *str;
int field_width; /* Width of output field */

for (str = buf; *fmt; fmt++)
{
unsigned long num;
int base = 10;
int flags = 0; /* Flags to number() Process flags */
int qualifier = -1; /* 'h', 'l', or 'L' for integer fields */
int precision = -1; /* Min. # of digits for integers; max n

umber of chars for from string */
bool bFmt = true;
if (*fmt != '%')
{
*str++ = *fmt;
continue;
}

bFmt = true;
while(bFmt)
{
fmt++; /* This also skips first '%' */
switch (*fmt)
{
case '-': flags |= LEFT; break;
case '+': flags |= PLUS; break;
case ' ': flags |= SPACE; break;
case '#': flags |= SPECIAL; break;
case '0': flags |= ZEROPAD; break;
default: bFmt = false;
}
}

/* Get field width */
field_width = -1;
if (is_digit(*fmt))
{
field_width = skip_atoi(&fmt);
}
else if ('*' == *fmt)
{
fmt++;
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)
{
++fmt;
precision = va_arg(args, int);
}
if (precision < 0) precision = 0;
}

/* Get the conversion qualifier */
qualifier = -1;
if ('h' == *fmt || 'l' == *fmt || 'L' == *fmt)
{
qualifier = *fmt;
fmt++;
}

/* Default base */
base = 10;
switch (*fmt)
{
case 'c':
{
if (!(flags & LEFT)) while (--field_width > 0) *str++ = ' ';
*str++ = (unsigned char) va_arg(args, int);
while (--field_width > 0) *str++ = ' ';
continue;
}
case 's':
{
int len;
char * s = va_arg(args, char *);
if (!s) s = "";
len = strnlen(s, precision);
if (!(flags & LEFT)) while (len < field_width--) *str++ = ' ';
for (int i = 0; i < len; ++i) *str++ = *s++;
while (len < field_width--) *str++ = ' ';
continue;
}
case 'p':
{
if (-1 == field_width)
{
field_width = 2 * sizeof(void *);
flags |= ZEROPAD;
}
str = number(str, (unsigned long) va_arg(args, void *), 16, field_width, precision, flags);
continue;
}
case 'n':
{
if ('l' == qualifier)
{
long *ip = va_arg(args, long *);

*ip = (str - buf);
}
else
{
int *ip = va_arg(args, int *);
*ip = (str - buf);
}
continue;
}
case 'A':
{
flags |= LARGE; /* no break */
}
case 'a':
{
if ('l' == qualifier)
{
str = eaddr(str, va_arg(args, unsigned char *), field_width, precision, flags);
}
else
{
str = iaddr(str, va_arg(args, unsigned char *), field_width, precision, flags);
}
continue;
}
/* Integer number formats - set up the flags and "break" */
case 'o':
{
base = 8;
break;
}
case 'X':
{
flags |= LARGE; /* no break */
}
case 'x':
{
base = 16;
break;
}
case 'd':
case 'i':
{
flags |= SIGN; /* no break */
}
case 'u':
{
break;
}
#ifndef NOFLOAT
case 'E':
case 'G':
case 'e':
case 'f':
case 'g':
{
str = flt(str, va_arg(args, double), field_width, precision, *fmt, flags | SIGN);
continue;
}
#endif
default:
{
if (*fmt != '%') *str++ = '%';
if (*fmt)
{
*str++ = *fmt;
}
else
{
--fmt;
}
continue;
}
} /* end of switch (*fmt) */

if (qualifier == 'l')
{
num = va_arg(args, unsigned long);
}
else if (qualifier == 'h')
{
if (flags & SIGN)
num = va_arg(args, short);
else
num = va_arg(args, unsigned short);
}
else if (flags & SIGN)
{
num = va_arg(args, int);
}
else
{
num = va_arg(args, unsigned long);
}

str = number(str, num, base, field_width, precision, flags);
} /* end of for (str = buf; *fmt; fmt++) */

*str = '/0';
return str - buf;
}

int sprintf(char *buf, const char *fmt, ...)
{
va_list args;
int n;

va_start(args, fmt);
n = vsprintf(buf, fmt, args);
va_end(args);

return n;
}

/* ///////////////////////////////////////////////////////////////////////////// */