Automatically derive decoding

BenMcAvoy · BenMcAvoy · commit dbeab28fa729 · 2024-01-29T01:43:01.000Z
diff --git a/lib/macros/src/lib.rs b/lib/macros/src/lib.rs
@@ -35,6 +35,16 @@ fn get_type_name(ty: &syn::Type) -> String {
     }
 }
 
+fn variant_opcode_value(v: &syn::Variant) -> u8 {
+    for attr in v.attrs.iter() {
+        if attr.path().is_ident("opcode") {
+            return attr.parse_args::<syn::LitInt>().unwrap().base10_parse().unwrap();
+        }
+    }
+
+    0
+}
+
 fn impl_opcode_struct(ast: &ItemEnum) -> TokenStream {
     let field_names: Vec<_> = ast.variants.iter().map(|x| &x.ident).collect();
     let field_values = ast.variants.iter().map(|x| {
@@ -87,13 +97,94 @@ fn impl_opcode_struct(ast: &ItemEnum) -> TokenStream {
                             | ((*r2 as u16) & 0xf) << 12
                     },
 
-                    ["Register", "u8"] => quote! {
-                        // reg as u16 | 8 BIT INT
-                        // req as u16 | (((*reg as u8) >> 4) | (*amount))
-                        // Self::#name(reg, amount) => OpCode::#name as u16 | ((((*reg as u8) >> 4) | (amount)) as u16 >> 8)
-                        Self::#name(reg, amount) => ((((*reg as u8) << 4 | amount) as u16) << 8) | (OpCode::#name as u16)
-                        // ((*reg as u8) & 0xf) << 8
-                        // | ((*amount as u8) & 0xf) << 8
+                    _ => panic!("Invalid types {types:?}"),
+                }
+            } else {
+                panic!("Unknown fields type for ident {name}");
+            }
+        })
+    .collect();
+
+    let field_u16_decodings: Vec<_> = ast
+        .variants
+        .iter()
+        .map(|x| {
+            let value = variant_opcode_value(x);
+            let name = &x.ident;
+
+            if let syn::Fields::Unit = &x.fields {
+                return quote! {
+                    #value => Ok(Self::#name)
+                };
+            }
+
+            if let syn::Fields::Unnamed(fields) = &x.fields {
+                let types: Vec<_> = fields
+                    .unnamed
+                    .iter()
+                    .map(|f| get_type_name(&f.ty))
+                    .collect();
+
+                let types: Vec<&str> = types.iter().map(AsRef::as_ref).collect();
+
+                match types[..] {
+                    ["u8"] => quote! {
+                        #value => Ok(Self::#name(((ins & 0xff00) >> 8) as u8))
+                    },
+
+                    ["Register"] => quote! {
+                        #value => Ok(Self::#name(Register::from(((ins & 0xf00) >> 8) as u8)))
+                    },
+
+                    ["Register", "Register"] => quote! {
+                        #value => {
+                            let r1 = Register::from(((ins & 0xf00) >> 8) as u8);
+                            let r2 = Register::from(((ins & 0xf000) >> 12) as u8);
+
+                            Ok(Self::#name(r1, r2))
+                        }
+                    },
+
+                    _ => panic!("Invalid types {types:?}"),
+                }
+            } else {
+                panic!("Unknown fields type for ident {name}");
+            }
+        })
+    .collect();
+
+    let field_to_string: Vec<_> = ast
+        .variants
+        .iter()
+        .map(|x| {
+            let name = &x.ident;
+
+            if let syn::Fields::Unit = &x.fields {
+                return quote! {
+                    Self::#name => write!(f, stringify!(#name))
+                };
+            }
+
+            if let syn::Fields::Unnamed(fields) = &x.fields {
+                let types: Vec<_> = fields
+                    .unnamed
+                    .iter()
+                    .map(|f| get_type_name(&f.ty))
+                    .collect();
+
+                let types: Vec<&str> = types.iter().map(AsRef::as_ref).collect();
+
+                match types[..] {
+                    ["u8"] => quote! {
+                        Self::#name(byte) => write!(f, "{} {}", stringify!(#name), byte)
+                    },
+
+                    ["Register"] => quote! {
+                        Self::#name(r) => write!(f, "{} {}", stringify!(#name), r)
+                    },
+
+                    ["Register", "Register"] => quote! {
+                        Self::#name(r1, r2) => write!(f, "{} {} {}", stringify!(#name), r1, r2)
                     },
 
                     _ => panic!("Invalid types {types:?}"),
@@ -131,12 +222,32 @@ fn impl_opcode_struct(ast: &ItemEnum) -> TokenStream {
             fn try_from(value: u8) -> Result<Self, Self::Error> {
                 match value {
                     #(x if x == Self::#field_names as u8 => Ok(Self::#field_names),)*
-                    // x if x == Self::AddReg as u8 => Ok(Self::AddReg),
                     _ => Err(format!("Unknown opcode 0x{value:X}")),
                 }
             }
         }
 
+        impl TryFrom<u16> for Instruction {
+            type Error = String;
+
+            fn try_from(ins: u16) -> Result<Self, Self::Error> {
+                let op = (ins & 0xff) as u8;
+
+                match op {
+                    #(#field_u16_decodings,)*
+                    _ => panic!("Invalid types"),
+                }
+            }
+        }
+
+        impl std::fmt::Display for Instruction {
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                match self {
+                    #(#field_to_string,)*
+                }
+            }
+        }
+
         impl Instruction {
             pub fn encode_u16(&self) -> u16 {
                 match self {
@@ -176,3 +287,34 @@ pub fn derive_from_u8(input: proc_macro::TokenStream) -> proc_macro::TokenStream
 
     proc_macro::TokenStream::from(expanded)
 }
+
+/// Automatically implements the from display trait
+/// for ease of use
+#[proc_macro_derive(Display)]
+pub fn derive_display(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    let name = input.ident;
+
+    let variants = if let syn::Data::Enum(data) = input.data {
+        data.variants
+    } else {
+        panic!("Display can only be derived for enums");
+    };
+
+    let variant_names: Vec<_> = variants.iter().map(|v| &v.ident).collect();
+
+    let expanded = quote! {
+        impl std::fmt::Display for #name {
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                let string = match self {
+                    #(Self::#variant_names => stringify!(#variant_names),)*
+                    _ => panic!("Invalid value"),
+                };
+
+                write!(f, "{string}")
+            }
+        }
+    };
+
+    proc_macro::TokenStream::from(expanded)
+}
diff --git a/strawberry/src/memory.rs b/strawberry/src/memory.rs
@@ -1,3 +1,5 @@
+use std::fmt::Write;
+
 type DynErr = Box<dyn std::error::Error>;
 
 /// A trait implemented on all types of memory used
@@ -59,8 +61,8 @@ pub enum Error {
 impl std::fmt::Display for Error {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match *self {
-            Error::OutOfBounds(v) => write!(f, "OutOfBounds error occurred @ 0x{v:X}"),
-            Error::OtherError => write!(f, "Another error occurred"),
+            Self::OutOfBounds(v) => write!(f, "OutOfBounds error occurred @ 0x{v:X}"),
+            Self::OtherError => write!(f, "Another error occurred"),
         }
     }
 }
@@ -89,12 +91,13 @@ impl Linear {
 
 impl Addressable for Linear {
     fn dump(&self) -> String {
-        self.bytes
-            .chunks_exact(2)
-            .fold(String::new(), |mut acc, chunk| {
-                acc.push_str(&format!("{:02x}{:02x} ", chunk[0], chunk[1]));
-                acc
-            })
+        let mut result = String::with_capacity(self.bytes.len() * 4);
+
+        for chunk in self.bytes.chunks_exact(2) {
+            write!(result, "{:02x}{:02x} ", chunk[0], chunk[1]).unwrap();
+        }
+
+        result
     }
 
     fn read(&self, addr: u16) -> Result<u8, DynErr> {
diff --git a/strawberry/src/op.rs b/strawberry/src/op.rs
@@ -28,52 +28,3 @@ pub enum Instruction {
     #[opcode(0x6)]
     Signal(u8),
 }
-
-fn parse_instruction_arg(ins: u16) -> u8 {
-    ((ins & 0xff00) >> 8) as u8
-}
-
-impl TryFrom<u16> for Instruction {
-    type Error = String;
-
-    fn try_from(ins: u16) -> Result<Self, Self::Error> {
-        let op = (ins & 0xff) as u8;
-        let opcode = OpCode::try_from(op)?;
-
-        match opcode {
-            OpCode::Nop => Ok(Instruction::Nop),
-            OpCode::Push => {
-                let arg = parse_instruction_arg(ins);
-                Ok(Instruction::Push(arg))
-            }
-
-            OpCode::PopReg => {
-                let reg = (ins & 0xf00) >> 8;
-                let reg = Register::from(reg as u8);
-
-                Ok(Instruction::PopReg(reg))
-            }
-
-            OpCode::PushReg => {
-                let reg = (ins & 0xf00) >> 8;
-                let reg = Register::from(reg as u8);
-
-                Ok(Instruction::PushReg(reg))
-            }
-
-            OpCode::AddStack => Ok(Instruction::AddStack),
-
-            OpCode::AddReg => {
-                let r1 = Register::from(((ins & 0xf00) >> 8) as u8);
-                let r2 = Register::from(((ins & 0xf00) >> 12) as u8);
-
-                Ok(Instruction::AddReg(r1, r2))
-            }
-
-            OpCode::Signal => {
-                let arg = parse_instruction_arg(ins);
-                Ok(Instruction::Signal(arg))
-            }
-        }
-    }
-}
diff --git a/strawberry/src/register.rs b/strawberry/src/register.rs
@@ -1,8 +1,8 @@
-use strawberryvm_derive::FromU8;
+use strawberryvm_derive::{FromU8, Display};
 
 /// Enum for registers, only really used
 /// to coordinate the register slice.
-#[derive(Debug, Clone, Copy, FromU8)]
+#[derive(Debug, Clone, Copy, FromU8, Display)]
 pub enum Register {
     A = 0,  // General purpose
     B = 1,  // General purpose
diff --git a/strawberry/src/vm.rs b/strawberry/src/vm.rs
@@ -141,7 +141,7 @@ impl Machine {
         let instruction = self.memory.read_u16(pc)?;
         let op = Instruction::try_from(instruction)?;
 
-        println!("{pc:0>4} │ Got instruction {op:?}");
+        println!("{pc:0>4} │ Got instruction `{op}`");
 
         match op {
             Instruction::Nop => Ok(()),
