#include <ctype.h>
#include <stdlib.h>
#include <stdarg.h>
#include <limits.h>
#include <math.h>
#include <float.h>
#include "stdio.h"

// a union to handle the
union _d_bits {
	double d;
	struct {
		unsigned sign :1;
		unsigned exp :11;
		unsigned frac0 :20;
		unsigned frac1 :32;
	} b;
	unsigned u;
};

#ifdef FULL_SPECIFIERS
extern unsigned char *__decimalpoint;
#endif

extern int __vfprintf_total_size(FILE *stream, const char *fmt, va_list args);

/* a little macro to make life easier */

#define OUT(c)  do                           \
                { putc((c),stream);         \
                  outcount++;                \
                }while(0)

#define MINFLOATSIZE (DBL_DIG+3)
#define MININTSIZE (sizeof(unsigned long long)*CHAR_BIT/3+1)
#define MINPOINTSIZE (sizeof(void *)*CHAR_BIT/4+1)
#define REQUIREDBUFFER (MININTSIZE>MINPOINTSIZE? \
                        (MININTSIZE>MINFLOATSIZE?MININTSIZE:MINFLOATSIZE): \
                        (MINPOINTSIZE>MINFLOATSIZE?MINPOINTSIZE:MINFLOATSIZE))

/**
 * '#'
 * Used with o, exponent or X specifiers the value is preceeded with 0, 0x or 0X
 * respectively for values different than zero.
 * Used with a, A, e, E, f, F, g or G it forces the written output
 * to contain a decimal point even if no more digits follow.
 * By default, if no digits follow, no decimal point is written.
 */
#define ALTERNATEFLAG 1  /* '#' is set */

/**
 * '0'
 * Left-pads the number with zeroes (0) instead of spaces when padding is specified
 * (see width sub-specifier).
 */
#define ZEROPADFLAG   2  /* '0' is set */

/**
 * '-'
 * Left-justify within the given field width;
 * Right justification is the default (see width sub-specifier).
 */
#define LALIGNFLAG    4  /* '-' is set */

/**
 * ' '
 * If no sign is going to be written, a blank space is inserted before the value.
 */
#define BLANKFLAG     8  /* ' ' is set */

/**
 * '+'
 * Forces to preceed the result with a plus or minus sign (+ or -) even for positive numbers.
 * By default, only negative numbers are preceded with a - sign.
 */
#define SIGNFLAG      16 /* '+' is set */

static const char flagc[] = { '#', '0', '-', ' ', '+' };

/**
 * Set if an explicit precision is given.
 */
#define HAS_PRECI 32

#if 0
static int ___vfprintf_total_size(FILE *stream, const char *format,
		va_list args) {
	unsigned char buf[64];
	FILE fp;
	int ret;

	fp._w = 0;
	fp._flags = stream->_flags & ~(__SWO | __SWR | __SNBF);
	fp.file = stream->file;
	fp._bf._base = buf;
	fp._bf._size = sizeof(buf);
	fp.linebufsize = 0;
#ifdef __posix_threads__
	fp.__spinlock[0] = 0;
#endif
	if (((ret = __vfprintf_total_size(&fp, format, args)) >= 0)
			&& __fflush(&fp))
		ret = -1;
	if (fp._flags & __SERR)
		stream->_flags |= __SERR;
	return ret;
}
#endif

extern unsigned __ulldivus(unsigned long long * llp, unsigned short n);

/**
 *  Differs from vfprintf such that it returns total number of bytes that
 *  would've been written if there were sufficient space in file.
 *  Required for vsnprintf
 */
int __vfprintf_total_size(FILE *stream, const char *format, va_list args) {
	size_t outcount = 0;

	__STDIO_LOCK(stream);

//	/* optimize unbuffered write-only files */
//	if ((stream->_flags & (__SWO | __SNBF)) == (__SWO | __SNBF)) {
//		return ___vfprintf_total_size(stream, format, args);
//	}

	while (*format) {
		if (*format == '%') {
			static const char lowertabel[] = { '0', '1', '2', '3', '4', '5',
					'6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
			static const char uppertabel[] = { '0', '1', '2', '3', '4', '5',
					'6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
			short width = 0;
			unsigned short preci = 0x7fff;
			short flags = 0; /* Specifications */
			char type, subtype = 'i';
			char buffer1[2]; /* Signs and that like */
			char buffer[REQUIREDBUFFER]; /* The body */
			char *buffer2 = buffer; /* So we can set this to any other strings */
			size_t size1 = 0, size2 = 0; /* How many chars in buffer? */
			const char *ptr = format + 1; /* pointer to format string */
			unsigned short i, pad; /* Some temporary variables */

			do /* read flags */
				for (i = 0; i < sizeof(flagc); i++)
					if (flagc[i] == *ptr) {
						flags |= 1 << i;
						ptr++;
						break;
					} while (i < sizeof(flagc));

			if (*ptr == '*') /* read width from arguments */
			{
				signed int a;
				ptr++;
				a = va_arg(args, signed int);
				if (a < 0) {
					flags |= LALIGNFLAG;
					width = -a;
				} else
					width = a;
			} else {
				while (isdigit(*ptr))
					width = width * 10 + (*ptr++ - '0');
			}

			if (*ptr == '.') {
				flags |= HAS_PRECI;
				ptr++;
				if (*ptr == '*') /* read precision from arguments */
				{
					signed int a;
					ptr++;
					a = va_arg(args, signed int);
					if (a >= 0)
						preci = a;
				} else {
					preci = 0;
					while (isdigit(*ptr))
						preci = preci * 10 + (*ptr++ - '0');
				}
			}

			if (*ptr == 'h' || *ptr == 'l' || *ptr == 'L' || *ptr == 'j'
					|| *ptr == 'z' || *ptr == 't') {
				subtype = *ptr++;
				if (*ptr == 'h' || *ptr == 'l')
					++ptr, ++subtype;
			} else
				subtype = 0;

			type = *ptr++;

			switch (type) {
			case 'd':
			case 'i':
			case 'o':
			case 'p':
			case 'u':
			case 'x':
			case 'X': {
				unsigned long long v;
				const char *tabel;
				int base;

				if (type == 'p') {
					subtype = 'l'; /* This is written as %#lx */
					type = 'x';
					flags |= ALTERNATEFLAG;
				}

				if (type == 'd' || type == 'i') /* These are signed */
				{
					signed long long v2;
					if (subtype == 'l')
						v2 = va_arg(args, signed long);
					else if (subtype == 'm' || subtype == 'j')
						v2 = va_arg(args, signed long long);
					else
						v2 = va_arg(args, signed int);
					if (subtype == 'h')
						v2 &= 0xffff;
					else if (subtype == 'i')
						v2 &= 0xff;
					if (v2 < 0 || (subtype == 'h' && (short)v2 < 0) || (subtype == 'i' && (char)v2 < 0)) {
						buffer1[size1++] = '-';
						v = -v2;
					} else {
						if (flags & SIGNFLAG)
							buffer1[size1++] = '+';
						else if (flags & BLANKFLAG)
							buffer1[size1++] = ' ';
						v = v2;
					}
				} else /* These are unsigned */
				{
					if (subtype == 'l')
						v = va_arg(args, unsigned long);
					else if (subtype == 'm' || subtype == 'j')
						v = va_arg(args, unsigned long long);
					else
						v = va_arg(args, unsigned int);
					if (subtype == 'h')
						v &= 0xffff;
					else if (subtype == 'i')
						v &= 0xff;
					if (flags & ALTERNATEFLAG) {
						if (type == 'o') {
							if (!preci || v)
								buffer1[size1++] = '0';
						} else if ((type == 'x' || type == 'X') && v) {
							buffer1[size1++] = '0';
							buffer1[size1++] = type;
						}
					}
				}

				buffer2 = &buffer[sizeof(buffer)]; /* Calculate body string */
				base = type == 'x' || type == 'X' ? 16 : (type == 'o' ? 8 : 10);
				tabel = type != 'X' ? lowertabel : uppertabel;
				do {
					*--buffer2 = tabel[__ulldivus(&v, base)];
					size2++;
				} while (v);
				if (preci == 0x7fff) /* default */
					preci = 0;
				else
					flags &= ~ZEROPADFLAG;
				break;
			}
			case 'c':
				if (subtype == 'l')
					*buffer2 = va_arg(args, long);
				else
					*buffer2 = va_arg(args, int);
				size2 = 1;
				preci = 0;
				break;
			case 's':
				buffer2 = va_arg(args, char *);
				size2 = strlen(buffer2);
				size2 = size2 <= preci ? size2 : preci;
				preci = 0;
				break;

#ifdef FULL_SPECIFIERS



			case 'a':
			case 'A':
			case 'f':
			case 'e':
			case 'E':
			case 'g':
			case 'G': {
				union _d_bits d;
				short exponent = 0;
				char sign = 0;
				const char * infnan = 0;
				char pad = (flags & ZEROPADFLAG) ? '0' : ' ';

				if (type == 'f' || type == 'F')
					type = 0;

				d = va_arg(args, union _d_bits);

				// check for negative number and set the sign char if necessary
				if (d.b.sign) {
					d.b.sign = 0;
					sign = '-';
				} else if (flags & SIGNFLAG)
					sign = '+';
				else if (flags & BLANKFLAG)
					sign = ' ';

				// check for inf/nan
				if (d.b.exp == 0x7ff) {
					if (d.b.frac0 || d.b.frac1) {
						infnan = "NaN";
						sign = 0;
					} else {
						infnan = "inf";
					}
					width -= 3;
				}


				{
					short pos;
					unsigned x, y;

				// count of digts:
				// f, F : all digits before dot, preci digits behind. = 1 + preci, add exponent if > 0
				// e, E : one digit before dot, preci digits behind dot = 1 + preci
				// g, G : preci digits total
				int startPos = 1; // first digit
				short stopPos; // behind last digit
				short leading = 1; // digits until dot is inserted
				short dotZero = 0; // insert zeroes after dot
				short postZero = 0; // append zeroes at end
				short killZero = 0; // kill trailing zeroes

				// real number
				if (!infnan) {
					if (type != 'a' && type != 'A') {

						if (preci == 0x7fff) /* old default */
							preci = 6; /* new default */
						stopPos = preci + 1;

						// compute exponent - a tad slow but ok
						if (d.u || d.b.frac1) {
							if (d.d >= 1) {
								while (d.d >= 10000000000) {
									d.d *= 0.0000000001;
									exponent += 10;
								}
								while (d.d >= 10) {
									d.d *= 0.1;
									++exponent;
								}
							} else {
								while (d.d < 0.0000000001) {
									d.d *= 10000000000;
									exponent -= 10;
								}
								while (d.d < 1) {
									d.d *= 10;
									--exponent;
								}
							}
						}

						while ((int) d.d > 9) {
							d.d /= 10;
							++exponent;
						}

						// convert g into e or f
						if (type == 'g' || type == 'G') {
							int limit = preci + 4;
							--preci;
							if (preci >= exponent && exponent >= 0) {
								type = 0;
								preci -= exponent;
							} else if (exponent < 0
									&& limit + exponent + 1 > preci) {
								type = 0;
								preci -= exponent;
							} else {
								type = 'e';
							}
							stopPos = preci + 1;
							if (!(flags & ALTERNATEFLAG))
								killZero = 1;
						}

						// fill it with digits
						buffer[0] = '0';
						pos = 1;
						if (type == 0) { // f, F
							if (exponent >= 0) {
								leading += exponent;
								stopPos += exponent + 1;
							} else {
								dotZero = -exponent - 1;
								buffer[1] = '0';
								if (dotZero > preci) {
									dotZero = preci;
									buffer[2] = '0'; // mandatory - uninitialized values may break rounding
									pos = 3;
								} else
									pos = 2;
								stopPos -= dotZero - 1;
							}
						} else {
							++stopPos; // add one for leading digit
						}
						if (stopPos >= REQUIREDBUFFER) {
							postZero = stopPos - REQUIREDBUFFER + 1;
							if (type == 0 && postZero > preci)
								postZero = preci;
							stopPos = REQUIREDBUFFER - 1;
						}

						// compute the digits + one more for rounding
						for (; pos < stopPos; ++pos) {
							int z = (int) d.d;
							if (z) {
								d.d = (d.d - z) * 10;
								if (d.d <= -0.1) {
									--z;
									d.d += 10;
								}
							} else
								d.d *= 10;
							buffer[pos] = (char) ('0' + z);
						}

						// round up
						if (d.d >= 5.) {
							--pos;
							for (; pos >= startPos; --pos) {
								if (++buffer[pos] <= '9')
									break;
								buffer[pos] = '0';
							}
							// overflow
							if (pos <= startPos) {
								if (type != 0) {
									if (pos < startPos) {
										startPos = pos;
										buffer[pos] = '1';
									}
									++exponent;
									--stopPos;
								} else if (type == 0) {
									if (exponent < 0) {
										if (dotZero > 0) {
											startPos = 0;
											--dotZero;
										}
									} else if (pos < startPos ){
										startPos = pos;
										buffer[pos] = '1';
										++leading;
									}
								}
							}
						}
					} else {
						if (preci == 0x7fff) /* old default */
							preci = 0; /* new default */
						if (!(flags & HAS_PRECI)) killZero = 1;

						// 'a' 'A'
						OUT('0');
						OUT(type + 'X' - 'A');

						if (!d.b.exp) {
							exponent = x = y = 0;
						} else {
							exponent = d.b.exp - 1023;
							x = d.b.frac0;
							y = d.b.frac1;
							buffer[0] = '1';
							startPos = 0;
							if (HAS_PRECI)
								++preci;
						}
						stopPos = 1;

						{unsigned j; for (j = 16;j <= 28; j += 12) {
							{int i; for (i = j; i >= 0; i -= 4) {
								unsigned c = (x >> i) & 0xf;
								x -= c << i;
								if (c > 9)
									c += type - 10;
								else
									c += '0';
								buffer[stopPos++] = c;
								if (!x && !y && stopPos >= preci)
									break;
							}}
							if (!y && stopPos >= preci)
								break;
							x = y;
							y = 0;
						}}

						type += 'P' - 'A';
					}

					// kill trailing zeroes
					if (killZero != 0) {
						int stop = stopPos - 1;
						while (stop > startPos) {
							if (buffer[stop] != '0')
								break;
							if (type == 0 && stop - startPos == exponent)
								break;
							--stop;
						}
						if (type != 0 && stop - startPos + 5 < width)
							width = stop - startPos + preci + 5;
						else if (type == 0) {
							if (stop + 1 != stopPos
									&& stop - startPos == exponent)
								++width;
						}
						stopPos = stop + 1;
					}

					// calculate width
					if (type != 0) {
						// 1e+00
						width -= 5 + stopPos - startPos + postZero;

						if (exponent < -99) {
							--width;
							if (exponent < -999)
								--width;
						} else if (exponent > 99) {
							--width;
							if (exponent > 999)
								--width;
						}
					} else {
						// 123.456  -> exponent = 2, preci = 3
						if (leading > stopPos - startPos)
							width -= leading + dotZero + postZero;
						else
							width -= stopPos - startPos + dotZero
									+ postZero;
					}

					// dot?
					if (preci > 0 || (flags & ALTERNATEFLAG) != 0)
						--width;
				}
				if (sign != 0)
					--width;

				// pad on left side
				if ((flags & LALIGNFLAG) == 0)
					while (--width >= 0)
						OUT(pad);

				// output sign if set
				if (sign != 0)
					OUT(sign);

				if (infnan) {
					// output inf/nan
					OUT(infnan[0]);
					OUT(infnan[1]);
					OUT(infnan[2]);
				} else {
					// leading digits
					while (leading-- > 0 && startPos < stopPos)
						OUT(buffer[startPos++]);

					// more leading digits than buffer size
					while (leading-- >= 0)
						OUT('0');

					// output dot
					if (startPos < stopPos || dotZero != 0 || postZero != 0
							|| (flags & ALTERNATEFLAG) != 0)
						OUT(__decimalpoint[0]);

					// output zeroes behind dot not in buffer
					while (dotZero-- > 0)
						OUT('0');

					// digits somewhere behind dot
					for (; startPos < stopPos; ++startPos)
						OUT(buffer[startPos]);

					// output trailing zeroes not in buffer
					while (postZero-- > 0)
						OUT('0');

					if (type != 0) {
						int xout;

						OUT(type);
						if (exponent < 0) {
							OUT('-');
							exponent = -exponent;
						} else
							OUT('+');
						--width;

						xout = 0;
						if (exponent > 999) {
							int z = exponent / 1000;
							OUT('0' + z);
							exponent -= z * 1000;
							--width;
							xout = 1;
						}
						if (xout || exponent > 99) {
							int z = exponent / 100;
							OUT('0' + z);
							exponent -= z * 100;
							--width;
							xout = 1;
						}
						if (xout || exponent > 9 || (type | 0x20) != 'p' ) {
							int z = exponent / 10;
							OUT('0' + z);
							exponent -= z * 10;
							--width;
						}
						OUT('0' + exponent);
						--width;
					}
				}

				// pad on right side
				if ((flags & LALIGNFLAG) != 0)
					while (--width >= 0)
						OUT(' ');
				/* Everything already done */
				format = ptr;
				continue;
			}
			}
#endif
			case '%':
				buffer2 = "%";
				size2 = 1;
				preci = 0;
				break;
			case 'n':
				*va_arg(args, int *) = outcount;
				width = preci = 0;
				break;
			default:
				if (!type)
					ptr--; /* We've gone too far - step one back */
				buffer2 = (char *) format;
				size2 = ptr - format;
				width = preci = 0;
				break;
			}

			if (flags & HAS_PRECI) {
				if (size2 == 1 && !preci && buffer2[0] == '0')
					size2 = 0;
			}

			pad = size1 + (size2 >= preci ? size2 : preci); /* Calculate the number of characters */
			pad = pad >= width ? 0 : width - pad; /* and the number of resulting pad bytes */

			if (flags & ZEROPADFLAG) /* print sign and that like */
				for (i = 0; i < size1; i++)
					OUT(buffer1[i]);

			if (!(flags & LALIGNFLAG)) /* Pad left */
				for (i = 0; i < pad; i++)
					OUT(flags&ZEROPADFLAG?'0':' ');

			if (!(flags & ZEROPADFLAG)) /* print sign if not zero padded */
				for (i = 0; i < size1; i++)
					OUT(buffer1[i]);

			for (i = size2; i < preci; i++) /* extend to precision */
				OUT('0');

			for (i = 0; i < size2; i++) /* print body */
				OUT(buffer2[i]);

			if (flags & LALIGNFLAG) /* Pad right */
				for (i = 0; i < pad; i++)
					OUT(' ');

			format = ptr;
		} else
			OUT(*format++);
	}
	__STDIO_UNLOCK(stream);

	return outcount;
}

#ifdef TESTME
int main(int argc, char ** argv) {
	double d;
	printf("%-20.0f|\n", 0.0);
	printf("%-20.0e\n", 0.0);
	printf("%-20.1g\n", 0.0);
	printf("%#20.0f\n", 0.0);
	printf("%#20.0e\n", 0.0);
	printf("%#20.1g\n", 0.0);

	d = 1.2345678902468e-13;
	for (int i = 0; i < 24; ++i) {
		d *= 10;
		printf("%20.7f\n", d);
	}

	d = 1.2345678902468e-13;
	for (int i = 0; i < 24; ++i) {
		d *= 10;
		printf("%20.7g\n", d);
	}

	d = 1.2345678902468e-13;
	for (int i = 0; i < 24; ++i) {
		d *= 10;
		printf("%20.7e\n", d);
	}

	return 0;
}
#endif