get_file_info.aii

	string asis

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

	include 'fst.equ'

	include 'fst.macros'

	include 'M16.Debug'




	entry path_to_inode
	entry load_inode
	entry find_file
	entry volume_by_name
	entry vstrcmp

	import id_disk
	import device_read


	import disk_inode:v1_inode
	import disk_super:v1_super

data	record

path_offset	ds.w 1
more		ds.w 1

	endr

get_file_info	procname export

	with fst_parms
	with dev_parms
	with dp

	;~DebugSetTrace #1

	;brk $ea
	jsr path_to_inode
	bcs exit

	jsr load_inode
	bcs exit





	;pha ; space
	;~DebugSetTrace #0
	;pla ; prev value


	lda <call_class
	beq class0

class1
	lda [param_blk_ptr] ; pcount
	dec a
	asl a ; x 2
	asl a ; x 4
	tax
	dispatch file_info_dcb_1
	lda tool_error
	cmp #1
	rtl

class0
	ldx #file_info_dcb_0_size-4
	dispatch file_info_dcb_0
	lda tool_error
	cmp #1
	rtl

exit
	rtl

	import do_ignore
	import do_access
	import do_create_date_time, do_mod_date_time
	import do_create_date_time_0, do_mod_date_time_0
	import do_option_list
	import do_file_type, do_aux_type, do_storage_type
	import do_eof, do_blocks, do_r_eof, do_r_blocks

file_info_dcb_0
	with FileRec
	dc.w pathname, do_ignore ; pathname
	dc.w fAccess, do_access
	dc.w fileType, do_file_type
	dc.w auxType, do_aux_type
	dc.w storageType, do_storage_type
	dc.w createDate, do_create_date_time_0
	dc.w modDate, do_mod_date_time_0
	dc.w blocksUsed, do_blocks
	endwith
file_info_dcb_0_size equ *-file_info_dcb_0

file_info_dcb_1
	with FileInfoRecGS
	;dc.w $00, do_ignore	; pCount
	dc.w pathname, do_ignore ; pathname
	dc.w access, do_access
	dc.w fileType, do_file_type
	dc.w auxType, do_aux_type
	dc.w storageType, do_storage_type
	dc.w createDateTime, do_create_date_time
	dc.w modDateTime, do_mod_date_time
	dc.w optionList, do_option_list
	dc.w eof, do_eof
	dc.w blocksUsed, do_blocks
	dc.w resourceEOF, do_r_eof
	dc.w resourceBlocks, do_r_blocks
	endwith
	endp



load_inode	procname export
	;
	; loads inode into disk_inode.
	;
	; inputs : 
	; my_vcr
	; inode
	; device
	;
	; outputs :
	; disk_inode
	; error in a/c

	; todo -- check if inode # is valid?
	; todo -- check if bit set in imap?


	with fst_parms
	with dev_parms
	with dp

	ldy #vcr.first_inode_block
	lda [my_vcr],y
	asl a ; x 2
	sta dev_blk_num
	;lda #0
	;rol a
	;sta dev_blk_num+2
	stz dev_blk_num+2 ; should be less than 0xffff inode blocks!

	; 32 inodes per block.
	; however, I'd rather read half-block chunks, with means
	; 16 inodes per half-block.
	lda inode
	dec a ; inode 1 is offset 0.
	lsr a ; / 2
	lsr a ; / 4
	lsr a ; / 8
	lsr a ; / 16
	;lsr a ; / 32

	clc
	adc dev_blk_num
	sta dev_blk_num

	lda #512
	;sta dev_blk_size
	sta dev_req_cnt

	; dev_num must already be set up.
	;lda device ;;;;
	;sta dev_num

	jsr device_read
	bcc ok
	rts
ok

	; find the inode...
	lda inode
	dec a ; inode 1 is offset 0.
	and #$0f
	; multiply by 32
	asl a ; x 2
	asl a ; x 4
	asl a ; x 8
	asl a ; x 16
	asl a ; x 32
	clc
	adc #v1_inode.__sizeof-2
	tay

	;adc io_buffer
	;sta ptr
	;lda #0
	;adc io_buffer+2
	;sta ptr+2

	; copy to dp
	ldx #v1_inode.__sizeof-2
@loop
	lda [io_buffer],y
	sta disk_inode,x
	dey
	dey
	dex
	dex
	bpl @loop

	lda #0
	clc
	rts


	endp

	;
	; sets inode, parent_inode, disk_inode, 
	; if file not present but path is otherwise, ok (eg, create),
	; parent inode and disk_inode will be valid for the parent directory.
	;
	; uses path1, dev1, span1.
	;


	;
	; After GS/OS expands prefixes, there are two path types
	; 1. device root  (.dev:path)
	; 2. path root (:volume:path)
	;
	; in the case of 1, verify the device is a minix volume, create 
	; the vcr (if necessary) and proceed from there.
	;
	; in the case of 2, gs/os will check for a vcr with the volume
	; name and, if found, give the FST a first shot at handling it. 
	; if the FST doesn't claim it, or no vcr is found, all FSTs will 
	; be called until it's claimed.
	;
	; fst_parms.vcr will not be populated even if GS/OS previously found 
	; it. 
	;


path_to_inode	procname export
	with dp,fst_parms


path	equ path1_ptr
dev_num	equ dev1_num
span	equ span1

	stz inode
	lda #1
	sta parent_inode

	lda path_flag
	and #$4000
	bne check_path


no_path
	; device only (eg, .dev1 )
	; 
	lda #1
	sta inode

	lda dev_num
	beq bps
	;sta device
	jmp id_disk
	; returns
bps
	lda #bad_path_syntax
	sec
exit
	rts

check_path

	; linux allows a 30-char name. minix is 14 char
	; will check for minix later.
	lda span
	cmp #v1L.DIRSIZE+1
	bcs bps

	; but is it relative?

	ldy #2
	lda [path],y
	and #$00ff
	cmp #':'
	beq absolute

	lda #1
	sta inode

	lda dev_num
	beq bps
	;sta device
	jsr id_disk
	bcs exit
	lda #2
	sta data.path_offset ; skip past gs-os length word
	brl find_file ; will rts.
	;

absolute
	;
	; worst case ... 
	; 1. extract the volume name.
	; 2. call find_vcr to find it by name
	; 3. if that fails, scan all devices.


	jsr volume_by_name
	_rts.cs

	brl find_file
	
	endp

	entry skip_colon
skip_colon	proc
	;returns carry set if end of path.

	with dp, data
path	equ fst_parms.path1_ptr


	ldy path_offset
	short m
@loop
	lda [path],y
	beq zero
	cmp #':'
	bne done
	iny
	bra @loop
done
	lda #':'
	sta more
	sty path_offset
	long m
	clc
	rts
zero
	long m
	stz more
	sty data.path_offset
	sec
	rts
	endp

find_file	procname

	with dp
	with data

	import find_entry_by_name

path	equ fst_parms.path1_ptr
dev_num	equ fst_parms.dev1_num
span	equ fst_parms.span1

	import target:GSString32

	stz more

	; we always need to load inode 1
	lda #1
	sta inode
	jsr load_inode
	_rts.cs


dir_loop


	; get a path component.


	; 1. check for a null path.
	jsr skip_colon
	bcs done

	lda inode
	sta parent_inode

	ldx #0
	ldy path_offset
	short m
path_loop
	lda [path],y
	beq eop
	cmp #':'
	beq eop
	sta target.text,x
	inx
	iny
	bra path_loop
eop
	sta more
	long m
	stx target.length
	sty path_offset
	; a = ':' or 0 ... worry about which later!

	; target is valid, inode is valid, is target in inode?

	;~DebugHexDump #target, #34


	jsr find_entry_by_name
	bcc @ok
	; may be file_not_found, may be path_not_found.
	ldx more
	beq @exit
	lda #path_not_found
@exit
	sec
	rts

@ok
	; inode,  has been updated.
	jsr load_inode
	_rts.cs

	lda more 
	beq done

	; more to go...

	; this is a directory, right?
	lda disk_inode.mode
	and #S_IFMT
	cmp #S_IFDIR
	beq dir_loop
	lda #path_not_found
	sec
	rts

done
	clc
	rts

	endp

volume_by_name	procname export
	;
	; extract the volume name from path1_ptr and find (or create) a vcr.
	;
	;

	with dp
	with data

path	equ fst_parms.path1_ptr

	import target:GSString32

	; copy volume name to target.
	; leading : is NOT included.

	ldx #0
	ldy #3
	short m
@loop
	lda [path],y
	beq done
	cmp #':'
	bne @next
	iny
	bra done
@next
	sta target.text,x
	inx
	iny
	bra @loop
done

	long m
	sty path_offset
	stx target.length

	ldx #target
	ldy #^target
	lda #0
	jsl find_vcr
	bcs no_vcr

	; store it for later...
	;stx ptr
	;	sty ptr+2

	jsl deref
	stx my_vcr
	sty my_vcr+2

	ldy #vcr.fst_id
	lda [my_vcr],y
	cmp #fst_id
	bne no_vcr

	; there is a vcr and it's a minix vcr.
	; 1. should do a case-sensitive name check.
	; 2. if the volume is marked as swapped, we need to
	; re-scan devices.
	; 3. if the volume is not swapped, we need to verify 
	; the disk didn't switch on us.

	ldy #vcr.status
	lda [my_vcr],y
	and #vcr_swapped
	bne no_vcr

	ldy #vcr.device
	lda [my_vcr],y
	jsr id_disk
	bcs no_vcr

	;
	; I suppose reading a block could alloc memory and invalidate the vcr...
	;

	;ldx ptr
	;ldy ptr+2

	;jsl deref
	;stx my_vcr
	;sty my_vcr+2

	; check the volume name here...

	jsr vstrcmp
	bcs no_vcr
	rts


no_vcr
	; no vcr on file... scan all devices to find the volume.
	stz my_vcr
	stz my_vcr+2

	stz device

@loop
	lda device
	inc a
	sta device
	jsr id_disk

	bcs @error_check

	; check if the volume name matches...
	jsr vstrcmp
	bcs @loop

	; match!  hooray!
	clc
	rts

@error_check
	cmp #dup_volume
	beq @error
	cmp #invalid_dev_num
	bne @loop
	lda #vol_not_found
@error
	sec
	rts
device
	ds.w 1
	endp

vstrcmp	procname

	import target:GSString32

	; case-sensitive strcmp for volume name
	;
	; target does not have a leading :
	; vcr.vname has a leading : 
	;

	with dp


	lda target.length
	inc a ; + 1 for :

	ldy #vcr.vname.length
	cmp [my_vcr],y
	bne fail

	lda #vcr.vname.text
	clc
	adc target.length
	tay

	ldx target.length
	dex

	short m
@loop
	lda target.text,x
	cmp [my_vcr],y
	bne fail8
	dey
	dex
	bpl @loop

	;success
	long m
	clc
	rts


fail8
	long m
fail
	sec
	rts

	endp

	end