Mini-Terminal-Hex-Editor mit Basisnavigation

Ein einfacher Terminal-Hex-Editor in Rust mit Basisnavigation, dynamischer Anzeige und nicht blockierender Tastatureingabe für Binärdateien.

Kurze Einführung

Mini-Terminal-Hex-Editor mit Basisnavigation (rust)
BESCHREIBUNG:
Ein einfacher Terminal-Hex-Editor in Rust, der das Laden einer Binärdatei, die Anzeige ihres Inhalts im Hex- und ASCII-Format, die Navigation zwischen Bytes mit den Pfeiltasten und die Bearbeitung der Hex-Werte ermöglicht. Das Programm verarbeitet Tastatureingaben nicht blockierend und aktualisiert die Anzeige dynamisch.

WEITERE HINWEISE:
Dieser Editor ist ein minimalistisches Lehrbeispiel, geeignet für Dateien mittlerer Größe. Er implementiert keine Dateispeicherung, zeigt aber, wie man binäre Daten im Speicher navigiert und bearbeitet. Er kann mit Funktionen zum Speichern, Suchen und erweiterter Dateiverwaltung erweitert werden.

ERKLÄRUNGEN:
- Verwendung von 'crossterm' zur Handhabung der Tastatureingabe im Raw-Modus und zur Steuerung des Terminals (Bildschirm löschen, Cursorposition).
- Die Hauptstruktur hält einen Byte-Puffer, die Cursorposition (Offset und hoher/niedriger Nibble) und aktualisiert die Anzeige bei jeder Eingabe.
- Die Anzeige zeigt 16 Bytes pro Zeile mit hexadezimaler und ASCII-Darstellung nebeneinander.
- Die Navigation mit den Pfeiltasten bewegt den Cursor zwischen den Bytes, und die Bearbeitung erfolgt durch Eingabe hexadezimaler Ziffern (0-9, a-f).
- Das Programm beendet sich durch Drücken von 'q'.

Beispielcode: rust

use anyhow::Result;
use crossterm::event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode, KeyEvent};
use crossterm::execute;
use crossterm::terminal::{disable_raw_mode, enable_raw_mode, Clear, ClearType};
use crossterm::{cursor, style};
use std::env;
use std::fs;
use std::io::{self, stdout, Write};

/// Minimaler Hex-Editor mit Navigation und Bearbeitung im Terminal
struct HexEditor {
    buffer: Vec<u8>,      // Geladener Datenpuffer
    cursor_pos: usize,    // Aktuelle Cursorposition im Puffer
    high_nibble: bool,    // Wenn true, wird das hohe Nibble des Bytes bearbeitet, sonst das niedrige
}

impl HexEditor {
    /// Erstellt einen neuen Editor mit Anfangsdaten
    fn new(data: Vec<u8>) -> Self {
        HexEditor {
            buffer: data,
            cursor_pos: 0,
            high_nibble: true,
        }
    }

    /// Zeichnet den Pufferinhalt im Terminal
    fn draw(&self) -> Result<()> {
        let mut stdout = stdout();
        execute!(stdout, cursor::MoveTo(0, 0), Clear(ClearType::All))?;

        let bytes_per_line = 16;
        let lines = (self.buffer.len() + bytes_per_line - 1) / bytes_per_line;

        for line in 0..lines {
            let start = line * bytes_per_line;
            let end = usize::min(start + bytes_per_line, self.buffer.len());

            // Offset-Adresse
            write!(stdout, "{:08X}: ", start)?;

            // Hex-Teil
            for i in start..end {
                if i == self.cursor_pos {
                    // Hebt das aktuelle Byte hervor
                    if self.high_nibble {
                        // Hebt das hohe Nibble hervor
                        let byte = self.buffer[i];
                        let high = byte >> 4;
                        let low = byte & 0x0F;
                        write!(stdout, "{}", style::SetAttribute(style::Attribute::Reverse))?;
                        write!(stdout, "{:X}", high)?;
                        write!(stdout, "{}", style::SetAttribute(style::Attribute::NoReverse))?;
                        write!(stdout, "{:X} ", low)?;
                    } else {
                        // Hebt das niedrige Nibble hervor
                        let byte = self.buffer[i];
                        let high = byte >> 4;
                        let low = byte & 0x0F;
                        write!(stdout, "{:X}", high)?;
                        write!(stdout, "{}", style::SetAttribute(style::Attribute::Reverse))?;
                        write!(stdout, "{:X}", low)?;
                        write!(stdout, "{} ", style::SetAttribute(style::Attribute::NoReverse))?;
                    }
                } else {
                    write!(stdout, "{:02X} ", self.buffer[i])?;
                }
            }

            // Auffüllung für unvollständige Zeilen
            for _ in end..start + bytes_per_line {
                write!(stdout, "   ")?;
            }

            // ASCII-Teil
            write!(stdout, "|")?;
            for i in start..end {
                let c = self.buffer[i];
                let ch = if c.is_ascii_graphic() || c == b' ' { c as char } else { '.' };
                if i == self.cursor_pos {
                    write!(stdout, "{}{}{}", style::SetAttribute(style::Attribute::Reverse), ch, style::SetAttribute(style::Attribute::NoReverse))?;
                } else {
                    write!(stdout, "{}", ch)?;
                }
            }
            writeln!(stdout, "|")?;
        }

        writeln!(stdout, "\nBefehle: Pfeile zum Bewegen des Cursors, 0-9 a-f zum Bearbeiten, q zum Beenden")?;
        stdout.flush()?;
        Ok(())
    }

    /// Verarbeitet ein Tastatureingabe-Ereignis
    fn handle_event(&mut self, event: Event) -> bool {
        if let Event::Key(KeyEvent { code, .. }) = event {
            match code {
                KeyCode::Char('q') => return false, // Beenden
                KeyCode::Left => {
                    if self.cursor_pos > 0 {
                        self.cursor_pos -= 1;
                        self.high_nibble = true;
                    }
                }
                KeyCode::Right => {
                    if self.cursor_pos + 1 < self.buffer.len() {
                        self.cursor_pos += 1;
                        self.high_nibble = true;
                    }
                }
                KeyCode::Up => {
                    let bytes_per_line = 16;
                    if self.cursor_pos >= bytes_per_line {
                        self.cursor_pos -= bytes_per_line;
                        self.high_nibble = true;
                    }
                }
                KeyCode::Down => {
                    let bytes_per_line = 16;
                    if self.cursor_pos + bytes_per_line < self.buffer.len() {
                        self.cursor_pos += bytes_per_line;
                        self.high_nibble = true;
                    }
                }
                KeyCode::Char(c) => {
                    // Ändert das aktuelle Nibble, wenn hexadezimale Zeichen
                    if let Some(val) = c.to_digit(16) {
                        let byte = self.buffer[self.cursor_pos];
                        let new_byte = if self.high_nibble {
                            ((val as u8) << 4) | (byte & 0x0F)
                        } else {
                            (byte & 0xF0) | (val as u8)
                        };
                        self.buffer[self.cursor_pos] = new_byte;

                        // Nach Änderung zum niedrigen Nibble oder zum nächsten Byte wechseln
                        if self.high_nibble {
                            self.high_nibble = false;
                        } else {
                            self.high_nibble = true;
                            if self.cursor_pos + 1 < self.buffer.len() {
                                self.cursor_pos += 1;
                            }
                        }
                    }
                }
                _ => {}
            }
        }
        true
    }
}

fn main() -> Result<()> {
    // Liest Dateinamen aus Argument
    let args: Vec<String> = env::args().collect();
    if args.len() != 2 {
        eprintln!("Verwendung: {} <binärdatei>", args[0]);
        std::process::exit(1);
    }

    let filename = &args[1];
    let data = fs::read(filename)?;

    let mut editor = HexEditor::new(data);

    enable_raw_mode()?;
    let mut stdout = stdout();
    execute!(stdout, EnableMouseCapture, cursor::Hide)?;

    editor.draw()?;

    // Haupt-Eingabeschleife
    loop {
        if event::poll(std::time::Duration::from_millis(500))? {
            let ev = event::read()?;
            if !editor.handle_event(ev) {
                break;
            }
            editor.draw()?;
        }
    }

    // Terminal wiederherstellen
    disable_raw_mode()?;
    execute!(stdout, DisableMouseCapture, cursor::Show, cursor::MoveTo(0, 0), Clear(ClearType::All))?;

    Ok(())
}
×
×
×
Möchtest du die Antwort neu generieren?
×
Chat exportieren
Exportformat wählen
Generazione PDF in corso…
Allegati
×
Du bist dabei, den Chat zu schließen und zum Bildgenerator zu wechseln. Wenn du nicht eingeloggt bist, wirst du unseren Chat verlieren. Bestätigst du?
Du siehst einen geteilten Chat im temporären Modus. Er wird nicht gespeichert.
×
Gespeicherte Prompts
×
Private Notiz
×
Bezeichnung
×
In allen Chats suchen
×
Deine Erkenntnisse
Analyse läuft…
×
KI-Einstellungen
Name des Assistenten 30
Länge der Antworten
KI-Modell
Strukturierte Antworten
Beispiele einbeziehen
Emojis verwenden
Führe mich, löse nicht Hinweise und Fragen statt fertiger Lösung
Mehr Einstellungen →
×
Diesen Chat teilen
Wer diesen Link öffnet, kann den Chat ansehen oder ihn als eigenen Chat zum Profil hinzufügen.
Achtung: Auch die Anhänge des Chats werden geteilt. Wer ihn hinzufügt, erhält eine Kopie der Dateien im eigenen Ordner.
Geteilter Chat
Jemand hat einen Chat mit dir geteilt. Möchtest du ihn nur ansehen oder zu deinen Chats hinzufügen?
Achtung: Auch die Anhänge des Chats werden geteilt. Wer ihn hinzufügt, erhält eine Kopie der Dateien im eigenen Ordner.
×

Gespeicherte Nachrichten

Wird geladen...

×

Chat-Verlauf

beispiel-programme · CHAT-VERLAUF

Wird geladen...

KI-Einstellungen

×
  • BasisSchnelle und einfache Antworten zum Lernen
  • MittelHöhere Qualität für Studium und Programmierung
  • FortgeschrittenKomplexes Denken und detaillierte Analysen
Schritte erklären

Was wird benötigt?

Software:
  • Rust 1.60+
  • Crate 'crossterm' für Terminal-Ein-/Ausgabe und Cursorsteuerung
  • Crate 'anyhow' für Fehlerbehandlung
  • Cargo.toml-Konfiguration mit Abhängigkeiten: crossterm = "0.25", anyhow = "1.0"
Hardware:
  • PC oder Umgebung mit ANSI-kompatiblem Terminal
  • Keine externe Hardware erforderlich
Terminal-Konfiguration:
  • Terminal muss ANSI-Sequenzen für Farben und Cursorbewegung unterstützen
  • Raw-Modus für nicht blockierende, echo-freie Eingabe

Ähnliche Themen

Kommandozeilenrechner mit Fehlerbehandlung
Ein einfacher Kommandozeilenrechner in Rust mit robuster Fehlerbehandlung für grundlegende arithmetische Operationen und klare Benutzerfeedbacks.
Todo-Liste im Speicher mit Speicherung in JSON-Datei
Rust-Programm zur Verwaltung einer Todo-Liste im Speicher mit Speicherung in einer JSON-Datei. Aufgaben hinzufügen, entfernen und anzeigen mit Persistenz.
Mini-Telefonbuch im CSV-Format gespeichert
Ein einfaches Rust-Programm zum Verwalten von Telefonbuchkontakten im CSV-Format mit Hinzufügen, Anzeigen und Speichern in rubrica.csv.
Temperaturumwandler mit interaktivem Eingabefeld
Ein Rust-Programm zur interaktiven Umwandlung von Celsius in Fahrenheit mit Tastatureingabe und Ausgabe im Terminal, inklusive Fehlerbehandlung und Formatierung
Zufälliger Passwortgenerator mit Basisoptionen
Ein einfaches Rust-Programm zur Generierung zufälliger Passwörter mit Optionen für Großbuchstaben, Zahlen und Symbole. Ideal für Rust-Anfänger.
Mini-Multiple-Choice-Quiz im Terminal
Ein einfaches Rust-Terminalquiz mit Multiple-Choice-Fragen zur Interaktion und Eingabeverarbeitung, ideal für Anfänger im Programmieren.
Würfelwurf-Simulator mit Statistik
Rust-Programm simuliert Würfelwürfe mit Statistik. Benutzer gibt Anzahl der Würfe ein, Programm zeigt Häufigkeit und Prozent jeder Seite an.
Dezimalzahl-Konverter in Binär- und Hexadezimaldarstellung
Rust-Programm zur Umwandlung von Dezimalzahlen in Binär- und Hexadezimaldarstellung mit Eingabevalidierung und Standardbibliothek ohne externe Abhängigkeiten.