api1.asm

开放源码的编译器open watcom 1.6.0版的源代码

        pop     bx
        ret
    endfunc key_clos,e

; mallock
    function mallock,
        push    bx
        mov     bx,dvm_setesc*256+dva_tos
        jmp     short ep_han
    endfunc mallock,

; tim_open
    function tim_open,
        jmp     short do_mal_open
    endfunc tim_open,

; mal_open
    function mal_open,
do_mal_open:
        push    bx
        mov     bx,dvm_open*256+dva_tos
        jmp     short ep_han
    endfunc mal_open,

; mal_lock
    function mal_lock,
        push    bx
        mov     bx,dvm_lock*256+dva_tos
        jmp     short ep_han
    endfunc mal_lock,

; obq_subfrom
    function obq_subf,rom
        push    bx
        mov     bx,dvm_subfrom*256+dva_objqme
        jmp     short ep_han
    endfunc obq_subf,rom

; win_redraw
    function win_redr,aw
        push    bx
        mov     bx,dvm_redraw*256+dva_tos
        jmp     short ep_han
    endfunc win_redr,aw

; obq_read
    function obq_read,
        mov     bx,dvm_read*256+dva_objqme
        jmp     short ep_nul_ret_dword
    endfunc obq_read,

; pan_new
    function pan_new,
        mov     bx,dvm_new*256+dva_panel
        jmp     short ep_nul_ret_dword
    endfunc pan_new,

; ptr_new
    function ptr_new,
        mov     bx,dvm_new*256+dva_pointer
        jmp     short ep_nul_ret_dword
    endfunc ptr_new,

; tim_new
    function tim_new,
        mov     bx,dvm_new*256+dva_timer
        jmp     short ep_nul_ret_dword
    endfunc tim_new,

; mal_new
    function mal_new,
        mov     bx,dvm_new*256+dva_mailbox
        jmp     short ep_nul_ret_dword
    endfunc mal_new,

; mal_me
    function mal_me,
       mov     bx,dvm_handle*256+dva_mailme
        jmp     short ep_nul_ret_dword
    endfunc mal_me,

; win_me
    function win_me,
       mov     bx,dvm_handle*256+dva_me
        jmp     short ep_nul_ret_dword
    endfunc win_me,

; tsk_me
    function tsk_me,
       mov     bx,dvm_handle*256+dva_me
        jmp     short ep_nul_ret_dword
    endfunc tsk_me,

; key_new
    function key_new,
        mov     bx,dvm_new*256+dva_keyboard
        jmp     short ep_nul_ret_dword
    endfunc key_new,

; key_me
    function key_me,
       mov     bx,dvm_handle*256+dva_keyme
ep_nul_ret_dword:
        mov     ah,12h
        int     15h
        pop     ax
        pop     dx
        fix_long
        ret
    endfunc key_me ,

; key_of
    function key_of,
   frame
    arg winhan,dword
        mov     bx,dvm_handle*256+dva_keytos
ep_dword_ret_dword:
        push    bp
        mov     bp,sp
        push    winhan+2[bp]
        push    winhan[bp]
        mov     ah,12h
        int     15h
        pop     ax
        pop     dx
        pop     bp
        fix_long
        ret
    endfunc key_of ,

; mal_of
    function mal_of,
       mov     bx,dvm_handle*256+dva_mailtos
        jmp     short ep_dword_ret_dword
    endfunc mal_of,

; tim_len
    function tim_len,
    frame
    arg timhan,dword
        mov     bx,dvm_len*256+dva_tos
        jmp     short ep_dword_ret_dword
    endfunc tim_len,

; tim_read
    function tim_read,
        mov     bx,dvm_read*256+dva_tos
        jmp     short ep_dword_ret_dword
    endfunc tim_read,

; tim_sizeof
    function tim_size,of
        mov     bx,dvm_sizeof*256+dva_tos
        jmp     short ep_dword_ret_dword
    endfunc tim_size,of

; mal_addr
    function mal_addr,
        mov     bx,dvm_addr*256+dva_tos
        jmp     short ep_dword_ret_dword
    endfunc mal_addr,

; mal_sizeof
    function mal_size,of
        jmp     short do_key_sizeof
    endfunc mal_size,of

; pan_sizeof
    function pan_size,of
        jmp     short do_key_sizeof
    endfunc pan_size,of

; ptr_sizeof
    function ptr_size,of
        jmp     short do_key_sizeof
    endfunc ptr_size,of

; win_sizeof
    function win_size,of
        jmp     short do_key_sizeof
    endfunc win_size,of

; key_sizeof
    function key_size,of
    frame 1
    arg keyhan,dword
do_key_sizeof:
        push    bx
        mov     bx,dvm_sizeof*256+dva_tos
ep_dword_ret_int:
        push    bp
        mov     bp,sp
        push    keyhan+2[bp]
        push    keyhan[bp]
        mov     ah,12h
        int     15h
        pop     ax
        pop     bx
        pop     bp
        pop     bx
        ret
    endfunc key_size,of

; mal_status
    function mal_stat,us
        jmp     short do_key_status
    endfunc mal_stat,us

; pan_status
    function pan_stat,us
        jmp     short do_key_status
    endfunc pan_stat,us

; ptr_status
    function ptr_stat,us
        jmp     short do_key_status
    endfunc ptr_stat,us

; key_status
    function key_stat,us
do_key_status:
        push    bx
        mov     bx,dvm_status*256+dva_tos
        jmp     short ep_dword_ret_int
    endfunc key_stat,us

; win_len
    function win_len,
        push    bx
        mov     bx,dvm_len*256+dva_tos
        jmp     short ep_dword_ret_int
    endfunc win_len,

; ptr_open
    function ptr_open,
        jmp     short do_key_open
    endfunc ptr_open,

; key_open
    function key_open,
    frame
    arg keyhan,dword
    arg winhan,dword
do_key_open:
        push    bp
        mov     bp,sp
        push    bx
        push    winhan+2[bp]
        push    winhan[bp]
        @send   open,keyhan[bp]
        xor     ax,ax
        pop     bx
        pop     bp
        ret
    endfunc key_open,

; mal_read
    function mal_read,
    frame
    arg malhan,dword
    arg bufptr,fptr
    arg lbuf,fptr
        push    bp
        mov     bp,sp
        push    bx
        push    es
        @send   read,malhan[bp]
        load_fptr es,bx,lbuf[bp]
        pop     es:[bx]
        pop     ax
        load_fptr es,bx,bufptr[bp]
        pop     es:[bx]
        pop     es:[bx+2]
        @send   status,malhan[bp]
        pop     ax
        pop     bx
        pop     es
        pop     bx
        pop     bp
        ret
    endfunc mal_read,

; ptr_read
    function ptr_read,
        jmp     short do_key_read
    endfunc ptr_read,

; win_read
    function win_read,
        jmp     short do_key_read
    endfunc win_read,

; key_read
    function key_read,
    frame 1
    arg keyhan,dword
    arg bufptr,ptr
    arg lbuf,ptr
do_key_read:
        push    bx
        mov     bx,dvm_read*256+dva_tos
ep_dword_set_dword_int:
        push    bp
        mov     bp,sp
        push    es
        push    keyhan+2[bp]
        push    keyhan[bp]
        mov     ah,12h
        int     15h
        load_dptr es,bx,lbuf[bp]
        pop     es:[bx]
        pop     ax
        load_dptr es,bx,bufptr[bp]
        pop     es:[bx]
        pop     es:[bx+2]
        xor     ax,ax
        pop     es
        pop     bp
        pop     bx
        ret
    endfunc key_read,

; pan_dir
    function pan_dir,
        push    bx
        mov     bx,dvm_dir*256+dva_tos
        jmp     short ep_dword_set_dword_int
    endfunc pan_dir,

; key_getc
    function key_getc,
    frame
    arg keyhan,dword
        push    bp
        mov     bp,sp
        push    bx
        push    es
        @send   read,keyhan[bp]         ; wait for input
        pop     bx                      ; ignore length - should be 1
        pop     bx
        pop     bx                      ; get buffer address
        pop     es
        xor     ah,ah
        mov     al,es:[bx]              ; get character code
        test    al,al                   ; extended code ?
        jnz     kgc1                    ; jump if not
        @send   status,keyhan[bp]       ; get extended key code
        pop     ax
        pop     bx
        add     ax,256                  ; add 256 to extended code
kgc1:   pop     es                      ; restore registers
        pop     bx
        pop     bp
        ret                             ; return
    endfunc key_getc,

; key_setesc
    function key_sete,sc
    frame
    arg keyhan,dword
    arg entryp,cptr
        push    bp
        mov     bp,sp
        push    bx
        push_cptr entryp[bp]
        @send   setesc,keyhan[bp]
        xor     ax,ax
        pop     bx
        pop     bp
        ret
    endfunc key_sete,sc

; mal_addto
    function mal_addt,o
        push    bx
        mov     bx,dvm_addto*256+dva_tos
        jmp     short ep_dword_ptr_int_int
    endfunc mal_addt,o

; mal_subfrom
    function mal_subf,rom
        push    bx
        mov     bx,dvm_subfrom*256+dva_tos
        jmp     short ep_dword_ptr_int_int
    endfunc mal_subf,rom

; key_write
    function key_writ,e
    frame 1
    arg keyhan,dword
    arg bufptr,ptr
    arg lbuf,word
    arg stat,word
        push    bx
        mov     bx,dvm_write*256+dva_tos
ep_dword_ptr_int_int:
        push    bp
        mov     bp,sp
        push_dptr  bufptr[bp]
        xor     ax,ax
        push    ax
        push    lbuf[bp]
        push    ax
        push    stat[bp]
        push    keyhan+2[bp]
        push    keyhan[bp]
        mov     ah,12h
        int     15h
        xor     ax,ax
        pop     bp
        pop     bx
        ret
    endfunc key_writ,e

; win_subfrom
    function win_subf,rom
        push    bx
        mov     bx,dvm_subfrom*256+dva_tos
        jmp     short ep_dword_fptr_int
    endfunc win_subf,rom

; mal_name
    function mal_name,
        push    bx
        mov     bx,dvm_setscale*256+dva_tos
        jmp     short ep_dword_fptr_int
    endfunc mal_name,

; mal_write
    function mal_writ,e
    frame 1
    arg malhan,dword
    arg bufptr,fptr
    arg lbuf,word
        push    bx
        mov     bx,dvm_write*256+dva_tos
ep_dword_fptr_int:
        push    bp
        mov     bp,sp
        push_fptr  bufptr[bp]
        xor     ax,ax
        push    ax
        push    lbuf[bp]
        push    malhan+2[bp]
        push    malhan[bp]
        mov     ah,12h
        int     15h
        xor     ax,ax
        pop     bp
        pop     bx
        ret
    endfunc mal_writ,e

; pan_open
    function pan_open,
    frame 1
    arg panhan,dword
    arg bufptr,ptr
    arg lbuf,word
        push    bx
        push    bp
        mov     bp,sp
        push_dptr  bufptr[bp]
        xor     ax,ax
        push    ax
        push    lbuf[bp]
        @send   open,panhan[bp]
        @send   status,panhan[bp]
        pop     ax
        pop     bx
        pop     bp
        pop     bx
        ret
    endfunc pan_open,

; obq_close
    function obq_clos,e
        push    bx
        @send   close,objqme
        xor     ax,ax
        pop     bx
        ret
    endfunc obq_clos,e

; obq_erase
    function obq_eras,e
        push    bx
        @send   erase,objqme
        xor     ax,ax
        pop     bx
        ret
    endfunc obq_eras,e

; obq_open
    function obq_open,
        push    bx
        @send   open,objqme
        xor     ax,ax
        pop     bx
        ret
    endfunc obq_open,

; obq_sizeof
    function obq_size,of
        push    bx
        @send   sizeof,objqme
        pop     ax
        pop     bx
        pop     bx
        ret
    endfunc obq_size,of

; obq_status
    function obq_stat,us
        push    bx
        @send   status,objqme
        pop     bx
        pop     ax