Teile einer Zeile einer .txt Datei lesen und in eine ROM schreiben

[out]

Ich habs so verstenden: Ziffernfolge Leerzeichen Ziffernfolge // So sieht jede Zeile aus?

[Kazeshin]

TNA schrieb:

Du willst eine Zeile einlesen, das Leerzeichen entfernen und dann noch was an die Zeile anhängen. Verstehe ich das richtig?

Ja.
Wobei mir da grade einfällt, dass die Zahlen alle im Hexadezimalen system geschrieben sind, sodass ich da vielleicht auch irgendwas besonderes brauche, damit a,b,c,d,e und f nicht als ascii gespeichert werden, sondern als hexadezimal. (sofern das überhaupt geht)

out schrieb:

Ich habs so verstenden: Ziffernfolge Leerzeichen Ziffernfolge // So sieht jede Zeile aus?

Die Zeilen sehen z.b. so aus:
D033AFA1 0020
8133B1BC 4220
D033B1BD 0020
8133B17C 0300
D033B1BD 0020
8133B17E 0880

[TNA]

out schrieb:

Ich habs so verstenden: Ziffernfolge Leerzeichen Ziffernfolge // So sieht jede Zeile aus?

Prinzipiell habe ich es auch so verstanden, aber er will das ja noch irgendwie wegschreiben. Den Teil verstehe ich noch nicht.

[out]

Kopier ein paar Zeilen deiner Datei hier rein sonst reden wir in 2h noch über den Dateiaufbau.

[TNA]

Kazeshin schrieb:

Die Zeilen sehen z.b. so aus:
D033AFA1 0020
8133B1BC 4220
D033B1BD 0020
8133B17C 0300
D033B1BD 0020
8133B17E 0880

OK, und was soll da nachher genau rauskommen, bzw was willst du damit genau machen?

[Kazeshin]

TNA schrieb:

Kazeshin schrieb:

Die Zeilen sehen z.b. so aus:
D033AFA1 0020
8133B1BC 4220
D033B1BD 0020
8133B17C 0300
D033B1BD 0020
8133B17E 0880

OK, und was soll da nachher genau rauskommen, bzw was willst du damit genau machen?

es soll in eine ROM an einer bestimmten stelle eingefügt werden. vorher sollte es zu
D033AFA10020008133B1BC422000D033B1BD0020008133B17C030000D033B1BD0020008133B17E088000
umgeschrieben werden.

[out]

#include <iostream>
#include <fstream>
#include<string>
using namespace std;

int main()
{
	ifstream file( "test.txt" );
	string data;

	for(string s1,s2; file>>s1>>s2; data+=s1+s2+"00");

	cout << data;
}

[TNA]

Das hört sich so an, als solle das in ein Binärformat umgewandelt werden. Also z.B. die erste Zahl in ein tU32 und die zweite in ein tU16. Wie genau willst du das nachher in das ROM schreiben?

[out]

TNA schrieb:

Das hört sich so an, als solle das in ein Binärformat umgewandelt werden. Also z.B. die erste Zahl in ein tU32 und die zweite in ein tU16. Wie genau willst du das nachher in das ROM schreiben?

Wie sich mit Zahlen herumschlagen? Einfach 2 Strings nehmen und verknüpfen.

[TNA]

out schrieb:

Wie sich mit Zahlen herumschlagen? Einfach 2 Strings nehmen und verknüpfen.

Ich fürchte er will nicht wirklich einen String schreiben sondern Bytes deren Werte durch Hexadezimalzahlen repräsentiert werden.

[Kazeshin]

TNA schrieb:

Das hört sich so an, als solle das in ein Binärformat umgewandelt werden. Also z.B. die erste Zahl in ein tU32 und die zweite in ein tU16. Wie genau willst du das nachher in das ROM schreiben?

Binär klingt richtig^^ nicht als ascii string, das wäre fatal^^

Btw: der code, den "out" geschrieben hat, hat zumindest schonmal die richtigen Ziffern ausgegeben.

[TNA]

Kazeshin schrieb:

Binär klingt richtig^^ nicht als ascii string, das wäre fatal^^

Wie genau schreibst du die Sachen denn ins ROM? Hast du dafür eine spezielle Funktion? Wenn ja, zeig mal die Signatur.

[Kazeshin]

TNA schrieb:

Kazeshin schrieb:

Binär klingt richtig^^ nicht als ascii string, das wäre fatal^^

Wie genau schreibst du die Sachen denn ins ROM? Hast du dafür eine spezielle Funktion? Wenn ja, zeig mal die Signatur.

Das ist mein Problem. Ich weiß nicht, wie das geht.

[Nathan]

OK, mal ganz anders gefragt:
Was willst du mit diesen Zahlen im ROM erreichen?

[TNA]

Kazeshin schrieb:

Das ist mein Problem. Ich weiß nicht, wie das geht.

Das solltest du irgendwie herausfinden. Hier kann leider niemand hellsehen und solange selbst du nicht weißt, was du genau machen möchtest, wird dir daher leider keiner helfen können.

[Kazeshin]

TNA schrieb:

Kazeshin schrieb:

Das ist mein Problem. Ich weiß nicht, wie das geht.

Das solltest du irgendwie herausfinden. Hier kann leider niemand hellsehen und solange selbst du nicht weißt, was du genau machen möchtest, wird dir daher leider keiner helfen können.

ich weiß, was ich damit tun will, das Problem ist nur, dass ich nicht weiß, wie ich diese Daten hereinbekomme. Sie sollen an eine bestimmte Stelle der Datei geschrieben werden. so wie ich es kenne, gibt es für jede 2. Hexadezimalstelle eine Addresse. Ich will die Zahlen an die Addresse BEA20 schreiben.

Nathan schrieb:

OK, mal ganz anders gefragt:
Was willst du mit diesen Zahlen im ROM erreichen?

Ich habe einen Assembler code für die N64 geschrieben, der die Zahlen ausliest. Dadurch erhält das Spiel ein "ingame gameshark device", das wie ein echte funktioniert. Das soll für Romhacks nützlich sein
Das Problem ist halt, dass es für den Nutzer verdammt nervig sein wird, 1000 (wirklich 1000 ._.) Ziffern einzutippen.

[Werner Salomon]

Hallo Kazeshin,

Willkommen im C++-Forum.

Erzähl mal ein wenig vom Hintergrund; dann können wir Dir auch besser helfen.
Wo kommen die Daten her (Quelle der Datei) und wo sollen die Daten hin und warum? und was sollen sie dort bewirken?

ROM steht für "Read Only Memory" - das ist Speicher, aus dem man nur Lesen, aber in dem man nicht schreiben kann. Vielleicht meinst Du RAM (random access memory).

Das was dort in der Datei steht, ist sogenannter HexCode. Es sollten also nur die Zeichen '0' bis '9' und 'A' bis 'F' dort vorkommen. Und zwar immer paarweise.
Wobei es überhaupt keine Rolle spielt, wenn zwischen den Paaren Leerzeichen auftauchen.
Jeweils zwei Zeichen bilden ein Byte und damit eine Zahl zwischen 0 und 255 (Hexadezimal 0x00 bis 0xFF). Mit C++ kannst Du Zahlen als Hexcode lesen. Auf Grund von einigen Gegebenheiten würde ich Dir hier aber empfehlen, Dir eine eigene kleine struct zu bauen, mit dem Du genau ein Byte einlesen kannst (also zwei Zeichen).

Hier mal ein Vorschlag - bitte frage nach - Du wirst einiges davon nicht verstehen.
Das Schreiben in 'ROM' habe ich geraten, da Du dazu noch nichts gesagt hast.

#include <iostream>
#include <iomanip> // setw
#include <fstream>
#include <cctype> // toupper

struct Byte
{
    char get() const { return value_; }
    friend std::istream& operator>>( std::istream& in, Byte& b );
private:
    char value_;
};
int calc_value_of_nibble( char nibble, bool& err ) // umwandel eines Zeichens '0'-'9' 'A'-'F' in dessen Wert 0-15
{
    const char hx[] = "0123456789ABCDEF";
    const char* p = std::char_traits< char >::find( hx, sizeof(hx)-1, char(std::toupper(nibble)) );
    if( p )
        return p - hx;
    err = true;
    return 0;
}
std::istream& operator>>( std::istream& in, Byte& b ) // Einlesen eines Bytes
{
    char high_nibble, low_nibble;
    if( in >> high_nibble && in.get( low_nibble ) )
    {
        bool err = false;
        b.value_ = calc_value_of_nibble( high_nibble, err )*16 + calc_value_of_nibble( low_nibble, err );
        if( err )
            in.setstate( std::ios_base::failbit );
    }
    return in;
}

// --   'ROM' nur für Demozwecke
class ROM
{
public:
    ROM()
    {
        std::clog.fill( '0' );
        std::clog << std::hex << std::uppercase;
    }
    void write( char byte )
    {
        std::clog << std::setw(2) << int(static_cast< unsigned char >( byte ));
    }
};

int main()
{
    using namespace std;
    ROM rom;
    for( ifstream in("input.txt"); (in >> ws).good(); )
    {
        int i=0;
        for( Byte b; i<6 && in >> b; ++i )
            rom.write( b.get() );
        rom.write( char(0) ); // nach 6 Byte eine 0 hinzufügen
    }
    cout << endl;
    return 0;
}

Gruß
Werner

[Nathan]

Kazeshin schrieb:

Nathan schrieb:

OK, mal ganz anders gefragt:
Was willst du mit diesen Zahlen im ROM erreichen?

Ich habe einen Assembler code für die N64 geschrieben, der die Zahlen ausliest. Dadurch erhält das Spiel ein "ingame gameshark device", das wie ein echte funktioniert. Das soll für Romhacks nützlich sein
Das Problem ist halt, dass es für den Nutzer verdammt nervig sein wird, 1000 (wirklich 1000 ._.) Ziffern einzutippen.

Ah, Memory-Hack, hatte ich mir schon fast gedacht.
Für die Implementierung der write()-Funktion sollst du dir mal WriteProcessMemory() unter Windows anschauen

[TNA]

Werner Salomon schrieb:

Hallo Kazeshin,

ROM steht für "Read Only Memory" - das ist Speicher, aus dem man nur Lesen, aber in dem man nicht schreiben kann. Vielleicht meinst Du RAM (random access memory).

Ne, der meint wahrscheinlich so was hier http://de.wikipedia.org/wiki/ROM_(Spielmodul). War auch die ganze Zeit auf dem falschen Dampfer aber langsam dämmert mir, was er vor hat.

[hustbaer]

@Kazeshin
Ist schlimmes C-gefrickel, aber das ist man der Aufgabe schuldig, was anderes wäre irgendwie nicht OK
(Nein, das ist nicht wirklich mein Ernst, aber mit den C Funktionen lässt sich das schnell lösen, und ne "schöne" C++ version ist vermutlich doppelt so lange, und > 10x so schwer für den OP nachzuvollziehen.)

Und vollkommen ungetestet, aber es könnte u.U. das machen was du willst (sofern es überhaupt compiliert). Und wenn nicht, sollte es dir ein paar Ideen geben.

#include <stdio.h>

int main()
{
    // files aufmachen
    FILE* patchFile = fopen("patch.txt", "r");
    // TODO: error handling
    FILE* romFile = fopen("rom.dat", "r+");
    // TODO: error handling

    // im ROM file dorthin seeken wo wir patchen wollen
    fseek(romFile, 0xBEA20, SEEK_SET);
    // TODO: error handling (ich lass das ab jetzt weg, ich hab hier gar kein error-handling, also fehlt es eh überall :D)

    // zeilenweise reinlesen
    char lineBuffer[100] = {};
    while (fgets(lineBuffer, sizeof(lineBuffer), patchFile))
    {
        unsigned long part1 = 0;
        unsigned long part2 = 0;
        // zwei hex zahlen aus der zeile lesen
        if (sscanf(lineBuffer, "%lx %lx", &part1, &part2) < 2)
            // TODO: message ausgeben -- dazu müssten wir aber erstmal auf ne leerzeile prüfen
            //       um unnötige warn-/fehlermeldungen zu vermeiden
            break;

        // in bytes zerlegen
        // hier reihenfolge ggf. umdrehen - je nachdem was für endian benötigt wird
        unsigned char patchBytes[4] = {
            ((part1 >> 24) & 0xFF),
            ((part1 >> 16) & 0xFF),
            ((part1 >> 8)  & 0xFF),
            ( part1        & 0xFF)
            };

        // ins ROM file schreiben
        fwrite(patchBytes, 1, 4, romFile);
    }

    // und files wieder zumachen
    fclose(patchFile);
    fclose(romFile);
}

Ich habe einen Assembler code für die N64 geschrieben, der die Zahlen ausliest. Dadurch erhält das Spiel ein "ingame gameshark device", das wie ein echte funktioniert.

Sorry, aber anhand deines Programmier-Kenntnisstandes ist wohl eher davon auszugehen dass du ihn dir ergoogelt hast. Ist aber andrerseits auch egal.