chore: lint

1 files changed, 13 insertions, 21 deletions

diff --git a/src/main.rs b/src/main.rs
index ad3043d..d9e75d7 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -2,15 +2,7 @@ use elf::ElfBytes;
 use elf::endian::AnyEndian;
 use std::io;
 use std::io::Write;
-use std::path::Component::ParentDir;
 use std::sync::{LazyLock, Mutex};
-
-const ABI: [&str; 32] = [
-    "x0", "ra", "sp", "gp", "tp", "t0", "t1", "t2", "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5",
-    "a6", "a7", "s2", "s3", "s4", "s5", "s6", "s7", "s8", "s9", "s10", "s11", "t3", "t4", "t5",
-    "t6",
-];
-
 static MEMORY: LazyLock<Mutex<[u8; 64 * 1024 * 1024]>> =
     LazyLock::new(|| Mutex::new([0u8; 64 * 1024 * 1024]));
 
@@ -164,7 +156,7 @@ fn handle_instruction(memory: &mut [u8], registers: &mut [u32], pc: &mut u32) {
                     let low = memory[(registers[rs1] + imm) as usize];
                     let high = memory[(registers[rs1] + imm + 1) as usize];
                     registers[rd] = ((high as u16) << 8 | low as u16) as u32; // lhu
-                },
+                }
                 _ => panic!("Illegal instruction: {:x}", word),
             }
         }
@@ -184,11 +176,11 @@ fn handle_instruction(memory: &mut [u8], registers: &mut [u32], pc: &mut u32) {
                     let index = (registers[rs1] + imm) as usize;
                     memory[index] = (halfword & 0xFF) as u8;
                     memory[index + 1] = (halfword >> 8) as u8;
-                }, // sh
+                } // sh
                 2 => {
                     let index = (registers[rs1] + imm) as usize;
                     memory[index..index + 4].copy_from_slice(&registers[rs2].to_le_bytes()); // sw
-                },
+                }
                 _ => panic!("Illegal instruction: {:x}", word),
             };
         }
@@ -207,46 +199,46 @@ fn handle_instruction(memory: &mut [u8], registers: &mut [u32], pc: &mut u32) {
                         *pc += imm;
                     }
                     return;
-                }, // beq
+                } // beq
                 1 => {
                     if registers[rs1] != registers[rs2] {
                         *pc += imm;
                     }
                     return;
-                }, // bne
+                } // bne
                 4 => {
                     if (registers[rs1] as i32) < (registers[rs2] as i32) {
                         *pc += imm;
                     }
                     return;
-                }, // blt
+                } // blt
                 5 => {
                     if (registers[rs1] as i32) >= (registers[rs2] as i32) {
                         *pc += imm;
                     }
                     return;
-                }, // bge
+                } // bge
                 6 => {
                     if (registers[rs1] < registers[rs2]) {
                         *pc += imm;
                     }
                     return;
-                }, // bltu
+                } // bltu
                 7 => {
                     if (registers[rs1] >= registers[rs2]) {
                         *pc += imm;
                     }
                     return;
-                }, // bgeu
-                _ => panic!("Illegal instruction: {:x}", word)
+                } // bgeu
+                _ => panic!("Illegal instruction: {:x}", word),
             }
-        },
+        }
         0b1101111 => {
             let rd = (word >> 7) & 0b11111;
             let imm = word >> 12;
             registers[rd as usize] = *pc + 4;
             *pc += imm;
-        }, // jal
+        } // jal
         0b1100111 => {
             let rs1 = (word >> 15) & 0b11111;
             let rd = (word >> 7) & 0b11111;
@@ -259,7 +251,7 @@ fn handle_instruction(memory: &mut [u8], registers: &mut [u32], pc: &mut u32) {
 
             registers[rd as usize] = *pc + 4;
             *pc = registers[rs1 as usize] + imm;
-        },
+        }
         0b0110111 => {
             let imm = word >> 12;
             let rd = ((word >> 7) & 0b11111) as usize;