CODE.md

@@ -32,25 +32,6 @@ Thus, code that glue parts together could look like:
     MOD2_RAMSTART .equ MOD1_RAMEND
     #include "mod2.asm"
 
-## Register protection
-
-As a general rule, all routines systematically protect registers they use,
-including input parameters. This allows us to stop worrying, each time we call
-a routine, whether our registers are all messed up.
-
-Some routines stray from that rule, but the fact that they destroy a particular
-register is documented. An undocumented register change is considered a bug.
-Clean up after yourself, you nasty routine!
-
-Another exception to this rule are "top-level" routines, that is, routines that
-aren't designed to be called from other parts of Collapse OS. Those are
-generally routines close to an application's main loop.
-
-It is important to note, however, that shadow registers aren't preserved.
-Therefore, shadow registers should only be used in code that doesn't call
-routines or that call a routine that explicitly states that it preserves
-shadow registers.
-
 ## Stack management
 
 Keeping the stack "balanced" is a big challenge when writing assembler code.

TRICKS.txt

@@ -1,8 +1,6 @@
 This file describe tricks and conventions that are used throughout the code and
 might need explanation.
 
-*** Quickies
-
 or a: Equivalent to "cp 0", but results in a shorter opcode.
 
 xor a: sets A to 0 more efficiently than ld a, 0
@@ -10,16 +8,12 @@ xor a: sets A to 0 more efficiently than ld a, 0
 and 0xbf: Given a letter in the a-z range, changes it to its uppercase value
 if it's already uppercased, then it stays that way.
 
-*** Z flag for results
-
 Z if almost always used as a success indicator for routines. Set for success,
 Reset for failure. "xor a" (destroys A) and "cp a" (preserves A) are used to
 ensure Z is set. To ensure that it is reset, it's a bit more complicated and
 "unsetZ" routine exists for that, although that in certain circumstances,
 "inc a \ dec a" or "or a" can work.
 
-*** Little endian
-
 z80 is little endian in its 16-bit loading operations. For example, "ld hl, (0)"
 will load the contents of memory address 0 in L and memory address 1 in H. This
 little-endianess is followed by Collapse OS in most situations. When it's not,
@@ -31,21 +25,3 @@ are stored as "big endian pair of little endian 16-bit numbers". For example,
 if "ld dehl, (0)" existed and if the first 4 bytes of memory were 0x01, 0x02,
 0x03 and 0x04, then DE (being the "high" word) would be 0x0201 and HL would be
 0x0403.
-
-*** DAA
-
-When it comes to dealing with decimals, the DAA instruction, which look a bit
-obscur, can be very useful. It transforms the result of a previous arithmetic
-operation involving two BCD (binary coded decimal, one digit in high nibble,
-the other digit in low nibble. For example, 0x99 represents 99) into a valid
-BCD. For example, 0x12+0x19=0x2b, but after calling DAA, it will be 0x31.
-
-To clear misunderstanding: this does **not** transform an arbitrary value into
-BCD. For example, "ld a, 0xff \ daa" isn't going to magically give you a binary
-coded 255 (how could it?). This is designed to be ran after an arithmetic
-operation.
-
-A common trick to transform an arbitrary number to BCD is to loop 8 times over
-your bitstream, SLA your bits out of your binary value and then run
-"adc a, a \ daa" over it (with provisions for carries if you expect numbers
-over 99).

apps/basic/glue.asm

@@ -11,12 +11,7 @@
 
 .inc "core.asm"
 .inc "lib/util.asm"
-.inc "lib/ari.asm"
 .inc "lib/parse.asm"
-.inc "lib/fmt.asm"
-.equ	EXPR_PARSE	parseLiteral
-.inc "lib/expr.asm"
-.inc "basic/tok.asm"
 .equ	BAS_RAMSTART	USER_RAMSTART
 .inc "basic/main.asm"
 USER_RAMSTART:

apps/basic/main.asm

@@ -1,13 +1,10 @@
-; *** Constants ***
-.equ	BAS_SCRATCHPAD_SIZE	0x20
 ; *** Variables ***
 ; Value of `SP` when basic was first invoked. This is where SP is going back to
 ; on restarts.
 .equ	BAS_INITSP	BAS_RAMSTART
 ; **Pointer** to current line number
 .equ	BAS_PCURLN	@+2
-.equ	BAS_SCRATCHPAD	@+2
+.equ	BAS_RAMEND	@+2
-.equ	BAS_RAMEND	@+BAS_SCRATCHPAD_SIZE
 
 ; *** Code ***
 basStart:
@@ -42,37 +39,24 @@ basPrompt:
 	.db "> ", 0
 
 basDirect:
-	; First, get cmd length
-	call	fnWSIdx
-	cp	7
-	jr	nc, .unknown	; Too long, can't possibly fit anything.
-	; A contains whitespace IDX, save it in B
-	ld	b, a
 	ex	de, hl
-	ld	hl, basCmds1+2
+	ld	hl, basCmds1
 .loop:
-	ld	a, b		; whitespace IDX
+	ld	a, 4
 	call	strncmp
 	jr	z, .found
-	ld	a, 8
+	ld	a, 6
 	call	addHL
 	ld	a, (hl)
 	cp	0xff
 	jr	nz, .loop
-.unknown:
 	ld	hl, .sUnknown
 	jr	basPrintLn
 
 .found:
-	dec	hl \ dec hl
+	inc	hl \ inc hl \ inc hl \ inc hl
 	call	intoHL
-	push	hl \ pop ix
+	jp	(hl)
-	; Bring back command string from DE to HL
-	ex	de, hl
-	ld	a, b	; cmd's length
-	call	addHL
-	call	rdWS
-	jp	(ix)
 
 .sUnknown:
 	.db	"Unknown command", 0
@@ -82,17 +66,7 @@ basPrintLn:
 	call	printstr
 	jp	printcrlf
 
-basERR:
-	ld	hl, .sErr
-	jr	basPrintLn
-.sErr:
-	.db	"ERR", 0
-
 ; *** Commands ***
-; A command receives its argument through (HL), which is already placed to
-; either:
-; 1 - the end of the string if the command has no arg.
-; 2 - the beginning of the arg, with whitespace properly skipped.
 basBYE:
 	ld	hl, .sBye
 	call	basPrintLn
@@ -104,20 +78,10 @@ basBYE:
 .sBye:
 	.db	"Goodbye!", 0
 
-basPRINT:
-	call	parseExpr
-	jp	nz, basERR
-	push	ix \ pop de
-	ld	hl, BAS_SCRATCHPAD
-	call	fmtDecimal
-	jp	basPrintLn
-
 ; direct only
 basCmds1:
+	.db	"bye", 0
 	.dw	basBYE
-	.db	"bye", 0, 0, 0
 ; statements
 basCmds2:
-	.dw	basPRINT
+	.db	0xff	; end of table
-	.db	"print", 0
-	.db	0xff, 0xff, 0xff	; end of table

apps/basic/tok.asm

@@ -1,48 +0,0 @@
-; Expect at least one whitespace (0x20, 0x09) at (HL), and then advance HL
-; until a non-whitespace character is met.
-; HL is advanced to the first non-whitespace char.
-; Sets Z on success, unset on failure.
-; Failure is either not having a first whitespace or reaching the end of the
-; string.
-; Sets Z if we found a non-whitespace char, unset if we found the end of string.
-rdWS:
-	ld	a, (hl)
-	call	isSep
-	ret	nz	; failure
-.loop:
-	inc	hl
-	ld	a, (hl)
-	call	isSep
-	jr	z, .loop
-	or	a	; cp 0
-	jp	z, .fail
-	cp	a	; ensure Z
-	ret
-.fail:
-	; A is zero at this point
-	inc	a	; unset Z
-	ret
-
-; Find the first whitespace in (HL) and returns its index in A
-; Sets Z if whitespace is found, unset if end of string was found.
-; In the case where no whitespace was found, A returns the length of the string.
-fnWSIdx:
-	push	hl
-	push	bc
-	ld	b, 0
-.loop:
-	ld	a, (hl)
-	call	isSep
-	jr	z, .found
-	or	a
-	jr	z, .eos
-	inc	hl
-	inc	b
-	jr	.loop
-.eos:
-	inc	a	; unset Z
-.found:			; Z already set from isSep
-	ld	a, b
-	pop	bc
-	pop	hl
-	ret

apps/lib/ari.asm

@@ -1,27 +0,0 @@
-; Borrowed from Tasty Basic by Dimitri Theulings (GPL).
-; Divide HL by DE, placing the result in BC and the remainder in HL.
-divide:
-	push hl		; --> lvl 1
-	ld l, h		; divide h by de
-	ld h, 0
-	call .dv1
-	ld b, c		; save result in b
-	ld a, l		; (remainder + l) / de
-	pop hl		; <-- lvl 1
-	ld h, a
-.dv1:
-	ld c, 0xff	; result in c
-.dv2:
-	inc c		; dumb routine
-	call .subde	; divide using subtract and count
-	jr nc, .dv2
-	add hl, de
-	ret
-.subde:
-	ld a, l
-	sub e		; subtract de from hl
-	ld l, a
-	ld a, h
-	sbc a, d
-	ld h, a
-	ret

apps/lib/fmt.asm

@@ -1,46 +0,0 @@
-
-; Format the number in DE into the string at (HL) in a decimal form.
-; Null-terminated. DE is considered an unsigned number.
-fmtDecimal:
-	push	ix
-	push	hl
-	push	de
-	push	af
-
-	push	hl \ pop ix
-	ex	de, hl	; orig number now in HL
-	ld	e, 0
-.loop1:
-	call	.div10
-	push	hl	; push remainder. --> lvl E
-	inc	e
-	ld	a, b		; result 0?
-	or	c
-	push	bc \ pop hl
-	jr	nz, .loop1	; not zero, continue
-	; We now have C digits to print in the stack.
-	; Spit them!
-	push	ix \ pop hl	; restore orig HL.
-	ld	b, e
-.loop2:
-	pop	de	; <-- lvl E
-	ld	a, '0'
-	add	a, e
-	ld	(hl), a
-	inc	hl
-	djnz	.loop2
-
-	; null terminate
-	xor	a
-	ld	(hl), a
-	pop	af
-	pop	de
-	pop	hl
-	pop	ix
-	ret
-.div10:
-	push	de
-	ld	de, 0x000a
-	call	divide
-	pop	de
-	ret

apps/lib/parse.asm

@@ -136,168 +136,3 @@ parseDecimal:
 .error:
 	pop	hl
 	jp	unsetZ
-
-; Parse string at (HL) as a hexadecimal value and return value in IX under the
-; same conditions as parseLiteral.
-parseHexadecimal:
-	call	hasHexPrefix
-	ret	nz
-	push	hl
-	push	de
-	ld	d, 0
-	inc	hl	; get rid of "0x"
-	inc	hl
-	call	strlen
-	cp	3
-	jr	c, .single
-	cp	4
-	jr	c, .doubleShort	; 0x123
-	cp	5
-	jr	c, .double	; 0x1234
-	; too long, error
-	jr	.error
-.double:
-	call	parseHexPair
-	jr	c, .error
-	inc	hl			; now HL is on first char of next pair
-	ld	d, a
-	jr	.single
-.doubleShort:
-	ld	a, (hl)
-	call	parseHex
-	jr	c, .error
-	inc	hl			; now HL is on first char of next pair
-	ld	d, a
-.single:
-	call	parseHexPair
-	jr	c, .error
-	ld	e, a
-	cp	a			; ensure Z
-	jr	.end
-.error:
-	call	unsetZ
-.end:
-	push	de \ pop ix
-	pop	de
-	pop	hl
-	ret
-
-; Sets Z if (HL) has a '0x' prefix.
-hasHexPrefix:
-	ld	a, (hl)
-	cp	'0'
-	ret	nz
-	push	hl
-	inc	hl
-	ld	a, (hl)
-	cp	'x'
-	pop	hl
-	ret
-
-; Parse string at (HL) as a binary value (0b010101) and return value in IX.
-; High IX byte is always clear.
-; Sets Z on success.
-parseBinaryLiteral:
-	call	hasBinPrefix
-	ret	nz
-	push	bc
-	push	hl
-	push	de
-	ld	d, 0
-	inc	hl	; get rid of "0b"
-	inc	hl
-	call	strlen
-	or	a
-	jr	z, .error	; empty, error
-	cp	9
-	jr	nc, .error	; >= 9, too long
-	; We have a string of 8 or less chars. What we'll do is that for each
-	; char, we rotate left and set the LSB according to whether we have '0'
-	; or '1'. Error out on anything else. C is our stored result.
-	ld	b, a		; we loop for "strlen" times
-	ld	c, 0		; our stored result
-.loop:
-	rlc	c
-	ld	a, (hl)
-	inc	hl
-	cp	'0'
-	jr	z, .nobit	; no bit to set
-	cp	'1'
-	jr	nz, .error	; not 0 or 1
-	; We have a bit to set
-	inc	c
-.nobit:
-	djnz	.loop
-	ld	e, c
-	cp	a		; ensure Z
-	jr	.end
-.error:
-	call	unsetZ
-.end:
-	push	de \ pop ix
-	pop	de
-	pop	hl
-	pop	bc
-	ret
-
-; Sets Z if (HL) has a '0b' prefix.
-hasBinPrefix:
-	ld	a, (hl)
-	cp	'0'
-	ret	nz
-	push	hl
-	inc	hl
-	ld	a, (hl)
-	cp	'b'
-	pop	hl
-	ret
-
-; Parse string at (HL) and, if it is a char literal, sets Z and return
-; corresponding value in IX. High IX byte is always clear.
-;
-; A valid char literal starts with ', ends with ' and has one character in the
-; middle. No escape sequence are accepted, but ''' will return the apostrophe
-; character.
-parseCharLiteral:
-	ld	a, 0x27		; apostrophe (') char
-	cp	(hl)
-	ret	nz
-
-	push	hl
-	push	de
-	inc	hl
-	inc	hl
-	cp	(hl)
-	jr	nz, .end	; not ending with an apostrophe
-	inc	hl
-	ld	a, (hl)
-	or	a		; cp 0
-	jr	nz, .end	; string has to end there
-	; Valid char, good
-	ld	d, a		; A is zero, take advantage of that
-	dec	hl
-	dec	hl
-	ld	a, (hl)
-	ld	e, a
-	cp	a		; ensure Z
-.end:
-	push	de \ pop ix
-	pop	de
-	pop	hl
-	ret
-
-; Parses the string at (HL) and returns the 16-bit value in IX. The string
-; can be a decimal literal (1234), a hexadecimal literal (0x1234) or a char
-; literal ('X').
-;
-; As soon as the number doesn't fit 16-bit any more, parsing stops and the
-; number is invalid. If the number is valid, Z is set, otherwise, unset.
-parseLiteral:
-	call	parseCharLiteral
-	ret	z
-	call	parseHexadecimal
-	ret	z
-	call	parseBinaryLiteral
-	ret	z
-	jp	parseDecimal
-

apps/lib/util.asm

@@ -26,67 +26,3 @@ strcpy:
 	pop	hl
 	ret
 
-; Compares strings pointed to by HL and DE until one of them hits its null char.
-; If equal, Z is set. If not equal, Z is reset.
-strcmp:
-	push	hl
-	push	de
-
-.loop:
-	ld	a, (de)
-	cp	(hl)
-	jr	nz, .end	; not equal? break early. NZ is carried out
-				; to the called
-	or	a		; If our chars are null, stop the cmp
-	jr	z, .end		; The positive result will be carried to the
-	                        ; caller
-	inc	hl
-	inc	de
-	jr	.loop
-
-.end:
-	pop	de
-	pop	hl
-	; 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
-
-; Returns length of string at (HL) in A.
-; Doesn't include null termination.
-strlen:
-	push	bc
-	push	hl
-	ld	bc, 0
-	xor	a	; look for null char
-.loop:
-	cpi
-	jp	z, .found
-	jr	.loop
-.found:
-	; How many char do we have? the (NEG BC)-1, which started at 0 and
-	; decreased at each CPI call. In this routine, we stay in the 8-bit
-	; realm, so C only.
-	ld	a, c
-	neg
-	dec	a
-	pop	hl
-	pop	bc
-	ret
-
-; DE * BC -> DE (high) and HL (low)
-multDEBC:
-	ld	hl, 0
-	ld	a, 0x10
-.loop:
-	add	hl, hl
-	rl	e
-	rl	d
-	jr	nc, .noinc
-	add	hl, bc
-	jr	nc, .noinc
-	inc	de
-.noinc:
-	dec a
-	jr	nz, .loop
-	ret

apps/zasm/expr.asm

@@ -1,15 +1,3 @@
-; *** Requirements ***
-; findchar
-; multDEBC
-;
-; *** Defines ***
-;
-; EXPR_PARSE: routine to call to parse literals or symbols that are part of
-;             the expression. Routine's signature:
-;	      String in (HL), returns its parsed value to IX. Z for success.
-;
-; *** Code ***
-;
 ; 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.
@@ -31,7 +19,7 @@ _parseExpr:
 	ld	a, '*'
 	call	_findAndSplit
 	jp	z, _applyMult
-	jp	EXPR_PARSE
+	jp	parseNumberOrSymbol
 
 ; 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

apps/zasm/glue.asm

@@ -31,6 +31,8 @@
 ; _blkSeek
 ; _blkTell
 ; printstr
+; FS_HANDLE_SIZE
+; BLOCKDEV_SIZE
 
 .inc "user.h"
 
@@ -78,8 +80,7 @@ jp	zasmMain
 .equ	DIREC_RAMSTART	INS_RAMEND
 .inc "zasm/directive.asm"
 .inc "zasm/parse.asm"
-.equ	EXPR_PARSE	parseNumberOrSymbol
+.inc "zasm/expr.asm"
-.inc "lib/expr.asm"
 .equ	SYM_RAMSTART	DIREC_RAMEND
 .inc "zasm/symbol.asm"
 .equ	ZASM_RAMSTART	SYM_RAMEND

apps/zasm/parse.asm

@@ -1,3 +1,167 @@
+; Parse string at (HL) as a hexadecimal value and return value in IX under the
+; same conditions as parseLiteral.
+parseHexadecimal:
+	call	hasHexPrefix
+	ret	nz
+	push	hl
+	push	de
+	ld	d, 0
+	inc	hl	; get rid of "0x"
+	inc	hl
+	call	strlen
+	cp	3
+	jr	c, .single
+	cp	4
+	jr	c, .doubleShort	; 0x123
+	cp	5
+	jr	c, .double	; 0x1234
+	; too long, error
+	jr	.error
+.double:
+	call	parseHexPair
+	jr	c, .error
+	inc	hl			; now HL is on first char of next pair
+	ld	d, a
+	jr	.single
+.doubleShort:
+	ld	a, (hl)
+	call	parseHex
+	jr	c, .error
+	inc	hl			; now HL is on first char of next pair
+	ld	d, a
+.single:
+	call	parseHexPair
+	jr	c, .error
+	ld	e, a
+	cp	a			; ensure Z
+	jr	.end
+.error:
+	call	unsetZ
+.end:
+	push	de \ pop ix
+	pop	de
+	pop	hl
+	ret
+
+; Sets Z if (HL) has a '0x' prefix.
+hasHexPrefix:
+	ld	a, (hl)
+	cp	'0'
+	ret	nz
+	push	hl
+	inc	hl
+	ld	a, (hl)
+	cp	'x'
+	pop	hl
+	ret
+
+; Parse string at (HL) as a binary value (0b010101) and return value in IX.
+; High IX byte is always clear.
+; Sets Z on success.
+parseBinaryLiteral:
+	call	hasBinPrefix
+	ret	nz
+	push	bc
+	push	hl
+	push	de
+	ld	d, 0
+	inc	hl	; get rid of "0b"
+	inc	hl
+	call	strlen
+	or	a
+	jr	z, .error	; empty, error
+	cp	9
+	jr	nc, .error	; >= 9, too long
+	; We have a string of 8 or less chars. What we'll do is that for each
+	; char, we rotate left and set the LSB according to whether we have '0'
+	; or '1'. Error out on anything else. C is our stored result.
+	ld	b, a		; we loop for "strlen" times
+	ld	c, 0		; our stored result
+.loop:
+	rlc	c
+	ld	a, (hl)
+	inc	hl
+	cp	'0'
+	jr	z, .nobit	; no bit to set
+	cp	'1'
+	jr	nz, .error	; not 0 or 1
+	; We have a bit to set
+	inc	c
+.nobit:
+	djnz	.loop
+	ld	e, c
+	cp	a		; ensure Z
+	jr	.end
+.error:
+	call	unsetZ
+.end:
+	push	de \ pop ix
+	pop	de
+	pop	hl
+	pop	bc
+	ret
+
+; Sets Z if (HL) has a '0b' prefix.
+hasBinPrefix:
+	ld	a, (hl)
+	cp	'0'
+	ret	nz
+	push	hl
+	inc	hl
+	ld	a, (hl)
+	cp	'b'
+	pop	hl
+	ret
+
+; Parse string at (HL) and, if it is a char literal, sets Z and return
+; corresponding value in IX. High IX byte is always clear.
+;
+; A valid char literal starts with ', ends with ' and has one character in the
+; middle. No escape sequence are accepted, but ''' will return the apostrophe
+; character.
+parseCharLiteral:
+	ld	a, 0x27		; apostrophe (') char
+	cp	(hl)
+	ret	nz
+
+	push	hl
+	push	de
+	inc	hl
+	inc	hl
+	cp	(hl)
+	jr	nz, .end	; not ending with an apostrophe
+	inc	hl
+	ld	a, (hl)
+	or	a		; cp 0
+	jr	nz, .end	; string has to end there
+	; Valid char, good
+	ld	d, a		; A is zero, take advantage of that
+	dec	hl
+	dec	hl
+	ld	a, (hl)
+	ld	e, a
+	cp	a		; ensure Z
+.end:
+	push	de \ pop ix
+	pop	de
+	pop	hl
+	ret
+
+; Parses the string at (HL) and returns the 16-bit value in IX. The string
+; can be a decimal literal (1234), a hexadecimal literal (0x1234) or a char
+; literal ('X').
+;
+; As soon as the number doesn't fit 16-bit any more, parsing stops and the
+; number is invalid. If the number is valid, Z is set, otherwise, unset.
+parseLiteral:
+	call	parseCharLiteral
+	ret	z
+	call	parseHexadecimal
+	ret	z
+	call	parseBinaryLiteral
+	ret	z
+	jp	parseDecimal
+
 ; Parse string in (HL) and return its numerical value whether its a number
 ; literal or a symbol. Returns value in IX.
 ; Sets Z if number or symbol is valid, unset otherwise.

apps/zasm/util.asm

@@ -30,6 +30,28 @@ toggleZ:
 	cp	a
 	ret
 
+; Returns length of string at (HL) in A.
+; Doesn't include null termination.
+strlen:
+	push	bc
+	push	hl
+	ld	bc, 0
+	ld	a, 0	; look for null char
+.loop:
+	cpi
+	jp	z, .found
+	jr	.loop
+.found:
+	; How many char do we have? the (NEG BC)-1, which started at 0 and
+	; decreased at each CPI call. In this routine, we stay in the 8-bit
+	; realm, so C only.
+	ld	a, c
+	neg
+	dec	a
+	pop	hl
+	pop	bc
+	ret
+
 ; Sets Z if string at (HL) is one character long
 strIs1L:
 	xor	a
@@ -76,6 +98,32 @@ strncmpI:
 	; early, set otherwise)
 	ret
 
+; Compares strings pointed to by HL and DE until one of them hits its null char.
+; If equal, Z is set. If not equal, Z is reset.
+strcmp:
+	push	hl
+	push	de
+
+.loop:
+	ld	a, (de)
+	cp	(hl)
+	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
+	jr	.loop
+
+.end:
+	pop	de
+	pop	hl
+	; 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
+
 ; If string at (HL) starts with ( and ends with ), "enter" into the parens
 ; (advance HL and put a null char at the end of the string) and set Z.
 ; Otherwise, do nothing and reset Z.
@@ -171,3 +219,19 @@ findStringInList:
 	ret
 
 
+; DE * BC -> DE (high) and HL (low)
+multDEBC:
+	ld	hl, 0
+	ld	a, 0x10
+.loop:
+	add	hl, hl
+	rl	e
+	rl	d
+	jr	nc, .noinc
+	add	hl, bc
+	jr	nc, .noinc
+	inc	de
+.noinc:
+	dec a
+	jr	nz, .loop
+	ret

tools/tests/unit/test_expr.asm

@@ -18,8 +18,7 @@ jp	test
 .inc "zasm/parse.asm"
 .equ	SYM_RAMSTART	DIREC_LASTVAL+2
 .inc "zasm/symbol.asm"
-.equ	EXPR_PARSE	parseNumberOrSymbol
+.inc "zasm/expr.asm"
-.inc "lib/expr.asm"
 
 ; Pretend that we aren't in first pass
 zasmIsFirstPass:

tools/tests/unit/test_lib_fmt.asm

@@ -1,70 +0,0 @@
-jp	test
-
-.inc "core.asm"
-.inc "lib/util.asm"
-.inc "lib/ari.asm"
-.inc "lib/fmt.asm"
-
-testNum:	.db 1
-
-test:
-	ld	sp, 0xffff
-
-	call	testFmtDecimal
-
-	; success
-	xor	a
-	halt
-
-testFmtDecimal:
-	ld	ix, .t1
-	call	.test
-	ld	ix, .t2
-	call	.test
-	ld	ix, .t3
-	call	.test
-	ld	ix, .t4
-	call	.test
-	ld	ix, .t5
-	call	.test
-	ret
-.test:
-	ld	e, (ix)
-	ld	d, (ix+1)
-	ld	hl, sandbox
-	call	fmtDecimal
-	ld	hl, sandbox
-	push	ix \ pop de
-	inc	de \ inc de
-	call	strcmp
-	jp	nz, fail
-	jp	nexttest
-.t1:
-	.dw 1234
-	.db "1234", 0
-.t2:
-	.dw 9999
-	.db "9999", 0
-.t3:
-	.dw 0
-	.db "0", 0
-.t4:
-	.dw 0x7fff
-	.db "32767", 0
-.t5:
-	.dw 0xffff
-	.db "65535", 0
-
-nexttest:
-	ld	a, (testNum)
-	inc	a
-	ld	(testNum), a
-	ret
-
-fail:
-	ld	a, (testNum)
-	halt
-
-; used as RAM
-sandbox:
-

tools/tests/unit/test_util_z.asm

@@ -2,7 +2,6 @@ jp	test
 
 .inc "core.asm"
 .inc "str.asm"
-.inc "lib/util.asm"
 .inc "zasm/util.asm"
 
 testNum:	.db 1

tools/tests/unit/test_z_instr.asm

@@ -7,8 +7,8 @@ jp	runTests
 .inc "lib/util.asm"
 .inc "zasm/util.asm"
 .inc "lib/parse.asm"
-.equ	EXPR_PARSE	parseLiteral
+.inc "zasm/parse.asm"
-.inc "lib/expr.asm"
+.inc "zasm/expr.asm"
 .equ	INS_RAMSTART	RAMSTART
 .inc "zasm/instr.asm"