collapseos/kernel/core.asm

226 lines
3.8 KiB
NASM
Raw Normal View History

; core
;
; Routines used by pretty much all parts. You will want to include it first
; in your glue file.
; *** CONSTS ***
2019-05-14 16:42:44 -04:00
.equ ASCII_CR 0x0d
.equ ASCII_LF 0x0a
2019-04-23 13:29:16 -04:00
; *** DATA ***
; Useful data to point to, when a pointer is needed.
P_NULL: .db 0
; *** REGISTER FIDDLING ***
; add the value of A into DE
addDE:
2019-04-30 15:51:39 -04:00
push af
add a, e
jr nc, .end ; no carry? skip inc
inc d
.end:
ld e, a
2019-04-30 15:51:39 -04:00
pop af
ret
; copy (DE) into DE, little endian style (addresses in z80 are always have
; their LSB before their MSB)
intoDE:
push af
ld a, (de)
inc de
ex af, af'
ld a, (de)
ld d, a
ex af, af'
ld e, a
pop af
ret
2019-04-23 13:29:16 -04:00
intoHL:
push de
ex de, hl
call intoDE
ex de, hl
pop de
ret
; add the value of A into HL
addHL:
2019-04-30 15:51:39 -04:00
push af
add a, l
jr nc, .end ; no carry? skip inc
inc h
.end:
ld l, a
2019-04-30 15:51:39 -04:00
pop af
ret
; subtract the value of A from HL
subHL:
push af
; To avoid having to swap L and A, we sub "backwards", that is, we add
; a NEGated value. This means that the carry flag is inverted
neg
add a, l
jr c, .end ; if carry, no carry. :)
dec h
.end:
ld l, a
pop af
ret
; Write the contents of HL in (DE)
writeHLinDE:
push af
ld a, l
ld (de), a
inc de
ld a, h
ld (de), a
dec de
pop af
ret
2019-04-14 17:01:28 -04:00
; jump to the location pointed to by IX. This allows us to call IX instead of
; just jumping it. We use IX because we never use this for arguments.
callIX:
jp (ix)
ret
callIY:
jp (iy)
ret
; Ensures that Z is unset (more complicated than it sounds...)
unsetZ:
push bc
ld b, a
inc b
cp b
pop bc
ret
; *** STRINGS ***
2019-04-23 13:29:16 -04:00
; Fill B bytes at (HL) with A
fill:
push bc
push hl
.loop:
ld (hl), a
inc hl
djnz .loop
pop hl
pop bc
ret
; Increase HL until the memory address it points to is equal to A for a maximum
; of 0xff bytes. Returns the new HL value as well as the number of bytes
; iterated in A.
; If a null char is encountered before we find A, processing is stopped in the
; same way as if we found our char (so, we look for A *or* 0)
2019-05-14 15:26:29 -04:00
; Set Z if the character is found. Unsets it if not
findchar:
push bc
ld c, a ; let's use C as our cp target
ld a, 0xff
ld b, a
.loop: ld a, (hl)
cp c
2019-05-14 15:26:29 -04:00
jr z, .match
or a ; cp 0
jr z, .nomatch
inc hl
djnz .loop
2019-05-14 15:26:29 -04:00
.nomatch:
call unsetZ
jr .end
.match:
; We ran 0xff-B loops. That's the result that goes in A.
ld a, 0xff
2019-05-17 20:47:43 -04:00
sub b
2019-05-14 15:26:29 -04:00
cp a ; ensure Z
.end:
pop bc
ret
; Format the lower nibble of A into a hex char and stores the result in A.
fmtHex:
2019-05-14 16:42:44 -04:00
and 0xf
cp 10
jr nc, .alpha ; if >= 10, we have alpha
add a, '0'
ret
.alpha:
add a, 'A'-10
ret
; Formats value in A into a string hex pair. Stores it in the memory location
; that HL points to. Does *not* add a null char at the end.
fmtHexPair:
push af
; let's start with the rightmost char
inc hl
call fmtHex
ld (hl), a
; and now with the leftmost
dec hl
pop af
push af
2019-05-14 16:50:35 -04:00
and 0xf0
rra \ rra \ rra \ rra
call fmtHex
ld (hl), a
pop af
ret
; Compares strings pointed to by HL and DE up to A count of characters. If
; equal, Z is set. If not equal, Z is reset.
strncmp:
push bc
push hl
push de
ld b, a
.loop:
ld a, (de)
cp (hl)
2019-04-14 17:01:28 -04:00
jr nz, .end ; not equal? break early. NZ is carried out
; to the called
cp 0 ; If our chars are null, stop the cmp
jr z, .end ; The positive result will be carried to the
; caller
inc hl
inc de
djnz .loop
2019-04-14 17:01:28 -04:00
; We went through all chars with success, but our current Z flag is
; unset because of the cp 0. Let's do a dummy CP to set the Z flag.
cp a
.end:
pop de
pop hl
pop bc
; Because we don't call anything else than CP that modify the Z flag,
; our Z value will be that of the last cp (reset if we broke the loop
; early, set otherwise)
ret
; Transforms the character in A, if it's in the a-z range, into its upcase
; version.
upcase:
cp 'a'
ret c ; A < 'a'. nothing to do
cp 'z'+1
ret nc ; A >= 'z'+1. nothing to do
; 'a' - 'A' == 0x20
sub 0x20
ret