interpreter: read the leading number in strtonum and in Str values

Author: jayhemnani9910

interpreter/src/builtins.rs

@@ -17,7 +17,10 @@ use parser::{AriadneSpan, BuiltinFunction};
 
 use crate::{
     InterpreterError,
-    vm::{Interpreter, types::Value},
+    vm::{
+        Interpreter,
+        types::{Value, str_to_num},
+    },
 };
 
 use rc_vec::RcVec as Vec;
@@ -242,18 +245,27 @@ fn to_bits(v: &Value) -> u64 {
 
 fn strtonum(v: &Value) -> f64 {
     let bytes = value_bytes(v);
-    let Ok(s) = std::str::from_utf8(&bytes) else {
-        return 0.;
-    };
-    let s = s.trim_start();
-    if let Some(hex) = s.strip_prefix("0x").or_else(|| s.strip_prefix("0X")) {
-        return u64::from_str_radix(hex, 16).map_or(0., |n| n as f64);
-    }
-    if s.len() > 1 && s.starts_with('0') && s.bytes().all(|b| (b'0'..=b'7').contains(&b)) {
-        // Leading zero and only octal digits → octal, as in gawk `strtonum`.
-        return u64::from_str_radix(s, 8).map_or(0., |n| n as f64);
+    // As in gawk, a hex or octal prefix only counts at the very start; an 8,
+    // 9, `.` or exponent after the leading 0 makes it a decimal number.
+    match bytes.as_slice() {
+        [b'0', b'x' | b'X', rest @ ..] => rest
+            .iter()
+            .map_while(|&b| char::from(b).to_digit(16))
+            .fold(0., |n, d| n * 16. + f64::from(d)),
+        [b'0', rest @ ..] => {
+            let octal = rest
+                .iter()
+                .take_while(|b| (b'0'..=b'7').contains(*b))
+                .count();
+            match rest.get(octal) {
+                Some(b'8' | b'9' | b'.' | b'e' | b'E') => str_to_num(&bytes),
+                _ => rest[..octal]
+                    .iter()
+                    .fold(0., |n, &d| n * 8. + f64::from(d - b'0')),
+            }
+        }
+        _ => str_to_num(&bytes),
     }
-    s.parse().unwrap_or(0.)
 }
 
 fn value_bytes(v: &Value) -> Vec<u8> {
@@ -278,6 +290,11 @@ mod tests {
         f(&mut intrp);
     }
 
+    #[test]
+    fn str_value_reads_the_leading_number() {
+        assert_eq!(Value::new_str(b" 3x").to_num(), 3.);
+    }
+
     #[test]
     fn int_truncates_toward_zero() {
         with_intrp(|intrp| {

interpreter/src/vm/types.rs

@@ -60,7 +60,7 @@ pub struct AwkNum(f64);
 /// are skipped and the longest prefix that is a decimal number counts, so
 /// `" 12 "` is 12, `"3x"` is 3 and `"x"` is 0. Like gawk, `inf` and `nan`
 /// are only recognized with a sign and nothing else but blanks around them.
-fn str_to_num(s: &[u8]) -> f64 {
+pub(crate) fn str_to_num(s: &[u8]) -> f64 {
     let is_blank = |b: &u8| matches!(b, b' ' | b'\t' | b'\n' | 0x0B | 0x0C | b'\r');
     let s = &s[s.iter().take_while(|b| is_blank(b)).count()..];
     let digits = |from: usize| {
@@ -334,6 +334,8 @@ impl<'a> AwkValue<'a> {
             &Self::Int(AwkInt(n)) => n as f64,
             &Self::Bool(AwkBool(b)) => b as usize as f64,
             Self::String(s) => str_to_num(s),
+            Self::Str(s) => str_to_num(s),
+            Self::StrNum(s) => s.num.0,
             _ => 0.,
         }
     }

tests/by-util/test_awk.rs

@@ -1052,3 +1052,18 @@ fn fields_with_blanks_around_numbers_sum() {
         .succeeds()
         .stdout_only("26\n");
 }
+
+#[test]
+fn strtonum_reads_the_leading_number() {
+    ucmd()
+        .arg(
+            r#"BEGIN {
+                print strtonum("3x"), strtonum(" 12 "), strtonum("-3x"), strtonum(".5x"), strtonum("1e3x")
+                print strtonum("0x1Fz"), strtonum("0X1g"), strtonum("0x"), strtonum(" 0x10"), strtonum("+0x10")
+                print strtonum("017x"), strtonum("0778"), strtonum("0189"), strtonum("01.5"), strtonum("017e1")
+                print strtonum("x"), strtonum(""), strtonum("0"), strtonum("00"), strtonum("0xFFFFFFFF")
+            }"#,
+        )
+        .succeeds()
+        .stdout_only("3 12 -3 0.5 1000\n31 1 0 0 0\n15 778 189 1.5 170\n0 0 0 0 4294967295\n");
+}