···

       
14
       
14
       
 
       
}

     

       
15
       
15
       
 
       


     

       
16
       
16
       
 
       


     

       
17
       
17
       
+
       


     

       
18
       
18
       
+
       


     

       
19
       
19
       
+
       


     

       
20
       
20
       
+
       


     

       
17
       
21
       
 
       
impl CartridgeHeader {

     

       
18
       
18
       
-
       
    fn new(rom_location: &str ) -> Result<Self, Error>  {

     

       
19
       
19
       
-
       
        let mut rom_file = File::open(rom_location)?;

     

       
20
       
20
       
-
       
        rom_file.seek(SeekFrom::Start(CartridgeHeaderAddress::CartridgeHeaderStart as u64))?;

     

       
21
       
21
       
-
       
        let mut header_buffer: [u8; 80] = [0; 80];

     

       
22
       
22
       
-
       
        rom_file.read_exact(&mut header_buffer)?;

     

       
22
       
22
       
+
       
    fn new(rom_bytes: &[u8] ) -> Result<Self, Error>  {

     

       
23
       
23
       
+
       
        let start = CartridgeHeaderAddress::CartridgeHeaderStart as usize;

     

       
24
       
24
       
+
       
        //We know the header is only 80 chars

     

       
25
       
25
       
+
       
        let end = start + 80;

     

       
26
       
26
       
+
       


     

       
23
       
27
       
 
       
        Ok(Self {

     

       
24
       
24
       
-
       
            buffer: header_buffer

     

       
28
       
28
       
+
       
            buffer: rom_bytes[start..end].try_into().map_err(|_| Error::CartridgeReadError)?

     

       
25
       
29
       
 
       
        })

     

       
30
       
30
       
+
       
    }

     

       
31
       
31
       
+
       


     

       
32
       
32
       
+
       
    fn print_test(&self) {

     

       
33
       
33
       
+
       
        for byte in self.buffer.iter() {

     

       
34
       
34
       
+
       
            print!("{} ", *byte as char);

     

       
35
       
35
       
+
       
        }

     

       
26
       
36
       
 
       
    }

     

       
27
       
37
       
 
       
}

     

       
28
       
38
       
 
       


     
···

       
35
       
45
       
 
       


     

       
36
       
46
       
 
       
fn main() -> std::io::Result<()> {

     

       
37
       
47
       
 
       
    let mut rom_file = File::open(ROM_NAME)?;

     

       
38
       
38
       
-
       
    rom_file.seek(SeekFrom::Start(CartridgeHeaderAddress::CartridgeHeaderStart as u64))?;

     

       
39
       
39
       
-
       
    let mut header_buffer: [u8; 80] = [0; 80];

     

       
40
       
40
       
-
       
    rom_file.read_exact(&mut header_buffer)?;

     

       
41
       
41
       
-
       
    let mut byte_index = 0x0100;

     

       
42
       
42
       
-
       
    for byte in header_buffer.iter() {

     

       
43
       
43
       
-
       
        // println!("{}", *byte as char);

     

       
44
       
44
       
-
       
        print!("{:02x} ", byte_index);

     

       
45
       
45
       
-
       
        byte_index += 1;

     

       
46
       
46
       
-
       


     

       
47
       
47
       
-
       
    }

     

       
48
       
48
       
-
       


     

       
48
       
48
       
+
       
    let mut rom_buffer: Vec<u8> = Vec::new();

     

       
49
       
49
       
+
       
    rom_file.read_to_end(&mut rom_buffer)?;

     

       
50
       
50
       
+
       
    let cart_header = CartridgeHeader::new(&*rom_buffer).map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, "Rom failed to parse"))?;

     

       
51
       
51
       
+
       
    cart_header.print_test();

     

       
49
       
52
       
 
       
    Ok(())

     

       
50
       
53
       
 
       
}

     

       
54
       
54
       
+
       


     

       
55
       
55
       
+
       


     

       
56
       
56
       
+
       
fn buffer_from_file(path: &str) -> Vec<u8> {

     

       
57
       
57
       
+
       
    let mut file = std::fs::File::open(path).expect("File not there");

     

       
58
       
58
       
+
       
    let mut buffer = Vec::new();

     

       
59
       
59
       
+
       
    file.read_to_end(&mut buffer).expect("Could not read file");

     

       
60
       
60
       
+
       
    buffer

     

       
61
       
61
       
+
       
}