vihaco_cpu/execute/values/
comparisons.rs

1// SPDX-FileCopyrightText: 2026 The vihaco Authors
2// SPDX-License-Identifier: MIT
3
4use crate::{CPU, cpu};
5use vihaco_runtime::{Execute, PopFromStack, PushToStack};
6
7impl Execute<cpu::NegI32> for CPU {
8    type Message = PopFromStack<(i32,)>;
9    type Effect = PushToStack<(i32,)>;
10    type Error = eyre::Report;
11
12    fn execute(
13        &mut self,
14        _: &cpu::NegI32,
15        PopFromStack((operand,)): Self::Message,
16    ) -> eyre::Result<Self::Effect> {
17        let value = operand.wrapping_neg();
18        Ok(PushToStack((value,)))
19    }
20}
21
22impl Execute<cpu::NegI64> for CPU {
23    type Message = PopFromStack<(i64,)>;
24    type Effect = PushToStack<(i64,)>;
25    type Error = eyre::Report;
26
27    fn execute(
28        &mut self,
29        _: &cpu::NegI64,
30        PopFromStack((operand,)): Self::Message,
31    ) -> eyre::Result<Self::Effect> {
32        let value = operand.wrapping_neg();
33        Ok(PushToStack((value,)))
34    }
35}
36
37impl Execute<cpu::NegF32> for CPU {
38    type Message = PopFromStack<(f32,)>;
39    type Effect = PushToStack<(f32,)>;
40    type Error = eyre::Report;
41
42    fn execute(
43        &mut self,
44        _: &cpu::NegF32,
45        PopFromStack((operand,)): Self::Message,
46    ) -> eyre::Result<Self::Effect> {
47        let value = -operand;
48        Ok(PushToStack((value,)))
49    }
50}
51
52impl Execute<cpu::NegF64> for CPU {
53    type Message = PopFromStack<(f64,)>;
54    type Effect = PushToStack<(f64,)>;
55    type Error = eyre::Report;
56
57    fn execute(
58        &mut self,
59        _: &cpu::NegF64,
60        PopFromStack((operand,)): Self::Message,
61    ) -> eyre::Result<Self::Effect> {
62        let value = -operand;
63        Ok(PushToStack((value,)))
64    }
65}
66
67impl Execute<cpu::EqI32> for CPU {
68    type Message = PopFromStack<(i32, i32)>;
69    type Effect = PushToStack<(bool,)>;
70    type Error = eyre::Report;
71
72    fn execute(
73        &mut self,
74        _: &cpu::EqI32,
75        PopFromStack((lhs, rhs)): Self::Message,
76    ) -> eyre::Result<Self::Effect> {
77        Ok(PushToStack((lhs == rhs,)))
78    }
79}
80
81impl Execute<cpu::EqI64> for CPU {
82    type Message = PopFromStack<(i64, i64)>;
83    type Effect = PushToStack<(bool,)>;
84    type Error = eyre::Report;
85
86    fn execute(
87        &mut self,
88        _: &cpu::EqI64,
89        PopFromStack((lhs, rhs)): Self::Message,
90    ) -> eyre::Result<Self::Effect> {
91        Ok(PushToStack((lhs == rhs,)))
92    }
93}
94
95impl Execute<cpu::EqU32> for CPU {
96    type Message = PopFromStack<(u32, u32)>;
97    type Effect = PushToStack<(bool,)>;
98    type Error = eyre::Report;
99
100    fn execute(
101        &mut self,
102        _: &cpu::EqU32,
103        PopFromStack((lhs, rhs)): Self::Message,
104    ) -> eyre::Result<Self::Effect> {
105        Ok(PushToStack((lhs == rhs,)))
106    }
107}
108
109impl Execute<cpu::EqU64> for CPU {
110    type Message = PopFromStack<(u64, u64)>;
111    type Effect = PushToStack<(bool,)>;
112    type Error = eyre::Report;
113
114    fn execute(
115        &mut self,
116        _: &cpu::EqU64,
117        PopFromStack((lhs, rhs)): Self::Message,
118    ) -> eyre::Result<Self::Effect> {
119        Ok(PushToStack((lhs == rhs,)))
120    }
121}
122
123impl Execute<cpu::EqF32> for CPU {
124    type Message = PopFromStack<(f32, f32)>;
125    type Effect = PushToStack<(bool,)>;
126    type Error = eyre::Report;
127
128    fn execute(
129        &mut self,
130        _: &cpu::EqF32,
131        PopFromStack((lhs, rhs)): Self::Message,
132    ) -> eyre::Result<Self::Effect> {
133        Ok(PushToStack((lhs == rhs,)))
134    }
135}
136
137impl Execute<cpu::EqF64> for CPU {
138    type Message = PopFromStack<(f64, f64)>;
139    type Effect = PushToStack<(bool,)>;
140    type Error = eyre::Report;
141
142    fn execute(
143        &mut self,
144        _: &cpu::EqF64,
145        PopFromStack((lhs, rhs)): Self::Message,
146    ) -> eyre::Result<Self::Effect> {
147        Ok(PushToStack((lhs == rhs,)))
148    }
149}
150
151impl Execute<cpu::NeI32> for CPU {
152    type Message = PopFromStack<(i32, i32)>;
153    type Effect = PushToStack<(bool,)>;
154    type Error = eyre::Report;
155
156    fn execute(
157        &mut self,
158        _: &cpu::NeI32,
159        PopFromStack((lhs, rhs)): Self::Message,
160    ) -> eyre::Result<Self::Effect> {
161        Ok(PushToStack((lhs != rhs,)))
162    }
163}
164
165impl Execute<cpu::NeI64> for CPU {
166    type Message = PopFromStack<(i64, i64)>;
167    type Effect = PushToStack<(bool,)>;
168    type Error = eyre::Report;
169
170    fn execute(
171        &mut self,
172        _: &cpu::NeI64,
173        PopFromStack((lhs, rhs)): Self::Message,
174    ) -> eyre::Result<Self::Effect> {
175        Ok(PushToStack((lhs != rhs,)))
176    }
177}
178
179impl Execute<cpu::NeU32> for CPU {
180    type Message = PopFromStack<(u32, u32)>;
181    type Effect = PushToStack<(bool,)>;
182    type Error = eyre::Report;
183
184    fn execute(
185        &mut self,
186        _: &cpu::NeU32,
187        PopFromStack((lhs, rhs)): Self::Message,
188    ) -> eyre::Result<Self::Effect> {
189        Ok(PushToStack((lhs != rhs,)))
190    }
191}
192
193impl Execute<cpu::NeU64> for CPU {
194    type Message = PopFromStack<(u64, u64)>;
195    type Effect = PushToStack<(bool,)>;
196    type Error = eyre::Report;
197
198    fn execute(
199        &mut self,
200        _: &cpu::NeU64,
201        PopFromStack((lhs, rhs)): Self::Message,
202    ) -> eyre::Result<Self::Effect> {
203        Ok(PushToStack((lhs != rhs,)))
204    }
205}
206
207impl Execute<cpu::NeF32> for CPU {
208    type Message = PopFromStack<(f32, f32)>;
209    type Effect = PushToStack<(bool,)>;
210    type Error = eyre::Report;
211
212    fn execute(
213        &mut self,
214        _: &cpu::NeF32,
215        PopFromStack((lhs, rhs)): Self::Message,
216    ) -> eyre::Result<Self::Effect> {
217        Ok(PushToStack((lhs != rhs,)))
218    }
219}
220
221impl Execute<cpu::NeF64> for CPU {
222    type Message = PopFromStack<(f64, f64)>;
223    type Effect = PushToStack<(bool,)>;
224    type Error = eyre::Report;
225
226    fn execute(
227        &mut self,
228        _: &cpu::NeF64,
229        PopFromStack((lhs, rhs)): Self::Message,
230    ) -> eyre::Result<Self::Effect> {
231        Ok(PushToStack((lhs != rhs,)))
232    }
233}
234
235impl Execute<cpu::LtI32> for CPU {
236    type Message = PopFromStack<(i32, i32)>;
237    type Effect = PushToStack<(bool,)>;
238    type Error = eyre::Report;
239
240    fn execute(
241        &mut self,
242        _: &cpu::LtI32,
243        PopFromStack((lhs, rhs)): Self::Message,
244    ) -> eyre::Result<Self::Effect> {
245        Ok(PushToStack((lhs < rhs,)))
246    }
247}
248
249impl Execute<cpu::LtI64> for CPU {
250    type Message = PopFromStack<(i64, i64)>;
251    type Effect = PushToStack<(bool,)>;
252    type Error = eyre::Report;
253
254    fn execute(
255        &mut self,
256        _: &cpu::LtI64,
257        PopFromStack((lhs, rhs)): Self::Message,
258    ) -> eyre::Result<Self::Effect> {
259        Ok(PushToStack((lhs < rhs,)))
260    }
261}
262
263impl Execute<cpu::LtU32> for CPU {
264    type Message = PopFromStack<(u32, u32)>;
265    type Effect = PushToStack<(bool,)>;
266    type Error = eyre::Report;
267
268    fn execute(
269        &mut self,
270        _: &cpu::LtU32,
271        PopFromStack((lhs, rhs)): Self::Message,
272    ) -> eyre::Result<Self::Effect> {
273        Ok(PushToStack((lhs < rhs,)))
274    }
275}
276
277impl Execute<cpu::LtU64> for CPU {
278    type Message = PopFromStack<(u64, u64)>;
279    type Effect = PushToStack<(bool,)>;
280    type Error = eyre::Report;
281
282    fn execute(
283        &mut self,
284        _: &cpu::LtU64,
285        PopFromStack((lhs, rhs)): Self::Message,
286    ) -> eyre::Result<Self::Effect> {
287        Ok(PushToStack((lhs < rhs,)))
288    }
289}
290
291impl Execute<cpu::LtF32> for CPU {
292    type Message = PopFromStack<(f32, f32)>;
293    type Effect = PushToStack<(bool,)>;
294    type Error = eyre::Report;
295
296    fn execute(
297        &mut self,
298        _: &cpu::LtF32,
299        PopFromStack((lhs, rhs)): Self::Message,
300    ) -> eyre::Result<Self::Effect> {
301        Ok(PushToStack((lhs < rhs,)))
302    }
303}
304
305impl Execute<cpu::LtF64> for CPU {
306    type Message = PopFromStack<(f64, f64)>;
307    type Effect = PushToStack<(bool,)>;
308    type Error = eyre::Report;
309
310    fn execute(
311        &mut self,
312        _: &cpu::LtF64,
313        PopFromStack((lhs, rhs)): Self::Message,
314    ) -> eyre::Result<Self::Effect> {
315        Ok(PushToStack((lhs < rhs,)))
316    }
317}
318
319impl Execute<cpu::GtI32> for CPU {
320    type Message = PopFromStack<(i32, i32)>;
321    type Effect = PushToStack<(bool,)>;
322    type Error = eyre::Report;
323
324    fn execute(
325        &mut self,
326        _: &cpu::GtI32,
327        PopFromStack((lhs, rhs)): Self::Message,
328    ) -> eyre::Result<Self::Effect> {
329        Ok(PushToStack((lhs > rhs,)))
330    }
331}
332
333impl Execute<cpu::GtI64> for CPU {
334    type Message = PopFromStack<(i64, i64)>;
335    type Effect = PushToStack<(bool,)>;
336    type Error = eyre::Report;
337
338    fn execute(
339        &mut self,
340        _: &cpu::GtI64,
341        PopFromStack((lhs, rhs)): Self::Message,
342    ) -> eyre::Result<Self::Effect> {
343        Ok(PushToStack((lhs > rhs,)))
344    }
345}
346
347impl Execute<cpu::GtU32> for CPU {
348    type Message = PopFromStack<(u32, u32)>;
349    type Effect = PushToStack<(bool,)>;
350    type Error = eyre::Report;
351
352    fn execute(
353        &mut self,
354        _: &cpu::GtU32,
355        PopFromStack((lhs, rhs)): Self::Message,
356    ) -> eyre::Result<Self::Effect> {
357        Ok(PushToStack((lhs > rhs,)))
358    }
359}
360
361impl Execute<cpu::GtU64> for CPU {
362    type Message = PopFromStack<(u64, u64)>;
363    type Effect = PushToStack<(bool,)>;
364    type Error = eyre::Report;
365
366    fn execute(
367        &mut self,
368        _: &cpu::GtU64,
369        PopFromStack((lhs, rhs)): Self::Message,
370    ) -> eyre::Result<Self::Effect> {
371        Ok(PushToStack((lhs > rhs,)))
372    }
373}
374
375impl Execute<cpu::GtF32> for CPU {
376    type Message = PopFromStack<(f32, f32)>;
377    type Effect = PushToStack<(bool,)>;
378    type Error = eyre::Report;
379
380    fn execute(
381        &mut self,
382        _: &cpu::GtF32,
383        PopFromStack((lhs, rhs)): Self::Message,
384    ) -> eyre::Result<Self::Effect> {
385        Ok(PushToStack((lhs > rhs,)))
386    }
387}
388
389impl Execute<cpu::GtF64> for CPU {
390    type Message = PopFromStack<(f64, f64)>;
391    type Effect = PushToStack<(bool,)>;
392    type Error = eyre::Report;
393
394    fn execute(
395        &mut self,
396        _: &cpu::GtF64,
397        PopFromStack((lhs, rhs)): Self::Message,
398    ) -> eyre::Result<Self::Effect> {
399        Ok(PushToStack((lhs > rhs,)))
400    }
401}
402
403impl Execute<cpu::LeI32> for CPU {
404    type Message = PopFromStack<(i32, i32)>;
405    type Effect = PushToStack<(bool,)>;
406    type Error = eyre::Report;
407
408    fn execute(
409        &mut self,
410        _: &cpu::LeI32,
411        PopFromStack((lhs, rhs)): Self::Message,
412    ) -> eyre::Result<Self::Effect> {
413        Ok(PushToStack((lhs <= rhs,)))
414    }
415}
416
417impl Execute<cpu::LeI64> for CPU {
418    type Message = PopFromStack<(i64, i64)>;
419    type Effect = PushToStack<(bool,)>;
420    type Error = eyre::Report;
421
422    fn execute(
423        &mut self,
424        _: &cpu::LeI64,
425        PopFromStack((lhs, rhs)): Self::Message,
426    ) -> eyre::Result<Self::Effect> {
427        Ok(PushToStack((lhs <= rhs,)))
428    }
429}
430
431impl Execute<cpu::LeU32> for CPU {
432    type Message = PopFromStack<(u32, u32)>;
433    type Effect = PushToStack<(bool,)>;
434    type Error = eyre::Report;
435
436    fn execute(
437        &mut self,
438        _: &cpu::LeU32,
439        PopFromStack((lhs, rhs)): Self::Message,
440    ) -> eyre::Result<Self::Effect> {
441        Ok(PushToStack((lhs <= rhs,)))
442    }
443}
444
445impl Execute<cpu::LeU64> for CPU {
446    type Message = PopFromStack<(u64, u64)>;
447    type Effect = PushToStack<(bool,)>;
448    type Error = eyre::Report;
449
450    fn execute(
451        &mut self,
452        _: &cpu::LeU64,
453        PopFromStack((lhs, rhs)): Self::Message,
454    ) -> eyre::Result<Self::Effect> {
455        Ok(PushToStack((lhs <= rhs,)))
456    }
457}
458
459impl Execute<cpu::LeF32> for CPU {
460    type Message = PopFromStack<(f32, f32)>;
461    type Effect = PushToStack<(bool,)>;
462    type Error = eyre::Report;
463
464    fn execute(
465        &mut self,
466        _: &cpu::LeF32,
467        PopFromStack((lhs, rhs)): Self::Message,
468    ) -> eyre::Result<Self::Effect> {
469        Ok(PushToStack((lhs <= rhs,)))
470    }
471}
472
473impl Execute<cpu::LeF64> for CPU {
474    type Message = PopFromStack<(f64, f64)>;
475    type Effect = PushToStack<(bool,)>;
476    type Error = eyre::Report;
477
478    fn execute(
479        &mut self,
480        _: &cpu::LeF64,
481        PopFromStack((lhs, rhs)): Self::Message,
482    ) -> eyre::Result<Self::Effect> {
483        Ok(PushToStack((lhs <= rhs,)))
484    }
485}
486
487impl Execute<cpu::GeI32> for CPU {
488    type Message = PopFromStack<(i32, i32)>;
489    type Effect = PushToStack<(bool,)>;
490    type Error = eyre::Report;
491
492    fn execute(
493        &mut self,
494        _: &cpu::GeI32,
495        PopFromStack((lhs, rhs)): Self::Message,
496    ) -> eyre::Result<Self::Effect> {
497        Ok(PushToStack((lhs >= rhs,)))
498    }
499}
500
501impl Execute<cpu::GeI64> for CPU {
502    type Message = PopFromStack<(i64, i64)>;
503    type Effect = PushToStack<(bool,)>;
504    type Error = eyre::Report;
505
506    fn execute(
507        &mut self,
508        _: &cpu::GeI64,
509        PopFromStack((lhs, rhs)): Self::Message,
510    ) -> eyre::Result<Self::Effect> {
511        Ok(PushToStack((lhs >= rhs,)))
512    }
513}
514
515impl Execute<cpu::GeU32> for CPU {
516    type Message = PopFromStack<(u32, u32)>;
517    type Effect = PushToStack<(bool,)>;
518    type Error = eyre::Report;
519
520    fn execute(
521        &mut self,
522        _: &cpu::GeU32,
523        PopFromStack((lhs, rhs)): Self::Message,
524    ) -> eyre::Result<Self::Effect> {
525        Ok(PushToStack((lhs >= rhs,)))
526    }
527}
528
529impl Execute<cpu::GeU64> for CPU {
530    type Message = PopFromStack<(u64, u64)>;
531    type Effect = PushToStack<(bool,)>;
532    type Error = eyre::Report;
533
534    fn execute(
535        &mut self,
536        _: &cpu::GeU64,
537        PopFromStack((lhs, rhs)): Self::Message,
538    ) -> eyre::Result<Self::Effect> {
539        Ok(PushToStack((lhs >= rhs,)))
540    }
541}
542
543impl Execute<cpu::GeF32> for CPU {
544    type Message = PopFromStack<(f32, f32)>;
545    type Effect = PushToStack<(bool,)>;
546    type Error = eyre::Report;
547
548    fn execute(
549        &mut self,
550        _: &cpu::GeF32,
551        PopFromStack((lhs, rhs)): Self::Message,
552    ) -> eyre::Result<Self::Effect> {
553        Ok(PushToStack((lhs >= rhs,)))
554    }
555}
556
557impl Execute<cpu::GeF64> for CPU {
558    type Message = PopFromStack<(f64, f64)>;
559    type Effect = PushToStack<(bool,)>;
560    type Error = eyre::Report;
561
562    fn execute(
563        &mut self,
564        _: &cpu::GeF64,
565        PopFromStack((lhs, rhs)): Self::Message,
566    ) -> eyre::Result<Self::Effect> {
567        Ok(PushToStack((lhs >= rhs,)))
568    }
569}
vihaco_cpu/execute/values/comparisons.rs

vihaco_cpu/execute/values/
comparisons.rs
