Merge pull request #13 from Rodrigodd/override-mbc

Add option for overriding MBC type

Author: Rodrigodd

Cargo.lock

@@ -1,5 +1,9 @@
 use std::io::{Read, Seek, SeekFrom};
 
+mod size;
+
+pub use size::{parse_number, parse_size};
+
 fn read_u32(file: &mut impl Read) -> Result<u32, std::io::Error> {
     let mut value = [0; 4];
     file.read_exact(&mut value)?;

core/src/gameboy/cartridge.rs

@@ -0,0 +1,114 @@
+use std::num::ParseIntError;
+
+#[derive(Debug, PartialEq)]
+pub enum ParseSizeError {
+    InvalidFormat,
+    InvalidSuffix,
+    NumberTooLarge,
+    ParseError(ParseIntError),
+}
+
+pub fn parse_number(input: &str) -> Result<u64, ParseIntError> {
+    if let Some(stripped) = input.strip_prefix("0x") {
+        u64::from_str_radix(stripped, 16)
+    } else {
+        input.parse()
+    }
+}
+
+pub fn parse_size(input: &str) -> Result<u64, ParseSizeError> {
+    if input.is_empty() {
+        return Err(ParseSizeError::InvalidFormat);
+    }
+
+    let (num_part, suffix) = input.trim().split_at(
+        input
+            .find(|c: char| !c.is_ascii_digit() && c != 'x')
+            .unwrap_or(input.len()),
+    );
+
+    let num = parse_number(num_part).map_err(ParseSizeError::ParseError)?;
+
+    let multiplier = match suffix.trim() {
+        "B" => 1,
+        "kB" => 1_024,
+        "MB" => 1_024 * 1_024,
+        "GB" => 1_024 * 1_024 * 1_024,
+        "" => return Err(ParseSizeError::InvalidFormat),
+        _ => return Err(ParseSizeError::InvalidSuffix),
+    };
+
+    let result = num
+        .checked_mul(multiplier as u64)
+        .ok_or(ParseSizeError::NumberTooLarge)?;
+
+    if result > u32::MAX as u64 {
+        return Err(ParseSizeError::NumberTooLarge);
+    }
+
+    Ok(result)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_number_decimal() {
+        assert_eq!(parse_number("123"), Ok(123));
+        assert_eq!(parse_number("0"), Ok(0));
+    }
+
+    #[test]
+    fn test_parse_number_hexadecimal() {
+        assert_eq!(parse_number("0x10"), Ok(16));
+        assert_eq!(parse_number("0x1F4"), Ok(500));
+    }
+
+    #[test]
+    fn test_parse_number_invalid() {
+        assert!(parse_number("not_a_number").is_err());
+        assert!(parse_number("0xZZZ").is_err());
+    }
+
+    #[test]
+    fn test_parse_size_with_hexadecimal() {
+        assert_eq!(parse_size("0x100B"), Ok(256));
+        assert_eq!(parse_size("0x1kB"), Ok(1_024));
+        assert_eq!(parse_size("0x2MB"), Ok(2 * 1_024 * 1_024));
+    }
+
+    #[test]
+    fn test_valid_sizes() {
+        assert_eq!(parse_size("0B"), Ok(0));
+        assert_eq!(parse_size("256B"), Ok(256));
+        assert_eq!(parse_size("1kB"), Ok(1_024));
+        assert_eq!(parse_size("2MB"), Ok(2 * 1_024 * 1_024));
+        assert_eq!(parse_size("1GB"), Ok(1_024 * 1_024 * 1_024));
+    }
+
+    #[test]
+    fn test_invalid_formats() {
+        assert_eq!(parse_size(""), Err(ParseSizeError::InvalidFormat));
+        assert_eq!(parse_size("256"), Err(ParseSizeError::InvalidFormat));
+        assert_eq!(parse_size("256MBExtra"), Err(ParseSizeError::InvalidSuffix));
+    }
+
+    #[test]
+    fn test_invalid_suffix() {
+        assert_eq!(parse_size("256mB"), Err(ParseSizeError::InvalidSuffix));
+        assert_eq!(parse_size("256TB"), Err(ParseSizeError::InvalidSuffix));
+    }
+
+    #[test]
+    fn test_parse_errors() {
+        assert!(matches!(
+            parse_size("not_a_numberMB"),
+            Err(ParseSizeError::ParseError(_))
+        ));
+        assert!(matches!(
+            parse_size("0xnot_hexB"),
+            Err(ParseSizeError::ParseError(_))
+        ));
+    }
+}

core/src/parser/mod.rs

@@ -100,7 +100,7 @@ fn test_interrupt_prediction(rom: &str, timeout: u64) -> bool {
     let rom = std::fs::read(rom_path).unwrap();
     let cartridge = match Cartridge::new(rom) {
         Ok(x) => x,
-        Err(x) => {
+        Err((x, _)) => {
             eprintln!("Error reading rom: {}", x);
             return true;
         }

core/src/parser/size.rs

@@ -162,7 +162,7 @@ fn test_interrupt_prediction(rom: &str, timeout: u64) -> bool {
     };
     let cartridge = match Cartridge::new(rom) {
         Ok(x) => x,
-        Err(x) => {
+        Err((x, _)) => {
             eprintln!("Error reading rom: {}", x);
             return true;
         }

core/tests/check_interrupt_prediction.rs

@@ -174,12 +174,16 @@ extern "C" fn retro_load_game(info: Option<&retro_game_info>) -> bool {
     log::info!("retro load game");
 
     // load rom data into core
-    let Some(info) = info else { return false } ;
+    let Some(info) = info else { return false };
 
     let data = unsafe { std::slice::from_raw_parts(info.data as *const u8, info.size as usize) };
     let cartridge = match Cartridge::new(data.to_vec()) {
-        Ok(x) => x,
-        Err(err) => {
+        Ok(rom) => rom,
+        Err((err, Some(rom))) => {
+            log::warn!("Warnings when loading rom: {}", err);
+            rom
+        }
+        Err((err, None)) => {
             log::error!("Error loading rom: {}", err);
             return false;
         }
@@ -371,7 +375,10 @@ impl log::Log for RetroLogger {
             let Ok(mut file) = std::fs::OpenOptions::new()
                 .create(true)
                 .append(true)
-                .open(path) else { return };
+                .open(path)
+            else {
+                return;
+            };
 
             let _ = writeln!(
                 &mut file,

jit/tests/check_jit_compilation.rs

@@ -1,5 +1,12 @@
 ignore-dev-dependencies = true
 ignore-build-dependencies = true
-accepted = ["Apache-2.0", "MIT", "Unicode-DFS-2016", "ISC", "BSD-3-Clause"]
+accepted = [
+    "Apache-2.0",
+    "MIT",
+    "Unicode-DFS-2016",
+    "Unicode-3.0",
+    "ISC",
+    "BSD-3-Clause",
+]
 
 targets = ["aarch64-linux-android"]

libretro/src/lib.rs

@@ -4,6 +4,7 @@ accepted = [
     "Apache-2.0",
     "MIT",
     "Unicode-DFS-2016",
+    "Unicode-3.0",
     "BSD-2-Clause",
     "BSD-3-Clause",
     "ISC",

license/about-android.toml

@@ -4,6 +4,7 @@ accepted = [
     "Apache-2.0",
     "MIT",
     "Unicode-DFS-2016",
+    "Unicode-3.0",
     "ISC",
     "BSD-3-Clause",
     "BSL-1.0",