*DECK,DADRARE                                                              DADRARE
*CALL COMUSETXT 
     PROC RARE$DA ;                                                      DADRARE
      BEGIN                                                              RPN0628
                                                                         DADRARE
                                                                         DADRARE
     XREF BEGIN                                                          DADRARE
          PROC STMD$AA ;                                                 DADRARE
          PROC UNFX$AA ;                                                 DADRARE
          PROC NUBL$AA ;                                                 DADRARE
          PROC DELL$AA ;                                                 DADRARE
          PROC LOCR$AA ;                                                 DADRARE
          PROC TROW$AA ;                                                 DADRARE
          PROC LOCB$AA ;                                                 DADRARE
          PROC FIXX$AA ;                                                 DADRARE
          PROC SEBL$AA ;                                                 DADRARE
          PROC ALTR$AA ;                                                 DADRARE
          PROC XMET$DA ;                                                 DADRARE
          FUNC ZING$DA ;                                                 DADRARE
          PROC CONS$AA ;                                                 DADRARE
          PROC IOWR$AA ;                                                 DADRARE
          PROC ADRC$AA ;                                                 DADRARE
          PROC BNCH$AA ;                                                 DADRARE
          PROC LKEY$AA ;                                                 DADRARE
          PROC EXRP$AA ;                                                 AFB0801
          PROC METB$DA ;                                                 AFB0801
          END                                                            DADRARE
                                                                         DADRARE
     XDEF BEGIN                                                          DADRARE
          PROC ADNU$DA ;                                                 DADRARE
          END                                                            DADRARE
                                                                         DADRARE
CONTROL EJECT ;                                                          AFB0912
 #                                                                       AFB0912
* *   ADNU$DA - FIND A NEW OVERFLOW BLOCK               PAGE 1           AFB0912
* *   A.F.R.BROWN                                                        AFB0912
* 1DC ADNU$DA                                                            AFB0912
*                                                                        AFB0912
* DC  FUNCTION                                                           AFB0912
*                                                                        AFB0912
*     TO FIND A BLOCK WITH SPACE FOR A NEW RECORD, POSSIBLY AFTER        AFB0912
*     A LITTLE REARRANGEMENT. THIS IS CALLED WHEN NO BLOCK IN THE        AFB0912
*     EXISTING CHAIN THAT BEGINS AT THE PROPER HOME BLOCK HAS SPACE.     AFB0912
*     (1) SEARCH ALL THE BLOCKS IN CORE (BELONGING TO THIS FILE) TO      AFB0912
*     SEE IF THERE IS A TERMINAL BLOCK WITH ENOUGH FREE SPACE.           AFB0912
*     ((ENOUGH)) MEANS (A) IF THE OVERFLOW IS FROM A HOME BLOCK, FROM    AFB0912
*     WHICH NOTHING HAS YET BEEN CHAINED, ENOUGH FOR THE NEW RECORD      AFB0912
*     (B)OTHERWISE, ENOUGH TO HOLD THE NEW RECORD PLUS ANY OTHER         AFB0912
*     RECORDS THAT MAY BE IN THE EXISTING TERMINAL BLOCK AND HAVE KEYS   AFB0912
*     THAT HASH TO THE SAME HOME BLOCK AS THE NEW RECORD. FOR ANY ONE    AFB0912
*     HOME BLOCK, THERE CAN BE ONLY ONE TERMINAL BLOCK CONTAINING ITS    AFB0912
*     OVERFLOW ORPHANS. HENCE IF THE NEW RECORD GOES INTO A DIFFERENT    AFB0912
*     TERMINAL BLOCK, ITS BROTHERS WILL HAVE TO MOVE FROM THE OLD        AFB0912
*     TERMINAL BLOCK TO THE DIFFERENT ONE, AS WELL.                      AFB0912
*     (2) IF NO SUCH TERMINAL BLOCK FOUND IN CORE, LOOK AT THE MOST-     AFB0912
*     EMPTY TABLE.                                                       AFB0912
*     (3) IF THAT FAILS, CALL NUBL$AA FOR A NEW BLOCK, WHICH WILL COME   AFB0912
*     FROM THE EMPTY CHAIN IF ANY OR ELSE WILL BE CREATED BY EXTENDING   AFB0912
*     THE FILE.                                                          AFB0912
*     (4) IF THE OVERFLOW IS FROM A HOME BLOCK, OVERFLOWING FOR THE      AFB0912
*     FIRST TIME, JUST MAKE THE HOME BLOCK POINT TO THE ((NEW))          AFB0912
*     BLOCK. WE DO NOT ACTUALLY PUT THE NEW RECORD INTO THE NEW BLOCK,   AFB0912
*     BUT LEAVE THAT TO BE DONE IN THE ROUTINE THAT CALLED ADNU$DA.      AFB0912
*     (5) IF THE OVERFLOW IS FROM A TERMINAL BLOCK THAT CONTAINS ONLY    AFB0912
*     RECORDS HASHING TO THE SAME HOME BLOCK AS THE NEW RECORD, MAKE     AFB0912
*     THAT TERMINAL BLOCK POINT TO THE NEW BLOCK. THIS CONVERTS THE      AFB0912
*     OLD TERMINAL BLOCK INTO A MEMBER BLOCK, WHICH IS POSSIBLE BECAUSE  AFB0912
*     ALL ITS RECORDS BELONG TO THE SAME SPECIES.                        AFB0912
*     (6) OTHERWISE, MOVE AS MANY AS POSSIBLE OF THE COUSINS OF THE NEW  AFB0912
*     RECORD OUT OF THE OLD TERMINAL BLOCK AND INTO THE NEW ONE, STILL   AFB0912
*     LEAVING SPACE IN THE NEW BLOCK FOR THE NEW RECORD TO BE ADDED      AFB0912
*     LATER. IN THE BLOCK THAT PRECEDED THE OLD TERMINAL BLOCK IN THE    AFB0912
*     OVERFLOW CHAIN (IT MAY BE THE HOME BLOCK OR A MEMBER BLOCK),       AFB0912
*     CHANGE THE FORWARD POINTER TO POINT TO THE NEW BLOCK. NOW, IF ALL  AFB0912
*     THE COUSINS COULD BE MOVED INTO THE NEW BLOCK, LEAVE THE NEW       AFB0912
*     BLOCK WITH 0 FORWARD POINTER, I.E. A TERMINAL BLOCK.               AFB0912
*     BUT IF NOT ALL THE COUSINS COULD BE MOVED -- THIS CAN HAPPEN IF    AFB0912
*     WE HAVE TO CALL NUBL$AA FOR A REALLY NEW BLOCK, BUT ONE BLOCK IS   AFB0912
*     NOT ENOUGH TO HOLD THE COUSINS PLUS THE NEW RECORD -- THEN THE     AFB0912
*     NEW BLOCK HAS TO POINT FORWARD TO THE EXISTING TERMINAL BLOCK,     AFB0912
*     I.E. THE NEW BLOCK BECOMES A MEMBER BLOCK.                         AFB0912
*                                                                        AFB0912
* DC  ENTRY CONDITIONS                                                   AFB0912
*                                                                        AFB0912
*     THERE ARE THREE PARAMETERS, PASSED IN THE NORMAL SYMPL WAY --      AFB0912
*     GAMMA IS THE PRU NUMBER OF THE HOME BLOCK OF THE OVERFLOWING       AFB0912
*       CHAIN.                                                           AFB0912
*     ALPHA IS THE PRU NUMBR OF THE LAST BLOCK IN THAT CHAIN. IT         AFB0912
*       IS EITHER A TERMINAL BLOCK, OR THE SAME AS GAMMA.                AFB0912
*     ETA IS THE PRU NUMBER OF THE BLOCK PRECEDING ALPHA IN THE          AFB0912
*       CHAIN. IF ALPHA=GAMMA, ETA HAS NOT BEEN SET AND DOES NOT         AFB0912
*       MATTER.                                                          AFB0912
*                                                                        AFB0912
*     NEWLNG IS THE LENGTH OF THE NEW RECORD IN WORDS.                   AFB0912
*                                                                        AFB0912
*     P<FIT$AA> AND P<FIAT$AA> POINT TO THE CURRENT FIT AND FIAT.        AFB0912
*     P<FSTT$AA> POINTS TO THE FSTT OF THE CURRENT DA FILE.              AFB0912
*                                                                        AFB0912
* DC  EXIT CONDITIONS                                                    AFB0912
*                                                                        AFB0912
*     NEWBNUM IS THE PRU OF A BLOCK, TERMINAL OR MEMBER, THAT            AFB0912
*       HAS ROOM FOR THE NEW RECORD. ALL THE NECESSARY RECHAINING        AFB0912
*       OF BLOCKS AND MOVING OF RECORDS (EXCEPT THE NEW RECORD)          AFB0912
*       HAVE BEEN DONE.                                                  AFB0912
*                                                                        AFB0912
*     NEWFWA, NEWLNG, KEYFWA, KEYOFF HAVE BEEN PRESERVED.                AFB0912
*                                                                        AFB0912
*     IF A NEW OVERFLOW BLOCK HAS COME INTO BEING, FSOBCNT HAS           AFB0912
*       BEEN INCREASED BY 1. IF IT WAS AN EXTENSION, RATHER THAN         AFB0912
*       A BLOCK FROM THE EMPTY CHAIN, FSLSTPRU HAS ALSO BEEN             AFB0912
*       INCREASED, BY THE NUMBER OF PRUS IN A BLOCK.                     AFB0912
*                                                                        AFB0912
*     THE MOST-EMPTY TABLE HAS BEEN ADJUSTED FOR ANY CHANGES TO          AFB0912
*       BLOCKS EXCEPT THE ONE THAT THE NEW RECORD IS TO BE ADDED         AFB0912
*       TO. IF THAT BLOCK IS A TERMINAL BLOCK, METB$DA WILL BE           AFB0912
*       CALLED FOR IT AFTER THE NEW RECORD IS ADDED, IN THE PROGRAM      AFB0912
*       THAT CALLED ADNU$DA.                                             AFB0912
*                                                                        AFB0912
* DC  ERROR CONDITIONS - NONE                                            AFB0912
*                                                                        AFB0912
* DC  CALLED ROUTINES                                                    AFB0912
*                                                                        AFB0912
*     SEBL$AA - TO LOOK AT A BLOCK WHOSE PRU NUMBER IS IN THE            AFB0912
*       FIRST WORD OF THE PTREE.                                         AFB0912
*     FIXX$AA - TO FREEZE A BLOCK BY REMOVING IT FROM THE KICKOUT        AFB0912
*       CHAIN AND SAVING ITS FWA IN ARRAY FIXHOLD. WE HAVE TO DO         AFB0912
*       THIS BECAUSE ULTIMATELY WE MAY COPY RECORDS FROM ONE BLOCK       AFB0912
*       TO ANOTHER, AND TO MAKE SURE ONE BLOCK STAYS IN CORE WHILE       AFB0912
*       ANOTHER IS BEING READ IN, THE FIRST ONE MUST BE FROZEN.          AFB0912
*     UNFX$AA - TO UNFREEZE A BLOCK BY PUTTING IT BACK INTO THE          AFB0912
*       KICKOUT CHAIN AND ZEROING ITS ENTRY IN ARRAY FIXHOLD. WE         AFB0912
*       HAVE TO DO THIS BEFORE EXITING FROM ADNU$DA, TO LEAVE THINGS     AFB0912
*       AS WE FOUND THEM.                                                AFB0912
*     ZING$DA - TO FIND THE HOME BLOCK NUMBER CORRESPONDING TO THE       AFB0912
*       KEY OF A GIVEN RECORD, WHEN THE RECORD IS SPECIFIED ONLY         AFB0912
*       BY ITS NUMBER IN THE CURRENT BLOCK.                              AFB0912
*     NUBL$AA - TO GET A NEW BLOCK,WHETHER FROM THE EMPTY CHAIN          AFB0912
*       OR BY EXTENDING THE FILE. THIS AUTOMATICALLY FREEZES THE         AFB0912
*       NEW BLOCK, SO A CORRESPONDING CALL TO UNFX$AA WILL BE NEEDED     AFB0912
*       BEFORE WE LEAVE ADNU$DA.                                         AFB0912
*     LOCBLOC - TO LOCATE A BLOCK, GIVEN ITS PRU NUMBER, READING IT      AFB0912
*       IN IF NECESSARY. ALSO TO HANDLE THE ERROR EXIT IF THERE IS       AFB0912
*       AN UNCORRECTABLE I/O ERROR ON THE READ.                          AFB0912
*     LKEY$AA - TO SET CERTAIN POINTERS THAT ARE NEEDED BY               AFB0912
*       SUBROUTINES THAT LOCATE INDIVIDUAL RECORDS.                      AFB0912
*     TROW$AA - TO MAKE CURRENT, ONE OF THE BLOCKS PREVIOUSLY FROZEN     AFB0912
*       BY FIXX$AA.                                                      AFB0912
*     XMET$DA - TO REMOVE A BLOCK FROM THE MOST-EMPTY TABLE, WHEN IT     AFB0912
*       CEASES TO BE A TERMINAL BLOCK.                                   AFB0912
*     METB$DA - TO UPDATE THE MOST-EMPTY TABLE ENTRY FOR AN OLD TERMINAL AFB0912
*       AFTER MOVING SOME RECORDS OUT OF IT.                             AFB0912
*     CONS$AA - TO SQUEEZE OUT ANY DEAD RECORDS THAT MAY BE IN AN OLD    AFB0912
*       TERMINAL BLOCK, BEFORE MOVING RECORDS INTO IT.                   AFB0912
*     ALTR$AA - TO DO THE NECESSARY FORMALITIES BEFORE ALTERING A BLOCK  AFB0912
*       IMAGE IN CORE,  BECAUSE IT MAY BE THE FIRST TIME IT BECOMES      AFB0912
*       UNLIKE THE BLOCK ON DISK                                         AFB0912
*     DELL$AA - TO DELETE A RECORD FROM A BLOCK (AFTER WE HAVE COPIED IT AFB0912
*       TO A DIFFERENT BLOCK.)                                           AFB0912
*     BNCH$AA - TO SCAN A BLOCK OF ORDERED RECORDS FOR THE RECORD        AFB0912
*       MATCHING A GIVEN KEY, OR THE LOWEST HIGHER RECORD IF NO MATCH.   AFB0912
*       HERE WE USE IT TO FIND THE POINT AT WHICH A RECORD OUGHT TO BE   AFB0912
*       INSERTED. THE RECORD IS BEING MOVED FROM ONE                     AFB0912
*       BLOCK TO ANOTHER.                                                AFB0912
*     LOCR$AA - TO FIND THE FWA LWA AND LENGTH OF A RECORD, GIVEN ITS    AFB0912
*       RECORD NUMBER WITHIN THE BLOCK. BNCH$AA RETURNS JUST THE         AFB0912
*       NUMBER OF THE RECORD, NOT ITS ADDRESS.                           AFB0912
*     ADRC$AA - TO INSERT A RECORD AT THE CURRENT POSITION IN THE        AFB0912
*       CURRENT BLOCK. THIS SUBROUTINE AND DELL$AA ARE WHAT              AFB0912
*       ACTUALLY MOVE EACH RECORD FROM ONE BLOCK TO THE OTHER.           AFB0912
*     IOWR$AA - TO WRITE OUT THE ((NEW)) BLOCK, IF ANY OLD RECORDS       AFB0912
*       HAVE BEEN MOVED INTO IT FROM AN EXISTING TERMINAL  BLOCK.        AFB0912
*       THIS IS DONE FOR THE SAKE OF RELIABILITY, TO MAKE SURE THE       AFB0912
*       IMAGE OF THE BLOCK THAT HAS GAINED THE RECORDS IS WRITTEN        AFB0912
*       BEFORE THE NEW IMAGE OF THE BLOCK THAT HAS LOST THEM, SO         AFB0912
*       THAT THERE IS NO INSTANT AT WHICH THE RECORDS ARE ABSENT FROM    AFB0912
*       BOTH BLOCKS ON DISK.                                             AFB0912
*                                                                        AFB0912
* DC  NON-LOCAL VARIABLES                                                AFB0912
*                                                                        AFB0912
*     BARREN - AN INPUT TO ADRC$AA. BEING 0, IT CAUSES THE SUBFILE       AFB0912
*       FLAG OF THE NEW RECORD POINTER TO BE 0.                          AFB0912
*     TEMPLOC - SET BY LOCR$AA, CALLED BY ZING$DA, TO THE ADDRESS        AFB0912
*       OF THE WORD THAT CONTAINS THE START OF THE RECORD KEY. KEYFWA IS AFB0912
*       THEN SET = THIS, SO THAT ADRC$AA CAN USE IT                      AFB0912
*       WHEN CALLED A FEW LINES LATER.                                   AFB0912
*     TEMPOS - ALSO SET BY LOCR$AA TO THE CHARACTER POSITION OF THE      AFB0912
*       START OF THE KEY. COPIED TO KEYOFF, WHICH IS USED BY             AFB0912
*       ADRC$AA BELOW.                                                   AFB0912
*                                                                        AFB0912
 #                                                                       AFB0912
                                                                         DADRARE
     PROC ADNU$DA ( ALPHA , GAMMA , ETA ) ; BEGIN                        DADRARE
          ITEM ALPHA,GAMMA,ETA,J,DEVIL,ANGEL,P,K,ROOM,SA,SB,SC,SD;       DADRARE
                                                                         DADRARE
 #                                                                       AFB0912
*     FIRST WE FETCH BLOCK ALPHA, THE TERMINAL BLOCK THAT IS SO TO SPEAK AFB0912
*     OVERFLOWING. THEN FREEZE IT IN SLOT 1 (THE NEW BLOCK WILL          AFB0912
*     EVENTUALLY BE FROZEN IN SLOT 0, SO THAT RECORDS CAN BE COPIED FROM AFB0912
*     ALPHA TO THE NEW BLOCK IF NECESSARY.) THEN CLEAR NEWBNUM, WHICH    AFB0912
*     WILL BE SET TO THE PRU NUMBER OF THE NEW BLOCK.                    AFB0912
 #                                                                       AFB0912
          PTCURBLK[0] = ALPHA ;                                          DADRARE
          SEBL$AA ( 0 , 1 ) ;                                            DADRARE
          FIXX$AA ( P<BLOK$AA> , 1 ) ;                                   DADRARE
          NEWBNUM = 0 ;                                                  DADRARE
          J = 2 * ( WLG(NEWLNG)+OUTKEY ) + 1 ;
          ANGEL = 0 ;                                                    DADRARE
          DEVIL = 0 ;                                                    DADRARE
 #                                                                       AFB0912
*     NOW IF ALPHA = GAMMA (THE HOME BLOCK PRU NUMBER), ALPHA IS A HOME  AFB0912
*     BLOCK NOT A TERMINAL BLOCK AND THINGS WILL BE SIMPLER.             AFB0912
*     LEAVE ANGEL = 0 IF THIS IS TRUE. BUT OTHER-                        AFB0912
*     WISE SCAN ALL THE RECORDS IN BLOCK ALPHA, COUNTING THE TOTAL       AFB0912
*     LENGTH OF THOSE WHOSE KEYS HASH TO THE HOME BLOCK WE ARE CONCERNED AFB0912
*     WITH. SET ANGEL = THE TOTAL LENGTH, AND DEVIL = THE TOTAL LENGTH   AFB0912
*     OF ALL OTHER RECORDS IN THE BLOCK. ANGEL CANNOT BE ZERO, FOR IF    AFB0912
*     THIS TERMINAL BLOCK HAD NO GAMMA-TYPE RECORDS IN IT, WE WOULD      AFB0912
*     PREVIOUSLY HAVE BROKEN THE LINK CHAINING GAMMA TO ALPHA. SO        AFB0912
*     LEAVING ANGEL=0 WILL BE A SIGNAL THAT ALPHA IS JUST A HOME BLOCK   AFB0912
*     AFTER ALL.                                                         AFB0912
 #                                                                       AFB0912
          IF ALPHA NQ GAMMA                                              DADRARE
            THEN BEGIN  #COUNT SPECIES IN TERMINAL BLOCK#                DADRARE
              FOR SA = 1 STEP 1 UNTIL RC                                 DADRARE
                DO BEGIN                                                 DADRARE
                  IF ZING$DA ( SA ) EQ GAMMA                             DADRARE
                    THEN BEGIN                                           DADRARE
                      ANGEL = ANGEL + 2 * RECLNG + 1 ;                   DADRARE
                    END                                                  DADRARE
                END                                                      DADRARE
              DEVIL = MAXMT - EC - ANGEL ;                               DADRARE
            END                                                          DADRARE
 #                                                                       AFB0912
*     J IS THE LENGTH OF THE NEW RECORD IN HALFWORDS. IF IT AND ALL      AFB0912
*     THE ANGEL RECORDS COULD FIT INTO ONE EMPTY BLOCK, LET US LOOK      AFB0912
*     FOR AN EMPTY-ENOUGH BLOCK, IN TWO STAGES (1) LOOK AT ANY TERMINAL  AFB0912
*     BLOCKS OF THIS FILE THAT ARE NOW IN CORE, AND IF ANY HAS FREE      AFB0912
*     SPACE ENOUGH, CHOOSE IT, OR IF MORE THAN ONE, CHOOSE THE ONE       AFB0912
*     WITH THE MOST EMPTY SPACE. (2) IF THE PREVIOUS SEARCH FAILS,       AFB0912
*     LOOK AT THE MOST EMPTY TABLE, AND IF THERE IS MORE THAN ONE        AFB0912
*     POSSIBILITY,CHOOSE THE EMPTIEST.                                   AFB0912
*       NOTE THAT USING ANGEL=0 TO MEAN ALPHA IS A HOME BLOCK            AFB0912
*     IS FITTING HERE, BECAUSE NO RECORDS NEED TO BE COPIED OUT OF       AFB0912
*     A HOME BLOCK WHEN IT OVERFLOWS FOR THE FIRST TIME.                 AFB0912
*       BUT IF THE NEW RECORD AND ALL THE ANGELS COULD NOT FIT           AFB0912
*     INTO ONE EMPTY BLOCK, DONT MAKE THESE SEARCHES BUT GO              AFB0912
*     STRAIGHT FOR A NEW BLOCK. AN EXISTING TERMINAL BLOCK THAT          AFB0912
*     COULD NOT ACCEPT THE NEW RECORD PLUS THE ANGELS WOULD BE NO        AFB0912
*     USE BECAUSE IF WE USED IT, WE WOULD HAVE (IN THE GENERAL CASE)     AFB0912
*     TWO TERMINAL BLOCKS BOTH HOLDING SOME RECORDS THAT BELONGED        AFB0912
*     TO HOME BLOCK GAMMA -- I.E. THE CHAIN STARTING AT GAMMA WOULD      AFB0912
*     END IN TWO TERMINALS, WHICH IS NOT ALLOWED.                        AFB0912
 #                                                                       AFB0912
          IF  ( J + ANGEL ) LS MAXMT                                     DADRARE
            THEN BEGIN                                                   DADRARE
              P = J + ANGEL - 1 ;                                        DADRARE
              SB = P<BLOK$AA> ;                                          DADRARE
              P<BLOK$AA> = P<FSTT$AA> ;                                  DADRARE
              FOR SC = BLKFPTR[0] - DOFFBFCHN WHILE SC NQ P<FSTT$AA>     DADRARE
                DO BEGIN                                                 DADRARE
                  P<BLOK$AA> = SC ;                                      DADRARE
                  SC = BLKFPTR[0] - DOFFBFCHN ;                          DADRARE
                  IF BLOCKID[0] GQ FSFDBPRU[0] AND FWD EQ 0 AND EC GR P  AFB0801
                      AND RC NQ 0 #TO RULE OUT EMPTY CHAIN BLOCKS#
                    THEN BEGIN                                           DADRARE
                      P = EC ;                                           DADRARE
                      NEWBNUM = BLOCKID[0] ;                             DADRARE
                    END                                                  DADRARE
                END                                                      DADRARE
              P<BLOK$AA> = SB ;                                          DADRARE
              IF NEWBNUM EQ 0                                            DADRARE
                THEN BEGIN                                               DADRARE
                  FOR SA = 0 STEP 1 UNTIL DFMETLG-1                      DADRARE
                    DO BEGIN                                             DADRARE
                      K = FSMTUSW[SA] ;                                  DADRARE
                      IF K GR P                                          DADRARE
                        THEN BEGIN                                       DADRARE
                          P = K ;                                        DADRARE
                          NEWBNUM = FSMTPRU[SA] ;                        DADRARE
                        END                                              DADRARE
                    END                                                  DADRARE
                END                                                      DADRARE
            END                                                          DADRARE
 #                                                                       AFB0912
*     IF NO LUCK ON THOSE TWO SEARCHES, WE HAVE TO CALL NUBL$AA TO GET   AFB0912
*     A NEW BLOCK. THIS COULD BE EITHER A BLOCK FROM THE EMPTY CHAIN,    AFB0912
*     OR A NEW BLOCK AT EOI. IF THE LATTER, WE HAVE TO EXTEND THE        AFB0912
*     LAST PRU NUMBER. IN EITHER CASE, STEP THE COUNT OF OVERFLOW        AFB0912
*     BLOCKS.                                                            AFB0912
 #                                                                       AFB0912
          IF NEWBNUM EQ 0                                                DADRARE
            THEN BEGIN                                                   DADRARE
              NUBL$AA ( 0 ) ;                                            DADRARE
              FSOBCNT[0] = FSOBCNT[0] + 1 ;                              AFB0801
              IF NEWBNUM EQ FSLSTPRU[0]                                  DADRARE
                THEN BEGIN                                               DADRARE
                  FSLSTPRU[0] = FSLSTPRU[0] + FSBLKSIZ[0] ;              DADRARE
                END                                                      DADRARE
            END                                                          DADRARE
 #                                                                       AFB0912
*     BUT IF AN EXISTING BLOCK COULD BE USED WITHOUT CALLING NUBL$AA.    AFB0912
*     CALL LOCBLOC TO GET IT. WE MUST ALSO CALL LKEY$AA TO SET A         AFB0912
*     COUPLE OF POINTERS THAT NUBL$AA SETS UP BUT LOCB$AA DOES NOT,      AFB0912
*     AND FIXX$AA TO FREEZE THE BLOCK IN SLOT 0, WHICH NUBL$AA(0)        AFB0912
*     WOULD HAVE DONE IN ANY CASE TO A NEW BLOCK. ALSO THE OLD BLOCK     AFB0912
*     MAY HAVE DEAD RECORDS IN IT, AND TO SIMPLIFY ADDING RECORDS        AFB0912
*     TO THE BLOCK, WE CALL CONS$AA TO SQUEEZE OUT THE DEAD SPACE.       AFB0912
 #                                                                       AFB0912
            ELSE BEGIN                                                   DADRARE
              LOCBLOC ( NEWBNUM ) ;                                      AFB0801
              LKEY$AA ;                                                  DADRARE
              FIXX$AA ( P<BLOK$AA> , 0 ) ;                               DADRARE
              IF ANYDEAD NQ 0 THEN CONS$AA ;                             DADRARE
            END                                                          DADRARE
 #                                                                       AFB0912
*     SET ROOM TO THE AMOUNT OF EMPTY SPACE IN THE NEW BLOCK, LESS THE   AFB0912
*     LENGTH OF THE NEW RECORD. BECAUSE IF WE ARE GOING TO MOVE OLD      AFB0912
*     RECORDS FROM THE OVERFLOWED TERMINAL BLOCK INTO THE NEW BLOCK, WE  AFB0912
*     STILL WANT TO BE SURE TO LEAVE ROOM FOR THE NEW RECORD IN THE NEW  AFB0912
*     BLOCK. WHY SHOULD THE NEW RECORD GO ALWAYS GO INTO THE NEW BLOCK   AFB0912
*     -- JUST BECAUSE IT MAKES THE OVERALL PROGRAM SIMPLER.              AFB0912
*       SO IF WE DO TRANSFER GAMMA-TYPE RECORDS FROM BLOCK ALPHA TO      AFB0912
*     BLOCK NEWBNUM, WE SHALL TRANSFER ALL THERE ARE IF POSSIBLE, BUT    AFB0912
*     STOP IN TIME TO LEAVE ROOM FOR THE NEW RECORD TO BE ADDED          AFB0912
*     LATER.                                                             AFB0912
*                                                                        AFB0912
*     CALL TROW$AA(1) TO POINT US AT THE OVERFLOWED BLOCK, WHICH IS      AFB0912
*     FROZEN IN SLOT 1. IF THE OVERFLOWED BLOCK IS A HOME BLOCK,         AFB0912
*     SKIP TO ADNUP. IN THAT CASE, WE DONT MOVE ANY OLD RECORDS, BUT     AFB0912
*     JUST CHAIN ALPHA FORWARD TO NEWBNUM AND RETURN TO THE CALLER,      AFB0912
*     WHERE THE NEW RECORD WILL BE INSERTED IN NEWBNUM. THIS IS OK       AFB0912
*     WHETHER NEWBNUM IS A NEW BLOCK, OR AN EXISTING TERMINAL BLOCK      AFB0912
*     TO WHICH OTHER HOME BLOCKS ALREADY POINT.                          AFB0912
 #                                                                       AFB0912
          ROOM = EC - J ;                                                DADRARE
          TROW$AA ( 1 ) ;                                                DADRARE
          IF ALPHA EQ GAMMA THEN GOTO ADNUP ; #HOME BLOCK OVERFLOW#      DADRARE
                                                                         DADRARE
 #                                                                       AFB0912
*     BUT IF THE OVERFLOWING BLOCK IS ITSELF A TERMINAL BLOCK, IT        AFB0912
*     IS MORE COMPLICATED. DEVIL IS THE TOTAL LENGTH OF RECORDS IN       AFB0912
*     THAT BLOCK, WHICH DO NOT BELONG TO THE SAME HOME BLOCK AS THE      AFB0912
*     NEW RECORD. SO IF DEVIL=0, ALPHA CONTAINS ONLY RECORDS BELONG-     AFB0912
*     ING TO THE GAMMA CHAIN, AND CAN BE CONVERTED PAINLESSLY FROM       AFB0912
*     A TERMINAL BLOCK TO A MEMBER BLOCK. IN THIS CASE WE CALL           AFB0912
*     XMET$DA TO REMOVE ALPHA FROM THE MOST-EMPTY TABLE (IF THERE),      AFB0912
*     BECAUSE THE TABLE IS ONLY FOR TERMINAL BLOCKS. THEN SET ANGEL=0    AFB0912
*     NOT WITH ITS NATURAL MEANING, BUT FOR THE SAKE OF THE TEST BELOW   AFB0912
*     ADNUQ, TO PREVENT TWO ACTIONS THERE. CALL ALTR$AA BECAUSE WE ARE   AFB0912
*     ABOUT TO ALTER THE IMAGE OF BLOCK ALPHA FOR WHAT MAY BE THE        AFB0912
*     FIRST TIME, THEN CHAIN ALPHA FORWARD TO NEWBNUM, AS A MEMBER       AFB0912
*     BLOCK POINTING TO A TERMINAL BLOCK. THEN SKIP TO ADNUQ.            AFB0912
 #                                                                       AFB0912
          IF DEVIL EQ 0                                                  DADRARE
            THEN BEGIN #PURE TERMINAL OFLOWS - MAKE IT A MEMBER#         DADRARE
              XMET$DA ; #TAKE OUT OF M.E.T.#                             DADRARE
              ANGEL = 0 ;                                                DADRARE
     ADNUP:                                                              DADRARE
              ALTR$AA ;                                                  DADRARE
              FWD = NEWBNUM ; #CHAIN ALPHA TO NEW BLOCK#                 DADRARE
              GOTO ADNUQ ; #VERY SIMPLE#                                 DADRARE
            END                                                          DADRARE
                                                                         DADRARE
 #                                                                       AFB0912
*     IF DEVIL IS NOT 0, ALPHA CONTAINS RECORDS OF BOTH KINDS, GAMMA     AFB0912
*     AND NON-GAMMA. SO IT MUST REMAIN A TERMINAL BLOCK, WHILE           AFB0912
*     BLOCK NEWBNUM IS INSERTED BEHIND IT AND AHEAD OF ITS IMMEDIATE     AFB0912
*     PREDECESSOR IN THE CHAIN. THE PREDECESSOR-S PRU NUMBER IS IN ETA.  AFB0912
*     BEFORE CALLING LOCBLOC TO GET BLOCK ETA, SO THAT WE CAN MAKE IT    AFB0912
*     POINT FORWARD TO NEWBNUM, WE HAVE TO RELEASE ONE OF THE TWO        AFB0912
*     FROZEN BLOCKS, ALPHA AND NEWBNUM. IT IS POSSIBLE THAT WE ARE       AFB0912
*     RUNNING WITH SPACE FOR ONLY TWO BUFFERS, AND IF TWO ARE FROZEN,    AFB0912
*     THERE IS NO ROOM FOR ETA, AND THE SPACE MANAGER WILL ABORT THE     AFB0912
*     RUN. SO CALL UNFX$AA TO UNFREEZE BLOCK ALPHA, THEN GET ETA AND     AFB0912
*     ADJUST ITS FORWARD POINTER, WHICH IS ALL THAT HAS TO BE DONE TO    AFB0912
*     THAT BLOCK, THEN RETURN TO BLOCK ALPHA AND RE-FREEZE IT.           AFB0912
 #                                                                       AFB0912
          UNFX$AA ( 1 ) ; #ALPHA#                                        DADRARE
          LOCBLOC ( ETA ) ;                                              AFB0801
          ALTR$AA ;                                                      DADRARE
          FWD = NEWBNUM ;                                                DADRARE
          BLCIP[0] = 0 ;                                                 DADRARE
          LOCBLOC (ALPHA ) ;                                             AFB0801
          LKEY$AA ;                                                      DADRARE
          FIXX$AA ( P<BLOK$AA> , 1 ) ;                                   DADRARE
 #                                                                       AFB0912
*     NOW SCAN THE LIST OF RECORDS IN BLOCK ALPHA. EACH TIME ONE         AFB0912
*     HASHES TO HOME BLOCK GAMMA, DELETE IT FROM BLOCK ALPHA (THIS IS    AFB0912
*     ONLY SETTING A FLAG. THE CONTENT OF THE RECORD IS NOT IMMEDIATELY  AFB0912
*     COVERED OR MOVED, BECAUSE A TERMINAL BLOCK NEVER HAS THE           AFB0912
*     ((UNIFORM RECORD)) BIT SET), FIND THE RIGHT PLACE TO INSERT IT     AFB0912
*     IN BLOCK NEWBNUM, AND INSERT IT. EVERY TIME A RECORD IS MOVED      AFB0912
*     IN THIS WAY, SUBTRACT ITS LENGTH FROM ROOM AND ALSO FROM ANGEL.    AFB0912
*     WHEN ROOM GETS TOO LOW, IT STOPS THE TRANSFER OF RECORDS TO        AFB0912
*     NEWBNUM WHILE THERE IS STILL SPACE FOR THE REALLY NEW RECORD.      AFB0912
*     IF ANGEL IS REDUCED TO 0, IT WILL MEAN, JUST BELOW ADNUQ, THAT     AFB0912
*     ALL THE GAMMA-TYPE RECORDS HAVE BEEN REMOVED FROM BLOCK ALPHA,     AFB0912
*     SO THAT ALPHA SHOULD NO LONGER BELONG TO THE GAMMA CHAIN. WE       AFB0912
*     KNOW IT MUST ALSO BELONG TO SOME OTHER CHAIN, BECAUSE DEVIL        AFB0912
*     WAS NOT 0. ALL WE DO TO BREAK IT OFF THE GAMMA CHAIN IS NOT TO     AFB0912
*     MAKE BLOCK NEWBNUM POINT FORWARD TO IT, SO THAT NOW NEWBNUM        AFB0912
*     IS THE TERMINAL BLOCK OF THE GAMMA CHAIN.                          AFB0912
 #                                                                       AFB0912
          ALTR$AA ;                                                      DADRARE
          SA = NEWFWA ;                                                  DADRARE
          SB = NEWLNG ;                                                  DADRARE
          SC = KEYFWA ;                                                  DADRARE
          SD = KEYOFF ;                                                  DADRARE
          FOR P = 1 STEP 1 UNTIL RC                                      DADRARE
            DO BEGIN                                                     DADRARE
              IF ZING$DA ( P ) EQ GAMMA AND ( 2*RECLNG+1 ) LQ ROOM       DADRARE
                THEN BEGIN                                               DADRARE
                  ROOM = ROOM - ( 2*RECLNG+1 ) ;                         DADRARE
                  ANGEL = ANGEL - ( 2*RECLNG+1 ) ;                       DADRARE
                  CMPREC = RPCMP ;
                  NEWFWA = RECFWA + OUTKEY ;
                  NEWLNG = WC * ( RECLNG - OUTKEY ) - UCCFIELD ;
                  KEYFWA = TEMPLOC ;                                     DADRARE
                  KEYOFF = TEMPOS ;                                      DADRARE
                  DELL$AA ;                                              DADRARE
                  TROW$AA ( 0 ) ; #GO TO NEW BLOCK#                      DADRARE
                  IF RC NQ 0                                             DADRARE
                    THEN BEGIN                                           DADRARE
                      BNCH$AA ;                                          DADRARE
                      LOCR$AA ( SMALREC + 1 ) ;                          DADRARE
                    END                                                  DADRARE
                  BARREN = 0 ;                                           DADRARE
                  ADRC$AA ;                                              DADRARE
                  UR = 0 ;                                               DADRARE
                  TROW$AA ( 1 ) ;                                        DADRARE
                END                                                      DADRARE
            END                                                          DADRARE
          METB$DA ;                                                      AFB0801
          NEWFWA = SA ;                                                  DADRARE
          NEWLNG = SB ;                                                  DADRARE
          KEYFWA = SC ;                                                  DADRARE
          KEYOFF = SD ;                                                  DADRARE
 #                                                                       AFB0912
*     AT ADNUQ WE RETURN TO BLOCK NEWBNUM. WE MIGHT ALREADY BE THERE,    AFB0912
*     OR MIGHT NOT. IF ANGEL IS 0, IT MEANS (NATURALLY) THAT ALL THE     AFB0912
*     GAMMA-TYPE RECORDS HAVE BEEN MOVED FROM ALPHA TO NEWBNUM, SO       AFB0912
*     THAT NEWBNUM CAN BE A TERMINAL BLOCK, OR (BY CONVENTION) THAT      AFB0912
*     ALPHA COULD JUST POINT FORWARD TO NEWBNUM, LETTING NEWBNUM BE      AFB0912
*     TERMINAL. IF ANGEL IS NOT 0, IT MEANS ALPHA IS STILL TERMINAL,     AFB0912
*     AND NEWBNUM IS TO BE A MEMBER BLOCK, HENCE WE SET THE FORWARD      AFB0912
*     POINTER IN NEWBNUM. THEN UNFREEZE BOTH BLOCKS.                     AFB0912
 #                                                                       AFB0912
     ADNUQ:                                                              DADRARE
          BLCIP[0] = 0 ;                                                 DADRARE
          TROW$AA ( 0 ) ; #NEWBNUM#                                      DADRARE
          IF ANGEL NQ 0                                                  DADRARE
            THEN BEGIN                                                   DADRARE
              FWD = ALPHA ;                                              DADRARE
              BLCIP[0] = 0 ;                                             DADRARE
              IOWR$AA ( 1 ) ;                                            DADRARE
            END                                                          DADRARE
            ELSE BLCIP[0] = 0 ;                                          DADRARE
          UNFX$AA ( 1 ) ;                                                DADRARE
          UNFX$AA ( 0 ) ;                                                DADRARE
          IF ANYDEAD NQ 0 THEN CONS$AA ;                                 DADRARE
          END                                                            DADRARE
CONTROL EJECT ;                                                          AFB0912
 #                                                                       AFB0912
* *   LOCBLOC - LOCATE A BLOCK BY PRU NUMBER     PAGE 1                  AFB0912
* *   A.F.R.BROWN                                                        AFB0912
* 1DC LOCBLOC                                                            AFB0912
*                                                                        AFB0912
* DC  FUNCTION                                                           AFB0912
*                                                                        AFB0912
*     TO CALL LOCB$AA WITH RECALL, SIMPLY PASSING THE                    AFB0912
*     PRU NUMBER ON TO IT, AND THEN TO DEAL WITH THE POSSIBILITY         AFB0912
*     OF A BAD READ (BAD REDUNDANCY CHECK OR BAD CHECKSUM).              AFB0912
*     LOCB$AA IS NOT CALLED IN VERY MANY PLACES IN CRM 2.0 AAM, SO       AFB0912
*     WE LEAVE THE QUESTION OF WHAT TO DO WITH A BAD READ TO BE          AFB0912
*     DECIDED AT EACH POINT, RATHER THAN HAVING AN ERROR EXIT            AFB0912
*     STRAIGHT OUT OF LOCB$AA. HERE IN DA$RARE WE HAVE A FEW             AFB0912
*     PLACES WHERE A CALL TO LOCB$AA IS NEEDED, AND AS THE PROVISION     AFB0912
*     FOR THE ERROR POSSIBILITY CAN BE THE SAME AT EACH POINT,           AFB0912
*     WE SET UP LOCBLOC TO CONSOLIDATE THE WHOLE THING.                  AFB0912
*                                                                        AFB0912
* DC  ENTRY CONDITIONS                                                   AFB0912
*                                                                        AFB0912
*     THERE IS ONE PARAMETER, PASSED IN THE NORMAL SYMPL WAY, WHICH      AFB0912
*     IS THE PRU NUMBER OF THE WANTED BLOCK.                             AFB0912
*                                                                        AFB0912
* DC  EXIT CONDITIONS                                                    AFB0912
*                                                                        AFB0912
*     P<BLOK$AA> IS THE FWA OF THE BLOCK IN CORE.                        AFB0912
*     IF THE READ WAS BAD, WE DO NOT EXIT FROM LOCBLOC, BUT TAKE         AFB0912
*     A SHORT CUT TO EXIT$AA BY CALLING EXRP$AA.                         AFB0912
*                                                                        AFB0912
* DC  ERROR CONDITIONS                                                   AFB0912
*                                                                        AFB0912
*     EXRP$AA IS CALLED IF THERE IS AN UNCORRECTABLE ERROR               AFB0912
*       ON THE READING OF THE BLOCK. WE NEVER RETURN FROM EXRP$AA        AFB0912
*       AND HENCE NOT FROM LOCBLOC EITHER.                               AFB0912
*                                                                        AFB0912
* DC  CALLED ROUTINES                                                    AFB0912
*                                                                        AFB0912
*     LOCB$AA - TO LOCATE THE  BLOCK AND GET IT READ IN                  AFB0912
*       IF NECESSARY.                                                    AFB0912
*     EXRP$AA - TO DEAL WITH AN UNCORRECTABLE READ ERROR.                AFB0912
*                                                                        AFB0912
* DC  NON-LOCAL VARIABLES                                                AFB0912
*                                                                        AFB0912
*     NONE                                                               AFB0912
*                                                                        AFB0912
 #                                                                       AFB0912
                                                                         AFB0801
     PROC LOCBLOC ( N ); BEGIN                                           GAG0807
          ITEM N ;                                                       AFB0801
          LOCB$AA ( N , 1 ) ;                                            AFB0801
          IF P<BLOK$AA> LS 0                                             AFB0801
            THEN BEGIN                                                   AFB0801
              EXRP$AA ;                                                  AFB0801
            END                                                          AFB0801
          END                                                            AFB0801
                                                                         DADRARE
          END TERM                                                       DADRARE
