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

extern crate alloc;

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

use olympia_core::registers::WordRegister;
use olympia_core::registers::WordRegister::*;

#[derive(Debug, PartialEq, Eq, OlympiaInstruction)]
#[olympia(opcode = 0x1111_1001, label = "LD")]
struct LoadStackPointer {
    #[olympia(dest, constant(SP))]
    dest: WordRegister,
    #[olympia(src, constant(WordRegister::HL))]
    src: WordRegister,
}

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

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

#[test]
fn constant_args_expansion() {
    let opcode = LoadStackPointerOpcode::from_opcode(0xF9);

    let data = vec![];
    assert_eq!(
        opcode.build_instruction(&mut data.into_iter()),
        LoadStackPointer {
            dest: WordRegister::SP,
            src: WordRegister::HL,
        },
    );
}

#[test]
fn constant_args_disasm() {
    let op = LoadStackPointer {
        dest: WordRegister::SP,
        src: WordRegister::HL,
    };

    assert_eq!(op.disassemble(), "LD SP, HL");
}