Merge pull request #205 from wcampbell0x2a/updates

Author: wcampbell0x2a

CHANGELOG.md

@@ -5,6 +5,13 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
+## [0.8.0] - 2025-12-15
+- Add `Source` improvements:
+  - Add `Source` display page
+  - Add `Source` highlight support for Rust, C, and C++ using [arborium](arborium.bearcove.eu)(treesitter).
+- Send child process stderr to null
+- Resolve info addresses with another symbol address lookup in `Symbol` page.
+- Poll slower when not expecting gdb response
 
 ## [0.7.0] - 2025-11-14
 - Hexdump memory mapping selection using `H` [#192](https://github.com/wcampbell0x2a/heretek/pull/192)

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "heretek"
-version = "0.7.0"
+version = "0.8.0"
 edition = "2024"
 description = "GDB TUI Dashboard for the understanding of vast knowledge"
 license = "MIT OR Apache-2.0"
@@ -23,6 +23,7 @@ once_cell = "1.20.2"
 ratatui = "0.29.0"
 regex = "1.11.1"
 tui-input = "0.14.0"
+arborium = { version = "2.1.1", features = ["lang-c", "lang-cpp", "lang-rust"] }
 
 [dev-dependencies]
 insta = "1.41.1"

Cargo.toml

@@ -31,19 +31,7 @@ Sleep 2s
 Type "si"
 Enter
 Sleep 2s
-Type "si"
-Enter
-Sleep 2s
-Type "si"
-Enter
-Sleep 2s
-Type "si"
-Enter
-Sleep 2s
-Type "si"
-Enter
-Sleep 2s
-Type "si"
+Type "finish"
 Enter
 Sleep 2s
 
@@ -97,3 +85,6 @@ Sleep 2s
 Enter
 Type "d"
 Sleep 2s
+Tab
+# Source
+Sleep 2s

docs/hexdump_section.gif

@@ -43,6 +43,9 @@ pub fn gdb_interact(gdb_stdout: BufReader<Box<dyn Read + Send>>, state: Arc<Mute
 }
 
 fn async_record_stopped(state: &mut State, kv: &HashMap<String, String>) {
+    // Execution has stopped, clear the executing flag for slower polling
+    state.executing = false;
+
     // in the case of a breakpoint, save the output
     // Either it's a breakpoint event, step, signal
     state.async_result.clear();
@@ -82,6 +85,8 @@ fn async_record_stopped(state: &mut State, kv: &HashMap<String, String>) {
     // Get endian
     state.next_write.push(r#"-interpreter-exec console "show endian""#.to_string());
     // TODO: We only need to do this once
+    // Get source language
+    state.next_write.push(r#"-interpreter-exec console "show language""#.to_string());
     state.next_write.push("-data-list-register-names".to_string());
     // When a breakpoint is hit, query for register values
     state.next_write.push("-data-list-register-values x".to_string());
@@ -95,6 +100,8 @@ fn async_record_stopped(state: &mut State, kv: &HashMap<String, String>) {
         debug!("Source location from stopped event: {fullname}:{line}");
 
         if let Ok(line_num) = line.parse::<u32>() {
+            let file_changed = state.current_source_file.as_ref() != Some(fullname);
+
             state.current_source_file = Some(fullname.clone());
             state.current_source_line = Some(line_num);
 
@@ -107,12 +114,18 @@ fn async_record_stopped(state: &mut State, kv: &HashMap<String, String>) {
                 warn!("Could not read source file: {fullname}");
                 state.source_lines.clear();
             }
+
+            if file_changed {
+                state.next_write.push(r#"-interpreter-exec console "show language""#.to_string());
+            }
         }
     } else if let (Some(file), Some(line)) = (kv.get("file"), kv.get("line")) {
         // Fallback to 'file' if 'fullname' is not available
         debug!("Source location from stopped event (fallback): {file}:{line}");
 
         if let Ok(line_num) = line.parse::<u32>() {
+            let file_changed = state.current_source_file.as_ref() != Some(file);
+
             state.current_source_file = Some(file.clone());
             state.current_source_line = Some(line_num);
 
@@ -125,6 +138,10 @@ fn async_record_stopped(state: &mut State, kv: &HashMap<String, String>) {
                 warn!("Could not read source file: {file}");
                 state.source_lines.clear();
             }
+
+            if file_changed {
+                state.next_write.push(r#"-interpreter-exec console "show language""#.to_string());
+            }
         }
     } else {
         debug!("No source location information in stopped event");

docs/main_section.gif

@@ -12,8 +12,9 @@ pub fn recv_exec_result_asm_insns(state: &mut State, asm: &String) {
     if let Written::AsmAtPc = last_written {
         state.asm = parse_asm_insns_values(asm).clone();
     }
-    if let Written::SymbolDisassembly(_name) = &last_written {
+    if let Written::SymbolDisassembly(name) = &last_written {
         state.symbol_asm = parse_asm_insns_values(asm).clone();
+        state.symbol_asm_name = name.clone();
     }
     if let Written::SymbolAtAddrRegister((base_reg, _n)) = &last_written {
         for RegisterStorage { name: _, register, deref } in &mut state.registers {

docs/vhs/readme.tape

@@ -29,6 +29,37 @@ pub fn stream_output(
         return;
     }
 
+    if s.starts_with("The current source language") {
+        let unescaped = s.replace(r#"\""#, "\"");
+
+        if let Some(is_idx) = unescaped.find(" is ") {
+            let after_is = &unescaped[is_idx + 4..];
+            if let Some(quote_start) = after_is.find('"') {
+                let after_quote = &after_is[quote_start + 1..];
+
+                let language = if let Some(currently_idx) = after_quote.find("currently ") {
+                    let lang_start = currently_idx + 10;
+                    let after_currently = &after_quote[lang_start..];
+                    let end_idx = after_currently
+                        .find('"')
+                        .or_else(|| after_currently.find('.'))
+                        .unwrap_or(after_currently.len());
+                    after_currently[..end_idx].trim()
+                } else {
+                    let end_idx = after_quote
+                        .find('"')
+                        .or_else(|| after_quote.find('.'))
+                        .unwrap_or(after_quote.len());
+                    after_quote[..end_idx].trim()
+                };
+
+                state.source_language = Some(language.to_string());
+                debug!("detected source language: {}", language);
+            }
+        }
+        return;
+    }
+
     // When using attach, assume the first symbols found are the text field
     // StreamOutput("~", "Reading symbols from /home/wcampbell/a.out...\n")
     if state.filepath.is_none() {
@@ -75,6 +106,24 @@ pub fn stream_output(
         return;
     }
 
+    if let Some(Written::SymbolAddressLookup(symbol_name)) = state.written.front() {
+        let symbol_name = symbol_name.clone();
+        if let Some(addr_start) = s.find(" at address ") {
+            let after_at = &s[addr_start + 12..];
+            let addr_end =
+                after_at.find('.').or_else(|| after_at.find(' ')).unwrap_or(after_at.len());
+            let addr_str = &after_at[..addr_end];
+            if let Some(hex_addr) = addr_str.strip_prefix("0x") {
+                if let Ok(address) = u64::from_str_radix(hex_addr, 16) {
+                    state.next_write.push(crate::mi::data_disassemble(address as usize, 500));
+                    state.written.pop_front();
+                    state.written.push_back(Written::SymbolDisassembly(symbol_name));
+                    return;
+                }
+            }
+        }
+    }
+
     let split: Vec<String> =
         s.split('\n').map(String::from).map(|a| a.trim_end().to_string()).collect();
     for s in split {
@@ -274,4 +323,24 @@ mod tests {
 
         assert_eq!(state.filepath, Some(PathBuf::from("/original/path"))); // should not change
     }
+
+    #[rstest]
+    #[case(r#"The current source language is \"auto; currently c\"."#, "c")]
+    #[case(r#"The current source language is \"auto; currently rust\"."#, "rust")]
+    #[case(r#"The current source language is \"auto; currently c++\"."#, "c++")]
+    #[case(r#"The current source language is \"c\"."#, "c")]
+    #[case(r#"The current source language is \"rust\"."#, "rust")]
+    #[case(r#"The current source language is \"c++\"."#, "c++")]
+    #[case(r#"The current source language is \"auto; currently c\".\n"#, "c")]
+    #[case(r#"The current source language is \"rust\".\n"#, "rust")]
+    fn test_stream_output_language_detection(#[case] input: &str, #[case] expected_lang: &str) {
+        let mut state = create_test_state();
+        let mut current_map = (None, String::new());
+        let mut current_symbols = String::new();
+
+        stream_output("~", input, &mut state, &mut current_map, &mut current_symbols);
+
+        assert_eq!(state.source_language, Some(expected_lang.to_string()));
+        assert_eq!(state.output.len(), 0); // should not be added to output
+    }
 }