Skip to main content

code_transpiler/
exact.rs

1use std::fmt;
2
3#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4pub struct RExact {
5    pub raw: u128,
6    pub bits: u32,
7    pub signed: bool,
8}
9#[derive(Debug, Clone, PartialEq, Eq)]
10pub enum ExactValue {
11    Integer(RExact),
12    Bool(bool),
13    Text(String),
14}
15#[derive(Debug, Clone, PartialEq, Eq)]
16pub enum ExactError {
17    Width,
18    Parse,
19    Operand,
20    TypeMismatch,
21    DivideByZero,
22    NegativeShift,
23    Unsupported(String),
24    Overflow,
25}
26impl fmt::Display for ExactError {
27    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
28        write!(f, "{:?}", self)
29    }
30}
31impl std::error::Error for ExactError {}
32
33impl RExact {
34    pub fn new(value: i128, bits: u32, signed: bool) -> Result<Self, ExactError> {
35        if bits == 0 || bits > 64 {
36            return Err(ExactError::Width);
37        };
38        let raw = (value as u128) & ((1u128 << bits) - 1);
39        Ok(Self { raw, bits, signed })
40    }
41    pub fn from_raw(raw: u128, bits: u32, signed: bool) -> Result<Self, ExactError> {
42        if bits == 0 || bits > 64 {
43            return Err(ExactError::Width);
44        };
45        Ok(Self {
46            raw: raw & ((1u128 << bits) - 1),
47            bits,
48            signed,
49        })
50    }
51}
52pub fn exact_value(x: RExact) -> i128 {
53    if x.signed && x.raw >= (1u128 << (x.bits - 1)) {
54        (x.raw as i128) - (1i128 << x.bits)
55    } else {
56        x.raw as i128
57    }
58}
59fn check(x: RExact, bits: u32, signed: bool) -> Result<RExact, ExactError> {
60    if x.bits == bits && x.signed == signed {
61        Ok(x)
62    } else {
63        Err(ExactError::TypeMismatch)
64    }
65}
66
67pub fn r_exact(
68    name: &str,
69    bits: u32,
70    signed: bool,
71    text: &str,
72    values: &[RExact],
73) -> Result<ExactValue, ExactError> {
74    if name == "integer.literal" {
75        let v = text.parse::<i128>().map_err(|_| ExactError::Parse)?;
76        return Ok(ExactValue::Integer(RExact::new(v, bits, signed)?));
77    }
78    let a = *values.first().ok_or(ExactError::Operand)?;
79    let a = if name == "integer.convert" {
80        a
81    } else {
82        check(a, bits, signed)?
83    };
84    let av = exact_value(a);
85    match name {
86        "integer.value" => return Ok(ExactValue::Integer(a)),
87        "integer.convert" => return Ok(ExactValue::Integer(RExact::new(av, bits, signed)?)),
88        "integer.format" => return Ok(ExactValue::Text(av.to_string())),
89        "integer.negate" => {
90            return Ok(ExactValue::Integer(RExact::new(
91                av.wrapping_neg(),
92                bits,
93                signed,
94            )?))
95        }
96        "integer.complement" => {
97            return Ok(ExactValue::Integer(RExact::from_raw(!a.raw, bits, signed)?))
98        }
99        _ => {}
100    }
101    let b = check(*values.get(1).ok_or(ExactError::Operand)?, bits, signed)?;
102    let bv = exact_value(b);
103    let integer = |raw: u128| RExact::from_raw(raw, bits, signed).map(ExactValue::Integer);
104    match name {
105        "integer.equal" => Ok(ExactValue::Bool(a.raw == b.raw)),
106        "integer.not_equal" => Ok(ExactValue::Bool(a.raw != b.raw)),
107        "integer.less" => Ok(ExactValue::Bool(av < bv)),
108        "integer.less_equal" => Ok(ExactValue::Bool(av <= bv)),
109        "integer.greater" => Ok(ExactValue::Bool(av > bv)),
110        "integer.greater_equal" => Ok(ExactValue::Bool(av >= bv)),
111        "integer.add" => integer(a.raw.wrapping_add(b.raw)),
112        "integer.subtract" => integer(a.raw.wrapping_sub(b.raw)),
113        "integer.multiply" => integer(a.raw.wrapping_mul(b.raw)),
114        "integer.and" => integer(a.raw & b.raw),
115        "integer.or" => integer(a.raw | b.raw),
116        "integer.xor" => integer(a.raw ^ b.raw),
117        "integer.and_not" => integer(a.raw & !b.raw),
118        "integer.shift_left" => {
119            if bv < 0 {
120                return Err(ExactError::NegativeShift);
121            };
122            integer(if bv as u32 >= bits {
123                0
124            } else {
125                a.raw.wrapping_shl(bv as u32)
126            })
127        }
128        "integer.shift_right" => {
129            if bv < 0 {
130                return Err(ExactError::NegativeShift);
131            };
132            let v = if bv as u32 >= bits {
133                if signed && av < 0 {
134                    -1
135                } else {
136                    0
137                }
138            } else {
139                av >> bv as u32
140            };
141            Ok(ExactValue::Integer(RExact::new(v, bits, signed)?))
142        }
143        "integer.divide" => {
144            if bv == 0 {
145                return Err(ExactError::DivideByZero);
146            };
147            let q = match av.checked_div(bv) {
148                Some(v) => v,
149                None if signed && bv == -1 => av,
150                None => return Err(ExactError::Overflow),
151            };
152            Ok(ExactValue::Integer(RExact::new(q, bits, signed)?))
153        }
154        "integer.remainder" => {
155            if bv == 0 {
156                return Err(ExactError::DivideByZero);
157            };
158            let r = match av.checked_rem(bv) {
159                Some(v) => v,
160                None if signed && bv == -1 => 0,
161                None => return Err(ExactError::Overflow),
162            };
163            Ok(ExactValue::Integer(RExact::new(r, bits, signed)?))
164        }
165        _ => Err(ExactError::Unsupported(name.into())),
166    }
167}