Subversion Repositories Kolibri OS

/*

 * vsprintf - print formatted output without ellipsis on an array

 */

/* $Header$ */

//#include  "stdio.h"

//#include  

typedef unsigned size_t;

typedef struct

{

  char *_ptr;

  unsigned _count;

}__str;

#define va_start(v,l) __builtin_va_start(v,l)

#define va_end(v)	__builtin_va_end(v)

#define va_arg(v,l)	__builtin_va_arg(v,l)

#if !defined(__STRICT_ANSI__) || __STDC_VERSION__ + 0 >= 199900L

#define va_copy(d,s)	__builtin_va_copy(d,s)

#endif

#define __va_copy(d,s)	__builtin_va_copy(d,s)

typedef __builtin_va_list __gnuc_va_list;

typedef __gnuc_va_list va_list;

#define arg(x) va_arg (ap, u32)

#define	io_testflag(p,x)	((p)->_flags & (x))

char *_i_compute(unsigned long val, int base, char *s, int nrdigits);

char *_f_print(va_list *ap, int flags, char *s, char c, int precision);

void __cleanup(void);

void *calloc( size_t num, size_t size );

int memcmp(const void *s1, const void *s2, size_t n);

void * memcpy(void * _dest, const void *_src, size_t _n);

char * strcpy(char *to, const char *from);

char * strcat(char *s, const char *append);

int strcmp(const char *s1, const char *s2);

size_t strlen(const char *str);

char * strdup(const char *_s);

char * strchr(const char *s, int c);

#define	FL_LJUST	0x0001		/* left-justify field */

#define	FL_SIGN		0x0002		/* sign in signed conversions */

#define	FL_SPACE	0x0004		/* space in signed conversions */

#define	FL_ALT		0x0008		/* alternate form */

#define	FL_ZEROFILL	0x0010		/* fill with zero's */

#define	FL_SHORT	0x0020		/* optional h */

#define	FL_LONG		0x0040		/* optional l */

#define	FL_LONGDOUBLE	0x0080		/* optional L */

#define	FL_WIDTHSPEC	0x0100		/* field width is specified */

#define	FL_PRECSPEC	0x0200		/* precision is specified */

#define FL_SIGNEDCONV	0x0400		/* may contain a sign */

#define	FL_NOASSIGN	0x0800		/* do not assign (in scanf) */

#define FL_NOMORE 0x1000    /* all flags collected */

#define	_IOFBF		0x000

#define	_IOREAD		0x001

#define	_IOWRITE	0x002

#define	_IONBF		0x004

#define	_IOMYBUF	0x008

#define	_IOEOF		0x010

#define	_IOERR		0x020

#define	_IOLBF		0x040

#define	_IOREADING	0x080

#define	_IOWRITING	0x100

#define	_IOAPPEND	0x200

#define _IOFIFO		0x400

#define SGL_MAX      254  /*  standard definition */

#define	SGL_MIN		     1	/*	standard definition	*/

#define	DBL_MAX		  2046	/*	standard definition	*/

#define	DBL_MIN		     1	/*	standard definition	*/

#define EXT_MAX		 16383	/*	standard minimum	*/

#define EXT_MIN   -16382  /*  standard minimum  */

#include	

static char *cvt();

#define NDIGITS	128

unsigned char __dj_ctype_toupper[] = {

  0x00,

  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,

  0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,

  0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,

  0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,

  0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,

  0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,

  0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,

  0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,

  0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,

  0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,

  0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,

  0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,

  0x60, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,

  0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,

  0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,

  0x58, 0x59, 0x5a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,

  0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,

  0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,

  0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,

  0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,

  0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,

  0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,

  0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,

  0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,

  0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,

  0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,

  0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,

  0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,

  0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,

  0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,

  0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,

  0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff

};

#define toupper(c) (__dj_ctype_toupper[(int)(c)+1])

int (toupper)(int c)

{

  return toupper(c);

}

char *

_ecvt(value, ndigit, decpt, sign)

	double value;

	int ndigit, *decpt, *sign;

{

	return cvt(value, ndigit, decpt, sign, 1);

}

char *

_fcvt(value, ndigit, decpt, sign)

	double value;

	int ndigit, *decpt, *sign;

{

	return cvt(value, ndigit, decpt, sign, 0);

}

static struct powers_of_10 {

	double pval;

	double rpval;

	int exp;

} p10[] = {

	1.0e32, 1.0e-32, 32,

	1.0e16, 1.0e-16, 16,

	1.0e8, 1.0e-8, 8,

	1.0e4, 1.0e-4, 4,

	1.0e2, 1.0e-2, 2,

	1.0e1, 1.0e-1, 1,

	1.0e0, 1.0e0, 0

};

static char *

cvt(value, ndigit, decpt, sign, ecvtflag)

	double value;

	int ndigit, *decpt, *sign;

{

	static char buf[NDIGITS+1];

	register char *p = buf;

	register char *pe;

	if (ndigit < 0) ndigit = 0;

	if (ndigit > NDIGITS) ndigit = NDIGITS;

	pe = &buf[ndigit];

	buf[0] = '\0';

	*sign = 0;

	if (value < 0) {

		*sign = 1;

		value = -value;

	}

	*decpt = 0;

	if (value >= DBL_MAX) {

		value = DBL_MAX;

	}

	if (value != 0.0) {

		register struct powers_of_10 *pp = &p10[0];

		if (value >= 10.0) do {

			while (value >= pp->pval) {

				value *= pp->rpval;

				*decpt += pp->exp;

			}

		} while ((++pp)->exp > 0);

		pp = &p10[0];

		if (value < 1.0) do {

			while (value * pp->pval < 10.0) {

				value *= pp->pval;

				*decpt -= pp->exp;

			}

		} while ((++pp)->exp > 0);

		(*decpt)++;	/* because now value in [1.0, 10.0) */

	}

	if (! ecvtflag) {

		/* for fcvt() we need ndigit digits behind the dot */

		pe += *decpt;

		if (pe > &buf[NDIGITS]) pe = &buf[NDIGITS];

	}

	while (p <= pe) {

		*p++ = (int)value + '0';

		value = 10.0 * (value - (int)value);

	}

	if (pe >= buf) {

		p = pe;

		*p += 5;	/* round of at the end */

		while (*p > '9') {

			*p = '0';

			if (p > buf) ++*--p;

			else {

				*p = '1';

				++*decpt;

				if (! ecvtflag) {

					/* maybe add another digit at the end,

					   because the point was shifted right

					*/

					if (pe > buf) *pe = '0';

					pe++;

				}

			}

		}

		*pe = '\0';

	}

	return buf;

}

int _fp_hook = 1;

static char *

_pfloat(double r, register char *s, int n, int flags)

{

	register char *s1;

	int sign, dp;

	register int i;

	s1 = _fcvt(r, n, &dp, &sign);

	if (sign)

		*s++ = '-';

	else if (flags & FL_SIGN)

		*s++ = '+';

	else if (flags & FL_SPACE)

		*s++ = ' ';

	if (dp<=0)

		*s++ = '0';

	for (i=dp; i>0; i--)

		if (*s1) *s++ = *s1++;

		else *s++ = '0';

	if (((i=n) > 0) || (flags & FL_ALT))

		*s++ = '.';

	while (++dp <= 0) {

		if (--i<0)

			break;

		*s++ = '0';

	}

	while (--i >= 0)

		if (*s1) *s++ = *s1++;

		else *s++ = '0';

	return s;

}

static char *

_pscien(double r, register char *s, int n, int flags)

{

	int sign, dp;

	register char *s1;

	s1 = _ecvt(r, n + 1, &dp, &sign);

	if (sign)

		*s++ = '-';

	else if (flags & FL_SIGN)

		*s++ = '+';

	else if (flags & FL_SPACE)

		*s++ = ' ';

	*s++ = *s1++;

	if ((n > 0) || (flags & FL_ALT))

		*s++ = '.';

	while (--n >= 0)

		if (*s1) *s++ = *s1++;

		else *s++ = '0';

	*s++ = 'e';

	if ( r != 0 ) --dp ;

	if ( dp<0 ) {

		*s++ = '-' ; dp= -dp ;

	} else {

		*s++ = '+' ;

	}

	if (dp >= 100) {

		*s++ = '0' + (dp / 100);

		dp %= 100;

	}

	*s++ = '0' + (dp/10);

	*s++ = '0' + (dp%10);

	return s;

}

#define	NDIGINEXP(exp)		(((exp) >= 100 || (exp) <= -100) ? 3 : 2)

#define	LOW_EXP			-4

#define	USE_EXP(exp, ndigits)	(((exp) < LOW_EXP + 1) || (exp >= ndigits + 1))

static char *

_gcvt(double value, int ndigit, char *s, int flags)

{

	int sign, dp;

	register char *s1, *s2;

	register int i;

	register int nndigit = ndigit;

	s1 = _ecvt(value, ndigit, &dp, &sign);

	s2 = s;

	if (sign) *s2++ = '-';

	else if (flags & FL_SIGN)

		*s2++ = '+';

	else if (flags & FL_SPACE)

		*s2++ = ' ';

	if (!(flags & FL_ALT))

		for (i = nndigit - 1; i > 0 && s1[i] == '0'; i--)

			nndigit--;

	if (USE_EXP(dp,ndigit))	{

		/* Use E format */

		dp--;

		*s2++ = *s1++;

		if ((nndigit > 1) || (flags & FL_ALT)) *s2++ = '.';

		while (--nndigit > 0) *s2++ = *s1++;

		*s2++ = 'e';

		if (dp < 0) {

			*s2++ = '-';

			dp = -dp;

		}

		else	 *s2++ = '+';

		s2 += NDIGINEXP(dp);

		*s2 = 0;

		for (i = NDIGINEXP(dp); i > 0; i--) {

			*--s2 = dp % 10 + '0';

			dp /= 10;

		}

		return s;

	}

	/* Use f format */

	if (dp <= 0) {

		if (*s1 != '0')	{

			/* otherwise the whole number is 0 */

			*s2++ = '0';

			*s2++ = '.';

		}

		while (dp < 0) {

			dp++;

			*s2++ = '0';

		}

	}

	for (i = 1; i <= nndigit; i++) {

		*s2++ = *s1++;

		if (i == dp) *s2++ = '.';

	}

	if (i <= dp) {

		while (i++ <= dp) *s2++ = '0';

		*s2++ = '.';

	}

	if ((s2[-1]=='.') && !(flags & FL_ALT)) s2--;

	*s2 = '\0';

	return s;

}

char *

_f_print(va_list *ap, int flags, char *s, char c, int precision)

{

	register char *old_s = s;

  double ld_val;

 // if (flags & FL_LONGDOUBLE) ld_val = va_arg(*ap, double);

//  else

   ld_val = (double) va_arg(*ap, double);

	switch(c) {

	case 'f':

		s = _pfloat(ld_val, s, precision, flags);

		break;

	case 'e':

	case 'E':

		s = _pscien(ld_val, s, precision , flags);

		break;

	case 'g':

	case 'G':

		s = _gcvt(ld_val, precision, s, flags);

		s += strlen(s);

		break;

	}

	if ( c == 'E' || c == 'G') {

		while (*old_s && *old_s != 'e') old_s++;

		if (*old_s == 'e') *old_s = 'E';

	}

	return s;

}

//#endif  /* NOFLOAT */

/* $Header$ */

//#include 

//#include "../ansi/ext_fmt.h"

//void _str_ext_cvt(const char *s, char **ss, struct EXTEND *e);

//double _ext_dbl_cvt(struct EXTEND *e);

//double

//strtod(const char *p, char **pp)

//{

//  struct EXTEND e;

//  _str_ext_cvt(p, pp, &e);

//  return _ext_dbl_cvt(&e);

//}

#define BUFSIZ    4096

#define	NULL		((void *)0)

#define	EOF		(-1)

/* gnum() is used to get the width and precision fields of a format. */

static const char *

gnum(register const char *f, int *ip, va_list *app)

{

	register int	i, c;

	if (*f == '*') {

		*ip = va_arg((*app), int);

		f++;

	} else {

		i = 0;

		while ((c = *f - '0') >= 0 && c <= 9) {

			i = i*10 + c;

			f++;

		}

		*ip = i;

	}

	return f;

}

#if	_EM_WSIZE == _EM_PSIZE

#define set_pointer(flags)				/* nothing */

#elif	_EM_LSIZE == _EM_PSIZE

#define set_pointer(flags)	(flags |= FL_LONG)

#else

#error garbage pointer size

#define set_pointer(flags)		/* compilation might continue */

#endif

/* print an ordinal number */

static char *

o_print(va_list *ap, int flags, char *s, char c, int precision, int is_signed)

{

	long signed_val;

	unsigned long unsigned_val;

	char *old_s = s;

	int base;

	switch (flags & (FL_SHORT | FL_LONG)) {

	case FL_SHORT:

		if (is_signed) {

			signed_val = (short) va_arg(*ap, int);

		} else {

			unsigned_val = (unsigned short) va_arg(*ap, unsigned);

		}

		break;

	case FL_LONG:

		if (is_signed) {

			signed_val = va_arg(*ap, long);

		} else {

			unsigned_val = va_arg(*ap, unsigned long);

		}

		break;

	default:

		if (is_signed) {

			signed_val = va_arg(*ap, int);

		} else {

			unsigned_val = va_arg(*ap, unsigned int);

		}

		break;

	}

	if (is_signed) {

		if (signed_val < 0) {

			*s++ = '-';

			signed_val = -signed_val;

		} else if (flags & FL_SIGN) *s++ = '+';

		else if (flags & FL_SPACE) *s++ = ' ';

		unsigned_val = signed_val;

	}

	if ((flags & FL_ALT) && (c == 'o')) *s++ = '0';

	if (!unsigned_val && c != 'p') {

		 if (!precision)

			return s;

	} else if (((flags & FL_ALT) && (c == 'x' || c == 'X'))

		    || c == 'p') {

		*s++ = '0';

		*s++ = (c == 'X' ? 'X' : 'x');

	}

	switch (c) {

	case 'b':	base = 2;	break;

	case 'o':	base = 8;	break;

	case 'd':

	case 'i':

	case 'u':	base = 10;	break;

	case 'x':

	case 'X':

	case 'p':	base = 16;	break;

	}

	s = _i_compute(unsigned_val, base, s, precision);

	if (c == 'X')

		while (old_s != s) {

			*old_s = toupper(*old_s);

			old_s++;

		}

	return s;

}

#define putc(c, p)  (--(p)->_count >= 0 ?  (int) (*(p)->_ptr++ = (c)) : EOF)

int

_doprnt(register const char *fmt, va_list ap, __str *stream)

{

	register char	*s;

	register int	j;

	int		i, c, width, precision, zfill, flags, between_fill;

	int		nrchars=0;

	const char	*oldfmt;

  char    *s1, buf[512];

  while (c = *fmt++)

  {

    if (c != '%')

    {

      if (c == '\n')

      {

				if (putc('\r', stream) == EOF)

					return nrchars ? -nrchars : -1;

				nrchars++;

      }

			if (putc(c, stream) == EOF)

				return nrchars ? -nrchars : -1;

			nrchars++;

			continue;

		}

		flags = 0;

		do {

			switch(*fmt) {

			case '-':	flags |= FL_LJUST;	break;

			case '+':	flags |= FL_SIGN;	break;

			case ' ':	flags |= FL_SPACE;	break;

			case '#':	flags |= FL_ALT;	break;

			case '0':	flags |= FL_ZEROFILL;	break;

			default:	flags |= FL_NOMORE;	continue;

			}

			fmt++;

		} while(!(flags & FL_NOMORE));

		oldfmt = fmt;

		fmt = gnum(fmt, &width, &ap);

		if (fmt != oldfmt) flags |= FL_WIDTHSPEC;

		if (*fmt == '.') {

			fmt++; oldfmt = fmt;

			fmt = gnum(fmt, &precision, &ap);

			if (precision >= 0) flags |= FL_PRECSPEC;

		}

		if ((flags & FL_WIDTHSPEC) && width < 0) {

			width = -width;

			flags |= FL_LJUST;

		}

		if (!(flags & FL_WIDTHSPEC)) width = 0;

		if (flags & FL_SIGN) flags &= ~FL_SPACE;

		if (flags & FL_LJUST) flags &= ~FL_ZEROFILL;

		s = s1 = buf;

		switch (*fmt) {

		case 'h':	flags |= FL_SHORT; fmt++; break;

		case 'l':	flags |= FL_LONG; fmt++; break;

		case 'L':	flags |= FL_LONGDOUBLE; fmt++; break;

		}

		switch (c = *fmt++) {

		default:

      if (c == '\n') {

				if (putc('\r', stream) == EOF)

					return nrchars ? -nrchars : -1;

				nrchars++;

			}

			if (putc(c, stream) == EOF)

				return nrchars ? -nrchars : -1;

			nrchars++;

			continue;

		case 'n':

			if (flags & FL_SHORT)

				*va_arg(ap, short *) = (short) nrchars;

			else if (flags & FL_LONG)

				*va_arg(ap, long *) = (long) nrchars;

			else

				*va_arg(ap, int *) = (int) nrchars;

			continue;

		case 's':

			s1 = va_arg(ap, char *);

			if (s1 == NULL)

				s1 = "(null)";

			s = s1;

			while (precision || !(flags & FL_PRECSPEC)) {

				if (*s == '\0')

					break;

				s++;

				precision--;

			}

			break;

		case 'p':

			set_pointer(flags);

			/* fallthrough */

		case 'b':

		case 'o':

		case 'u':

		case 'x':

		case 'X':

			if (!(flags & FL_PRECSPEC)) precision = 1;

			else if (c != 'p') flags &= ~FL_ZEROFILL;

			s = o_print(&ap, flags, s, c, precision, 0);

			break;

		case 'd':

		case 'i':

			flags |= FL_SIGNEDCONV;

			if (!(flags & FL_PRECSPEC)) precision = 1;

			else flags &= ~FL_ZEROFILL;

			s = o_print(&ap, flags, s, c, precision, 1);

			break;

		case 'c':

			*s++ = va_arg(ap, int);

			break;

		case 'G':

		case 'g':

			if ((flags & FL_PRECSPEC) && (precision == 0))

				precision = 1;

		case 'f':

		case 'E':

		case 'e':

			if (!(flags & FL_PRECSPEC))

				precision = 6;

			if (precision >= sizeof(buf))

				precision = sizeof(buf) - 1;

			flags |= FL_SIGNEDCONV;

			s = _f_print(&ap, flags, s, c, precision);

			break;

    case 'r':

			ap = va_arg(ap, va_list);

			fmt = va_arg(ap, char *);

			continue;

		}

		zfill = ' ';

		if (flags & FL_ZEROFILL) zfill = '0';

		j = s - s1;

		/* between_fill is true under the following conditions:

		 * 1- the fill character is '0'

		 * and

		 * 2a- the number is of the form 0x... or 0X...

		 * or

		 * 2b- the number contains a sign or space

		 */

		between_fill = 0;

		if ((flags & FL_ZEROFILL)

		    && (((c == 'x' || c == 'X') && (flags & FL_ALT) && j > 1)

			|| (c == 'p')

			|| ((flags & FL_SIGNEDCONV)

			    && ( *s1 == '+' || *s1 == '-' || *s1 == ' '))))

			between_fill++;

		if ((i = width - j) > 0)

			if (!(flags & FL_LJUST)) {	/* right justify */

				nrchars += i;

				if (between_fill) {

				    if (flags & FL_SIGNEDCONV) {

					j--; nrchars++;

					if (putc(*s1++, stream) == EOF)

						return nrchars ? -nrchars : -1;

				    } else {

					j -= 2; nrchars += 2;

					if ((putc(*s1++, stream) == EOF)

					    || (putc(*s1++, stream) == EOF))

						return nrchars ? -nrchars : -1;

				    }

				}

				do {

					if (putc(zfill, stream) == EOF)

						return nrchars ? -nrchars : -1;

				} while (--i);

			}

		nrchars += j;

		while (--j >= 0) {

			if (putc(*s1++, stream) == EOF)

				return nrchars ? -nrchars : -1;

		}

		if (i > 0) nrchars += i;

		while (--i >= 0)

			if (putc(zfill, stream) == EOF)

				return nrchars ? -nrchars : -1;

	}

	return nrchars;

}

int

vsnprintf(char *s, size_t n, const char *format, va_list arg)

{

	int retval;

  __str tmp_stream;

  //tmp_stream._buf    = (unsigned char *) s;

	tmp_stream._ptr    = (unsigned char *) s;

	tmp_stream._count  = n-1;

	retval = _doprnt(format, arg, &tmp_stream);

	tmp_stream._count  = 1;

	putc('\0',&tmp_stream);

	return retval;

}

int

vsprintf(char *s, const char *format, va_list arg)

{

	return vsnprintf(s, INT_MAX, format, arg);

}