editor changes

common/src/instructions.rs

@@ -116,6 +116,40 @@ impl TryFrom<u8> for Register {
     }
 }
 
+impl TryFrom<&str> for Register {
+    type Error = RegisterParseError;
+
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value.to_lowercase().as_str() {
+            "rg0" => Ok(Self::Rg0),
+            "rg1" => Ok(Self::Rg1),
+            "rg2" => Ok(Self::Rg2),
+            "rg3" => Ok(Self::Rg3),
+            "rg4" => Ok(Self::Rg4),
+            "rg5" => Ok(Self::Rg5),
+            "rg6" => Ok(Self::Rg6),
+            "rg7" => Ok(Self::Rg7),
+            "rg8" => Ok(Self::Rg8),
+            "rg9" => Ok(Self::Rg9),
+            "rga" => Ok(Self::Rga),
+            "rgb" => Ok(Self::Rgb),
+            "rgc" => Ok(Self::Rgc),
+            "rgd" => Ok(Self::Rgd),
+            "rge" => Ok(Self::Rge),
+            "rgf" => Ok(Self::Rgf),
+            "acc" => Ok(Self::Acc),
+            "spr" => Ok(Self::Spr),
+            "bpr" => Ok(Self::Bpr),
+            "ret" => Ok(Self::Ret),
+            "idr" => Ok(Self::Idr),
+            "mmr" => Ok(Self::Mmr),
+            "zero" => Ok(Self::Zero),
+            "null" => Ok(Self::NoReg),
+            _ => Err(RegisterParseError::InvalidName(value.to_string())),
+        }
+    }
+}
+
 impl std::fmt::Display for Register {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {

common/src/instructions/args.rs

@@ -16,6 +16,7 @@ impl From<RegisterParseError> for ArgsDecodeError {
     fn from(value: RegisterParseError) -> Self {
         match value {
             RegisterParseError::InvalidIndex(idx) => Self::InvalidRegister(idx),
+            RegisterParseError::InvalidName(_) => Self::InvalidRegister(0xFF),
         }
     }
 }

common/src/instructions/errors.rs

@@ -6,12 +6,14 @@ use crate::prelude::*;
 /// Error type for parsing register numbers.
 pub enum RegisterParseError {
     InvalidIndex(u8),
+    InvalidName(String),
 }
 
 impl std::fmt::Display for RegisterParseError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Self::InvalidIndex(idx) => write!(f, "invalid index given ({idx})"),
+            Self::InvalidName(name) => write!(f, "invalid name given ({name})"),
         }
     }
 }