*DECK,DCMBIT
*#
* *    DC$MBIT                                   PAGE 1 
* *   MOVE-BIT-STRING PRIMITIVE   DC$MBIT 
* *   J.W.PERRY                                  DATE  12/05/73 
* 
* DC  PURPOSE 
*     MOVE ARBITRARY LENGTH BIT-STRING. 
* DC  ENTRY CONDITIONS
*     (A1) = ADDR OF PARAM ADDR LIST (STANDARD CALLING SEQ) 
*     ALL PARAMS ARE NON-NEGATIVE INTEGERS. 
*         PARAM 1 = FWA OF INPUT STRING.
*         PARAM 2 = BIT OFFSET OF INPUT STRING (0-59, FROM LEFT OF WORD)
*         PARAM 3 = FWA OF OUTPUT STRING. 
*         PARAM 4 = BIT OFFSET OF OUTPUT STRING (0-59). 
*         PARAM 5 = SIZE OF MOVE (BITS).
*     RESULTS ARE UNPREDICTED IF STRINGS OVERLAP. 
* DC  EXIT CONDITIONS 
*     PARAMETERS AS ON ENTRY. 
*     REGISTERS USED
*         ALL EXCEPT A0,B1. 
* DC  CALLING ROUTINES
*         DC$XFER  TRANSFER PRIMITIVE 
* DC  CALLED ROUTINES 
*     NONE
* DC  NON-LOCAL VARIABLES 
*     NONE
* DC  DESCRIPTION 
*     BIT-STRING OF ARBITRARY SIZE IS MOVED BY FETCHING, SHIFTING,
*     MASKING, AND STORING. 
*#
          IDENT  DC$MBIT
          ENTRY  DC$MBIT
 F60      VFD    60/17257400000000000000B 
 DC$MBIT  DATA   0
          SB7    1           B7 = 1 
          SA3    X1          PARAM 1
          SB4    X3                ADDR OF INPUT ARRAY
          SA4    A1+B7
          SA2    X4          PARAM 2 -- OFFSET OF INPUT ARRAY 
          SA3    A4+B7
          SA5    X3          PARAM 3
          SB5    X5-1              ADDR - 1 OF OUTPUT ARRAY 
          SA1    A3+B7
          SA3    X1          PARAM 4 -- OFFSET OF OUTPUT ARRAY
          SA4    A1+B7
          SA5    X4          PARAM 5 -- SIZE IN BITS
          IX1    X3+X5       X1 = SIZE + OUTPUT OFFSET
          SA4    F60         FLOATING 60
          PX0    X1 
          NX1    X0 
          FX5    X1/X4
          UX0    B6,X5
          LX0    B6,X0
          SB3    X0          B3 = INTEGER QUOTIENT (SIZE+OUTPUT OFFS)/60
          PX0    X0 
          NX0    X0 
          FX4    X0*X4       INTEGER QUOTIENT * 60
* 
*  FOLLOWING CODE LIFTED FROM FORM -- DECK FM$TMOV
* 
*                ENTER WITH REGISTERS AS FOLLOWS
*         B7 = 1
*         B4 = ADDR OF IN ARRAY 
*         B5 = ADDR - 1 OF OUT ARRAY
*         X2 = IN ARRAY BIT OFFSET (INTEGER LESS THAN 60) 
*         X3 = OUT ARRAY BIT OFFSET (INTEGER LESS THAN 60)
*         X1 = MOVE SIZE + OUT ARRAY BIT OFFSET (FLOAT, NORM) 
*         B3 = WORDS OF (SIZE + OUT OFFSET) = INTEGER QUOTIENT X1/60
*         X4 = BITS OF (SIZE + OUT OFFSET) (BITS MOD 60) = B3*60 (FT,NM)
* 
         SX5   B0       NOW WE USE BITB TO GET
         SB4   B4-B7
         ZR    X3,NOMASK1  OUR INITIAL MASK. IT 
         MX5   1        CONSISTS OF BITA 1-BITS 
         SB2   X3-1     FOLLOWED BY ALL ZEROS.
         AX5   B2,X5
NOMASK1  FX1   X1-X4
          UX1    B6,X1
          LX1    B6,X1
         NZ   X1,GOON 
         SB3   B3-B7
         MX7   60 
          EQ     NOMASK2
GOON     SB2   X1-1     CREATE MASK IN X7 FOR LAST
         MX7   1
         AX7   B2,X7
NOMASK2  IX3   X2-X3    BITA-BITB-=SHIFT COUNT FOR
         SX0   B0       ORING WORDS. ALSO GIVES 
         ZR    X3,NOSHIFT   THAT ORING. THIS IS THE 
         MX0   1
         NG    X3,SHFTRT    SHIFT COUNT FOR MASK FOR
         SB4   B4+B7
         SB2   X3-1     CASE OF A LEFT SHIFT, SO
         AX0   B2,X0    RIGHT HAND PART OF THE
         SB2   X3       WORD AND COMPLEMENT IT. 
         LX0   B2,X0    MASK IS PUT IN X0.
         BX0   -X0
          EQ     NOSHIFT
SHFTRT   SB2   X3+B7    THIS IS A RT-SHIFT, SO
         LX0   B2,X0    SHIFT LFT BECAUSE B2 NEG
         SX3   X3+60    RT-CIRCULAR SHIFT COUNT 
NOSHIFT  SB2   X3       SHIFT COUNT 
         SA1   B5+B7    GET FIRST TO WORD 
         SA3   B4       FIRST TWO FROM WORDS
         SA4   B4+B7
         LX2   B2,X3    SHIF FIRST FROM 
         BX2   X0*X2    KNOCK OFF RIGHT HALF
         LX4   B2,X4    SHIFT 2ND FROM INTO X4
         BX4   -X0*X4   KNOCK OFF LEFT HALF 
         BX2   X2+X4    COMBINE FROM WORDS
         BX2   -X5*X2   KNOCK OFF UNWANTED PART 
         BX1   X5*X1    LEFT PART OF TO 
PAKLOOP  SB5   B5+B7    STEP FOR NEXT STORE 
         BX6   X1+X2    PUT PARTS TOGETHER IN OUTPUT REG
         SA3   A3+B7    NEXT FROM WORD
         SA4   A4+B7    NEXT FROM WORD+1
         EQ    B3,PAKDONE   JUMP IF ON LAST WORD
         LX1   B2,X3    LONG LEFT SHIFT IDEA REQUIRES A SHIFT AND THEN
         SB3   B3-B7    DECREASE WORD COUNTER 
         BX1   X0*X1    LEFT PART OF THIS ONE,
         LX2   B2,X4    AND THE 
         SA6   B5       STORE NEXT WORD 
         BX2   -X0*X2   RT PART OF NEXT ONE 
         EQ    PAKLOOP      CONTINUE
PAKDONE  SA4   B5       GET THE LAST TO WORD
         BX6   X7*X6    KNOCK OFF RT PART OF LAST ASSEMBLED WORD
         BX4   -X7*X4   AND LEFT PART OF LAST TO WORD 
         BX6   X4+X6    COMBINE THEM
         SA6   B5       AND STORE 
          EQ     DC$MBIT     EXIT 
          END 
