mirror of
https://github.com/SEPPDROID/DR-DOS-OpenDOS.git
synced 2025-10-22 07:54:28 +00:00
961 lines
24 KiB
Plaintext
961 lines
24 KiB
Plaintext
title 'FCB - DOS file system FCB support'
|
|
; File : $FCBS.A86$
|
|
;
|
|
; Description :
|
|
;
|
|
; Original Author : DIGITAL RESEARCH
|
|
;
|
|
; Last Edited By : $CALDERA$
|
|
;
|
|
;-----------------------------------------------------------------------;
|
|
; Copyright Work of Caldera, Inc. All Rights Reserved.
|
|
;
|
|
; THIS WORK IS A COPYRIGHT WORK AND CONTAINS CONFIDENTIAL,
|
|
; PROPRIETARY AND TRADE SECRET INFORMATION OF CALDERA, INC.
|
|
; ACCESS TO THIS WORK IS RESTRICTED TO (I) CALDERA, INC. EMPLOYEES
|
|
; WHO HAVE A NEED TO KNOW TO PERFORM TASKS WITHIN THE SCOPE OF
|
|
; THEIR ASSIGNMENTS AND (II) ENTITIES OTHER THAN CALDERA, INC. WHO
|
|
; HAVE ACCEPTED THE CALDERA OPENDOS SOURCE LICENSE OR OTHER CALDERA LICENSE
|
|
; AGREEMENTS. EXCEPT UNDER THE EXPRESS TERMS OF THE CALDERA LICENSE
|
|
; AGREEMENT NO PART OF THIS WORK MAY BE USED, PRACTICED, PERFORMED,
|
|
; COPIED, DISTRIBUTED, REVISED, MODIFIED, TRANSLATED, ABRIDGED,
|
|
; CONDENSED, EXPANDED, COLLECTED, COMPILED, LINKED, RECAST,
|
|
; TRANSFORMED OR ADAPTED WITHOUT THE PRIOR WRITTEN CONSENT OF
|
|
; CALDERA, INC. ANY USE OR EXPLOITATION OF THIS WORK WITHOUT
|
|
; AUTHORIZATION COULD SUBJECT THE PERPETRATOR TO CRIMINAL AND
|
|
; CIVIL LIABILITY.
|
|
;-----------------------------------------------------------------------;
|
|
;
|
|
; *** Current Edit History ***
|
|
; *** End of Current Edit History ***
|
|
; $Log$
|
|
; FCBS.A86 1.10 93/11/11 15:38:14
|
|
; Chart Master fix - fcb_readblk over > 64k is truncated to 64k and
|
|
; error 2 (Segment boundry overlap) is returned
|
|
; FCBS.A86 1.9 93/10/18 17:37:06
|
|
; fix for >255 open files (PNW Server)
|
|
; ENDLOG
|
|
|
|
eject ! include i:fdos.equ
|
|
eject ! include i:msdos.equ
|
|
eject ! include i:mserror.equ
|
|
eject ! include i:doshndl.def ; DOS Handle Structures
|
|
eject
|
|
|
|
|
|
BDOS_DATA dseg word
|
|
|
|
BDOS_CODE cseg
|
|
|
|
extrn ifn2dhndl:near
|
|
extrn parse_one:near
|
|
extrn fdos_entry:near
|
|
|
|
Public fdos_exit
|
|
|
|
eject
|
|
; TERMINATE CHILD (EXIT)
|
|
|
|
; +----+----+
|
|
; | 24 |
|
|
; +----+----+
|
|
|
|
; entry:
|
|
; ------
|
|
; -none-
|
|
|
|
; exit:
|
|
; -----
|
|
; -none-
|
|
|
|
; Close down all FCB handles associated with the current PSP
|
|
;
|
|
fdos_exit:
|
|
;---------
|
|
push ds
|
|
push ss ! pop ds ; DS -> PCM_DSEG
|
|
sub ax,ax ; start with first DHNDL_
|
|
fdos_exit10:
|
|
call ifn2dhndl ; get DHNDL_
|
|
jc fdos_exit40 ; stop if we have run out
|
|
mov fcb_pb+2,ax ; we may close this IFN
|
|
push ax
|
|
mov cx,es:DHNDL_COUNT[bx] ; get the open count
|
|
jcxz fdos_exit30 ; skip if nothing to do
|
|
mov ax,current_psp ; get current PSP
|
|
cmp ax,es:DHNDL_PSP[bx] ; does it belong to this PSP
|
|
jne fdos_exit30
|
|
mov ax,ss:machine_id ; get current process
|
|
cmp ax,es:DHNDL_UID[bx]
|
|
jne fdos_exit30
|
|
test es:DHNDL_MODE[bx],DHM_FCB
|
|
jz fdos_exit20 ; skip close if not FCB
|
|
push es
|
|
push bx ; save the DHNDL
|
|
mov ax,MS_X_CLOSE
|
|
call fcb_fdos ; make the FDOS do the work
|
|
pop bx
|
|
pop es ; recover the DHNDL
|
|
fdos_exit20:
|
|
mov es:DHNDL_COUNT[bx],0 ; always free the handle if it's ours
|
|
fdos_exit30:
|
|
pop ax
|
|
inc al ; onto next IFN
|
|
jnz fdos_exit10
|
|
fdos_exit40:
|
|
pop ds
|
|
ret
|
|
|
|
|
|
|
|
|
|
|
|
Public fdos_fcb
|
|
|
|
eject
|
|
; GENERIC FCB FUNCTION (FCB)
|
|
|
|
; +----+----+----+----+----+----+----+----+
|
|
; | 22 | fcbadr | count |
|
|
; +----+----+----+----+----+----+----+----+
|
|
; | func |
|
|
; +----+----+
|
|
|
|
; entry:
|
|
; ------
|
|
; fcbadr: FCB address
|
|
; count: multi-sector count for read/write
|
|
; func: FCB sub-function
|
|
|
|
; exit:
|
|
; -----
|
|
; AX: return code or error code ( < 0)
|
|
|
|
fdos_fcb:
|
|
;--------
|
|
mov bx,2[bp] ; BX -> parameter block
|
|
mov bx,8[bx] ; get subfunction code
|
|
shl bx,1 ; make it word index
|
|
sub bl,15*WORD ; adjust to base address
|
|
jc fcb_error ; reject if too low
|
|
cmp bl,FCB_MAX1 ; is it in 1st block
|
|
jb fdos_fcb10
|
|
sub bl,(33-24)*WORD ; adjust for gap
|
|
jc fcb_error
|
|
cmp bl,FCB_MAX2 ; is it in 2nd block
|
|
jb fdos_fcb10
|
|
sub bl,(39-37)*WORD ; adjust for gap
|
|
jc fcb_error
|
|
fdos_fcb10:
|
|
cmp bx,FCB_MAX3 ; check the range
|
|
jae fcb_error ; skip if invalid function
|
|
jmp fcb_table[bx] ; call the right function
|
|
|
|
fcb_error:
|
|
mov bx,ED_FUNCTION
|
|
ret
|
|
|
|
fcb_table dw fcb_open ; 15-open file
|
|
dw fcb_close ; 16-close file
|
|
dw fcb_first ; 17-find first
|
|
dw fcb_next ; 18-find next
|
|
dw fcb_delete ; 19-delete file
|
|
dw fcb_read ; 20-read from file
|
|
dw fcb_write ; 21-write to file
|
|
dw fcb_make ; 22-make file
|
|
dw fcb_rename ; 23-rename file
|
|
FCB_MAX1 equ (offset $ - offset fcb_table)
|
|
dw fcb_readrand ; 33-read from file
|
|
dw fcb_writerand ; 34-write to file
|
|
dw fcb_size ; 35-compute file size
|
|
dw fcb_setrecord ; 36-set relative record
|
|
FCB_MAX2 equ (offset $ - offset fcb_table)
|
|
dw fcb_readblk ; 39-read from file
|
|
dw fcb_writeblk ; 40-write to file
|
|
FCB_MAX3 equ (offset $ - offset fcb_table)
|
|
|
|
fcb_make:
|
|
;--------
|
|
call fcb_path_prep ; build pathname
|
|
mov ax,MS_X_CREAT
|
|
jmps fcb_open_make_common
|
|
|
|
fcb_open:
|
|
;--------
|
|
call fcb_path_prep ; build pathname
|
|
mov ax,MS_X_OPEN
|
|
fcb_open_make_common:
|
|
mov fcb_pb+6,DHM_RW+DHM_FCB ; open as an FCB for read/write
|
|
call fcb_fdos ; lets try and open the file
|
|
jnc fcb_open10 ; skip if we can't
|
|
ret
|
|
fcb_open10:
|
|
call ifn2dhndl ; ES:BX -> DHNDL_ we have opened
|
|
push ds
|
|
push es ! push bx ; save DHNDL_
|
|
call fcb_point ; ES:BX = FCB
|
|
pop si ! pop ds ; DS:SI -> DHNDL_
|
|
mov es:MSF_IFN[bx],al ; store IFN away
|
|
mov es:MSF_BLOCK[bx],0 ; current block number
|
|
mov es:MSF_RECSIZE[bx],128 ; current logical record size
|
|
call fcb_update ; update misc changing fields
|
|
mov ax,ds:DHNDL_DEVOFF[si]
|
|
mov es:word ptr MSF_DEVPTR[bx],ax
|
|
mov ax,ds:DHNDL_DEVSEG[si]
|
|
mov es:word ptr MSF_DEVPTR+2[bx],ax
|
|
mov ax,ds:DHNDL_BLK1[si]
|
|
mov es:MSF_BLOCK1[bx],ax
|
|
mov al,ds:DHNDL_ATTR[si]
|
|
mov es:MSF_IOCTL[bx],al
|
|
mov al,es:MSF_DRIVE[bx] ; get drive from FCB
|
|
dec al ; was absolute drive specified ?
|
|
jns fcb_open20 ; if so use it
|
|
mov al,ss:current_dsk ; else use default drive
|
|
fcb_open20:
|
|
inc al ; make drive 1 rather than 0 based
|
|
mov es:MSF_DRIVE[bx],al ; drive code
|
|
if 0
|
|
test ds:DHNDL_DATRB[si],DA_VOLUME
|
|
else
|
|
test ss:fcb_pb+8,DA_VOLUME
|
|
endif
|
|
pop ds
|
|
jnz fcb_close ; don't leave VOL label's open
|
|
xor bx,bx ; no errors !
|
|
ret
|
|
|
|
|
|
fcb_update:
|
|
;----------
|
|
; On Entry:
|
|
; DS:SI -> DHNDL_
|
|
; ES:BX -> FCB
|
|
; On Exit:
|
|
; DATE/TIME/SIZE/DBLK/DCNT fields updated
|
|
;
|
|
mov ax,ds:DHNDL_TIME[si]
|
|
mov es:MSF_TIME[bx],ax
|
|
mov ax,ds:DHNDL_DATE[si]
|
|
mov es:MSF_DATE[bx],ax
|
|
mov ax,ds:DHNDL_SIZELO[si]
|
|
mov es:MSF_SIZE[bx],ax
|
|
mov ax,ds:DHNDL_SIZEHI[si]
|
|
mov es:MSF_SIZE+2[bx],ax
|
|
mov ax,ds:DHNDL_DBLK[si]
|
|
mov es:MSF_DBLK[bx],ax
|
|
mov al,ds:DHNDL_DCNTLO[si]
|
|
mov ah,ds:DHNDL_DCNTHI[si]
|
|
mov es:MSF_DCNT[bx],ax
|
|
ret
|
|
|
|
fcb_close:
|
|
;---------
|
|
; close file (DOS function 10h)
|
|
call fcb_point ; ES:BX -> FCB
|
|
mov al,0FFh
|
|
cmp al,es:MSF_IFN[bx] ; is it a multiple close ?
|
|
je fcb_fdos_common10 ; don't re-open for this...
|
|
call fcb_handle_vfy ; verify we have a sensible handle
|
|
mov es:MSF_IFN[bx],al ; mark FCB as closed (it will be)
|
|
mov ax,MS_X_CLOSE ; now close it
|
|
; jmps fcb_fdos_common
|
|
|
|
fcb_fdos_common:
|
|
;---------------
|
|
call fcb_fdos ; make the FDOS do the work
|
|
jc fcb_fdos_common20 ; return any error codes
|
|
fcb_fdos_common10:
|
|
xor bx,bx ; else return zero
|
|
fcb_fdos_common20:
|
|
ret
|
|
|
|
|
|
|
|
fcb_rename:
|
|
;----------
|
|
call fcb_path_prep
|
|
call fcb_path2_prep
|
|
mov ax,MS_X_RENAME ; it's a rename
|
|
jmps fcb_fdos_common
|
|
|
|
fcb_delete:
|
|
;----------
|
|
call fcb_path_prep
|
|
mov ax,MS_X_UNLINK ; it's a delete
|
|
jmps fcb_fdos_common
|
|
|
|
|
|
fcb_first:
|
|
;---------
|
|
call fcb_path_prep ; prepare pathname
|
|
mov ax,MS_X_FIRST ; we want to search 1st
|
|
jmps fcb_search_common
|
|
|
|
fcb_next:
|
|
;--------
|
|
call fcb_restore_search_state
|
|
mov ax,MS_X_NEXT
|
|
fcb_search_common:
|
|
call fcb_search ; 0 of OK, otherwise ED_..
|
|
jc fcb_search_common10
|
|
call fcb_save_search_state ; save sucessful state
|
|
xor bx,bx ; return code in BX
|
|
fcb_search_common10:
|
|
ret
|
|
|
|
|
|
fcb_setrecord:
|
|
;-------------
|
|
call fcb_point ; ES:BX -> FCB
|
|
mov ax,128 ; multiply current block by 128
|
|
mul es:MSF_BLOCK[bx] ; to give current record number
|
|
xor cx,cx
|
|
mov cl,es:MSF_CR[bx] ; Add in the current record
|
|
add ax,cx ; to DX:AX to give the
|
|
adc dx,0 ; relative record
|
|
mov es:MSF_RR[bx],ax ; save the result
|
|
mov es:MSF_RR2[bx],dl
|
|
xor bx,bx ; we did OK
|
|
ret
|
|
|
|
fcb_write:
|
|
;---------
|
|
mov ax,MS_X_WRITE ; make it a write
|
|
jmps fcb_seq_rw
|
|
|
|
fcb_read:
|
|
;--------
|
|
mov ax,MS_X_READ ; make it a read
|
|
fcb_seq_rw:
|
|
call fcb_handle_vfy ; verify we have a sensible handle
|
|
push ax ; save the operation
|
|
call fcb_get_count ; AX = bytes to read
|
|
push ax ; save byte count
|
|
call fcb_seek_seq ; Seek to position in the file
|
|
pop cx ; recover byte to xfer
|
|
pop ax ; and the Operation Code
|
|
jc fcb_seq_rw10
|
|
call fcb_rw ; do the Op
|
|
jc fcb_seq_rw10
|
|
push bx ; save the error code
|
|
call fcb_update_seq ; update FCB filepos
|
|
pop bx ; recover error
|
|
fcb_seq_rw10:
|
|
ret
|
|
|
|
fcb_rw:
|
|
; On Entry:
|
|
; AX = operation code
|
|
; CX = count
|
|
; fcb_pb+2 = IFN
|
|
; On Exit:
|
|
; BX = error code
|
|
les dx,ss:dword ptr dma_offset
|
|
add cx,dx ; see if we overflow
|
|
jc fcb_rw20
|
|
sub cx,dx ; count back to normal
|
|
push cx ; save target count
|
|
mov fcb_pb+4,dx
|
|
mov fcb_pb+6,es ; setup buffer address
|
|
mov fcb_pb+8,cx ; and target count
|
|
call fcb_fdos ; ask the FDOS to do the read/write
|
|
jc fcb_rw10 ; we got a real error...
|
|
push ds
|
|
push es
|
|
mov ax,fcb_pb+2 ; get IFN
|
|
call ifn2dhndl ; ES:BX -> DHNDL_ we have open
|
|
push es ! push bx ; save DHNDL_
|
|
call fcb_point ; ES:BX = FCB
|
|
pop si ! pop ds ; DS:SI -> DHNDL_
|
|
call fcb_update ; update file size/time-stamp
|
|
pop es
|
|
pop ds
|
|
pop ax ; recover target count
|
|
mov cx,fcb_pb+8 ; we xfered this much
|
|
cmp cx,ax ; did we xfer enough
|
|
jb fcb_rw30 ; nope..
|
|
xor bx,bx ; xfer went OK
|
|
ret
|
|
|
|
fcb_rw10:
|
|
pop ax ; discard target count
|
|
ret
|
|
|
|
fcb_rw20:
|
|
; Our DTA is too small - return 2
|
|
mov bx,2 ; indicate the DTA is too small
|
|
; stc ; error - don't update FCB
|
|
ret
|
|
|
|
fcb_rw30:
|
|
; We have some form of EOF - lets look into it
|
|
call fcb_point ; ES:BX = FCB
|
|
mov bx,es:MSF_RECSIZE[bx] ; BX = record size
|
|
mov ax,cx
|
|
xor dx,dx ; DX:AX = bytes xfer'd
|
|
div bx ; did we xfer a complete
|
|
test dx,dx ; number of records ?
|
|
jz fcb_rw40 ; if so return 1
|
|
; Partial data was read - fill out with zero's and return 3
|
|
inc ax ; allow for incomplete record
|
|
push ax ; save rounded up xfer count
|
|
les di,ss:dword ptr dma_offset
|
|
add di,cx ; point to 1st byte after xfer
|
|
mov cx,bx ; this many in a record
|
|
sub cx,dx ; so this many weren't xfer'd
|
|
xor ax,ax ; fill them with zero's
|
|
rep stosb ; zap the bytes we didn't xfer to
|
|
pop ax ; recover xfer count
|
|
mul bx ; and work out # bytes xfered
|
|
xchg ax,cx ; return bytes in CX
|
|
mov bx,3 ; indicate EOF (partial read)
|
|
; clc ; update FCB
|
|
ret
|
|
|
|
fcb_rw40:
|
|
; No Data was xfered - return 1
|
|
mov bx,1 ; indicate EOF (no data read)
|
|
; clc ; update FCB
|
|
ret
|
|
|
|
fcb_writerand:
|
|
;-------------
|
|
mov ax,MS_X_WRITE ; make it a write
|
|
jmps fcb_random_rw
|
|
|
|
fcb_readrand:
|
|
;------------
|
|
mov ax,MS_X_READ ; make it a read
|
|
fcb_random_rw:
|
|
call fcb_handle_vfy ; check the handle is OK
|
|
push ax ; save the code
|
|
call fcb_get_count ; AX = bytes to read
|
|
push ax ; save byte count
|
|
xor cx,cx ; cause update of seq posn from
|
|
call fcb_update_rr ; random record position
|
|
call fcb_seek_rr ; Seek to position in the file
|
|
pop cx ; recover byte to xfer
|
|
pop ax ; and the Operation Code
|
|
jc fcb_random_rw10
|
|
call fcb_rw ; do the Op
|
|
fcb_random_rw10:
|
|
ret
|
|
|
|
|
|
fcb_writeblk:
|
|
;------------
|
|
mov ax,MS_X_WRITE ; make it a write
|
|
jmps fcb_block_rw
|
|
|
|
fcb_readblk:
|
|
;-----------
|
|
mov ax,MS_X_READ ; make it a read
|
|
fcb_block_rw:
|
|
call fcb_handle_vfy ; check the handle is OK
|
|
push ax ; save the code
|
|
call fcb_get_count ; AX = bytes per record, CX = # records
|
|
xchg ax,cx ; CX = bytes per record
|
|
mul cx ; AX = bytes to xfer
|
|
test dx,dx ; more than 64K ?
|
|
jz fcb_block_rw10 ; then we should truncate it
|
|
mov ax,15 ; AX = handy mask
|
|
cwd ; DX = 0
|
|
and ax,ss:dma_offset ; get dma offset for para
|
|
not ax ; DX/AX = maximum bytes we can xfer
|
|
div cx ; AX = maximum blocks we can xfer
|
|
mul cx ; AX = bytes to xfer (now < 64K)
|
|
fcb_block_rw10:
|
|
push ax ; save byte count
|
|
call fcb_seek_rr ; Seek to position in the file
|
|
pop cx ; recover byte to xfer
|
|
pop ax ; and the Operation Code
|
|
jc fcb_block_rw20
|
|
call fcb_rw ; do the Op
|
|
jc fcb_block_rw20
|
|
push bx ; save the error code
|
|
call fcb_update_rr ; update FCB filepos, get records xferd
|
|
mov bx,2[bp] ; BX -> parameter block
|
|
xchg cx,6[bx] ; update amount xfered
|
|
sub cx,6[bx] ; CX = # we didn't xfer (normally 0)
|
|
pop bx ; recover (possible) error
|
|
jcxz fcb_block_rw20 ; skip if we read all we wanted to
|
|
test bx,bx ; did we have a partial read for
|
|
jnz fcb_block_rw20 ; a reason like EOF ?
|
|
mov bx,2 ; no, we must have truncated it
|
|
fcb_block_rw20:
|
|
ret
|
|
|
|
|
|
fcb_size:
|
|
;--------
|
|
call fcb_path_prep
|
|
mov ax,MS_X_CHMOD ; it's a get info
|
|
mov fcb_pb+6,0
|
|
call fcb_fdos
|
|
jc fcb_size40
|
|
call fcb_point ; ES:BX = FCB
|
|
mov cx,es:MSF_RECSIZE[bx] ; get the record size
|
|
test cx,cx ; is it non-zero ?
|
|
jnz fcb_size10 ; if not
|
|
mov cx,128 ; make it 128 bytes
|
|
fcb_size10:
|
|
mov ax,fcb_pb+10
|
|
mov dx,fcb_pb+12 ; DX:AX = file length in bytes
|
|
call div_32 ; DX:AX = file length in records
|
|
jcxz fcb_size20 ; was there an overflow
|
|
add ax,1
|
|
adc dx,0 ; include an extra record
|
|
fcb_size20:
|
|
call fcb_point ; ES:BX = FCB
|
|
mov es:MSF_RR[bx],ax ; low word of size
|
|
mov es:MSF_RR2[bx],dl ; hi byte of size
|
|
cmp es:MSF_RECSIZE[bx],64 ; if record size < 64 bytes
|
|
jae fcb_size30 ; then we use a 4 byte
|
|
mov es:MSF_RR2+1[bx],dh ; random record position
|
|
fcb_size30:
|
|
xor bx,bx ; good return
|
|
fcb_size40:
|
|
ret
|
|
|
|
|
|
; Utility FCB subroutines
|
|
;========================
|
|
|
|
fcb_handle_vfy:
|
|
;--------------
|
|
; Verify FCB is valid and open, do not return if it isn't
|
|
; nb. Called with nothing on stack
|
|
;
|
|
; On Entry:
|
|
; FCB address in parameter block
|
|
; On Exit:
|
|
; AX preserved
|
|
; ES:BX -> FCB (skipping EXT bit if present)
|
|
; fcb_pb+2 = IFN of handle
|
|
; On Error - blow away caller and return error in BX
|
|
;
|
|
|
|
; DEBUG - on reopen we could do more checks to ensure we are re-opening the
|
|
; same file
|
|
push ax
|
|
call fcb_point
|
|
cmp es:MSF_RECSIZE[bx],0
|
|
jne fcb_handle_vfy10
|
|
mov es:MSF_RECSIZE[bx],128
|
|
fcb_handle_vfy10:
|
|
mov al,es:MSF_IFN[bx] ; get IFN
|
|
call ifn2dhndl ; ES:BX -> DHNDL_
|
|
jc fcb_handle_vfy20 ; it must be a valid IFN
|
|
test es:DHNDL_MODE[bx],DHM_FCB
|
|
jz fcb_handle_vfy20 ; it must be an FCB..
|
|
cmp es:DHNDL_COUNT[bx],0
|
|
jne fcb_handle_vfy30 ; it must also be open..
|
|
fcb_handle_vfy20:
|
|
call fcb_point
|
|
push es:MSF_RECSIZE[bx] ; save current record size
|
|
push es:MSF_BLOCK[bx] ; save current block number
|
|
push es ! push bx
|
|
call fcb_open ; try to re-open the file
|
|
pop bx ! pop es ; point back at FCB
|
|
pop es:MSF_BLOCK[bx] ; restore current block number
|
|
pop es:MSF_RECSIZE[bx] ; restore record size
|
|
jc fcb_handle_err
|
|
mov al,es:MSF_IFN[bx] ; get new IFN
|
|
fcb_handle_vfy30:
|
|
xor ah,ah
|
|
mov fcb_pb+2,ax ; set parameter block accordingly
|
|
call fcb_point ; ES:BX -> MSF_
|
|
pop ax
|
|
clc
|
|
ret
|
|
|
|
fcb_handle_err:
|
|
add sp,2*WORD ; discard AX and near return address
|
|
cmp ax,ED_HANDLE ; if we have run out of handles then
|
|
jne fcb_handle_err10 ; say no FCB's, else return error
|
|
mov ax,ED_NOFCBS
|
|
fcb_handle_err10:
|
|
xchg ax,bx ; error code in BX
|
|
stc
|
|
ret
|
|
|
|
|
|
fcb_path2_prep:
|
|
;--------------
|
|
; On Entry:
|
|
; FCB address in parameter block
|
|
; On Exit:
|
|
; ES:BX -> FCB (skipping EXT bit if present)
|
|
; fcb_pb+6/8 -> unparse name from FCB
|
|
;
|
|
call fcb_point ; point at the FCB
|
|
mov al,es:MSF_DRIVE[bx] ; get drive
|
|
add bx,16 ; point at 2nd name in FCB
|
|
mov di,offset fcb_path2
|
|
mov fcb_pb+6,di
|
|
mov fcb_pb+8,ds ; point at buffer we want
|
|
jmps fcb_path_prep_common
|
|
|
|
fcb_path_prep:
|
|
;-------------
|
|
; On Entry:
|
|
; FCB address in parameter block
|
|
; On Exit:
|
|
; ES:BX -> FCB (skipping EXT bit if present)
|
|
; fcb_pb+2/4 -> unparse name from FCB
|
|
;
|
|
xor ax,ax ; assume no attribute
|
|
mov bx,2[bp] ; BX -> parameter block
|
|
les bx,2[bx] ; ES:BX -> FCB
|
|
cmp es:MSF_EXTFLG[bx],0ffh ; is it an extended FCB
|
|
jne fcb_path_prep10
|
|
or al,es:MSF_ATTRIB[bx] ; we can use file mode from XFCB
|
|
add bx,7 ; skip EXT bit of FCB
|
|
fcb_path_prep10:
|
|
mov fcb_pb+8,ax ; remember the attribute
|
|
mov al,es:MSF_DRIVE[bx] ; get drive
|
|
mov di,offset fcb_path
|
|
mov fcb_pb+2,di
|
|
mov fcb_pb+4,ds ; point at buffer we want
|
|
fcb_path_prep_common:
|
|
dec al ; 0 = default drive
|
|
jns fcb_path_prep20
|
|
mov al,current_dsk ; use default drive
|
|
fcb_path_prep20:
|
|
push ds
|
|
push ds ! push es
|
|
pop ds ! pop es ; ES:DI -> name buffer
|
|
add al,'A' ; make drive ASCII
|
|
stosb
|
|
mov al,':'
|
|
stosb ; now we have 'd:'
|
|
lea si,MSF_NAME[bx] ; DS:SI -> source name
|
|
movsw ! movsw
|
|
movsw ! movsw ; copy the name leaving spaces intact
|
|
mov al,'.'
|
|
stosb
|
|
movsw ! movsb ; copy the extention
|
|
pop ds
|
|
; jmps fcb_point ; point ES:BX at FCB again
|
|
|
|
|
|
fcb_point:
|
|
;---------
|
|
; On Entry:
|
|
; FCB address in parameter block
|
|
; On Exit:
|
|
; ES:BX -> FCB (skipping EXT bit if present)
|
|
; (All other regs preserved)
|
|
;
|
|
mov bx,2[bp] ; BX -> parameter block
|
|
les bx,2[bx] ; ES:BX -> FCB
|
|
cmp es:MSF_EXTFLG[bx],0ffh ; is it an extended FCB
|
|
jne fcb_point10
|
|
add bx,7 ; skip EXT bit of FCB
|
|
fcb_point10:
|
|
ret
|
|
|
|
fcb_get_count:
|
|
;-------------
|
|
; On Entry:
|
|
; none
|
|
; On Exit:
|
|
; AX = bytes per record
|
|
; CX = callers CX count
|
|
; All regs fair game
|
|
;
|
|
call fcb_point ; ES:BX -> FCB
|
|
mov si,2[bp] ; SI -> parameter block
|
|
mov cx,6[si] ; CX = count
|
|
mov ax,es:MSF_RECSIZE[bx] ; get record size
|
|
ret
|
|
|
|
fcb_update_seq:
|
|
;--------------
|
|
; On Entry:
|
|
; CX = byte count actually transferred
|
|
; On Exit:
|
|
; CX = record count transferred
|
|
; All other regs fair game
|
|
; CR/BLOCK updated with new value
|
|
;
|
|
mov ax,cx
|
|
xor dx,dx ; DX:AX = byte count transfered
|
|
call fcb_point ; ES:BX -> FCB
|
|
div es:MSF_RECSIZE[bx] ; make records xfered
|
|
push ax ; save records xfered
|
|
xchg ax,cx ; also in CX for later
|
|
mov ax,128
|
|
mul es:MSF_BLOCK[bx] ; DX:AX = record of block
|
|
add ax,cx
|
|
adc dx,0 ; add in amount just xfered
|
|
mov cl,es:MSF_CR[bx]
|
|
xor ch,ch ; now add in CR as a word
|
|
add ax,cx
|
|
adc dx,0 ; DX:AX = record
|
|
mov dh,dl ; DH:AX = record for common code
|
|
jmps fcb_update_common
|
|
|
|
|
|
fcb_update_rr:
|
|
;-------------
|
|
; On Entry:
|
|
; CX = byte count actually transferred
|
|
; On Exit:
|
|
; CX = record count transferred
|
|
; All other regs fair game
|
|
; Random Record and CR/BLOCK updated with new value
|
|
;
|
|
xchg ax,cx
|
|
xor dx,dx ; DX:AX = byte count transfered
|
|
call fcb_point ; ES:BX -> FCB
|
|
div es:MSF_RECSIZE[bx] ; make records xfered
|
|
push ax ; save records xfered
|
|
add es:MSF_RR[bx],ax ; update the RR field
|
|
adc es:MSF_RR2[bx],0 ; and the overflow
|
|
mov ax,es:MSF_RR[bx] ; get low part of RR
|
|
mov dh,es:MSF_RR2[bx] ; and the hi part
|
|
fcb_update_common:
|
|
mov dl,ah ; DX will be block number
|
|
shl al,1 ; get top bit of CR into CY
|
|
adc dx,dx ; then into DX
|
|
shr al,1 ; AL = CR (remember mod 128)
|
|
mov es:MSF_CR[bx],al ; set the CR field
|
|
mov es:MSF_BLOCK[bx],dx ; and the block field
|
|
pop cx ; recover records xfered
|
|
ret
|
|
|
|
|
|
fcb_seek_seq:
|
|
;------------
|
|
; Seek to position in file indicated by the RR position
|
|
; On Entry:
|
|
; ES:BX -> FCB_
|
|
; On Exit:
|
|
; CY clear if no problem, fcb_pb+2=IFN
|
|
; else
|
|
; CY set, AX = BX = error code
|
|
; All other regs fair game
|
|
;
|
|
call fcb_point ; ES:BX -> FCB_
|
|
mov ax,128
|
|
mul es:MSF_BLOCK[bx] ; get record in DX:AX
|
|
mov cl,es:MSF_CR[bx]
|
|
xor ch,ch
|
|
add ax,cx ; add in CR
|
|
adc dx,0 ; so DX:AX is really the record
|
|
push ax ; save low word of record
|
|
mov ax,dx
|
|
mul es:MSF_RECSIZE[bx] ; DX:AX = byte offset in file/10000h
|
|
mov cx,ax ; save the important word
|
|
pop ax ; recover low word of record
|
|
jmps fcb_seek_common
|
|
|
|
fcb_seek_rr:
|
|
;-----------
|
|
; Seek to position in file indicated by the RR position
|
|
; On Entry:
|
|
; ES:BX -> FCB_
|
|
; On Exit:
|
|
; CY clear if no problem, fcb_pb+2=IFN
|
|
; else
|
|
; CY set, AX = BX = error code
|
|
; All other regs fair game
|
|
;
|
|
call fcb_point ; ES:BX -> FCB_
|
|
mov al,es:MSF_RR2[bx]
|
|
xor ah,ah
|
|
mul es:MSF_RECSIZE[bx] ; DX:AX = byte offset in file/10000h
|
|
mov cx,ax ; save the important word
|
|
mov ax,es:MSF_RR[bx]
|
|
fcb_seek_common:
|
|
mul es:MSF_RECSIZE[bx] ; DX:AX = byte offset in file
|
|
add dx,cx ; add the two bits together
|
|
mov fcb_pb+4,ax
|
|
mov fcb_pb+6,dx ; save position
|
|
mov fcb_pb+8,0 ; seek from start
|
|
xor ax,ax
|
|
mov al,es:MSF_IFN[bx] ; AX = IFN
|
|
mov fcb_pb+2,ax ; save IFN
|
|
mov ax,MS_X_LSEEK
|
|
jmp fcb_fdos ; try and seek to this position
|
|
|
|
|
|
fcb_search:
|
|
;----------
|
|
; On Entry:
|
|
; AX = operation to perform
|
|
; On Exit:
|
|
; AX = 0, or ED_ error code (CY set if error)
|
|
push dma_offset
|
|
push dma_segment
|
|
mov dma_offset,offset fcb_search_buf
|
|
mov dma_segment,ds
|
|
call fcb_fdos ; do the search
|
|
pop dma_segment
|
|
pop dma_offset
|
|
test ax,ax ; was there an error
|
|
stc ; assume there was
|
|
js fcb_search10 ; return the error
|
|
xor ax,ax ; no problems
|
|
fcb_search10:
|
|
ret
|
|
|
|
fcb_save_search_state:
|
|
;---------------------
|
|
; On entry DS=PCMODE
|
|
|
|
call fcb_point
|
|
lea di,MSF_NAME[bx] ; ES:DI -> FCB name
|
|
mov si,offset fcb_search_buf
|
|
lodsb ; get 1st byte = drive info
|
|
mov cx,20/WORD ; copy 20 bytes to FCB
|
|
rep movsw ; (the rest of the search template)
|
|
stosb ; drive info byte follow them
|
|
|
|
les di,dword ptr dma_offset ; ES:DI -> search state in DMA address
|
|
mov si,2[bp] ; SI -> parameter block
|
|
lds si,2[si] ; DS:SI -> FCB_
|
|
cmp ds:MSF_EXTFLG[si],0ffh ; extended FCB ?
|
|
jne fcb_sss10
|
|
mov cx,7 ; copy extended FCB portions too
|
|
rep movsb ; we have copied up to name
|
|
fcb_sss10:
|
|
stosb ; save drive byte info
|
|
push di
|
|
mov al,' ' ; space fill name
|
|
mov cx,11
|
|
rep stosb ; all blanks now
|
|
pop di
|
|
push ss ! pop ds ; DS:SI -> pathname
|
|
mov si,offset fcb_search_buf+1Eh
|
|
|
|
push di ; unparse knowing name is good
|
|
mov cx,8 ; length of name field
|
|
fcb_sss20:
|
|
lodsb ; treat '.' and '..' specially
|
|
cmp al,'.' ; is either possible ?
|
|
jne fcb_sss30 ; no, continue as normal
|
|
stosb ; copy the '.'
|
|
loop fcb_sss20 ; go around for another '.'
|
|
jmps fcb_sss40 ; this name is rubbish!!
|
|
fcb_sss30:
|
|
dec si ; forget the non '.'
|
|
call parse_one ; parse just the name
|
|
fcb_sss40:
|
|
pop di
|
|
add di,8 ; di -> fcb ext field
|
|
cmp al,'.' ; do we have an extention ?
|
|
jne fcb_sss50
|
|
mov cx,3 ; length of ext field
|
|
push di
|
|
call parse_one ; parse just extension
|
|
pop di
|
|
fcb_sss50:
|
|
add di,3 ; di -> rest of fcb
|
|
mov si,offset fcb_search_buf+15h
|
|
movsb ; copy the attribute field
|
|
xor ax,ax
|
|
mov cx,10/WORD
|
|
rep stosw ; 10 bytes of zeros
|
|
movsw ; copy time
|
|
movsw ; copy date
|
|
mov ax,word ptr srch_buf+21+DBLOCK1
|
|
stosw ; 1st block
|
|
movsw ! movsw ; copy filesize
|
|
ret
|
|
|
|
fcb_restore_search_state:
|
|
;------------------------
|
|
; On entry DS=PCMODE
|
|
push ds
|
|
call fcb_point ; ES:BX -> FCB_
|
|
push es ! push ds
|
|
pop es ! pop ds ; swap DS/ES
|
|
mov di,offset fcb_search_buf+1
|
|
; ES:DI -> internal state
|
|
lea si,1[bx] ; DS:SI -> FCB+1
|
|
mov cx,10
|
|
rep movsw ; copy info from FCB
|
|
lodsb ; get "drive" info
|
|
mov es:fcb_search_buf,al ; it's the 1st byte in the srch state
|
|
pop ds
|
|
ret
|
|
|
|
fcb_fdos:
|
|
;--------
|
|
; Make an FDOS call (NB. We don't have MX here, so it's OK)
|
|
; Set top bit of remote_call flag so we use IFN's not XFN's
|
|
; On Entry:
|
|
; AX = FDOS operation
|
|
; fcb_pb -> FDOS parameter block
|
|
; On Exit:
|
|
; As FDOS call
|
|
;
|
|
mov fcb_pb,ax ; save operation type
|
|
or remote_call,DHM_FCB ; forget about PSP during FCB call
|
|
mov dx,offset fcb_pb ; DS:DX -> parameter block
|
|
push ds
|
|
push bp
|
|
call fdos_entry ; call the FDOS
|
|
pop bp
|
|
pop ds
|
|
and remote_call,not DHM_FCB ; FCB operation over
|
|
cmp ax,ED_LASTERROR
|
|
cmc ; CY set if an error occurred
|
|
ret
|
|
|
|
div_32:
|
|
; Entry: DX,AX = long dividend
|
|
; CX = word divisor
|
|
; Exit: DX,AX = long result
|
|
; CX = remainder
|
|
|
|
jcxz div0 ; divide by 0
|
|
cmp cx,1
|
|
je div1 ; divide by 1
|
|
push di
|
|
push bx
|
|
xor bx,bx ; BX = 0
|
|
xchg ax,bx ; low word in BX, AX = 0
|
|
xchg ax,dx ; high word in DX:AX
|
|
push ax ; save high word
|
|
div cx ; divide high part
|
|
mov di,ax ; save result
|
|
mul cx ; AX = even divisor part
|
|
pop dx ; old high in DX
|
|
sub dx,ax ; eliminate even part
|
|
xchg ax,bx ; AX = low word
|
|
div cx ; low part in AX
|
|
mov cx,dx ; CX = remainder
|
|
mov dx,di ; high result in DX
|
|
pop bx
|
|
pop di
|
|
ret
|
|
|
|
div0:
|
|
mov ax,-1
|
|
mov dx,ax
|
|
ret
|
|
div1:
|
|
dec cx ; CX = remainder = 0
|
|
ret
|
|
|
|
|
|
PCMODE_DATA DSEG WORD
|
|
|
|
extrn fcb_pb:word
|
|
extrn fcb_path:byte
|
|
extrn fcb_path2:byte
|
|
extrn fcb_search_buf:byte
|
|
|
|
extrn current_dsk:byte
|
|
extrn current_psp:word
|
|
extrn dma_offset:word
|
|
extrn dma_segment:word
|
|
extrn machine_id:word
|
|
extrn remote_call:word
|
|
extrn srch_buf:byte
|
|
|
|
end
|