Mittels Rekursiver Funktion per C# in eine Text-Datei schreiben
Hallo, mein Name ist Hugh und ich bin ein absoluter C# Noob. Hatte noch nie was damit zu tun gehabt, jedoch jetzt brauche ich C# um einen Algorithmus zu testen.
Der Algorithmus an sich ist uninteressant, seine Aufgabe ist es, in einem .txt File, einen Assemblercode durchzugehen und die Variablennamen zu reduzieren.
Dabei habe ich eine Input Datei test.txt und das Resultat des Algorithmus wird in die test1.txt geschrieben. Die test.txt ist so aufgebaut, dass zuerst Variablendeklartionen stehen, diese Zeilen beginnen immer mit einem 'dq'. Nach den Deklartionszeilen kommen die Anweisungen, in denen die Reduktion stattfindet. Nun habe ich zwei Probleme, das erste Problem ist, dass in meiner Ergebnisdatei test1.txt die neuen 'dq' Zeilen fehlen (es sollten weniger sein, als in test.txt) und das zweite Problem ist, ich möchte dass der Algorithmus solange rekursiv die Inputdatei test.txt durchlaeuft, bis er nichts mehr reduzieren kann.
Der C# Code stammt nicht von mir, ich möchte den aber entsprechend meiner Beschreibung oben modifizieren, der Algorithmus an sich sollte schon richtig funktionieren.
Ich habe auch die Input und Output Dateien hochgeladen.
Wie gesagt, bin ein absoluter Noob und vermutlich werde ich C# nie wieder brauchen (obwohl ich die Sprache meganice finde), später muss ich das alles in Matlab realisieren, aber zum Testen ist es deutlich angenehmer (und schneller) mit C# zu arbeiten. Vielen Dank und liebe Grüße.
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.IO;
using System.Text;
using System.Windows.Forms;
namespace SGR
{
public partial class Form1 : Form
{
string[] test;
List<List<string>> a = new List<List<string>>();
List<string> var1 = new List<string>();
public Form1()
{
InitializeComponent();
try
{
test = File.ReadAllLines(@"Z:\Desktop\test.txt");
}
catch
{
MessageBox.Show("error");
}
}
private void button1_Click(object sender, EventArgs e)
{
for (int i = 0; i < test.Length; i++) //i = anzahl codezeilen
{
if (test[i].Split(' ')[0] == "dq") //Trennen der Deklarionszeilen
{
var1.Add(test[i].Split(' ')[1]);
}
else
{
a.Add(test[i].Split(' ').ToList<string>());
}
}
MessageBox.Show(Get_Vars(a).ToString());
a = Main1(a); //zu verarbeitende Zeilen
MessageBox.Show(Get_Vars(a).ToString());
string[] KJO = new string[a.Count];
for(int k = 0; k < KJO.Length; k++)
{
string temp2 = "";
for(int kk = 0; kk < 4; kk++)
{
temp2 += " " + a[k][kk];
}
KJO[k] = temp2;
}
//File.Create(@"Z:\Desktop\test1.txt"); //hier die neuen dq Zeilen mit reinschreiben
File.WriteAllLines(@"Z:\Desktop\test1.txt", KJO);
MessageBox.Show("Done");
}
List<List<string>> Main1(List<List<string>> a)
{
string currVar = ""; //in currVar steht die momentane Variable, die betrachtet wird
for (int i = 0; i < a.Count; i++)
{
if (!(a[i][0] == "wbnone")) // wbnone Zeilen ignorieren
{
for (int l = 1; l < 4; l++) //l =anzahl strings in zeile, durch leerzeichen getrennt
{
if (!(a[i][l] == "?")) //das "?" darf nicht als variablenname angesehen werden
{
string test = a[i][l];
if (currVar != test)
{
currVar = a[i][l];
int[] point = new int[2];
int[] point2 = new int[2];
for (int ii = 0; ii < a.Count; ii++)
{
for (int j = 0; j < 4; j++)
{
if (a[ii][j] == currVar) //Falls eine Var in der zeile gefunden wurde
{
point[0] = ii; //setzen der Pointer auf die Position
point[1] = j; //in der Zeile
}
}
}
string sndVar = "";
if (point[1] == 3) //point=positionen der Var im Zeilenstring
{
point2[0] = point[0];
point2[1] = 1;
sndVar = a[point2[0]][point2[1]]; //bestimmung der zu ersetzenden Var
}
else
{
point2[0] = point[0];
if (point[1] == 1)
point2[1] = point[1] + 2;
if (point[1] == 2)
point2[1] = point[1] + 1;
sndVar = a[point2[0]][point2[1]];
}
int temp6 = 0;
for (int gg = point2[1]; gg <= point2[1]; gg++)
{
if (a[point2[0]][point2[1] + temp6] == sndVar)
a[point2[0]][point2[1] + temp6] = currVar;
temp6++;
}
for (int h = point2[0]; h < a.Count; h++)
{
for (int k = 1; k < 4; k++)
{
if (h > point2[0])
{
if (a[h][k] == sndVar)
{
a[h][k] = currVar;
}
}
}
}
}
}
}
}
}
return (a);
}
int Get_Vars(List<List<string>> a)
{
int counter = 0;
List<string> vars = new List<string>();
for (int i = 0; i < a.Count; i++)
{
for (int ii = 1; ii < a[i].Count; ii++)
{
if(!(vars.Contains(a[i][ii])))
{
vars.Add(a[i][ii]);
counter++;
}
}
}
List<string> tm = new List<string>();
foreach (string x in vars)
{
tm.Add(x);
}
File.WriteAllLines(@"Z:\Desktop\vars.txt", tm);
return counter;
}
}
}
Kleiner Hinweis um die Antwort-Chancen zu erhöhen:
Erstelle eine kleine Input-Datei und die daraus erwartete Output-Datei. Erläutere anhand dieses Minimal-Beispiels, warum der Output so aussehen soll. In dem Beispiel sollte die einfachste Variante und die mit der größtmöglichen Komplikation vorkommen.
Ich habe diese Datei
1 foo 4 bar 7 foobar 55 foobarbaraIch will alle Zeilen in einer neuen Datei haben, wo die Zahl am Anfang gerade ist, oder durch 7 teilbar oder der Text nach der Zahl mit a endet
Das erwartete Ergebnis wäre also
4 bar 7 foobar 55 foobarbaraWie mache ich das?
Bis jetzt kann ich deiner Erläuterung nur dann folgen, wenn ich ganz nah mit der Lupe zwischen den Zeilen lese und sehr viel hinein interpretiere (was dann auch falsch sein kann).
Hi,
wirklich schlau werde ich auch nicht ganz aus der Frage...
Das Ergebnis soll dann SO ausschauen? 🤔
(bzw.: Wo ist die Outputdatei von der Du sprichst?)
dq avoid ? 0x0000000000000000 ; uninitialised program memory here
dq _Constant0 ? 0x0000000000000000 ; 0
dq _Constant1 ? 0x3FF0000000000000 ; 1
dq t_10 ? 0xffffffffffffffff ;
dq t_12 ? 0x0000000000000000 ; 0
add t_12 _Constant1 t_10 ;
mul t_12 t_12 t_10 ;
sub t_12 t_12 t_10 ;
mul t_10 t_12 t_10 ;
add t_10 t_10 t_10 ;
mul t_10 t_10 t_10 ;
div t_10 t_10 t_10 ;
div t_10 t_10 t_10 ;
div t_10 t_10 t_10 ;
sub _Constant0 t_10 t_10 ;
add t_10 t_10 t_10 ;
natexp t_10 ? t_10 ;
wbnone ? ? ? ;
wbnone ? ? ? ;
wbnone ? ? ? ;
mul t_10 t_10 t_10 ;
mul t_10 t_10 t_10 ;
sub t_10 t_12 t_10 ;
mul t_10 t_10 t_10 ;
mul t_10 t_10 t_10 ;
mul t_10 t_10 t_10 ;
mul t_10 t_10 t_10 ;
mul t_10 t_10 t_10 ;
add t_10 t_12 t_10 ;
add t_10 t_12 t_10 ;
add t_12 t_10 t_10 ;
add t_10 t_12 t_10 ;
add t_10 t_12 t_10 ;
Ja, genau so! Prinzip ist so: man hat eine Input Datei mit Assemblercode, anhand dieser Datei sind die Variablen in diesem Code bekannt (die, die in den dq Zeilen stehen). Dann gibt es den geposteten Algorithmus, der einmal diese Datei durchgeht und die Variabeln drin reduziert und anschließend eine Output Datei erstellt, aber halt ohne der reduzierten dq Zeilen, und so kann er den Code nicht weiter reduzieren, weil ihm ja in der Ergebnis datei die dq-Zeilen fehlen.
Zum Vergleich lade ich mal meine Output Datei.
EDIT: Ja, im ersten Beitrag fehlt die Output Datei, weil ich irgendwie nur eine .txt hochladen durfte. Hier ist sie ja nachgeliefert. Tut mir leid.
Fullquote entfernt. Bitte beachte zukünftig [Hinweis] Wie poste ich richtig?
Lade doch ein ZipFile hoch?
Deine OutputDatei ist aber noch FALSCH, oder?
Das verwirrt etwas. Habe mit NUR die Letzte Zeile angeschaut:
add t_20 t_8 t_8 (Nennen wir es mal A-B-B)
Dann arbeitet Dein Algo. auch noch nicht richtig!
Richtig wäre doch: A-B-A ?
Beide Varianten A-B-A und A-B-B sollten richtig sein.
Zur Erklärung: Die ersten beiden Variablen in einer Zeile, sind die Variablen, die nur gelesen werden. Die dritte Variable in der Zeile, ist die Ergebnisvariable der Zeile, diese wird nur beschrieben. Jede Zeile des Assemblercodes in der Input Datei, wird exakt zum einem Zeitpunkt ausgeführt. Das heisst, wenn eine Variable das letzte mal ausglesen wird, ist der deren Name frei verfügbar und diese Variable kann neu beschrieben werden.
Hier ein sehr einfaches (Output Datei) Beispiel, ich poste das mal hier, weil es nur 12 Zeilen sind. Die DQ Zeilen habe ich manuell eingefügt wegen der Lesbarkeit:
dq avoid ? 0x0000000000000000 ; uninitialised program memory here
dq _Constant0 ? 0x0000000000000000 ; 0
dq _Constant1 ? 0x3FF0000000000000 ; 1
dq t_1 ? 0x0000000000000000 ; 0
dq t_2 ? 0xffffffffffffffff ;
dq t_5 ? 0x0000000000000000 ; 0
dq t_6 ? 0x0000000000000000 ; 0
mov _Constant1 ? t_2 ;
add t_6 t_6 t_6 ;
sub t_5 t_6 t_5 ;
mov_ispositive _Constant0 t_5 t_2 ;
add t_2 t_1 t_1 ;
^^Es wird ja immer verwirrender...
Ich glaube Du kommst um Sir Rufo's Hinweis (Post #2) nicht drum herum!
Ok, Ich lade eine Input Datei und eine Output Datei hoch. Die Output Datei ist 100% ig richtig aus der Input Datei erstellt worden, es ist das einfachste Beispiel. Der im ersten Post stehende Quelltext, funktioniert bei diese Input Datei, weil er nur einmal ausgeführt werden muss, bei der geringen Anzahl Zeilen und Variablen.
Trotzdem die Frage, wie füge ich die dq Zeilen zu der Output Datei hinzu?
und die Variablennamen zu reduzieren
Das könnte auf ein Entfernen mehrfacher Elemente hinauslaufen: Ixquick.com - remove duplicates from an array c#. Ansonsten wieder Post Nr. 2
Goalkicker.com // DNC Magazine for .NET Developers // .NET Blogs zum Folgen
Software is like cathedrals: first we build them, then we pray 😉