path: root/tvix/eval/src/vm/macros.rs

/// This module provides macros which are used in the implementation
/// of the VM for the implementation of repetitive operations.

/// This macro simplifies the implementation of arithmetic operations,
/// correctly handling the behaviour on different pairings of number
/// types.
#[macro_export]
macro_rules! arithmetic_op {
    ( $self:ident, $op:tt ) => {{ // TODO: remove
        let b = $self.pop();
        let a = $self.pop();
        let result = fallible!($self, arithmetic_op!(&a, &b, $op));
        $self.push(result);
    }};

    ( $a:expr, $b:expr, $op:tt ) => {{
        match ($a, $b) {
            (Value::Integer(i1), Value::Integer(i2)) => Ok(Value::Integer(i1 $op i2)),
            (Value::Float(f1), Value::Float(f2)) => Ok(Value::Float(f1 $op f2)),
            (Value::Integer(i1), Value::Float(f2)) => Ok(Value::Float(*i1 as f64 $op f2)),
            (Value::Float(f1), Value::Integer(i2)) => Ok(Value::Float(f1 $op *i2 as f64)),

            (v1, v2) => Err(ErrorKind::TypeError {
                expected: "number (either int or float)",
                actual: if v1.is_number() {
                    v2.type_of()
                } else {
                    v1.type_of()
                },
            }),
        }
    }};
}

/// This macro simplifies the implementation of comparison operations.
#[macro_export]
macro_rules! cmp_op {
    ( $vm:ident, $frame:ident, $span:ident, $op:tt ) => {{
        let b = $vm.stack_pop();
        let a = $vm.stack_pop();

        async fn compare(a: Value, b: Value, co: GenCo) -> Result<Value, ErrorKind> {
            let a = generators::request_force(&co, a).await;
            let b = generators::request_force(&co, b).await;
            let ordering = a.nix_cmp_ordering(b, co).await?;
            Ok(Value::Bool(cmp_op!(@order $op ordering)))
        }

        let gen_span = $frame.current_light_span();
        $vm.push_call_frame($span, $frame);
        $vm.enqueue_generator("compare", gen_span, |co| compare(a, b, co));
        return Ok(false);
    }};

    (@order < $ordering:expr) => {
        $ordering == Ordering::Less
    };

    (@order > $ordering:expr) => {
        $ordering == Ordering::Greater
    };

    (@order <= $ordering:expr) => {
        matches!($ordering, Ordering::Equal | Ordering::Less)
    };

    (@order >= $ordering:expr) => {
        matches!($ordering, Ordering::Equal | Ordering::Greater)
    };
}