use "alloc"use "bigint"use "chartype"use "chomp"use "extremum"use "fltbits"use "hasprefix"use "intparse"use "option"use "utf"use "striter" pkg std =	const flt64parse	: (str : byte[:] -> std.option(flt64))	const flt32parse	: (str : byte[:] -> std.option(flt32));; type parseresult = union	`Flt (int, std.bigint#, int16)	`Inf int	`Nan int	`Badflt;; const flt64parse = {str	var val 	match fltparse(str)	| `Badflt:	-> `std.None	| `Inf sign:	-> `std.Some ((sign : flt64) * std.flt64inf())	| `Nan sign:	-> `std.Some ((sign : flt64) * std.flt64nan())	| `Flt (sign, mant, exp):		val = toflt(sign, mant, exp, &lim64)		std.bigfree(mant)		-> `std.Some val	;;} const flt32parse = {str	var val 	match fltparse(str)	| `Badflt:	-> `std.None	| `Inf sign:	-> `std.Some ((sign : flt32) * std.flt32inf())	| `Nan sign:	-> `std.Some ((sign : flt32) * std.flt32nan())	| `Flt (sign, mant, exp):		val = toflt(sign, mant, exp, &lim32)		std.bigfree(mant)		-> `std.Some (val : flt32)	;;} const fltparse = {str	var sign, exp, mant, expinc, i 	if std.chomp(&str, "-")		sign = -1	else		sign = 1		std.chomp(&str, "+")	;; 	match str	| "inf":	-> `Inf sign	| "Inf":	-> `Inf sign	| "nan":	-> `Nan sign	| "NaN":	-> `Nan sign	| "":	-> `Badflt	| _:	/* nothing */	;; 	i = 0	exp = 0	expinc = 0	mant = std.mkbigint(0)	for var c = std.decode(str[i:]); c == '0'; c = std.decode(str[i:])		i++	;;	for var c = std.decode(str[i:]); fltchar(c); c = std.decode(str[i:])		i++		if c == '_'			continue		elif c == '.'			/* fail if we've already seen the '.' */			if expinc != 0				goto error			;;			expinc = -1		elif std.isdigit(c)			exp += expinc			std.bigmuli(mant, 10)			std.bigaddi(mant, std.charval(c, 10))		else			goto error		;;	;;		if std.hasprefix(str[i:], "e") || std.hasprefix(str[i:], "E")		/* intparse doesn't accept '+', so if we have 'e+', consume the '+ */		if std.hasprefix(str[i+1:], "+")			i++		;;		match std.intparsebase(str[i+1:], 10)		| `std.Some n:	exp += n		| `std.None:	goto error		;;		i = str.len	;;	if i != str.len		goto error	;; 	-> `Flt (sign, mant, exp) :error	std.bigfree(mant)	-> `Badflt} const fltchar = {c	-> std.isdigit(c) || c == '.' || c == '_'} type lim = struct	minsig	: uint64	maxsig	: uint64	loshift	: uint64	nextinc	: uint64	minexp	: int16	maxexp	: int16	sigbits	: int16;; const lim64 : lim = [	.minsig=0x10000000000000ul,	.maxsig=0x20000000000000ul,	.minexp=-1022 - 52,	.maxexp=1023 - 52,	.sigbits=53,	.nextinc=1,	.loshift=0] const lim32 : lim = [	.minsig=0x400000,	.maxsig=0x800000,	.minexp=-126-22,	.maxexp=127-22,	.sigbits=22,	.nextinc=0x20000000,	.loshift=30] const toflt = {sign, mant, exp, lim	/* if it's all zero, just return 0 */	if std.bigeqi(mant, 0)		-> (sign : flt64) * 0.0	/* todo: add fast parsing for common cases */	else		-> (sign : flt64) * fallback(mant, exp, lim)	;;} const fallback = {mant, exp, lim	var u, v, k : int16, eabs	var x, r, xprime, rprime	var f 	u = mant	k = 0	v = std.mkbigint(1)	x = std.mkbigint(0)	r = std.mkbigint(0)	eabs = std.abs(exp)	if exp >= 0		/* can be optimized */		mulexp(u, eabs, 10)	else		mulexp(v, eabs, 10)	;; 	estimate(u, v, &k, lim) 	while true		(xprime, rprime) = std.bigdivmod(u, v)		std.bigsteal(x, xprime)		std.bigsteal(r, rprime)		if k == lim.minexp 			if std.biggei(x, lim.minsig) && std.biglei(x, lim.maxsig)				break			else				f = denormal(x, v, r, lim)				goto done			;;		elif k > lim.maxexp			f = std.flt64inf()			goto done		;;		if std.biglti(x, lim.minsig)			std.bigmuli(u, 2)			k--		elif std.biggti(x, lim.maxsig)			std.bigmuli(v, 2)			k++		else			break		;;	;;	f = assemble(u, v, r, k, lim):done	std.bigfree(v)	std.bigfree(x)	std.bigfree(r)	-> f} const estimate = {u, v, k, lim	var log2u, log2v, log2rat	var ushift, vshift	var targ 	targ = lim.sigbits	log2u = std.bigbitcount(u)	log2v = std.bigbitcount(v)	ushift = 0	vshift = 0	log2rat = (log2u - log2v : int16)	/* 	if we deal with denormals, we just punt to the 'k == minexp' test	and take the slow path.	*/	if log2rat < targ - 1		ushift = std.clamp(targ - log2rat - 1, lim.minexp, lim.maxexp)		k# -= ushift	elif log2rat > targ + 1		vshift = std.clamp(log2rat - targ + 1, lim.minexp, lim.maxexp)		k# += vshift	;;	std.bigshli(u, ushift)	std.bigshli(v, vshift)} const assemble = {u, v, r, k, lim	var z, diff 	std.bigdiv(u, v)	diff = std.bigdup(v)	std.bigsub(diff, r)	z = mkflt(u, k) 	match std.bigcmp(r, diff)	| `std.Before:	/* nothing */	| `std.After:	z = nextfloat(z, lim)	| `std.Equal:		if !std.bigiseven(u)			z = nextfloat(z, lim)		;;	;;	std.bigfree(diff)	-> z} const nextfloat = {z, lim	var sign, mant, exp	var za 	(sign, exp, mant) = std.flt64explode(z)	if std.abs((mant : int64) - (1l << 52) - 1) < (lim.nextinc : int64)		mant = 0		exp++	else		mant += lim.nextinc	;;	za = std.flt64assem(sign, exp, mant)	-> za} const mulexp = {val, exp, pow	while exp > 0		exp--		std.bigmuli(val, pow)	;;} const denormal = {x, v, rem, lim	var m, z 	if x.dig.len == 0		m = 0	elif x.dig.len == 2		m = (x.dig[0] : uint64) 		m |= (x.dig[1] : uint64) << 32	else		m = (x.dig[0] : uint64) << lim.loshift	;;	z = std.flt64frombits(m) 	match std.bigcmp(rem, v)	| `std.Before:	/* nothing */	| `std.After:	z = nextfloat(z, lim)	| `std.Equal:		if !std.bigiseven(x)			z = nextfloat(z, lim)		;;	;;	-> z} const mkflt = {mant, exp	var m, e	if mant.dig.len == 2		/* flt64: guaranteed to be in the range 2^52..2^53 */		m = (mant.dig[0] : uint64) 		m |= (mant.dig[1] : uint64) << 32	else		/* flt32: 2^22..2^23, so adjust into flt64 range */		m = (mant.dig[0] : uint64) << 30		exp -= 30	;;	m &= (1<<52) - 1 	e = (exp : uint64)	e += 1023 + 52 /* exponent bias */	e &= 0x7ff	e <<= 52 	-> std.flt64frombits(m | e) }