*DECK AKDAK                                                              AKDAK
*CALL COMUSETXT 
PROC AK$AK;                                                              GAG0905
      BEGIN                                                              GAG0905
     XREF BEGIN                                                          GAG0905
          PROC BACK$AA;                                                  GAG0905
          FUNC MXPR$AA;                                                  GAG0905
          PROC MOVC$AA;                                                  GAG0905
          PROC MOVW$AA;                                                  GAG0905
          PROC IMPR$AA;                                                  GAG0905
          PROC GET$MP;                                                   GAG0905
          PROC GETN$MP;                                                  GAG0905
          PROC RWIN$MP;                                                  GAG0905
          PROC CPKY$AA;                                                  GAG0905
          PROC RDRC$AA;                                                  GAG0905
          FUNC UUCC$AA;                                                  GAG0905
          FUNC QUMP$AA;                                                  GAG0905
          PROC SEBL$AA;                                                  GAG0905
          PROC SETR$AA;                                                  GAG0905
          PROC SEEK$MP;                                                  GAG0905
          PROC LOCB$AA;                                                  GAG0905
          PROC SKIP$MP;                                                  GAG0905
          PROC STPF$AA;                                                  GAG0905
          PROC STMD$AA;                                                  GAG0905
          PROC CURR$AA;                                                  GAG0905
          PROC VOKG$AA;                                                  GAG0905
          PROC LOCR$AA;                                                  GAG0905
          PROC MSGZ$AA;                                                  GAG0905
          PROC MSGF$AA;                                                  GAG0905
          PROC GTNR$MP;                                                  GAG0905
          LABEL EXIT$AA;                                                 GAG0905
          END                                                            GAG0905
CONTROL WEAK SKIP$MP;                                                    GAG0905
CONTROL WEAK GET$MP,GETN$MP,RWIN$MP;                                     GAG0905
CONTROL WEAK GTNR$MP,SEEK$MP;                                            GAG0905
     XDEF BEGIN                                                          GAG0905
          FUNC MACH$AK ;                                                 GAG0905
          PROC FILP$AK;                                                  GAG0905
          PROC GET$AK;                                                   GAG0905
          PROC GETN$AK;                                                  GAG0905
          PROC GTNR$AK;                                                  GAG0905
          PROC LBK$AK ;                                                  GAG0905
          PROC LBK2$AK ;                                                 GAG0905
          PROC CURR$AK ;                                                 GAG0905
          PROC NWEM$AK;                                                  GAG0905
          PROC RDBK$AK;                                                  GAG0905
          PROC REW$AK;                                                   GAG0905
          PROC SEEK$AK;                                                  GAG0905
          PROC SKIP$AK;                                                  GAG0905
          PROC SVKY$AK ;                                                 GAG0905
          END                                                            GAG0905
                                                                         GAG0905
          ITEM IX;            #INDUCTION VARIABLE#                       GAG0905
          ITEM T1;            #TEMP CELL#                                GAG0905
          ITEM BN , RB , SN ;                                            GAG0905
CONTROL EJECT;                                                           GAG0905
 #                                                                       AFB0926
* *   MACH$AK - CHECK THE LINK BETWEEN TWO RECORDS         PAGE 1        AFB0926
* *   A.F.R.BROWN                                                        AFB0926
* 1DC MACH$AK                                                            AFB0926
*                                                                        AFB0926
* DC  FUNCTION                                                           AFB0926
*                                                                        AFB0926
*     TO MAKE SURE THAT THE POINTER AT THE BEGINNING OF THE              AFB0926
*     CURRENT RECORD, WHICH IS EITHER A PLACEHOLDER OR AN                AFB0926
*     ALIEN, CONTAINS THE BLOCK AND SLOT NUMBER OF THE RECORD            AFB0926
*     AT THE OTHER END OF THE LINK, AS INDICATED BY THE PTREE            AFB0926
*     WORD THAT POINTS TO THAT OTHER RECORD.                             AFB0926
*                                                                        AFB0926
* DC  ENTRY CONDITIONS                                                   AFB0926
*                                                                        AFB0926
*     THE CURRENT BLOCK AND RECORD ARE LOCATED AS IF CURR$AA HAD         AFB0926
*     JUST BEEN CALLED, AND THE RECORD POINTER OF THE CURRENT RECORD     AFB0926
*     HAS BEEN COPIED TO VARIABLE RECPTR.                                AFB0926
*                                                                        AFB0926
*     RECFWA IS THE FWA OF THE CURRENT RECORD.                           AFB0926
*                                                                        AFB0926
*     IF CURPTR = 0 OR 3, THE CURRENT RECORD MUST BE A PLACEHOLDER       AFB0926
*     (MOTHER) CONSISTING OF ONE WORD THAT IS ESSENTIALLY A COPY         AFB0926
*     OF PTREEWRD[1] OR PTREEWRD[4] RESPECTIVELY.                        AFB0926
*                                                                        AFB0926
*     IF CURPTR = 1 OR 4, THE CURRENT RECORD MUST BE AN ALIEN,           AFB0926
*     WHOSE FIRST WORD IS ESSENTIALLY A COPY OF PTREEWRD[0] OR           AFB0926
*     PTREEWRD[3] RESPECTIVELY.                                          AFB0926
*                                                                        AFB0926
*     (PTREEWRD[0] AND [1] ARE USED FOR OPERATIONS THAT ALTER            AFB0926
*     THE FILE, AND PTREEWRD[3] AND [4] FOR OPERATIONS THAT DO NOT.)     AFB0926
*                                                                        AFB0926
* DC  EXIT CONDITIONS                                                    AFB0926
*                                                                        AFB0926
*     THIS SUBROUTINE RETURNS IN X6, AS A SYMPL FUNCTION, 0 IF           AFB0926
*     THE POINTER MATCHES THE PTREE WORD CORRECTLY, AND                  AFB0926
*     NON-ZERO IF NOT.                                                   AFB0926
*                                                                        AFB0926
* DC  ERROR CONDITIONS                                                   AFB0926
*                                                                        AFB0926
*     NONE TREATED HERE. THE ROUTINE THAT CALLED MACH$AK WILL            AFB0926
*     PROBABLY DECLARE A FATAL ERROR IF MACH$AK IS NON-ZERO.             AFB0926
*                                                                        AFB0926
* DC  CALLED ROUTINES                                                    AFB0926
*                                                                        AFB0926
*     NONE                                                               AFB0926
*                                                                        AFB0926
* DC  NON-LOCAL VARIABLES                                                AFB0926
*                                                                        AFB0926
*     T1 - USED FOR SCRATCH                                              AFB0926
*                                                                        AFB0926
 #                                                                       AFB0926
FUNC MACH$AK ;                                                           GAG0905
          BEGIN                                                          GAG0905
          ITEM A ;                                                       GAG0905
                                                                         GAG0905
          MACH$AK = 1 ;                                                  GAG0905
          T1 = CURPTR ;                                                  GAG0905
          IF T1 EQ 3                                                     GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              A = 4 ;                                                    GAG0905
              GOTO MACHA ;                                               GAG0905
              END                                                        GAG0905
          ELSE                                                           GAG0905
              BEGIN                                                      GAG0905
              IF T1 EQ 4                                                 GAG0905
              THEN                                                       GAG0905
                  BEGIN                                                  GAG0905
                  A = 3 ;                                                GAG0905
                  GOTO MACHB ;                                           GAG0905
                  END                                                    GAG0905
              ELSE                                                       GAG0905
                  BEGIN                                                  GAG0905
                  IF T1 EQ 0                                             GAG0905
                  THEN                                                   GAG0905
                      BEGIN                                              GAG0905
                      A = 1 ;                                            GAG0905
                      GOTO MACHA ;                                       GAG0905
                      END                                                GAG0905
                  END #ELSE ASSUM CURPTR=1#                              GAG0905
              END                                                        GAG0905
          A = 0 ;                                                        GAG0905
MACHB:                                                                   GAG0905
          IF RPUCC NQ ALIEN                                              GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              RETURN ; #BAD#                                             GAG0905
              END                                                        GAG0905
          ELSE                                                           GAG0905
              BEGIN                                                      GAG0905
              GOTO MACHC ;                                               GAG0905
              END                                                        GAG0905
MACHA:                                                                   GAG0905
          IF RPUCC NQ OVERFLOW                                           GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              RETURN ;                                                   GAG0905
              END                                                        GAG0905
MACHC:                                                                   GAG0905
          IF PTBLKIN[A] EQ 0                                             GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              T1 = PTCURBLK[A] ;                                         GAG0905
              END                                                        GAG0905
          ELSE                                                           GAG0905
              BEGIN                                                      GAG0905
              T1 = BLOCKID[PTCURBADR[A]-P<BLOK$AA>] ;                    GAG0905
              END                                                        GAG0905
          IF B<35,25>W[RECFWA] EQ T1                                     GAG0905
            AND B<22,13>W[RECFWA] EQ PTCUREC[A]                          GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              MACH$AK = 0 ;                                              GAG0905
              END                                                        GAG0905
          END                                                            GAG0905
PROC CURR$AK ;    CONTROL EJECT ;                                        GAG0905
          BEGIN                                                          GAG0905
 #                                                                       AFB0926
* *   CURR$AK - LOCATE THE CURRENT RECORD BY THE PTREE      PAGE 1       AFB0926
* *   A.F.R.BROWN                                                        AFB0926
* 1DC CURR$AK                                                            AFB0926
*                                                                        AFB0926
* DC  FUNCTION                                                           AFB0926
*                                                                        AFB0926
*     BASICALLY JUST THE SAME AS CURR$AA, TO TAKE THE CURRENT WORD       AFB0926
*     OF THE PTREE, AND LOCATE FROM IT THE CURRENT BLOCK AND             AFB0926
*     THEN THE CURRENT RECORD. HOWEVER, CURR$AK CHECKS, AS               AFB0926
*     CURR$AA DOES NOT, TO SEE THAT THE BLOCK AND RECORD NUMBERS ARE     AFB0926
*     VALID BEFORE RISKING A FATAL ERROR.                                AFB0926
*                                                                        AFB0926
* DC  ENTRY CONDITIONS                                                   AFB0926
*                                                                        AFB0926
*     P<PTRE$AA> POINTS TO THE PTREE OF AN AK FILE, AND CURPTR           AFB0926
*     INDICATES WHICH WORD IN THE PTREE.                                 AFB0926
*                                                                        AFB0926
*     THE PTREE WORD MUST CONTAIN A BLOCK PRU NUMBER, NOT THE ADDRESS    AFB0926
*     OF A BLOCK IMAGE IN CORE. I.E. PTBLKIN[CURPTR] MUST BE 0.          AFB0926
*     IF NOT, THE SUBROUTINE WILL ALWAYS APPEAR TO BE GETTING A TOO-HIGH AFB0926
*     PRU NUMBER.                                                        AFB0926
*                                                                        AFB0926
* DC  EXIT CONDITIONS                                                    AFB0926
*                                                                        AFB0926
*     QMF = 1 IF THE RECORD EXISTS AND IS NOT DEAD AND                   AFB1009
*       (A) IF CURPTR = 0 OR 3, IMPLYING THAT WE ARE LOOKING             AFB1009
*          AT THE HOME BLOCK, THE RECORD IS NOT AN ALIEN.                AFB1009
*       (B) OTHERWISE, PRESUMING THAT WE ARE LOOKING AT                  AFB1009
*      AN ALIEN BLOCK, THE RECORD IS AN ALIEN.                           AFB1009
*     QMF = 0 IF THE RECORD DOES NOT EXIST OR IS AN ALIEN OR DEAD.       AFB0926
*     QEI = 1 IF THE RECORD DOES NOT EXIST, BECAUSE THE BLOCK NUMBER     AFB0926
*       IS BEYOND EOI.                                                   AFB0926
*       IN THIS CASE WE SET THE BLOCK NUMBER IN THE PTREE WORD
*       TO 3, THE LOWEST POSSIBLE VALUE, FOR SAFETYS SAKE. QEI
*       WILL BE ENOUGH TO INDICATE THE EOI POSITION.
*        BUT THIS PROTECTIVE CHANGE TO THE BLOCK NUMBER IS NOT
*        DONE IF CURPTR=0, WHICH INDICATES THE OPERATION IS AN
*        UPDATE. QMF=0 WILL PREVENT REPLACE OR DELETE FROM DOING
*        ANYTHING, AND IF THE OPERATION IS A PUT, THE BLOCK 
*        NUMBER WILL BE RECHECKED IN THE PUT ROUTINE. 
*     QEI = 0 OTHERWISE.                                                 AFB0926
*     IF QEI = 0 AND THE RECORD EXISTS, THEN RECPTR CONTAINS A COPY      AFB0926
*       OF THE RECORD POINTER, AND THE RECORD HAS BEEN LOCATED AS BY     AFB0926
*       CURR$AA. THEN QMF = 1 IF THE RECORD IS NOT AN ALIEN OR DEAD.     AFB0926
*       IF RECPTR = 0, QMF WILL BE 0. BUT IF RECPTR IS NOT 0 AND         AFB0926
*       QMF = 0, THE RECORD IS AN ALIEN OR DEAD.                         AFB0926
*     IF THE RECORD EXISTS, RNO=PTCUREC[CURPTR].                         AFB0926
*                                                                        AFB0926
* DC  ERROR CONDITIONS                                                   AFB0926
*                                                                        AFB0926
*     NONE                                                               AFB0926
*                                                                        AFB0926
* DC  CALLED ROUTINES                                                    AFB0926
*                                                                        AFB0926
*     MXPR$AA - A FUNCTION THAT TELLS THE PRU NUMBER AT LOGICAL EOI      AFB0926
*       IN THE CURRENT FILE.                                             AFB0926
*     RDBK$AK - READ OR LOCATE A BLOCK TO WHICH A PTREE WORD POINTS,     AFB0926
*       AND UPDATE THE MOSTEMPTY TABLE IF THE BLOCK IS READ FROM DISK.   AFB0926
*     CUR2$AK - LOCATE A RECORD BY NUMBER IN THE CURRENT BLOCK. BUT      AFB0926
*       CHECK AGAINST THE NUMBER BEING TOO HIGH.                         AFB0926
*                                                                        AFB0926
* DC  NON-LOCAL VARIABLES                                                AFB0926
*                                                                        AFB0926
*     NONE.                                                              AFB0926
*                                                                        AFB0926
 #                                                                       AFB0926
          IF PTCURBLK[CURPTR] GQ MXPR$AA                                 GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              QMF = 0 ;                                                  GAG0905
              QEI = 1 ;                                                  GAG0905
            IF CURPTR NQ 0 THEN 
              PTCURBLK[CURPTR] = PRU3 ; 
              END                                                        GAG0905
          ELSE                                                           GAG0905
              BEGIN                                                      GAG0905
              RDBK$AK ( 1 ) ;                                            GAG0905
              CUR2$AK ;                                                  GAG0905
              END                                                        GAG0905
          END                                                            GAG0905
                                                                         GAG0905
PROC CUR2$AK ;                                                           GAG0905
          BEGIN                                                          GAG0905
 #                                                                       AFB0926
* *   CUR2$AK - LOCATE A RECORD BY NUMBER                  PAGE 1        AFB0926
* *   A.F.R.BROWN                                                        AFB0926
* 1DC CUR2$AK                                                            AFB0926
*                                                                        AFB0926
* DC  FUNCTION                                                           AFB0926
*                                                                        AFB0926
*     TO LOCATE THE RECORD POINTED TO BY THE CURRENT PTREE WORD,         AFB0926
*     IN AN AK BLOCK THAT IS ALREADY IN CORE. A CHECK IS MADE            AFB0926
*     AGAINST A TOO-HIGH RECORD NUMBER.                                  AFB0926
*                                                                        AFB0926
* DC  ENTRY CONDITIONS                                                   AFB0926
*                                                                        AFB0926
*     P<BLOK$AA> ALREADY POINTS TO THE CURRENT BLOCK, AND BLOCLWA        AFB0926
*     TO ITS LWA+1.                                                      AFB0926
*                                                                        AFB0926
*     PTCUREC[CURPTR] IS THE WANTED RECORD NUMBER. BUT THERE IS NO       AFB0926
*     GUARANTEE THAT IT EXISTS.                                          AFB0926
*                                                                        AFB0926
* DC  EXIT CONDITIONS                                                    AFB0926
*                                                                        AFB0926
*     QEI = 0. FOR THE REMAINING EXIT CONDITIONS, SEE UNDER SUBROUTINE   AFB0926
*     CURR$AK ABOVE.                                                     AFB0926
*                                                                        AFB0926
* DC  ERROR CONDITIONS                                                   AFB0926
*                                                                        AFB0926
*     NONE                                                               AFB0926
*                                                                        AFB0926
* DC  CALLED ROUTINES                                                    AFB0926
*                                                                        AFB0926
*     LOCR$AA - TO LOCATE A RECORD BY NUMBER IN THE CURRENT BLOCK,       AFB0926
*       ALREADY KNOWING THAT IT EXISTS.                                  AFB0926
*                                                                        AFB0926
* DC  NON-LOCAL VARIABLES                                                AFB0926
*                                                                        AFB0926
*     ONLY THOSE INVOLVED IN THE EXIT CONDITIONS.                        AFB0926
*                                                                        AFB0926
 #                                                                       AFB0926
          RECPTR = 0 ;                                                   GAG0905
          QMF = 0 ;                                                      GAG0905
          QEI = 0 ;                                                      GAG0905
          RNO = PTCUREC[CURPTR] ;                                        GAG0905
          IF RNO LQ RC                                                   GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              LOCR$AA ( RNO ) ;                                          GAG0905
              IF CURPTR EQ 0 OR CURPTR EQ 3                              AFB1009
              THEN                                                       AFB1009
                  BEGIN                                                  AFB1009
                  IF RPUCC LS ALIEN                                      AFB1009
                  THEN                                                   AFB1009
                      BEGIN                                              AFB1009
                      QMF = 1 ;                                          AFB1009
                      END                                                AFB1009
                  END                                                    AFB1009
              ELSE                                                       AFB1009
                  BEGIN                                                  AFB1009
                  IF RPUCC EQ ALIEN                                      AFB1009
                  THEN                                                   AFB1009
                      BEGIN                                              AFB1009
                      QMF = 1 ;                                          AFB1009
                      END                                                AFB1009
                  END                                                    AFB1009
              END                                                        GAG0905
          END                                                            GAG0905
PROC FILP$AK(STAT);          CONTROL EJECT;                              GAG0905
          BEGIN                                                          GAG0905
 #                                                                       GAG0905
* *       FILP$AK - SET FILE POSITION STATUS.    PAGE  1                 GAG0905
* *       PROGRAM - AK$AK                                                GAG0905
* *       R.P.NG.                               DATE.                    GAG0905
* 1CD     FILP$AK                                                        GAG0905
*                                                                        GAG0905
* CD      FUNCTION - TO SET FILE POSITION FP IN FIT AND FAFP IN FIAT     GAG0905
*         ON COMPLETION OF A COMMAND.                                    GAG0905
*                                                                        GAG0905
* CD      ENTRY CONDITIONS                                               GAG0905
*                                                                        GAG0905
*         THE INPUT PARAMTER IS THE FP STATUS VALUE THAT IS TO BE USED.  GAG0905
*         P<FIT$AA> AND P<FIAT$AA> SHOULD BE SET FOR THE CURRENT USER.   GAG0905
*                                                                        GAG0905
* CD      EXIT CONDITIONS.                                               GAG0905
*                                                                        GAG0905
*         FTFP AND FAFP ARE SET TO THE CORRESPONDING VALUES.  FAALTPOS   GAG0905
*         IS CLEARED.                                                    GAG0905
*                                                                        GAG0905
* CD      ERROR CONDITIONS                                               GAG0905
*                                                                        GAG0905
*         NONE                                                           GAG0905
*                                                                        GAG0905
* CD      CALLED ROUTINES                                                GAG0905
*                                                                        GAG0905
*         NONE                                                           GAG0905
*                                                                        GAG0905
* CD      DESCRIPTION                                                    GAG0905
*                                                                        GAG0905
*         SET FTFP AND FAFP TO STAT.  SET FAALTPOS TO ZERO.  EXIT.       GAG0905
 #                                                                       GAG0905
          ITEM STAT;                                                     GAG0905
          FTFP = STAT;                                                   GAG0905
          FAFP = STAT;                                                   GAG0905
          FAALTPOS = 0;                                                  GAG0905
          END  #END FILP$AK#                                             GAG0905
PROC FOLLOW ;       CONTROL EJECT ;                                      GAG0905
          BEGIN                                                          GAG0905
 #                                                                       AFB0926
* *   FOLLOW - LOCATE THE OVERFLOW RECORD IF ANY      PAGE 1             AFB0926
* *   A.F.R.BROWN                                                        AFB0926
* 1DC FOLLOW                                                             AFB0926
*                                                                        AFB0926
* DC  FUNCTION                                                           AFB0926
*                                                                        AFB0926
*     AS PART OF A GET OR GETNEXT, WHEN THE RECORD TO WHICH THE          AFB0926
*     KEY POINTS HAS BEEN LOCATED, TO SEE IF THE RECORD IS A             AFB0926
*     PLACEHOLDER POINTING TO AN OVERFLOW RECORD, AND IF SO TO           AFB0926
*     LOCATE THE OVERFLOW RECORD.                                        AFB0926
*                                                                        AFB0926
* DC  ENTRY CONDITIONS                                                   AFB0926
*                                                                        AFB0926
*     IF PTREEWRD[4] IS NOT 0, THEN IT ALREADY POINTS TO THE             AFB0926
*     OVERFLOW RECORD.                                                   AFB0926
*                                                                        AFB0926
*     IF PTREEWRD[4] IS 0, THEN RECPTR CONTAINS A COPY OF THE RECORD     AFB0926
*     POINTER FOR THE HOME RECORD, AND RECFWA IS THE FWA OF THAT         AFB0926
*     RECORD IN CORE.                                                    AFB0926
*                                                                        AFB0926
*     IF FIELD RPUCC OF RECPTR = 13 (OVERFLOW) THEN THE CURRENT          AFB0926
*     RECORD IS JUST A PLACEHOLDER FOR AN OVERFLOW RECORD,               AFB0926
*     WHICH IS NOW TO BE LOCATED. OTHERWISE NOT.                         AFB0926
*                                                                        AFB0926
* DC  EXIT CONDITIONS                                                    AFB0926
*                                                                        AFB0926
*     IF ON ENTRY PTREEWRD[4] = 0, WHICH IS THE COMMON CASE, THEN--      AFB0926
*     (1) IF THERE WAS NO OVERFLOW RECORD, EVERYTHING IS UNCHANGED,      AFB0926
*        EXCEPT THAT OUTKEY HAS BEEN SET TO 0. (IN DA AND IS FILES,      AFB0926
*        OUTKEY IS LENGTH OF NON-EMBEDDED KEY STORED BEFORE A RECORD.    AFB0926
*        IN AN AK FILE, THERE IS NO NEED TO STORE A NON-EMBEDDED KEY, SO AFB0926
*        OUTKEY IS ALWAYS 0 FROM THAT POINT OF VIEW. BUT AS IN AK FILES  AFB0926
*        ALONE, WE HAVE OVERFLOW POINTERS TO WORRY ABOUT, OUTKEY IS SET  AFB0926
*        TO 0 FOR AN ORDINARY RECORD, OR TO 1 FOR AN ALIEN OVERFLOW      AFB0926
*        RECORD, WHICH CONSISTS OF THE SUBSTANCE OF THE RECORD           AFB0926
*        PREFIXED WITH A ONE-WORD POINTER BACK TO THE MOTHER POSITION.)  AFB0926
*     (2) IF THERE WAS AN OVERFLOW RECORD, SATISFACTORILY LOCATED NOW,   AFB0926
*        OUTKEY=1, QMF=1, CURPTR=4, PTREEWRD[4] POINTS TO THE OVERFLOW   AFB0926
*        RECORD, RECFWA RECLNG AND RECLWA POINT TO ITS IMAGE IN CORE,    AFB0926
*        RECPTR CONTAINS A COPY OF THE RECORD POINTER FOR IT, AND THE    AFB0926
*        RPUCC FIELD OF RECPTR HAS BEEN ALTERED FROM 14 (AS IT WAS ON    AFB0926
*        DISK, INDICATING AN ALIEN) TO A COPY OF THE REAL UCC, TAKEN     AFB0926
*        FROM THE ONE-WORD PREFIX AT THE BEGINNING OF THE RECORD.        AFB0926
*        ALSO RNO = THE RECORD NUMBER OF THE OVERFLOW RECORD.            AFB0926
*     (3) IF THERE WAS AN OVERFLOW RECORD, BUT SOMETHING WAS WRONG       AFB0926
*        WITH THE POINTER TO IT, OR THE BACK-POINTER FROM IT,            AFB0926
*        CURPTR=4, BUT PTREEWRD[4] AND QMF BOTH = 0.                     AFB0926
*     WHEN FOLLOW IS CALLED WITH PTREEWRD[4] = 0, QMF = 1 BECAUSE WE     AFB0926
*     HAVE JUST LOCATED THE MAIN RECORD. SO IT IS ENOUGH TO TEST QMF     AFB0926
*     ON RETURN. IF UNCHANGED AT 1, ALL IS WELL. IF SET TO 0, FATAL FILE AFB0926
*     STRUCTURE ERROR. WHEN FOLLOW IS CALLED WITH PTREEWRD[4] NOT 0,     AFB0926
*     IT WILL DEFINITELY SET QMF TO 0 OR 1.                              AFB0926
*                                                                        AFB0926
* DC  ERROR CONDITIONS                                                   AFB0926
*                                                                        AFB0926
*     NONE THAT ARE CAUGHT HERE. IF FOLLOW IS CALLED WITH PTREEWRD[4]    AFB0926
*     =0, AND EXITS WITH QMF=0, IT INDICATES BAD STRUCTURE IN THE FILE.  AFB0926
*                                                                        AFB0926
* DC  CALLED ROUTINES                                                    AFB0926
*                                                                        AFB0926
*     RDBK$AK - TO READ IN OR LOCATE THE BLOCK CONTAINING THE            AFB0926
*       OVERFLOW RECORD.                                                 AFB0926
*     TRY4$AK - TO LOCATE THE OVERFLOW RECORD WITHIN THE BLOCK, AND      AFB0926
*       CHECK THE BACK-POINTER.                                          AFB0926
*                                                                        AFB0926
* DC  NON-LOCAL VARIABLES                                                AFB0926
*                                                                        AFB0926
*                                                                        AFB0926
*     ONLY THOSE MENTIONED UNDER ENTRY AND EXIT CONDITIONS ABOVE.        AFB0926
*                                                                        AFB0926
 #                                                                       AFB0926
          OUTKEY = 0 ;                                                   GAG0905
          IF PTREEWRD[4] EQ 0                                            GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              IF RPUCC NQ OVERFLOW                                       GAG0905
              THEN                                                       GAG0905
                  BEGIN                                                  GAG0905
                  RETURN ;                                               GAG0905
                  END                                                    GAG0905
              ELSE                                                       GAG0905
                  BEGIN                                                  GAG0905
                  PTREEWRD[4] = W[RECFWA] ;                              GAG0905
                  END                                                    GAG0905
              END                                                        GAG0905
          CURPTR = 4 ;                                                   GAG0905
          RDBK$AK ( 1 ) ;                                                GAG0905
          TRY4$AK ;                                                      GAG0905
          END                                                            GAG0905
CONTROL EJECT;                                                           GAG0905
PROC GET$AK;                                                             GAG0905
          BEGIN                                                          GAG0905
 #                                                                       GAG0905
* *       GET$AK                                 PAGE  1                 GAG0905
* *       PROGRAM - AK$AK                                                GAG0905
* *       R.P.NG.                               DATE.                    GAG0905
* 1CD     GET$AK                                                         GAG0905
*                                                                        GAG0905
* CD      FUNCTION                                                       GAG0905
*                                                                        GAG0905
*         TO PROCESS RANDOM ACCESS ON AK FILES.  THIS ROUTINE IS CALLED  GAG0905
*         BY THE AK EXECUTIVE SAAM$AK TO HANDLE THE ACCESS.  ALTHOUGH    GAG0905
*         AK PROPER DOES NOT SUPPORT START, GET$AK ALSO PROVIDES FOR     AFB0926
*         START ON A MIPPED AK FILE BY ALTERNATE KEY.                    GAG0905
*                                                                        GAG0905
* DC      ENTRY CONDITIONS.                                              GAG0905
*                                                                        GAG0905
*         P<FSTT$AA>, P<FIT$AA>, P<FIAT$AA> MUST ALL BE SET FOR THE      GAG0905
*         USER REQUEST.  FTCOP CONTAINS THE OP CODE, WHCIH CAN BE A      GAG0905
*         GET OR A START.                                                GAG0905
*                                                                        GAG0905
* CD      EXIT CONDITIONS.                                               GAG0905
*                                                                        GAG0905
*         A RECORD IS RETURNED IN THE USER WSA IF IT IS FOUND.           GAG0905
*         THE PTREE WILL BE SET UP TO REFLECT A VALID POSITION.          GAG0905
*         PTREEWRD[3] CONTAINS THIS POSITION, WHILE PTREEWRD[4] HAS      AFB0926
*         BEEN CLEARED TO 0. THIS IS TRUE EVEN IF THE CURRENT RECORD     AFB0926
*         IS AN OVERFLOW, FOR THE POSITION RESIDES IN THE MOTHER,        AFB0926
*         WHOSE POSITION IS IN PTREEWRD[3]. THE REASON PTREEWRD[4]       AFB0926
*         IS CAREFULLY CLEARED IS THAT WHEN LEFT NON-ZERO, THIS WORD     AFB0926
*         HAS A SPECIAL MEANING, THAT A GETNR OPERATION HAS ALREADY      AFB0926
*         LOCATED THE MOTHER RECORD AND COPIED THE OVERFLOW POINTER      AFB0926
*         TO PTREEWRD[4], BUT HAS NOT YET SEEN THE BLOCK THAT            AFB0926
*         POINTS TO. THE GETNEXT ROUTINE COULD USE THAT INFORMATION.     AFB0926
*         ONCE THE OVERFLOW RECORD HAS BEEN REALLY SEEN, ITS POSITION    AFB0926
*         IS UNINTERESTING AND PTREEWRD[4] IS ZEROED.                    AFB0926
*                                                                        GAG0905
* CD      ERROR CONDITIONS.                                              GAG0905
*                                                                        GAG0905
*         EC300 - NO READ PERMISSION ON FILE, DETECTED BY VOKG$AA.       GAG0905
*         EC445 - KEY NOT FOUND.  POSITION IS LONGER DEFINED BY PTREE.   GAG0905
*         EC506 - ALTERNATE KEY NOT FOUND (DETECTED BY GET$MP)           GAG0905
*         EC552 - INVALID OP CODE - START FOR AK.                        GAG0905
*         EC553 - FATAL MISMATCH IN OVERFLOW POINTER.                    AFB0926
*         EC546 - FATAL ERROR, MISMATCH BETWEEN MIP AND DATA FILE KEYS.  GAG0905
*            (REPORTED BY POSTGMP).                                      AFB0926
*                                                                        GAG0905
* CD      CALLED ROUTINES.                                               GAG0905
*                                                                        GAG0905
*         QUMP$AA - TEST IF MIP GET OR START                             AFB0926
*         MSGZ$AA AND MSGF$AA - TO PROCESS ERRORS                        AFB0926
*         GET$MP - MIP GET OR START                                      GAG0905
*         RDRC$AA - TO RETURN A RECORD TO USER.                          GAG0905
*         VOKG$AA - VALIDATE ACCESS REQUEST.                             GAG0905
*         POSTGMP - TO LOCATE THE RECORD, ONCE THE PRIMARY KEY           AFB0926
*           HAS BEEN DETERMINED.                                         AFB0926
*         LBK2$AK - TO LOCATE THE RECORD, STARTING FROM A PRIMARY KEY    AFB0926
*           SUPPLIED BY THE USER.                                        AFB0926
*         FOLLOW - ONCE THE RECORD HAS BEEN LOCATED, TO PURSUE THE       AFB0926
*           POSSIBILITY OF AN OVERFLOW RECORD.                           AFB0926
*         FILP$AK - TO SET FP STATUS.                                    AFB0926
*                                                                        GAG0905
* CD      DESCRIPTION                                                    GAG0905
*                                                                        GAG0905
*         FIRST CALL VOKG$AA TO ENSURE THAT WE ARE ALLOWED TO READ.      GAG0905
 #                                                                       GAG0905
          VOKG$AA;  #VERIFY OK TO GET#                                   GAG0905
 #                                                                       GAG0905
* 0       NEXT, IF THIS IS A GET BY ALTERNATE KEY, LETS CALL GET$MP      GAG0905
*         FIRST.  ON RETURN, FAPOSKEY3 CONTAINS THE AK LEFT JUSTIFIED.   GAG0905
*         IF THIS IS A START, IT IS ENOUGH TO HAVE RECORDED THE          AFB0926
*         PRIMARY KEY. BUT IF GET, CALL POSTGMP TO LOCATE THE            AFB0926
*         CORRESPONDING RECORD.                                          AFB0926
 #                                                                       GAG0905
          XFER = 0;  #CLEAR XFER FLAG FOR MIP#                           GAG1106
          PTREEWRD[4] = 0 ; #GTNR$AK COULD HAVE LEFT SOMETHING HERE#
          IF QUMP$AA(0) NQ 0
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              GET$MP;  #NOTE EC506 IS REPORTED BY GET$MP DIRECTLY#       GAG0905
              IF FTCOP[0] NQ OP"GET"                                     GAG0905
              THEN                                                       GAG0905
                  BEGIN                                                  GAG0905
                  RETURN ;                                               GAG0905
                  END                                                    GAG0905
              POSTGMP ;                                                  GAG0905
              END                                                        GAG0905
          ELSE                                                           GAG0905
 #                                                                       GAG0905
* O       IF MIP IS NOT INVOLVED, THEN WE SET UP DIRECTLY FOR THE DATA   GAG0905
*         FILE GET.  WE MUST NOW MAKE SURE THAT THE CURRENT OP IS NOT A  GAG0905
*         START.                                                         GAG0905
 #                                                                       GAG0905
              BEGIN                                                      GAG0905
              IF FTCOP EQ OP"STR"                                        GAG0905
              THEN                                                       GAG0905
                  BEGIN                                                  GAG0905
                  MSGZ$AA(EC245);  #INVALID OP# 
                  GOTO EXIT$AA;    #ERROR EXIT#                          GAG0905
                  END                                                    GAG0905
              ELSE                                                       GAG0905
                  BEGIN                                                  GAG0905
 #                                                                       GAG0905
* 0       ZERO FAPOSKEY1, TO MARK THAT THE POSITION WE ARE NOW           AFB0926
*         ESTABLISHING IS BY PRIMARY KEY. THEN CALL LBK2$AK, TO LOCATE   AFB0926
*         THE RECORD ACCORDING TO KA AND KP IN THE FIT. IF QMF IS 0      AFB0926
*         ON RETURN, THERE IS NO RECORD FOR THIS KEY AND WE HAVE A       AFB0926
*         TRIVIAL ERROR.                                                 AFB0926
 #                                                                       GAG0905
                  FAPOSKEY1 = 0;                                         GAG0905
                  CURPTR = 3;                                            GAG1106
                  LBK2$AK ;                                              GAG0905
                  IF QMF EQ 0                                            GAG0905
                  THEN                                                   GAG0905
                      BEGIN                                              GAG0905
                      IF QEI EQ 0 
                      THEN
                          BEGIN 
                          FILP$AK ( EOR ) ; 
                          END 
                      ELSE
                          BEGIN 
                          FILP$AK ( EOI ) ; 
                          END 
                      MSGZ$AA ( EC445 ) ;                                GAG0905
                      GOTO EXIT$AA ;                                     GAG0905
                      END                                                GAG0905
                  END                                                    GAG0905
              END                                                        GAG0905
 #                                                                       AFB0926
* 0       ONCE WE HAVE LOCATED THE RECORD CORRESPONDING TO THE           AFB0926
*         PRIMARY KEY, WE MUST CONSIDER THE POSSIBILITY THAT THAT        AFB0926
*         RECORD IS JUST A POINTER TO AN OVERFLOW RECORD SOMEWHERE       AFB0926
*         ELSE. SUBROUTINE FOLLOW DOES THIS, AND GOES TO THE OVERFLOW    AFB0926
*         RECORD IF THERE IS ONE. IF FOLLOW LEAVES QMF=0, IT MEANS, NOT  AFB0926
*         NO OVERFLOW, BUT THAT THERE WAS, AND WHAT SHOULD               AFB0926
*         HAVE BEEN THE OVERFLOW RECORD DID NOT CONTAIN A HEADER         AFB0926
*         POINTING BACK TO THE RECORD THAT POINTED TO IT. THIS IS A      AFB0926
*         FATAL FILE STRUCTURE ERROR.                                    AFB0926
 #                                                                       AFB0926
          FOLLOW ;                                                       GAG0905
          IF QMF EQ 0                                                    GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              MSGF$AA ( EC553 ) ;                                        GAG0905
              GOTO EXIT$AA ;                                             GAG0905
              END                                                        GAG0905
 #                                                                       AFB0926
* 0       HAVING REACHED THE REAL RECORD AT LAST, CALL RDRC$AA TO        AFB0926
*         COPY IT TO THE USER SPACE. SET PTREEWRD[4] = 0. THIS IS A      AFB0926
*         SIGN THAT THE CURRENT POSITION OF THE FILE, IF IT IS           AFB0926
*         POSITIONED BY PRIMARY KEY, IS AT THE ((END)) SO TO SPEAK       AFB0926
*         OF THE RECORD TO WHICH PTREEWRD[3] POINTS. PTREEWRD[4] IS      AFB0926
*         ONLY LEFT NON-ZERO SOMETIMES BY GTNR$AK.                       AFB0926
*         FINALLY, STEP THE COUNT OF GETS, AND CALL FILP$AK              AFB0926
*         TO SET THE FP STATUS TO EOR - BUT IF THE GET IS BY ALTERNATE
*         KEY, DONT, BECAUSE THE STATUS WAS SET IN GET$MP TO EOR OR EOK 
*         AS APPROPRIATE. 
 #                                                                       AFB0926
          RDRC$AA;  #RETURN RECORD#                                      GAG0905
          PTREEWRD[4] = 0 ;                                              GAG0905
          FSGETCNT = FSGETCNT + 1; #BUMP STAT COUNT#                     GAG0905
          IF FAPOSKEY1[0] EQ 0
          THEN
              BEGIN 
              FILP$AK ( EOR ) ; 
              END 
          END  #END GET$AK#                                              GAG0905
CONTROL EJECT;                                                           GAG0905
PROC GETN$AK;                                                            GAG0905
          BEGIN                                                          GAG0905
 #                                                                       GAG0905
* *       GETN$AK                                PAGE  1                 GAG0905
* *       PROGRAM - AK$AK                                                GAG0905
* *       R.P.NG.                               DATE.                    GAG0905
* 1CD     GETN$AK                                                        GAG0905
*                                                                        GAG0905
* CD      FUNCTION                                                       GAG0905
*                                                                        GAG0905
*         TO PROCESS SEQUENTIAL ACCESS ON AK FILES.  IT IS CALLED FROM   GAG0905
*         SAAM$AK.  THE NEXT LOGICAL, NOT PHYSICAL RECORD IS RETURNED.   GAG0905
*         (I.E. IF RECORDS CORRESPONDING TO KEY 1 AND 2 BOTH EXIST, THE  GAG0905
*         RECORD RETURNED BY GETN$AK AFTER GETTING 1 IS RECORD WITH KEY  GAG0905
*         2.  IF THE RECORD HAS OVERFLOWED, AK WILL GO OUT AND LOCATE IT GAG0905
*         ALSO.                                                          GAG0905
*                                                                        GAG0905
* CD      ENTRY CONDITIONS.                                              GAG0905
*                                                                        GAG0905
*         P<FSTT$AA>,P<FIT$AA>,P<FIAT$AA>,P<PTRE$AA> MUST ALL BE SET FOR GAG0905
*         THE USER REQUEST. IF PTREEWRD[4] IS NON-ZERO, THIS IS A GETN   AFB0926
*         TRYING TO FINISH UP A GETNR.                                   GAG0905
*                                                                        AFB1009
*         FTCOP[0] = OP"GTN".  THIS IS IMPORTANT WHEN RDRC$AA IS CALLED. GAG1025
*                                                                        GAG0905
* CD      EXIT CONDITIONS.                                               GAG0905
*                                                                        GAG0905
*         A RECORD IS RETURNED IN THE USER WSA IF IT IS FOUND.           GAG0905
*         THE KEY CORRESPONDING TO THE RECORD IS RETURNED IF KEY IS NON- GAG0905
*         EMBEDDED.                                                      GAG0905
*         PTREEWRD[4] = 0.                                               AFB0926
*                                                                        GAG0905
* CD      ERROR CONDITIONS.                                              GAG0905
*                                                                        GAG0905
*         EC300 - NO READ PERMISSION ON FILE, DETECTED BY VOKG$AA.       GAG0905
*         EC100 - PROCESSING BEYOND END OF FILE.                         GAG0905
*         EC546 - DATA AND MIP FILE MISMATCH - FATAL.                    GAG0905
*           (DETECTED BY POSTGMP)                                        AFB0926
*         EC553 - OVERFLOW RECORD NOT FOUND, FILE BAD.                   GAG0905
*                                                                        GAG0905
* CD      CALLED ROUTINES.                                               GAG0905
*                                                                        GAG0905
*         VOKG$AA - TO VERIFY GETN IS VALID.                             GAG0905
*         GETN$MP - TO HANDLE GETN BY ALTERNATE KEYS.                    GAG0905
*         MSGZ$AA AND MSGF$AA - ISSUE ERRORS                             AFB0926
*         RDRC$AA - TO READ THE DATA FILE                                GAG0905
*         STEP$AK - TO STEP FORWARD ONE LOGICAL RECORD, ACROSS BLOCK IF  GAG0905
*                   NECESSARY.                                           GAG0905
*         FILP$AK - SET FILE POSITION.                                   GAG0905
*         POSTGMP - TO LOCATE THE RECORD, AFTER THE PRIMARY KEY HAS      AFB0926
*           BEEN EXTRACTED FROM THE MIP FILE.                            AFB0926
*         FOLLOW - TO CONSIDER THE POSSIBILITY THAT THE RECORD MAY       AFB0926
*           POINT TO AN OVERFLOW RECORD, WHICH CONTAINS THE REAL         AFB0926
*           INFORMATION.                                                 AFB0926
*         SVKY$AK - TO STORE THE PRIMARY KEY OF THE CURRENT RECORD       AFB0926
*           IN THE FIAT, WHERE FAPKY3ADR[0] POINTS. THIS IS NEEDED       AFB0926
*           BECAUSE RDRC$AA WILL COPY THE KEY FROM THERE TO WHERE        AFB0926
*           KA IN THE FIT POINTS - THIS IS CALLED RETURNING THE          AFB0926
*           PRIMARY KEY TO THE USER. NOTE THAT IF POSITION IS BY         AFB0926
*           PRIMARY KEY, HOWEVER, WE DO NOT RELY ON THIS STORED KEY      AFB0926
*           VALUE BUT ON PTREEWRD[3] AND PTREEWRD[4] TO RECORD           AFB0926
*           POSITION.                                                    AFB0926
*                                                                        GAG0905
* CD      DESCRIPTIONS.                                                  GAG0905
*                                                                        GAG0905
*         FIRST CALL VOGK$AA TO ENSURE THAT WE ARE ALLOWED TO READ.      GAG0905
 #                                                                       GAG0905
          VOKG$AA;  #VERIFY OK TO GETN#                                  GAG0905
 #                                                                       GAG0905
*         NEXT, IF THE FILE IS POSITIONED AT EOI, WE WILL RETURN WITH    GAG0905
*         ERROR EC100.                                                   GAG0905
 #                                                                       GAG0905
          IF FAFP EQ EOI OR FSPUTCNT EQ 0 
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              FTFP = EOI;                                                GAG0905
              MSGZ$AA(EC100);                                            GAG0905
              GOTO EXIT$AA;  #ERROR EXIT#                                GAG0905
              END                                                        GAG0905
 #                                                                       GAG0905
*         IF FAPOSKEY1 IS NON-ZERO, WE ARE POSITIONED ON THE MIP FILE,   GAG0905
*         SO CALL GETN$MP TO GET THE CORRESPONDING PRIMARY KEY.  ON      GAG0905
*         RETURN, CALL POSTGMP TO LOCATE THE RECORD IN THE DATA          AFB0926
*         FILE.                                                          AFB0926
 #                                                                       GAG0905
          IF FAPOSKEY1 NQ 0 #MIP GETN#                                   GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              GETN$MP;                                                   GAG0905
              POSTGMP ;                                                  GAG0905
              GOTO GN2 ;                                                 GAG0905
              END                                                        GAG0905
          ELSE                                                           GAG0905
              BEGIN                                                      GAG0905
 #                                                                       GAG0905
*         IF NO MIP, POSSIBLY PTREEWRD[4] IS NOT 0, WHICH                AFB0926
*         INDICATES THAT WE HAVE STARTED UP A GETNR IN THE PAST, AND WE  GAG0905
*         HAVE BEEN TRYING TO LOCATE AN ALIEN.  THE THING TO DO HERE IS  GAG0905
*         TO CHECK ON THAT POSITION.  IF POSITION HAS NOT BEEN DISTURBED GAG0905
*         BY INTERVENING UPDATES, WE ARE READY. AN INTERVENING UPDATE    AFB0926
*         MIGHT OR MIGHT NOT HAVE DISTURBED THE POSITION.  WE VERIFY     GAG0905
*         THAT BY READING UP THE ALIEN, AND COMPARE IT TO THE PTREE 3    GAG0905
*         POSITION.  IF THEY MATCH, THIS IS THE RECORD WE NEED. IF NOT,  GAG0905
*         WE HAVE TO FALL BACK ON THE POSITION SAVED IN PTREEWRD[3],     AFB0926
*         MINUS 1. THE RULE FOR POSITION BY PRIMARY KEY IS THAT WHEN     AFB0926
*         PTREEWRD[4] IS LEFT 0, WE ARE AT THE ((END))                   AFB0926
*         OF THE RECORD PTREEWRD[3] POINTS TO. BUT IF                    AFB0926
*         PTREEWRD[4] IS LEFT NON-ZERO, WHICH IS ONLY DONE BY GTNR$AK,   AFB0926
*         WE ARE AT THE ((BEGINNING)) OF THE RECORD PTREEWRD[3] POINTS   AFB0926
*         TO, BECAUSE IT POINTS TO A POINTER WHICH HAS BEEN COPIED TO    AFB0926
*         PTREEWRD[4], WHICH POINTS TO THE ACTUAL RECORD, BUT THAT       AFB0926
*         RECORD HAS NOT BEEN READ YET. GETN$AK IS GEARED TO THE FORMER  AFB0926
*         CASE, SO WHEN THE LATTER CASE CROPS UP, WE MUST REDUCE THE     AFB0926
*         RECORD NUMBER IN PTREEWRD[3] BY 1 SO THAT STEP$AK WILL BRING   AFB0926
*         US UP TO THE SAME RECORD AGAIN. NOTE THAT THIS WILL WORK ALL   AFB0926
*         RIGHT EVEN IF WE REDUCE THE RECORD NUMBER TO 0, OR TO THE      AFB0926
*         NUMBER OF A DEAD RECORD.                                       AFB0926
 #                                                                       GAG0905
              IF PTREEWRD[4] NQ 0                                        GAG0905
              THEN                                                       GAG0905
                  BEGIN                                                  GAG0905
                  FOLLOW ;                                               GAG0905
                  IF QMF NQ 0                                            GAG0905
                  THEN                                                   GAG0905
                      BEGIN                                              GAG0905
                      GOTO START3;                                       GAG0905
                      END                                                GAG0905
                  ELSE                                                   GAG0905
                      BEGIN                                              GAG0905
                      PTCUREC[3] = PTCUREC[3] - 1 ;                      GAG0905
                      END                                                GAG0905
                  END                                                    GAG0905
              CURPTR = 3;                                                GAG0905
              STEP$AK(1);  #STEP TO FIRST LIVE RECORD#                   GAG0905
 #                                                                       AFB0926
* 0       NOW WE HAVE LOCATED THE NEXT RECORD IN THE DATA FILE           AFB0926
*         --UNLESS QEI=1, INDICATING EOI. NOW CALL FOLLOW TO HANDLE      AFB0926
*         THE POSSIBILITY THAT THE RECORD MERELY POINTS TO AN OVERFLOW   AFB0926
*         RECORD SOMEWHERE ELSE. QMF=0 ON RETURN COULD MEAN              AFB0926
*         TWO THINGS (1) THERE WAS AN OVERFLOW POINTER, WHICH WAS        AFB0926
*         FOLLOWED, BUT THE RECORD AT THE OTHER END DID NOT POINT        AFB0926
*         BACK CORRECTLY -- A FATAL FILE STRUCTURE ERROR (2) THERE       AFB0926
*         WAS NO OVERFLOW POINTER, AND FOLLOW LEFT EVERYTHING,           AFB0926
*         INCLUDING QMF, UNCHANGED. SO SET QMF=1 BEFORE CALLING          AFB0926
*         FOLLOW SO THAT QMF=0 AFTERWARDS WILL BE DEFINITE.              AFB0926
 #                                                                       AFB0926
GN2:                                                                     GAG0905
              IF QEI EQ 0  #NOT EOI#                                     GAG0905
              THEN                                                       GAG0905
                  BEGIN                                                  GAG0905
                  QMF = 1 ;                                              GAG0905
                  FOLLOW ;                                               GAG0905
                  IF QMF EQ 0                                            GAG0905
                  THEN                                                   GAG0905
                      BEGIN                                              GAG0905
                      MSGF$AA ( EC553 ) ;                                GAG0905
                      GOTO EXIT$AA ;                                     GAG0905
                      END                                                GAG0905
                  IF FAPOSKEY1 [0] EQ 0                                  GAG1121
                  THEN                                                   GAG1121
                      BEGIN                                              GAG1121
                      FILP$AK ( EOR ) ;                                  GAG1121
                      END                                                GAG1121
                  END                                                    GAG0905
              END                                                        GAG0905
 #                                                                       GAG0905
*         IF QEI IS 1, WE DONT RETURN A RECORD, BUT JUST CALL            AFB0926
*         FILP$AK TO SET THE FP STATUS.                                  AFB0926
*         OTHERWISE, WE ARE AT START3 TO RETURN THE RECORD TO THE        AFB0926
*         USER. WE ALSO SKIPPED TO START3 IF PTREEWRD[4] WAS NOT         AFB0926
*         0 ON ENTRY TO GETN$AK, AND WE IMMEDIATELY FOUND THE            AFB0926
*         WANTED RECORD, WHICH POINTED BACK CORRECTLY TO ITS             AFB0926
*         MOTHER.                                                        AFB0926
*                                                                        AFB0926
*         BEFORE CALLING RDRC$AA TO RETURN THE RECORD TO THE USER,       AFB0926
*         WE MUST CALL SVKY$AK TO COPY THE PRIMARY KEY VALUE TO THE      AFB0926
*         FIAT AREA POINTED TO BY FAPKY3ADR[0]. IF POSITION IS BY        AFB0926
*         PRIMARY KEY, PTREEWRD[3] AND PTREEWRD[4] ARE USED TO KEEP      AFB0926
*         TRACK OF IT. BUT RDRC$AA NEEDS TO FIND THE PRIMARY KEY         AFB0926
*         VALUE WHERE FAPKY3ADR[0] POINTS, IN ORDER TO RETURN IT         AFB0926
*         TO THE USER AS PART OF A GETNEXT. AFTER CALLING RDRC$AA, STEP  AFB0926
*         THE GETNEXT COUNT, THEN ZERO PTREEWRD[4] IN CASE -- ACTUALLY   AFB0926
*         IF IT WAS NON-ZERO ON ENTRY TO GETN$AK, WE WOULD HAVE          AFB0926
*         CALLED FOLLOW, WHICH MUST HAVE LEFT IT 0. BUT HERE WE          AFB0926
*         CLEAR IT AGAIN TO BE SURE. PTREEWRD[4]=0, AS EXPLAINED         AFB0926
*         ABOVE, INDICATES WE ARE AT THE ((END)) OF THE RECORD           AFB0926
*         PTREEWRD[3] POINTS TO, IF POSITION IS BEING MAINTAINED         AFB0926
*         BY PRIMARY KEY.                                                AFB0926
 #                                                                       GAG0905
          IF QEI EQ 1  #POSITIONED AT EOI#                               GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              FILP$AK(EOI);                                              GAG0905
              MSGZ$AA ( NOTE011 ) ;                                      AFB0926
              END                                                        GAG0905
          ELSE                                                           GAG0905
              BEGIN                                                      GAG0905
START3:                                                                  GAG0905
              SVKY$AK ;                                                  GAG0905
              RDRC$AA;                                                   GAG0905
              FSGTNCNT = FSGTNCNT + 1;                                   GAG0905
              PTREEWRD[4] = 0 ;                                          GAG0905
              END                                                        GAG0905
          END  #END GETN$AK#                                             GAG0905
CONTROL EJECT;                                                           GAG0905
PROC GTNR$AK;                                                            GAG0905
          BEGIN  #GTNR$AK CODE#                                          GAG0905
 #                                                                       AFB0926
* *   GTNR$AK - GETNEXT WITHOUT RECALL - AK        PAGE 1                AFB0926
* *   G.A.GREEN + A.F.BROWN                                              AFB0926
* 1DC GTNR$AK                                                            AFB0926
*                                                                        AFB0926
* DC  FUNCTION                                                           AFB0926
*                                                                        AFB0926
*     TO DO A GETNEXT WITHOUT RECALL. THIS MEANS MOVING TOWARD           AFB0926
*     ACCOMPLISHING A GETNEXT. BUT AS SOON AS AN I-O HAS TO BE           AFB0926
*     DONE, IT IS BEGUN WITHOUT RECALL, AND CONTROL RETURNS TO           AFB0926
*     THE USER WITH FP=0. WHEN THE LAST STEP OF THE GETNEXT CAN          AFB0926
*     BE TAKEN WITHOUT I-O, WE DO IT, SET FP TO EOR, AND ALTER           AFB0926
*     THE OP CODES IN THE FIT FROM GTNR TO GETN. NOTE THE                AFB0926
*     DIFFERENCE BETWEEN THIS AND SEEKING.                               AFB0926
*                                                                        AFB0926
* DC  ENTRY CONDITIONS                                                   AFB0926
*                                                                        AFB0926
*     THE SAME AS FOR GETN$AK.                                           AFB0926
*                                                                        AFB0926
* DC  EXIT CONDITIONS                                                    AFB0926
*                                                                        AFB0926
*     IF THE OPERATION COMPLETES, THE EXIT CONDITIONS ARE THE            AFB0926
*     SAME AS FOR GETN$AK. THIS IS WHEN FP = EOR OR EOK OR EOI.          AFB0926
*     BUT IF FP = 0, THE OPERATION HAS NOT COMPLETED, BECAUSE            AFB0926
*     I-O HAS BEEN NECESSARY. IF THE CURRENT POSITION IS BY              AFB0926
*     ALTERNATE KEY, THE EXIT CONDITIONS ARE THEN QUITE COMPLI-          AFB0926
*     CATED, AND THE READER SHOULD LOOK AT THE COMMENTS TO               AFB0926
*     SUBROUTINE GTNR$IS FOR A LONG EXPLANATION. IF THE CURRENT          AFB0926
*     POSITION IS BY PRIMARY KEY, IT IS RECORDED IN PTREEWRD[3]          AFB0926
*     AND PTREEWRD[4] ON ONE OF THE FOLLOWING MODELS --                  AFB0926
*     (1) FAFP[0] IN THE FIAT, WHICH IS A COPY OF THE LAST FP            AFB0926
*     WE STORED IN THE FIT, =EOI. THIS OVERRIDES THE PTREEWRDS           AFB0926
*     AND PUTS US AT EOI. OTHERWISE --                                   AFB0926
*     (2) BOTH PTREEWRD[3] AND PTREEWRD[4] ARE 0. THE FILE IS            AFB0926
*     REWOUND.                                                           AFB0926
*     (3) PTREEWRD[4] IS 0, BUT PTREEWRD[3] CONTAINS A BLOCK             AFB0926
*     AND RECORD NUMBER,OR A BLOCK ADDRESS AND RECORD NUMBER.            AFB0926
*     WE WANT THE RECORD NEXT AFTER THAT ONE. THE RECORD NUMBER          AFB0926
*     MAY BE 0 OR BE THE NUMBER OF A DEAD RECORD. EITHER OF              AFB0926
*     THESE IS EASY TO STEP FORWARD FROM, TO THE WANTED RECORD.          AFB0926
*     (4) BOTH WORDS ARE NON-ZERO. WE ARE LOGICALLY POSITIONED           AFB0926
*     AT THE START OF A NEW RECORD, TO WHICH PTREEWRD[3]                 AFB0926
*     POINTS. BUT THIS RECORD IS A POINTER TO AN OVERFLOW RECORD         AFB0926
*     AND HAS BEEN COPIED INTO PTREEWRD[4]. OUR TASK IS TO GET           AFB0926
*     THE RECORD PTREEWRD[4] POINTS TO AND THEN ZERO PTREEWRD[4].        AFB0926
*     WHETHER THAT WILL BE ACHIEVED ON THIS TRY DEPENDS ON               AFB0926
*     WHETHER THE BLOCK PTREEWRD[4] POINTS TO HAS ALREADY BEEN           AFB0926
*     COMPLETELY READ INTO CORE.                                         AFB0926
*                                                                        AFB0926
* DC  ERROR CONDITIONS                                                   AFB0926
*                                                                        AFB0926
*     EC100 - WE WERE ALREADY AT EOI.                                    AFB0926
*     EC546 - WE GOT A PRIMARY KEY VALUE OUT OF THE MIP FILE,            AFB0926
*      BUT IT DID NOT POINT TO A LIVE RECORD IN THE DATA FILE.           AFB0926
*                                                                        AFB0926
* DC  CALLED ROUTINES                                                    AFB0926
*                                                                        AFB0926
*     MSGZ$AA - TO ISSUE NON-FATAL ERRORS.                               AFB0926
*     MSGF$AA - TO ISSUE FATAL ERRORS.                                   AFB0926
*     GETN$AK - TO DO ALL THE WORK, WITHOUT WORRYING ABOUT               AFB0926
*        OVERLAPPING I-O, WHEN THE LAST POSITIONING OPERATION            AFB0926
*        ON THIS FILE WAS A REWIND, AND IT FOUND THE FILE                AFB0926
*        EMPTY. SOME RECORDS MAY HAVE BEEN ADDED SINCE THEN,             AFB0926
*        AND THE SITUATION IS A LITTLE OBSCURE SO WE JUST                AFB0926
*        CALL GETN$AK TO DO THE WHOLE THING.                             AFB0926
*     GTNR$MP - TO DO ALL THE MIP WORK, IF POSITION IS BY                AFB0926
*       ALTERNATE KEY.                                                   AFB0926
*     KEYGO - TO BREAK UP A PRIMARY KEY VALUE, RETURNED BY               AFB0926
*       GTNR$MP, INTO A BLOCK AND RECORD NUMBER.                         AFB0926
*     RDBK$AK - TO LOCATE OR READ IN A BLOCK.                            AFB0926
*     CUR2$AK - TO LOCATE A RECORD BY NUMBER IN A BLOCK, BUT             AFB0926
*       CHECKING TO SEE THE NUMBER IS VALID.                             AFB0926
*     STEP$AK - TO STEP FORWARD ONE LIVE RECORD IN THE AK FILE.          AFB0926
*     FILP$AK - TO SET FP STATUS IN THE FIT.                             AFB0926
*     TRY4$AK - TO LOCATE AN OVERFLOW RECORD ONCE ITS BLOCK IS IN        AFB0926
*       CORE, AND CHECK ITS BACKPOINTER.                                 AFB0926
*     SVKY$AK - TO CONVERT THE CURRENT POSITION INTO A PRIMARY           AFB0926
*       KEY VALUE AND STORE IT IN THE FIAT WORD TO WHICH                 AFB0926
*       FAPKY3ADR[0] POINTS, FROM WHICH SUBROUTINE RDRC$AA WILL          AFB0926
*       RETURN IT TO THE CALLER.                                         AFB0926
*     RDRC$AA - TO RETURN THE RECORD AND POSSIBLY A KEY VALUE TO
*       THE USER, ONCE THE RECORD HAS BEEN FINALLY LOCATED. 
*     MOVC$AA - TO RETURN THE PRIMARY KEY VALUE TO THE USER, IF 
*       ACCESS IS BY ALTERNATE KEY AND PKA IS NOT ZERO. 
*                                                                        AFB0926
* DC  NON-LOCAL VARIABLES                                                AFB0926
*                                                                        AFB0926
*     COND - SET AS A RESULT VARIABLE BY GTNR$MP. FOR ITS                AFB0926
*       MEANINGS, SEE THE COMMENTS TO THAT ROUTINE.                      AFB0926
*     QMF - SET BY CUR2$AK OR TRY4$AK TO 1 IF THERE IS A LIVE            AFB0926
*       RECORD AT THE GIVEN POSITION, AND 0 IF NOT.                      AFB0926
*     RECFWA - SET BY ANY ROUTINE THAT LOCATES A RECORD, LIKE            AFB0926
*       CUR2$AK, TO THE FWA OF THE RECORD.                               AFB0926
*     FAIL - SET BY STEP$AK TO 0 IF IT SUCCESSFULLY ADVANCED TO          AFB0926
*       THE NEXT LIVE RECORD, AND TO 1 IF NOT (EITHER BECAUSE            AFB0926
*       EOI WAS REACHED, OR BECAUSE WE HAD TO READ THE NEXT              AFB0926
*       BLOCK WITHOUT RECALL, AND THE READ IS NOT COMPLETE.)             AFB0926
*     OUTKEY - SET BY TRY4$AK TO 1 WHEN AN OVERFLOW RECORD IS            AFB0926
*       SUCCESSFULLY LOCATED.                                            AFB0926
*                                                                        AFB0926
* DC  NARRATIVE                                                          AFB0926
*                                                                        AFB0926
*     IF FAFP = EOI, WE ARE ALREADY AT EOI, AND AN ATTEMPT TO            AFB0926
*     TO GETNEXT IS AN ERROR. IF FAFP = 63, IT MEANS THAT THE            AFB0926
*     LAST TIME POSITION WAS ESTABLISHED, IT WAS BY A REWIND             AFB0926
*     AND THE FILE WAS EMPTY. IN THAT CASE SWITCH TO A GETNEXT.          AFB0926
*     (THIS IS NOT A DISTORTION, BECAUSE ONCE A GTNR GOES TO             AFB0926
*     COMPLETION IT TURNS INTO A GETNEXT ANYWAY. WE ARE JUST             AFB0926
*     MAKING SURE COMPLETION COMES RIGHT AWAY INSTEAD OF                 AFB0926
*     REQUIRING ADDITIONAL GTNR CALLS.)                                  AFB0926
*                                                                        AFB0926
*     SET OUTKEY=0. THIS IS AN INITIALIZATION FOR THE GENERAL            AFB0926
*     CASE THAT THE RECORD HAS NO PREFIX. IF IT HAS, TRY4$AK             AFB0926
*     WILL SET OUTKEY=1, INSTRUCTING RDRC$AA TO DROP ONE WORD            AFB0926
*     WHEN RETURNING THE RECORD TO THE CALLER.                           AFB0926
 #                                                                       AFB0926
          IF FAFP[0] EQ EOI OR FSPUTCNT EQ 0
          THEN                                                           GAG0905
              BEGIN  #FILE POSITIONED AT EOI#                            GAG0905
              FTFP[0] = EOI;                                             GAG0905
              MSGZ$AA(EC100);  #EOI ENCOUNTERED#                         GAG0905
              GOTO EXIT$AA;                                              GAG0905
              END                                                        GAG0905
          IF FAFP[0] EQ 63                                               GAG0905
          THEN                                                           GAG0905
              BEGIN  #AFTER A REWIND, FILE WAS DISCOVERED EMPTY#         GAG0905
NOHOPE:                                                                  GAG0905
              FTCOP[0] = OP"GTN";                                        GAG0905
              FTPOP[0] = OP"GTN";                                        GAG0905
              GETN$AK;                                                   GAG0905
              RETURN;                                                    GAG0905
              END                                                        GAG0905
          OUTKEY = 0 ;                                                   AFB0926
 #                                                                       AFB0926
*     OTHERWISE SEE IF CURRENT POSITION IS SET BY PRIMARY OR             AFB0926
*     BY ALTERNATE KEY. IF BY ALTERNATE, CALL GTNR$MP TO DO              AFB0926
*     MOST OF THE WORK. COND TELLS THE RESULT. REFER TO THE              AFB0926
*     NOTES ON GTNR$IS FOR DETAILS. IF COND=100, WE ARE                  AFB0926
*     POSITIONED IN A FIFO LIST OF PRIMARY KEY VALUES, ALL               AFB0926
*     RELATING TO ONE ALTERNATE KEY VALUE. AS THIS IS A FOOLISH          AFB0926
*     FILE ORGANIZATION, WE HOPE IT IS RARE, AND AVOID HAVING            AFB0926
*     TO PUT IN THE EXTRA CODE FOR HANDLING GTNR IN IT, BY               AFB0926
*     SIMPLY BRANCHING TO NOHOPE AND TREATING THE GTNR AS A              AFB0926
*     GETNEXT. IF COND .LQ. 6, GTNR$MP HAS NOT FINISHED LOOKING AT       AFB0926
*     THE MIP FILE YET, AND WE CAN DO NOTHING FURTHER ON THIS CALL.      AFB0926
*     IF COND=8, WE ARE AT EOI. IF COND = 7, GTNR$MP HAS                 AFB0926
*     JUST DETERMINED THE PRIMARY KEY VALUE, WE ADVANCE MPSKSTG          AFB0926
*     (WHICH IS SET THE SAME AS COND BY GTNR$MP, AND WHICH               AFB0926
*     GTNR$MP LOOKS AT WHEN ENTERED, TO SEE WHAT STAGE WE ARE            AFB0926
*     AT) TO 9, SHOWING THAT THE PRIMARY KEY IS NOW KNOWN, BUT           AFB0926
*     NOT FOR THE FIRST TIME, AND CALL KEYGO TO CONVERT THE              AFB0926
*     KEY VALUE TO A BLOCK AND SLOT NUMBER, AND FILL THEM INTO           AFB0926
*     THE CURRENT WORD OF THE PTREE, PTREEWRD[3].                        AFB0926
*     CLEAR PTREEWRD[4], INDICATING THAT WE DONT KNOW ANYTHING           AFB0926
*     ABOUT OVERFLOW AS YET.                                             AFB0926
 #                                                                       AFB0926
          IF FAPOSKEY1[0] NQ 0                                           GAG0905
          THEN                                                           GAG0905
              BEGIN  #MIP IS INVOLVED#                                   GAG0905
              GTNR$MP;  #DO THE MIP GETNR#                               GAG0905
              IF COND EQ 100
              THEN
                  BEGIN 
                  MIPMODE = 0;
                  P<FSTT$AA> = FTFSTT[0]; 
                  GOTO NOHOPE;        #FIFO STRUCTURE#
                  END 
              IF COND LQ 6 THEN GOTO FAILURE; #MIP NOT COMPLETED#        GAG0905
              IF COND EQ 8 THEN GOTO GOTEOI;  #MIP GOT EOI#              GAG0905
              IF COND EQ 7                                               GAG0905
              THEN                                                       GAG0905
                  BEGIN  #MIP FOUND A PRIMARY KEY#                       GAG0905
                  MPSKSTG = 9;  #LET MIP KNOW HE DID THE WORK#           GAG0905
                  CURPTR = 3 ;                                           AFB0926
                  KEYGO ( FAPKY3ADR[0] , 0 ) ;                           GAG0905
                  PTREEWRD[4] = 0 ;                                      AFB0926
                  END                                                    GAG0905
              ELSE                                                       GAG0905
                  BEGIN                                                  GAG0905
 #                                                                       AFB0926
*     IF COND IS NONE OF THE ABOVE IT MUST BE 9,                         AFB0926
*     SHOWING THAT OUR POSITION IN THE DATA FILE HAS                     AFB0926
*     ALREADY, ON A PREVIOUS GTNR CALL, BEEN RECORDED IN                 AFB0926
*     PTREEWRD[3], AND THE ONLY INTERESTING POSSIBILITY IS               AFB0926
*     WHETHER PTREEWRD[4] IS NON-ZERO. IF SO, PTREEWRD[3]                AFB0926
*     ALREADY POINTS TO THE NEXT RECORD, BUT IT IS A MERE PLACE-         AFB0926
*     HOLDER POINTING TO AN OVERFLOW RECORD. PTREEWRD[4] THEN            AFB0926
*     POINTS TO THAT OVERFLOW RECORD, AND WE SKIP TO OVFREC              AFB0926
*     TO LOOK AT IT.                                                     AFB0926
 #                                                                       AFB0926
                  IF PTREEWRD[4] NQ 0                                    GAG0905
                  THEN                                                   GAG0905
                      BEGIN                                              GAG0905
                      GOTO OVFREC;                                       GAG0905
                      END                                                GAG0905
                  END                                                    GAG0905
 #                                                                       AFB0926
*     IF NO OVERFLOW POINTER, WE HAVE THE POINTER TO THE                 AFB0926
*     WANTED RECORD IN                                                   AFB0926
*     PTREEWRD[3]. CALL RDBK$AK TO LOCATE THE BLOCK, BUT                 AFB0926
*     WITHOUT RECALL. IF PTBLKIN[3]=0 ON RETURN, THE BLOCK IS            AFB0926
*     NOT YET READY IN CORE, SO GO TO FAILURE TO SET FP=0                AFB0926
*     AND RETURN TO THE USER. BUT IF THE BLOCK IS IN CORE,               AFB0926
*     CALL CUR2$AK TO LOCATE THE RECORD. THIS SUBROUTINE HAS             AFB0926
*     A SAFEGUARD AGAINST A TOO-HIGH RECORD NUMBER -- IF THE             AFB0926
*     MIP FILE IS BAD AND YIELDS SUCH A NUMBER, WE MIGHT                 AFB0926
*     ABORT OTHERWISE. IF CUR2$AK LEAVES QMF=0, THAT IS WHAT             AFB0926
*     HAS HAPPENED, AND WE ISSUE A FATAL ERROR. OTHERWISE,               AFB0926
*     WE NOW HAVE A LIVE RECORD, WHICH MAY BE A SIMPLE RECORD            AFB0926
*     OR AN OVERFLOW POINTER (PLACEHOLDER, MOTHER). IF THE               AFB0926
*     FORMER, ALL SET, GO TO SUCCESS. ELSE WE HAVE TO TAKE A             AFB0926
*     SECOND STEP. COPY THE POINTER INTO PTREEWRD[4] AND SKIP            AFB0926
*     TO OVFREC TO START FINDING THE OVERFLOW RECORD.                    AFB0926
 #                                                                       AFB0926
              CURPTR = 3;                                                GAG0905
              RDBK$AK(0);  #GO READ THE BLOCK INTO CORE/WITHOUT RECALL#  GAG0905
              IF PTBLKIN[3] NQ 1                                         GAG0905
              THEN                                                       GAG0905
                  BEGIN  #THE BLOCK HAS NOT YET BEEN READ IN#            GAG0905
                  GOTO FAILURE;                                          GAG0905
                  END                                                    GAG0905
              ELSE                                                       GAG0905
                  BEGIN  #THE BLOCK IS IN CORE#                          GAG0905
                  CUR2$AK ;                                              GAG0905
                  IF QMF EQ 0                                            GAG0905
                  THEN                                                   GAG0905
                      BEGIN  #THE RECORD COULD NOT BE LOCATED#           GAG0905
                      MSGF$AA(EC546);  #PRIMARY KEY NOT FOUND#           GAG0905
                      GOTO EXIT$AA;                                      GAG0905
                      END                                                GAG0905
                  IF UCCFIELD NQ OVERFLOW                                GAG0905
                  THEN                                                   GAG0905
                      BEGIN  #DELIVER THE RECORD#                        GAG0905
                      GOTO SUCCESS;                                      GAG0905
                      END                                                GAG0905
                  ELSE                                                   GAG0905
                      BEGIN  #THE RECORD HAS OVERFLOWED#                 GAG0905
                      PTREEWRD[4] = W[RECFWA];                           GAG0905
                      GOTO OVFREC;                                       GAG0905
                      END                                                GAG0905
                  END  #OF BLOCK IS IN CORE CONDITIONAL#                 GAG0905
              END  #OF MIP CASE#                                         GAG0905
          ELSE                                                           GAG0905
              BEGIN  #NON-MIP CASE#                                      GAG0905
 #                                                                       AFB0926
*     IF POSITION IS BY PRIMARY KEY, THEN EITHER PTREEWRD[3] POINTS      AFB0926
*     TO THE WANTED RECORD, WHICH HAS OVERFLOWED, AND PTREEWRD[4]        AFB0926
*     POINTS TO THE OVERFLOW RECORD WE REALLY HAVE TO READ, OR ELSE      AFB0926
*     PTREEWRD[4] IS 0 AND PTREEWRD[3] POINTS TO THE RECORD WHOSE        AFB0926
*     SUCCESSOR WE NEED. IN THE LATTER CASE, CALL STEP$AK TO MOVE        AFB0926
*     TO THE NEXT LIVE RECORD WITHOUT RECALL. IF FAIL=0 ON EXIT,         AFB0926
*     WE HAVE THE WANTED RECORD, BUT IS IT A MERE PLACEHOLDER.           AFB0926
*     IF NOT, GO TO SUCCESS TO SEND IT TO THE USER. BUT IF YES,          AFB0926
*     COPY THE POINTER INTO PTREEWRD[4] AND DROP THROUGH TO OVFREC,      AFB0926
*     WHERE WE LOOK FOR OVERFLOW RECORDS.                                AFB0926
*                                                                        AFB0926
*     IF STEP$AK LEAVES FAIL NON-ZERO, IT COULD BE EITHER BECAUSE        AFB0926
*     WE WE HAVE ARRIVED AT EOI, OR BECAUSE WE ARE WAITING FOR           AFB0926
*     A READ TO COMPLETE. IF EOI, CALL FILP$AK TO SET FP IN THE FIT      AFB0926
*     TO THAT STATUS. IF WAITING, CALL IT SO SET FP=0. THEN EXIT.        AFB0926
 #                                                                       AFB0926
              IF PTREEWRD[4] EQ 0                                        GAG0905
              THEN                                                       GAG0905
                  BEGIN  #GETNR NOT PREVIOUSLY ISSUED#                   GAG0905
READIT:                                                                  GAG0905
                  STEP$AK(0);  #STEP FWD 1 LIVE RECORD/WITHOUT RECALL#   GAG0905
                  IF FAIL EQ 0                                           GAG0905
                  THEN                                                   GAG0905
                      BEGIN  #RECORD WAS POSITIONED BY STEP$AK#          GAG0905
                      IF UCCFIELD NQ OVERFLOW                            GAG0905
                      THEN                                               GAG0905
                          BEGIN  #DELIVER THE NATIVE RECORD#             GAG0905
                          GOTO SUCCESS;                                  GAG0905
                          END                                            GAG0905
                      ELSE                                               GAG0905
                          BEGIN  #ADVANCE TO OVERFLOW BLOCK#             GAG0905
                          PTREEWRD[4] = W[RECFWA];                       GAG0905
                          END                                            GAG0905
                      END  #OF RECORD WAS POSITIONED CASE#               GAG0905
                  ELSE                                                   GAG0905
                      BEGIN  #RECORD WAS NOT POSITIONED BY STEP$AK#      GAG0905
                      IF QEI NQ 0                                        GAG0905
                      THEN                                               GAG0905
GOTEOI:  #GETNR ENCOUNTERED END OF INFORMATION#                          GAG0905
                          BEGIN                                          GAG0905
                          FILP$AK(EOI);                                  GAG0905
                          END                                            GAG0905
                      ELSE                                               GAG0905
FAILURE:  #GETNR NOT READY TO RETURN THE REQUESTED RECORD TO THE USER#   GAG0905
                          BEGIN                                          GAG0905
                          FILP$AK(FPNULL);                               GAG0905
                          END                                            GAG0905
                      RETURN;                                            GAG0905
                      END  #OF RECORD WAS NOT POSITIONED CASE#           GAG0905
                  END  #OF GETNR NOT PREVIOUSLY ISSUED CASE#             GAG0905
              END  #OF THE EXCLUSIVELY NON-MIP CASE#                     GAG0905
                                                                         GAG0905
 #                                                                       AFB0926
*     WHEN WE HAVE AN OVERFLOW POINTER IN PTREEWRD[4], WE COME TO        AFB0926
*     OVFREC, AND CALL RDBK$AK TO LOCATE THE BLOCK WITHOUT RECALL.       AFB0926
*     IF PTBLKIN[4]=0 ON RETURN, THE BLOCK IS NOT YET READY IN           AFB0926
*     CORE, SO JUMP TO FAILURE. IF PTBLKIN[4]=1 WE SHOULD BE             AFB0926
*     FINISHED -- BUT THERE IS A POSSIBILITY THAT BETWEEN THE TIME       AFB0926
*     PTREEWRD[4] WAS SET, AND NOW, THE RECORD HAS BEEN DELETED OR       AFB0926
*     REPLACED, OR THE OVERFLOW RECORD HAS BEEN MOVED. SO WE CALL        AFB0926
*     TRY4$AK TO LOCATE THE OVERFLOW RECORD AND VERIFY THAT IT HAS       AFB0926
*     A BACK POINTER TO THE SAME RECORD PTREEWRD[3] POINTS TO.           AFB0926
*     IF TRY4$AK LEAVES QMF=1, ALL IS WELL AND WE GO ON TO SUCCESS.      AFB0926
*     BUT IF QMF=0, PTREEWRD[4] WAS MISLEADING.                          AFB0926
*     NOW A BAD PTREEWRD[4] IS NOT AN ERROR WHEN POSITION IS             AFB0926
*     BY PRIMARY KEY, BECAUSE WE HAVE NO OTHER WAY OF DETECTING          AFB0926
*     ALTERATIONS OF THE FILE. BUT IF POSITION IS BY ALTERNATE           AFB0926
*     KEY, IT IS FATAL, BECAUSE ALTERATIONS ARE SUPPOSED TO              AFB0926
*     HAVE BEEN DETECTED BY GTNR$MP BEFORE WE LOOK AT PTREEWRD[4].       AFB0926
*     SO IF BY ALTERNATE KEY, FATAL. IF BY PRIMARY,                      AFB0926
*     SUBTRACT 1 FROM THE RECORD NUMBER IN PTREEWRD[3], AND GO           AFB0926
*     BACK TO READIT TO TRY AGAIN. SUBTRACT 1 BECAUSE AT READIT WE       AFB0926
*     SHALL CALL RDBK$AK TO ADVANCE US TO THE WANTED RECORD. EVEN        AFB0926
*     IF SUBTRACTING 1 MAKES THE RECORD NUMBER 0 OR THE NUMBER OF        AFB0926
*     A DEAD RECORD, RDBK$AK WILL NOT BE INCONVENIENCED.                 AFB0926
 #                                                                       AFB0926
OVFREC:  #RETRIEVE THE OVERFLOW RECORD#                                  GAG0905
                                                                         GAG0905
          CURPTR = 4;                                                    GAG0905
          RDBK$AK(0);  #GET THE OVERFLOW BLOCK INTO CORE/WITHOUT RECALL# GAG0905
          IF PTBLKIN[4] NQ 1                                             GAG0905
          THEN                                                           GAG0905
              BEGIN  #THE OVERFLOW BLOCK IS NOT IN CORE#                 GAG0905
              GOTO FAILURE;                                              GAG0905
              END                                                        GAG0905
          TRY4$AK ; #LOCATE THE OVERFLOW RECORD#                         GAG0905
          IF QMF EQ 0                                                    GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              IF FAPOSKEY1[0] NQ 0                                       AFB0926
              THEN                                                       AFB0926
                  BEGIN                                                  AFB0926
                  MSGF$AA ( EC553 ) ;                                    AFB0926
                  GOTO EXIT$AA ;                                         AFB0926
                  END                                                    AFB0926
              PTCUREC[3] = PTCUREC[3] - 1;                               GAG0905
              PTREEWRD[4] = 0;                                           GAG0905
              GOTO READIT;  #REESTABLISH CURRENT RECORD POSITION#        GAG0905
              END                                                        GAG0905
          ELSE                                                           GAG0905
 #                                                                       AFB0926
*     WE ARRIVE AT SUCCESS WHEN THE WANTED RECORD IS READY IN CORE       AFB0926
*     TO BE RETURNED TO THE USER. CALL FILP$AK TO SET FP IN THE          AFB0926
*     FIT TO EOK OR EOR. EOK MEANS POSITION IS BY ALTERNATE KEY,         AFB0926
*     AND THE CURRENT RECORD IS THE ONLY OR LAST ONE WITH ITS            AFB0926
*     PARTICULAR ALTERNATE KEY VALUE (LAST ACCORDING TO PRIMARY          AFB0926
*     KEY SEQUENCE, OR ACCORDING TO TIME OF INSERTION IF FIFO            AFB0926
*     ORDER WAS SELECTED LONG AGO.) MPEOK IS A FLAG IN THE FIAT          AFB0926
*     WHICH GTNR$MP MAINTAINS. THEN ZERO PTREEWRD[4]. IF IT WAS          AFB0926
*     NON-ZERO, YET WE ALREADY HAVE THE RECORD IT POINTS TO, AND         AFB0926
*     THE POSITION OF THAT OVERFLOW RECORD HAS NO MORE LOGICAL           AFB0926
*     VALUE. WHEN PTREEWRD[4]=0, WE KNOW WE ARE LOGICALLY AT THE         AFB0926
*     ((END)) RATHER THAN THE ((BEGINNING)) OF THE RECORD POINTED        AFB0926
*     TO BY PTREEWRD[3]. (THIS IS TRUE FOR POSITION BY PRIMARY KEY       AFB0926
*     ONLY. WHEN POSITION IS BY ALTERNATE KEY, PTREEWRD[3] AND           AFB0926
*     PTREEWRD[4] POINT, IF ANYTHING, TO THE WANTED RECORD. ONCE         AFB0926
*     THAT RECORD HAS BEEN DELIVERED, PTREEWRD[3] AND PTREEWRD[4]        AFB0926
*     HAVE NO VALUE AS POINTING TO THE PRECEDING RECORD, BECAUSE         AFB0926
*     THEY CAN GIVE NO CLUE AS TO WHERE TO FIND THE NEXT ONE.)           AFB0926
*                                                                        AFB0926
*     THEN CHANGE THE OP CODE FIELDS IN THE FIT FROM GTNR TO             AFB0926
*     GETNEXT. THIS IS DONE SO THAT IF THE NEXT OPERATION IS A           AFB0926
*     GTNR, IT WILL CONSIDER IT IS BEGINNING A SERIES OF THEM,           AFB0926
*     NOT CONTINUING A SERIES. FOR AK PRIMARY KEY, THIS                  AFB0926
*     ACTUALLY DOESNT MATTER, BUT IT DOES MATTER FOR AK ALTERNATE        AFB0926
*     KEY (IT ALSO WOULD MATTER FOR DA OR IS PRIMARY KEY.)               AFB0926
*                                                                        AFB0926
*     THEN CALL SVKY$AK TO CONVERT THE BLOCK AND RECORD NUMBERS          AFB0926
*     IN PTREEWRD[3] TO A KEY VALUE, AND STORE IT IN THE FIAT            AFB0926
*     WHERE FAPKY3ADR[0] POINTS. IF WE ARE POSITIONED BY                 AFB0926
*     ALTERNATE KEY THIS IS NOT REALLY NECESSARY AS GTNR$MP HAS          AFB0926
*     ALREADY DONE IT. ANYWAY THE KEY HAS TO BE THERE FOR                AFB0926
*     RDRC$AA TO RETURN IT TO THE USER. THEN CALL RDRC$AA TO             AFB0926
*     RETURN THE RECORD, AND POSSIBLY A KEY VALUE, TO THE USER. 
*     THEN, IF ACCESS IS BY ALTERNATE KEY AND PKA IS NOT 0, 
*     CALL MOVC$AA TO RETURN THE PRIMARY KEY VALUE TO WHERE 
*     PKA POINTS (IF KA IS NOT 0, THE ALTERNATE KEY VALUE WILL
*     HAVE BEEN RETURNED BY RDRC$AA.) 
*     FINALLY, STEP THE COUNT OF GETNEXTS.
*     GTNR-S ARE NOT COUNTED IN THE STATISTICS UNTIL THEY                AFB0926
*     COMPLETE, AND THEN THEY COUNT AS GETNEXTS.                         AFB0926
 #                                                                       AFB0926
SUCCESS:                                                                 GAG0905
              BEGIN  #DELIVER THE RECORD#                                GAG0905
              IF FAPOSKEY1[0] EQ 0 OR MPEOK[0] EQ 0                      GAG0905
              THEN                                                       GAG0905
                  BEGIN                                                  GAG0905
                  FILP$AK ( EOR ) ;                                      GAG0905
                  END                                                    GAG0905
              ELSE                                                       GAG0905
                  BEGIN                                                  GAG0905
                  FILP$AK ( EOK ) ;                                      GAG0905
                  END                                                    GAG0905
              PTREEWRD[4] = 0;                                           GAG0905
              FTCOP[0] = OP"GTN" ;                                       GAG0905
              FTPOP[0] = OP"GTN" ;                                       GAG0905
              SVKY$AK ;                                                  GAG0905
              RDRC$AA;                                                   GAG0905
              IF FAPOSKEY1[0] NQ 0 AND FTPKA[0] NQ 0
              THEN
                  BEGIN 
                  MOVC$AA ( FAPKY3ADR[0],0,FTPKA[0],0,FSKEYSIZE[0] ) ;
                  END 
              FSGTNCNT = FSGTNCNT + 1;                                   GAG0905
              RETURN;                                                    GAG0905
              END                                                        GAG0905
          END  #OF GTNR$AK CODE#                                         GAG0905
CONTROL EJECT ;                                                          GAG0905
PROC KEYGO ( P , Q ) ;                                                   GAG0905
          BEGIN                                                          GAG0905
 #                                                                       AFB0926
* *   KEYGO - TRANSLATE A KEY INTO BLOCK AND SLOT NUMBERS  PAGE 1        AFB0926
* *   A.F.R.BROWN                                                        AFB0926
* 1DC KEYGO                                                              AFB0926
*                                                                        AFB0926
* DC  FUNCTION                                                           AFB0926
*                                                                        AFB0926
*     TO LOCATE A PRIMARY KEY, CONVERT IT TO A BLOCK PRU NUMBER          AFB0926
*     AND A RECORD NUMBER, AND FILL THOSE NUMBERS INTO THE               AFB0926
*     CURRENT WORD OF THE PTREE.                                         AFB0926
*                                                                        AFB0926
* DC  ENTRY CONDITIONS                                                   AFB0926
*                                                                        AFB0926
*     THERE ARE TWO FORMAL PARAMETERS OF NORMAL SYMPL TYPE --            AFB0926
*     (1) THE ADDRESS OF THE WORD IN WHICH THE KEY VALUE                 AFB0926
*       BEGINS.                                                          AFB0926
*     (2) THE CHARACTER POSITION WITHIN THE WORD AT WHICH IT BEGINS.     AFB0926
*                                                                        AFB0926
*     P<FSTT$AA> POINTS TO THE FSTT IMAGE OF THE CURRENT AK FILE.        AFB0926
*     P<FINF$AA> POINTS TO THE 3-WORD FILE DESCRIPTOR INSIDE THE         AFB0926
*       FSTT (IT WILL HAVE BEEN SET SO BY STMD$AA(0) ).                  AFB0926
*                                                                        AFB0926
* DC  EXIT CONDITIONS                                                    AFB0926
*                                                                        AFB0926
*     CKEY CONTAINS THE KEY VALUE.                                       AFB0926
*     IF CKEY=0, BN=0.                                                   AFB0926
*     IF CKEY IS NOT 0, BN AND SN CONTAIN THE CORRESPONDING BLOCK AND    AFB0926
*       SLOT NUMBERS, AND THESE HAVE ALSO BEEN FILLED INTO THE BLOCK     AFB0926
*       AND RECORD NUMBER FIELDS OF PTREEWRD[CURPTR].                    AFB0926
*     NOTE THAT BN IS REALLY A PRU NUMBER. THE FIRST BLOCK BEGINS AT     AFB0926
*     PRU 3, AND CONTAINS SLOTS NUMBERED 1 THROUGH X, WHERE X IS THE     AFB0926
*     BLOCKING FACTOR. KEYS 1 THROUGH X POINT TO THESE SLOTS.            AFB0926
*     KEYS X+1 THROUGH 2*X POINT TO SLOTS 1 THROUGH X IN THE SECOND      AFB0926
*     BLOCK, WHICH BEGINS AT PRU 3+FSBLKSIZ. AND SO ON.                  AFB0926
*                                                                        AFB0926
* DC  ERRROR CONDITIONS                                                  AFB0926
*                                                                        AFB0926
*     NONE                                                               AFB0926
*                                                                        AFB0926
* DC  CALLED ROUTINES                                                    AFB0926
*                                                                        AFB0926
*      NONE.                                                             AFB0926
*                                                                        AFB0926
* DC  NON-LOCAL VARIABLES                                                AFB0926
*                                                                        AFB0926
*     T1 FOR SCRATCH                                                     AFB0926
*                                                                        AFB0926
 #                                                                       AFB0926
          ITEM P , Q ;                                                   GAG0905
                                                                         GAG0905
          T1 = KLENG ;                                                   AFB0926
          IF T1 + Q GR WC                                                AFB0926
          THEN                                                           AFB0926
              BEGIN                                                      AFB0926
              CKEY = 0 ;                                                 AFB0926
              MOVC$AA ( P, Q, LOC(CKEY), WC-T1, T1 ) ;
              END                                                        AFB0926
          ELSE                                                           AFB0926
              BEGIN                                                      AFB0926
              CKEY = B<Q*CHSZB,T1*CHSZB>W[P] ;                           AFB0926
              END                                                        AFB0926
          IF CKEY NQ 0                                                   GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              RB = FSBKFACTR[0] ;                                        GAG0905
              BN = (CKEY-1) / RB ;                                       GAG0905
              IF BN GQ O"77777777"
              THEN
                BEGIN 
                PTCURBLK[CURPTR] = O"77777777"; 
                RETURN;                # KEY IS TOO BIG # 
                END 
              SN = CKEY - BN * RB ;                                      GAG0905
              BN = BN * FSBLKSIZ[0] + PRU3 ;                             GAG0905
              IF BN GQ O"77777777"
              THEN
                BEGIN 
                PTCURBLK[CURPTR] = O"77777777"; 
                RETURN;                # KEY IS TOO BIG # 
                END 
              PTCURBLK[CURPTR] = BN ;                                    AFB0926
              PTCUREC[CURPTR] = SN ;                                     AFB0926
              END                                                        GAG0905
          ELSE                                                           GAG0905
              BEGIN                                                      GAG0905
              BN = 0 ;                                                   GAG0905
              END                                                        GAG0905
          END                                                            GAG0905
CONTROL EJECT ;                                                          GAG0905
 #                                                                       AFB0926
* *   LBK$AK - FIND AND USE THE PRIMARY KEY                 PAGE 1       AFB0926
* *   A.F.R.BROWN                                                        AFB0926
* 1DC LBK$AK                                                             AFB0926
*                                                                        AFB0926
* DC  FUNCTION                                                           AFB0926
*                                                                        AFB0926
*     TO LOCATE THE PRIMARY KEY OFFERED BY THE USER, BY A METHOD         AFB0926
*     THAT DEPENDS ON WHICH ENTRY POINT THE ROUTINE IS CALLED  THROUGH,  AFB0926
*     AND THEN TO TRANSLATE THE KEY TO A BLOCK AND SLOT NUMBER AND       AFB0926
*     INSERT THEM IN THE CURRENT PTREE WORD. THEN, UNLESS A SEEK IS      AFB0926
*     BEING DONE, TO LOCATE THE BLOCK AND RECORD WITH CURR$AK.           AFB0926
*                                                                        AFB0926
* DC  ENTRY CONDITIONS                                                   AFB0926
*                                                                        AFB0926
*     THERE ARE NO INCOMING PARAMETERS, BUT THE ENTRY POINT USED TO      AFB0926
*     CALL THIS ROUTINE IS IMPORTANT --                                  AFB0926
*     (1) LBK$AK - THIS IS FOR A PUT OR REPLACE. IF FSKEYPOS LS 10,      AFB0926
*       WE ARE USING AN EMBEDDED KEY, WHICH CAN BE FOUND IN THE RECORD   AFB0926
*       ACCORDING TO FSKEYLOC AND FSKEYPOS. IF FSKEYPOS IS 10, IT        AFB0926
*       SIGNALS NON-EMBEDDED KEYS, AND WE USE KA AND KP IN THE FIT.      AFB0926
*     (2) LBK2$AK - THIS IS FOR A GET OR DELETE. KA AND KP IN THE FIT    AFB0926
*       POINT TO THE KEY.                                                AFB0926
*     (3) LBK3$AK - THIS IS FOR A GET BY ALTERNATE KEY. THE PRIMARY KEY  AFB0926
*       HAS BEEN EXTRACTED FROM THE MIP FILE AND SAVED IN A FIAT AREA    AFB0926
*       TO WHICH FAPKY3ADR[0] POINTS.                                    AFB0926
*                                                                        AFB0926
*     P<FSTT$AA>, P<FIT$AA>, AND P<FIAT$AA> MUST POINT TO THE FSTT OF    AFB0926
*     THE CURRENT AK FILE, AND TO THE CURRENT FIT AND FIAT.              AFB0926
*                                                                        AFB0926
* DC  EXIT CONDITIONS                                                    AFB0926
*                                                                        AFB0926
*     THE BLOCK AND SLOT NUMBER HAVE BEEN FOUND AND INSERTED IN THE      AFB0926
*     CURRENT PTREE WORD AS DESCRIBED ABOVE UNDER ((FUNCTION)).          AFB0926
*                                                                        AFB0926
*     IF THE KEY VALUE WAS NON-ZERO, AND THE CURRENT OPERATION IS        AFB0926
*     NOT A SEEK, CURR$AK HAS BEEN CALLED TO TRY TO FIND THE RECORD.     AFB0926
*                                                                        AFB0926
*     IF CURR$AK IS SUCCESSFUL IN FINDING THE RECORD, QMF=1 AND RECPTR   AFB0926
*     CONTAINS ITS RECORD POINTER.                                       AFB0926
*                                                                        AFB0926
*     IF CURR$AK FINDS A RECORD, BUT IT IS AN ALIEN OR DEAD, QMF=0 BUT   AFB0926
*     RECPTR CONTAINS THE RECORD POINTER AND SO IS NOT 0.                AFB0926
*                                                                        AFB0926
*     IF QMF AND RECPTR ARE BOTH 0, THEN CKEY = 0,OR THE CURRENT         AFB0926
*     OPERATION IS A SEEK, OR THE KEY DOES NOT POINT TO A RECORD,NOT     AFB0926
*     EVEN A DEAD ONE.                                                   AFB0926
*                                                                        AFB0926
* DC  ERROR CONDITIONS                                                   AFB0926
*                                                                        AFB0926
*     NONE                                                               AFB0926
*                                                                        AFB0926
* DC  CALLED ROUTINES                                                    AFB0926
*                                                                        AFB0926
*     KEYGO - TO LOCATE THE KEY VALUE, CONVERT IT INTO A BLOCK AND SLOT  AFB0926
*       NUMBER, AND INSERT THEM IN THE PTREE.                            AFB0926
*     CURR$AK - TO LOCATE THE BLOCK AND RECORD THE PTREE WORD POINTS     AFB0926
*       TO, WITH SAFEGUARDS AGAINST INVALID NUMBERS.                     AFB0926
*                                                                        AFB0926
* DC  NON-LOCAL VARIABLES                                                AFB0926
*                                                                        AFB0926
*     KEYFWA AND KEYOFF - USED TO CONTAIN THE FWA AND OFFSET OF THE KEY, AFB0926
*       WHATEVER ENTRY POINT WE COME IN BY.                              AFB0926
*                                                                        AFB0926
 #                                                                       AFB0926
PROC LBK$AK ;   #ENTRY FOR PUT,REPLACE#                                  GAG0905
          BEGIN                                                          GAG0905
          IF FSKEYPOS[0] LS WC                                           GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              KEYFWA = FTWSA[0] + FSKEYLOC[0] ;                          GAG0905
              KEYOFF = FSKEYPOS[0] ;                                     GAG0905
              GOTO LBK4 ;                                                GAG0905
              END                                                        GAG0905
          GOTO LBK2 ;                                                    GAG0905
                                                                         GAG0905
ENTRY PROC LBK2$AK ;   #ENTRY FOR GET,DELETE#                            GAG0905
LBK2:                                                                    GAG0905
          KEYFWA = FTKA[0] ;                                             GAG0905
          KEYOFF = FTKP[0] ;                                             GAG0919
          GOTO LBK4 ;                                                    GAG0905
                                                                         GAG0905
ENTRY PROC LBK3$AK ;    #ENTRY FOR GET BY ALT KEY#                       GAG0905
          KEYFWA = FAPKY3ADR[0] ;                                        GAG0905
          KEYOFF = 0 ;                                                   GAG0905
                                                                         GAG0905
LBK4:                                                                    GAG0905
          RECPTR = 0 ;                                                   GAG0905
          KEYGO ( KEYFWA , KEYOFF ) ;                                    GAG0905
          IF CKEY NQ 0                                                   GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              IF FTCOP[0] NQ OP"SEK"                                     GAG0905
              THEN                                                       GAG0905
                  BEGIN                                                  GAG0905
                  CURR$AK ;                                              GAG0905
                  END                                                    GAG0905
              END                                                        GAG0905
          ELSE                                                           GAG0905
              BEGIN                                                      GAG0905
              QMF = 0 ;                                                  GAG0905
              END                                                        GAG0905
          END                                                            GAG0905
PROC NWEM$AK;                      CONTROL EJECT;                        GAG0905
          BEGIN                                                          GAG0905
 #                                                                       GAG0905
* *   NWEM$AK -- UPDATE THE MOST EMPTY BLOCKS TABLE.              PAGE 1 GAG0905
* *   G.B.KINGSLAND                                                      GAG0905
* LDC NWEM$AK                                                            GAG0905
*                                                                        GAG0905
* DC  FUNCTION                                                           GAG0905
*                                                                        GAG0905
*     DETERMINE IF A BLOCK QUALIFIES AS ONE OF THE MOST EMPTY BLOCKS AND GAG0905
*     IF SO, RECORD IT IN THE MOST EMPTY BLOCK TABLE.                    GAG0905
*                                                                        GAG0905
* DC  ENTRY CONDITIONS                                                   GAG0905
*                                                                        GAG0905
*     P<BLOK$AA> SET POINTING TO THE CURRENT BLOCK.                      GAG0905
*     P<FSTT$AA> SET POINTING TO THE FSTT OF THE CURRENT FILE.           GAG0905
*                                                                        AFB0926
*     NOTE THAT IF BLFRESLTS[0] IS 0, WE HERE COUNT THE BLOCK AS HAVING  AFB0926
*     ONE HALFWORD OF SPACE LESS THAN EC, FOR IF A NEW RECORD HAD TO     AFB0926
*     BE ADDED TO THE BLOCK, ONE HALFWORD WOULD BE REQUIRED FOR THE      AFB0926
*     NEW RECORD POINTER. IF BLFRESLTS[0] IS NOT 0, A NEW RECORD         AFB0926
*     POINTER COULD JUST BE SLIPPED IN PLACE OF ONE OF THE DEAD          AFB0926
*     ONES.                                                              AFB0926
*                                                                        GAG0905
* DC  EXIT CONDITIONS                                                    GAG0905
*                                                                        GAG0905
*     P<BLOK$AA> PRESERVED                                               GAG0905
*     P<FSTT$AA> PRESERVED                                               GAG0905
*     FSMTLIST MAY BE CHANGED.                                           GAG0905
*                                                                        GAG0905
 #                                                                       GAG0905
          ITEM TABX, MINX;                                               GAG0905
          ITEM BKID;                                                     GAG0905
          ITEM ECOUNT , FRS ;                                            GAG0905
                                                                         GAG0905
          BKID = BLOCKID;                                                GAG0905
          IF BLFRESLTS[0] EQ 0                                           GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              FRS = 0 ;                                                  GAG0905
              END                                                        GAG0905
          ELSE                                                           GAG0905
              BEGIN                                                      GAG0905
              FRS = 1 ;                                                  GAG0905
              END                                                        GAG0905
          ECOUNT = EC + FRS - 1 ;                                        GAG0905
          IF ECOUNT LS 2 OR ( FRS EQ 0 AND RC EQ FSBKFACTR[0] )          GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              FOR TABX=0 STEP 1 UNTIL DFMETLG-1 DO #CLEAR THAT ENTRY#    GAG0905
                  BEGIN                                                  GAG0905
                  IF FSMTPRU[ TABX ] EQ BKID                             GAG0905
                  THEN                                                   GAG0905
                      BEGIN                                              GAG0905
                      FSEMPLIST[ TABX ] = 0;                             GAG0905
                      RETURN;                                            GAG0905
                      END                                                GAG0905
                  END #END DO#                                           GAG0905
              RETURN; #FORGET THIS ENTRY#                                GAG0905
              END                                                        GAG0905
          MINX = 0;                                                      GAG0905
          FOR TABX=0 STEP 1 UNTIL DFMETLG-1 DO                           GAG0905
              BEGIN                                                      GAG0905
              IF FSMTPRU[ TABX ] EQ BKID                                 GAG0905
              THEN                                                       GAG0905
                  BEGIN                                                  GAG0905
                  FSMTUSW[ TABX ] = ECOUNT;                              GAG0905
                  RETURN;                                                GAG0905
                  END                                                    GAG0905
              IF FSMTUSW[ TABX ] LS FSMTUSW[ MINX ]                      GAG0905
              THEN                                                       GAG0905
                  BEGIN                                                  GAG0905
                  MINX = TABX;                                           GAG0905
                  END                                                    GAG0905
              END                                                        GAG0905
          IF ECOUNT GR FSMTUSW[ MINX ]                                   GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              FSMTUSW[ MINX ] = ECOUNT;                                  GAG0905
              FSMTPRU[ MINX ] = BLOCKID;                                 GAG0905
              END                                                        GAG0905
          END #NWEM$AK#                                                  GAG0905
PROC POSTGMP ;    CONTROL EJECT ;                                        GAG0905
 #                                                                       AFB0926
* *   POSTGMP - LOCATE THE RECORD AFTER MIP        PAGE 1                AFB0926
* *   A.F.R.BROWN                                                        AFB0926
* 1DC POSTGMP                                                            AFB0926
*                                                                        AFB0926
* DC  FUNCTIONS                                                          AFB0926
*                                                                        AFB0926
*     WHEN DOING A GET OR GETNEXT BY ALTERNATE KEY, AFTER THE MIP        AFB0926
*     SUBROUTINE HAS EXTRACTED THE PRIMARY KEY VALUE FROM THE MIP        AFB0926
*     FILE, TO LOCATE THE DATA RECORD BY THAT KEY.                       AFB0926
*                                                                        AFB0926
* DC  ENTRY CONDITIONS                                                   AFB0926
*                                                                        AFB0926
*     P<PTRE$AA> LOCATES THE CURRENT PTREE, WHICH MIGHT BE THAT OF       AFB0926
*     THE DATA FILE, OR THAT OF A SUBFILE IN THE MIP FILE. IF THIS       AFB0926
*     PTREE HAS THE QEI FLAG SET, WE HAVE SOMEHOW COME TO EOI DURING     AFB0926
*     A GETNEXT, AND POSTGMP IS NOT TO DO ANYTHING.                      AFB0926
*                                                                        AFB0926
*     OTHERWISE, IT MUST BE THE DATA (AK) FILE PTREE. P<FIT$AA>          AFB0926
*     AND P<FIAT$AA> POINT TO THE CURRENT FIT AND FIAT, IN               AFB0926
*     WHICH FAPKY3ADR[0] POINTS TO WHERE THE PRIMARY KEY                 AFB0926
*     VALUE HAS BEEN STORED BY THE MIP ROUTINE.                          AFB0926
*     P<FSTT$AA> MUST POINT TO THE FSTT OF THE AK FILE.                  AFB0926
*                                                                        AFB0926
* DC  EXIT CONDITIONS                                                    AFB0926
*                                                                        AFB0926
*     IF WE EXIT NORMALLY, PTREEWRD[3] POINTS TO THE RECORD IN           AFB0926
*     ITS BLOCK, AND CURR$AK HAS BEEN CALLED TO LOCATE IT.               AFB0926
*     SEE THE EXIT CONDITIONS FOR CURR$AK. NOTE THAT POSTGMP             AFB0926
*     ONLY TAKES US AS FAR AS THE SLOT WHERE THE RECORD LOGICALLY        AFB0926
*     OUGHT TO BE. IT DOES NOT FOLLOW A POSSIBLE OVERFLOW POINTER,       AFB0926
*     BECAUSE THAT CAN BE LEFT IN THE GET OR GETNEXT ROUTINE AS          AFB0926
*     COMMON TO BOTH ACTION BY PRIMARY KEY AND ACTION BY ALTERNATE       AFB0926
*     KEY.                                                               AFB0926
*                                                                        AFB0926
* DC  ERROR CONDITIONS                                                   AFB0926
*                                                                        AFB0926
*     FATAL ERROR 546 IF QEI WAS NOT SET, AND THE KEY COULD NOT BE       AFB0926
*     FOUND IN THE AK FILE. THE MIP AND AK FILES ARE OUT OF SYNC.        AFB0926
*                                                                        AFB0926
* DC  CALLED ROUTINES                                                    AFB0926
*                                                                        AFB0926
*     LBK3$AK - TO DO MOST OF THE WORK, IF QEI IS NOT SET.               AFB0926
*     MSGF$AA - TO ISSUE A FATAL ERROR.                                  AFB0926
*                                                                        AFB0926
* DC  NON-LOCAL VARIABLES                                                AFB0926
*                                                                        AFB0926
*     QMF - SET AS A RESULT FLAG BY LBK3$AK, 0 FOR BAD, 1 FOR GOOD.      AFB0926
*                                                                        AFB0926
 #                                                                       AFB0926
          BEGIN                                                          GAG0905
          IF QEI EQ 0                                                    GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              CURPTR = 3 ;                                               GAG0905
              LBK3$AK ;                                                  GAG0905
              IF QMF EQ 0                                                GAG0905
              THEN                                                       GAG0905
                  BEGIN                                                  GAG0905
                  MSGF$AA ( EC546 ) ; #PRIMARY KEY NOT FOUND#            GAG0905
                  GOTO EXIT$AA ;                                         GAG0905
                  END                                                    GAG0905
              END                                                        GAG0905
          END                                                            GAG0905
CONTROL EJECT;                                                           GAG0905
PROC RDBK$AK(RR);                                                        GAG0905
          BEGIN                                                          GAG0905
 #                                                                       GAG0905
* *   RDBK$AK - READ IN OR LOCATE AN AK BLOCK    PAGE  1                 GAG0905
* *   PROGRAM - AK$AK                                                    GAG0905
* *   R.P.NG                                    DATE.                    GAG0905
* 1CD RDBK$AK                                                            GAG0905
*                                                                        GAG0905
* CD  FUNCTION                                                           GAG0905
*                                                                        GAG0905
*     TO READ IN OR LOCATE A BLOCK REFERRED TO BY THE PTREE.  THE        GAG0905
*     PROCESS CAN BY DONE WITH OR WITHOUT RECALL IF IO IS NEEDED.        GAG0905
*                                                                        GAG0905
* CD  ENTRY CONDITIONS.                                                  GAG0905
*                                                                        GAG0905
*     A PARAMETER RR WILL BE 0 IS ANY BLOCK READ INVOLVED ARE TO BE DONE GAG0905
*     WITHOUT RECALL.  RR OF 1 WILL ALWAYS RESULT IN THE PTREE WORD SET  GAG0905
*     POINTING TO THE RIGHT BLCOK IN CORE ON EXIT.                       GAG0905
*     P<PTRE$AA>,P<FSTT$AA> SHOULD BE SET.  CURPTR SHOULD BE SET IN THE  GAG0905
*     PTREE.  PTCURBLK[CURPTR] SHOULD BE A VALID PRU NUMBER FOR THE FILE GAG0905
*                                                                        GAG0905
* CD  EXIT CONDITIONS.                                                   GAG0905
*     IF RR IS 1, PTREE IS SET UP POINTING TO A BLOCK IN CORE.  THE MOST GAG0905
*     EMPTY TABLE WOULD HAVE BEEN UPDATED IF NECESSARY.  P<BLOK$AA>      GAG0905
*     WILL BE SET POINTING TO THAT BLOCK.  IF RR IS 0, NOTHING MIGHT     GAG0905
*     HAVE BEEN DONE.                                                    GAG0905
*                                                                        GAG0905
* CD  ERROR CONDITIONS.                                                  GAG0905
*                                                                        GAG0905
*     NONE                                                               GAG0905
*                                                                        GAG0905
* CD  CALLED ROUTINES.                                                   GAG0905
*                                                                        GAG0905
*     NWEM$AK - TO UPDATE THE MOST EMPTY TABLE.                          GAG0905
*     SEBL$AA - TO READ IN OR LOCATE A BLOCK.                            GAG0905
*                                                                        GAG0905
* CD  DESCRIPTION.                                                       GAG0905
*                                                                        GAG0905
*     FIRST, WE CALL SEBL$AA.  ON RETURN, IF PTBLKIN IS SET,             GAG0905
*     SEBL$AA HAS READ IN OR LOCATED THE REQUIRED BLOCK.  ALL THAT       GAG0905
*     IS LEFT IS TO SEE IF WE HAVE TO UPDATE THE MOST EMPTY TABLE. WE    GAG0905
*     BASE THIS ON BLNFTRD FLAG, WHICH WILL BE 0 IF THE BLOCK HAS JUST   GAG0905
*     BEEN READ IN (FLAG IS 0 IN THAT CASE).                             GAG0905
 #                                                                       GAG0905
          ITEM RR;  #INPUT RECALL PARAMETER#                             GAG0905
                                                                         GAG0905
          SEBL$AA(CURPTR,RR);                                            GAG0905
          IF PTBLKIN[CURPTR] EQ 1 AND BLNFTRD EQ 0                       GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              NWEM$AK;                                                   GAG0905
              BLNFTRD = 1;                                               GAG0905
              END                                                        GAG0905
          END                                                            GAG0905
CONTROL EJECT;                                                           GAG0905
PROC REW$AK;                                                             GAG0905
 #                                                                       AFB0926
* *   REW$AK - REWIND AN AK FILE                      PAGE 1             AFB0926
* *   A.F.R.BROWN                                                        AFB0926
* 1DC REW$AK                                                             AFB0926
*                                                                        AFB0926
* DC  FUNCTION                                                           AFB0926
*                                                                        AFB0926
*     TO DO A REWIND ON AN AK FILE, WHETHER BY PRIMARY OR BY             AFB0926
*     ALTERNATE KEY.                                                     AFB0926
*                                                                        AFB0926
* DC  ENTRY CONDITIONS                                                   AFB0926
*                                                                        AFB0926
*     IF KL, RKP, AND RKW IN THE FIT DESCRIBE THE LENGTH AND             AFB0926
*     THE POSITION IN THE RECORD, OR NON-EMBEDDEDNESS IN IT,             AFB0926
*     OF THE PRIMARY KEY OF THE AK FILE, THE REWIND IS TO BE             AFB0926
*     BY PRIMARY KEY. OTHERWISE, IT IS TO BE BY ALTERNATE KEY,           AFB0926
*     THE PARTICULAR ALTERNATE KEY BEING DETERMINED BY THE               AFB0926
*     COMBINATION OF THOSE THREE VALUES. IT MAY BE THAT THERE            AFB0926
*     IS NO SUCH ALTERNATE KEY DEFINED FOR THIS FILE, IN WHICH           AFB0926
*     CASE NOTHING WILL BE DONE BUT A NON-FATAL ERROR.                   AFB0926
*                                                                        AFB0926
* DC  EXIT CONDITIONS                                                    AFB0926
*                                                                        AFB0926
*     IF THE REWIND WAS BY PRIMARY KEY, FAPOSKEY1[0] IN THE              AFB0926
*     FIAT HAS BEEN SET TO ZERO TO MARK THAT POSITION IS NOW             AFB0926
*     BY PRIMARY KEY, AND PTREEWRD[3] HAS BEEN SET TO ZERO               AFB0926
*     TO INDICATE REWOUND POSITION.                                      AFB0926
*                                                                        AFB0926
*     IF BY ALTERNATE KEY, FAPOSKEY1[0] HAS BEEN SET TO INDICATE         AFB0926
*     WHICH ALTERNATE KEY, AND VARIOUS FIELDS ARE SET IN THE             AFB0926
*     FIAT TO MARK THE REWOUND POSITION. SEE THE EXIT CONDITIONS         AFB0926
*     OF SUBROUTINE RWIN$MP.                                             AFB0926
*                                                                        AFB0926
*     IF RWIN$MP FOUND AN ERROR, NOTHING HAS BEEN CHANGED.               AFB0926
*                                                                        AFB0926
* DC  ERROR CONDITIONS                                                   AFB0926
*                                                                        AFB0926
*     NONE FOUND HERE.                                                   AFB0926
*                                                                        AFB0926
* DC  CALLED ROUTINES                                                    AFB0926
*                                                                        AFB0926
*     QUMP$AA - TO DECIDE IF THE CALL IS BY PRIMARY KEY OR NOT.          AFB0926
*     RWIN$MP - TO DO ALL THE WORK IF BY ALTERNATE KEY.                  AFB0926
*     FILP$AK - TO SET FP = EOR.
*                                                                        AFB0926
* DC  NON-LOCAL VARIABLES                                                AFB0926
*                                                                        AFB0926
*     NONE                                                               AFB0926
*                                                                        AFB0926
 #                                                                       AFB0926
          BEGIN  #REW$AK CODE#                                           GAG0905
          IF QUMP$AA(0) EQ 0
          THEN                                                           GAG0905
              BEGIN  #THIS IS A DATA FILE REWIND#                        GAG0905
              PTREEWRD[3] = 0 ;                                          GAG0905
              FAPOSKEY1 = 0;                                             GAG0905
              FILP$AK ( EOR ) ; 
              RETURN;                                                    GAG0905
              END                                                        GAG0905
          ELSE                                                           GAG0905
              BEGIN  #THIS IS A MIP REWIND#                              GAG0905
              RWIN$MP;                                                   GAG0905
              RETURN;                                                    GAG0905
              END                                                        GAG0905
          END  #OF REW$AK CODE#                                          GAG0905
CONTROL EJECT;                                                           GAG0905
PROC SEEK$AK;                                                            GAG0905
 #                                                                       AFB0926
* *   SEEK$AK - DO A SEEK ON AN AK FILE                  PAGE 1          AFB0926
* *   A.F.R.BROWN                                                        AFB0926
* 1DC SEEK$AK                                                            AFB0926
*                                                                        AFB0926
* DC  FUNCTION                                                           AFB0926
*                                                                        AFB0926
*     TO CARRY OUT A SEEK OPERATION, BY PRIMARY OR ALTERNATE KEY,        AFB0926
*     ON AN AK FILE. THE FARTHEST THE SEEK WILL EVER GO IS TO            AFB0926
*     READ IN THE BLOCK OF THE AK FILE THAT SHOULD CONTAIN THE           AFB0926
*     WANTED RECORD. IF THAT RECORD TURNS OUT TO OVERFLOW, THE           AFB0926
*     READ OF THE OVERFLOW BLOCK HAS TO BE DONE WITH RECALL,             AFB0926
*     DURING THE GET OPERATION THAT SHOULD FOLLOW THE INDICATION         AFB0926
*     FROM SEEK THAT EVERYTHING IS READY.                                AFB0926
*                                                                        AFB0926
* DC  ENTRY CONDITIONS                                                   AFB0926
*                                                                        AFB0926
*     P<FSTT$AA> POINTS TO THE FSTT OF THE CURRENT AK FILE.              AFB0926
*     P<FIT$AA> AND P<FIAT$AA> POINT TO THE CURRENT FIT AND FIAT.        AFB0926
*     KA AND KP IN THE FIT POINT TO THE START OF A KEY OFFERED           AFB0926
*       BY THE USER.                                                     AFB0926
*     KL, RKW, AND RKP IN THE FIT GIVE THE LENGTH AND POSITION           AFB0926
*       WITHIN THE RECORD OF EITHER THE PRIMARY KEY OR SOME              AFB0926
*       ALTERNATE KEY (RKP=10, RKW=0 REPRESENTS NON-EMBEDDEDNESS         AFB0926
*       IN THE CASE OF THE PRIMARY KEY.) THIS TELLS WHAT TYPE            AFB0926
*       OF KEY WE ARE TO SEEK ON.                                        AFB0926
*                                                                        AFB0926
*     IF THE SEEK IS BY ALTERNATE KEY, FASEEKEY1[0] AND FAALTPOS[0]      AFB0926
*     AND PREVOP ARE USED BY SUBROUTINE SEEK$MP TO DECIDE WHETHER THIS   AFB0926
*     IS A CONTINUATION OF A PREVIOUS SEEK, OR WHETHER EVERYTHING HAS    AFB0926
*     TO START FROM THE BEGINNING. THE DETAILS OF THIS ARE GIVEN IN      AFB0926
*     THE COMMENTS TO SUBROUTINE SEEK$MP. AT ANY RATE, IF                AFB0926
*     FASEEKEY1[0] CONTAINS 0, THE PREVIOUS OPERATION WAS NOT A          AFB0926
*     SEEK BY ALTERNATE KEY. WHETHER OR NOT IT WAS A SEEK BY THE SAME    AFB0926
*     PRIMARY KEY DOES NOT MATTER, BECAUSE FOR AK FILES, A SEEK BY       AFB0926
*     PRIMARY KEY IS A ONE-SHOT ACTION ANYWAY.                           AFB0926
*                                                                        AFB0926
* DC  EXIT CONDITIONS                                                    AFB0926
*                                                                        AFB0926
*     IF THE FP FIELD OF THE FIT CONTAINS ((EOR)) (20B), THEN THE        AFB0926
*     DATA BLOCK CORRESPONDING TO THE KEY VALUE IS IN CORE, OR IS        AFB0926
*     CURRENTLY BEING READ IN. THE APPROPRIATE ACTION FOR THE CALLER     AFB0926
*     IS TO WAIT FOR COMPLETION OF THE CURRENT I/O ON THE AK FILE        AFB0926
*     (BZF IN THE FIT POINTS TO THE FET TO WATCH) AND THEN DO A GET      AFB0926
*     OPERATION. IF THE RECORD TURNS OUT TO BE IN AN OVERFLOW BLOCK,     AFB0926
*     THIS MAY INVOLVE A READ WITH RECALL, BUT THERE IS NO WAY           AFB0926
*     AROUND IT AT PRESENT.                                              AFB0926
*                                                                        AFB0926
*     OTHERWISE, THE FP FIELD OF THE FIT WILL CONTAIN 0, INDICATING      AFB0926
*     THAT THE CALLER CAN USEFULLY GIVE ANOTHER SEEK, AFTER FIRST        AFB0926
*     WATCHING FOR COMPLETION THE FET TO WHICH BZF IN THE FIT POINTS.    AFB0926
*                                                                        AFB0926
*     FASEEKEY1[0] IS SET 0 IF THE SEEK IS BY PRIMARY KEY. IF BY         AFB0926
*     ALTERNATE KEY, SEEK$MP LEAVES IT SET TO A NON-ZERO VALUE           AFB0926
*     INCLUDING A DEFINITION OF THE ALTERNATE KEY AND AN INDICATION      AFB0926
*     OF HOW FAR ALONG THE SEEK PROCESS HAS COME.                        AFB0926
*                                                                        AFB0926
* DC  ERROR CONDITIONS                                                   AFB0926
*                                                                        AFB0926
*     NONE. A SEEK BY FALSE PRIMARY KEY IS DISCOVERED WHEN THE           AFB0926
*     SERIES OF SEEKS IS WOUND UP BY A GET. A SEEK BY FALSE ALTERNATE    AFB0926
*     KEY IS DISCOVERED THE SAME WAY, BUT FP IS SET TO EOR               AFB0926
*     PREMATURELY. IN AN APPLICATION WITH A LOT OF SEEKS BY ALTERNATE    AFB0926
*     KEY, OF WHICH A HIGH PERCENTAGE WERE FALSE, THIS WOULD REPRESENT   AFB0926
*     A LOT OF WASTED TIME.                                              AFB0926
*                                                                        AFB0926
* DC  CALLED ROUTINES                                                    AFB0926
*                                                                        AFB0926
*     QUMP$AA - TO DECIDED WHETHER THE SEEK IS BY PRIMARY OR             AFB0926
*       ALTERNATE KEY.                                                   AFB0926
*     SEEK$MP - TO DO MOST OF THE WORK IF BY ALTERNATE KEY, TAKING THE   AFB0926
*       PROCESS SO FAR AS TO STORE THE PRIMARY KEY VALUE IN THE FIAT     AFB0926
*       AREA TO WHICH FAPKY3ADR[0] POINTS, OR LESS FAR IF A BLOCK HAS    AFB0926
*       TO BE READ.                                                      AFB0926
*     LBK3$AK - TO CONVERT THE KEY TO A BLOCK AND SLOT NUMBER AND        AFB0926
*       STUFF THEM IN PTREEWRD[3].                                       AFB0926
*     LBK2$AK - IF BY PRIMARY KEY, TO GET THE KEY VIA FTKA AND FTKP,     AFB0926
*       CONVERT IT TO A BLOCK AND SLOT NUMBER, AND STUFF THEM IN         AFB0926
*       PTREEWRD[3].                                                     AFB0926
*     NOTE THAT THE LAST TWO HAVE A PARTICULAR TEST IN THEM, TO AVOID    AFB0926
*       ACTUALLY READING THE BLOCK IF THE OP CODE IS A SEEK.             AFB0926
*     MXPR$AA - A FUNCTION THAT GIVES THE PRU NUMBER AT LOGICAL EOI IN   AFB0926
*       THE CURRENT FILE.                                                AFB0926
*     LOCB$AA - LOCATE A GIVEN BLOCK IN CORE, READING IT FROM DISK IF    AFB0926
*       NECESSARY, BUT WITHOUT RECALL BECAUSE THE SECOND PARAMETER IS 0. AFB0926
*                                                                        AFB0926
* DC  NON-LOCAL VARIABLES                                                AFB0926
*                                                                        AFB0926
*     MIPMODE - SET BY SEEK$MP TO 0 IF THE PRIMARY KEY VALUE HAS BEEN    AFB0926
*       ASCERTAINED, OTHERWISE LEFT NON-ZERO.                            AFB0926
*     BN - THE BLOCK PRU NUMBER DERIVED FROM THE KEY BY LBK3$AK OR       AFB0926
*       LBK2$AK.                                                         AFB0926
*                                                                        AFB0926
 #                                                                       AFB0926
          BEGIN  #SEEK$AK CODE#                                          GAG0905
          IF QUMP$AA(0) NQ 0
          THEN                                                           GAG0905
              BEGIN  #MIP IS INVOLVED#                                   GAG0905
              SEEK$MP;  #DO THE MIP SEEK#                                GAG0905
              IF MIPMODE EQ 0                                            GAG0905
              THEN                                                       GAG0905
                  BEGIN                                                  GAG0905
                  LBK3$AK ;                                              GAG0905
                  END                                                    GAG0905
              END  #OF MIP CODE#                                         GAG0905
          ELSE                                                           GAG0905
              BEGIN                                                      GAG0905
              FASEEKEY1[0] = 0 ;                                         GAG0905
              LBK2$AK ;                                                  GAG0905
              END                                                        GAG0905
          IF MIPMODE EQ 0                                                GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              IF BN EQ 0 OR BN GQ MXPR$AA                                GAG0905
              THEN                                                       GAG0905
                  BEGIN                                                  GAG0905
                  GOTO SUCKER ;                                          GAG0905
                  END                                                    GAG0905
              LOCB$AA ( BN , 0 ) ;                                       GAG0905
              END                                                        GAG0905
              IF MIPMODE EQ 0 AND P<BLOK$AA> GR 0                        GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
SUCKER:                                                                  GAG0905
              FTFP[0] = EOR ;                                            GAG0905
              END                                                        GAG0905
          ELSE                                                           GAG0905
              BEGIN                                                      GAG0905
              FTFP[0] = FPNULL ;                                         GAG0905
              END                                                        GAG0905
          RETURN;                                                        GAG0905
          END  #OF SEEK$AK CODE#                                         GAG0905
PROC SKIP$AK;                      CONTROL EJECT;                        GAG0905
          BEGIN                                                          GAG0905
 #                                                                       GAG0905
* *   SKIP$AK - SKIP LOGICAL RECORDS IN ACTUAL KEY FILE.    PAGE 1       GAG0905
* *   PROGRAM - AK$AK                                                    GAG0905
* *   G.B.KINGSLAND                                                      GAG0905
* 1CD SKIP$AK                                                            GAG0905
*                                                                        GAG0905
* CD  FUNCTION                                                           GAG0905
*                                                                        GAG0905
*     TO SKIP FOWARD OR BACKWARD A NUMBER OF LOGICAL RECORDS.            GAG0905
*                                                                        GAG0905
* CD  ENTRY CONDITIONS                                                   GAG0905
*                                                                        GAG0905
*     P<FIT$AA> POINTS TO USER FIT.                                      GAG0905
*     FTSKP - CONTAINS THE SKIP COUNT.                                   GAG0905
*     FTCOP - CONTAINS SKIP FORWARD OR SKIP BACKWARD OPERATION CODE.     GAG0905
*                                                                        GAG0905
* CD  EXIT CONDITIONS                                                    GAG0905
*                                                                        GAG0905
*     THE FILE IS PROPERLY POSITIONED, PERHAPS AT BOI/EOI.               GAG0905
*                                                                        GAG0905
* CD  ERROR CONDITIONS                                                   GAG0905
*                                                                        GAG0905
*     NOTE 1012 - EOI/BOI ENCOUNTERED ON SKIP OR GETN.                   AFB0926
*                                                                        GAG0905
* CD  CALLED ROUTINES                                                    GAG0905
*                                                                        GAG0905
*     STEP$AK - STEP FORWARD ONE LOGICAL RECORD                          GAG0905
*     BACK$AA - STEP BACKWARD ONE LOGICAL RECORD                         GAG0905
*     SKIP$MP - HANDLE SKIP IN MIP FILE                                  GAG0905
*     MSGZ$AA - ISSUE NOTE                                               GAG0905
*     FILP$AK - SET FILE POSITION IN FET                                 GAG0905
*     RDBK$AK - LOCATE BLOCK IN MEMORY, READ IT IF NECESSARY.            GAG0905
*                                                                        GAG0905
* CD  DESCRIPTION                                                        GAG0905
*                                                                        GAG0905
*     1. IF MIP IS ACTIVE CALL SKIP$MP TO HANDLE MIP SKIP                GAG0905
*        AND GO TO STEP 7.                                               GAG0905
*     2. RE-ESTABLISH FILE POSITION WITH CURPTR SET TO THREE.            GAG0905
*        SET *ABSENT* TO 1 OR 0 DEPENDING ON OVERFLOW RECORD.            GAG0905
*     3. IF DIRECTION IS FORWARD INCREMENT SKIP COUNT BY VALUE OF        GAG0905
*        *ABSENT*, ELSE DECREMENT SKIP COUNT BY VALUE OF *ABSENT* AND    GAG0905
*        LOCATE BLOCK FOR BACK$AA.                                       GAG0905
*     4. IF SKIP COUNT IS ZERO OR FAIL IS NON ZERO GO TO STEP 7.         GAG0905
*     5. IF DIRECTION IS FORWARD CALL STEP$AK TO ADVANCE ONE LOGICAL     GAG0905
*        RECORD, ELSE CALL BACK$AA TO GO BACK ONE LOGICAL RECORD.        GAG0905
*     6. DECREMENT RECORD COUNT.                                         GAG0905
*     7. IF EOI OR BOI ISSUE NOTE 12, SET FILE POSITION AND EXIT.        GAG0905
 #                                                                       GAG0905
          ITEM                                                           GAG0905
              AVANTI,                                                    GAG0905
              RESIDUAL,                                                  GAG0905
              BOUNDARY,                                                  GAG0905
              ABSENT;                                                    GAG0905
                                                                         GAG0905
          RESIDUAL = FTSKP[0] ;                                          GAG0905
          IF RESIDUAL EQ 0                                               GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              FTFP[0] = FAFP[0];                                         AFB0928
              RETURN;                                                    AFB0928
              END                                                        GAG0905
          BOUNDARY = EOI;                                                GAG0905
          IF FAPOSKEY1 NQ 0                                              GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              SKIP$MP;                        #DO MIP SKIP#              GAG0905
              END                                                        GAG0905
          ELSE                                                           GAG0905
              BEGIN                                                      GAG0905
              IF FSPUTCNT EQ 0
              THEN
                  BEGIN 
                  GOTO SKIPEND ;
                  END 
              CURPTR = 3;                     #RE-ESTABLISH CUR POSIT#   GAG0905
              IF PTREEWRD[ 3 ] EQ 0                                      GAG0905
              THEN                                                       GAG0905
                  BEGIN                                                  GAG0905
                  PTCURBLK[ 3 ] = PRU3;       #REWIND#                   GAG0905
                  END                                                    GAG0905
              ABSENT = 0;                     #CUR REC NOT OVERFLOW#     GAG0905
              IF PTREEWRD[ 4 ] NQ 0                                      GAG0905
              THEN                                                       GAG0905
                  BEGIN                                                  GAG0905
                  PTREEWRD[ 4 ] = 0;                                     GAG0905
                  ABSENT = 1;                 #CUR REC IS OVERFLOW#      GAG0905
                  END                                                    GAG0905
              AVANTI = FTCOP - OP"SKF";       #DIRECTION#                GAG0905
              IF AVANTI EQ 0                                             GAG0905
              THEN                                                       GAG0905
                  BEGIN                                                  GAG0905
                  IF FAFP EQ EOI
                  THEN
                      BEGIN 
                      GOTO SKIPEND ;
                      END 
                  RESIDUAL = RESIDUAL - ABSENT;  #ADJUST FORWARD COUNT#  GAG0905
                  END                                                    GAG0905
              ELSE                                                       GAG0905
                  BEGIN                                                  GAG0905
                  RESIDUAL = RESIDUAL + ABSENT;  #ADJUST BACKWARD COUNT# GAG0905
                  BOUNDARY = BOI;                                        GAG0905
                  QFR = 0;                                               GAG0905
                  IF FAFP EQ EOI
                  THEN
                      BEGIN 
                      PTCURBLK[3] = MXPR$AA - FSBLKSIZ[0] ; 
                      RDBK$AK ( 1 ) ; 
                      PTCUREC[3] = RC ; 
                      END 
                  ELSE
                      BEGIN 
                      RDBK$AK ( 1 ) ; 
                      END 
                  END                                                    GAG0905
SKSTEP:                                                                  AFB0928
              IF RESIDUAL NQ 0                                           AFB0928
              THEN                                                       AFB0928
                  BEGIN                                                  GAG0905
                  IF AVANTI EQ 0                                         GAG0905
                  THEN                                                   GAG0905
                      BEGIN                                              GAG0905
                      STEP$AK( 1 );           #FORWARD 1 LOGICAL#        GAG0905
                      END                                                GAG0905
                  ELSE                                                   GAG0905
                      BEGIN                                              GAG0905
                      BACK$AA;                #BACKWARD 1 LOGICAL#       GAG0905
                      END                                                GAG0905
                  IF FAIL EQ 0                                           AFB0928
                  THEN                                                   AFB0928
                      BEGIN                                              AFB0928
                      RESIDUAL = RESIDUAL - 1;                           AFB0928
                      GOTO SKSTEP;                                       AFB0928
                      END                                                AFB0928
                  END                                                    AFB0928
              FTSKP[0] = RESIDUAL;                                       AFB0928
              END                                                        GAG0905
SKIPEND:  
          IF FTSKP NQ 0                                                  GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              FILP$AK( BOUNDARY );            #EOI/BOI ENCOUNTERED#      GAG0905
              MSGZ$AA( NOTE012 );                                        GAG0905
              END                                                        GAG0905
          ELSE                                                           GAG0905
              BEGIN                                                      GAG0905
SKEW:                                                                    GAG0905
              FILP$AK ( EOR ) ;                                          GAG0905
              END                                                        GAG0905
          END #SKIP$AK#                                                  GAG0905
CONTROL EJECT;                                                           GAG0905
PROC STEP$AK(RECALL);  #STEP FWD 1 LIVE REC-OVER BLOCK BOUNDS IF NEEDED# GAG0905
          BEGIN  #STEP$AK CODE#                                          GAG0905
 #                                                                       GAG0905
* *       STEP$AK                                PAGE  1                 GAG0905
* *       PROGRAM AK$AK                                                  GAG0905
* *       G.A.GREENE                            DATE.                    GAG0905
* 1CD     STEP$AK - STEP OVER TO NEXT LIVE RECORD.                       GAG0905
*                                                                        GAG0905
*         FUNCTION                                                       GAG0905
*                                                                        GAG0905
*         THIS ROUTINE IS CALLED TO POSITION TO THE NEXT LIVE RECORD.    GAG0905
*         IF THERE ARE NO MORE RECORD IN THE CURRENT BLOCK, IT WILL      GAG0905
*         TRY TO STEP OVER TO THE FIRST RECORD OF THE NEXT BLOCK.  IF    GAG0905
*         THAT HAPPENS, THE INPUT PARAMETER WILL CONTROL WHETHER THE     GAG0905
*         READ OF THE FOLLOWING BLOCK IS TO BE DONE WITH RECALL.         GAG0905
*                                                                        GAG0905
* CD      ENTRY CONDITIONS                                               GAG0905
*                                                                        GAG0905
*         THERE IS ONE FORMAL PARAMETER, WHICH IS 0 IF ANY NECESSARY     AFB0926
*         BLOCK READ IS TO BE DONE WITHOUT RECALL, OR NON-ZERO IF        AFB0926
*         WITH RECALL.                                                   AFB0926
*                                                                        AFB0926
*         STARTING FILE POSITION IS DESCRIBED BY PTREEWRD[3]. IF THIS    AFB0926
*         WORD=0, THE FILE IS REWOUND. THE BASED ARRAY POINTS FOR FIT,   AFB0926
*         FIAT, PTREE, FSTT ETC. MUST BE SET UP CORRECTLY. FAFP[0]       AFB0926
*         MUST NOT = EOI.                                                AFB0926
*                                                                        GAG0905
* CD      EXIT CONDITIONS.                                               GAG0905
*                                                                        GAG0905
*         FAIL = QEI = 0 IF RECORD IS POSITIONED.                        GAG0905
*         FAIL = 1 IF REQUESTED LIVE RECORD IS NOT FOUND BEFORE RETURN.  GAG0905
*         QEI = 1  IF EOI IS ENCOUNTERED.                                GAG0905
*                                                                        GAG0905
* CD      ERROR CONDITIONS                                               GAG0905
*                                                                        GAG0905
*         NONE                                                           GAG0905
*                                                                        GAG0905
* CD      CALLED ROUTINES                                                GAG0905
*                                                                        GAG0905
*         RDBK$AK - TO READ IN BLOCK POINTED TO BY PTREE ENTRY           GAG0905
*         STPF$AA - TO STEP FORWARD 1 LIVE RECORD WITHIN A BLOCK         GAG0905
*                                                                        GAG0905
* CD      DESCRIPTION                                                    GAG0905
*                                                                        GAG0905
*         THERE ARE TWO CASES WHEN STEP$AK MAY FAIL:                     GAG0905
*             (1) IF STEP$AK IS CALLED WITHOUT RECALL AND THE BLOCK IS   GAG0905
*                 NOT IN CORE                                            GAG0905
*             (2) IF EOI IS ENCOUNTERED.                                 GAG0905
*         IF STEP$AK SUCCEEDS, FAIL WILL NOT BE 1 AND QEI WILL BE SET TO GAG0905
*             0.                                                         GAG0905
*                                                                        GAG0905
 #                                                                       AFB0926
          ITEM RECALL;  #RECALL = 1 IF CALLED WITH RECALL#               GAG0905
          FAIL = 1;                                                      GAG0905
          CURPTR = 3 ;                                                   GAG0905
          IF PTREEWRD[3] EQ 0                                            GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              PTCURBLK[3] = PRU3 ;                                       GAG0905
              END                                                        GAG0905
START:                                                                   GAG0905
          RDBK$AK(RECALL);                                               GAG0905
          IF PTBLKIN[3] EQ 0                                             GAG0905
          THEN                                                           GAG0905
              BEGIN  #BLOCK IS NOT IN CORE#                              GAG0905
              RETURN;  #FAIL = 1#                                        GAG0905
              END                                                        GAG0905
          STPF$AA;                                                       GAG0905
          IF FAIL EQ 0                                                   GAG0905
          THEN                                                           GAG0905
              BEGIN  #SUCCESS#                                           GAG0905
              QEI = 0;                                                   GAG0905
              RETURN;                                                    GAG0905
              END                                                        GAG0905
          IF (BLOCKID+FSBLKSIZ) LS MXPR$AA                               GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              PTCURBLK[3] = BLOCKID + FSBLKSIZ ;                         GAG0905
              PTCUREC[3] = 0 ;                                           GAG0905
              GOTO START;                                                GAG0905
              END                                                        GAG0905
          ELSE                                                           GAG0905
              BEGIN  #EOI ENCOUNTERED#                                   GAG0905
              QEI =1;                                                    GAG0905
              RETURN;                                                    GAG0905
              END                                                        GAG0905
          END  #OF STEP$AK CODE#                                         GAG0905
CONTROL EJECT ;                                                          GAG0905
PROC SVKY$AK ;                                                           GAG0905
 #                                                                       AFB0926
* *   SVKY$AK - STORE CURRENT PRIMARY KEY IN FIAT         PAGE 1         AFB0926
* *   A.F.R.BROWN                                                        AFB0926
* 1DC SVKY$AK                                                            AFB0926
*                                                                        AFB0926
* DC  FUNCTION                                                           AFB0926
*                                                                        AFB0926
*     IF THE FILE IS CURRENTLY POSITIONED BY PRIMARY KEY, TO CONVERT     AFB0926
*     THE CURRENT POSITION, KEPT IN PTREEWRD[3], TO A                    AFB0926
*     PRIMARY KEY VALUE, AND STORE IT IN THE FIAT AREA TO WHICH          AFB0926
*     FAPKY3ADR[0] POINTS. THIS IS NOT NEEDED AS A RECORD OF POSITION    AFB0926
*     (AS THE KEY IN FAPKY3ADR[0] WOULD BE NEEDED FOR AN IS FILE)        AFB0926
*     BECAUSE PTREEWRD[3] DOES THE SAME JOB BETTER. IT IS NEEDED BY      AFB0926
*     SUBROUTINE RDRC$AA, AS A STANDARD PLACE TO GET THE PRIMARY         AFB0926
*     KEY VALUE, WHEN RETURNING IT TO THE USER.                          AFB0926
*                                                                        AFB0926
* DC  ENTRY CONDITIONS                                                   AFB0926
*                                                                        AFB0926
*     IF FAPOSKEY1[0] IS NOT 0, CURRENT POSITION IS BY ALTERNATE         AFB0926
*     KEY, SO SVKY$AK NEED DO NOTHING.                                   AFB0926
*                                                                        AFB0926
*     IF FAPOSKEY1[0] = 0, PTREEWRD[3] DESCRIBES THE CURRENT             AFB0926
*     POSITION. THE BLOCK PRU NUMBER IS IN THAT WORD IF                  AFB0926
*     PTBLKIN[3]=0. OTHERWISE THE BLOCK NUMBER CAN BE TAKEN              AFB0926
*     OUT OF THE PREFIX OF THE BLOCK IMAGE TO WHICH                      AFB0926
*     THE BLOCK PART OF PTREEWRD[3] POINTS.                              AFB0926
*                                                                        AFB0926
*     THE FILE MUST NOT BE REWOUND, I.E. PTREEWRD[0] MUST NOT =0.        AFB0926
*     THE FILE MAY BE POSITIONED AT THE FIRST RECORD, HOWEVER.           AFB0926
*     THIS WOULD IMPLY THAT IT WAS AT THE END OF THE FIRST RECORD.       AFB0926
*                                                                        AFB0926
* DC  EXIT CONDITIONS                                                    AFB0926
*                                                                        AFB0926
*     IF FAPOSKEY1[0] = 0, THE PRIMARY KEY VALUE HAS BEEN                AFB0926
*     STORED LEFT JUSTIFIED IN THE WORD TO WHICH                         AFB0926
*     FAPKY3ADR[0] POINTS.                                               AFB0926
*                                                                        AFB0926
* DC  ERROR CONDITIONS                                                   AFB0926
*                                                                        AFB0926
*     NONE                                                               AFB0926
*                                                                        AFB0926
* DC  CALLED ROUTINES                                                    AFB0926
*                                                                        AFB0926
*     NONE                                                               AFB0926
*                                                                        AFB0926
* DC  NON-LOCAL VARIABLES                                                AFB0926
*                                                                        AFB0926
*     NONE                                                               AFB0926
 #                                                                       AFB0926
          BEGIN                                                          GAG0905
          ITEM B ;                                                       GAG0905
                                                                         GAG0905
          IF FAPOSKEY1[0] EQ 0                                           GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              IF PTBLKIN[3] EQ 0                                         GAG0905
              THEN                                                       GAG0905
                  BEGIN                                                  GAG0905
                  B = PTCURBLK[3] ;                                      GAG0905
                  END                                                    GAG0905
              ELSE                                                       GAG0905
                  BEGIN                                                  GAG0905
                  B = BLOCKID[PTCURBADR[3]-P<BLOK$AA>] ;                 GAG0905
                  END                                                    GAG0905
              W[FAPKY3ADR[0]] =                                          GAG0905
      (((B-PRU3)/FSBLKSIZ)*FSBKFACTR+PTCUREC[3])*2**((WC-KLENG)*CHSZB);  GAG0905
              END                                                        GAG0905
          END                                                            GAG0905
CONTROL EJECT;                                                           GAG0905
PROC TRY4$AK ;                                                           GAG0905
 #                                                                       AFB0926
* *   TRY4$AK - LOCATE RECORD IN OVERFLOW BLOCK       PAGE 1             AFB0926
* *   A.F.R.BROWN                                                        AFB0926
* 1DC TRY4$AK                                                            AFB0926
*                                                                        AFB0926
* DC  FUNCTION                                                           AFB0926
*                                                                        AFB0926
*     WHEN AN OVERFLOW BLOCK HAS ALREADY BEEN READ AND LOCATED           AFB0926
*     IN CORE, ACCORDING TO PTREEWRD[4], TO LOCATE THE RECORD IN         AFB0926
*     THAT BLOCK TO WHICH THE RECORD NUMBER PART OF PTREEWRD[4]          AFB0926
*     POINTS, WHILE GUARDING AGAINST A POSSIBLE ABORT DUE TO A           AFB0926
*     TOO-HIGH RECORD NUMBER. ALSO TO VERIFY THE BACKPOINTER IN          AFB0926
*     THE OVERFLOW RECORD.                                               AFB0926
*                                                                        AFB0926
* DC  ENTRY CONDITIONS                                                   AFB0926
*                                                                        AFB0926
*     PTREEWRD[4] POINTS TO AN OVERFLOW BLOCK ALREADY IN CORE,           AFB0926
*     AND CONTAINS A RECORD NUMBER. PTREEWRD[3] POINTS TO THE            AFB0926
*     THE MOTHER RECORD OF THIS OVERFLOW RECORD. THE MOTHER              AFB0926
*     MAY OR MAY NOT BE IN CORE NOW.                                     AFB0926
*                                                                        AFB0926
*     CURPTR = 4.                                                        AFB0926
*                                                                        AFB0926
* DC  EXIT CONDITIONS                                                    AFB0926
*                                                                        AFB0926
*     IF QMF = 0, WE HAVE HAD A FAILURE. THE RECORD NUMBER IS            AFB0926
*     GREATER THAN THE NUMBER OF RECORDS IN THE BLOCK, OR IT             AFB0926
*     POINTS TO A RECORD THAT IS DEAD OR NOT AN OVERFLOW                 AFB0926
*     RECORD, OR IT IS AN OVERFLOW RECORD BUT ITS BACKPOINTER            AFB0926
*     NAMES A DIFFERENT MOTHER RECORD FROM PTREEWRD[3].                  AFB0926
*     PTREEWRD[4] HAS BEEN SET TO 0.                                     AFB0926
*                                                                        AFB0926
*     IF QMF IS NOT ZERO, ALL IS WELL, RNO IS THE RECORD NUMBER,         AFB0926
*     AND RECFWA, RECLWA AND RECLNG GIVE ITS FWA, LWA+1 AND              AFB0926
*     LENGTH IN WORDS (INCLUDING THE ONE-WORD BACKPOINTER AT             AFB0926
*     THE BEGINNING.) OUTKEY HAS BEEN SET TO 1, AS A SIGNAL THAT         AFB0926
*     THE FIRST WORD OF THE RECORD DOES NOT REALLY BELONG TO IT          AFB0926
*     AND SHOULD NOT BE RETURNED BY RDRC$AA. RECPTR HAS BEEN             AFB0926
*     ADJUSTED -- THE RPUCC FIELD HAD CONTAINED A MERE OVERFLOW          AFB0926
*     INDICATOR, BUT THIS HAS BEEN REPLACED BY THE REAL UNUSED           AFB0926
*     CHARACTER COUNT, TAKEN FROM THE FIRST WORD OF THE RECORD.          AFB0926
*                                                                        AFB0926
* DC  ERROR CONDITIONS                                                   AFB0926
*                                                                        AFB0926
*     NONE                                                               AFB0926
*                                                                        AFB0926
* DC  CALLED ROUTINES                                                    AFB0926
*                                                                        AFB0926
*     LOCR$AA - TO LOCATE THE RECORD BY NUMBER.                          AFB0926
*     MACH$AK - TO CHECK ITS BACKPOINTER.                                AFB0926
*                                                                        AFB0926
* DC  NON-LOCAL VARIABLES                                                AFB0926
*                                                                        AFB0926
*     NONE                                                               AFB0926
 #                                                                       AFB0926
          BEGIN                                                          GAG0905
          RNO = PTCUREC[4] ;                                             GAG0905
          IF RNO LQ RC                                                   GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              LOCR$AA ( RNO ) ;                                          GAG0905
              IF MACH$AK EQ 0                                            GAG0905
              THEN                                                       GAG0905
                  BEGIN                                                  GAG0905
                  QMF = 1 ;                                              GAG0905
                  RPUCC = B<0,4>W[RECFWA] ;                              AFB0926
                  OUTKEY = 1 ;                                           AFB0926
                  RETURN ;                                               GAG0905
                  END                                                    GAG0905
              END                                                        GAG0905
          PTREEWRD[4] = 0 ;                                              GAG0905
          QMF = 0 ;                                                      GAG0905
          END                                                            GAG0905
      END                                                                GAG0905
      TERM;                                                              GAG0905
