[MSX-C] Q&A official thread

Here goes an almost working code:

#include<stdio.h>
#include<glib.h>

#define REGISTROS 16
int paleta[REGISTROS];
int valores[REGISTROS];

NAT grbdat[16]={0x0442,0x0000,0x0400,0x0040,0x0200,0x0221,0x0231,0x0224,0x0346,0x0777,0x0436,0x0120,0x0555,0x0420,0x0250,0x0113};

readHex() {
	FILE *file;
	char *head;
	char str[2];
	int i;
	int valor;
	printf("Loading pal...\n");
	file=fopen("arthur4.pl5","rb");
	fread(head,sizeof(char),7,file); /* Quitamos cabecera */
	fread(paleta,sizeof(int),REGISTROS,file);
	printf("Loaded\n");
	fclose(file);
	for(i=0;i<REGISTROS;i++) {
		printf("%x ",paleta[i]); /* 1st printf */
		printf("%x ",grbdat[i]); /* 2nd printf */
		sprintf(str,"%x", paleta[i]);
		sscanf(str,"%x",&valor); 
		printf("%x ",valor); /* 3rd printf */
	}
}

main() {
	readHex();
}

The 3 printf prints exactly the same, so it's supossed that palette is being readed correctly.
442 0 400 ...

However this funcion works (sets palete correctly):

loadplt() {
	TINY pal;
	iniplt();
	for(pal=0;pal<16;pal++) {
		setplt(pal,grbdat[pal]); 
	}
	rstplt();
} 

And this one not:

ldplt() {
	FILE *fp;
	char *head;
	char str[2];
	int i;
	NAT valor;
	TINY pal;
	fp=fopen("arthur4.pl5","rb");
	if(fp==NULL) {
		printf("File read error!");
		return;
	}
	fread(head,sizeof(char),7,fp);		 
	fread(paleta,sizeof(int),REGISTROS,fp);
	fclose(fp);
	iniplt();
	for(pal=0;pal<16;pal++) {
		sprintf(str,"%x",paleta[i]);
		sscanf(str,"%x",&valor);
		setplt(pal,&valor);
	}
	rstplt(); 
}

What's wrong?

Also, here’s an example of loading into a struct:

struct BinPalette {
   TINY head[7];            /* char */
   NAT paleta[REGISTROS];   /* int */
};

ldplt() {
   FILE *fp;
   BinPalette binpal;
   int i;
   TINY pal;

   fp = fopen("arthur4.pl5", "rb");
   if (fp == NULL) {
      printf("File read error!");
      return;
   }
   fread(&binpal, sizeof(BinPalette), 1, fp);
   fclose(fp);
   iniplt();
   for (pal = 0; pal < REGISTROS; pal++) {
      setplt(pal, binpal.paleta[i]);
   }
   rstplt(); 
}

Note that I’m unfamiliar with the exact syntax of K&R C so fingers crossed that it works , but hopefully it’ll illustrate the idea.

What about this?

#define PALETTE_COLOR_COUNT 16

void ldplt(void) {
	FILE *f;
	NAT palette[PALETTE_COLOR_COUNT];
	NAT palette_address;
	
	palette_address = 0x7680; // palette address on VRAM
	
	f = fopen("file.pl5", "rb");
	if(f != NULL) {
		fseek(f, 7, SEEK_SET); // bypass the header
		fread(palette, sizeof(NAT), PALETTE_COLOR_COUNT, f);
		fclose(f);
		
		// copy palette to VRAM palette address
		ldirvm(palette_address, palette, sizeof(NAT)*PALETTE_COLOR_COUNT);
		// restore the palette
		rstplt();
	}
}

It would be useful to have a "seek", at least forward, function for files. Maybe this one works:

#define FSEEK_BUFFER_SIZE 32
#define FSEEK_STEPS_SHIFT 5 // FSEEK_STEPS_SHIFT = log2(FSEEK_BUFFER_SIZE)

int ffwd(int size, FILE *f) {
	char buffer[FSEEK_BUFFER_SIZE];
	int steps, remainder;
	
	steps = size >> FSEEK_STEPS_SHIFT;
	remainder = size - (steps << FSEEK_STEPS_SHIFT);
	
	// steps
	while(steps > 0) {
		fread(buffer, FSEEK_BUFFER_SIZE, 1, f);
		if(feof(f) || ferror(f)) {
			return 0; // fail
		}
		steps--;
	}
	// remainder
	if(remainder > 0) {
		fread(buffer, remainder, 1, f);
		if(feof(f) || ferror(f)) {
			return 0; // fail
		}
	}
	return 1; // success
}

A global byte array?

The space will be reserved statically, although you can’t tell it what start address it must have (idk if you need that).