Power-Programmierung/CD1.mdf/lan/basnet/ibasneta.asm

Assembly Source File | 1987-06-12 | 27KB | 1,550 lines

SegZero segment at    0H
        ORG    4f0h        ;Intra-application comm area

ComArea_Off    dw    ?        ;Vector pointing to permanent
ComArea_Seg    dw    ?        ;BASIC subroutine.
SegZero     ends


grp    GROUP    AAAA,RLOADER



AAAA    SEGMENT 'CODE'

    jmp    far ptr Loader

AAAA    ends

public    loader,xtndopn,setattr,eojstat,PRLH_Log,PRLH_Rel,PRLH_Clr
public    PRLF_Log, PRLF_Rel,PRLF_Clr,PRLS_Lck,PRLS_Rel,PRLS_Clr
public    OpenSem,ExamSem,WaitSem,SigSem,ClosSem,setlck,TTS,BLFTran
public    ELFTran,exclog,exclcks,exculkf,exculks,excclrs,reclog,reclck
public    reculk,reculks,recclr,recclrs,eoj,sysout,allocr,dallocr,volstat
public    locdrv,wsid,errmode,bcsmode,ctlspl,splreq,pipreq,dpath,syslog
public    fattr,updfcb,cpyfile,nettod,clsmode,drvmap,retshl,asclog,asculkf
public    ascclrf,Get_PSN,Get_STA,SetServ,ModServ,GetDrv,setspl,loglck

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;                    ;
;    INTERFACE CODE AREA        ;
;                    ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


subseg    segment para public 'CODE'
    assume cs:subseg


;     vector table - starts at 0000, with each ensuing call
;    offset by 3 (the jmp instruction and an offset address)
Subrt:    jmp    near ptr xtndopn
    jmp    near ptr setattr
    jmp    near ptr eojstat
    jmp    near ptr PRLH_Log
    jmp    near ptr PRLH_Rel
    jmp    near ptr PRLH_Clr
    jmp    near ptr PRLF_Log
    jmp    near ptr PRLF_Rel
    jmp    near ptr PRLF_Clr
    jmp    near ptr PRLS_Lck
    jmp    near ptr PRLS_Rel
    jmp    near ptr PRLS_Clr
    jmp    near ptr OpenSem
    jmp    near ptr ExamSem
    jmp    near ptr WaitSem
    jmp    near ptr SigSem
    jmp    near ptr ClosSem
    jmp    near ptr setlck
    jmp    near ptr TTS
    jmp    near ptr BLFTran
    jmp    near ptr ELFTran
    jmp    near ptr exclog
    jmp    near ptr exclcks
    jmp    near ptr exculkf
    jmp    near ptr exculks
    jmp    near ptr excclrf
    jmp    near ptr excclrs
    jmp    near ptr reclog
    jmp    near ptr reclck
    jmp    near ptr reculk
    jmp    near ptr reculks
    jmp    near ptr recclr
    jmp    near ptr recclrs
    jmp    near ptr eoj
    jmp    near ptr sysout
    jmp    near ptr allocr
    jmp    near ptr dallocr
    jmp    near ptr volstat
    jmp    near ptr locdrv
    jmp    near ptr wsid
    jmp    near ptr errmode
    jmp    near ptr bcsmode
    jmp    near ptr ctlspl
    jmp    near ptr splreq
    jmp    near ptr pipreq
    jmp    near ptr dpath
    jmp    near ptr syslog
    jmp    near ptr fattr
    jmp    near ptr updfcb
    jmp    near ptr cpyfile
    jmp    near ptr nettod
    jmp    near ptr clsmode
    jmp    near ptr drvmap
    jmp    near ptr retshl
    jmp    near ptr asclog
    jmp    near ptr asculkf
    jmp    near ptr ascclrf
    jmp    near ptr Get_PSN
    jmp    near ptr Get_STA
    jmp    near ptr SetServ
    jmp    near ptr ModServ
    jmp    near ptr GetDrv
    jmp    near ptr setspl
    jmp    near ptr loglck


;--------------------------------
; Extended Open a File func(61) (3DH)
;
; call xtndopn(Mode%, Filename$, Handle%, ErrCode%)
;

xtndopn proc    far
    push    bp
    mov    bp,sp
    mov    si,[bp+12]  ; put the mode in ax
    mov    ax,[si]
    mov    ah,03Dh     ; put the function in ah
    mov    di,[bp+10]  ;ptr to var desc block for ASCIIZ string
    mov    dx,[di+1]   ;add 1 to get the address of the string
                ;put it in dx
    int    21h
    jnc    noerr
    mov    di,[bp+6]
    mov    [di],ax
    jmp    quit
noerr:
    mov    di,[bp+8]   ;put the handle into the variable
    mov    [di],ax      ;if there is no error
    xor    ax,ax
    mov    di,[bp+6]    ;return a 0 if there is no error
    mov    [di],ax
quit:
    pop    bp
    ret    8
xtndopn endp


;--------------------------------
; Get or Set File Attributes(handle) func(67) (43H)
;
; call setattr(Func%, Filename$, Attribute%, ErrCode%)
;


setattr proc    far
    push    bp
    mov    bp,sp
    mov    si,[bp+12]  ; put the subfunction in ax
    mov    ax,[si]
    mov    ah,043h     ; put the function in ah
    mov    si,[bp+10]  ;ptr to var desc block for ASCIIZ string
    mov    dx,[si+1]   ;add 1 to get the address of the string
                ;put it in dx
    mov    si,[bp+8]  ;put the attribute to set in cx
    mov    cx,[si]
    int    21h
    jnc    okay
    mov    di,[bp+6]
    mov    [di],ax
    jmp    getout
okay:
    mov    di,[bp+8]   ;put the returned attributes in the
    mov    [di],cx      ;variable if there is no error
    xor    ax,ax
    mov    di,[bp+6]    ;return a 0 error code if there is no error
    mov    [di],ax
getout:
    pop    bp
    ret    8
setattr endp

;--------------------------------
; End of Job Flag Status func(187) (BBH)
;
; call eojstat(Flag%)
;

eojstat proc    far
    push    bp
    mov    bp,sp
    mov    si,[bp+6]   ; put the flag in ax
    mov    ax,[si]
    mov    ah,0BBh     ; put the function in ah
    int    21h
    mov    ah,0
    mov    di,[bp+6]
    mov    [di],ax
    pop    bp
    ret    2
eojstat endp


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; Physical Record Lock: Log Record   BCH
;
; call PRLH_Log(FileHandle%,HiByteOffset%,LoByteOffset%,HiLockLen%,
;        LoLockLen%,Flags%,TimeOut%,ErrCode%);
;
PRLH_Log proc    far
    push    bp
    mov    bp,sp

    mov    si,[bp+20]        ;FileHandle
    mov    bx,[si]
    mov    si,[bp+18]        ;ByteOffset
    mov    cx,[si]
    mov    si,[bp+16]
    mov    dx,[si]
    mov    si,[bp+10]        ;AL = Log Flags
    mov    ax,[si]
    mov    si,[bp+14]        ;LockLen
    mov    si,[si]
    mov    di,[bp+12]
    mov    di,[di]
    push    bp
    mov    bp,[bp+8]           ;time out
    mov    bp,[bp]
    mov    ah,0BCH
    int    21H
    pop    bp
    mov    ah,0
    mov    di,[bp+6]        ;return code
    mov    [di],ax
    pop    bp
    ret    16

PRLH_Log endp



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; Physical Record Lock: Release Rec  BDH
;
; call PRLH_Rel(FileHandle%,HiByteOffset%,LoByteOffset%,ErrCode%);
;
PRLH_Rel proc    far
    push    bp
    mov    bp,sp

    mov    si,[bp+12]        ;FileHandle
    mov    bx,[si]
    mov    si,[bp+10]        ;ByteOffset
    mov    cx,[si]
    mov    si,[bp+8]
    mov    dx,[si]
    mov    ah,0BDH
    int    21H
    mov    ah,0
    mov    di,[bp+6]        ;return code
    mov    [di],ax
    pop    bp
    ret    8

PRLH_Rel endp



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; Physical Record Lock: Release Clr  BEH
;
; call PRLH_Clr(FileHandle%,HiByteOffset%,LoByteOffset%,Errcode%);
;
PRLH_Clr proc    far
    push    bp
    mov    bp,sp

    mov    si,[bp+12]        ;FileHandle
    mov    bx,[si]
    mov    si,[bp+10]        ;ByteOffset
    mov    cx,[si]
    mov    si,[bp+8]
    mov    dx,[si]
    mov    ah,0BEH
    int    21H
    mov    ah,0
    mov    di,[bp+6]        ;return code
    mov    [di],ax
    pop    bp
    ret    8

PRLH_Clr endp


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; Physical Record Lock: Log Rec FCB BFH
;
; call PRLF_Log(fcb%,HiByteOffset%,LoByteOffset%,HiLockLen%,LoLockLen%,Flags%,TimeOut%,ErrCode%);
;
PRLF_Log proc    far
    push    bp
    mov    bp,sp

    mov    si,[bp+20]          ;FCB
    mov    dx,[si+1]
    mov    si,[bp+18]          ;ByteOffset
    mov    bx,[si]
    mov    si,[bp+16]
    mov    cx,[si]
    mov    si,[bp+10]          ;AL = Log Flags
    mov    ax,[si]
    mov    si,[bp+12]          ;low lock length
    mov    di,[si]
    mov    si,[bp+14]          ;hi lock length
    mov    si,[si]
    push    bp
    mov    bp,[bp+8]         ;timeout value
    mov    bp,[bp]

    mov    ah,0BFH
    int    21H
    pop    bp
    mov    ah,0
    mov    di,[bp+6]          ;return code
    mov    [di],ax
    pop    bp
    ret    16
PRLF_Log endp



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; Physical Record Lock: Rel Rec FCB C0H
;
; call PRLF_Rel(fcb%,HiByteOffset%,LoByteOffset%,ErrCode%);
;
PRLF_Rel proc    far
    push    bp
    mov    bp,sp

    mov    si,[bp+12]          ;FCB
    mov    dx,[si+1]
    mov    si,[bp+10]          ;ByteOffset
    mov    bx,[si]
    mov    si,[bp+8]
    mov    cx,[si]
    mov    ah,0C0H
    int    21H
    mov    ah,0
    mov    di,[bp+6]          ;return code
    mov    [di],ax
    pop    bp
    ret    8
PRLF_Rel endp



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; Physical Record Lock: Clr Rec FCB C1H
;
; call PRLF_Clr(fcb%,HiByteOffset%,LoByteOffset%,ErrCode%);
;
PRLF_Clr proc    far
    push    bp
    mov    bp,sp

    mov    si,[bp+12]          ;FCB
    mov    dx,[si+1]
    mov    si,[bp+10]          ;ByteOffset
    mov    bx,[si]
    mov    si,[bp+8]
    mov    cx,[si]

    mov    ah,0C1H
    int    21H
    mov    ah,0
    mov    di,[bp+6]        ;return code
    mov    [di],ax
    pop    bp
    ret    8
PRLF_Clr endp


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; Lock Record Set  C2H
;
; call PRLS_Lck(Flags%,TimeOut%,ErrCode%);
;
PRLS_Lck proc    far
    push    bp
    mov    bp,sp
    mov    si,[bp+10]        ;AL = Lock flag bits
    mov    ax,[si]
    mov    si,[bp+8]           ;TimeOut Value
    push    bp
    mov    bp,[si]

    mov    ah,0C2h
    int    21h
    pop    bp
    mov    ah,0
    mov    di,[bp+6]        ;return code
    mov    [di],ax
    pop    bp
    ret    6
PRLS_Lck endp



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; Release Record Set  C3H
;
; call PRLS_Rel(ErrCode%);
;
PRLS_Rel proc    far
    push    bp
    mov    bp,sp

    mov    ah,0C3h
    int    21h
    mov    ah,0
    mov    di,[bp+6]
    mov    [di],ax
    pop    bp
    ret    2
PRLS_Rel endp



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; Clear Record Set  C4H
;
; call PRLS_Clr(ErrCode%);
;
PRLS_Clr proc    far
    push    bp
    mov    bp,sp

    mov    ah,0C4h
    int    21h
    mov    ah,0
    mov    di,[bp+6]        ;return code
    mov    [di],ax
    pop    bp
    ret    2
PRLS_Clr endp


;--------------------------------
; Semaphores func(197) (C5H) subfunction 00h
;
; call OpenSem(Sema4$,SemaValu%,HiHandle%,LoHandle%,OpenCnt%,RetCode%)
;

OpenSem proc    far
    push    bp
    mov    bp,sp
    mov    si,[bp+16]  ;ptr to var desc block for Semaphore string
    mov    dx,[si+1]   ;add 1 to get the address of the string
                ;put it in dx
    mov    si,[bp+14]  ;set semaphore value
    mov    cx,[si]
    mov    ax,0C500h    ;set the function
    int    21h
    mov    bh,00h
    mov    di,[bp+8]  ;return the open count
    mov    [di],bx
    mov    di,[bp+10]  ;return low handle
    mov    [di],cx
    mov    di,[bp+12]  ;return high handle
    mov    [di],dx
    mov    ah,00h
    mov    di,[bp+6]   ;return code
    mov    [di],ax
    pop    bp
    ret    12
OpenSem endp


;--------------------------------
; Semaphores func(197) (C5H) subfunction 01h
;
; call ExamSem(HiHandle%,LoHandle%,SemaValu%,OpenCnt%,RetCode%)
;

ExamSem proc    far
    push    bp
    mov    bp,sp
    mov    si,[bp+14]        ;hi handle
    mov    dx,[si]
    mov    si,[bp+12]        ;lo handle
    mov    cx,[si]
    mov    ax,0C501h         ;set function
    int    21h
    mov    di,[bp+10]        ;return semaphore value
    mov    [di],cx
    mov    dh,00h
    mov    di,[bp+8]
    mov    [di],dx          ;return open count
    mov    ah,00h
    mov    di,[bp+6]        ;return code
    mov    [di],ax
    pop    bp
    ret    10
ExamSem endp


;--------------------------------
; Semaphores func(197) (C5H) subfunction 02h
;
; call WaitSem(HiHandle%,LoHandle%,TimeOut%,RetCode%)
;

WaitSem proc    far
    push    bp
    mov    bp,sp
    mov    si,[bp+12]        ;hi handle
    mov    dx,[si]
    mov    si,[bp+10]        ;lo handle
    mov    cx,[si]
    mov    si,[bp+8]
    push    bp
    mov    bp,[si]          ;set time out
    mov    ax,0C502h         ;set function
    int    21h
    pop    bp
    mov    ah,00h
    mov    di,[bp+6]        ;return code
    mov    [di],ax
    pop    bp
    ret    8
WaitSem endp


;--------------------------------
; Semaphores func(197) (C5H) subfunction 03h
;
; call SigSem(HiHandle%,LoHandle%,RetCode%)
;

SigSem    proc    far
    push    bp
    mov    bp,sp
    mov    si,[bp+10]        ;hi handle
    mov    dx,[si]
    mov    si,[bp+8]           ;lo handle
    mov    cx,[si]
    mov    ax,0C503h         ;set function
    int    21h
    mov    ah,00h
    mov    di,[bp+6]        ;return code
    mov    [di],ax
    pop    bp
    ret    6
SigSem    endp


;--------------------------------
; Semaphores func(197) (C5H) subfunction 04h
;
; call ClosSem(HiHandle%,LoHandle%,RetCode%)
;

ClosSem proc    far
    push    bp
    mov    bp,sp
    mov    si,[bp+10]        ;hi handle
    mov    dx,[si]
    mov    si,[bp+8]           ;lo handle
    mov    cx,[si]
    mov    ax,0C504h         ;set function
    int    21h
    mov    ah,00h
    mov    di,[bp+6]
    mov    [di],ax           ;return code
    pop    bp
    ret    6
ClosSem endp


;--------------------------------
; Get or Set Lock Mode func(198) (C6H)
;
; call setlck(Func%,Mode%)
;

setlck    proc    far
    push    bp
    mov    bp,sp
    mov    si,[bp+8]
    mov    ax,[si]           ;set the subfunction
    mov    ah,0C6h          ;set  the function
    int    21h
    mov    ah,0
    mov    di,[bp+6]
    mov    [di],ax         ;return the mode
    pop    bp
    ret    4
setlck endp

;--------------------------------
; Transactional Calls (C7H)
;
; call TTS(Func%,RetCode%)
;

TTS    proc    far
    push    bp
    mov    bp,sp
    mov    si,[bp+8]           ;set the subfunction
    mov    ax,[si]
    mov    ah,0C7h          ;set  the function
    int    21h
    mov    ah,0
    mov    di,[bp+6]
    mov    [di],ax          ;set the return
    pop    bp
    ret    4
TTS    endp


;--------------------------------
; Begin Logical File Transaction
; func(200) (C8H)
;
; call BLFtran(ReturnCode%, Mode%)
;

BLFTran    proc    far
    mov    ah,0C8h
    call    arg1
    ret    4
BLFTran    endp



;--------------------------------
; End Logical File Transaction
; func(201) (C9H)
;
; call ELFtran(ReturnCode%)
;

ELFTran    proc    far
    mov    ah,0C9H
    call    arg0
    ret    2
ELFTran    endp


;--------------------------------
; Exc.log File (202) (CA)
;
; call exclog(ReturnCode%, fcb$)
;

exclog    proc    far
    mov    ah,0CAH
    call    arg1f
    ret    4
exclog    endp


;--------------------------------
; Exc Lock Set    func(203) (CBH)
;
; call exclcks(ReturnCode%, Mode%)
;

exclcks proc    far
    mov    ah,0CBH
    call    arg1
    ret    4
exclcks endp



;--------------------------------
; Exclusive file unlock (204) (CC)
;
; call exculkf(ReturnCode%, fcb$)
;

exculkf proc    far
    mov    ah,0CCH
    call    arg1f
    ret    4
exculkf endp



;--------------------------------
; Exclusive Unlock Set (205)(CD)
;
; call exculks(ReturnCode%)
;

exculks proc    far
    mov    ah,0CDH
    call    arg0
    ret    2
exculks endp



;--------------------------------
; Exc Clear file func(206) (CEH)
;
; call excclrf(ReturnCode%, fcb$)
;

excclrf proc    far
    mov    ah,0CEH
    call    arg1f
    ret    4
excclrf endp



;--------------------------------
; Exc Clear Set  func(207) (CFH)
;
; call excclrs(ReturnCode%)
;

excclrs proc    far
    mov    ah,0CFH
    call    arg0
    ret    2
excclrs endp



;--------------------------------
; Log Record(s) func(208) (D0H)
;
; call reclog(ReturnCode%,String$,Flags%,Timeout%)
;

reclog    proc    far
    mov    ah,0D0H
    call    arg1a
    ret    4
reclog    endp

;---------------------------------
; Record Lock func(209) (D1H)  for both old and new lock modes
;
; call reclck(ReturnCode%, Mode%)
;

reclck    proc    far
    push    bp
           mov    bp,sp
           mov     ah,0C6h
    mov    al,02h
    int    21h
    cmp    al,01
    je    newmd
    mov    ah,0D1H
    call    arg1
    jmp    finish
newmd:
    push    bp
    mov    ah,0D1h
    mov    si,[bp+6]
    mov    bp,[si]
    int    21h
    pop    bp
    mov    ah,0
    mov    di,[bp+8]
    mov    [di],ax
finish:
    pop    bp
    ret    4

reclck    endp



;--------------------------------
; Record Unlock func(210) (D2H)
;
; call reculk(ReturnCode%,String$)
;

reculk    proc    far
    mov    ah,0D2H
    call    arg1a
    ret    4
reculk    endp



;--------------------------------
; Unlock Record Set func(211) (D3H)
;
; call reculks(ReturnCode%)
;

reculks proc    far
    mov    ah,0D3H
    call    arg0
    ret    2
reculks endp



;--------------------------------
; Record Clear func(212) (D4H)
;
; call recclr(ReturnCode%, Semaphore$)
;

recclr    proc    far
    mov    ah,0D4H
    call    arg1a
    ret    4
recclr    endp



;--------------------------------
; Clear record set func(213) (D5H)
;
; call recclrs(ReturnCode%)
;

recclrs proc    far
    mov    ah,0D5H
    call    arg0
    ret    2
recclrs endp



;--------------------------------
; End of Job  func(214) (D6H)
;
; call eoj(ReturnCode%)
;

eoj    proc    far
    mov    ah,0D6H
    call    arg0
    ret    2
eoj    endp



;--------------------------------
; Logout System  func(215) (D7H)
;
; call sysout(ReturnCode%)
;

sysout    proc    far
    mov    ah,0D7H
    call    arg0
    ret    2
sysout    endp


;--------------------------------
; func(216) (D8H)
;
; call allocr OBSOLETE FUNCTION
;

allocr    proc    far
allocr    endp


;--------------------------------
; Logout System  func(217) (D9H)
;
; call dallocr OBSOLETE FUNCTION
;

dallocr    proc    far
dallocr    endp


;--------------------------------
; Vol Statistics func(218) (DAH)
;
; call volstat(volume%, reply$)

volstat proc    far
    mov    ah,0DAh
    push    bp
    mov    bp,sp
    mov    si,[bp+8];addr for the volume number
    mov    dx,[si]   ;get the volume number
    mov    di,[bp+6] ;ptr to var desc block for reply buffer
    mov    cx,[di+1]   ;add 1 to get the address of the string
    mov    di,cx        ;put it in di
    int    21h
    pop    bp
    ret    4
volstat endp



;--------------------------------
; Local Disks  func(219) (DBH)
;
; call locdrv(NumDisks%)
;

locdrv    proc    far
    mov    ah,0DBH
    call    arg0
    ret    2
locdrv endp



;--------------------------------
; WorkStation ID func(220) (DCH)
;
; call wsid(ThisStationNum%)
;

wsid   proc    far
       mov     ah,0DCH
       call    arg0
       ret     2
wsid   endp


;--------------------------------
; Set Error mode func(221) (DDH)
;
; call errmode(mode%)
;


errmode proc    far
    mov    ah,0DDH
    call    arg1wor
    ret 2
errmode endp



;--------------------------------
; Brodcast Mode func(222) (DEH)
;
; call bcsmode(mode%)
;


bcsmode proc    far
    mov    ah,0DEH
    call    arg1wor
    ret    2
bcsmode endp



;--------------------------------
; Modify LST Device  func(223) (DFH)
;
; call ctlspl(mode%)
;

ctlspl    proc    far
    push    bp
    mov    bp,sp
    mov    si,[bp+6]
    mov    dx,[si]
    mov    ah,0DFh
    int     21h
    mov    ah,0
    mov    di,[bp+6]
    mov    [di],ax
    pop    bp
    ret    2
ctlspl    endp



;--------------------------------
; Spool Request func(224) (E0H)
;
; call splreq(ErrCode%, RequestBlock$, Reply$)
;

splreq    proc    far
    mov    ah,0E0h
    call    req_rep
    ret    6
splreq    endp



;--------------------------------
; Pipe Request func(225) (E1H)
;
;
; call pipreq(ErrCode%, RequestBlock$, Reply$)
;

pipreq    proc    far
    mov    ah,0E1h
    call    req_rep
    ret    6
pipreq    endp



;--------------------------------
; Directory Path func(226) (E2H)
;
; call dpath(ReturnCode%, RequestBlock$, Reply$)
;

dpath    proc    far
    mov    ah,0E2h
    call    req_rep
    ret    6
dpath    endp



;--------------------------------
; Login system func(227) (E3H)
;
; call syslog(ReturnCode%, RequestBlock$, Reply$)
;

syslog    proc    far
    mov    ah,0E3h
    call    req_rep
    ret    6
syslog    endp



;--------------------------------
; Set File Attribute func(228) (E4H)
;
; call fattr(ReturnCode%, fcb$, Attribute%)
;

fattr    proc    far
    push    bp
    mov    bp,sp
    mov    si,[bp+6]
    mov    cx,[si]  ;cx=attribute
    mov    si,[bp+8]
    mov    dx,[si+1]  ;dx=address of fcb
    mov    ah,0E4h
    int    21h
    mov    ah,0
    mov    di,[bp+10]; address of the return code
    mov    [di],ax  ;save the return code
    pop    bp
    ret    6
fattr    endp



;--------------------------------
; Update file size func(229) (E5H)
;
; call updfcb(ErrCode%,fcb$)
;

updfcb    proc    far
    mov    ah,0E5H
    call    arg1f
    ret    4
updfcb    endp



;--------------------------------
; Copy File to File func(230) (E6H)
;
; call cpyfile(ReturnCode%, FcbSource, FcbDest, CountLow, CountHigh)
;
; where count-low is the low 16 or 32 bits
; specifing the number of bytes to copy
; the resulting values are saved back into
; these variables
;

cpyfile proc    far            ;
    mov    ah,0E6h
    push    bp
    mov    bp,sp
    mov    si,[bp+6]   ;addr of the high byte cnt
    mov    cx,[si]     ;cx=high word of byte cnt
    mov    si,[bp+8] ;addr low word of byte cnt
    mov    dx,[si]     ;dx=low 16 bits of count
    mov    si,[bp+10] ;address of dest fcb
    mov    di,[si+1]     ;di=addr of dest fcb
    mov    si,[bp+12] ;address of the source fcb
    mov    si,[si+1]     ;si=addr of the source fcb
    int    21h
    mov    si,[bp+6]   ;get addr of high count
    mov    [si],cx     ;save high count
    mov    si,[bp+8] ;get addr of low count
    mov    [si],dx     ;save remaining low count
    mov    si,[bp+14] ;address of return code
    mov    ah,0
    mov    [si],ax   ;save error code
    pop    bp
    ret    10
cpyfile endp



;--------------------------------
; get time / date string func(231) (E7H)
;
; call nettod(time$)
; where time is a string of the form Y M D H M S
;

nettod    proc    far
    mov    ah,0E7h
    call    arg1awor
    ret    2
nettod    endp



;--------------------------------
; Set Close mode func(232) (E8H)
;
; call clsmode(mode%)
;

clsmode proc    far
    mov    ah,0E8H
    call    arg1wor
    ret    2
clsmode endp


;--------------------------------
; Shell Base Status func(233) (E9H)
;
;
; call drvmap(ReturnFlags%, drive%)

drvmap    proc    far
    push    bp
    mov    bp,sp
    mov    ax,0E900h
    mov    si,[bp+6]
    mov    dx,[si]    ;dx gets the argument
    int    21h
    mov    di,[bp+8] ;addr to put the ret code into
    mov    [di],ax    ;save the result
    pop    bp
    ret    4
drvmap    endp


;--------------------------------
; Return Shell Version func(234) (EAH)
;
; call retshl(RetCode%, Mode%)
;

retshl    proc    far
    mov    ah,0EAh
    call    arg1
    ret    4
retshl    endp


;--------------------------------
; ascii log File (235) (EB)
;
; call asclog(RetCode%, Asciiz$)
;

asclog    proc    far
    mov    ah,0EBH
    call    arg1a
    ret    4
asclog    endp


;--------------------------------
; ASCIIZ file unlock (236) (EC)
;
; call asculkf(RetCode%, Asciiz$)
;

asculkf proc    far
    mov    ah,0ECH
    call    arg1a
    ret    4
asculkf endp


;--------------------------------
; ASCIIZ Clear file func(237) (EDH)
;
; call ascclrf(RetCode%, Asciiz$)
;

ascclrf proc    far
    mov    ah,0EDH
    call    arg1a
    ret    4
ascclrf endp



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; Get Physical Station Number  EEH
;
; call Get_PSN(StationNo%)
;

Get_PSN proc    far

    push    bp
    mov    bp,sp
    mov    ah,0EEh
    int    21h
    mov    ah,0
    mov    di,[bp+6]
    mov    [di],ax
    pop    bp
    ret    2

Get_PSN endp


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; Get Shell Table Addresses (239) EFH
;
; call Get_STA(Mode%,Segment%,Offset%)
;

Get_STA proc    far
    push    es
    push    bp
    mov    bp,sp
    mov    si,[bp+12]        ;get the mode
    mov    ax,[si]
    mov    ah,0EFh         ;set the function
    int    21h
    mov    di,[bp+10]        ;segment location
    mov    [di],es
    mov    di,[bp+8]        ;offset location
    mov    [di],si
    pop    bp
    pop    es
    ret    6
Get_STA endp


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; Set Preferred File Server (240) F0H
;
; call SetServ(Mode%,NewServ%,CurrServ%)
;

SetServ proc    far
    push    bp
    mov    bp,sp
    mov    si,[bp+10]        ;get the mode
    mov    ax,[si]
    mov    si,[bp+8]           ;set the preferred server number
    mov    dx,[si]
    mov    ah,0F0h         ;set the function
    int    21h
    mov    ah,0
    mov    di,[bp+6]        ;Current server
    mov    [di],ax
    pop    bp
    ret    6
SetServ endp


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; Attach/Detach To File Server (241) F1H
;
; call ModServ(Mode%,NewServ%,RetCode%)
;

ModServ proc    far
    push    bp
    mov    bp,sp
    mov    si,[bp+10]        ;get the mode
    mov    ax,[si]
    mov    si,[bp+8]           ;set the preferred server number
    mov    dx,[si]
    mov    ah,0F1h         ;set the function
    int    21h
    mov    ah,0
    mov    di,[bp+6]        ;Return Code
    mov    [di],ax
    pop    bp
    ret    6
ModServ endp

;---------------------------
;
; Get Current Disk - DOS function 19H
;
; call GetDrv(Drive%)
;

GetDrv    proc    far
    push    bp
    mov    bp,sp
    mov    ah,19h            ;set the function
    int    21h
    mov    ah,0
    mov    di,[bp+6]
    mov    [di],ax         ;return the drive
    pop    bp
    ret    2
GetDrv    endp

;--------------------------------------
; Set Default spool flags func(184) (B8h)
;
; call setspl(buffer$,mode%)
;

setspl    proc    far
    push    bp
        mov     bp,sp
    push    es
    push    ds
    pop    es
    mov    si,[bp+6]    ;load mode into al
    mov    ax,[si]
    mov    ah,0B8h
    mov    si,[bp+8]    ;load size into cx and buff into es:bx
    mov    cx,[si]
    xor    ch,ch
    mov    bx,[si+1]
    int    21h
    pop    es
    pop    bp
    ret    4
setspl    endp


;--------------------------------
;Logical record log and lock(208) (D0H)
;
; call loglck(returncode%,recname$,flags%,timeout%) Only use for lock mode 01
;

loglck    proc    far
    push    bp
    mov    bp,sp
    mov    di,[bp+10]    ;get address of string structure
    mov    dx,[di+1]    ;add 1 to get string address
    mov    di,[bp+8]    ;get flags
    mov    ax,[di]
    push    bp
    mov    bp,[bp+6]    ;load time out value
    mov    bp,[bp]
    mov    ah,0D0H
    int    21H
    pop    bp
    mov    ah,0
    mov    di,[bp+12]    ;load return code
    mov    [di],ax
    pop    bp
    ret    8
loglck    endp




;--------------------------------
; Process a single integer argument in a
; function call with the return code on the front

arg1    proc    near
    push    bp
    mov    bp,sp
    mov    si,[bp+8]
    mov    dx,[si]    ;dx gets the argument
    int    21h
    mov    ah,0       ;clear ah for al return code
    mov    di,[bp+10] ;addr to put the ret code into
    mov    [di],ax    ;save the result
    pop    bp
    ret
arg1    endp



;--------------------------------
; Process an fcb address in a
; function call with the return code on the front

arg1f    proc    near
    push    bp
    mov    bp,sp
    mov    si,[bp+8]
    mov    dx,[si+1]  ;dx gets the argument
    int    21h
    mov    ah,0       ;clear ah for al return code
    mov    di,[bp+10] ;addr to put the ret code into
    mov    [di],ax    ;save the result
    pop    bp
    ret
arg1f    endp


;--------------------------------
; Process a single string argument in a
; function call with the return code on the front

arg1a    proc    near
    push    bp
    mov    bp,sp
    mov    di,[bp+8] ;ptr to var desc block for parameter string
    mov    cx,[di+1]   ;add 1 to get the address of the string
    mov    di,cx        ;put it in di
    mov    dx,di
    int    21h
    mov    ah,0      ;clear ah for al return code
    mov    di,[bp+10];addr for the ret code var.
    mov    [di],ax   ;save the result
    pop    bp
    ret
arg1a    endp



;----------------------------
; Perform a single integer argument
; but without a return code

arg1wor proc    near
    push    bp
    mov    bp,sp
    mov    si,[bp+8]
    mov    dx,[si]   ;dx gets the arg (or ptr)
    int    21h
    pop    bp
    ret
arg1wor endp


;----------------------------
; Perform a single string argument
; but without a return code

arg1awor proc    near
    push    bp
    mov    bp,sp
    mov    si,[bp+8]
    mov    dx,[si+1]
    int    21h
    pop    bp
    ret
arg1awor endp

;--------------------------------
; Process no arguments - only a return code

arg0    proc    near
    push    bp
    mov    bp,sp
    int    21h
    mov    ah,0
    mov    di,[bp+8]
    mov    [di],ax
    pop    bp
    ret
arg0    endp


;----------------------------
; Handle a request$ and reply$ function
; with error code

req_rep proc    near
    push    bp
    mov    bp,sp
    push    es
    push    ds
    pop     es
    mov    si,[bp+10] ;ptr to var desc block for req. string
    mov    cx,[si+1]   ;add 1 to get the address of the string
    mov    si,cx        ;put it in si
    mov    di,[bp+8] ;ptr to var desc block for reply buf
    mov    cx,[di+1]   ;add 1 to get the address of the string
    mov    di,cx        ;put it in di
    pushf              ;save the direction flag
    int    21h
    popf
    pop    es
    mov    si,[bp+12] ;address for error
    mov    ah,0
    mov    [si],ax     ;save error code
    pop    bp
    ret
req_rep endp


subseg    ends



RLOADER segment byte 'RLOAD'
    assume    cs:RLOADER,ss:RStack

EndRes    equ    $

LOADER    proc    far            ;Entry from DOS
    push    es            ;Setup stack to contain a vector
    xor    ax,ax            ; so RET will return a INT 27H
    push    ax            ;  instruction at offset 0 in PSP.
    mov    byte ptr es:1,27H    ;Change INT 20H to INT 27H at start of PSP.
    xor    ax,ax            ;clear AX register
    mov    es,ax            ;set ES: to segment 0

    assume    es:SegZero        ;ES: ref. segment 0

;Pass offset to entry point of interface module to the ComArea Vector as
;well as the interface module segment.    Pass offset of the end of the
;resident code in the DX register.  At exit CS will point to the PSP
;which has the exit instruction 27H.


    mov    ComArea_Off,offset Subrt
    mov    ComArea_Seg,seg Subrt
    mov    dx,offset Grp:EndRes+100H
    ret
LOADER    endp
RLOADER ends

RStack    segment para stack 'STACK'
    db    16 dup ("STACK")        ;Stack local to Load proc.
RStack    ends
    end