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}