strconv,js: f64_to_str works on JS backend now; Fix BigInt usage in infix expressions (#12464)

Author: playXE

vlib/strconv/f32_str.js.v

@@ -0,0 +1 @@
+module strconv

vlib/strconv/f64_str.c.v

@@ -20,42 +20,6 @@ https://github.com/cespare/ryu/tree/ba56a33f39e3bbbfa409095d0f9ae168a595feea
 
 =============================================================================*/
 
-// pow of ten table used by n_digit reduction
-const (
-	ten_pow_table_64 = [
-		u64(1),
-		u64(10),
-		u64(100),
-		u64(1000),
-		u64(10000),
-		u64(100000),
-		u64(1000000),
-		u64(10000000),
-		u64(100000000),
-		u64(1000000000),
-		u64(10000000000),
-		u64(100000000000),
-		u64(1000000000000),
-		u64(10000000000000),
-		u64(100000000000000),
-		u64(1000000000000000),
-		u64(10000000000000000),
-		u64(100000000000000000),
-		u64(1000000000000000000),
-		u64(10000000000000000000),
-	]
-)
-
-//=============================================================================
-// Conversion Functions
-//=============================================================================
-const (
-	mantbits64 = u32(52)
-	expbits64  = u32(11)
-	bias64     = 1023 // f64 exponent bias
-	maxexp64   = 2047
-)
-
 [direct_array_access]
 fn (d Dec64) get_string_64(neg bool, i_n_digit int, i_pad_digit int) string {
 	mut n_digit := i_n_digit + 1
@@ -87,10 +51,10 @@ fn (d Dec64) get_string_64(neg bool, i_n_digit int, i_pad_digit int) string {
 	// rounding last used digit
 	if n_digit < out_len {
 		// println("out:[$out]")
-		out += strconv.ten_pow_table_64[out_len - n_digit - 1] * 5 // round to up
-		out /= strconv.ten_pow_table_64[out_len - n_digit]
+		out += ten_pow_table_64[out_len - n_digit - 1] * 5 // round to up
+		out /= ten_pow_table_64[out_len - n_digit]
 		// println("out1:[$out] ${d.m / ten_pow_table_64[out_len - n_digit ]}")
-		if d.m / strconv.ten_pow_table_64[out_len - n_digit] < out {
+		if d.m / ten_pow_table_64[out_len - n_digit] < out {
 			d_exp++
 			n_digit++
 		}
@@ -170,11 +134,11 @@ fn (d Dec64) get_string_64(neg bool, i_n_digit int, i_pad_digit int) string {
 
 fn f64_to_decimal_exact_int(i_mant u64, exp u64) (Dec64, bool) {
 	mut d := Dec64{}
-	e := exp - strconv.bias64
-	if e > strconv.mantbits64 {
+	e := exp - bias64
+	if e > mantbits64 {
 		return d, false
 	}
-	shift := strconv.mantbits64 - e
+	shift := mantbits64 - e
 	mant := i_mant | u64(0x0010_0000_0000_0000) // implicit 1
 	// mant  := i_mant | (1 << mantbits64) // implicit 1
 	d.m = mant >> shift
@@ -195,11 +159,11 @@ fn f64_to_decimal(mant u64, exp u64) Dec64 {
 	if exp == 0 {
 		// We subtract 2 so that the bounds computation has
 		// 2 additional bits.
-		e2 = 1 - strconv.bias64 - int(strconv.mantbits64) - 2
+		e2 = 1 - bias64 - int(mantbits64) - 2
 		m2 = mant
 	} else {
-		e2 = int(exp) - strconv.bias64 - int(strconv.mantbits64) - 2
-		m2 = (u64(1) << strconv.mantbits64) | mant
+		e2 = int(exp) - bias64 - int(mantbits64) - 2
+		m2 = (u64(1) << mantbits64) | mant
 	}
 	even := (m2 & 1) == 0
 	accept_bounds := even
@@ -373,13 +337,13 @@ pub fn f64_to_str(f f64, n_digit int) string {
 	u1.f = f
 	u := unsafe { u1.u }
 
-	neg := (u >> (strconv.mantbits64 + strconv.expbits64)) != 0
-	mant := u & ((u64(1) << strconv.mantbits64) - u64(1))
-	exp := (u >> strconv.mantbits64) & ((u64(1) << strconv.expbits64) - u64(1))
+	neg := (u >> (mantbits64 + expbits64)) != 0
+	mant := u & ((u64(1) << mantbits64) - u64(1))
+	exp := (u >> mantbits64) & ((u64(1) << expbits64) - u64(1))
 	// println("s:${neg} mant:${mant} exp:${exp} float:${f} byte:${u1.u:016lx}")
 
 	// Exit early for easy cases.
-	if (exp == strconv.maxexp64) || (exp == 0 && mant == 0) {
+	if (exp == maxexp64) || (exp == 0 && mant == 0) {
 		return get_string_special(neg, exp == 0, mant == 0)
 	}
 
@@ -398,13 +362,13 @@ pub fn f64_to_str_pad(f f64, n_digit int) string {
 	u1.f = f
 	u := unsafe { u1.u }
 
-	neg := (u >> (strconv.mantbits64 + strconv.expbits64)) != 0
-	mant := u & ((u64(1) << strconv.mantbits64) - u64(1))
-	exp := (u >> strconv.mantbits64) & ((u64(1) << strconv.expbits64) - u64(1))
+	neg := (u >> (mantbits64 + expbits64)) != 0
+	mant := u & ((u64(1) << mantbits64) - u64(1))
+	exp := (u >> mantbits64) & ((u64(1) << expbits64) - u64(1))
 	// println("s:${neg} mant:${mant} exp:${exp} float:${f} byte:${u1.u:016lx}")
 
 	// Exit early for easy cases.
-	if (exp == strconv.maxexp64) || (exp == 0 && mant == 0) {
+	if (exp == maxexp64) || (exp == 0 && mant == 0) {
 		return get_string_special(neg, exp == 0, mant == 0)
 	}