Oakland CPM Archive/oakcpm.iso/cpm/cpm86/fmacs86.ark/CCPMINT.A86

Text File | 1989-02-09 | 23KB | 827 lines

    pagesize    86
    title     'CCPM interface for FREEMACS'

v30    equ    0
files    equ    8        ;max. number of files that can be opened

    if v30
;macros for NEC V20/V30 or Intel 80186/286
    codemacro SHLW parm:ew,count:db        ;shift word left by
        db 0c1h                ;immediate count
        modrm 4,parm
        db count
        endm
    codemacro SHRW parm:ew,count:db        ;shift word right by
        db 0c1h                ;immediate count
        modrm 5,parm
        db count
        endm
    endif

;CCPM function EQUs
c_attach    equ    92h
c_detach    equ    93h
drv_get        equ    19h
f_close        equ    10h
f_delete    equ    13h
f_dmaoff    equ    1Ah
f_dmaseg    equ    33h
f_make        equ    16h
f_multisec    equ    2Ch
f_open        equ    0Fh
f_parse        equ    98h
f_readrand    equ    21h
f_rename    equ    17h
f_sfirst    equ    11h
f_size        equ    23h
f_snext        equ    12h
f_usernum    equ    20h
f_writerand    equ    22h
p_cli        equ    96h
p_pdadr        equ    9Ch
p_priority    equ    91h
t_seconds    equ    9Bh
    codemacro CCPM parm:db            ;call CCPM
        db 0b1h ! db parm            ;mov cl,parm
        db 0cdh ! db 0e0h            ;int 0E0H
        endm

data    dseg    word public
our_ds        rs    0

pfcb        rw    2        ;F_PARSE parameter block

flesize        equ    48        ;length of file_list element
file_list    rb    files*flesize    ;IO buffers and FCBs
file_list_end    rs    0
;file list element structure
;        +-------------------------------+
;    0    |    FLAGS    |   USER CODE    |
;        +-------------------------------+
;    2    |           (reserved)        |
;        +-------------------------------+
;    4    |        RWPOINTER        |
;        |         4 bytes        |
;        +-------------------------------+
;    8    |        FILELENGTH        |
;        |         4 bytes        |
;        +-------------------------------+
;    12    |         CCPM        |
;        /    File Control Block    /
;        |        36 bytes        |
;        +-------------------------------+
flags        equ    byte ptr 0    ;buffer flags          1 byte
usercode    equ    byte ptr 1    ;user code          1 byte
reserved    equ    byte ptr 2    ;              2 bytes
rwpointer    equ    word ptr 4    ;read/write pointer      4 bytes
filelength    equ    word ptr 8    ;file length          4 bytes
fcb        equ    byte ptr 12    ;File Control Block     36 bytes
fcb_f6        equ    byte ptr fcb+6    ;read only open flag
fcb_r01        equ    word ptr fcb+33    ;random record number
fcb_r2        equ    byte ptr fcb+35
;
open_mask    equ    80h
modf_mask    equ    40h
ro_mask        equ    20h
;
search_fle    rb    flesize
search_fle_fcb    equ    byte ptr search_fle+12
help_fle    rb    flesize
help_fle_fcb    equ    byte ptr help_fle+12
help_buffer    rb    130

tod        rb    5

dft_user    rb    1
;
;data    end

;stack    sseg    word
callers_bp    equ    word ptr 0[bp]
callers_di    equ    word ptr 2[bp]
callers_es    equ    word ptr 4[bp]
callers_si    equ    word ptr 6[bp]
callers_ds    equ    word ptr 8[bp]
callers_dx    equ    word ptr 10[bp]
callers_cx    equ    word ptr 12[bp]
callers_bx    equ    word ptr 14[bp]
callers_ax    equ    word ptr 16[bp]
handle_nbr    equ    callers_bx        ;handle #
iob_count    equ    word ptr (-2)[bp]    ;number of bytes to transfer
iodma_seg    equ    word ptr (-4)[bp]    ;DMA segment
iodma_off    equ    word ptr (-6)[bp]    ;DMA offset
iodma_adr    equ    dword ptr (-6)[bp]
iotrf_count    equ    word ptr (-8)[bp]    ;transfer count
;stack    ends


code    cseg    byte public
    ;*** assume cs:code,ds:data,es:data,ss:stack

    public    ccpm_init
ccpm_init:
    push ds ! mov ds,own_ds
    mov dl,0FFh ! ccpm f_usernum
    inc al ! mov dft_user,al
    pop ds ! ret

own_ds    dw    seg our_ds
pe_ret    dw    return

prolog:    pop pe_ret
    push ax ! push bx ! push cx ! push dx
    push ds ! push si ! push es ! push di
    push bp ! mov bp,sp
    jmp pe_ret

epilog:    pop pe_ret
    mov sp,bp ! pop bp
    pop di ! pop es ! pop si ! pop ds
    pop dx ! pop cx ! pop bx ! pop ax
    jmp pe_ret

    public    ccpm_create_file
ccpm_create_file:        ;MS-DOS function 3CH
;enter with DS:DX -> ASCIIZ of file name
    call prolog
    mov ds,own_ds
    call inithandle        ;init file list element
    mov bx,di ! call set_user    ;set user code
    lea dx,fcb[di]        ;point to fcb
    ccpm f_make        ;call ccpm to create the file
    or al,al        ;test for error
    jz ccpm_open_file_2    ;creation secceeded
    cmp ah,8h        ;test extended error
    je ccpm_open_file_1    ;file exists already -- try to open
    jmp err_return        ;error

    public    ccpm_open_file
ccpm_open_file:            ;MS-DOS function 3DH
;enter with DS:DX -> ASCIIZ of file name
    call prolog
    mov ds,own_ds
    call inithandle        ;init file list element
    mov bx,di ! call set_user
ccpm_open_file_1:
    lea dx,fcb[di]
    ccpm f_close        ;perhaps we reopen
    lea dx,fcb[di]
    ccpm f_open        ;try to open the file
    inc al ! jnz ccpm_open_file_2
    jmp err_return        ;file opening did not succeeded
ccpm_open_file_2:
    mov bx,di ! call file_size_1    ;determine the file size
    or flags[bx],open_mask    ;set file open flag
    mov callers_ax,bx    ;return file handle in AX
    jmp return

    public    ccpm_close_file
ccpm_close_file:        ;MS-DOS function 3EH
;enter with BX = File handle number
    call prolog
    call check_handle
    mov ds,own_ds
    mov di,bx ! call set_user
    test flags[di],modf_mask    ;test if file has been modified
    jz ccpm_close_file_1        ;jump if not
    mov ax,filelength[di]
    test al,7fh            ;is there a partial last record
    jz ccpm_close_file_1        ;jump if not
    mov rwpointer[di],ax
    mov ax,filelength+2[di]
    mov rwpointer+2[di],ax
    mov dx,offset help_buffer
    mov al,1 ! call set_dma
    call rw_to_recptr
    lea dx,fcb[di]            ;read last record
    ccpm f_readrand ! mov bx,di
    mov di,rwpointer[bx] ! and di,7fh    ;offset to EOF
    mov cx,80h ! sub cx,di            ;no. of bytes till EOR
    add di,offset help_buffer
    push ds ! pop es
    mov al,1ah ! rep stosb        ;pad with EOF chars (^Z)
    lea dx,fcb[bx] ! mov di,bx
    ccpm f_writerand        ;rewrite last record
ccpm_close_file_1:
    lea dx,fcb[di]
    ccpm f_close            ;close the file
    inc al ! jnz $+5
    jmp err_return
    mov flags[di],0
    jmp return

set_user:    ;set user number
    mov dl,usercode[bx]
    or dl,dl ! jnz $+6
    mov dl,dft_user ! dec dl
    push bx ! ccpm f_usernum
    pop bx ! ret

inithandle:
    mov cx,files            ;number of file list elements
    mov bx,offset file_list
inithandle_1:                ;look for an empty file handle entry
    cmp flags[bx],0
    jz inithandle_2            ;element found
    add bx,flesize
    loop inithandle_1
    jmp err_return            ;no element found -- return carry
    ;
inithandle_2:                ;entry found -- clear it
    push ds ! pop es
    xor ax,ax ! mov cx,flesize/2    ;clear file list element
    mov di,bx ! rep stosw
    push ds ! mov ds,callers_ds
    mov si,callers_dx
    mov di,offset help_buffer
    mov cx,128 ! lodsb ! stosb    ;copy ASCIIZ filename to help buffer
    or al,al ! loopne $-4
    pop ds ! jcxz err_return    ;error -- no ASCIIZ filename
    ;
    mov pfcb,offset help_buffer
    push bx ! lea ax,fcb[bx]    ;parse the file name
    mov pfcb+2,ax
    mov dx,offset pfcb
    ccpm f_parse
    pop di ! inc ax
    jz err_return            ;error -- invalid filename
    dec ax ! jz inithandle_ret
    mov si,ax ! lodsb ! cmp al,'['    ;test for options
    je inithandle_3            ;options follow
inithandle_ret:
    ret
inithandle_3:
    lodsb ! or al,al ! jz err_return    ;End of string
    cmp al,']' ! je inithandle_ret        ;End of options
    and al,5Fh            ;option char. to uppercase
    mov bx,offset optiontab
inithandle_4:
    cmp cs:byte ptr [bx],0
    jz err_return            ;end of table --- invalid option
    cmp al,cs:[bx] ! je inithandle_5
    lea bx,3[bx] ! jmps inithandle_4
inithandle_5:
    call cs:word ptr 1[bx]        ;call option routine
    jmps inithandle_3

optiontab    db 'G' ! dw inithandle_uc    ;user code
        db 'R' ! dw inithandle_r    ;read only
        db 0
cb10        db 10

inithandle_uc:                ;"G"-option -- set user code
    lodsb ! cmp al,'9' ! ja err_return
    cmp al,'0' ! jb err_return
    and al,0Fh ! mov dl,al
    lodsb ! cmp al,'5' ! ja inithandle_uc1
    cmp al,'0' ! jb inithandle_uc1
    and al,0Fh ! xchg al,dl
    mul cs:cb10 ! add dl,al ! inc si
inithandle_uc1:
    inc dl ! mov usercode[di],dl    ;save user code
    dec si ! ret

inithandle_r:                ;"R"-Option -- read only file
    or flags[di],ro_mask ! ret

err_return:
    stc ! call epilog ! ret

ret_trf:mov ax,iotrf_count
    mov callers_ax,ax

return:    clc ! call epilog ! ret

check_handle:
    cmp bx,offset file_list
    jb err_return
    cmp bx,offset file_list_end
    jnb err_return
    ret

    public    ccpm_write_file
ccpm_write_file:        ;MS-DOS function 40H
;enter with DS:DX -> data to write
;    CX = number of bytes to write
;    BX = handle number
    call prolog ! call check_handle
    sub sp,8            ;scratch space
    mov iotrf_count,0
    jcxz ret_trf            ;nothing to do
    call calc_dma            ;preset DMA address
    mov ds,own_ds
    push cx ! call set_user ! pop cx
    mov iob_count,cx        ;save # of bytes to transfer
    test rwpointer[bx],7fh        ;test for broken record io
    jz ccpm_write_file_1        ;direct write possible

    mov dx,offset help_buffer
    mov al,1 ! call set_dma        ;set DMA parameters to help buffer
    call rw_to_recptr        ;get record ptr
    lea dx,fcb[bx]
    ccpm f_readrand            ;read record to be partially updated
    mov bx,handle_nbr
    mov di,rwpointer[bx] ! and di,7fh    ;partial record offset
    mov cx,80h ! sub cx,di
    cmp iob_count,cx ! ja $+5
    mov cx,iob_count ! push cx        ;partial record length
    add di,offset help_buffer    ;point to partial record
    push ds ! pop es ! push ds
    lds si,iodma_adr ! rep movsb    ;copy partial record
    pop ds ! mov iodma_off,si
    lea dx,fcb[bx] ! push bx
    ccpm f_writerand        ;rewrite record
    or al,al ! jz $+5
    jmp err_return            ;error
    pop bx ! pop ax            ;# of bytes transfered
    add iotrf_count,ax        ;update transfer count
    add rwpointer[bx],ax        ;update R/W pointer
    adc rwpointer+2[bx],0
    sub iob_count,ax
    mov cx,iob_count

ccpm_write_file_1:
    if v30
    mov ax,cx ! shrw cx,7        ;cx = sector count
    else
    push cx ! mov ax,cx
    mov cl,7 ! shr ax,cl
    mov cx,ax ! pop ax
    endif
    and ax,7fh ! mov iob_count,ax    ;ax = rest byte count
ccpm_write_file_2:
    jcxz ccpm_write_file_3
    push cx                ;save total sector count
    cmp cx,80h ! jbe $+5
    mov cx,80h ! push cx        ;save max. sector count
    push ds ! lds dx,iodma_adr
    call calc_dma            ;form DMA address
    mov ds,ax ! mov al,cl
    call set_dma            ;set DMA parameters
    pop ds
    call rw_to_recptr        ;form record ptr
    lea dx,fcb[bx]
    ccpm f_writerand        ;perform IO
    or al,al ! jz $+5
    jmp err_return            ;IO error
    mov bx,handle_nbr
    pop ax ! pop cx            ;retrieve record counts
    sub cx,ax            ;update total record count
    if v30
    shlw ax,7            ;# of bytes transfered
    else
    push cx ! mov cl,7 ! shl ax,cl ! pop cx
    endif
    add iotrf_count,ax        ;update transfer count
    add rwpointer[bx],ax        ;update R/W pointer
    adc rwpointer+2[bx],0
    add iodma_off,ax        ;update DMA address
    jmps ccpm_write_file_2

ccpm_write_file_3:
    mov cx,iob_count        ;get rest length
    jcxz ccpm_write_file_4        ;all done
    mov dx,offset help_buffer    ; not yet -- there's a little rest
    mov al,1 ! call set_dma
    call rw_to_recptr        ;form record pointer
    lea dx,fcb[bx] ! ccpm f_readrand    ;read record
    push ds ! pop es ! push ds
    lds dx,iodma_adr ! call calc_dma
    mov si,dx ! mov ds,ax
    mov di,offset help_buffer
    mov cx,iob_count ! rep movsb    ;copy partial record
    pop ds
    mov bx,handle_nbr
    lea dx,fcb[bx] ! ccpm f_writerand    ;rewrite record
    or ax,ax ! jz $+5
    jmp err_return            ;error
    mov ax,iob_count        ;# if bytes written
    mov bx,handle_nbr
    add rwpointer[bx],ax        ;update R/W pointer
    adc rwpointer+2[bx],0
    add iotrf_count,ax
ccpm_write_file_4:
    or flags[bx],modf_mask        ;signal that file has been modified
    mov dx,rwpointer+2[bx]
    cmp dx,filelength+2[bx]        ;has file been extended ?
    jb ret_trf1
    mov ax,rwpointer[bx]
    cmp ax,filelength[bx]
    jbe ret_trf1
    mov filelength[bx],ax        ;yes -- update file length
    mov filelength+2[bx],dx
ret_trf1:
    jmp ret_trf

    public    ccpm_read_file
ccpm_read_file:        ;MS-DOS function 3FH
;enter with DS:DX -> buffer to read into
;    CX = number of bytes to read
;    BX = handle number
    call prolog ! call check_handle
    sub sp,8            ;scratch space
    mov iotrf_count,0
    jcxz ret_trf1            ;nothing to do
    call calc_dma            ;preset DMA address
    mov ds,own_ds
    push cx ! call set_user ! pop cx
    mov ax,rwpointer[bx]
    mov dx,rwpointer+2[bx]
    add ax,cx ! adc dx,0
    cmp dx,filelength+2[bx]    ! ja $+7;shall we read past the EOF ?
    cmp ax,filelength[bx] ! jbe $+9
    sub ax,filelength[bx]        ;yes -- truncate CX to file length
    sub cx,ax ! jcxz ret_trf1        ;that's EOF
    mov iob_count,cx        ;save # of bytes to transfer
    test rwpointer[bx],7fh        ;test for broken record io
    jz ccpm_read_file_1        ;direct write possible

    mov dx,offset help_buffer
    mov al,1 ! call set_dma        ;set DMA parameters to help buffer
    call rw_to_recptr        ;get record ptr
    lea dx,fcb[bx]
    ccpm f_readrand            ;read record
    or al,al ! jz $+5
    jmp err_return
    mov bx,handle_nbr
    mov si,rwpointer[bx] ! and si,7fh    ;partial record offset
    mov cx,80h ! sub cx,si
    cmp iob_count,cx ! ja $+5
    mov cx,iob_count ! push cx        ;partial record length
    add si,offset help_buffer    ;point to partial record
    les di,iodma_adr ! rep movsb    ;copy partial record
    mov iodma_off,di
    pop ax                ;# of bytes transfered
    add iotrf_count,ax        ;update transfer count
    add rwpointer[bx],ax        ;update R/W pointer
    adc rwpointer+2[bx],0
    sub iob_count,ax
    mov cx,iob_count
;
ccpm_read_file_1:
    if v30
    mov ax,cx ! shrw cx,7        ;cx = sector count
    else
    push cx ! mov ax,cx
    mov cl,7 ! shr ax,cl
    mov cx,ax ! pop ax
    endif
    and ax,7fh ! mov iob_count,ax    ;ax = rest byte count
ccpm_read_file_2:
    jcxz ccpm_read_file_3
    push cx                ;save total sector count
    cmp cx,80h ! jbe $+5
    mov cx,80h ! push cx        ;save max. sector count
    push ds ! lds dx,iodma_adr
    call calc_dma            ;form DMA address
    mov ds,ax ! mov al,cl
    call set_dma            ;set DMA parameters
    pop ds
    call rw_to_recptr        ;form record ptr
    lea dx,fcb[bx]
    ccpm f_readrand            ;perform IO
    mov bx,handle_nbr
    or al,al ! jz ccpm_read_file_2a
    dec al ! jz $+5            ;EOF ?
    jmp err_return            ;no - IO error
    shr ax,1 ! add iotrf_count,ax    ;number of bytes transfered
    add rwpointer[bx],ax
    adc rwpointer+2[bx],0
    ; *** pop ax ! pop cx
    jmp ret_trf2
ccpm_read_file_2a:
    pop ax ! pop cx            ;retrieve record counts
    sub cx,ax            ;update total record count
    if v30
    shlw ax,7            ;# of bytes transfered
    else
    push cx ! mov cl,7
    shl ax,cl ! pop cx
    endif
    add iotrf_count,ax        ;update transfer count
    add rwpointer[bx],ax        ;update R/W pointer
    adc rwpointer+2[bx],0
    add iodma_off,ax        ;update DMA address
    jmps ccpm_read_file_2

ccpm_read_file_3:
    mov cx,iob_count        ;get rest length
    jcxz ret_trf2            ;all done
    mov dx,offset help_buffer    ; not yet -- there's a little rest
    mov al,1 ! call set_dma
    call rw_to_recptr        ;form record pointer
    lea dx,fcb[bx] ! ccpm f_readrand    ;read record
    or al,al ! jz $+5
    jmp err_return
    push ds ! lds dx,iodma_adr
    call calc_dma ! pop ds
    les di,iodma_adr
    mov si,offset help_buffer
    mov cx,iob_count
    push cx ! rep movsb ! pop cx    ;copy partial record
    mov bx,handle_nbr
    add rwpointer[bx],cx        ;update R/W pointer
    adc rwpointer+2[bx],0
    add iotrf_count,cx
ret_trf2:
    jmp ret_trf


calc_dma:    ;recalc. DMA address
    ;enter with DS:DX = current DMA address
    ;exit with DX and IODMA_OFF = new DMA offset
    ;       AX and IODMA_SEG = new DMA segment
    mov ax,ds ! push dx
    if v30
    shrw dx,4 ! add ax,dx        ;AX = new DMA segment
    else
    push cx ! mov cl,4
    shr dx,cl ! pop cx ! add ax,dx
    endif
    mov iodma_seg,ax
    pop dx ! and dx,0fh        ;DX = new DMA offset
    mov iodma_off,dx
    ret

set_dma:    ;set new DMA segment, offset, and sector count
    ;enter with DS = DMA segment
    ;        DX = DMA offset
    ;        AL = sector count
    push ax ! ccpm f_dmaoff        ;set DMA offset
    mov dx,ds ! ccpm f_dmaseg    ;set DMA segment
    pop dx ! ccpm f_multisec    ;set sector count
    ret

rw_to_recptr:    ;convert R/W pointer to record pointer
    mov bx,handle_nbr
    mov ax,rwpointer[bx]        ;get file pointer
    mov dx,rwpointer+2[bx]
    mov cl,7
    sar dx,1 ! rcr ax,1        ;form record pointer
    loop $-4
    mov fcb_r01[bx],ax        ;record pointer -- low word
    mov fcb_r2[bx],dl        ;record pointer -- high byte
    ret

    public    ccpm_delete_file
ccpm_delete_file:        ;MS-DOS function 41H
;enter with DS:DX -> ASCIIZ filename
    call prolog
    mov ds,own_ds
    mov bx,offset help_fle
    call inithandle_2
    mov bx,di ! call set_user
    mov flags[di],0
    lea dx,fcb[di]
    ccpm f_delete
    or al,al ! jz $+5
    jmp err_return
    jmp return

    public    ccpm_lseek_file
ccpm_lseek_file:        ;MS-DOS function 42H
;enter with  CX:DX - Distance to move
;        AL - Method of moving
;        BX - Handle
;exit with   DX:AX - New pointer location

; >>>>> CAUTION <<<<<
;MS-DOS maintains the file length in BYTES, but CCPM in RECORDS of 128 bytes.
;Therefore, if we position to the end of a file (AL=2), we have to look in
;in last record for the last non-EOF-mark (^Z) and position after it. This
;procedure may cause TRUBBLES IN CASE OF BINARY FILES if there is an EOF-mark
;pertaining to data in the last record !!!!!

    call prolog ! call check_handle
    mov ds,own_ds
    or al,al ! jnz ccpm_lseek_file_1
    mov rwpointer[bx],dx
    mov rwpointer+2[bx],cx
ccpm_lseek_file_ret:
    mov callers_ax,dx
    mov callers_dx,cx
    jmp return
ccpm_lseek_file_1:
    cmp al,1 ! jne ccpm_lseek_file_2
    add dx,rwpointer[bx]
    adc cx,rwpointer+2[bx]
    mov rwpointer[bx],dx
    mov rwpointer+2[bx],cx
    jmps ccpm_lseek_file_ret
ccpm_lseek_file_err:
    jmp err_return
ccpm_lseek_file_2:
    cmp al,2 ! jne ccpm_lseek_file_err
    call file_size
    jc ccpm_lseek_file_err
    mov rwpointer[bx],ax
    mov rwpointer+2[bx],dx
    mov callers_ax,ax
    mov callers_dx,dx
    jmp return

file_size:
    call set_user
    push bx ! lea dx,fcb[bx]    ;to determine the file size correctly
    ccpm f_close ! pop bx        ;      the file nust first be closed.
    push bx ! lea dx,fcb[bx]
    ccpm f_open ! pop bx
    inc al ! jnz $+4 ! stc ! ret    ;cannot reopen
file_size_1:
    push bx ! lea dx,fcb[bx]    ;compute the virt. file size
    ccpm f_size ! pop bx
    sub fcb_r01[bx],1        ;position to last record
    sbb fcb_r2[bx],0
    jnc file_size_2
    xor ax,ax ! mov dx,ax        ;file is empty
    jmps file_size_3
file_size_2:
    mov dx,offset help_buffer
    push bx ! mov al,1        ;set our own DMA
    call set_dma ! pop bx
    push bx ! lea dx,fcb[bx]    ;read the last record
    ccpm f_readrand ! pop bx
    mov di,offset help_buffer+127    ;point to end of our buffer
    push ds ! pop es
    mov cx,128 ! mov al,1ah        ;and search for first non EOF char
    std ! rep scasb ! cld
    sub di,offset help_buffer-2    ;build buffer rel. offset
    mov ax,fcb_r01[bx]
    xor dx,dx ! mov dl,fcb_r2[bx]
    mov cx,7 ! clc
    rcl ax,1 ! rcl dx,1 ! loop $-4    ;point to first byte of last record
    add ax,di ! adc dx,0        ;point to EOF mark
file_size_3:
    mov filelength[bx],ax
    mov filelength+2[bx],dx
    ret


    public    ccpm_find_file
ccpm_find_file:
;enter with AH = 0    To find first entry (MS-DOS function 4EH)
;        DS:DX        pointer to ASCIIZ filename
;        ES:DI        where to put the resultant ASCIIZ filename
;        AH <> 0    To find the next entry (MS-DOS function 4F)
;        ES:DI        where to put the resultant ASCIIZ filename
; >>>>>>> CAUTION: not MS-DOS compatible (yet) !!! <<<<<<<
    call prolog
    mov ds,own_ds
    mov dx,offset help_buffer
    mov al,1 ! call set_dma            ;set DMA address
    mov ax,callers_ax
    or ah,ah ! jnz ccpm_find_file_1

    mov bx,offset search_fle
    call inithandle_2

    cmp fcb[di],0 ! jne ccpm_file_0
    ccpm drv_get ! inc al ! mov fcb[di],al    ;set drive to default
ccpm_file_0:
    mov bx,di ! call set_user
    lea dx,fcb[di] ! ccpm f_sfirst        ;find first entry
    cmp al,0ffh ! jnz ccpm_find_file_2
    jmp err_return

ccpm_find_file_1:
    mov bx,offset search_fle
    call set_user
    mov dx,offset search_fle_fcb
    ccpm f_snext                ;find next entry
    cmp al,0ffh ! jne ccpm_find_file_2
    jmp err_return

ccpm_find_file_2:            ;copy back the filename
    les di,dword ptr callers_di    ;load destination
    if v30
    xor ah,ah ! shlw ax,5        ;source offset rel. to DMA buffer
    else
    xor ah,ah ! mov cl,5 ! shl ax,cl
    endif
    mov si,ax ! lea si,help_buffer[si]    ;point to DIR entry
    lodsb ! and al,0fh ! push ax    ;save user code from DIR
    mov al,search_fle_fcb        ;drive code from fcb
    add al,'@' ! mov ah,':' ! stosw    ;store drive specification
    push si ! mov cx,8 ! lodsb    ;copy file name
    and al,7Fh ! cmp al,32 ! je $+5    ;    blank=exit loop
    stosb ! loop $-8
    pop si ! lea si,8[si]        ;point to extention
    cmp byte ptr [si],32        ;is there an extention ?
    je ccpm_find_file_3        ;jump if not
    mov al,'.' ! stosb        ;else append '.'
    mov cx,3 ! lodsb
    and al,7Fh ! cmp al,20h        ;and copy file extention
    je $+5 ! stosb ! loop $-8
ccpm_find_file_3:            ;form user specification
    mov ax,'G[' ! stosw ! pop ax    ;restore user from DIR entry
    aaa ! or ax,3030h        ;form ASCII user number
    cmp ah,30h ! je $+7
    xchg al,ah ! stosb        ;store high digit
    xchg al,ah ! stosb        ;store low digit
    mov ax,']' ! stosw        ;store final delimiter
    jmp return

    public ccpm_rename_file
ccpm_rename_file:        ;MS-DOS function 56h
;enter with    DS:DX    - old ASCIIZ file name
;        ES:DI    - new ASCIIZ file name
;exit with CARRY in error
    call prolog
    mov ds,own_ds ! mov bx,offset help_fle
    call inithandle_2
    mov bx,di ! call set_user
    mov es,own_ds
    mov di,offset help_fle_fcb+17
    mov al,' ' ! mov cx,11
    rep stosb            ;preset new file name with blanks
    mov si,callers_di
    mov ds,callers_es        ;copy new file name
    mov di,offset help_fle_fcb+17    ;into FCB
    mov cl,9
ccpm_rename_file_1:
    lodsb ! cmp al,'.'
    je ccpm_rename_file_2        ;extension follow
    or al,al ! jz ccpm_rename_file_4
    call to_upper ! stosb
    loop ccpm_rename_file_1
    jmp err_return            ;new file name to long
ccpm_rename_file_2:
    mov di,offset help_fle_fcb+17+8
    mov cl,4            ;copy new extension
ccpm_rename_file_3:
    lodsb ! or al,al
    jz ccpm_rename_file_4
    call to_upper ! stosb
    loop ccpm_rename_file_3
    jmp err_return            ;new extention is to long
ccpm_rename_file_4:
    mov ds,own_ds
    mov dx,offset help_fle_fcb
    ccpm f_rename            ;rename the file
    inc al ! jz $+5
    jmp return
    jmp err_return            ;error -- cannot rename the file

to_upper:
    and al,7fh            ;remove status bits
    cmp al,'a' ! jb to_upper_exit
    cmp al,'z' ! ja to_upper_exit
    and al,5fh
to_upper_exit:
    ret

    public ccpm_get_time
ccpm_get_time:        ;MS-DOS function 2CH
;exit with    CH - Hour (0-23)
;        CL - Minutes (0-59)
;        DH - Seconds (0-59)
;        DL - Hundredths (0-99)  >>>>>>> currently 0 !!!! <<<<<<<
    call prolog
    mov ds,own_ds
    mov dx,offset tod
    ccpm t_seconds            ;get current time and day
    mov cl,4 ! xor dl,dl        ;>>>>>>>> clear hundredths <<<<<<<
    xor ah,ah ! mov al,tod+4    ;get seconds
    shl ax,cl ! shr al,cl
    aad ! mov dh,al
    mov al,tod+3            ;get minutes
    shl ax,cl ! shr al,cl
    aad ! mov bl,al
    mov al,tod+2            ;get hour
    shl ax,cl ! shr al,cl
    aad ! mov bh,al
    mov callers_dx,dx
    mov callers_cx,bx
    jmp return

    public ccpm_execute_program
;enter with ds:si,cx = P_CLI string
;exit with ax = Error code
ccpm_execute_program:
    call prolog
    mov es,own_ds
    mov di,offset help_buffer
    lds si,dword ptr callers_si
    xor al,al ! stosb
    and cx,7fh ! rep movsb
    stosb ! mov ds,own_ds
    ccpm p_pdadr            ;get our PD address
    mov al,es:byte ptr 5[bx]    ;get our priority
    push ax ! push es ! push bx    ;save all
    mov si,es:word ptr 1eh[bx]    ;get parent's PD
    or si,si ! jz execute_program_0    ;I'm alone
    mov al,es:byte ptr 5[si]    ;get parent's prio
    dec al ! mov es:byte ptr 5[bx],al    ;I'm one better
execute_program_0:
    mov dx,offset help_buffer
    ccpm p_cli
    or ax,ax ! jz execute_program_1
    mov ax,cx
execute_program_1:
    mov callers_ax,ax
    ccpm c_attach
    pop bx ! pop es ! pop ax
    mov es:byte ptr 5[bx],al    ;reset our priority
    jmp return
    end