strconv: fix handling of subnormal numbers like '1.23e-308'.f64() (fix #25751) (#25752)

Author: davlgd

vlib/strconv/atof.c.v

@@ -298,6 +298,30 @@ fn converter(mut pn PrepNumber) u64 {
 			s0 = q0
 		}
 	}
+
+	// Handle subnormal (denormalized) numbers - very small numbers near zero
+	//
+	// Normal floats have an implicit leading 1 bit in their mantissa (like 1.xxxxx).
+	// When numbers get too small (binexp < -1022), we can't represent them normally.
+	// Instead, we use subnormals: set exponent to 0 and shift the mantissa right,
+	// losing precision gradually. This prevents abrupt underflow to zero.
+	//
+	// Example: 1.23e-308 is smaller than the minimum normal float, so we:
+	// 1. Keep the normalized mantissa from s2 and s1
+	// 2. Shift it right to "denormalize" it (the leading 1 moves into the mantissa)
+	// 3. Round correctly using the bits that were shifted out
+	// 4. Return with exponent = 0 (subnormal marker)
+	if binexp < -1022 && (s2 | s1) != 0 {
+		shift := -1022 - binexp
+		if shift > 60 {
+			return if pn.negative { double_minus_zero } else { double_plus_zero }
+		}
+		shifted := ((u64(s2) << 32) | u64(s1)) >> u32(shift)
+		q := (shifted >> 8) +
+			u64((shifted >> 7) & 1 != 0 && ((shifted & 0x7F) != 0 || (shifted >> 8) & 1 != 0))
+		return (q & 0x000FFFFFFFFFFFFF) | (u64(pn.negative) << 63)
+	}
+
 	// rounding if needed
 	/*
 	* "round half to even" algorithm
@@ -374,6 +398,8 @@ fn converter(mut pn PrepNumber) u64 {
 			result = double_plus_infinity
 		}
 	} else if binexp < 1 {
+		// Should not reach here for subnormals anymore (handled earlier)
+		// This is now only for true zeros
 		if pn.negative {
 			result = double_minus_zero
 		} else {

vlib/strconv/atof_test.c.v

@@ -82,6 +82,29 @@ fn test_atof() {
 	println('DONE!')
 }
 
+fn test_atof_subnormal() {
+	// Test subnormal (denormalized) float numbers and edge cases
+	// These are very small numbers close to the f64 minimum
+	// IMPORTANT: Compare with hardcoded f64 literals, not .f64() which uses the same parser
+
+	// Normal numbers
+	assert strconv.atof64('1.0e-250') or { panic('parse error') } == 1.0e-250
+	assert strconv.atof64('2.5e-260') or { panic('parse error') } == 2.5e-260
+
+	// Transition zone
+	assert strconv.atof64('1.0e-300') or { panic('parse error') } == 1.0e-300
+	assert strconv.atof64('2.2250738585072014e-308') or { panic('parse error') } == 2.2250738585072014e-308
+
+	// Subnormal numbers (these fail without the fix)
+	assert strconv.atof64('1.23e-308') or { panic('parse error') } == 1.23e-308
+	assert strconv.atof64('1.0e-310') or { panic('parse error') } == 1.0e-310
+	assert strconv.atof64('5.0e-320') or { panic('parse error') } == 5.0e-320
+	assert strconv.atof64('5e-324') or { panic('parse error') } == 5e-324
+
+	// Negative subnormal
+	assert strconv.atof64('-1.0e-320') or { panic('parse error') } == -1.0e-320
+}
+
 fn test_atof_errors() {
 	if x := strconv.atof64('') {
 		eprintln('> x: ${x}')