goscript 0.2.5 → 0.2.7

package/gs/strconv/atof.gs.ts

@@ -1,60 +1,174 @@
 import * as $ from "@goscript/builtin/index.js";
-import { ErrSyntax, ErrRange, NumError } from "./atoi.gs.js";
+import { ErrSyntax, ErrRange, NumError, underscoreOK } from "./atoi.gs.js";
 
-// ParseFloat converts the string s to a floating-point number
-// with the precision specified by bitSize: 32 for float32, or 64 for float64.
-// When bitSize=32, the result still has type float64, but it will be
-// convertible to float32 without changing its value.
-export function ParseFloat(s: string, bitSize: number): [number, $.GoError] {
+const maxFloat32 = 3.4028234663852886e+38;
+
+// special matches Go's special-value parsing: an optional sign followed by a
+// case-insensitive inf/infinity/nan, with nan rejecting a sign. It returns the
+// value and whether s was a special form.
+function special(s: string): [number, boolean] {
 	if (s === "") {
-		return [0, new NumError({Func: "ParseFloat", Num: s, Err: ErrSyntax})];
+		return [0, false];
+	}
+	let sign = 1;
+	let nsign = 0;
+	if (s[0] === '+' || s[0] === '-') {
+		if (s[0] === '-') {
+			sign = -1;
+		}
+		nsign = 1;
+	}
+	const body = s.slice(nsign).toLowerCase();
+	if (body === "nan") {
+		if (nsign === 1) {
+			return [0, false]; // signed NaN is not accepted
+		}
+		return [NaN, true];
+	}
+	if (body === "inf" || body === "infinity") {
+		return [sign * Infinity, true];
+	}
+	return [0, false];
+}
+
+// parseHexFloat parses Go's hexadecimal floating-point syntax
+// (0x1.8p3) into a float64, returning [value, ok]. The exponent letter p and a
+// decimal exponent are mandatory; the value is mantissa * 2^(exp - 4*fracDigits).
+function parseHexFloat(s: string): [number, boolean] {
+	let sign = 1;
+	let i = 0;
+	if (s[0] === '+' || s[0] === '-') {
+		if (s[0] === '-') {
+			sign = -1;
+		}
+		i = 1;
+	}
+	if (i + 1 >= s.length || s[i] !== '0' || s[i + 1].toLowerCase() !== 'x') {
+		return [0, false];
+	}
+	i += 2;
+	let intPart = "";
+	while (i < s.length && /[0-9a-fA-F]/.test(s[i])) {
+		intPart += s[i];
+		i++;
+	}
+	let fracPart = "";
+	if (i < s.length && s[i] === '.') {
+		i++;
+		while (i < s.length && /[0-9a-fA-F]/.test(s[i])) {
+			fracPart += s[i];
+			i++;
+		}
+	}
+	if (intPart === "" && fracPart === "") {
+		return [0, false];
+	}
+	if (i >= s.length || s[i].toLowerCase() !== 'p') {
+		return [0, false]; // exponent is required for hex floats
 	}
+	i++;
+	let expSign = 1;
+	if (i < s.length && (s[i] === '+' || s[i] === '-')) {
+		if (s[i] === '-') {
+			expSign = -1;
+		}
+		i++;
+	}
+	if (i >= s.length) {
+		return [0, false];
+	}
+	let expStr = "";
+	while (i < s.length && s[i] >= '0' && s[i] <= '9') {
+		expStr += s[i];
+		i++;
+	}
+	if (expStr === "" || i !== s.length) {
+		return [0, false];
+	}
+	const mant = parseInt(intPart + fracPart, 16);
+	const exp = expSign * parseInt(expStr, 10) - 4 * fracPart.length;
+	return [sign * mant * Math.pow(2, exp), true];
+}
+
+// decimalSyntaxOK reports whether s is a syntactically valid Go decimal float
+// literal (after underscores are removed): optional sign, a mantissa with digits
+// on at least one side of an optional dot, and an optional decimal exponent.
+function decimalSyntaxOK(s: string): boolean {
+	return /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/.test(s);
+}
 
-	// Validate bitSize
-	if (bitSize !== 32 && bitSize !== 64) {
-		return [0, new NumError({Func: "ParseFloat", Num: s, Err: ErrSyntax})];
+// hasNonZeroDigit reports whether s contains a digit other than 0, used to tell
+// a true zero from an underflow to zero.
+function hasNonZeroDigit(s: string): boolean {
+	for (const ch of s) {
+		if (ch >= '1' && ch <= '9') {
+			return true;
+		}
 	}
+	return false;
+}
+
+// ParseFloat converts the string s to a floating-point number with the precision
+// specified by bitSize: 32 for float32 or 64 for float64. The result always has
+// type float64; for bitSize 32 it is rounded to float32 precision and reports
+// ErrRange on overflow to infinity or underflow to zero. Any bitSize other than
+// 32 is treated as float64.
+export function ParseFloat(s: string, bitSize: number): [number, $.GoError] {
+	const syntax = (): [number, $.GoError] => [0, new NumError({Func: "ParseFloat", Num: s, Err: ErrSyntax})];
+	const range = (v: number): [number, $.GoError] => [v, new NumError({Func: "ParseFloat", Num: s, Err: ErrRange})];
 
-	// Handle special cases
-	const lower = s.toLowerCase();
-	switch (lower) {
-		case "+inf":
-		case "inf":
-		case "+infinity":
-		case "infinity":
-			return [Infinity, null];
-		case "-inf":
-		case "-infinity":
-			return [-Infinity, null];
-		case "nan":
-			return [NaN, null];
+	if (s === "") {
+		return syntax();
 	}
 
-	// Remove underscores if present (Go allows them in numeric literals)
-	let cleanS = s;
-	if (s.includes('_')) {
-		cleanS = s.replace(/_/g, '');
+	const [sv, isSpecial] = special(s);
+	if (isSpecial) {
+		return [sv, null];
 	}
 
-	// Use JavaScript's parseFloat
-	const result = parseFloat(cleanS);
-	
-	if (isNaN(result)) {
-		return [0, new NumError({Func: "ParseFloat", Num: s, Err: ErrSyntax})];
+	let value: number;
+	let nonZero: boolean;
+	if (/^[+-]?0[xX]/.test(s)) {
+		const [hv, ok] = parseHexFloat(s);
+		if (!ok) {
+			return syntax();
+		}
+		value = hv;
+		nonZero = hv !== 0;
+	} else {
+		if (s.includes('_')) {
+			if (!underscoreOK(s)) {
+				return syntax();
+			}
+		}
+		const clean = s.replace(/_/g, '');
+		if (!decimalSyntaxOK(clean)) {
+			return syntax();
+		}
+		value = Number(clean);
+		nonZero = hasNonZeroDigit(clean);
 	}
 
-	// Check for range errors based on bitSize
 	if (bitSize === 32) {
-		const maxFloat32 = 3.4028234663852886e+38;
-		const minFloat32 = 1.175494351e-38;
-		
-		if (isFinite(result) && Math.abs(result) > maxFloat32) {
-			return [result > 0 ? Infinity : -Infinity, new NumError({Func: "ParseFloat", Num: s, Err: ErrRange})];
+		const f = Math.fround(value);
+		if (!isFinite(f) && isFinite(value)) {
+			return range(value > 0 ? Infinity : -Infinity);
+		}
+		if (f === 0 && nonZero) {
+			return range(0);
 		}
-		if (isFinite(result) && result !== 0 && Math.abs(result) < minFloat32) {
-			return [0, new NumError({Func: "ParseFloat", Num: s, Err: ErrRange})];
+		// A finite float64 above float32 max also overflows.
+		if (isFinite(value) && Math.abs(value) > maxFloat32) {
+			return range(value > 0 ? Infinity : -Infinity);
 		}
+		return [f, null];
 	}
 
-	return [result, null];
-} 
+	if (!isFinite(value) && nonZero) {
+		return range(value > 0 ? Infinity : -Infinity);
+	}
+	if (value === 0 && nonZero) {
+		return range(0);
+	}
+	return [value, null];
+}

package/gs/strconv/atof.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from 'vitest'
+
+import { ParseFloat } from './atof.gs.js'
+import { ErrRange, ErrSyntax, NumError } from './atoi.gs.js'
+
+// Ground truth captured from go1.26.4 strconv.ParseFloat over the same inputs.
+describe('strconv.ParseFloat (Go float syntax)', () => {
+  it('parses decimal floats and forms with a leading dot', () => {
+    expect(ParseFloat('1.5', 64)).toEqual([1.5, null])
+    expect(ParseFloat('.5', 64)).toEqual([0.5, null])
+    expect(ParseFloat('1_000.5', 64)).toEqual([1000.5, null])
+  })
+
+  it('rejects trailing junk and leading whitespace over the whole input', () => {
+    const [, errJunk] = ParseFloat('1.5abc', 64)
+    expect((errJunk as NumError).Err).toBe(ErrSyntax)
+    const [, errWs] = ParseFloat('  1.5', 64)
+    expect((errWs as NumError).Err).toBe(ErrSyntax)
+  })
+
+  it('parses Go hexadecimal floating-point syntax', () => {
+    expect(ParseFloat('0x1p2', 64)).toEqual([4, null])
+    expect(ParseFloat('0x1.8p3', 64)).toEqual([12, null])
+  })
+
+  it('reports ErrRange on overflow to infinity', () => {
+    const [v, err] = ParseFloat('1e400', 64)
+    expect(v).toBe(Infinity)
+    expect((err as NumError).Err).toBe(ErrRange)
+  })
+
+  it('rounds to float32 precision and ranges float32 overflow', () => {
+    expect(ParseFloat('0.1', 32)).toEqual([0.10000000149011612, null])
+    const [v, err] = ParseFloat('3.5e38', 32)
+    expect(v).toBe(Infinity)
+    expect((err as NumError).Err).toBe(ErrRange)
+  })
+
+  it('accepts inf and nan special forms', () => {
+    expect(ParseFloat('inf', 64)).toEqual([Infinity, null])
+    expect(ParseFloat('-Inf', 64)).toEqual([-Infinity, null])
+    const [nan] = ParseFloat('NaN', 64)
+    expect(Number.isNaN(nan)).toBe(true)
+  })
+})

package/gs/strconv/atoi.gs.ts

@@ -90,17 +90,25 @@ export function bitSizeError(fn: string, str: string, bitSize: number): NumError
 
 export let IntSize: number = 64;
 
-// lower(c) is a lower-case letter if and only if
-// c is either that lower-case letter or the equivalent upper-case letter.
-function lower(c: number): number {
-	return (c | (120 - 88));
+// digitValue decodes the value of a single base-36 digit, returning 99 (an
+// invalid sentinel above any legal base) for non-alphanumeric runes so the
+// caller rejects them with a syntax error.
+function digitValue(c: string): number {
+	if (c >= '0' && c <= '9') {
+		return c.charCodeAt(0) - 48;
+	}
+	const lc = c.toLowerCase();
+	if (lc >= 'a' && lc <= 'z') {
+		return lc.charCodeAt(0) - 97 + 10;
+	}
+	return 99;
 }
 
 // ParseUint is like ParseInt but for unsigned numbers.
-// A sign prefix is not permitted.
-export function ParseUint(s: string, base: number, bitSize: number): [number, $.GoError] {
+// A sign prefix is not permitted. It returns the uint64 value as a bigint.
+export function ParseUint(s: string, base: number, bitSize: number): [bigint, $.GoError] {
 	if (s === "") {
-		return [0, syntaxError("ParseUint", s)];
+		return [0n, syntaxError("ParseUint", s)];
 	}
 
 	const base0 = base === 0;
@@ -108,7 +116,7 @@ export function ParseUint(s: string, base: number, bitSize: number): [number, $.
 
 	// Handle base validation
 	if (base < 0 || base === 1 || base > 36) {
-		return [0, baseError("ParseUint", s0, base)];
+		return [0n, baseError("ParseUint", s0, base)];
 	}
 
 	// Handle base inference
@@ -141,118 +149,128 @@ export function ParseUint(s: string, base: number, bitSize: number): [number, $.
 	if (bitSize === 0) {
 		bitSize = 64;
 	} else if (bitSize < 0 || bitSize > 64) {
-		return [0, bitSizeError("ParseUint", s0, bitSize)];
+		return [0n, bitSizeError("ParseUint", s0, bitSize)];
 	}
 
-	// Check for underscores only if base0 (auto-detected base)
+	// Underscores are permitted only when the base was auto-detected, and only
+	// between digits. Validate against the original string so the base prefix
+	// and hex-digit context are visible to underscoreOK.
 	if (base0 && s.includes('_')) {
-		if (!underscoreOK(s)) {
-			return [0, syntaxError("ParseUint", s0)];
+		if (!underscoreOK(s0)) {
+			return [0n, syntaxError("ParseUint", s0)];
 		}
 		s = s.replace(/_/g, '');
 	}
 
-	// Use JavaScript's parseInt
-	const result = parseInt(s, base);
-	
-	if (isNaN(result) || !isFinite(result)) {
-		return [0, syntaxError("ParseUint", s0)];
-	}
-
-	if (result < 0) {
-		return [0, syntaxError("ParseUint", s0)];
+	if (s === "") {
+		return [0n, syntaxError("ParseUint", s0)];
 	}
 
-	// Check range for the specified bit size
-	// Note: JavaScript bitwise operators only work on 32-bit integers,
-	// so we use Math.pow() for larger bit sizes
-	let maxVal: number;
-	if (bitSize >= 53) {
-		// For 53+ bits, use MAX_SAFE_INTEGER as JavaScript can't represent larger integers accurately
-		maxVal = Number.MAX_SAFE_INTEGER;
-	} else {
-		maxVal = Math.pow(2, bitSize) - 1;
-	}
-	if (result > maxVal) {
-		return [0, rangeError("ParseUint", s0)];
+	const baseBig = BigInt(base);
+	const maxVal = (1n << BigInt(bitSize)) - 1n;
+	let n = 0n;
+	for (const ch of s) {
+		const d = digitValue(ch);
+		if (d >= base) {
+			return [0n, syntaxError("ParseUint", s0)];
+		}
+		n = n * baseBig + BigInt(d);
+		if (n > maxVal) {
+			return [maxVal, rangeError("ParseUint", s0)];
+		}
 	}
 
-	return [result, null];
+	return [n, null];
 }
 
 // ParseInt interprets a string s in the given base (0, 2 to 36) and
-// bit size (0 to 64) and returns the corresponding value i.
-export function ParseInt(s: string, base: number, bitSize: number): [number, $.GoError] {
+// bit size (0 to 64) and returns the corresponding value i as a bigint.
+export function ParseInt(s: string, base: number, bitSize: number): [bigint, $.GoError] {
 	if (s === "") {
-		return [0, syntaxError("ParseInt", s)];
+		return [0n, syntaxError("ParseInt", s)];
 	}
 
+	const s0 = s;
 	let neg = false;
 	if (s[0] === '+' || s[0] === '-') {
 		neg = s[0] === '-';
 		s = s.slice(1);
 		if (s.length < 1) {
-			return [0, syntaxError("ParseInt", s)];
+			return [0n, syntaxError("ParseInt", s0)];
 		}
 	}
 
 	// Convert to unsigned first
 	const [un, err] = ParseUint(s, base, bitSize);
-	if (err !== null) {
+	if (err !== null && (err as NumError).Err !== ErrRange) {
 		const numErr = err as NumError;
 		numErr.Func = "ParseInt";
-		return [0, err];
+		numErr.Num = s0;
+		return [0n, numErr];
 	}
 
 	if (bitSize === 0) {
 		bitSize = 64;
 	}
 
-	// Note: JavaScript bitwise operators only work on 32-bit integers,
-	// so we use Math.pow() for larger bit sizes
-	let cutoff: number;
-	if (bitSize >= 53) {
-		// For 53+ bits, use MAX_SAFE_INTEGER as JavaScript can't represent larger integers accurately
-		cutoff = Number.MAX_SAFE_INTEGER;
-	} else {
-		cutoff = Math.pow(2, bitSize - 1);
-	}
+	const cutoff = 1n << BigInt(bitSize - 1);
 	if (!neg && un >= cutoff) {
-		return [0, rangeError("ParseInt", s)];
+		return [cutoff - 1n, rangeError("ParseInt", s0)];
 	}
 	if (neg && un > cutoff) {
-		return [0, rangeError("ParseInt", s)];
+		return [-cutoff, rangeError("ParseInt", s0)];
 	}
 
-	const result = neg ? -un : un;
-	return [result, null];
+	return [neg ? -un : un, null];
 }
 
 // Atoi is equivalent to ParseInt(s, 10, 0), converted to type int.
 export function Atoi(s: string): [number, $.GoError] {
 	const [i64, err] = ParseInt(s, 10, 0);
-	return [i64, err];
+	return [Number(i64), err];
 }
 
-// underscoreOK reports whether the underscores in s are allowed.
-function underscoreOK(s: string): boolean {
-	// Simplified validation for underscores
-	if (s.length === 0) {
-		return false;
+// underscoreOK reports whether the underscores in s are allowed, matching Go's
+// strconv.underscoreOK: an underscore must sit directly between two digits (or
+// between a base prefix and a digit), never adjacent to a sign, prefix letter,
+// dot, exponent marker, or another underscore. Used by ParseUint and ParseFloat.
+export function underscoreOK(s: string): boolean {
+	// saw tracks the previous character class: '^' start, '0' digit or prefix,
+	// '_' underscore, '!' anything else.
+	let saw = '^';
+	let i = 0;
+	if (s.length >= 1 && (s[0] === '-' || s[0] === '+')) {
+		s = s.slice(1);
 	}
-	
-	// Can't start or end with underscore
-	if (s[0] === '_' || s[s.length - 1] === '_') {
-		return false;
+	let hex = false;
+	if (
+		s.length >= 2 &&
+		s[0] === '0' &&
+		(s[1].toLowerCase() === 'b' || s[1].toLowerCase() === 'o' || s[1].toLowerCase() === 'x')
+	) {
+		i = 2;
+		saw = '0';
+		hex = s[1].toLowerCase() === 'x';
 	}
-	
-	// Can't have consecutive underscores
-	for (let i = 0; i < s.length - 1; i++) {
-		if (s[i] === '_' && s[i + 1] === '_') {
+	for (; i < s.length; i++) {
+		const c = s[i];
+		const lc = c.toLowerCase();
+		if ((c >= '0' && c <= '9') || (hex && lc >= 'a' && lc <= 'f')) {
+			saw = '0';
+			continue;
+		}
+		if (c === '_') {
+			if (saw !== '0') {
+				return false;
+			}
+			saw = '_';
+			continue;
+		}
+		if (saw === '_') {
 			return false;
 		}
+		saw = '!';
 	}
-	
-	return true;
+	return saw !== '_';
 }
 

package/gs/strconv/atoi.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it } from 'vitest'
+
+import { ErrRange, ErrSyntax, NumError, ParseInt, ParseUint } from './atoi.gs.js'
+
+// Ground truth captured from go1.26.4 strconv.ParseUint / ParseInt.
+describe('strconv.ParseUint (Go base + validation)', () => {
+  it('rejects trailing non-digit junk', () => {
+    const [, err] = ParseUint('12abc', 10, 64)
+    expect((err as NumError).Err).toBe(ErrSyntax)
+  })
+
+  it('infers base from 0x, 0b, and 0o prefixes when base is 0', () => {
+    expect(ParseUint('0xff', 0, 64)).toEqual([255n, null])
+    expect(ParseUint('0b101', 0, 64)).toEqual([5n, null])
+    expect(ParseUint('0o17', 0, 64)).toEqual([15n, null])
+    expect(ParseUint('0', 0, 64)).toEqual([0n, null])
+  })
+
+  it('enforces the bit-size range ceiling', () => {
+    expect(ParseUint('255', 10, 8)).toEqual([255n, null])
+    const [v, err] = ParseUint('256', 10, 8)
+    expect(v).toBe(255n)
+    expect((err as NumError).Err).toBe(ErrRange)
+  })
+
+  it('allows underscores only when the base is auto-detected', () => {
+    expect(ParseUint('1_000', 0, 64)).toEqual([1000n, null])
+    const [, err] = ParseUint('1_000', 10, 64)
+    expect((err as NumError).Err).toBe(ErrSyntax)
+  })
+})
+
+describe('strconv.ParseInt (Go sign + range)', () => {
+  it('parses signed values within range', () => {
+    expect(ParseInt('-128', 10, 8)).toEqual([-128n, null])
+    expect(ParseInt('+42', 10, 64)).toEqual([42n, null])
+  })
+
+  it('reports ErrRange past the signed ceiling', () => {
+    const [v, err] = ParseInt('-129', 10, 8)
+    expect(v).toBe(-128n)
+    expect((err as NumError).Err).toBe(ErrRange)
+  })
+
+  it('rejects trailing junk', () => {
+    const [, err] = ParseInt('12x', 10, 64)
+    expect((err as NumError).Err).toBe(ErrSyntax)
+  })
+})