refactor: use openwa_core::mem::classify_pointer in dump_region

Replace inline pointer classification logic in dump_region with calls to
the shared classify_pointer function. Remove duplicated IsBadReadPtr
extern and can_read helper (now live in openwa_core::mem).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

crates/openwa-wormkit/src/replacements/input.rs

@@ -31,10 +31,6 @@ use openwa_core::engine::ddgame::{offsets, TeamArenaRef};
 use openwa_core::engine::{DDGame, DDGameWrapper};
 use openwa_core::rebase::rb;
 
-extern "system" {
-    fn IsBadReadPtr(lp: *const u8, ucb: u32) -> i32;
-}
-
 /// Trampoline to the original TurnManager_ProcessFrame.
 static ORIG_TURN_MANAGER: AtomicU32 = AtomicU32::new(0);
 
@@ -77,30 +73,16 @@ unsafe fn get_ddgame() -> *mut DDGame {
     (*wrapper_ptr).ddgame
 }
 
-/// Check if a pointer is safe to read.
-#[inline]
-pub unsafe fn can_read(ptr: u32, size: u32) -> bool {
-    ptr >= 0x10000 && IsBadReadPtr(ptr as *const u8, size) == 0
-}
-
 /// Dump a memory region as DWORDs with automatic classification.
 ///
-/// Each non-zero DWORD is classified as:
-/// - `[VTABLE]`  — points into .rdata (likely a vtable or function pointer table);
-///   also dereferences `vt[0]` if readable
-/// - `[CODE]`    — points into .text
-/// - `[DATA]`    — points into .data/.bss
-/// - `[OBJECT]`  — heap pointer whose first DWORD is a vtable; prints vtable address
-/// - `[ptr]`     — any other readable heap pointer; prints the dereferenced DWORD
-/// - `[small=N]` — value < 0x10000 (integer / enum / flag)
-/// - `[value]`   — anything else
-///
-/// # Parameters
-/// - `base_ptr`: start of the object to dump (e.g. `turngame as *const u8`)
-/// - `offset`: byte offset within `base_ptr` to start the dump
-/// - `size`: number of bytes to dump (must be a multiple of 4)
-/// - `struct_name`: used as the prefix in log lines (e.g. `"CTaskTurnGame"`)
+/// Uses `openwa_core::mem::classify_pointer` for pointer detection.
+/// See that module for the classification categories.
 pub unsafe fn dump_region(base_ptr: *const u8, offset: usize, size: usize, struct_name: &str) {
+    use openwa_core::address::va;
+    use openwa_core::mem;
+    use openwa_core::rebase::rb;
+    use openwa_debug_proto::PointerKind;
+
     let wa_base = rb(va::IMAGE_BASE);
     let delta = wa_base.wrapping_sub(va::IMAGE_BASE);
 
@@ -116,65 +98,48 @@ pub unsafe fn dump_region(base_ptr: *const u8, offset: usize, size: usize, struc
         let field_offset = offset + i * 4;
         let val = *(base_ptr.add(field_offset) as *const u32);
         if val == 0 {
-            continue; // Skip zeros to reduce noise
+            continue;
         }
 
-        let ghidra_val = val.wrapping_sub(delta);
-
-        // Check if value itself is in .rdata (direct vtable pointer)
-        if ghidra_val >= va::RDATA_START && ghidra_val < va::DATA_START {
-            if can_read(val, 4) {
-                let vt0 = *(val as *const u32);
-                let _ = log_line(&format!(
-                    "  +0x{:04X}: 0x{:08X} [VTABLE] g:0x{:08X} vt[0]=g:0x{:08X}",
-                    field_offset,
-                    val,
-                    ghidra_val,
-                    vt0.wrapping_sub(delta)
-                ));
-            } else {
-                let _ = log_line(&format!(
-                    "  +0x{:04X}: 0x{:08X} [VTABLE] g:0x{:08X} (unreadable)",
-                    field_offset, val, ghidra_val
-                ));
+        if let Some(info) = mem::classify_pointer(val, delta) {
+            let detail_str = info.detail.as_deref().unwrap_or("");
+            match info.kind {
+                PointerKind::Vtable => {
+                    let _ = log_line(&format!(
+                        "  +0x{:04X}: 0x{:08X} [VTABLE] g:0x{:08X} {}",
+                        field_offset, val, info.ghidra_value, detail_str
+                    ));
+                }
+                PointerKind::Code => {
+                    let _ = log_line(&format!(
+                        "  +0x{:04X}: 0x{:08X} [CODE] g:0x{:08X}",
+                        field_offset, val, info.ghidra_value
+                    ));
+                }
+                PointerKind::Data => {
+                    let _ = log_line(&format!(
+                        "  +0x{:04X}: 0x{:08X} [DATA] g:0x{:08X}",
+                        field_offset, val, info.ghidra_value
+                    ));
+                }
+                PointerKind::Object => {
+                    let _ = log_line(&format!(
+                        "  +0x{:04X}: 0x{:08X} [OBJECT] {}",
+                        field_offset, val, detail_str
+                    ));
+                }
+                PointerKind::Heap => {
+                    let _ = log_line(&format!(
+                        "  +0x{:04X}: 0x{:08X} [ptr] {}",
+                        field_offset, val, detail_str
+                    ));
+                }
             }
-        } else if ghidra_val >= va::TEXT_START && ghidra_val <= va::TEXT_END {
-            let _ = log_line(&format!(
-                "  +0x{:04X}: 0x{:08X} [CODE] g:0x{:08X}",
-                field_offset, val, ghidra_val
-            ));
-        } else if ghidra_val >= va::DATA_START && ghidra_val < 0x008C5000 {
-            let _ = log_line(&format!(
-                "  +0x{:04X}: 0x{:08X} [DATA] g:0x{:08X}",
-                field_offset, val, ghidra_val
-            ));
         } else if val < 0x10000 {
             let _ = log_line(&format!(
                 "  +0x{:04X}: 0x{:08X} [small={}]",
                 field_offset, val, val
             ));
-        } else if can_read(val, 4) {
-            // Heap pointer — safely read first DWORD to check for vtable
-            let first = *(val as *const u32);
-            let ghidra_first = first.wrapping_sub(delta);
-            if ghidra_first >= va::RDATA_START && ghidra_first < va::DATA_START {
-                // It's an object with a vtable!
-                let vt0_str = if can_read(first, 4) {
-                    let vt0 = *(first as *const u32);
-                    format!("vt[0]=g:0x{:08X}", vt0.wrapping_sub(delta))
-                } else {
-                    "vt[0]=?".to_string()
-                };
-                let _ = log_line(&format!(
-                    "  +0x{:04X}: 0x{:08X} [OBJECT] vtable=g:0x{:08X} {}",
-                    field_offset, val, ghidra_first, vt0_str
-                ));
-            } else {
-                let _ = log_line(&format!(
-                    "  +0x{:04X}: 0x{:08X} [ptr] *=0x{:08X}",
-                    field_offset, val, first
-                ));
-            }
         } else {
             let _ = log_line(&format!("  +0x{:04X}: 0x{:08X} [value]", field_offset, val));
         }