olympia_derive 0.3.0

Olympia is a gameboy emulator and toolkit, intended to run as a native or web assembly application targeting a cycle count accurate emulation. olympia_derive provides a couple of proc macros used for olympia implementation.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

extern crate alloc;

use olympia_core::address;
use olympia_core::disasm::Disassemble;
use olympia_core::instructions::{
    AppendedParam, ConstantParam, ExtensionType, Instruction, InstructionOpcode, ParamDefinition,
    ParamPosition, ParamType,
};
use olympia_core::registers::WordRegister;
use olympia_derive::OlympiaInstruction;

#[derive(PartialEq, Eq, Debug, OlympiaInstruction)]
#[olympia(opcode = 0x1111_1000, label = "LD")]
struct LoadStackOffset {
    #[olympia(dest, constant(WordRegister::HL))]
    dest: WordRegister,
    #[olympia(src, constant(WordRegister::SP))]
    base: WordRegister,
    #[olympia(addsrc)]
    value: address::AddressOffset,
}

#[test]
fn three_arg_definition() {
    let definition = LoadStackOffset::definition();
    assert_eq!(definition.label, "LD");
    assert_eq!(definition.opcodes, &[0xF8]);
    assert_eq!(definition.extension_type, ExtensionType::None);

    assert_eq!(
        definition.params,
        &[
            ParamDefinition {
                pos: ParamPosition::Dest,
                param_type: ParamType::Constant(ConstantParam::WordRegister(WordRegister::HL)),
            },
            ParamDefinition {
                pos: ParamPosition::Src,
                param_type: ParamType::Constant(ConstantParam::WordRegister(WordRegister::SP)),
            },
            ParamDefinition {
                pos: ParamPosition::AddSrc,
                param_type: ParamType::Appended(AppendedParam::AddressOffset),
            }
        ]
    );
}

#[test]
fn three_arg_expansion() {
    let opcode = LoadStackOffsetOpcode::from_opcode(0xF8);

    assert_eq!(
        opcode.build_instruction(&mut vec![0xFE].into_iter()),
        LoadStackOffset {
            dest: WordRegister::HL,
            base: WordRegister::SP,
            value: address::AddressOffset(-2)
        }
    );
}

#[test]
fn three_arg_disasm() {
    let op = LoadStackOffset {
        dest: WordRegister::HL,
        base: WordRegister::SP,
        value: address::AddressOffset(-2),
    };

    assert_eq!(op.disassemble(), "LD HL, SP + -2h")
}