#include <dos.h>
#include <dir.h>
#include <stdio.h>
#include <windows.h>
#include <string.h>
#include <conio.h>
#include <sys\stat.h>
#include <fcntl.h>
#include <io.h>
#include "routines.h"
#include "datom.h"
extern unsigned char adres_b000;
extern unsigned char capsstatus;
extern unsigned char bEnd;
extern unsigned char bCursor;
extern unsigned char scale_x, scale_y;
extern unsigned char msb;
extern unsigned char joystat;
extern unsigned char venster_xlo; // coordinaten tekstvenster
extern unsigned char venster_ylo; //
extern unsigned char venster_xrb; //
extern unsigned char venster_yrb; //
extern unsigned int gwindow_xlo; // coordinaten grafisch venster
extern unsigned int gwindow_ylo; //
extern unsigned int gwindow_xrb; //
extern unsigned int gwindow_yrb; //
extern unsigned char kleur;
extern unsigned int rvenster_xrb;
extern unsigned int iobase;
extern unsigned char	regels;
extern BYTE bscan, bascii;
extern BOOL bShift, bCaps, bCtrl;
extern BOOL bKey;
extern BOOL bClear0, bGraph;
extern int rb_xco, rb_yco, nJoyb;
char szFilename[30];
extern BOOL		bPrinterstatus;
extern FILE		*prnfile;
extern char		schermpag;
extern BYTE		resettype;
unsigned char buf[256];
unsigned char buffer[256];
unsigned char keytab [] = {
0x00,0x71,0x2C,0x51,0x44,0x45,0x46,0x47,0x40,0x10,0x17,0x16,0x15,
0x14,0x13,0x2B,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x48,0x18,0x1F,0x1E,
0x1D,0x1C,0x23,0x43,0x53,0x54,0x55,0x56,0x39,0x50,0x20,0x27,0x26,
0x25,0x24,0x3C,0x00,0x1B,0x73,0x74,0x75,0x76,0x77,0x70,0x28,0x2F,
0x2E,0x2D,0x00,0x06,0x00,0x37,0x00,0x3D,0x3E,0x3F,0x38,0x0E,0x0D,
0x0C,0x0B,0x08,0x0F,0x00,0x00,0x09,0x2A,0x21,0x04,0x33,0x00,0x31,
0x07,0x0A,0x32,0x29,0x1A,0x19,0x00,0x00,0x00,0x67,0x68,0x69,0x04,
0x64,0x65,0x66,0x07,0x61,0x62,0x63,0x60,0x6A
};
unsigned char kbmatrix [] = {
0x99,0x05,0x21,0x11,0x01,0x92,0x82,0x72,0x62,0x52,
0x42,0x31,0x02,0x32,0x41,0x51,0x04,0x45,0x23,0x95,
0x75,0x25,0x65,0x84,0x24,0x14,0x80,0x60,0x61,0x99,
0x63,0x85,0x33,0x13,0x03,0x94,0x74,0x64,0x54,0x22,
0x73,0x50,0x99,0x70,0x15,0x35,0x43,0x55,0x53,0x34,
0x44,0x12,0x93,0x83,0x99,0x99,0x99,0x90,0x40
	 };
unsigned char setkey [] ={0xFE,0xFD,0xFB,0xF7,0xEF,0xDF,0xBF,0x7F };
unsigned char resetkey [] ={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80 };
unsigned char keymatrix [16];
extern int xco, yco;
extern char scherm[50][99];
void drukaf()
/*
#00 Druk $0 af
Invoer: geen
Uitvoer: geen
*/
{
}
void keyb()
/*
#01 Keyboard scan
	 Invoer: geen
Uitvoer: scan code (1 byte)
keyboard status (1 byte)
De scan codes zijn niet gelijk aan de standaard PC-
scancodes. Deze codes worden door de Atom als index
gebruikt om de bijbehorende ascii waarde te bepalen uit
een tabel.
Als u gebruik wil maken van keyboard codes wordt commando
#3A aanbevolen; daarmee zijn ook functietoetsen uit te
lezen.
De keyboard status bits hebben de volgende betekenis:

Door de Atom wordt de TAB toets gebruikt als COPY toets.
*/
{
unsigned char toets=0, status = 0;
if (bShift)
status |= 0x80;
if (bCtrl)
status |= 0x40;
if (bKey == TRUE) {
if (bscan < 0x46) {
toets = keytab[bscan];
status |= 0x01;
}
bKey = FALSE;
}
WRITEBYTE(iobase, toets);
WRITEBYTE(iobase, status);
}
void copy()
/*
#02 Lees karakter op cursorpositie
Invoer: geen
Uitvoer: ascii waarde van teken op cursorpositie
Wordt o.a. gebruikt bij afhandeling van copy toets.
*/
{
char tekst[40];
WRITEBYTE(iobase, (char) scherm[yco][xco]);
}
void gplot()
/*
#03 Plot pixel
Invoer: X-coördinaat (1 word)
Y-coördinaat (1 word)
Plot mode (1 byte)
Uitvoer: geen
De coördinaten zijn afhankelijk van de grafische
resolutie van de videokaart. Voor Hercules is dat 720*348
en voor CGA is dat 640*200. Dit commando voert een
bewerking uit met het opgegeven pixel. Deze bewerkingen
zijn:
mode = 1 -> zet pixel
mode = 2 -> inverteer pixel
mode = 3 -> wis pixel
*/
{
unsigned int x,y;
unsigned int plot;
unsigned int result;
result = READBYTEW(iobase); // low value
x = result & 255;
result = READBYTEW(iobase); // high value
x = x + (256 * result);
result = READBYTEW(iobase); // low value
y = result & 255;
result = READBYTEW(iobase); // high value
y = y + (256 * result);
result = READBYTEW(iobase);
plot = result & 255;
pixel(x, y, plot);
}
void igraph()
/*
#04 Initialiseer grafische mode
Invoer: geen
Uitvoer: geen
Dit commando schakelt de videokaart om naar de grafische
mode. Voor EGA/VGA kaarten wordt de CGA mode ingeschakeld
met een resolutie van 640*200.
*/
{
// Binnen windows heeft deze functie geen betekenis
bGraph = TRUE;
// settimers(hWnd);
wClear();
}
void simulate4()
/*
#05 Plot pixel in clear 4 coördinatenstelsel
Invoer: X-coördinaat (1 word)
Y-coördinaat (1 word)
	 Plot mode (1 byte)
Uitvoer: geen
De coördinaten zijn in dit geval gelijk aan de grafische
resolutie van de Atom (256*192). Verder is dit commando
hetzelfde als #03.
mode = 1 -> zet pixel
mode = 2 -> inverteer pixel
mode = 3 -> wis pixel
*/
{
unsigned int x,y;
unsigned int plot;
unsigned int result;
result = READBYTEW(iobase); // low value
x = result & 255;
result = READBYTEW(iobase); // high value
x = x + (256 * result);
result = READBYTEW(iobase); // low value
y = result & 255;
result = READBYTEW(iobase); // high value
y = y + (256 * result);
result = READBYTEW(iobase);
plot = result & 255;
if (y < 192 && x < 256) {
pixel(x, y, plot);
}
}
void ramfnt()
/*
#06 Ramfont laden
Invoer: filenaam van het ramfont als ASCIIZ string
Uitvoer: errorcode
De naam van het te laden font wordt als ascii string
overgestuurd. Deze string eindigt met de code #00. De
filenaam mag een kompleet pad bevatten maar geen
wildcards (* of ?).
Als het font geladen is, is de errorcode #00. Als een
fout opgetreden is (bijv. font niet gevonden) dan duidt
de uitvoer de aard van de fout aan.
*/
{
unsigned char dummy;
int i;
do {
dummy = READBYTEW(iobase);
} while (dummy !=0);
// Binnen windows heeft deze functie geen betekenis
}
int schrijf()
/*
#07 Schrijf string in grafische mode
Invoer: X-coördinaat (1 word)
Y-coördinaat (1 word)
ASCIIZ string
Uitvoer: geen
De opgegeven string wordt geplot vanaf de coördinaten X
en Y.
*/
{
char szTekst[80];
int i=0;
int x, y;
unsigned int result;
result = READBYTEW(iobase); // low value
x = result & 255;
result = READBYTEW(iobase); // high value
x = x + (256 * result);
result = READBYTEW(iobase); // low value
y = result & 255;
result = READBYTEW(iobase); // high value
y = y + (256 * result);
do {
szTekst[i] = READBYTEW(iobase);
} while (szTekst[i++] !=0);
// de handel nog even via de plot vector wegsturen
return TRUE;
}
void schaal()
/*
#08 Zet horizontale en vertikale schaalfactor
Invoer: horizontale schaalfactor (1 byte)
vertikale schaalfactor (1 byte)
Uitvoer: geen
De horizontale en vertikale schaalfactoren bepalen de
afmetingen van de karakters die met commando #07 worden
afgedrukt.
*/
{
scale_x = READBYTEW(iobase);
scale_x = READBYTEW(iobase);
}
void cursor_on()
/*
#09 Zet cursor aan
Invoer: geen
Uitvoer: geen
De cursor verschijnt als knipperend streepje op het
scherm.
*/
{
bCursor = TRUE;
}
void cursor_off()
/*
#0A Zet cursor uit
Invoer: geen
Uitvoer: geen
De cursor verdwijnt van het scherm.
*/
{
bCursor = FALSE;
}
int loadfile()
/*
#0B File van disk laden
Invoer: filenaam als ASCIIZ string
Uitvoer: errorcode, bloklengte(n) en data
Als de PC de filenaam ontvangen heeft wordt de file
geopend. Als dit lukt wordt de errorcode #00 (geen error)
teruggestuurd. Vervolgens wordt een datablok van max. 255
bytes gelezen. De lengte van dit datablok wordt naar de
Atom gestuurd, direct gevolgd door de data. Als het einde
van de file bereikt is dan ontvangt de Atom een
filelengte van #00.
*/
{
FILE *input;
int i, aantal;
leesnaam();
if ((input = fopen(szFilename, "rb+")) == NULL) {
WRITEBYTE(iobase, 1); // zeg dat de file *niet* geopend is
return FALSE;
}
WRITEBYTE(iobase, 0); // zeg dat de file geopend is
do {
/* read the data and display it */
aantal = fread(buf, sizeof(char), 255, input);
WRITEBYTE(iobase, aantal);
for (i=0; i<aantal; i++) {
WRITEBYTE(iobase, buf[i]);
	 }
} while (aantal == 255);
WRITEBYTE(iobase, 0); // klaar is leen
fclose(input);
return TRUE;
}
int savefile()
/*
#0C File naar disk schrijven
Invoer: filenaam als ASCIIZ string
	 bloklengte(n)
	 data
Uitvoer: errorcode
De PC leest de filenaam en probeert de file te openen.
Als de file reeds bestond dan wordt deze overschreven
(zonder vermelding). Als de file nog niet bestond dan
wordt deze aangemaakt. Als de file geopend is wordt het
resultaat overgestuurd naar de Atom; errorcode #00 geeft
aan dat er geen fout opgetreden is. Daarna begint de
data-overdracht. Eerst geeft de Atom de bloklengte,
direct gevolgd door data. Als een blok overgestuurd is
van Atom naar PC en het blok is naar disk geschreven dan
meldt de PC het aantal geschreven bytes naar de Atom. Als
dit niet gelijk is aan de bloklengte dan is de disk vol.
Als de PC een bloklengte #00 ontvangt wordt de file
gesloten. 
*/
{
FILE *output;
int i, aantal, result;
leesnaam();
if ((output = fopen(szFilename, "wb+")) == NULL) {
WRITEBYTE(iobase, 1); // zeg dat de file *niet* geopend is
return FALSE;
}
WRITEBYTE(iobase, 0); // zeg dat de file geopend is
while ((aantal = READBYTEW(iobase)) !=0) { // lees de bloklengte
for (i=0; i<aantal; i++) {
result=READBYTEW(iobase);
result &= 255;
buf[i]=result;
}
fwrite(buf, sizeof(char), aantal, output);
WRITEBYTE(iobase, aantal);
}
fclose(output);
return TRUE;
}
void cat()
/*
#0D Disk catalog op scherm afbeelden
Invoer: zoekpad/filespec als ASCIIZ string
Uitvoer: geen
De PC leest de filespecificatie, deze mag een drive,
directory en een file-aanduiding met wildcards bevatten,
en drukt deze op het scherm af. De uitvoer wordt door de
PC direct op het scherm gezet en komt niet ter
beschikking van de Atom. Een lege string wordt behandeld
als *.*
Hidden files worden niet op het scherm weergegeven.
*/
{
struct 		ffblk ffblk;
int 		done, i, count=0;
char 		tekst[80];
leesnaam();
if (strlen(szFilename) == 0)
strcpy(szFilename, "*.*");
done = findfirst(szFilename, &ffblk, 0);
Process(CTRL_M); // genereeer een linefeed/cr
while (!done) {
sprintf(tekst, "%s", ffblk.ff_name);
for (i=0; i<strlen(tekst); i++) {
	 Process(tekst[i]);
	 }
for (;i<13; i++) {
	 Process(0x20);
	 }
count += 13;
if (count+13 > rvenster_xrb) {
	 Process(CTRL_M); // genereer een linefeed/cr
	 Process(CTRL_J); // genereer een linefeed/cr
	 count = 0;
	 }
done = findnext(&ffblk);
}
// WRITEBYTE(iobase, 0);
}
int adir()
/* Hulpfunctie voor het ophalen van de directory
*/
{
leesnaam();
if (strlen(szFilename) != 0) {
if (szFilename[1] == ':') {
	 return szFilename[1] - 'A';
	 }
}
return 0;
}
void achdir()
/*
#0E Veranderen/opvragen van huidige directory
Invoer: nieuwe directory als ASCIIZ string
Uitvoer: foutcode
	 huidige directory als ASCIIZ string
Dit commando verandert van directory naar de opgegeven
directory. Als er geen fout opgetreden is, wordt de
foutcode #00, gevolgd door de actuele directory als
ASCIIZ string naar de Atom gestuurd.
Als de foutcode niet #00 is, dan volgt er geen ASCIIZ
	 string.
*/
{
int i;
// if (adir() == 0) {
leesnaam();
if (strlen(szFilename) != 0) {
if (chdir(szFilename) == 0) {
	 WRITEBYTE(iobase, 0);
	 WRITEBYTE(iobase, szFilename[0]-'A');
	 for (i=1; i<strlen(szFilename); i++)
	 WRITEBYTE(iobase, szFilename[i]);
	 WRITEBYTE(iobase, 0);
	 return;
	 }
}
WRITEBYTE(iobase, 255);
}
void armdir()
/*
#0F Verwijder directory
Invoer: te verwijderen directory als ASCIIZ string
Uitvoer: foutcode
	 lege ASCIIZ string
De opgegeven directory wordt indien mogelijk van de disk
verwijderd. Als dat gelukt is dan volgt nogmaals een #00
byte na de foutcode. Als de foutcode niet #00 is, dan
volgt er geen ASCIIZ string.
*/
{
int i;
leesnaam();
if (strlen(szFilename) != 0) {
if (rmdir(szFilename) == 0) {
	 WRITEBYTE(iobase, 0);
	 return;
	 }
}
WRITEBYTE(iobase, 255);
}
void amkdir()
/*
#10 Maak directory aan
Invoer: aan te maken directory als ASCIIZ string
Uitvoer: foutcode
	 lege ASCIIZ string
De opgegeven directory wordt indien mogelijk op de disk
aangemaakt. Als dat gelukt is dan volgt nogmaals een #00
byte na de foutcode. Als de foutcode niet #00 is, dan
volgt er geen ASCIIZ string.
*/
{
int i;
leesnaam();
if (strlen(szFilename) != 0) {
if (mkdir(szFilename) == 0) {
	 WRITEBYTE(iobase, 0);
	 return;
	 }
}
WRITEBYTE(iobase, 255);
}
void delete()
/*
#11 Verwijder file van disk
Invoer: filespec als ASCIIZ string
Uitvoer: foutcode
Deze functie verwijdert de opgegeven files van disk, mits
deze niet Read-Only en/of Hidden zijn. Als er geen files
gewist kunnen worden dan is de foutcode niet gelijk aan
#00. Als er één of meerdere files gewist zijn, dan is de
foutcode #00. De filespecificatie mag geen drive en
directory bevatten, eventueel wel wildcards.
*/
{
struct find_t ffblk;
int done;
int 	rc = 1;
leesnaam();
done = _dos_findfirst(szFilename, _A_NORMAL, &ffblk);
Process(CTRL_M); // genereeer een linefeed/cr
while (!done) {
rc = 0;
unlink(ffblk.name);
done = _dos_findnext(&ffblk);
}
WRITEBYTE(iobase, rc);
}
void alock()
/*
#12 Lock files
Invoer: filespec als ASCIIZ string
Uitvoer: foutcode
Deze functie zet van de opgegeven files het Read-Only
bit. Als er geen files gelocked kunnen worden dan is de
	 foutcode niet gelijk aan #00. Als er één of meerdere
files gelocked zijn, dan is de foutcode #00. De
filespecificatie mag bestaan uit een drive, directory en
wildcards.
*/
{
struct find_t ffblk;
int done;
int 	rc = 1;
leesnaam();
done = _dos_findfirst(szFilename, _A_NORMAL, &ffblk);
Process(CTRL_M); // genereeer een linefeed/cr
while (!done) {
rc = 0;
// lock(ffblk.name);
done = _dos_findnext(&ffblk);
}
WRITEBYTE(iobase, rc);
}
void aunlock()
/*
#13 Unlock files
Invoer: filespec als ASCIIZ string
Uitvoer: foutcode
Deze functie reset van de opgegeven files het Read-Only
bit. Als er geen files geunlocked kunnen worden dan is de
foutcode niet gelijk aan #00. Als er één of meerdere
files geunlocked zijn, dan is de foutcode #00. De
filespecificatie mag bestaan uit een drive, directory en
wildcards.
*/
{
struct find_t ffblk;
int done;
int 	rc = 1;
leesnaam();
done = _dos_findfirst(szFilename, _A_NORMAL, &ffblk);
Process(CTRL_M); // genereeer een linefeed/cr
while (!done) {
rc = 0;
// unlock(ffblk.name);
done = _dos_findnext(&ffblk);
}
WRITEBYTE(iobase, rc);
}
void adrive()
/*
#14 Verander actuele drive
Invoer: drive nummer (1 byte)
Uitvoer: geen
Met dit commando kan de actuele drive gewijzigd worden.
Voor drive A: is het drivenummer 0, drive B: is drive
nummer 1 etc.
Er is geen terugmelding en controle op geldigheid van het
drive nummer.
*/
{
int result;
result = READBYTEW(iobase);
setdisk('A' + result);
}
void msdos()
/*
#15 Ga naar MS-DOS
Invoer: geen
Uitvoer: geen
Dit commando be‰indigt het Atom terminal programma op de
PC en de besturing wordt teruggegeven aan het oproepende
programma. Voordat dit commando wordt uitgevoerd dienen
geopende bestanden eerst gesloten te worden.
*/
{
bEnd = TRUE;
}
void hide()
/*
#16 Maak file verborgen
Invoer: filespec als ASCIIZ string
Uitvoer: foutcode
Deze functie zet van de opgegeven files het Hidden bit.
Als er geen files verborgen kunnen worden dan is de
	 foutcode niet gelijk aan #00. Als er één of meerdere
files verborgen zijn, dan is de foutcode #00. De
filespecificatie mag bestaan uit een drive, directory en
wildcards.
*/
{
struct find_t ffblk;
int done;
int 	rc = 1;
leesnaam();
done = _dos_findfirst(szFilename, _A_NORMAL, &ffblk);
Process(CTRL_M); // genereeer een linefeed/cr
while (!done) {
rc = 0;
// hide(ffblk.name);
done = _dos_findnext(&ffblk);
}
WRITEBYTE(iobase, rc);
}
void unhide()
/*
#17 Maak files weer zichtbaar
Invoer: filespec als ASCIIZ string
Uitvoer: foutcode
Deze functie reset van de opgegeven files het Hidden bit.
Als er geen files zichtbaar kunnen worden gemaakt dan is
de foutcode niet gelijk aan #00. Als er één of meerdere
files zichtbaar gemaakt zijn, dan is de foutcode #00. De
filespecificatie mag bestaan uit een drive, directory en
wildcards.
*/
{
struct find_t ffblk;
int done;
int 	rc = 1;
leesnaam();
done = _dos_findfirst(szFilename, _A_NORMAL, &ffblk);
Process(CTRL_M); // genereeer een linefeed/cr
while (!done) {
rc = 0;
// unhide(ffblk.name);
done = _dos_findnext(&ffblk);
}
WRITEBYTE(iobase, rc);
}
void info()
/*
#18 Opvragen file informatie
Invoer: filenaam als ASCIIZ string
Uitvoer: foutcode
	 file header (16 bytes)
	 attribuut ( 1 byte)
	 tijd en datum van laatste schrijfopdracht
De opgegeven file wordt gezocht en indien gevonden wordt
de file header overgestuurd naar de Atom. Bij succes is
de foutcode #00.
De fileheader bevat de volgende informatie:
- load adres van file, twee bytes
- exec adres van file, twee bytes
- dataveld lengte, vier bytes
- gereserveerd, acht bytes
Aangezien de header in de file zelf is opgeslagen, is de
totale file lengte zestien bytes langer dan de
doorgegeven lengte; deze bytes zijn niet meegeteld in de
dataveld lengte.
De tijd en datum van de laatste schrijfopdracht naar de
file, normaal gesproken is dat het moment waar de file
naar disk is geschreven, wordt in twee woorden
doorgegeven. Hiervan hebben de bits de volgende
betekenis:
Tijd: bit 0-4: seconden/2 (0-29)
	 bit 5-10: minuten (0-59)
	 bit 11-15: uren (0-23)
Datum: bit 0-4: dag van de maand (0-31)
	 bit 5-8: maand (1-12)
	 bit 9-15: jaar-1980 (0-127)
*/
{
struct find_t ffblk;
int done, aantal, i;
unsigned attrib;
FILE *input;
leesnaam();
done = _dos_findfirst(szFilename, _A_NORMAL,&ffblk);
Process(CTRL_M); // genereeer een linefeed/cr
while (!done) {
if (_dos_getfileattr(szFilename, &attrib) != 0) {
	 WRITEBYTE(iobase, 255);
	 return;
	 }
WRITEBYTE(iobase, 0); // geef aan dat file is gevonden
if ((input = fopen(szFilename, "rb+")) == NULL) {
	 WRITEBYTE(iobase, 1); // zeg dat de file *niet* geopend is
	 return;
	 }
else {
	 aantal = fread(buf, sizeof(char), 16, input);
	 fclose(input);
	 if (aantal == 16) {
	 for (i=0; i<16; i++) {
		WRITEBYTE(iobase, buf[i]);
		}
	 WRITEBYTE(iobase, attrib);
	 }
	 else {
	 WRITEBYTE(iobase, 255);
	 return;
	 }
	 }
done = _dos_findnext(&ffblk);
}
WRITEBYTE(iobase, 0);
}
void geluid()
/*
#19 Produceer geluid
Invoer: toonhoogte (1 byte)
	 toonduur (1 byte)
Uitvoer: geen
De toonhoogte en de toonduur zijn beiden één byte lang.
De maximale toonhoogte ligt rond de waarde 100. Dit is al
een behoorlijk hoge toon. De waarden vanaf 128 geven een
ongedefinieerde toon. De toonduur wordt gegeven in 18den
van seconden.
Als de toonhoogte 0 bedraagt dan wordt geen geluid
geproduceerd; het commando kan dan gebruikt worden om de
opgegeven toonduur te wachten.
*/
{
unsigned hoogte, duur;
hoogte = READBYTEW(iobase);
duur = READBYTEW(iobase);
WinBiep(hoogte, duur);
}
void bliep()
/*
#1A Instelling bell-toon
Invoer: toonhoogte (1 byte)
	 toonduur (1 byte)
Uitvoer: geen
Met dit commando worden de toonhoogte en de toonduur
ingesteld voor het bell-signaal. Dit is de pieptoon die
gegeven wordt voor de ASCII code #07. Wat de waarden
betreft zijn deze gelijk als voor het commando #19.
*/
{
unsigned hoogte, duur;
hoogte = READBYTEW(iobase);
duur = READBYTEW(iobase);
WinBiep(hoogte, duur);
}
void errmsg()
/*
#1B Druk foutmelding af
Invoer: Atom errorcode (1 byte)
Uitvoer: geen
Dit commando drukt een tekststring, behorende bij de
gegeven errorcode, af op het beeldscherm van de PC. Dit
schrijven doet de PC zelf. Er wordt geen informatie
overgestuurd naar de Atom.
*/
{
int result;
result = READBYTEW(iobase);
PrintError(result);
}
void knaagdier()
/*
#1C Oproepen muisfunctie (PC INT 33)
Invoer: registerset (4 words)
Uitvoer: registerset (4 words)
Hiermee kunnen functies van de PC-muisdriver opgeroepen
worden. De registerset bestaat uit acht bytes, die de
registers AX, BX, CX en DX van de 8088/80x86 processor
voorstellen. Voor het gebuik van deze functie wordt
verwezen naar de handleiding voor muizen.
*/
{
unsigned char tab[9]; // 8 posities voor AL, AH .. DL, DH
read8b(tab);
write8b(tab);
}
void defmuismasker()
/*
#1D Definieer muiscursor
Invoer: muismasker (64 bytes)
Uitvoer: geen
Met muisfunctie #09 kan de vorm van de grafische
muiscursor opgegeven worden. Deze dient dan echter wel
eerst in het geheugen van de PC te staan. Met commando
#1D kan de vorm van de muiscursor in het PC geheugen
geplaatst worden. Voor het verdere gebruik van deze
functie wordt ook verwezen naar de handleiding voor
muizen.
*/
{
unsigned char muistab[65];
int i;
char szTekst[] = "Deze functie (defmuismasker) heeft binnen windows geen waarde\r\n";
for (i=0; i<64; i++)
muistab[i]=READBYTEW(iobase);
for (i=0; i<strlen(szTekst); i++)
Process(szTekst[i]);
}
void cursorpos()
/*
#1E Opvragen cursorpositie
Invoer: geen
Uitvoer: X en Y coördinaat tekstcursor (2 bytes)
Dit commando geeft de positie van de tekstcursor naar de
Atom. De linkerbovenhoek is (0,0)
*/
{
WRITEBYTE(iobase, xco);
WRITEBYTE(iobase, yco);
}
void video()
/*
#1F Oproepen video functies (PC INT 10)
Invoer: registerset (4 words)
Uitvoer: registerset (4 words)
Hiermee kunnen videofuncties van het PC-BIOS opgeroepen
worden. De registerset bestaat uit acht bytes, die de
registers AX, BX, CX en DX van de 8088/80x86 processor
voorstellen. Voor het gebuik van deze functie wordt
verwezen naar betreffende literatuur.
*/
{
unsigned char tab[9]; // 8 posities voor AL, AH .. DL, DH
char szTekst[] = "Deze functie (Video) heeft binnen windows geen waarde\r\n";
int i;
read8b(tab);
write8b(tab);
for (i=0; i<strlen(szTekst); i++)
Process(szTekst[i]);
}
void serport()
/*
#20 Oproepen seri‰le communicatie functies (PC INT 14)
Invoer: registerset (4 words)
Uitvoer: registerset (4 words)
Hiermee kunnen communicatiefuncties van het PC-BIOS
opgeroepen worden. De registerset bestaat uit acht bytes,
die de registers AX, BX, CX en DX van de 8088/80x86
processor voorstellen. Voor het gebuik van deze functie
wordt verwezen naar betreffende literatuur.
*/
{
unsigned char tab[9]; // 8 posities voor AL, AH .. DL, DH
char szTekst[] = "Deze functie (serport) heeft binnen windows geen waarde\r\n";
int i;
read8b(tab);
write8b(tab);
for (i=0; i<strlen(szTekst); i++)
Process(szTekst[i]);
}
void printit()
/*
#21 Oproepen printer functies (PC INT 17)
Invoer: registerset (4 words)
Uitvoer: registerset (4 words)
Hiermee kunnen printerfuncties van het PC-BIOS opgeroepen
worden. De registerset bestaat uit acht bytes, die de
registers AX, BX, CX en DX van de 8088/80x86 processor
voorstellen. Voor het gebuik van deze functie wordt
verwezen naar betreffende literatuur.
*/
{
unsigned char tab[9]; // 8 posities voor AL, AH .. DL, DH
read8b(tab);
write8b(tab);
}
void dosfunctie()
/*
#22 Oproepen MS-DOS functies (PC INT 21)
Invoer: registerset (4 words)
Uitvoer: registerset (4 words)
Hiermee kunnen MS-DOS systeemfuncties opgeroepen worden.
De registerset bestaat uit acht bytes, die de registers
AX, BX, CX en DX van de 8088/80x86 processor voorstellen.
Omdat niet alle functies uitsluitend gebruik maken van
bovengenoemde registers, kunnen sommige functies niet
uitgevoerd worden. Voor het gebuik van deze functie wordt
verwezen naar betreffende literatuur.
*/
{
unsigned char tab[9]; // 8 posities voor AL, AH .. DL, DH
char szTekst[] = "Deze functie (dosfunctie) heeft binnen windows geen waarde\r\n";
int i;
read8b(tab);
write8b(tab);
for (i=0; i<strlen(szTekst); i++)
Process(szTekst[i]);
}
void port_in()
/*
#23 Lees I/O byte
Invoer: I/O adres (1 word)
Uitvoer: gelezen data (1 byte)
De PC leest het opgegeven I/O adres uit en geeft deze
waarde aan de Atom. Het I/O adres ligt in het algemeen in
het gebied $0000 - $03FF.
*/
{
unsigned char tab[9]; // 8 posities voor AL, AH .. DL, DH
char szTekst[] = "Deze functie (Port_in) heeft binnen windows geen waarde\r\n";
int i;
READBYTEW(iobase);
READBYTEW(iobase);
WRITEBYTE(iobase, 0);
for (i=0; i<strlen(szTekst); i++)
Process(szTekst[i]);
}
void port_out()
/*
#24 Schrijf I/O byte
Invoer: I/O adres (1 word)
	 data (1 byte)
Uitvoer: geen
De PC stuurt de data naar het opgegeven I/O adres. Het
I/O adres ligt in het algemeen in het gebied $0000 -
$03FF.
*/
{
unsigned char tab[9]; // 8 posities voor AL, AH .. DL, DH
char szTekst[] = "Deze functie (Port_in) heeft binnen windows geen waarde\r\n";
int i;
READBYTEW(iobase);
READBYTEW(iobase);
WRITEBYTE(iobase, 0);
for (i=0; i<strlen(szTekst); i++)
Process(szTekst[i]);
}
void uds()
/*
#25 Defini‰er grafische letter
Invoer: ASCII waarde van karakter (1 byte)
	 karakter patroon (16 bytes)
Uitvoer: geen
Karakters die met commando #07 in de grafische mode
geschreven worden kunnen met deze functie gedefini‰erd
worden. Het eerst gelezen byte vormt de bovenste regel
van het karakter.
*/
{
unsigned char ascii;
int i;
unsigned char tab[17];
ascii = READBYTEW(iobase);
for (i=0; i< 16; i++)
tab[i]=READBYTEW(iobase);
}
void mouse_mot()
/*
#26 Opvragen muis aktiviteiten
Invoer: geen
Uitvoer: horizontale beweging (1 byte)
	 vertikale beweging (1 byte)
	 status van knoppen (1 byte)
Deze functie biedt de mogelijk om snel de beweging van de
muis op te vragen. Dit is relatief t.o.v. de laatst
gelezen positie.
*/
{
WRITEBYTE(iobase, 0); // hor
WRITEBYTE(iobase, 0); // ver
WRITEBYTE(iobase, 0); // buttons
}
void whoami()
/*
#27 Opvragen PC informatie
Invoer: geen
Uitvoer: PC identificatie (1 word)
Het PC identificatie woord geeft enige informatie omtrent
de beschikbare hardware die op de PC is aangesloten. Dit
woord is als volgt samengesteld:
bit 0 gezet als drive(s) aanwezig
bit 1 gezet als 80x87 coprocessor aanwezig is
bit 2 pc type (0=XT, 1=AT)
bit 3 video type (1=Hercules mono, 0=kleurenkaart)
bit 4,5 video mode bij opstarten
bit 6,7 aantal drives als bit 0 gezet is
bit 8 ---
bit 9,11 aantal seri‰le poorten
bit 12,13 video kaart (00=CGA, 01=EGA, 10=VGA, 11=HGC)
bit 14,15 aantal printerpoorten
De bits 12 en 13, welke het type videokaart aangeven,
kunnen vanuit de MS-DOS commandline met de optie /V=
gezet worden. De niet gebruikte bits zijn '0'. Deze
kunnen in de toekomst nog ingevuld worden.
*/
{
WRITEBYTE(iobase, 0xa9);
WRITEBYTE(iobase, 0x7b);
}
void clear0()
/*
#28 Emulatie clear 0
Invoer: video adres (1 word)
	 video data (1 byte)
Uitvoer: geen
De opgegeven data wordt overeenkomstig met Atom grafics
op het beeldscherm weergegeven. De positie van deze data
wordt opgegeven met het videoadres. V¢¢r het gebruik van
dit commando dient het font ATOMVDU.FNT geladen te zijn
m.b.v. commando #06. Dit is nodig omdat bij het emuleren
van CLEAR 0 gebruik wordt gemaakt van een karaktertabel.
Bij de Windows versie, wordt verondersteld dat er met het
standaard ATOM.TTF wordt gewerkt. Na correcte installatie
is het niet nodig verdere actie te ondernemen.
*/
{
unsigned int adres;
unsigned char data;
int lxco, lyco;
adres = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase);
data = READBYTEW(iobase); // inhoud van het adres
if (adres < 0x8200&& adres >0x7fff) { // ligt binnen video plane
lxco = (adres-0x8000) % 32;
lyco = (adres-0x8000) / 32;
if (data < 0x20)
	 data = data + 0x40;
else if (data >=0x40 && data < 0x60)
	 data = data + 0x40;
else if (data >=0x60 && data < 0x80)
	 data = data + 0x40;
else if (data >=0x80 && data < 0xA0)
	 data = data - 0x20;
else if (data >=0xa0 && data < 0xc0)
	 data = data + 0x20;
else if (data >=0xc0 && data < 0xe0)
	 data = data + 0x20;
else if (data >=0xe0)
	 data = data - 0x20;
paintclear0(lxco, lyco, data);
}
}
void palet()
/*
#29 Wijzigen van palet of achtergrondkleur in CGA modi
	 Invoer: paletnummer of kleurnummer (1 byte)
	 Uitvoer: geen
	 In de grafische modi kan met deze functie gekozen worden
	 tussen de twee kleurensets van een CGA kaart. Als bit 7
	 van de kleur gezet is dan wordt de achtergrondkleur
	 ingesteld.
	 Palet 0: groen, rood, geel
	 Palet 1: ultramarijn, violet, wit
	 Dit commando kan ook gebruikt worden in tekstmode. In dat
	 geval wordt, indien bit 7 gezet is, de kaderkleur van het
	 scherm ingesteld.
*/
{
READBYTE(iobase);
}
void clear1()
/*
#2A t/m #31 Emulatie grafische Atom modi
	 Deze commando's werken op dezelfde manier als commando
#28. De ge‰muleerde modi zijn:
#2A clear 1 monochroom
In de kleurenmodi kan met behulp van commando #29 gekozen
worden tussen twee kleurensets. In monochroom modi kan op
dezelfde wijze een van de achtergrondkleuren gekozen
worden. Dus monochroom is niet altijd zwart/wit. Voor
emulatie van een van deze modi hoeft geen speciale
karakterset geladen te worden.
*/
{
unsigned int adres;
BYTE data;
unsigned int result;
adres = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase);
data = READBYTEW(iobase); // inhoud van het adres
if (adres < 0x8400 && adres >0x7fff) { // ligt binnen video plane
SetByte((MIRROR(adres)-0x8000), data, 0x10);
}
}
void clear1a()
/*
#2A t/m #31 Emulatie grafische Atom modi
Deze commando's werken op dezelfde manier als commando
#28. De ge‰muleerde modi zijn:
#2B clear 1 kleur
	00 groen
	01 geel
	02 blauw
	03 rood
In de Winatom moeten deze bitwaardes vertaald worden
naar resp. 0B, 0C 0D en 0A. Dit omdat er in de aange-
maakte DIB vier bits per kleur worden gebruikt. Het
omschakelen van pallet met de daarbij horende gevol-
gen moet nog worden uitgewerkt.
In de kleurenmodi kan met behulp van commando #29 gekozen
worden tussen twee kleurensets. In monochroom modi kan op
dezelfde wijze een van de achtergrondkleuren gekozen
worden. Dus monochroom is niet altijd zwart/wit. Voor
emulatie van een van deze modi hoeft geen speciale
karakterset geladen te worden.
*/
{
unsigned int adres;
BYTE data;
unsigned int result;
adres = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase);
data = READBYTEW(iobase); // inhoud van het adres
if (adres < 0x8400&& adres >0x7fff) { // ligt binnen video plane
SetByte((MIRROR(adres)-0x8000), data, 0x1a);
}
}
void clear2()
/*
#2A t/m #31 Emulatie grafische Atom modi
	 Deze commando's werken op dezelfde manier als commando
	 #28. De ge‰muleerde modi zijn:
	 #2C clear 2 monochroom
	 In de kleurenmodi kan met behulp van commando #29 gekozen
	 worden tussen twee kleurensets. In monochroom modi kan op
	 dezelfde wijze een van de achtergrondkleuren gekozen
	 worden. Dus monochroom is niet altijd zwart/wit. Voor
	 emulatie van een van deze modi hoeft geen speciale
	 karakterset geladen te worden.
*/
{
unsigned int adres;
BYTE data;
unsigned int result;
adres = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase);
data = READBYTEW(iobase); // inhoud van het adres
if (adres < 0x8800&& adres >0x7fff) { // ligt binnen video plane
SetByte((MIRROR(adres)-0x8000), data, 0x20);
}
}
void clear2a()
/*
#2A t/m #31 Emulatie grafische Atom modi
	 Deze commando's werken op dezelfde manier als commando
	 #28. De ge‰muleerde modi zijn:
	 #2D clear 2 kleur
	 In de kleurenmodi kan met behulp van commando #29 gekozen
	 worden tussen twee kleurensets. In monochroom modi kan op
	 dezelfde wijze een van de achtergrondkleuren gekozen
	 worden. Dus monochroom is niet altijd zwart/wit. Voor
	 emulatie van een van deze modi hoeft geen speciale
			 karakterset geladen te worden.
*/
{
unsigned int adres;
BYTE data;
unsigned int result;
adres = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase);
data = READBYTEW(iobase); // inhoud van het adres
if (adres < 0x8600&& adres >0x7fff) { // ligt binnen video plane
SetByte((MIRROR(adres)-0x8000), data, 0x2a);
}
}
void clear3()
/*
#2A t/m #31 Emulatie grafische Atom modi
	 Deze commando's werken op dezelfde manier als commando
	 #28. De ge‰muleerde modi zijn:
	 #2E clear 3 monochroom
	 In de kleurenmodi kan met behulp van commando #29 gekozen
	 worden tussen twee kleurensets. In monochroom modi kan op
	 dezelfde wijze een van de achtergrondkleuren gekozen
	 worden. Dus monochroom is niet altijd zwart/wit. Voor
	 emulatie van een van deze modi hoeft geen speciale
	 karakterset geladen te worden.
*/
{
unsigned int adres;
BYTE data;
unsigned int result;
adres = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase);
data = READBYTEW(iobase); // inhoud van het adres
if (adres < 0x8c00&& adres >0x7fff) { // ligt binnen video plane
SetByte((MIRROR(adres)-0x8000), data, 0x30);
}
}
void clear3a()
/*
#2A t/m #31 Emulatie grafische Atom modi
	 Deze commando's werken op dezelfde manier als commando
	 #28. De ge‰muleerde modi zijn:
	 #2F clear 3 kleur
	 In de kleurenmodi kan met behulp van commando #29 gekozen
	 worden tussen twee kleurensets. In monochroom modi kan op
	 dezelfde wijze een van de achtergrondkleuren gekozen
	 worden. Dus monochroom is niet altijd zwart/wit. Voor
	 emulatie van een van deze modi hoeft geen speciale
			 karakterset geladen te worden.
*/
{
unsigned int adres;
BYTE data;
unsigned int result;
adres = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase);
data = READBYTEW(iobase); // inhoud van het adres
if (adres < 0x8c00&& adres >0x7fff) { // ligt binnen video plane
SetByte((MIRROR(adres)-0x8000), data, 0x3a);
}
}
void clear4()
/*
#2A t/m #31 Emulatie grafische Atom modi
			 Deze commando's werken op dezelfde manier als commando
			 #28. De ge‰muleerde modi zijn:
			 #30 clear 4 monochroom
			 In de kleurenmodi kan met behulp van commando #29 gekozen
			 worden tussen twee kleurensets. In monochroom modi kan op
			 dezelfde wijze een van de achtergrondkleuren gekozen
			 worden. Dus monochroom is niet altijd zwart/wit. Voor
			 emulatie van een van deze modi hoeft geen speciale
			 karakterset geladen te worden.
*/
{
unsigned int adres;
BYTE data;
unsigned int result, mir;
adres = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase);
mir = MIRROR(adres);
data = READBYTEW(iobase) & 255; // inhoud van het adres
if (mir > 0x7fff && mir <0x9800) {
SetByte(mir-0x8000, data, 0x40);
}
}
void clear4a()
/*
#2A t/m #31 Emulatie grafische Atom modi
	 Deze commando's werken op dezelfde manier als commando
	 #28. De ge‰muleerde modi zijn:
	 #31 clear 4 kleur
	 In de kleurenmodi kan met behulp van commando #29 gekozen
	 worden tussen twee kleurensets. In monochroom modi kan op
	 dezelfde wijze een van de achtergrondkleuren gekozen
	 worden. Dus monochroom is niet altijd zwart/wit. Voor
			 emulatie van een van deze modi hoeft geen speciale
	 karakterset geladen te worden.
*/
{
unsigned int adres;
BYTE data;
unsigned int result;
adres = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase);
data = READBYTEW(iobase); // inhoud van het adres
if (adres < 0x9800&& adres >0x7fff) { // ligt binnen video plane
SetByte((MIRROR(adres)-0x8000), data, 0x4a);
}
}
void videomod()
/*
#32 Inschakelen extended video mode
Invoer: schermmode (1 byte)
Uitvoer: geen
De PC schakelt de aanwezige videokaart over naar de
opgegeven mode. Hiermee kunnen dus hogere grafische modi
opgeroepen worden. De toegestane waarden zijn afhankelijk
van de aanwezige videokaart.
Als een extended video mode gekozen wordt dient het
tekstvenster met de juiste waarden gedefinieerd te worden
om problemen bij het scrollen te voorkomen.
Of de muis gebruikt kan worden in deze modi is
afhankelijk van de gebruikte muisdriver.
*/
{
READBYTEW(iobase);
// clrscr();
}
void videocol()
/*
#33 Zet graphics kleur voor extended video mode
	 Invoer: pixelkleur (1 byte)
Uitvoer: geen
De opgegeven kleur wordt gebruikt bij plot opdrachten in
extended video modi. De toegestane waarden zijn
afhankelijk van de videomode.
*/
{
kleur = READBYTEW(iobase);
}
void schrijfpix()
/*
#34 Schrijf grafisch pixel in extended video mode
Invoer: X-coördinaat (1 word)
	 Y-coördinaat (1 word)
	 plot opdracht (1 byte)
Uitvoer: geen
Met dit commando kunnen punten in de extended video modi
gezet of gewist worden. De bewerking wordt gegeven door
de plot opdracht, 1=zet pixel, 2=wis pixel en 3=exor
pixel met kleur.
	 De X en Y-coördinaten zijn afhankelijk van de grafische
resolutie van de geselecteerde video mode. In theorie kan
een resolutie van 65535*65535 met 256 kleuren gebruikt
worden. Slechts weinig videokaarten ondersteunen deze
mode.
Let erop dat in extended video modi de punt (0,0) links
boven op het scherm is en niet zoals bij de Atom modi
links onder!
*/
{
unsigned int x,y;
unsigned int plot;
unsigned int result;
x = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase);
y = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase);
result = READBYTEW(iobase);
plot = result & 255;
if (plot == 1)
plot = kleur;
else if (plot == 2)
plot = kleur | 0x80;
else
plot = kleur ^ -1;
pixel(x, y, plot); // 65532, 65532, 255
}
void windowd()
/*
#35 Instellen tekstvenster
Invoer: X-links onder (1 byte)
	 Y-links onder (1 byte)
	 X-rechts boven (1 byte)
	 Y-rechts boven (1 byte)
Uitvoer: geen
Het tekstvenster kan met dit commando ingesteld worden.
Alle door de Atom geproduceerde beeldscherm uitvoer wordt
in dit venster afgedrukt.
Uitvoer die door de PC op het scherm afgebeeld wordt
zoals een catalog of foutmelding kan buiten het venster
vallen.
	 Zoals bij de beschrijving van commando #32 al is vermeld
moeten bij extended video modi de tekstvensters expliciet
opgegeven worden. De windowbreedte klopt meestal wel,
maar de hoogte is altijd 25 regels. Dit omdat in het PC-
BIOS wel het aantal tekens per regel kan worden
opgevraagd, maar niet het aantal regels per scherm.
Daarom is gekozen voor de meest voorkomende waarde van 25
regels per scherm.
*/
{
venster_xlo = READBYTEW(iobase); // coordinaten tekstvenster
venster_ylo = READBYTEW(iobase); //
venster_xrb = READBYTEW(iobase); //
venster_yrb = READBYTEW(iobase); //
xco = venster_xlo;
yco = venster_ylo;
regels = 0;
}
void window_off()
/*
#36 Opheffen tekstvenster
Invoer: geen
Uitvoer: geen
Dit (overbodige) commando heft een gedefini‰erd
tekstvenster op.
*/
{
// schermbreedte opvragen
venster_xlo = 0; // coordinaten tekstvenster
venster_ylo = 24; //
venster_xrb = 80; // beetje anders dus
venster_yrb = 0; //
}
void joystick()
/*
#37 Joystick uitlezen
Invoer: geen
Uitvoer: stand joystick en vuurknoppen
De analoge joystick van de PC wordt uitgelezen en omgezet
naar digitale waarden die voor de Atom joystick
gebruikelijk zijn. Voor de volledigheid de betekenis van
de afzonderlijke bits:

*/
{
WRITEBYTE(iobase, joystat);
}
void callibrate()
/*
#38 Joystick calibreren
Invoer: geen
Uitvoer: geen
Een analoge joystick moet altijd gecalibreerd worden. Bij
	 deze gebeurtenis wordt de stand van de joystick gelezen
en deze stand wordt als "neutraal" beschouwd. Alle
joystick bewegingen gelden ten opzichte van deze
neutraalstand.
Bij het opstarten van het terminal programma en bij een
reset van de Atom wordt de joystick automatisch
gecalibreerd; deze functie is alleen nodig indien tijdens
het werken met de Atom van joystick gewisseld wordt of
als de PC van snelheid veranderd. Dit laatste geval omdat
het uitlezen van de joystick tijdafhankelijk is.
*/
{
}
void bit7()
/*
#39 Masker bit 7 instellen
Invoer: 0 -> bit 7 is altijd '0'
	 1 -> bit 7 blijft ongewijzigd.
Uitvoer: geen
De ascii-codes #00 t/m #1F worden door de Atom als
	 controlcodes opgevat. De PC kent echter voor deze codes
ook nog een aantal symbolen. Als het masker voor bit 7
gezet is, worden alle ascii-codes normaal afgehandeld;
als dit masker gewist is wordt van ieder, op het scherm
af te drukken karakter, bit 7 gewist. Hiermee kunnen de
speciale symbolen door middel van de ascii waarden #80
t/m #9F ook op het scherm afgebeeld worden.
*/
{
unsigned char waarde;
waarde = READBYTEW(iobase);
if (waarde !=0)
msb = 0xff;
else
msb = 0x7f;
}
void bioskey()
/*
#3A Oproepen keyboard functies (PC INT 16)
Invoer: registerset (4 words)
Uitvoer: registerset (4 words)
Hiermee kunnen de keyboard functies van het PC-BIOS
opgeroepen worden. De registerset bestaat uit acht bytes,
die de registers AX, BX, CX en DX van de 8088/80x86
processor voorstellen. Voor het gebuik van deze functie
wordt verwezen naar betreffende literatuur.
Let erop dat er bij het gebruik van deze interrupt
verschillen kunnen zijn bij de XT en AT!
*/
{
unsigned char tab[9]; // 8 posities voor AL, AH .. DL, DH
char szTekst[] = "Deze functie (dosfunctie) heeft binnen windows geen waarde\r\n";
int i;
read8b(tab);
write8b(tab);
for (i=0; i<strlen(szTekst); i++)
Process(szTekst[i]);
}
void shell()
/*
#3B Shell naar DOS
Invoer: MSDOS commando als ASCIIZ string
Uitvoer: geen
Als men tijdens het werken behoefte krijgt om een MS-Dos
	 programma te gebruiken (bijvoorbeeld FORMAT of DISKCOPY)
kan met dit commando ieder geldig MS-DOS commando
uitgevoerd worden. Als men tijdelijk naar MS-DOS wil kan
dat door het opstarten van een tweede COMMAND.COM. Geef
om terug te keren naar de Atom dan het commando EXIT.
*/
{
}
void zoekfile()
/*
#3C Zoek eerste passende file
Invoer: filespecificatie als ASCIIZ string
Uitvoer: resultaat (1 byte)
	 DTA informatie (22 bytes)
MS-DOS biedt de mogelijkheid om files te zoeken die
voldoen aan de opgegeven filespecificatie. Hierin mogen
wildcards * en ? voorkomen. Dit zoeken naar files gaat in
twee stappen.
Bij de eerste zoekactie dient dit commando gebruikt te
worden. Als een file gevonden is dan wordt als resultaat
	 een 0 overgezonden. Het resultaat geeft de foutcode weer
als geen passende file gevonden is; in dat geval volgt er
geen DTA.
In de DTA, dit staat voor Disk Transfer Area, is alle MS-
DOS directory informatie opgenomen. Voor de exacte inhoud
wordt verwezen naar bijlage II.
*/
{
struct find_t ffblk;
int done, i;
char tekst[80];
char far *dta;
/* leesnaam();
if (strlen(szFilename) == 0)
strcpy(szFilename, "*.*");
// WRITEBYTE(iobase, 255); // geen naam opgegeven tulpekop!
done = _dos_findfirst(szFilename, _A_NORMAL,&ffblk);
if (!done) {
WRITEBYTE(iobase, 0); // geef aan dat het goed gegaan
// dta = getdta();
// printf("The current disk transfer address is: %Fp\n", dta);
// WRITEBYTE(iobase, dta[22]); // hier iets voor test
}
else {
WRITEBYTE(iobase, 255);
} */
WRITEBYTE(iobase, 0); // geef aan dat het goed gegaan
}
void zoeknext()
/*
#3D Zoek volgende passende file
Invoer: geen
Uitvoer: resultaat (1 byte)
	 DTA informatie (22 bytes)
De tweede stap bij het zoeken naar files krijgt geen
parameters mee omdat deze nog bekend is vanuit de eerste
zoekactie. Een voorwaarde is dat er tussen twee
zoektochten geen disk activiteiten hebben plaats
gevonden.
De teruggegeven informatie is het zelfde als bij functie
#3C.
*/
{
struct find_t ffblk;
int done, i;
char tekst[80];
char far *dta;
done = _dos_findnext(&ffblk);
if (!done) {
WRITEBYTE(iobase, 0); // geef aan dat het goed gegaan
dta = getdta();
}
else {
WRITEBYTE(iobase, 0); // geef aan dat er nix te verhapstukken is
}
}
void lpt()
/*
#3E Selecteer printer
Invoer: printernummer (1 byte)
Uitvoer: printerstatus (1 byte)
Met deze functie wordt een printer gekozen die
aangesproken wordt als de printer aangezet wordt met $2
of CTRL-B. De uitvoer is de status van de betreffende
printer. Als deze status #90 bedraagt is de printer
gereed om data te ontvangen en af te drukken.
*/
{
READBYTEW(iobase);
WRITEBYTE(iobase, 0x90);
}
void raf_open()
/*
#3F Open random access file
Invoer: filenaam als ASCIIZ-string
	 file-attribuut (1 byte)
Uitvoer: handle (1 byte)
Bij het openen van een file bepaalt het attribuut op
welke wijze de file aangesproken mag worden. De volgende
attributen worden geaccepteerd:
#00 alleen lezen
#01 alleen schrijven
#02 lezen en schrijven
De computer zoekt het opgegeven bestand. Als dit gevonden
is wordt het geopend voor de gewenste toegang. Bestanden
waarnaar geschreven mag worden worden aangemaakt als zij
niet gevonden worden.
Bij een niet geopend bestand is de afgegeven handle 0;
het is niet te achterhalen waarom de file niet gevonden
is. Iedere andere waarde voor de handle duidt erop dat de
file geopend is.
*/
{
unsigned char attrib;
int handle, bx, i;
unsigned nBytes;
leesnaam();
attrib = READBYTEW(iobase) & 0x03;
if (_dos_open(szFilename, O_RDWR, &handle) == 0) {
lseek(handle, 16L, SEEK_SET);
WRITEBYTE(iobase, handle);
}
else {
if (attrib == 0) {
WRITEBYTE(iobase, 1); // geef foutcode aan
}
else {
if (_dos_creat(szFilename, _A_NORMAL, &handle) != 0) {
	WRITEBYTE(iobase, 0); // geef foutcode aan
	}
else {
	for (i=0; i<16; i++)
buffer[i]=0x00;
	nBytes=16;
	bx = _dos_write(handle, buffer, sizeof(buffer), &nBytes);
	WRITEBYTE(iobase, bx);
	}
}
}
}
void raf_sluit()
/*
#40 Sluit random access file
Invoer: handle (1 byte)
Uitvoer: geen
De opgegeven file wordt afgesloten en de handle wordt
vrijgegeven. De handle moet een waarde hebben groter dan
4 omdat anders een MS-DOS standaard apparaat gesloten kan
worden. Zie bijlage II.
*/
{
int handle;
handle=READBYTEW(iobase);
close(handle);
}
void raf_schrijf()
/*
#41 Schrijf byte naar random access file
Invoer: handle (1 byte)
data (1 byte)
Uitvoer: resultaat (1 byte)
De data wordt naar de file met de betreffende handle
gestuurd. Bij succes is het resultaat 1. Een resultaat 0
geeft aan dat er geen byte meer naar de file geschreven
kon worden; de disk is dan vol.
*/
{
FILE * handle;
unsigned char data[1], rc;
handle=(FILE *) READBYTEW(iobase);
data[0]=READBYTEW(iobase);
rc = fwrite(data, sizeof(data), 1, handle);
WRITEBYTE(iobase, rc);
}
void raf_lezen()
/*
#42 Lees byte van random access file
Invoer: handle (1 byte)
Uitvoer: resultaat (1 byte)
data (1 byte)
De data wordt van de file met de betreffende handle
gelezen. Bij succes is het resultaat 1. Een resultaat 0
geeft aan dat er geen byte meer gelezen kon worden; het
einde van de file is dan bereikt. Er moet dan toch nog
een leesopdracht plaats vinden omdat de PC een
willekeurig byte overstuurd.
*/
{
FILE * handle;
unsigned char data[1], rc;
handle=(FILE *) READBYTEW(iobase);
rc = fread(&data, sizeof(data), 1, handle);
WRITEBYTE(iobase, data[0]);
WRITEBYTE(iobase, rc);
}
void raf_move_ptr()
/*
#43 Verplaats random access file pointer
Invoer: handle (1 byte)
offset van pointer (4 bytes)
offset code (1 byte)
Uitvoer: resultaat (1 byte)
absolute waarde van pointer (4 bytes)
De pointer naar een random access file kan met deze
functie opgevraagd worden. Hiertoe wordt eerst de handle
van de betreffende file gegeven en daarna een 32 bits
offset voor de pointer. Tenslotte volgt de offset code,
hiermee wordt aangegeven hoe de offset geinterpreteerd
dient te worden:
0: offset heeft betrekking op begin van het bestand
1: offset heeft betrekking op acuele positie van
pointer
2: offset heeft betrekking op einde van het bestand
Als er geen fout optreed is het resultaat 0, gevolgd door
de waarde van de pointer ten opzichte van het begin van
het bestand. De offset mag 0 of negatief zijn bij offset
codes 1 en 2. Het is zelfs mogelijk om de pointer voor
het begin of achter het eind van het bestand te zetten.
Hiervoor wordt geen foutmelding gegeven. De fout treedt
pas op bij de eerstvolgende lees of schrijfopdracht voor
die file.
Met dit commando kan de actuele waarde van de pointer
opgevraagd worden door een offset 0 te geven en offset
code 1; hierdoor wordt de pointer 0 bytes verplaatst ten
opzichte van de actuele positie -> deze blijft dus staan.
*/
{
long int offset, roffset;
char * poffset;
int i;
int handle;
unsigned char offsetcode, rc = 0;
poffset = (char *) &offset;
handle = READBYTEW(iobase);
for (i=0; i< sizeof(long int); i++)
*poffset++ = READBYTEW(iobase);
offsetcode = READBYTEW(iobase);
roffset = lseek(handle, offset, offsetcode);
poffset = (char *) &roffset;
for (i=0; i< sizeof(long int); i++)
WRITEBYTE(iobase, *poffset++);
if (roffset == -1)
rc = errno;
WRITEBYTE(iobase, rc);
}
void raf_lees_ext()
/*
#44 Opvragen extensie van random access file
Invoer: handle (1 byte)
Uitvoer: resultaat (1 byte)
extensie van file (4 bytes)
De extensie is in dit geval niet het laatste stukje van
de filenaam maar de lengte van de file. Bij een resultaat
0 volgt de lengte van de file.
*/
{
unsigned long offset;
char * poffset = (char *) &offset;
int i;
int handle;
unsigned char rc=0;
handle = READBYTEW(iobase);
offset = filelength(handle);
poffset = (char *) &offset;
if (offset == -1)
rc = errno;
WRITEBYTE(iobase, rc);
for (i=0; i< sizeof(unsigned long); i++)
WRITEBYTE(iobase, *poffset++);
}
void mousekar()
/*
#45 Lees teken onder muiscursor
Invoer: geen
Uitvoer: teken onder muiscursor (1 byte)
Deze functie is analoog aan functie #02, behalve dat nu
het karakter gelezen wordt op de plaats van de
muiscursor; deze functie werkt alleen in tekstmodi 40*25
en 80*25.
*/
{
WRITEBYTE(iobase, scherm[rb_xco][rb_yco]);
}
void versie()
/*
#46 Opvragen versienummer terminal programma
Invoer: geen
Uitvoer: release/update nummer (1 byte)
hoofdversienummer (1 byte)
Het is zinnig om het versienummer van het terminal
programma op te vragen als er gebruik wordt gemaakt van
deze serie PC-commando's. Hiermee kan de gebruiker
gewaarschuwd worden dat hij/zij mogelijk een recentere
versie van het terminal programma dient te gebruiken.
Alle commando's in deze handleiding zijn beschikbaar
vanaf versie 2.20.
*/
{
WRITEBYTE(iobase, VER_HI);
WRITEBYTE(iobase, VER_LO);
}
void teken2lpt()
/*
#47 Teken naar printer sturen
Invoer: teken (1 byte)
Uitvoer: geen
Het gelezen teken wordt naar de printer gestuurd indien
deze aangezet is met $2 of ^B. Als de printer niet aange-
zet is dan voert dit commando niets uit. In het geval dat
de printer wel aangezet is maar de printer is niet on-
line wordt gewacht totdat de printer on-line komt.
*/
{
char teken[1];
teken[0] = READBYTEW(iobase);
if (bPrinterstatus == TRUE) {
fwrite(&teken, sizeof(char), 1, prnfile);
}
}
void cgabitmap()
/*
#48 CGA grafisch teken defini‰ren
Invoer: ascii waarde van teken (1 byte)
	 bitpatroon van teken (8 bytes)
Uitvoer: geen
In de grafische CGA mode is het mogelijk om zelf de
tekens 128 t/m 255 te defini‰ren (iets dat MS-DOS doet
met het commando GRAFTABL). Deze mogelijkheid is nu ook
beschikbaar voor de Atom.
Nadat de ascii waarde van het te defini‰ren teken is
overgezonden worden de volgende acht bytes opgeslagen als
bitpatroon.
De nieuwe tekens worden in hetzelfde gebied opgeslagen
als het font voor GTEXT en Atomvdu; het is dus niet
mogelijk om deze drie fonts gelijktijdig te gebruiken of
de fonts moeten om en om geladen worden.
Het is al aan te voelen dat een komplete karakterset
geladen kan worden. Om een nieuwe karakterset te laden
kan het bekende FONT statement gebruikt worden.
*/
{
int	i;
for (i=0; i<9; i++) {
READBYTE(iobase);
}
}
void hfill()
/*
#49 Horizontaal vullen
Invoer: coördinaten beginpunt (2 words)
grenskleur (1 byte)
Uitvoer: geen
Vanaf het opgegeven punt wordt de beeldlijn naar links en
naar rechts gekleurd in de aktuele kleur. Dit kleuren
gaat door totdat een pixel ontmoet wordt dat gelijk is
aan de grenskleur.
Bij het kleuren wordt rekening gehouden met een eventueel
grafisch venster en een verschoven oorsprong. Voorwaarde
is wel dat het beginpunt in het grafisch venster ligt.
*/
{
}
void vfill()
/*
#4A Vertikaal vullen
Invoer: coördinaten beginpunt (2 words)
grenskleur (1 byte)
Uitvoer: geen
Vanaf het opgegeven punt wordt de beeldlijn naar boven en
naar beneden gekleurd in de aktuele kleur. Dit kleuren
gaat door totdat een pixel ontmoet wordt dat gelijk is
aan de grenskleur.
Bij het kleuren wordt rekening gehouden met een eventueel
grafisch venster en een verschoven oorsprong. Voorwaarde
is wel dat het beginpunt in het grafisch venster ligt.
*/
{
}
void roep61()
/*
#4B Aanroepen INT 61h
Invoer: afhankelijk van aangeroepen programma
Uitvoer: afhankelijk van aangeroepen programma
Om het Atom terminal programma zelf uit te breiden kan op
de PC een resident programma gestart worden dat geakti-
veerd wordt bij een oproep van INT 61h. Parameters en
resultaten kunnen afhankelijk van het opgeroepen program-
ma uitgewisseld worden. 
Zie het hoofdstuk "communicatie met andere programma's"
voor meer uitleg.
*/
{
}
void gwindow()
/*
#4C Defini‰er een grafisch venster
Invoer: X-coördinaat linker benedenhoek (1 word)
	 X-coördinaat linker benedenhoek (1 word)
	 Y-coördinaat rechter bovenhoek (1 word)
	 Y-coördinaat rechter bovenhoek (1 word)
Uitvoer: geen
Voor de Atom grafische mode bood het Gagsrom al mogelijk-
heden voor grafische vensters. Voor de extended video
mode kan dit commando gebruikt worden om een grafisch
venster vast te leggen. Dat houdt in dat alleen binnen
dat venster getekend kan worden.
Na het gebruiken van een CLEAR opdracht wordt het venster
automatisch opgeheven.
*/
{
gwindow_xlo = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase);
gwindow_xrb = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase);
gwindow_ylo = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase);
gwindow_yrb = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase);
}
void gwoff()
/*
#4D Grafisch venster opheffen
Invoer: geen
Uitvoer: geen
Hiermee wordt een grafisch venster opgeheven.
*/
{
gwindow_xlo = 0;
gwindow_ylo = -1;
gwindow_xrb = -1;
gwindow_yrb = 0;
}
void oorsprong()
/*
#4E Grafische oorsprong verschuiven
Invoer: coördinaten van nieuwe oorsprong (2 words)
Uitvoer: geen
Het grafische nulpunt ligt normaal in de linker bovenhoek
van het scherm. Met dit commando kan het punt (0,0)
verschoven worden naar een willekeurige plaats op het
scherm.
Bij het verschuiven van de grafische oorsprong wordt geen
rekening gehouden met een eerder verschoven oorsprong en
een grafisch venster. De nieuwe positie is dus altijd ten
opzichte van de linker bovenhoek van het scherm.
Na een CLEAR opdracht bevindt de oorsprong zich altijd in
de linker bovenhoek.
*/
{
int x, y;
x = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase);
y = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase);
}
void viewscherm()
/*
#4F Selecteer schermpagina voor monitor
Invoer: schermpagina nummer (1 byte)
Uitvoer: geen
Bij gebruik van een tekstmode kan gebruik gemaakt worden
van verschillende schermpagina's. Er zijn in feite twee
mogelijkheden bij het werken met verschillende pagina's,
te weten: werkpagina is zichtbaar op scherm of de werkpa-
gina en de getoonde pagina zijn verschillend. Met het
commando #4F kan de pagina gekozen worden die op de
monitor getoond wordt.
Zie voor meer informatie het hoofdstuk "Schermpagina's".
*/
{
schermpag = READBYTEW(iobase);
}
void werkscherm()
/*
#50 Selecteer schermpagina voor bewerkingen
Invoer: schermpagina nummer (1 byte)
Uitvoer: geen
Bij gebruik van een tekstmode kan gebruik gemaakt worden
van verschillende schermpagina's. Er zijn in feite twee
mogelijkheden bij het werken met verschillende pagina's,
te weten: werkpagina is zichtbaar op scherm of de werkpa-
gina en de getoonde pagina zijn verschillend. Met het
commando #50 kan de pagina gekozen worden waar de
schrijfopdrachten naar toe gestuurd worden.
Zie voor meer informatie het hoofdstuk "Schermpagina's".
*/
{
schermpag = READBYTEW(iobase);
}
void cursordef()
/*
#51 Zet cursor lijnen
Invoer: bovenste cursorlijn (1 byte)
	 onderste cursorlijn (1 byte)
Uitvoer: geen
De vorm van de cursor kan ingesteld worden met dit com-
mando. De cursorlijnen worden van boven naar beneden
geteld. De eerste parameter zal dus altijd groter zijn
dan de tweede. Bij ongeldige waarden verdwijnt de cursor
van het scherm. Het aantal lijnen verschilt per video-
kaart.
*/
{
char	cur_lo, cur_hi;
cur_hi = READBYTEW(iobase);
cur_lo = READBYTEW(iobase);
}
void read_b001(unsigned char status)
/*
*/
{
unsigned char toets = 0xff;
if (status & SHFTMASK)
toets &= 0x7f;
if (status & CTRLMASK)
toets &= 0xbf;
if (adres_b000 != 0xff)
status &= kbmatrix[status];
WRITEBYTE(iobase, status);
/* MOV BL,AL ; BEWAAR STATUS VAN JOYSTICK
		MOV AH,2 ; LEES KEYBOARD STATUS
		INT 16H
		TEST AL,00000011B ; TEST OP SHIFTTOETS
		JE READ1 ; SPRING INDIEN GEEN SHIFTTOETS
		AND BL,01111111B ; ZET SHIFT BIT
READ1: TEST AL,00000100B ; TEST OP CONTROL TOETS
JE READ2 ; SPRING INDIEN GEEN CONTROL TOETS
AND BL,10111111B ; ZET CTRL BIT
READ2: XOR AH,AH ; BEPAAL RIJ VAN KEYBOARD MATRIX
MOV AL,ADRES_B000
CMP AL,0FFH ; KIJK OF 8255 EMULATIE AANSTAAT
JE READ2A ; SPRING INDIEN NIET AKTIEF
MOV SI,AX ; ZET RIJ IN INDEXREGISTER
MOV AL,BL ; ZET RESULTAAT IN AL
AND AL,KEYMATRIX[SI]; LEES STATUS VAN ATOM-TOETSENBORD
READ2A: CALL ZENDBYTE ; STUUR NAAR DE ATOM
JMP LEESCOM ; EINDE ROUTINE */
}
void read_b002()
/*
*/
{ /*
READ_B002: MOV BL,6FH ; ZET INITIELE WAARDE
		MOV AH,2 ; LEES KEYBOARD STATUS
INT 16H
TEST AL,08H ; TEST OP ALT TOETS
JE READ3 ; SPRING INDIEN GEEN ALT TOETS
AND BL,0BFH ; WIS BIT VOOR ALT TOETS
*/
unsigned char status;
READ3:
asm IN AL,40H // LEES LAGE BYTE VAN TIMER 0
asm TEST AL,02H // TEST LAGE BIT "2400 HZ"
asm JE READ4 // SPRING INDIEN 0
asm OR BL,10H // ZET "2400 HZ" BIT
READ4:
asm IN AL,40H // LEES HOGE BYTE VAN TIMER 0
asm TEST AL,80H // TEST HOGE BIT "60 HZ"
asm JE READ5 // SPRING INDIEN 0
asm OR BL,80H // ZET "60 HZ" BIT
READ5:
asm MOV status,BL // ZET RESULTAAT IN AL
WRITEBYTE(iobase, status);
/* CALL ZENDBYTE ; STUUR NAAR ATOM
JMP LEESCOM ; EINDE ROUTINE */
}
void write_b000()
/*
*/
{
READBYTEW(iobase);
}
void egafont()
/*
#55 Selecteer user font voor EGA/VGA tekstmode
Invoer: geen
Uitvoer: geen
Dit commando laadt het geladen font in het fontram van de
EGA of VGA kaart. Hiermee kunnen de karakters in tekstmo-
de gewijzigd worden.
*/
{
}
void ega8x14()
/*
#56 Selecteer EGA 8*14 ROM font
Invoer: geen
Uitvoer: geen
Hiermee wordt het standaard EGA 8*14 karakterset in de
fontram van de EGA of VGA kaart geladen. Automatisch
wordt omgeschakeld naar 25 regels per scherm. Het kan
nodig zijn om het tekstwindow te herdefini‰ren.
*/
{
}
void ega8x8()
/*
#57 Selecteer EGA 8*8 ROM font
Invoer: geen
Uitvoer: geen
Hiermee wordt het standaard EGA 8*8 karakterset in de
fontram van de EGA of VGA kaart geladen. Automatisch
wordt omgeschakeld naar 43 regels per scherm voor EGA en
50 regels per scherm voor VGA. Het tekstwindow zal aange-
past moeten worden.
*/
{
}
// vanaf hier de 3.xx uitbreidingen.
/*
#58 Schrijf grafisch venster naar disk
Invoer: x-coördinaat links onder (1 word)
y-coördinaat links onder (1 word)
x-coördinaat rechts boven (1 word)
y-coördinaat rechts boven (1 word)
filehandle (1 byte)
Uitvoer: geen
Schrijft een grafisch window in een extended video mode
naar file. De file moet reeds geopend zijn. De
coordinaten van het window en de file handle worden als
parameter opgegeven. De coördinaten gelden vanaf de
logische oorsprong. Er wordt dus rekening gehouden met
een verschoven oorsprong. Er wordt geen resultaat
teruggegeven; het is dus niet bekend of alle data op de
disk terecht zijn gekomen. Dit commando is hoofdzakelijk
bedoeld om stukken van een grafisch scherm tijdelijk in
een bestand op te slaan. Na beëindiging van het commando
wordt de file niet automatisch afgesloten.
#59 Lees grafisch venster van disk
Invoer: x-coördinaat links onder (1 word)
y-coördinaat links onder (1 word)
filehandle (1 byte)
Uitvoer: geen
Een grafisch window dat met commando #58 naar file
geschreven is kan hiermee teruggezet worden op het
scherm. Dit hoeft niet op dezelfde plaats te zijn. De
file moet al geopend zijn. Er wordt geen resultaat
teruggemeld zodat niet bekend is of de data goed gelezen
zijn. Na het inlezen wordt het bestand niet automatisch
gesloten.
#5A Diverse grafische functies
SHAPES - leest een sub-commando nummer en voert
vervolgens de functie uit. Bij deze functies wordt
rekening gehouden met een verschoven grafische oorsprong
en het huidige grafische venster.
#5A subfunctie #0: teken een cirkel
Invoer: x-coördinaat middelpunt (1 word)
y-coördinaat middelpunt (1 word)
straal (1 word)
Uitvoer: geen
In extended video mode wordt een cirkel getekend met het
middelpunt op de opgegeven coördinaten en met de
opgegeven straal.
#5A subfunctie #1: teken een cirkel en vul deze
Invoer: x-coördinaat middelpunt (1 word)
y-coördinaat middelpunt (1 word)
straal (1 word)
Uitvoer: geen
In extended video mode wordt een cirkel getekend met het
middelpunt op de opgegeven coördinaten en met de
opgegeven straal. Deze cirkel wordt opgevuld in de
geldende voorgrondkleur.
#5A subfunctie #2: teken een rechthoek
Invoer: x-coördinaat linker benedenhoek (1 word)
y-coördinaat rechter benedenhoek (1 word)
x-coördinaat linker bovenhoek (1 word)
y-coördinaat rechter bovenhoek (1 word)
Uitvoer: geen
In extended video mode wordt een rechthoek getekend
tussen de opgegeven hoekpunten.
#5A subfunctie #3: teken een rechthoek en vul deze
Invoer: x-coördinaat linker benedenhoek (1 word)
y-coördinaat rechter benedenhoek (1 word)
x-coördinaat linker bovenhoek (1 word)
y-coördinaat rechter bovenhoek (1 word)
Uitvoer: geen
In extended video mode wordt een rechthoek getekend
tussen de opgegeven hoekpunten. Deze rechthoek wordt
opgevuld in de geldende voorgrondkleur.
#5A subfunctie #4: teken een driehoek
Invoer: x en y-coördinaten eerste hoekpunt (2 words)
x en y-coördinaten tweede hoekpunt (2 words)
x en y-coördinaten derde hoekpunt (2 words)
In extended video mode wordt een driehoek getekend tussen
de opgegeven hoekpunten.
#5A subfunctie #5: teken een driehoek en vul deze
Invoer: x en y-coördinaten eerste hoekpunt (2 words)
x en y-coördinaten tweede hoekpunt (2 words)
x en y-coördinaten derde hoekpunt (2 words)
In extended video mode wordt een driehoek getekend tussen
de opgegeven hoekpunten. Deze driehoek wordt opgevuld in
de geldende voorgrondkleur.
#5A subfunctie #6: zet lijn patroon
Invoer: bitpatroon van de lijn (1 word)
Uitvoer: geen
Om niet-aaneengesloten lijnen te tekenen kan met deze
functie een 16-bits patroon opgegeven worden.
#5A subfunctie #7: teken een rechte lijn
Invoer: x-coördinaat beginpunt (1 word)
y-coördinaat beginpunt (1 word)
x-coördinaat eindpunt (1 word)
y-coördinaat eindpunt (1 word)
Uitvoer: geen
In extended video mode wordt een lijn getekend tussen het
opgegeven begin en eindpunt. Hierbij geldt dat een '1' in
het lijn patroon (zie ook subfunctie #06) geplot wordt de
geldende voorgrondkleur. Een '0' in het lijn patroon laat
het pixel ongewijzigd.
#5B Lees direct PC videogeheugen
Invoer: offset adres videogeheugen (1 word)
Uitvoer: data uit videogeheugen (1 byte)
Deze call maakt het mogelijk om het PC videogeheugen
direct uit te lezen, dus niet via het BIOS. Deze
werkwijze is over het algemeen wat sneller. Bovendien
worden hiermee ook systemen met twee monitoren
ondersteund.
#5C Schrijf direct PC videogeheugen
Invoer: offset adres videogeheugen (1 word)
data (1 byte)
Uitvoer: geen
Deze call maakt het mogelijk om direct naar het PC
videogeheugen te schrijven, dus niet via het BIOS. Deze
werkwijze is over het algemeen wat sneller. Bovendien
worden hiermee ook systemen met twee monitoren
ondersteund.
#5D Verplaats datablok in PC videogeheugen
Invoer: offset adres bron (1 word)
offset adres bestemming (1 word)
bloklengte (1 word)
Uitvoer: geen
Het datablok beginnende vanaf 'offset adres bron' met
lengte 'bloklengte' wordt gekopieerd naar 'offset adres
bestemming'. Hierme kunnen snel stukken tekst over het
scherm verplaatst worden, data kan tussen verschillende
schermpagina's gekopieerd worden of in twee-monitor
systemen van de ene monitor naar de andere.
#5E Diverse wachtfuncties
Let op: de functies van commando #5E maken gebruik van
BIOS INT 15H; deze is niet in een PC/XT ge‹mplementeerd!
#5E subfunctie #0: Wacht gedurende ingestelde tijd
Invoer: geen
Uitvoer: dummy (1 byte)
De PC wacht gedurende een van te voren opgegeven tijd. Na
het verstijken van deze tijd wordt een dummy byte naar de
Atom gestuurd om beide systemen te synchroniseren. De
wachttijd kan met subfunctie #1 van commando #5E
ingesteld worden.
#5E subfunctie #1: Stel wachttijd in
Invoer: tijd in microseconden (4 bytes)
Uitvoer: geen
Met deze functie wordt de wachttijd ingesteld voor de
functies #0 en #2 van commando #5E. Het meest lage byte
wordt als eerste overgestuurd.
#5E subfunctie #2: Vlag zetten na wachttijd
Invoer: geen
Uitvoer: geen
In de PC wordt een vlag gewist die na de opgegeven
wachttijd gezet wordt. De wachttijd wordt ingesteld met
commando #5E subfunctie #1. De status van deze vlag kan
opgevraagd worden met commando #5E subfunctie #3.
#5E subfunctie #3: Timer vlag uitlezen
Invoer: geen
Uitvoer: status van de vlag (1 byte)
Als de wachtperiode, die met commando #5E subfunctie #2
gestart werd, verstreken is heeft bit 7 de waarde '1'.
#5E subfunctie #4: 1/60 seconde wachten
Invoer: geen
Uitvoer: dummy byte (1 byte)
Deze functie laat de PC 1/60 seconde wachten waarna een
dummy byte naar de Atom gestuurd wordt om de twee
systemen te synchroniseren.
#5E subfunctie #5: 1/50 seconde wachten
Invoer: geen
Uitvoer: dummy byte (1 byte)
Deze functie laat de PC 1/50 seconde wachten waarna een
dummy byte naar de Atom gestuurd wordt om de twee
systemen te synchroniseren.
#5F Paint functies
Deze functies kleuren gesloten vlakken in met
gedefini‰rde patronen. Hierbij wordt rekening gehouden
met een verschoven oorsprong en grafisch venster.
Paint-patronen worden samen met de geplande sprites
opgeslagen in het geheugen van de PC. In totaal zijn 64
patronen en sprites beschikbaar. Beiden hebben hetzelfde
formaat, met afmetingen van 16*16 pixels. 
#5F subfunctie 0: vlak inkleuren in voorgrondkleur
Invoer: grenskleur (1 byte)
Uitvoer: geen
Een vlak, ingesloten door lijnen in de grenskleur, wordt
gevuld in de geldende voorgrondkleur. De grenskleur mag
hetzelfde zijn als de huidige voorgrondkleur.
#5F subfunctie n: vlak inkleuren volgens patroon n
waarbij geldt: 1 < n < 64 
Invoer: grenskleur (1 byte)
Uitvoer: 0 -> geen fout (1 byte)
n -> ongeldig patroon nummer
Een vlak, ingesloten door lijnen in de grenskleur, wordt
gevuld met het opgegeven patroon. De grenskleur mag
hetzelfde zijn als de huidige voorgrondkleur.
#5F subfunctie #FD: patroonfile laden van disk
Invoer: pad+filenaam als ASCIIZ
Uitvoer: error code (1 byte)
Om een set met patronen te laden van disk dient dit
commando gebruikt te worden. De filenaam mag vooraf
gegaan worden door een drive en pad aanduiding. Wildcards
zijn niet toegestaan.
#5F subfunctie #FE: patroonfile schrijven naar disk
Invoer: pad+filenaam als ASCIIZ
Uitvoer: error code (1 byte)
Een set met patronen wordt met dit commando op disk
opgeslagen. De filenaam mag vooraf gegaan worden door een
drive en pad aanduiding. Wildcards zijn niet toegestaan.
#5F subfunctie #FF: patroon defini‰ren
Invoer: patroonnummer (1 byte)
patroon (256 bytes)
Uitvoer: 0 -> geen fout (1 byte)
n -> ongeldig patroon nummer
Een patroon heeft de afmetingen van 16x16 bytes. Ieder
byte bevat de kleurwaarde van ‚‚n pixel. Op deze manier
kunnen dus maximaal 256 kleuren in een patroon verwerkt
worden. De eerste 16 bytes vormen de bovenste rij van de
patroon, de daaropvolgende 16 bytes de tweede rij enz.
*/
// vanaf hier de extra routines buiten de aanroep om.
char *current_directory(char *path)
/*
*/
{
strcpy(path, "X:\\"); /* fill string with form of response: X:\ */
path[0] = 'A' + getdisk(); /* replace X with current drive letter */
getcurdir(0, path+3); /* fill rest of string with current directory */
return(path);
}
void read8b(unsigned char *tab)
/*
*/
{
int i;
for (i=0; i<8; i++)
tab[i]=READBYTEW(iobase);
}
void write8b(unsigned char *tab)
/*
*/
{
int i;
for (i=0; i<8; i++)
WRITEBYTE(iobase, tab[i]);
}
void pixel(int x, int y, int plot)
/*
*/
{
}
void leesnaam()
/*
*/
{
unsigned int result;
int i=0;
do {
szFilename[i] = READBYTEW(iobase);
} while (szFilename[i++] !=0);
// hier nog enige uitbreiding voor de : en de \
}
void kopypage()
{
}
void putwin()
{
}
void getwin()
{
}
void shapes()
{
unsigned char param;
param= READBYTEW(iobase);
switch (param) {
case 0: // teken een circel
break;
case 1: // teken een filled circel
break;
case 2: // teken een rechthoek
break;
case 3: // teken een filled rechthoek
break;
case 4: // teken driehoek
break;
case 5: // teken een filled driehoek
break;
case 6: // zet lijn patroon
break;
case 7: // teken een rechte lijn
break;
case 8: // opvragen huidige schermkleur/attribuut
break;
default: // een nog onbekende paardemeter meegestuurd.
break;
}
}
void dir_vid_acc()
{
unsigned char param;
param= READBYTEW(iobase);
switch (param) {
case 0:
	 // lees direct video
	 break;
case 1:
	 // schrijf direct video
	 break;
case 2:
	 // blok kopieren
	break;
case 0x5b:
	getreset();
	break;
case 0x5c:
	setreset();
	break;
case 0x5d:
RESET(iobase); // reset the atom
	break;
default:
	 // foute boel aan parameters
	 break;
	 }
}
void dir_vid_rd()
{
unsigned char waarde;
waarde = READBYTEW(iobase);
// en nog veel meer
}
void getreset()
{
WRITEBYTE(iobase, resettype);
}
void setreset()
{
resettype = READBYTEW(iobase);
}
void wait()
{
unsigned char param;
param= READBYTEW(iobase);
switch (param) {
case 0: // wacht een vooraf ingestelde tijd
	break;
case 1: // stel wachttijd voor functies 0, 2 en 6 in
	break;
case 2: // vlag zetten na wachttijd
	break;
case 3: // vlag uitzetten
	break;
case 4: // wacht 1/60e seconde
	wait160();
	break;
case 5: // wacht 1/50e seconde
	break;
case 6: // laat toon horen gedurende de wachttijd
	break;
default: // foute boel in parameters
	break;
}
}
void paint()
{
unsigned char param;
param = READBYTEW(iobase);
switch (param) {
case 0:
	 break;
case 1:
	 break;
case 2:
	 break;
case 3:
	 break;
case 4:
	 break;
case 5:
	 break;
default:
	 break;
}
}
void init0()
{
	xco = 0 ;
	yco = 0 ;
	venster_xrb=32;
	venster_yrb=0;
venster_ylo=16;
venster_xlo=0;
	regels=0;
	bClear0 = TRUE;
	clear0w();
}
void ascii_scan()
/*
#01 Keyboard scan
Invoer: geen
	 Uitvoer: scan code (1 byte)
		 keyboard status (1 byte)
De scan codes zijn gelijk aan de standaard PC-
	 scancodes.
*/
{
unsigned char status = 0;
if (bShift)
status |= 0x02;
if (bKey != TRUE) {
WRITEBYTE(iobase, status);
}
else {
status |= 0x01;
WRITEBYTE(iobase, status);
WRITEBYTE(iobase, bascii);
WRITEBYTE(iobase, bscan);
}
bKey = FALSE;
}