Skip to content

Ghidrust provides a hyper fast, AI native reverse engineering platform built in Rust, inspired by Ghidra. Includes experimental GPU kernels to rapidly decompile large files, a decryption suite, and network monitor for packet to binary reverse engineering.

9.8 KB
Raw Blame
//! Program edits — rename/retype/comment/signature/types + dialog openers.
//!
//! Extracted per demonolith Wave 6.

use super::{NewTypeKind, GhidrustApp};
use crate::events::{GhidrustEvent, MutationKind};
use ghidrust_core::CommentKind;

impl GhidrustApp {

    /// Rename the symbol / function at `va` (persists into `Program::edits`).
    ///
    /// Also mirrors the rename into `Program::analysis.functions[i].name()` so
    /// every downstream pane (Symbol Tree, Functions Window, Symbol Table,
    /// Bookmarks label preview) sees the new name without a full re-analyze.
    /// Emits a `ProgramMutated::Rename` event which invalidates the Decompiler
    /// cache so the header string is rebuilt.
    pub(crate) fn rename_at(&mut self, va: u64, new_name: impl Into<String>) -> Result<(), String> {
        let new_name = new_name.into();
        if new_name.trim().is_empty() {
            return Err("empty name".into());
        }
        let prog = self
            .program
            .as_mut()
            .ok_or_else(|| "no program loaded".to_string())?;
        // Mirror into analysis so tables / listing / decomp header pick it up.
        if let Some(f) = prog.function_at_mut(va) {
            f.name = new_name.clone();
        } else if let Some(s) = prog.analysis.symbols.iter_mut().find(|s| s.va == va) {
            s.name = new_name.clone();
        }
        // Persist as an edit even if analysis had no matching entry.
        prog.edits.set_rename(va, &new_name);
        self.event_bus.publish(GhidrustEvent::ProgramMutated {
            kind: MutationKind::Rename {
                va,
                new_name: new_name.clone(),
            },
        });
        self.status = format!("Renamed {va:#x} → {new_name}");
        self.log(self.status.clone());
        Ok(())
    }

    /// Retype the variable / global at `va` (persists into `Program::edits`).
    pub(crate) fn retype_at(&mut self, va: u64, type_desc: impl Into<String>) -> Result<(), String> {
        let type_desc = type_desc.into();
        let prog = self
            .program
            .as_mut()
            .ok_or_else(|| "no program loaded".to_string())?;
        prog.edits.set_retype(va, &type_desc);
        self.event_bus.publish(GhidrustEvent::ProgramMutated {
            kind: MutationKind::Retype {
                va,
                type_desc: type_desc.clone(),
            },
        });
        self.status = format!("Retyped {va:#x} → {type_desc}");
        self.log(self.status.clone());
        Ok(())
    }

    /// Set (or clear) a comment at `va` (persists into `Program::edits`).
    pub(crate) fn set_comment_at(
        &mut self,
        va: u64,
        kind: CommentKind,
        text: impl Into<String>,
    ) -> Result<(), String> {
        let text = text.into();
        let prog = self
            .program
            .as_mut()
            .ok_or_else(|| "no program loaded".to_string())?;
        prog.edits.set_comment(va, kind, &text);
        self.event_bus.publish(GhidrustEvent::ProgramMutated {
            kind: MutationKind::CommentChanged { va },
        });
        self.status = if text.is_empty() {
            format!("Cleared {} comment at {va:#x}", kind.label())
        } else {
            format!("Set {} comment at {va:#x}", kind.label())
        };
        self.log(self.status.clone());
        Ok(())
    }

    /// Set / replace a function signature (Edit Function Signature dialog).
    pub(crate) fn set_function_signature(
        &mut self,
        entry: u64,
        signature: impl Into<String>,
    ) -> Result<(), String> {
        let signature = signature.into();
        let prog = self
            .program
            .as_mut()
            .ok_or_else(|| "no program loaded".to_string())?;
        let mut sig = prog
            .edits
            .function_signature(entry)
            .cloned()
            .unwrap_or_default();
        sig.signature = signature.clone();
        prog.edits.set_function_signature(entry, sig);
        self.event_bus.publish(GhidrustEvent::ProgramMutated {
            kind: MutationKind::Retype {
                va: entry,
                type_desc: signature.clone(),
            },
        });
        self.status = format!("Function signature @ {entry:#x} → {signature}");
        self.log(self.status.clone());
        Ok(())
    }

    /// Listing → Apply Data Type at `va` (drag from DTM, or `T` key).
    pub(crate) fn apply_type_at(&mut self, va: u64, type_name: impl Into<String>) -> Result<(), String> {
        let type_name = type_name.into();
        let prog = self
            .program
            .as_mut()
            .ok_or_else(|| "no program loaded".to_string())?;
        prog.edits.set_applied_type(va, &type_name);
        self.event_bus.publish(GhidrustEvent::ProgramMutated {
            kind: MutationKind::Retype {
                va,
                type_desc: type_name.clone(),
            },
        });
        self.status = format!("Applied type {type_name} @ {va:#x}");
        self.log(self.status.clone());
        Ok(())
    }

    /// DTM → Rename an existing user type (`Rename` on a Data Type
    /// leaf). Rewrites `applied_types` so Listing decorations stay in sync.
    #[cfg(test)]
    pub(crate) fn rename_user_type(
        &mut self,
        old: impl Into<String>,
        new: impl Into<String>,
    ) -> Result<(), String> {
        let old = old.into();
        let new = new.into();
        if new.trim().is_empty() {
            return Err("empty type name".into());
        }
        let prog = self
            .program
            .as_mut()
            .ok_or_else(|| "no program loaded".to_string())?;
        if !prog.edits.rename_user_type(&old, &new) {
            return Err(format!("no type named {old}"));
        }
        self.event_bus.publish(GhidrustEvent::ProgramMutated {
            kind: MutationKind::Retype {
                va: 0,
                type_desc: format!("rename type: {old} → {new}"),
            },
        });
        self.status = format!("Renamed type {old} → {new}");
        self.log(self.status.clone());
        Ok(())
    }

    /// DTM → Delete a user type (also unlinks any `Applied` decorations).
    pub(crate) fn delete_user_type(&mut self, name: &str) -> Result<(), String> {
        let prog = self
            .program
            .as_mut()
            .ok_or_else(|| "no program loaded".to_string())?;
        if !prog.edits.delete_user_type(name) {
            return Err(format!("no type named {name}"));
        }
        self.event_bus.publish(GhidrustEvent::ProgramMutated {
            kind: MutationKind::Retype {
                va: 0,
                type_desc: format!("deleted type: {name}"),
            },
        });
        self.status = format!("Deleted type {name}");
        self.log(self.status.clone());
        Ok(())
    }

    pub(crate) fn open_rename_dialog(&mut self, va: u64) {
        let old = self
            .program
            .as_ref()
            .and_then(|p| p.display_name_at(va))
            .map(|s| s.to_string())
            .unwrap_or_default();
        self.show_rename_dialog = true;
        self.rename_dialog_target_va = Some(va);
        self.rename_dialog_old_name = old.clone();
        self.rename_dialog_new_name = old;
    }

    pub(crate) fn open_retype_dialog(&mut self, va: u64) {
        let cur = self
            .program
            .as_ref()
            .and_then(|p| p.edits.retype_at(va))
            .unwrap_or_default()
            .to_string();
        self.show_retype_dialog = true;
        self.retype_dialog_target_va = Some(va);
        self.retype_dialog_type = cur;
    }

    pub(crate) fn open_comment_dialog(&mut self, va: u64, kind: CommentKind) {
        let text = self
            .program
            .as_ref()
            .and_then(|p| p.edits.comment_at(va, kind))
            .unwrap_or_default()
            .to_string();
        self.show_comment_dialog = true;
        self.comment_dialog_target_va = Some(va);
        self.comment_dialog_kind = kind;
        self.comment_dialog_text = text;
    }

    pub(crate) fn open_signature_dialog(&mut self, entry: u64) {
        let existing = self
            .program
            .as_ref()
            .and_then(|p| p.edits.function_signature(entry))
            .map(|s| s.signature.clone())
            .unwrap_or_else(|| {
                self.program
                    .as_ref()
                    .and_then(|p| p.function_at(entry))
                    .map(|f| {
                        format!(
                            "undefined {}({})",
                            f.name,
                            if f.parameters.is_empty() {
                                "void".to_string()
                            } else {
                                f.parameters.join(", ")
                            }
                        )
                    })
                    .unwrap_or_default()
            });
        self.show_fn_signature_dialog = true;
        self.fn_signature_dialog_entry = Some(entry);
        self.fn_signature_dialog_text = existing;
    }

    pub(crate) fn open_new_type_dialog(&mut self, kind: NewTypeKind) {
        self.show_new_type_dialog = true;
        self.new_type_dialog_kind = kind;
        self.new_type_dialog_name.clear();
        self.new_type_dialog_body = kind.template().to_string();
    }

    pub(crate) fn open_edit_type_dialog(&mut self, name: &str) {
        let body = self
            .program
            .as_ref()
            .and_then(|p| p.edits.user_type(name))
            .unwrap_or_default()
            .to_string();
        self.show_edit_type_dialog = true;
        self.edit_type_dialog_orig_name = name.to_string();
        self.edit_type_dialog_name = name.to_string();
        self.edit_type_dialog_body = body;
    }

    pub(crate) fn open_type_chooser(&mut self, va: Option<u64>) {
        self.show_type_chooser_dialog = true;
        self.type_chooser_target_va = va;
        self.type_chooser_filter.clear();
    }
}