diff options
Diffstat (limited to 'src/lib.rs')
| -rw-r--r-- | src/lib.rs | 804 |
1 files changed, 804 insertions, 0 deletions
diff --git a/src/lib.rs b/src/lib.rs new file mode 100644 index 0000000..6c0f79c --- /dev/null +++ b/src/lib.rs @@ -0,0 +1,804 @@ +#[cfg(feature="use-serde")] +#[macro_use] extern crate serde_derive; +#[cfg(feature="use-serde")] +extern crate serde; + +extern crate yaxpeax_arch; + +extern crate core; + +use core::fmt; + +use yaxpeax_arch::AddressDiff; +use yaxpeax_arch::Arch; +use yaxpeax_arch::Decoder; +use yaxpeax_arch::LengthedInstruction; + +#[cfg(feature="use-serde")] +#[derive(Debug, Serialize, Deserialize)] +pub struct SM83; + +#[cfg(not(feature="use-serde"))] +#[derive(Debug)] +pub struct SM83; + +impl Arch for SM83 { + type Address = u16; + type Instruction = Instruction; + type DecodeError = DecodeError; + type Decoder = InstDecoder; + type Operand = Operand; +} + +#[derive(Debug, Copy, Clone)] +pub struct Instruction { + opcode: Opcode, + operands: [Operand; 2], + length: u8, +} + +impl Instruction { + pub fn opcode(&self) -> Opcode { + self.opcode + } + + pub fn operands(&self) -> &[Operand; 2] { + &self.operands + } + + pub fn length(&self) -> u8 { + self.length + } +} + +impl Default for Instruction { + fn default() -> Instruction { + Instruction { + opcode: Opcode::NOP, + operands: [Operand::Nothing, Operand::Nothing], + length: 1, + } + } +} + +impl fmt::Display for Instruction { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "{}", self.opcode())?; + let ops = self.operands(); + if ops[0] != Operand::Nothing { + write!(f, " {}", ops[0])?; + } + if ops[1] != Operand::Nothing { + write!(f, ", {}", ops[1])?; + } + Ok(()) + } +} + +impl LengthedInstruction for Instruction { + type Unit = AddressDiff<<SM83 as Arch>::Address>; + fn min_size() -> Self::Unit { + AddressDiff::from_const(1) + } + fn len(&self) -> Self::Unit { + AddressDiff::from_const(self.length as u16) + } +} + +#[derive(Debug, PartialEq)] +pub enum DecodeError { + ExhaustedInput, + InvalidOpcode, + Incomplete, +} + +impl yaxpeax_arch::DecodeError for DecodeError { + fn data_exhausted(&self) -> bool { self == &DecodeError::ExhaustedInput } + fn bad_opcode(&self) -> bool { self == &DecodeError::InvalidOpcode } + fn bad_operand(&self) -> bool { false } +} + +impl fmt::Display for DecodeError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match self { + DecodeError::ExhaustedInput => { write!(f, "exhausted input") } + DecodeError::InvalidOpcode => { write!(f, "invalid opcode") } + DecodeError::Incomplete => { write!(f, "incomplete") } + } + } +} + +impl yaxpeax_arch::Instruction for Instruction { + // only decode well-formed instructions (for now???) + fn well_defined(&self) -> bool { true } +} + +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum Operand { + A, + B, + C, + D, + E, + H, + L, + AF, + BC, + DE, + HL, + SP, + DerefHL, + DerefBC, + DerefDE, + DerefDecHL, + DerefIncHL, + DerefHighC, + DerefHighD8(u8), + SPWithOffset(i8), + Bit(u8), + D8(u8), + I8(i8), + R8(i8), + A16(u16), + D16(u16), + + CondC, + CondNC, + CondZ, + CondNZ, + + Nothing, +} + +impl fmt::Display for Operand { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match self { + Operand::A => write!(f, "a"), + Operand::B => write!(f, "b"), + Operand::C => write!(f, "c"), + Operand::D => write!(f, "d"), + Operand::E => write!(f, "e"), + Operand::H => write!(f, "h"), + Operand::L => write!(f, "l"), + Operand::AF => write!(f, "af"), + Operand::BC => write!(f, "bc"), + Operand::DE => write!(f, "de"), + Operand::HL => write!(f, "hl"), + Operand::SP => write!(f, "sp"), + Operand::DerefHL => write!(f, "[hl]"), + Operand::DerefBC => write!(f, "[bc]"), + Operand::DerefDE => write!(f, "[de]"), + Operand::DerefDecHL => write!(f, "[hl-]"), + Operand::DerefIncHL => write!(f, "[hl+]"), + Operand::DerefHighC => write!(f, "[0xff00 + c]"), + Operand::DerefHighD8(imm) => write!(f, "[$ff00 + ${:02x}]", imm), + Operand::SPWithOffset(imm) => { + if *imm == -128 { + write!(f, "[sp - $80]") + } else if *imm >= 0 { + write!(f, "[sp + ${:02x}]", imm) + } else { + write!(f, "[sp - ${:02x}]", -imm) + } + } + Operand::Bit(imm) => write!(f, "{}", imm), + Operand::D8(imm) => write!(f, "${:02x}", imm), + Operand::D16(imm) => write!(f, "${:04x}", imm), + Operand::I8(imm) => { + if *imm == -128 { + write!(f, "-0x80") + } else if *imm >= 0 { + write!(f, "${:02x}", imm) + } else { + write!(f, "-${:02x}", -imm) + } + } + Operand::R8(imm) => { + if *imm == -128 { + write!(f, "$-0x80") + } else if *imm >= 0 { + write!(f, "$+${:02x}", imm) + } else { + write!(f, "$-${:02x}", -imm) + } + } + Operand::A16(addr) => write!(f, "[${:4x}]", addr), + + Operand::CondC => write!(f, "C"), + Operand::CondNC => write!(f, "nC"), + Operand::CondZ => write!(f, "Z"), + Operand::CondNZ => write!(f, "nZ"), + + Operand::Nothing => write!(f, "nothing (BUG: should not be shown)"), + } + } +} + +#[derive(Debug, Copy, Clone)] +enum OperandSpec { + A, + B, + C, + D, + E, + H, + L, + AF, + BC, + DE, + HL, + SP, + DerefHL, + DerefBC, + DerefDE, + DerefDecHL, + DerefIncHL, + DerefHighC, + DerefHighD8, + SPWithOffset, + D8, + R8, + I8, + A16, + D16, + + CondC, + CondNC, + CondZ, + CondNZ, + + Bit(u8), + Imm(u8), + + Nothing, +} + +#[derive(Debug, Copy, Clone)] +pub enum Opcode { + NOP, + + LD, + + DEC, + INC, + + ADC, + ADD, + SBC, + SUB, + + AND, + XOR, + OR, + CP, + + POP, + PUSH, + + JP, + JR, + CALL, + RET, + RETI, + HALT, + RST, + STOP, + + RLCA, + RRCA, + RLA, + RRA, + + DAA, + CPL, + SCF, + CCF, + + DI, + EI, + + LDH, + + RLC, + RRC, + RL, + RR, + SLA, + SRA, + SWAP, + SRL, + BIT, + RES, + SET, +} + +impl fmt::Display for Opcode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match self { + Opcode::NOP => write!(f, "nop"), + + Opcode::LD => write!(f, "ld"), + + Opcode::DEC => write!(f, "dec"), + Opcode::INC => write!(f, "inc"), + + Opcode::ADC => write!(f, "adc"), + Opcode::ADD => write!(f, "add"), + Opcode::SBC => write!(f, "sbc"), + Opcode::SUB => write!(f, "sub"), + + Opcode::AND => write!(f, "and"), + Opcode::XOR => write!(f, "xor"), + Opcode::OR => write!(f, "or"), + Opcode::CP => write!(f, "cp"), + + Opcode::POP => write!(f, "pop"), + Opcode::PUSH => write!(f, "push"), + + Opcode::JP => write!(f, "jp"), + Opcode::JR => write!(f, "jr"), + Opcode::CALL => write!(f, "call"), + Opcode::RET => write!(f, "ret"), + Opcode::RETI => write!(f, "reti"), + Opcode::HALT => write!(f, "halt"), + Opcode::RST => write!(f, "rst"), + Opcode::STOP => write!(f, "stop"), + + Opcode::RLCA => write!(f, "rlca"), + Opcode::RRCA => write!(f, "rrca"), + Opcode::RLA => write!(f, "rla"), + Opcode::RRA => write!(f, "rra"), + + Opcode::DAA => write!(f, "daa"), + Opcode::CPL => write!(f, "cpl"), + Opcode::SCF => write!(f, "scf"), + Opcode::CCF => write!(f, "ccf"), + + Opcode::DI => write!(f, "di"), + Opcode::EI => write!(f, "ei"), + + Opcode::LDH => write!(f, "ldh"), + + Opcode::RLC => write!(f, "rlc"), + Opcode::RRC => write!(f, "rrc"), + Opcode::RL => write!(f, "rl"), + Opcode::RR => write!(f, "rr"), + Opcode::SLA => write!(f, "sla"), + Opcode::SRA => write!(f, "sra"), + Opcode::SWAP => write!(f, "swap"), + Opcode::SRL => write!(f, "srl"), + Opcode::BIT => write!(f, "bit"), + Opcode::RES => write!(f, "res"), + Opcode::SET => write!(f, "set"), + } + } +} + +#[derive(Debug)] +pub struct InstDecoder { } + +impl Default for InstDecoder { + fn default() -> Self { + InstDecoder { } + } +} + +// main operand map is used for ld, arithmetic, and $CB-prefixed instructions +const OPMAP: [OperandSpec; 8] = [ + OperandSpec::B, + OperandSpec::C, + OperandSpec::D, + OperandSpec::E, + OperandSpec::H, + OperandSpec::L, + OperandSpec::DerefHL, + OperandSpec::A, +]; + +const UPPER_INSTRUCTIONS: [(Option<Opcode>, [OperandSpec; 2]); 64] = [ + // 0xc0 + (Some(Opcode::RET), [OperandSpec::CondNZ, OperandSpec::Nothing]), + (Some(Opcode::POP), [OperandSpec::BC, OperandSpec::Nothing]), + (Some(Opcode::JP), [OperandSpec::CondNZ, OperandSpec::D16]), + (Some(Opcode::JP), [OperandSpec::D16, OperandSpec::Nothing]), + (Some(Opcode::CALL), [OperandSpec::CondNZ, OperandSpec::D16]), + (Some(Opcode::PUSH), [OperandSpec::BC, OperandSpec::Nothing]), + (Some(Opcode::ADD), [OperandSpec::D8, OperandSpec::Nothing]), + (Some(Opcode::RST), [OperandSpec::Imm(0x00), OperandSpec::Nothing]), + // 0xc8 + (Some(Opcode::RET), [OperandSpec::CondZ, OperandSpec::Nothing]), + (Some(Opcode::RET), [OperandSpec::Nothing, OperandSpec::Nothing]), + (Some(Opcode::JP), [OperandSpec::CondNC, OperandSpec::D16]), + (None, [OperandSpec::Nothing, OperandSpec::Nothing]), + (Some(Opcode::CALL), [OperandSpec::CondZ, OperandSpec::D16]), + (Some(Opcode::CALL), [OperandSpec::D16, OperandSpec::Nothing]), + (Some(Opcode::ADC), [OperandSpec::D8, OperandSpec::Nothing]), + (Some(Opcode::RST), [OperandSpec::Imm(0x08), OperandSpec::Nothing]), + // 0xd0 + (Some(Opcode::RET), [OperandSpec::CondNC, OperandSpec::Nothing]), + (Some(Opcode::POP), [OperandSpec::DE, OperandSpec::Nothing]), + (Some(Opcode::JP), [OperandSpec::CondNC, OperandSpec::D16]), + (None, [OperandSpec::Nothing, OperandSpec::Nothing]), + (Some(Opcode::CALL), [OperandSpec::CondNC, OperandSpec::D16]), + (Some(Opcode::PUSH), [OperandSpec::DE, OperandSpec::Nothing]), + (Some(Opcode::SUB), [OperandSpec::D8, OperandSpec::Nothing]), + (Some(Opcode::RST), [OperandSpec::Imm(0x10), OperandSpec::Nothing]), + // 0xd8 + (Some(Opcode::RET), [OperandSpec::CondC, OperandSpec::Nothing]), + (Some(Opcode::RETI), [OperandSpec::Nothing, OperandSpec::Nothing]), + (Some(Opcode::JP), [OperandSpec::CondC, OperandSpec::D16]), + (None, [OperandSpec::Nothing, OperandSpec::Nothing]), + (Some(Opcode::CALL), [OperandSpec::CondC, OperandSpec::D16]), + (None, [OperandSpec::Nothing, OperandSpec::Nothing]), + (Some(Opcode::SBC), [OperandSpec::D8, OperandSpec::Nothing]), + (Some(Opcode::RST), [OperandSpec::Imm(0x18), OperandSpec::Nothing]), + // 0xe0 + (Some(Opcode::LDH), [OperandSpec::DerefHighD8, OperandSpec::A]), + (Some(Opcode::POP), [OperandSpec::HL, OperandSpec::Nothing]), + (Some(Opcode::LDH), [OperandSpec::DerefHighC, OperandSpec::A]), + (None, [OperandSpec::Nothing, OperandSpec::Nothing]), + (None, [OperandSpec::Nothing, OperandSpec::Nothing]), + (Some(Opcode::PUSH), [OperandSpec::HL, OperandSpec::Nothing]), + (Some(Opcode::AND), [OperandSpec::D8, OperandSpec::Nothing]), + (Some(Opcode::RST), [OperandSpec::Imm(0x20), OperandSpec::Nothing]), + // 0xe8 + (Some(Opcode::ADD), [OperandSpec::SP, OperandSpec::I8]), + (Some(Opcode::JP), [OperandSpec::HL, OperandSpec::Nothing]), + (Some(Opcode::LD), [OperandSpec::A16, OperandSpec::A]), + (None, [OperandSpec::Nothing, OperandSpec::Nothing]), + (None, [OperandSpec::Nothing, OperandSpec::Nothing]), + (None, [OperandSpec::Nothing, OperandSpec::Nothing]), + (Some(Opcode::XOR), [OperandSpec::D8, OperandSpec::Nothing]), + (Some(Opcode::RST), [OperandSpec::Imm(0x28), OperandSpec::Nothing]), + // 0xf0 + (Some(Opcode::LDH), [OperandSpec::A, OperandSpec::DerefHighD8]), + (Some(Opcode::POP), [OperandSpec::AF, OperandSpec::Nothing]), + (Some(Opcode::LDH), [OperandSpec::A, OperandSpec::DerefHighC]), + (Some(Opcode::DI), [OperandSpec::Nothing, OperandSpec::Nothing]), + (None, [OperandSpec::Nothing, OperandSpec::Nothing]), + (Some(Opcode::PUSH), [OperandSpec::AF, OperandSpec::Nothing]), + (Some(Opcode::OR), [OperandSpec::D8, OperandSpec::Nothing]), + (Some(Opcode::RST), [OperandSpec::Imm(0x30), OperandSpec::Nothing]), + // 0xf8 + (Some(Opcode::LD), [OperandSpec::HL, OperandSpec::SPWithOffset]), + (Some(Opcode::LD), [OperandSpec::SP, OperandSpec::HL]), + (Some(Opcode::LD), [OperandSpec::A, OperandSpec::A16]), + (Some(Opcode::EI), [OperandSpec::Nothing, OperandSpec::Nothing]), + (None, [OperandSpec::Nothing, OperandSpec::Nothing]), + (None, [OperandSpec::Nothing, OperandSpec::Nothing]), + (Some(Opcode::CP), [OperandSpec::D8, OperandSpec::Nothing]), + (Some(Opcode::RST), [OperandSpec::Imm(0x38), OperandSpec::Nothing]), +]; + +impl Decoder<Instruction> for InstDecoder { + type Error = DecodeError; + + fn decode_into<T: IntoIterator<Item=u8>>(&self, inst: &mut Instruction, bytes: T) -> Result<(), Self::Error> { + let mut iter = bytes.into_iter(); + + let opc: u8 = iter.next().ok_or(DecodeError::ExhaustedInput)?; + inst.length = 1; + + let high = ((opc >> 3) & 0b111) as usize; + let low = (opc & 0b111) as usize; + + // early part of the table is more varied, more special cases + if opc < 0x40 { + let (opcode, operands) = match low { + 0 => { + // special case on high + match high { + 0 => { (Opcode::NOP, [OperandSpec::Nothing, OperandSpec::Nothing]) }, + 1 => { (Opcode::LD, [OperandSpec::A16, OperandSpec::SP]) }, + 2 => { (Opcode::STOP, [OperandSpec::Nothing, OperandSpec::Nothing]) }, + 3 => { (Opcode::JR, [OperandSpec::R8, OperandSpec::Nothing]) }, + 4 => { (Opcode::JR, [OperandSpec::CondNZ, OperandSpec::R8]) }, + 5 => { (Opcode::JR, [OperandSpec::CondZ, OperandSpec::R8]) }, + 6 => { (Opcode::JR, [OperandSpec::CondNC, OperandSpec::R8]) }, + 7 => { (Opcode::JR, [OperandSpec::CondC, OperandSpec::R8]) }, + _ => { unreachable!("impossible bit pattern"); } + } + } + 1 => { + // also special case, but fewer + if high & 1 == 0 { + let opcode = Opcode::LD; + let ops = [[ + OperandSpec::BC, + OperandSpec::DE, + OperandSpec::HL, + OperandSpec::SP, + ][high as usize >> 1], OperandSpec::D16]; + (opcode, ops) + } else { + let opcode = Opcode::ADD; + let ops = [OperandSpec::HL, [ + OperandSpec::BC, + OperandSpec::DE, + OperandSpec::HL, + OperandSpec::SP, + ][high as usize >> 1]]; + (opcode, ops) + } + } + 2 => { + let op = Opcode::LD; + if high & 1 == 0 { + let op0 = [ + OperandSpec::DerefBC, + OperandSpec::DerefDE, + OperandSpec::DerefIncHL, + OperandSpec::DerefDecHL, + ][high as usize >> 1]; + (op, [op0, OperandSpec::A]) + } else { + let op1 = [ + OperandSpec::DerefBC, + OperandSpec::DerefDE, + OperandSpec::DerefIncHL, + OperandSpec::DerefDecHL, + ][high as usize >> 1]; + (op, [OperandSpec::A, op1]) + } + } + 3 => { + if high & 1 == 0 { + let op0 = [ + OperandSpec::BC, + OperandSpec::DE, + OperandSpec::HL, + OperandSpec::SP, + ][high as usize >> 1]; + (Opcode::INC, [op0, OperandSpec::Nothing]) + } else { + let op0 = [ + OperandSpec::BC, + OperandSpec::DE, + OperandSpec::HL, + OperandSpec::SP, + ][high as usize >> 1]; + (Opcode::DEC, [op0, OperandSpec::Nothing]) + } + } + 4 => { + let op = Opcode::INC; + let op0 = [ + OperandSpec::B, + OperandSpec::C, + OperandSpec::D, + OperandSpec::E, + OperandSpec::H, + OperandSpec::L, + OperandSpec::DerefHL, + OperandSpec::A, + ][high as usize]; + (op, [op0, OperandSpec::Nothing]) + } + 5 => { + let op = Opcode::DEC; + let op0 = [ + OperandSpec::B, + OperandSpec::C, + OperandSpec::D, + OperandSpec::E, + OperandSpec::H, + OperandSpec::L, + OperandSpec::DerefHL, + OperandSpec::A, + ][high as usize]; + (op, [op0, OperandSpec::Nothing]) + } + 6 => { + let op = Opcode::LD; + let op0 = [ + OperandSpec::B, + OperandSpec::C, + OperandSpec::D, + OperandSpec::E, + OperandSpec::H, + OperandSpec::L, + OperandSpec::DerefHL, + OperandSpec::A, + ][high as usize]; + (op, [op0, OperandSpec::D8]) + } + 7 => { + // special cases here too + let op = [ + Opcode::RLCA, + Opcode::RRCA, + Opcode::RLA, + Opcode::RRA, + Opcode::DAA, + Opcode::CPL, + Opcode::SCF, + Opcode::CCF, + ][high as usize]; + (op, [OperandSpec::Nothing, OperandSpec::Nothing]) + } + _ => { + unreachable!("impossible bit pattern"); + } + }; + inst.opcode = opcode; + interpret_operands(iter, inst, operands)?; + return Ok(()); + } else if opc < 0x80 { + if opc == 0x76 { + inst.opcode = Opcode::HALT; + inst.operands = [Operand::Nothing, Operand::Nothing]; + return Ok(()); + } else { + inst.opcode = Opcode::LD; + interpret_operands(iter, inst, [OPMAP[high], OPMAP[low]])?; + return Ok(()); + } + } else if opc < 0xc0 { + const OPCODES: [Opcode; 8] = [ + Opcode::ADD, + Opcode::ADC, + Opcode::SUB, + Opcode::SBC, + Opcode::AND, + Opcode::XOR, + Opcode::OR, + Opcode::CP, + ]; + inst.opcode = OPCODES[high]; + let operands = [OPMAP[low], OperandSpec::Nothing]; + interpret_operands(iter, inst, operands)?; + return Ok(()); + } else { + if opc == 0xcb { + // sm83 special CB-prefixed instructions + let opc: u8 = iter.next().ok_or(DecodeError::ExhaustedInput)?; + inst.length += 1; + if opc < 0x40 { + let high = (opc >> 3) & 0b111; + let low = opc & 0b111; + const LOW_OP: [OperandSpec; 8] = [ + OperandSpec::B, + OperandSpec::C, + OperandSpec::D, + OperandSpec::E, + OperandSpec::H, + OperandSpec::L, + OperandSpec::DerefHL, + OperandSpec::A, + ]; + let operands = [LOW_OP[low as usize], OperandSpec::Nothing]; + const OPCODES: [Opcode; 8] = [ + Opcode::RLC, + Opcode::RRC, + Opcode::RL, + Opcode::RR, + Opcode::SLA, + Opcode::SRA, + Opcode::SWAP, + Opcode::SRL, + ]; + inst.opcode = OPCODES[high as usize]; + interpret_operands(iter, inst, operands)?; + return Ok(()); + } else { + let bit = (opc >> 3) & 0b111; + let low = opc & 0b111; + const LOW_OP: [OperandSpec; 8] = [ + OperandSpec::B, + OperandSpec::C, + OperandSpec::D, + OperandSpec::E, + OperandSpec::H, + OperandSpec::L, + OperandSpec::DerefHL, + OperandSpec::A, + ]; + let operands = [OperandSpec::Bit(bit), LOW_OP[low as usize]]; + const OPCODES: [Opcode; 3] = [ + Opcode::BIT, + Opcode::RES, + Opcode::SET, + ]; + inst.opcode = OPCODES[(opc >> 6) as usize - 1]; + interpret_operands(iter, inst, operands)?; + return Ok(()); + } + } else { + // there is no special thing we can do here. do a table lookup. + let (maybe_opcode, operands) = UPPER_INSTRUCTIONS[opc as usize - 0xc0]; + if let Some(opcode) = maybe_opcode { + inst.opcode = opcode; + interpret_operands(iter, inst, operands)?; + return Ok(()); + } else { + return Err(DecodeError::InvalidOpcode); + } + } + } + } +} + +fn interpret_operands<I: Iterator<Item=u8>>(mut iter: I, inst: &mut Instruction, operands: [OperandSpec; 2]) -> Result<(), DecodeError> { + inst.operands[0] = interpret_operand(&mut iter, inst, operands[0])?; + inst.operands[1] = interpret_operand(&mut iter, inst, operands[1])?; + Ok(()) +} + +fn interpret_operand<I: Iterator<Item=u8>>(iter: &mut I, inst: &mut Instruction, operand: OperandSpec) -> Result<Operand, DecodeError> { + let operand = match operand { + OperandSpec::A => Operand::A, + OperandSpec::B => Operand::B, + OperandSpec::C => Operand::C, + OperandSpec::D => Operand::D, + OperandSpec::E => Operand::E, + OperandSpec::H => Operand::H, + OperandSpec::L => Operand::L, + OperandSpec::AF => Operand::AF, + OperandSpec::BC => Operand::BC, + OperandSpec::DE => Operand::DE, + OperandSpec::HL => Operand::HL, + OperandSpec::SP => Operand::SP, + OperandSpec::DerefHL => Operand::DerefHL, + OperandSpec::DerefBC => Operand::DerefBC, + OperandSpec::DerefDE => Operand::DerefDE, + OperandSpec::DerefDecHL => Operand::DerefDecHL, + OperandSpec::DerefIncHL => Operand::DerefIncHL, + OperandSpec::D8 => { + let imm = iter.next().ok_or(DecodeError::ExhaustedInput)?; + inst.length += 1; + Operand::D8(imm) + } + OperandSpec::DerefHighC => { + Operand::DerefHighC + } + OperandSpec::DerefHighD8 => { + let imm = iter.next().ok_or(DecodeError::ExhaustedInput)?; + inst.length += 1; + Operand::DerefHighD8(imm) + } + OperandSpec::R8 => { + let imm = iter.next().ok_or(DecodeError::ExhaustedInput)?; + inst.length += 1; + Operand::R8(imm as i8) + } + OperandSpec::I8 => { + let imm = iter.next().ok_or(DecodeError::ExhaustedInput)?; + inst.length += 1; + Operand::I8(imm as i8) + } + OperandSpec::A16 => { + let imm = + (iter.next().ok_or(DecodeError::ExhaustedInput)? as u16) | + ((iter.next().ok_or(DecodeError::ExhaustedInput)? as u16) << 8); + inst.length += 2; + Operand::A16(imm as u16) + } + OperandSpec::D16 => { + let imm = + (iter.next().ok_or(DecodeError::ExhaustedInput)? as u16) | + ((iter.next().ok_or(DecodeError::ExhaustedInput)? as u16) << 8); + inst.length += 2; + Operand::D16(imm as u16) + } + OperandSpec::SPWithOffset => { + let imm = iter.next().ok_or(DecodeError::ExhaustedInput)?; + inst.length += 1; + Operand::SPWithOffset(imm as i8) + } + + OperandSpec::Imm(u) => { + Operand::D8(u) + } + OperandSpec::Bit(u) => { + Operand::Bit(u) + } + + OperandSpec::CondC => Operand::CondC, + OperandSpec::CondNC => Operand::CondNC, + OperandSpec::CondZ => Operand::CondZ, + OperandSpec::CondNZ => Operand::CondNZ, + + OperandSpec::Nothing => Operand::Nothing, + }; + Ok(operand) +} |