Fix address bounds checking and metadata calculation for 64 KiB binaries

Prevent `u16` truncation when calculating end addresses or bounds
for full 64 KiB binaries where `len as u16` wrapped 65536 to 0.

- Simplify `AppState::is_external` to `addr.offset_from(self.origin) >= self.raw_data.len()`.
- Fix `FileInfo` end address calculation for 64 KiB binaries to correctly report `$FFFF`.
- Update analyzer routines (`promote_return_labels`, `follow_indirect_jumps`, `flow_analyze`) and HTML exporter to use canonical `AppState::is_external` checks.
- Fix end address calculation in D64 and CRT picker dialogs.
- Add test case verifying MCP address details on 64 KiB projects (#42).

Fixes #42

Author: ricardoquesada

crates/regenerator2000-core/src/analyzer.rs

@@ -374,8 +374,6 @@ fn analyze_instruction(
 fn promote_return_labels(state: &AppState, usage_map: &mut BTreeMap<Addr, UsageData>) {
     let origin = state.origin;
     let data = &state.raw_data;
-    let data_len = data.len();
-    let end_addr = origin.wrapping_add(data_len as u16);
 
     for (addr, (_types, _refs, first_type)) in usage_map.iter_mut() {
         // Only promote code-flow label types.
@@ -388,16 +386,11 @@ fn promote_return_labels(state: &AppState, usage_map: &mut BTreeMap<Addr, UsageD
         }
 
         // Only for internal addresses (we cannot inspect external bytes).
-        let is_internal = if origin < end_addr {
-            addr.0 >= origin.0 && addr.0 < end_addr.0
-        } else {
-            addr.0 >= origin.0 || addr.0 < end_addr.0
-        };
-        if !is_internal {
+        if state.is_external(*addr) {
             continue;
         }
 
-        let offset = addr.0.wrapping_sub(origin.0) as usize;
+        let offset = addr.offset_from(origin);
 
         // Target must be in a Code block.
         if state
@@ -452,7 +445,6 @@ fn follow_indirect_jumps(
     let data = &state.raw_data;
     let origin = state.origin;
     let data_len = data.len();
-    let end_addr = origin.wrapping_add(data_len as u16);
 
     let mut pc = 0;
     while pc < data_len {
@@ -491,17 +483,10 @@ fn follow_indirect_jumps(
         }
 
         let jmp_addr = origin.wrapping_add(pc as u16);
-        let pointer_addr: u16 = u16::from(data[pc + 2]) << 8 | u16::from(data[pc + 1]);
-
-        // Check if pointer_addr is inside our binary
-        let is_internal = if origin < end_addr {
-            pointer_addr >= origin.0 && pointer_addr < end_addr.0
-        } else {
-            pointer_addr >= origin.0 || pointer_addr < end_addr.0
-        };
+        let pointer_addr = Addr(u16::from(data[pc + 2]) << 8 | u16::from(data[pc + 1]));
 
-        if is_internal {
-            let ptr_offset = pointer_addr.wrapping_sub(origin.0) as usize;
+        if !state.is_external(pointer_addr) {
+            let ptr_offset = pointer_addr.offset_from(origin);
 
             // Check if the pointer location is an Address block
             let is_address_block = ptr_offset + 1 < data_len
@@ -552,19 +537,10 @@ pub fn flow_analyze(state: &AppState, start: Addr) -> Vec<std::ops::Range<usize>
 
     let origin = state.origin;
     let data_len = state.raw_data.len();
-    let end_addr = origin.wrapping_add(data_len as u16);
 
     let to_offset = |addr: Addr| -> Option<usize> {
-        let in_bounds = if origin < end_addr {
-            addr.0 >= origin.0 && addr.0 < end_addr.0
-        } else {
-            addr.0 >= origin.0 || addr.0 < end_addr.0
-        };
-        if in_bounds {
-            Some(addr.0.wrapping_sub(origin.0) as usize)
-        } else {
-            None
-        }
+        let offset = addr.offset_from(origin);
+        (offset < data_len).then_some(offset)
     };
 
     if let Some(offset) = to_offset(start) {

crates/regenerator2000-core/src/exporter/html.rs

@@ -257,8 +257,6 @@ pub fn export_html(state: &AppState, path: &PathBuf) -> Result<(), CoreError> {
                         && !refs.is_empty()
                         && state.settings.max_xref_count > 0
                     {
-                        let origin_val = state.origin.0;
-                        let size = state.raw_data.len() as u16;
                         let mut all_refs = refs.clone();
                         all_refs.sort_unstable();
                         all_refs.dedup();
@@ -268,7 +266,7 @@ pub fn export_html(state: &AppState, path: &PathBuf) -> Result<(), CoreError> {
                             .iter()
                             .take(max)
                             .map(|r| {
-                                if r.0 >= origin_val && r.0 < origin_val + size {
+                                if !state.is_external(*r) {
                                     format!("<a href=\"#L{:04X}\">${:04X}</a>", r.0, r.0)
                                 } else {
                                     format!("${:04X}", r.0)
@@ -350,9 +348,7 @@ pub fn export_html(state: &AppState, path: &PathBuf) -> Result<(), CoreError> {
         // 6. Instruction part
         let mut operand_str = line.operand.clone();
         if let Some(target) = line.target_address {
-            let origin_val = state.origin.0;
-            let size = state.raw_data.len() as u16;
-            if target.0 >= origin_val && target.0 < origin_val + size {
+            if !state.is_external(target) {
                 operand_str = format!("<a href=\"#L{:04X}\">{}</a>", target.0, line.operand);
             }
         } else {
@@ -364,10 +360,14 @@ pub fn export_html(state: &AppState, path: &PathBuf) -> Result<(), CoreError> {
                 } else {
                     if !current_word.is_empty() {
                         if let Some(addr) = label_name_to_addr.get(&current_word) {
-                            new_op.push_str(&format!(
-                                "<a href=\"#L{:04X}\">{}</a>",
-                                addr.0, current_word
-                            ));
+                            if !state.is_external(*addr) {
+                                new_op.push_str(&format!(
+                                    "<a href=\"#L{:04X}\">{}</a>",
+                                    addr.0, current_word
+                                ));
+                            } else {
+                                new_op.push_str(&current_word);
+                            }
                         } else {
                             new_op.push_str(&current_word);
                         }
@@ -378,10 +378,14 @@ pub fn export_html(state: &AppState, path: &PathBuf) -> Result<(), CoreError> {
             }
             if !current_word.is_empty() {
                 if let Some(addr) = label_name_to_addr.get(&current_word) {
-                    new_op.push_str(&format!(
-                        "<a href=\"#L{:04X}\">{}</a>",
-                        addr.0, current_word
-                    ));
+                    if !state.is_external(*addr) {
+                        new_op.push_str(&format!(
+                            "<a href=\"#L{:04X}\">{}</a>",
+                            addr.0, current_word
+                        ));
+                    } else {
+                        new_op.push_str(&current_word);
+                    }
                 } else {
                     new_op.push_str(&current_word);
                 }
@@ -400,16 +404,13 @@ pub fn export_html(state: &AppState, path: &PathBuf) -> Result<(), CoreError> {
         let mut comment_str = line.comment.clone();
         // Format x-refs in comments as hyperlinks if they are internal
         if comment_str.contains("x-ref:") {
-            let origin_val = state.origin.0;
-            let size = state.raw_data.len() as u16;
             let words: Vec<String> = comment_str
                 .split(' ')
                 .map(|w| {
                     if w.starts_with('$') {
                         let hex_str = w.trim_matches(|c| c == '$' || c == ',' || c == ';');
                         if let Ok(addr) = u16::from_str_radix(hex_str, 16)
-                            && addr >= origin_val
-                            && addr < origin_val + size
+                            && !state.is_external(crate::state::Addr(addr))
                         {
                             return format!("<a href=\"#L{:04X}\">${:04X}</a>", addr, addr)
                                 + if w.ends_with(',') { "," } else { "" };

crates/regenerator2000-core/src/state/app_state.rs

@@ -262,16 +262,7 @@ impl AppState {
 
     #[must_use]
     pub fn is_external(&self, addr: Addr) -> bool {
-        let len = self.raw_data.len();
-        if len == 0 {
-            return true;
-        }
-        let end = self.origin.wrapping_add(len as u16);
-        if self.origin < end {
-            addr < self.origin || addr >= end
-        } else {
-            !(addr >= self.origin || addr < end)
-        }
+        addr.offset_from(self.origin) >= self.raw_data.len()
     }
 
     #[must_use]
@@ -298,7 +289,7 @@ impl AppState {
         let end_addr = if size == 0 {
             start_addr
         } else {
-            Addr(start_addr.0.saturating_add(size as u16).saturating_sub(1))
+            start_addr.wrapping_add(size.saturating_sub(1) as u16)
         };
 
         let mut mem = vec![0u8; 0x10000];
@@ -312,7 +303,10 @@ impl AppState {
         let packer = crate::packers::detect_packer(
             &mem,
             start_addr.0,
-            load_start.saturating_add(size) as u16,
+            (load_start
+                .saturating_add(size)
+                .min(0x10000)
+                .saturating_sub(1)) as u16,
         );
 
         let (is_packed, packer_name, entry_point) = if let Some(ref p) = packer {
@@ -615,4 +609,25 @@ mod tests {
         assert_eq!(info.entry_point, Some(Addr(2061)));
         assert!(!info.is_packed);
     }
+
+    #[test]
+    fn test_file_info_full_64k() {
+        let mut app_state = AppState::new();
+        app_state.origin = Addr(0x0000);
+        app_state.raw_data = vec![0xEA; 65536];
+        let info = app_state.file_info();
+        assert_eq!(info.start_addr, Addr(0x0000));
+        assert_eq!(info.end_addr, Addr(0xFFFF));
+        assert_eq!(info.size, 65536);
+    }
+
+    #[test]
+    fn test_is_external_full_64k() {
+        let mut app_state = AppState::new();
+        app_state.origin = Addr(0x0000);
+        app_state.raw_data = vec![0xEA; 65536];
+        assert!(!app_state.is_external(Addr(0x0000)));
+        assert!(!app_state.is_external(Addr(0x0810)));
+        assert!(!app_state.is_external(Addr(0xFFFF)));
+    }
 }

crates/regenerator2000-tui/src/ui/dialog_crt_picker.rs

@@ -88,7 +88,7 @@ impl Widget for CrtBankPickerDialog {
             .map(|picker_entry| {
                 let chip = &picker_entry.chip;
                 let start = chip.load_address;
-                let end = start.wrapping_add(chip.data.len() as u16).wrapping_sub(1);
+                let end = start.wrapping_add(chip.data.len().saturating_sub(1) as u16);
 
                 let addr_str = format!("${start:04X}-${end:04X}");
                 let entropy_str = format!("{:>5.2}", picker_entry.entropy);

crates/regenerator2000-tui/src/ui/dialog_d64_picker.rs

@@ -53,8 +53,7 @@ impl D64FilePickerDialog {
                         end_addr = Some(
                             prg_data
                                 .origin
-                                .wrapping_add(prg_data.raw_data.len() as u16)
-                                .wrapping_sub(1),
+                                .wrapping_add(prg_data.raw_data.len().saturating_sub(1) as u16),
                         );
                         entropy = Some(crate::utils::calculate_entropy(&prg_data.raw_data));
                     }

tests/mcp_address_details_test.rs

@@ -153,4 +153,53 @@ mod tests {
             assert!(refs.iter().any(|v| v.as_u64() == Some(0x1005)));
         }
     }
+
+    #[test]
+    fn test_address_details_full_64k() {
+        let mut app_state = AppState::default();
+        app_state.system_config.default_is_unexplored = false;
+        let origin = regenerator2000_core::state::Addr(0x0000);
+        let mut data = vec![0u8; 65536];
+        // At $0810 (2064):
+        // LDA #$1B (A9 1B)
+        // STA $D011 (8D 11 D0)
+        // LDA #$00 (A9 00)
+        // STA $D020 (8D 20 D0)
+        // JSR $FFD2 (20 D2 FF)
+        // RTS (60)
+        data[0x0810..0x081E].copy_from_slice(&[
+            0xA9, 0x1B, 0x8D, 0x11, 0xD0, 0xA9, 0x00, 0x8D, 0x20, 0xD0, 0x20, 0xD2, 0xFF, 0x60,
+        ]);
+        app_state.load_binary(origin, data).unwrap();
+
+        let mut ui_state = UIState::new(Theme::default());
+
+        let details = call_tool(
+            &mut app_state,
+            &mut ui_state,
+            "r2000_get_address_details",
+            json!({ "address": 2064 }),
+        );
+
+        assert_eq!(details["address"], 2064);
+        assert_eq!(details["type"], "Code");
+        assert_eq!(details["instruction"]["mnemonic"], "LDA");
+
+        // First address ($0000) and last address ($FFFF) should also be valid details
+        let details_first = call_tool(
+            &mut app_state,
+            &mut ui_state,
+            "r2000_get_address_details",
+            json!({ "address": 0 }),
+        );
+        assert_eq!(details_first["address"], 0);
+
+        let details_last = call_tool(
+            &mut app_state,
+            &mut ui_state,
+            "r2000_get_address_details",
+            json!({ "address": 0xFFFF }),
+        );
+        assert_eq!(details_last["address"], 0xFFFF);
+    }
 }