string asis

	include 'gsos.equ'
	include 'minix.equ'
	include 'records.equ'

	include 'fst.equ'

	include 'fst.macros'

	include 'M16.Debug'

	include 'p.equ'

	import do_ignore
	import init_fcr
	import init_vcr
	import read_data_block

	entry memcpy
	entry do_transfer_count
	entry do_data_buffer
	entry do_request_count

	entry init_block
	entry next_block

	entry slow_read
	entry read_direct_block
	entry read_partial_block

	entry getchar
	entry build_nl_table

	import disk_inode:v1_inode

my_dp		record dp.__end

dataBuffer	ds.l 1
requestCount	ds.l 1
transferCount	ds.l 1
mark		ds.l 1

mtc		ds.l 1

count		ds.w 1 ; count from partial block read
block		ds.w 1 ; current block for reading.

zone		ds.l 1

nl_mask		ds.w 1

		IF *>=$d4 THEN
		AERROR 'dp -- too large.'
		ENDIF

		endr

data		record

nl_table	ds.b 256
		endr


	;
	; read logic...
	; if (mark & 1024-1) read partial block
	; while (transferCount >= 1024) direct read into dataBuffer
	; if (transferCount & 1024 - 1) read partial block



do_transfer_count procname
	with fst_parms, my_dp

	lda transferCount
	sta [param_blk_ptr],y
	iny
	iny
	lda transferCount+2
	sta [param_blk_ptr],y
	rts
	endp

do_data_buffer procname
	with fst_parms, my_dp

	lda [param_blk_ptr],y
	sta dataBuffer
	iny
	iny
	lda [param_blk_ptr],y
	sta dataBuffer+2
	rts
	endp

do_request_count procname
	with fst_parms, my_dp

	lda [param_blk_ptr],y
	sta requestCount
	iny
	iny
	lda [param_blk_ptr],y
	sta requestCount+2
	rts
	endp

do_cache_priority procname
	with fst_parms, my_dp, dp

	lda [param_blk_ptr],y
	; 0 or 1 only.
	cmp #2
	bcs pre
	sta dev_parms.dev_cache_pr
	rts
pre
	lda #parm_range_err
	sta tool_error
	rts
	endp

	entry set_zone

init_block	procname

	with my_dp

	lda mark+1
	sta zone
	lda mark+3
	and #$00ff
	sta zone+2
	lsr zone+2
	ror zone
	lsr zone+2
	ror zone
	ldx zone
	bra set_zone
	endp

	; updates block, zone, etc.
	; find the block to read.
next_block	procname

	with my_dp, dp, v1

	ldx zone
	inx
	inx
	stx zone
	entry set_zone

set_zone
	cpx #NR_DZONES*2
	bcc direct

indirect
double_indirect
	; todo ...
	lda #damaged_bitmap
	sec
	rts
direct
	lda disk_inode.zone,x
	sta block
	clc
	rts

	endp

read	procname export

	with dp, my_dp, fst_parms

	;
	jsr init_vcr
	jsr init_fcr

	; zero-out transferCount, even if there's an error
	; later
	ldy call_class
	lda tc_table,y
	tay
	lda #0
	sta [param_blk_ptr],y
	iny
	iny
	sta [param_blk_ptr],y

	;brk $ea
	;~DebugSetTrace #1

	; can only read from regular files or links.
	lda disk_inode.mode
	and #S_IFMT
	cmp #S_IFREG
	beq @ok
	cmp #S_IFLNK
	beq @ok

	lda #bad_store_type
	sec
	rtl

@ok
	; offset is 2 for class 0, 4 for class 1!


	; check for read-access
	ldy #fcr.access
	lda [<my_fcr],y

	and #read_access
	bne @access_ok

	lda #invalid_access
	sec
	rtl


@access_ok


	stz transferCount
	stz transferCount+2


	ldy #fcr.mark
	lda [my_fcr],y
	sta mark
	iny
	iny
	lda [my_fcr],y
	sta mark+2

	lda call_class
	beq class0

class1
	lda [param_blk_ptr] ; pcount
	dec a
	asl a ; x 2
	asl a ; x 4
	tax
	dispatch read_dcb_1

	lda tool_error
	beq class_over

	sec
	rtl

class0
	ldx #read_dcb_0_size-4
	dispatch read_dcb_0
	bra class_over


read_dcb_1
	with IORecGS
	dc.w refNum, do_ignore
	dc.w dataBuffer, do_data_buffer
	dc.w requestCount, do_request_count
	dc.w transferCount, do_ignore
	dc.w cachePriority, do_cache_priority
	endwith

read_dcb_0
	with FileIORec
	dc.w fileRefNum, do_ignore
	dc.w dataBuffer, do_data_buffer
	dc.w requestCount, do_request_count
	dc.w transferCount, do_ignore
	endwith
read_dcb_0_size equ *-read_dcb_0


class_over


	; end of file?
	lda mark+2
	cmp disk_inode.size+2
	bcc noteof
	lda mark
	cmp disk_inode.size
	bne noteof

eof
	lda #end_of_file
	sec
	rtl
noteof

	; if requestCount is 0, just quit now!
	lda requestCount
	ora requestCount+2
	bne @rc

	lda #0
	clc
	rtl
@rc


	; transferCount can't go past the eof mark...

tc
	; mtc -- max transferCount
	sec
	lda disk_inode.size
	sbc mark
	sta mtc

	lda disk_inode.size+2
	sbc mark+2
	sta mtc+2

	; if negative, we have a problem...
	bmi eof
	; if 0, end of file...
	ora mtc
	beq eof


	lda requestCount+2
	cmp mtc+2
	bcc @ok
	beq @lw
	bra @toobig

@lw	; low word
	lda requestCount
	cmp mtc
	beq @ok
	bcc @ok

@toobig
	lda mtc
	sta requestCount
	lda mtc+2
	sta requestCount+2

@ok


	jsr init_block
	bcs exit

	; we are ok to read!
	; check for new line mode...
	jsr build_nl_table
	bcs normal_read

	jsr slow_read
	bcc done
	rtl

normal_read


	; currently limited to 7 zones, anyhow!

	; first block may have extra work since it may be offset into a block.
	; (should store block in the fcr)

	lda mark
	and #1024-1
	beq aligned

	jsr read_partial_block
	bcs exit

aligned

	; while transferCount >= 1024 { read_direct_block }
	lda requestCount+2
	bne @read
	lda requestCount
	beq done
	cmp #1024
	bcc tail

@read
	jsr read_direct_block
	bcs exit

	bra aligned

tail
	; read a partial tail block.
	;  set up block...

	jsr read_partial_block
	bcs exit

done
	; read complete!
	; todo -- update fcr, transferCount


	ldy #fcr.mark
	lda mark
	sta [my_fcr],y
	iny
	iny
	lda mark+2
	sta [my_fcr],y

	; eventually, data_zone, data_block.


	ldx call_class
	lda tc_table,x
	tay
	lda transferCount
	sta [param_blk_ptr],y
	iny
	iny
	lda transferCount+2
	sta [param_blk_ptr],y

	;~DebugSetTrace #0

	lda tool_error
	cmp #1
	rtl


exit
	rtl


tc_table	dc.w FileIORec.transferCount, IORecGS.transferCount


	endp

update_counts procname

	with my_dp


	; mark += count

	lda count
	clc
	adc mark
	sta mark
	lda #0
	adc mark+2
	sta mark+2

	;dataBuffer += count

	lda count
	clc
	adc dataBuffer
	sta dataBuffer
	lda #0
	adc dataBuffer+2
	sta dataBuffer+2

	; transferCount += count

	lda count
	clc
	adc transferCount
	sta transferCount
	lda #0
	adc transferCount+2
	sta transferCount+2
	;

	; requestCount -= count

	lda requestCount
	sec
	sbc count
	sta requestCount
	lda requestCount+2
	sbc #0
	sta requestCount+2

	; a = requestCount+2
	ora requestCount
	beq done
	jmp next_block

done
	clc
	rts

	endp

	; todo -- should read block into fcr, update fcr.
read_partial_block procname
	; read a block into io_buffer, then copy the parts we want into dataBuffer.
	; a = block number.

	with my_dp, dp


	; count = 1024 - (mark & 0x1023)
	lda mark
	and #1024-1
	rsb #1024


	sta count
	lda requestCount+2
	bne @ok
	lda requestCount
	cmp count
	bcs @ok
	; requestCount is less than count...
	sta count

@ok

	; assume block, etc are set up.

	lda io_buffer
	sta dev_parms.dev_buff
	lda io_buffer+2
	sta dev_parms.dev_buff+2

	lda block
	jsr read_data_block
	bcs exit

	; set ptr to the offset...
	lda mark
	and #1024-1
	clc
	adc io_buffer
	sta ptr
	lda #0
	adc io_buffer+2
	sta ptr+2

	lda count
	jsr memcpy


	jmp update_counts
exit
	rts

	endp

read_direct_block procname

	with dp, my_dp


	; set up for direct read!
	lda dataBuffer
	sta dev_parms.dev_buff
	lda dataBuffer+2
	sta dev_parms.dev_buff+2

	lda block
	jsr read_data_block
	bcs exit

	lda #1024
	sta count
	jmp update_counts

exit
	rts
	endp

memcpy	procname

	; copy from ptr to dataBuffer
	; a = count
	;pha ; save
	; all registers are clobbered.

	with dp, my_dp

	lsr a ; / 2
	beq last_byte

	tax
	ldy #0
loop
	lda [ptr],y
	sta [dataBuffer],y
	iny
	iny
	dex
	bne loop

last_byte
	;pla
	; carry still set...
	bcc done
	short m
	lda [ptr],y
	sta [dataBuffer],y
	long m
done
	rts
	endp

	macro
	fix_count
	lda requestCount+2
	bne @fini
	lda requestCount
	cmp count
	bcs @fini
	sta count
@fini
	endm

	;
	; builds a new-line table, if necessary.
	; returns:
	; c = 0 if new_line mode enabled.
	; c = 1 if new_line mode disabled.

build_nl_table	procname

	with dp, my_dp
	with data

	ldy #fcr.mask
	lda [my_fcr],y
	sta nl_mask
	bne @yes
	sec
	rts
@yes
	lda #0
	ldx #256-2
zloop
	sta nl_table,x
	dex
	dex
	bpl zloop


	; newline list is a virtual pointer.
	ldy #fcr.newline
	lda [my_fcr],y
	tax
	iny
	iny
	lda [my_fcr],y
	tay
	jsl deref
	stx ptr
	sty ptr+2

	ldy #fcr.newline_length
	lda [my_fcr],y
	tay
	dey

	ldx #0
	short m
nloop
	lda [ptr],y
	;and nl_mask
	tax
	lda #$ff
	sta nl_table,x
	dey
	bpl nloop
	long m
	clc
	rts
	endp

slow_read	procname

	with dp, my_dp

	; new-line processing is in effect.
	; read a block, then copy each character at a time.

	; first block may not be aligned.

	;jsr build_nl_table

	lda mark
	and #1024-1
	beq aligned

	lda block
	jsr read_data_block
	_rts.cs

	; set up ptr.
	lda mark
	and #1024-1
	clc
	adc io_buffer
	sta ptr
	lda #0
	adc io_buffer+2
	sta ptr+2

	; count = (1024 - mark) & 1023
	lda #1024
	sec
	sbc mark
	and #1024-1
	sta count
	; count = min(requestCount,count)
	fix_count

	jsr getchar
	bcs exit
	bvs done

	lda requestCount
	ora requestCount+2
	beq done

aligned

	lda io_buffer
	sta ptr
	lda io_buffer+2
	sta ptr+2

@loop
	; read aligned blocks.
	lda block
	jsr read_data_block
	bcs exit

	lda #1024
	sta count
	fix_count
	jsr getchar
	bcs exit
	bvs done

	lda requestCount
	ora requestCount+2
	bne @loop


done
	lda #0
	clc
exit
	rts

	endp


	; copies up to count characters from ptr to dataBuffer
	; returns v = 1 if eol found,
	; returns v = 0 if eol not found.
	; (c set from next_block)
	; updates mark, transferCount, dataBuffer, requestCount, etc.
	; 
getchar	procname

	with dp, my_dp
	with data


	ldy #0
	short m
bloop
	lda [ptr],y
	sta [dataBuffer],y
	iny

	and nl_mask
	; bit nl_mask+1 ; high bit set if 1-char nl 
	; bpl @table
	; cmp nl_char
	; beq @eol
	;@table
	tax
	lda nl_table,x
	bne @eol
@next
	cpy count
	bcc bloop
	long m
	sty count
	jsr update_counts
	clv
	rts

@eol
	; end-of-line!
	long m
	sty count
	jsr update_counts
	sep #p.v
	rts
	endp

	end