bitcalc 0.3.0

A calculator with bit operations
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

use std::fmt::Display;

use crate::ast::{Expr, Op, Val};
use num_traits::{CheckedRem, CheckedShl, CheckedShr, PrimInt};

pub fn eval<
    I: PrimInt + TryFrom<u64> + TryInto<u32> + TryInto<usize> + CheckedRem + CheckedShl + CheckedShr,
>(
    answers: &[u64],
    expr: &Expr,
) -> Result<I, EvalError> {
    let eval = |x| eval::<I>(answers, x);

    match expr {
        Expr::Op(op) => match op {
            Op::Mul(a, b) => eval(a)?.checked_mul(&eval(b)?).ok_or(EvalError::Overflow),
            Op::Div(a, b) => eval(a)?.checked_div(&eval(b)?).ok_or(EvalError::Overflow),
            Op::Mod(a, b) => eval(a)?.checked_rem(&eval(b)?).ok_or(EvalError::Overflow),
            Op::Add(a, b) => eval(a)?.checked_add(&eval(b)?).ok_or(EvalError::Overflow),
            Op::Sub(a, b) => eval(a)?.checked_sub(&eval(b)?).ok_or(EvalError::Overflow),
            Op::Pow(a, b) => {
                let a = eval(a)?;
                let b = eval(b)?.try_into().map_err(|_| EvalError::ShiftTooLarge)?;
                num_traits::pow::checked_pow(a, b).ok_or(EvalError::Overflow)
            }
            Op::ShiftLeft(a, b) => {
                let a = eval(a)?;
                let b = eval(b)?.try_into().map_err(|_| EvalError::ShiftTooLarge)?;
                a.checked_shl(b).ok_or(EvalError::ShiftTooLarge)
            }
            Op::ShiftRight(a, b) => {
                let a = eval(a)?;
                let b = eval(b)?.try_into().map_err(|_| EvalError::ShiftTooLarge)?;
                a.checked_shr(b).ok_or(EvalError::ShiftTooLarge)
            }
            Op::RotLeft(a, b) => {
                let a = eval(a)?;
                let b = eval(b)?.try_into().map_err(|_| EvalError::ShiftTooLarge)?;
                Ok(a.rotate_left(b))
            }
            Op::RotRight(a, b) => {
                let a = eval(a)?;
                let b = eval(b)?.try_into().map_err(|_| EvalError::ShiftTooLarge)?;
                Ok(a.rotate_right(b))
            }
            Op::BitXor(a, b) => Ok(eval(a)? ^ eval(b)?),
            Op::BitOr(a, b) => Ok(eval(a)? | eval(b)?),
            Op::BitAnd(a, b) => Ok(eval(a)? & eval(b)?),
        },
        Expr::Val(Val::Int(x) | Val::Hex(x) | Val::Bin(x)) => {
            I::try_from(*x).map_err(|_| EvalError::LiteralTooLarge)
        }
        Expr::Val(Val::LastAnswer) => {
            let x = answers.last().ok_or(EvalError::HistoryValueDoesNotExist)?;
            I::try_from(*x).map_err(|_| EvalError::HistoryValueTooLarge)
        }
        Expr::Val(Val::History(idx)) => {
            let x = answers
                .get(*idx)
                .ok_or(EvalError::HistoryValueDoesNotExist)?;
            I::try_from(*x).map_err(|_| EvalError::HistoryValueTooLarge)
        }
    }
}

pub enum EvalError {
    Overflow,
    ShiftTooLarge,
    LiteralTooLarge,
    HistoryValueTooLarge,
    HistoryValueDoesNotExist,
}

impl Display for EvalError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let s = match self {
            EvalError::Overflow => "an overflow happened",
            EvalError::ShiftTooLarge => "the amount to shift by exceeded the number of bits",
            EvalError::LiteralTooLarge => "the value of a literal was too big to fit",
            EvalError::HistoryValueTooLarge => "the value of a history value was too big to fit",
            EvalError::HistoryValueDoesNotExist => "requested history value does not exist",
        };
        f.write_str(s)
    }
}