Stringreplace mit einer unbekannten

[ReVenGer]

Hi, ich möchte einen string erstzen der aus vier bytes und einem unbekannten besteht.
Nun hab ich schon einiges probiert aber irgendwie komme ich zu keinem vernünftigen ergebnis.

Delphi-Quellcode:

var
 s : string;

begin
 Form3.Memo1.Text:=StringReplace(Form3.Memo1.Text,'3B 00 01 00 ' + (s,1),'3B 00 01 00 02',[rfReplaceAll, rfIgnoreCase]);
end;

[chaosben]

Hi!

Ich glaube wir müssen erstmal über Grundlegendes reden. :)

Was für einen Text hast du denn da?
Sieht er aus, wie oben in deinem Beispiel, also so

Code:

3B 00 1A FF 34 82

oder stehen die Bytes wirklich in deinem Text

Code:

;

?

Falls letzteres zutrifft, musst du dir erstmal eine anderen Typ außer "String" suchen (z.B. array of byte) da ein String immer nur bis zum nächste 0-Byte geht.

Falls ersteres zutrifft, müßtest du nach den ersten 4 Byte suchen und dir deren Position merken (siehe Hilfe "Funktion Pos"). Danach musst du nur noch ab dieser Position die 5 neuen Bytes schreiben. (siehe Hilfe "Funktion Delete/Insert") Fertig :)

Aber irgendwie habe ich das Gefühl, das du dir das Leben unnötig schwer machst (durch String-Operationen).
Wenn du uns also verrätst was du machen willst, können wir dir vielleicht helfen.

[Gruber_Hans_12345]

Zitat:

Zitat von chaosben

da ein String immer nur bis zum nächste 0-Byte geht.

ähm? wir sollten wirklich über grundlegendes reden ;) - wir sind hier doch in der Delphi Sektion oder? - da kann ein String sehr wohl die binäre 0 speichern, und ich kann in den string wenn ich will ein Bild oder ein EXE File ablegen, ohne das informationen verloren gehen.

Aber ansonsten haste schon recht, zuerst mal festestellen, ob das File diese Werte wirklich als Text hat, oder ob diese Texte von einem Hex Editor kommen, der die Zeichen als Hex code darstellt.
Anschließend kannst du dann mit Pos arbeiten (warum das Leben unnötig schwer machen, wenn es strings gibt)

[chaosben]

Zitat:

Zitat von Gruber_Hans_12345

Zitat:

Zitat von chaosben

da ein String immer nur bis zum nächste 0-Byte geht.

ähm? wir sollten wirklich über grundlegendes reden ;)

:-D

Ok, es war schlecht formuliert. Natürlich kannst du deine Bilder als Strings halten :).

Aber wenn wir hier über String und deren Bearbeitung reden, geht es im Endeffekt (meistens) um PChars. Und alle Routinen die mit eben diesen arbeiten (z.B. auch das StringReplace) orientieren sich am 0-Byte. Und damit sind solche Operatioen (wie oben) mit Strings ein wenig sinnlos. :)

[SirThornberry]

bei mir hat stringreplace sich noch nie an diesem 0-byte orientiert und laut quelltext macht es das auch nicht. StringReplace erwartet einen String und wenn man einen PChar übergibt wird dieser in einen String gewandelt. Und NUR in diesem Fall ist bei #0 schluss weil bei der Wandelung von PChar zu String beim #0-Byte abgeschnitten wird.

[marabu]

Hallo,

das Beispiel mit den Hex-Werten aus Beitrag #1 ist wohl irreführend, da es sich dabei ja nur um die Visualierung von Daten handelt, wie sie in einem anderen Thread des OP besprochen wurde.

Natürlich kann man einen beliebigen Datenblock in einen String packen und diesen dann patchen:

Delphi-Quellcode:

function PatchString(var s: string; const prefix, data: string): Boolean;
var
  iPos: Integer;
begin
  if prefix = ''
    then iPos := 1
    else iPos := Pos(prefix, s);
  if iPos > 0 then
    iPos := iPos + Length(prefix);
  Result := (data <> '') and (iPos > 0) and (Pred(iPos) <= Length(s) - Length(data));
  if Result then
    Move(data[1], s[iPos], Length(data));
end;

Das funktioniert auch, wenn der String beliebige Daten enthält. Die Fallstricke der Kombination von Pascal- und C-Routinen zur Stringverarbeitung verdeutlicht folgendes Beispiel:

Delphi-Quellcode:

var
  s: string;
begin
  s := 'the quick brown fox jumps over the lazy dog';
  if PatchString(s, 'quick', 'green') then
    ShowMessage(s);
  s := 'the'#0'quick'#0'brown'#0'fox jumps over the lazy dog';
  if PatchString(s, 'quick'#0, 'green'#0) then
    ShowMessage(s);
end;

Grüße vom marabu

[ReVenGer]

Hab leider nicht erwähnt, das wir das in einem anderen thread besprochen haben.
Das Problem was ich bei Delphi habe, das ich keine direkten Anweisungen geben kann wie bei Assembler.
Das verwirrt mich immer.

Die Datei wir in Hex eingelesen und im Memo angezeigt. Im Memo möchte ich diese Hexwerte nun editieren. Nur fügt er mir die neuen Werte ein, er soll aber die alten überschreiben.

Und das letzte Byte, was er erstzen soll ist dabei variabel, deshalb für mich unbekannt.
Ich kenne nur das Byte durch was es ersetzt werden soll.

[chaosben]

Zitat:

Zitat von SirThornberry

bei mir hat stringreplace sich noch nie an diesem 0-byte orientiert und laut quelltext macht es das auch nicht.

Nein?
Mein StringReplace arbeitet mit AnsiPos und dieses wiederum enthält folgende Zeile:

Delphi-Quellcode:

P := AnsiStrPos(PChar(S), PChar(SubStr));

Ab diesem Zeitpunkt muss die Funktion sich am 0-Byte orientieren, da sie ja die Länge nicht kennt.


Probier doch mal folgendes:

Delphi-Quellcode:

program Project1;

{$APPTYPE CONSOLE}

uses
  SysUtils,
  Dialogs,
  Classes;

var
  S1, S2 : String;
begin
  S1:='A'+#0+'B';
  S2:=StringReplace(S1,'B','C',[rfIgnoreCase]);
  Writeln(s2);
  Readln;
end.

"B" wird nicht ersetzt weil StringReplace sich am 0-Byte orientiert.

@ReVenGer:

Zitat:

Zitat von chaosben

Falls ersteres zutrifft, müßtest du nach den ersten 4 Byte suchen und dir deren Position merken (siehe Hilfe "Funktion Pos"). Danach musst du nur noch ab dieser Position die 5 neuen Bytes schreiben. (siehe Hilfe "Funktion Delete/Insert") Fertig :)

[SirThornberry]

@chaosben: wieder was gelernt, dann muss ich mich entschuldigen. :oops:

[marabu]

Hallo,

Zitat:

Zitat von ReVenGer

... Die Datei wir in Hex eingelesen und im Memo angezeigt. Im Memo möchte ich diese Hexwerte nun editieren. ...

nach meiner Auffassung liest du eine Binär-Datei ein und willst sie an bestimmten Stellen patchen:

Delphi-Quellcode:

// Getippt und nicht getestet.

procedure TDemoForm.ButtonClick(Sender: TObject);
var
  s: string;
  fn: TFileName;
  fs: TFileStream;
begin
  fs := TFileStream.Create(fn, fmOpenReadWrite or fmShareDenyWrite);
  SetLength(s, fs.Size);
  fs.ReadBuffer(s[1], fs.Size);
  if PatchString(s, #$3B#$00#$01#$00, #$02) then
  begin
    fs.Position := 0;
    fs.WriteBuffer(s[1], Length(s));
  end;
  fs.Free;
end;

Dieses Code-Fragment überschreibt das Byte, welches deiner Byte-Signatur 3B 00 01 00 direkt folgt, mit dem Wert 02.

Freundliche Grüße