collapseos/tools/emul/zasm/glue.asm

; Glue code for the emulated environment
.equ RAMSTART		0x4000
.equ USER_CODE		0x4800
.equ STDIO_PORT		0x00
.equ STDIN_SEEK		0x01
.equ FS_DATA_PORT	0x02
.equ FS_SEEK_PORT	0x03
.equ STDERR_PORT	0x04

jp     init    ; 3 bytes
; *** JUMP TABLE ***
jp	strncmp
jp	addDE
jp	addHL
jp	upcase
jp	unsetZ
jp	intoDE
jp	intoHL
jp	writeHLinDE
jp	findchar
jp	parseHex
jp	parseHexPair
jp	blkSel
jp	fsFindFN
jp	fsOpen
jp	fsGetC
jp	fsSeek
jp	fsTell
jp	cpHLDE
jp	parseArgs

#include "core.asm"
#include "err.h"
#include "parse.asm"
.equ	BLOCKDEV_RAMSTART	RAMSTART
.equ	BLOCKDEV_COUNT		3
#include "blockdev.asm"
; List of devices
.dw	emulGetC, 0, emulSeek, emulTell
.dw	0, emulPutC, 0, 0
.dw	fsdevGetC, fsdevPutC, fsdevSeek, fsdevTell

.equ	FS_RAMSTART	BLOCKDEV_RAMEND
.equ	FS_HANDLE_COUNT	0
#include "fs.asm"

init:
	di
	ld	hl, 0xffff
	ld	sp, hl
	ld	a, 2	; select fsdev
	ld	de, BLOCKDEV_GETC
	call	blkSel
	call	fsOn
	ld	hl, .zasmArgs
	call	USER_CODE
	; signal the emulator we're done
	halt

.zasmArgs:
	.db	"0 1", 0

; *** I/O ***
emulGetC:
	in	a, (STDIO_PORT)
	or	a		; cp 0
	jr	z, .eof
	cp	a		; ensure z
	ret
.eof:
	call	unsetZ
	ret

emulPutC:
	out	(STDIO_PORT), a
	ret

emulSeek:
	; the STDIN_SEEK port works by poking it twice. First poke is for high
	; byte, second poke is for low one.
	ld	a, h
	out	(STDIN_SEEK), a
	ld	a, l
	out	(STDIN_SEEK), a
	ret

emulTell:
	; same principle as STDIN_SEEK
	in	a, (STDIN_SEEK)
	ld	h, a
	in	a, (STDIN_SEEK)
	ld	l, a
	ret

fsdevGetC:
	in	a, (FS_DATA_PORT)
	cp	a		; ensure Z
	ret

fsdevPutC:
	out	(FS_DATA_PORT), a
	ret

fsdevSeek:
	push	af
	ld	a, e
	out	(FS_SEEK_PORT), a
	ld	a, h
	out	(FS_SEEK_PORT), a
	ld	a, l
	out	(FS_SEEK_PORT), a
	pop	af
	ret

fsdevTell:
	push	af
	in	a, (FS_SEEK_PORT)
	ld	e, a
	in	a, (FS_SEEK_PORT)
	ld	h, a
	in	a, (FS_SEEK_PORT)
	ld	l, a
	pop	af
	ret
Move apps/zasm/emul to tools/emul 2019-05-10 04:09:40 +10:00			`; Glue code for the emulated environment`
zasm: use blkdev IDs as input and output This will soon allow use to seek and tell on input, which is necessary for a second pass which is necessary for forward symbol references. This require making `blkSel` a bit more flexible. Rather than having one global selected blkdev, each app can select its own, in its own memory space. 2019-05-11 08:20:43 +10:00			`.equ RAMSTART 0x4000`
zasm now bootstraps itself without scas! 2019-05-20 05:03:34 +10:00			`.equ USER_CODE 0x4800`
Move apps/zasm/emul to tools/emul 2019-05-10 04:09:40 +10:00			`.equ STDIO_PORT 0x00`
zasm: change ioRewind to ioSeek Will need it soon. 2019-05-16 03:41:56 +10:00			`.equ STDIN_SEEK 0x01`
zasm emul: hook fsdev in glue code 2019-05-17 03:23:23 +10:00			`.equ FS_DATA_PORT 0x02`
			`.equ FS_SEEK_PORT 0x03`
zasm emul: add dumpSymbolTable debug routine Very helpful... 2019-05-18 03:22:45 +10:00			`.equ STDERR_PORT 0x04`
Move apps/zasm/emul to tools/emul 2019-05-10 04:09:40 +10:00
zasm emul: bring back kernel/user distinction It was a bad idea to remove it. Now that I'm introducing the concept of a per-app glue file, it becomes much easier to build emulated zasm as a userspace app. 2019-05-20 02:57:59 +10:00			`jp init ; 3 bytes`
			`; * JUMP TABLE *`
fs: check for file size bounds in GetC 2019-06-01 01:12:29 +10:00			`jp strncmp`
			`jp addDE`
			`jp addHL`
			`jp upcase`
			`jp unsetZ`
			`jp intoDE`
			`jp intoHL`
			`jp writeHLinDE`
			`jp findchar`
			`jp parseHex`
			`jp parseHexPair`
			`jp blkSel`
			`jp fsFindFN`
			`jp fsOpen`
			`jp fsGetC`
			`jp fsSeek`
			`jp fsTell`
			`jp cpHLDE`
Make userspace parse args the same way the shell does 2019-06-03 04:05:20 +10:00			`jp parseArgs`
Move apps/zasm/emul to tools/emul 2019-05-10 04:09:40 +10:00
zasm emul: hook fsdev in glue code 2019-05-17 03:23:23 +10:00			`#include "core.asm"`
Make userspace parse args the same way the shell does 2019-06-03 04:05:20 +10:00			`#include "err.h"`
Add the concept of unit tests Will be much much easier to tests new core routines without having to re-create their context first. Also, extract parse.asm from core.asm 2019-05-17 23:33:20 +10:00			`#include "parse.asm"`
zasm emul: hook fsdev in glue code 2019-05-17 03:23:23 +10:00			`.equ BLOCKDEV_RAMSTART RAMSTART`
			`.equ BLOCKDEV_COUNT 3`
			`#include "blockdev.asm"`
			`; List of devices`
			`.dw emulGetC, 0, emulSeek, emulTell`
			`.dw 0, emulPutC, 0, 0`
			`.dw fsdevGetC, fsdevPutC, fsdevSeek, fsdevTell`

			`.equ FS_RAMSTART BLOCKDEV_RAMEND`
			`.equ FS_HANDLE_COUNT 0`
			`#include "fs.asm"`

Move apps/zasm/emul to tools/emul 2019-05-10 04:09:40 +10:00			`init:`
			`di`
zasm emul: get rid of the kernel/user distinction Made things complicated for nothing. 2019-05-19 23:14:40 +10:00			`ld hl, 0xffff`
Move apps/zasm/emul to tools/emul 2019-05-10 04:09:40 +10:00			`ld sp, hl`
zasm emul: hook fsdev in glue code 2019-05-17 03:23:23 +10:00			`ld a, 2 ; select fsdev`
			`ld de, BLOCKDEV_GETC`
			`call blkSel`
			`call fsOn`
Make userspace parse args the same way the shell does 2019-06-03 04:05:20 +10:00			`ld hl, .zasmArgs`
zasm emul: bring back kernel/user distinction It was a bad idea to remove it. Now that I'm introducing the concept of a per-app glue file, it becomes much easier to build emulated zasm as a userspace app. 2019-05-20 02:57:59 +10:00			`call USER_CODE`
Move apps/zasm/emul to tools/emul 2019-05-10 04:09:40 +10:00			`; signal the emulator we're done`
			`halt`

Make userspace parse args the same way the shell does 2019-06-03 04:05:20 +10:00			`.zasmArgs:`
Make parseArgs not expect a leading space 2019-06-03 04:46:07 +10:00			`.db "0 1", 0`
Make userspace parse args the same way the shell does 2019-06-03 04:05:20 +10:00
zasm emul: add dumpSymbolTable debug routine Very helpful... 2019-05-18 03:22:45 +10:00			`; * I/O *`
zasm: Read from and write to streams instead of memory 2019-05-10 05:36:03 +10:00			`emulGetC:`
			`in a, (STDIO_PORT)`
			`or a ; cp 0`
			`jr z, .eof`
			`cp a ; ensure z`
			`ret`
			`.eof:`
			`call unsetZ`
			`ret`

			`emulPutC:`
			`out (STDIO_PORT), a`
			`ret`

zasm: read input in two passes 2019-05-11 10:32:05 +10:00			`emulSeek:`
zasm: change ioRewind to ioSeek Will need it soon. 2019-05-16 03:41:56 +10:00			`; the STDIN_SEEK port works by poking it twice. First poke is for high`
			`; byte, second poke is for low one.`
			`ld a, h`
			`out (STDIN_SEEK), a`
			`ld a, l`
			`out (STDIN_SEEK), a`
zasm: read input in two passes 2019-05-11 10:32:05 +10:00			`ret`

zasm: big local symbols overhaul 2019-05-16 10:07:21 +10:00			`emulTell:`
			`; same principle as STDIN_SEEK`
			`in a, (STDIN_SEEK)`
			`ld h, a`
			`in a, (STDIN_SEEK)`
			`ld l, a`
			`ret`

zasm emul: hook fsdev in glue code 2019-05-17 03:23:23 +10:00			`fsdevGetC:`
			`in a, (FS_DATA_PORT)`
			`cp a ; ensure Z`
			`ret`

			`fsdevPutC:`
			`out (FS_DATA_PORT), a`
			`ret`

			`fsdevSeek:`
			`push af`
Make blockdev pointers 32 bits This allows us to break through the 64K limit for includes CFS in zasm, a limit we were dangerously close to breaking. In fact, this commit makes us go over that limit. Right in time! 2019-05-29 05:56:39 +10:00			`ld a, e`
			`out (FS_SEEK_PORT), a`
zasm emul: hook fsdev in glue code 2019-05-17 03:23:23 +10:00			`ld a, h`
			`out (FS_SEEK_PORT), a`
zasm: iiiiiiiincluuuuuuudes!!1! 2019-05-17 11:15:00 +10:00			`ld a, l`
			`out (FS_SEEK_PORT), a`
zasm emul: hook fsdev in glue code 2019-05-17 03:23:23 +10:00			`pop af`
			`ret`

			`fsdevTell:`
			`push af`
			`in a, (FS_SEEK_PORT)`
Make blockdev pointers 32 bits This allows us to break through the 64K limit for includes CFS in zasm, a limit we were dangerously close to breaking. In fact, this commit makes us go over that limit. Right in time! 2019-05-29 05:56:39 +10:00			`ld e, a`
			`in a, (FS_SEEK_PORT)`
zasm emul: hook fsdev in glue code 2019-05-17 03:23:23 +10:00			`ld h, a`
zasm: iiiiiiiincluuuuuuudes!!1! 2019-05-17 11:15:00 +10:00			`in a, (FS_SEEK_PORT)`
			`ld l, a`
zasm emul: hook fsdev in glue code 2019-05-17 03:23:23 +10:00			`pop af`
			`ret`