assembler/
inst.rs

1use rfvp::script::parser::Nls;
2
3pub trait Inst {
4    fn address(&self) -> u32;
5    fn set_address(&mut self, address: u32);
6    fn serialize_to_binary(&self) -> Vec<u8>;
7    fn size(&self) -> u32;
8}
9
10#[derive(Default)]
11pub struct NopInst {
12    address: u32,
13}
14
15impl NopInst {
16    pub fn new() -> Self {
17        Self::default()
18    }
19}
20
21impl Inst for NopInst {
22    fn address(&self) -> u32 {
23        self.address
24    }
25
26    fn set_address(&mut self, address: u32) {
27        self.address = address;
28    }
29
30    fn serialize_to_binary(&self) -> Vec<u8> {
31        vec![0x00]
32    }
33
34    fn size(&self) -> u32 {
35        1
36    }
37}
38
39pub struct InitStackInst {
40    address: u32,
41    arg_count: u8,
42    locals_count: u8,
43}
44
45impl InitStackInst {
46    pub fn new(arg_count: u8, locals_count: u8) -> Self {
47        Self {
48            address: 0,
49            arg_count,
50            locals_count,
51        }
52    }
53}
54
55impl Inst for InitStackInst {
56    fn address(&self) -> u32 {
57        self.address
58    }
59
60    fn set_address(&mut self, address: u32) {
61        self.address = address;
62    }
63
64    fn serialize_to_binary(&self) -> Vec<u8> {
65        vec![0x01, self.arg_count, self.locals_count]
66    }
67
68    fn size(&self) -> u32 {
69        3
70    }
71}
72
73pub struct CallInst {
74    address: u32,
75    func_address: u32,
76}
77
78impl CallInst {
79    pub fn new(func_address: u32) -> Self {
80        Self {
81            address: 0,
82            func_address,
83        }
84    }
85
86    pub fn set_func_target(&mut self, target: u32) {
87        self.func_address = target;
88    }
89
90    pub fn get_old_func_target(&self) -> u32 {
91        self.func_address
92    }
93}
94
95impl Inst for CallInst {
96    fn address(&self) -> u32 {
97        self.address
98    }
99
100    fn set_address(&mut self, address: u32) {
101        self.address = address;
102    }
103
104    fn serialize_to_binary(&self) -> Vec<u8> {
105        let mut bytes = vec![0x02];
106        bytes.extend_from_slice(&self.func_address.to_le_bytes());
107        bytes
108    }
109
110    fn size(&self) -> u32 {
111        5
112    }
113}
114
115pub struct SyscallInst {
116    address: u32,
117    syscall_id: u16,
118}
119
120impl SyscallInst {
121    pub fn new(syscall_id: u16) -> Self {
122        Self {
123            address: 0,
124            syscall_id,
125        }
126    }
127}
128
129impl Inst for SyscallInst {
130    fn address(&self) -> u32 {
131        self.address
132    }
133
134    fn set_address(&mut self, address: u32) {
135        self.address = address;
136    }
137
138    fn serialize_to_binary(&self) -> Vec<u8> {
139        let mut bytes = vec![0x03];
140        bytes.extend_from_slice(&self.syscall_id.to_le_bytes());
141        bytes
142    }
143
144    fn size(&self) -> u32 {
145        3
146    }
147}
148
149#[derive(Default)]
150pub struct RetInst {
151    address: u32,
152}
153
154impl RetInst {
155    pub fn new() -> Self {
156        Self::default()
157    }
158}
159
160impl Inst for RetInst {
161    fn address(&self) -> u32 {
162        self.address
163    }
164
165    fn set_address(&mut self, address: u32) {
166        self.address = address;
167    }
168
169    fn serialize_to_binary(&self) -> Vec<u8> {
170        vec![0x04]
171    }
172
173    fn size(&self) -> u32 {
174        1
175    }
176}
177
178#[derive(Default)]
179pub struct RetVInst {
180    address: u32,
181}
182
183impl RetVInst {
184    pub fn new() -> Self {
185        Self::default()
186    }
187}
188
189impl Inst for RetVInst {
190    fn address(&self) -> u32 {
191        self.address
192    }
193
194    fn set_address(&mut self, address: u32) {
195        self.address = address;
196    }
197
198    fn serialize_to_binary(&self) -> Vec<u8> {
199        vec![0x05]
200    }
201
202    fn size(&self) -> u32 {
203        1
204    }
205}
206
207pub struct JmpInst {
208    address: u32,
209    target_address: u32,
210}
211
212impl JmpInst {
213    pub fn new(target_address: u32) -> Self {
214        Self {
215            address: 0,
216            target_address,
217        }
218    }
219
220    pub fn set_target(&mut self, target: u32) {
221        self.target_address = target;
222    }
223
224    pub fn get_old_target(&self) -> u32 {
225        self.target_address
226    }
227}
228
229impl Inst for JmpInst {
230    fn address(&self) -> u32 {
231        self.address
232    }
233
234    fn set_address(&mut self, address: u32) {
235        self.address = address;
236    }
237
238    fn serialize_to_binary(&self) -> Vec<u8> {
239        let mut bytes = vec![0x06];
240        bytes.extend_from_slice(&self.target_address.to_le_bytes());
241        bytes
242    }
243
244    fn size(&self) -> u32 {
245        5
246    }
247}
248
249pub struct JzInst {
250    address: u32,
251    target_address: u32,
252}
253
254impl JzInst {
255    pub fn new(target_address: u32) -> Self {
256        Self {
257            address: 0,
258            target_address,
259        }
260    }
261
262    pub fn set_target(&mut self, target: u32) {
263        self.target_address = target;
264    }
265
266    pub fn get_old_target(&self) -> u32 {
267        self.target_address
268    }
269}
270
271impl Inst for JzInst {
272    fn address(&self) -> u32 {
273        self.address
274    }
275
276    fn set_address(&mut self, address: u32) {
277        self.address = address;
278    }
279
280    fn serialize_to_binary(&self) -> Vec<u8> {
281        let mut bytes = vec![0x07];
282        bytes.extend_from_slice(&self.target_address.to_le_bytes());
283        bytes
284    }
285
286    fn size(&self) -> u32 {
287        5
288    }
289}
290
291#[derive(Default)]
292pub struct PushNilInst {
293    address: u32,
294}
295
296impl PushNilInst {
297    pub fn new() -> Self {
298        Self::default()
299    }
300}
301
302impl Inst for PushNilInst {
303    fn address(&self) -> u32 {
304        self.address
305    }
306
307    fn set_address(&mut self, address: u32) {
308        self.address = address;
309    }
310
311    fn serialize_to_binary(&self) -> Vec<u8> {
312        vec![0x08]
313    }
314
315    fn size(&self) -> u32 {
316        1
317    }
318}
319
320#[derive(Default)]
321pub struct PushTrueInst {
322    address: u32,
323}
324
325impl PushTrueInst {
326    pub fn new() -> Self {
327        Self::default()
328    }
329}
330
331impl Inst for PushTrueInst {
332    fn address(&self) -> u32 {
333        self.address
334    }
335
336    fn set_address(&mut self, address: u32) {
337        self.address = address;
338    }
339
340    fn serialize_to_binary(&self) -> Vec<u8> {
341        vec![0x09]
342    }
343
344    fn size(&self) -> u32 {
345        1
346    }
347}
348
349pub struct PushI32Inst {
350    address: u32,
351    value: i32,
352}
353
354impl PushI32Inst {
355    pub fn new(value: i32) -> Self {
356        Self { address: 0, value }
357    }
358
359    pub fn get_value(&self) -> i32 {
360        self.value
361    }
362
363    pub fn set_value(&mut self, value: i32) {
364        self.value = value;
365    }
366}
367
368impl Inst for PushI32Inst {
369    fn address(&self) -> u32 {
370        self.address
371    }
372
373    fn set_address(&mut self, address: u32) {
374        self.address = address;
375    }
376
377    fn serialize_to_binary(&self) -> Vec<u8> {
378        let mut bytes = vec![0x0A];
379        bytes.extend_from_slice(&self.value.to_le_bytes());
380        bytes
381    }
382
383    fn size(&self) -> u32 {
384        5
385    }
386}
387
388pub struct PushI16Inst {
389    address: u32,
390    value: i16,
391}
392
393impl PushI16Inst {
394    pub fn new(value: i16) -> Self {
395        Self { address: 0, value }
396    }
397
398    pub fn get_value(&self) -> i16 {
399        self.value
400    }
401
402    pub fn set_value(&mut self, value: i16) {
403        self.value = value;
404    }
405}
406
407impl Inst for PushI16Inst {
408    fn address(&self) -> u32 {
409        self.address
410    }
411
412    fn set_address(&mut self, address: u32) {
413        self.address = address;
414    }
415
416    fn serialize_to_binary(&self) -> Vec<u8> {
417        let mut bytes = vec![0x0B];
418        bytes.extend_from_slice(&self.value.to_le_bytes());
419        bytes
420    }
421
422    fn size(&self) -> u32 {
423        3
424    }
425}
426
427pub struct PushI8Inst {
428    address: u32,
429    value: i8,
430}
431
432impl PushI8Inst {
433    pub fn new(value: i8) -> Self {
434        Self { address: 0, value }
435    }
436}
437
438impl Inst for PushI8Inst {
439    fn address(&self) -> u32 {
440        self.address
441    }
442
443    fn set_address(&mut self, address: u32) {
444        self.address = address;
445    }
446
447    fn serialize_to_binary(&self) -> Vec<u8> {
448        vec![0x0C, self.value as u8]
449    }
450
451    fn size(&self) -> u32 {
452        2
453    }
454}
455
456pub struct PushF32Inst {
457    address: u32,
458    value: f32,
459}
460
461impl PushF32Inst {
462    pub fn new(value: f32) -> Self {
463        Self { address: 0, value }
464    }
465}
466
467impl Inst for PushF32Inst {
468    fn address(&self) -> u32 {
469        self.address
470    }
471
472    fn set_address(&mut self, address: u32) {
473        self.address = address;
474    }
475
476    fn serialize_to_binary(&self) -> Vec<u8> {
477        let mut bytes = vec![0x0D];
478        bytes.extend_from_slice(&self.value.to_le_bytes());
479        bytes
480    }
481
482    fn size(&self) -> u32 {
483        5
484    }
485}
486
487pub struct PushStringInst {
488    address: u32,
489    content: String,
490    content_blob: Vec<u8>,
491    nls: Nls,
492}
493
494impl PushStringInst {
495    pub fn new(content: String, nls: Nls) -> Self {
496        Self {
497            address: 0,
498            content: content.clone(),
499            content_blob: Self::string_to_blob(&content, nls.clone()),
500            nls,
501        }
502    }
503
504    fn string_to_blob(content: &str, nls: Nls) -> Vec<u8> {
505        // convert utf-8 string to local string via Nls
506        let mut content_bytes = match nls {
507            Nls::GBK => encoding_rs::GBK.encode(content).0.to_vec(),
508            Nls::ShiftJIS => encoding_rs::SHIFT_JIS.encode(content).0.to_vec(),
509            Nls::UTF8 => content.as_bytes().to_vec(),
510        };
511
512        if !content_bytes.ends_with(&[0]) {
513            content_bytes.push(0);
514        }
515
516        content_bytes
517    }
518}
519
520impl Inst for PushStringInst {
521    fn address(&self) -> u32 {
522        self.address
523    }
524
525    fn set_address(&mut self, address: u32) {
526        self.address = address;
527    }
528
529    fn serialize_to_binary(&self) -> Vec<u8> {
530        let mut bytes = vec![0x0E];
531        if self.content_blob.len() > 0xFF {
532            panic!("String too long");
533        }
534        bytes.push(self.content_blob.len() as u8);
535        bytes.extend_from_slice(&self.content_blob);
536        bytes
537    }
538
539    fn size(&self) -> u32 {
540        self.content_blob.len() as u32 + 2
541    }
542}
543
544pub struct PushGlobalInst {
545    address: u32,
546    idx: u16,
547}
548
549impl PushGlobalInst {
550    pub fn new(idx: u16) -> Self {
551        Self { address: 0, idx }
552    }
553}
554
555impl Inst for PushGlobalInst {
556    fn address(&self) -> u32 {
557        self.address
558    }
559
560    fn set_address(&mut self, address: u32) {
561        self.address = address;
562    }
563
564    fn serialize_to_binary(&self) -> Vec<u8> {
565        let mut bytes = vec![0x0F];
566        bytes.extend_from_slice(&self.idx.to_le_bytes());
567        bytes
568    }
569
570    fn size(&self) -> u32 {
571        3
572    }
573}
574
575pub struct PushStackInst {
576    address: u32,
577    idx: i8,
578}
579
580impl PushStackInst {
581    pub fn new(idx: i8) -> Self {
582        Self { address: 0, idx }
583    }
584}
585
586impl Inst for PushStackInst {
587    fn address(&self) -> u32 {
588        self.address
589    }
590
591    fn set_address(&mut self, address: u32) {
592        self.address = address;
593    }
594
595    fn serialize_to_binary(&self) -> Vec<u8> {
596        vec![0x10, self.idx as u8]
597    }
598
599    fn size(&self) -> u32 {
600        2
601    }
602}
603
604pub struct PushGlobalTableInst {
605    address: u32,
606    idx: u16,
607}
608
609impl PushGlobalTableInst {
610    pub fn new(idx: u16) -> Self {
611        Self { address: 0, idx }
612    }
613}
614
615impl Inst for PushGlobalTableInst {
616    fn address(&self) -> u32 {
617        self.address
618    }
619
620    fn set_address(&mut self, address: u32) {
621        self.address = address;
622    }
623
624    fn serialize_to_binary(&self) -> Vec<u8> {
625        let mut bytes = vec![0x11];
626        bytes.extend_from_slice(&self.idx.to_le_bytes());
627        bytes
628    }
629
630    fn size(&self) -> u32 {
631        3
632    }
633}
634
635pub struct PushLocalTableInst {
636    address: u32,
637    idx: i8,
638}
639
640impl PushLocalTableInst {
641    pub fn new(idx: i8) -> Self {
642        Self { address: 0, idx }
643    }
644}
645
646impl Inst for PushLocalTableInst {
647    fn address(&self) -> u32 {
648        self.address
649    }
650
651    fn set_address(&mut self, address: u32) {
652        self.address = address;
653    }
654
655    fn serialize_to_binary(&self) -> Vec<u8> {
656        vec![0x12, self.idx as u8]
657    }
658
659    fn size(&self) -> u32 {
660        2
661    }
662}
663
664pub struct PushTopInst {
665    address: u32,
666}
667
668impl PushTopInst {
669    pub fn new() -> Self {
670        Self { address: 0 }
671    }
672}
673
674impl Inst for PushTopInst {
675    fn address(&self) -> u32 {
676        self.address
677    }
678
679    fn set_address(&mut self, address: u32) {
680        self.address = address;
681    }
682
683    fn serialize_to_binary(&self) -> Vec<u8> {
684        vec![0x13]
685    }
686
687    fn size(&self) -> u32 {
688        1
689    }
690}
691
692pub struct PushReturnInst {
693    address: u32,
694}
695
696impl PushReturnInst {
697    pub fn new() -> Self {
698        Self { address: 0 }
699    }
700}
701
702impl Inst for PushReturnInst {
703    fn address(&self) -> u32 {
704        self.address
705    }
706
707    fn set_address(&mut self, address: u32) {
708        self.address = address;
709    }
710
711    fn serialize_to_binary(&self) -> Vec<u8> {
712        vec![0x14]
713    }
714
715    fn size(&self) -> u32 {
716        1
717    }
718}
719
720pub struct PopGlobalInst {
721    address: u32,
722    idx: u16,
723}
724
725impl PopGlobalInst {
726    pub fn new(idx: u16) -> Self {
727        Self { address: 0, idx }
728    }
729}
730
731impl Inst for PopGlobalInst {
732    fn address(&self) -> u32 {
733        self.address
734    }
735
736    fn set_address(&mut self, address: u32) {
737        self.address = address;
738    }
739
740    fn serialize_to_binary(&self) -> Vec<u8> {
741        let mut bytes = vec![0x15];
742        bytes.extend_from_slice(&self.idx.to_le_bytes());
743        bytes
744    }
745
746    fn size(&self) -> u32 {
747        3
748    }
749}
750
751pub struct PopStackInst {
752    address: u32,
753    idx: i8,
754}
755
756impl PopStackInst {
757    pub fn new(idx: i8) -> Self {
758        Self { address: 0, idx }
759    }
760}
761
762impl Inst for PopStackInst {
763    fn address(&self) -> u32 {
764        self.address
765    }
766
767    fn set_address(&mut self, address: u32) {
768        self.address = address;
769    }
770
771    fn serialize_to_binary(&self) -> Vec<u8> {
772        vec![0x16, self.idx as u8]
773    }
774
775    fn size(&self) -> u32 {
776        2
777    }
778}
779
780pub struct PopGlobalTableInst {
781    address: u32,
782    idx: u16,
783}
784
785impl PopGlobalTableInst {
786    pub fn new(idx: u16) -> Self {
787        Self { address: 0, idx }
788    }
789}
790
791impl Inst for PopGlobalTableInst {
792    fn address(&self) -> u32 {
793        self.address
794    }
795
796    fn set_address(&mut self, address: u32) {
797        self.address = address;
798    }
799
800    fn serialize_to_binary(&self) -> Vec<u8> {
801        let mut bytes = vec![0x17];
802        bytes.extend_from_slice(&self.idx.to_le_bytes());
803        bytes
804    }
805
806    fn size(&self) -> u32 {
807        3
808    }
809}
810
811pub struct PopLocalTableInst {
812    address: u32,
813    idx: i8,
814}
815
816impl PopLocalTableInst {
817    pub fn new(idx: i8) -> Self {
818        Self { address: 0, idx }
819    }
820}
821
822impl Inst for PopLocalTableInst {
823    fn address(&self) -> u32 {
824        self.address
825    }
826
827    fn set_address(&mut self, address: u32) {
828        self.address = address;
829    }
830
831    fn serialize_to_binary(&self) -> Vec<u8> {
832        vec![0x18, self.idx as u8]
833    }
834
835    fn size(&self) -> u32 {
836        2
837    }
838}
839
840pub struct NegInst {
841    address: u32,
842}
843
844impl NegInst {
845    pub fn new() -> Self {
846        Self { address: 0 }
847    }
848}
849
850impl Inst for NegInst {
851    fn address(&self) -> u32 {
852        self.address
853    }
854
855    fn set_address(&mut self, address: u32) {
856        self.address = address;
857    }
858
859    fn serialize_to_binary(&self) -> Vec<u8> {
860        vec![0x19]
861    }
862
863    fn size(&self) -> u32 {
864        1
865    }
866}
867
868pub struct AddInst {
869    address: u32,
870}
871
872impl AddInst {
873    pub fn new() -> Self {
874        Self { address: 0 }
875    }
876}
877
878impl Inst for AddInst {
879    fn address(&self) -> u32 {
880        self.address
881    }
882
883    fn set_address(&mut self, address: u32) {
884        self.address = address;
885    }
886
887    fn serialize_to_binary(&self) -> Vec<u8> {
888        vec![0x1A]
889    }
890
891    fn size(&self) -> u32 {
892        1
893    }
894}
895
896pub struct SubInst {
897    address: u32,
898}
899
900impl SubInst {
901    pub fn new() -> Self {
902        Self { address: 0 }
903    }
904}
905
906impl Inst for SubInst {
907    fn address(&self) -> u32 {
908        self.address
909    }
910
911    fn set_address(&mut self, address: u32) {
912        self.address = address;
913    }
914
915    fn serialize_to_binary(&self) -> Vec<u8> {
916        vec![0x1B]
917    }
918
919    fn size(&self) -> u32 {
920        1
921    }
922}
923
924pub struct MulInst {
925    address: u32,
926}
927
928impl MulInst {
929    pub fn new() -> Self {
930        Self { address: 0 }
931    }
932}
933
934impl Inst for MulInst {
935    fn address(&self) -> u32 {
936        self.address
937    }
938
939    fn set_address(&mut self, address: u32) {
940        self.address = address;
941    }
942
943    fn serialize_to_binary(&self) -> Vec<u8> {
944        vec![0x1C]
945    }
946
947    fn size(&self) -> u32 {
948        1
949    }
950}
951
952pub struct DivInst {
953    address: u32,
954}
955
956impl DivInst {
957    pub fn new() -> Self {
958        Self { address: 0 }
959    }
960}
961
962impl Inst for DivInst {
963    fn address(&self) -> u32 {
964        self.address
965    }
966
967    fn set_address(&mut self, address: u32) {
968        self.address = address;
969    }
970
971    fn serialize_to_binary(&self) -> Vec<u8> {
972        vec![0x1D]
973    }
974
975    fn size(&self) -> u32 {
976        1
977    }
978}
979
980pub struct ModInst {
981    address: u32,
982}
983
984impl ModInst {
985    pub fn new() -> Self {
986        Self { address: 0 }
987    }
988}
989
990impl Inst for ModInst {
991    fn address(&self) -> u32 {
992        self.address
993    }
994
995    fn set_address(&mut self, address: u32) {
996        self.address = address;
997    }
998
999    fn serialize_to_binary(&self) -> Vec<u8> {
1000        vec![0x1E]
1001    }
1002
1003    fn size(&self) -> u32 {
1004        1
1005    }
1006}
1007
1008pub struct BitTestInst {
1009    address: u32,
1010}
1011
1012impl BitTestInst {
1013    pub fn new() -> Self {
1014        Self { address: 0 }
1015    }
1016}
1017
1018impl Inst for BitTestInst {
1019    fn address(&self) -> u32 {
1020        self.address
1021    }
1022
1023    fn set_address(&mut self, address: u32) {
1024        self.address = address;
1025    }
1026
1027    fn serialize_to_binary(&self) -> Vec<u8> {
1028        vec![0x1F]
1029    }
1030
1031    fn size(&self) -> u32 {
1032        1
1033    }
1034}
1035
1036pub struct AndInst {
1037    address: u32,
1038}
1039
1040impl AndInst {
1041    pub fn new() -> Self {
1042        Self { address: 0 }
1043    }
1044}
1045
1046impl Inst for AndInst {
1047    fn address(&self) -> u32 {
1048        self.address
1049    }
1050
1051    fn set_address(&mut self, address: u32) {
1052        self.address = address;
1053    }
1054
1055    fn serialize_to_binary(&self) -> Vec<u8> {
1056        vec![0x20]
1057    }
1058
1059    fn size(&self) -> u32 {
1060        1
1061    }
1062}
1063
1064pub struct OrInst {
1065    address: u32,
1066}
1067
1068impl OrInst {
1069    pub fn new() -> Self {
1070        Self { address: 0 }
1071    }
1072}
1073
1074impl Inst for OrInst {
1075    fn address(&self) -> u32 {
1076        self.address
1077    }
1078
1079    fn set_address(&mut self, address: u32) {
1080        self.address = address;
1081    }
1082
1083    fn serialize_to_binary(&self) -> Vec<u8> {
1084        vec![0x21]
1085    }
1086
1087    fn size(&self) -> u32 {
1088        1
1089    }
1090}
1091
1092pub struct SetEInst {
1093    address: u32,
1094}
1095
1096impl SetEInst {
1097    pub fn new() -> Self {
1098        Self { address: 0 }
1099    }
1100}
1101
1102impl Inst for SetEInst {
1103    fn address(&self) -> u32 {
1104        self.address
1105    }
1106
1107    fn set_address(&mut self, address: u32) {
1108        self.address = address;
1109    }
1110
1111    fn serialize_to_binary(&self) -> Vec<u8> {
1112        vec![0x22]
1113    }
1114
1115    fn size(&self) -> u32 {
1116        1
1117    }
1118}
1119
1120pub struct SetNEInst {
1121    address: u32,
1122}
1123
1124impl SetNEInst {
1125    pub fn new() -> Self {
1126        Self { address: 0 }
1127    }
1128}
1129
1130impl Inst for SetNEInst {
1131    fn address(&self) -> u32 {
1132        self.address
1133    }
1134
1135    fn set_address(&mut self, address: u32) {
1136        self.address = address;
1137    }
1138
1139    fn serialize_to_binary(&self) -> Vec<u8> {
1140        vec![0x23]
1141    }
1142
1143    fn size(&self) -> u32 {
1144        1
1145    }
1146}
1147
1148pub struct SetGInst {
1149    address: u32,
1150}
1151
1152impl SetGInst {
1153    pub fn new() -> Self {
1154        Self { address: 0 }
1155    }
1156}
1157
1158impl Inst for SetGInst {
1159    fn address(&self) -> u32 {
1160        self.address
1161    }
1162
1163    fn set_address(&mut self, address: u32) {
1164        self.address = address;
1165    }
1166
1167    fn serialize_to_binary(&self) -> Vec<u8> {
1168        vec![0x24]
1169    }
1170
1171    fn size(&self) -> u32 {
1172        1
1173    }
1174}
1175
1176pub struct SetLEInst {
1177    address: u32,
1178}
1179
1180impl SetLEInst {
1181    pub fn new() -> Self {
1182        Self { address: 0 }
1183    }
1184}
1185
1186impl Inst for SetLEInst {
1187    fn address(&self) -> u32 {
1188        self.address
1189    }
1190
1191    fn set_address(&mut self, address: u32) {
1192        self.address = address;
1193    }
1194
1195    fn serialize_to_binary(&self) -> Vec<u8> {
1196        vec![0x25]
1197    }
1198
1199    fn size(&self) -> u32 {
1200        1
1201    }
1202}
1203
1204pub struct SetLInst {
1205    address: u32,
1206}
1207
1208impl SetLInst {
1209    pub fn new() -> Self {
1210        Self { address: 0 }
1211    }
1212}
1213
1214impl Inst for SetLInst {
1215    fn address(&self) -> u32 {
1216        self.address
1217    }
1218
1219    fn set_address(&mut self, address: u32) {
1220        self.address = address;
1221    }
1222
1223    fn serialize_to_binary(&self) -> Vec<u8> {
1224        vec![0x26]
1225    }
1226
1227    fn size(&self) -> u32 {
1228        1
1229    }
1230}
1231
1232pub struct SetGEInst {
1233    address: u32,
1234}
1235
1236impl SetGEInst {
1237    pub fn new() -> Self {
1238        Self { address: 0 }
1239    }
1240}
1241
1242impl Inst for SetGEInst {
1243    fn address(&self) -> u32 {
1244        self.address
1245    }
1246
1247    fn set_address(&mut self, address: u32) {
1248        self.address = address;
1249    }
1250
1251    fn serialize_to_binary(&self) -> Vec<u8> {
1252        vec![0x27]
1253    }
1254
1255    fn size(&self) -> u32 {
1256        1
1257    }
1258}
assembler/inst.rs

assembler/
inst.rs
