collapseos/apps/zasm/main.asm

; *** Requirements ***
; blockdev
; JUMP_STRNCMP
; JUMP_ADDDE
; JUMP_ADDHL
; JUMP_UPCASE
; JUMP_UNSETZ
; JUMP_INTODE
; JUMP_FINDCHAR
; JUMP_BLKSEL
; RAMSTART	(where we put our variables in RAM)

jp	main
#include "util.asm"
.equ	IO_RAMSTART	RAMSTART
#include "io.asm"
#include "parse.asm"
#include "literal.asm"
#include "instr.asm"
#include "directive.asm"
.equ	SYM_RAMSTART	IO_RAMEND
#include "symbol.asm"

; *** Code ***
; Read file through blockdev ID in H and outputs its upcodes through blockdev
; ID in L.
main:
	ld	a, h
	ld	de, IO_IN_GETC
	call	JUMP_BLKSEL
	ld	a, l
	ld	de, IO_OUT_GETC
	call	JUMP_BLKSEL
	ld	hl, 0
	ld	(curOutputOffset), hl
.loop:
	call	ioReadLine
	or	a		; is A 0?
	jr	z, .stop	; We have EOF
	call	parseLine
	jr	nz, .stop
	jr	.loop
.stop:
	ret

; Increase (curOutputOffset) by A
incOutputOffset:
	push	de
	ld	de, (curOutputOffset)
	call	JUMP_ADDDE
	ld	(curOutputOffset), de
	pop	de
	ret

; Parse line in (HL), write the resulting opcode(s) in (DE) and increases
; (curOutputOffset) by the number of bytes written. Advances HL where
; tokenization stopped and DE to where we should write the next upcode.
; Sets Z if parse was successful, unset if there was an error or EOF.
parseLine:
	push	bc

	call	tokenize
	ld	a, b		; TOK_*
	cp	TOK_INSTR
	jr	z, .instr
	cp	TOK_DIRECTIVE
	jr	z, .direc
	cp	TOK_LABEL
	jr	z, .label
	cp	TOK_EMPTY
	jr	z, .success	; empty line? do nothing but don't error out.
	jr	.error		; token not supported
.instr:
	ld	a, c		; I_*
	call	parseInstruction
	or	a	; is zero?
	jr	z, .error
	call	incOutputOffset
	ld	b, a
	ld	hl, instrUpcode
.loopInstr:
	ld	a, (hl)
	call	ioPutC
	inc	hl
	djnz	.loopInstr
	jr	.success
.direc:
	ld	a, c		; D_*
	call	parseDirective
	call	incOutputOffset
	ld	b, a
	ld	hl, direcData
.loopDirec:
	ld	a, (hl)
	call	ioPutC
	inc	hl
	djnz	.loopDirec
	jr	.success
.label:
	; The string in (scratchpad) is a label with its trailing ':' removed.
	ld	hl, scratchpad
	ld	de, (curOutputOffset)
	call	symRegister

	jr	.success
.success:
	xor	a		; ensure Z
	jr	.end
.error:
	call	JUMP_UNSETZ
.end:
	pop	bc
	ret

; *** Variables ***
; The offset where we currently are with regards to outputting opcodes
curOutputOffset:
	.fill	2
Move apps/zasm/emul to tools/emul 2019-05-09 14:09:40 -04:00			`; * Requirements *`
zasm: Read from and write to streams instead of memory 2019-05-09 15:36:03 -04:00			`; blockdev`
Move apps/zasm/emul to tools/emul 2019-05-09 14:09:40 -04:00			`; JUMP_STRNCMP`
			`; JUMP_ADDDE`
zasm: add support for labels! 2019-05-09 21:21:08 -04:00			`; JUMP_ADDHL`
Move apps/zasm/emul to tools/emul 2019-05-09 14:09:40 -04:00			`; JUMP_UPCASE`
			`; JUMP_UNSETZ`
			`; JUMP_INTODE`
zasm: add support for labels! 2019-05-09 21:21:08 -04:00			`; JUMP_FINDCHAR`
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-10 18:20:43 -04:00			`; JUMP_BLKSEL`
zasm: add support for labels! 2019-05-09 21:21:08 -04:00			`; RAMSTART (where we put our variables in RAM)`
zasm: assemble multiple lines at once 2019-04-30 15:51:39 -04:00
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-10 18:20:43 -04:00			`jp main`
			`#include "util.asm"`
			`.equ IO_RAMSTART RAMSTART`
			`#include "io.asm"`
			`#include "parse.asm"`
			`#include "literal.asm"`
			`#include "instr.asm"`
			`#include "directive.asm"`
			`.equ SYM_RAMSTART IO_RAMEND`
			`#include "symbol.asm"`

zasm: assemble multiple lines at once 2019-04-30 15:51:39 -04:00			`; * Code *`
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-10 18:20:43 -04:00			`; Read file through blockdev ID in H and outputs its upcodes through blockdev`
			`; ID in L.`
zasm: assemble multiple lines at once 2019-04-30 15:51:39 -04:00			`main:`
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-10 18:20:43 -04:00			`ld a, h`
			`ld de, IO_IN_GETC`
			`call JUMP_BLKSEL`
			`ld a, l`
			`ld de, IO_OUT_GETC`
			`call JUMP_BLKSEL`
zasm: add support for labels! 2019-05-09 21:21:08 -04:00			`ld hl, 0`
			`ld (curOutputOffset), hl`
zasm: assemble multiple lines at once 2019-04-30 15:51:39 -04:00			`.loop:`
zasm: Read from and write to streams instead of memory 2019-05-09 15:36:03 -04:00			`call ioReadLine`
			`or a ; is A 0?`
			`jr z, .stop ; We have EOF`
zasm: assemble multiple lines at once 2019-04-30 15:51:39 -04:00			`call parseLine`
zasm: adjust parseLine success condition De-couple "success" from "wrote something to (DE)" so that directive parsing can be considered successful without writing to (DE). 2019-05-01 10:16:57 -04:00			`jr nz, .stop`
zasm: assemble multiple lines at once 2019-04-30 15:51:39 -04:00			`jr .loop`
			`.stop:`
			`ret`

zasm: add support for labels! 2019-05-09 21:21:08 -04:00			`; Increase (curOutputOffset) by A`
			`incOutputOffset:`
			`push de`
			`ld de, (curOutputOffset)`
			`call JUMP_ADDDE`
			`ld (curOutputOffset), de`
			`pop de`
			`ret`

			`; Parse line in (HL), write the resulting opcode(s) in (DE) and increases`
			`; (curOutputOffset) by the number of bytes written. Advances HL where`
			`; tokenization stopped and DE to where we should write the next upcode.`
zasm: adjust parseLine success condition De-couple "success" from "wrote something to (DE)" so that directive parsing can be considered successful without writing to (DE). 2019-05-01 10:16:57 -04:00			`; Sets Z if parse was successful, unset if there was an error or EOF.`
zasm: assemble multiple lines at once 2019-04-30 15:51:39 -04:00			`parseLine:`
			`push bc`
zasm: move token variables from tok.asm into main.asm 2019-04-30 17:04:42 -04:00
zasm: assemble multiple lines at once 2019-04-30 15:51:39 -04:00			`call tokenize`
zasm: remove the "token" variable 2019-04-30 22:27:11 -04:00			`ld a, b ; TOK_*`
zasm: still inching toward directives 2019-04-30 21:40:22 -04:00			`cp TOK_INSTR`
			`jr z, .instr`
zasm: add support for ".db" directive 2019-05-01 11:26:41 -04:00			`cp TOK_DIRECTIVE`
			`jr z, .direc`
zasm: add support for labels! 2019-05-09 21:21:08 -04:00			`cp TOK_LABEL`
			`jr z, .label`
zasm: Read from and write to streams instead of memory 2019-05-09 15:36:03 -04:00			`cp TOK_EMPTY`
			`jr z, .success ; empty line? do nothing but don't error out.`
zasm: add support for ".db" directive 2019-05-01 11:26:41 -04:00			`jr .error ; token not supported`
zasm: still inching toward directives 2019-04-30 21:40:22 -04:00			`.instr:`
zasm: remove the "token" variable 2019-04-30 22:27:11 -04:00			`ld a, c ; I_*`
zasm: still inching toward directives 2019-04-30 21:40:22 -04:00			`call parseInstruction`
zasm: assemble multiple lines at once 2019-04-30 15:51:39 -04:00			`or a ; is zero?`
			`jr z, .error`
zasm: add support for labels! 2019-05-09 21:21:08 -04:00			`call incOutputOffset`
zasm: Read from and write to streams instead of memory 2019-05-09 15:36:03 -04:00			`ld b, a`
zasm: add support for ".db" directive 2019-05-01 11:26:41 -04:00			`ld hl, instrUpcode`
zasm: Read from and write to streams instead of memory 2019-05-09 15:36:03 -04:00			`.loopInstr:`
			`ld a, (hl)`
			`call ioPutC`
			`inc hl`
			`djnz .loopInstr`
zasm: add support for ".db" directive 2019-05-01 11:26:41 -04:00			`jr .success`
			`.direc:`
			`ld a, c ; D_*`
			`call parseDirective`
zasm: add support for labels! 2019-05-09 21:21:08 -04:00			`call incOutputOffset`
zasm: Read from and write to streams instead of memory 2019-05-09 15:36:03 -04:00			`ld b, a`
zasm: add support for ".db" directive 2019-05-01 11:26:41 -04:00			`ld hl, direcData`
zasm: Read from and write to streams instead of memory 2019-05-09 15:36:03 -04:00			`.loopDirec:`
			`ld a, (hl)`
			`call ioPutC`
			`inc hl`
			`djnz .loopDirec`
zasm: adjust parseLine success condition De-couple "success" from "wrote something to (DE)" so that directive parsing can be considered successful without writing to (DE). 2019-05-01 10:16:57 -04:00			`jr .success`
zasm: add support for labels! 2019-05-09 21:21:08 -04:00			`.label:`
			`; The string in (scratchpad) is a label with its trailing ':' removed.`
			`ld hl, scratchpad`
			`ld de, (curOutputOffset)`
			`call symRegister`

			`jr .success`
zasm: adjust parseLine success condition De-couple "success" from "wrote something to (DE)" so that directive parsing can be considered successful without writing to (DE). 2019-05-01 10:16:57 -04:00			`.success:`
			`xor a ; ensure Z`
zasm: assemble multiple lines at once 2019-04-30 15:51:39 -04:00			`jr .end`
			`.error:`
zasm: adjust parseLine success condition De-couple "success" from "wrote something to (DE)" so that directive parsing can be considered successful without writing to (DE). 2019-05-01 10:16:57 -04:00			`call JUMP_UNSETZ`
zasm: assemble multiple lines at once 2019-04-30 15:51:39 -04:00			`.end:`
			`pop bc`
			`ret`

zasm: add support for labels! 2019-05-09 21:21:08 -04:00			`; * Variables *`
			`; The offset where we currently are with regards to outputting opcodes`
			`curOutputOffset:`
			`.fill 2`