*COMDECK COMCMOS
 MOS      CTEXT  COMCMOS - MOVE BIT STRING. 
 MOS      SPACE  4,10 
          IF     -DEF,QUAL$,1 
          QUAL   COMCMOS
          BASE   D
*         COMMENT COPYRIGHT CONTROL DATA CORPORATION 1978.
 MOS      SPACE  4,10 
***       MOS - MOVE OVERLAPPING BIT STRING.
* 
*         R. E. JAMES.       77/09/09.
*         L. D. HARE.        78/04/12.
* 
*         ******************************************************* 
*         * THIS COMMON DECK IS PART OF THE COMMON COMMON DECKS * 
*         * RESIDING ON THE COMPASS PROGRAM LIBRARY, AND BEING  * 
*         * MAINTAINED BY THE COMPASS PROJECT.  ANY CHANGES     * 
*         * REQUIRED SHOULD BE DIRECTED TO THE COMPASS PROJECT  * 
*         * THROUGH THE PROPER PROCEDURE.                       * 
*         ******************************************************* 
* 
* 
*         MOS WILL MOVE A BIT STRING FROM ONE CM LOCATION TO ANOTHER, 
*         OVERLAP IS ALLOWED. 
 MOS      SPACE  4,10 
***       MOS WILL MOVE A SPECIFIED SOURCE STRING FROM ONE LOCATION 
*         TO ANOTHER IN CENTRAL MEMORY.  THE ONLY BITS DISTURBED IN 
*         THE DESTINATION FIELD WILL BE THOSE EXTRACTED TO ACCEPT 
*         THE SOURCE. MOS ALLOWS THE USER TO MOVE OVERLAPPING STRINGS,
*         I.E. STRINGS WHERE THE DESTINATION FIELD LIES PARTLY OR 
*         COMPLETELY WITHIN THE SOURCE FIELD.  HOWEVER, MOS CHECKS
*         TO SEE WHETHER THIS MOVE IS IN ACTUAL FACT AN OVERLAP MOVE
*         AND IF NOT, CALLS THE FASTER MNS TO DO THE MOVE.  FOR THIS
*         REASON, USERS OF THIS ROUTINE SHOULD ALSO CALL *COMCMNS*. 
* 
*         ENTRY  (B1) = 1.
*                (B2) = SOURCE FIRST BIT (0,1,..,59). 
*                (B4) = DESTINATION FIRST BIT (0,1,..,59).
*                (X0) = NUMBER OF BITS TO MOVE. 
*                (X2) = SOURCE FIRST WORD ADDRESS.
*                (X4) = DESTINATION FIRST WORD ADDRESS. 
* 
*         EXIT   (B1) = 1.
*                (B2) = SOURCE NEXT BIT (0,1,..,59).
*                (B4) = DESTINATION NEXT BIT (0,1,..,59). 
*                (X2) = SOURCE NEXT WORD ADDRESS. 
*                (X4) = DESTINATION NEXT WORD ADDRESS.
* 
*         USES   X0, X1, X2, X3, X4, X5, X6, X7.
*                B1, B2, B3, B4, B5, B6.
*                A1, A2, A3, A5, A6, A7.
* 
*         CALLS  MNS=.
  
*         THE COMMENTING SCHEME INVOLVED HEREIN COULD ALSO USE
*         SOME EXPLANATION.  IT IS BASED ON A SIX BIT WORD, EACH BIT
*         IDENTIFIED BY A LETTER IN THE 64 CHARACTER CHARACTER SET. 
*         THE OVERALL ASSUMPTION IS THAT THE SOURCE STARTS AT BIT 0,
*         (LEFT MOST), AND THE DESTINATION COMMENCES AT BIT 3 (THE
*         MIDDLE).  THIS ASSUMPTION IS MODIFIED FOR THE BIT ALIGNED 
*         MOVE (MOS10 ET SEQ.), AND FOR THE FIRST BIT SOURCE GREATER
*         THAN FIRST BIT DESTINATION CASE (MOS50 ET SEQ.).  THE 
*         COMMENTS EXPLAIN THE DIFFERENCE FOR THESE CASES.
  
*         PROCESS OVERLAP MOVE. 
  
 MOS50    BX7    X5+X7       /      /      /      /      /      /DEFGHI/
          SX6    X6+1 
          SA7    A7-B1       /      /      /      /      /      /*STOR*/
  
*         SITUATION:         /  X1  /  X2  /  X3  /  X5  /  X6  /  X7  /
*         WITH PRIOR JUMP:   /PQRMNO/      /GHIJKL/      /      /      /
*         WITHOUT JUMP:      /JKLGHI/      /ABCDEF/      /      /      /
  
 MOS60    BX5    X0*X1       /      /      /      /...GHI/      /      /
          LX1    X3,B3       /DEFABC/      /      /      /      /      /
          SA3    A3-B1       /      /      /<>@\^;/      /      /      /
          BX7    -X0*X1      /      /      /      /      /      /DEF.../
          MI     X6,MOS50    IF NOT ON LAST WORD
  
*         SITUATION AFTER    /  X1  /  X2  /  X3  /  X5  /  X6  /  X7  /
*         ONE LOOP:          /\^;<>@/      /"_!&'?/...ABC/      /\^;.../
  
          SA1    A7-1        /XXXXXX/      /      /      /      /      /
          MX0    59 
          BX7    X5+X7       /      /      /      /      /      /\^;ABC/
          AX5    X0,B5
          IX6    X5-X0       MASK FOR LAST WORD 
          BX3    -X6*X7      /      /      /...ABC/      /      /      /
          BX5    X6*X1       /      /      /      /XXX.../      /      /
          BX7    X5+X3       /      /      /      /      /      /XXXABC/
          SA7    A1          /      /      /      /      /      /*STOR*/
  
*         DETERMINE IF WE CAN PERFORM A NON OVERLAP MOVE. 
  
 MOS      SUBR               ENTRY/EXIT.. 
          IX6    X2-X4       WOV = SOURCE ADDRESS - DESTINATION ADDRESS 
          PL     X6,MOS40    IF NO ADDRESS OVERLAP
          LX6    2           WO4 = WOV * 4
          SX1    B4-B2       BOV = DESTINATION BIT - SOURCE BIT 
          IX3    X1+X6       TMP = WO4 + BOV
          LX6    4           W64 = WO4 * 16 = WOV * 64
          IX5    X3-X6       NBA = W64 - TMP = W64 - WO4 + BOV
          IX6    X5-X0
          PL     X6,MOS40    IF NBA (NUM. BITS APART) .LT. BITS TO MOVE 
          SA1    =00000104210422000074B D60 = 1.0/60 .OR. 60
          FX7    X1*X0       WTM = BITS TO MOVE / 60. 
          SB3    X1 
          BX6    X4 
          ZR     X7,MOS40    IF BITS TO MOVE .LT. 60 (WTM = 0)
  
*         THIS IS A GENUINE OVERLAP MOVE. 
  
          IX4    X4+X7       TENTATIVE END OF DESTINATION FIELD 
          IX2    X2+X7       TENTATIVE END OF SOURCE FIELD
          LX7    2           WT4 = WTM * 4
          IX3    X0+X7       TMP = WT4 + BTM (BITS TO MOVE) 
          LX7    4           W64 = WT4 * 16 = WTM * 64
          IX5    X3-X7       REM = TMP - W64 ( MOD(BTM, 60) ) 
          SB5    B4-B3       FOR FINAL PUT TOGETHER 
          SB2    X5+B2       TENTATIVE SOURCE BIT 
          SB4    X5+B4       TENTATIVE DESTINATION BIT
          SB1    1
          LT     B2,B3,MOS10  IF SOURCE BIT WITHIN SAME WORD
          SB2    B2-B3       CORRECT SOURCE BIT 
          SX2    X2+B1       POSITION AT NEXT SOURCE WORD 
 MOS10    LT     B4,B3,MOS20  IF DESTINATION BIT WITHIN SAME WORD 
          SB4    B4-B3       CORRECT DESTINATION BIT
          SX4    X4+B1       POSITION AT NEXT DESTINATION WORD
  
*         STARTING POINT IS NOW DETERMINED FOR A BACKWARDS MOVE.
* 
*         SITUATION:         /  X1  /  X2  /  X3  /  X5  /  X6  /  X7  /
*                            /      /      /      /      /      /      /
  
 MOS20    SA3    X2          /      /      /MNOPQR/      /      /      /
          MX0    1           FORM MASK
          SA5    X4          /      /      /      /XXXXXX/      /      /
          AX1    X0,B4
          SB3    B2-B4       SHIFT
          BX7    -X0*X1 
          LX1    X3,B3       /PQRMNO/      /      /      /      /      /
          IX7    X7+X7       MASK 
          BX5    -X7*X5      /      /      /      /...XXX/      /      /
          IX6    X6-X4
          LX3    X0,B3
          BX7    X7*X1       /      /      /      /      /      /PQR.../
          IX0    X3-X0
          BX7    X7+X5       /      /      /      /      /      /PQRXXX/
          SA3    A3-B1       /      /      /GHIJKL/      /      /      /
          LX0    X0,B1       - MASK ( 60 - SHIFT ) FOR LOOP 
          LE     B4,B2,MOS30  IF DESTINATION BIT .LE. SOURCE BIT
          SB3    B3+60       WE NEED AN EXTRA SOURCE WORD 
          BX0    -X0         REVERSE THE MASK 
          LX1    X3,B3       /JHKGHI/      /      /      /      /      /
          SA3    A3-1        /      /      /ABCDEF/      /      /      /
          BX7    X0*X7       /      /      /      /      /      /...XXX/
          BX5    -X0*X1      /      /      /      /JKL.../      /      /
          NO
          BX7    X5+X7       /      /      /      /      /      /JKLXXX/
 MOS30    SA7    A5          /      /      /      /      /      /*STOR*/
          SX6    X6+B1
          EQ     MOS60       CONTINUE 
  
*         HERE WE HAVE A NON-OVERLAPPING MOVE.
  
 MOS40    SA1    MOS         TRANSFER CALLERS RETURN ADDRESS
          BX6    X1 
          SA6    =XMNS= 
          EQ     =XMNS=+1    MOVE BIT STRING WITH NO OVERLAP
 MOS      SPACE  4,10 
          BASE   *
 QUAL$    IF     -DEF,QUAL$ 
          QUAL   *
 MOS      EQU    /COMCMOS/MOS 
 MOS=     EQU    /COMCMOS/MOS 
 QUAL$    ENDIF 
 MOS      ENDX
