zerodmg-codes 0.1.8

pieces of a naive incomplete broken game boy emulator
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
73
74
75
76
77
78
79
80
81
82
83

#![feature(rust_2018_preview)]
#![feature(rust_2018_idioms)]
#![feature(try_from)]
#![warn(missing_docs, missing_debug_implementations)]

//! Experiments in decoding Game Boy machine code.

/// Encoding/decoding individual CPU instructions.
pub mod instruction;

/// Decoding and disassembling assembled ROMs binaries.
pub mod assembled;

/// Assembling and manipulating disassembled ROM programs.
pub mod disassembled;

/// Re-exports important traits and types for glob importing.
pub mod prelude {
    pub use crate::assembled::prelude::*;
    pub use crate::disassembled::prelude::*;
    pub use crate::instruction::prelude::*;
}

use self::prelude::*;

/// An example/experimental use of this crate.
pub fn main() -> Result<(), Box<std::any::Any + Send>> {
    let disassembled = DisassembledRom::from({
        let main_addr = 0x0000;
        let init_addr = 0x0030;
        vec![
            RomBlock {
                address: Some(main_addr),
                content: Code(vec![INC(A), INC(A), INC(A)]),
            },
            RomBlock {
                address: None,
                content: Code(vec![DEC(A)]),
            },
            RomBlock {
                address: Some(main_addr + 0x0005),
                content: Code(vec![DEC(A), JP(init_addr)]),
            },
            RomBlock {
                address: None,
                content: Data(vec![
                    0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
                    0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x02,
                    0x03, 0x04, 0x05, 0x06, 0x07, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
                ]),
            },
            RomBlock {
                address: Some(init_addr),
                content: Code(vec![DEC(A), JP(main_addr)]),
            },
        ]
    });

    println!("=== Input ===");
    println!("{:?}\n", disassembled);
    println!("{}\n", disassembled);

    println!("=== Assembled ===");
    let assembled = disassembled.assemble();
    println!("{:?}\n", assembled.to_bytes());

    println!("=== Redisassembled (using metadata) ===");
    let redisassembled = assembled.disassemble();
    println!("{:?}\n", redisassembled);
    println!("{}\n", redisassembled);

    println!("=== Redisassembled (just from the bytes) ===");
    let really_disassembled = AssembledRom::new(assembled.to_bytes()).disassemble();
    println!("{:?}\n", really_disassembled);
    println!("{}\n", really_disassembled);

    Ok(())
}

#[test]
fn test_main() -> Result<(), Box<std::any::Any + Send>> {
    main()
}