1use 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#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14pub(crate) struct Dec {
15 pub mantissa: i128,
16 pub scale: u32,
17}
18
19pub 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}