Diskimage einlesen: Brauche mal Meinungen zu meinem Strukturkonzept

bit-streamer

Hallo zusammen,

bin neu hier.

Alles beschäftigt sich heute mit Emulationen und Diskimages, um z. B. den C64 mal wieder aufleben zu lassen. Einige Systeme haben noch keine Tools zum Fehlercheck von Images, ohne dass man den Emulator selbst anschmeißen muss und da drin geeignete Tools starten. (Das anvisierte System tut im Moment übrigens noch nichts zur Sache, bis das Tool fertig ist :))

Mein Problem nun: wie konzipiere ich das, damit ich das nicht nachher xmal umwerfen muss? Müsste einfach mal einen Expertenrat haben, der mir auch mal die Meinung sagt dass ich irgendwo Unsinn treibe - darf er gerne, ohne Akzeptanz von Kritik gibt's i. d. R. keinen guten Code. Andersrum, wenn ich einfach mal was dahincode und darauf aufbaue, wird das Programm irgendwann >= 2K Zeilen groß und dann wird's ne Sisyphusarbeit, den GPF zu lokalisieren.

gegeben sind:
Disk-Image mit 1024 Blöcken à 256 Bytes Daten.
JEDES Byte, Wort oder Langwort sollte direkt zugreifbar sein.

#include <stdlib.h>

typedef struct einzelBlk {
  unsigned char block_data [256];
  char * strInLW [256/4] /* String; kann 256/4 = 64 4-byte Strings aufnehmen */
  char * multiStr; /* fuer Strings, die mehrere Langwoerter umfassen koennen */

} einzelBlkS_t;

typedef struct diskImg {
  einzelBlkS_t * diskBlk [1024];
} diskImgS_t;

void baueImgS(diskImgS_t *);

int main(void)
{
  diskImgS_t img; /* RAM fuer 1024 _Zeiger_ auf Unterstruktur bereitstellen */
  diskImgS_t * imgZ = &img; /* zeigt auf grosse Struktur */

  baueImgS(imgZ);
}

/* ------------------------------ */

void baueImgS (diskImgS_t * zImg)
{
int i, j;
for (i = 0; i < 1024; i++)
{
   /* naechste Zeile reserviert: 
     - 1x Unterstruktur 'einzelBlk_t' selbst
     - 256 byte fuer Blockpuffer (Daten)
     - 64 char Zeiger fuer 1-Langwort-String
     - 1 char Zeiger fuer Multi-LW-String
   */  

  zImg->diskBlk[i] = malloc (256* sizeof (einzelBlkS_t));

  /* nun wird noch der Rest (Zeiger) alloziert */

  for (j = 0; j < 256; j++)
    zImg->diskBlk[i]->strInLW[j] = malloc (4 * sizeof(char));

  zImg->diskBlk[i]->multiStr = malloc (256 * sizeof(char));
}
}

Hi !

bit-streamer schrieb:

...
gegeben sind:
Disk-Image mit 1024 Blöcken à 256 Bytes Daten.
JEDES Byte, Wort oder Langwort sollte direkt zugreifbar sein.

Ich weiß nicht was genau du vorhast. Für dein Vorhaben kann dein Strukturkonzept durchaus ok sein.
Jedenfalls kannst du auch mit einem char Zeiger jedes Byte direkt erreichen, das ist bestimmt nix neues für dich.

Erstmal Speicher reservieren:
char* data = malloc ( 1024 * 256 );

Zack und über data kannst du nun jedes Byte einzeln adressieren.
Möchtest du die Images in der Form einlesen, wie es z.B. MagicISO macht und möglicher weise grafisch darstellen ?
Dann wä

Ich weiß auch nicht so recht, worauf du am Ende hinauswillst.
Wahrscheinlich hätte ich das ohne solche Strukturen gemacht.
Du hast da dann 1024 Block-Strukturen, die alle irgendwo im Speicher herumfliegen.
Wenn du das Image als ganzes irgendwo hinschreiben willst, mußt du erst einmal aus dem Speicher zusammensuchen.
Ich hätte also wie struct oder nicht struct ein großes Byte-Array für das Image.
Den Zugriff auf Blöcke/Worte/Bytes würde ich dann über Makros machen, die mir Zeiger zurückliefern.

Ach ja:
Du mußt aufpassen, daß sizeof(char) auch wirklich 1 ist.

flamer schrieb:

Du mußt aufpassen, daß sizeof(char) auch wirklich 1 ist.

das isses immer. über die anzahl der bits, die ein 'char' verschlingt, sagt sizeof() ja nix aus.

Da hast du wiedereinmal recht, alter Freund.
Aber nach 6 Monaten Wildnis muß ich ganz einfach überall meinen Senf dazugeben, auch wenn's Kuchen ist.