*DECK RECOVR
          IDENT  RECOVR 
          COMMENT RECOVR - V2.0, USER INTERFACE TO *RPV*. 
          ENTRY  RECOVR,SETUP.
          SST 
          SPACE  4
****      RECOVR - V2.0, USER INTERFACE TO *RPV*. 
* 
*         A.F.R.BROWN               1 OCTOBER 1981
* 
*         COPYRIGHT CONTROL DATA SYSTEMS INC. 1994. 
************************************************************
* 
*    *     *   *   ***  *  * * *  *  ***
*    *     *  * *  *  * ** * * ** * * 
*     * * *  ***** ***  * ** * * ** *  ** 
*      * *   *   * *  * *  * * *  *  ***
* 
*         IF THIS PROGRAM HAS TO BE CHANGED IN FUTURE, THE SAME CHANGES 
*         PROBABLY HAVE TO BE MADE IN PROGRAM *DBUG.*, PART OF THE CYBER
*         INTERACTIVE DEBUGGER. IT CONTAINS AN ALMOST IDENTICAL COPY OF 
*         RECOVR (THE DIFFERENCES ARE NOTED IN THE LISTING OF DBUG.)
*         AS WELL AS A SECOND, HEAVILY ALTERED COPY. THE ALTERED COPY 
*         WILL REQUIRE MORE THOUGHT, TO DECIDE WHETHER IT NEEDS THE 
*         CHANGES, OR SOME EQUIVALENT CHANGES, OR NO CHANGE.
*************************************************************** 
* 
***       *RECOVR* VERSION 2.0 IS A REWRITE OF THE *RPV* INTERFACE
*         SUBROUTINE TO PROVIDE ACCESS TO THE EXTENDED FEATURES OF
*         *RPV*. WE HAVE TRIED NOT TO RESPOND UNEXPECTEDLY TO ANY 
*         OLD-STYLE CALLS TO RECOVR AND SETUP.
* 
*         THE FIRST EXTENSION IS THAT WHEN CALLING RECOVR OR SETUP.,
*         THE USER MAY SPECIFY CHECKSUMMING OR NOT CHECKSUMMING AS
*         BEFORE, OR HE MAY SPECIFY CHECKSUMMING OF AN AREA WITH
*         A GIVEN STARTING ADDRESS AS WELL AS A GIVEN END ADDRESS,
*         AND THIS AREA DOES NOT HAVE TO BEGIN WHERE THE SPECIFIED
*         REPRIEVE ROUTINE IS ENTERED.
* 
*         THE SECOND EXTENSION IS THAT THE STACK CAN ACCOMODATE 10
*         DIFFERENT RECOVR OR SETUP. CALLS, INSTEAD OF 5 AS BEFORE. 
* 
*         THE THIRD EXTENSION IS THAT MORE INFORMATION IS MADE AVAILABLE
*         TO A USER ROUTINE CALLED AT REPRIEVE TIME. SUCH A ROUTINE IS
*         CALLED WITH THREE PARAMETERS, OF WHICH THE FIRST HAS BEEN,
*         HITHERTO, AN ARRAY OF 17 WORDS. THE FIRST 16 ARE THE EXCHANGE 
*         PACKAGE AS IT WAS WHEN THE REPRIEVE-CAUSING EVENT TOOK PLACE, 
*         AND THE 17TH IS A COPY OF RA+1 AS IT WAS AT THAT MOMENT.
*         THE EXTENSION ADDS A FURTHER 9 WORDS AFTER THOSE 17. THE FIRST
*         OF THOSE WORDS -- THE 18TH IN THE WHOLE ARRAY -- DOES NOT 
*         REALLY CONTAIN ANY INFORMATION, BUT THE LAST 8 -- THE 19TH
*         THROUGH 26TH -- ARE A COPY OF THE 2ND THROUGH 9TH WORDS OF THE
*         PARAMETER BLOCK SHOWN ON PAGE 2-10-7 OF THE *NOS* MANUAL, 
*         UNDER *REPRIEVE PROCESSING* . WHEN RECOVR CALLS MONITOR RPV,
*         THE CALL POINTS TO THIS PARAMETER BLOCK, AND IF A REPRIEVE
*         ACTUALLY OCCURS, INFORMATION IS STORED IN THE BLOCK BY
*         MONITOR BEFORE MONITOR CALLS RECOVR. REMEMBER THAT RECOVR 
*         IS ACTING AS A WHOLESALER BETWEEN MONITOR AND THE RETAIL
*         REPRIEVE ROUTINES THAT THE MEMBERS OF THE PROGRAM SET, AND
*         USER PROGRAMS, PROVIDE. 
* 
*         THE FOURTH EXTENSION IS THAT A REPRIEVE ROUTINE MAY NOW CALL
*         FOR A ((RESUME)) TO BE DONE. THIS MEANS THAT THE JOB CAN BE,
*         MAYBE, RESTORED TO ((NORMAL)) LIFE, AS THOUGH A REVERSAL OF 
*         CONVICTION FOLLOWED THE TEMPORARY REPRIEVE. 
*         THE USER REPRIEVE ROUTINE MAKES ANY CHANGES IT WANTS TO IN
*         THE EXCHANGE PACKAGE, AND IN THE PENDING-RA+1-REQUEST AND 
*         INTERRUPTED-TERMINAL-I/O WORDS (7TH AND 8TH AFTER THE END 
*         OF THE EXCHANGE PACKAGE), THEN STORES THE VALUE 4 IN
*         THE 2ND WORD AFTER THE END OF THE EXCHANGE PACKAGE, AND 
*         FINALLY DOES A SUBROUTINE EXIT. *RECOVR* SEES THE 4, AND SO 
*         COPIES THE 3RD THROUGH 10TH WORDS AFTER THE EXCHANGE PACKAGE
*         INTO THE 2ND THROUGH 9TH WORDS OF THE REPRIEVE PACKAGE (OF
*         WHICH THE EXCHANGE PACKAGE IS THE 10TH THROUGH 25TH WORDS)
*         AND THEN MAKES AN RPV-RESUME CALL TO MONITOR, POINTING TO 
*         THAT REPRIEVE PACKAGE.
* 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
* 
*         *RECOVR* HAS TWO ENTRY POINTS -- SETUP., WHICH IS CALLED WITH 
*         PARAMETERS IN X AND B REGISTERS, AND RECOVR, WHICH IS CALLED
*         WITH A1 POINTING TO AN APLIST. THIS IS THE ONLY DIFFERENCE
*         BETWEEN THE TWO ENTRY POINTS. HENCEFORTH WE SHALL MOSTLY
*         REFER TO SETUP. AS THE ENTRY POINT, BUT RECOVR IS 
*         EQUALLY AVAILABLE.
* 
*         WHEN SETUP. IS CALLED WITH A NON-ZERO MASK, IT IS TO ADD A
*         NEW ENTRY TO THE END OF THE REPRIEVE STACK, OR TO CHANGE
*         THE MASK OF AN EXISTING ENTRY, WITHOUT CHANGING ITS POSITION
*         IN THE STACK. THE ENTRY IS NEW IF THERE IS NO ENTRY ALREADY IN
*         THE STACK WITH THE SAME ENTRY POINT.
* 
*         WHEN SETUP. IS CALLED WITH A ZERO MASK, IT IS TO REMOVE AN
*         ENTRY FROM THE REPRIEVE STACK, NAMELY THE ENTRY WITH THE SAME 
*         ENTRY POINT ADDRESS AS THAT GIVEN IN THE CALL. IF THERE 
*         IS NO SUCH ENTRY ALREADY IN THE STACK, A SETUP. CALL WITH 
*         ZERO MASK HAS NO EFFECT.
* 
*         WHEN A MONITOR REPRIEVE OCCURS,CONTROL GOES TO SYSEP IN RECOVR
*         AND AT SYSEP WE SCAN THE REPRIEVE STACK BACKWARDS, FROM END TO
*         BEGINNING, AND CALL AS A SUBROUTINE THE ENTRY POINT OF EACH 
*         ITEM IN THE STACK, IF ITS ACCOMPANYING MASK HAS THE RIGHT BIT 
*         SET. WHILE ANY OF THESE SUBROUTINES IS BEING EXECUTED,
*         NO REPRIEVE AT ALL IS IN EFFECT, SO THAT A FATAL ERROR WOULD
*         CAUSE A SIMPLE JOB ABORT. FURTHERMORE, IF ANY OF THESE SUB- 
*         ROUTINES TRIES TO CALL SETUP. TO CHANGE THE CONTENTS OF THE 
*         REPRIEVE STACK, SETUP. WILL EXIT IMMEDIATELY WITHOUT DOING
*         ANYTHING. IT WILL NOT COUNT AS AN ERROR AGAINST THE REPRIEVE
*         ROUTINE, BUT THE CALL TO SETUP. WILL HAVE NO EFFECT AT ALL. 
* 
*         ON GETTING CONTROL BACK FROM EACH OF THESE ROUTINES, SYSEP
*         CHECKS WHETHER A RESUME HAS BEEN CALLED FOR, AS DESCRIBED 
*         ABOVE. IF SO, THE RPV-RESUME REQUEST IS MADE TO MONITOR,
*         AND ANY REMAINING ENTRIES IN THE REPRIEVE STACK ARE LEFT
*         UNEXECUTED, AT LEAST FOR THIS CYCLE. WHEN THE RESUME TAKES
*         PLACE, THE STATUS OF THE JOB IS NORMAL AGAIN, AT LEAST IN 
*         THE SENSE THAT (1) AN OVER-ALL REPRIEVE IS ONCE MORE IN 
*         EFFECT, AND (2) THE JOB CAN CALL SETUP. TO ALTER THE
*         REPRIEVE STACK. 
* 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
* 
*         AS THIS VERSION OF RECOVR WAS CODED AND TESTED IN SYMPL 
*         FIRST, AND TRANSLATED INTO COMPASS AFTERWARDS, WE HAVE LEFT 
*         THE SYMPL CODE (WITH ASTERISKS IN COLUMN 1 TO MAKE COMMENTS 
*         OUT OF IT) INTERMIXED WITH THE COMPASS CODE, HOPING THAT IT 
*         IT WILL HELP TO EXPLAIN THE COMPASS CODE. IT SHOULD BE
*         AT LEAST CONVENIENT AS A DESCRIPTION OF THE TABLE FORMATS 
*         OF THE REPRIEVE STACK (ARRAY USER$STACK) AND THE REPRIEVE 
*         PACKAGE (ARRAY RPV$BLOCK).
* 
***    ENTRY CONDITIONS --- AT *RECOVR* 
* 
*                (A1) = FWA OF PARAMETER LIST.
*                (X1) = ((A1)) = ENTRY POINT OF REPRIEVE SUBROUTINE.
*                IF (X1) .LT. 0, THEN JUST REINSTATE *RPV* AND RETURN 
*                ALL OTHER PARAMETERS ARE IRRELEVANT. 
*                ((A1)+1) = ADDRESS OF REPRIEVE MASK. 
*                ((A1)+2) = ADDRESS OF WORD CONTAINING ONE OF --
*                              [A] 0 FOR NO CHECKSUMMING
*                              [B] AN ADDRESS GREATER THAN (X1),
*                                  INDICATING THAT WORDS FROM (X1)+1 TO 
*                                  THIS ADDRESS INCLUSIVE SHOULD BE 
*                                  CHECKSUMMED. 
*                              [C] A NEGATIVE NUMBER, INDICATING
*                                  THAT THERE ARE 2 MORE PARAMETERS.
* 
*                   IF AND ONLY IF THE THIRD PARAMETER IS NEGATIVE -- 
* 
*                ((A1)+3) = ADDRESS OF WORD CONTAINING
*                           FWA OF AREA TO BE CHECKSUMMED.
*                ((A1)+4) = ADDRESS OF WORD CONTAINING
*                           LWA OF AREA TO BE CHECKSUMMED.
* 
*         THE CHECKSUM IS FORMED AND SAVED WHEN THE CALL TO RECOVR
*         IS MADE, AND CHECKED WHENEVER THE SUBROUTINE AT THE GIVEN 
*         ENTRY POINT IS ABOUT TO BE CALLED.
* 
*         IF REPRVD CONTAINS NON-ZERO, RECOVR SHOULD DO NOTHING AND EXIT
*         IMMEDIATELY. THIS FLAG MEANS THAT RECOVR HAS BEEN CALLED BY 
*         A USER REPRIEVE ROUTINE. IN THE INTEREST OF SIMPLICITY, SUCH
*         A CALL IS FORBIDDEN BUT NOT PUNISHED. 
* 
***     ENTRY CONDITIONS -- AT SETUP. 
* 
*         LOGICALLY THE SAME AS FOR RECOVR, BUT PARAMETERS ARE IN 
*         REGISTERS --
* 
*                (B1) = ENTRY POINT OF REPRIEVE SUBROUTINE. 
*                (X4) = REPRIEVE MASK (RIGHT JUSTIFIED).
*                (B3) = ONE OF -- 
*                         0 , FOR NO CHECKSUMMING.
*                         AN ADDRESS GREATER THAN (B1), INDICATING
*                           THAT ((B1)+1) THROUGH ((B3)) INCLUSIVE ARE
*                           TO BE CHECKSUMMED.
*                         A NEGATIVE NUMBER, INDICATING THAT
*                           ((B4)) THROUGH ((B5)) INCLUSIVE ARE TO
*                           CHECKSUMMED.
*                (B4) AND (B5) ARE USED ONLY IF (B3) IS NEGATIVE. 
* 
*         IF REPRVD CONTAINS NON-ZERO, SETUP. SHOULD DO NOTHING AND EXIT
*         IMMEDIATELY. THIS FLAG MEANS THAT SETUP. HAS BEEN CALLED BY 
*         A USER REPRIEVE ROUTINE. IN THE INTEREST OF SIMPLICITY, SUCH
*         A CALL IS FORBIDDEN BUT NOT PUNISHED. 
* 
***    ENTRY CONDITIONS -- WHEN USER REPRIEVE SUBROUTINE ENTERED
* 
*                (B1)=(X1)=((A1)) = ADDRESS OF REPRIEVE PACKAGE.
*                (B2)=((A1)+1) = ADDRESS OF ABT$FLAG. 
*                (B3)=((A1)+2) = 1 .
*                     ((A1)+3) = 0 .
* 
*         THE REPRIEVE PACKAGE CONSISTS OF 26 WORDS. THE FIRST 16 ARE 
*         THE EXCHANGE PACKAGE AS IT WAS WHEN THE REPRIEVE-CAUSING
*         EVENT HAPPENED. IF THE REPRIEVE SUBROUTINE CALLS FOR A RESUME,
*         THE SAME EXCHANGE PACKAGE AREA WILL BE USED BY MONITOR IN 
*         STARTING UP THE C.P. OF COURSE, THE CONTENTS OF THE EXCHANGE
*         PACKAGE AREA MAY HAVE BEEN CHANGED IN WHOLE OR IN PART BY 
*         THE REPRIEVE SUBROUTINE.
* 
*         THE 17TH WORD IS A COPY OF RA+1 AS IT WAS AT THE MOMENT OF
*         REPRIEVE. THE 18TH WORD IS NOT INTERESTING. THE 19TH THROUGH
*         26TH WORDS ARE COPIES OF THE 2ND THROUGH 9TH WORDS OF THE 
*         REPRIEVE PACKAGE DESCRIBED BELOW UNDER ((ENTRY CONDITIONS 
*         -- WHEN MONITOR CALLS RECOVR AT SYSEP)). THE WORDS HAVE BEEN
*         COPIED SO THAT THE USER REPRIEVE SUBROUTINE CAN GET AT THEM 
*         WITHOUT NEGATIVE INDEXING.
* 
*         ABT$FLAG IS A WORD THAT IS SET TO ZERO BEFORE EACH REPRIEVE 
*         SUBROUTINE IS CALLED. THE SUBROUTINE CAN LEAVE IT ZERO OR 
*         OR SET IT NON-ZERO. WHEN RECOVR HAS CALLED ALL THE REPRIEVE 
*         SUBROUTINES LISTED WITH THE RIGHT FLAG IN THE REPRIEVE STACK, 
*         AND NONE OF THEM CALLED FOR A RESUME, THEN IF NONE OF THEM
*         SET ABT$FLAG NON-ZERO, RECOVR TERMINATES BY DOING AN
*         RPV-RESET REQUEST. BUT IF ANY ONE OR MORE OF THEM SET 
*         ABT$FLAG NON-ZERO, RECOVR TERMINATES WITH AN ENDRUN REQUEST.
* 
*         REPRVD = 1. IT WILL BE RESET TO 0 IF AN RPV-RESUME CALL IS
*         DONE. WE SET IT NON-ZERO AT SYSEP SO THAT IF SYSEP LEADS TO 
*         CALLING A USER REPRIEVE ROUTINE, WHICH WE ASSUME TO BE THE
*         CASE HERE, AND THAT USER ROUTINE MISGUIDEDLY CALLS RECOVR OR
*         SETUP., WE SHALL IMMEDIATELY KNOW BY REPRVD NOT BEING 0 THAT
*         THE CALL TO RECOVR OR SETUP. SHOULD NOT BE ALLOWED TO DO
*         ANYTHING. AN RPV-RESUME CALL IS SUPPOSED TO RESTORE NORMAL
*         OPERATION, SO WE ZERO REPRVD JUST BEFORE MAKING IT. NATURALLY,
*         REPRVD INITIALLY CONTAINS 0.
* 
***   ENTRY CONDITIONS -- WHEN MONITOR CALLS RECOVR AT SYSEP
* 
*         THE NUMBER OF ENTRIES IN THE REPRIEVE STACK IS GIVEN BY 
*         VARIABLE RCVSTKL. 
* 
*         THE FIRST TWO-WORD ENTRY IN THE STACK BEGINS AT RCVSTKL+1.
* 
*         THE FORMAT OF A REPRIEVE STACK ENTRY IS GIVEN AS THE
*         DEFINITION OF ARRAY USER$STACK IN THE SUPPRESSED SYMPL CODE.
* 
*         THE EXCHANGE PACKAGE AND OTHER INFORMATION ABOUT THE
*         MOMENT WHEN REPRIEVE TOOK PLACE BEGIN AT RPV$XX. THE
*         FORMAT IS GIVEN AS THE DEFINITION OF ARRAY RPV$BLOCK IN 
*         THE SUPPRESSED SYMPL CODE, AND ALSO ON PAGE 2-10-7 OF THE 
*         *NOS* MANUAL. THE LAST 10 WORDS OF THE ARRAY, BEGINNING 
*         AT RPV$RA1B, ARE NOT SHOWN ON PAGE 2-10-7. THEY ARE THE 
*         AREA WHERE RECOVR COPIES THE 9 WORDS PRECEDING THE
*         EXCHANGE PACKAGE, JUST BEFORE CALLING A USER REPRIEVE 
*         ROUTINE, SO THAT THE USER ROUTINE CAN ACCESS THEM 
*         WITHOUT DOING NEGATIVE INDEXING.
* 
*         BITS 12-35 OF THE 4TH WORD ( RPV$ERRCLASS ) ARE THE MASK
*         SET BY MONITOR WHEN IT REPRIEVED THE JOB. ONE BIT 
*         OF THIS FIELD WILL BE 1 WHEN RECOVR IS CALLED AT SYSEP, 
*         SHOWING WHAT KIND OF THING CAUSED THE REPRIEVE, AND 
*         THE SYSEP CODE MATCHES THE FIELD WITH THE MASKS IN THE
*         REPRIEVE STACK ENTRIES. 
* 
*         BITS 36-59 OF THE SAME WORD ( RPV$MASK ) ARE NOT
*         ENTRY INFORMATION TO SYSEP, BUT OLD INFORMATION WHICH 
*         RECOVR PASSED TO MONITOR THE LAST TIME IT DID AN RPV
*         CALL. (THE BIT THAT IS 1 IN RPV$ERRCLASS MUST 
*         CORRESPOND TO A 1-BIT IN RPV$MASK, OTHERWISE MONITOR
*         WOULD NOT HAVE REPRIEVED THE JOB FOR THAT REASON.)
* 
*         BITS 0-11 OF THE SAME WORD ( RPV$ERRCODE ) ARE ALSO 
*         SET BY MONITOR TO INDICATE WHAT HAPPENED. 
*         FOR ERROR CODES AND THE CORRESPONDING ERROR CLASSES,
*         SEE PAGE 2-10-9 OF THE *NOS* MANUAL.
* 
***    EXIT CONDITIONS -- FROM RECOVR OR SETUP. 
* 
*         NO INFORMATION IS FORMALLY RETURNED TO THE CALLER.
* 
***    EXIT CONDITIONS -- FROM SYSEP
* 
*         WE DONT REALLY EXIT FROM SYSEP, BUT TERMINATE IT WITH 
*         AN RPV-RESET CALL, OR AN RPV-RESUME CALL, OR AN ENDRUN
*         CALL, AS EXPLAINED ABOVE. 
* 
***    EXIT CONDITIONS -- FROM A USER REPRIEVE ROUTINE
* 
*         THE ONLY INFORMATION THAT IS FORMALLY HANDED BACK IS IN 
*         WORD RPV$XX+26 AND IN ABT$FLAG. 
* 
*         IF RPV$XX+26 CONTAINS 4, WE ARE TO DO AN IMMEDIATE
*         RPV$RESUME, AND THE CONTENT OF ABT$FLAG DOES NOT MATTER.
* 
*         OTHERWISE, IF ABT$FLAG IS NON-ZERO, WE ARE TO DO AN 
*         ENDRUN RATHER THAN AN RPV-RESET, WHEN WE GET TO THE END 
*         OF THE REPRIEVE STACK.
* 
*         OTHERWISE, THE USER REPRIEVE JUST FINISHED DID NOT ASK
*         FOR ENDRUN, AND IF NONE OF THE OTHERS ASKS FOR IT EITHER, 
*         WE WILL DO AN RPV-RESET WHEN WE GET TO THE END OF 
*         THE REPRIEVE STACK. 
* 
***      ERROR MESSAGES 
* 
*         RECOVR - TOO MANY RECOVR REQUESTS 
* 
*                RECOVR (OR SETUP.) HAS BEEN CALLED TO ADD ANOTHER
*                ENTRY TO THE REPRIEVE STACK, BUT THERE ARE ALREADY 
*                TEN ENTRIES. NOTHING IS DONE.
* 
*         RECOVR - BAD CHECKSUM 
* 
*                WE ARE ABOUT TO CALL A USER REPRIEVE ROUTINE, BUT
*                THE ASSOCIATED CHECKSUM DOES NOT CHECK. WE SKIP
*                THAT USER ROUTINE AND CONTINUE SCANNING THE REPRIEVE 
*                STACK. 
* 
          EJECT 
***   LOCAL VARIABLES AND ARRAYS FOR RECOVR/SETUP.
* 
*         RCVSTKL IS A COUNTER, FOLLOWED BY SPACE FOR 10 2-WORD 
*         REPRIEVE STACK ENTRIES. IT CORRESPONDS TO ITEM RCVSTKL
*         AND ARRAY USER$STACK IN THE SUPPRESSED SYMPL CODE.
* 
*         ABT$REQ, END$REQ, AND RPV$REQ ARE MONITOR REQUESTS. 
* 
*         RPV$XX AND THE 34 WORDS THAT FOLLOW IT CORRESPOND TO ARRAY
*         RPV$BLOCK IN THE SUPPRESSED SYMPL CODE. 
* 
*         EINGANG,MASK,LWA,FWA AND LWA2 ARE IN EFFECT THE INCOMING
*         PARAMETERS FOR RECOVR OR SETUP. 
* 
*         REPRVD IS A FLAG THAT WE TRY TO KEEP 0 AS LONG AS A USER
*         REPRIEVE ROUTINE IS NOT BEING EXECUTED, AND 1 WHEN ONE IS.
* 
*         ABT$FLAG IS THE RETURN PARAMETER THAT A USER REPRIEVE ROUTINE 
*         MAY SET NON-ZERO IN ORDER TO ASK THAT THE REPRIEVE PROCESS
*         TERMINATE WITH AN ENDRUN REQUEST RATHER THAN AN 
*         RPV-RESET REQUEST. AFTER EACH USER REPRIEVE ROUTINE RETURNS,
*         WE OR ABT$FLAG INTO ABT$SUM, AND AT THE END OF ALL THOSE
*         ROUTINES, WE CHECK ABT$SUM TO SEE WHETHER TO ENDRUN OR NOT. 
* 
*         I,J,K AND TEMP ARE SCRATCH VARIABLES. 
* 
RCVSTKL   BSSZ   21 
* 
ABT$REQ   VFD    18/3RABT,2/1,40/0
END$REQ   VFD    18/3REND,2/1,40/0
RPV$REQ   VFD    18/3RRPV,2/1,22/1,18/RPV$XX
* 
RPV$XX    VFD    36/0,12/25,12/1
RPV$TRA   DATA   0
RPV$CKS   DATA   0
RPV$MASK  DATA   0
          BSSZ   31 
* 
EINGANG   DATA   0
MASK      DATA   0
LWA       DATA   0
FWA       DATA   0
LWA2      DATA   0
REPRVD    DATA   0
ABT$FLAG  DATA   0
ABT$SUM   DATA   0
I         DATA   0
J         DATA   0
K         DATA   0
TEMP      DATA   0
* 
*     PROC RECOVR (EINGANG, MASK, LWA, FWA, LWA2);
*     BEGIN 
*#                                  # 
*#MISC DEF-S ETC.                   # 
*#                                  # 
*     STATUS FUNC$ NULL, SET, RESUME, RESET;
*     DEF MAX$STACK # 10 #;          # MAX SIZE OF RPV STACK   #
*     ITEM RCVSTKL = 0 ;
*     ARRAY USER$STACK [ 1 : MAX$STACK ] S(2) ; 
*       BEGIN 
*       ITEM USER$ENTRY     I(0,6,18);
*       ITEM USER$FWA       I(0,24,18); 
*       ITEM USER$LWA       I(0,42,18); 
*       ITEM USER$MASK      U(1,0,24);
*       ITEM USER$CKSUM     U(1,30,30); 
*       ITEM USER$W0          U(0,0,60);
*       ITEM USER$W1          U(1,0,60);
*       END 
*#                                  # 
*#A R R A Y S                       # 
*#                                  # 
*     ARRAY ABT$REQ [0:0] S(1); 
*       BEGIN 
*       ITEM ABT$NAME     C (0, 0, 3) = ["ABT"];
*       ITEM ABT$RECALL   B (0, 19, 1) = [TRUE];
*       END 
*     ARRAY END$REQ [0:0] S(1); 
*       BEGIN 
*       ITEM END$NAME     C (0, 0, 3) = ["END"];
*       ITEM END$RECALL   B (0, 19, 1) = [TRUE];
*       END 
*     ARRAY RPV$REQ [0:0] S(1); 
*       BEGIN 
*       ITEM RPV$NAME     C (0,  0,  3) = ["RPV"];
*       ITEM RPV$RECALL   B (0, 19,  1) = [TRUE]; 
*       ITEM RPV$EXT      B (0, 41,  1) = [TRUE]; 
*       ITEM RPV$ADDR     U (0, 42, 18);
*       END 
*     ARRAY RPV$BLOCK [0:0] S(35);
*       BEGIN 
*       ITEM RPV$XX       U (0,  0, 36) = [0];
*       ITEM RPV$LENGTH   U (0, 36, 12) = [25]; 
*       ITEM RPV$FUNC$     S:FUNC$ (0, 50,  9); 
*       ITEM RPV$COMPLETE B (0, 59,  1);
*       ITEM RPV$CHECKLWA U (1,  0, 30);
*       ITEM RPV$TRANSFER U (1, 30, 30);
*       ITEM RPV$CHECKSUM U (2,  0, 60);
*       ITEM RPV$MASK     U (3,  0, 24) = [0] ; 
*       ITEM RPV$ERRCLASS U (3, 24, 24);
*       ITEM RPV$ERRCODE  U (3, 48, 12);
*       ITEM RPV$PENDING  U (4,  0, 60);
*       ITEM RPV$RA1      U (5,  0, 60);
*       ITEM RPV$TERMIO   U (6,  0, 60);
*       ITEM RPV$ERRFLAG  U (7, 48, 12);
*       ITEM RPV$XPACK    U (9,  0, 60);
*       ITEM RPV$B0       U (9, 42, 18);
*       ITEM RPV$RA1B   U(25,0,60) ;
*       ITEM RPV$XXB    U(26,0,60) ;
*       END 
* 
*     DEF RPV$NINE #9# ;
* 
*     BASED ARRAY DUMMY [0:0] S(1); 
*       BEGIN 
*       ITEM DUMMY$ITEM   U (0, 0, 60); 
*       END 
*     XREF ARRAY RA$0 [0:0] S(1); 
*       BEGIN 
*       ITEM RA0$ITEM     U (0, 0, 60); 
*       END 
*#                                  # 
*#I T E M S                         # 
*#                                  # 
*     ITEM EINGANG; 
*     ITEM MASK U;
*     ITEM LWA, FWA, LWA2 U;
*     ITEM REPRIEVED B = FALSE; 
*     ITEM ABT$FLAG, ABT$SUM U; 
*     ITEM I, J, K  I;
*     ITEM TEMP I;
*#                                  # 
*#X R E F S                         # 
*#                                  # 
*     XREF PROC SYS$EQ; 
*     XREF PROC REMARK; 
*     XREF PROC RJ$;
*     XREF ITEM RA$1 I; 
          EJECT 
***      SUBROUTINE CHECKSUM
* 
*         ENTRY CONDITIONS
* 
*         X1 CONTAINS AN INTEGER THAT SHOULD BE BETWEEN 1 AND THE 
*         NUMBER OF ENTRIES IN THE REPRIEVE STACK. IT IS THE
*         ORDINAL OF AN ENTRY IN THAT STACK, COUNTING FROM 1 NOT 0
* 
*         EXIT CONDITIONS 
* 
*         X6 CONTAINS 0 IN BITS 30-59, AND THE WANTED CHECKSUM IN 
*         BITS 0-29. THE CHECKSUM IS FORMED AS FOLLOWS -- 
*         1. FOLLOW THE ORDINAL THAT WAS IN X1 ON ENTRY TO THE
*         STACK ENTRY IT INDICATES. GET THE FWA AND LWA OF THE
*         SUBROUTINE FROM THAT ENTRY. 
*         2. IF THE FWA > THE LWA, EXIT WITH 0 AS CHECKSUM. 
*         3. OTHERWISE, GET THE INTEGER SUM OF THE WORDS FROM 
*         FWA TO LWA INCLUSIVE. 
*         4. TREAT THE LEFT AND RIGHT HALVES OF THE SUM AS 30-BIT 
*         INTEGERS, ADD THEM, AND TAKE THE RIGHT 30 BITS OF THEIR 
*         SUM AS THE WANTED CHECKSUM. 
* 
*         ERROR CONDITIONS
* 
*         NONE - NO CHECKING IS DONE. 
* 
*     FUNC CHECKSUM  ( I ) U; 
*#                                  # 
*#C H E C K S U M                   # 
*#                                  # 
*     BEGIN                         # COMPUTE CHECKSUM OF USER-S AREA # 
*     ITEM I, J I;
*     TEMP = 0; 
*     FOR J = USER$FWA [I] STEP 1 UNTIL USER$LWA [I] DO 
*       BEGIN 
*       TEMP = TEMP + RA0$ITEM [J]; 
*       END 
*     TEMP = B<0,30>TEMP + B<30,30>TEMP;
*     CHECKSUM = B<30,30>TEMP;
*     END # C H E C K S U M # 
* 
CHECKSUM  DATA   0
          LX1    1
          SA1    RCVSTKL-1+X1 
          SB2    X1 
          AX1    18 
          SB3    X1 
          SX6    B0 
          GT     B3,B2,CHECKSUM 
CKSB      SA1    B3 
          IX6    X6+X1
          SB3    B3+1 
          LE     B3,B2,CKSB 
          MX0    30 
          BX1    -X0*X6 
          BX6    X0*X6
          LX6    30 
          IX6    X6+X1
          BX6    -X0*X6 
          EQ     CHECKSUM 
          EJECT 
* 
*#                                  # 
*#R E C O V R                       # 
*#                                  # 
* 
RECOVR    DATA   0
          MI     X1,RERPV    IF RECOVR ASKED TO RESTORE *RPV* 
          BX6    X1 
          SA6    EINGANG
          SA1    A1+1 
          SA2    X1 
 NOS.BE   IFC       NE,/"OS.NAME"/KRONOS/ 
          SX3       10B 
          BX3       X3*X2 
          LX3       4 
          BX6       X2+X3 
 NOS.BE   ELSE
          BX6    X2 
 NOS.BE   ENDIF 
          SA6    MASK 
          SA1    A1+1 
          SA2    X1 
          BX6    X2 
          SA6    LWA
          SX6    A1+1 
          SA6    FWA
* 
*     IF REPRIEVED THEN 
*       BEGIN 
*       RETURN ;
*       END 
*     J = 0 ; 
*     FOR I = 1 STEP 1 UNTIL RCVSTKL DO 
*       BEGIN 
*       IF USER$ENTRY[I] EQ LOC(EINGANG) THEN 
*         BEGIN 
*         J = I ; 
*         END 
*       END 
* 
          SA1    REPRVD 
          NZ     X1,RECOVR
          SX6    B0 
          SA6    J
          SA2    EINGANG
          SA1    RCVSTKL
          SB2    X1 
          ZR     B2,RCVN
          SB3    1
RCVA      SA1    A1+1 
          LX1    24 
          SX1    X1 
          IX1    X1-X2
          NZ     X1,RCVB
          SX6    B3 
          SA6    J
RCVB      SA1    A1+1 
          SB3    B3+1 
          LE     B3,B2,RCVA 
* 
*     IF J NQ 0 THEN
*       BEGIN 
*       IF MASK EQ 0 THEN 
*         BEGIN 
*         FOR I = J+1 STEP 1 UNTIL RCVSTKL DO 
*           BEGIN 
*           USER$W0[I-1] = USER$W0[I] ; 
*           USER$W1[I-1] = USER$W1[I] ; 
*           END 
*         RCVSTKL = RCVSTKL - 1 ; 
*         GOTO CHECK$RPV ;
*         END 
*       ELSE
*         BEGIN 
*         GOTO NEWMASK ;
*         END 
*       END 
* 
          SA1    J
          ZR     X1,RCVN
          SA2    MASK 
          NZ     X2,NEWMASK 
          LX1    1
          SB3    X1 
          SB2    B2+B2
          GE     B3,B2,RCVE 
RCVF      SA1    RCVSTKL+1+B3 
          BX6    X1 
          SA6    A1-2 
          SB3    B3+1 
          LT     B3,B2,RCVF 
RCVE      SA1    RCVSTKL
          SX6    X1-1 
          SA6    A1 
          EQ     CKRPV
* 
*     ELSE
*       BEGIN 
*       IF MASK EQ 0 THEN 
*         BEGIN 
*         RETURN ;
*         END 
*       ELSE
*         BEGIN 
*         IF RCVSTKL EQ MAX$STACK THEN
*           BEGIN 
*           REMARK ( "RECOVR - TOO MANY RECOVR REQUESTS&" ) ; 
*           SYS$EQ ( ABT$REQ ) ;
*           END 
*         ELSE
*           BEGIN 
*           RCVSTKL = RCVSTKL + 1 ; 
*           J = RCVSTKL ; 
*           USER$ENTRY[J] = LOC ( EINGANG ) ; 
* 
RCVN      SA1    MASK 
          ZR     X1,RECOVR
          SA1    RCVSTKL
          SX6    X1-10
          NG     X6,RCVP
          SX6    MSG1 
          RJ     MSG
          SA1    ABT$REQ
          BX6    X1 
          RJ     SYS$EQ 
* 
MSG1      DIS    0,*RECOVR - TOO MANY RECOVR REQUESTS*
* 
MSG       DATA   0
          LX6    30 
          SA6    MSGA 
          SA1    MSG$REQ
          BX6    X1 
          RJ     SYS$EQ 
          EQ     MSG
* 
MSG$REQ   VFD    18/3RMSG,2/1,22/0,18/MSGA
MSGA      DATA   0
* 
RCVP      SX6    X1+1 
          SA6    A1 
          SA6    J
          LX6    1
          SA1    EINGANG
          LX1    36 
          BX7    X1 
          SA7    RCVSTKL-1+X6 
* 
* NEWMASK:  
*           USER$MASK[J] = MASK ; 
*           IF LWA EQ 0 THEN
*             BEGIN 
*             USER$FWA[J] = 0 ; 
*             USER$LWA[J] = 0 ; 
*             END 
*           ELSE
*             BEGIN 
*             IF LWA GR 0 THEN
*               BEGIN 
*               USER$FWA[J] = LOC ( EINGANG ) + 1 ; 
*               USER$LWA[J] = LWA ; 
*               END 
*             ELSE
*               BEGIN 
*               USER$FWA[J] = FWA ; 
*               USER$LWA[J] = LWA2 ;
*               END 
*             END 
*           END 
*         END 
*       END 
* 
NEWMASK   SA1    J
          SA2    MASK 
          MX0    36 
          BX6    -X0*X2 
          LX6    36 
          LX1    1
          SA6    RCVSTKL+X1 
          SA1    A6-1 
          MX0    18 
          LX0    54 
          BX6    X0*X1
          SA3    LWA
          ZR     X3,NEWC
          NG     X3,NEWA
          SA2    EINGANG
          SX2    X2+1 
          EQ     NEWB 
* 
NEWA      SA2    FWA
          SA2    X2 
          SA3    A2+1 
          SA2    X2 
          SA3    X3 
* 
NEWB      SX2    X2 
          SX3    X3 
          LX2    18 
          BX6    X6+X2
          BX6    X6+X3
NEWC      SA6    A1 
* 
*     IF USER$LWA[J] NQ 0 THEN
*       BEGIN 
*       USER$CKSUM[J] = CHECKSUM ( J ) ;
*       END 
* 
          SA1    J
          LX1    1
          SA2    RCVSTKL-1+X1 
          SX2    X2 
          ZR     X2,CKRPV 
          AX1    1           X1=J 
          RJ     CHECKSUM 
          SA1    J
          LX1    1
          SA2    RCVSTKL+X1 
          MX0    30 
          BX0    X0*X2
          BX6    X6+X0
          SA6    A2 
* 
*CHECK$RPV:                        # TELL RPV ABOUT NEW MASK BITS # 
*     TEMP = 0; 
*     FOR I = 1 STEP 1 UNTIL RCVSTKL DO 
*       BEGIN                       # SUM OF ALL USER MASK VALUES # 
*       TEMP = TEMP LOR USER$MASK [I];
*       END 
*     IF RPV$MASK EQ TEMP THEN RETURN;
*     FOR I = 1 STEP 1 UNTIL RPV$NINE-1 DO
*       BEGIN 
*       RA0$ITEM[LOC(RPV$XX)+I] = 0 ; 
*       END 
*     RPV$MASK = TEMP;              # NEW MASK VALUE FOR RPV #
* 
CKRPV     SX6    B0 
          SA1    RCVSTKL
          ZR     X1,CKRPVA
          MX0    24 
          SB2    X1 
CKRPVB    SA1    A1+2 
          BX1    X0*X1
          BX6    X6+X1
          SB2    B2-1 
          NZ     B2,CKRPVB
CKRPVA    SA1    RPV$MASK 
          BX3    X0*X1
          IX3    X3-X6
          ZR     X3,RECOVR
          SA6    A1 
          SX6    B0 
          SB2    5
CKRPVC    SA6    A6+1 
          SB2    B2-1 
          NZ     B2,CKRPVC
* 
*     RPV$FUNC$ = S"SET" ;
*     RPV$COMPLETE = FALSE; 
*     RPV$TRANSFER = LOC (SYSEP); 
*     RPV$CHECKLWA = LOC (END$SYSEP); 
*     RPV$ADDR = LOC (RPV$BLOCK); 
*     SYS$EQ (RPV$REQ); 
*     RETURN; 
* 
          SX6    SYSEP
          SX7    ENDSYSEP 
          LX7    30 
          BX6    X6+X7
          SA6    RPV$TRA
          SX3    2
          EQ     SYSEPG 
  
 RERPV    SA1    RPV$MASK 
          BX6    X1 
          SA6    A1 
          BX6    X6-X6
          SB2    5
          EQ     CKRPVC      REISSUE THE *RPV* CALL 
* 
*     CONTROL EJECT;
*#                                  # 
*#X X X X X X  - SYSTEM ENTRY POINT # 
*#                                  # 
*SYSEP:                             # START OF RECOVERY CODE  # 
*     REPRIEVED = TRUE ;
*     ABT$SUM = 0 ; 
* 
SYSEP     SX6    1
          SA6    REPRVD 
          SX6    B0 
          SA6    ABT$SUM
* 
*     FOR I = RCVSTKL STEP -1 UNTIL 1 DO
*       BEGIN                       # LOOP FOR ALL WHO CALLED RPV # 
* 
          SA1    RCVSTKL
          BX6    X1 
          SA6    I
SYSEPA    SA1    I
          ZR     X1,SYSEPQ
          LX1    1
* 
*       IF USER$MASK [I] LAN RPV$ERRCLASS EQ 0 THEN TEST I; 
* 
          SA2    RCVSTKL+X1 
          SA3    RPV$MASK 
          LX3    24 
          BX4    X2*X3
          MX0    24 
          BX4    X0*X4
          ZR     X4,SYSEPB
*                                   # DID USER SELECT THIS ERROR #
*       IF USER$LWA [I] NQ 0 THEN   # RECOMPUTE CHECKSUM #
*         BEGIN 
*         IF CHECKSUM ( I ) NQ USER$CKSUM [I] THEN
*           BEGIN                   # CHECKSUM ERROR #
*           REMARK ( "RECOVR - BAD CHECKSUM&" ) ; 
*           TEST I;                 # LOOP FOR OTHER USERS #
*           END 
*         END 
* 
          SA4    A2-1 
          SX4    X4          USER$LWA 
          ZR     X4,SYSEPC
          AX1    1           X1=I 
          RJ     CHECKSUM 
          SA1    I
          LX1    1
          SA2    RCVSTKL+X1 
          MX0    30 
          BX2    -X0*X2      USER$CKSUM[I]
          IX6    X2-X6
          ZR     X6,SYSEPC
          SX6    MS2
          RJ     MSG
          EQ     SYSEPB 
* 
MS2       DIS    0,*RECOVR - BAD CHECKSUM*
* 
*       RPV$RA1B[0] = RPV$RA1[0] ; #FOR OLD-STYLE REPRIEVE# 
*       RPV$XXB = 0 ; 
*       FOR J = 1 STEP 1 UNTIL RPV$NINE-1 DO
*         BEGIN 
*         RA0$ITEM[LOC(RPV$XXB)+J] = RA0$ITEM[LOC(RPV$XX)+J] ;
*         END 
*       RPV$B0 = RPV$ERRCODE; 
*       ABT$FLAG = 0 ;
*       P<DUMMY> = LOC (RPV$XPACK); 
*       RJ$ (USER$ENTRY [I], DUMMY, ABT$FLAG, RA$1);
* 
SYSEPC    SA1    RPV$XX+5 
          BX6    X1 
          SA6    RPV$XX+25
          SX6    B0 
          SA6    A6+1 
          SA1    RPV$XX+1 
          SB2    8
SYSEPD    BX6    X1 
          SA6    A1+26
          SA1    A1+1 
          SB2    B2-1 
          NZ     B2,SYSEPD
          SA1    RPV$XX+3 
          MX0    48 
          BX6    -X0*X1 
          SA1    RPV$XX+9 
          MX0    42 
          BX7    X0*X1
          BX7    X7+X6
          SA7    A1 
          SX6    B0 
          SA6    ABT$FLAG 
          SA1    I
          LX1    1
          SA1    RCVSTKL-1+X1 
          AX1    36 
          SX1    X1 
          MX6    1
          LX6    55 
          LX1    30 
          BX6    X6+X1
          SA6    SYSEPE 
          RJ     SYSEPX 
* 
PARAM     VFD    42/0,18/RPV$XX+9 
          VFD    42/0,18/ABT$FLAG 
          DATA   1
          DATA   0
* 
SYSEPX    DATA   0
          SA1    PARAM
          SB1    X1 
          SB2    ABT$FLAG 
          SB3    1
SYSEPE    RJ     *+400000B
* 
*       ABT$SUM = ABT$SUM LOR ABT$FLAG ;
* 
          SA1    ABT$SUM
          SA2    ABT$FLAG 
          BX6    X1+X2
          SA6    A1 
* 
*       IF RPV$XXB[0] EQ 4 THEN 
*         BEGIN 
* 
          SA1    RPV$XX+26
          SX1    X1-4 
          NZ     X1,SYSEPB
* 
*         FOR J = 1 STEP 1 UNTIL RPV$NINE-1 DO
*           BEGIN 
*           RA0$ITEM[LOC(RPV$XX)+J] = RA0$ITEM[LOC(RPV$XXB)+J] ;
*           END 
*         REPRIEVED = FALSE ; 
*         RPV$ADDR[0] = LOC(RPV$BLOCK) ;
*         RPV$COMPLETE[0] = FALSE ; 
*         RPV$FUNC$[0] = S"RESUME" ;
*         SYS$EQ ( RPV$REQ ) ;
* 
          SA1    RPV$XX+27
          SB2    8
SYSEPF    BX6    X1 
          SA6    A1-26
          SA1    A1+1 
          SB2    B2-1 
          NZ     B2,SYSEPF
          SX6    B0 
          SA6    REPRVD 
          SX3    4
SYSEPG    SA1    RPV$XX 
          MX0    48 
          BX6    X0*X1
          BX6    X3+X6
          SA6    A1 
          SA1    RPV$REQ
 PLOP     BX6    X1 
          RJ     SYS$EQ 
          EQ     RECOVR 
* 
*         END 
*       END 
* 
SYSEPB    SA1    I
          SX6    X1-1 
          SA6    A1 
          EQ     SYSEPA 
* 
*     IF ABT$SUM EQ 0 THEN
*       BEGIN                     # RESET - RETURN TO USER #
*       REPRIEVED = FALSE ; 
*       RPV$FUNC$ = S"RESET"; 
*       RPV$COMPLETE = FALSE; 
*       RPV$ADDR[0] = LOC(RPV$BLOCK) ;
*       SYS$EQ (RPV$REQ); 
*       END 
*     ELSE
*       BEGIN                       # JUST A SIMPLE -END- # 
*       SYS$EQ (END$REQ); 
*       END 
* 
SYSEPQ    SA1    ABT$SUM
          NZ     X1,SYSEPR
          SX6    B0 
          SA6    REPRVD 
          SX3    6
          EQ     SYSEPG 
* 
SYSEPR    SA1    END$REQ
          EQ     PLOP 
* 
*END$SYSEP:                         # END OF RECOVERY CODE #
* 
ENDSYSEP  DATA   0
* 
*     END # R E C O V R # 
*     TERM
* 
SETUP.0   SA1    APLIST 
          RJ     =XRECOVR 
          SB1    1
          SPACE  2
SETUP.    EQ     *+400000B         ENTRY / EXIT 
          BX6    X4                 MASK VALUE
          SA6    P2 
          SX7    B1                 RECOVERY ADDRESS
          SA7    APLIST 
          SX6    B3                 LWA OF CHECKSUM AREA
          SA6    P3 
          SX6    B4 
          SA6    P4 
          SX6    B5 
          SA6    P5 
          EQ     SETUP.0
          SPACE  2
          SPACE  3
 APLIST   VFD    42/0,18/0
          VFD    42/0,18/P2 
          VFD    42/0,18/P3 
          VFD    42/0,18/P4 
* 
*         THE FOLLOWING CODE IS VERY POSITION DEPENDANT 
*         DO NOT ADD LINES WITHOUT THOROUGHLY ANALYZING ROUTINE 
+         EQ     XJW               TEMP STORAGE FOR PLUG CODE 
 XJW      XJ
SYS$EQ    DATA   0
+         SA1    1
          NZ     X1,* 
+         SA6    1
          SA1    XJW-1
+         BX6    X1                ONE TIME CODE
          SA6    *                 COVER TRACKS 
+         SA1    RA.CEJ            PICK UP XJ FLAG
          NG     X1,XJW            IF SET 
          SA1    SYS$EQ+1          ELSE REPLACE XJ
          BX6    X1                WITH LOOP
          SA6    XJW
          RJ     XJW-1             CLEAR STACK
  
P2        DATA   0                  MASK
P3        DATA   0                  LWA OF CHECKSUM AREA
P4        DATA   0                 MAY BE FWA OF CHECKSUM AREA
P5        DATA   0                 MAY BE LWA OF CHECKSUM AREA
  
          END 
