Ich habe folgendes Problem

Ich habe einen Text (normal *.Txt) welcher folgendermaßen aufgebaut ist

8709876 ADD ADD 5468578 (-> Nur so als Beispiel!)

Und das in endlosen Reihen. Nun sind die 1. und die letzte Spalte für die Neuumwandlung ( Gott sei Dank gibts die neue Rechtschreibung) des Assembler Codes ziemlich unprktisch. Da es aber jeden zeitlichen Ramen sprengen würde, alle per Hand zu formatieren, wollte ich fragen, ob es einen Delphi- Code gibt, welcher mir das abnimmt.

Ich hoffe, ihr versteht mein Problem und könnt mir helfen. Danke!

Hallo Celine,

kannst Du einmal (am besten mehrere) beispielhafte Ein- und Ausgaben gegenüberstellen. Mir ist noch nicht ganz klar, was Du am Ende haben möchtest...

Hi! Herzlich willkommen in der DP!

Ich verstehe auch nicht ganz, was du willst


Einzelne Textabschnitte kannst du evtl. so löschen:

http://www.delphipraxis.net/internal...putername+ohne

Der Eingegebene Text sieht folgendermaßen aus:

00000000 4D DEC ebp 386
00000001 5A POP edx 386
00000002 50 PUSH eax 386
00000003 0002 ADD [edx],al 8086
00000005 0000 ADD [eax],al 8086
00000007 000400 ADD [eax+eax],al 8086
0000000A 0F <Unknown> ? ?
0000000B 00FF ADD bh,bh 8086
0000000D FF00 INC [eax] 386
0000000F 00B800000000 ADD [eax+0x00000000],bh 8086
00000015 0000 ADD [eax],al 8086
00000017 004000 ADD [eax+0x00],al 8086
0000001A 1A00 SBB al,[eax] 8086
0000001C 0000 ADD [eax],al 8086
0000001E 0000 ADD [eax],al 8086
00000020 0000 ADD [eax],al 8086
00000022 0000 ADD [eax],al 8086
00000024 0000 ADD [eax],al 8086
00000026 0000 ADD [eax],al 8086
00000028 0000 ADD [eax],al 8086
0000002A 0000 ADD [eax],al 8086
0000002C 0000 ADD [eax],al 8086
0000002E 0000 ADD [eax],al 8086
00000030 0000 ADD [eax],al 8086
00000032 0000 ADD [eax],al 8086
00000034 0000 ADD [eax],al 8086
00000036 0000 ADD [eax],al 8086
00000038 0000 ADD [eax],al 8086
0000003A 0000 ADD [eax],al 8086
0000003C 0001 ADD [ecx],al 8086
0000003E 0000 ADD [eax],al 8086

Und ich möchte, dass der Text dann zum scluss wieder normaler Assemblercode

ADD [eax],al
ADD [ecx],al
ADD [eax],al
SBB al,[eax]
usw.. wird, damit ich das dann alles wieder Assemblieren kann. Und da es mir einfach zu zeitaufwendig ist, alles von Hand zu kopieren, möchte ich ein Programm schreiben, welches mir die Assembler Zeilen
ADD [eax],al
ADD [ecx],al
ADD [eax],al
SBB al,[eax]
aus dem obigen Text eidet und in eine neue Textdatei schreibt!

so wie ich das sehe sind vor jedem deiner sinnvollen zeilen 2
Leerzeichen!

(alles zeilenweise bearbeiten)
mit pos() kannst du dies doch in einer schleife 2 mal suchen und dann immer vom
Anfang bis zur gefundenen position alles mit delete() löschen!

Und so suchst du dir einfach immer weiter bestimmte punkte bis wo
oder von wo an du deine zeile bearbeitest!

Wenn Du reguläre Ausdrücke einsetzen magst, könnte der Vollständige Code, um die Eingangsdaten aus Memo1 in die von Dir geünschte Form nach Memo2 (unter der Vorraussetzung, das keine weiteren Sonderfälle vorhanden sind) innerhalb der Ereignisbehandlungsroutine Button1Click zB so aussehen

markieren

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
  iLine: Integer;
begin
  Memo2.Clear;
  with Memo1.Lines, RegExp('^(.*?\s){2}(.*)\s.*?86\s*$') do
    for iLine:=0 to Pred(Count) do
      Memo2.Lines.Add( Replace(Strings[iLine], '$2', True));
end;

Du willst ja die 1., 2. und letzte Spalte löschen.

zusammenfalten · markieren

Delphi-Quellcode:

Var F1, F2: TextFile;
  S: String;
  I: Integer;

Begin
  AssignFile(F1, 'Dateiname.txt'); Reset(F1);
  AssignFile(F2, 'Dateiname2.txt'); Rewrite(F2);
  While not EoF(F1) do Begin
    ReadLn(F1, S);
    If Pos(' ', S) > 0 Then S := Trim(Delete(S, 1, Pos(' ', S)));
    If Pos(' ', S) > 0 Then S := Trim(Delete(S, 1, Pos(' ', S)));
    If Pos(' ', S) > 0 Then Begin
      I := Length(S);
      While S[I] <> ' ' do Dec(I);
      S := Trim(Copy(S, 1, I - 1));
    End;
    WriteLn(F2, S);
  End;
  CloseFile(F2);
  CloseFile(F1);
End;

PS: Für sowas mißbrauche ich aber meistens den Texteditor und Excel.
In diesem Beispiel hätte ich einfach jedes Leerzeichen im Texteditor durch je einen Tabulator ersetzt.
Danach alles nach Excel kopiert. (da wird ja alles durch den Tabulator auf verschiedene Spalten verteilt)
Und aus Excel dann einfach alles ab der 3. Spalte zurück in den Editor, da werden natürlich wieder aus den Tabulatoren Leerzeichen gemacht.
Und fertig.

@himutsu

Mus i nicht noch initialisiert werden?

markieren

Delphi-Quellcode:

//...
    If Pos(' ', S) > 0 Then Begin
      I := length(S);
      While S[I] <> ' ' do Dec(I);
//...

Hast recht, hatte ich wohl überseh'n

Danke, himutsu, dass war genau der Code, den ich benötigt hatte. Warum ich nicht selbst darauf gekommen bin? Das hilft mir extrem weiter.

PS: Du wirst doch aber zugeben, dass es enorm leichter ist, 2,5k Zeilen Text von einem Programm umwandeln zu lassen, als erst überall Tabulatoren einzufügen etc. etc. etc...
Getreu nach dem Motto
"Never let a human do, what a computer can do better"