From 978c44eca74971fc8e66fc32940287158f6c0e25 Mon Sep 17 00:00:00 2001
From: Emmanuel Marty <emmanuel@fgl.com>
Date: Sun, 21 Nov 2021 18:03:03 +0100
Subject: [PATCH] Revert

---
 asm/6502/decompress_faster_v1.asm | 224 +++++++++++++++---------------
 asm/6502/decompress_faster_v2.asm |  68 ++++-----
 2 files changed, 148 insertions(+), 144 deletions(-)

diff --git a/asm/6502/decompress_faster_v1.asm b/asm/6502/decompress_faster_v1.asm
index 76d1b59..2e29c5d 100644
--- a/asm/6502/decompress_faster_v1.asm
+++ b/asm/6502/decompress_faster_v1.asm
@@ -7,7 +7,7 @@
 ;
 ; This code is written for the ACME assembler.
 ;
-; The code is 169 bytes for the small version, and 193 bytes for the normal.
+; The code is 167 bytes for the small version, and 192 bytes for the normal.
 ;
 ; Copyright John Brandwood 2021.
 ;
@@ -37,16 +37,15 @@ LZSA_SMALL_SIZE =       0
 ; ***************************************************************************
 ; ***************************************************************************
 ;
-; Data usage is last 7 bytes of zero-page.
+; Data usage is last 8 bytes of zero-page.
 ;
 
+lzsa_length     =       $F8                     ; 1 byte.
 lzsa_cmdbuf     =       $F9                     ; 1 byte.
 lzsa_winptr     =       $FA                     ; 1 word.
 lzsa_srcptr     =       $FC                     ; 1 word.
 lzsa_dstptr     =       $FE                     ; 1 word.
 
-lzsa_offset     =       lzsa_winptr
-
 LZSA_SRC_LO     =       $FC
 LZSA_SRC_HI     =       $FD
 LZSA_DST_LO     =       $FE
@@ -61,6 +60,7 @@ LZSA_DST_HI     =       $FF
 ;
 ; Args: lzsa_srcptr = ptr to compessed data
 ; Args: lzsa_dstptr = ptr to output buffer
+; Uses: lots!
 ;
 
 DECOMPRESS_LZSA1_FAST:
@@ -95,14 +95,19 @@ lzsa1_unpack:   ldy     #0                      ; Initialize source index.
                 lsr
                 lsr
                 cmp     #$07                    ; Extended length?
-                bcc     .cp_got_len
+                bcc     .inc_cp_len
 
-                jsr     .get_length             ; X=0, CS from CMP, returns CC.
-                stx     .cp_npages + 1          ; Hi-byte of length.
+                jsr     .get_length             ; CS from CMP, X=0.
 
-.cp_got_len:    tax                             ; Lo-byte of length.
+                ora     #0                      ; Check the lo-byte of length
+                beq     .put_cp_len             ; without effecting CC.
 
-.cp_byte:       lda     (lzsa_srcptr),y         ; CC throughout the execution of
+.inc_cp_len:    inx                             ; Increment # of pages to copy.
+
+.put_cp_len:    stx     <lzsa_length
+                tax
+
+.cp_page:       lda     (lzsa_srcptr),y         ; CC throughout the execution of
                 sta     (lzsa_dstptr),y         ; of this .cp_page loop.
                 inc     <lzsa_srcptr + 0
                 bne     .cp_skip1
@@ -111,24 +116,28 @@ lzsa1_unpack:   ldy     #0                      ; Initialize source index.
                 bne     .cp_skip2
                 inc     <lzsa_dstptr + 1
 .cp_skip2:      dex
-                bne     .cp_byte
-.cp_npages:     lda     #0                      ; Any full pages left to copy?
-                beq     .lz_offset
-
-                dec     .cp_npages + 1          ; Unlikely, so can be slow.
-                bcc     .cp_byte                ; Always true!
-
-                !if     LZSA_SMALL_SIZE {
+                bne     .cp_page
+                dec     <lzsa_length            ; Any full pages left to copy?
+                bne     .cp_page
 
                 ;
                 ; Copy bytes from decompressed window.
                 ;
-                ; Shorter but slower version.
-                ;
                 ; N.B. X=0 is expected and guaranteed when we get here.
                 ;
 
-.lz_offset:     jsr     .get_byte               ; Get offset-lo.
+.lz_offset:     !if     LZSA_SMALL_SIZE {
+
+                jsr     .get_byte
+
+                } else {
+
+                lda     (lzsa_srcptr),y
+                inc     <lzsa_srcptr + 0
+                bne     .offset_lo
+                inc     <lzsa_srcptr + 1
+
+                }
 
 .offset_lo:     adc     <lzsa_dstptr + 0        ; Always CC from .cp_page loop.
                 sta     <lzsa_winptr + 0
@@ -137,105 +146,96 @@ lzsa1_unpack:   ldy     #0                      ; Initialize source index.
                 bit     <lzsa_cmdbuf
                 bpl     .offset_hi
 
-                jsr     .get_byte               ; Get offset-hi.
-
-.offset_hi:     adc     <lzsa_dstptr + 1        ; lzsa_winptr < lzsa_dstptr, so
-                sta     <lzsa_winptr + 1        ; always leaves CS.
-
-.lz_length:     lda     <lzsa_cmdbuf            ; X=0 from previous loop.
-                and     #$0F
-                adc     #$03 - 1                ; CS from previous ADC.
-                cmp     #$12                    ; Extended length?
-                bcc     .lz_got_len
-
-                jsr     .get_length             ; CS from CMP, X=0, returns CC.
-                stx     .lz_npages + 1          ; Hi-byte of length.
-
-.lz_got_len:    tax                             ; Lo-byte of length.
-
-.lz_byte:       lda     (lzsa_winptr),y         ; CC throughout the execution of
-                sta     (lzsa_dstptr),y         ; of this .lz_page loop.
-                inc     <lzsa_winptr + 0
-                bne     .lz_skip1
-                inc     <lzsa_winptr + 1
-.lz_skip1:      inc     <lzsa_dstptr + 0
-                bne     .lz_skip2
-                inc     <lzsa_dstptr + 1
-.lz_skip2:      dex
-                bne     .lz_byte
-.lz_npages:     lda     #0                      ; Any full pages left to copy?
-                beq     .cp_length
-
-                dec     .lz_npages + 1          ; Unlikely, so can be slow.
-                bcc     .lz_byte                ; Always true!
+                !if     LZSA_SMALL_SIZE {
+                jsr     .get_byte
 
                 } else {
 
-                ;
-                ; Copy bytes from decompressed window.
-                ;
-                ; Longer but faster.
-                ;
-                ; N.B. X=0 is expected and guaranteed when we get here.
-                ;
-
-.lz_offset:     lda     (lzsa_srcptr),y         ; Get offset-lo.
-                inc     <lzsa_srcptr + 0
-                bne     .offset_lo
-                inc     <lzsa_srcptr + 1
-
-.offset_lo:     sta     <lzsa_offset + 0
-
-                lda     #$FF                    ; Get offset-hi.
-                bit     <lzsa_cmdbuf
-                bpl     .offset_hi
-
                 lda     (lzsa_srcptr),y
                 inc     <lzsa_srcptr + 0
                 bne     .offset_hi
                 inc     <lzsa_srcptr + 1
 
-.offset_hi:     sta     <lzsa_offset + 1
+                }
+
+.offset_hi:     adc     <lzsa_dstptr + 1        ; lzsa_winptr < lzsa_dstptr, so
+                sta     <lzsa_winptr + 1        ; always leaves CS.
+
+                !if     LZSA_SMALL_SIZE {
 
 .lz_length:     lda     <lzsa_cmdbuf            ; X=0 from previous loop.
                 and     #$0F
-                adc     #$03                    ; Always CC from .cp_page loop.
+                adc     #$03 - 1                ; CS from previous ADC.
                 cmp     #$12                    ; Extended length?
-                bcc     .got_lz_len
+                bcc     .inc_lz_len
 
-                jsr     .get_length             ; X=0, CS from CMP, returns CC.
+                jsr     .get_length             ; CS from CMP, X=0, returns CC.
 
-.got_lz_len:    inx                             ; Hi-byte of length+256.
+                ora     #0                      ; Check the lo-byte of length
+                beq     .put_lz_len             ; without effecting CC.
 
-                eor     #$FF                    ; Negate the lo-byte of length
-                tay                             ; and check for zero.
-                iny
-                eor     #$FF
+.inc_lz_len:    inx                             ; Increment # of pages to copy.
 
-.get_lz_dst:    adc     <lzsa_dstptr + 0        ; Calc address of partial page.
-                sta     <lzsa_dstptr + 0        ; Always CC from .cp_page loop.
-                bcs     .get_lz_win
-                dec     <lzsa_dstptr + 1
+.put_lz_len:    stx     <lzsa_length
+                tax
 
-.get_lz_win:    clc                             ; Calc address of match.
-                adc     <lzsa_offset + 0        ; N.B. Offset is negative!
-                sta     <lzsa_winptr + 0
-                lda     <lzsa_dstptr + 1
-                adc     <lzsa_offset + 1
-                sta     <lzsa_winptr + 1
-
-.lz_byte:       lda     (lzsa_winptr),y
-                sta     (lzsa_dstptr),y
-                iny
-                bne     .lz_byte
+.lz_page:       lda     (lzsa_winptr),y         ; CC throughout the execution of
+                sta     (lzsa_dstptr),y         ; of this .lz_page loop.
+                inc     <lzsa_winptr + 0
+                bne     .skip3
+                inc     <lzsa_winptr + 1
+.skip3:         inc     <lzsa_dstptr + 0
+                bne     .skip4
                 inc     <lzsa_dstptr + 1
-                dex                             ; Any full pages left to copy?
-                bne     .lz_more
+.skip4:         dex
+                bne     .lz_page
+                dec     <lzsa_length            ; Any full pages left to copy?
+                bne     .lz_page
 
                 jmp     .cp_length              ; Loop around to the beginning.
 
-.lz_more:       inc     <lzsa_winptr + 1        ; Unlikely, so can be slow.
-                bne     .lz_byte                ; Always true!
+                } else {
+
+.lz_length:     lda     <lzsa_cmdbuf            ; X=0 from previous loop.
+                and     #$0F
+                adc     #$03 - 1                ; CS from previous ADC.
+                cmp     #$12                    ; Extended length?
+                bcc     .got_lz_len
+
+                jsr     .get_length             ; CS from CMP, X=0, returns CC.
+
+.got_lz_len:    tay                             ; Check the lo-byte of length.
+                beq     .lz_page
+
+                inx                             ; Increment # of pages to copy.
+
+.get_lz_win:    adc     <lzsa_winptr + 0        ; Calc address of partial page.
+                sta     <lzsa_winptr + 0        ; Always CC from previous CMP.
+                bcs     .get_lz_dst
+                dec     <lzsa_winptr + 1
+
+.get_lz_dst:    tya                             ; Calc address of partial page.
+                clc
+                adc     <lzsa_dstptr + 0
+                sta     <lzsa_dstptr + 0
+                bcs     .get_lz_idx
+                dec     <lzsa_dstptr + 1
+
+.get_lz_idx:    tya                             ; Negate the lo-byte of length.
+                eor     #$FF
+                tay
+                iny
+
+.lz_page:       lda     (lzsa_winptr),y
+                sta     (lzsa_dstptr),y
+                iny
+                bne     .lz_page
+                inc     <lzsa_winptr + 1
+                inc     <lzsa_dstptr + 1
+                dex                             ; Any full pages left to copy?
+                bne     .lz_page
+
+                jmp     .cp_length              ; Loop around to the beginning.
 
                 }
 
@@ -252,32 +252,30 @@ lzsa1_unpack:   ldy     #0                      ; Initialize source index.
                 inc     <lzsa_srcptr + 1
 
 .skip_inc:      bcc     .got_length             ; No overflow means done.
-                clc                             ; MUST return CC!
-                tax                             ; Overflow to 256 or 257?
-                beq     .extra_word
+                cmp     #$01                    ; Overflow to 256 or 257?
+                bcc     .extra_word
 
-.extra_byte:    jsr     .get_byte               ; So rare, this can be slow!
-                pha
-.check_length:  pla                             ; Length-lo.
-                bne     .got_length             ; Check for zero.
-                dex                             ; Do one less page loop if so.
-.got_length:    rts
+.extra_byte:    clc                             ; MUST return CC!
+                inx
+                bne     .get_byte               ; Always NZ from previous INX.
 
 .extra_word:    jsr     .get_byte               ; So rare, this can be slow!
                 pha
                 jsr     .get_byte               ; So rare, this can be slow!
                 tax
-                bne     .check_length           ; Length-hi == 0 at EOF.
-
-.finished:      pla                             ; Length-lo.
-                pla                             ; Decompression completed, pop
-                pla                             ; return address.
+                beq     .finished               ; Length-hi == 0 at EOF.
+                pla                             ; Length-lo.
                 rts
 
 .get_byte:      lda     (lzsa_srcptr),y         ; Subroutine version for when
                 inc     <lzsa_srcptr + 0        ; inlining isn't advantageous.
                 beq     .next_page
-                rts
+.got_length:    rts
 
 .next_page:     inc     <lzsa_srcptr + 1        ; Inc & test for bank overflow.
                 rts
+
+.finished:      pla                             ; Length-lo.
+                pla                             ; Decompression completed, pop
+                pla                             ; return address.
+                rts
diff --git a/asm/6502/decompress_faster_v2.asm b/asm/6502/decompress_faster_v2.asm
index fe95754..0ec214b 100644
--- a/asm/6502/decompress_faster_v2.asm
+++ b/asm/6502/decompress_faster_v2.asm
@@ -7,7 +7,7 @@
 ;
 ; This code is written for the ACME assembler.
 ;
-; The code is 241 bytes for the small version, and 256 bytes for the normal.
+; The code is 240 bytes for the small version, and 255 bytes for the normal.
 ;
 ; Copyright John Brandwood 2021.
 ;
@@ -66,6 +66,7 @@ LZSA_DST_HI     =       $FF
 ;
 ; Args: lzsa_srcptr = ptr to compessed data
 ; Args: lzsa_dstptr = ptr to output buffer
+; Uses: lots!
 ;
 
 DECOMPRESS_LZSA2_FAST:
@@ -100,28 +101,34 @@ lzsa2_unpack:   ldx     #$00                    ; Hi-byte of length or offset.
                 lsr
                 lsr
                 cmp     #$03                    ; Extended length?
-                bcc     .cp_got_len
+                bcc     .inc_cp_len
 
-                jsr     .get_length             ; X=0 for literals, returns CC.
-                stx     .cp_npages + 1          ; Hi-byte of length.
+                inx
+                jsr     .get_length             ; X=1 for literals, returns CC.
 
-.cp_got_len:    tax                             ; Lo-byte of length.
+                ora     #0                      ; Check the lo-byte of length
+                beq     .put_cp_len             ; without effecting CC.
 
-.cp_byte:       lda     (lzsa_srcptr),y         ; CC throughout the execution of
+.inc_cp_len:    inx                             ; Increment # of pages to copy.
+
+.put_cp_len:    stx     <lzsa_length
+                tax
+
+.cp_page:       lda     (lzsa_srcptr),y         ; CC throughout the execution of
                 sta     (lzsa_dstptr),y         ; of this .cp_page loop.
+
                 inc     <lzsa_srcptr + 0
                 bne     .cp_skip1
                 inc     <lzsa_srcptr + 1
+
 .cp_skip1:      inc     <lzsa_dstptr + 0
                 bne     .cp_skip2
                 inc     <lzsa_dstptr + 1
-.cp_skip2:      dex
-                bne     .cp_byte
-.cp_npages:     lda     #0                      ; Any full pages left to copy?
-                beq     .lz_offset
 
-                dec     .cp_npages + 1          ; Unlikely, so can be slow.
-                bcc     .cp_byte                ; Always true!
+.cp_skip2:      dex
+                bne     .cp_page
+                dec     <lzsa_length            ; Any full pages left to copy?
+                bne     .cp_page
 
                 ;
                 ; Copy bytes from decompressed window.
@@ -186,7 +193,7 @@ lzsa2_unpack:   ldx     #$00                    ; Hi-byte of length or offset.
 .set_offset:    stx     <lzsa_offset + 1        ; Save new offset.
                 sta     <lzsa_offset + 0
 
-.lz_length:     ldx     #1                      ; Hi-byte of length+256.
+.lz_length:     ldx     #$00                    ; Hi-byte of length.
 
                 lda     <lzsa_cmdbuf
                 and     #$07
@@ -195,48 +202,49 @@ lzsa2_unpack:   ldx     #$00                    ; Hi-byte of length or offset.
                 cmp     #$09                    ; Extended length?
                 bcc     .got_lz_len
 
-                jsr     .get_length             ; X=1 for match, returns CC.
-                inx                             ; Hi-byte of length+256.
+                jsr     .get_length             ; X=0 for match, returns CC.
 
 .got_lz_len:    eor     #$FF                    ; Negate the lo-byte of length
                 tay                             ; and check for zero.
                 iny
+                beq     .get_lz_win
                 eor     #$FF
 
+                inx                             ; Increment # of pages to copy.
+
 .get_lz_dst:    adc     <lzsa_dstptr + 0        ; Calc address of partial page.
                 sta     <lzsa_dstptr + 0        ; Always CC from previous CMP.
                 bcs     .get_lz_win
                 dec     <lzsa_dstptr + 1
 
 .get_lz_win:    clc                             ; Calc address of match.
-                adc     <lzsa_offset + 0        ; N.B. Offset is negative!
+                lda     <lzsa_dstptr + 0        ; N.B. Offset is negative!
+                adc     <lzsa_offset + 0
                 sta     <lzsa_winptr + 0
                 lda     <lzsa_dstptr + 1
                 adc     <lzsa_offset + 1
                 sta     <lzsa_winptr + 1
 
-.lz_byte:       lda     (lzsa_winptr),y
+.lz_page:       lda     (lzsa_winptr),y
                 sta     (lzsa_dstptr),y
                 iny
-                bne     .lz_byte
+                bne     .lz_page
+                inc     <lzsa_winptr + 1
                 inc     <lzsa_dstptr + 1
                 dex                             ; Any full pages left to copy?
-                bne     .lz_more
+                bne     .lz_page
 
                 jmp     .cp_length              ; Loop around to the beginning.
 
-.lz_more:       inc     <lzsa_winptr + 1        ; Unlikely, so can be slow.
-                bne     .lz_byte                ; Always true!
-
                 ;
                 ; Lookup tables to differentiate literal and match lengths.
                 ;
 
-.nibl_len_tbl:  !byte   3                       ; 0+3 (for literal).
-                !byte   9                       ; 2+7 (for match).
+.nibl_len_tbl:  !byte   9                       ; 2+7 (for match).
+                !byte   3                       ; 0+3 (for literal).
 
-.byte_len_tbl:  !byte   18 - 1                  ; 0+3+15 - CS (for literal).
-                !byte   24 - 1                  ; 2+7+15 - CS (for match).
+.byte_len_tbl:  !byte   24 - 1                  ; 2+7+15 - CS (for match).
+                !byte   18 - 1                  ; 0+3+15 - CS (for literal).
 
                 ;
                 ; Get 16-bit length in X:A register pair, return with CC.
@@ -255,15 +263,13 @@ lzsa2_unpack:   ldx     #$00                    ; Hi-byte of length or offset.
                 bcc     .got_length
                 beq     .finished
 
-.word_length:   clc                             ; MUST return CC!
-                jsr     .get_byte               ; So rare, this can be slow!
+.word_length:   jsr     .get_byte               ; So rare, this can be slow!
                 pha
                 jsr     .get_byte               ; So rare, this can be slow!
                 tax
                 pla
-                bne     .got_word               ; Check for zero lo-byte.
-                dex                             ; Do one less page loop if so.
-.got_word:      rts
+                clc                             ; MUST return CC!
+                rts
 
 .get_byte:      lda     (lzsa_srcptr),y         ; Subroutine version for when
                 inc     <lzsa_srcptr + 0        ; inlining isn't advantageous.