Add instruction enum and parser (#1)

* parse: add instruction enum and parser

Add an enum of all (supported) ARM and RISC-V instructions and implement a parser from a text file of asm to the instruction enums.

* **Instruction Enum**: Add `Instruction` enum in `src/instruction.rs` with all ARM and RISC-V instructions.
* **Parser Implementation**: Implement `parse_asm` function in `src/main.rs` to parse asm text files into `Instruction` enums.
* **Binary Translation**: Update `binary_translate` function in `src/main.rs` to use `parse_asm` for translation.
* **Dependencies**: Add `strum` and `strum_macros` dependencies in `Cargo.toml` for enum parsing.
* **Tests**: Add tests in `test/parse_asm.rs` to verify parsing functionality and in `test/binary_translate.rs` to verify translation functionality.

* test: store testing binaries in separate folder

* parse: fix deserialization to use strum

Author: Samir-Rashid

Cargo.toml

@@ -4,3 +4,5 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+strum = "0.21.0"
+strum_macros = "0.21.1"

test/flake.lock flake.locktest/flake.lock renamed to flake.lock

@@ -0,0 +1,22 @@
+{
+  description = "A very basic flake";
+
+  inputs = {
+    nixpkgs.url = "github:nixos/nixpkgs?ref=nixos-unstable";
+  };
+
+
+  outputs = { self, nixpkgs }: let
+	  pkgs = import nixpkgs {
+            system = "x86_64-linux";
+	  };
+   in {
+    devShells.x86_64-linux.default = pkgs.mkShell {
+      # Use the same mkShell as documented above
+        packages = with pkgs; [
+          # TODO: @Anthony, you can change this to use Fenix if you would like
+          rustup
+      ];
+    };
+  };
+}

flake.nix

@@ -0,0 +1,54 @@
+/// This file defines all the supported ARM and RISC-V instructions we support.
+/// We use `strum` to assist in serializing asm files to our [`Instruction`] enum.
+///
+/// We do not aim for completness of translating every possible instruction,
+/// but we do want to thoroughly test for correctness.
+use strum_macros::EnumString;
+
+#[derive(Debug, EnumString)]
+pub enum Instruction {
+    // RISC-V Instructions
+    #[strum(serialize = "addi")]
+    Addi,
+    #[strum(serialize = "sd")]
+    Sd,
+    #[strum(serialize = "ld")]
+    Ld,
+    #[strum(serialize = "sw")]
+    Sw,
+    #[strum(serialize = "lw")]
+    Lw,
+    #[strum(serialize = "mv")]
+    Mv,
+    #[strum(serialize = "addw")]
+    Addw,
+    #[strum(serialize = "sext.w")]
+    SextW,
+    #[strum(serialize = "jr")]
+    Jr,
+    #[strum(serialize = "li")]
+    Li,
+
+    // ARM Instructions
+    #[strum(serialize = "add")]
+    Add,
+    #[strum(serialize = "sub")]
+    Sub,
+    #[strum(serialize = "mov")]
+    Mov,
+    #[strum(serialize = "ldr")]
+    Ldr,
+    #[strum(serialize = "str")]
+    Str,
+    #[strum(serialize = "b")]
+    B,
+    #[strum(serialize = "bl")]
+    Bl,
+    #[strum(serialize = "bx")]
+    Bx,
+    #[strum(serialize = "cmp")]
+    Cmp,
+    #[strum(serialize = "beq")]
+    Beq,
+}
+

src/instruction.rs

@@ -1,13 +1,42 @@
 use std::fs;
+use std::str::FromStr;
+mod instruction;
+use instruction::Instruction;
 
-fn binary_translate(riscv_asm: &str) -> &str {
-    "noop"
+/// Parse a text file into our enum.
+fn parse_asm(asm: &str) -> Vec<Instruction> {
+    asm.lines()
+        .filter_map(|line| {
+            // TODO (Samir): Not sure that this will handle assembly labels
+            // We probably need to construct a map for those to find the
+            // original instruction they map to.
+            let parts: Vec<&str> = line.split_whitespace().collect();
+            if parts.is_empty() {
+                None
+            } else {
+                Instruction::from_str(parts[0]).ok()
+            }
+        })
+        .collect()
 }
 
+/// Runs binary translation
+///   text file -> [`Instruction`] enum array -> text file
+fn binary_translate(riscv_asm: &str) -> String {
+    let instructions = parse_asm(riscv_asm);
+    instructions
+        .into_iter()
+        .map(|instr| format!("{:?}", instr))
+        .collect::<Vec<String>>()
+        .join("\n")
+}
+
+// Samir: I am using main for testing, but it not needed since you can run
+// `cargo test` instead.
 fn main() {
     // Hard code the arguments for now.
-    let path = "./test/hello_world.s";
-    let output_path = "./test/hello_world_translated.s";
+    let path = "../test/binaries/hello_world.s";
+    let output_path = "../test/binaries/hello_world_translated.s";
     let riscv_asm = fs::read_to_string(path).expect("Unable to read file");
 
     let translated_asm = binary_translate(&riscv_asm);