Iterating through addresses matching a signature

src/emulator/gba/mednafen.rs

@@ -20,7 +20,7 @@
         if self.is_64_bit {
             self.cached_ewram_pointer = {
                 const SIG: Signature<13> = Signature::new("48 8B 05 ?? ?? ?? ?? 81 E1 FF FF 03 00");
-                let ptr: Address = SIG.scan_process_range(game, main_module_range)? + 3;
+                let ptr: Address = SIG.scan_once(game, main_module_range)? + 3;
                 let mut addr: Address = ptr + 0x4 + game.read::<i32>(ptr).ok()?;
 
                 if game.read::<u8>(ptr + 10).ok()? == 0x48 {
@@ -36,7 +36,7 @@
             self.cached_iwram_pointer = {
                 const SIG2: Signature<13> =
                     Signature::new("48 8B 05 ?? ?? ?? ?? 81 E1 FF 7F 00 00");
-                let ptr: Address = SIG2.scan_process_range(game, main_module_range)? + 3;
+                let ptr: Address = SIG2.scan_once(game, main_module_range)? + 3;
                 let mut addr: Address = ptr + 0x4 + game.read::<i32>(ptr).ok()?;
 
                 if game.read::<u8>(ptr + 10).ok()? == 0x48 {
@@ -56,13 +56,13 @@
         } else {
             self.cached_ewram_pointer = {
                 const SIG: Signature<11> = Signature::new("A1 ?? ?? ?? ?? 81 ?? FF FF 03 00");
-                let ptr = SIG.scan_process_range(game, main_module_range)?;
+                let ptr = SIG.scan_once(game, main_module_range)?;
                 game.read::<Address32>(ptr + 1).ok()?.into()
             };
 
             self.cached_iwram_pointer = {
                 const SIG2: Signature<11> = Signature::new("A1 ?? ?? ?? ?? 81 ?? FF 7F 00 00");
-                let ptr = SIG2.scan_process_range(game, main_module_range)?;
+                let ptr = SIG2.scan_once(game, main_module_range)?;
                 game.read::<Address32>(ptr + 1).ok()?.into()
             };
 
@@ -95,7 +95,7 @@
         true
     }
 
     pub const fn new() -> Self {
         Self {
             cached_ewram_pointer: Address::NULL,
             cached_iwram_pointer: Address::NULL,

src/emulator/gba/nocashgba.rs

@@ -16,7 +16,7 @@
             .find_map(|(name, _)| game.get_module_range(name).ok())?;
 
         self.base_addr = game
-            .read::<Address32>(SIG.scan_process_range(game, main_module_range)? + 0x2)
+            .read::<Address32>(SIG.scan_once(game, main_module_range)? + 0x2)
             .ok()?
             .into();
 
@@ -49,7 +49,7 @@
         true
     }
 
     pub const fn new() -> Self {
         Self {
             base_addr: Address::NULL,
         }

src/emulator/gba/retroarch.rs

@@ -47,7 +47,7 @@
             const SIG2: Signature<13> = Signature::new("48 8B 05 ?? ?? ?? ?? 81 E1 FF 7F 00 00");
 
             let ewram_pointer = {
-                let ptr: Address = SIG.scan_process_range(game, module_range)? + 3;
+                let ptr: Address = SIG.scan_once(game, module_range)? + 3;
                 let mut addr: Address = ptr + 0x4 + game.read::<i32>(ptr).ok()?;
 
                 if game.read::<u8>(ptr + 10).ok()? == 0x48 {
@@ -61,7 +61,7 @@
             };
 
             let iwram_pointer = {
-                let ptr: Address = SIG2.scan_process_range(game, module_range)? + 3;
+                let ptr: Address = SIG2.scan_once(game, module_range)? + 3;
                 let mut addr: Address = ptr + 0x4 + game.read::<i32>(ptr).ok()?;
 
                 if game.read::<u8>(ptr + 10).ok()? == 0x48 {
@@ -85,12 +85,12 @@
         } else {
             let ewram_pointer: Address = {
                 const SIG: Signature<11> = Signature::new("A1 ?? ?? ?? ?? 81 ?? FF FF 03 00");
-                let ptr = SIG.scan_process_range(game, module_range)?;
+                let ptr = SIG.scan_once(game, module_range)?;
                 game.read::<Address32>(ptr + 1).ok()?.into()
             };
             let iwram_pointer: Address = {
                 const SIG2: Signature<11> = Signature::new("A1 ?? ?? ?? ?? 81 ?? FF 7F 00 00");
-                let ptr = SIG2.scan_process_range(game, module_range)?;
+                let ptr = SIG2.scan_once(game, module_range)?;
                 game.read::<Address32>(ptr + 1).ok()?.into()
             };
 
@@ -114,24 +114,24 @@
         let base_addr: Address = match is_64_bit {
             true => {
                 const SIG: Signature<10> = Signature::new("48 8B 15 ?? ?? ?? ?? 8B 42 40");
-                let ptr = SIG.scan_process_range(game, (self.core_base, module_size))? + 3;
+                let ptr = SIG.scan_once(game, (self.core_base, module_size))? + 3;
                 let ptr: Address = ptr + 0x4 + game.read::<i32>(ptr).ok()?;
                 game.read::<Address64>(ptr).ok()?.into()
             }
             false => {
                 const SIG: Signature<11> = Signature::new("A3 ?? ?? ?? ?? F7 C5 02 00 00 00");
-                let ptr = SIG.scan_process_range(game, (self.core_base, module_size))? + 1;
+                let ptr = SIG.scan_once(game, (self.core_base, module_size))? + 1;
                 game.read::<Address32>(ptr).ok()?.into()
             }
         };
 
         let ewram = {
-            let offset = SIG_EWRAM.scan_process_range(game, (self.core_base, module_size))? + 8;
+            let offset = SIG_EWRAM.scan_once(game, (self.core_base, module_size))? + 8;
             base_addr + game.read::<i32>(offset).ok()?
         };
 
         let iwram = {
-            let offset = SIG_IWRAM.scan_process_range(game, (self.core_base, module_size))? + 9;
+            let offset = SIG_IWRAM.scan_once(game, (self.core_base, module_size))? + 9;
             base_addr + game.read::<i32>(offset).ok()?
         };
 
@@ -142,7 +142,7 @@
         game.read::<u8>(self.core_base).is_ok()
     }
 
     pub const fn new() -> Self {
         Self {
             core_base: Address::NULL,
         }

src/emulator/gba/vba.rs

@@ -25,7 +25,7 @@
             const SIG2: Signature<13> = Signature::new("48 8B 05 ?? ?? ?? ?? 81 E3 FF 7F 00 00");
 
             self.cached_ewram_pointer = {
-                let ptr: Address = SIG.scan_process_range(game, main_module_range)? + 3;
+                let ptr: Address = SIG.scan_once(game, main_module_range)? + 3;
                 let mut addr: Address = ptr + 0x4 + game.read::<i32>(ptr).ok()?;
 
                 if game.read::<u8>(ptr + 10).ok()? == 0x48 {
@@ -39,7 +39,7 @@
             };
 
             self.cached_iwram_pointer = {
-                let ptr: Address = SIG2.scan_process_range(game, main_module_range)? + 3;
+                let ptr: Address = SIG2.scan_once(game, main_module_range)? + 3;
                 let mut addr: Address = ptr + 0x4 + game.read::<i32>(ptr).ok()?;
 
                 if game.read::<u8>(ptr + 10).ok()? == 0x48 {
@@ -58,11 +58,11 @@
                 const SIG_RUNNING2: Signature<16> =
                     Signature::new("48 8B 15 ?? ?? ?? ?? 31 C0 8B 12 85 D2 74 ?? 48");
 
-                if let Some(ptr) = SIG_RUNNING.scan_process_range(game, main_module_range) {
+                if let Some(ptr) = SIG_RUNNING.scan_once(game, main_module_range) {
                     let ptr = ptr + 2;
                     ptr + 0x4 + game.read::<i32>(ptr).ok()? + 0x1
                 } else {
-                    let ptr = SIG_RUNNING2.scan_process_range(game, main_module_range)? + 3;
+                    let ptr = SIG_RUNNING2.scan_once(game, main_module_range)? + 3;
                     let ptr = ptr + 0x4 + game.read::<i32>(ptr).ok()?;
                     game.read::<Address64>(ptr).ok()?.into()
                 }
@@ -76,11 +76,11 @@
             const SIG: Signature<11> = Signature::new("A1 ?? ?? ?? ?? 81 ?? FF FF 03 00");
             const SIG_OLD: Signature<12> = Signature::new("81 E6 FF FF 03 00 8B 15 ?? ?? ?? ??");
 
-            if let Some(ptr) = SIG.scan_process_range(game, main_module_range) {
+            if let Some(ptr) = SIG.scan_once(game, main_module_range) {
                 self.cached_ewram_pointer = game.read::<Address32>(ptr + 1).ok()?.into();
                 self.cached_iwram_pointer = {
                     const SIG2: Signature<11> = Signature::new("A1 ?? ?? ?? ?? 81 ?? FF 7F 00 00");
-                    let ptr = SIG2.scan_process_range(game, main_module_range)?;
+                    let ptr = SIG2.scan_once(game, main_module_range)?;
                     game.read::<Address32>(ptr + 1).ok()?.into()
                 };
 
@@ -91,8 +91,8 @@
                         Signature::new("8B 15 ?? ?? ?? ?? 31 C0 85 D2 74 ?? 0F");
 
                     let ptr = SIG
-                        .scan_process_range(game, main_module_range)
-                        .or_else(|| SIG_OLD.scan_process_range(game, main_module_range))?;
+                        .scan_once(game, main_module_range)
+                        .or_else(|| SIG_OLD.scan_once(game, main_module_range))?;
 
                     game.read::<Address32>(ptr + 2).ok()?.into()
                 };
@@ -101,15 +101,15 @@
                 let iwram = game.read::<Address32>(self.cached_iwram_pointer).ok()?;
 
                 Some([ewram.into(), iwram.into()])
-            } else if let Some(ptr) = SIG_OLD.scan_process_range(game, main_module_range) {
+            } else if let Some(ptr) = SIG_OLD.scan_once(game, main_module_range) {
                 // This code is for very old versions of VisualBoyAdvance (1.8.0-beta 3)
                 self.cached_ewram_pointer = game.read::<Address32>(ptr + 8).ok()?.into();
                 self.cached_iwram_pointer = self.cached_ewram_pointer.add_signed(0x4);
 
                 self.is_emulating = {
                     const SIG_RUNNING: Signature<11> =
                         Signature::new("8B 0D ?? ?? ?? ?? 85 C9 74 ?? 8A");
-                    let ptr = SIG_RUNNING.scan_process_range(game, main_module_range)? + 2;
+                    let ptr = SIG_RUNNING.scan_once(game, main_module_range)? + 2;
                     game.read::<Address32>(ptr).ok()?.into()
                 };
 
@@ -149,7 +149,7 @@
         true
     }
 
     pub const fn new() -> Self {
         Self {
             cached_ewram_pointer: Address::NULL,
             cached_iwram_pointer: Address::NULL,

src/emulator/genesis/blastem.rs

@@ -18,7 +18,7 @@ impl State {
                     .contains(MemoryRangeFlags::WRITE)
                     && m.size().unwrap_or_default() == 0x101000
             })
-            .find_map(|m| SIG.scan_process_range(game, m.range().ok()?))?
+            .find_map(|m| SIG.scan_once(game, m.range().ok()?))?
             + 11;
 
         let wram = game.read::<Address32>(scanned_address).ok()?;

src/emulator/genesis/fusion.rs

@@ -14,7 +14,7 @@ impl State {
             .filter(|(_, state)| matches!(state, super::State::Fusion(_)))
             .find_map(|(name, _)| game.get_module_range(name).ok())?;
 
-        let ptr = SIG.scan_process_range(game, main_module)? + 1;
+        let ptr = SIG.scan_once(game, main_module)? + 1;
 
         let addr = ptr + game.read::<u8>(ptr).ok()? as u64 + 3;
         let addr = game.read::<Address32>(addr).ok()?;

src/emulator/genesis/gens.rs

@@ -12,7 +12,7 @@ impl State {
             .filter(|(_, state)| matches!(state, super::State::Gens(_)))
             .find_map(|(name, _)| game.get_module_range(name).ok())?;
 
-        let ptr = SIG.scan_process_range(game, main_module)? + 11;
+        let ptr = SIG.scan_once(game, main_module)? + 11;
 
         *endian = if game.read::<u8>(ptr + 4).ok()? == 0x86 {
             Endian::Big

src/emulator/genesis/retroarch.rs

@@ -45,7 +45,7 @@ impl State {
                         .contains(MemoryRangeFlags::WRITE)
                         && m.size().unwrap_or_default() == 0x101000
                 })
-                .find_map(|m| SIG.scan_process_range(game, m.range().ok()?))?
+                .find_map(|m| SIG.scan_once(game, m.range().ok()?))?
                 + 11;
 
             let wram = game.read::<Address32>(scanned_address).ok()?;
@@ -58,21 +58,19 @@ impl State {
             if is_x86_64 {
                 const SIG_64: Signature<10> = Signature::new("48 8D 0D ?? ?? ?? ?? 4C 8B 2D");
 
-                let addr = SIG_64.scan_process_range(
-                    game,
-                    (core_address, game.get_module_size(core_name).ok()?),
-                )? + 3;
+                let addr = SIG_64
+                    .scan_once(game, (core_address, game.get_module_size(core_name).ok()?))?
+                    + 3;
 
                 let wram = addr + 0x4 + game.read::<i32>(addr).ok()?;
 
                 Some(wram)
             } else {
                 const SIG_32: Signature<7> = Signature::new("A3 ?? ?? ?? ?? 29 F9");
 
-                let ptr = SIG_32.scan_process_range(
-                    game,
-                    (core_address, game.get_module_size(core_name).ok()?),
-                )? + 1;
+                let ptr = SIG_32
+                    .scan_once(game, (core_address, game.get_module_size(core_name).ok()?))?
+                    + 1;
 
                 let wram = game.read::<Address32>(ptr).ok()?;
 
@@ -85,21 +83,19 @@ impl State {
             if is_x86_64 {
                 const SIG_64: Signature<9> = Signature::new("48 8D 0D ?? ?? ?? ?? 41 B8");
 
-                let addr = SIG_64.scan_process_range(
-                    game,
-                    (core_address, game.get_module_size(core_name).ok()?),
-                )? + 3;
+                let addr = SIG_64
+                    .scan_once(game, (core_address, game.get_module_size(core_name).ok()?))?
+                    + 3;
 
                 let wram = addr + 0x4 + game.read::<i32>(addr).ok()?;
 
                 Some(wram)
             } else {
                 const SIG_32: Signature<8> = Signature::new("B9 ?? ?? ?? ?? C1 EF 10");
 
-                let ptr = SIG_32.scan_process_range(
-                    game,
-                    (core_address, game.get_module_size(core_name).ok()?),
-                )? + 1;
+                let ptr = SIG_32
+                    .scan_once(game, (core_address, game.get_module_size(core_name).ok()?))?
+                    + 1;
 
                 let wram = game.read::<Address32>(ptr).ok()?;
 

src/emulator/genesis/segaclassics.rs

@@ -13,14 +13,14 @@ impl State {
         const GENESISWRAPPERDLL: &str = "GenesisEmuWrapper.dll";
 
         let mut ptr = if let Ok(module) = game.get_module_range(GENESISWRAPPERDLL) {
-            SIG_GAMEROOM.scan_process_range(game, module)? + 2
+            SIG_GAMEROOM.scan_once(game, module)? + 2
         } else {
             let main_module = super::PROCESS_NAMES
                 .iter()
                 .filter(|(_, state)| matches!(state, super::State::SegaClassics(_)))
                 .find_map(|(name, _)| game.get_module_range(name).ok())?;
 
-            SIG_SEGACLASSICS.scan_process_range(game, main_module)? + 8
+            SIG_SEGACLASSICS.scan_once(game, main_module)? + 8
         };
 
         ptr = game.read::<Address32>(ptr).ok()?.into();

src/emulator/ps1/duckstation.rs

@@ -24,7 +24,7 @@ impl State {
             self.addr = debug_symbol.address;
         } else {
             // For older versions of Duckstation, we fall back to regular sigscanning
-            let addr = SIG.scan_process_range(game, main_module_range)? + 3;
+            let addr = SIG.scan_once(game, main_module_range)? + 3;
             self.addr = addr + 0x4 + game.read::<i32>(addr).ok()?;
         }
 

src/emulator/ps1/epsxe.rs

@@ -12,7 +12,7 @@ impl State {
             .filter(|(_, state)| matches!(state, super::State::Epsxe(_)))
             .find_map(|(name, _)| game.get_module_range(name).ok())?;
 
-        let ptr = SIG.scan_process_range(game, main_module_range)? + 5;
+        let ptr = SIG.scan_once(game, main_module_range)? + 5;
 
         Some(game.read::<Address32>(ptr).ok()?.into())
     }

src/emulator/ps1/mednafen.rs

@@ -17,8 +17,8 @@ impl State {
             pe::MachineType::read(game, main_module_range.0) == Some(pe::MachineType::X86_64);
 
         let ptr = match is_64_bit {
-            true => SIG_64.scan_process_range(game, main_module_range)?,
-            false => SIG_32.scan_process_range(game, main_module_range)?,
+            true => SIG_64.scan_once(game, main_module_range)?,
+            false => SIG_32.scan_once(game, main_module_range)?,
         } + 0x5;
 
         Some(game.read::<Address32>(ptr).ok()?.into())

src/emulator/ps1/pcsx_redux.rs

@@ -25,10 +25,10 @@ impl State {
             );
             const SIG_OFFSET: Signature<9> = Signature::new("89 D1 C1 E9 10 48 8B ?? ??");
 
-            self.addr_base = SIG_BASE.scan_process_range(game, main_module_range)? + 2;
+            self.addr_base = SIG_BASE.scan_once(game, main_module_range)? + 2;
             self.addr = game.read::<Address64>(self.addr_base).ok()?.into();
 
-            let offset = SIG_OFFSET.scan_process_range(game, main_module_range)? + 8;
+            let offset = SIG_OFFSET.scan_once(game, main_module_range)? + 8;
             let offset = game.read::<u8>(offset).ok()? as u64;
 
             let addr = game.read::<Address64>(self.addr + offset).ok()?;
@@ -45,7 +45,7 @@ impl State {
                         .unwrap_or_default()
                         .contains(MemoryRangeFlags::WRITE)
                 })
-                .find_map(|m| SIG.scan_process_range(game, m.range().ok()?))?
+                .find_map(|m| SIG.scan_once(game, m.range().ok()?))?
                 + 2;
 
             self.addr = game.read::<Address32>(self.addr_base).ok()?.into();

src/emulator/ps1/psxfin.rs

@@ -15,14 +15,13 @@ impl State {
             .filter(|(_, state)| matches!(state, super::State::PsxFin(_)))
             .find_map(|(name, _)| game.get_module_range(name).ok())?;
 
-        let mut ptr: Address32 = if let Some(sig) = SIG.scan_process_range(game, main_module_range)
-        {
+        let mut ptr: Address32 = if let Some(sig) = SIG.scan_once(game, main_module_range) {
             game.read(sig + 2).ok()?
-        } else if let Some(sig) = SIG_0.scan_process_range(game, main_module_range) {
+        } else if let Some(sig) = SIG_0.scan_once(game, main_module_range) {
             game.read(sig + 1).ok()?
-        } else if let Some(sig) = SIG_1.scan_process_range(game, main_module_range) {
+        } else if let Some(sig) = SIG_1.scan_once(game, main_module_range) {
             game.read(sig + 1).ok()?
-        } else if let Some(sig) = SIG_2.scan_process_range(game, main_module_range) {
+        } else if let Some(sig) = SIG_2.scan_once(game, main_module_range) {
             game.read(sig + 1).ok()?
         } else {
             return None;