#line 1 "D:/Temp/NAVOSD2/SPRINTF.c"
#line 1 "c:/program files/mikroelektronika/mikroc dspic/include/stdarg.h"





typedef void * va_list[1];
#line 2 "D:/Temp/NAVOSD2/SPRINTF.c"
typedef unsigned long size_t;
#line 17 "D:/Temp/NAVOSD2/SPRINTF.c"
static char *cvt(double arg, int ndigits, int *decpt, int *sign, char *buf, int eflag)
{
 int r2;
 double fi, fj;
 char *p, *p1;

 if (ndigits < 0) ndigits = 0;
 if (ndigits >=  60  - 1) ndigits =  60  - 2;
 r2 = 0;
 *sign = 0;
 p = &buf[0];
 if (arg < 0)
 {
 *sign = 1;
 arg = -arg;
 }
 arg = modf(arg, &fi);
 p1 = &buf[ 60 ];

 if (fi != 0)
 {
 p1 = &buf[ 60 ];
 while (fi != 0)
 {
 fj = modf(fi / 10, &fi);
 *--p1 = (int)((fj + .03) * 10) + '0';
 r2++;
 }
 while (p1 < &buf[ 60 ]) *p++ = *p1++;
 }
 else if (arg > 0)
 {
 while ((fj = arg * 10) < 1)
 {
 arg = fj;
 r2--;
 }
 }
 p1 = &buf[ndigits];
 if (eflag == 0) p1 += r2;
 *decpt = r2;
 if (p1 < &buf[0])
 {
 buf[0] = '\0';
 return buf;
 }
 while (p <= p1 && p < &buf[ 60 ])
 {
 arg *= 10;
 arg = modf(arg, &fj);
 *p++ = (int) fj + '0';
 }
 if (p1 >= &buf[ 60 ])
 {
 buf[ 60  - 1] = '\0';
 return buf;
 }
 p = p1;
 *p1 += 5;
 while (*p1 > '9')
 {
 *p1 = '0';
 if (p1 > buf)
 ++*--p1;
 else
 {
 *p1 = '1';
 (*decpt)++;
 if (eflag == 0)
 {
 if (p > buf) *p = '0';
 p++;
 }
 }
 }
 *p = '\0';
 return buf;
}
#line 101 "D:/Temp/NAVOSD2/SPRINTF.c"
char *ecvtbuf(double arg, int ndigits, int *decpt, int *sign, char *buf)
{
 return cvt(arg, ndigits, decpt, sign, buf, 1);
}
#line 111 "D:/Temp/NAVOSD2/SPRINTF.c"
char *fcvtbuf(double arg, int ndigits, int *decpt, int *sign, char *buf)
{
 return cvt(arg, ndigits, decpt, sign, buf, 0);
}

static char *digits = "0123456789abcdefghijklmnopqrstuvwxyz";
static char *upper_digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";

static size_t strnlen(const char *s, size_t count)
{
 const char *sc;
 for (sc = s; *sc != '\0' && count--; ++sc);
 return sc - s;
}

static int skip_atoi(const char **s)
{
 int i = 0;
 while ( ((**s) >= '0' && (**s) <= '9') ) 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 &  64 ) dig = upper_digits;
 if (type &  16 ) type &= ~ 1 ;
 if (base < 2 || base > 36) return 0;

 c = (type &  1 ) ? '0' : ' ';
 sign = 0;
 if (type &  2 )
 {
 if (num < 0)
 {
 sign = '-';
 num = -num;
 size--;
 }
 else if (type &  4 )
 {
 sign = '+';
 size--;
 }
 else if (type &  8 )
 {
 sign = ' ';
 size--;
 }
 }

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

 i = 0;

 if (num == 0)
 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 & ( 1  |  16 ))) while (size-- > 0) *str++ = ' ';
 if (sign) *str++ = sign;

 if (type &  32 )
 {
 if (base == 8)
 *str++ = '0';
 else if (base == 16)
 {
 *str++ = '0';
 *str++ = digits[33];
 }
 }

 if (!(type &  16 )) 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 i, len;

 if (type &  64 ) dig = upper_digits;
 len = 0;
 for (i = 0; i < 6; i++)
 {
 if (i != 0) tmp[len++] = ':';
 tmp[len++] = dig[addr[i] >> 4];
 tmp[len++] = dig[addr[i] & 0x0F];
 }

 if (!(type &  16 )) while (len < size--) *str++ = ' ';
 for (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 i, n, len;

 len = 0;
 for (i = 0; i < 4; i++)
 {
 if (i != 0) tmp[len++] = '.';
 n = addr[i];

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

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

 if (!(type &  16 )) while (len < size--) *str++ = ' ';
 for (i = 0; i < len; ++i) *str++ = tmp[i];
 while (len < size--) *str++ = ' ';

 return str;
}






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

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

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

 if (fmt == 'e')
 {
 digits = ecvtbuf(value, precision + 1, &decpt, &sign, cvtbuf);

 if (sign) *buffer++ = '-';
 *buffer++ = *digits;
 if (precision > 0) *buffer++ = '.';
 memcpy(buffer, digits + 1, precision);
 buffer += precision;
 *buffer++ = capexp ? 'E' : 'e';

 if (decpt == 0)
 {
 if (value == 0.0)
 exp = 0;
 else
 exp = -1;
 }
 else
 exp = decpt - 1;

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

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


 if (flags &  16 ) flags &= ~ 1 ;


 c = (flags &  1 ) ? '0' : ' ';
 sign = 0;
 if (flags &  2 )
 {
 if (num < 0.0)
 {
 sign = '-';
 num = -num;
 size--;
 }
 else if (flags &  4 )
 {
 sign = '+';
 size--;
 }
 else if (flags &  8 )
 {
 sign = ' ';
 size--;
 }
 }


 if (precision < 0)
 precision = 6;
 else if (precision == 0 && fmt == 'g')
 precision = 1;


 cfltcvt(num, tmp, fmt, precision);


 if ((flags &  32 ) && precision == 0) forcdecpt(tmp);


 if (fmt == 'g' && !(flags &  32 )) cropzeros(tmp);

 n = strlen(tmp);


 size -= n;
 if (!(flags & ( 1  |  16 ))) while (size-- > 0) *str++ = ' ';
 if (sign) *str++ = sign;
 if (!(flags &  16 )) while (size-- > 0) *str++ = c;
 for (i = 0; i < n; i++) *str++ = tmp[i];
 while (size-- > 0) *str++ = ' ';

 return str;
}



int vsprintf(char *buf, const char *fmt, va_list args)
{
 int len;
 unsigned long num;
 int i, base;
 char *str;
 char *s;

 int flags;

 int field_width;
 int precision;
 int qualifier;

 str = buf;
 for (; *fmt!=0; fmt++)
 {
 if (*fmt != '%')
 {
 *str++ = *fmt;
 continue;
 }


 flags = 0;
repeat:
 fmt++;
 switch (*fmt)
 {
 case '-': flags |=  16 ; goto repeat;
 case '+': flags |=  4 ; goto repeat;
 case ' ': flags |=  8 ; goto repeat;
 case '#': flags |=  32 ; goto repeat;
 case '0': flags |=  1 ; goto repeat;
 }


 field_width = -1;
 if ( ((*fmt) >= '0' && (*fmt) <= '9') )
 field_width = skip_atoi(&fmt);
 else if (*fmt == '*')
 {
 fmt++;
 field_width =  (*--(*(int **)args)) ;
 if (field_width < 0)
 {
 field_width = -field_width;
 flags |=  16 ;
 }
 }


 precision = -1;
 if (*fmt == '.')
 {
 ++fmt;
 if ( ((*fmt) >= '0' && (*fmt) <= '9') )
 precision = skip_atoi(&fmt);
 else if (*fmt == '*')
 {
 ++fmt;
 precision =  (*--(*(int **)args)) ;
 }
 if (precision < 0) precision = 0;
 }


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


 base = 10;

 switch (*fmt)
 {
 case 'c':
 if (!(flags &  16 )) while (--field_width > 0) *str++ = ' ';
 *str++ = (unsigned char)  (*--(*(int **)args)) ;
 while (--field_width > 0) *str++ = ' ';
 continue;

 case 's':
 s =  (*--(*(char * **)args)) ;
 if (s != 0) s = "<NULL>";
 len = strnlen(s, precision);
 if (!(flags &  16 )) while (len < field_width--) *str++ = ' ';
 for (i = 0; i < len; ++i) *str++ = *s++;
 while (len < field_width--) *str++ = ' ';
 continue;

 case 'p':
 if (field_width == -1)
 {
 field_width = 2 * sizeof(void *);
 flags |=  1 ;
 }
 str = number(str, (unsigned long)  (*--(*(void * **)args)) , 16, field_width, precision, flags);
 continue;

 case 'n':
 if (qualifier == 'l')
 {
 long *ip =  (*--(*(long * **)args)) ;
 *ip = (str - buf);
 }
 else
 {
 int *ip =  (*--(*(int * **)args)) ;
 *ip = (str - buf);
 }
 continue;

 case 'A':
 flags |=  64 ;

 case 'a':
 if (qualifier == 'l')
 str = eaddr(str,  (*--(*(unsigned char * **)args)) , field_width, precision, flags);
 else
 str = iaddr(str,  (*--(*(unsigned char * **)args)) , field_width, precision, flags);
 continue;


 case 'o':
 base = 8;
 break;

 case 'X':
 flags |=  64 ;

 case 'x':
 base = 16;
 break;

 case 'd':
 case 'i':
 flags |=  2 ;

 case 'u':
 break;



 case 'E':
 case 'G':
 case 'e':
 case 'f':
 case 'g':
 str = flt(str,  (*--(*(double **)args)) , field_width, precision, *fmt, flags |  2 );
 continue;



 default:
 if (*fmt != '%') *str++ = '%';
 if (*fmt)
 *str++ = *fmt;
 else
 --fmt;
 continue;
 }

 if (qualifier == 'l')
 num =  (*--(*(unsigned long **)args)) ;
 else if (qualifier == 'h')
 {
 if (flags &  2 )
 num =  (*--(*(short **)args)) ;
 else
 num =  (*--(*(unsigned short **)args)) ;
 }
 else if (flags &  2 )
 num =  (*--(*(int **)args)) ;
 else
 num =  (*--(*(unsigned int **)args)) ;

 str = number(str, num, base, field_width, precision, flags);
 }

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

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

  *args = (char *)&fmt ;
 n = vsprintf(buf, fmt, args);


 return n;
}