Merge pull request #1036 from boriel-basic/refact/use_include_arch_for_zxnext_arch

Refact/use include arch for zxnext arch

Author: boriel

src/lib/arch/zxnext/runtime/arith/_mul32.asm

@@ -1,70 +1,8 @@
-
-; Ripped from: http://www.andreadrian.de/oldcpu/z80_number_cruncher.html#moztocid784223
-; Used with permission.
-; Multiplies 32x32 bit integer (DEHL x D'E'H'L')
-; 64bit result is returned in H'L'H L B'C'A C
-
-
-    push namespace core
-
-__MUL32_64START:
-    push hl
-    exx
-    ld b, h
-    ld c, l		; BC = Low Part (A)
-    pop hl		; HL = Load Part (B)
-    ex de, hl	; DE = Low Part (B), HL = HightPart(A) (must be in B'C')
-    push hl
-
-    exx
-    pop bc		; B'C' = HightPart(A)
-    exx			; A = B'C'BC , B = D'E'DE
-
-    ; multiply routine 32 * 32bit = 64bit
-    ; h'l'hlb'c'ac = b'c'bc * d'e'de
-    ; needs register a, changes flags
-    ;
-    ; this routine was with tiny differences in the
-    ; sinclair zx81 rom for the mantissa multiply
-
-__LMUL:
-    xor     a               ; reset carry flag
-    ld      h, a            ; result bits 32..47 = 0
-    ld      l, a
-    exx
-    ld      h, a            ; result bits 48..63 = 0
-    ld      l, a
-    exx
-    ld      a,b             ; mpr is b'c'ac
-    ld      b,33            ; initialize loop counter
-    jp      __LMULSTART
-
-__LMULLOOP:
-    jr      nc,__LMULNOADD  ; JP is 2 cycles faster than JR. Since it's inside a LOOP
-    ; it can save up to 33 * 2 = 66 cycles
-    ; But JR if 3 cycles faster if JUMP not taken!
-    add     hl,de           ; result += mpd
-    exx
-    adc     hl,de
-    exx
-
-__LMULNOADD:
-    exx
-    rr      h               ; right shift upper
-    rr      l               ; 32bit of result
-    exx
-    rr      h
-    rr      l
-
-__LMULSTART:
-    exx
-    rr      b               ; right shift mpr/
-    rr      c               ; lower 32bit of result
-    exx
-    rra                     ; equivalent to rr a
-    rr      c
-    djnz    __LMULLOOP
-
-    ret						; result in h'l'hlb'c'ac
-
-    pop namespace
+' ----------------------------------------------------------------
+' This file is released under the MIT License
+'
+' Copyleft (k) 2008
+' by Jose Rodriguez-Rosa (a.k.a. Boriel) <https://www.boriel.com>
+' ----------------------------------------------------------------
+
+#include once [arch:zx48k] <arith/_mul32.asm>

src/lib/arch/zxnext/runtime/arith/addf.asm

@@ -1,24 +1,8 @@
-#include once <stackf.asm>
-
-; -------------------------------------------------------------
-; Floating point library using the FP ROM Calculator (ZX 48K)
-; All of them uses A EDCB registers as 1st paramter.
-; For binary operators, the 2n operator must be pushed into the
-; stack, in the order AF DE BC (F not used).
-;
-; Uses CALLEE convention
-; -------------------------------------------------------------
-
-    push namespace core
-
-__ADDF:	; Addition
-    call __FPSTACK_PUSH2
-
-    ; ------------- ROM ADD
-    rst 28h
-    defb 0fh	; ADD
-    defb 38h;   ; END CALC
-
-    jp __FPSTACK_POP
-
-    pop namespace
+' ----------------------------------------------------------------
+' This file is released under the MIT License
+'
+' Copyleft (k) 2008
+' by Jose Rodriguez-Rosa (a.k.a. Boriel) <https://www.boriel.com>
+' ----------------------------------------------------------------
+
+#include once [arch:zx48k] <arith/addf.asm>

src/lib/arch/zxnext/runtime/arith/div16.asm

@@ -1,104 +1,8 @@
-; 16 bit division and modulo functions
-; for both signed and unsigned values
-
-#include once <neg16.asm>
-
-    push namespace core
-
-__DIVU16:    ; 16 bit unsigned division
-    ; HL = Dividend, Stack Top = Divisor
-
-    ;   -- OBSOLETE ; Now uses FASTCALL convention
-    ;   ex de, hl
-    ;	pop hl      ; Return address
-    ;	ex (sp), hl ; CALLEE Convention
-
-__DIVU16_FAST:
-    ld a, h
-    ld c, l
-    ld hl, 0
-    ld b, 16
-
-__DIV16LOOP:
-    sll c
-    rla
-    adc hl,hl
-    sbc hl,de
-    jr  nc, __DIV16NOADD
-    add hl,de
-    dec c
-
-__DIV16NOADD:
-    djnz __DIV16LOOP
-
-    ex de, hl
-    ld h, a
-    ld l, c
-
-    ret     ; HL = quotient, DE = Mudulus
-
-
-
-__MODU16:    ; 16 bit modulus
-    ; HL = Dividend, Stack Top = Divisor
-
-    ;ex de, hl
-    ;pop hl
-    ;ex (sp), hl ; CALLEE Convention
-
-    call __DIVU16_FAST
-    ex de, hl	; hl = reminder (modulus)
-    ; de = quotient
-
-    ret
-
-
-__DIVI16:	; 16 bit signed division
-    ;	--- The following is OBSOLETE ---
-    ;	ex de, hl
-    ;	pop hl
-    ;	ex (sp), hl 	; CALLEE Convention
-
-__DIVI16_FAST:
-    ld a, d
-    xor h
-    ex af, af'		; BIT 7 of a contains result
-
-    bit 7, d		; DE is negative?
-    jr z, __DIVI16A
-
-    ld a, e			; DE = -DE
-    cpl
-    ld e, a
-    ld a, d
-    cpl
-    ld d, a
-    inc de
-
-__DIVI16A:
-    bit 7, h		; HL is negative?
-    call nz, __NEGHL
-
-__DIVI16B:
-    call __DIVU16_FAST
-    ex af, af'
-
-    or a
-    ret p	; return if positive
-    jp __NEGHL
-
-
-__MODI16:    ; 16 bit modulus
-    ; HL = Dividend, Stack Top = Divisor
-
-    ;ex de, hl
-    ;pop hl
-    ;ex (sp), hl ; CALLEE Convention
-
-    call __DIVI16_FAST
-    ex de, hl	; hl = reminder (modulus)
-    ; de = quotient
-
-    ret
-
-    pop namespace
+' ----------------------------------------------------------------
+' This file is released under the MIT License
+'
+' Copyleft (k) 2008
+' by Jose Rodriguez-Rosa (a.k.a. Boriel) <https://www.boriel.com>
+' ----------------------------------------------------------------
+
+#include once [arch:zx48k] <arith/div16.asm>

src/lib/arch/zxnext/runtime/arith/div32.asm

@@ -1,144 +1,8 @@
-#include once <neg32.asm>
-
-    ; ---------------------------------------------------------
-    push namespace core
-
-__DIVU32:    ; 32 bit unsigned division
-    ; DEHL = Dividend, Stack Top = Divisor
-    ; OPERANDS P = Dividend, Q = Divisor => OPERATION => P / Q
-    ;
-    ; Changes A, BC DE HL B'C' D'E' H'L'
-    ; ---------------------------------------------------------
-    exx
-    pop hl   ; return address
-    pop de   ; low part
-    ex (sp), hl ; CALLEE Convention ; H'L'D'E' => Dividend
-
-__DIVU32START: ; Performs D'E'H'L' / HLDE
-    ; Now switch to DIVIDEND = B'C'BC / DIVISOR = D'E'DE (A / B)
-    push de ; push Lowpart(Q)
-    ex de, hl	; DE = HL
-    ld hl, 0
-    exx
-    ld b, h
-    ld c, l
-    pop hl
-    push de
-    ex de, hl
-    ld hl, 0        ; H'L'HL = 0
-    exx
-    pop bc          ; Pop HightPart(B) => B = B'C'BC
-    exx
-
-    ld a, 32 ; Loop count
-
-__DIV32LOOP:
-    sll c  ; B'C'BC << 1 ; Output most left bit to carry
-    rl  b
-    exx
-    rl c
-    rl b
-    exx
-
-    adc hl, hl
-    exx
-    adc hl, hl
-    exx
-
-    sbc hl,de
-    exx
-    sbc hl,de
-    exx
-    jp nc, __DIV32NOADD	; use JP inside a loop for being faster
-
-    add hl, de
-    exx
-    adc hl, de
-    exx
-    dec bc
-
-__DIV32NOADD:
-    dec a
-    jp nz, __DIV32LOOP	; use JP inside a loop for being faster
-    ; At this point, quotient is stored in B'C'BC and the reminder in H'L'HL
-
-    push hl
-    exx
-    pop de
-    ex de, hl ; D'E'H'L' = 32 bits modulus
-    push bc
-    exx
-    pop de    ; DE = B'C'
-    ld h, b
-    ld l, c   ; DEHL = quotient D'E'H'L' = Modulus
-
-    ret     ; DEHL = quotient, D'E'H'L' = Modulus
-
-
-
-__MODU32:    ; 32 bit modulus for 32bit unsigned division
-    ; DEHL = Dividend, Stack Top = Divisor (DE, HL)
-
-    exx
-    pop hl   ; return address
-    pop de   ; low part
-    ex (sp), hl ; CALLEE Convention ; H'L'D'E' => Dividend
-
-    call __DIVU32START	; At return, modulus is at D'E'H'L'
-
-__MODU32START:
-
-    exx
-    push de
-    push hl
-
-    exx
-    pop hl
-    pop de
-
-    ret
-
-
-__DIVI32:    ; 32 bit signed division
-    ; DEHL = Dividend, Stack Top = Divisor
-    ; A = Dividend, B = Divisor => A / B
-    exx
-    pop hl   ; return address
-    pop de   ; low part
-    ex (sp), hl ; CALLEE Convention ; H'L'D'E' => Dividend
-
-__DIVI32START:
-    exx
-    ld a, d	 ; Save sign
-    ex af, af'
-    bit 7, d ; Negative?
-    call nz, __NEG32 ; Negates DEHL
-
-    exx		; Now works with H'L'D'E'
-    ex af, af'
-    xor h
-    ex af, af'  ; Stores sign of the result for later
-
-    bit 7, h ; Negative?
-    ex de, hl ; HLDE = DEHL
-    call nz, __NEG32
-    ex de, hl
-
-    call __DIVU32START
-    ex af, af' ; Recovers sign
-    and 128	   ; positive?
-    ret z
-
-    jp __NEG32 ; Negates DEHL and returns from there
-
-
-__MODI32:	; 32bits signed division modulus
-    exx
-    pop hl   ; return address
-    pop de   ; low part
-    ex (sp), hl ; CALLEE Convention ; H'L'D'E' => Dividend
-
-    call __DIVI32START
-    jp __MODU32START
-
-    pop namespace
+' ----------------------------------------------------------------
+' This file is released under the MIT License
+'
+' Copyleft (k) 2008
+' by Jose Rodriguez-Rosa (a.k.a. Boriel) <https://www.boriel.com>
+' ----------------------------------------------------------------
+
+#include once [arch:zx48k] <arith/div32.asm>