mirror of
https://github.com/hsoft/collapseos.git
synced 2024-11-10 02:28:06 +11:00
337 lines
5.6 KiB
NASM
337 lines
5.6 KiB
NASM
; *** CONSTS ***
|
|
|
|
.equ D_DB 0x00
|
|
.equ D_DW 0x01
|
|
.equ D_EQU 0x02
|
|
.equ D_ORG 0x03
|
|
.equ D_FIL 0x04
|
|
.equ D_OUT 0x05
|
|
.equ D_INC 0x06
|
|
.equ D_BIN 0x07
|
|
.equ D_BAD 0xff
|
|
|
|
; *** Variables ***
|
|
; Result of the last .equ evaluation. Used for "@" symbol.
|
|
.equ DIREC_LASTVAL DIREC_RAMSTART
|
|
.equ DIREC_SCRATCHPAD DIREC_LASTVAL+2
|
|
.equ DIREC_RAMEND DIREC_SCRATCHPAD+SCRATCHPAD_SIZE
|
|
; *** CODE ***
|
|
|
|
; 3 bytes per row, fill with zero
|
|
dirNames:
|
|
.db "DB", 0
|
|
.db "DW", 0
|
|
.db "EQU"
|
|
.db "ORG"
|
|
.db "FIL"
|
|
.db "OUT"
|
|
.db "INC"
|
|
.db "BIN"
|
|
|
|
; This is a list of handlers corresponding to indexes in dirNames
|
|
dirHandlers:
|
|
.dw handleDB
|
|
.dw handleDW
|
|
.dw handleEQU
|
|
.dw handleORG
|
|
.dw handleFIL
|
|
.dw handleOUT
|
|
.dw handleINC
|
|
.dw handleBIN
|
|
|
|
handleDB:
|
|
push de
|
|
push hl
|
|
.loop:
|
|
call readWord
|
|
jr nz, .badfmt
|
|
ld hl, scratchpad
|
|
call enterDoubleQuotes
|
|
jr z, .stringLiteral
|
|
call parseExpr
|
|
jr nz, .badarg
|
|
ld a, d
|
|
or a ; cp 0
|
|
jr nz, .overflow ; not zero? overflow
|
|
ld a, e
|
|
call ioPutB
|
|
jr nz, .ioError
|
|
.stopStrLit:
|
|
call readComma
|
|
jr z, .loop
|
|
cp a ; ensure Z
|
|
.end:
|
|
pop hl
|
|
pop de
|
|
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:
|
|
or a ; unset Z
|
|
jr .end
|
|
|
|
.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
|
|
|
|
handleDW:
|
|
push de
|
|
push hl
|
|
.loop:
|
|
call readWord
|
|
jr nz, .badfmt
|
|
ld hl, scratchpad
|
|
call parseExpr
|
|
jr nz, .badarg
|
|
ld a, e
|
|
call ioPutB
|
|
jr nz, .ioError
|
|
ld a, d
|
|
call ioPutB
|
|
jr nz, .ioError
|
|
call readComma
|
|
jr z, .loop
|
|
cp a ; ensure Z
|
|
.end:
|
|
pop hl
|
|
pop de
|
|
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:
|
|
or a ; unset Z
|
|
jr .end
|
|
|
|
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.
|
|
push hl
|
|
push de
|
|
push bc
|
|
; Read our constant name
|
|
call readWord
|
|
jr nz, .badfmt
|
|
; 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
|
|
|
|
; Now, read the value associated to it
|
|
call readWord
|
|
jr nz, .badfmt
|
|
ld hl, scratchpad
|
|
call parseExpr
|
|
jr nz, .badarg
|
|
ld hl, DIREC_SCRATCHPAD
|
|
; 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
|
|
.end:
|
|
pop bc
|
|
pop de
|
|
pop hl
|
|
ret
|
|
.skip:
|
|
; consume args and return
|
|
call readWord
|
|
jp readWord
|
|
|
|
handleORG:
|
|
push de
|
|
call readWord
|
|
jr nz, .badfmt
|
|
call parseExpr
|
|
jr nz, .badarg
|
|
ex de, hl
|
|
ld (DIREC_LASTVAL), hl
|
|
call zasmSetOrg
|
|
cp a ; ensure Z
|
|
.end:
|
|
pop de
|
|
ret
|
|
.badfmt:
|
|
ld a, ERR_BAD_FMT
|
|
jr .error
|
|
.badarg:
|
|
ld a, ERR_BAD_ARG
|
|
.error:
|
|
or a ; unset Z
|
|
jr .end
|
|
|
|
handleFIL:
|
|
call readWord
|
|
jr nz, .badfmt
|
|
call parseExpr
|
|
jr nz, .badarg
|
|
ld a, d
|
|
cp 0xd0
|
|
jr nc, .overflow
|
|
.loop:
|
|
ld a, d
|
|
or e
|
|
jr z, .loopend
|
|
xor a
|
|
call ioPutB
|
|
jr nz, .ioError
|
|
dec de
|
|
jr .loop
|
|
.loopend:
|
|
cp a ; ensure Z
|
|
ret
|
|
.ioError:
|
|
ld a, SHELL_ERR_IO_ERROR
|
|
jp unsetZ
|
|
.badfmt:
|
|
ld a, ERR_BAD_FMT
|
|
jp unsetZ
|
|
.badarg:
|
|
ld a, ERR_BAD_ARG
|
|
jp unsetZ
|
|
.overflow:
|
|
ld a, ERR_OVFL
|
|
jp unsetZ
|
|
|
|
handleOUT:
|
|
push de
|
|
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
|
|
ld a, d
|
|
out (ZASM_DEBUG_PORT), a
|
|
ld a, e
|
|
out (ZASM_DEBUG_PORT), a
|
|
jr .end
|
|
.badfmt:
|
|
ld a, ERR_BAD_FMT
|
|
jr .error
|
|
.badarg:
|
|
ld a, ERR_BAD_ARG
|
|
.error:
|
|
or a ; unset Z
|
|
.end:
|
|
pop hl
|
|
pop de
|
|
ret
|
|
|
|
handleINC:
|
|
call readWord
|
|
jr nz, .badfmt
|
|
; HL points to scratchpad
|
|
call enterDoubleQuotes
|
|
jr nz, .badfmt
|
|
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
|
|
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
|
|
|
|
; 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
|
|
push bc
|
|
push de
|
|
inc hl
|
|
ld b, D_BIN+1 ; D_BIN is last
|
|
ld c, 3
|
|
ld de, dirNames
|
|
call findStringInList
|
|
pop de
|
|
pop bc
|
|
pop hl
|
|
ret
|
|
|
|
; Parse directive specified in A (D_* const) with args in I/O and act in
|
|
; 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_*).
|
|
parseDirective:
|
|
push de
|
|
; double A to have a proper offset in dirHandlers
|
|
add a, a
|
|
ld de, dirHandlers
|
|
call addDE
|
|
call intoDE
|
|
push de \ pop ix
|
|
pop de
|
|
jp (ix)
|