; 
;    DOMINO:conofacepc.s                           DATE: 5-86   
;    O'Leary, Stewart, Van de Geijn    University of Maryland
;
;    Programmed by Xiaobai Sun
;



;                      This is conoface 
;                 (awaken, pause, and finis) 
;           for the 8086/8088 Series microprocessor
;                 and the Lattice C compiler
;
;  "awaken (nodep)"  activates  "nodeprog (nodep, initialp)", which
;  returns control either by a "return" (to set status=0), a
;  "pause()" (to set status=1), or a "finis()" (to set status=2).
;
;  A fourth routine, "initds", is not a CONOFACE routine.  It 
;  initializes register DS of the processor. initds() should be the 
;  first routine called by the PROFACE prostart routine.
;

include     dos.mac

nodep    equ      6
status   equ      4
proces   equ     20
stackp   equ     28
  
READY    equ      0
ACTIVE   equ      1
DETATCH  equ      2


pushr    macro
         pushf
         push     DS
         push     ES
         push     DI
         push     SI
         push     DX
         push     CX
         push     BX
         push     AX
         push     BP
         endm

popr     macro
         pop      BP
         pop      AX
         pop      BX
         pop      CX
         pop      DX
         pop      SI
         pop      DI
         pop      ES
         pop      DS
         popf
         endm


         dseg
         extrn    initial:word
dummy    dw       ?
         endds
  
         pseg
         public   awaken,pause,finis,initds
  
awaken   proc     far        ;called by awaken(p) where p is a pointer
     ; pass argument : nodep
         push     BP
         mov      BP,SP
         les      SI,dword ptr [BP+nodep]  ;pass node pointer
         pop      BP

     ;save system enviroment
         pushr                             ;save system registers
         mov      CS:sysstk,SP             ;save system stack pointer 
         mov      CS:sysstk+2,SS
 
     ;get user process information
         mov      AX,ES:[SI+status]        ;get user process status
         mov      SP,ES:[SI+stackp]        ;get user stack pointer
         mov      SS,ES:[SI+stackp+2]

     ;start or restart user program and back to system when finish
         cmp      AX,ACTIVE                ;check node status
         je       restart                  ;restart when p->status = ACTIVE
         push     CS:saveds                ;initial DS for node program
         pop      DS
         mov      AX,ACTIVE                ;prepare to start
         mov      ES:[SI+status],AX        ;set p->status = ACTIVE
         mov      AX,seg initial           ;pass argument: initial
         push     AX
         mov      AX,offset initial
         push     AX
         push     ES                       ;pass argument:nodep
         push     SI
         call     dword ptr ES:[SI+process];call node program
  
     ;back from node program
         mov      CS:usrstk,SP             ;swap stack pointer
         mov      CS:usrstk+2,SS
         mov      SP,CS:sysstk
         mov      SS,CS:sysstk+2
         popr                              ;restore system registers
         push     CS:usrstk                ;save user stack pointer
         pop      ES:[SI+stackp]
         push     CS:usrstk+2
         pop      ES:[SI+stackp+2]
         mov      AX,READY
         mov      ES:[SI+status],AX        ;reset p->status= READY
         ret                               ;back to system
restart:
         popr                              ;restore user registers
         ret                               ;restart user program
awaken   endp     


pause    proc     far                      ;called by user program
         pushr                             ;save user registers
         mov      CS:usrstk,SP             ;swap stack pointer
         mov      CS:usrstk+2,SS           ;
         mov      SP,CS:sysstk
         mov      SS,CS:sysstk+2
         popr                              ;restore system registers
         push     CS:usrstk                ;save user stack pointer
         pop      ES:[SI+stackp]
         push     CS:usrstk+2
         pop      ES:[SI+stackp+2]
         ret                               ;transfer control to system
pause    endp


finis    proc     far                      ;called by user program
         mov      SP,CS:sysstk             ;restore system stack
         mov      SS,CS:sysstk+2 
         popr                              ;restore system registers
         mov      AX,DETATCH
         mov      ES:[SI+status],AX        ;set p->status = DETATCH
         ret                               ;transfer control to system
finis    endp


initds   proc     far                       ;called by prostart program
         mov      AX,DS
         mov      CS:saveds,AX
         ret
initds   endp


CSdata   proc                               ;reserve memory locatoin for data
sysstk   dw       ?
         dw       ?
usrstk   dw       ?
         dw       ?
saveds   dw       ?
CSdata   endp

         
         endps
   
         end