none
Portierung meines Rohbaus von Java RRS feed

  • Frage

  • Habe da folgenden "Rohbau" aus Java (von dem ich auch wenig verstehe), den ich aber brauche, um Assembler-Teile unter Windows laufen zu lassen (Bitmanipulationen - und dem Java fehlt ja das "goto"):


    // // // // // // // // // // // // // // // // ** \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\
    //                                                                                                                                                            \\
    //    Das Prog läd eine Datei "hex-cd" ges. in den RAM um sie zu bearbeiten und das Ergebnis        \\
    //                         in einer zweiten Datei "hex-out" auszugeben.                                                         \\
    //                                                                                                                                                            \\
    //                  Version mit vieeeelen Erläuterungen zur Arbeit mit Dateien                                          \\
    //                                                                                                                                                            \\
    // // // // // // // // // // // // // // // // ** \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\

    // Imports
    import java.io.*;

    class Test
    { public static void main ( String[] args ) throws IOException
      {
    //  FileInputStream fileIn_01 = new FileInputStream ("hex-cd"); // Datei öffnen - muß existieren !
    //  DataInputStream inStr = new DataInputStream(      // und mit DataInputStream-Objekt verknüpfen
    //    new BufferedInputStream(                                       // Lesepuffer für Performance
    //      ( fileIn_01 )));           // Datei kann mit dieser Methode nur FORTLAUFEND gelesen werden
    //                                 // == >> daher ersetzt durch RandomAccessFile !!!
        RandomAccessFile inStr = new RandomAccessFile("hex-cd","r");    // wird nur zum lesen geöffnet

    //    // Datei 'hex-out' erzeugen oder öffen => dann aber wird der alte Inhalt einer bestehenden
    //    //                                        Datei dieses Namens sofort gelöscht !!!
    //  FileOutputStream fileOut_01 = new FileOutputStream ("hex-out");
    //  DataOutputStream outStr = new DataOutputStream(
    //    new BufferedOutputStream(
    //      ( fileOut_01 )));      // Datei kann mit dieser Methode nur FORTLAUFEND geschrieben werden
    //                                // == >> mit der folgenden Methode hat man aber überall Zugriff:
        File file_02 = new File("hex-out");   // für Dateizugriff auf hex-out
        file_02.delete();               // Löscht vorsichtshalber eine etwa bestehende Datei "hex-out"
                                        // diese sollte nicht durch ein anderes Program geöffnet sein.
        RandomAccessFile outStr = new RandomAccessFile("hex-out","rw");  // und legt sie neu an (leer)
        File file_01 = new File("hex-cd");    // für Dateizugriff auf hex-cd

    //  int dateigroesse = 0x00;            // holt Größe der Datei "hex-cd" um zu wissen wie groß das
    //  File file = new File("hex-cd");    
    //  dateigroesse = (int) file.length(); // - Array dafür werden soll -> Ergebnis in "dateigroesse"
    //  System.out.println("Laenge in Bytes: " + file.length());
    //  System.out.print("Dateigroesse = " + dateigroesse + " ");
    //  System.out.println("in Bytes");               // 3 x "System.out.print" ist Kontroll-Spielerei
    //
    // zwei Arrays für die Binär-Dateien (wobei das eine ja nicht gebraucht wird, und das andere ??? )
    //  byte[] datei_in  = new byte[dateigroesse];
    //  byte[] datei_aus = new byte[2 * dateigroesse];    //   ergibt evtl. Fehler, muss dann mit Hand
                                                          // bis höchstens 0xffffffff angepasst werden

    // Variablendeklaration:
    // file_01 und file_02 werden weiter oben schon deklariert.
    // instr und outStr    werden weiter oben schon deklariert.
    //  int r00 = 0;      // erstellt eine Var. Typ int für 1. CPU-Register
    //  int r01 = 0;      // wahlweise verwenden was geeigneter erscheint
        int r02 = 0;      // hier nur freischalten was wirklich gebraucht wird ...
        ...
    //  byte b000 = 0x00;
    //  byte b001 = 0x01;
    //  byte b002 = 0x02;
        int inDateigroesse = 0x00;
        int outDateigroesse = 0x00;
        int inStrAuswahl = 0x00; // = r12 = t4
        int inStrDaten = 0x00;   // = r10 = t2
        int outStrEnde = 0x00;   // = r09 = t1
        int outStrZurueck = 0x00;


    // Prog. selbst:
        inStrAuswahl = inStr.seek(1);
        inStrDaten = inStr.seek(2);

    //  AdS
        r04 = inStrAuswahl.readByte(); // 14474
        r03 = r04 + 0xFF10;            // 1447c
                                       // 14480


    //  b000 = inStr.readByte(); // liest 1 Byte in die Variable "b000", diese darf auch größer sein
    //  outStr.writeByte(b000);  // schreibt 1 Byte aus der Var. "b000", (wenn größer - z.B. Int =>
    //  b000 = inStr.readByte(); // wird das Nieder-Wertigste Byte geschrieben => also glücklicher-
    //  outStr.writeByte(b000);  // weise adäquat den Prozessor-Befehlen der PSX)
    //  b000 = inStr.readByte(); // (wird casten genannt, macht der Compiler meist ohne Aufforderung)
    //  outStr.writeByte(b000);
    //  b000 = inStr.readByte();
    //  outStr.writeByte(b000);  // kopiert einfach die ersten 4 Bytes der 1. in die 2. Datei

    //  inDateigroesse = (int) file_01.length();     // holt die aktuelle Dateilänge von hex-cd
    //  System.out.println("hex-cd  " + dateigroesse);
    //
    //  outDateigroesse = (int) file_02.length();     // holt die aktuelle Dateilänge von hex-out
    //  System.out.println("hex-out " + dateigroesse);

    //  outStr.seek(0);            // Zeiger der Ausgabedatei auf 1. Byte
    //  b000 = outStr.readByte();  // Das 1. Byte der Ausgabedatei einlesen - Zeiger geht auf 2. Byte!
    //  outStr.seek(4);            // Zeiger der Ausgabedatei auf 5. Byte (existiert noch nicht !! )
                                   // übersprungene Bytes werden mit 0x00 aufgefüllt !
    //  outStr.skipBytes(0x03);    // arbeitet mit Int. - aber keine Interpretation als negativer Wert
    //  b000 = outStr.readByte();
    //  outStr.writeByte(b000);  

    // planmäßiges Ende:
       outStr.close();        // Datei "hex-out" schließen
       inStr.close();         // Datei "hex-cd" braucht nicht geschlossen werden ??? (ist aber besser)
      }
    }

    Wäre cool. wenn das jemand für mich nach C# portieren könnte. Mit 2 Kleinkindern habe ich einfach nicht die Zeit, mich in C# einzuarbeiten - und ich will ja "nur" hobbymäßig Assembler "nachbilden ...

     

    PS.: ich muss mit der aktuellen Dateiposition belibig innerhalb beider Dateien wandern können - und die Datei sollte schon 1 GB groß werden dürfen (vorsorglich).

    • Bearbeitet Gast-110 Donnerstag, 25. November 2010 06:23 ist so genauer
    Donnerstag, 25. November 2010 02:15