Skip to main content

vibe/stdlib_v2/num_and_autodiff/
decimal.rs

1//! Strict Non-Coercing Numeric Parsers (`num.parse_*`) and Exact Base-10 `Decimal`
2//! Arithmetic (`decimal.*`) for VibeScript v0.02.
3
4use std::collections::BTreeMap;
5
6use crate::error::{DiagCode, Diagnostic};
7use crate::span::Span;
8use crate::value::Value;
9
10use super::{extract_i64, extract_str, opt_i64, opt_str};
11
12/// Internal exact base-10 decimal (`value = mantissa * 10^-scale`).
13#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14pub(crate) struct Dec {
15    pub mantissa: i128,
16    pub scale: u32,
17}
18
19/// Dispatch `num.parse_*` and `decimal.*` calls.
20pub fn call_decimal(
21    path: &str,
22    args: &[Value],
23    span: Span,
24) -> Result<Option<Value>, Diagnostic> {
25    match path {
26        "num.parse_i64" => {
27            let Some(Value::String(s)) = args.first() else {
28                return Ok(Some(parse_res(false, Value::Null, "non-string input")));
29            };
30            let radix = opt_i64(args, 1, 10);
31            if !(2..=36).contains(&radix) {
32                return Ok(Some(parse_res(false, Value::Null, "radix out of range 2..=36")));
33            }
34            Ok(Some(strict_parse_i64(s, radix as u32)))
35        }
36        "num.parse_u64" => {
37            let Some(Value::String(s)) = args.first() else {
38                return Ok(Some(parse_res(false, Value::Null, "non-string input")));
39            };
40            let radix = opt_i64(args, 1, 10);
41            if !(2..=36).contains(&radix) {
42                return Ok(Some(parse_res(false, Value::Null, "radix out of range 2..=36")));
43            }
44            Ok(Some(strict_parse_u64(s, radix as u32)))
45        }
46        "num.parse_f64" => {
47            let Some(Value::String(s)) = args.first() else {
48                return Ok(Some(parse_res(false, Value::Null, "non-string input")));
49            };
50            Ok(Some(strict_parse_f64(s)))
51        }
52        "decimal.from_str" => {
53            let s = extract_str(args, 0, "decimal.from_str(text)", span)?;
54            let d = parse_dec_str(&s, span)?;
55            Ok(Some(dec_to_record(d)))
56        }
57        "decimal.from_parts" => {
58            let mantissa = extract_i64(args, 0, "decimal.from_parts(mantissa, scale)", span)?;
59            let scale = extract_i64(args, 1, "decimal.from_parts(mantissa, scale)", span)?;
60            if !(0..=28).contains(&scale) {
61                return Err(Diagnostic::new(
62                    DiagCode::E100,
63                    span,
64                    "decimal.from_parts: scale must be in 0..=28",
65                ));
66            }
67            Ok(Some(dec_to_record(Dec {
68                mantissa: mantissa as i128,
69                scale: scale as u32,
70            })))
71        }
72        "decimal.add" => {
73            let a = coerce_dec(args.first(), "decimal.add", span)?;
74            let b = coerce_dec(args.get(1), "decimal.add", span)?;
75            let (ma, mb, sc) = align_scales(a, b);
76            Ok(Some(dec_to_record(strip_trailing_zeros(Dec {
77                mantissa: ma.saturating_add(mb),
78                scale: sc,
79            }))))
80        }
81        "decimal.sub" => {
82            let a = coerce_dec(args.first(), "decimal.sub", span)?;
83            let b = coerce_dec(args.get(1), "decimal.sub", span)?;
84            let (ma, mb, sc) = align_scales(a, b);
85            Ok(Some(dec_to_record(strip_trailing_zeros(Dec {
86                mantissa: ma.saturating_sub(mb),
87                scale: sc,
88            }))))
89        }
90        "decimal.mul" => {
91            let a = coerce_dec(args.first(), "decimal.mul", span)?;
92            let b = coerce_dec(args.get(1), "decimal.mul", span)?;
93            Ok(Some(dec_to_record(strip_trailing_zeros(Dec {
94                mantissa: a.mantissa.saturating_mul(b.mantissa),
95                scale: a.scale + b.scale,
96            }))))
97        }
98        "decimal.div" => {
99            let a = coerce_dec(args.first(), "decimal.div", span)?;
100            let b = coerce_dec(args.get(1), "decimal.div", span)?;
101            if b.mantissa == 0 {
102                return Err(Diagnostic::new(
103                    DiagCode::E600,
104                    span,
105                    "decimal.div: division by zero",
106                ));
107            }
108            let target_scale = opt_i64(args, 2, 10).clamp(0, 24) as u32;
109            let shift = target_scale + b.scale;
110            let scaled_num = if shift >= a.scale {
111                a.mantissa.saturating_mul(pow10(shift - a.scale))
112            } else {
113                a.mantissa / pow10(a.scale - shift)
114            };
115            let raw = Dec {
116                mantissa: scaled_num.saturating_mul(10) / b.mantissa,
117                scale: target_scale + 1,
118            };
119            let rounded = round_dec(raw, target_scale, "half_away_from_zero", span)?;
120            Ok(Some(dec_to_record(strip_trailing_zeros(rounded))))
121        }
122        "decimal.round" => {
123            let d = coerce_dec(args.first(), "decimal.round", span)?;
124            let scale = extract_i64(args, 1, "decimal.round(d, scale, mode)", span)?.clamp(0, 28) as u32;
125            let mode = opt_str(args, 2, "half_away_from_zero");
126            let r = round_dec(d, scale, &mode, span)?;
127            Ok(Some(dec_to_record(r)))
128        }
129        "decimal.to_fixed" => {
130            let d = coerce_dec(args.first(), "decimal.to_fixed", span)?;
131            let scale = extract_i64(args, 1, "decimal.to_fixed(d, scale)", span)?.clamp(0, 28) as u32;
132            let mode = opt_str(args, 2, "half_away_from_zero");
133            let r = round_dec(d, scale, &mode, span)?;
134            Ok(Some(Value::String(format_dec(r.mantissa, r.scale))))
135        }
136        "decimal.eq" => {
137            let a = coerce_dec(args.first(), "decimal.eq", span)?;
138            let b = coerce_dec(args.get(1), "decimal.eq", span)?;
139            let (ma, mb, _) = align_scales(a, b);
140            Ok(Some(Value::Bool(ma == mb)))
141        }
142        "decimal.cmp" => {
143            let a = coerce_dec(args.first(), "decimal.cmp", span)?;
144            let b = coerce_dec(args.get(1), "decimal.cmp", span)?;
145            let (ma, mb, _) = align_scales(a, b);
146            let ord = if ma < mb {
147                -1
148            } else if ma > mb {
149                1
150            } else {
151                0
152            };
153            Ok(Some(Value::I64(ord)))
154        }
155        _ => Ok(None),
156    }
157}
158
159fn strict_parse_i64(s: &str, radix: u32) -> Value {
160    if s.is_empty() {
161        return parse_res(false, Value::Null, "empty string");
162    }
163    if s != s.trim() {
164        return parse_res(false, Value::Null, "leading or trailing whitespace");
165    }
166    let body = s.strip_prefix(['+', '-']).unwrap_or(s);
167    if body.is_empty() {
168        return parse_res(false, Value::Null, "missing digits");
169    }
170    let mut seen_digit = false;
171    for ch in body.chars() {
172        if ch.is_digit(radix) {
173            seen_digit = true;
174        } else if seen_digit {
175            return parse_res(false, Value::Null, "trailing characters");
176        } else {
177            return parse_res(false, Value::Null, "invalid digit");
178        }
179    }
180    match i64::from_str_radix(s, radix) {
181        Ok(n) => parse_res(true, Value::I64(n), ""),
182        Err(_) => parse_res(false, Value::Null, "integer overflow"),
183    }
184}
185
186fn strict_parse_u64(s: &str, radix: u32) -> Value {
187    if s.is_empty() {
188        return parse_res(false, Value::Null, "empty string");
189    }
190    if s != s.trim() {
191        return parse_res(false, Value::Null, "leading or trailing whitespace");
192    }
193    if s.starts_with('-') {
194        return parse_res(false, Value::Null, "negative value for u64");
195    }
196    let body = s.strip_prefix('+').unwrap_or(s);
197    if body.is_empty() {
198        return parse_res(false, Value::Null, "missing digits");
199    }
200    let mut seen_digit = false;
201    for ch in body.chars() {
202        if ch.is_digit(radix) {
203            seen_digit = true;
204        } else if seen_digit {
205            return parse_res(false, Value::Null, "trailing characters");
206        } else {
207            return parse_res(false, Value::Null, "invalid digit");
208        }
209    }
210    match u64::from_str_radix(body, radix) {
211        Ok(n) => parse_res(true, Value::U64(n), ""),
212        Err(_) => parse_res(false, Value::Null, "integer overflow"),
213    }
214}
215
216fn strict_parse_f64(s: &str) -> Value {
217    if s.is_empty() {
218        return parse_res(false, Value::Null, "empty string");
219    }
220    if s != s.trim() {
221        return parse_res(false, Value::Null, "leading or trailing whitespace");
222    }
223    let body = s.strip_prefix(['+', '-']).unwrap_or(s);
224    if body.is_empty() {
225        return parse_res(false, Value::Null, "missing digits");
226    }
227    let first = body.chars().next().unwrap_or(' ');
228    if !first.is_ascii_digit() && first != '.' {
229        return parse_res(false, Value::Null, "invalid float syntax");
230    }
231    for (idx, ch) in body.char_indices() {
232        let valid = ch.is_ascii_digit()
233            || ch == '.'
234            || ch == 'e'
235            || ch == 'E'
236            || ((ch == '+' || ch == '-')
237                && idx > 0
238                && matches!(body.as_bytes()[idx - 1], b'e' | b'E'));
239        if !valid {
240            return parse_res(false, Value::Null, "trailing characters");
241        }
242    }
243    match s.parse::<f64>() {
244        Ok(v) if v.is_finite() => parse_res(true, Value::F64(v), ""),
245        _ => parse_res(false, Value::Null, "invalid or non-finite float"),
246    }
247}
248
249fn parse_res(ok: bool, value: Value, error: &str) -> Value {
250    let mut rec = BTreeMap::new();
251    rec.insert("ok".into(), Value::Bool(ok));
252    rec.insert("value".into(), value);
253    rec.insert("error".into(), Value::String(error.into()));
254    Value::Record(rec)
255}
256
257pub(crate) fn coerce_dec(
258    val: Option<&Value>,
259    ctx: &str,
260    span: Span,
261) -> Result<Dec, Diagnostic> {
262    match val {
263        Some(Value::Record(m)) => {
264            if let (Some(man), Some(sc)) = (
265                m.get("mantissa").and_then(Value::as_i64),
266                m.get("scale").and_then(Value::as_i64),
267            ) {
268                return Ok(Dec {
269                    mantissa: man as i128,
270                    scale: sc.max(0) as u32,
271                });
272            }
273            if let Some(Value::String(s)) = m.get("text") {
274                return parse_dec_str(s, span);
275            }
276            Err(Diagnostic::new(
277                DiagCode::E100,
278                span,
279                format!("{ctx}: invalid Decimal record"),
280            ))
281        }
282        Some(Value::String(s)) => parse_dec_str(s, span),
283        Some(Value::I64(n)) => Ok(Dec {
284            mantissa: *n as i128,
285            scale: 0,
286        }),
287        Some(Value::U64(n)) => Ok(Dec {
288            mantissa: *n as i128,
289            scale: 0,
290        }),
291        Some(Value::F64(f)) => parse_dec_str(&format!("{f}"), span),
292        _ => Err(Diagnostic::new(
293            DiagCode::E100,
294            span,
295            format!("{ctx}: expected Decimal, String, or number"),
296        )),
297    }
298}
299
300pub(crate) fn parse_dec_str(s: &str, span: Span) -> Result<Dec, Diagnostic> {
301    let trimmed = s.trim();
302    if trimmed.is_empty() {
303        return Err(Diagnostic::new(DiagCode::E100, span, "empty decimal string"));
304    }
305    let (neg, rest) = if let Some(r) = trimmed.strip_prefix('-') {
306        (true, r)
307    } else if let Some(r) = trimmed.strip_prefix('+') {
308        (false, r)
309    } else {
310        (false, trimmed)
311    };
312    let (int_part, frac_part) = match rest.split_once('.') {
313        Some((i, f)) => (i, f),
314        None => (rest, ""),
315    };
316    if (int_part.is_empty() && frac_part.is_empty())
317        || !int_part.chars().all(|c| c.is_ascii_digit())
318        || !frac_part.chars().all(|c| c.is_ascii_digit())
319    {
320        return Err(Diagnostic::new(
321            DiagCode::E100,
322            span,
323            format!("invalid decimal literal '{s}'"),
324        ));
325    }
326    let scale = frac_part.len() as u32;
327    let combined = format!("{int_part}{frac_part}");
328    let mag: i128 = combined.parse().map_err(|_| {
329        Diagnostic::new(DiagCode::E100, span, format!("decimal overflow '{s}'"))
330    })?;
331    Ok(Dec {
332        mantissa: if neg { -mag } else { mag },
333        scale,
334    })
335}
336
337pub(crate) fn round_dec(
338    d: Dec,
339    target_scale: u32,
340    mode: &str,
341    span: Span,
342) -> Result<Dec, Diagnostic> {
343    if d.scale <= target_scale {
344        let factor = pow10(target_scale - d.scale);
345        return Ok(Dec {
346            mantissa: d.mantissa.saturating_mul(factor),
347            scale: target_scale,
348        });
349    }
350    let diff = d.scale - target_scale;
351    let factor = pow10(diff);
352    let half = factor / 2;
353    let q = d.mantissa / factor;
354    let r = d.mantissa % factor;
355    let abs_r = r.abs();
356    let step = if d.mantissa >= 0 { 1 } else { -1 };
357
358    let rounded = match mode {
359        "half_away_from_zero" => {
360            if abs_r >= half {
361                q + step
362            } else {
363                q
364            }
365        }
366        "half_even" | "bankers" => {
367            if abs_r > half || (abs_r == half && q.abs() % 2 != 0) {
368                q + step
369            } else {
370                q
371            }
372        }
373        "floor" => {
374            if r < 0 {
375                q - 1
376            } else {
377                q
378            }
379        }
380        "ceil" => {
381            if r > 0 {
382                q + 1
383            } else {
384                q
385            }
386        }
387        "trunc" | "toward_zero" => q,
388        _ => {
389            return Err(Diagnostic::new(
390                DiagCode::E100,
391                span,
392                format!("unsupported rounding mode '{mode}'"),
393            ))
394        }
395    };
396    Ok(Dec {
397        mantissa: rounded,
398        scale: target_scale,
399    })
400}
401
402fn align_scales(a: Dec, b: Dec) -> (i128, i128, u32) {
403    let sc = a.scale.max(b.scale);
404    let ma = a.mantissa.saturating_mul(pow10(sc - a.scale));
405    let mb = b.mantissa.saturating_mul(pow10(sc - b.scale));
406    (ma, mb, sc)
407}
408
409fn strip_trailing_zeros(mut d: Dec) -> Dec {
410    while d.scale > 0 && d.mantissa != 0 && d.mantissa % 10 == 0 {
411        d.mantissa /= 10;
412        d.scale -= 1;
413    }
414    if d.mantissa == 0 {
415        d.scale = 0;
416    }
417    d
418}
419
420pub(crate) fn format_dec(mantissa: i128, scale: u32) -> String {
421    if scale == 0 {
422        return mantissa.to_string();
423    }
424    let neg = mantissa < 0;
425    let abs = mantissa.unsigned_abs();
426    let factor = pow10(scale) as u128;
427    let int_part = abs / factor;
428    let frac_part = abs % factor;
429    let sign = if neg { "-" } else { "" };
430    format!("{sign}{int_part}.{frac_part:0width$}", width = scale as usize)
431}
432
433fn dec_to_record(d: Dec) -> Value {
434    let text = format_dec(d.mantissa, d.scale);
435    let mut rec = BTreeMap::new();
436    rec.insert("__decimal".into(), Value::Bool(true));
437    rec.insert(
438        "mantissa".into(),
439        Value::I64(d.mantissa.clamp(i64::MIN as i128, i64::MAX as i128) as i64),
440    );
441    rec.insert("scale".into(), Value::I64(d.scale as i64));
442    rec.insert("text".into(), Value::String(text));
443    Value::Record(rec)
444}
445
446fn pow10(exp: u32) -> i128 {
447    10_i128.saturating_pow(exp.min(36))
448}