*DECK DB$SWPO 
USETEXT CDCSCTX 
      PROC DB$SWPO(SWAPUCP);
      BEGIN 
 #
* *   DB$SWPO--SWAP OUT TABLES FOR USER          PAGE  1
* *   C O GIMBER                                 7/13/76
* 
* DC  PURPOSE 
* 
*     SWAP OUT TABLES FOR USER. 
* 
* DC  ENTRY CONDITIONS
* 
*     SWAPUCP = TRUE, SWAP OUT USER CONTROL POINT AND CDCS TABLES 
*                            P<RCB> MUST BE SET TO THE USERS RCB
* 
*               FALSE, SWAP OUT ONLY CDCS INTERNAL TABLES 
* 
* DC  CALLING ROUTINES
* 
*     DB$ADAX                ATTACH DATA AND INDEX FILES
*     DB$ATCH                ATTACH PROCESSOR 
*     DB$CMOH                CENTRAL MEMORY OVERFLOW HANDLER
*     DB$SOSI                SWAP OUT AND SWAP IN JOBS (EXCHANGE) 
* 
* DC  CALLED ROUTINES 
# 
      XREF PROC DB$FLOP;     #GENERATE FLOW POINT                      #
      XREF PROC DB$MFF;      #RELEASE MANAGED MEMORY# 
      XREF ITEM DB$NOS B;    #TRUE IF RUNNING ON THE NOS OPERATING SYS #
      XREF PROC DB$POP;      #POP ENTRY FROM STACK# 
      XREF PROC DB$PUSH;     #PUSH ENTRY INTO STACK#
      XREF PROC DB$SFCL;     #SF CALL PROCESSOR#
      XREF FUNC DB$SWO;      #WRITE TABLE TO SWAP FILE# 
      XREF PROC DB$WSAR;     # RETURN WORKING STORAGE AREAS#
# 
* DC  NON-LOCAL VARIABLES 
* 
*     CDCS COMMON 
 #
# 
*     LOCAL VARIABLES 
# 
      ITEM SWAPUCP B;              #INPUT PARAMETER#
      ITEM SAVE;                   #POINTER SAVE VARIABLE#
      ITEM SAVE2;                  #POINTER SAVE VARIABLE#
  
 #
* 
*     NOTE -
*         THE SF.SWPO FUNCTION IS AN ADVISORY FUNCTION TO THE OPERATING 
*         SYSTEM.  THE OPERATING SYSTEM MAY ELECT TO SET A STATUS THAT
*         INDICATES THAT THE CDCS SCP RECOMMENDS SWAPPING OUT OF THE
*         SPECIFIED USER.  THIS STATUS MAY BE RETAINED EVEN THOUGH THE
*         UCP IS SWAPPED IN.
* 
*         IT IS ESSENTIAL THAT CDCS WILL AT SOME FUTURE TIME ISSUE AN 
*         SF.SWPI TO CANCEL THE "SWAP OUT RECOMMENDED" STATUS.
*         THE RCB EXCEPTION STATUS FLAG "RCSFSWP" IS SET TO INDICATE
*         THAT THE STATUS IS IN EFFECT. 
* 
*         IF CDCS ATTEMPTS TO ISSUE ANY OTHER SFCALL AND FINDS THE USER 
*         IS SWAPPED OUT, THE RCSFSWP FLAG WILL CAUSE DB$SFCL TO ISSUE
*         AN SF.SWPI. 
* 
*         IF RCSFSWP IS STILL SET WHEN DB$WRP IS CALLED, DB$RCBF IS 
*         CALLED TO ISSUE THE SF.SWPI FUNCTION. 
* 
 #
  
  
  
#     B E G I N   D B $ S W P O   E X E C U T A B L E   C O D E .      #
  
  
 #
* DC  DESCRIPTION 
* 
*     EXIT IF THE LONG TERM CONNECTION FLAG IS NOT SET. 
 #
      IF NOT TQLTCF[0]
      THEN
        BEGIN 
        RETURN; 
        END 
 #
* 
*     IF NOT MUJ TYPE JOB THEN
*       MAKE SF CALL TO SYSTEM TO SWAP OUT USER.
 #
  
      CONTROL IFGR DFFLOP,0;
        DB$FLOP ("SWPO   ");
      CONTROL ENDIF;
  
      IF TQTASK[0] EQ 0 
        AND SWAPUCP 
        AND NOT RCSFSWP[0]
      THEN
        BEGIN 
        DB$PUSH(DB$SWPO); 
        DB$SFCL(DFSFSWPO,0,0,0);
        DB$POP(DB$SWPO);
        RCSFSWP[0] = TRUE;   #SET CDCS SWAP OUT FLAG                   #
        END 
  
 #
*     SWAP OUT RSB. 
*         DO NOT SWAP AN RSB THAT IS CURRENTLY PERFORMING A FUNCTION
*         OTHER THAN INVOKE, READ OR VERSION CHANGE.
 #
      IF TQRSB[0] GR 0
        AND DB$NOS
      THEN
        BEGIN 
        SAVE = P<RCB>;
        P<RCB> = TQRCB[0];
        IF TQRCB[0] EQ 0
          OR (TQRCB[0] GR 0 
          AND (RCFUNC[0] EQ DFINV 
            OR RCFUNC[0] EQ DFRD1 
            OR RCFUNC[0] EQ DFRD2 
            OR RCFUNC[0] EQ DFVER)) 
        THEN
          BEGIN 
          SAVE2 = P<FKL>; 
          P<RSB> = TQRSB[0];
          P<FKL> = RSFFKLLOC[0];
          IF LOC(FKL) NQ LOC(RSB) + RSFRLEN[0]
          THEN               # SWAP THE RSB AND FKL SEPARATELY         #
            BEGIN 
            RSFFKLLOC[0] = DB$SWO(RSFFKLLOC[0],FKLLENGTH[0]); 
            TQRSB[0] = DB$SWO(TQRSB[0],TQRSBSIZE[0]); 
            END 
          ELSE
                             # SWAP THE RSB AND FKL AS ONE TABLE       #
            BEGIN 
            RSFFKLLOC[0] = RSFFKLLOC[0] - LOC(RSB); 
            TQRSB[0] = DB$SWO(TQRSB[0],TQRSBSIZE[0]+FKLLENGTH[0]);
            END 
          P<FKL> = SAVE2; 
          END 
        P<RCB> = SAVE;
        END 
 #
*     IF THERE IS AN ASL AND THE RSB WAS ACTUALLY SWAPPED OUT,
*     INCREMENT CST SWAP OUT COUNT IN ASL ENTRY.
 #
      IF TQASL[0] NQ 0
        AND TQRSB[0] LS 0 
      THEN
        BEGIN 
        SAVE = P<ASL>;             #SAVE CURRENT ASL POINTER# 
        P<ASL> = TQASL[0];
        ASNSWP[0] = ASNSWP[0]+1;
        P<ASL> = SAVE;             #RESTORE CURRENT ASL POINTER#
        END 
 #
*     IF COMMAND IS NOT BEING PROCESSED, RELEASE WORKING STORAGE BUFFERS
*     THAT HAVE BEEN ALLOCATED, AND CLEAR TQT POINTERS TO THE BUFFERS 
 #
      IF TQRCB[0] EQ 0 THEN 
        BEGIN 
        DB$WSAR;             # RETURN WORKING STORAGE AREAS            #
        END 
 #
*     SET SWAP FLAG IN TQT ENTRY. 
 #
      TQSWPF[0] = TRUE; 
  
      RETURN; 
      END 
      TERM; 
