Update bootstrap binaries

It's an awkward register to use and avoiding its use allows us to strip the
resulting binary significantly. parseEXPR keeps the same signature though.

apps/README.md

@@ -89,8 +89,16 @@ this way, it's going to mess with the parser.
 
 ### Expressions
 
-An expression is a bunch of literals or symbols assembled by operators. For
-now, only `+`, `-` and `*` operators are supported. No parenthesis yet.
+An expression is a bunch of literals or symbols assembled by operators.
+Supported operators are `+`, `-`, `*`, `/`, `%` (modulo), `&` (bitwise and),
+`|` (bitwise or), `^` (bitwise xor), `{` (shift left), `}` (shift right).
+Bitwise operator always operate on the whole 16-bits.
+
+Shift operators break from the `<<` and `>>` tradition because the complexity
+if two-sized operator is significant and deemed not worth it. The shift
+operator shift the left operand X times, X being the right operand.
+
+There is no parenthesis support yet.
 
 Symbols have a different meaning depending on the application. In zasm, it's
 labels and constants. In basic, it's variables.

apps/lib/expr.asm

@@ -1,6 +1,7 @@
 ; *** Requirements ***
 ; findchar
 ; multDEBC
+; callIXI
 ;
 ; *** Defines ***
 ;
@@ -14,6 +15,9 @@
 ; **This routine mutates (HL).**
 ; We expect (HL) to be disposable: we mutate it to avoid having to make a copy.
 ; Sets Z on success, unset on error.
+; TODO: the IX output register is a bit awkward. Nearly everywhere, I need
+;       to push \ pop that thing. See if we could return the result in DE
+;       instead.
 parseExpr:
 	push	de
 	push	hl
@@ -38,15 +42,16 @@ _parseExpr:
 	; Operator found, string splitted. Left in (HL), right in (DE)
 	call	_resolveLeftAndRight
 	; Whether _resolveLeftAndRight was a success, we pop our lvl 1 stack
-	; out, which contains our operator row. We pop it in HL because we
-	; don't need our string anymore. L-R numbers are parsed, and in DE and
-	; IX.
-	pop	hl		; <-- lvl 1
+	; out, which contains our operator row. We pop it in IX.
+	; L-R numbers are parsed in HL (left) and DE (right).
+	pop	ix		; <-- lvl 1
 	ret	nz
 	; Resolving left and right succeeded, proceed!
-	inc	hl		; point to routine pointer
-	call	intoHL
-	jp	(hl)
+	inc	ix		; point to routine pointer
+	call	callIXI
+	push	de \ pop ix
+	cp	a		; ensure Z
+	ret
 
 ; 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
@@ -90,7 +95,7 @@ _findAndSplit:
 .find:
 
 ; parse expression on the left (HL) and the right (DE) and put the results in
-; DE (left) and IX (right)
+; HL (left) and DE (right)
 _resolveLeftAndRight:
 	call	parseExpr
 	ret	nz		; return immediately if error
@@ -98,12 +103,14 @@ _resolveLeftAndRight:
 	; 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
+	push	ix	; --> lvl 1
+	call	parseExpr
+	pop	hl	; <-- lvl 1. left
+	push	ix \ pop de	; right
+	ret		; Z is parseExpr's result
 
 ; Routines in here all have the same signature: they take two numbers, DE (left)
-; and IX (right), apply the operator and put the resulting number in IX.
+; and IX (right), apply the operator and put the resulting number in DE.
 ; The table has 3 bytes per row: 1 byte for operator and 2 bytes for routine
 ; pointer.
 exprTbl:
@@ -113,27 +120,104 @@ exprTbl:
 	.dw	.minus
 	.db	'*'
 	.dw	.mult
+	.db	'/'
+	.dw	.div
+	.db	'%'
+	.dw	.mod
+	.db	'&'
+	.dw	.and
+	.db	0x7c		; '|'
+	.dw	.or
+	.db	'^'
+	.dw	.xor
+	.db	'}'
+	.dw	.rshift
+	.db	'{'
+	.dw	.lshift
 	.db	0		; end of table
 
 .plus:
-	add	ix, de
-	cp	a		; ensure Z
+	add	hl, de
+	ex	de, hl
 	ret
 
 .minus:
-	push	ix
-	pop	hl
-	ex	de, hl
-	scf \ ccf
+	or	a	; clear carry
 	sbc	hl, de
-	push	hl
-	pop	ix
-	cp	a		; ensure Z
+	ex	de, hl
 	ret
 
 .mult:
-	push	ix \ pop bc
-	call	multDEBC
-	push	hl \ pop ix
-	cp	a		; ensure Z
+	ld	b, h
+	ld	c, l
+	call	multDEBC	; --> HL
+	ex	de, hl
+	ret
+
+.div:
+	; divide takes HL/DE
+	push	bc
+	call	divide
+	ld	e, c
+	ld	d, b
+	pop	bc
+	ret
+
+.mod:
+	call	.div
+	ex	de, hl
+	ret
+
+.and:
+	ld	a, h
+	and	d
+	ld	d, a
+	ld	a, l
+	and	e
+	ld	e, a
+	ret
+.or:
+	ld	a, h
+	or	d
+	ld	d, a
+	ld	a, l
+	or	e
+	ld	e, a
+	ret
+
+.xor:
+	ld	a, h
+	xor	d
+	ld	d, a
+	ld	a, l
+	xor	e
+	ld	e, a
+	ret
+
+.rshift:
+	ld	a, e
+	and	0xf
+	ret	z
+	push	bc
+	ld	b, a
+.rshiftLoop:
+	srl	h
+	rr	l
+	djnz	.rshiftLoop
+	ex	de, hl
+	pop	bc
+	ret
+
+.lshift:
+	ld	a, e
+	and	0xf
+	ret	z
+	push	bc
+	ld	b, a
+.lshiftLoop:
+	sla	l
+	rl	h
+	djnz	.lshiftLoop
+	ex	de, hl
+	pop	bc
 	ret

tools/tests/unit/test_expr.asm

@@ -42,9 +42,9 @@ sFOO:		.db "FOO", 0
 sBAR:		.db "BAR", 0
 
 test:
-	ld	hl, 0xffff
-	ld	sp, hl
+	ld	sp, 0xffff
 
+	; Old-style tests, not touching them now.
 	ld	hl, s1
 	call	parseExpr
 	jp	nz, fail
@@ -128,10 +128,65 @@ test:
 	jp	nz, fail
 	call	nexttest
 
+	; New-style tests
+	call	testParseExpr
 	; success
 	xor	a
 	halt
 
+testParseExpr:
+	ld	iy, .t1
+	call	.testEQ
+	ld	iy, .t2
+	call	.testEQ
+	ld	iy, .t3
+	call	.testEQ
+	ld	iy, .t4
+	call	.testEQ
+	ld	iy, .t5
+	call	.testEQ
+	ld	iy, .t6
+	call	.testEQ
+	ld	iy, .t7
+	call	.testEQ
+	ret
+
+.testEQ:
+	push	iy \ pop hl
+	inc	hl \ inc hl
+	call	parseExpr
+	jp	nz, fail
+	push	ix \ pop de
+	ld	a, e
+	cp	(iy)
+	jp	nz, fail
+	ld	a, d
+	cp	(iy+1)
+	jp	nz, fail
+	jp	nexttest
+
+.t1:
+	.dw	7
+	.db	"42/6", 0
+.t2:
+	.dw	1
+	.db	"7%3", 0
+.t3:
+	.dw	0x0907
+	.db	"0x99f7&0x0f0f", 0
+.t4:
+	.dw	0x9fff
+	.db	"0x99f7|0x0f0f", 0
+.t5:
+	.dw	0x96f8
+	.db	"0x99f7^0x0f0f", 0
+.t6:
+	.dw	0x133e
+	.db	"0x99f7}3", 0
+.t7:
+	.dw	0xcfb8
+	.db	"0x99f7{3", 0
+
 nexttest:
 	ld	a, (testNum)
 	inc	a