*COMDECK COMQSVR
 SVR=     CTEXT  COMQSVR - SAVE AND RESTORE REGISTERS.
 SVR=     SPACE  4,8
          IF     -DEF,QUAL$,1 
          QUAL   COMQSVR
          BASE   D
 SVR=     SPACE  4,8
***       SVR - SAVE AND RESTORE REGISTERS. 
* 
* 
*                CONTAINS THE ROUTINES *SVR=* TO SAVE ALL REGISTERS,
*         AND *RSR=* TO RESTORE ALL REGISTERS. MINUS ZERO (-0) IS PRE-
*         SERVED IN ALL REGISTERS, PARTICULARLY -A- AND -B- REGISTERS.
*         EACH REGISTER IS SAVED IN A FULL CM WORD (-A- AND -B- 
*         REGISTERS ARE SIGN EXTENDED TO BIT 59). A REGISTER BLOCK IS 
*         DEFINED TO BE ALL THE -B- REGISTERS, ALL THE -A- REGISTERS, OR
*         ALL THE -X- REGISTERS. ALL REGISTERS IN A REGISTER BLOCK ARE
*         SAVED CONTIGUOUSLY IN ASCENDING ORDER.
* 
*         ASSEMBLY-TIME OPTIONS-- 
* 
*            IF THE SYMBOL *BN=1* (N=1 THRU 7) IS DEFINED, (B.N) ARE
*         ASSUMED TO BE EQUAL TO 1. IF *BN=1* IS NOT DEFINED, (B1)
*         ARE CHECKED FOR 1 TO TRY TO AVOID EXECUTING THE *SAVE (B1)
*         VIA RJ SEQUENCE* CODE.
* 
*            IF THE SYMBOL *#SVR* IS DEFINED (DEF), THEN THE CALLER 
*         WILL PROVIDE THE FWA OF THE REGISTER SAVE AREA IN THE LOWER 
*         30 BITS OF THE CALLING *RJ* FOR *SVR=*--
*                30/RJ SVR, 30/FWA OF REGISTER SAVE AREA
*         AND IN (X1) FOR *RSR=*. 
*            IF THE SYMBOL *#SVR* IS NOT DEFINED (-DEF), THEN A LOCAL 
*         REGISTER SAVE AREA, (SVREG) ET SEQ, WILL BE USED AND NO 
*         PARAMETERS NEED TO BE PASSED. 
* 
*            THE MICRO "SVBAX" DEFINES THE ORDER IN WHICH THE -B-, -A-, 
*         AND -X- REGISTER BLOCKS ARE SAVED IN CM.
*         I.E.   SVBAX    MICRO  1,,/BAX/        (DEFAULT) MEANS
*                SV=B     BSSZ   8
*                SV=A     BSSZ   8
*                SV=X     BSSZ   8
*         OR     SVBAX    MICRO  1,,/ABX/        MEANS
*                SV=A     BSSZ   8
*                SV=B     BSSZ   8
*                SV=X     BSSZ   8
 SVR=     SPACE  4,8
          IF     -MIC,SVBAX,1 
 SVBAX    MICRO  1,,/BAX/ 
  
 .1       MICRO  1,1,/"SVBAX"/
 .2       MICRO  2,1,/"SVBAX"/
 .3       MICRO  3,1,/"SVBAX"/
  
 SV".1"   =      0
 SV".2"   =      0+8
 SV".3"   =      0+8+8
  
 .SVR     IF     -DEF,#SVR
 SVREG    BSSZ   3*8
  
 .SVR     ELSE
 SVX7     BSSZ   1           TEMPORARY SAVE (X7)
 SVA5     BSSZ   1           TEMPORARY SAVE (A5)
 SVX5     BSSZ   1           TEMPORARY SAVE (X5)
 .SVR     ENDIF 
  
 SVR=     SPACE  4,8
**        SVR - SAVE ALL REGISTERS. 
* 
* 
*         ENTRY  IF *#SVR* DEFINED--
*                LOWER 30 BITS OF CALLING *RJ* CONTAINS FWA OF
*                 REGISTER SAVE AREA (RSA)--   30/RJ SVR=, 30/FWA OF RSA
* 
*                IF *#SVR* NOT DEFINED-- NONE 
* 
*                IF *BN=1* DEFINED-- (B.N) = 1
* 
*         EXIT   (B1) = 1 
* 
*         USES   ALL
* 
*         CALLS  NONE 
  
  
 SVR=     EQ     *+4S15      ** ENTRY/EXIT ** 
  
*         CHECK TO SEE IF ANY REGISTER HAS BEEN DEFINED TO BE EQUAL 
*           TO 1 AT ASSEMBLY TIME VIA *BN=1* SYMBOL. IF NOT, CHECK FOR
*           (B1) = 1. IF (B1).NE.1, SAVE (B1) THE HARD WAY BY EXECUTING 
*           THE *SAVE (B1)* RJ SEQUENCE AT *SVR2*. IF BIT 2**N WAS ON 
*           IN (B1), THEN THE *RJ* AT (SVR2+2*N+1) WILL BE EXECUTED,
*           RESULTING IN AN /EQ SVR2+2*N+2/. IF BIT 2**N WAS NOT ON 
*           IN (B1), THEN THE *RJ* WILL NOT BE  EXECUTED. BY QUERYING 
*           (SVR2+2*N+1), ONE CAN DETERMINE WHETHER OR NOT BIT 2**N 
*           WAS ON IN (B1) BY THE PRESENCE OF AN *EQ* (BIT WAS ON), OR
*           AN *RJ* (BIT WAS OFF) INSTRUCTION.
  
 B=1      MICRO  1,,/B0/
          ECHO   4,BN=(B1,B7,B5,B2,B3,B4,B6)
          IF     DEF,BN=1,3 
 B=1      MICRO  1,,/BN/
          STOPDUP 
 B.EQ.1   SKIP
  
          LE     B1,B0,SVR2  IF (B1).LE.0 (INSURES -0 WILL BE HONORED)
          SB1    B1-1 
          ZR     B1,SVR4     IF (B1) = 1
          SB1    B1+1        RESTORE (B1) 
  
 SVR2     BSS    0
          PL     B1,*+2 
 +        RJ     *
  
 B.NE.1   DUP    17 
 +        SB1    B1+B1
          NO
          PL     B1,*+2 
 +        RJ     *
 B.NE.1   ENDD
  
 +        SB0    B0+         FILLER BECAUSE /RJ */S MUST BE 2 WORDS 
*                              APART FOR RESTORE
  
 SVR3     RJ     *           (B1)=1/(B1).NE.1 FLAG
  
 SVR4     BSS    0
  
 B.EQ.1   ELSE
          MI     "B=1",*+4S15  IF ("B=1") IS BAD (SHOULD BE EQUAL TO 1) 
          S"B=1" "B=1"-1
          ZR     "B=1",SVR2  IF ("B=1") = 1 
          S"B=1" "B=1"+1     RESTORE ("B=1")
          EQ     *+4S15 
  
 SVR2     BSS    0
          IFC    NE,/"B=1"/B1/,1
          S"B=1" B1-B0       SAVE (B1)
 B.EQ.1   ENDIF 
  
*         SAVE   A - 4,5,6,7
*                X - 4,5,6,7
  
 .SVR1    IF     -DEF,#SVR   IF USING LOCAL REGISTER SAVE AREA
          SB1    A7-B0
          SA7    SVREG+SVX+7
          SX7    B1-B0
          SA7    SVREG+SVA+7
          SB1    1
          SX7    A6-B0
          SA6    SVREG+SVX+6
          SA7    A7-B1
          BX6    X5 
          SX7    A5-B0
          SA6    A6-B1
          SA7    A7-B1
          BX6    X4 
          SX7    A4-B0
          SA6    A6-B1
          SA7    A7-B1
          SX5    SVREG       (X5) = FWA OF SAVED REGISTER AREA
  
 .SVR1    ELSE               IF USING USER DEFINED SAVE AREA
          SB1    A7-B0       SAVE (A7) ** TEMPORARY **
          SA7    SVX7        SAVE (X7) ** TEMPORARY **
          SX7    A5-B0
          SA7    SVA5        SAVE (A5) ** TEMPORARY **
          BX7    X5 
          SA7    SVX5        SAVE (X5) ** TEMPORARY **
  
          SA5    SVR=        (X5) = 30/EQ CALLER+1, 30/0
          LX5    30 
          SA5    X5-1        (X5) = 30/RJ SVR=, 30/FWA OF RSA 
          SX7    B1-B0
          SB1    1
          SA7    X5+SVA+7 
          SX7    A6-B0
          SA6    X5+SVX+6 
          SA7    A7-B1
          BX6    X4 
          SX7    A4-B0
          SA6    A6-2 
          SA7    A7-2 
 .SVR1    ENDIF 
  
*         SAVE   A - 0,1,2,3
*                X - 0,1,2,3
  
 SV=AX    ECHO   ,N=(3,2,1,0) 
          BX6    X.N
          SX7    A.N-B0 
          SA6    A6-B1
          SA7    A7-B1
 SV=AX    ENDD
  
*         IF USING USER DEFINED SAVE AREA, SAVE (X7),(A5),(X5) FINALLY. 
  
 .SVR2    IF     DEF,#SVR 
          SA2    SVX7        (X2) = SAVED (X7)
          SA3    A2+B1       (X3) = SAVED (A5)
          SA4    A3+B1       (X4) = SAVED (X5)
          BX6    X2 
          LX7    X3 
          SA6    X5+SVX+7 
          SA7    X5+SVA+5 
          BX6    X4 
          SA6    X5+SVX+5 
 .SVR2    ENDIF 
  
*         SAVE   B - 0,2,3,4,5,6,7
  
          BX6    X6-X6
          SA6    X5+SVB+0 
  
 B=1      IFC    NE,/"B=1"/B0/
          SX7    "B=1"-B0 
          S"B=1" B1          RESET ("B=1") = 1
  
 B=1      ELSE
          SX7    B1 
 B=1      ENDIF 
  
          SA7    A6+B1
  
 SV=B     ECHO   ,U=(2,4,6),L=(3,5,7) 
          SX6    B.U-B0 
          SX7    B.L-B0 
          SA6    A7+B1
          SA7    A6+B1
 SV=B     ENDD
  
*         SAVE (B1) 
  
 B.NE.1   IFC    EQ,/"B=1"/B0/
          SA5    SVR3        (X5) = (B1)=1/(B1).NE.1 FLAG 
          SX4    0100B       (X4) = *RJ* OP CODE
          SX3    B1 
          LX3    42-0-1 
          SX6    A5 
          LX4    29-11
          BX6    X4+X6       (X6) = 30/0, 30/RJ * 
          LX6    30 
          SA6    A5          RESTORE .RJ *. 
          LX5    59-56
          BX7    X7-X7
          PL     X5,SVR=     IF (B1) = 1, NO NEED TO ASSEMBLE (B1)
          SB2    B1+B1
  
*         ASSEMBLE ORIGINAL (B1) INTO (X7). 
  
 SVR5     SA5    A5-B2
          IX3    X3+X3
          SX6    A5 
          LX5    59-56
          BX6    X4+X6
          PL     X5,SVR6     IF BIT WAS CLEAR 
          BX7    X7+X3
  
 SVR6     LX6    59-29
          SA6    A5 
          PL     X3,SVR5     IF MORE BITS TO ASSEMBLE 
  
*         HERE FOR FINAL SAVE OF (B1).
  
          AX7    42          SIGN EXTEND
          SA7    A7-7+1 
 B.NE.1   ENDIF 
  
          EQ     SVR=        EXIT...
 RSR=     SPACE  4,8
**        RSR - RESTORE ALL REGISTERS.
* 
* 
*         ENTRY  IF *#SVR* NOT DEFINED-- NONE 
* 
*                IF *#SVR* DEFINED-- (X1) = FWA OF REGISTER SAVE AREA 
* 
*         EXIT   ALL REGISTERS SET TO THE CONTENTS OF REGISTER SAVE AREA
* 
*         USES   ALL
* 
*         CALLS  NONE 
  
  
 RSR=     EQ     *+4S15      ** ENTRY/EXIT ** 
          SB1    1
  
*         SET UP FINAL -B- REGISTERS RESTORE AT (RSR4) ET SEQ.
  
 .RSR     IF     DEF,#SVR    IF USING USER DEFINED REGISTER SAVE AREA 
          SB7    X1+         (B7) = FWA OF REGISTER SAVE AREA 
  
 .RSR     ELSE               IF USING LOCAL REGISTER SAVE AREA
          SB7    SVREG
 .RSR     ENDIF 
  
          MX4    -18
          SA1    B7+SVB+7    (X1) = SAVED (B7)
          BX5    X4 
          LX4    30 
          SB4    4
          BX0    X4*X5       (X0) = 77770000007777000000B 
  
 RSR2     SA2    A1-B1       (X2) = SAVED (B.N-1) 
          SA3    RSR4+B4-1
          BX1    -X5*X1 
          SB4    B4-B1
          BX2    -X5*X2 
          LX1    30 
          BX3    X0*X3
          IX6    X1+X2
          BX7    X6+X3       (X7) = 30/SB.N B7+K, 30/SB.N-1 B7+K
          SA7    A3 
          SA1    A2-B1       (X1) = SAVED (B.N) 
          GT     B4,B0,RSR2  IF STILL MORE -B- REGS TO GO...
  
          SA2    B7+SVA+6    (X2) = SAVED (A6)
          RJ     *+1         VOID INSTRUCTION STACK 
 +        EQ     *
  
*         THE MOST LIKELY CANDIDATE FOR THE DANGER DISCUSSED IN THE NEXT
*           PARAGRAPH IS THE SYSTEM COMMUNICATION CELL (RA.MTR).
*           ACCORDINGLY, WE WAIT FOR IT TO CLEAR BEFORE PROCEEDING. 
  
 RSR3     SA1    B1 
          NZ     X1,RSR3     IF (RA.MTR) NOT CLEAR
  
*         A SLIGHT BIT OF CARE IS SPENT ON RESTORATION OF (A6) AND (A7).
*           WE WISH TO AVOID HAVING THE CONTENTS OF THE WORD THAT THE 
*           STORE REGISTER IS POINTING TO TO GET CHANGED (I.E. BY A PP) 
*           WHILE WE ARE RESTORING (A6) OR (A7). ABOUT THE ONLY THING 
*           THAT CAN BE DONE TO MINIMIZE THIS POSSIBILITY IS TO GET THE 
*           LOAD AND THE STORE AS CLOSE TOGETHER AS POSSIBLE. BY KEEPING
*           THEM IN THE SAME WORD, WE HAVE AT LEAST INSURED THAT WE WILL
*           NOT BE EXCHANGED AFTER THE LOAD BUT BEFORE THE STORE. 
*           BARRING DELAYS IN THE HOPPER, THIS SHOULD REDUCE THE DANGER 
*           PERIOD TO A FEW MINOR CYCLES. SUGGESTIONS ARE WELCOME.
  
          SA3    A2+B1       (X3) = SAVED (A7)
  
 +        SA4    X2-0 
          BX6    X4 
          SA6    A4-B0       RESTORE (A6) 
  
 +        SA5    X3-0 
          BX7    X5 
          SA7    A5-B0       RESTORE (A7) 
  
          SA1    B7+SVX+6 
          SA4    A1+B1
          BX6    X1          RESTORE (X6) 
          LX7    X4          RESTORE (X7) 
          BX0    -X0-X0 
          SB6    X0-0        (B6) = -0
  
*         RESTORE (A0),(X0).
  
          SA4    B7+SVA+0 
          SA5    B7+SVX+0 
          SA0    X4+B6
          BX0    X5 
  
*         RESTORE A - 1,2,3,4 
*                 X - 1,2,3,4 
  
          ECHO   4,N=(1,2,3,4)
          SA4    A4+B1       (X4) = SAVED (A.N) 
          SA5    A5+B1       (X5) = SAVED (X.N) 
          SA.N   X4+B6
          BX.N   X5 
  
*         RESTORE (A5),(X5)-- THE ORIGINAL (X5) ARE BROKEN APART INTO 
*           (B1) THRU (B5) AS DISPLAYED BELOW. THIS ALLOWS US TO RESTORE
*           (A5). 
*           DISASSEMBLY IS FROM LEFT TO RIGHT, TOP TO BOTTOM. 
*           REASSEMBLY IS FROM RIGHT TO LEFT, BOTTOM TO TOP.
*         5          4          3          2          1               55
*         9          8          7          6          5              098
*         ..............................................................
*         ++++++++++++
*             (B1)   ++++++++++++ 
*                        (B2)   ++++++++++++
*                                   (B3)   ++++++++++++ 
*                                              (B4)   ++++++++++++++++++
*         ++                                                 (B5) 
  
          SA5    A5+B1       (X5) = SAVED (X5)
  
          ECHO   2,N=(1,2,3)
          UX5    X5,B.N 
          LX5    11 
  
          UX5    X5,B4
          LX5    11+18
          SB5    X5+B6
  
          SA5    B7+SVA+5    (X5) = SAVED (A5)
          SA5    X5+B6       RESTORE (A5) 
  
*         REASSEMBLE (X5).
  
          SX5    B5+B6
          LX5    60-11-18 
          PX5    X5,B4
  
          ECHO   2,N=(3,2,1)
          LX5    -11
          PX5    X5,B.N 
  
*         RESTORE B - 0,1,2,3,4,5,6,7 
  
 RSR4     BSS    0
          ECHO   2,U=(1,3,5,7),L=(0,2,4,6)
          SB.U   B6+* 
          SB.L   B6+* 
  
          EQ     RSR=        EXIT...
 SVR=     SPACE  4,8
          BASE   *
  
 #SVR     IF     -DEF,#SVR
 SV=B     =      SVREG+SVB
 SV=A     =      SVREG+SVA
 SV=X     =      SVREG+SVX
 #SVR     ENDIF 
  
 QUAL$    IF     -DEF,QUAL$ 
          QUAL   *
 SVR=     =      /COMQSVR/SVR=
 RSR=     =      /COMQSVR/RSR=
  
 #SVR     IF     -DEF,#SVR
 SV=B     =      /COMQSVR/SV=B
 SV=A     =      /COMQSVR/SV=A
 SV=X     =      /COMQSVR/SV=X
 #SVR     ENDIF 
 QUAL$    ENDIF 
          ENDX
