superacli 1.1.4 → 1.1.6

package/ref-monty/crates/monty/src/builtins/pow.rs

@@ -0,0 +1,365 @@
+//! Implementation of the pow() builtin function.
+
+use num_bigint::BigInt;
+use num_traits::{Signed, ToPrimitive, Zero};
+
+use crate::{
+    args::ArgValues,
+    bytecode::VM,
+    defer_drop,
+    exception_private::{ExcType, RunResult, SimpleException},
+    heap::{Heap, HeapData},
+    resource::{ResourceTracker, check_pow_size},
+    types::{LongInt, PyTrait},
+    value::Value,
+};
+
+/// Implementation of the pow() builtin function.
+///
+/// Returns base to the power exp. With three arguments, returns (base ** exp) % mod.
+/// Handles negative exponents by returning a float.
+pub fn builtin_pow(vm: &mut VM<'_, '_, impl ResourceTracker>, args: ArgValues) -> RunResult<Value> {
+    // pow() accepts 2 or 3 arguments
+    let positional = args.into_pos_only("pow", vm.heap)?;
+    defer_drop!(positional, vm);
+
+    match positional.as_slice() {
+        [base, exp] => {
+            let base = normalize_bool(base);
+            let exp = normalize_bool(exp);
+            two_arg_pow(base, exp, vm.heap)
+        }
+        [base, exp, m] => {
+            let base = normalize_bool(base);
+            let exp = normalize_bool(exp);
+            let m = normalize_bool(m);
+            // Three-argument pow: modular exponentiation
+            match (base, exp, m) {
+                (Value::Int(b), Value::Int(e), Value::Int(m_val)) => {
+                    if *m_val == 0 {
+                        Err(SimpleException::new_msg(ExcType::ValueError, "pow() 3rd argument cannot be 0").into())
+                    } else if *e < 0 {
+                        Err(SimpleException::new_msg(
+                            ExcType::ValueError,
+                            "pow() 2nd argument cannot be negative when 3rd argument specified",
+                        )
+                        .into())
+                    } else {
+                        // Use modular exponentiation
+                        let result = mod_pow(
+                            *b,
+                            u64::try_from(*e).expect("pow exponent >= 0 but failed u64 conversion"),
+                            *m_val,
+                        );
+                        Ok(Value::Int(result))
+                    }
+                }
+                _ => Err(SimpleException::new_msg(
+                    ExcType::TypeError,
+                    "pow() 3rd argument not allowed unless all arguments are integers",
+                )
+                .into()),
+            }
+        }
+        args => Err(SimpleException::new_msg(
+            ExcType::TypeError,
+            format!("pow expected 2 or 3 arguments, got {}", args.len()),
+        )
+        .into()),
+    }
+}
+
+/// Normalizes a `Bool` to its `Int` equivalent by reference.
+///
+/// Returns `&Value::Int(0)` or `&Value::Int(1)` for bools (using static storage),
+/// and the original reference unchanged for all other types.
+fn normalize_bool(value: &Value) -> &Value {
+    static FALSE_INT: Value = Value::Int(0);
+    static TRUE_INT: Value = Value::Int(1);
+    match value {
+        Value::Bool(false) => &FALSE_INT,
+        Value::Bool(true) => &TRUE_INT,
+        other => other,
+    }
+}
+
+/// Computes (base^exp) % modulo using binary exponentiation.
+///
+/// Handles negative bases correctly using Python's modulo semantics.
+fn mod_pow(base: i64, exp: u64, modulo: i64) -> i64 {
+    if modulo == 1 {
+        return 0;
+    }
+
+    let modulo_u = u128::from(modulo.unsigned_abs());
+    let mut result: u128 = 1;
+    let mut b = base.rem_euclid(modulo) as u128;
+    let mut e = exp;
+
+    while e > 0 {
+        if e % 2 == 1 {
+            result = (result * b) % modulo_u;
+        }
+        e /= 2;
+        b = (b * b) % modulo_u;
+    }
+
+    // Convert back to signed, handling negative modulo
+    // result < modulo_u <= i64::MAX as u128, so this conversion is safe
+    let result_i64 = i64::try_from(result).expect("mod_pow result exceeds i64::MAX");
+    if modulo < 0 && result_i64 > 0 {
+        result_i64 + modulo
+    } else {
+        result_i64
+    }
+}
+
+fn checked_pow_i64(mut base: i64, mut exp: u32) -> Option<i64> {
+    let mut result: i64 = 1;
+
+    while exp > 0 {
+        if exp & 1 == 1 {
+            result = result.checked_mul(base)?;
+        }
+        exp >>= 1;
+        if exp > 0 {
+            base = base.checked_mul(base)?;
+        }
+    }
+
+    Some(result)
+}
+
+/// Implements two-argument pow with LongInt support.
+///
+/// On overflow, promotes to LongInt instead of returning an error.
+fn two_arg_pow(base: &Value, exp: &Value, heap: &mut Heap<impl ResourceTracker>) -> RunResult<Value> {
+    match (base, exp) {
+        (Value::Int(b), Value::Int(e)) => int_pow_int(*b, *e, heap),
+        (Value::Int(b), Value::Ref(id)) => {
+            // Clone to avoid borrow conflict with heap mutation
+            let e_bi = if let HeapData::LongInt(li) = heap.get(*id) {
+                li.inner().clone()
+            } else {
+                return Err(ExcType::binary_type_error(
+                    "** or pow()",
+                    base.py_type(heap),
+                    exp.py_type(heap),
+                ));
+            };
+            int_pow_longint(*b, &e_bi, heap)
+        }
+        (Value::Ref(id), Value::Int(e)) => {
+            // Clone to avoid borrow conflict with heap mutation
+            let b_bi = if let HeapData::LongInt(li) = heap.get(*id) {
+                li.inner().clone()
+            } else {
+                return Err(ExcType::binary_type_error(
+                    "** or pow()",
+                    base.py_type(heap),
+                    exp.py_type(heap),
+                ));
+            };
+            longint_pow_int(&b_bi, *e, heap)
+        }
+        (Value::Ref(id1), Value::Ref(id2)) => {
+            // Clone both to avoid borrow conflict with heap mutation
+            let b_bi = if let HeapData::LongInt(li) = heap.get(*id1) {
+                li.inner().clone()
+            } else {
+                return Err(ExcType::binary_type_error(
+                    "** or pow()",
+                    base.py_type(heap),
+                    exp.py_type(heap),
+                ));
+            };
+            let e_bi = if let HeapData::LongInt(li) = heap.get(*id2) {
+                li.inner().clone()
+            } else {
+                return Err(ExcType::binary_type_error(
+                    "** or pow()",
+                    base.py_type(heap),
+                    exp.py_type(heap),
+                ));
+            };
+            longint_pow_longint(&b_bi, &e_bi, heap)
+        }
+        (Value::Float(b), Value::Float(e)) => {
+            if *b == 0.0 && *e < 0.0 {
+                Err(ExcType::zero_negative_power())
+            } else {
+                Ok(Value::Float(b.powf(*e)))
+            }
+        }
+        (Value::Int(b), Value::Float(e)) => {
+            if *b == 0 && *e < 0.0 {
+                Err(ExcType::zero_negative_power())
+            } else {
+                Ok(Value::Float((*b as f64).powf(*e)))
+            }
+        }
+        (Value::Float(b), Value::Int(e)) => {
+            if *b == 0.0 && *e < 0 {
+                Err(ExcType::zero_negative_power())
+            } else if let Ok(exp_i32) = i32::try_from(*e) {
+                Ok(Value::Float(b.powi(exp_i32)))
+            } else {
+                Ok(Value::Float(b.powf(*e as f64)))
+            }
+        }
+        _ => Err(ExcType::binary_type_error(
+            "** or pow()",
+            base.py_type(heap),
+            exp.py_type(heap),
+        )),
+    }
+}
+
+/// int ** int with LongInt promotion on overflow.
+fn int_pow_int(b: i64, e: i64, heap: &mut Heap<impl ResourceTracker>) -> RunResult<Value> {
+    if e < 0 {
+        // Negative exponent returns float
+        if b == 0 {
+            return Err(ExcType::zero_negative_power());
+        }
+        Ok(Value::Float((b as f64).powf(e as f64)))
+    } else if let Ok(exp_u32) = u32::try_from(e) {
+        if let Some(v) = checked_pow_i64(b, exp_u32) {
+            Ok(Value::Int(v))
+        } else {
+            // Overflow - promote to LongInt
+            // Check size before computing to prevent DoS
+            check_pow_size(i64_bits(b), u64::from(exp_u32), heap.tracker())?;
+            let bi = BigInt::from(b).pow(exp_u32);
+            Ok(LongInt::new(bi).into_value(heap)?)
+        }
+    } else {
+        // Exponent too large for u32 - use BigInt for result
+        // Safety: e >= 0 at this point
+        #[expect(clippy::cast_sign_loss)]
+        let exp_u64 = e as u64;
+        // Check size before computing to prevent DoS
+        check_pow_size(i64_bits(b), exp_u64, heap.tracker())?;
+        let base_bi = BigInt::from(b);
+        let bi = bigint_pow_large(&base_bi, exp_u64)?;
+        Ok(LongInt::new(bi).into_value(heap)?)
+    }
+}
+
+/// int ** LongInt with LongInt result.
+fn int_pow_longint(b: i64, e: &BigInt, heap: &mut Heap<impl ResourceTracker>) -> RunResult<Value> {
+    if b == 0 && e.is_negative() {
+        return Err(ExcType::zero_negative_power());
+    }
+    if e.is_negative() {
+        // Negative LongInt exponent: return float
+        if let Some(e_f64) = e.to_f64() {
+            Ok(Value::Float((b as f64).powf(e_f64)))
+        } else {
+            Ok(Value::Float(0.0))
+        }
+    } else if e.is_zero() {
+        // x ** 0 = 1 for all x (including 0 ** 0 = 1)
+        Ok(Value::Int(1))
+    } else if b == 0 {
+        Ok(Value::Int(0))
+    } else if b == 1 {
+        Ok(Value::Int(1))
+    } else if b == -1 {
+        // (-1) ** n = 1 if n is even, -1 if n is odd
+        let is_even = (e % 2i32).is_zero();
+        Ok(Value::Int(if is_even { 1 } else { -1 }))
+    } else if let Some(exp_u32) = e.to_u32() {
+        // Check size before computing to prevent DoS
+        check_pow_size(i64_bits(b), u64::from(exp_u32), heap.tracker())?;
+        let bi = BigInt::from(b).pow(exp_u32);
+        Ok(LongInt::new(bi).into_value(heap)?)
+    } else {
+        // Exponent too large
+        Err(ExcType::overflow_exponent_too_large())
+    }
+}
+
+/// LongInt ** int with LongInt result.
+fn longint_pow_int(b: &BigInt, e: i64, heap: &mut Heap<impl ResourceTracker>) -> RunResult<Value> {
+    if b.is_zero() && e < 0 {
+        return Err(ExcType::zero_negative_power());
+    }
+    if e < 0 {
+        // Negative exponent: return float
+        if let (Some(b_f64), Some(e_f64)) = (b.to_f64(), Some(e as f64)) {
+            Ok(Value::Float(b_f64.powf(e_f64)))
+        } else {
+            Ok(Value::Float(0.0))
+        }
+    } else if let Ok(exp_u32) = u32::try_from(e) {
+        // Check size before computing to prevent DoS
+        check_pow_size(b.bits(), u64::from(exp_u32), heap.tracker())?;
+        let bi = b.pow(exp_u32);
+        Ok(LongInt::new(bi).into_value(heap)?)
+    } else {
+        // Exponent too large for u32
+        // Safety: e >= 0 at this point
+        #[expect(clippy::cast_sign_loss)]
+        let exp_u64 = e as u64;
+        // Check size before computing to prevent DoS
+        check_pow_size(b.bits(), exp_u64, heap.tracker())?;
+        let bi = bigint_pow_large(b, exp_u64)?;
+        Ok(LongInt::new(bi).into_value(heap)?)
+    }
+}
+
+/// LongInt ** LongInt with LongInt result.
+fn longint_pow_longint(b: &BigInt, e: &BigInt, heap: &mut Heap<impl ResourceTracker>) -> RunResult<Value> {
+    if b.is_zero() && e.is_negative() {
+        return Err(ExcType::zero_negative_power());
+    }
+    if e.is_negative() {
+        // Negative exponent: return float
+        if let (Some(b_f64), Some(e_f64)) = (b.to_f64(), e.to_f64()) {
+            Ok(Value::Float(b_f64.powf(e_f64)))
+        } else {
+            Ok(Value::Float(0.0))
+        }
+    } else if let Some(exp_u32) = e.to_u32() {
+        // Check size before computing to prevent DoS
+        check_pow_size(b.bits(), u64::from(exp_u32), heap.tracker())?;
+        let bi = b.pow(exp_u32);
+        Ok(LongInt::new(bi).into_value(heap)?)
+    } else {
+        // Exponent too large
+        Err(ExcType::overflow_exponent_too_large())
+    }
+}
+
+/// BigInt power for large exponents (> u32::MAX).
+///
+/// This handles exponents that are too large for the standard pow function.
+/// For most bases, the result would be astronomically large, so we only handle
+/// special cases (0, 1, -1) and return an error for others.
+fn bigint_pow_large(base: &BigInt, exp: u64) -> RunResult<BigInt> {
+    if base.is_zero() {
+        Ok(BigInt::from(0))
+    } else if *base == BigInt::from(1) {
+        Ok(BigInt::from(1))
+    } else if *base == BigInt::from(-1) {
+        // (-1) ** n = 1 if n is even, -1 if n is odd
+        if exp.is_multiple_of(2) {
+            Ok(BigInt::from(1))
+        } else {
+            Ok(BigInt::from(-1))
+        }
+    } else {
+        // For any other base, exponent > u32::MAX would produce an astronomically large result
+        Err(ExcType::overflow_exponent_too_large())
+    }
+}
+
+/// Computes the number of significant bits in an i64.
+fn i64_bits(value: i64) -> u64 {
+    if value == 0 {
+        0
+    } else {
+        u64::from(64 - value.unsigned_abs().leading_zeros())
+    }
+}

package/ref-monty/crates/monty/src/builtins/print.rs

@@ -0,0 +1,141 @@
+//! Implementation of the print() builtin function.
+
+use crate::{
+    args::{ArgValues, KwargsValues},
+    bytecode::VM,
+    defer_drop,
+    exception_private::{ExcType, RunError, RunResult, SimpleException},
+    heap::{Heap, HeapData},
+    intern::Interns,
+    resource::ResourceTracker,
+    types::PyTrait,
+    value::Value,
+};
+
+/// Implementation of the print() builtin function.
+///
+/// Supports the following keyword arguments:
+/// - `sep`: separator between values (default: " ")
+/// - `end`: string appended after the last value (default: "\n")
+/// - `flush`: whether to flush the stream (accepted but ignored)
+///
+/// The `file` kwarg is not supported.
+pub fn builtin_print(vm: &mut VM<'_, '_, impl ResourceTracker>, args: ArgValues) -> RunResult<Value> {
+    // Split into positional args and kwargs
+    let (positional, kwargs) = args.into_parts();
+    defer_drop!(positional, vm);
+
+    // Extract kwargs first
+    let (sep, end) = extract_print_kwargs(kwargs, vm.heap, vm.interns)?;
+
+    // Print positional args with separator, dropping each value after use
+    let mut first = true;
+    for value in positional.as_slice() {
+        if first {
+            first = false;
+        } else if let Some(sep) = &sep {
+            vm.print_writer.stdout_write(sep.as_str().into())?;
+        } else {
+            vm.print_writer.stdout_push(' ')?;
+        }
+        vm.print_writer.stdout_write(value.py_str(vm))?;
+    }
+
+    // Append end string
+    if let Some(end) = end {
+        vm.print_writer.stdout_write(end.into())?;
+    } else {
+        vm.print_writer.stdout_push('\n')?;
+    }
+
+    Ok(Value::None)
+}
+
+/// Extracts sep and end kwargs from print() arguments.
+///
+/// Consumes the kwargs, dropping all values after extraction.
+/// Returns (sep, end, error) where error is Some if a kwarg error occurred.
+fn extract_print_kwargs(
+    kwargs: KwargsValues,
+    heap: &mut Heap<impl ResourceTracker>,
+    interns: &Interns,
+) -> RunResult<(Option<String>, Option<String>)> {
+    let mut sep: Option<String> = None;
+    let mut end: Option<String> = None;
+    let mut error: Option<RunError> = None;
+
+    for (key, value) in kwargs {
+        // defer_drop! ensures key and value are cleaned up on every path through
+        // the loop body — including continue, early return, and normal iteration
+        defer_drop!(key, heap);
+        defer_drop!(value, heap);
+
+        // If we already hit an error, just drop remaining values
+        if error.is_some() {
+            continue;
+        }
+
+        let Some(keyword_name) = key.as_either_str(heap) else {
+            error = Some(SimpleException::new_msg(ExcType::TypeError, "keywords must be strings").into());
+            continue;
+        };
+
+        let key_str = keyword_name.as_str(interns);
+        match key_str {
+            "sep" => match extract_string_kwarg(value, "sep", heap, interns) {
+                Ok(custom_sep) => sep = custom_sep,
+                Err(e) => error = Some(e),
+            },
+            "end" => match extract_string_kwarg(value, "end", heap, interns) {
+                Ok(custom_end) => end = custom_end,
+                Err(e) => error = Some(e),
+            },
+            "flush" => {} // Accepted but ignored (we don't buffer output)
+            "file" => {
+                error = Some(
+                    SimpleException::new_msg(ExcType::TypeError, "print() 'file' argument is not supported").into(),
+                );
+            }
+            _ => {
+                error = Some(ExcType::type_error_unexpected_keyword("print", key_str));
+            }
+        }
+    }
+
+    if let Some(error) = error {
+        Err(error)
+    } else {
+        Ok((sep, end))
+    }
+}
+
+/// Extracts a string value from a print() kwarg.
+///
+/// The kwarg can be None (returns empty string) or a string.
+/// Raises TypeError for other types.
+fn extract_string_kwarg(
+    value: &Value,
+    name: &str,
+    heap: &Heap<impl ResourceTracker>,
+    interns: &Interns,
+) -> RunResult<Option<String>> {
+    match value {
+        Value::None => Ok(None),
+        Value::InternString(string_id) => Ok(Some(interns.get_str(*string_id).to_owned())),
+        Value::Ref(id) => {
+            if let HeapData::Str(s) = heap.get(*id) {
+                return Ok(Some(s.as_str().to_owned()));
+            }
+            Err(SimpleException::new_msg(
+                ExcType::TypeError,
+                format!("{} must be None or a string, not {}", name, value.py_type(heap)),
+            )
+            .into())
+        }
+        _ => Err(SimpleException::new_msg(
+            ExcType::TypeError,
+            format!("{} must be None or a string, not {}", name, value.py_type(heap)),
+        )
+        .into()),
+    }
+}

package/ref-monty/crates/monty/src/builtins/repr.rs

@@ -0,0 +1,16 @@
+//! Implementation of the repr() builtin function.
+
+use crate::{
+    args::ArgValues, bytecode::VM, defer_drop, exception_private::RunResult, heap::HeapData, resource::ResourceTracker,
+    types::PyTrait, value::Value,
+};
+
+/// Implementation of the repr() builtin function.
+///
+/// Returns a string containing a printable representation of an object.
+pub fn builtin_repr(vm: &mut VM<'_, '_, impl ResourceTracker>, args: ArgValues) -> RunResult<Value> {
+    let value = args.get_one_arg("repr", vm.heap)?;
+    defer_drop!(value, vm);
+    let heap_id = vm.heap.allocate(HeapData::Str(value.py_repr(vm).into_owned().into()))?;
+    Ok(Value::Ref(heap_id))
+}

package/ref-monty/crates/monty/src/builtins/reversed.rs

@@ -0,0 +1,28 @@
+//! Implementation of the reversed() builtin function.
+
+use crate::{
+    args::ArgValues,
+    bytecode::VM,
+    exception_private::RunResult,
+    heap::HeapData,
+    resource::ResourceTracker,
+    types::{List, MontyIter},
+    value::Value,
+};
+
+/// Implementation of the reversed() builtin function.
+///
+/// Returns a list with elements in reverse order.
+/// Note: In Python this returns an iterator, but we return a list for simplicity.
+pub fn builtin_reversed(vm: &mut VM<'_, '_, impl ResourceTracker>, args: ArgValues) -> RunResult<Value> {
+    let value = args.get_one_arg("reversed", vm.heap)?;
+
+    // Collect all items
+    let mut items: Vec<_> = MontyIter::new(value, vm)?.collect(vm)?;
+
+    // Reverse in place
+    items.reverse();
+
+    let heap_id = vm.heap.allocate(HeapData::List(List::new(items)))?;
+    Ok(Value::Ref(heap_id))
+}