Merge pull request #13 from ian-h-chamberlain/parse-pseudo-opcodes

Parse pseudo opcodes ORG + END

Author: ian-h-chamberlain

Cargo.lock

@@ -1,18 +1,6 @@
-[package]
-name = "corewa_rs"
-version = "0.1.0"
-authors = ["Ian Chamberlain <[email protected]>"]
-edition = "2018"
+[workspace]
 
-[dependencies]
-itertools = "0.8.0"
-lazy_static = "1.2.0"
-pest_derive = "2.1.0"
-pest = "2.1.0"
-structopt = "0.3.5"
-
-[dev-dependencies]
-assert_cmd = "0.11.1"
-predicates = "1.0.2"
-assert_fs = "0.13.1"
-indoc = "0.3.4"
+members = [
+    "corewa_rs",
+    "testutils",
+]

Cargo.toml

@@ -2,3 +2,7 @@
 A Rust implementation of [Core Wars](http://www.koth.org/index.html).
 
 The implementation is based on [this introductory guide](http://vyznev.net/corewar/guide.html) to Redcode, as well as the [pMARS '94 reference](http://www.koth.org/info/pmars-redcode-94.txt) and an [annotated version](http://corewar.co.uk/standards/icws94.txt) of the ICWS '94 draft.
+
+## Crates
+* `corewa_rs` - the main implementation
+* `testutils` - some utilities for working with load files and testing complex predicates

README.md

@@ -0,0 +1,18 @@
+[package]
+name = "corewa_rs"
+version = "0.1.0"
+authors = ["Ian Chamberlain <[email protected]>"]
+edition = "2018"
+
+[dependencies]
+itertools = "0.8.0"
+lazy_static = "1.2.0"
+pest_derive = "2.1.0"
+pest = "2.1.0"
+structopt = "0.3.5"
+
+[dev-dependencies]
+assert_cmd = "0.11.1"
+assert_fs = "0.13.1"
+predicates = "1.0.2"
+testutils = { path = "../testutils" }

corewa_rs/Cargo.toml

@@ -0,0 +1,151 @@
+use std::fmt;
+
+use lazy_static::lazy_static;
+
+mod program;
+mod types;
+
+pub use program::{LabelMap, Program};
+pub use types::{AddressMode, Modifier, Opcode, Value};
+
+lazy_static! {
+    pub static ref DEFAULT_CONSTANTS: LabelMap = {
+        let mut constants = LabelMap::new();
+        constants.insert("CORESIZE".into(), 8000);
+        constants.insert("MAXPROCESSES".into(), 8000);
+        constants.insert("MAXCYCLES".into(), 80_000);
+        constants.insert("MAXLENGTH".into(), 100);
+        constants.insert("MINDISTANCE".into(), 100);
+        constants.insert("ROUNDS".into(), 1);
+
+        // TODO: handle command-line constant redefinition and things like
+        // CURLINE, VERSION, WARRIORS, PSPACESIZE
+        constants
+    };
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Field {
+    pub address_mode: AddressMode,
+    pub value: Value,
+}
+
+impl Default for Field {
+    fn default() -> Self {
+        Self {
+            address_mode: AddressMode::Immediate,
+            value: Default::default(),
+        }
+    }
+}
+
+impl fmt::Display for Field {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.pad(&format!("{}{}", self.address_mode, self.value))
+    }
+}
+
+impl Field {
+    pub fn direct(value: i32) -> Self {
+        Self {
+            address_mode: AddressMode::Direct,
+            value: Value::Literal(value),
+        }
+    }
+
+    pub fn direct_label<S: ToString>(label: S) -> Self {
+        Self {
+            address_mode: AddressMode::Direct,
+            value: Value::Label(label.to_string()),
+        }
+    }
+
+    pub fn immediate(value: i32) -> Self {
+        Self {
+            address_mode: AddressMode::Immediate,
+            value: Value::Literal(value),
+        }
+    }
+
+    pub fn resolve(&self, from: usize, labels: &LabelMap) -> Result<Self, String> {
+        match &self.value {
+            Value::Literal(_) => Ok(self.clone()),
+            Value::Label(label) => {
+                let label_value = labels
+                    .get(label)
+                    .ok_or_else(|| format!("Label '{}' not found", &label))?;
+
+                let value = Value::Literal((*label_value as i32) - (from as i32));
+
+                Ok(Self {
+                    value,
+                    ..self.clone()
+                })
+            }
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Instruction {
+    pub opcode: Opcode,
+    pub modifier: Modifier,
+    pub field_a: Field,
+    pub field_b: Field,
+}
+
+impl fmt::Display for Instruction {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.pad(&format!(
+            "{}.{:<2} {}, {}",
+            self.opcode, self.modifier, self.field_a, self.field_b,
+        ))
+    }
+}
+
+impl Instruction {
+    pub fn new(opcode: Opcode, field_a: Field, field_b: Field) -> Self {
+        let modifier =
+            Modifier::default_88_to_94(opcode, field_a.address_mode, field_b.address_mode);
+
+        Instruction {
+            opcode,
+            modifier,
+            field_a,
+            field_b,
+        }
+    }
+
+    pub fn resolve(&self, from: usize, labels: &LabelMap) -> Result<Self, String> {
+        let field_a = self.field_a.resolve(from, labels)?;
+        let field_b = self.field_b.resolve(from, labels)?;
+        Ok(Self {
+            field_a,
+            field_b,
+            ..self.clone()
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn default_instruction() {
+        let expected_instruction = Instruction {
+            opcode: Opcode::Dat,
+            modifier: Modifier::F,
+            field_a: Field {
+                address_mode: AddressMode::Immediate,
+                value: Value::Literal(0),
+            },
+            field_b: Field {
+                address_mode: AddressMode::Immediate,
+                value: Value::Literal(0),
+            },
+        };
+
+        assert_eq!(Instruction::default(), expected_instruction)
+    }
+}