use anyhow::{Context as _, Result, anyhow, bail};
use core::{mem::take, slice::Iter};
use std::{collections::HashMap, path::Path};
use r8cpu::{
instructions::InstructionKind::{self, *},
regs::{Reg, RegToReg, ShiftReg},
};
use crate::token::{
Token::{self, *},
Tokenizer, tokenize_source_file,
};
pub const BASE: u16 = 0x0100;
pub const KEYWORDS: &[&str] = &[
"add", "and", "asr", "bcc", "bcs", "beq", "bmi", "bne", "bpl", "bra", "call", "clc", "cli",
"cmp", "cpuid", "data", "dec", "halt", "inc", "jmp", "ld", "lsr", "nop", "or", "org", "pop",
"push", "ret", "rol", "ror", "rti", "sec", "sei", "shl", "sub", "test", "trap", "trapv", "xor",
];
pub struct Assembler {
pub code: Vec<u8>,
pub cur_bytes: Vec<u8>,
pub cur_tokens: Vec<Token>,
pub cursor: usize,
pub debug: bool,
pub labels: HashMap<String, u16>,
pub line_no: usize,
pub listing: String,
pub loc: u16,
pub pass2: bool,
pub path: String,
pub prev_loc: u16,
pub source: String,
pub tokens: Vec<Token>,
}
impl Assembler {
pub fn assemble(&mut self) -> Result<Vec<u8>> {
self.pass()
.context(format!("syntax error in {}:{}", self.path, self.line_no))?;
self.code.clear();
self.listing.clear();
self.source.clear();
self.pass2 = true;
self.cursor = 0;
self.line_no = 1;
self.loc = BASE;
self.prev_loc = BASE;
self.pass()?;
Ok(self.code.clone())
}
pub fn assemble_kw(&mut self, kw: &String) -> Result<()> {
match kw.as_str() {
op @ ("add" | "and" | "cmp" | "or" | "sub" | "test" | "xor") => self.gen_alu(op),
"asr" => self.gen_shift(Asr, AsrReg),
"bcc" => self.gen_branch(BranchCc),
"bcs" => self.gen_branch(BranchCs),
"beq" => self.gen_branch(BranchEq),
"bmi" => self.gen_branch(BranchMi),
"bne" => self.gen_branch(BranchNe),
"bpl" => self.gen_branch(BranchPl),
"bra" => self.gen_branch(BranchAlways),
"call" => self.gen_call(),
"clc" => self.emit_byte(u8::from(Clc)),
"cli" => self.emit_byte(u8::from(Cli)),
"cpuid" => self.gen_cpuid(),
"data" => self.gen_data(),
"dec" => self.gen_dec(),
"halt" => self.emit_byte(u8::from(Halt)),
"inc" => self.gen_inc(),
"jmp" => self.gen_jmp(),
"ld" => self.gen_ld_or_store(),
"lsr" => self.gen_shift(Lsr, LsrReg),
"nop" => self.emit_byte(u8::from(Nop)),
"org" => self.org(),
"pop" => self.gen_pop(),
"push" => self.gen_push(),
"ret" => self.emit_byte(u8::from(Ret)),
"rol" => self.gen_shift(Rol, RolReg),
"ror" => self.gen_shift(Ror, RorReg),
"rti" => self.emit_byte(u8::from(Rti)),
"sec" => self.emit_byte(u8::from(Sec)),
"sei" => self.emit_byte(u8::from(Sei)),
"shl" => self.gen_shift(Shl, ShlReg),
"trap" => self.gen_trap(),
"trapv" => self.emit_byte(u8::from(TrapV)),
_ => unreachable!("unknown keyword '{kw}'"),
}
}
pub fn emit_byte(&mut self, byte: u8) -> Result<()> {
self.cur_bytes.push(byte);
self.code.push(byte);
self.loc = self.loc.wrapping_add(1);
if self.loc == 1 && self.code.len() > 1 {
bail!("code too big for memory");
}
Ok(())
}
pub fn emit_word(&mut self, word: u16) -> Result<()> {
let [lo, hi] = word.to_le_bytes();
self.emit_byte(lo)?;
self.emit_byte(hi)
}
pub fn expect(&mut self, expected: &Token) -> Result<()> {
let token = self.next_token()?;
if token != *expected {
bail!("expected {expected}, got {token}")
}
Ok(())
}
#[expect(clippy::cast_possible_truncation, reason = "code ensures valid range")]
pub fn expect_displacement(&mut self) -> Result<u8> {
match self.next_token()? {
ByteLiteral(dis) => Ok(dis),
Identifier(label) if self.pass2 => {
let addr = self.resolve_label(&label)?;
let long_dis = addr.wrapping_sub(self.loc).wrapping_sub(2);
match long_dis {
0x0000..=0x007F | 0xFF80..=0xFFFF => Ok(long_dis as u8),
_ => bail!("displacement out of range: {long_dis:#06X}"),
}
}
Identifier(_) => Ok(0), other => bail!("expected label or immediate byte displacement, got {other}"),
}
}
pub fn expect_op_for_reg(&mut self, reg: Reg) -> Result<Vec<u8>> {
Ok(match self.next_token()? {
ByteLiteral(operand) if !reg.is16() => vec![operand],
WordLiteral(operand) if reg.is16() => Vec::from(operand.to_le_bytes()),
other if reg.is16() => bail!("expected immediate word, got {other}"),
other => bail!("expected immediate byte, got {other}"),
})
}
pub fn expect_reg(&mut self) -> Result<Reg> {
let reg = match self.next_token()? {
Register(reg) => reg,
other => bail!("expected register name, got {other}"),
};
Ok(reg)
}
pub fn expect_reg16(&mut self) -> Result<Reg> {
let reg = match self.next_token()? {
Register(reg) if reg.is16() => reg,
Register(reg) => bail!("expected 16-bit register name, got '{reg}'"),
other => bail!("expected register name, got {other}"),
};
Ok(reg)
}
pub fn expect_reg8(&mut self) -> Result<Reg> {
let reg = match self.next_token()? {
Register(reg) if !reg.is16() => reg,
Register(reg) => bail!("expected 8-bit register name, got '{reg}'"),
other => bail!("expected register name, got '{other}'"),
};
Ok(reg)
}
pub fn gen_alu(&mut self, imm_name: &str) -> Result<()> {
let target = self.expect_reg()?;
let (imm_kind, reg_kind) = match imm_name {
"add" => (Add(target), AddReg),
"and" => (And(target), AndReg),
"cmp" => (Cmp(target), CmpReg),
"or" => (Or(target), OrReg),
"sub" => (Sub(target), SubReg),
"test" => (Test(target), TestReg),
"xor" => (Xor(target), XorReg),
other => unreachable!("unknown instruction '{other}'"),
};
self.expect(&Comma)?;
match self.next_token()? {
ByteLiteral(addend) if !target.is16() => {
self.emit_byte(u8::from(imm_kind))?;
self.emit_byte(addend)
}
WordLiteral(addend) if target.is16() => {
self.emit_byte(u8::from(imm_kind))?;
self.emit_word(addend)
}
Register(source) if source.is16() == target.is16() => {
self.emit_byte(u8::from(reg_kind))?;
self.emit_byte(u8::from(RegToReg { source, target }))
}
other => bail!("expected same-size immediate value or register name, got '{other}'"),
}
}
pub fn gen_branch(&mut self, kind: InstructionKind) -> Result<()> {
let dis = self.expect_displacement()?;
self.emit_byte(u8::from(kind))?;
self.emit_byte(dis)?;
Ok(())
}
pub fn gen_call(&mut self) -> Result<()> {
let addr = match self.next_token()? {
Identifier(label) => self.resolve_label(&label)?,
WordLiteral(addr) => addr,
other => bail!("expected label or address, got {other}"),
};
self.emit_byte(u8::from(Call))?;
self.emit_word(addr)?;
Ok(())
}
pub fn gen_cpuid(&mut self) -> Result<()> {
let query = match self.next_token()? {
ByteLiteral(query) => query,
other => bail!("expected query number, got {other}"),
};
self.emit_byte(u8::from(Cpuid))?;
self.emit_byte(query)?;
Ok(())
}
pub fn gen_data(&mut self) -> Result<()> {
loop {
match self.next_token() {
Err(_) => break,
Ok(ByteLiteral(byte)) => self.emit_byte(byte)?,
Ok(Comma) => {}
Ok(StringLiteral(string)) => {
for ch in string.chars() {
if ch.is_ascii() {
self.emit_byte(ch as u8)?;
} else {
bail!("non-ASCII character {:#04X} in string", ch as u8);
}
}
}
Ok(Newline) => {
self.update_listing();
break;
}
Ok(WordLiteral(word)) => self.emit_word(word)?,
Ok(other) => bail!("expected immediate byte, got {other}"),
}
}
Ok(())
}
pub fn gen_dec(&mut self) -> Result<()> {
match self.next_token()? {
ParenOpen => match self.next_token()? {
Register(reg) if reg.is16() => {
self.expect(&ParenClose)?;
self.emit_byte(u8::from(DecIndirect))?;
self.emit_byte(u8::from(reg))?;
}
WordLiteral(addr) => {
self.expect(&ParenClose)?;
self.emit_byte(u8::from(DecMem))?;
self.emit_word(addr)?;
}
other => bail!("expected 16-bit register or address, got {other}"),
},
Register(reg) => self.emit_byte(u8::from(Dec(reg)))?,
other => bail!("expected register or indirect address, got {other}"),
}
Ok(())
}
pub fn gen_inc(&mut self) -> Result<()> {
match self.next_token()? {
ParenOpen => match self.next_token()? {
Register(reg) if reg.is16() => {
self.expect(&ParenClose)?;
self.emit_byte(u8::from(IncIndirect))?;
self.emit_byte(u8::from(reg))?;
}
WordLiteral(addr) => {
self.expect(&ParenClose)?;
self.emit_byte(u8::from(IncMem))?;
self.emit_word(addr)?;
}
other => bail!("expected 16-bit register or address, got {other}"),
},
Register(reg) => self.emit_byte(u8::from(Inc(reg)))?,
other => bail!("expected register or indirect address, got {other}"),
}
Ok(())
}
pub fn gen_jmp(&mut self) -> Result<()> {
let addr = match self.next_token()? {
Identifier(label) => self.resolve_label(&label)?,
WordLiteral(addr) => addr,
other => bail!("expected label or address, got {other}"),
};
self.emit_byte(u8::from(Jmp))?;
self.emit_word(addr)?;
Ok(())
}
pub fn gen_ld(&mut self, target: Reg) -> Result<()> {
self.expect(&Comma)?;
match self.next_token()? {
ByteLiteral(byte) if !target.is16() => self.gen_ld_imm8(target, byte),
ByteLiteral(byte) => bail!("expected immediate word, got {byte:#04X}"),
Identifier(label) if target.is16() => self.gen_ld_imm_label(target, &label),
Identifier(label) => bail!("expected immediate byte, got label '{label}'"),
ParenOpen if !target.is16() => self.gen_ld_indirect(target),
ParenOpen => bail!("expected 8-bit register, got '{target}'"),
Register(source) if source.is16() == target.is16() => self.gen_ld_reg(source, target),
Register(source) => bail!("expected same size register, got '{source}'"),
WordLiteral(word) if target.is16() => self.gen_ld_imm16(target, word),
WordLiteral(word) => bail!("expected immediate byte, got {word:#06X}"),
other => bail!("unexpected token {other}"),
}
}
pub fn gen_ld_imm16(&mut self, target: Reg, word: u16) -> Result<()> {
self.emit_byte(u8::from(Ld(target)))?;
self.emit_word(word)
}
pub fn gen_ld_imm8(&mut self, target: Reg, byte: u8) -> Result<()> {
self.emit_byte(u8::from(Ld(target)))?;
self.emit_byte(byte)
}
pub fn gen_ld_imm_label(&mut self, target: Reg, label: &str) -> Result<()> {
self.emit_byte(u8::from(Ld(target)))?;
self.emit_word(self.resolve_label(label)?)
}
pub fn gen_ld_indirect(&mut self, target: Reg) -> Result<()> {
let source = self.expect_reg16()?;
match self.next_token()? {
ParenClose => {
self.emit_byte(u8::from(LdIndirect))?;
self.emit_byte(u8::from(RegToReg { source, target }))
}
Plus => {
self.emit_byte(u8::from(LdIndexed))?;
self.emit_byte(u8::from(RegToReg { source, target }))?;
match self.next_token()? {
ByteLiteral(index) => self.emit_byte(index)?,
other => bail!("unexpected token {other}"),
}
self.expect(&ParenClose)
}
other => bail!("unexpected token {other}"),
}
}
pub fn gen_ld_or_store(&mut self) -> Result<()> {
match self.next_token()? {
ParenOpen => self.gen_store_indirect(),
Register(target) => self.gen_ld(target),
WordLiteral(addr) => self.gen_store_direct(addr),
other => bail!("expected register name, got {other}"),
}
}
pub fn gen_ld_reg(&mut self, source: Reg, target: Reg) -> Result<()> {
self.emit_byte(u8::from(LdReg))?;
self.emit_byte(u8::from(RegToReg { source, target }))
}
pub fn gen_pop(&mut self) -> Result<()> {
match self.next_token()? {
Identifier(id) if id == "ps" => self.emit_byte(u8::from(PopPS)),
Register(reg) => self.emit_byte(u8::from(Pop(reg))),
other => bail!("expected register name, got {other}"),
}
}
pub fn gen_push(&mut self) -> Result<()> {
match self.next_token()? {
Identifier(id) if id == "ps" => self.emit_byte(u8::from(PushPS)),
Register(reg) => self.emit_byte(u8::from(Push(reg))),
other => bail!("expected register name, got {other}"),
}
}
pub fn gen_shift(
&mut self,
imm_kind: InstructionKind,
reg_kind: InstructionKind,
) -> Result<()> {
let target = self.expect_reg()?;
self.expect(&Comma)?;
match self.next_token()? {
ByteLiteral(shift) => {
self.emit_byte(u8::from(imm_kind))?;
self.emit_byte(u8::from(ShiftReg {
count: shift,
target,
}))
}
Register(source) if !source.is16() => {
self.emit_byte(u8::from(reg_kind))?;
self.emit_byte(u8::from(RegToReg { source, target }))
}
other => bail!("expected shift count or 8-bit register name, got '{other}'"),
}
}
pub fn gen_store_direct(&mut self, addr: u16) -> Result<()> {
self.expect(&Comma)?;
let reg = self.expect_reg8()?;
self.emit_byte(u8::from(Store(reg)))?;
self.emit_word(addr)?;
Ok(())
}
pub fn gen_store_indirect(&mut self) -> Result<()> {
let target = self.expect_reg16()?;
match self.next_token()? {
ParenClose => {
self.expect(&Comma)?;
match self.next_token()? {
ByteLiteral(value) => {
self.emit_byte(u8::from(StoreIndirectImm))?;
self.emit_byte(u8::from(target))?;
self.emit_byte(value)?;
}
Register(source) if !source.is16() => {
self.emit_byte(u8::from(StoreIndirect))?;
self.emit_byte(u8::from(RegToReg { source, target }))?;
}
Register(reg) => bail!("expected 8-bit register name, got '{reg}'"),
other => bail!("expected register or immediate value, got {other}"),
}
}
Plus => {
let index = match self.next_token()? {
ByteLiteral(index) => index,
other => bail!("unexpected token {other}"),
};
self.expect(&ParenClose)?;
self.expect(&Comma)?;
let source = self.expect_reg8()?;
self.emit_byte(u8::from(StoreIndexed))?;
self.emit_byte(u8::from(RegToReg { source, target }))?;
self.emit_byte(index)?;
}
other => bail!("unexpected token {other}"),
}
Ok(())
}
pub fn gen_trap(&mut self) -> Result<()> {
let trap_code = match self.next_token()? {
ByteLiteral(code @ 0x00..=0x3F) => code,
ByteLiteral(code) => bail!("invalid trap code {code:#04X}"),
other => bail!("expected trap code byte, got {other}"),
};
self.emit_byte(u8::from(Trap))?;
self.emit_byte(trap_code)?;
Ok(())
}
#[must_use]
pub fn new(tokens: Vec<Token>) -> Self {
Self {
cur_bytes: Vec::new(),
cur_tokens: Vec::new(),
code: Vec::new(),
cursor: 0,
debug: false,
labels: HashMap::new(),
line_no: 1,
listing: String::new(),
loc: BASE,
pass2: false,
path: "input".to_owned(),
prev_loc: BASE,
source: String::new(),
tokens,
}
}
pub fn next_token(&mut self) -> Result<Token> {
let token = self
.tokens
.get(self.cursor)
.cloned()
.ok_or(anyhow!("unexpected end of input"))?;
self.cur_tokens.push(token.clone());
self.cursor = self.cursor.checked_add(1).context("token count overflow")?;
Ok(token)
}
pub fn org(&mut self) -> Result<()> {
let addr = match self.next_token()? {
WordLiteral(addr) => addr,
other => bail!("expected address, got {other}"),
};
if !self.code.is_empty() {
let (offset, underflow) = addr.overflowing_sub(self.loc);
if underflow {
bail!("invalid address {addr} for 'org'")
}
self.code
.extend(core::iter::repeat_n(0, usize::from(offset)));
}
self.loc = addr;
Ok(())
}
pub fn pass(&mut self) -> Result<()> {
while let Ok(token) = self.next_token() {
match token {
Comment(_) => {}
Newline => {
self.update_listing();
self.line_no = self.line_no.checked_add(1).context("line count overflow")?;
}
Keyword(kw) => self.assemble_kw(&kw)?,
LabelDef(label) => {
self.labels.insert(label, self.loc);
}
unexpected => bail!("unexpected token {unexpected}"),
}
}
self.update_listing();
Ok(())
}
pub fn resolve_label(&self, label: &str) -> Result<u16> {
Ok(match self.labels.get(label) {
Some(&addr) => addr,
None if self.pass2 => bail!("undefined label {label}"),
None => 0,
})
}
#[expect(clippy::let_underscore_must_use, reason = "writing to strings is safe")]
pub fn update_listing(&mut self) {
use core::fmt::Write as _;
let mut bytes = String::new();
let raw_code = take(&mut self.cur_bytes);
let mut code = raw_code.chunks(4);
if let Some(chunk) = code.next() {
for byte in chunk {
let _ = write!(bytes, " {byte:02X}");
}
}
let tokens = take(&mut self.cur_tokens);
let source = format_line(tokens.as_slice());
self.source.push_str(&source);
let line = format!("{:04X}{:12} {}", self.prev_loc, bytes, source);
self.listing.push_str(&line);
for chunk in code {
self.prev_loc = self.prev_loc.wrapping_add(4);
bytes.clear();
for byte in chunk {
let _ = write!(bytes, " {byte:02X}");
}
let _ = writeln!(self.listing, "{:04X}{bytes}", self.prev_loc);
}
self.prev_loc = self.loc;
}
}
pub struct Disassembler<'code> {
pub code: Iter<'code, u8>,
}
impl<'code> From<&'code [u8]> for Disassembler<'code> {
fn from(code: &'code [u8]) -> Self {
Self { code: code.iter() }
}
}
impl Iterator for Disassembler<'_> {
type Item = String;
fn next(&mut self) -> Option<Self::Item> {
let &opcode = self.code.next()?;
Some(if let Ok(ins) = InstructionKind::try_from(opcode) {
match ins {
Add(reg) => self.format_reg_imm("add", reg),
AddReg => self.format_reg_reg("add"),
And(reg) => self.format_reg_imm("and", reg),
AndReg => self.format_reg_reg("and"),
Asr => self.format_shift_imm("asr"),
AsrReg => self.format_reg_reg("asr"),
BranchAlways => format!("bra {}", self.format_byte()),
BranchCc => format!("bcc {}", self.format_byte()),
BranchCs => format!("bcs {}", self.format_byte()),
BranchEq => format!("beq {}", self.format_byte()),
BranchMi => format!("bmi {}", self.format_byte()),
BranchNe => format!("bne {}", self.format_byte()),
BranchPl => format!("bpl {}", self.format_byte()),
Call => format!("call {}", self.format_word()),
Clc => "clc".into(),
Cli => "cli".into(),
Cmp(reg) => self.format_reg_imm("cmp", reg),
CmpReg => self.format_reg_reg("cmp"),
Cpuid => format!("cpuid {}", self.format_byte()),
Dec(reg) => format!("dec {reg}"),
DecIndirect => self.format_dec_indirect(),
DecMem => format!("dec ({})", self.format_word()),
Halt => "halt".into(),
Inc(reg) => format!("inc {reg}"),
IncIndirect => self.format_inc_indirect(),
IncMem => format!("inc ({})", self.format_word()),
Jmp => format!("jmp {}", self.format_word()),
Ld(reg) => self.format_reg_imm("ld", reg),
LdIndexed => self.format_ld_indexed(),
LdIndirect => self.format_ld_indirect(),
LdReg => self.format_reg_reg("ld"),
Lsr => self.format_shift_imm("lsr"),
LsrReg => self.format_reg_reg("lsr"),
Nop => "nop".into(),
Or(reg) => self.format_reg_imm("or", reg),
OrReg => self.format_reg_reg("or"),
Pop(reg) => format!("pop {reg}"),
PopPS => "pop ps".into(),
Push(reg) => format!("push {reg}"),
PushPS => "push ps".into(),
Ret => "ret".into(),
Rol => self.format_shift_imm("rol"),
RolReg => self.format_reg_reg("rol"),
Ror => self.format_shift_imm("ror"),
RorReg => self.format_reg_reg("ror"),
Rti => "rti".into(),
Sec => "sec".into(),
Sei => "sei".into(),
Shl => self.format_shift_imm("shl"),
ShlReg => self.format_reg_reg("shl"),
Store(reg) => format!("ld {}, {reg}", self.format_word()),
StoreIndexed => self.format_store_indexed(),
StoreIndirect => self.format_store_indirect(),
StoreIndirectImm => self.format_store_indirect_imm(),
Sub(reg) => self.format_reg_imm("sub", reg),
SubReg => self.format_reg_reg("sub"),
Test(reg) => self.format_reg_imm("test", reg),
TestReg => self.format_reg_reg("test"),
Trap => format!("trap {}", self.format_byte()),
TrapV => "trapv".into(),
Xor(reg) => self.format_reg_imm("xor", reg),
XorReg => self.format_reg_reg("xor"),
}
} else {
format!("??? ({opcode:#04X})")
})
}
}
#[expect(clippy::elidable_lifetime_names, reason = "can't be elided here")]
impl<'code> Disassembler<'code> {
fn format_byte(&mut self) -> String {
if let Some(op) = self.code.next() {
format!("{op:#04X}")
} else {
"??? (no operand)".to_owned()
}
}
fn format_dec_indirect(&mut self) -> String {
if let Some(&target_spec) = self.code.next()
&& let Ok(target) = Reg::try_from(target_spec)
&& target.is16()
{
format!("dec ({target})")
} else {
"??? (no operand)".to_owned()
}
}
fn format_inc_indirect(&mut self) -> String {
if let Some(&target_spec) = self.code.next()
&& let Ok(target) = Reg::try_from(target_spec)
&& target.is16()
{
format!("inc ({target})")
} else {
"??? (no operand)".to_owned()
}
}
fn format_ld_indexed(&mut self) -> String {
if let (Some(®s), Some(index)) = (self.code.next(), self.code.next())
&& let Ok(RegToReg { source, target }) = RegToReg::try_from(regs)
{
format!("ld {target}, ({source}+{index:#04X})")
} else {
"??? (no operand)".to_owned()
}
}
fn format_ld_indirect(&mut self) -> String {
if let Some(®s) = self.code.next()
&& let Ok(RegToReg { source, target }) = RegToReg::try_from(regs)
{
format!("ld {target}, ({source})")
} else {
"??? (no operand)".to_owned()
}
}
fn format_op_for_reg(&mut self, reg: Reg) -> String {
if reg.is16() {
self.format_word()
} else {
self.format_byte()
}
}
fn format_reg_imm(&mut self, name: &str, reg: Reg) -> String {
format!("{name} {reg}, {}", self.format_op_for_reg(reg))
}
fn format_reg_reg(&mut self, name: &str) -> String {
if let Some(®s) = self.code.next()
&& let Ok(RegToReg { source, target }) = RegToReg::try_from(regs)
{
format!("{name} {target}, {source}")
} else {
"??? (no operand)".to_owned()
}
}
fn format_shift_imm(&mut self, name: &str) -> String {
if let Some(&encoded) = self.code.next()
&& let Ok(ShiftReg {
count: shift,
target,
}) = ShiftReg::try_from(encoded)
{
format!("{name} {target}, {shift:#04X}")
} else {
"??? (no operand)".to_owned()
}
}
fn format_store_indexed(&mut self) -> String {
if let (Some(®s), Some(index)) = (self.code.next(), self.code.next())
&& let Ok(RegToReg { source, target }) = RegToReg::try_from(regs)
{
format!("ld ({target}+{index:#04X}), {source}")
} else {
"??? (no operand)".to_owned()
}
}
fn format_store_indirect(&mut self) -> String {
if let Some(®s) = self.code.next()
&& let Ok(RegToReg { source, target }) = RegToReg::try_from(regs)
{
format!("ld ({target}), {source}")
} else {
"??? (no operand)".to_owned()
}
}
fn format_store_indirect_imm(&mut self) -> String {
if let (Some(®), Some(byte)) = (self.code.next(), self.code.next())
&& let Ok(target) = Reg::try_from(reg)
{
format!("ld ({target}), {byte:#04X}")
} else {
"??? (no operand)".to_owned()
}
}
fn format_word(&mut self) -> String {
if let (Some(&lo), Some(&hi)) = (self.code.next(), self.code.next()) {
format!("{:#06X}", u16::from_le_bytes([lo, hi]))
} else {
"??? (no operand)".to_owned()
}
}
}
#[must_use]
pub fn as_hex(data: &[u8]) -> String {
let mut byte_strs = Vec::new();
for byte in data {
byte_strs.push(format!("{byte:#04X}"));
}
format!("[{}]", byte_strs.join(", "))
}
pub fn assemble(source: &str) -> Result<Vec<u8>> {
let tokens = Tokenizer::new(source).tokenize()?;
Assembler::new(tokens).assemble()
}
pub fn assemble_with_debug(source: &str) -> Result<Vec<u8>> {
let tokens = Tokenizer::new_with_debug(source).tokenize()?;
let mut asm = Assembler::new(tokens);
asm.debug = true;
asm.assemble()
}
pub fn assemble_source_file(path: impl AsRef<Path>) -> Result<Vec<u8>> {
let tokens = tokenize_source_file(&path)?;
let mut asm = Assembler::new(tokens);
asm.path = path.as_ref().display().to_string();
asm.assemble()
}
#[must_use]
pub fn disassemble(code: &[u8]) -> String {
let mut dis = Disassembler::from(code);
dis.next().unwrap_or_default()
}
#[expect(clippy::let_underscore_must_use, reason = "writing to strings is safe")]
#[expect(clippy::pattern_type_mismatch, reason = "can't make this explicit")]
#[expect(clippy::let_underscore_untyped, reason = "ignoring write result")]
#[must_use]
pub fn format_line(tokens: &[Token]) -> String {
use core::fmt::Write as _;
let mut source = String::new();
match tokens {
[Comment(comment), Newline] => {
let _ = writeln!(source, "; {comment}");
}
[Keyword(kw)] => {
let _ = write!(source, " {kw}");
}
[Keyword(kw), Newline] => {
let _ = writeln!(source, " {kw}");
}
line_tokens => {
for token in line_tokens {
let _ = match token {
ByteLiteral(byte) => write!(source, "{byte:#04X}"),
Comma => write!(source, ", "),
Comment(comment) => {
let padding = 18_usize.saturating_sub(source.len());
write!(source, "{} ; {comment}", " ".repeat(padding))
}
Identifier(text) | Illegal(text) => {
write!(source, "{text}")
}
Include(_) => Ok(()),
Keyword(kw) => write!(source, " {kw} "),
LabelDef(label) => write!(source, "{label}:"),
Newline => writeln!(source),
ParenClose => write!(source, ")"),
ParenOpen => write!(source, "("),
Plus => write!(source, "+"),
Register(reg) => write!(source, "{reg}"),
StringLiteral(text) => write!(source, "\"{text}\""),
WordLiteral(word) => write!(source, "{word:#06X}"),
};
}
}
}
source
}
#[cfg(test)]
#[expect(clippy::unwrap_used, reason = "tests")]
#[expect(clippy::expect_used, reason = "tests")]
#[expect(clippy::default_numeric_fallback, reason = "hex literals")]
mod tests {
use crate::token::tokenize;
use super::*;
macro_rules! assert_asm {
( $source:expr, $generated:expr, $object:expr ) => {
assert_eq!(
&$generated,
$object,
"wrong assembly for '{}': want {}, got {}",
$source,
as_hex($object),
as_hex(&$generated),
);
};
}
macro_rules! assert_disasm {
( $generated:expr, $source:expr ) => {
assert_eq!(
&disassemble(&$generated),
$source,
"wrong disassembly for {}",
as_hex(&$generated)
);
};
}
macro_rules! assert_eq_lines {
( $got:expr, $want:expr ) => {
let mut got_lines = $got.lines();
for want_line in $want.lines() {
assert_eq!(got_lines.next().unwrap_or_default(), want_line);
}
};
}
macro_rules! assert_hex {
( $got:expr, $want:expr, $msg:expr ) => {
assert_eq!(
$got, $want,
"{}: want {:#06X}, got {:#06X}",
$msg, $want, $got,
);
};
}
#[test]
fn assembler_accepts_label_as_immediate_word_value() {
let source = "
LABEL:
ld cd, LABEL
";
let generated = assemble_with_debug(source).unwrap();
assert_asm!(source, generated, &[u8::from(Ld(Reg::CD)), 0x00, 0x01]);
}
#[test]
fn assembler_counts_lines_correctly() {
let source = "ld a, 0xFF\ninc a\nhalt";
let mut asm = Assembler::new(tokenize(source).unwrap());
asm.debug = true;
asm.assemble().unwrap();
assert_eq!(asm.line_no, 3, "wrong line count");
}
#[test]
fn assembler_formats_source() {
let input = "; start
org 0xC000
ld a, 0x10
LOOP:
dec a
beq 0x03
jmp LOOP ; repeat
END:
ld cd, 0xBABE ; babe
ld h, (cd) ; lined up with above
halt
data 0x0E, \"Hello, world!\", 0x0A
";
let mut asm = Assembler::new(tokenize(input).unwrap());
asm.debug = true;
asm.assemble().unwrap();
let source = "; start
org 0xC000
ld a, 0x10
LOOP:
dec a
beq 0x03
jmp LOOP ; repeat
END:
ld cd, 0xBABE ; babe
ld h, (cd) ; lined up with above
halt
data 0x0E, \"Hello, world!\", 0x0A
";
assert_eq_lines!(asm.source, source);
}
#[test]
fn assembler_generates_listing() {
let source = "; start
org 0xC000
ld a, 0x10
LOOP:
dec a
beq 0x03
jmp LOOP ; repeat
END:
ld cd, 0xBABE ; babe
ld h, (cd) ; lined up with above
halt
data 0x0E, \"Hello, world!\", 0x0A
";
let mut asm = Assembler::new(tokenize(source).unwrap());
asm.debug = true;
asm.assemble().unwrap();
let listing = "0100 ; start
0100 org 0xC000
C000 10 10 ld a, 0x10
C002 LOOP:
C002 40 dec a
C003 F1 03 beq 0x03
C005 F7 02 C0 jmp LOOP ; repeat
C008 END:
C008 19 BE BA ld cd, 0xBABE ; babe
C00B 1D 97 ld h, (cd) ; lined up with above
C00D 00 halt
C00E 0E 48 65 6C data 0x0E, \"Hello, world!\", 0x0A
C012 6C 6F 2C 20
C016 77 6F 72 6C
C01A 64 21 0A
";
assert_eq_lines!(asm.listing, listing);
}
#[test]
fn assembler_uses_0x0100_as_default_base_address() {
let source = "
call AHEAD
halt
AHEAD:
halt
";
let mut asm = Assembler::new(tokenize(source).unwrap());
asm.debug = true;
asm.assemble().unwrap();
assert_hex!(asm.resolve_label("AHEAD").unwrap(), 0x0104, "wrong address");
}
#[test]
fn assembler_ignores_comments() {
let source = "ld a, 0xFF ; loop count";
let generated = assemble_with_debug(source).unwrap();
let object = &[u8::from(Ld(Reg::A)), 0xFF];
assert_asm!(source, generated, object);
}
#[test]
fn assembler_includes_specified_file() {
use Reg::A;
let source = "include testdata/include.asm\ninc a";
let generated = assemble_with_debug(source).unwrap();
let object = &[
u8::from(Ld(A)),
0x01,
u8::from(Dec(A)),
u8::from(Nop),
u8::from(Inc(A)),
];
assert_asm!(source, generated, object);
}
#[test]
fn assembler_resolves_backward_labels() {
let source = "
ld a, 0x06 ; about 1 second
LOOP:
ld cd, 0xFFFF ; inner loop
INNER_LOOP:
dec cd
bne INNER_LOOP
dec a
bne LOOP
halt
";
let generated = assemble_with_debug(source).unwrap();
let object = &[
u8::from(Ld(Reg::A)),
0x06,
u8::from(Ld(Reg::CD)),
0xFF,
0xFF,
u8::from(Dec(Reg::CD)),
u8::from(BranchNe),
0xFD,
u8::from(Dec(Reg::A)),
u8::from(BranchNe),
0xF7,
u8::from(Halt),
];
assert_asm!(source, generated, object);
}
#[test]
fn assembler_resolves_forward_labels_for_branches() {
let source = "
bra AHEAD
halt
AHEAD:
halt
";
let generated = assemble_with_debug(source).unwrap();
let object = &[u8::from(BranchAlways), 0x01, u8::from(Halt), u8::from(Halt)];
assert_asm!(source, generated, object);
}
#[test]
fn assembler_resolves_forward_labels_for_calls() {
let source = "
call AHEAD
halt
AHEAD:
halt
";
let generated = assemble_with_debug(source).unwrap();
let object = &[u8::from(Call), 0x04, 0x01, u8::from(Halt), u8::from(Halt)];
assert_asm!(source, generated, object);
}
#[test]
fn data_emits_literal_bytes() {
let source = "
nop
data 0x01, 0x02, 0x03";
let generated = assemble_with_debug(source).unwrap();
let object = &[u8::from(Nop), 0x01, 0x02, 0x03];
assert_asm!(source, generated, object);
}
#[test]
fn data_emits_words_as_le_bytes() {
let source = "
data 0xBEEF, 0xCAFE";
let generated = assemble_with_debug(source).unwrap();
let object = &[0xEF, 0xBE, 0xFE, 0xCA];
assert_asm!(source, generated, object);
}
#[test]
fn data_emits_bytes_for_strings() {
let source = "
nop
data 0x01, \"hello\", 0x0A, 0x03
halt
";
let generated = assemble_with_debug(source).unwrap();
let object = &[
u8::from(Nop),
0x01,
0x68,
0x65,
0x6C,
0x6C,
0x6F,
0x0A,
0x03,
u8::from(Halt),
];
assert_asm!(source, generated, object);
}
#[test]
fn emit_byte_fn_detects_wraparound_of_memory() {
let source = "
org 0xFFFF
data 0x01, 0x02";
assemble_with_debug(source).expect_err("overflowing memory should fail");
}
#[test]
fn emit_word_fn_detects_wraparound_of_memory_before_word() {
let source = "
org 0xFFFF
call 0xBABE";
assemble_with_debug(source).expect_err("overflowing memory should fail");
}
#[test]
fn emit_word_fn_detects_wraparound_of_memory_in_mid_word() {
let source = "
org 0xFFFE
call 0xBABE";
assemble_with_debug(source).expect_err("overflowing memory should fail");
}
#[test]
fn org_adjusts_subsequent_label_address() {
let source = "
org 0xC000
call AHEAD
halt
AHEAD:
halt
";
let generated = assemble_with_debug(source).unwrap();
let object = &[u8::from(Call), 0x04, 0xC0, u8::from(Halt), u8::from(Halt)];
assert_asm!(source, generated, object);
}
#[test]
fn org_after_code_start_pads_with_zeroes() {
let source = "
ld a, 0xFF
bra AHEAD
org 0x0108
AHEAD:
halt
";
let generated = assemble_with_debug(source).unwrap();
let object = &[
u8::from(Ld(Reg::A)),
0xFF,
u8::from(BranchAlways),
0x04,
0x00,
0x00,
0x00,
0x00,
u8::from(Halt),
];
assert_asm!(source, generated, object);
}
#[test]
fn get_displacement_fn_calculates_correct_max_displacements() {
let mut source = String::from("LOOP:\n");
source.push_str("nop\n".repeat(126).as_str());
source.push_str("beq LOOP");
let generated = assemble_with_debug(&source).unwrap();
let mut object = vec![u8::from(Nop); 126];
object.extend([u8::from(BranchEq), 0x80]);
assert_asm!(source, generated, &object);
}
#[test]
fn get_displacement_fn_rejects_out_of_range_displacement() {
let mut source = String::from("LOOP:\n");
source.push_str("nop\n".repeat(127).as_str());
source.push_str("beq LOOP");
assemble_with_debug(source.as_str()).expect_err("invalid displacement should be rejected");
}
#[test]
fn disassembler_correctly_disassembles_multiline_programs() {
let source = "ld a, 0x01\ndec a\nld b, 0x02\ninc b\nld c, 0x03\ndec c\ndec c";
let code = assemble_with_debug(source).unwrap();
let output: Vec<_> = Disassembler::from(code.as_slice()).collect();
assert_eq!(output.join("\n"), source);
}
#[test]
fn disassembler_copes_with_invalid_code() {
assert_disasm!([0x10], "ld a, ??? (no operand)");
assert_disasm!([0x1D], "??? (no operand)");
assert_disasm!([0x28], "??? (no operand)");
assert_disasm!([0x1E], "??? (no operand)");
assert_disasm!([0x3D], "??? (no operand)");
assert_disasm!([0x3E], "inc (??? (no operand))");
assert_disasm!([0x4D], "??? (no operand)");
assert_disasm!([0x4E], "dec (??? (no operand))");
assert_disasm!([0xFF, 0xFF], "??? (0xFF)");
}
#[test]
fn as_hex_fn_formats_value_as_hex() {
assert_eq!(as_hex(&[1, 255]), "[0x01, 0xFF]");
}
#[test]
fn assembler_assembles_and_disassembles_instructions_correctly() {
use Reg::*;
let cases: &[(&str, &[u8])] = &[
("", &[]),
("add a, 0x01", &[u8::from(Add(A)), 0x01]),
("add sp, 0x0104", &[u8::from(Add(SP)), 0x04, 0x01]),
("and a, 0x01", &[u8::from(And(A)), 0x01]),
("and cd, 0xFFFE", &[u8::from(And(CD)), 0xFE, 0xFF]),
("and ab, cd", &[u8::from(AndReg), 0x98]),
("add a, b", &[u8::from(AddReg), 0x10]),
("add cd, ef", &[u8::from(AddReg), 0xA9]),
("asr a, 0x04", &[u8::from(Asr), 0x40]),
("asr ab, c", &[u8::from(AsrReg), 0x28]),
("bcc 0x10", &[u8::from(BranchCc), 0x10]),
("bcs 0x10", &[u8::from(BranchCs), 0x10]),
("beq 0xF0", &[u8::from(BranchEq), 0xF0]),
("bmi 0xF0", &[u8::from(BranchMi), 0xF0]),
("bne 0x01", &[u8::from(BranchNe), 0x01]),
("bpl 0x01", &[u8::from(BranchPl), 0x01]),
("bra 0x99", &[u8::from(BranchAlways), 0x99]),
("call 0xBEEE", &[u8::from(Call), 0xEE, 0xBE]),
("clc", &[u8::from(Clc)]),
("cli", &[u8::from(Cli)]),
("cmp d, 0x01", &[u8::from(Cmp(D)), 0x01]),
("cmp d, a", &[u8::from(CmpReg), 0x03]),
("cmp gh, 0xDEAD", &[u8::from(Cmp(GH)), 0xAD, 0xDE]),
("cmp ab, sp", &[u8::from(CmpReg), 0xC8]),
("cpuid 0x00", &[u8::from(Cpuid), 0x00]),
("dec (0xBABE)", &[u8::from(DecMem), 0xBE, 0xBA]),
("dec (gh)", &[u8::from(DecIndirect), 0x0B]),
("dec ab", &[u8::from(Dec(AB))]),
("dec g", &[u8::from(Dec(G))]),
("halt", &[u8::from(Halt)]),
("inc (0xCAFE)", &[u8::from(IncMem), 0xFE, 0xCA]),
("inc (cd)", &[u8::from(IncIndirect), 0x09]),
("inc a", &[u8::from(Inc(A))]),
("inc ef", &[u8::from(Inc(EF))]),
("jmp 0x1234", &[u8::from(Jmp), 0x34, 0x12]),
("ld (cd), 0xBA", &[u8::from(StoreIndirectImm), 0x09, 0xBA]),
("ld (ef), a", &[u8::from(StoreIndirect), 0x0A]),
("ld (sp+0x01), b", &[u8::from(StoreIndexed), 0x1C, 0x01]),
("ld 0x00AF, h", &[u8::from(Store(H)), 0xAF, 0x00]),
("ld a, b", &[u8::from(LdReg), 0x10]),
("ld ab, 0x000F", &[u8::from(Ld(AB)), 0x0F, 0x00]),
("ld b, (cd)", &[u8::from(LdIndirect), 0x91]),
("ld b, 0xFF", &[u8::from(Ld(B)), 0xFF]),
("ld cd, 0xBEEF", &[u8::from(Ld(CD)), 0xEF, 0xBE]),
("ld sp, 0x010F", &[u8::from(Ld(SP)), 0x0F, 0x01]),
("ld h, (sp+0x01)", &[u8::from(LdIndexed), 0xC7, 0x01]),
("lsr a, 0x04", &[u8::from(Lsr), 0x40]),
("lsr ab, c", &[u8::from(LsrReg), 0x28]),
("nop", &[u8::from(Nop)]),
("or a, 0x01", &[u8::from(Or(A)), 0x01]),
("or cd, 0xFFFE", &[u8::from(Or(CD)), 0xFE, 0xFF]),
("or ab, cd", &[u8::from(OrReg), 0x98]),
("pop e", &[u8::from(Pop(E))]),
("pop ps", &[u8::from(PopPS)]),
("push c", &[u8::from(Push(C))]),
("push ps", &[u8::from(PushPS)]),
("ret", &[u8::from(Ret)]),
("rol a, 0x04", &[u8::from(Rol), 0x40]),
("rol gh, a", &[u8::from(RolReg), 0x0B]),
("ror a, 0x04", &[u8::from(Ror), 0x40]),
("ror gh, a", &[u8::from(RorReg), 0x0B]),
("rti", &[u8::from(Rti)]),
("sec", &[u8::from(Sec)]),
("sei", &[u8::from(Sei)]),
("shl ef, 0x04", &[u8::from(Shl), 0x4A]),
("shl cd, a", &[u8::from(ShlReg), 0x09]),
("sub a, 0x01", &[u8::from(Sub(A)), 0x01]),
("sub b, c", &[u8::from(SubReg), 0x21]),
("sub cd, 0x0104", &[u8::from(Sub(CD)), 0x04, 0x01]),
("sub sp, ef", &[u8::from(SubReg), 0xAC]),
("test a, 0x01", &[u8::from(Test(A)), 0x01]),
("test cd, 0xFFFE", &[u8::from(Test(CD)), 0xFE, 0xFF]),
("test b, h", &[u8::from(TestReg), 0x71]),
("trap 0x01", &[u8::from(Trap), 0x01]),
("trapv", &[u8::from(TrapV)]),
("xor a, 0x01", &[u8::from(Xor(A)), 0x01]),
("xor cd, 0xFFFE", &[u8::from(Xor(CD)), 0xFE, 0xFF]),
("xor ab, cd", &[u8::from(XorReg), 0x98]),
];
for &(source, object) in cases {
let generated = assemble_with_debug(source).unwrap();
assert_asm!(source, generated, object);
assert_disasm!(generated, source);
}
}
#[test]
#[expect(clippy::non_ascii_literal, reason = "test")]
fn assembler_rejects_invalid_code() {
let cases: &[&str] = &[
"&",
"add",
"add a",
"add a, cd",
"add ab, c",
"add ab, 0xFF",
"add sp",
"and",
"and ab, 0xFF",
"and cd, a",
"and a, 0x1000",
"and 0x01, 0x0F",
"asr",
"asr a",
"asr ab, 0x0002",
"asr ab, cd",
"asr a, cd",
"bcc",
"bcs a",
"bcs 0x1000",
"beq UNDEFINED_LABEL",
"beq",
"bmi",
"bne 0x1000",
"bpl a",
"bogus",
"bra a",
"call 0x01",
"call gh",
"call",
"clc 0x00",
"cli a",
"cmp a, b, d",
"cpuid",
"cpuid 0xFFFF",
"cpuid a",
"data (",
"data \"©\"",
"data bogus",
"dec (",
"dec (a)",
"dec z",
"dec",
"inc (",
"inc (0xFF)",
"inc (a)",
"inc ,",
"inc 0x0000",
"inc ax",
"inc",
"jmp",
"jmp ab",
"jmp 0x01",
"ld (0x0), b",
"ld (ab), 0xFFFF",
"ld (cd+a), b",
"ld 0x0000",
"ld 0x0000, ",
"ld 0x00AF, ab",
"ld a 0x01",
"ld a",
"ld a, ",
"ld a, (bogus)",
"ld a, 0x1000",
"ld a, 0xZ",
"ld a, LABEL",
"ld a, cd",
"ld ab, (cd)",
"ld ab, 0x--",
"ld ab, 0x00009",
"ld ab, UNDEFINED",
"ld bogus, 0x01",
"ld cd, 0x09",
"ld ef",
"ld ef, 0x02",
"ld",
"lsr",
"lsr a",
"lsr ab, 0x0002",
"lsr ab, cd",
"lsr a, cd",
"nop\norg 0x0000",
"or",
"or ab, 0xFF",
"or cd, a",
"or a, 0x1000",
"or 0x01, 0x0F",
"org 0xFFFF\nld a, 0x01",
"pop",
"pop 0x01",
"pop ps LABEL",
"push",
"push ps, 0x01",
"ret cd",
"rol",
"rol a",
"rol ab, 0x0002",
"rol ab, cd",
"rol 0x0000, cd",
"ror",
"ror a",
"ror ab, 0x0002",
"ror ab, cd",
"ror 0x0000, cd",
"rti 0x0100",
"sec ab",
"sei 0x01",
"shl",
"shl a",
"shl ab, 0x0002",
"shl ab, cd",
"shl 0x0000, cd",
"sub",
"sub a",
"sub a, cd",
"sub ab, 0xFF",
"sub sp, a",
"test",
"test ab, 0xFF",
"test cd, a",
"test a, 0x1000",
"test 0x01, 0x0F",
"trap 0x40",
"trap 0xFF",
"trap a",
"trap",
"trapv a",
"trapv 0x01",
"xor",
"xor ab, 0xFF",
"xor cd, a",
"xor a, 0x1000",
"xor 0x01, 0x0F",
];
for &source in cases {
assemble_with_debug(source)
.expect_err(&format!("assembling invalid source '{source}' should fail"));
}
}
}