Problem mit HKStreams und Delphi 2010 (EOutOfMemory)

[MuTzE.Y85]

Hi,

ich hab ein Problem. Ich hatte damals mal mit Delphi 7 einen Texteditor geschrieben, welcher passwortgeschützte Dateien mit der Komponente HKStreams speichern und laden konnte.

Das wollte ich jetzt wieder aufleben lassen, weil er damals nicht richtig fertig geworden ist.
Mittlerweile habe ich Delphi 2010 und nun ein Problem. Die Komponente habe ich ohne Probleme installiert bekommen.

Jetzt bekomm ich aber bei jedem Versuch eine geschützte Datei zu öffnen den Fehler: EOutOfMemory


Hier mal die Codeschnipsel:

Delphi-Quellcode:

// Meine procedure
procedure LoadFile(FileName: TFileName);
var
 MS: TMemoryStream;
begin
 try
  HKStreams.LoadFromFile(FileName);
 except
  on ECorruptFile do
   Exit;
  on EStreamError do
   Exit;
 end;
 MS := TMemoryStream.Create;
 try
  with HKStreams do
   begin
    GetStream('Text', MS);
    SynEdit.Lines.LoadFromStream(MS);
    MS.Clear;
    ClearStreams;
   end;
 finally
  MS.Free;
 end;
end;

// Proceduren aus der HKStreams-Komponente
procedure THKStreams.LoadFromFile(const Filename: string);
var fs:TFileStream;
begin
 Fs:=TFileStream.Create(FileName,fmOpenRead);
 try
  // Hier bleibt Delphi stehen
  LoadFromStream(fs);
 finally
  FS.free;
 end;
end;

procedure THKStreams.LoadFromStream(ms: TStream);
var CMem,mem : TMemoryStream; e,c:byte; AKey : string;
begin
 AKey:=FKey;
 Cmem:=TMemoryStream.create;
 mem:=TMemoryStream.create;
 try
  ms.Position:=0;
  ms.read(c,sizeof(c));
  ms.read(e,sizeof(e));
  CMem.copyfrom(ms,ms.size-2);
  CMEm.position:=0;
  if (e = EncryptedByte[True]) then begin
   If not assigned(FOnAskForKey) then AKey:=FKey else AKey:=FOnAskForKey(Self);
   try DecryptStream(CMem,AKEy);
   except on Exception do begin foundcorrupt; end; end;
  end;
  if not (c = CompressedByte[True]) then
   if not CheckGood(CMem) then exit;
  CMem.Position:=0;
  if (c = CompressedByte[True]) then
   try
    LHAExpand(Cmem,Mem)
   except
    on Exception do begin
     FoundCorrupt;
    end;
   end
   else Mem.copyfrom(Cmem,0);
  LoadFromStreamNor(Mem);
 finally
  CMem.Free;
  mem.free;
 end;
 FKey:=AKey;
 FCompressed:=(C = CompressedByte[True]);
 FEncrypted:=(e = EncryptedByte[True]);
end;

Wo genau da jetzt der Fehler liegt weiss ich nicht. Ich kann es nicht per Einzelschritt ausführen, weil dann ständig eine WndProc von der Komponente SynEdit ausgeführt wird.
Bloß was ich jetzt nicht verstehe ist, warum es unter Delphi 7 lief und jetzt nicht mehr.

[MuTzE.Y85]

Also ich habe herausgefunden woran es liegt, weiss aber nicht wie bzw. wo ich das verhindern kann.

Ich habe mal eine Datei ohne Kompression bzw. Verschlüsselung gespeichert.
Einmal mit der originalen Demo und einmal wurde die Demo mit Delphi 2010 von mir kompiliert.

Um kurz zu erklären wie es funktioniert.
Die Komponente speichert einen Header, in welchem die Info ist, ob verschlüsselt bzw. komprimiert wurde und dann die einzelnen Streams mit Namen und deren Inhalt.

In folgendem Beispiel heißen die Streams MEMO1, MEMO2 und MEMO3.
Anhand der Namen werden diese wieder gelesen.

Hier der Inhalt der Datei, die mit dem Original gespeichert wurde:

Zitat:

MEMO1
Anfange-Ende1 MEMO2
Anfange-Ende2 MEMO3
Anfange-Ende3

Und hier der Inhalt der Datei, die mit Delphi 2010 kompliliert wurde:

Zitat:

M E M Anfang-Ende1 M E M Anfang-Ende2 M E M Anfang-Ende3

Er speichert den Namen der Streams falsch. Und kann diese auch nicht laden. Wobei beim Ladevorgang auch ein Fehler sein muss, denn die neu kompilierte Demo kann auch keine Dateien öffnen, welche mit der Originalen gespeichert wurde.

Ich hoffe jetzt kann mir jemand helfen!


EDIT:
Nochwas aufgefallen.
Beim ersten Laden, schafft er es Stream 1 korrekt zu laden den Rest gar nicht, danach lädt er nichts mehr.



Habe die Funktionen gefunden, die dafür verantwortlich sind!
Diese beiden hier:

Delphi-Quellcode:

function THKStreams.ReadStr(Stream: TStream): String;
var
  I: Word;
  S: String;
begin
  Stream.Read(I, SizeOf(I));
  SetLength(S, I);
  Stream.Read(PChar(S)^, I);
  Result := S;
end;

procedure THKStreams.WriteStr(S: String; Stream: TStream);
var
  I: Word;
begin
  I := Length(S);
  Stream.Write(I, SizeOf(I));
  Stream.Write(PChar(S)^, I));
end;

Es wird nach jedem Zeichen ein Leerzeichen eingefügt, weshalb der komplette String nicht aufgenommen werden kann.
Habe es jetzt damit gelöst:

Delphi-Quellcode:

function THKStreams.ReadStr(Stream: TStream): String;
var
  I: Word;
  S: String;
begin
  Stream.ReadBuffer(I, SizeOf(I));
  SetLength(S, I);
  Stream.ReadBuffer(PChar(S)^, I * SizeOf(S[1]));
  Result := S;
end;

procedure THKStreams.WriteStr(S: String; Stream: TStream);
var
  I: Word;
begin
  I := Length(S);
  Stream.WriteBuffer(I, SizeOf(I));
  Stream.WriteBuffer(PChar(S)^, I * SizeOf(S[1]));
end;

Aber warum macht er mit Delphi 2010 Leerzeichen rein und mit Delphi 7 nicht?
Das muss doch einen Grund haben oder?

Frage auch selber beantwortet!
Früher wars Ansi (1 Byte/Zeichen) jetzt Unicode (2 Byte/Zeichen).

Das könnte ich jetzt umsetzen indem ich den Unicode-String zum Ansi-String umwandle und ausgebe.
Aber sinvoller wäre es doch, sie Unicode zu lassen oder? Ich meiner das wurde ja nicht umsonst eingeführt?


Ansonsten danke liebes Forum für die Hilfe

[MuTzE.Y85]

So hier steht die Lösung:
Anwendungen für Unicode anpassen

Habe den Code so geändert:

Delphi-Quellcode:

// Lesen alt
function THKStreams.ReadStr(Stream: TStream): String;
var
  I: Word;
  S: String;
begin
  Stream.ReadBuffer(I, SizeOf(I));
  Setlength(S, I);
  Stream.ReadBuffer(PChar(S)^, I);
  Result := S;
end;

// Angepasst für Delphi 2010 (Unicode)
function THKStreams.ReadStr(Stream: TStream): String;
var
  I: Word;
  S: String;
begin
  Stream.ReadBuffer(I, SizeOf(I));
  Setlength(S, I);
  Stream.ReadBuffer(Pointer(S)^, I * SizeOf(Char));
  Result := S;
end;


// Schreiben alt
procedure THKStreams.WriteStr(S: String; Stream: TStream);
var
  I: Word;
begin
  I := Length(S);
  Stream.WriteBuffer(I, SizeOf(I));
  Stream.WriteBuffer(PChar(S)^, I);
end;

// Angepasst für Delphi 2010 (Unicode)
procedure THKStreams.WriteStr(S: String; Stream: TStream);
var
  I: Word;
begin
  I := Length(S);
  Stream.WriteBuffer(I, SizeOf(I));
  Stream.WriteBuffer(Pointer(S)^, I * SizeOf(Char));
end;