Implement opcode modifier table

Author: ian-h-chamberlain

src/data/redcode.pest

@@ -8,7 +8,7 @@ Line = { Instruction? ~ NEWLINE }
 
 Instruction = _{ Operation ~ Field ~ ("," ~ Field)? }
 
-Operation = ${ Opcode }
+Operation = ${ Opcode ~ ("." ~ Modifier)? }
 
 Field = !{ AddressMode? ~ Expr }
 
@@ -18,7 +18,7 @@ Opcode = {
     ^"SLT" | ^"SPL" | ^"NOP" | ^"ORG" | ^"EQU" | ^"END"
 }
 
-Modifier = { ^"A" | ^"B" | ^"AB" | ^"BA" | ^"F" | ^"X" | ^"I" }
+Modifier = { ^"AB" | ^"BA" | ^"A" | ^"B" | ^"F" | ^"X" | ^"I" }
 
 AddressMode = { "#" | "$" | "*" | "@" | "{" | "<" | "}" | ">" }
 

src/load_file.rs

@@ -34,6 +34,46 @@ enum_string!(pub PseudoOpcode, {
     End => "END",
 });
 
+enum_string!(pub Modifier, {
+    A => "A",
+    B => "B",
+    AB => "AB",
+    BA => "BA",
+    F => "F",
+    X => "X",
+    I => "I",
+});
+
+impl Default for Modifier {
+    fn default() -> Modifier {
+        Modifier::F
+    }
+}
+
+impl Modifier {
+    pub fn from_context(opcode: Opcode, a_mode: AddressMode, b_mode: AddressMode) -> Modifier {
+        use Opcode::*;
+
+        match opcode {
+            Dat => Modifier::F,
+            Jmp | Jmz | Jmn | Djn | Spl | Nop => Modifier::B,
+            opcode => {
+                if a_mode == AddressMode::Immediate {
+                    Modifier::AB
+                } else if b_mode == AddressMode::Immediate {
+                    Modifier::B
+                } else {
+                    match opcode {
+                        Mov | Cmp | Seq | Sne => Modifier::I,
+                        Slt => Modifier::B,
+                        Add | Sub | Mul | Div | Mod => Modifier::F,
+                    }
+                }
+            }
+        }
+    }
+}
+
 enum_string!(pub AddressMode, {
     Immediate => "#",
     Direct => "$",
@@ -82,14 +122,17 @@ impl ToString for Field {
 #[derive(Copy, Clone, Default, Debug, PartialEq)]
 pub struct Instruction {
     pub opcode: Opcode,
+    pub modifier: Modifier,
     pub field_a: Field,
     pub field_b: Field,
 }
 
 impl Instruction {
     pub fn new(opcode: Opcode, field_a: Field, field_b: Field) -> Instruction {
+        let modifier = Modifier::from_context(opcode, field_a.address_mode, field_b.address_mode);
         Instruction {
             opcode,
+            modifier,
             field_a,
             field_b,
         }
@@ -177,6 +220,7 @@ mod tests {
     fn default_instruction() {
         let expected_instruction = Instruction {
             opcode: Opcode::Dat,
+            modifier: Modifier::F,
             field_a: Field {
                 address_mode: AddressMode::Direct,
                 value: 0,

src/parser.rs

@@ -6,7 +6,7 @@ use pest::{
     Parser,
 };
 
-use crate::load_file::{AddressMode, Core, Field, Instruction, Opcode};
+use crate::load_file::{AddressMode, Core, Field, Instruction, Modifier, Opcode};
 
 pub struct Error {
     details: String,
@@ -72,6 +72,11 @@ fn parse_instruction(mut instruction_pairs: Pairs<Rule>) -> Instruction {
             .expect("Opcode must be first pair in Instruction"),
     );
 
+    let maybe_modifier = instruction_pairs
+        .peek()
+        .filter(|pair| pair.as_rule() == Rule::Modifier)
+        .map(|pair| Modifier::from_str(pair.as_str()).expect("Invalid Modifier"));
+
     let field_a = parse_field(
         instruction_pairs
             .next()
@@ -83,8 +88,13 @@ fn parse_instruction(mut instruction_pairs: Pairs<Rule>) -> Instruction {
         .filter(|pair| pair.as_rule() == Rule::Field)
         .map_or_else(Field::default, parse_field);
 
+    let modifier = maybe_modifier.unwrap_or_else(|| {
+        Modifier::from_context(opcode, field_a.address_mode, field_b.address_mode)
+    });
+
     Instruction {
         opcode,
+        modifier,
         field_a,
         field_b,
     }
@@ -95,8 +105,6 @@ fn parse_opcode(opcode_pair: &Pair<Rule>) -> Opcode {
 }
 
 fn parse_field(field_pair: Pair<Rule>) -> Field {
-    dbg!(&field_pair);
-
     let field_pairs = field_pair.into_inner();
 
     let address_mode = field_pairs
@@ -183,7 +191,6 @@ mod tests {
         ]
         .iter()
         {
-            dbg!(test_input);
             parses_to! {
                 parser: RedcodeParser,
                 input: test_input,

src/util.rs

@@ -20,7 +20,7 @@ macro_rules! enum_string {
 
         impl std::string::ToString for $name {
             fn to_string(&self) -> String {
-                use self::$name::*;
+                use $name::*;
                 match *self {
                     $($variant => $value,)*
                 }.to_owned()
@@ -30,7 +30,7 @@ macro_rules! enum_string {
         impl std::str::FromStr for $name {
             type Err = String;
             fn from_str(input_str: &str) -> Result<Self, Self::Err> {
-                use self::$name::*;
+                use $name::*;
                 match input_str {
                     $($value => Ok($variant),)*
                     _ => Err(format!(