PROC ALT$RP; 
# TITLE ALT$RP - SSALTER REQUEST PROCESSOR.                           #
 
      BEGIN  # ALT$RP #
 
#
**    ALT$RP - SSALTER REQUEST PROCESSOR.
*
*     *ALT$RP* PROCESSES THE *SSALTER* TYPE 5 REQUESTS.
*
*     PROC ALT$RP
*
*     ENTRY      P<CPR> = ADDRESS OF TYPE 5 *UCP* REQUEST BLOCK.
*
*     EXIT       THE *UNIT DEVICE TABLE* TRANSMITTED, OR THE *UNIT
*                DEVICE TABLE* FIELD CHANGED.
#
 
#
****  PROC ALT$RP - XREF LIST BEGIN.
#
 
      XREF
        BEGIN
        PROC ABORT;                  # INTERFACE TO *ABORT* #
        PROC MESSAGE;                # ABORT A *UCP* #
        PROC KILL$UC;                # ABORT A UCP #
        PROC LLRQENQ;                # *LLRQ* ENGUEUER #
        PROC UCP$RES;                # ISSUE RESPONSE TO *UCP* #
        PROC UCP$WRI;                # PASS DATA TO *UCP* #
        END
 
#
****  PROC ALT$RP - XREF LIST END.
#
 
      DEF LISTCON  #0#;              # DO NOT LIST COMDECKS #
*CALL COMBFAS
*CALL COMBCPR
*CALL COMBLRQ
*CALL COMBUCR
*CALL COMBUDT
*CALL COMXCTF
*CALL COMXLTC
*CALL COMXMSC
 
      ITEM BYNR       U;             # OFF/SET BIT ADDRESS #
      ITEM LLRADR     U;             # *LLRQ* ENTRY ADDRESS #
      ITEM PMMR       U;             # STATUS BIT #
      ITEM RETCODE    U;             # RETURN CODE #
      ITEM STAT       U;             # STATUS OF *UDT* BIT #
      ITEM UDTQ       U;             # UDT ADDRESS #
 
      BASED
      ARRAY  UDTBIT  [0:0]  P(1);      # ALTER *UDT* AREA #
        BEGIN
        ITEM UDT$BIT    U(00,00,60);
        END
 
 
      IF CPR$RQC[0] LQ REQTYP5"RES5"  ##
        OR CPR$RQC[0] GQ REQTYP5"LSTREQTYP5"
      THEN
        BEGIN  # IF REQUEST CODE IS INCORRECT #
        KILL$UC(KILLCODE"INVRQC");   # ABORT THE UCP #
        RETURN;
        END
 
#
*     RETURN THE UNIT DEVICE TABLE TO THE UCP.
#
 
      IF CPR$RQC[0] EQ REQTYP5"SSA$PUDT"     ##
      THEN
        BEGIN  # TRANFERS THE UDT TO THE UCP #
        UDTQ = UDTCADR + CPR$ADDR3[0];
        UCP$WRI(CPR$ADDR2[0],CPR$ADDR4[0],UDTQ,RETCODE);
        IF RETCODE EQ SFRCUCPGON
        THEN
          BEGIN
          RETURN;
          END
 
        IF RETCODE EQ SFRCBDUCPA
        THEN
          BEGIN
          KILL$UC(KILLCODE"INVADDR");
          RETURN;
          END
 
        IF RETCODE NQ 0
        THEN
          BEGIN
          FE$RTN[0] = "ALT$RP.";
          MESSAGE(FEMSG[0],UDFL1);
          ABORT;
          END
 
        ELSE
          BEGIN
 
          IF INITIALIZE
          THEN
            BEGIN     # BEFORE INITIALIZATION #
            LTC$RQR[LTCENTRY] = RESPTYP5"SSA$OK";
            END
          ELSE
            BEGIN    # AFTER INITIALIZATION #
            LTC$RQR[LTCENTRY] = RESPTYP5"OK5";
            END
 
          UCP$RES;
          RETURN;
          END
 
        END  # RETURN OF UDT #
 
#
*     CHANGE A PATH NOD.
#
 
      UDTQ = CPR$UDTQ[0]+UDTCADR;    # UDT RELATIVE ADDRESS #
      BYNR = CPR$BYNR[0];            # OFF SET BIT ADDRESS #
 
      P<UDTBIT> = UDTQ;
      IF CPR$PMMR[0]
      THEN
        BEGIN
        PMMR = 1;
        END
 
      ELSE
        BEGIN
        PMMR = 0;
        END
 
      STAT = B<BYNR,1> UDT$BIT[0];    # CHECK FOR BIT ALREADY SET #
      IF STAT EQ PMMR
      THEN
        BEGIN
        LTC$RQR[LTCENTRY] = RESPTYP5"SSA$UIRC";
        UCP$RES;
        RETURN;
        END
 
      ELSE
        BEGIN
        B<BYNR,1> UDT$BIT[0] = PMMR;    # SET OPTION BIT #
        B<BYNR+1,1> UDT$BIT[0] = 1;     # SET *ACK* FLAG #
        END
 
#
*     CHECK FOR INITIALIZATION.
#
 
      IF INITIALIZE
      THEN
        BEGIN
        LTC$RQR[LTCENTRY] = RESPTYP5"SSA$OK";
        UCP$RES;
        RETURN;
        END
 
#
*     SET UP A *LLRQ* ENTRY.
#
 
 
        LLRQENQ(LLRADR);
        P<LLRQ> = LLRADR;
        LLR$LTCT[0] = LTCENTRY;
        LLR$UCPRA[0] = UCP$ADDR[0];
        LLR$WORD4[0] = CPR3[0];
        LLR$WORD5[0] = CPR2[0];
        LLR$PRCNME[0] = REQTYP4"INITHW";
        LLR$CU[0] = CPR$CUORD[0];
        LLR$UDTQ[0] = UDTQ;
        LLR$BYNR[0] = BYNR;
        LLR$PMMR[0] = PMMR;
 
        LTC$LLRQA[LTCENTRY] = LLRADR;
        RETURN;
 
      END  # ALT$PR #
 
    TERM
PROC CONNECT;
# TITLE CONNECT - ESTABLISH LONG TERM CONNECTION.                     #
 
      BEGIN  # CONNECT #
 
#
**    CONNECT - ESTABLISH LONG TERM CONNECTION.
*
*     *CONNECT* PROCESSES *UCP* CONNECT REQUESTS.
*
*     PROC CONNECT
*
*     ENTRY     THE CONNECT REQUEST TO BE PROCESSED IS IN ARRAY
*               *CPR*.  THE BASE POINTER FOR *CPR* IS ALREADY SET.
*
*     EXIT      THE LONG TERM CONNECTION HAS BEEN ESTABLISHED, THE
*               *LTCT* ENTRY FOR THE CONNECTING *UCP* HAS BEEN BUILT,
*               AND A RESPONSE HAS BEEN SENT BACK TO THE *UCP*.
*
*     MESSAGES  * EXEC ABNORMAL, CONNECT.*
#
 
#
****  PROC CONNECT - XREF LIST BEGIN.
#
 
      XREF
        BEGIN
        PROC ABORT;                  # INTERFACE TO *ABORT* MACRO #
        PROC KILL$UC;                # ABORT A *UCP* #
        PROC MESSAGE;                # CALLS *MESSAGE* MACRO #
        PROC SFCALL;                 # INTERFACE TO *SFCALL* MACRO #
        PROC UCP$RES;                # NOTIFY *UCP* OF REQUEST COMPLETE
                                     #
        END
 
#
****  PROC CONNECT - XREF LIST END.
#
 
      DEF LISTCON #0#;               # DO NOT LIST COMMON DECKS #
 
*CALL COMBFAS
*CALL COMBCPR
*CALL COMBMAP
*CALL COMBUCR
*CALL COMXCTF
*CALL COMXLTC
*CALL COMXMSC
 
 
      ITEM J          U;             # COUNTER #
      ITEM ORD$MRFT   U;             # *MRFT* ORDINAL #
      ITEM UCPSWAPPED B;             # UCP WAS SWAPPED OUT #
 
 
 
 
#
*     ABORT *UCP* IF *DRYUP* FLAG IS SET.
#
 
      IF DRYUP
      THEN
        BEGIN
        KILL$UC(KILLCODE"CLOSED");
        RETURN;
        END
 
#
*     REQUESTOR ID HAS TO BE IN RANGE.
#
 
      IF CPR$RQI[0] EQ  REQNAME"RQIFIRST" OR  ##
        CPR$RQI[0] GQ  REQNAME"RQILAST"
      THEN
        BEGIN
        KILL$UC(KILLCODE"NOTAUTH");
        RETURN;
        END
 
#
*     SYSTEM LONG TERM CONNECTION HAS TO BE CLEARED.
#
 
      IF LTCENTRY NQ 0
      THEN
        BEGIN
        KILL$UC(KILLCODE"MULCON");
        RETURN;
        END
 
#
*     1. MULTIPLE COPIES OF *SSMOVE* CAN BE RUN AT A TIME, HOWEVER,
*        ONLY ONE COPY OF *SSMOVE* THAT IS IN THE PROCESS OF
*        DESTAGING FILES CAN BE CONNECTED AT A TIME. *MULTIPLE RUN*
*
*     2. MULTIPLE COPIES OF *SSLABEL*, *SSDEBUG* OR *SSVAL* CAN NOT
*        BE CONNECTED. *MULTIPLE RUN*
*
*     3. *SSLABEL*, *SSDEBUG* OR *SSVAL* CAN NOT BE CONNECTED WHILE
*        ANOTHER COPY OF THESE UTILITIES ARE CONNECTED.
*        *UTILITY CONFLICT*
*
*     4. *SSVAL* CAN NOT BE CONNECTED WHILE *SSMOVE* IS IN THE
*        PROCESS OF DESTAGING FILES. *SSMOVE* CAN NOT BE CONNECTED
*        WHEN *SSVAL* IS CONNECTED. *UTILITY CONFLICT*
#
 
      IF CPR$RQI[0] EQ REQNAME"RQIMOVE"
      THEN
        BEGIN  # *SSMOVE* REQUEST #
        IF DSC$FAM NQ 0
        THEN
          BEGIN  # MULTIPLE RUN #
          KILL$UC(KILLCODE"MULRUN");
          RETURN;
          END  # MULTIPLE RUN #
 
        IF CONIND[REQNAME"RQIVALD"]
        THEN
          BEGIN  # UTILITY CONFLICT #
          KILL$UC(KILLCODE"UTLCONF");
          RETURN;
          END  # UTILITY CONFLICT #
 
        END  # *SSMOVE* REQUEST #
 
      ELSE
        BEGIN  # NOT *SSMOVE* REQUEST #
        IF CONIND[CPR$RQI[0]]
        THEN
          BEGIN  # MULTIPLE RUN #
          KILL$UC(KILLCODE"MULRUN");
          RETURN;
          END  # MULTIPLE RUN #
 
        ELSE
          BEGIN  # NOT MULTIPLE RUN #
          IF (CPR$RQI[0] EQ REQNAME"RQILABL")    ##
            OR (CPR$RQI[0] EQ REQNAME"RQIDBUG")  ##
            OR (CPR$RQI[0] EQ REQNAME"RQIVALD")
          THEN
            BEGIN  # *SSLABEL*, *SSDEBUG* OR *SSVAL* REQUEST #
            IF ((CONIND[REQNAME"RQILABL"])       ##
              OR (CONIND[REQNAME"RQIDBUG"])      ##
              OR (CONIND[REQNAME"RQIVALD"]))     ##
              OR ((CPR$RQI[0] EQ REQNAME"RQIVALD") AND (DSC$FAM NQ 0))
            THEN
              BEGIN  # UTILITY CONFLICT #
              KILL$UC(KILLCODE"UTLCONF");
              RETURN;
              END  # UTILITY CONFLICT #
 
            END  # *SSLABEL*, *SSDEBUG* OR *SSVAL* REQUEST #
 
          END  # NOT MULTIPLE RUN #
 
        END  # NOT *SSMOVE* REQUEST #
 
#
*     FIND AN EMPTY LONG TERM CONNECT TABLE ENTRY AND
*     ASSIGN THE *UCP* TO THE ENTRY.  SET THE SYSTEM LONG
*     TERM CONNECT BIT.
#
 
      FASTFOR LTCENTRY = 1 STEP 1 UNTIL LTCTCNT
      DO
        BEGIN  # SEARCH *LTCT* FOR AN EMPTY SLOT #
        IF LTC$SFJBSN[LTCENTRY] EQ 0
        THEN
          BEGIN  # SET UP LONG TERM CONNECTION #
          UCPSWAPPED = TRUE;
          REPEAT WHILE UCPSWAPPED
          DO
            BEGIN  # REPEAT WHILE SWAPPED #
            SFFC[0] = SFSLTC;
            SFCALL(SFBLKPTR,RCL);
            IF SFRC[0] EQ SFRCSWPOUT
            THEN
              BEGIN
              SFFC[0] = SFSWPI;
              SFCALL(SFBLKPTR,RCL);
              END
 
            ELSE
              BEGIN
              UCPSWAPPED = FALSE;
              END
 
            END  # REPEAT WHILE SWAPPED #
 
          IF SFRC[0] NQ 0
          THEN
            BEGIN  # PROCESS UNEXPECTED RESPONSE #
            IF SFRC[0] EQ SFRCUCPGON
            THEN
              BEGIN
              RETURN;
              END
 
            ELSE
              BEGIN
              FE$RTN[0] = "CONNECT.";
              MESSAGE(FEMSG[0],UDFL1);
              ABORT;
              END
 
            END  # PROCESS UNEXPECTED RESPONSE #
 
          LTC$WORD1[LTCENTRY] = UCP$WORD1[0];
          LTC$WORD2[LTCENTRY] = 0;
          LTC$RQI[LTCENTRY] = CPR$RQI[0];
          LTC$UCPA[LTCENTRY] = UCP$ADDR[0];
          LTC$WORD3[LTCENTRY] = CPR3[0];
          CONIND[CPR$RQI[0]] = TRUE;
          LTC$RQR[LTCENTRY] = RESPTYP1"OK1";
          UCP$RES;
          RETURN;
          END  # SET UP LONG TERM CONNECTION #
 
        END  # SEARCH *LTCT* FOR AN EMPTY SLOT #
 
#
*     ABORT IF THERE ARE NO LONG TERM CONNECT TABLE ENTRIES
*     AVAILABLE.
#
 
      FE$RTN[0] = "CONNECT.";
      MESSAGE(FEMSG[0],UDFL1);
      ABORT;
      END  # CONNECT #
 
    TERM
PROC KILL$UC((MCODE));
# TITLE KILL$UC - ABORT A *UCP*.                                      #
      BEGIN  # KILL$UC #
 
#
**    KILL$UC - ABORT A *UCP*.
*
*     *KILL$UC* ABORTS A *UCP*.
*
*     PROC KILL$UC((MCODE))
*
*     ENTRY     MCODE = MESSAGE CODE ORDINAL.
*               THE JOB SEQUEUNCE NUMBER FROM THE OFFENDING *UCP* IS
*               IN ARRAY *UCPR*. THE BASE POINTER FOR *UCPR* IS
*               ALREADY SET.
*
*     EXIT      A DAYFILE MESSAGE HAS BEEN ISSUED TO EXPLAIN WHY THE
*               *UCP* IS BEING ABORTED, AND AN *SF.REGR* HAS BEEN
*               ISSUED TO ABORT THE OFFENDING *UCP*.
*
*     MESSAGES  * EXEC ABNORMAL, KILL$UC.*
*               * XXXX ABORTED - NOT CONNECTED.*
*               * XXXX ABORTED - ALREADY CONNECTED.*
*               * XXXX ABORTED - MULTIPLE REQUESTS.*
*               * XXXX ABORTED - MULTIPLE RUN.*
*               * XXXX ABORTED - INCORRECT REQUEST TYPE.*
*               * XXXX ABORTED - INCORRECT REQUEST CODE.*
*               * XXXX ABORTED - UTILITY CONFLICT.*
*               * XXXX ABORTED - CARTRIDGE ACTIVE.*
*               * XXXX ABORTED - SSEXEC IS CLOSED.*
*               * XXXX ABORTED - INCORRECT ADDRESS.*
*                   XXXX = JOB SEQUENCE NUMBER.
*
#
 
      ITEM MCODE      U;             # MESSAGE-CODE ORDINAL #
 
#
****  PROC KILL$UC - XREF LIST BEGIN.
#
 
      XREF
        BEGIN
        PROC ABORT;                  # INTERFACE TO *ABORT* MACRO #
        PROC MESSAGE;                # INTERFACE TO *MESSAGE* MACRO #
        PROC SFCALL;                 # INTERFACE TO *SFCALL* MACRO #
        END
 
#
****  PROC KILL$UC - XREF LIST END.
#
 
      DEF LISTCON #0#;               # DO NOT LIST COMMON DECKS #
*CALL COMBFAS
*CALL COMBUCR
*CALL COMXLTC
*CALL COMXMSC
 
#
*     ABORT MESSAGE DEFINITION.
#
 
      ARRAY DISPMESS [0:0] S(5);
        BEGIN
        ITEM MESSJBSN   C(00,00,04);  # JOB NAME #
        ITEM MESSFLR    C(00,24,03) = ["   "];
        ITEM MESSABT    C(00,42,10) = ["ABORTED - "];
        ITEM MESSREASON C(01,42,21);
        ITEM MESSTERMTR C(03,48,12) = [0];
        END
 
#
*     REASON WHY *UCP* IS BEING ABORTED.
#
 
      ARRAY ABTREASON [KILLCODE"NOTAUTH":KILLCODE"LASTCODE"] S(3);
        BEGIN
        ITEM REASONMESS C(00,00,21) = ["NOT AUTHORIZED.",
        "NOT CONNECTED.",
        "ALREADY CONNECTED.",
        "MULTIPLE REQUESTS.",
        "MULTIPLE RUN.",
        "INVALID REQUEST TYPE.",
        "INVALID REQUEST CODE.",
        "UTILITY CONFLICT.",
        "CARTRIDGE ACTIVE.",
        "SSEXEC IS CLOSED.",
        "INVALID ADDRESS.",
        "LAST ENTRY."];
        END
 
 
 
 
 
#
*     REASON CODE HAS TO BE WITHIN RANGE.
#
 
      IF MCODE LS KILLCODE"NOTAUTH" OR MCODE GQ KILLCODE"LASTCODE"
        THEN
        BEGIN
        FE$RTN[0] = "KILLUCP.";
        MESSAGE(FEMSG[0],UDFL1);
        ABORT;
        END
 
      MESSJBSN[0] = UCP$JBSN[0];
      MESSREASON[0] = REASONMESS[MCODE];
      MESSAGE(DISPMESS,3);
 
#
*     ABORT THE *UCP* VIA A *SFCALL* REQUEST.
#
 
REPEATREGR:
      SFFP[0] = 0;
      SFUCPA[0] = 2;
      SFSCPA[0] = LOC(DISPMESS);
      SFFC[0] = SFREGR;
      SFJBSN[0] = UCP$JBSN[0];
      SFFSTA[0] = UCP$FSTA[0];
      SFCALL(SFBLKPTR,RCL);
 
#
*     SWAPIN *UCP* IF OUT.
#
 
      IF SFRC[0] EQ SFRCSWPOUT
      THEN
        BEGIN
        SFFC[0] = SFSWPI;
        SFCALL(SFBLKPTR,RCL);
        GOTO REPEATREGR;
        END
 
#
*     ABORT IF *SFERROR* NOT *UCP* ABORTED OR UNDEFINED.
#
 
      IF SFRC[0] NQ 0
      THEN
        BEGIN
        IF SFRC[0] NQ SFRCUCPGON
        THEN
          BEGIN
          FE$RTN[0] = "KILLUCP.";
          MESSAGE(FEMSG[0],UDFL1);
          ABORT;
          END
 
        END
 
      RETURN;
      END  # KILL$UC #
 
    TERM
PROC LINK$RP;
# TITLE LINK$RP - PRELIMINARY LINKAGE PROCESSING.                     #
      BEGIN  # LINK$RP #
 
 
#
**    LINK$RP - PRELIMINARY LINKAGE PROCESSING.
*
*     *LINK$RP* DOES PRELIMINARY PROCESSING OF *UCP* LINKAGE
*     REQUESTS AND THEN CALLS THE APPROPRIATE MODULE TO DO
*     THE DETAILED PROCESSING OF THE REQUEST.
*
*     PROC LINK$RP
*
*     ENTRY     THE TYPE 1 UCP REQUEST TO BE PROCESSED IS IN ARRAY
*               *CPR*.  THE BASE POINTER FOR *CPR* IS ALREADY SET.
*
*     EXIT      THE TYPE 1 REQUEST HAS BEEN PROCESSED AND A RESPONSE
*               HAS BEEN SENT BACK TO THE UCP INDICATING COMPLETION
*               OF THE REQUEST.
#
 
#
****  PROC LINK$RP - XREF LIST BEGIN.
#
 
      XREF
        BEGIN
        PROC CONNECT;                # ESTABLISH LONG TERM CONNECTION #
        PROC KILL$UC;                # ABORT A *UCP* #
        PROC SFCALL;                 # INTERFACE TO *SFCALL* MACRO #
        PROC UCP$DON;                # TERMINATE *UCP* REQUEST PROPERLY
                                     #
        END
 
#
****  PROC LINK$RP - XREF LIST END.
#
 
 
      DEF LISTCON #0#;               # DO NOT LIST COMMON DECKS #
*CALL COMBFAS
*CALL COMBCPR
*CALL COMBUCR
*CALL COMXMSC
 
#
*     LIST FOR PROCESSING LINKAGE REQUESTS.
#
 
      SWITCH TYP1SW:REQTYP1
              PRCON:CONNECT,
             PRDISC:DISCONNECT;
 
 
 
 
 
#
*     REQUEST CODE HAS TO BE A VALID LINKAGE REQUEST CODE.
#
 
      IF CPR$RQC[0] EQ REQTYP1"RES1"  ##
        OR CPR$RQC[0] GQ REQTYP1"LSTREQTYP1"
      THEN
        BEGIN
        KILL$UC(KILLCODE"INVRQC");
        RETURN;
        END
 
 
#
*     PROCESS THE APPROPRIATE LINKAGE REQUEST AND THEN RETURN TO
*     THE CALLER.
#
 
      GOTO TYP1SW[CPR$RQC[0]];
 
 
PRCON:
      CONNECT;
      RETURN;
 
 
PRDISC:
      UCP$DON;
      RETURN;
 
 
      END  # LINK$RP #
 
    TERM
PROC QUE$RP;
# TITLE QUE$RP - QUEUABLE REQUEST PROCESSOR.                          #
 
      BEGIN  # QUE$RP #
 
#
**    QUE$RP - QUEUABLE REQUEST PROCESSOR.
*
*     *QUE$RP* DOES PRELIMINARY PROCESSING OF TYPE 4 *UCP* REQUESTS.
*     A LOW LEVEL REQUEST QUEUE ENTRY IS SET UP. FOR AN UNLOAD
*     CARTRIDGE REQUEST, THE UTILITY CARTRIDGE TABLE IS CLEARED.
*
*     PROC QUE$RP
*
*     ENTRY      POINTERS TO THE UCP REQUEST BEING PROCESSED AND
*                THE *LTCT* ENTRY CORRESPONDING TO THE REQUEST HAVE
*                BEEN SET.
*
*     EXIT       IF AN INCORRECT REQUEST CODE OR A UTILITY CONFLICT IS
*                DISCOVERED, THE UCP WILL BE ABORTED AND CONTROL WILL
*                RETURN TO THE CALLER.
*
*     NOTES      *QUE$RP* MUST NOT BE CALLED IF THE *LLRQ* IS FULL.
#
 
#
****  PROC QUE$RP - XREF LIST BEGIN.
#
 
      XREF
        BEGIN
        PROC ADD$LNK;                # ADD ENTRY TO END OF CHAIN #
        PROC KILL$UC;                # ABORT A UCP #
        PROC LLRQENQ;                # *LLRQ* ENQUEUER #
        END
 
#
****  PROC QUE$RP - XREF LIST END.
#
 
      DEF LISTCON    #0#;
*CALL COMBFAS
*CALL COMBCHN
*CALL COMBCPR
*CALL COMBLRQ
*CALL COMXLTC
*CALL COMXMSC
*CALL COMBUCR
 
      ITEM LLRADR     U;             # *LLRQ* ENTRY ADDRESS #
 
      SWITCH REQCODE:REQTYP4
                REQ1:LOAD$CART,
                REQ2:UNLD$CART,
                REQ3:CP$RAW$AU,
                REQ4:WRT$LAB,
              REQEND:LSTREQTYP4;
 
                                               CONTROL EJECT;
 
      IF CPR$RQC[0] LQ REQTYP4"RES4"  ##
        OR CPR$RQC[0] GQ REQTYP4"LSTREQTYP4"
      THEN                           # IF REQUEST CODE IS INCORRECT #
        BEGIN
        KILL$UC(KILLCODE"INVRQC");   # ABORT THE UCP #
        RETURN;
        END
 
      IF CPR$RQC[0] EQ REQTYP4"LOAD$CART"
      THEN                           # IF LOAD CARTRDIGE REQUEST #
        BEGIN  # LOAD CARTRDIGE REQUEST #
        IF LTC$CART[LTCENTRY]
        THEN                         # IF *UTCT* NOT EMPTY #
          BEGIN
          KILL$UC(KILLCODE"MULCART");  # CARTRIDGE ALREADY ACTIVE #
          RETURN;
          END
        ELSE
          BEGIN     # SET UP *LLRQ* ENTRY #
          LLRQENQ(LLRADR);
          P<LLRQ> = LLRADR;
          LLR$LTCT[0] = LTCENTRY;
          LLR$UCPRA[0] = UCP$ADDR[0];
          LLR$WORD4[0] = CPR3[0];
          LLR$WORD5[0] = CPR2[0];
          LTC$LLRQA[LTCENTRY] = LLRADR;
          END
 
        END  # LOAD CARTRIDGE REQUEST #
 
      IF CPR$RQC[0] EQ REQTYP4"UNLD$CART"
      THEN                           # IF UNLOAD CARTRIDGE REQUEST #
        BEGIN
        LTC$CART[0] = FALSE;
        END
 
      IF CPR$RQC[0] NQ REQTYP4"LOAD$CART"
      THEN
        BEGIN        # NO BUILD OF *LLRQ* #
        P<LLRQ> = LTC$LLRQA[LTCENTRY];
        LLR$DR[0] = 0;          # CLEAR OLD RESPONSE CODE #
        LLR$PRCST[0] = 0;
        LLR$RQC[0] = CPR$RQC[0];   # NEW REQUEST CODE #
        LLR$WORD4[0] = CPR3[0];
        LLR$YZ[0] = CPR$YZ[0];
        LLR$ADDR2[0] = CPR$ADDR2[0];
        END
 
#
*     SIMULATED CASE COMMAND FOR SETTING PROCESS NAME.
#
 
CORCOD:
      GOTO REQCODE[CPR$RQC[0]];
 
REQ1:                                # LOAD CARTRIDGE #
      LLR$PRCNME[0] = REQTYP4"LOAD$CART";
      RETURN;
 
REQ2:                                # UNLOAD CARTRIDGE #
      LLR$PRCNME[0] = REQTYP4"UNLD$CART";
      GOTO REQEND;
 
REQ3:                                # COPY RAW STREAM #
      LLR$PRCNME[0] = REQTYP4"CP$RAW$AU";
      GOTO REQEND;
 
REQ4:                                # WRITE LABEL #
      LLR$PRCNME[0] = REQTYP4"WRT$LAB";
      GOTO REQEND;
 
REQEND:
 
#
*     END SIMULATED CASE COMMAND FOR SETTING PROCESS NAME.
#
 
      ADD$LNK(LTC$LLRQA[LTCENTRY],LCHN"LL$READY",0);
      RETURN;
 
      END  # QUE$RP #
 
    TERM
PROC TYP2$RP;
# TITLE TYP2$RP - TYPE 2 REQUEST PROCESSOR.                           #
 
      BEGIN  # TYP2$RP #
 
#
**    TYP2$RP - TYPE 2 REQUEST PROCESSOR.
*
*     *TYP2$RP* DOES PRELIMINARY PROCESSING OF TYPE 2 *UCP* REQUESTS.
*     THE APPROPRIATE MODULE IS CALLED TO DO DETAILED PROCESSING OF
*     THE REQUEST.
*
*     PROC TYP2$RP
*
*     ENTRY      THE POINTER TO THE *UCP* REQUEST BEING PROCESSED
*                HAS BEEN SET (BASED ARRAY *CPR*).
*
*     EXIT       IF AN INCORRECT REQUEST CODE WAS DETECTED, THE *UCP*
*                HAS BEEN ABORTED, ELSE *ACTVMF* HAS BEEN CALLED.
#
 
#
*     PROC TYP2$RP - XREF LIST BEGIN.
#
 
      XREF
        BEGIN
        PROC DSSETUP;        # SETUP DESTAGE PROCESSING #
        PROC KILL$UC;                # ABORT A *UCP* #
        PROC SFCALL;         # INTERFACE TO *SFCALL* MACRO #
      PROC UCP$RES;        # ISSUE RESPONSE TO A *UCP* #
        END
 
#
*     PROC TYP2$RP - XREF LIST END.
#
 
      DEF LISTCON #0#;               # DO NOT LIST COMDECKS #
*CALL COMBFAS
*CALL COMBCPR
*CALL COMBUCR
*CALL,COMXLTC
*CALL,COMXMSC
 
      ITEM STAT      U;  # STATUS #
                                               CONTROL EJECT;
      IF CPR$RQC[0] LQ REQTYP2"RES2"  ##
        OR CPR$RQC[0] GQ REQTYP2"LSTREQTYP2"
      THEN                           # IF INCORRECT REQUEST CODE #
        BEGIN
        KILL$UC(KILLCODE"INVRQC");   # ABORT THE *UCP* #
        RETURN;
        END
 
#
*     CALL *DSSETUP* TO INITIATE DESTAGE PROCESSING.
*     IF PROBLEMS WITH THIS INITIATION OR IF THE NO-WAIT OPTION IS
*     SELECTED, ISSUE AN IMMEDIATE REPLY TO *SSMOVE*.  OTHERWISE,
*     SAVE THE LONG-TERM CONNECT TABLE ORDINAL SO A REPLY CAN
*     BE RETURNED UPON COMPLETION OF DESTAGING.
#
 
      DSSETUP(CPR$FAM[0],STAT);
 
      IF STAT NQ 0
      THEN
        BEGIN STAT = RESPTYP2"MRFERR"; END
      ELSE BEGIN STAT = RESPTYP2"OK2";
        IF NOT CPR$NW[0]
        THEN   # CAUSE *SSMOVE* TO BE ROLLED UNTIL DESTAGING
                        IS COMPLETE #
        BEGIN
        LTC$SFUCPA[LTCENTRY] = 0;
        LTC$SFSCPA[LTCENTRY] = 0;
        LTC$SFFC[LTCENTRY] = SFSWPO;
        SFCALL(LOC(LTC$WORD0[LTCENTRY]),NRCL);
        DSC$LTCT = LTCENTRY;
        RETURN;
        END
 
      END
 
#
*     REPLY IMMEDIATELY.
#
 
      LTC$RQR[LTCENTRY] = STAT;
      UCP$RES;
      RETURN;
      END  # TYP2$RP #
 
    TERM
PROC UCP$DON;
# TITLE UCP$DON - TERMINATE *UCP* REQUEST PROPERLY.                   #
 
      BEGIN  # UCP$DON #
 
#
**    UCP$DON - TERMINATE *UCP* REQUEST PROPERLY.
*
*     *UCP$DON* CLEANS UP THE LONG TERM CONNECT TABLE
*     ENTRY AND ANY OUTSTANDING REQUESTS WHEN A *UCP*
*     TERMINATES WHILE STILL HAVING A LONG TERM
*     CONNECTION WITH *SSEXEC*.
*
*     PROC UCP$DON
*
*     ENTRY     THE DISCONNECT REQUEST OR TERMINATION NOTICE IS IN
*               ARRAY *CPR*.  THE BASE POINTER FOR *CPR* IS ALREADY
*               SET.  THE *LTCT* ENTRY FOR THE REQUESTING *UCP* IS
*               POINTED TO BY *LTCENTRY*.
*
*     EXIT      THE REQUEST/NOTICE HAS BEEN PROCESSED.
*
*     MESSAGES  * EXEC ABNORMAL, UCP$DON.*
*
*     NOTE      IT IS ASSUMED THAT THE *LTCENTRY* FOR THE *UCP*
*               IS SET ON ENTRY.  THE REQUEST AREA FOR THE UCP,
*               AS DEFINED IN *COMBCPR*, IS USED AS A COUNTER
*               TO CLEAR THE TEST POINTS IF THE CONDITIONS ARE
*               PROPER.
#
 
#
****  PROC UCP$DON - XREF LIST BEGIN.
#
 
      XREF
        BEGIN
        PROC ABORT;                  # ABORTS PROCESSING #
        PROC ADD$LNK;                # ADD ENTRY TO END OF CHAIN #
        PROC LLRQENQ;                # LOW LEVEL REQUEST QUEUE ENQUEUER
                                     #
        PROC MESSAGE;                # ISSUES DAYFILE MESSAGE #
        PROC SFCALL;                 # INTERFACE TO *SFCALL* MACRO #
        PROC UCP$RES;                # NOTIFY *UCP* OF REQUEST
                                       COMPLETION #
        END
 
#
****  PROC UCP$DON - XREF LIST END.
#
 
      DEF OVERRIDE   #3#;            # N.OVERRIDE ON UCP #
 
      DEF LISTCON    #0#;            # DO NOT LIST COMMON DECKS #
*CALL COMBFAS
*CALL COMBCHN
*CALL COMBCPR
*CALL COMBLRQ
*CALL COMBMAT
*CALL COMBUCR
*CALL COMXCTF
*CALL COMXLTC
*CALL COMXMSC
 
      ITEM I          U;             # COUNTER #
      ITEM LLRQE      U;             # ADDRESS OF THE *LLRQ* FROM
                                       *LLRQENQ* #
      ITEM MATCH      B;             # LOOP CONTROL FLAG #
      ITEM RESTRT     B=FALSE;       # RESTART ALL PROCESSES AT A STEP
                                       POINT #
      ITEM UCPSWAPPED   B;           # UCP WAS SWAPPED OUT #
 
 
 
 
 
#
*     IF THE *UCP* HAS AN *LLRQ* ENTRY, FLAG THE *LLRQ* THAT
*
*     THE *UCP* HAS ABORTED.  IF AN CARTRIDGE IS LOADED, CLEAN-UP
*     WILL UNLOAD THE CARTRIDGE.
#
 
 
      IF LTC$LLRQA[LTCENTRY] NQ 0
      THEN
        BEGIN     # SET ABORT FLAG #
        P<LLRQ> = LTC$LLRQA[LTCENTRY];
        LLR$UCPABT[0] = TRUE;
        IF LTC$CART[LTCENTRY]                      ##
          AND LLR$RS[0] EQ PROCST"COMPLETE"          ##
          AND LTC$RQI[LTCENTRY] NQ REQNAME"RQIDBUG"
        THEN
          BEGIN     # SET UNLOAD OF CARTRIDGE #
          LLR$RQC[0] = REQTYP4"UNLD$CART";
          LLR$DR[0] = 0;     # CLEAR OLD FIELDS #
          LLR$PRCST[0] = 0;
          LLR$PRCNME[0] = REQTYP4"UNLD$CART";
          ADD$LNK(LTC$LLRQA[LTCENTRY],LCHN"LL$READY",0);
          END       # END OF UNLOAD CARTRIDGE #
        END      # END OF *LLRQ* CLEAN UP #
 
#
*     CLOSE OUT THE CONNECTION.
#
 
      LTC$SFSCPA[LTCENTRY] = 0;
 
      IF UCP$STAT[0] NQ 0
      THEN
        BEGIN  # PROCESS THE *UCP* TERMINATION NOTICE #
        LTC$SFUCPA[LTCENTRY] = -1;
        UCPSWAPPED = TRUE;
        REPEAT WHILE UCPSWAPPED
        DO
          BEGIN  # PROCESS SWAPPED *UCP* #
          LTC$SFFC[LTCENTRY] = SFENDT;
          SFCALL(LOC(LTC$WORD0[LTCENTRY]),RCL);
          IF LTC$SFRC[LTCENTRY] EQ SFRCSWPOUT
          THEN
            BEGIN
            LTC$SFFC[LTCENTRY] = SFSWPI;
            SFCALL(LOC(LTC$WORD0[LTCENTRY]),RCL);
            END
 
          ELSE
            BEGIN
            UCPSWAPPED = FALSE;
            END
 
          END  # PROCESS SWAPPED *UCP* #
 
        END  # PROCESS THE *UCP* TERMINATION NOTICE #
 
      ELSE
        BEGIN  # PROCESS THE DISCONNECT REQUEST #
 
#
*       CLEAR THE LONG TERM CONNECT.
#
 
        LTC$SFUCPA[LTCENTRY] = LTC$UCPA[LTCENTRY];
        UCPSWAPPED = TRUE;
        REPEAT WHILE UCPSWAPPED
        DO
          BEGIN  # WAIT FOR CONNECTION TO CLEAR #
          LTC$SFFC[LTCENTRY] = SFCLTC;
          SFCALL(LOC(LTC$WORD0[LTCENTRY]),RCL);
          IF LTC$SFRC[LTCENTRY] EQ SFRCSWPOUT
          THEN
            BEGIN
            LTC$SFFC[LTCENTRY] = SFSWPI;
            SFCALL(LOC(LTC$WORD0[LTCENTRY]),RCL);
            END
 
          ELSE
            BEGIN
            UCPSWAPPED = FALSE;
            END
 
          END  # WAIT FOR CONNECTION TO CLEAR #
 
        IF LTC$SFRC[LTCENTRY] NQ 0
        THEN
          BEGIN
          GOTO SFERR;
          END
 
#
*       RETURN THE OK1 RESPONSE.
#
 
        LTC$RQR[LTCENTRY] = RESPTYP1"OK1";
        UCPSWAPPED = TRUE;
        REPEAT WHILE UCPSWAPPED
        DO
          BEGIN  # WAIT FOR RESPONSE TO BE PROCESSED #
          LTC$SFFC[LTCENTRY] = SFWRIT;
          LTC$SFSCPA[LTCENTRY] = LOC(LTC$RQR[LTCENTRY]);
          LTC$SFUCPA[LTCENTRY] = LTC$UCPA[LTCENTRY] + 2;
          LTC$SFFP[LTCENTRY] = 1;
          SFCALL(LOC(LTC$WORD0[LTCENTRY]),RCL);
          IF LTC$SFRC[LTCENTRY] EQ SFRCSWPOUT
          THEN
            BEGIN
            LTC$SFFC[LTCENTRY] = SFSWPI;
            LTC$SFSCPA[LTCENTRY] = 0;
            LTC$SFFP[LTCENTRY] = 0;
            LTC$SFUCPA[LTCENTRY] = LTC$UCPA[LTCENTRY];
            SFCALL(LOC(LTC$WORD0[LTCENTRY]),RCL);
            END
 
          ELSE
            BEGIN
            UCPSWAPPED = FALSE;
            END
 
          END  # WAIT FOR RESPONSE TO BE PROCESSED #
 
        IF LTC$SFRC[LTCENTRY] NQ 0
        THEN
          BEGIN
          GOTO SFERR;
          END
 
#
*       ACKNOWLEDGE REQUEST COMPLETION.
#
 
        UCPSWAPPED = TRUE;
        LTC$SFUCPA[LTCENTRY] = LTC$UCPA[LTCENTRY];
        LTC$SFSCPA[LTCENTRY] = 0;
        LTC$SFFP[LTCENTRY] = 0;
        REPEAT WHILE UCPSWAPPED
        DO
          BEGIN  # WAIT UNTIL *ENDT* IS PROCESSED #
          LTC$SFFC[LTCENTRY] = SFENDT;
          SFCALL(LOC(LTC$WORD0[LTCENTRY]),RCL);
          IF LTC$SFRC[LTCENTRY] EQ SFRCSWPOUT
          THEN
            BEGIN
            LTC$SFFC[LTCENTRY] = SFSWPI;
            SFCALL(LOC(LTC$WORD0[LTCENTRY]),RCL);
            END
 
          ELSE
            BEGIN
            UCPSWAPPED = FALSE;
            END
 
          END  # WAIT UNTIL *ENDT* IS PROCESSED #
 
        END  # PROCESS THE DISCONNECT REQUEST #
 
SFERR:
      IF LTC$SFRC[LTCENTRY] EQ 0 OR LTC$SFRC[LTCENTRY] EQ SFRCUCPGON
        OR (LTC$SFRC[LTCENTRY] EQ SFRCUCPNET AND UCP$STAT[0] EQ
        OVERRIDE)
      THEN
        BEGIN  # CLEAR THE *LTCT* ENTRY #
        CONIND[LTC$RQI[LTCENTRY]] = FALSE;
        LTC$WORD0[LTCENTRY] = 0;
        LTC$WORD1[LTCENTRY] = 0;
        LTC$WORD2[LTCENTRY] = 0;
        LTC$WORD3[LTCENTRY] = 0;
        RETURN;
        END  # CLEAR THE *LTCT* ENTRY #
 
      ELSE
        BEGIN  # UNEXPECTED *SFCALL* RESPONSE #
        FE$RTN[0] = "UCP$DON.";
        MESSAGE(FEMSG[0],UDFL1);
        ABORT;
        END  # UNEXPECTED *SFCALL* RESPONSE #
 
      END  # UCP$DON #
 
    TERM
PROC UCP$RES;
# TITLE UCP$RES - NOTIFY *UCP* OF REQUEST COMPLETE.                   #
 
      BEGIN  # UCP$RES #
 
#
**    UCP$RES - NOTIFY *UCP* OF REQUEST COMPLETE.
*
*     *UCP$RES* RETURNS THE REQUEST RESPONSE WORD TO THE *UCP*
*     AND THEN NOTIFIES THE *UCP* (AND O/S) THAT THE PROCESSING
*     OF THE REQUEST HAS BEEN COMPLETED.
*
*     PROC UCP$RES
*
*     ENTRY     THE *LTCT* ENTRY POINTED TO BY *LTCENTRY* CONTAINS
*               ALL THE INFORMATION NEEDED.
*
*     EXIT      IF THE *UCP* WAS SWAPPED OUT, AN *SF.SWPI* REQUEST
*               HAS BEEN ISSUED AND THE SWAPPED-UCP FLAG IN THE *LTCT*
*               ENTRY HAS BEEN SET.  OTHERWISE, THE RESPONSE WORD HAS
*               BEEN WRITTEN BACK TO THE *UCP* AND THE *UCP* HAS BEEN
*               NOTIFIED THAT PROCESSING OF ITS LAST REQUEST HAS BEEN
*               COMPLETED.
*
*     MESSAGES  * EXEC ABNORMAL, UCP$RES.*
*
#
 
#
****  PROC UCP$RES - XREF LIST BEGIN.
#
 
      XREF
        BEGIN
        PROC ABORT;                  # ABORTS PROCESSING #
        PROC MESSAGE;                # ISSUES DAYFILE MESSAGE #
        PROC RTIME;                  # GETS TIME SINCE DEADSTART #
        PROC SFCALL;                 # INTERFACE TO *SFCALL* MACRO #
        END
 
#
****  PROC UCP$RES - XREF LIST END.
#
 
      DEF LISTCON #0#;               # DO NOT LIST COMMON DECKS #
*CALL COMBFAS
*CALL COMBUCR
*CALL COMXCTF
*CALL COMXIPR
*CALL COMXLTC
*CALL COMXMSC
 
 
 
 
 
#
*     RETURN REQUEST RESPONSE WORD TO THE *UCP*.
#
 
      LTC$SFUCPA[LTCENTRY] = LTC$UCPA[LTCENTRY] + 2;
      LTC$SFSCPA[LTCENTRY] = LOC(LTC$RQR[LTCENTRY]);
      LTC$SFFP[LTCENTRY] = 1;
      LTC$SFFC[LTCENTRY] = SFWRIT;
      SFCALL(LOC(LTC$WORD0[LTCENTRY]),RCL);
      IF LTC$SFRC[LTCENTRY] EQ SFRCSWPOUT
      THEN
        BEGIN  # SWAPPED *UCP* #
        LTC$UCPSW[LTCENTRY] = TRUE;
        GLBUCPSW = TRUE;
        LTC$SFUCPA[LTCENTRY] = 0;
        LTC$SFSCPA[LTCENTRY] = 0;
        LTC$SFFC[LTCENTRY] = SFSWPI;
        SFCALL(LOC(LTC$WORD0[LTCENTRY]),NRCL);
 
        IF UCP$EXPIR EQ 0
        THEN
          BEGIN
          RTIME(RTIMESTAT[0]);
          UCP$EXPIR = RTIMSECS[0] + UCP$INTV;
          END
 
        RETURN;
        END  # SWAPPED *UCP* #
 
      ELSE
        BEGIN
        IF LTC$SFRC[LTCENTRY] NQ 0 AND LTC$SFRC[LTCENTRY] NQ
          SFRCUCPGON
        THEN                         # UNEXPECTED RESPONSE #
          BEGIN
          FE$RTN[0] = "UCP$RES.";
          MESSAGE(FEMSG[0],UDFL1);
          ABORT;
          END
 
        END
 
#
*     NOTIFY THE *UCP* THAT THE REQUEST IS COMPLETE.
#
 
      LTC$SFUCPA[LTCENTRY] = LTC$UCPA[LTCENTRY];
      LTC$SFSCPA[LTCENTRY] = 0;
      LTC$SFFP[LTCENTRY] = 0;
      LTC$SFFC[LTCENTRY] = SFENDT;
      SFCALL(LOC(LTC$WORD0[LTCENTRY]),RCL);
      IF LTC$SFRC[LTCENTRY] EQ SFRCSWPOUT
      THEN
        BEGIN  # *UCP* SWAPPED #
        LTC$UCPSW[LTCENTRY] = TRUE;
        GLBUCPSW = TRUE;
        LTC$SFUCPA[LTCENTRY] = 0;
        LTC$SFSCPA[LTCENTRY] = 0;
        LTC$SFFC[LTCENTRY] = SFSWPI;
        SFCALL(LOC(LTC$WORD0[LTCENTRY]),NRCL);
 
        IF UCP$EXPIR EQ 0
        THEN
          BEGIN
          RTIME(RTIMESTAT[0]);
          UCP$EXPIR = RTIMSECS[0] + UCP$INTV;
          END
 
        RETURN;
        END  # *UCP* SWAPPED #
 
      ELSE
        BEGIN
        IF LTC$SFRC[LTCENTRY] NQ 0 AND LTC$SFRC[LTCENTRY] NQ
          SFRCUCPGON
        THEN                         # UNEXPECTED RESPONSE #
          BEGIN
          FE$RTN[0] = "UCP$RES.";
          MESSAGE(FEMSG[0],UDFL1);
          ABORT;
          END
 
        END
 
#
*     CLEAR THE REQUEST FROM THE LONG TERM CONNECT TABLE.
#
 
      LTC$UCPSW[LTCENTRY] = FALSE;
      LTC$UCPA[LTCENTRY] = 0;
      LTC$WORD3[LTCENTRY] = 0;
      RETURN;
 
      END  # UCP$RES #
 
    TERM
PROC UCP$RP;
# TITLE UCP$RP - PRELIMINARY PROCESSING OF *UCP* REQUESTS.            #
 
      BEGIN  # UCP$RP #
 
#
**    UCP$RP - PRELIMINARY PROCESSING OF *UCP* REQUESTS.
*
*     *UCP$RP* DOES PRELIMINARY PROCESSING OF *UCP* REQUESTS AND CALLS
*     THE APPROPRIATE MODULES TO DO FURTHER PROCESSING OF THE REQUESTS.
*
*     PROC UCP$RP
*
*     ENTRY     A NEW *UCP* REQUEST HAS BEEN RECEIVED AND IF
*               IT IS A TYPE 4 OR 5 REQUEST, AT LEAST ONE *LLRQ*
*               ENTRY IS AVAILABLE ON THE *LLRQ* FREE SPACE CHAIN.
*
*     EXIT      TYPE 4 OR 5 REQUESTS HAVE BEEN ENQUEUED IN THE
*               *LLRQ* FOR FUTURE PROCESSING. ALL OTHER REQUESTS HAVE
*               BEEN PROCESSED TO COMPLETION.
*
*     NOTES     BEFORE SUBORDINATE ROUTINES ARE CALLED, THE BASE
*               POINTERS FOR *CPR* AND *UCPR* ARE SET AND *LTCENTRY*
*               IS SET TO POINT TO THE *LTCT* ENTRY FOR THE *UCP*.
#
 
#
****  PROC UCP$RP - XREF LIST BEGIN.
#
 
      XREF
        BEGIN
        PROC ALT$RP;                 # PRELIMINARY PROCESSING OF
                                       *SSALTER* REQUESTS #
        PROC KILL$UC;                # ABORT A *UCP* #
        PROC LINK$RP;                # PRELIMINARY LINKAGE PROCESSING #
        PROC NONQ$RP;                # PRELIMINARY PROCESSING OF TYPE 3
                                       REQUEST #
        PROC QUE$RP;                 # QUEUABLE REQUEST PROCESSOR #
        PROC SFCALL;                 # ISSUES *SFCALL* REQUEST #
        PROC TYP2$RP;                # TYPE 2 REQUEST PROCESSOR #
        PROC UCP$DON;                # TERMINATE *UCP* REQUEST PROPERLY
                                     #
        END
 
#
****  PROC UCP$RP - XREF LIST END.
#
 
      DEF LISTCON    #0#;            # DO NOT LIST COMMON DECKS #
*CALL COMBFAS
*CALL COMBCHN
*CALL COMBCPR
*CALL COMBLRQ
*CALL COMBUCR
*CALL COMXCTF
*CALL,COMXJCA
*CALL COMXLTC
*CALL COMXMSC
 
      ITEM I          U;             # LOOP COUNTER #
      ITEM J          U;             # LOOP COUNTER #
      ITEM TESTEXIT   B;             # *FOR* LOOP CONTROL SWITCH #
      ITEM UCPSWAPPED B;             # UCP WAS SWAPPED OUT #
#
*     STATUS SWITCH LIST TO PROCESS TYPE OF REQUEST.
#
 
      SWITCH TYPSW:TYP
             TYPE1:TYP1,
             TYPE2:TYP2,
             TYPE3:TYP3,
             TYPE4:TYP4,
             TYPE5:TYP5;
 
 
 
 
 
      P<LTCT> = LTCTPTR;
 
#
*     THE FOLLOWING *FOR* LOOP IS THE MAIN CONTROL LOOP OF *UCP$RP*.
*     THIS LOOP MAINTAINS CONTROL IN THIS PROCEDURE UNTIL THERE ARE
*     NO MORE *UCP* REQUESTS TO BE STARTED.
#
 
      SLOWFOR I=0 WHILE RA$SSCINLK[0]  ##
        AND CHN$BOC[LCHN"LL$FRSPC"] NQ 0
      DO
        BEGIN  # PROCESS *UCP* REQUEST #
        P<UCPR> = RA$SSCAP[0];
        P<CPR> = RA$SSCAP[0] + 2;
 
#
*     SWITCH TO ALTERNATE *UCP* REQUEST RECEIVING AREA.
#
 
        RA$SSCAP[0] = LOC(UCPPARM[UCPPARMSW]);
        IF UCPPARMSW EQ 0
        THEN
          BEGIN
          UCPPARMSW = 1;
          END
 
        ELSE
          BEGIN
          UCPPARMSW = 0;
          END
 
        RA$SSCINLK[0] = FALSE;
        TESTEXIT = FALSE;
        SFJBSN[0] = UCP$JBSN[0];
        SFFSTA[0] = UCP$FSTA[0];
 
        LTCENTRY = 0;
        FASTFOR J = 1 STEP 1 WHILE J LQ LTCTCNT AND NOT TESTEXIT
        DO
          BEGIN  # *LTCT* SEARCH #
          IF UCP$JBSN[0] EQ LTC$SFJBSN[J]  ##
            AND UCP$FSTA[0] EQ LTC$SFFSTA[J]
          THEN
            BEGIN  # *UCP* HAS AN ENTRY IN THE *LTCT* #
            TESTEXIT = TRUE;
            LTCENTRY = J;
            END  # *UCP* HAS AN ENTRY IN THE *LTCT* #
 
          ELSE
            BEGIN
            TEST J;
            END
 
          END  # *LTCT* SEARCH #
 
        IF UCP$STAT NQ 0
        THEN
          BEGIN  # PROCESS TERMINATION NOTICE FROM O/S #
          IF TESTEXIT
          THEN
            BEGIN  # TERMINATING *UCP* WAS CONNECTED #
            UCP$DON;
            END  # TERMINATING *UCP* WAS CONNECTED #
 
          ELSE
            BEGIN  # TERMINATING UCP NOT CONNECTED #
            SFUCPA[0] = -1;
            UCPSWAPPED = TRUE;
            REPEAT WHILE UCPSWAPPED
            DO
              BEGIN  # WAIT UNTIL *ENDT* IS PROCESSED #
              SFFC[0] = SFENDT;
              SFCALL(SFBLKPTR,RCL);
              IF SFRC[0] EQ SFRCSWPOUT
              THEN
                BEGIN
                SFFC[0] = SFSWPI;
                SFCALL(SFBLKPTR,RCL);
                END
 
              ELSE
                BEGIN
                UCPSWAPPED = FALSE;
                END
 
              END  # WAIT UNTIL *ENDT* IS PROCESSED #
 
            END  # TERMINATING *UCP* NOT CONNECTED #
 
          TEST I;
          END  # PROCESS TERMINATION NOTICE FROM O/S #
 
        ELSE
          BEGIN  # PROCESS REQUEST FROM *UCP* #
          IF NOT TESTEXIT
          THEN
            BEGIN  # NOT IN *LTCT* SO REQUIRE A CONNECT #
            IF CPR$RQT[0] EQ TYP"TYP1"  ##
              AND CPR$RQC[0] EQ REQTYP1"CONNECT"
            THEN
              BEGIN
              LINK$RP;
              END
 
            ELSE
              BEGIN
              KILL$UC(KILLCODE"NOTCON");
              END
 
            TEST I;
            END  # NOT IN *LTCT* SO REQUIRE A CONNECT #
 
          IF LTC$UCPA[LTCENTRY] NQ 0
          THEN
            BEGIN  # PREVIOUS REQUEST NOT PROCESSED YET #
            KILL$UC(KILLCODE"MULREQ");
            TEST I;
            END  # PREVIOUS REQUEST NOT PROCESSED YET #
 
          IF CPR$RQT[0] EQ TYP"TYP0" OR CPR$RQT[0] GQ TYP"TYPLST"
          THEN
            BEGIN  # TYPE CODE OUT OF RANGE #
            KILL$UC(KILLCODE"INVRQT");
            TEST I;
            END  # TYPE CODE OUT OF RANGE #
 
#
*      SET THE LONG TERM CONNECT TABLE ENTRY TO REFLECT THE CURRENT
*      REQUEST.
#
 
          LTC$WORD3[LTCENTRY] = CPR3[0];
          LTC$UCPA[LTCENTRY] = UCP$ADDR[0];
 
#
*     CALL THE APPROPRIATE REQUEST PROCESSOR.
#
 
          GOTO TYPSW[CPR$RQT[0]];
 
TYPE1:
          LINK$RP;
          TEST I;
 
TYPE2:
          TYP2$RP;
          TEST I;
 
TYPE3:
          NONQ$RP;
          TEST I;
 
TYPE4:
          QUE$RP;
          TEST I;
 
TYPE5:
          ALT$RP;
          TEST I;
 
          END  # PROCESS REQUEST FROM *UCP* #
 
        END  # PROCESS *UCP* REQUEST #
 
#
*     RETURN TO THE CALLER WHEN THERE IS NO REQUEST TO
*     PROCESS OR NO REQUEST CAN BE PROCESSED.
#
 
      RETURN;
      END  # UCP$RP #
 
    TERM
PROC UCP$WRI((LLRQADDR2),(WORDCOUNT),(SCPADDR),RSTATUS);
# TITLE UCP$WRI - PASS DATA TO *UCP*.                                 #
 
      BEGIN  # UCP$WRI #
 
#
**    UCP$WRI - PASS DATA TO *UCP*.
*
*     *UCP$WRI* ISSUES AN *SF.WRIT* TO TRANSFER INFORMATION BACK
*     TO THE *UCP*.
*
*     PROC UCP$WRI((LLRQADDR2),(WORDCOUNT),(SCPADDR),RSTATUS)
*
*     ENTRY      LLRQADDR2 = DESTINATION OF DATA IN *UCP*.
*                WORDCOUNT = NUMBER OF WORDS TO BE TRANSFERRED
*                            TO *UCP*.
*                SCPADDR   = SOURCE OF DATA IN THE *SCP*.
*
*     EXIT       RSTATUS   = *SFCALL* ERROR RETURNED TO THE CALLER.
*
*     NOTE       *LTCENTRY* CONTAINS THE ORDINAL OF THE *UCP* LONG
*                TERM CONNECT TABLE ENTRY.
*
#
 
      ITEM LLRQADDR2  U;             # DESTINATION OF DATA IN *UCP* #
      ITEM WORDCOUNT  U;             # NUMBER OF WORDS TO BE
                                       TRANSFERRED #
      ITEM SCPADDR    U;             # SOURCE OF DATA IN *SCP* #
      ITEM RSTATUS    U;             # *SFCALL* ERROR RETURNED TO
                                       CALLER #
 
#
****  PROC UCP$WRI - XREF LIST BEGIN.
#
 
      XREF
        BEGIN
        PROC SFCALL;                 # INTERFACE TO *SFCALL* MACRO #
        END
 
#
****  PROC UCP$WRI - XREF LIST END.
#
 
 
 
      DEF LISTCON #0#;               # DO NOT LIST COMMON DECKS #
*CALL COMBFAS
*CALL COMBUCR
*CALL COMXLTC
*CALL COMXMSC
 
 
 
 
 
#
*     SET UP AN *SFCALL* REQUEST FOR AN *SF.WRIT* AND ISSUE IT.
#
 
      LTC$SFUCPA[LTCENTRY] = LLRQADDR2;
      LTC$SFSCPA[LTCENTRY] = SCPADDR;
      LTC$SFFP[LTCENTRY] = WORDCOUNT;
      LTC$SFFC[LTCENTRY] = SFWRIT;
      SFCALL(LOC(LTC$WORD0[LTCENTRY]),RCL);
      RSTATUS = LTC$SFRC[LTCENTRY];
      RETURN;
      END  # UCP$WRI #
 
    TERM