collapseos/apps/zasm/expr.asm
2019-05-19 10:45:11 -04:00

93 lines
2.2 KiB
NASM

; Parse expression in string at (HL) and returns the result in IX.
; We expect (HL) to be disposable: we mutate it to avoid having to make a copy.
; Sets Z on success, unset on error.
parseExpr:
; Before we evaluate an expression, we first try for a regular number or
; symbol. We do this because parsing expressions can mess up some values
; with its splitting logic. For example '-' is going to end up '\0'.
call parseNumberOrSymbol
ret z
push de
push hl
call _parseExpr
pop hl
pop de
ret
_parseExpr:
ld a, '+'
call _findAndSplit
jp z, _applyPlus
ld a, '-'
call _findAndSplit
jp z, _applyMinus
ld a, '*'
call _findAndSplit
jp z, _applyMult
ret ; failure
; Given a string in (HL) and a separator char in A, return a splitted string,
; that is, the same (HL) string but with the found A char replaced by a null
; char. DE points to the second part of the split.
; Sets Z if found, unset if not found.
_findAndSplit:
push hl
call findchar
jr nz, .end ; nothing found
; Alright, we have our char and we're pointing at it. Let's replace it
; with a null char.
xor a
ld (hl), a ; + changed to \0
inc hl
ex de, hl ; DE now points to the second part of the split
cp a ; ensure Z
.end:
pop hl ; HL is back to the start
ret
; parse expression on the left (HL) and the right (DE) and put the results in
; DE (left) and IX (right)
_resolveLeftAndRight:
call parseExpr
ret nz ; return immediately if error
; Now we have parsed everything to the left and we have its result in
; IX. What we need to do now is the same thing on (DE) and then apply
; the + operator. Let's save IX somewhere and parse this.
ex de, hl ; right expr now in HL
push ix
pop de ; numeric left expr result in DE
jp parseExpr
; Parse expr in (HL) and expr in (DE) and apply + operator to both sides.
; Put result in IX.
_applyPlus:
call _resolveLeftAndRight
ret nz
; Good! let's do the math! IX has our right part, DE has our left one.
add ix, de
cp a ; ensure Z
ret
; Same as _applyPlus but with -
_applyMinus:
call _resolveLeftAndRight
ret nz
push ix
pop hl
ex de, hl
scf \ ccf
sbc hl, de
push hl
pop ix
cp a ; ensure Z
ret
_applyMult:
call _resolveLeftAndRight
ret nz
push ix \ pop bc
call multDEBC
push hl \ pop ix
cp a ; ensure Z
ret