api1.asm

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

        mov     dx,es
        mov     ax,di
        pop     es
        pop     di
        pop     bp
        fix_long
        ret
    endfunc api_getm,em

; api_putmem
    function api_putm,em
    frame
    arg memptr,dword
        push    bp
        mov     bp,sp
        push    es
        mov     es,word ptr memptr+2[bp]
        @call   putmem
        xor     ax,ax
        pop     es
        pop     bp
        ret
    endfunc api_putm,em

; api_isobj
    function api_isob,j
    frame
    arg obj,dword
        push    bp
        mov     bp,sp
        push    bx
        push    di
        push    es
        les     di,dword ptr obj[bp]
        @call   isobj
        mov     ax,bx
        neg     ax
        pop     es
        pop     di
        pop     bx
        pop     bp
        ret
    endfunc api_isob,j

; api_justify
    function api_just,ify
    frame
    arg val,word
        push    bp
        mov     bp,sp
        push    bx
        mov     bx,val[bp]
        @call   justify
        xor     ax,ax
        pop     bx
        pop     bp
        ret
    endfunc api_just,ify

; api_level
    function api_leve,l
    frame
    arg level,word
        push    bp
        mov     bp,sp
        push    bx
        mov     bx,level[bp]
        @call   apilevel
        pop     bx
        pop     bp
        ret
    endfunc api_leve,l

; api_poke
    function api_poke,
    frame
    arg val,word
        push    bp
        mov     bp,sp
        push    bx
        mov     bx,val[bp]
        @call   dbgpoke
        pop     bx
        pop     bp
        ret
    endfunc api_poke,

init_stream db  1bh,10h,2,0,0bdh,0bfh

; api_init
    function api_init,
        mov     cs:CrunDS,ds            ; save C runtime DS
        @call   dvpresent
        mov     cs:apiversion,ax        ; save API version number
        test    ax,ax
        jz      apr1
        cmp     ax,200h                 ; version 2 ?
        jb      apr1                    ; jump if not
        push    ax                      ; save version number
        push    bx
        cmp     ax,201h                 ; version 2.01 or later ?
        jb      apr2                    ; jump if not
        push    es
        @send   handle,me               ; get task handle
        pop     ax
        pop     es
        mov     bl,1
        @call   cstyle                  ; use C style control codes
        pop     es
apr2:   mov     bx,200h                 ; enable level 2 extensions
        @call   apilevel
        push    cs                      ; set alternate field mode
        mov     ax,offset cs:init_stream ;  and allow changing of
        push    ax                      ;   reverse attributes
        xor     ax,ax
        push    ax
        mov     ax,6
        push    ax
        @send   write,me
        @send   new,mailbox             ; allocate mailbox object
        @pop    cs:lockobj              ;   as dvapibuf semaphore
        pop     bx
        pop     ax                      ; return DESQview version
apr1:   ret
    endfunc api_init,

exit_stream db  1bh,10h,2,0,0bch,0beh

; api_exit
    function api_exit,
        push    bx
        cmp     cs:apiversion,201h
        jb      aex2
        push    es
        @send   handle,me               ; get task handle
        pop     ax
        pop     es
        mov     bl,0
        @call   cstyle                  ; use normal control codes
        pop     es
aex2:   push    cs                      ; set normal field mode
        mov     ax,offset cs:exit_stream ;  and disallow changing of
        push    ax                      ;   reverse attributes
        xor     ax,ax
        push    ax
        mov     ax,6
        push    ax
        @send   write,me
        @mov    bxax,cs:lockobj
        or      ax,bx
        jz      aex1
        @send   free,cs:lockobj         ; free dvapibuf semaphore
        xor     ax,ax
        mov     bx,ax
        @mov    cs:lockobj,bxax
aex1:   pop     bx
        xor     ax,ax
        ret
    endfunc api_exit,

; ; api_pushkey
;     function api_push,key
;     frame
;     arg keyx,word
;       push    bp
;       mov     bp,sp
;       push    bx
;       push    di
;       push    es
;       mov     bx,keyx[bp]
;       @call   pushkey
;       pop     es
;       pop     di
;       pop     bx
;       pop     bp
;       ret
;     endfunc api_push,key


wpf_cs  dw      0
wpf_ip  dw      0
wpf_bp  dw      0
wpf_win dw      0,0

; ; win_printf
;     function win_prin,tf
;     frame
;     arg win,dword
;       @send   lock,cs:lockobj
;       pop     cs:wpf_ip
;     if farcode
;       pop     cs:wpf_cs
;     endif
;       mov     cs:wpf_bp,bp
;       mov     bp,sp
;       pop     cs:wpf_win
;       pop     cs:wpf_win+2
;
;     if underscore
;       if fardata
;       mov     ax, seg DGROUP:_dvapibuf
;       push    ax
;       endif
;       mov     ax,offset DGROUP:_dvapibuf
;       push    ax
;     else
;       if fardata
;       mov     ax, seg DGROUP:dvapibuf
;       push    ax
;       endif
;       mov     ax,offset DGROUP:dvapibuf
;       push    ax
;     endif
;
;     if farcode
;       push    cs
;     endif
;       mov     ax,offset cs:wpf_part2
;       push    ax
;
;     if (compiler eq metaware)
;       if farcode
;       jmp     sprintf
;       else
;       jmp     cgroup:sprintf
;       endif
;     else
;     if (compiler eq watcom)
;       jmp     sprintf_
;     else
;       if underscore
;       jmp     _sprintf
;       else
;       jmp     sprintf
;       endif
;     endif
;     endif
;
;
; wpf_part2:
;       mov     sp,bp
;     if farcode
;       push    cs:wpf_cs
;     endif
;       push    cs:wpf_ip
;       push    bx
;       push    cx
;       mov     cx,ax
;
;     if underscore
;       mov     ax,seg DGROUP:_dvapibuf
;       push    ax
;       mov     ax,offset DGROUP:_dvapibuf
;       push    ax
;     else
;       mov     ax,seg DGROUP:dvapibuf
;       push    ax
;       mov     ax,offset DGROUP:dvapibuf
;       push    ax
;     endif
;
;       xor     ax,ax
;       push    ax
;       push    cx
;       @send   write,cs:wpf_win
;       mov     bp,cs:wpf_bp
;       @send   close,cs:lockobj
;       pop     cx
;       pop     bx
;       ret
;     endfunc win_prin,tf

; app_number
    function app_numb,er
        @call   appnum
        ret
    endfunc app_numb,er

; mal_find
    function mal_find,
    frame
    arg name_ptr,fptr
    arg lname,word
        push    bp
        mov     bp,sp
        push    bx
        push    cx
        push    di
        push    es
        push    si
        push    ds
        load_fptr es,di,name_ptr[bp]
        mov     cx,lname[bp]
        @call   findmail
        test    bx,bx
        jnz     mf1
        xor     ax,ax
        xor     dx,dx
        jmp     short mf2
mf1:    @send   handle,dssi
        pop     ax
        pop     dx
mf2:    pop     ds
        pop     si
        pop     es
        pop     di
        pop     cx
        pop     bx
        pop     bp
        fix_long
        ret
    endfunc mal_find,

; win_async
    function win_asyn,c
    frame
    arg win,dword
    arg entryp,cptr
        push    bp
        mov     bp,sp
        sub     sp,14
        push    bx
        push    cx
        push    dx
        mov     word ptr [bp-14],101bh
        mov     word ptr [bp-12],10
        mov     byte ptr [bp-10],8ah
        null_cptr entryp[bp]
        jz      was1
        mov     ax,offset cs:async_entry
        mov     bx,cs
        load_cptr dx,cx,entryp[bp]      ; push task entry point
        jmp     short was2
was1:   xor     ax,ax
        xor     bx,bx
        xor     cx,cx
        xor     dx,dx
was2:   mov     word ptr [bp-9],ax
        mov     word ptr [bp-7],bx
        mov     byte ptr [bp-5],8bh
        mov     word ptr [bp-4],cx
        mov     word ptr [bp-2],dx
        push    ss
        lea     ax,[bp-14]
        push    ax
        xor     ax,ax
        push    ax
        mov     ax,14
        push    ax
        @send   write,win[bp]
        pop     dx
        pop     cx
        pop     bx
        mov     bx,ax
        mov     sp,bp
        pop     bp
        xor     ax,ax
        ret
    endfunc win_asyn,c

async_entry proc far
        @call   ustack                  ; back to user stack
    if farcode
        push    cs                      ; push return to here
    endif
        mov     ax,offset cs:async_ret
        push    ax
        push    ds                      ; push user entry point
        push    si
        mov     ds,cs:CrunDS            ; set user DS and ES
        mov     es,cs:CrunDS
        ret                             ; entry async routine
async_ret:
        @call   ostack                  ; back on system stack
        ret                             ; return
async_entry endp

; tsk_pgmint
    function tsk_pgmi,nt
    frame
    arg winhan,dword
    arg entryp,cptr
    arg wordparm,word
    arg ptrparm,ptr
        push    bp
        mov     bp,sp
        push    bx
        push    cx
        push    dx
        push    di
        push    si
        push    ds
        push    es
        mov     bx,winhan+2[bp]
        mov     dx,cs
        mov     cx,offset cs:pgmint_entry
        load_dptr es,di,ptrparm[bp]
        load_cptr ds,si,entryp[bp]
        mov     bp,wordparm[bp]
        @call   pgmint
        pop     es
        pop     ds
        pop     si
        pop     di
        pop     dx
        pop     cx
        pop     bx
        xor     ax,ax
        pop     bp
        ret
    endfunc tsk_pgmi,nt

pgmint_entry proc far
        @call   ustack                  ; back to user stack
    if fardata
        push    es                      ; push pointer parm
    endif
        push    di
        push    bp                      ; push integer parm
    if farcode
        push    cs                      ; push return to here
    endif
        mov     ax,offset cs:pgmint_ret
        push    ax
        push    ds                      ; push user entry point
        push    si
        mov     ds,cs:CrunDS            ; set user DS and ES
        mov     es,cs:CrunDS
        ret                             ; entry async routine
pgmint_ret:
    if fardata
        add     sp,6                    ; drop parms
    else
        add     sp,4
    endif
        @call   ostack                  ; back on system stack
        ret                             ; return
pgmint_entry endp

; ; win_reorder
;     function win_reor,der
;       push    bp
;       mov     bp,sp
;       push    bx
;       push    cx
;       push    di
;       push    es
;       @send   lock,cs:lockobj
;      if farcode                       ; adjust BP to point to parms
;       add     bp,6
;      else
;       add     bp,4
;      endif
;
;      if underscore
;       mov     ax,seg DGROUP:_dvapibuf         ; point ES:DI to _dvapibuf
;       mov     es,ax
;       mov     di,offset DGROUP:_dvapibuf
;      else
;       mov     ax,seg DGROUP:dvapibuf          ; point ES:DI to dvapibuf
;       mov     es,ax
;       mov     di,offset DGROUP:dvapibuf
;      endif
;
;       mov     cx,64                   ; limit of 64 parameters
;       add     di,cx
;       add     di,cx
;       std
;       xor     ax,ax                   ; terminate list
;       stosw
; wro2: mov     ax,[bp]                 ; get low order word of window handle
;       test    ax,ax                   ; terminator ?
;       jnz     wro1                    ; jump if so
;       mov     ax,[bp+2]               ; get high order word
;       stosw                           ; put in buffer
;       add     bp,4                    ; point to next parm
;       loop    wro2                    ; loop
;
; wro1: add     di,2                    ; point to start of list
;       push    di                      ; push pointer to list
;       sub     di,9                    ; reserve room for a stream
;       cld
;       mov     ax,101bh                ; manager stream header
;       stosw
;       mov     ax,5                    ; # of command bytes
;       stosw
;       mov     al,0ceh                 ; reorder command byte
;       stosb
;       pop     ax                      ; store window list offset
;       stosw
;       mov     ax,es                   ; store window list segment
;       stosw
;       sub     di,9
;       push    es                      ; push pointer to stream
;       push    di
;       xor     ax,ax                   ; push stream length = 9
;       push    ax
;       mov     ax,9
;       push    ax
;       @send   write,me                ; send reorder stream
;       @send   close,cs:lockobj
;       pop     es
;       pop     di
;       pop     cx
;       pop     bx
;       pop     bp
;       xor     ax,ax
;       ret
;     endfunc win_reor,der

        cend                            ; end of code segment

        END