Unter Vernachlässigung des Dateientyps Dateien editieren!

[qubeus]

Hallo

Also ich versuche seit einigen Tagen ein paar Files zu editieren und zwar so, als wenn ich den Datentyp nicht weiß...

Bisher habe ich immer FileToString verwendet, wenn ich eine Datei editieren wollte! Was auch immer super geklappt hat, wenn es sich um Dateientypen gehandelt hat, die irgendwas mit Texten zu tun haben

Nun will ich aber Beispielsweise einfach beliebig mit verschiedenen Dateien rumwerkeln, so wie man es aus einem Hexeditior kennt, dem es egal ist, was für einen Dateientyp er öffnet!!!

Ich will also so eine Art Byte-Array haben, dass ich verändern und dann ganz normal wieder als Datei abspeichern kann...

Die Möglichkeit einen Stream zu benutzen hat mir aber garnicht gefallen, auch wenn man mir versichert hat, dass man damit unabhängig von Dateientypen arbeiten kann...

Ich möchte ganz einfach eine Datei in ein Array mit Bytes umwandeln, so dass ich ganz einfach z.B. Byte 5 und Byte 15 tauschen kann in dem ich schreibe:

Delphi-Quellcode:

//Also erst wurde die Datei in das Array x geladen

//Nun wird x verändert
a:=x[15];
x[15]:=x[5];
x[5]:=a;

//x wird wieder in die Datei gespeichert

...ohne, dass ich irgend einen anderen Schnickschnack brauche....

...falls mir wirklich jemand eine gute Lösung dazu geben kann, dann würde ich mich noch sehr darüber freuen, wenn ich damit z.B. einzelne Bytes in den Typ Char umwandelnkönnte, falls es dazu kommen sollte, dass ich doch mal eine Text-Datei öffne... z.B. gibt es bei Texteditioren oft noch einen extra Bereich, wo dann nochmal der Hexcode als Satzzeichen steht...

Ich würde mich wirklich riesig freuen über eine Hilfe... sitze schon einige Tage daran und habe leider hier im Forum nichts gefunden... falls ich hier irgendwas ganz falsch beschrieben habe... z.B. dass man ein Byte in einen Buchstaben umwandeln kann oder sowas, dann sagt mir das bitte!!!

Vielen Dank schonmal, dass ihr mein Problem gelesen habt

Info: Ich benutze Delphi5

[Apollonius]

Arbeite doch mit einem File of Byte. (Falls du nicht weißt, wie das geht: klick).

[sirius]

Warum willst du nicht mit FileStream arbeiten? Wäre doch viel einfacher.

1. Umwandeln von Byte in Char und umgekehrt geht mit "ord" bzw "chr"

2. ganz simpel

Delphi-Quellcode:

var f:file of byte
    x:array of byte;
    i:integer;


//laden
  assignfile(f,'xyz.dat');
  reset(f);
  setlength(x,filesize(f));
  for i:=0 to high(x) do read(f,x[i]);
  closefile(f);

//arbeiten mit deinem array

//speichern 
  assignfile(f,'xyz.dat');
  rewrite(f);
  for i:=0 to high(x) do write(f,x[i]);
  closefile(f);

end;

Edit: untypisierte Dateien könnten schneller gehen (aber hier bin ich mir nicht sicher, oder anders gesagt: ungetestet)

Delphi-Quellcode:

var f:file;
    gelesen:integer;

//laden
  assignfile(f,'xyz.dat');
  reset(f,128);
  setlength(x,filesize(f)*128);
  blockread(f,x[0],length(x),gelesen);
  setlength(x,gelesen);
  closefile(f);


//speichern dann eben ähnlich nur mit blockwrite

Edit2: Na hab ich mir doch gedacht (bei filesize sollte man aufpassen)

[inherited]

Was gefällt dir an Streams nicht? Damit lädst du eine Datei Byteweise in ein Array, wandelst sie in Chars um und fügst sie einem Memotext hinzu:

Delphi-Quellcode:

var fs: TFileStream;
  MyArray: Array of Byte;
  i: Integer;
begin
  fs:=TFileStream.Create('C:\boot.ini', fmOpenRead);
  try
    SetLength(MyArray, fs.Size);
    fs.Read(MyArray[0], fs.Size);
    for i := 0 to High(MyArray) do
    begin
      Memo1.text:=Memo1.Text+Char(MyArray[i]);
    end;
  finally
    fs.Free;
  end;
end;

[qubeus]

Ok ich probiere eure Vorschläge mal aus... danke euch

[shmia]

Delphi hat glücklicherweise einen Stringtyp, der keine Probleme mit Hex-0 ($00) hat.
Deshalb kann man (sollte man) auch binäre Daten in einem Ansistring speichern.
Das hat folgende Vorteile:
* Ansistrings können dynamisch angelegt werden und werden von Delphi durch Compiler-Magik automatisch
entsorgt.
* ob man Textdateien lädt oder binäre Dateien ist egal; man verwendet die gleiche Technik
* ein String trägt seine Länge in sich - man braucht keine zusätzliche Längenvariable
Beispiel:

Delphi-Quellcode:

var
   s : Ansistring;
   a : char;
begin
   s := FileToString('C:\datei.xyz');  // Datei komplett laden
   // zwei Bytes tauschen
   a := s[16];
   s[16] := s[6];
   s[6] := a;
   // direkt 2 Bytes setzen
   s[1] := chr(200);
   s[2] := chr($A2); // man kann auch hexadezimale Konstanten angeben
   StringToFile('C:\datei.xyz', s); // veränderten String speichern
end;

FileToString() und StringTofile() gibt es hier: http://www.delphipraxis.net/internal...=665975#665975
Falls man nur Teile der Datei laden und verändern möchte, kann man diese Funktionen um die Parameter Position und Laenge erweitern.

Die Alternative mit Assignfile, read, write, ... ist eine veraltete Technik aus der Anfangszeit von Pascal.

[sirius]

@Shmia: Wobei wir dann wieder bei der Frage wären: FileStream oder nicht Filestream ?

[shmia]

Zitat von sirius:

@Shmia: Wobei wir dann wieder bei der Frage wären: FileStream oder nicht Filestream ?

Natürlich FileStream, nichts anderes!
Prof. N. Wirth (Erfinder von Pascal) hat damals den Fehler gemacht, Funktionen für Datei Ein-/Ausgabe direkt in die Sprache Pascal zu integrieren.
Eine universelle Prog.sprache sollte aber diese Aufgabe der Laufzeitbibliothek überlassen (wie es z.B. bei C/C++ der Fall ist).
Begründg.: der Compiler sollte schlank aber universell sein. Datei Ein-/Ausgabe ist Sache des Betriebssystems und kann sich während der Lebenszeit einer Prog.sprache ändern.

Borland hat diese Altlast in Delphi mitgezogen (um rückwärts kompatibel zu bleiben) aber zusätzlich das objektorientierte Stream-Konzept erfunden.
VCL-Anwendung sollten daher Streams verwenden, non-VCL Anwendungen gehen direkt auf die Windows API.

[Christian Seehase]

Moin Nikolai,

Zitat von inherited:

Was gefällt dir an Streams nicht? Damit lädst du eine Datei Byteweise in ein Array, wandelst sie in Chars um und fügst sie einem Memotext hinzu:

Wobei das hier
      Memo1.text:=Memo1.Text+Char(MyArray[i]); ein Performancekiller erster Güte ist

Ausserdem wird's interessant, sobald eine #00 im Dateiinhalt vorkommt.

Besser wäre es wohl die Daten gleich als Hexwerte darzustellen.

Delphi-Quellcode:

var
  sBuf    : string;
  sResult : string;
  i       : integer;
  iPos    : integer;
  iCount  : integer;
  fs      : TFileStream;
  sByte   : string;

begin
  fs := TFileStream.Create('...', fmOpenRead);  
  try
    SetLength(sBuf,fs.Size);
    // Annahme: 16 Byte je Zeile, getrennt mit Blank
    // fs.Size*3 => Zwei Hexstellen+Blank/#13 je Quellbyte
    // fs.Size div 16 => anschliessend noch ein #10 je Zeile
    SetLength(sResult,fs.Size*3+fs.Size div 16);
    fs.Read(sBuf[1],fs.Size);
    iPos := 1;
    for i := 1 to fs.Size do begin
      sByte           := IntToHex(ord(sBuf[i]),2);
      sResult[iPos]   := sByte[1];
      sResult[iPos+1] := sByte[2];
      inc(iPos,2);
      if i mod 16 = 0 then begin
        sResult[iPos]   := #13;
        sResult[iPos+1] := #10;
        inc(iPos,2);
      end else begin
        sResult[iPos] := #32;
        inc(iPos);
      end;
    end;
  finally
    fs.free;
  end;
  Memo1.Text := sResult;
end;

[sirius]

@shmia
Ich hab ja nix gegen Filestream. Und solange ich die VCL nicht ausschließen will, bin ich auch dabei. Aber:

Zitat:

Die Möglichkeit einen Stream zu benutzen hat mir aber garnicht gefallen, auch wenn man mir versichert hat, dass man damit unabhängig von Dateientypen arbeiten kann...

Wobei ich mich gerade frage, ob er weis, wovon er redet. Aber Beispiele für und gegen Filestream gibts ja jetzt genug.

Allerdings, ob es damals, unter der vorhanden Technik ein Fehler gewesen ist, darüber könnte man noch streiten. Aber nicht hier