*DECK,AAMDCTL 
          IDENT  AAM$CTL                                                 RPN0524
*#                                                                      015070
* *   AAM$CTL - CRM/AAM EXTENDED CONTROL MODULE     PAGE  1              AM2A077
* *   THIS IS THE CRM AAM CONTROL MODULE                                 JJJ0916
* *   PROGRAMMER - RPN                             DATE  76/08/12        JJJ0916
*#                                                                      015110
*#                                                                      015120
*         AAM$CTL CONSISTS OF                                            RPN0524
*               1.   THE AAM CONTROLLER AAM.CTL THAT INTERFACES WITH CRM015140
*               2.   THE CAPSULE LOADER WHICH LOADS AND UNLOADS CAPSULES015150
*               3.   THE CONDITIONAL CALL HANDLER CCAL$AA               015160
*         THESE ARE ALL GROUPED UNDER ONE IDENT SO THAT ANYTIME BAM IS  015170
*         CAPABLE OF SWITCHING THE CALL TO A DIFFERENT MODULE TO HANDLE 015180
*         STATIC LOADING, THE MODULE CAN EASILY BE REPLACED.            015190
*         THE FOLLOWING TABLES WILL BE USED BY AAM$CTL                   RPN0524
*#                                                                      015210
          SST                                                           015220
 GENCAP   MACRO  CAPNAME,CAPENT                                         015230
          VFD    42/0L_CAPNAME,18/=Y_CAPENT 
          ENDM                                                          015260
 RESET    MACRO 
*         TO RESET A0 AND B1 FROM FIT$AA
          SA1    FIT$AA 
          SB1    1
          SA0    X1 
          ENDM
 AAMALF   EQU    507B 
 BADNDX   EQU    512B 
 NUMLIV   EQU    3       NUMBER OF TIMES CAPS WILL TRAVERSE KICK OUT CHN CY209
 BADOP    EQU    666B 
 MAXRCAP  EQU    0
 OPRANGE  SET    #STR#+1
 #B6STK#  EQU    7
*#                                                                      015270
*         MACRO GENCAP IS USED TO GENERATE THE CAPSULE NAME TABLE.      015280
*         THE ENTRY WILL BE A 1 WORD ENTRY OF THE FOLLOWING FORMAT
*         WORD 0 -  59-18 : CAPSULE NAME                                015300
*                   17- 0 : WEAK EXT REFERENCE TO AN ENTRY POINT IN     015310
*                   THE CAPSULE                                         015320
*         A CAPSULE THAT IS SUBJECTED TO KICKOUT WILL HAVE A ONE WORD   015370
*         ENTRY SET UP BY THE GENCJP MACRO.  THE MACRO IS DEFINED BELOW 015380
*         IF EXPANDS TO A RJ TO THE REQUIRED ENTRY POINT.               015390
*                                                                       015400
*#                                                                      015410
 GENCJP   MACRO  EPT,CAPTAG                                             015420
          VFD    6/01,6/0,18/=Y_EPT,12/0,18/CAPTAG                      015430
          ENDM                                                          015440
*#                                                                      015450
*         THE GENCAP MACRO EXPANDS TO A WORD CONTAINING AN RJ TO        015460
*         AN ENTRY POINT IN A CAPSULE SUBJECTED TO KICKOUT.  BEFORE     015470
*         WE MAKE THE JUMP, WE TEST IF THAT ENTRY POINT IS SATIFIED.    015480
*         IF IT IS, THE CAPSULE IS THEN LOCKED, AND WE CAN TRANSFER     015490
*         CONTROL TO THE ENTRY POINT BY AN RJ.  THE LOW END OF THE      015500
*         ENTRY CONTAINS A POINTER TO THE CAPSULE NAME ENTRY OF THAT    015510
*         CAPSULE.  HENCE, IF THE CAPSULE IS NOT LOADED, WE CAN CALL    015520
*         THE CAPSULE LOADER QUITE EASILY THEN.                         015530
*#                                                                      015540
          ENTRY  CAPN$AA,CJPN$AA                                        015550
 CAPN$AA  GENCAP  AAM$CTL,AAM$CTL  AAM CONTROLLING ROUTINE
 OPN$AA   GENCAP OPNM$AA,OPNM$AA   OPEN/CLOSE                            *--AK--
 KDF$MIP  GENCAP MP$KDEF,MP$KDEF
 IS$EXEC  GENCAP EXEC$IS,EXEC$IS
 IS$SKGN  GENCAP SKGN$IS,SKGN$IS   SEEK AND SKIP
 IS$UPDT  GENCAP UPDT$IS,UPDT$IS
 IS$RARE  GENCAP RARE$IS,RARE$IS   IS RARE CAPSULE
 MP$EXEC  GENCAP EXEC$MP,EXEC$MP   MIP EXECUTIVE
 MP$SKGN  GENCAP SKGN$MP,SKGN$MP   MIP SKIP AND GETNR AND SEEK
 MP$UPDT  GENCAP UPDT$MP,UPDT$MP   MIP UPDATE CAPSULE 
 MP$RARE  GENCAP RARE$MP,RARE$MP   MIP INDEX ONLY PROCESSING CAPSULE
 DA$EXEC  GENCAP EXEC$DA,EXEC$DA   DA EXECUTIVE                          GAG0807
 DA$SKGN  GENCAP EXEC$DA,EXEC$DA   SEEK,GETNR AND SKIP                   GAG0726
DA$UPDT   GENCAP UPDT$DA,UPDT$DA   DA UPDATE
 DA$RARE  GENCAP OVFM$DA,OVFM$DA   DA OVERFLOW                           GAG0814
 AK$EXEC  GENCAP EXEC$AK,EXEC$AK   AK EXECUTIVE                          GAG0807
 AK$SKGN  GENCAP EXEC$AK,EXEC$AK   SEEK,GETNR AND SKIP                   GAG0726
AK$UPDT   GENCAP UPDT$AK,UPDT$AK   AK UPDATE
 AK$RARE  GENCAP OVFM$AK,OVFM$AK   OVERFLOW                              RPN0615
 AA$NRO   GENCAP NRO$AA,NRO$AA     AAM NON-READ ONLY CODE 
*         END OF CAPSULE TABLE
*         THE FOLLOWING ARE CONDITIONAL CALL ENTRIES
 CJPN$AA  GENCJP SPLT$IS,RARE.IS
          GENCJP VANB$IS,RARE.IS
          GENCJP AWAY$IS,RARE.IS
          GENCJP WNOW$IS,RARE.IS
          GENCJP SPC1$AK,RARE.AK                                         RPN0615
          GENCJP MALR$AK,RARE.AK   #CALCODE = 5#                         GAG0627
          GENCJP MKRM$AK,RARE.AK   #CALCODE = 6#                         GAG0627
          GENCJP ADNU$DA,RARE.DA   #CALCODE = 7#                         GAG0811
*         ALL OTHER CONDITIONAL JUMP SHOULD BE DECLARED BEFORE THIS CARD015770
 P        ERRNZ  CJPN$AA-CAPN$AA+2-#AM2DSZ#   DIRECTORY SIZE CHANGED
 SETNAME  VFD    42/7LAAM$CTL,18/#AM2DSZ# 
 LIBLIST  DATA   6LAAMLIB                                                RPN0114
*         DECLARE ANY OTHER LIBRARIES IN WHICH CAPSULES OF THIS         015800
*         SET MAY RESIDE IN BEFORE THESE TWO CARDS.                     015810
          BSSZ   1                 TERMINATE LIBRARY LIST 
 RARE.IS  VFD    30/MAXRCAP,12/0,18/IS$RARE IS RARE CAPSULE ENTRY POINTS
 RARE.AK  VFD    30/MAXRCAP,12/0,18/AK$RARE AK RARE CAPSULE ENTRY POINTS RPN0615
 RARE.DA  VFD    30/MAXRCAP,12/0,18/DA$RARE DA RARE CAPSULE ENTRY POINTS GAG0811
*         ADD    OTHER RARE CAPSULE LENGTH DESCRIPTION BEFORE THIS CARD 
*         THE ABOVE ENTRIES ARE USED FOR FDL LOADING                    015830
*         BELOW IS THE CALL TO AAMCOMCMP WHICH IS NOT LISTED.           015840
 #DBF#    SET    0           MUST BE 0 ON RELEASE CODE                   RPN0322
          LIST   -L                                                     015860
          NOREF  'R?,'M?,'W?                                            015870
 '<DEF>?    SET    1                                                    015880
*CALL AAMCOMCMP                                                         015890
          LIST   L                                                      015900
          LDSET  EPT=CMM$ALF/CMM$FRF/ER$SRM                              JJJ0107
          ENTRY  LOAD$AA,UNLD$AA,CCAL$AA                                 RPN0524
          ENTRY  IS$UPDT,MP$UPDT                                         JJJ0628
          LDSET  EPT=AAM.CTL/CCAL$AA                                    015920
          LDSET  EPT=CAPN$AA/WTIO$AA                                     RPN1134
          LDSET  EPT=UNL1$AA/UUCC$AA/LWAD$AA
          LDSET  EPT=SETR$AA/RPGT$AA/STMD$AA
          LDSET  EPT=FIXX$AA/ALTR$AA/LOCB$AA
          LDSET  EPT=WRLB$AA/CRA1$AA/MSGZ$AA
          LDSET  EPT=EXIT$AA/IOWR$AA
          LDSET  EPT=UNCH$AA/INCH$AA                                     JJJ1207
          LDSET  EPT=LKEY$AA
          LDSET  EPT=OWN$AA                                              JJJ0609
          LDSET  EPT=RESP$AA                                             AM2A011
          LDSET  EPT=LOCR$AA/CKSM$AA                                     JJJ0721
 #USM#    MICRO  1,,/0,28,60,0,0,1/                                     015940
          LDSET  EPT=MSGF$AA                                             VBG1026
          LDSET  EPT=FLSH$AA                                             JJJ1117
          LDSET  EPT=IMPR$AA
*#                                                                      015970
*1CD      AAM$CTL                                                        RPN0524
*0CD      FUNCTION                                                      015990
*         THIS IS THE INTERFACE BETWEEN BAM AND AAM.  THIS ROUTINE      016000
*         WILL DECIDE ON THE PROCESSOR(S) NEDDED TO HANCLE A COMMAND    016010
*         FROM THE USER, TO ENSURE THAT THE PROCESSOR(S) IS LOADED, AND 016020
*         THEN TRANSFER CONTROL TO IT.                                  016030
*0CD      ENTRY CONDITIONS                                              016040
*         A0 = FIT ADDRESS                                              016050
*         B1 = 1                                                        016060
*         B6 = RETURN ADDRESS TO BAM TO UNLOAD CONTROLLER                RPN1116
*         USER RETURN ADDRESS IS STACKED IN FIT + 7                      RPN1116
*         AAM OPERATION CODE IS SET IN COP FIELD OF FIT.                016080
*         SKIP COUNT FOR A SKIP OPERATION IS SET IN SKP FIELD OF FIT    016090
*0CD      EXIT CONDITIONS                                               016100
*         A0,B1 PRESERVED EXCEPT FOR FLUSH COMMAND.  COMMAND PROCESSED.  RPN1116
*0CD      ERROR CONDITIONS                                              016120
*         CRMEP WILL BE CALLED WITH THE FOLLOWING ERRORS
*         BADNDX - USER ERROR SETTING NDX ON WITH PD = OUTPUT 
*         BADXN  - NDX ON BUT XN NOT SET
*         BADOP  - SYSTEM ERROR, OP CODE OUT OF RANGE.
*0CD      CALLED ROUTINES 
*         SAAM$(FO) TO PROCESS (FO) FILE
*         OPEN$AA  FOR OPEN REQUEST 
*         LOAD.R   TO TRY AND LOAD A RESIDEBT OR FUNCTION CAPSULE 
*         LOAD.T   TO LOAD A TRANSIENT
*         UNLD.T   TO UNLOAD TRANSIENTS.
*0CD      DESCRIPTION 
*         ON ENTRY, A BUNCH OF BASE ARRAY POINTERS AND OP CODES VARIABLE
*         ARE INITIALIZED.  THE CURRENT OP IS THEN EVALUATED. 
*         THERE ARE CURRENTLY 16D OP CODES THAT HAVE TO BE DEALT WITH,
*         SO NATURALLY WE CHECK TO SEE IF OP CODE IS IN RANGE FIRST.
*0CD      NON LOCAL VARIABLES                                           016320
*         FITSAV - SET ON ENTRY TO USER FIT ADDRESS (A0)                016330
*         NOFDL - SET TO 1 IF FDL IS NOT AVAILABLE                      016340
*         NOCMM - SET IF CMM IS NOT AVAILABLE                           016350
*         NOTFRST - SET TO 1 AFTER THE FIRST OPEN CALL TO AAM           016360
*0CD      DESCRIPTION                                                   016370
*         IT INTERPRETS THE CALL, TRANSFERRING CONTROL TO THE PROPER    016380
*         PROCESSOR.  IT ALSO ENSURES THAT ALL CAPSULES REQUIRED FOR    016390
*         PROCESSING A COMMAND IS LOADED.                               016400
*         THE FIRST THING IT DOES ON ENTRY IS TO DETERMINE IF THIS IS   016410
*         THE FIRST AAM CALL.  IF IT IS, IT HAS TO SIDETRACK OFF TO DO  016420
*         SOME INITIALIZATION AND SET UP REPRIEVE CALL.  AT THIS POINT, 016430
*         WE CAN EASILY DETERMINE IF WE ARE IN A STATIC LOAD ENVIRONMENT016440
*         WE WILL SET A FLAG TO TELL US THAT.                           016450
*#                                                                      016460
 BLANKS   DATA   10H                                                     RPN0928
 AAM$CTL  CAP.RM                                                         RPN0524
          SAVE   SAVE CALLER RETURN ADDRESS 
          RF.AA  GCOM$AA,IMPERR 
          NZ     X1,KILLAAM 
          SET.RM ES,0 
          SET.RM FP,#EOR# 
          F.RM   FIAT,3 
          BX6    X3 
          SA6    FIAT$AA     GET FIAT$AA SETTING DONE NOW 
          SX7    A0 
          SA7    FIT$AA      SET P<FIT> 
          SF.AA  GCOM$AA,FITSAV,X7 AND STORE IN COMMON
          EQ.RM  COP,#OPN#,AAMCB,B5,3,7                                  GAG0928
          EQ.RM  COP,#STF#,AAMCB,B5,3,7 
          F.RM   FSTT,3 
          ZR     X3,AAMCA 
          RF.AA  X3,FSFTERR,5 
          NZ     X5,AAMCX 
AAMCA     F.RM   MIPFS,3
          ZR     X3,AAMCB 
          RF.AA  X3,FSFTERR,5 
          ZR     X5,AAMCB 
AAMCX     BX6    X5 
          SA6    AAMCY+1
          SA1    A6-1 
          RJ     =XMSGF$AA
          EQ     EXIT$AA
AAMCY     VFD    42/0,18/*+1
          DATA   0
* 
AAMCB     BSS    0
          F.RM   POP,5
          SF.AA  GCOM$AA,PREVOP,X5 PREVOP IN GLOBAL COMMON
          F.RM   COP,,B4
          SET.RM POP,B4      SET POP TO COP 
          SB5    B4-OPRANGE 
          CRMEP  IFOP=(GE B5),ES=BADOP,FNF=1
*#
*         AFTER THAT WE WILL USE THE JUMP TABLE TO DECIDE WHERE TO GO.
*         THE JUMP TABLE ALSO SETS UP THE TYPE OF RETURN IN B6. 
*         BASICALLY, THERE ARE 7 TYPES OF JUMP TARGET 
*         RMKD - TO HANDLE RMKDEF PROCESSING
*         OPEN - TO HANDLE OPEN AND SETFIT
*         CLSE - TO HANDLE CLOSE
*         READ - TO HANDLE GET,GETN,REWIND AND START
*         UPDT - TO HANDLE PUT,DELETE AND REPLACE 
*         SORS - TO HANDLE SEEK,GETNR AND SKIP
* 
*         EACH JUMP TARGET WILL BE EXPLAINED IN GREATER DETAIL LATER. 
*0        B6 IS SET TO A RETURN POINT WHERE CONTROL IS RETURNED TO AFTER
*         THE COMMAND IS PROCESSED. 
*         THE EXIT POINTS ARE 
*         EXIT.N - THE USUAL EXIT POINT, ALSO CALL EXIT$AA, ONLY ERROR
*                  EXIT CHECKING HAS TO BE DONE PRIOR TO RETURNING. 
*         EXIT.C - THE CLOSE RETURN.  CLOSE WILL BE UNLOADED IF LAST
*                  AAM FILE.
*         EXIT.O - OPEN RETURNS HERE TO UNLOAD OPEN AND AAM$CTL IF THE
*                  FILE WAS NOT SUCCESSFULLY OPENED AND THERE ARE NO
*                  MORE USERS 
*         EXIT.G - GET,GETN,GETNR EXIT POINT TO HANDLE Z RECORDS
*         EXIT.P - SKIP(AND GETN,GETNR,EVENTUALLY) RETURNS TO TAKE DATA 
*                  EXITS. 
*#
 IFFO     IFEQ   #IS#,3 
 IFFO     IFEQ   #DA#,5 
 IFFO     IFEQ   #AK#,6 
          F.RM   FO,X5,-#IS#
 IFFO     ELSE
          ERR    FO VALUE CHANGED 
 IFFO     ENDIF 
          OFF.RM NDX,AAMCD                                               GAG1005
          SX5    B0          USE ONLY IS IF NDX IS ON                    GAG1005
 AAMCD    BSS    0                                                       GAG1005
          LX5    2
          SB3    X5                B3 = (FO-#IS#)*4 AS SHIFT COUNT
          JP     B4+JTAB
 JTAB     BSS    0
 <OP>     SET    #OPN#
*         IMPORTANT NOTE.  THE TABLE IS GENERATED ASSUMING IS=3,DA=5, 
*         AND AK=6.  FO CHANGED SHOULD BE ACCOMPANIED BY A CODE CHANGE
          ECHO    ,P1=(0,#OPN#,#CLO#,#GET#,#GTN#,#PUT#,#SIK#,#GNR#,#DLT#
,,#RPL#,#REW#,#STF#,#SKF#,#SKB#,#STR#),P2=(RMKD,OPEN,CLSE,READ,READ,UPDT
,,SORS,SORS,UPDT,UPDT,READ,OPEN,SORS,SORS,READ),P3=(N,O,C,G,G,N,N,G,N,N,
,N,N,P,P,N) 
          IFLT   P1,<OP>
 <OP>     SET    <OP>+1 
          SB6    EXIT._P3 
          EQ     P2 
          ELSE
          ERR    OP CODE ORDER CHANGED
          ENDIF 
          ENDD
          SPACE  3
*#
*0        RMKD
*         HERE WE ARE TRYING TO DO RMKDEF.  WE WILL LOAD UP KDEF$MP, AND
*         PROCEED FROM THERE.  LOAD.T IS CALLED TO LOAD THE CAPSULE, AS 
*         THIS WILL BE TREATED AS A TRAMSIENT.  B5 IS SET TO ENTRY POINT
*         KDEF$MP AND CONTROL TRANSFERRED TO CALLER TO SET UP THE CALL. 
*#
 RMKD     SA2    KDF$MIP
          RJ     LOAD.T      TRY LOAD THIS TRANSIENT
          SA2    AA$NRO 
          RJ     LOAD.F      LOAD NRO CAPSULE 
          SA2    IS$UPDT
          RJ     LOAD.F      LOAD IS UPDATE 
          SA2    MP$UPDT
          RJ     LOAD.F      LOAD MIP UPDATE
          MX6    1           SET TRANSIENT CAPSULE LOADED FLAG
          SA6    TCAPF
          F.RM   WSA,5       SET UP PARAMETER LIST
          BX6    X5 
          SA6    PAR
          SA1    A6 
          SB5    =YKDEF$MP   WHERE TO GO
          EQ     CALLER      GO 
*#
*0        OPEN(SETFIT)
*         HERE WE ARE HANDLING OPEN.  FIRST BAM MIGHT HAVE SET UP DUMMY 
*         FET POINTERS TO HANDLE CIO CALLS, SO WE WILL UNDO THAT FIRST. 
*         NEXT, WE HAVE TO DECIDE ON WHAT CAPSULE TO LOAD.  WE START OUT
*         WITH X5 = 0.  FOR EVERY RESIDENT CAPSULE WE LOAD, A BIT WILL
*         BE SET IN X5.  THOS WILL THEN BECOME THE CAPSULE USAGE MASK,
*         WHICH SHOULD BE SAVED INTO THE FIAT BY OPEN.
*         IF XN IS SET, PRESUMABLY MIP IS INVOLVED, SO WE WILL LOAD UP
*         EXEC$MP AND EXEC$IS.  NOTE THAT B3 IS PRESERVED ACROSS ALL THE
*         LOAD CALLS, AND B5 WILL BE SET TO SAAM$(FO) OR SAAM$IS (FOR 
*         NDX CASE) AT THE END BY THE LOAD.R ROUTINES.  THEN WE DO A
*         LOAD.T ON OPEN, AND GO DIRECTLY TO OPEN.
*#
 OPEN     BSS    0
          SB5    A0 
          F.RM   FWB,,B2,-#FTL# 
          NE     B2,B5,OPEN.1      SKIP IF NOT DUMMY POINTER
          SET.RM FWB,B0 
 OPEN.1   MX5    0
          F.RM   XN                IF MIP INVOLVED. 
          ZR     X1,OPEN.2         SKIP IF NO 
          SA2    IS$EXEC           LOAD MIP EXEC
          RJ     LOAD.R 
          SA2    MP$EXEC           LOAD IS EXEC 
          RJ     LOAD.R 
          ON.RM  NDX,OPEN.3        SKIP IF NDX IS ON
 OPEN.2   SA2    B3+IS$EXEC        LOAD EXEC FO 
          RJ     LOAD.R 
 OPEN.3   SET.RM USM,X5            SAVE USAGE MASK
*#
*0        CLSE
*         FOR CLOSE, JUST LOAD UP OPEN/CLOSE CAPSULE, THEN GO.
*#
 CLSE     BSS    0
          SA2    OPN$AA                                                  *--AK--
          RJ     LOAD.T 
          MX6    1
          SA6    TCAPF       SET TRANSIENT CAPSULE LOADED FLAG
          F.RM   COP,B4                                                  CY209
          SB5    =YCLSF$AA                                               *--AK--
          SB2    B4-#CLS#    TEST FOR CLOSE                              CY209
          ZR     B2,CALLER   GO CLSF$IS DIRECTLY IF CLOSE                CY209
          SB5    =YOPEN$AA   IS IT OPEN                                  *--AK--
          EQ     B4,B1,CALLER      GO CALLER IF OPEN                     CY209
          SB5    =YSTFT$IS   GO SETFET                                   CY209
          EQ     CALLER                                                  CY209
*#
*0        READ
*         HERE WE HANDLE GET GETN, START, REWIND. 
*         FIRST CALL F.NOP TO UNLOAD ANY TRANSIENTS.  THAT ROUTINE WILL 
*         ALSO LOAD UP INDX$MP IF NECESSARY.  IF NDX IS ON, F.NOP WILL
*         SET B3 TO ZERO, SO EITHER WAY WE CAN PICK UP THE RIGHT EXEC$FO
*         AND GO
*#
 READ     BSS    0
          RJ     F.NOP
          EQ     CALLFO 
*#
*0        SORS
*         HERE WE MIGHT HAVE TO LOAD THE SKGN CAPSULE 
*         AGAIN WE BEGIN BY CALLING F.NOP 
*         NEXT WE WILL CALL OMIP.  OMIP WILL TELL US IF MIP IS NEEDED.
*         IF IT IS, X5=1 ON EXIT, OTHERWISE 0.  A GLOBAL FLAG WOULD HAVE
*         BEEN SET TO IDENTIFY THE SAME FACT, WHICH CAN BE USE BY OTHER 
*         PROGRAMS.  AGAIN, B3 AND B6 ARE CAREFULLY PRESERVED THROUGHOUT
*         WE WILL LOAD THE CORRESPONDING CAPSULE, AND GO.  THE LOADING
*         OF FUNCTION CAPSULE IS DONE BY LOAD.F.  NOTE THAT AS LONG AS
*         XN IS SET, BOTH SKGN$FO AND SKGN$MP WILL BE LOADED.  THIS IS
*         INDEED UNDESIRABLE FOR MIP USERS WHO ONLY NEED THE DATA FILE
*         SKGN.  THIS INSTANCE IS RARE, SO NO SPECIAL EFFORT IS MADE TO 
*         OPTIMIZE THAT.
*#
 SORS     BSS    0
          RJ     F.NOP
          F.RM   XN 
          ZR     X1,SORS.1
          SA2    MP$SKGN
          RJ     LOAD.F 
 SORS.1   SA2    IS$SKGN+B3        LOAD UP THE PROPER SKGN$FO 
          RJ     LOAD.F 
          EQ     CALLFO            GO SAAM$FO 
*#
*0        UPDT
*         FIRST WE MAKE SURE NDX IS NOT ON.  IF SO, ERROR EXIT. 
*         NEXT WE CALL F.NOP TO GET RID OF TRANSIENTS.
*         DO A LOAD.F ON NRO$AA.
*         THEN LOAD.F ON DATA AND OR MIP UPDT.
*         IF RT = D,R,T OR Z, CALL RTJP TO COMPUTE RRL
*         IF RT = F, MOVE FL INTO RRL.
*         SINCE B3 AND B6 WOULD BE DESTROYED, THEY ARE RESTORED AFTER 
*         THE RTJP CALL 
*#
 UPDT     BSS    0
          ON.RM  NDX,UPDTERR       ERROR IF NDX ON
          RJ     F.NOP
          SA2    AA$NRO 
          RJ     LOAD.F            LOAD NRO$AA
          SA2    IS$UPDT+B3 
          RJ     LOAD.F            LOAD UPDT$FO 
*#
*         IF XN IS SET, MIP IS NEEDED, SO WE WILL LOAD UP BOTH IS AND 
*         MIP UPDATE PROCESSORS 
*#
          F.RM   XN 
          ZR     X1,UPDT.1
          SA2    MP$UPDT
          RJ     LOAD.F 
          SA2    IS$UPDT
          RJ     LOAD.F 
 UPDT.1   BSS    0
          EQ.RM  COP,#DLT#,CALLFO,B2,2  NO RL COMP. FOR DELETE
          F.RM   RT,2,B2,-#FT#
          ZR     B2,UPDT.F
          IFEQ   #UT#,7 
          SX4    X2-#UT#
          ELSE
          ERR    RT VALUE CHANGED 
          ENDIF 
          AX4    59 
          BX4    X4*X2
          ZR     X4,CALLFO         SKIP IF RT=W,U OR S
          F.RM   RTJP,B6,+LDRT     SPECIAL RT                            CY211
          SB5    UPDT.T1                                                 RPN1201
          JP     B6 
UPDT.T1   PL     X3,UPDT.T2  SKIP IF EFFECTIVE RL IN RANGE
          MX3    0           ELSE USE 0, WHICH WILL BE CAUGHT LATER 
          EQ     UPDT.RT
UPDT.T2   NE.RM  RT,#ZT#,UPDT.RT,B6 
          F.RM   MNR         IF Z-RECORD, USER GREATER OF X3 AND MNR
          IX6    X3-X1
          PL     X6,UPDT.RT 
          BX3    X1 
 UPDT.RT  SB6    EXIT.N 
          F.RM   FO,,X5,-#IS# 
          LX5    2
          SB3    X5 
 UPDT.ST  SET.RM RRL,X3 
          EQ     CALLFO 
 UPDT.F   F.RM   FL,3 
          EQ     UPDT.ST
 UPDTERR  CRMEP  ES=BADNDX
 CALLFO   SA2    B3+IS$EXEC 
          SX0    B6 
          SX6    X2          SAVE WHERE TO GO 
          LX0    18 
          BX6    X0+X6       SAVE BOTH WHERE TO GO AND RETURN 
          SA6    PAR+1       IN PAR+1 
          MX0    1
          F.RM   NDX
          BX6    X0*X1       ISOLATE NDX BIT
          LX6    5           X6 = 0 IF NDX OFF, 16 IF ON
          SA6    A6-B1       STORE IN PAR 
          SA1    LISTP       SET UP PARAMTER LIST 
          RJ     =YSTMD$AA   CALL STMD$AA 
          RESET  A0,B1       RESET A0 AND B1
          SA1    PAR+1
          SB5    X1          RESTORE WHERE TO GO
          AX1    18 
          SB6    X1          RESTORE WHERE TO COME BACK 
 CALLER   SX6    B6 
          MX0    1                 SET UP EQ BACK TO
          LX0    27                EXIT POINTS
          BX6    X0+X6
          LX6    30 
          SA6    B5 
          JP     B5+1              CALL AS RJ 
*#
*         AT CALLFO, WE SET UP B5 TO WHERE WE WANT TO GO
*         CALLER WILL USE THE B5 VALUE TO DO THE SIMULATED RJ 
*         A STMD$AA CALL HAS TO BE MADE BEFORE GOING INTO THE PROPER
*         PROCESSORS.  SINCE THAT ROUTINE IS IN SYMPL, WE HAVE BETTER 
*         SAVE AND RESTORE ALL THE NEEDED REGISTERS BEFORE AND AFTER
*         THE CALL.  FOR NDX OPERATION, STMD$AA IS CALLED WITH 16.
*         OTHERWISE, IT IS CALLED WITH A 0. 
*#
*#
*0CD      SUBROUTINE F.NOP
*0        PURPOSE 
*         TO UN.OAD ANY TRANSIENTS AND TO LOAD UP INDX$NP IF NDX IS ON
*0        ENTRY CONDITIONS
*         A0=FIT, B1=1
*0        EXIT CONDITIONS 
*         OPEN AND/OR KDEF CAPSULE WILL BE UNLOADED.  INDX$MP WILL BE 
*         LOADED IF NDX IS ON 
*0        REGISTERS SAVED 
*         A0,B1,B3,B6 
*0        ROUTINES CALLED 
*         UNLD.U - UNLOAD UNCONDITIONALLY 
*         LOAD.F - LOAD INDX$MP AS A FUNCTION PROCESSOR.
*0        DESCRIPTION 
*         EXAMINE OPEN$AA AND KDEF$MP.  UNLOAD THEM IF LOADED.
*         IF NDX IS ON, DO A LOAD.F TO TRY TO LOAD INDX$MP
*#
 F.NOP    BSS    1
          SA5    TCAPF
          PL     X5,F.N1     SKIP IF NO TRANSIENT LOADED
          MX6    0
          SA6    A5          CLEAR TRANSIENT LOADED INDICATOR 
          SA2    OPN$AA                                                  *--AK--
          SB4    X2          TEST IF LOADED                              CY209
          NG     B4,F.N0     SKIP IF NOT LOADED                          CY209
          SX1    =YAAM$LOK
          NG     X1,UNLOAD
          SA4    =YAAM$LOK   TEST IF LOCK FOR CDCS INDICATED
          SB7    X4 
          NG     B7,F.N0     IF SET,SKIP UNLOAD 
 UNLOAD   RJ     UNLD.U      UNLOAD OPEN
 F.N0     BSS    0                                                       CY209
          SA2    KDF$MIP     UNLOAD KEYDEF CAPSULE
          SB4    X2                                                      CY209
          NG     B4,F.N1     SKIP UNLOAD IF CAP NOT LOADED               CY209
          RJ     UNLD.U 
 F.N1     BSS    0
          OFF.RM NDX,F.NOP
          SA2    MP$RARE     LOAD THE INDEX ONLY PROCESSOR
          RJ     LOAD.F 
          EQ     F.NOP
          SPACE  3
*#                                                                       CY211
*         WE ARRIVE AT LDRT FOR THE FIRST PUT WITH SPECIAL RT.THE REASON CY211
*         IS RTJP IN THE FIT IS INITIALIZE TO 0.  HERE WE WILL LOAD      CY211
*         UP THE SPECIAL RTJP ROUTINE BY A LGO.RM CALL TO LDRT$AA. ON    CY211
*         RETURN, WE WILL SET UP RTJP SUCH THAT IT WILL BE = ENTRY       CY211
*         POINT OF RTJP-LDRT.  THE SUBSEQUENT JUMPS FOR UPDATE WILL      CY211
*         THEN GO DIRECTLY INTO THE RTJP ROUTINE.                        CY211
*#                                                                       CY211
          LDSET  OMIT=RMP$LR/LDRT$AA                                     CY211
 LDRT     BSS    0                                                       CY211
          SB6    LDRT.1                                                  CY211
          LGO.RM =XRMP$LR                                                CY211
-         SB0    =XLDRT$AA   FORCE LOADING OF LDRT$AA                    CY211
 LDRT.1   F.RM   RTJP,B6                                                 CY211
          SX6    B6-LDRT     SET UP PORPERLY OFFSET                      CY211
          SET.RM RTJP,X6,,,T MAKE SURE SIGN DOES NOT PROPAGATE           CY211
          SB5    UPDT.T1                                                 RPN1201
          JP     B6          CALL SPECIAL RT ROUTINE TO COMPUTE RL       CY211
          SPACE  2                                                       CY211
 TCAPF    BSSZ   1
 LISTP    VFD    42/0,18/PAR
 PAR      BSS    2           TEMPORARY STORAGE CELL 
*#
*0        ON NOW WITH THE EXITS.
*         EXIT.O, WHERE OPEN RETURNS, CHECK TO SEE IF THE LAST OPEN WAS 
*         SUCCESSFUL.  IF YES, EVERYTHING IS FINE, AND WE GO TO EXIT.N
*         TO JOIN THE OTHERS.  OTHERWISE WE WILL SET X6 TO  0LAAM.CTL,
*         AND JOIN CLOSE.  THIS IS TO TAKE CARE OF THE SITUATION WHERE
*         THE UNSUCCESSFUL CLOSE MIGHT RESULT IN SOME CAPSULES NOT BEING
*         UNLOADED.  THESE CAPSULES INCLUDE OPEN ITSELF, THE TRANSIENTS,
*         THE DEMAND CAPSULES(RARE), AND AAM$CTL.  A CHECK IS MADE TO 
*         SEE IF ALL AAM FILES ARE CLOSED.  IF SO, A FULL PASS IS MADE
*         ACTUALLY ON ALL THE CAPSULES ENTRIES, UNLOADING EVERY LOADED
*         ONE.  FOR STATIC LOADING, THE CAPSTAT WORD IN AAM$CTL LOOKS 
*         AS IF THERE IS AT LEAST ONE MORE FILE IN USE, SO NO UNLOADING 
*         WILL BE DONE. 
*#
          ENTRY  EXIT$AA
 EXIT$AA  BSS    0           SOME ERRORS WILL RETURN HERE 
 EXIT.O   BSS    0
          RESET  A0,B1
          EQ.RM  OC,#OPE#,EXIT.N1,B4 JOIN HANDS AT EXIT.N1
          SA5    CAPN$AA
          EQ     CLUN              TEST FOR POSSIBLE UNLOAD 
*#
*0        EXIT.C IS WHERE CLOSE RETURNS.  RESET IS CALLED TO RESTORE
*         A0 AND B1.  THE NEXT STEP IS CLUN.  HERE, WE TEST IF THERE ARE
*         ANY MORE OPENED AAM FILE.  THIS WE DO BY EXAMINING THE CAPSTAT
*         COUNT OF AAM$CTL.  IF COUNT IS ONE, THERE ARE NO MORE AAM FILE
*         LEFT, AND THE CONTROLLER IS GOING TO BE UNLOADED NEXT.  BEFORE
*         DOINT THAT, LETS TAKE A LOOK TO SEE IF THERE ARE ANY MORE 
*         CAPSULES LEFT.  IF SO, UNLOAD THEM ALL.  FINALLY, X5 IS TESTED
*         FOR OPEN ERROR CONDITION. IN THE CASE OF THE UNSUCCESSFUL OPEN
*         X5 IS NONZERO, SO WE WILL UNLOAD AAM$CTL ALSO.
*         IF X5 IS ZERO, WE MUST BE DROPPING THROUGH ON A CLOSE.  WE
*         PROCEED AT TAG CLUN.0.  IF AN ERROR OCCURS DURING CLOSE,
*         SET E60.  THEN JUMP DOWN TO EXIT.N2, WHERE WE WILL RETURN TO
*         CLSF$RM THROUGH THE B6 STACK. 
*#
 EXIT.C   BSS    0
          RESET  A0,B1
          MX5    0           NO UNLOAD OF AAM$CTL 
 CLUN     SA1    CAPSTAT     DO WE HAVE ANY MORE FILES LEFT 
          SX1    X1-1 
          NZ     X1,EXIT.N1  SKIP IF YES
          SF.AA  GCOM$AA,NOTFRST,0
          SB3    AA$NRO-OPN$AA     SET UP SEARCH INDEX                   *--AK--
 CLUN.1   SA2    B3+OPN$AA                                               *--AK--
          SB5    X2 
          SB3    B3-B1
          LE     B5,B0,CLUN.2      SKIP IF NOT LOADED 
          RJ     UNLD.U 
 CLUN.2   PL     B3,CLUN.1   LOOP BACK TO UNLOAD NEXT CAPSULE 
          ZR     X5,EXIT.N2  SKIP IF CLOSE
          SA4    =YOFCT$RM   ADJUST OPENED CRM FILE COUNT 
          SX6    X4-1        DECREMENT
          SA6    A4 
          MX0    42 
          SX6    SETNAME
          BX5    X0*X5
          BX6    X6+X5
          SA6    =YRM$TMP 
*#
*0        EXIT.N
*         EVERY EXIT WILL EVENTUALLY JOIN HANDS HERE.  HERE THE ERROR 
*         EXIT IS TAKEN IF ES IS SET.  OTHERWISE, WE POP THE B6 STACK,
*         AND RETURN
*#
 EXIT.N   BSS    0
          RESET  A0,B1
 EXIT.N1  BSS    0
          F.RM   ES 
          CRMEP  IFOP=(NZ X1)      TAKE ERROR EXIT IF ES IS SET 
 EXIT.N2  BSS    0
          RESTORE                  POP B6 STACK 
          JP     B6                RETURN 
*#
*0        EXIT.G
*         GET,GETN AND GETNR RETURNS HERE.  THE ONLY COMPLICATION HERE
*         IS IF A RECORD IS RETURNED (FP NOT EOI), AND RT=2, WE NEED TO 
*         BLANK PAD THE WSA FROM RL TO MRL.  IF FP NE EOR, WE PROCEED AT
*         EXIT.P1 TO SEE IF DATA EXIT CONDITIONS HAVE BEEN ENCOUNTERED. 
*         NOTE THAT X5 WILL CONTAIN THE FP VALUE AS WE BRANCH TO EXIT.P1
*       AS USUAL, CONTROL GOES TO EXIT.N1 WHEN EVERYTHING IS DONE.
*#
 EXIT.G   BSS    0
          RESET  A0,B1
          EQ.RM  FP,#EOI#,EXIT.P1,B2,5     SKIP IF FP=EOI 
          NE.RM  RT,#ZT#,EXIT.N1,B2        SKIP TO EXIT.N1 IF RT NE Z 
          F.RM   MRL,1                                                   GAG1121
          SX2    X1+9                                                    GAG1121
          SX3    52429                                                   GAG1121
          IX4    X2*X3                                                   GAG1121
          AX4    19          X4=MRL/10 ROUNDED UP                        GAG1121
          SX5    10                                                      GAG1121
          IX2    X5*X4       X2=MRL ROUNDED UP                           GAG1121
          F.RM   RL,1        X1=RL                                       GAG1121
          SX6    X1+9                                                    GAG1121
          IX7    X6*X3                                                   GAG1121
          AX7    19          X7=RL/10 ROUNDED UP                         GAG1121
          IX3    X4-X7                                                   GAG1121
          SB2    X3          B2=EXTRA WORDS OF BLANKS                    GAG1121
          F.RM   WSA,3,,,6                                               GAG1121
          IX3    X3+X7                                                   GAG1121
          SA3    X3-1        LAST WORD OF RL                             GAG1121
          IX7    X7*X5       X7=RL ROUNDED UP                            GAG1121
          IX7    X7-X1       X7=UCC                                      GAG1121
          SA4    BLANKS                                                  GAG1121
          MX0    1                                                       GAG1121
          SX5    -6                                                      GAG1121
          IX7    X7*X5                                                   GAG1121
          SB3    X7+59                                                   GAG1121
          AX0    X0,B3       MASK TO EXCLUDE UCC                         GAG1121
          BX6    -X0*X4                                                  GAG1121
          BX3    X0*X3                                                   GAG1121
          BX6    X6+X3                                                   GAG1121
EXIT.G3   SA6    A3                                                      GAG1121
          ZR     B2,EXIT.N1                                              GAG1121
          BX6    X4                                                      GAG1121
          SA3    A3+B1                                                   GAG1121
          SB2    B2-B1                                                   GAG1121
          EQ     EXIT.G3                                                 GAG1121
*#
*0        EXIT.P
*         HERE FP IS CHECKED AGAINST BOI AND EOI.  IF SO, THE DATA EXIT 
*         IS TAKEN.  OTHERWISE, WE GO BACK TO EXIT N1 TO DO THE NORMAL
*         EXIT. 
*#
 EXIT.P   BSS    0
          RESET  A0,B1
 EXIT.P1  BSS    0
          F.RM   ES 
          NZ     X1,EXIT.N1 
          F.RM   DX,,B6 
          ZR     B6,EXIT.N1        NORMAL EXIT IF DX=0
          EQ.RM  FP,#EOI#,EXIT.P2,B2     SKIP IF FP=EOI 
          SB2    X1-#BOI# 
          NZ     B2,EXIT.N1        NORMAL EXIT IF FP NE BOI OR EOI
 EXIT.P2  SA1    A0+#B6STK# 
          MX6    0                 CLEAR RETURN STACK 
          SA6    A1 
 EXIT.P3  SX5    X1 
          AX1    18 
          NZ     X1,EXIT.P3        POP TO TOP ENTRY OF STACK
          MX6    1                 SET UP BACK TO USER
          LX6    27 
          BX6    X6+X5
          LX6    30 
          SA6    B6                STORE INTO ENTRY POINT OF DX 
          JP     B6+1 
*#
*1        ON WITH THE LOAD UNLOAD ROUTINES. 
*         LOAD.T,ALSO CALL LOAD$AA, WILL LOAD A CAPSULE IN THE AAM$CTL
*         GROUP.
*0        INPUT PARAMETERS
*         A2 = ENTRY TABLE ENTRY ADDRESS OF CAPSULE 
*         X2 = 4=/0LCAPNAME,18/=Y_EPTNAME 
*         A0 = FIT, B1=1
*0        REGISTERS PRESERVED 
*         X5,B3,B6,A0. B1=1 
*0        DESCRIPTION 
*         X4 IS SET TO THE GROUP NAME, AND RM$LDC IS CALLED.
*         THE ROUTINE IS CALLED TO LOAD A CAPSULE UNCONDITIONALLY.
*#
 LOAD$AA  BSS    0
 LOAD.T   BSS    1
          SX4    SETNAME
          RJ     =YRM$LDC          LOAD THE CAPSULE 
          EQ     LOAD.T 
*#
*0        LOAD.R
*         THIS IS CALLED WITH THE SAME CONDITION AS LOAD.T, WITH THE
*         EXCEPTION THAT X5 REPRESENT A BIT MASK OF CAPSULE USAGE.
*         LOAD.R RETURNS DIRECTLY WITHOUT ACTION IF THE BIT CORRESPOND- 
*         ING TO THE CAPSULE IS SET.  SINCE AAM$CTL IS THE FIRST CAPSULE
*         IN THE ENTRY TABLE, BUT LOADING OF THAT CAPSULE IS NEVER DONE 
*         WITHIN AAM, THE OFFSET OF ANY OTHER CAPSULE IS USED AS A SHIFT
*         COUNT TO EXAMINE THE BIT. 
*#
 LOAD.R   BSS    1
          SB2    A2-CAPN$AA 
          MX1    1
          LX1    X1,B2
          BX7    X1*X5
          NZ     X7,LOAD.R         EXIT IF BIT ALREADY SET
          BX5    X1+X5             SET THE BIT
          SX4    SETNAME
          RJ     =YRM$LDC          LOAD THE CAPSULE 
          EQ     LOAD.R 
*#
*0        LOAD.F
*         LOAD.F ASSUMES THAT FIAT$AA IS SET UP.  IT PICKS UP THE 
*         CAPSULE USAGE MASK FROM THE FIAT, AND USE IT TO CALL LOAD.R 
*#
 LOAD.F   BSS    1
          SA5    FIAT$AA           PICK UP USAGE MASK 
          RF.AA  X5,FACAPUS,5 
          RJ     LOAD.R 
          SA1    FIAT$AA
          SF.AA  X1,FACAPUS,X5
          EQ     LOAD.F 
*#
*1        UNLD.U
*         ALSO CALL UNLD$AA.  UMLOAD A CAPSULE UNCONDITIONALLY.  THIS IS
*         DONE BY PLACING THE CAPSULE NAME ON RM$TMP AND THEN CALL
*         RM$UTC. 
*0        CALLING SEQUENCE
*         SA2    CAPENT      CAPENT = CAPSULE ENTRY ON PASSLOC TABLE
*         RJ     UNLD.U 
*         REGISTERS SAVED 
*         B3,B6,X5, A0. B1=1. 
*0        DESCRIPTION 
*         FIRST EXAMINE THE NOFDL FLAG.  IF SET, RETURN WITHOUT, ACTION.
*         OTHERWISE, SAVE B6 IN B2, CALL RM$UTC TO CLEAR RM$TMP, BUILD
*         THE COMPOSITE, STORE IT INTO RM$TMP, AND CALL UTC AGAIN TO
*         UNLOAD IT 
*#
 UNLD$AA  BSS    0
 UNLD.U   BSS    1
          RF.AA  GCOM$AA,NOFDL
          NG     X1,UNLD.U         RETURN IF ONLY STATIC LOAD IS ALLOWED
          SB2    B6                SAVE B6
          BX0    X2                SAVE CAPSULE NAME
          RJ     =YRM$UTC    CLEAR RM$TMP 
          MX7    42                BUILD COMPOSITE
          SX1    SETNAME
          BX7    X7*X0
          BX7    X7+X1       OR IN POINTER TO GROUP NAME
          SA7    RM$TMP 
          RJ     RM$UTC            UNLOAD IT
          SB6    B2                RESTORE B6 
          EQ     UNLD.U 
*#
*1CD      CCAL$AA 
*         THIS ROUTINE IS CALLED TO HANDLE CONDITIONAL CALLS.  WITH 
*         DYNAMIC LOADING, A RARE CAPSULE WHICH IS NOT IN USE CAN BE
*         UNLOADED TO FREE UP SPACE FOR OTHER USAGE.  BECAUSE OF THAT,
*         AN ENTRY POINT IN ONE OF THESE CAPSULES MUST NEVER BE CALLED
*         DIRECTLY.  CONTROL ALWAYS GOES THROUGH HERE, WHICH ENSURES
*         (1) CAPSULE CONTAINING THE ENTRY POINT IS LOADED. 
*         (2) CAPSULE IS DELINKED FROM THE KICKOUT CHAIN WHILE IN USE.
*             AND RELINK AFTER USE. 
*0        CALLING SEQUENCE
*         CALLED FROM SYMPL BY XXXX$FO(PARAM.LIST)
*         DEF TO CALCODE=N; CCAL$AA(PARAM LIST) 
*0        DESCRIPTION 
*         THE FIRST 12B WORDS CONTAINS A SET OF CODE MODIFICATION STUFF.
*         CAUTION SHOULD BE EXERCISED WHILE CHANGING THIS CODE. 
*         THE CODE MODIFICATION WORKS AS FOLLOWS. 
*         THE VERY FIRST TIME THAT THIS ROUTINE IS CALLED, THE CAPSULE
*         NEEDED SHOULD, BY OUR NORMAL LOADING LOGIC DURING OPEN, NOT BE
*         LOADED.  IF IT IS, THAT CAPSULE MUST HAVE BEEN STATICALLY 
*         LOADED, AND AS AAM DOES NOT ALLOW PARTIAL STATIC LOADING, ALL 
*         CAPSULES WILL BE STATICALLY LOADED.  HENCE THE CODE IS
*         MODIFIED TO STORE THE RJ WORD INTO DYN, AND THE RJ IS DONE. 
*         IF DYNAMIC LOADING IS INVOLVED THOUGH, CODE IS MODIFIED TO
*         TRANSFER CONTROL TO EITHER
*         (1) CAL.1 - IF CAPSULE IS NOT LOADED
*         (2) CAL.2 - IF CAPSULE IS LOADED
*         FOR SUBSEQUENT CALLS. 
*         STATIC LOADING WILL RESULT IN A TRANSFET TO CAL.3, WHERE THE
*         RJ IS STUFFED INTO 5PS, AND THE CALL IS MADE
*0        AT CAL.1, WE NEED TO LOAD UP THE CAPSULE.  FIRST WE ASCERTAIN 
*         THAT THERE IS ENOUGH ROOM TO LOAD THAT CAPSULE.  IF NOT, WE 
*         WILL CALL RESP$AA TO FIND US SOME SPACE.  IF EVEN RESP$AA 
*         FAILS, WE HAVE A FATAL ERROR.  IF EVERYTHING GOES WELL, WE
*         WILL CALL LOAD.T TO LOAD UP THE CAPSULE.  ON RETURN, B5 POINTS
*         TO THE DUMMY BLOCK HEADER THAT WE HAVE BUILT INTO THE CAPSULE.
*         6 WORDS BACK FROM IT IS THE CAPSULE HEADER, AND WE WILL 
*         EXTRACT THE ACTUAL CAPSULE LENGTH FROM THE CAPSULE HEADER.
*         THERE ARE TWO LENGTHS OF INTERESTS, THE AMOUNT OF SPACE NEEDED
*         TO LOAD THE CAPSULE, AND THE ACTUAL SIZE OF THE CAPSULE AFTER 
*         IT IS BEING LOADED.  THESE TWO LENGTHS ARE DIFFERENT.  FIRST
*         WHETHER WE CAN LODD THE CAPSULE.  THE SECOND LENGTH IS IN WORD
*         2 OF CAPSULE HEADER.  THIS LENGTH IS MOVED INTO THE DUMMY 
*         BLOCK HEADER, WHICH IS USED BY THE SPACE MANAGER OF AAM WHEN
*         IT NEEDS TO FREE UP SPACE 
* 
*         IN ONLY ONE CASE WILL CCAL$AA BE CALLED WITH A NEGATIVE VALUE 
*         IN CALCODE. THIS IS WHEN CMM HAS REFUSED SPACE FOR A BLOCK
*         BUFFER, WHILE A RARE CAPSULE IS IN CORE BUT DE-LINKED FROM THE
*         KICK-OUT CHAIN. IT COULD NOT HAPPEN IF CAPSULES ARE STATICALLY
*         LOADED. THE RARE CAPSULE WOULD BE DE-LINKED BECAUSE IT WAS
*         BEING EXECUTED, BUT AN UTTER CMM FAILURE SENT CONTROL SOME- 
*         WHERE ELSE, SO WE NEVER EXITED FROM THE RARE CAPSULE TO 
*         JPWORD+1. NOW SOME REPAIR PROGRAM WANTS TO GET THE CAPSULE
*         RE-LINKED, SO AS NOT TO LEAVE IT IN AN ABNORMAL CONDITION.
*         IT CALLS CCAL$AA WITH CALCODE NEGATIVE. WE JUMP IMMEDIATELY 
*         TO JPWORD+1, TO RE-LINK INTO THE KICK-OUT CHAIN WHATEVER
*         RARE CAPSULE WAS MOST RECENTLY ENTERED FROM JPWORD. 
*#
 LIST1    VFD    42/0,18/STATIC 
          VFD    42/0,18/JPS
 STATIC   SA3    MOD2 
          LX3    30 
          BX7    X3 
 JPS      SA7    CCAL 
          RJ     CAL.3-1     DUMMY RJ TO CLEAR INST STACK 
 CCAL$AA  BSS    1
          RF.AA  GCOM$AA,CALCODE,4
          NG     X4,JPWORD+1   CALL JUST TO RE-LINK CAPSULE 
          SA5    X4+CJPN$AA        LOAD UP RJ WORD
          SB1    1
          BX6    X5 
 CCAL     SA5    X5          LOAD POINTER TO LENGTH WORD
          SA2    X5          LOAD UP CAPSULE ENTRY IN TABLE 
          SB5    X2          TEST IF CAPSULE LOADED 
          SX7    A1          SAVE A1
 MOD1     SA7    PAR
          PL     B5,STATIC   NOTE THE MOD LATER 
          MX7    42 
          SA3    MOD1 
          BX7    X7*X3
          SX3    CAL.2
          SA4    MOD2 
          BX7    X7+X3
          SA7    A3 
          BX7    X4 
          SA7    A7+B1
 MOD2     EQ     CAL.1
 -        EQ     CAL.3
          BSS    1           PLACE HOLDER FOR DUMMY RJ AT JPS 
 CAL.3    SA6    JPS
          JP     JPS
 CAL.1    SA6    JPWORD            SAVE RJ WORD 
          RF.AA  GCOM$AA,RUNTOTC,4 X4 = RUNNING TOTAL OF SPACE USED.
          RF.AA  GCOM$AA,TARGET,3  X3 = TARGET
          AX5    30                X5 = LENGTH TO LOAD CAPSULE
          IX6    X5+X4
          IX6    X6-X3
          NG     X6,CAL.4          SKIP IF TARGET NOT EXCEEDED
          MX7    0
          SA6    STATIC            SET UP PARAMETER LIST FOR RESP$AA
          SA1    LIST1             RESP$AA REQUIRES TWO PARAMETERS
          SA7    A6+B1             STORE A ZERO FSTT POINTER
          RJ     =YRESP$AA         CALL 
* IT DOES NOT MATTER IF WE RELEASED AS MUCH AS WE WANTED. WE TRIED.      CY209
* CODE AT LENOK - TARGOK WILL BUMP TARGET IF WE DID NOT RELEASE ENOUGH.  CY209
*#
*0        AT CAL.4, WE WILL SET UP TO LOAD THE CAPSULE.  ON RETURN, B5
*         POINTS TO THE DUMMY BLOCK HEADER.  WE WILL EXTRACT THE LENGTHS
*         FROM THE CAPSULE HEADER, AND SET THOSE LENGTHS UP FIRST.
*         NEXT, WE POP THE REVISED RJ WORD INTO JPWORD, AND PROCEED WITH
*         THE CALL. 
*#
 CAL.4    SA5    JPWORD 
          SA5    X5 
          SA2    X5                A2 = CAPSULE ENTRY 
          RJ     LOAD.T            LOAD THE CAPSULE 
          RF.AA  GCOM$AA,CALCODE,5
          SA5    X5+CJPN$AA           RELOAD RJ WORD
          BX6    X5 
          SA6    JPWORD 
          SA3    X5          PICK UP LENGTH OF CAP FROM TABLE 
          SA5    B5-2        LOAD FDL HEADER CONTAINING TRUE LENGTH 
          LX3    30          ISOLATE LENGTH 
          SX4    X3 
          RF.AA  GCOM$AA,MINTARG,2   NOTE-X2 NEEDED AFTER LENOK 
          NZ     X4,LENOK    SKIP IF LENGTH IS ET 
          SX4    X5          USE LENGTH FROM FDL HEADER 
          BX6    X3+X4
          LX6    30 
          RF.AA  GCOM$AA,MAXRARE,5
          SA6    A3          RESTORE TABLE ENTRY WITH TRUE LENGTH 
          IX7    X5-X4
          PL     X7,LENOK          SKIP IF CURRENT MAXRARE BIG ENOUGH 
          SF.AA  GCOM$AA,MAXRARE,X4,1,6,0 USE NEW MAXRARE 
          IX2    X2-X5
          IX2    X2+X4             NEW MINTARG VALUE
          BX6    X2 
          SA6    A2          RESTORE NEW MINTARG
 LENOK    BSS    0
          RF.AA  GCOM$AA,RUNTOTC,5
          BX6    X4 
          IX7    X5+X4
          SF.AA  GCOM$AA,RUNTOTC,X7      BUMP RUNNING TOTAL 
          RF.AA  GCOM$AA,TARGET,3 
          IX5    X7-X2             GET LARGEST OF MINTARG AND RUNTOT
          PL     X5,RUNMAX
          BX7    X2                X7 = LARGEST 
 RUNMAX   BSS    0
          IX4    X3-X7
          PL     X4,TARGOK         JUMP IF TARGET BIGEST OF THREE 
          SA7    A3                STORE BIGGEST IN TARGET
 TARGOK   BSS    0
          LX6    18          SET UP DUMMY BLKLNG
          SA6    B5+2 
          SA1    PAR                     RESTORE A1 
          SA1    X1 
          RJ     NEARJP      GO JPWORD,CLEAR INSTR STACK
*#
*0        AT CAL.2, THE CAPSULE IS ALREADY LOADED.  LETS DELINK IT FROM 
*         KICKOUT, AND DROP THROUGH TO JPWORD TO CALL THE ENTRY POINT.
*#
 CAL.2    SX7    B5 
          SA7    STATIC      SETUP FOR DELINK CALL
          SA1    LIST1       A1=UNCHAIN POINTER 
          SA6    JPWORD      STORE RJ WORD
          RJ     =YUNCH$AA   CALL DELINK
          SA1    PAR
          SA1    X1 
          RJ     NEARJP      GO JPWORD,CLEAR INSTR STACK
NEARJP    DATA   0           SPACE FOR DUMMY RJ TO CLEAR STACK
          RF.AA  GCOM$AA,CALCODE,4
          BX6    -X4         SET CALCODE NEGATIVE 
          SX6    X6-1        TO SHOW A RARE CAPSULE 
          SA6    A4          IS BEING EXECUTED
 JPWORD   RJ     *+1S17 
*#
*0        ON RETURN FROM JPWORD CALL, WE WILL RELINK THE CAPSULE AT THE 
*         TOP OF THE KICKOUT CHAIN, RESTORE CALCODE TO POSITIVE 
*         TO SHOW WE NO LONGER HAVE AN UNLINKED RARE CAPSULE, 
*         AND EXIT. 
*#
          SB1    1
          SA5    JPWORD 
          SA5    X5 
          SA2    X5 
          SX7    NUMLIV                                                  CY209
          SF.AA  X2,BLLIVES,X7   SET UP LIVES OF RARE CAPSULE            CY209
          SX7    GCOM$AA+?BFCHNHD 
          SX6    X2 
          SA6    STATIC 
          SA7    A6+B1
          SA1    LIST1
          RJ     =YINCH$AA         LINK INTO KICKOUT
          RF.AA  GCOM$AA,CALCODE,4
          BX6    -X4
          SX6    X6-1 
          SA6    A4 
          EQ     CCAL$AA           RETURN 
          SPACE  2                                                       RPN1116
 AAM$ENV  CAP.RM                                                         RPN0524
 FLUSH    BSS    0                                                       RPN1116
*#                                                                       RPN1116
*         FLUSH IS ENTERED WITH X1 POINTING TO A LIST OF FILES TO BE     RPN1116
*         FLUSHED.  FLSH$AA IS CALLED TO DO THE WORK FOR AAM FILES.      RPN1116
*         ON RETURN,,B6 IS USED TO RETURN TO USER.                       RPN1116
*#                                                                       RPN1116
          BX6    X1                                                      RPN1116
          SA6    PAR
          SX6    B6          SAVE RETURN ADDRESS
          SA6    JPWORD      USE JPWORD AS TEMP TO SAVE IT
          SA1    LISTP       SET PARAMETER LIST 
          RJ     =XFLSH$AA   CALL FLUSH 
          SA1    PAR         RESOTRE X1 
          SA5    JPWORD 
          SB6    X5                                                      RPN1116
          SB1    1
          JP     B6          RETURN TO USER                              RPN1116
          TITLE  LOAD$AA                                                020160
          ENTRY  UNL1$AA                                                022600
*#                                                                      022610
*1CD      UNL1$AA                                                       022620
*0CD      FUNCTION                                                      022630
*         TO LOAD OR UNLOAD A SPECIFIC CAPSULE.                         022640
*0CD      ENTRY CONDITIONS                                              022650
*         A1 POINTS TO A SYMPL TYPE CALL PARAMETER LIST OF TWO          022660
*         PARAMETERS.  THE FIRST PARAMETER CONTAINS THE ADDRESS OF THE  022670
*         CAPSULE NAME ENTRY IN THE CAPSULE NAME TABLE.  THE SECOND     022680
*         PARAMETER IS 0 IF THE REQUEST IS FOR UNLOAD, 1 OTHERWISE.     022690
*0CD      EXIT CONDITIONS                                               022700
*         B1=1, A0 PRESERVED, NO OTHER REGISTERS ARE GUARANTEED.        022710
*0CD      DESCRIPTION                                                   022720
*         ON ENTRY, PICK UP THE ADDRESS, PUT IT INTO CELL X, AND        022730
*         SET UP TO CALL LOAD$AA OR UNLD$AA DEPENDING ON P2.  NOTE      022740
*         THAT IT USES THE LOCAL CELL X IN ROUTINE UNLD$AA.             022750
*#                                                                       JJJ0916
 UNL1$AA  BSS    1                                                      022760
          SB1    1                                                      022770
          SA1    X1          LOAD UP ADDRESS OF CAPSULE 
          SA2    X1-1        GET CAPSULE NAME FROM BLOCK -1 
          SA5    X1+2        GET BLKLNG 
          RJ     UNLD.U      GO UNLOAD CAPSULE
          AX5    18 
          SX5    X5 
          RF.AA  GCOM$AA,RUNTOTC,4
          IX6    X4-X5       DECREMENT RUNNING TOTAL
          SA6    A4          RESTORE RUNNING TOTAL
          EQ     UNL1$AA     RETURN 
 KILLAAM  BSS    0                                                       CY209
          CRMEP  ES=AAMALF,FNF=1,INA=FATINS    ISSUE MALF ON THIS FIT    CY209
                                                                         CY209
FATINS    CRMEI  TYPE=2,MODE=1,DIS=1,LEN=1,LOC=GCOM$AA+?IMPERR,EOL=1
          TITLE  CCAL$AA                                                022930
 COPB     BSS    0
          ORG    TRKY$IS           USE THE TRANSLATE KEY BUFFER 
 COPYRT   DATA   C$ COPYRIGHT CONTROL DATA SYSTEMS, INC. - 1994$
 COPYLIM  EQU    *-COPYRT 
          IFGT   COPYLIM,25,1 
          ERR    COPYRIGHT MESSAGE IS GREATER THAN TRKY$IS
          ORG    COPB 
          END                                                           023980
