puZIP - ZIP File compression#

; DASM V2.12.04 source

; ZIP, 32k window, dynamic Huffman
; 174848  Defl:N   96995  45%  09-13-00  21:08  c4d2f886   t

; PUZIP, 32k window, fixed Huffman
; 174848  Defl:N  107741  39%  00-00-80  00:00  c4d2f886   T

; C64, 8k window, fixed Huffman
; 174848  Defl:N  113643  35%  00-00-80  00:00  c4d2f886   T

; C64, 4k window, fixed Huffman
; 174848  Defl:N  114699  34%  00-00-80  00:00  c4d2f886   T

; C64, 2k window, fixed Huffman
; 174848  Defl:N  119375  32%  00-00-80  00:00  c4d2f886   T


; PKZIP
; =====
; Length  Method   Size  Ratio   Date    Time   CRC-32     Name
; ------  ------   ----  -----   ----    ----   ------     ----
; 174848  Defl:N   60230  66%  12-02-99  18:03  d625f0bd   PARTS1.D64
; 174848  Defl:N   24441  86%  12-02-99  18:05  76e851cd   PARTS2.D64
; ------          ------  ---                              -------
; 349696           84671  76%                              2 files

; C128
; ====
; Length  Method   Size  Ratio   Date    Time   CRC-32     Name
; ------  ------   ----  -----   ----    ----   ------     ----
; 174848  Defl:N   75580  57%  00-00-80  00:00  d625f0bd   PARTS1.D64
; 174848  Defl:N   31867  82%  00-00-80  00:00  76e851cd   PARTS2.D64
; ------          ------  ---                              -------
; 349696          107447  69%                              2 files


; ZIP
; ===
; Length  Method   Size  Ratio   Date    Time   CRC-32     Name
; ------  ------   ----  -----   ----    ----   ------     ----
; 174848  Defl:N   59986  66%  02-09-89  00:45  d625f0bd   parts1.d64
; 174848  Defl:N   24418  86%  02-09-89  00:45  76e851cd   parts2.d64
; ------          ------  ---                              -------
; 349696           84404  76%                              2 files

; C64				39min (1581 files->1581)
; ===
; Length  Method   Size  Ratio   Date    Time   CRC-32     Name
; ------  ------   ----  -----   ----    ----   ------     ----
; 174848  Defl:N   71129  59%  06-07-01  02:39  d625f0bd   PARTS1.D64
; 174848  Defl:N   30614  83%  06-07-01  02:39  76e851cd   PARTS2.D64
; ------          ------  ---                              -------
; 349696          101743  71%                              2 files

; C64 with lazy matching	47min (1581 files->1581)
; ======================
; Length  Method   Size  Ratio   Date    Time   CRC-32     Name
; ------  ------   ----  -----   ----    ----   ------     ----
; 174848  Defl:N   70548  60%  06-07-01  02:39  d625f0bd   PARTS1.D64
; 174848  Defl:N   30491  83%  06-07-01  02:39  76e851cd   PARTS2.D64
; ------          ------  ---                              -------
; 349696          101039  71%                              2 files

;			Length   Size  Ratio   Date    Time   CRC-32     Name
; ZIP			174848   96995  45%  02-09-89  00:45  c4d2f886   t
; PuZip - 32k+lazy	174848  106660  39%  09-01-02  02:39  c4d2f886   t
; 0(8k+lazy)	19:50	174848  112701  36%  08-09-02  02:39  c4d2f886   T
; 1(4k+greedy)	15:12	174848  114635  34%  08-09-02  02:39  c4d2f886   T
; 2(2k+greedy)	13:51	174848  118802  32%  08-09-02  02:39  c4d2f886   T
; 3(1k+greedy)	12:57	174848  121699  30%  08-09-02  02:39  c4d2f886   T



	processor 6502

ACPTR  = $ffa5
CHKIN  = $ffc6
CHKOUT = $ffc9
CHRIN  = $ffcf
CHROUT = $ffd2
CIOUT  = $ffa8
CLOSE  = $ffc3
GETIN  = $ffe4
CLALL  = $ffe7
CLRCHN = $ffcc
LISTEN = $ffb1
OPEN   = $ffc0
SECOND = $ff93
SETLFS = $ffba
SETNAM = $ffbd
TALK   = $ffb4
TKSA   = $ff96
UNLSN  = $ffae
UNTLK  = $ffab
;READST = $ffb7

ST	= $90

pos	= $0200	; 4 bytes
arg	= $0204 ; 2 bytes

#if MACH == 64 || MACH == 128
IDE64BlockWrite = $DEF1
IDE64BlockRead = $DEF4
IDE64BR = $6e ;$6e $6f
be	= $69 ;dc.b 0
D2PRA  = $DD00		; c64 SERIAL PORT LOCATION
D1ICR  = $DC0D		; 6526 cia INTERRUPT CONTROL REGISTER
D1SDR  = $DC0C		; 6526 cia SERIAL DATA REGISTER
#endif

		; name	-- input file name 16+2
CA_CRC   = 18	; crc32	-- cyclic redundancy check
CA_CSize = 22	; csize	-- compressed size
CA_USize = 26	; usize	-- uncompressed size
CA_LHdr  = 30	; lhdroff -- local header offset
CA_FLen	 = 34	; filename length
CA_TS    = 35	; starting track & sector, if any
CA_Mode  = 37	; compress mode -- "S" or "Y"
CASIZE   = 38


; =============================== VIC20 ====================================
#if MACH == 20
; 16k expansion required	- $1200-$5fff

MAX_MATCH  = 255	;$0ff
BLOCK_SIZE = 4*256	;$400	; must be rounded to 256 bytes and power of 2
; Maximum for BLOCK_SIZE is 32768

LSHIFT = 4		; 4 and 5 supported, (3 too slow, 6 memory-hungry)
LSIZE  = (1<<LSHIFT)

lPairSize = 4*LSIZE*LSIZE
bSkipSize = 2*BLOCK_SIZE
bufferSize = BLOCK_SIZE + MAX_MATCH+1

; lPair must be before bSkip in memory, both must be aligned to page
lPair  = $4c00	; $4c00..$4fff	unsigned long  lPair[16*16]
bSkip  = lPair+lPairSize
		; $5000..$57ff	unsigned short bSkip[BLOCK_SIZE]
buffer = $5800	; $5800..$5cff	unsigned char  buffer[BLOCK_SIZE + MAX_MATCH]

;outbuf = $2b00
outend = $4a00	; $2b00..$4a00	; 181 files leaves 1k output buffer
MAXFILES = 181


byte   = $2
CRC    = $6a	; $6a..6d
bTmp   = $14	; $14,$15

rPtr   = $f7	; $f7,$f8
wPtr   = $f9	; $f9,$fa

zp0    = $fb
zp1    = $fc

tmp    = $fd
CAPtr  = $fe	; $fe,$ff

crc32_tab0 = $5d00
crc32_tab1 = $5e00
crc32_tab2 = $5f00
crc32_tab3 = $4b00
inBuf = $4a00


	ORG $1201
	DC.B $0b,$12,20,0	; '20 SYS4621'
	DC.B $9e,$34,$36,$32
	DC.B $31,0,0,0
#endif


; =============================== C16 ====================================
#if MACH == 16
; C16 $1000-$3fff	+/4 $1000-$fd00

MAX_MATCH  = 255	;$0ff
BLOCK_SIZE = 4*256	;$400	; must be rounded to 256 bytes and power of 2
; Maximum for BLOCK_SIZE is 32768

LSHIFT = 4		; 4 and 5 supported, (3 too slow, 6 memory-hungry)
LSIZE  = (1<<LSHIFT)

lPairSize = 4*LSIZE*LSIZE	; $400
bSkipSize = 2*BLOCK_SIZE	; $800
bufferSize = BLOCK_SIZE + MAX_MATCH+1	; $500

; lPair must be before bSkip in memory, both must be aligned to page
lPair  = $2a00	; $2a00..$2dff	unsigned long  lPair[16*16]
bSkip  = lPair+lPairSize
		; $2e00..$35ff	unsigned short bSkip[BLOCK_SIZE]
buffer = $3600	; $3600..$3aff	unsigned char  buffer[BLOCK_SIZE + MAX_MATCH]

outend = lPair
MAXFILES = 26	; 26 leaves $100 for output buffer


;	$00D8-00E8	216-232	Area for use by application software


byte   = $dd
CRC    = $e0	; $e0..$e3
bTmp   = $de	; $de,$df

rPtr   = $e4	; $e4,$e5
wPtr   = $e6	; $e6,$e7

zp0    = $db
zp1    = $dc

tmp    = $da
CAPtr  = $d8	; $d8,$d9

crc32_tab0 = $3b00
crc32_tab1 = $3c00
crc32_tab2 = $3d00
crc32_tab3 = $3e00
inBuf = $3f00


	ORG $1001
	DC.B $0b,$10,20,0	; '20 SYS4109'
	DC.B $9e,$34,$31,$30
	DC.B $39,0,0,0
#endif


; =============================== Plus/4 ====================================
#if MACH == 4
; C16 $1000-$3fff	+/4 $1000-$fd00

MAX_MATCH  = 255	;$0ff
BLOCK_SIZE = 32*256	;$2000	; must be rounded to 256 bytes and power of 2
; Maximum for BLOCK_SIZE is 32768

LSHIFT = 5		; 4 and 5 supported, (3 too slow, 6 memory-hungry)
LSIZE  = (1<<LSHIFT)

lPairSize = 4*LSIZE*LSIZE	; $1000
bSkipSize = 2*BLOCK_SIZE	; $4000
bufferSize = BLOCK_SIZE + MAX_MATCH+1	; $2100

; lPair must be before bSkip in memory, both must be aligned to page
lPair  = $8000	; $8000..$8fff	unsigned long  lPair[32*32]
bSkip  = lPair+lPairSize
		; $9000..$cfff	unsigned short bSkip[BLOCK_SIZE]
buffer = $d400	; $d400..$f4ff	unsigned char  buffer[BLOCK_SIZE + MAX_MATCH]

outend = $6000
MAXFILES = 254	; 254 leaves $344c for output buffer

crc32_tab0 = $d300
crc32_tab1 = $d200
crc32_tab2 = $d100
crc32_tab3 = $d000
inBuf = $7f00

;	$00D8-00E8	216-232	Area for use by application software


byte   = $dd
CRC    = $e0	; $e0..$e3
bTmp   = $de	; $de,$df

rPtr   = $e4	; $e4,$e5
wPtr   = $e6	; $e6,$e7

zp0    = $db
zp1    = $dc

tmp    = $da
CAPtr  = $d8	; $d8,$d9



	ORG $1001
	DC.B $0b,$10,20,0	; '20 SYS4109'
	DC.B $9e,$34,$31,$30
	DC.B $39,0,0,0
#endif


#if MACH == 64
; =============================== C64 =====================================
; $14..15, 2, $9e..9f
; $f7..ff


MAX_MATCH  = 255	;$0ff
BLOCK_SIZE = 32*256	;$2000	; must be rounded to 256 bytes and power of 2

LSHIFT = 5		; 4 and 5 supported, (3 too slow, 6 memory-hungry)
LSIZE  = (1<<LSHIFT)

lPairSize = 4*LSIZE*LSIZE	; $1000
bSkipSize = 2*BLOCK_SIZE	; $4000
bufferSize = BLOCK_SIZE + MAX_MATCH+1	; $2100

; lPair must be before bSkip in memory, both must be aligned to page
lPair  = $7800	; $7800..$87ff	unsigned long  lPair[32*32]
bSkip  = lPair+lPairSize
		; $8800..$c7ff	unsigned short bSkip[BLOCK_SIZE]
buffer = $d000	; $d000..$f0ff	unsigned char  buffer[BLOCK_SIZE + MAX_MATCH]

outend = $7800
MAXFILES = 254	; 255 means disk image

crc32_tab0 = $c900
crc32_tab1 = $ca00
crc32_tab2 = $cb00
crc32_tab3 = $cc00
inBuf = $cd00

; CE00 and CF00 reserved for REU/RamDOS


byte   = $2
CRC    = $6a	; $6a..6d
bTmp   = $14	; $14,$15

rPtr   = $f7	; $f7,$f8
wPtr   = $f9	; $f9,$fa

zp0    = $fb
zp1    = $fc

tmp    = $fd
CAPtr  = $fe	; $fe,$ff


FASTSER	= $02a3

	ORG $0801
	DC.B $0b,8,64,0		; '64 SYS2061'
	DC.B $9e,$32,$30,$36
	DC.B $31,0,0,0

	lda #$36
	sta 1
#endif

; =============================== C128 =====================================
#if MACH == 128

MAX_MATCH  = 255	;$0ff
BLOCK_SIZE = 32*256	;$2000	; must be rounded to 256 bytes and power of 2

LSHIFT = 5		; 4 and 5 supported, (3 too slow, 6 memory-hungry)
LSIZE  = (1<<LSHIFT)

lPairSize = 4*LSIZE*LSIZE	;$1000
bSkipSize = 2*BLOCK_SIZE	;$4000
bufferSize = BLOCK_SIZE + MAX_MATCH+1	; $2100

buffer = $9f00	; $9f00..$bfff	unsigned char  buffer[BLOCK_SIZE + MAX_MATCH]

; lPair must be before bSkip in memory, both must be aligned to page
; lPair and bSkip are now in bank1
lPair  = $1000	; $1000..$1fff	unsigned long  lPair[32*32]
bSkip  = lPair+lPairSize
		; $2000..$5fff	unsigned short bSkip[BLOCK_SIZE]

outend = $9f00	; $3d00..$9eff	; 254 files leaves 15k outpuf buffer
MAXFILES = 254	; 255 means disk image


byte   = $86
tmp    = $87
CRC    = $6a	; $6a..6d
bTmp   = $88	; $88,$89

rPtr   = $8a	; $8a,$8b

wPtr   = $fa	; $fa,$fb

zp0    = $fc
zp1    = $fd

CAPtr  = $fe	; $fe,$ff

prns = $ff7d

crc32_tab0 = $1300
crc32_tab1 = $1400
crc32_tab2 = $1500
crc32_tab3 = $1600
inBuf = $1700

FASTSER = $0a1c

SETBANK = $ff68		; sta c6 stx c7
SPIN_OUT = $FF47	; sET UP FAST SERIAL FOR INPUT OR OUTPUT.
			;  sec FOR OUTPUT, clc FOR INPUT.
READBANK = $ff74	; lda (ZP),y  bank in X, ZP in A
WRITEBANK = $ff77	; sta (ZP),y  bank in X, value in A, ZP in $02b9
VERIFYBANK = $ff7a	; cmp (ZP),y  bank in X, value in A, ZP in $02c8

JSRFAR = $02CD	; JSR XXXX to Any Bank & Return
; 02de	return memory config
;0002		Bank Number, Jump to SYS Address
;0003-0004	SYS address, MLM register PC
;0005-0009	SYS and MLM register save (SR, A, X, Y, SP)


	ORG $1c01
	DC.B $0b,$1c,128,0	; '128 SYS7181'
	DC.B $9e,$37,$31,$38
	DC.B $31,0,0,0

	lda $02de
	pha
	lda $ff00
	pha
	lda #$0e	; RAM0, System ROM, RAM, BASIC
	sta $ff00
	lda #0
	sta $f7		; enable SHIFT-C=
	sta $f8
	sta $f9
	tax
	jsr SETBANK	; I/O source/destination RAM0 64k
	jsr bank1install
#endif

	cli	; just in case..!?!?
	jsr prns
	dc.b 147
#if MACH == 4
	dc.b $b0,$ae,$20,$20,$b0,$ae,$20,$b0,$ae,$20,$20,$ae,$ae, 13
	dc.b $ab,$bd,$ae,$ae,$ac,$be,$7d,$ab,$bd,$20,$7b,$ad,$b3
#endif
#if MACH == 16
	dc.b $b0,$ae,$20,$20,$b0,$ae,$20,$b0,$ae,$20,$b0,$ae,$ae,$b0,$ae, 13
	dc.b $ab,$bd,$ae,$ae,$ac,$be,$7d,$ab,$bd,$20,$7d,$20,$7d,$ab,$ae
#endif
#if MACH == 64
	dc.b $b0,$ae,$20,$20,$b0,$ae,$20,$b0,$ae,$20,$b0,$ae,$b0,$ae,$ae,$ae, 13
	dc.b $ab,$bd,$ae,$ae,$ac,$be,$7d,$ab,$bd,$20,$7d,$20,$ab,$ae,$ad,$b3
#endif
#if MACH == 128
	dc.b $b0,$ae,$20,$20,$b0,$ae,$20,$b0,$ae,$20,$ae,$b0,$ae,$b0,$ae, 13
	dc.b $ab,$bd,$ae,$ae,$ac,$be,$7d,$ab,$bd,$20,$7d,$b0,$bd,$ab,$b3
#endif
	dc.b " V1.12     19.11.2002",13
#if MACH == 4
	dc.b $bd,$20,$ad,$bd,$ad,$bd,$bd,$bd,$20,$be,$20,$20,$bd
#endif
#if MACH == 16
	dc.b $bd,$20,$ad,$bd,$ad,$bd,$bd,$bd,$20,$be,$ad,$bd,$b1,$ad,$bd
#endif
#if MACH == 64
	dc.b $bd,$20,$ad,$bd,$ad,$bd,$bd,$bd,$20,$be,$ad,$bd,$ad,$bd,$20,$bd
#endif
#if MACH == 128
	dc.b $bd,$20,$ad,$bd,$ad,$bd,$bd,$bd,$20,$be,$ad,$ad,$bd,$ad,$bd
#endif
	dc.b " BY PASI'ALBERT'OJALA", 13
#if MACH != 20
	dc.b "        HTTP://WWW.CS.TUT.FI/%7EALBERT/", 13, 13, 0
#else
	dc.b " HTTP://WWW.CS.TUT.FI/%7EALBERT/", 13, 13, 0
#endif

	lda #8
	sta bits

#if MACH == 16 || MACH == 4
	sei
	sta $ff3f	; RAM
#endif
#if MACH == 64
	sei
	ldy #$34
	sty 1
#endif

	ldx #0			; create the CRC32 table (makecrc.c)
crc$	lda #0
	sta CRC+3
	sta CRC+2
	sta CRC+1
	stx CRC+0
	ldy #8
1$	lsr CRC+3
	ror CRC+2
	ror CRC+1
	ror CRC+0
	bcc 0$
	lda #$ed
	eor CRC+3
	sta CRC+3
	lda #$b8
	eor CRC+2
	sta CRC+2
	lda #$83
	eor CRC+1
	sta CRC+1
	lda #$20
	eor CRC+0
	sta CRC+0
0$	dey
	bne 1$
	lda CRC+0
	sta crc32_tab0,x
	lda CRC+1
	sta crc32_tab1,x
	lda CRC+2
	sta crc32_tab2,x
	lda CRC+3
	sta crc32_tab3,x
	inx
	bne crc$

#if MACH == 16 || MACH == 4
	sta $ff3e	; ROM
	cli
#endif
#if MACH == 64
	ldy #$36
	sty 1
	cli
#endif

restart
#if MACH == 64 || MACH == 128
	jsr on		; screen on / 2MHz mode if possible
#endif

idrive$	jsr prns
	dc.b "INPUT", 0

	lda #14		; channel #
	jsr askdrive
	beq idrive$
	sta inDrive

#if MACH == 64 || MACH == 128
	jsr CheckBurst
	jsr CheckIDE64
#endif
	lda #0
	sta files
	lda #<CA
	sta CAPtr+0
	lda #>CA
	sta CAPtr+1

	jsr ReadDir

	; Make the output buffer as big as possible,
	; i.e. it starts right after the last file entry.
	lda CAPtr+1	; HI
	sta obufhi	; start of output buffer
	inc obufhi	; right after filenames

	lda files
	cmp #255
	beq odrive$
	cmp #0
	bne files$
iagain$	lda #14		; no files -> try again
	jsr CLOSE
	jmp idrive$

files$	ldx #<files
	ldy #>files
	lda #1
	jsr putdec
	jsr prns
	dc.b " FILES",13, 0

odrive$	jsr prns
	dc.b "OUTPUT", 0

	lda #15
	jsr askdrive
	bcs iagain$	; RUN/STOP pressed - back to input drive
	beq odrive$	; device not present - ask again
	sta zipDrive

	lda files
	cmp #255
	bne ofile$
	cmp inDrive
	bne ofile$
	; image compression and one drives
	lda #15
	jsr CLOSE
	jsr prns
	dc.b "DISK IMAGE COMPRESSION NEEDS TWO DRIVES",13,0
	jmp odrive$

ofile$	jsr prns
	dc.b "ZIP FILE?", 13, 34, 0

	lda #0
	sta zipFile
	lda #<zipFile
	ldx #>zipFile
	ldy #28		; max filename length
	jsr getstr
	sty zipLen
	lda #34
	jsr OK_KEY

	lda zipLen
	bne onok$

	lda #15		; an empty filename.. ask the drive again
	jsr CLOSE
	jmp odrive$

onok$	lda zipFile+0
	cmp #"@"
	bne oopen$

	; a disk command..
	lda zipLen
	cmp #1
	beq orerr$
	ldx #15
	jsr CHKOUT
	ldy #1
ocmd$	lda zipFile,y
	jsr CHROUT
	iny
	cpy zipLen
	bne ocmd$
	jsr CLRCHN

orerr$	ldx #15
	jsr geterror
	ldx #<errorStr
	lda #>errorStr
	ldy errorLen
	jsr putstr
	jmp ofile$


oopen$	ldx #<zipFile
	ldy #>zipFile
	lda zipLen
	jsr SETNAM
	lda #3
	ldx zipDrive
	ldy #1		; open 3,8,1,"fileName"
	jsr SETLFS
	jsr OPEN

	ldx #15
	jsr geterror
	cmp #0
	beq 2$

	lda #3
	jsr CLOSE
	jsr CLRCHN
	ldx #<errorStr
	lda #>errorStr
	ldy errorLen
	jsr putstr
	jmp ofile$

2$	jsr CLRCHN
	lda files
	sta filecnt
	lda #<CA
	sta CAPtr+0
	lda #>CA
	sta CAPtr+1
	lda #0
	sta outSize+0
	sta outSize+1
	sta outSize+2
	sta outSize+3
	jsr InitBuffer32k

	jsr prns
	dc.b "ZIP COMMENT?", 13, 34, 0

	lda #0
	sta zipComment
	lda #<zipComment
	ldx #>zipComment
	ldy #36
	jsr getstr
	sty zipCommentLen
	lda #34
	jsr OK_KEY

; ---------------------------------------------

fileloop:
#if MACH == 64 || MACH == 128
	lda #0
	sta inMode
#endif
	lda files
	cmp #255
	beq disk$
	jmp fi$

	; D64/D71/D81 read -- open direct access buffer if needed
disk$	ldy #CA_Mode
	lda #"Y"	; always compress disk images
	sta (CAPtr),y
	ldy #0
dn$	lda diskName,y
	bpl nlow$
	eor #$a0
nlow$	sta (CAPtr),y
	beq nend$	; NUL -> end of file name
	iny
	cpy #16
	bne dn$
nend$
	; append .d81 .d71 or .d64
	cpy #15
	bcc append$	; if 0..14 chars, just append
	ldy #14		; if 15.. overwrite the end
append$	lda #"."
	sta (CAPtr),y
	iny
	lda #"D"
	sta (CAPtr),y
	iny
	lda #"8"
	sta (CAPtr),y
	iny
	lda #"1"
	sta (CAPtr),y

	lda fdos
	cmp #"D"
	beq dok$	; ".D81"

	dey
	lda #"7"
	sta (CAPtr),y
	iny
	bit fflag
	bmi dok$	; ".D71"

	dey
	lda #"6"
	sta (CAPtr),y
	iny
	lda #"4"
	sta (CAPtr),y	; ".D64"
dok$
	iny

	tya
	ldy #CA_FLen
	sta (CAPtr),y

	ldy #1
	sty inTrack
	dey		; ldy #0
	sty inSector

#if MACH == 64 || MACH == 128
	lda inBurst
	beq direct$	; can't use burst read -> use sequential read
	inc inMode	; burst mode, direct-access file not opened
	jmp 3$
direct$
#endif
	ldx #<d64chan$
	ldy #>d64chan$
	lda #1
	jsr SETNAM
	lda #2
	ldx inDrive
	tay	;ldy #2		; open 2,8,2,"#"
	jsr SETLFS
	jsr OPEN

	ldx #14
	jsr geterror
	cmp #0
	beq noerr1$

	jsr CLRCHN
	ldx #<errorStr
	lda #>errorStr
	ldy errorLen
	jsr putstr

noerr1$	lda #"2"
	jsr initbp
	jmp 3$

d64chan$
	dc.b "#"

fi$
#if MACH == 64 || MACH == 128
	lda inBurst
	beq open$	; can't use burst read -> use sequential read

	ldy #CA_TS
	lda (CAPtr),y
	beq open$	; no T&S -> use sequential read
	sta inTrack
	iny
	lda (CAPtr),y
	sta inSector
	inc inMode
	jmp 3$
#endif

open$	ldy #CA_FLen
	lda (CAPtr),y
	ldx CAPtr+0
	ldy CAPtr+1
	jsr SETNAM

	lda #2
	ldx inDrive
	ldy #0		; open 2,8,0,"fileName"
	jsr SETLFS
	jsr OPEN

	ldx #15
	jsr geterror
	cmp #0
	beq 3$
	lda #2
	jsr CLOSE
	ldx #<errorStr
	lda #>errorStr
	ldy errorLen
	jsr putstr
	jsr CR
	jmp fileloop	; TODO: update fields etc.


	; File opened and/or inTrack/inSector initialized
3$	lda #0
	sta be
	sta ST

	ldx #3
	ldy #CA_LHdr+3
5$	lda outSize+0,x
	sta (CAPtr),y		; CA[files].lhdroff = curbyte;
	dey
	dex
	bpl 5$

	ldy #0
lhdr$	lda lhdr,y		; Put local file header
	jsr PutBuffer
	iny
	cpy #26
	bne lhdr$

	ldy #CA_FLen
	lda (CAPtr),y
	sta curlen		; put current file name length
	jsr PutBuffer
	lda #0
	jsr PutBuffer
	lda #0
	jsr PutBuffer
	lda #0
	jsr PutBuffer

	jsr InitBits

	ldy #0
floop$	lda (CAPtr),y		; put filename
	bpl low$
	eor #$a0
low$	jsr PutBuffer
	lda (CAPtr),y
	jsr CHROUT
	iny
	cpy curlen
	bne floop$

	lda #" "
	jsr CHROUT

	ldx #3
6$	lda #255
	sta CRC+0,x
	lda #0
	sta usize+0,x
	lda outSize+0,x
	sta cstart+0,x
	dex
	bpl 6$

	lda #0
	sta zipMode	; not stored

file	ldy #CA_Mode
	lda (CAPtr),y
	cmp #"S"
	beq stored$
	jsr Huffman	; pass speed parameter in A
	jmp tail$

stored$	jsr Stored
tail$	; Put data descriptor header
	lda #$50
	jsr PutBuffer
	lda #$4b
	jsr PutBuffer
	lda #$07
	jsr PutBuffer
	lda #$08
	jsr PutBuffer

	ldx #3
	ldy #CA_CRC+3
crc$	lda CRC+0,x
	eor #255
	sta (CAPtr),y
	dey
	dex
	bpl crc$

	ldx #3
	ldy #CA_CSize
	sec		; csize =  curbyte - cstart;
subl$	lda outSize-CA_CSize,y
	sbc cstart-CA_CSize,y
	sta csize-CA_CSize,y
	sta (CAPtr),y
	iny
	dex
	bpl subl$

	ldx #3
	ldy #CA_USize
ul$	lda usize-CA_USize,y
	sta (CAPtr),y
	iny
	dex
	bpl ul$

	; put CRC, CSize and USize
	ldx #12
	ldy #CA_CRC
cs$	lda (CAPtr),y
	jsr PutBuffer
	iny
	dex
	bne cs$

#if MACH == 64 || MACH == 128
	jsr on
	lda inMode
	bne noclose$	; used burst read -> no close
#endif
	ldx #14
	jsr geterror
	cmp #0
	beq noerr$

	jsr CLRCHN
	ldx #<errorStr
	lda #>errorStr
	ldy errorLen
	jsr putstr
noerr$
	lda #2
	jsr CLOSE
noclose$

	jsr CLRCHN
	ldx #<usize
	ldy #>usize
	lda #4
	jsr putdec
	lda #"="
	jsr CHROUT
	lda #">"
	jsr CHROUT
	ldx #<csize
	ldy #>csize
	lda #4
	jsr putdec
	lda #" "
	jsr CHROUT
	jsr putratio

	lda #"%"
	jsr CHROUT
	jsr CR

	lda files
	cmp #255
	beq 4$

	lda CAPtr+0
	clc
	adc #CASIZE
	sta CAPtr+0
	bcc noc$
	inc CAPtr+1
noc$	dec filecnt
	beq 4$
	jmp fileloop

; ---------------------------------------------

4$	ldx #3
5$	lda #0
	sta csize,x
	lda outSize+0,x
	sta cstart+0,x
	dex
	bpl 5$

	lda files
	sta filecnt
	lda #<CA
	sta CAPtr+0
	lda #>CA
	sta CAPtr+1
headerloop
	ldy #0
ghdr$	lda ghdr,y		; Put global header
	jsr PutBuffer
	iny
	cpy #16
	bne ghdr$

	ldy #CA_CRC
1$	lda (CAPtr),y
	jsr PutBuffer
	iny
	cpy #CA_LHdr
	bne 1$

	ldy #CA_FLen
	lda (CAPtr),y
	sta curlen
	jsr PutBuffer
	ldy #10		;12
3$	lda #0
	jsr PutBuffer
	dey
	bpl 3$

	lda #$b4
	jsr PutBuffer
	lda #$80
	jsr PutBuffer

	ldy #CA_LHdr
	lda (CAPtr),y
	jsr PutBuffer
	iny
	lda (CAPtr),y
	jsr PutBuffer
	iny
	lda (CAPtr),y
	jsr PutBuffer
	iny
	lda (CAPtr),y
	jsr PutBuffer

	ldy #0
4$	lda (CAPtr),y	; put filename
	bpl low$
	eor #$a0
low$	jsr PutBuffer
	iny
	cpy curlen
	bne 4$

	lda curlen
	clc
	adc #46
	bcc 7$
	inc csize+1
	clc
7$	adc csize+0
	sta csize+0
	bcc 6$
	inc csize+1
	bne 6$
	inc csize+2
	bne 6$
	inc csize+3
6$
	lda files
	cmp #255
	beq 0$

	lda CAPtr+0
	clc
	adc #CASIZE
	sta CAPtr+0
	bcc noc$
	inc CAPtr+1
noc$	dec filecnt
	beq 0$
	jmp headerloop

0$	ldy #0
ehdr$	lda ehdr,y		; put end of header
	jsr PutBuffer
	iny
	cpy #8
	bne ehdr$

	lda files
	cmp #255
	bne 21$
	lda #1
21$	jsr PutBuffer
	lda #0
	jsr PutBuffer
	lda files
	cmp #255
	bne 22$
	lda #1
22$	jsr PutBuffer
	lda #0
	jsr PutBuffer

	ldy #0
11$	lda csize+0,y
	jsr PutBuffer
	iny
	cpy #4
	bne 11$

	ldy #0
2$	lda cstart+0,y
	jsr PutBuffer
	iny
	cpy #4
	bne 2$

	lda zipCommentLen	; Zip comment length
	jsr PutBuffer
	lda #0
	jsr PutBuffer

	lda zipCommentLen
	beq flush$
	ldy #0
33$	lda zipComment,y
	bpl 34$
	eor #$a0
34$	jsr PutBuffer
	iny
	cpy zipCommentLen
	bne 33$

flush$	jsr FlushBuffer
#if MACH == 64 || MACH == 128
	jsr on
#endif
	lda #3
	jsr CLOSE

	;lda #14
	;jsr CLOSE
	;lda #15
	;jsr CLOSE

	jsr CLALL
	jsr CLRCHN
#if MACH == 64
	lda #$37
	sta 1
#endif
#if MACH == 128
	pla
	sta $ff00	; restore memory config
	pla
	sta $02de	; restore return memory config
#endif
	cli	; just in case
	rts



Huffman:
	ldy #0
	cmp #"Y"
	beq speed$
	cmp #"0"
	beq speed$
	iny
	cmp #"1"
	beq speed$
	iny
	cmp #"2"
	beq speed$
	iny
speed$	sty speed	; speed = 0..3
;==============================================================
	; lPair must be before bSkip in memory
	; memset(lPair, 0, sizeof(lPair));
	; memset(bSkip, 0, sizeof(bSkip));

#if MACH == 16 || MACH == 4
	sei
	sta $ff3f	; RAM
#endif
#if MACH == 64
	sei
	ldy #$34
	sty 1
#endif

#if MACH == 128
	jsr ClearSearch
#else
	lda #>lPair
	sta clr$+2
	ldx #>(lPairSize+bSkipSize)

	ldy #0
	tya		;lda #0
clr$	sta $aa00,y
	iny
	bne clr$
	inc clr$+2
	dex
	bne clr$
#endif

	;lda #0
	sta oMaxlen	; oMaxlen = 0; /* 0 = not started */
	sta oChar	; oChar = 0;

	sta eof		; eof = 0;
	sta skip	; skip = 0;
	sta pos+0	; p = 0;
	sta pos+1
	sta pos+2
	sta pos+3
	sta buc		; bu = 0; bytes in the lookahead 'buffer'
	lda #<buffer	; wPtr = rPtr = &buffer[0];
	sta wPtr+0
	sta rPtr+0
	lda #>buffer
	sta wPtr+1
	sta rPtr+1

#if MACH == 16 || MACH == 4
	sta $ff3e	; ROM
	cli
#endif
#if MACH == 64
	ldy #$36
	sty 1
	cli
#endif

	lda #1	; last block, yes
	ldx #1
	jsr PutBits
	lda #1	; fixed huffman
	ldx #2
	jsr PutBits

dataloop$
	; Fill the lookahead buffer if no EOF seen yet..
	lda eof
	bne nofill$
	; bu is 0 for first entry, bu is decremented each dataloop$,
	; thus bu is never MAX_MATCH when while is entered
	;ldx #2
	;jsr CHKIN	;while (!eof && bu < MAX_MATCH) {
fill$	;jsr CHRIN	;  int c = fgetc(fp);
#if MACH == 16 || MACH == 4
	sta $ff3e	; ROM
	cli
#endif
#if MACH == 64
	ldy #$36
	sty 1
	cli
#endif
	jsr GetByte	;    if (c == EOF) {
#if MACH == 16 || MACH == 4
	sei
	sta $ff3f	; RAM
#endif
#if MACH == 64
	sei
	ldy #$34
	sty 1
#endif
	ldy #0		;	eof = 1;
	sta (wPtr),y	;	break;
	sta delta$+1	;    } else {
	jsr updcrc	;	crc32 = updcrc(c, crc32);
	lda wPtr+1
	cmp #>buffer	;	*wPtr = c;
	bne nodelta$	;	if (wPtr < &buffer[MAX_MATCH]) {
	tax
	clc
	adc #>BLOCK_SIZE
	sta wPtr+1
delta$	lda #0
	sta (wPtr),y	;	    *(wPtr + BLOCK_SIZE) = c;
	stx wPtr+1
nodelta$		;	}
	inc wPtr+0	;	wPtr++;
	bne wpe$
	inc wPtr+1	;	if (wPtr == &buffer[BLOCK_SIZE]) {
	lda wPtr+1	;	    wPtr = &buffer[0];
	cmp #>(buffer+BLOCK_SIZE)
	bne wpe$
	lda #>buffer
	sta wPtr+1	;	}
wpe$	inc buc		;	bu++;
	bit ST
	bvc noeof$
	lda #0
	sta ST
	inc eof
	bne nofill$
noeof$			;    }
	lda buc		; bytes in the lookahead 'buffer'
	cmp #MAX_MATCH
	bne fill$	;}

	;jsr CLRCHN
nofill$
	; Create index to our search structure and the
	; corresponding pointer from the search string's
	; two first characters.
#if MACH == 16 || MACH == 4
	sei
	sta $ff3f	; RAM
#endif
#if MACH == 64
	sei
	ldy #$34
	sty 1
#endif

	ldy #1
	lda (rPtr),y
	tax
	dey
	lda (rPtr),y
#if MACH == 128
	sta arg+0
	stx arg+1
	jsr UpdSearch
#else
	; no check.. it doesn't matter if we read 1 byte off the end
updsearch$		;if (bu > 1) {
			;  long off;
			;  unsigned short index =
	asl		;	((*rPtr & (LSIZE-1)) << LSHIFT) |
	asl		;	(*(rPtr+1) & (LSIZE-1));
	asl		;  long *lPairPtr = &lPair[index];

#if LSHIFT == 4
	asl		; shifting only leaves 4 bits
	sta zp0
	txa		; HI
	and #15		; take only 4 bits
	lsr		; shift 2 bits to LO part, because
	ror zp0		; array element is 4 bytes
	lsr
	ror zp0		; leaves 2 bits in HI part
#endif

#if LSHIFT == 5
	sta zp0		; shifting only leaves 5 bits
	txa
	and #31		; take only 5 bits
	lsr		; shift 1 bit to LO part
	ror zp0		; leaves 3 bits in HI part
#endif
	;clc		; C already clear, because zp0 is *8 (or *16)
	adc #>lPair
	sta zp1
	lda pos+0	;  unsigned short *tmp = &bSkip[p & (BLOCK_SIZE-1)];
	sta bTmp+0
	lda pos+1
	and #>(BLOCK_SIZE-1)
	asl bTmp+0
	rol
	;clc		; C already clear, because BLOCK_SIZE <= 32768
	adc #>bSkip
	sta bTmp+1

	;	    off = p - *lPairPtr;
	;	    if (off < (BLOCK_SIZE-MAX_MATCH)) {
	;		*tmp = off;
	;	    } else {
	;		*tmp = 0;
	;	    }
	ldy #0
	lda pos+0
	sec
	sbc (zp0),y
	sta off0$+1
	iny
	lda pos+1
	sbc (zp0),y
	sta off1$+1
	iny
	lda pos+2
	sbc (zp0),y
	sta off2$+1
	iny
	lda pos+3
	sbc (zp0),y
off2$	ora #0
	bne ptr0$	;16 top bits != 0

	lda off1$+1
	cmp #>(BLOCK_SIZE-MAX_MATCH)
	bcc ptr$	; HI byte <  --> ok!
	; HI byte >=
	;bne ptr0$	; HI byte >  --> not ok
	;todo: compare low byte -- but it doesn't matter much..

ptr0$	lda #0		; too far or not found
	sta off0$+1
	sta off1$+1

	; Update search structure pointers
ptr$	ldy #0
off0$	lda #0
	sta (bTmp),y	;  *tmp=..
	iny
off1$	lda #0
	sta (bTmp),y
	dey		;ldy #0
	lda pos+0
	sta (zp0),y	;  *lPairPtr = p;
	iny
	lda pos+1
	sta (zp0),y
	iny
	lda pos+2
	sta (zp0),y
	iny
	lda pos+3
	sta (zp0),y
#endif
	; Skip or perform search

	lda skip	;if (skip) {
	beq noskip$
	dec skip	;  skip--;
	jmp eskip$
			;} else {
noskip$	lda #1		;short maxlen = 1, maxpos = 0, j;
	sta maxlen
	lda #<(BLOCK_SIZE-MAX_MATCH)
	sta left+0	;int left = BLOCK_SIZE - MAX_MATCH;
	lda #>(BLOCK_SIZE-MAX_MATCH)
	sta left+1

#if 1
	ldy speed
	beq leftok$
ll$	lsr left+1
	ror left+0
	dey
	bne ll$
leftok$
#endif

	lda pos+0	;unsigned short im = p & (BLOCK_SIZE-1);
	sta im+0
	lda pos+1
	and #>(BLOCK_SIZE-1)
	sta im+1

	ldy #0
	lda (rPtr),y
	sta nChar

while$	lda im+0	;while ((j = bSkip[im])) {
	asl		; array element size 2
	sta zp0
	lda im+1
	rol
	;clc		; C already clear, because im < 32768
	adc #>bSkip
	sta zp1
#if MACH == 128
	sei
	ldy #1
	ldx #1		; RAM1
	lda #zp0
	jsr READBANK	; lda (ZP),y  bank in X, ZP in A
	sta j1$+1
	dey
	ldx #1		; RAM1
	lda #zp0
	jsr READBANK
	sta j0$+1
	cli
#else
	ldy #1
	lda (zp0),y
	sta j1$+1
	dey
	lda (zp0),y
	sta j0$+1
#endif
j1$	ora #0
	beq break$

	lda left+0
	sec
j0$	sbc #0
	sta left+0	;left -= j;
	lda left+1
	sbc j1$+1	;if (left < 0) {
	sta left+1	;    break;
	bmi break$	;}
			;im = (im - j) & (BLOCK_SIZE-1);
	lda im+0
	sec
	sbc j0$+1
	sta im+0
	sta ap$+1
	lda im+1
	sbc j1$+1
	and #>(BLOCK_SIZE-1)
	sta im+1	;ap = &buffer[im];
	clc
	adc #>buffer
	sta ap$+2

	ldy #0		;j = 0;
ap$	lda $aaaa,y	;while (*ap++ == rPtr[j] && ++j < MAX_MATCH)
	cmp (rPtr),y	;    ;
	bne out$
	iny
	bne ap$

	; All 256 bytes were equal,
	; but we currently handle only 8-bit MAX_MATCH i.e. 0..255
	ldy #MAX_MATCH

out$	cpy maxlen	;if (j > maxlen) {
	bcc while$	;    maxlen = j;
	beq while$	;    maxpos = (int)(&rPtr[j] - ap) & (BLOCK_SIZE-1);
new$	sty maxlen	;    if (maxlen == MAX_MATCH ||
	lda rPtr+0	;	*rPtr == *(rPtr+1)) {
	sec		;	break;
	sbc ap$+1	;    }
	sta maxpos+0
	lda rPtr+1
	sbc ap$+2
	and #>(BLOCK_SIZE-1)
	sta maxpos+1

	cpy #MAX_MATCH
	beq break$

	lda nChar
	ldy #1
	cmp (rPtr),y
	beq break$	; if seems like rle, got long enough..
			;}
	jmp while$
break$

#if MACH == 16 || MACH == 4
	sta $ff3e	; ROM
	cli
#endif
#if MACH == 64
	ldy #$36
	sty 1
	cli
#endif
	; Check if we accidentally compared off the end..
	lda buc
	cmp maxlen	;if (maxlen > bu) {
	bcs 0$
	sta maxlen	;    maxlen = bu;
0$			;}


	lda maxlen	;if (maxlen >= 3) {
	sec
	sbc #3
	bcs enough$
	jmp lit$

enough$
#if 1
	lda speed	; if (speed!=0) {
	beq lazylz$
	jsr PutLzNow	; PutLz(fpout, maxlen, maxpos);
	lda maxlen	; skip = maxlen-1;
	sec
	jmp cont0$	; oMaxlen = 0;
			; } else
#endif
lazylz$	lda oMaxlen
	sec		;if (oMaxlen >= maxlen) {
	sbc maxlen		;if (oMaxlen - maxlen >= 0) {
	bcc eelse$
	jsr PutLz	;    PutLz(fpout, oMaxlen, oMaxpos);
	lda oMaxlen
	clc
cont0$	sbc #1
	sta skip	;    skip = oMaxlen-2;
	lda #0
	sta oMaxlen	;    oMaxlen = 0; /* nothing in fifo */
	beq eend$
eelse$	lda oMaxlen	;} else {
	beq e2end$	;    if (oMaxlen)
	clc
	lda oChar
	jsr PutFixed	;	PutFixed(fpout, oChar);
e2end$	lda maxlen
	sta oMaxlen	;    oMaxlen = maxlen;
	lda maxpos+0
	sta oMaxpos+0
	lda maxpos+1
	sta oMaxpos+1	;    oMaxpos = maxpos;
eend$	jmp lend$	;}


lit$
#if 1
	lda speed	;} else {
	beq lazylit$	;if (speed!=0) {
	clc
	lda nChar	; PutFixed(fpout, nChar);
	jsr PutFixed
	jmp cont1$	; oMaxlen = 0;
			;} else
#endif
lazylit$
	lda oMaxlen
	sec
	sbc #3		;if (oMaxlen >= 3) {
	bcc lelse$
	jsr PutLz	;    PutLz(fpout, oMaxlen, oMaxpos);
	lda oMaxlen
	sec
	sbc #2
	sta skip	;    skip = oMaxlen-2;
cont1$	lda #0
	sta oMaxlen	;    oMaxlen = 0; /* nothing in fifo */
	beq lend$
lelse$	lda oMaxlen	;} else {
	beq lnolit$	;    if (oMaxlen)
	clc
	lda oChar
	jsr PutFixed	;	PutFixed(fpout, oChar);
lnolit$	lda #1
	sta oMaxlen	;    oMaxlen = 1;
lend$			;}
	lda nChar
	sta oChar	;    oChar = *rPtr;

eskip$			;}

#if MACH == 16 || MACH == 4
	sta $ff3e	; ROM
	cli
#endif
#if MACH == 64
	ldy #$36
	sty 1
	cli
#endif


	inc pos+0	;p++;
	bne pe$
	inc pos+1
	bne pe$
	inc pos+2
	bne pe$
	inc pos+3
pe$

#if 1		; progress indicator
	lda pos+0
	bne noprgupd$
#if MACH == 64 || MACH == 128
	lda pos+1
	and #31
	cmp #4
	bcs 123$
	jsr on		; block 0,1,2, 32,33,34, 64,65,66.. turn screen on
	jmp 124$
123$	;sec
	jsr off		; block 3, 35, 67, 99.. screen off / 2MHz
124$
#endif
	lda pos+2
	lsr
	lsr
	lsr
	lsr
	tay
	beq pi0$
	lda hex,y
	and #63
#if MACH == 64 || MACH == 128
	sta $0422
#endif
#if MACH == 20
	sta $1010
#endif
#if MACH == 16 || MACH == 4
	sta $0c22
#endif
pi0$	lda pos+2
	and #$0f
	tay
	lda hex,y
	and #63
#if MACH == 64 || MACH == 128
	sta $0423
#endif
#if MACH == 20
	sta $1011
#endif
#if MACH == 16 || MACH == 4
	sta $0c23
#endif
	lda pos+1
	lsr
	lsr
	lsr
	lsr
	tay
	lda hex,y
	and #63
#if MACH == 64 || MACH == 128
	sta $0424
#endif
#if MACH == 20
	sta $1012
#endif
#if MACH == 16 || MACH == 4
	sta $0c24
#endif
	lda pos+1
	and #$0f
	tay
	lda hex,y
	and #63
#if MACH == 64 || MACH == 128
	sta $0425
#endif
#if MACH == 20
	sta $1013
#endif
#if MACH == 16 || MACH == 4
	sta $0c25
#endif
noprgupd$
#endif



	inc rPtr+0	;rPtr++;
	bne re$
	ldx rPtr+1	;if (rPtr == &buffer[BLOCK_SIZE]) {
	inx
	cpx #>(buffer+BLOCK_SIZE)
	bne reh$
	ldx #>buffer
reh$	stx rPtr+1	;  rPtr = &buffer[0];
re$			;}


	dec buc		;bu--;
	bne bue$	;if (!bu && eof) {
	lda eof		;    break;
	bne break2$	;}
bue$	jmp dataloop$

break2$
#if 1
	lda speed	;if (speed!=0) {
	bne bend$	;} else
lazyflush$
#endif
	lda oMaxlen
	sec
	sbc #3		;if (oMaxlen >= 3) {
	bcc belse$
	jsr PutLz	;    PutLz(fpout, oMaxlen, oMaxpos);
	jmp bend$
belse$	lda oMaxlen	;} else if (oMaxlen)
	beq bend$
	clc
	lda oChar
	jsr PutFixed	;	PutFixed(fpout, oChar);
bend$			;}

	sec
	lda #0
	jsr PutFixed	;PutFixed(fpout, 256); /* EOF */

	; save uncompressed size
	lda pos+0
	sta usize+0
	lda pos+1
	sta usize+1
	lda pos+2
	sta usize+2
	lda pos+3
	sta usize+3
	jmp FlushBits	;FlushBits(fpout);

#if 1
PutLzNow
	; PutLz(maxlen, maxpos)
	lda maxlen
	sta oMaxlen
	lda maxpos+0
	sta oMaxpos+0
	lda maxpos+1
	sta oMaxpos+1
#endif
	; PutLz(oMaxlen, oMaxpos)
PutLz	lda oMaxlen
	sec
	sbc #3
	sta mx3$+1
	ldy #0		;  j = 0;
cpl$	cmp cplens_3,y	;  while (maxlen-3 >= cplens[j]-3)
	bcc cple$	;    j++;
	iny
	bne cpl$
cple$	tya
	dey		;  j--;
	sec
	jsr PutFixed	;  PutFixed(fpout, 256+j+1);
	ldx cplext,y	;  if (cplext[j]) {
	beq cps$
mx3$	lda #0		; 0 means 256, 1 means 257, 2 means 258
	sec
	sbc cplens_3,y	;    PutBits(fpout, cplext[j], (maxlen-3)-(cplens[j]-3));
	jsr PutBits	;  }
cps$	ldy #0		;  j = 0;
cpd$	lda oMaxpos+1	;  while (maxpos >= cpdist[j])
	cmp cpdistHi,y
	bcc cpde$
	bne cpdn$
	lda oMaxpos+0
	cmp cpdistLo,y
	bcc cpde$
cpdn$	iny		;    j++;
	bne cpd$
cpde$	dey		;  j--;
	tya
	ldx #5
	jsr PutBitsR	;  PutBitsR(fpout, 5, j);
	lda oMaxpos+0
	sec
	sbc cpdistLo,y
	sta zp0
	lda oMaxpos+1
	sbc cpdistHi,y
	sta zp1

	ldx cpdext,y	;  if (cpdext[j]) {
	beq onee$
	lda zp0	; load in advance
	cpx #9		;    if (cpdext[j] > 8) {
	bcc zerto8$
	ldx #8		;      PutBits(fpout, 8, maxpos-cpdist[j]);
	;lda zp0
	jsr PutBits
	lda cpdext,y
	sec
	sbc #8
	tax
	lda zp1
	;jmp PutBits	;      PutBits(fpout, cpdext[j]-8, (maxpos-cpdist[j])>>8);
	; jsr + rts

zerto8$	;lda zp0	;    } else {
	jmp PutBits	;      PutBits(fpout, cpdext[j], maxpos-cpdist[j]);
	; jsr + rts	;    }
onee$	rts		;  }

;==============================================================


Stored:
	jsr FlushBuffer	; save the header
	;-> next bytes will be at the start of the buffer

	lda #$80
	sta zipMode	; stored

real$	; put fake values -- FlushBuffer will fix them
	lda #0
	sta flushed
	jsr PutBuffer	; not last block, stored
	jsr PutBuffer
	jsr PutBuffer
	jsr PutBuffer
	jsr PutBuffer

again$	jsr GetByte
	ldy ST
	sty last
	pha
#if MACH == 16 || MACH == 4
	sei
	sta $ff3f	; RAM
#endif
#if MACH == 64
	sei
	ldy #$34
	sty 1
#endif
	jsr updcrc
#if MACH == 16 || MACH == 4
	sta $ff3e	; ROM
	cli
#endif
#if MACH == 64
	ldy #$36
	sty 1
	cli
#endif
	pla
	jsr PutBuffer

	; Update uncompressed length
	inc usize+0
	bne 2$
	inc usize+1
	bne 2$
	inc usize+2
	bne 2$
	inc usize+3
2$	bit last
	bvs leave$	; last block saved, time to leave
	lda flushed
	bne real$	; PutBuffer flushed -> must insert another header
	beq again$	; Not flushed, continue adding to output buffer..

leave$	jsr FlushBuffer
	lda #0
	sta zipMode
	rts


;--------------- Bit/byte input routines ---------------------

initbp	pha
	ldx #14
	jsr CHKOUT
	lda #"B"
	jsr CHROUT
	lda #"-"
	jsr CHROUT
	lda #"P"
	jsr CHROUT
	lda #" "
	jsr CHROUT
	pla
	jsr CHROUT
	lda #" "
	jsr CHROUT
	lda #"0"
	jsr CHROUT
	jmp CLRCHN


lastSector
	dc.b 0


sectorsPerTrack:
	dc.b 21,21,21,21,21,21,21,21	;1..8
	dc.b 21,21,21,21,21,21,21,21	;9..16
	dc.b 21,19,19,19,19,19,19,19	;17..24
	dc.b 18,18,18,18,18,18,17,17	;25..32
	dc.b 17,17,17			;33..35

GetByteD64
	ldx be
	beq fill$
	jmp read$

fill$	lda #0
	sta lastSector

#if MACH == 64 || MACH == 128
	lda inBurst
	beq std$

	lda #4
	sta retry$

again$	jsr BREAD
	lda status
	and #15
	cmp #2
	bcs chke$
	jmp bok$
chke$	cmp #11
	bne berr$
	; Disk changed -- the drive is confused
	ldx #14
	jsr BINQ
	dec retry$
	beq berr$
	jmp again$

retry$	dc.b 0
#endif

std$
#if MACH == 64 || MACH == 128
	clc		; screen off, but 1MHz
	jsr off
#endif
	ldx #14
	jsr CHKOUT
	lda #"U"
	jsr CHROUT
	lda #"1"
	jsr CHROUT
	lda #" "
	jsr CHROUT
	lda #"2"	; channel
	jsr CHROUT
	lda #" "
	jsr CHROUT
	lda #"0"	; unit
	jsr CHROUT

	lda inTrack	; track
	jsr putval
	lda inSector	; sector
	jsr putval
	jsr CLRCHN

	ldx #14
	jsr geterror	; waits until the read is finished..
	cmp #0
	beq noerr$
#if MACH == 64 || MACH == 128
	jsr on
#endif
	ldx #<errorStr
	lda #>errorStr
	ldy errorLen
	jsr putstr
noerr$
	ldx #2
	jsr CHKIN
	ldy #0
b2loop$	jsr CHRIN
	sta inBuf,y
#if MACH == 64 || MACH == 128
	sta $d020
#endif
#if MACH == 20
	and #7
	eor $900f
	sta $900f
#endif
#if MACH == 16 || MACH == 4
	sta $ff19
#endif
	iny
	bne b2loop$
	jsr CLRCHN
	lda #0
	sta ST
#if MACH == 64 || MACH == 128
	sec		; screen off, 2MHz
	jsr off
#endif
	jmp bok$

#if MACH == 64 || MACH == 128
berr$	jsr on
	ldx inTrack
	lda inSector
	jsr BERR
#endif

bok$	inc inSector	; advance to the next sector
	lda fdos
	cmp #"D"
	bne 1541$
	lda #80+1
	sta ltrack$+1	; 1581 has 80 tracks
	lda inSector
	cmp #40
	beq ntrack$	; next track for 1581
	bne chk$

1541$	lda #35+1	; one-sided has 35 tracks
	bit fflag
	bpl onesd$
	lda #2*35+1	; double-sided has 70 tracks
onesd$	sta ltrack$+1
	lda inTrack
	cmp #36
	bcc cmp$
	sbc #35
cmp$	tax
	lda inSector
	cmp sectorsPerTrack-1,x
	bcc sectok$
ntrack$	lda #0
	sta inSector
	inc inTrack
chk$	lda inTrack
ltrack$	cmp #35+1
	bne sectok$
	inc lastSector	; flag for EOF
sectok$
	ldx #0
	stx be

read$	inc be
	bne ok$
	lda lastSector
	beq ok$
	lda ST
	ora #$40
	sta ST
ok$	lda inBuf,x
	rts


GetByte	lda files
	cmp #255
	beq GetByteD64k$
  	ldx be
	beq fill0$

read$	inc be
	lda inBuf+0
	bne 1$
	cpx inBuf+1
	bne 1$
	lda #0
	sta be
	lda ST
	ora #$40
	sta ST
1$	lda inBuf,x
	rts

GetByteD64k$
	jmp GetByteD64

fill0$
#if MACH == 64 || MACH == 128
	lda inMode
	beq std$	; can't use burst read -> faster to do it sequentially
	lda inTrack
	beq eof$
	; can use burst and t&s known -> use burst read
	jsr BREAD
	lda status
	and #15
	cmp #2
	bcc bok$

	jsr on
	ldx inTrack
	lda inSector
	jsr BERR
	lda #0
	sta inBuf+0
	lda #255
	sta inBuf+1

bok$	lda inBuf+0	; copy links for next read
	sta inTrack
	lda inBuf+1
	sta inSector
eof$	ldx #2
	stx be
	bne read$
#endif

std$	ldx #2
	stx be
	stx inBuf+0	; Fake T&S
	stx inBuf+1

	lda #0
	sta ST

#if MACH == 64 || MACH == 128
	clc		; screen off, but 1MHz
	jsr off
#endif

	ldx #2
	jsr CHKIN

#if MACH == 64 || MACH == 128
	lda IDE64present
	bpl fill$	; IDE64 not found
	tya
	pha
	lda #IDE64BR
	ldx #254
	ldy #0
	jsr IDE64BlockRead
	pla
	tay
	bcs fill$	; Tried to read from a floppy...
	inx
	inx
	stx be
	bit ST
	bvc break$
	dex
	bvs IDE64notall$
#endif

fill$	jsr CHRIN
	ldx be
	sta inBuf,x
#if MACH == 64 || MACH == 128
	sta $d020
#endif
#if MACH == 20
	and #7
	eor $900f
	sta $900f
#endif
#if MACH == 16 || MACH == 4
	sta $ff19
#endif
	bit ST
	bvc 0$
	inc be

IDE64notall$
	lda #0
	sta ST
	sta inBuf+0	; EOF T
	stx inBuf+1	; index of last valid byte
	jmp break$
0$	inc be
	bne fill$

break$	jsr CLRCHN
#if MACH == 64 || MACH == 128
	sec		; screen off, 2MHz
	jsr off
#endif
	ldx #2
	stx be

	jmp read$


;--------------- Output/buffer routines ---------------------

updcrc:
	; updcrc()
	; (crc32_tab[((int)crc ^ cp) & 255] ^ (crc >> 8))
	sty y$+1
	eor CRC+0		; 3
	tay			; 2
	lda crc32_tab0,y	; 4
	eor CRC+1		; 3
	sta CRC+0		; 3
	lda crc32_tab1,y	; 4
	eor CRC+2		; 3
	sta CRC+1		; 3
	lda crc32_tab2,y	; 4
	eor CRC+3		; 3
	sta CRC+2		; 3
	lda crc32_tab3,y	; 4
	sta CRC+3		; 3	=42 cycles/byte = ~7.5 secs for 170.75kB
y$	ldy #0
	rts


; $80 0  $40 1  $20 2  $10 3  $08 4  $04 5  $02 6  $01 7

InitBits
	lda #$80
	sta bits
	rts

bits	dc.b $80

FlushBits
	ldx bits
	bpl 1$
	rts
1$	lsr byte
	lsr bits
	bne 1$
	;sec
	ror bits	; -> $80
	lda byte
	jmp PutBuffer

PutBits	cpx #0
	bne 1$
	rts
1$	lsr
	ror byte
	lsr bits
	bne 3$
	;sec
	ror bits	; -> $80
	pha
	lda byte
	jsr PutBuffer
	pla
3$	dex
	bne 1$
	rts


maskTab	dc.b 1,2,4,8,16,32,64,128
PutBitsR
	sta tmp
	dex
	bpl 0$
	rts
0$	lda maskTab,x
	bit tmp
	clc
	beq 1$
	sec
1$	ror byte
	lsr bits
	bne 3$
	;sec
	ror bits	; -> $80
	lda byte
	jsr PutBuffer
3$	dex
	bpl 0$
	rts

PutFixed	; C*256 + A
	bcc lt256$
	cmp #24
	bcs ge24$
	;256+ 0..23
	ldx #7
	jmp PutBitsR
ge24$	adc #167	;256+ 24..31
	ldx #8
	jmp PutBitsR
lt256$	cmp #144
	bcs ge144$
	adc #48
	ldx #8
	jmp PutBitsR
ge144$	pha
	ldx #1
	lda #1
	jsr PutBits
	pla
	ldx #8
	jmp PutBitsR


	; 70+12 cycles/byte (w/ CRC32)
PutBuffer
	sty puty+1	;4
	stx putx+1
	inc outSize+0	; (256*9+(256*8+(256*8+5)/256)/256)/256
	bne 0$		;  = 9.0314 cycles/byte
	inc outSize+1
	bne 0$
	inc outSize+2
	bne 0$
	inc outSize+3
0$

outCmd	sta $aaaa

	inc outCmd+1	;6
	bne 2$		;2/3
	inc outCmd+2
	lda outCmd+2
	cmp #>outend
	bne 2$
	; Save buffer data buffer32k .. (outCmd)
	jsr FlushBuffer
2$
puty	ldy #0	; restore Y value
putx	ldx #0
	rts



FlushBuffer	; Can trash A & Y, X
#if MACH == 64 || MACH == 128
	clc		; screen off, but 1MHz
	jsr off
#endif

	lda zipMode
	beq std$
	; if Stored, fix the block size, its complement etc.

	lda obufhi	; fix the HI parts
	sta bu0$+2
	sta bu1$+2
	sta bu2$+2
	sta bu3$+2
	sta bu4$+2
	bit last
	bvc 5$
bu0$	inc $2000+0	; 0 -> 1 == last block, stored
5$	lda outCmd+1
	sec
	sbc #5
bu1$	sta $2000+1	; size LO
	eor #255
bu2$	sta $2000+3
	lda outCmd+2
	sbc obufhi
bu3$	sta $2000+2	; size HI
	eor #255
bu4$	sta $2000+4

std$	ldx #3
	jsr CHKOUT	; (sends LISTEN+SECOND)

	lda #0
	sta bTmp+0
	lda obufhi
	sta bTmp+1

1$
#if MACH == 64 || MACH == 128
	lda IDE64present
	bpl noIDE64here$	; IDE64 not found
	lda outCmd+1
	sec
	sbc bTmp+0
	tax
	lda outCmd+2
	sbc bTmp+1
	tay
	lda #bTmp
	jsr IDE64BlockWrite
	bcc IDE64writeback$	;Tried to write to a floppy...
noIDE64here$
#endif
	lda bTmp+0
	cmp outCmd+1
	bne 0$
	lda bTmp+1
	cmp outCmd+2
	bne 0$

IDE64writeback$
	jsr CLRCHN
	jsr InitBuffer32k
	inc flushed
	rts

0$	ldy #0
	lda (bTmp),y
#if MACH == 64 || MACH == 128
	sta $d020
	jsr CHROUT
#endif
#if MACH == 20
	pha
	jsr CHROUT
	pla
	and #7
	eor $900f
	sta $900f
#endif
#if MACH == 16 || MACH == 4
	sta $ff19
	jsr CHROUT
#endif
	inc bTmp+0
	bne 1$
	inc bTmp+1
	jmp 1$

InitBuffer32k
	; Init buffer pointer
	lda #0
	sta outCmd+1
	lda obufhi
	sta outCmd+2
	rts

flushed	dc.b 0


;--------------- Misc utility routines ---------------------
	;      0   1   2   3   4   5   6   7   8   9     10  11  12   13  14   15  16  17
dec0	dc.b $00,$00,$80,$40,$a0,$10,$e8,$64,$0a,$01,	$00,$00,$00, $99,$5c, $89,$8d,$a7
dec1	dc.b $ca,$e1,$96,$42,$86,$27,$03,$00,$00,$00,	$00,$00,$00, $99,$8f, $41,$06,$00
dec2	dc.b $9a,$f5,$98,$0f,$01,$00,$00,$00,$00,$00,	$00,$00,$00, $19,$02, $00,$00,$00
dec3	dc.b $3b,$05,$00,$00,$00,$00,$00,$00,$00,$00,	$64,$0a,$01, $00,$00, $00,$00,$00
decv	dc.b 0,0,0,0
decs	dc.b 0
decout	dc.b 0

putpct	sta decbyt+1
	lda #10
	sta decstrt+1
	lda #18
	jmp putdec2

putdec	sta decbyt+1
	lda #0
	sta decstrt+1
	lda #10

putdec2	sta decend+1
	stx bTmp+0
	sty bTmp+1
	lda #0
	sta decs
	sta decout
	sta decv+1
	sta decv+2
	sta decv+3

decbyt	ldy #4
	dey
0$	lda (bTmp),y
	sta decv,y
	dey
	bpl 0$

decstrt	ldy #0
decend
for$	cpy #10
	bne 2$
	lda decout
	rts
2$	ldx #0
while$	lda decv+3
	cmp dec3,y
	bcc breakw$	; a < dec
	bne ge$		; a > dec
	lda decv+2
	cmp dec2,y
	bcc breakw$	; a < dec
	bne ge$		; a > dec
	lda decv+1
	cmp dec1,y
	bcc breakw$	; a < dec
	bne ge$		; a > dec
	lda decv+0
	cmp dec0,y
	bcc breakw$	; a < dec
ge$	inx		; a >= dec
	sec
	lda decv+0
	sbc dec0,y
	sta decv+0
	lda decv+1
	sbc dec1,y
	sta decv+1
	lda decv+2
	sbc dec2,y
	sta decv+2
	lda decv+3
	sbc dec3,y
	sta decv+3
	jmp while$
breakw$
	cpy #9
	beq put$
	txa
	ora decs
	beq noput$
put$	txa
	ora #"0"
	jsr CHROUT
	inc decout
	inc decs
noput$	cpy #14		; 12 for decimal, 14 for %
	bne 1$
	lda #"."
	jsr CHROUT
	inc decout
	inc decs
1$	iny
	jmp for$

ratioa	dc.b 0,0,0,0
ratiob	dc.b 0,0,0,0
ratiov	dc.b 0,0,0,0
ratiosh	dc.b 0

putratio
	ldy #3
0$	lda csize,y
	sta ratioa,y
	lda usize,y
	sta ratiob,y
	lda #0
	sta ratiov,y
	dey
	bpl 0$
	;lda #0
	sta ratiosh
while0$			; scale divider
	ldy #3
1$	lda ratiob,y
	cmp ratioa,y
	bcc lt$
	bne breakw$
	dey
	bpl 1$
	jmp breakw$	; b==a
lt$	; b < a
	asl ratiob+0
	rol ratiob+1
	rol ratiob+2
	rol ratiob+3
	inc ratiosh
	jmp while0$
breakw$
	ldx #0
for$	ldy #3
2$	lda ratioa,y
	cmp ratiob,y
	bcc break2$
	bne ge$
	dey
	bpl 2$
ge$	; a >= b
	sec
	lda ratioa+0
	sbc ratiob+0
	sta ratioa+0
	lda ratioa+1
	sbc ratiob+1
	sta ratioa+1
	lda ratioa+2
	sbc ratiob+2
	sta ratioa+2
	lda ratioa+3
	sbc ratiob+3
	sta ratioa+3
	sec
break2$
	rol ratiov+0
	rol ratiov+1
	rol ratiov+2
	rol ratiov+3

	asl ratioa+0
	rol ratioa+1
	rol ratioa+2
	rol ratioa+3
	inx
	cpx #25		; 25-bit result
	bne for$

5$	dec ratiosh
	bmi 4$
	asl ratiov+0
	rol ratiov+1
	rol ratiov+2
	rol ratiov+3
	jmp 5$
4$
	ldx #<ratiov
	ldy #>ratiov
	lda #4
	jmp putpct

puthex	pha
	lsr
	lsr
	lsr
	lsr		; 0..9 -> $30..$39, A..F -> $41..$46
	tay
	lda hex,y
	jsr CHROUT
	pla
	and #15
	tay
	lda hex,y
	jmp CHROUT
hex	dc.b "0123456789ABCDEF"


#if MACH == 64 || MACH == 128
on
#if MACH == 64
	lda $d011
	ora #$10
	sta $d011
	lda #0		; 1 MHz
	sta $d030
#else
	lda $d7		; 40/80 columns
	bne off		; 80 columns -> turn it off
	sta $d030	; 1 MHz
	lda $d011
	ora #$10	; blank off
	sta $d011
#endif
	rts

#if MACH == 64
	; NOTE: standard slow serial does not work with 2MHz in C64 mode
onemeg	lda #0		; 1MHz
	sta $d030
#endif

off	lda $d011
	and #$ef
	sta $d011
#if MACH == 64
	; NOTE: standard slow serial does not work with 2MHz in C64 mode
	lda #0
	rol		; clc = 1MHz, sec = 2 MHz
	sta $d030
#else
	; NOTE: standard slow serial does work with 2MHz in C128 mode
	lda #1
	sta $d030
#endif
	rts
#endif

putstr	stx 0$+1
	sta 0$+2
	sty 1$+1
	jsr CLRCHN
	ldy #0
0$	lda $aaaa,y
	jsr CHROUT
	iny
1$	cpy #0
	bne 0$
	rts



getstr	sta 0$+1	; <buffer
	sta 2$+1
	stx 0$+2	; >buffer
	stx 2$+2
	sty 1$+1	; max len+1
	jsr CLRCHN
	ldy #0
0$	lda $aaaa,y
	beq edit$
	jsr CHROUT
	iny
	bne 0$

edit$	sty 3$+1
	jsr getkey
3$	ldy #0
	bcs edit$
	cmp #13		; return
	beq quit$
	cmp #157	; cursor left
	beq bs$
	cmp #20		; backspace
	bne no8$
bs$	cpy #0
	beq edit$
	jsr CHROUT	; <- destructive bs?
	dey
	jmp edit$
no8$	cmp #" "
	bcc edit$	; 0..31
1$	cpy #0
	beq edit$	; no more room
2$	sta $aaaa,y
	jsr CHROUT
	iny
	jmp edit$
quit$	rts


getkey	jsr CLRCHN
	jsr GETIN
	clc
	bne ok$
	sec
ok$	rts


geterror:	; read the disk error channel - channel in X
#if MACH == 16 || MACH == 4
	ldy #30
11$	dey
	bpl 11$
#endif
	jsr CHKIN
#if MACH == 16 || MACH == 4
	ldy #30
12$	dey
	bpl 12$
#endif
	jsr CHRIN	; read the first digit
	sta errorStr+0
	and #15
	tax		; and store it
	jsr CHRIN	; read the second digit
	sta errorStr+1
	and #15
	clc
	adc tentimes,x
	sta errorCode
	pha
	;beq skip$	; no error -> do not read the rest
	ldy #2
2$	jsr CHRIN
	sta errorStr,y
	iny
	cmp #13		; IDE64 does not set ST at the end of the error string
	beq 3$
	lda ST		; READST
	beq 2$
3$	sty errorLen
skip$	jsr CLRCHN	; clear the channel
	pla
	rts		; return (error code in accumulator)


oPages	dc.b 0

putval	pha		; 0..99 decimal
	lda #" "
	jsr CHROUT
	pla

	ldx #0
1$	cmp #10
	bcc 0$
	inx
	sec
	sbc #10
	jmp 1$
0$	cpx #0
	beq 2$		; turn off leading zero
	pha
	txa
	clc
	adc #"0"
	jsr CHROUT
	pla
2$	clc
	adc #"0"
	jmp CHROUT


#if MACH != 128
prns	jsr CLRCHN
	pla
	sta addr$+1
	pla
	sta addr$+2
loop$	inc addr$+1
	bne addr$
	inc addr$+2
addr$	lda $aaaa
	beq out$
	jsr CHROUT
	jmp loop$
out$	lda addr$+2
	pha
	lda addr$+1
	pha
	rts
#endif




;--------------- Directory scan/list routine ---------------------

dir	dc.b "$0:*"
fname	ds.b 17
fnameln	dc.b 0
ftype	dc.b 0
ftrack	dc.b 0
fsector	dc.b 0
fblocks	dc.b 0,0
ftypstr	dc.b "SEQ PRG USR REL CBM ?6? ?7? "
fcount	dc.b 0
fdos	dc.b 0
fflag	dc.b 0	; Double-sided flag
fdtype	dc.b 0
diskName
	ds.b 23



ReadDir	lda #0
	sta fcount
	sta fdtype
#if MACH == 64 || MACH == 128
	jsr prns
	dc.b 13
	dc.b 18,"D",146," DISK IMAGE COMPRESSION (D64/D71/D81)",13
	dc.b 18,"N",146," DO NOT ARCHIVE THIS FILE",13
	dc.b 18,"Y",146," ARCHIVE WITH MAXIMUM COMPRESSION",13
	dc.b 18,"1",146,"-",18,"3",146," ARCHIVE WITH FASTER COMPRESSION",13
	dc.b 18,"S",146," ARCHIVE STORED (NO COMPRESSION)",13
	dc.b 18,"Q",146," QUIT MENU AND BEGIN CREATING ARCHIVE",13
	dc.b 13, 0
#endif
	; Open directory
	ldx #<dir
	ldy #>dir
	lda #4
	jsr SETNAM

	; We can't use "I0" because of IDE64
	; We have this hack instead.
	lda #2		; first a dummy open
	ldx inDrive
	ldy #0		; open 2,8,0,"$0:*"
	jsr SETLFS
	jsr OPEN
	lda #2
	jsr CLOSE

	lda #2		; first try raw directory
	ldx inDrive
	ldy #2		; open 2,8,2,"$0:*"
	jsr SETLFS
	jsr OPEN

	ldx #14
	jsr geterror
	cmp #0
	beq 2$

	ldx #<errorStr
	lda #>errorStr
	ldy errorLen
	jsr putstr

	lda #2
	jsr CLOSE

	lda #2		; could not open raw, try normal directory
	ldx inDrive
	ldy #0		; open 2,8,0,"$0:*"
	jsr SETLFS
	jsr OPEN

	inc fdtype

	lda ST
	beq 2$

quit0$	lda #2
	jsr CLOSE
	jsr CLRCHN

	ldx #14
	jsr geterror
	ldx #<errorStr
	lda #>errorStr
	ldy errorLen
	jmp putstr

2$	ldx #2		; disk name: 142..164 165..168 unused
	jsr CHKIN
	jsr CHRIN	; get disk format "A" for 1541/51/71/4040 or "D" for 1581
	sta fdos	; "C" for 8050
	lda ST
	bne quit0$
	jsr CHRIN	; get double-sided flag for "A"
	sta fflag
	cmp #$04
	bne notide$
	lda fdos
	cmp #$01
	bne notide$
	; probably IDE64 or some other device that does not support
	; raw directories
	inc fdtype

	ldy #6
is0$	jsr CHRIN
	cmp #34
	beq is01$
	dey
	bne is0$	; skip line link, line number, reverse + "
is01$

	ldy #0
is1$	jsr CHRIN	; get disk name, disk ID and dos/disk version
	sta diskName,y
	cmp #0
	beq gotdisk$
	iny
	cpy #23
	bne is1$
is2$	jsr CHRIN	; get 0
	cmp #0
	bne is2$
	jmp gotdisk$


notide$	lda fdos
	cmp #"D"
	beq 1581$	; no skip for 1581 & CMD Ramlink & CMD HD
	cmp #"H"
	beq 1581$
	ldy #2		; skip 2 bytes for 8050
	cmp #"C"
	beq skip0$
	ldy #140	; skip 140 bytes for 1541

skip0$	jsr CHRIN
	dey
	bne skip0$	; skip disk info

1581$	ldy #0
dname$	jsr CHRIN	; get disk name, disk ID and dos/disk version
	sta diskName,y
	iny
	cpy #23
	bne dname$

	lda fdos
	cmp #"C"
	bne nskp2$
	ldy #253	; skip 735-229=506=253*2 bytes for 8050
skip2$	jsr CHRIN
	jsr CHRIN
	dey
	bne skip2$
	; TODO: skip extra 2*254 bytes for double-sided 8050 disks

nskp2$	ldy #229	; skip 229 bytes for 1581 and 8050, CMD Ramlink & HD
	lda fdos
	cmp #"A"
	bne skip1$
	ldy #89		; skip 89 bytes for 1541
skip1$	jsr CHRIN
	dey
	bne skip1$	; skip disk info

gotdisk$		; display the disk name
	jsr CLRCHN

	lda #18
	jsr CHROUT
	lda #34
	jsr CHROUT
	ldy #0
dname2$	lda diskName,y
	cpy #16
	bne yes$
	lda #34
yes$	jsr CHROUT
	iny
	cpy #23
	bne dname2$
	jsr prns
	dc.b 146,13,0


dirloop$
	ldx #2
	jsr CHKIN

	lda fdtype
	bne ide2$
	jmp noide2$

ide2$	jsr CHRIN	; skip line link
	jsr CHRIN

	jsr CHRIN
	sta fblocks+0
	lda ST
	bne ret$
	jsr CHRIN
	sta fblocks+1

is3$	jsr CHRIN
	tax
	beq ret$	; xx BLOCKS FREE.	-- zero before quote
	lda ST
	bne ret$
	cpx #34
	bne is3$

	ldy #0
is4$	jsr CHRIN	; name
	cmp #34
	beq is5$
	sta fname,y
	iny
	cpy #17
	bne is4$
	dey
is5$	lda #0
	sta fname,y
	sty fnameln

is6$	jsr CHRIN
	iny
	cpy #18
	bne is6$

	ldx #$81
	cmp #"S"	; "SEQ"
	beq is7$
	inx
	cmp #"P"	; "PRG"
	beq is7$
	inx
	cmp #"U"	; "USR"
	beq is7$
	inx
	cmp #"R"	; "REL"
	beq is7$
	inx
	cmp #"C"	; "CBM"
	beq is7$
	cmp #"D"	; "DIR" (IDE64)
	beq is7$
	ldx #$80	; "DEL"
is7$
	stx ftype

is8$	jsr CHRIN
	ldx ST
	bne ret$
	cmp #0
	bne is8$
	sta ftrack
	sta fsector
	jmp noskip$

ret$	lda #2
	jsr CLOSE
	jmp CLRCHN	; jsr + rts


noide2$	jsr CHRIN	; file type	0
	sta ftype
	lda ST
	and #$c0
	bne ret$

	jsr CHRIN	; track		1
	sta ftrack
	jsr CHRIN	; sector	2
	sta fsector
	ldy #0		; 16
nameloop$
	jsr CHRIN	; name		3-18 (0-15)
	cmp #$a0
	beq nameend$
	sta fname,y
	iny
	cpy #16
	bne nameloop$
	lda #0
	sta fname,y
	sty fnameln
	jmp other$
nameend$
	lda #0
	sta fname,y
	sty fnameln
	iny
other$	jsr CHRIN	; skip the rest of the filename & other fields
	iny
	cpy #25		; 19-27 (16-24)
	bne other$
	jsr CHRIN	; blocks lo	28
	sta fblocks+0
	jsr CHRIN	; blocks hi	29
	sta fblocks+1

	inc fcount
	lda fcount
	and #7
	beq noskip$
	jsr CHRIN	; 'link'	30
	jsr CHRIN	; 'link'	31

noskip$
	jsr CLRCHN
	lda ftype
	and #7
	bne notdel$
	jmp dirloop$	; skip DELeted files

notdel$
	ldx #<fblocks
	ldy #>fblocks
	lda #2
	jsr putdec
	tay
0$	cpy #4
	bcs 1$
	lda #" "
	jsr CHROUT
	iny
	jmp 0$

1$	ldx #" "
	lda ftype
	bmi closed$
	ldx #"*"
closed$
	txa
	jsr CHROUT

	lda ftype
	and #7
	asl
	asl	; *4
	clc
	adc #<(ftypstr-4)
	tax
	lda #>(ftypstr-4)
	adc #0
	ldy #3
	jsr putstr

	lda #"<"
	bit ftype
	bvs locked$
	lda #" "
locked$
	jsr CHROUT

	lda #34
	jsr CHROUT
	ldx #<fname
	lda #>fname
	ldy fnameln
	jsr putstr
	lda #34
	jsr CHROUT
	ldy fnameln
tasaa$	lda #" "
	jsr CHROUT
	iny
	cpy #17
	bne tasaa$

	jsr prns
	dc.b 18,"Y",146," ",18,"S",146," ",18,"D",146," ",18,"N",146," ",18,"Q",146,"?", 0

ack$	jsr getkey
	bcs ack$
	cmp #"Y"
	beq this$
	cmp #"0"
	beq this$
	cmp #"1"
	beq this$
	cmp #"2"
	beq this$
	cmp #"3"
	beq this$
	cmp #"S"
	beq this$
	cmp #3
	beq quit$
	cmp #"Q"
	beq quit$
	cmp #"D"
	beq d64$
	cmp #"N"
	bne ack$

#if MACH != 128
	ldy #37
lnoff$	lda #20		; backspace
	jsr CHROUT
	dey
	bpl lnoff$
#else
	ldy #37
lnoff$	lda #157	; <--
	jsr CHROUT
	lda #32		; space
	jsr CHROUT
	lda #157	; <--
	jsr CHROUT
	dey
	bpl lnoff$
#endif
	jmp dirloop$

d64$	lda fdos
	cmp #"A"	; 1541/1571 disk
	beq dok$
	cmp #"D"	; 1851 disk
	beq dok$
	jmp ack$	; not a disk format we support!

dok$	lda #255
	sta files
quit$	lda #2
	jsr CLOSE
	jsr CLRCHN
	jmp CR

this$	sta tmp
	jsr OK_KEY
	lda #0
	ldy #CASIZE-1
clr$	sta (CAPtr),y	; clear
	dey
	bpl clr$

	ldy #0
cp$	lda fname,y
	sta (CAPtr),y
	iny
	cpy fnameln
	bne cp$
	lda ftype
	and #7
	cmp #2
	beq typok$	; If not PRG, append ",S" ",U" ",R"
	lda #","
	sta (CAPtr),y
	iny
	lda ftype
	and #7
	asl
	asl
	tax
	lda ftypstr-4,x
	sta (CAPtr),y
	iny

typok$	tya
	ldy #CA_FLen
	sta (CAPtr),y	; name lenght
	ldy #CA_TS
	lda ftrack
	sta (CAPtr),y	; start track
	iny
	lda fsector
	sta (CAPtr),y	; start sector
	lda tmp
	ldy #CA_Mode
	sta (CAPtr),y	; compress mode

	inc files
	lda CAPtr+0
	clc
	adc #CASIZE
	sta CAPtr+0
	bcc noc$
	inc CAPtr+1
noc$	lda files
	cmp #MAXFILES
	beq toomany$
	jmp dirloop$
toomany$
	lda #2
	jsr CLOSE
	jsr CLRCHN
	jsr prns
	dc.b "MAXIMUM NUMBER OF FILES REACHED",13,0
	rts


askdrive:
	sta chan$+1
	jsr prns
	dc.b " DRIVE? ",18,"8",146,"-",18,"9",146,",1",18,"0",146,"-1",18,"7",146, 0

ask$	jsr getkey
	bcs ask$
	cmp #3
	bne notc$
	jsr CR
	sec
	bcs brk$
notc$	cmp #"0"
	bcc ask$	; smaller than "0"
	cmp #":"
	bcs ask$	; ":" or greater
	sec
	sbc #"0"
	cmp #8
	bcs ook$
	;clc
	adc #10	; 0..7 becomes 10..17, 8..9 stays 8..9
ook$	sta drive$+1

	jsr putval
	jsr CR

	lda #0
	jsr SETNAM
chan$	lda #15
drive$	ldx #8
	ldy #15		; open chan,drive,15
	jsr SETLFS
	jsr OPEN

	lda chan$+1
	jsr CLOSE
	lda ST		; READST
	bne nok$
	jsr OPEN	; reopen
	clc
	lda drive$+1
	rts
nok$	clc
brk$	lda #0
	rts


OK_KEY	jsr CHROUT
CR	lda #13
	jmp CHROUT


d64mode	dc.b 0		; 0 = file, 4 = D64, 7 = D71, 8 = D81, $84 = one drive
d64chan	dc.b "#"

inDrive	dc.b 8
#if !(MACH == 64 || MACH == 128)
be	dc.b 0	; buffer index
#endif



cplens_3	; Copy lengths for literal codes 257..285 - 3
	dc.b   3-3,   4-3,   5-3,   6-3,   7-3,   8-3,   9-3,  10-3
	dc.b  11-3,  13-3,  15-3,  17-3,  19-3,  23-3,  27-3,  31-3
	dc.b  35-3,  43-3,  51-3,  59-3,  67-3,  83-3,  99-3, 115-3
	dc.b 131-3, 163-3, 195-3, 227-3, 258-3	;,   0,   0

cpdistLo	; Copy offsets for distance codes 0..29
	dc.b $01, $02, $03, $04, $05, $07, $09, $0d
	dc.b $11, $19, $21, $31, $41, $61, $81, $c1
	dc.b $01, $81, $01, $01, $01, $01, $01, $01
	dc.b $01, $01, $01, $01, $01, $01, $ff

cpdistHi	; Copy offsets for distance codes 0..29
	dc.b $00, $00, $00, $00, $00, $00, $00, $00
	dc.b $00, $00, $00, $00, $00, $00, $00, $00
	dc.b $01, $01, $02, $03, $04, $06, $08, $0c
	dc.b $10, $18, $20, $30, $40, $60, $ff

cplext	; Extra bits for literal codes 257..285
	dc.b 0, 0, 0, 0, 0, 0, 0, 0
	dc.b 1, 1, 1, 1, 2, 2, 2, 2
	dc.b 3, 3, 3, 3, 4, 4, 4, 4
	dc.b 5, 5, 5, 5, 0	;, 99, 99

cpdext	; Extra bits for distance codes
	dc.b  0,  0,  0,  0,  1,  1,  2,  2
	dc.b  3,  3,  4,  4,  5,  5,  6,  6
	dc.b  7,  7,  8,  8,  9,  9, 10, 10
	dc.b 11, 11, 12, 12, 13, 13


;============================================================================
; Start of work space - variables

tentimes:
	dc.b 0,10,20,30,40,50,60,70,80,90



#if MACH == 64 || MACH == 128
BREAD	sty y$+1
	ldx #$c0	; 1581 BURST: LEXS000N	L=logical t&s
	lda fdos
	cmp #"D"
	beq 2$
	; Other than 1581-format disks
	ldx #$40	; 1571 BURST: TEBS000N	T=no transfer
2$	stx cmdline+2
	;stx $0400

	LDA inTrack
	STA cmdline+3
	LDA inSector
	STA cmdline+4
	LDA #1
	STA cmdline+5

	LDA #$06
	STA cmdlen
	ldx #14
	JSR sendcmd

	SEI
	BIT D1ICR
	LDA D2PRA
	EOR #$10
	STA D2PRA

1$	LDA #8
wait0$	BIT D1ICR
	BEQ wait0$
	LDA D1SDR
	STA status

	and #15
	cmp #11		; disk changed -> no data
	beq 4$

	LDA D2PRA
	EOR #$10
	STA D2PRA

	ldy #0
3$	LDA #8
wait1$	BIT D1ICR
	BEQ wait1$

	LDA D2PRA
	EOR #$10
	STA D2PRA

	LDA D1SDR
	sta inBuf,y
#if MACH == 64 || MACH == 128
	sta $d020
#endif
#if MACH == 20
	and #7
	eor $900f
	sta $900f
#endif
	INY
	BNE 3$

4$	CLI
y$	ldy #0
	RTS


	; the channel number must be in X
BINQ	LDA #$04
	STA cmdline+2
	LDA #3
	STA cmdlen
	JSR sendcmd

	SEI
	BIT D1ICR

	LDA D2PRA
	EOR #$10
	STA D2PRA

	LDA #8
wait1$	BIT D1ICR
	BEQ wait1$

	LDA D1SDR
	STA status
        CLI
	RTS


cmdline
	dc.b "U0", $80, 1, 1, 1, 1, 1, 1
cmdlen
	dc.b 0
oldclk
	dc.b 0
status
	dc.b 0

sendcmd
	JSR CHKOUT
	LDX #0
	LDY cmdlen
1$	LDA cmdline,x
	JSR CHROUT
	INX
	DEY
	BNE 1$
	jmp CLRCHN


BERR	pha
	txa
	pha
	lda #"E"
	jsr CHROUT
	lda status
	jsr puthex
	lda #","
	jsr CHROUT

	lda status
	and #15
	tay
	lda ePtrLo,y
	sta str$+1
	lda ePtrHi,y
	sta str$+2
	ldy #0
str$	lda $aaaa,y
	beq end$
	jsr CHROUT
	iny
	bne str$
end$
	lda #","
	jsr CHROUT
#if 1
	pla
	sta tmp
	ldx #<tmp
	ldy #>tmp
	lda #1
	jsr putdec
#else
	lda #"T"
	jsr CHROUT
	pla
	jsr puthex
#endif
	lda #","
	jsr CHROUT
#if 1
	pla
	sta tmp
	ldx #<tmp
	ldy #>tmp
	lda #1
	jsr putdec
#else
	lda #"S"
	jsr CHROUT
	pla
	jsr puthex
#endif
	lda #13
	jmp CHROUT

e0	dc.b "OK",0
e1	dc.b "SELECTED PARTITION",0
e2	dc.b "NO SECTOR",0
e3	dc.b "NO SYNC",0
e4	dc.b "NO DATA BLOCK",0
e5	dc.b "DATA CRC ERROR",0
e6	dc.b "FORMAT ERROR",0
e7	dc.b "VERIFY ERROR",0
e8	dc.b "WRITE PROTECT",0
e9	dc.b "HEADER CRC ERROR",0
e10	dc.b "DATA EXTENDS INTO NEXT BLOCK",0
e11	dc.b "DISK CHANGED",0
e12	dc.b "DISK FORMAT NOT LOGICAL",0
e13	dc.b "DISK CONTROLLER IC ERROR",0
e14	dc.b "SYNTAX ERROR",0
e15	dc.b "NO DISK",0

ePtrLo	dc.b <e0,<e1,<e2,<e3,<e4,<e5,<e6,<e7,<e8,<e9,<e10,<e11,<e12,<e13,<e14,<e15
ePtrHi	dc.b >e0,>e1,>e2,>e3,>e4,>e5,>e6,>e7,>e8,>e9,>e10,>e11,>e12,>e13,>e14,>e15
#endif



lhdr	dc.b $50,$4b,$03,$04, $14,$00,$08,$00, $08,$00
	dc.b $9f,$05,$00,$00, $00,$00,$00,$00
	dc.b $00,$00,$00,$00, $00,$00,$00,$00
ghdr	dc.b $50,$4b,$01,$02, $14,$00,$14,$00
	dc.b $00,$00,$08,$00, $e0,$14,$69,$2d		; 9.11.2002 02:39
ehdr	dc.b $50,$4b,$05,$06, $00,$00,$00,$00

inTrack		dc.b 0
inSector	dc.b 0
inMode		dc.b 0
#if MACH != 20
inBurst		dc.b 0
#endif
#if MACH == 64 || MACH == 128
IDE64present:
	dc.b 0
#endif

zipMode		dc.b 0	; 0 == normal, $80 == stored
zipDrive	dc.b 8
zipFile		ds.b 30
zipLen		dc.b 0
zipComment	ds.b 36
zipCommentLen	dc.b 0

errorCode	dc.b 0
errorLen	dc.b 0
errorStr	ds.b 64

usize		dc.b 0,0,0,0
csize		dc.b 0,0,0,0
cstart		dc.b 0,0,0,0
outSize		dc.b 0,0,0,0
curlen		dc.b 0
last		dc.b 0

im		dc.b 0,0
left		dc.b 0,0
buc		dc.b 0
loops		dc.b 0
eof		dc.b 0
skip		dc.b 0
maxlen		dc.b 0
maxpos		dc.b 0,0

oMaxlen		dc.b 0
oMaxpos		dc.b 0,0
oChar		dc.b 0
nChar		dc.b 0
speed		dc.b 0

#if MACH == 64 || MACH == 128
CheckIDE64:
	ldy #2
	lda $DF09	; check for Action Replay!
	cmp #$78	; SEI
	beq 1$		; could be AR, must not read $DExx!
0$	lda $DE60,y
	cmp IDEID,y
	bne 1$
	dey
	bpl 0$
	lda #<(inBuf+2)
	sta IDE64BR
	lda #>(inBuf+2)
	sta IDE64BR+1
1$	sty IDE64present	; negative means IDE64 present
	rts

IDEID	dc.b "IDE"

CheckBurst:
	lda #0
	sta inBurst
	sta FASTSER

	lda inDrive
#if MACH == 64
	jsr myLISTEN
	lda #$6f
	jsr mySECOND
	lda #"U"
	jsr myCIOUT
	lda #"I"
	jsr myCIOUT
	lda #"+"
	jsr myCIOUT
	jsr myUNLSN
#else
	jsr LISTEN
	lda #$6f
	jsr SECOND
	lda #"U"
	jsr CIOUT
	lda #"I"
	jsr CIOUT
	lda #"+"
	jsr CIOUT
	jsr UNLSN
#endif
	bit FASTSER
	bvc nob$
	inc inBurst
	;ldx #14		; 1570/1571 seems to need this w/ C64+burst
	;jsr BINQ
	;lda status
	;jsr puthex
	;jsr CR
nob$	rts


#if MACH == 64
myLISTEN
	ora #$20
	pha
	bit $94			; C3PO - buffered char flag
	bpl 0$
	sec
	ror $a3			; set no-ATN flag
	jsr myPB		; send buffered char
	lsr $94			; clear buffered char flag
	lsr $a3			; clear no-ATN flag
0$	pla
	sta $95			; set buffered character
	sei
	jsr ee97		; DOUT lo, release DATA
#if 0
	cmp #$3f
	bne 1$
	jsr ee85		; CLKOUT lo, release CLK
#else
	lda D2PRA
	and #$08
	bne 1$
	jsr SPOUT		; SPOUT
	lda #$ff
	sta D1SDR
	jsr WAITSPIN		; waitSP+SPIN
	txa
	ldx #20
2$	dex
	bne 2$
	tax
#endif
1$	lda D2PRA
	ora #$08
	sta D2PRA		; ATNOUT hi, ATN low

myDEL	sei
	lda D2PRA		; CLKOUT hi, CLK low
	ora #$10
	sta D2PRA
	jsr ee97		; DOUT lo, release DATA
	txa			; DELAY937 delay for 937 cycles
	ldx #$b8
0$	dex
	bne 0$
	tax

myPB	sei
	jsr ee97		; DOUT lo, release DATA
	jsr eea9		; wait settle, DATA->C
	bcs edad		; device not present
	bit D1ICR
	jsr ee85		; CLKOUT lo, release CLK
	bit $a3			; under ATN?
	bpl 3$			;yes->wait for DATA up
	; not under ATN, wait for DATA up+down+up
5$	jsr eea9		; wait settle, DATA->C
	bcc 5$			;wait for DATA released
4$	jsr eea9		; wait settle, DATA->C
	bcs 4$			;wait for DATA low
#if 0
3$	jsr eea9		; wait settle, DATA->C
	bcc 3$			;wait for DATA released
#else
3$	lda D2PRA
	cmp D2PRA
	bne 3$
	pha
	lda D1ICR
	and #$08
	beq 6$
	lda #$c0
	sta FASTSER
6$	pla
	bpl 3$
#endif

#if 0
	jmp $ee8e
#else
	lda D2PRA	; CLKOUT hi, CLK low
	ora #$10
	sta D2PRA

	lda #$08
	sta $a5		; 8 bits to send
ed66	lda D2PRA
	cmp D2PRA
	bne ed66
	asl
	bcc edaf+1	;timeout read+write
	ror $95		; next bit to send
	bcs ed7a
	jsr eea0	; DOUT hi, DATA low
	bne ed7d
ed7a	jsr ee97	; DOUT lo, release DATA
ed7d
	jsr ee85	; CLKOUT lo, release CLK
	nop
	nop
	nop
	nop
	lda D2PRA
	and #$df
	ora #$10
	sta D2PRA	; release DATA, CLK low
	dec $a5
	bne ed66	;until 8 bits sent

	lda #$04
	sta $dc07	; timer B low byte
	lda #$19
	sta $dc0f	; force load, one-shot, run timer B
	lda D1ICR	; clear old interrupt bits
ed9f	lda D1ICR
	and #$02	; timer B expired?
	bne edaf+1	;timeout read+write
	jsr eea9	; wait settle, DATA->C
	bcs ed9f	;wait for ACK
	cli
	rts
#endif


edad	lda #$80	; device not present
edaf	bit $03a9	; timeout read+write
	ora ST
	sta ST
	cli
	clc
	bcc ee03


mySECOND
	sta $95
	jsr myDEL	; CLKLODELAY
	lda D2PRA
	and #$f7
	sta D2PRA	; ATNOUT lo, ATN hi
	rts

myCIOUT
	bit $94
	bmi 0$
	sec
	ror $94
	bne 1$
0$	pha
	jsr myPB	; put buffered char
	pla
1$	sta $95
	clc
	rts

myUNLSN
	lda #$3f
	;pha
	;lda FASTSER
	;and #$7f
	;sta FASTSER
	;pla
	jsr myLISTEN+2
	jmp ee03

SPOUT
	;lda #$7f
	;sta D1ICR
	lda #$00
	sta $dc05
	lda #$04
	sta $dc04
	lda $dc0e
	and #$80
	ora #$55
	sta $dc0e
	bit D1ICR
	rts
WAITSPIN
0$	lda D1ICR
	and #$08
	beq 0$
SPIN
	lda $dc0e
	and #$80	; preserve TOD mode, SP to input, timer A continuous
	ora #$01
	sta $dc0e

	lda #$25        ; Set the normal (PAL) frequence to TimerA
	sta $dc04       ; Change if you want to preserve NTSC-rate
	lda #$40
	sta $dc05

	rts


ee97	lda D2PRA	; DOUT lo, release DATA
	and #$df
	sta D2PRA
	rts

eea0	lda D2PRA	; DOUT hi, DATA low
	ora #$20
	sta D2PRA
	rts

eea9	lda D2PRA	; wait settle, DATA->C
	cmp D2PRA
	bne eea9
	asl
	rts

ee03	lda D2PRA
	and #$f7
	sta D2PRA	; ATNOUT lo, ATN hi
	txa
	ldx #$0a
0$	dex
	bne 0$
	tax
	jsr ee85	; CLKOUT lo, release CLK
	jmp ee97	; DOUT lo, release DATA

ee85	lda D2PRA	; CLKOUT lo, release CLK
	and #$ef
	sta D2PRA
	rts

#endif
#endif

obufhi	dc.b 0
files	dc.b 0		; number of files
filecnt	dc.b 0

#if MACH == 128
UpdSearch:
	ldx #<FarUpdSearch
	lda #>FarUpdSearch
	jmp farcall

ClearSearch:
	ldx #<FarClearSearch
	lda #>FarClearSearch
	;jmp farcall

farcall	stx 4	; low byte in X, high byte in A
	sta 3
	lda $02de
	pha
	lda $ff00
	sta $02de	; =return memory config
	jsr JSRFAR
	pla
	sta $02de
	cli
	rts

bank1install:
	; Install code to bank 1
	lda #bTmp
	sta $02b9	; ZP for writebank
	lda #<bank1code
	sta bTmp+0
	lda #>bank1code
	sta bTmp+1

	ldy #0
0$	lda bank1org,y
	ldx #1		; bank 1 (RAM1)
	jsr WRITEBANK
	iny
	cpy #bank1end-bank1org
	bne 0$

	lda #1		; bank 1 (RAM1)
	sta 2
	sei
	php
	pla
	sta 5	; SR
	cli
	rts

bank1org:
#rorg $0400
bank1code:

FarUpdSearch
	; no check.. it doesn't matter if we read 1 byte off the end
updsearch$		;if (bu > 1) {
	lda arg+0	;  long off;
			;  unsigned short index =
	asl		;	((*rPtr & (LSIZE-1)) << LSHIFT) |
	asl		;	(*(rPtr+1) & (LSIZE-1));
	asl		;  long *lPairPtr = &lPair[index];

#if LSHIFT == 4
	asl		; shifting only leaves 4 bits
	sta zp0
	lda arg+1	; HI
	and #15		; take only 4 bits
	lsr		; shift 2 bits to LO part, because
	ror zp0		; array element is 4 bytes
	lsr
	ror zp0		; leaves 2 bits in HI part
#endif

#if LSHIFT == 5
	sta zp0		; shifting only leaves 5 bits
	lda arg+1
	and #31		; take only 5 bits
	lsr		; shift 1 bit to LO part
	ror zp0		; leaves 3 bits in HI part
#endif
	;clc		; C already clear, because zp0 is *8 (or *16)
	adc #>lPair
	sta zp1
	lda pos+0	;  unsigned short *tmp = &bSkip[p & (BLOCK_SIZE-1)];
	sta bTmp+0
	lda pos+1
	and #>(BLOCK_SIZE-1)
	asl bTmp+0
	rol
	;clc		; C already clear, because BLOCK_SIZE <= 32768
	adc #>bSkip
	sta bTmp+1

	;	    off = p - *lPairPtr;
	;	    if (off < (BLOCK_SIZE-MAX_MATCH)) {
	;		*tmp = off;
	;	    } else {
	;		*tmp = 0;
	;	    }
	ldy #0
	lda pos+0
	sec
	sbc (zp0),y
	sta off0$+1
	iny
	lda pos+1
	sbc (zp0),y
	sta off1$+1
	iny
	lda pos+2
	sbc (zp0),y
	sta off2$+1
	iny
	lda pos+3
	sbc (zp0),y
off2$	ora #0
	bne ptr0$	;16 top bits != 0

	lda off1$+1
	cmp #>(BLOCK_SIZE-MAX_MATCH)
	bcc ptr$	; HI byte <  --> ok!
	; HI byte >=
	;bne ptr0$	; HI byte >  --> not ok
	;todo: compare low byte -- but it doesn't matter much..

ptr0$	lda #0		; too far or not found
	sta off0$+1
	sta off1$+1

	; Update search structure pointers
ptr$	ldy #0
off0$	lda #0
	sta (bTmp),y	;  *tmp=..
	iny
off1$	lda #0
	sta (bTmp),y
	dey		;ldy #0
	lda pos+0
	sta (zp0),y	;  *lPairPtr = p;
	iny
	lda pos+1
	sta (zp0),y
	iny
	lda pos+2
	sta (zp0),y
	iny
	lda pos+3
	sta (zp0),y
	rts

FarClearSearch:
	lda #>lPair
	sta clr$+2
	ldx #>(lPairSize+bSkipSize)

	ldy #0
	tya		;lda #0
clr$	sta $aa00,y
	iny
	bne clr$
	inc clr$+2
	dex
	bne clr$
	rts
#rend
bank1end
#endif	; MACH==128

CA
;	ds.b MAXFILES* CASIZE


Add new attachment

Only authorized users are allowed to upload new attachments.
« This page (revision-1) was last changed on 25-Jul-2010 13:46 by Carsten Strotmann