[MSX-C] Q&A official thread

Definitively JIFFY solution is the best. Since it works as TIME in BASIC, you can handle the desired fps of your game simply looping this variable. For example:

vertscr() {
	TINY i;
	for(i=0;i<212;i++){
		JIFFY=0;
		wrtvdp(VREG23,i);
		/* Wait for interrupt */
		while (JIFFY<2) {}
	}
}

We waits for 2 cycles of VDP, this is, we are setting the game at 30fps instead of 60fps.

It's true, they don't exists, I didn't find anything to use in Bios too. Perhaps we need to invoke MSX-DOS functions? Is there any way?

Hi JaviLM, we have talked about wrap MSX-DOS2 mapper functions to use in MSX-C, but really we have not seen an usage example still. I'm reading bdosfunc.h file and it has a lot values defined and a few functions at the end. For example:

#define _FORMAT (TINY)0x67 /* Format disk */

We have defined the following functions: bdosh(), call(), bdos(), calla(), bios(), callxx(). Since #defines are defining TINY values (this is, char), I suposse that correct functions to use are:
char bdos(c)
char c;
int bdosh(c)
char c;

Both of them are expecting a char parameter, so a call to MSX-DOS format function could be:

bdos(_FORMAT);

It's that right? Since we are talking about MSX-DOS(2) call functions, it should be a good moment to see how we can wrap mapper functions to use in MSX-C

Once again, thanks.

It's strange, bdos syntax don't adjust to the docs you attach. Take for example _FORMAT function. If we use bdos function of MSX-C, the syntax is:

You only passes a char as parameter. However in your page, it's supossed to operate with registers:

What function of MSX-C should be the correct? Thanks.

Let me try and answer both at the same time.

How to encapsulate and use MSX-DOS2 system calls in MSX~C

Let's look at a couple of MSX-DOS2 system calls: _FFIRST (040h) and _FNEXT (041h). To see what they do, check Grauw's function reference (this link).

_FFIRST takes these parameters:

• Register DE contains the address of a C string containing a filename pattern ("*.*", "FILE*.*", "a:\tmp\", etc)
• Register B contains a bitmask that defines what kind of files/directories this system call will find.
• Register IX contains the address of an empty File Info Block, that will be updated with the file's details, if any file matches

To run this system call from MSX-DOS2 first we put the registers in a struct of type XREG, and then call callxx(). callxx() fills the XREG struct with the values returned by the system call. This is how I encapsulated this call in MSX-C in my tests:

VOID	_ffirst(pattern, fib, regs)
char	*pattern;
FIB	*fib;
XREG	*regs;
{
	regs->bc = SEARCH_MASK | (unsigned)_FFIRST;
	regs->de = (unsigned)pattern;
	regs->ix = (unsigned)fib;
	callxx(BDOS, regs);
}

The parameters for _ffirst() are:

• A pointer to a string containing the file pattern
• A pointer to a File Info Block that will be filled with information about the file
• A pointer to an XREGS struct so we can inspect the result from the main program

_FNEXT is a bit simpler:

• Register B contains a bitmask that defines what kind of files/directories this system call will find.
• Register IX contains the address of the File Info Block that resulted from calling _FFIRST.

I’ve implemented it like this:

VOID	_fnext(fib, regs)
FIB	*fib;
XREG	*regs;
{
	regs->bc = SEARCH_MASK | (unsigned)_FNEXT;
	regs->ix = (unsigned)fib;
	callxx(BDOS, regs);
}

How to read directories in MSX-C

To show how this works, I’ve written a very basic implementation of opendir() that just prints the list of files found on the screen. A more serious version would return a pointer to an array of structs describing the files, but for demonstration purposes this will be enough.

Here’s the full program:

#include <stdio.h>
#include <bdosfunc.h>

#define	S_RO		0x01
#define	S_HIDDEN	0x02
#define	S_SYSTEM	0x04
#define	S_VOLUME	0x08
#define	S_DIRECT	0x10
#define	S_ARCHIV	0x20
/* reserved		0x40 */
#define	S_DEVICE	0x80

#define	SEARCH_MASK	(unsigned)((S_RO|S_HIDDEN|S_SYSTEM|S_DIRECT) * 256)

VOID	_ffirst(pattern, fib, regs)
char	*pattern;
FIB	*fib;
XREG	*regs;
{
	regs->bc = SEARCH_MASK | (unsigned)_FFIRST;
	regs->de = (unsigned)pattern;
	regs->ix = (unsigned)fib;
	callxx(BDOS, regs);
}

VOID	_fnext(fib, regs)
FIB	*fib;
XREG	*regs;
{
	regs->bc = SEARCH_MASK | (unsigned)_FNEXT;
	regs->ix = (unsigned)fib;
	callxx(BDOS, regs);
}

VOID	opendir(pattern)
char	*pattern;
{
	FIB		fib;
	BOOL		done;
	XREG		regs;

	/* Make sure the whole FIB is set to 0			*/
	memset(&fib, (char)0, sizeof(FIB));

	/* Search for first entry */
	_ffirst(pattern, &fib, &regs);

	if (!(regs.af & 0xff00)) {
		/* Found at least one matching file	*/
		printf("Found: %s\n", fib.name);

		/* Look for more matches		*/
		done = FALSE;

		while(!done) {
			_fnext(&fib, &regs);
			if (regs.af & 0xff00) {
				done = TRUE;
			} else {
				printf("Found: %s\n", fib.name);
			}
		}
	}
}

char	main(argc, argv)
int	argc;
char	*argv[];
{
	if (argc < 2) {
		printf("Usage: opendir \n");
		exit(0);
	}

	printf("Pattern: %s\n", argv[1]);
	opendir(argv[1]);
}

Compile it with this script:

cf opendir
cg -k opendir
m80 =opendir/z
rem del %1.mac
l80 a:\msxc\lib\ck,opendir,a:\msxc\lib\mlib/s,a:\msxc\lib\clib/s,a:\msxc\lib\crun/s,a:\msxc\lib\cend,opendir/n/y/e:xmain


This will generate a program called OPENDIR.COM. Run it with a parameter to list files and directories:

• OPENDIR a:¥
• OPENDIR *.COM
• OPENDIR *.*