#include <stdlib.h>
#include <math.h>

/* convert double to string.  Helper for sprintf. */

static int copystring(char* buf,int maxlen, const char* s) {
	int i;
	for (i=0; i<3&&i<maxlen; ++i)
		buf[i]=s[i];
	if (i<maxlen) { buf[i]=0; ++i; }
	return i;
}

int __dtostr(double d,char *buf,unsigned int maxlen,unsigned int prec,unsigned int prec2) {
#if 1
	union {
		unsigned long long l;
		double d;
	} u = { .d=d };
	/* step 1: extract sign, mantissa and exponent */
	signed long e=((u.l>>52)&((1<<11)-1))-1023;
#else
	signed long e=(((((unsigned long*)&d)[1])>>20)&((1<<11)-1))-1023;
#endif
/*  unsigned long long m=u.l & ((1ull<<52)-1); */
	/* step 2: exponent is base 2, compute exponent for base 10 */
	signed long e10;
	/* step 3: calculate 10^e10 */
	unsigned int i;
	double backup=d;
	double tmp;
	char *oldbuf=buf;

	if ((i=isinf(d))) return copystring(buf,maxlen,i>0?"inf":"-inf");
	if (isnan(d)) return copystring(buf,maxlen,"nan");
	e10=1+(long)(e*0.30102999566398119802); /* log10(2) */
	/* Wir iterieren von Links bis wir bei 0 sind oder maxlen erreicht
	 * ist.  Wenn maxlen erreicht ist, machen wir das nochmal in
	 * scientific notation.  Wenn dann von prec noch was übrig ist, geben
	 * wir einen Dezimalpunkt aus und geben prec2 Nachkommastellen aus.
	 * Wenn prec2 Null ist, geben wir so viel Stellen aus, wie von prec
	 * noch übrig ist. */
	if (d==0.0) {
		prec2=prec2==0?1:prec2+2;
		prec2=prec2>maxlen?8:prec2;
		i=0;
		if (prec2 && (long long)u.l<0) { buf[0]='-'; ++i; }
		for (; i<prec2; ++i) buf[i]='0';
		buf[buf[0]=='0'?1:2]='.'; buf[i]=0;
		return i;
	}

	if (d < 0.0) { d=-d; *buf='-'; --maxlen; ++buf; }

	/*
      Perform rounding. It needs to be done before we generate any
      digits as the carry could propagate through the whole number.
	*/

	tmp = 0.5;
	for (i = 0; i < prec2; i++) { tmp *= 0.1; }
	d += tmp;

	if (d < 1.0) { *buf='0'; --maxlen; ++buf; }
/*  printf("e=%d e10=%d prec=%d\n",e,e10,prec); */
	if (e10>0) {
		int first=1;	/* are we about to write the first digit? */
		tmp = 10.0;
		i=e10;
		while (i>10) { tmp=tmp*1e10; i-=10; }
		while (i>1) { tmp=tmp*10; --i; }
		/* the number is greater than 1. Iterate through digits before the
		 * decimal point until we reach the decimal point or maxlen is
		 * reached (in which case we switch to scientific notation). */
		while (tmp>0.9) {
			char digit;
			double fraction=d/tmp;
			digit=(int)(fraction);		/* floor() */
			if (!first || digit) {
				first=0;
				*buf=digit+'0'; ++buf;
				if (!maxlen) {
					/* use scientific notation */
					int len=__dtostr(backup/tmp,oldbuf,maxlen,prec,prec2);
					int initial=1;
					if (len==0) return 0;
					maxlen-=len; buf+=len;
					if (maxlen>0) {
						*buf='e';
						++buf;
					}
					--maxlen;
					for (len=1000; len>0; len/=10) {
						if (e10>=len || !initial) {
							if (maxlen>0) {
								*buf=(e10/len)+'0';
								++buf;
							}
							--maxlen;
							initial=0;
							e10=e10%len;
						}
					}
					if (maxlen>0) goto fini;
					return 0;
				}
				d-=digit*tmp;
				--maxlen;
			}
			tmp/=10.0;
		}
	}
	else
	{
		tmp = 0.1;
	}

	if (buf==oldbuf) {
		if (!maxlen) return 0; --maxlen;
		*buf='0'; ++buf;
	}
	if (prec2 || prec>(unsigned int)(buf-oldbuf)+1) {	/* more digits wanted */
		if (!maxlen) return 0; --maxlen;
		*buf='.'; ++buf;
		prec-=buf-oldbuf-1;
		if (prec2) prec=prec2;
		if (prec>maxlen) return 0;
		while (prec>0) {
			char digit;
			double fraction=d/tmp;
			digit=(int)(fraction);		/* floor() */
			*buf=digit+'0'; ++buf;
			d-=digit*tmp;
			tmp/=10.0;
			--prec;
		}
	}
fini:
	*buf=0;
	return buf-oldbuf;
}