zxq5/damn_simple_architecture
1
1
Fork 0
Code Issues 8 Pull Requests Actions Packages Projects 1 Releases Wiki Activity

misc: apply clippy lints

Browse Source
This commit is contained in:
J. Hinchliffe
2025-06-19 15:51:23 +01:00
parent c1d72e8d4c
commit 81433dcbcd
17 changed files with 134 additions and 127 deletions
Download Patch File Download Diff File Expand all files Collapse all files
assembler/src/codegen.rs
+20 -23
View File
@@ -1,11 +1,8 @@
use common::{
args, instructions,
prelude::{ITypeArgs, Instruction, Interrupt, RTypeArgs, Register},
};
use common::{args, prelude::*};
use crate::{
AssembleError, expect_token, expect_type,
model::{Node, Opcode, Token, TokenType},
AssembleError, expect_token,
model::{Node, Opcode},
};
pub fn codegen(nodes: Vec<Node>) -> Result<Vec<Instruction>, AssembleError> {
@@ -25,12 +22,12 @@ fn build_instruction(node: Node) -> Result<Instruction, AssembleError> {
match opcode {
Opcode::Nop => Ok(Instruction::Nop),
Opcode::Mov => {
let src = expect_token!(args.get(0).unwrap(), Register)?;
let src = expect_token!(args.first().unwrap(), Register)?;
let dest = expect_token!(args.get(1).unwrap(), Register)?;
Ok(Instruction::Mov(args!(R, sr1: src, dr: dest)))
}
Opcode::Movs => {
let src = expect_token!(args.get(0).unwrap(), Register)?;
let src = expect_token!(args.first().unwrap(), Register)?;
let dest = expect_token!(args.get(1).unwrap(), Register)?;
Ok(Instruction::MovSigned(args!(R, sr1: src, dr: dest)))
}
@@ -42,7 +39,7 @@ fn build_instruction(node: Node) -> Result<Instruction, AssembleError> {
| Opcode::Stb
| Opcode::Stw
| Opcode::Sth => {
let base = expect_token!(args.get(0).unwrap(), Register)?;
let base = expect_token!(args.first().unwrap(), Register)?;
let dest = expect_token!(args.get(1).unwrap(), Register)?;
let offset = expect_token!(args.get(2).unwrap(), Immediate)?;
let args = args!(I, immediate: offset as u16, r1: base, r2: dest);
@@ -60,14 +57,14 @@ fn build_instruction(node: Node) -> Result<Instruction, AssembleError> {
}
}
Opcode::Lli => {
let value = expect_token!(args.get(0).unwrap(), Immediate)?;
let value = expect_token!(args.first().unwrap(), Immediate)?;
let dest = expect_token!(args.get(1).unwrap(), Register)?;
let args = args!(I, immediate: value as u16, r1: dest);
Ok(Instruction::LoadLowerImmediate(args))
}
Opcode::Lui => {
let value = expect_token!(args.get(0).unwrap(), Immediate)? >> 16;
let value = expect_token!(args.first().unwrap(), Immediate)? >> 16;
let dest = expect_token!(args.get(1).unwrap(), Register)?;
let args = args!(I, immediate: value as u16, r1: dest);
@@ -80,7 +77,7 @@ fn build_instruction(node: Node) -> Result<Instruction, AssembleError> {
| Opcode::Jge
| Opcode::Jlt
| Opcode::Jle => {
let address = expect_token!(args.get(0).unwrap(), Immediate)?;
let address = expect_token!(args.first().unwrap(), Immediate)?;
let offset = expect_token!(args.get(1).unwrap(), Register)?;
let args = args!(I, immediate: address as u16, r1: offset);
@@ -96,25 +93,25 @@ fn build_instruction(node: Node) -> Result<Instruction, AssembleError> {
}
}
Opcode::Cmp => {
let left = expect_token!(args.get(0).unwrap(), Register)?;
let left = expect_token!(args.first().unwrap(), Register)?;
let right = expect_token!(args.get(1).unwrap(), Register)?;
Ok(Instruction::Compare(args!(R, sr1: left, sr2: right)))
}
Opcode::Inc => {
let reg = expect_token!(args.get(0).unwrap(), Register)?;
let reg = expect_token!(args.first().unwrap(), Register)?;
Ok(Instruction::Increment(args!(R, sr1: reg)))
}
Opcode::Dec => {
let reg = expect_token!(args.get(0).unwrap(), Register)?;
let reg = expect_token!(args.first().unwrap(), Register)?;
Ok(Instruction::Decrement(args!(R, sr1: reg)))
}
Opcode::Shl => {
let reg = expect_token!(args.get(0).unwrap(), Register)?;
let reg = expect_token!(args.first().unwrap(), Register)?;
let amount = expect_token!(args.get(1).unwrap(), Immediate)? as u8;
Ok(Instruction::ShiftLeft(args!(R, sr1: reg, shamt: amount)))
}
Opcode::Shr => {
let reg = expect_token!(args.get(0).unwrap(), Register)?;
let reg = expect_token!(args.first().unwrap(), Register)?;
let amount = expect_token!(args.get(1).unwrap(), Immediate)? as u8;
Ok(Instruction::ShiftRight(args!(R, sr1: reg, shamt: amount)))
}
@@ -126,7 +123,7 @@ fn build_instruction(node: Node) -> Result<Instruction, AssembleError> {
| Opcode::Nand
| Opcode::Nor
| Opcode::Xnor => {
let left = expect_token!(args.get(0).unwrap(), Register)?;
let left = expect_token!(args.first().unwrap(), Register)?;
let right = expect_token!(args.get(1).unwrap(), Register)?;
let dest = expect_token!(args.get(2).unwrap(), Register)?;
let args = args!(R, sr1: left, sr2: right, dr: dest);
@@ -144,7 +141,7 @@ fn build_instruction(node: Node) -> Result<Instruction, AssembleError> {
}
}
Opcode::Iadd | Opcode::Isub => {
let reg = expect_token!(args.get(0).unwrap(), Register)?;
let reg = expect_token!(args.first().unwrap(), Register)?;
let immediate = expect_token!(args.get(1).unwrap(), Immediate)? as u16;
let dest = expect_token!(args.get(2).unwrap(), Register)?;
let args = args!(I, immediate: immediate, r1: reg, r2: dest);
@@ -156,22 +153,22 @@ fn build_instruction(node: Node) -> Result<Instruction, AssembleError> {
}
}
Opcode::Not => {
let reg = expect_token!(args.get(0).unwrap(), Register)?;
let reg = expect_token!(args.first().unwrap(), Register)?;
let dest = expect_token!(args.get(1).unwrap(), Register)?;
Ok(Instruction::Not(args!(R, sr1: reg, dr: dest)))
}
Opcode::Int => {
let code = expect_token!(args.get(0).unwrap(), Immediate)? as u8;
let code = expect_token!(args.first().unwrap(), Immediate)? as u8;
Ok(Instruction::Interrupt(Interrupt::Software(code)))
}
Opcode::Irt => Ok(Instruction::IntReturn),
Opcode::Hlt => Ok(Instruction::Halt),
Opcode::Data => {
let immediate = expect_token!(args.get(0).unwrap(), Immediate)?;
let immediate = expect_token!(args.first().unwrap(), Immediate)?;
Ok(Instruction::Data(immediate))
}
Opcode::Segment => {
let immediate = expect_token!(args.get(0).unwrap(), Immediate)?;
let immediate = expect_token!(args.first().unwrap(), Immediate)?;
Ok(Instruction::Segment(immediate))
}
Opcode::Db
assembler/src/expand.rs
+6 -6
View File
@@ -1,8 +1,8 @@
use common::prelude::Register;
use crate::{
AssembleError, dsa, expect_token, expect_type,
model::{Node, Opcode, Token, TokenType},
AssembleError, expect_token, expect_type,
model::{Node, Opcode, Token},
node,
};
@@ -13,7 +13,7 @@ pub fn expand_pseudo_ops(
let mut result = Vec::<Node>::with_capacity(nodes.len());
for node in nodes.iter_mut() {
if let Err(_) = try_expand(node.clone(), &mut result, module) {
if try_expand(node.clone(), &mut result, module).is_err() {
result.push(node.clone());
}
}
@@ -22,9 +22,9 @@ pub fn expand_pseudo_ops(
}
fn try_expand(
mut node: Node,
node: Node,
result: &mut Vec<Node>,
module: u64,
_module: u64,
) -> Result<(), AssembleError> {
match node.opcode() {
Opcode::Push => expand_push(node.clone(), result)?,
@@ -176,7 +176,7 @@ fn expand_dx(current: Node, nodes: &mut Vec<Node>) -> Result<(), AssembleError>
let mut buffer = vec![];
let mut args = current.args();
let label = args.remove(0);
let _label = args.remove(0);
for word in process_dx_data(args, size)? {
buffer.push(node!(None, Opcode::Data, Token::Immediate(word)));
assembler/src/lib.rs
+29 -32
View File
@@ -6,7 +6,7 @@ use std::{
path::{Path, PathBuf},
};
use common::prelude::Instruction;
use common::prelude::*;
use crate::{
codegen::codegen,
@@ -38,7 +38,7 @@ pub fn assemble(src: &Path) -> Result<Vec<Instruction>, AssembleError> {
let instructions = codegen(nodes)?;
for inst in instructions.iter() {
println!("{}", inst);
println!("{inst}");
}
Ok(instructions)
@@ -87,7 +87,7 @@ fn prepare_dependency(
);
for n in nodes.iter() {
println!("{}", n);
println!("{n}");
}
program.add_module(nodes);
@@ -161,86 +161,83 @@ fn log(message: &str) {
// create a macro that lexes and parses the input string into Nodes
#[macro_export]
#[macro_use]
macro_rules! dsa {
// Version with formatting arguments
($hash:expr, $input:expr, $($args:expr),+) => {{
let input = format!($input, $($args),+);
let tokens = crate::lexer::lexer(input, $hash)?;
let parsed = crate::parser::Parser::parse_nodes(tokens)?;
let tokens = $crate::lexer::lexer(input, $hash)?;
let parsed = $crate::parser::Parser::parse_nodes(tokens)?;
parsed
}};
// Version without formatting
($hash:expr, $input:expr) => {{
let input = String::from($input);
let tokens = crate::lexer::lexer(input, $hash)?;
let parsed = crate::parser::Parser::parse_nodes(tokens)?;
let tokens = $crate::lexer::lexer(input, $hash)?;
let parsed = $crate::parser::Parser::parse_nodes(tokens)?;
parsed
}};
}
#[macro_export]
#[macro_use]
macro_rules! expect_token {
($token:expr, Symbol) => {
match $token {
Token::Symbol(value) => Ok(value.clone()),
other => Err(AssembleError::UnexpectedToken(
$crate::model::Token::Symbol(value) => Ok(value.clone()),
other => Err($crate::AssembleError::UnexpectedToken(
other.clone(),
TokenType::Symbol,
$crate::model::TokenType::Symbol,
)),
}
};
($token:expr, Register) => {
match $token {
Token::Register(value) => Ok(value.clone()),
other => Err(AssembleError::UnexpectedToken(
$crate::model::Token::Register(value) => Ok(value.clone()),
other => Err($crate::AssembleError::UnexpectedToken(
other.clone(),
TokenType::Register,
$crate::model::TokenType::Register,
)),
}
};
($token:expr, Immediate) => {
match $token {
Token::Immediate(value) => Ok(value.clone()),
other => Err(AssembleError::UnexpectedToken(
$crate::model::Token::Immediate(value) => Ok(value.clone()),
other => Err($crate::AssembleError::UnexpectedToken(
other.clone(),
TokenType::Immediate,
$crate::model::TokenType::Immediate,
)),
}
};
($token:expr, StringLit) => {
match $token {
Token::StringLit(value) => Ok(value.clone()),
other => Err(AssembleError::UnexpectedToken(
$crate::model::Token::StringLit(value) => Ok(value.clone()),
other => Err($crate::AssembleError::UnexpectedToken(
other.clone(),
TokenType::StringLit,
$crate::model::TokenType::StringLit,
)),
}
};
($token:expr, Opcode) => {
match $token {
Token::Opcode(value) => Ok(value.clone()),
other => Err(AssembleError::UnexpectedToken(
$crate::model::Token::Opcode(value) => Ok(value.clone()),
other => Err($crate::AssembleError::UnexpectedToken(
other.clone(),
TokenType::Opcode,
$crate::model::TokenType::Opcode,
)),
}
};
}
#[macro_export]
#[macro_use]
macro_rules! expect_type {
($token:expr, $($variant:ident),+) => {{
let token = $token;
match &token {
$(
Token::$variant(_) => Ok(token.clone()),
$crate::model::Token::$variant(_) => Ok(token.clone()),
)+
other => {
let expected_type = expect_type!(@get_first_type $($variant),+);
Err(AssembleError::UnexpectedToken(
Err($crate::AssembleError::UnexpectedToken(
other.clone().clone(),
expected_type,
))
@@ -248,9 +245,9 @@ macro_rules! expect_type {
}
}};
(@get_first_type Symbol $(, $rest:ident)*) => { TokenType::Symbol };
(@get_first_type Register $(, $rest:ident)*) => { TokenType::Register };
(@get_first_type Immediate $(, $rest:ident)*) => { TokenType::Immediate };
(@get_first_type StringLit $(, $rest:ident)*) => { TokenType::StringLit };
(@get_first_type Opcode $(, $rest:ident)*) => { TokenType::Opcode };
(@get_first_type Symbol $(, $rest:ident)*) => { $crate::model::TokenType::Symbol };
(@get_first_type Register $(, $rest:ident)*) => { $crate::model::TokenType::Register };
(@get_first_type Immediate $(, $rest:ident)*) => { $crate::model::TokenType::Immediate };
(@get_first_type StringLit $(, $rest:ident)*) => { $crate::model::TokenType::StringLit };
(@get_first_type Opcode $(, $rest:ident)*) => { $crate::model::TokenType::Opcode };
}
assembler/src/main.rs
+1 -1
View File
@@ -20,7 +20,7 @@ fn main() {
});
}
Err(e) => {
eprintln!("{}", e);
eprintln!("{e}");
std::process::exit(1);
}
}
assembler/src/model.rs
+9 -3
View File
@@ -12,7 +12,6 @@ pub struct Node {
}
#[macro_export]
#[macro_use]
macro_rules! node {
($symbol: expr, $opcode: expr, args: $tokens: expr) => {
Node::new($symbol.clone(), $opcode.clone(), $tokens.clone())
@@ -55,7 +54,7 @@ impl Node {
impl fmt::Display for Node {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let symbol = match &self.label() {
Some(symbol) => format!("{}:\n", symbol),
Some(symbol) => format!("{symbol}:\n"),
None => "".to_string(),
};
@@ -146,12 +145,19 @@ impl fmt::Display for Opcode {
}
}
#[derive(Debug, Clone, Eq, Hash)]
#[derive(Debug, Clone, Eq)]
pub struct Symbol {
pub name: String,
pub module: Module,
}
impl std::hash::Hash for Symbol {
fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
self.name.hash(state);
self.module.hash(state);
}
}
impl PartialEq for Symbol {
fn eq(&self, other: &Self) -> bool {
self.name == other.name && self.module == other.module
assembler/src/parser.rs
+9 -6
View File
@@ -1,9 +1,12 @@
use std::path::PathBuf;
use common::prelude::{Instruction, Register};
use crate::{
AssembleError, expect_token, expect_type,
model::{Node, Opcode, Token, TokenType},
node,
};
use crate::model::{Module, Node, Opcode, Symbol, Token, TokenType};
use crate::{AssembleError, dsa, expect_token, expect_type, node, quick_hash};
use common::prelude::*;
pub struct Parser {
tokens: Vec<Token>,
@@ -93,7 +96,7 @@ impl Parser {
let mut offset = Token::Immediate(0);
if let Ok(next) = self.peek_next() {
if let Ok(_) = expect_type!(next, Immediate) {
if expect_type!(next, Immediate).is_ok() {
offset = self.next()?;
}
}
@@ -105,7 +108,7 @@ impl Parser {
let dest = expect_type!(self.next()?, Register, Symbol)?;
let mut offset = Token::Immediate(0);
if let Ok(next) = self.peek_next() {
if let Ok(_) = expect_type!(next, Immediate) {
if expect_type!(next, Immediate).is_ok() {
offset = self.next()?;
}
}
@@ -273,7 +276,7 @@ impl Parser {
Token::StringLit(_) => {
values.push(self.tokens.pop().unwrap());
}
Token::Immediate(val) if *val <= u32::MAX as u32 => {
Token::Immediate(_) => {
values.push(self.tokens.pop().unwrap());
}
_ => break,
assembler/src/resolver.rs
+3 -5
View File
@@ -8,8 +8,8 @@ use crate::{
node, quick_hash,
};
pub fn resolve_symbols(nodes: &mut Vec<Node>) -> Result<(), AssembleError> {
let symbol_table = generate_symbol_table(&nodes)?;
pub fn resolve_symbols(nodes: &mut [Node]) -> Result<(), AssembleError> {
let symbol_table = generate_symbol_table(nodes)?;
for node in nodes.iter_mut() {
match node.opcode() {
@@ -53,9 +53,7 @@ pub fn resolve_symbols(nodes: &mut Vec<Node>) -> Result<(), AssembleError> {
Ok(())
}
fn generate_symbol_table(
nodes: &Vec<Node>,
) -> Result<HashMap<Symbol, u32>, AssembleError> {
fn generate_symbol_table(nodes: &[Node]) -> Result<HashMap<Symbol, u32>, AssembleError> {
let mut table = HashMap::new();
for (i, node) in nodes.iter().enumerate() {