use std::collections::HashMap;
use crate::instr_table::{find_by_mnemonic, Operand};
use crate::lexer::{lex, DataItem, LineKind};
#[derive(Debug)]
pub struct AsmError {
pub line_no: usize,
pub message: String,
}
impl std::fmt::Display for AsmError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "Line {}: {}", self.line_no, self.message)
}
}
pub fn assemble(source: &str, origin: u16) -> Result<Vec<u8>, AsmError> {
let lines = lex(source);
let mut symbols: HashMap<String, u16> = HashMap::new();
let mut addr: u32 = origin as u32;
for line in &lines {
if let Some(label) = &line.label {
if symbols.contains_key(label) {
return Err(AsmError {
line_no: line.line_no,
message: format!("Label '{}' already defined", label),
});
}
symbols.insert(label.clone(), addr as u16);
}
match &line.kind {
Some(LineKind::Instr { mnemonic, .. }) => {
let def = find_by_mnemonic(mnemonic).ok_or_else(|| AsmError {
line_no: line.line_no,
message: format!("Unknown instruction '{}'", mnemonic),
})?;
addr += def.encoded_len() as u32;
}
Some(LineKind::Db(items)) => {
addr += data_byte_len(items, 1) as u32;
}
Some(LineKind::Dw(items)) => {
addr += data_byte_len(items, 2) as u32;
}
None => {}
}
if addr > 0x10000 {
return Err(AsmError {
line_no: line.line_no,
message: "Exceeds 64KB memory range".to_string(),
});
}
}
let mut out = Vec::new();
for line in &lines {
match &line.kind {
None => {}
Some(LineKind::Instr { mnemonic, operands }) => {
let def = find_by_mnemonic(mnemonic).unwrap();
if operands.len() != def.operands.len() {
return Err(AsmError {
line_no: line.line_no,
message: format!(
"'{}' requires {} operands but got {}",
mnemonic,
def.operands.len(),
operands.len()
),
});
}
out.push(def.opcode);
for (token, shape) in operands.iter().zip(def.operands.iter()) {
encode_operand(token, *shape, &symbols, line.line_no, &mut out)?;
}
}
Some(LineKind::Db(items)) => {
encode_data_items(items, 1, &symbols, line.line_no, &mut out)?;
}
Some(LineKind::Dw(items)) => {
encode_data_items(items, 2, &symbols, line.line_no, &mut out)?;
}
}
}
Ok(out)
}
fn encode_operand(
token: &str,
shape: Operand,
symbols: &HashMap<String, u16>,
line_no: usize,
out: &mut Vec<u8>,
) -> Result<(), AsmError> {
match shape {
Operand::Reg => {
let reg = parse_register(token).ok_or_else(|| AsmError {
line_no,
message: format!("'{}' is not a valid register (r0~r15)", token),
})?;
out.push(reg);
}
Operand::Imm8 => {
let value = resolve_value(token, symbols, line_no)?;
if value > 0xFF {
return Err(AsmError {
line_no,
message: format!("'{}' exceeds 8-bit range (0-255)", token),
});
}
out.push(value as u8);
}
Operand::Imm16 => {
let value = resolve_value(token, symbols, line_no)?;
if value > 0xFFFF {
return Err(AsmError {
line_no,
message: format!("'{}' exceeds 16-bit range (0-65535)", token),
});
}
out.push((value & 0xFF) as u8);
out.push((value >> 8) as u8);
}
}
Ok(())
}
fn data_byte_len(items: &[DataItem], unit: usize) -> usize {
items.iter().map(|item| match item {
DataItem::Value(_) => unit,
DataItem::Str(s) => s.len(), }).sum()
}
fn encode_data_items(
items: &[DataItem],
unit: usize,
symbols: &HashMap<String, u16>,
line_no: usize,
out: &mut Vec<u8>,
) -> Result<(), AsmError> {
for item in items {
match item {
DataItem::Str(s) => {
if unit == 2 {
return Err(AsmError {
line_no,
message: "String literals are not allowed in 'dw'; use 'db' instead".to_string(),
});
}
let mut chars = s.chars().peekable();
while let Some(c) = chars.next() {
let byte = if c == '\\' {
match chars.next() {
Some('n') => b'\n',
Some('t') => b'\t',
Some('0') => b'\0',
Some('\\') => b'\\',
Some('"') => b'"',
Some(other) => other as u8,
None => b'\\',
}
} else {
c as u8
};
out.push(byte);
}
}
DataItem::Value(token) => {
let value = resolve_value(token, symbols, line_no)?;
if unit == 1 {
if value > 0xFF {
return Err(AsmError {
line_no,
message: format!("db: '{token}' exceeds 8-bit range"),
});
}
out.push(value as u8);
} else {
if value > 0xFFFF {
return Err(AsmError {
line_no,
message: format!("dw: '{token}' exceeds 16-bit range"),
});
}
out.push((value & 0xFF) as u8);
out.push((value >> 8) as u8);
}
}
}
}
Ok(())
}
fn parse_register(token: &str) -> Option<u8> {
let digits = token.to_lowercase();
let digits = digits.strip_prefix('r')?;
let n: u8 = digits.parse().ok()?;
(n <= 15).then_some(n)
}
fn resolve_value(token: &str, symbols: &HashMap<String, u16>, line_no: usize) -> Result<u32, AsmError> {
if let Some(hex) = token.strip_prefix("0x").or_else(|| token.strip_prefix("0X")) {
return u32::from_str_radix(hex, 16).map_err(|_| AsmError {
line_no,
message: format!("'{}' is not a valid hexadecimal number", token),
});
}
if let Ok(n) = token.parse::<u32>() {
return Ok(n);
}
symbols.get(token).map(|&a| a as u32).ok_or_else(|| AsmError {
line_no,
message: format!("'{}' is neither a number nor a defined label", token),
})
}