Fixed the result of the % operator for longs

git-svn-id: svn://svn.cc65.org/cc65/trunk@1409 b7a2c559-68d2-44c3-8de9-860c34a00d81

diff --git a/libsrc/runtime/ldiv.s b/libsrc/runtime/ldiv.s
index f08354d24347d368d8accf23a38ddd7eacfbb3e4..cbbf78aa7a1714c243ecd125ec6b960c17f5c711 100644 (file)
--- a/libsrc/runtime/ldiv.s
+++ b/libsrc/runtime/ldiv.s
@@ -8,13 +8,28 @@
 ; values if $80000000, in which case the negate will fail.
 
                .export         tosdiveax
-       .import         poplsargs, udiv32, adjlsres
-       .importzp       ptr1
+       .import         poplsargs, udiv32, negeax
+       .importzp       ptr1, tmp1, tmp2
 
 tosdiveax:
                jsr     poplsargs       ; Get arguments from stack, adjust sign
-               jsr     udiv32          ; Do the division
-       lda     ptr1            ; Result is in (ptr1:sreg)
-       ldx     ptr1+1
-       jmp     adjlsres        ; Adjust the sign of the result if needed
+               jsr     udiv32          ; Do the division, result is in (ptr1:sreg)
+        ldx     ptr1+1          ; Load byte 1 of result
+
+; Adjust the sign of the result
+
+        lda     tmp1            ; Get sign of left operand
+        eor     tmp2            ; Calculate sign of result
+        bpl     Pos             ; Jump if result positive
+
+; Result is negative
+
+       lda     ptr1            ; Load byte 0
+       jmp     negeax          ; Negate value
+
+; Result is positive
+
+Pos:    lda     ptr1
+        rts
+
 

diff --git a/libsrc/runtime/lmod.s b/libsrc/runtime/lmod.s
index 8c62d27c05b93684ba2218938ef5a6e8b32ffa95..b3376b60fea5687e90a42752a04a341140989dd4 100644 (file)
--- a/libsrc/runtime/lmod.s
+++ b/libsrc/runtime/lmod.s
@@ -8,19 +8,33 @@
 ; values if $8000, in which case the negate will fail.
 
                .export         tosmodeax
-       .import         poplsargs, udiv32, adjlsres
-       .importzp       sreg, ptr1, ptr2, tmp3, tmp4
+       .import         poplsargs, udiv32, negeax
+       .importzp       sreg, ptr1, ptr2, tmp1, tmp3, tmp4
 
 tosmodeax:
                jsr     poplsargs       ; Get arguments from stack, adjust sign
-       jsr     udiv32          ; Do the division
-       lda     ptr1            ; Remainder is in (ptr2:tmp3:tmp4)
-       lda     ptr2
-       ldx     ptr2+1
-       ldy     tmp3
-       sty     sreg
-       ldy     tmp4
-       sty     sreg+1
-       jmp     adjlsres        ; Adjust the sign of the result if needed
+       jsr     udiv32          ; Do the division, remainder is in (ptr2:tmp3:tmp4)
 
+; Load the result with the exception of the low byte
+
+       ldx     ptr2+1
+       ldy     tmp3
+       sty     sreg
+       ldy     tmp4
+       sty     sreg+1
+
+; Check the sign of the result. It is the sign of the left operand.
+
+        lda     tmp1            ; Check sign of left operand
+        bpl     Pos             ; Jump if result is positive
+
+; Result is negative
+
+        lda     ptr2            ; Load byte 0 of result
+        jmp     negeax          ; Negate result
+
+; Result is positive
+
+Pos:    lda     ptr2            ; Load byte 0 of result
+        rts                     ; Done
 

diff --git a/libsrc/runtime/lshelp.s b/libsrc/runtime/lshelp.s
index 9d8f366d2f716d7f5ab82de6851953e46f4b3a07..a17f12fd163916d72a57d93babcdf6fc60581342 100644 (file)
--- a/libsrc/runtime/lshelp.s
+++ b/libsrc/runtime/lshelp.s
@@ -7,23 +7,18 @@
 ; When negating values, we will ignore the possibility here, that one of the
 ; values if $80000000, in which case the negate will fail.
 
-               .export         poplsargs, adjlsres
-       .import         getlop, negeax
-       .importzp       sreg, tmp1, ptr1, ptr3, ptr4
+               .export         poplsargs
+       .import         getlop
+       .importzp       sreg, tmp1, tmp2, ptr1, ptr3, ptr4
 
 poplsargs:
        jsr     getlop          ; Get the operands
 
-; Calculate the sign of the result, that is sign(op1) * sign(op2) and
-; remember it.
+; Remember the signs of the operands (that is, the high bytes) in tmp1 and
+; tmp2. Make both operands positive.
 
-       lda     sreg+1
-       eor     ptr4+1
-       sta     tmp1            ; Save it across call
-
-; Make both operands positive
-
-       lda     sreg+1          ; Is the operand negative?
+       lda     sreg+1          ; Is the left operand negative?
+        sta     tmp1            ; Remember the sign for later
        bpl     L1              ; Jump if not
 
        clc                     ; Make it positive
@@ -44,7 +39,8 @@ poplsargs:
        adc     #$00
        sta     sreg+1
 
-L1:    lda     ptr4+1          ; Is the operand nagative?
+L1:    lda     ptr4+1          ; Is the right operand nagative?
+        sta     tmp2            ; Remember the sign for later
        bpl     L2              ; Jump if not
 
        clc                     ; Make it positive
@@ -67,10 +63,3 @@ L1:  lda     ptr4+1          ; Is the operand nagative?
 
 L2:    rts
 
-; Adjust the result of a mod/div/mul operation
-
-adjlsres:
-       ldy     tmp1            ; Check if we must adjust the sign
-       bpl     L2
-       jmp     negeax          ; Netage value
-