bytes-extr on aluasm!

Author: 6293

src/isa/asm.rs

@@ -166,6 +166,14 @@ macro_rules! instr {
         ))
     };
 
+    (extr s16[$idx:literal], $regr:ident[$regr_idx:literal],a16[$offset_idx:literal]) => {
+        Instr::Bytes(BytesOp::Extr(
+            RegS::from($idx),
+            $crate::_reg_ty!(Reg, $regr),
+            $crate::_reg_idx16!($regr_idx),
+            $crate::_reg_idx16!($offset_idx),
+        ))
+    };
     (put s16[$idx:literal], $val:literal) => {{
         Instr::Bytes(BytesOp::Put(RegS::from($idx), Box::new(ByteStr::with($val)), false))
     }};

src/isa/exec.rs

@@ -1052,55 +1052,10 @@ impl InstructionSet for ReservedOp {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::data::Layout;
     use crate::reg::Reg16;
     #[cfg(feature = "secp256k1")]
     use crate::reg::{Reg8, RegBlockAR};
 
-    #[test]
-    fn bytes_extr_test() {
-        let mut register = CoreRegs::default();
-        let lib_site = LibSite::default();
-        let mut bytes = [0; u16::MAX as usize];
-        let offset = 5;
-        let s = "hello";
-        for (i, e) in s.as_bytes().iter().enumerate() {
-            bytes[offset + i] = *e;
-        }
-        BytesOp::Put(1.into(), Box::new(ByteStr::with(bytes)), false).exec(
-            &mut register,
-            lib_site,
-            &(),
-        );
-        PutOp::PutA(RegA::A16, Reg32::Reg0, MaybeNumber::from(offset as u16).into()).exec(
-            &mut register,
-            lib_site,
-            &(),
-        );
-        BytesOp::Extr(1.into(), RegR::R128, Reg16::Reg0, Reg16::Reg0).exec(
-            &mut register,
-            lib_site,
-            &(),
-        );
-        let mut num = register.get(RegR::R128, Reg32::Reg0).unwrap();
-        num.reshape(Layout::unsigned(s.len() as u16));
-        assert_eq!(num, Number::from_slice(s.as_bytes()));
-        PutOp::PutA(RegA::A16, Reg32::Reg1, MaybeNumber::from(offset as u16 + 1).into()).exec(
-            &mut register,
-            lib_site,
-            &(),
-        );
-        BytesOp::Extr(1.into(), RegR::R128, Reg16::Reg1, Reg16::Reg1).exec(
-            &mut register,
-            lib_site,
-            &(),
-        );
-        let mut num = register.get(RegR::R128, Reg32::Reg1).unwrap();
-        num.reshape(Layout::unsigned(s.len() as u16 - 1));
-        assert_eq!(num, Number::from_slice("ello".as_bytes()));
-        assert!(register.st0);
-    }
-
     #[test]
     fn bytes_extr_offset_overflow_test() {
         let mut register = CoreRegs::default();

src/isa/instr.rs

@@ -696,7 +696,7 @@ pub enum BytesOp {
     ///
     /// If the source string register - or offset register is uninitialized, sets destination to
     /// uninitialized state and `st0` to `false`.
-    #[display("extr    {0},{1}{2},{1}{3}")]
+    #[display("extr    {0},{1}{2},a16[{3}]")]
     Extr(/** `s` register index */ RegS, RegR, Reg16, /** `a16` register with offset */ Reg16),
 
     /// Inject general `R` register value at a given position to string register, replacing value

tests/asm.rs

@@ -212,6 +212,28 @@ fn bytes_put() {
     run(code, false);
 }
 
+#[test]
+fn bytes_extr() {
+    let code = aluasm! {
+            put    s16[0],"################@@@@@@";
+            put    0,a16[0];
+            extr   s16[0],r128[0],a16[0];
+            put    0x23232323232323232323232323232323,r128[1];
+            eq.n   r128[0],r128[1];
+            ret;
+    };
+    run(code, true);
+    let code = aluasm! {
+            put    s16[0],"################@@@@@@";
+            put    3,a16[0];
+            extr   s16[0],r128[0],a16[0];
+            put    0x40404023232323232323232323232323,r128[1];
+            eq.n   r128[0],r128[1];
+            ret;
+    };
+    run(code, true);
+}
+
 fn run(code: Vec<Instr>, expect_success: bool) {
     let mut runtime = Vm::<Instr>::new();