snes_address 0.1.1

A library for translating memory address for SNES games
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

/*!

`snes_address` provides functions for translating between PC and SNES memory map address

## Supported Memory Map Conversions

- [x] LoRom
- [ ] HiRom
- [ ] ExLoRom
- [ ] ExHiRom
Others to be added...

## Example

```
use snes_address::errors::AddressError;

fn lorom_to_pc(lorom_address: usize) -> Result<usize, AddressError> {
    snes_address::lorom_to_pc(lorom_address)
}

fn compress_data(pc_address: usize) -> Result<usize, AddressError> {
    snes_address::pc_to_lorom(pc_address)
}
```

*/

use errors::AddressError;

pub mod errors;

pub fn pc_to_lorom(pc: usize) -> Result<usize, AddressError> {
    if pc >= 0x400000 {
        Err(AddressError::OutOfBounds)
    } else {
        let lower_word = pc & 0x00FFFF | 0x8000;
        let lorom = (((pc / 0x8000) << 16) + 0x800000) | lower_word;
        Ok(lorom)
    }
}

pub fn lorom_to_pc(lorom: usize) -> Result<usize, AddressError> {
    if !(0x800000..=0xFFFFFF).contains(&lorom) {
        Err(AddressError::OutOfBounds)
    } else {
        Ok((lorom & 0x7F0000) >> 1 | (lorom & 0x7FFF))
    }
}

#[cfg(test)]
mod adress_converter_tests {
    use super::*;

    #[test]
    fn pc_to_lorom_works() {
        let result = pc_to_lorom(0x2156E8);
        assert_eq!(result, Ok(0xC2D6E8));
    }

    #[test]
    fn pc_to_lorom_lowerbound() {
        let result = pc_to_lorom(0x000000);
        assert_eq!(result, Ok(0x808000));
    }

    #[test]
    fn pc_to_lorom_upperbound() {
        let result = pc_to_lorom(0x3FFFFF);
        assert_eq!(result, Ok(0xFFFFFF));
    }

    #[test]
    fn pc_to_lorom_out_of_bounds() {
        let result = pc_to_lorom(0x400000);
        assert_eq!(result, Err(AddressError::OutOfBounds));
    }

    #[test]
    fn lorom_to_pc_works() {
        let result = lorom_to_pc(0xC2D6E8);
        assert_eq!(result, Ok(0x2156E8));
    }

    #[test]
    fn lorom_to_pc_lowerbound() {
        let result = lorom_to_pc(0x808000);
        assert_eq!(result, Ok(0x000000));
    }

    #[test]
    fn lorom_to_pc_upperbound() {
        let result = lorom_to_pc(0xFFFFFF);
        assert_eq!(result, Ok(0x3FFFFF));
    }

    #[test]
    fn lorom_to_pc_out_of_bounds_lower() {
        let result = lorom_to_pc(0x7FFFFF);
        assert_eq!(result, Err(AddressError::OutOfBounds));
    }

    #[test]
    fn lorom_to_pc_out_of_bounds_upper() {
        let result = lorom_to_pc(0x1000000);
        assert_eq!(result, Err(AddressError::OutOfBounds));
    }
}