collapseos/apps/zasm/directive.asm

330 lines
5.6 KiB
NASM
Raw Normal View History

2019-04-30 21:40:22 -04:00
; *** CONSTS ***
.equ D_DB 0x00
.equ D_DW 0x01
2019-05-11 22:11:05 -04:00
.equ D_EQU 0x02
2019-05-19 13:22:14 -04:00
.equ D_ORG 0x03
2019-05-20 08:20:00 -04:00
.equ D_FIL 0x04
2019-06-03 11:13:31 -04:00
.equ D_OUT 0x05
.equ D_INC 0x06
.equ D_BIN 0x07
.equ D_BAD 0xff
2019-04-30 21:40:22 -04:00
2019-05-11 22:11:05 -04:00
; *** Variables ***
2019-10-04 20:26:21 -04:00
; Result of the last .equ evaluation. Used for "@" symbol.
.equ DIREC_LASTVAL DIREC_RAMSTART
.equ DIREC_SCRATCHPAD DIREC_LASTVAL+2
2019-05-11 22:11:05 -04:00
.equ DIREC_RAMEND DIREC_SCRATCHPAD+SCRATCHPAD_SIZE
2019-04-30 21:40:22 -04:00
; *** CODE ***
; 3 bytes per row, fill with zero
2019-04-30 21:40:22 -04:00
directiveNames:
.db "DB", 0
.db "DW", 0
.db "EQU"
.db "ORG"
.db "FIL"
.db "OUT"
.db "INC"
.db "BIN"
2019-04-30 21:40:22 -04:00
2019-05-01 11:26:41 -04:00
; This is a list of handlers corresponding to indexes in directiveNames
directiveHandlers:
.dw handleDB
.dw handleDW
2019-05-11 22:11:05 -04:00
.dw handleEQU
2019-05-19 13:22:14 -04:00
.dw handleORG
2019-05-20 08:20:00 -04:00
.dw handleFIL
2019-06-03 11:13:31 -04:00
.dw handleOUT
2019-05-16 21:15:00 -04:00
.dw handleINC
.dw handleBIN
2019-05-01 11:26:41 -04:00
handleDB:
push hl
.loop:
2019-05-01 11:26:41 -04:00
call readWord
jr nz, .badfmt
2019-05-01 11:26:41 -04:00
ld hl, scratchpad
call enterDoubleQuotes
jr z, .stringLiteral
2019-05-17 17:21:49 -04:00
call parseExpr
jr nz, .badarg
push ix \ pop hl
ld a, h
or a ; cp 0
jr nz, .overflow ; not zero? overflow
ld a, l
call ioPutB
jr nz, .ioError
.stopStrLit:
call readComma
jr z, .loop
cp a ; ensure Z
pop hl
ret
.ioError:
ld a, SHELL_ERR_IO_ERROR
jr .error
.badfmt:
ld a, ERR_BAD_FMT
jr .error
.badarg:
ld a, ERR_BAD_ARG
jr .error
.overflow:
ld a, ERR_OVFL
.error:
call unsetZ
2019-05-01 11:26:41 -04:00
pop hl
ret
.stringLiteral:
ld a, (hl)
inc hl
or a ; when we encounter 0, that was what used to
jr z, .stopStrLit ; be our closing quote. Stop.
; Normal character, output
call ioPutB
jr nz, .ioError
jr .stringLiteral
2019-05-01 11:26:41 -04:00
handleDW:
push hl
.loop:
call readWord
jr nz, .badfmt
ld hl, scratchpad
2019-05-14 15:26:29 -04:00
call parseExpr
jr nz, .badarg
2019-05-17 15:14:38 -04:00
push ix \ pop hl
ld a, l
call ioPutB
jr nz, .ioError
2019-05-17 15:14:38 -04:00
ld a, h
call ioPutB
jr nz, .ioError
call readComma
jr z, .loop
cp a ; ensure Z
pop hl
ret
.ioError:
ld a, SHELL_ERR_IO_ERROR
jr .error
.badfmt:
ld a, ERR_BAD_FMT
jr .error
.badarg:
ld a, ERR_BAD_ARG
.error:
call unsetZ
pop hl
ret
2019-05-01 11:26:41 -04:00
2019-05-11 22:11:05 -04:00
handleEQU:
call zasmIsLocalPass ; Are we in local pass? Then ignore all .equ.
jr z, .skip ; they mess up duplicate symbol detection.
; We register constants on both first and second pass for one little
; reason: .org. Normally, we'd register constants on second pass only
; so that we have values for forward label references, but we need .org
; to be effective during the first pass and .org needs to support
; expressions. So, we double-parse .equ, clearing the const registry
; before the second pass.
2019-05-11 22:11:05 -04:00
push hl
push de
push bc
; Read our constant name
call readWord
jr nz, .badfmt
2019-05-11 22:11:05 -04:00
; We can't register our symbol yet: we don't have our value!
; Let's copy it over.
ld de, DIREC_SCRATCHPAD
ld bc, SCRATCHPAD_SIZE
ldir
2019-05-11 22:11:05 -04:00
; Now, read the value associated to it
call readWord
jr nz, .badfmt
2019-05-11 22:11:05 -04:00
ld hl, scratchpad
2019-05-14 15:26:29 -04:00
call parseExpr
jr nz, .badarg
2019-05-11 22:11:05 -04:00
ld hl, DIREC_SCRATCHPAD
push ix \ pop de
2019-10-04 20:26:21 -04:00
; Save value in "@" special variable
ld (DIREC_LASTVAL), de
call symRegisterConst ; A and Z set
jr z, .end ; success
; register ended up in error. We need to figure which error. If it's
; a duplicate error, we ignore it and return success because, as per
; ".equ" policy, it's fine to define the same const twice. The first
; value has precedence.
cp ERR_DUPSYM
; whatever the value of Z, it's the good one, return
jr .end
.badfmt:
ld a, ERR_BAD_FMT
jr .error
.badarg:
ld a, ERR_BAD_ARG
.error:
call unsetZ
2019-05-11 22:11:05 -04:00
.end:
pop bc
pop de
pop hl
ret
.skip:
; consume args and return
call readWord
jp readWord
2019-05-11 22:11:05 -04:00
2019-05-19 13:22:14 -04:00
handleORG:
call readWord
jr nz, .badfmt
2019-05-19 13:22:14 -04:00
call parseExpr
jr nz, .badarg
2019-05-19 13:22:14 -04:00
push ix \ pop hl
call zasmSetOrg
cp a ; ensure Z
ret
.badfmt:
ld a, ERR_BAD_FMT
jr .error
.badarg:
ld a, ERR_BAD_ARG
.error:
call unsetZ
ret
2019-05-19 13:22:14 -04:00
2019-05-20 08:20:00 -04:00
handleFIL:
call readWord
jr nz, .badfmt
2019-05-20 08:20:00 -04:00
call parseExpr
jr nz, .badarg
2019-05-20 08:20:00 -04:00
push bc
push ix \ pop bc
.loop:
ld a, b
or c
jr z, .loopend
xor a
call ioPutB
jr nz, .ioError
dec bc
jr .loop
.loopend:
cp a ; ensure Z
2019-05-20 08:20:00 -04:00
pop bc
ret
.ioError:
ld a, SHELL_ERR_IO_ERROR
jr .error
.badfmt:
ld a, ERR_BAD_FMT
jr .error
.badarg:
ld a, ERR_BAD_ARG
.error:
call unsetZ
ret
2019-05-20 08:20:00 -04:00
2019-06-03 11:13:31 -04:00
handleOUT:
push hl
; Read our expression
call readWord
jr nz, .badfmt
call zasmIsFirstPass ; No .out during first pass
jr z, .end
ld hl, scratchpad
call parseExpr
jr nz, .badarg
push ix \ pop hl
ld a, h
out (ZASM_DEBUG_PORT), a
ld a, l
out (ZASM_DEBUG_PORT), a
jr .end
.badfmt:
ld a, ERR_BAD_FMT
jr .error
.badarg:
ld a, ERR_BAD_ARG
.error:
call unsetZ
.end:
pop hl
ret
2019-05-16 21:15:00 -04:00
handleINC:
call readWord
jr nz, .badfmt
2019-05-16 21:15:00 -04:00
; HL points to scratchpad
call enterDoubleQuotes
jr nz, .badfmt
2019-05-16 21:15:00 -04:00
call ioOpenInclude
jr nz, .badfn
cp a ; ensure Z
ret
.badfmt:
ld a, ERR_BAD_FMT
jr .error
.badfn:
ld a, ERR_FILENOTFOUND
.error:
call unsetZ
2019-05-16 21:15:00 -04:00
ret
handleBIN:
call readWord
jr nz, .badfmt
; HL points to scratchpad
call enterDoubleQuotes
jr nz, .badfmt
call ioSpitBin
jr nz, .badfn
cp a ; ensure Z
ret
.badfmt:
ld a, ERR_BAD_FMT
jr .error
.badfn:
ld a, ERR_FILENOTFOUND
.error:
call unsetZ
ret
2019-04-30 21:40:22 -04:00
; Reads string in (HL) and returns the corresponding ID (D_*) in A. Sets Z if
; there's a match.
getDirectiveID:
ld a, (hl)
cp '.'
ret nz
push hl
2019-04-30 21:40:22 -04:00
push bc
push de
inc hl
ld b, D_BIN+1 ; D_BIN is last
ld c, 3
2019-04-30 21:40:22 -04:00
ld de, directiveNames
call findStringInList
pop de
pop bc
pop hl
2019-04-30 21:40:22 -04:00
ret
; Parse directive specified in A (D_* const) with args in I/O and act in
2019-05-01 11:26:41 -04:00
; an appropriate manner. If the directive results in writing data at its
; current location, that data is directly written through ioPutB.
; Each directive has the same return value pattern: Z on success, not-Z on
; error, A contains the error number (ERR_*).
2019-04-30 21:40:22 -04:00
parseDirective:
2019-05-01 11:26:41 -04:00
push de
; double A to have a proper offset in directiveHandlers
add a, a
ld de, directiveHandlers
call addDE
call intoDE
push de \ pop ix
2019-05-01 11:26:41 -04:00
pop de
jp (ix)