#include	<stdlib.h>
#include	<stdio.h>
#include	<assert.h>
#include	<string.h>

char	*UTS_sprintf_wrap();
char	*do_efmt();
char	*do_gfmt();
char	*Fill();

/* main(argc, argv)
 * char	**argv;
 * {
 * 	double	d;
 * 	char	*Fmt, *Ret;
 * 	char	obuf[200];
 * 
 * 	assert(argc > 2);
 * 	Fmt = argv[1];
 * 	d = strtod(argv[2], (char **)0);
 * 
 * 	putchar('{');
 * 	printf(Fmt, d);
 * 	printf("}\n");
 * 
 * 	Ret = UTS_sprintf_wrap(obuf, Fmt, d);
 * 	assert(Ret == obuf);
 * 
 * 	printf("{%s}\n", obuf);
 * }
 */

char *
UTS_sprintf_wrap(obuf, fmt, d,
	a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15)
char	*obuf, *fmt;
double	d;
{
	int	fmtlen, Width=0, Precision=6, Alt=0, Plus=0, Minus=0,
		Zero = 0;
	int	FmtChar, BaseFmt = 0;
	char	*f = fmt, *AfterWidth = 0, *AfterPrecision = 0;
	char	*Dot;

	if(*f++ != '%') {
		return
sprintf(obuf, fmt, d, a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15);
	}
	fmtlen = strlen(fmt);
	FmtChar = fmt[fmtlen - 1];
	switch(FmtChar) {
	case 'f':
	case 'F':
		return
sprintf(obuf, fmt, d, a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15);
	case 'e':
	case 'E':
		BaseFmt = 'e';
		goto BaseFmt_IsSet;
	case 'g':
	case 'G':
		BaseFmt = 'g';
BaseFmt_IsSet:
		if(*f == '#') { Alt = 1; ++f; }   /* Always has '.' */
		if(*f == '+') { Plus = 1; ++f; }  /* Force explicit sign */
		if(*f == '-') { Minus = 1; ++f; } /* Left justify */
		if(*f == '0') { Zero = 1; ++f;} /* Fill using 0s*/
		if(Dot = strchr(f, '.')) {
			Precision = strtol(Dot+1, &AfterPrecision, 0);
		}
		if(!Dot || (Dot && Dot > f)) { /* Next char=='.' => no width*/
			Width = strtol(f, &AfterWidth, 0);
		}
		if(Dot) { f = AfterPrecision; }
		else if(AfterWidth) { f = AfterWidth; }
		if(*f != FmtChar) goto regular_sprintf;
		 /* It doesn't look like a f.p. sprintf call */
		 /* from Perl_sv_vcatpvfn		     */

		if(BaseFmt == 'e') {
			return do_efmt(d, obuf, Width, Precision, Alt,
				Plus, Minus, Zero, FmtChar == 'E');
		} else {
			return do_gfmt(d, obuf, Width, Precision, Alt,
				Plus, Minus, Zero, FmtChar == 'G');
		}
	default:
regular_sprintf:
		return
sprintf(obuf, fmt, d, a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15);
	}
}

char	*
do_efmt(d, obuf, Width, Precision, Alt, Plus, Minus, Zero, UpperCase)
char	*obuf;
double	d;
{
	char	*Ecvt;
	char	*ob;
	int	decpt, sign, E;
	int	len;
	int	AllZeroes = 0;

	Ecvt = ecvt( d , Precision+1, &decpt, &sign);

	/* fprintf(stderr, "decpt=%d, sign=%d\n", decpt, sign); */

	len = strlen(Ecvt);
	if(strspn(Ecvt, "0") == len) AllZeroes = 1;

	ob = obuf;
	if(sign)	*ob++ = '-';
	else if(Plus)	*ob++ = '+';

	*ob++ = Ecvt[0];

	if(Precision > 0 || Alt) *ob++ = '.';
	strcpy(ob, &Ecvt[1]);

	ob += strlen(ob);	/* ADVANCE TO END OF WHAT WE JUST ADDED */
	*ob++ = UpperCase ? 'E' : 'e';

	if(AllZeroes)	E = 0;
	else		E = decpt - 1;

	if(E < 0)	{ *ob++ = '-'; E = -E; }
	else		{ *ob++ = '+'; }

	sprintf(ob, "%.2d", E);	/* Too much horsepower used here */

	if(Width > strlen(obuf)) return Fill(obuf, Width, Minus, Zero);
	else			 return obuf;
}

char	*
do_gfmt(d, obuf, Width, Precision, Alt, Plus, Minus, Zero, UpperCase)
char	*obuf;
double	d;
{
	char	*Ecvt = gcvt(d, Precision ? Precision : 1, obuf);
	int	len = strlen(obuf);

	 /* gcvt fails (maybe give a warning? For now return empty string): */
	if(!Ecvt) { *obuf = '\0'; return obuf; }

	/* printf("Ecvt='%s'\n", Ecvt); */
	if(Plus && (Ecvt[0] != '-')) {
		memmove(obuf+1, obuf, len+1); /* "+1" to get '\0' at end */
		obuf[0] = '+';
		++len;
	}
	if(Alt && !strchr(Ecvt, '.')) {
		int	LenUpTo_E = strcspn(obuf, "eE");
		int	E_etc_len = strlen(&obuf[LenUpTo_E]);
			/* ABOVE: Will be 0 if there's no E/e because */
			/* strcspn will return length of whole string */

		if(E_etc_len)
			memmove(obuf+LenUpTo_E+1, obuf+LenUpTo_E, E_etc_len);
		obuf[LenUpTo_E] = '.';
		obuf[LenUpTo_E + 1 + E_etc_len ] = '\0';
	}
	{ char *E_loc;
	  if(UpperCase && (E_loc = strchr(obuf, 'e'))) { *E_loc = 'E'; }
	}
	if(Width > len)
		return Fill(obuf, Width, Minus, Zero);
	else
		return obuf;
}

char *
Fill(obuf, Width, LeftJustify, Zero)
char	*obuf;
{
	int	W = strlen(obuf);
	int	diff = Width - W;
	 /* LeftJustify means there was a '-' flag, and in that case,	*/
	 /* printf man page (UTS4.4) says ignore '0'			*/
	char	FillChar = (Zero && !LeftJustify) ? '0' : ' ';
	int	i;
	int	LeftFill = ! LeftJustify;

	if(Width <= W) return obuf;

	if(LeftFill) {
		memmove(obuf+diff, obuf, W+1); /* "+1" to get '\0' at end */
		for(i=0 ; i < diff ; ++i) { obuf[i] = FillChar; }
	} else {
		for(i=W ; i < Width ; ++i)
			obuf[i] = FillChar;
		obuf[Width] = '\0';
	}
	return obuf;
}