          EJECT
*         CTEXT  CTP$DFT READ MAINTENANCE REGS.
 RMR      SPACE  4,10
**        RMR - READ MAINTENANCE REGISTERS.
*
*         ENTRY  (REGI) = NUMBER OF LIST ENTRIES.
*                (REGL) = ARRAY OF LIST ADDRESSES TO PROCESS.
*
*         EXIT   THE MAINTENANCE REGISTERS IN EACH SPECIFIC LIST FOR
*                THE MODEL AND ELEMENT ARE READ AND STORED IN MAINTENANCE
*                REGISTER BUFFER 0.
*
*         CALLS  SLM, SNR, SPB, SRB, ZMR.


          ROUTINE RMR

*         ZERO MAINTENANCE REGISTER BUFFER.

          LRD    DP+1
          RJM    SPB         SET PP BOUNDARY
          RJM    ZMR
          LDM    IOUN
          ZJN    RMR0        IF IN IOU0
          RJM    ZSS         ZERO SUPPORTIVE STATUS BUFFER
 RMR0     LDM    REGI        GET SIZE OF LIST
          STD    T3
          LDN    0
          STD    T4          INITIALIZE CURRENT INDEX
          LDDL   MP
          RJM    SRB         SAVE BASE OFFSET TO BUFFER
 RMR1     LDM    REGL,T4     GET AN ELEMENT TYPE
          STM    RMRA        SAVE ELEMENT TYPE
          RJM    SCC         SET CONNECT CODE
          AOD    T4
          LDM    REGL,T4     GET LIST ADDRESS
          STD    T1
          LDI    T1
          STD    T6          SAVE LIST LENGTH
          AOD    T1          INCREMENT ADDRESS PAST LENGTH HEADER
          LRD    MP+1        SET UP *R* TO POINT TO BUFFER
 RMR2     LDI    T1          GET REGISTER NUMBER FROM LIST
          STD    RN

*         AT THIS POINT CHECK IF REGISTERS ARE BEING READ FOR A PROCESSOR
*         IF THEY ARE AND THE REGISTER IS SUMMARY STATUS THEN GET THE ORIGINAL
*         SUMMARY STATUS BEFORE THE PROCESSOR WAS HALTED BY THE *APE* OVERLAY.

          NJN    RMR4        IF NOT SUMMARY STATUS
          LDM    RMRA        GET ELEMENT TYPE
          SBN    PROCID
          NJN    RMR4        IF NOT A PROCESSOR
          LDN    7
          STD    T5          NUMBER OF BYTES TO STORE
 RMR3     LDM    OLSS        GET OLD SUMMARY STATUS
          STM    RDATA,T5
          SOD    T5
          PJN    RMR3
          UJN    RMR5        CONTINUE

 RMR4     READMR RDATA
 RMR5     LDM    S0FLG       CHECK MAINFRAME TYPE
          ZJN    RMR6        IF NOT S0/S0E
          LDM    RMRA        GET ELEMENT TYPE
          SHN    14          POSITION TO UPPER HEX DIGIT
          LMDL   RN
          STDL   RN          SAVE FOR STORE TO MRB
 RMR6     RJM    SNR         STORE REGISTER IN BUFFER
          SOD    T6
          MJN    RMR7        IF LIST EXHAUSTED
          AOD    T1          ADDRESS OF NEXT REGISTER IN LIST
          LJM    RMR2        LOOP

 RMR7     AOD    T4          BUMP CURRENT INDEX
          SBD    T3          SUBTRACT FROM LENGTH
          MJP    RMR1        LOOP
          LDN    0
          STM    REGI        RESET REGISTER INDEX

*         SET THE LOGGED MRB SIZE IN THE SCRATCH SUPPORTIVE STATUS BUFFER.

          LDDL   T2          DETERMINE LOGGED MRB SIZE
          ZJN    RMR8        IF NO PARTIAL GROUPING
          AODL   T2
 RMR8     LDML   /DSIPUR/RINX
          SBDL   MP
          RAML   T2
          RJM    SLM         SET LOGGED MRB SIZE IN SUPPORTIVE SCRATCH BUFFER
          LJM    RMRX        RETURN

 RMRA     CON    0           STORAGE FOR ELEMENT TYPE

 SCC      SPACE  4,10
**        SCC - SET CONNECT CODE.
*
*         ENTRY  (A) = ELEMENT TYPE FROM REGISTER LIST ENTRY.
*
*         EXIT   *EC* SET TO PROPER ELEMENT CONNECT CODE.
*
*         USES   T1.


 SCC      SUBR               ENTRY/EXIT
          STD    T1          SAVE ELEMENT TYPE
          LMK    IOUID
          NJN    SCC1        IF NOT IOU
          LDM    I0CC
          STD    EC
          UJN    SCCX        RETURN

 SCC1     LDD    T1
          SBN    CMID
          NJN    SCC2        IF NOT MEMORY
          LDM    CMCC
          STD    EC
          UJN    SCCX        RETURN

 SCC2     LDD    T1
          SBN    PROCID
          NJN    SCC5        IF NOT PROCESSOR
          LDM    CPUO        GET CPU ORDINAL
          NJN    SCC3        IF NOT CPU-0
          LDM    CP0CC       PROCESS CPU-0
          UJN    SCC4        CONTINUE

 SCC3     LDM    CP1CC       PROCESS CPU-1
 SCC4     STD    EC
          UJN    SCCX        RETURN

 SCC5     LDM    S0PMC       PAGE MAP CONNECT CODE
          STD    EC
          UJN    SCCX        RETURN
 SLM      SPACE  4,10
**        SLM - SET LOGGED MRB SIZE IN SCRATCH SUPPORTIVE STATUS BUFFER.
*
*         ENTRY  (T2) = LOGGED MRB SIZE.
*
*         EXIT   LOGGED MRD SIZE SET IN SCRATCH SUPPORTIVE STATUS BUFFER.
*                MRB TYPE IS SET TO *MTMRB*.
*
*         USES   CM - CM+3.
*
*         CALLS  IDA, VCK.


 SLM      SUBR               ENTRY/EXIT
          LDN    VER4        CHECK *DFT* VERSION NUMBER
          RJM    VCK
          MJN    SLMX        IF LESS THAN VERSION 4
          LDD    T2
          STM    LLOG        SAVE LENGTH TO LOG
          LDN    SSBP        READ SUPPORTIVE STATUS HEADER WORD
          RJM    IDA
          CRDL   CM
          AODL   CM          SKIP TO SCRATCH ENTRY HEADER WORD
          LRD    CM+1
          ADC    RR
          CRML   SLMA,ON
          LDDL   T2          SET LOGGED MRB SIZE
          STML   SLMA+3
          LDML   SLMA
          LPC    0#FF00
          ADN    MTMRB       SET MRB TYPE
          STML   SLMA
          LDDL   CM          REWRITE HEADER WORD
          ADC    RR
          CWML   SLMA,ON
          LJM    SLMX        RETURN

 SLMA     BSS    4
 ZMR      SPACE  4,10
**        ZMR - ZERO MAINTENANCE REGISTER BLOCK 0.
*
*         EXIT   MAINTENANCE REGISTER BLOCK 0 INITIALIZED TO ZERO.
*
*         USES   T1.
*
*         CALLS  IMB.


 ZMR      SUBR               ENTRY/EXIT
          LDN    0
          STD    T1
 ZMR1     LDD    T1
          RJM    IMB
          CWML   ZERO,ON
          AOD    T1
          SBM    LBUF
          PJN    ZMRX        IF DONE
          UJN    ZMR1        LOOP

 ZERO     BSSZ   4

*         END    CTP$DFT READ MAINTENANCE REGS
