*COMDECK /GETDS/
*#
*1CD  GET$S 
*0D   PURPOSE 
*0        RETRIEVE ALL, OR PART, OF AN S-TYPE RECORD FROM A FILE AND
*         DELIVER IT THROUGH A CIRCULAR BUFFER TO THE WORKING STORAGE 
*         AREA. 
*0D   CALL
*0                  SB6       RETURN-ADDRESS
*                   EQ        =XGET$S 
*0D   PARAMETERS
*0        A0        FIT 
*         B1        1 
*         B6        RETURN ADDRESS
*         WSA       FWA OF USER WORKING STORAGE AREA (WHERE TO PUT DATA)
*         RL        RECORD LENGTH (GET) 
*         PTL       PARTIAL TRANSFER LENGTH (GETP)
*         DX        USER END-OF-DATA ADDRESS
*         GPS       GETP-SKIP BIT (IF = 1 SKIP TO NEXT RECORD BEFORE
*                   GETTING DATA.)
*0D   ACTION
*         CHECK ERROR CONDITIONS:  REQUEST
*         PRECEDED BY NON-BUFFERED GET, GET FOLLOWS PUT.  IF FILE POS.
*         (*FP*) IS NON-ZERO THEN WE ARE AT A RECORD BOUNDARY; THEREFORE
*           INITIALIZE *RL*, INSUFICIENT DATA FLAG, AND CIO READ CODE 
*           DEPENDING ON S/L OR PRU DEVICE.  ALSO CLEAR *BCC* AND 
*           *UCP* FIELDS IF THIS IS A PARTIAL GET.
*         ELSE IF THIS IS NOT A GETP OR IF IT IS A GETP-SKIP THEN 
*          POSITION FILE TO START OF NEXT RECORD:  FOR S/L DEVICES, 
*          MOVE THE *OUT* POINTER FORWARD BY THE S/L RECORD LENGTH
*          RESIDUAL; FOR PRU DEVICES, IF CODE AND STATUS BITS 
*          INDICATE CIO END OF RECORD, SET *OUT* EQUAL TO *IN*, ELSE
*          CALL *RSPT$SQ* AND ISSUE SKIPF CIO REQUEST.
*           NOW INCREMENT *RC* AND SET *FP*.  IF THIS IS A SKIP REQUEST 
*           DECREMENT THE SKIP COUNT. 
*0        IF THIS IS A SKIP REQUEST THEN CALL *SKSF$SQ* WHERE THE BUFFER
*           IS EMPTY (THIS WOULD ALWAYS BE TRUE AT THIS POINT FOR PRU 
*           DEVICES).  ELSE, LOOP INCREMENTING *OUT* BY LENGTH INDICATED
*           BY EACH S/L CONTROL WORD DECREMENTING SKIP COUNT AND
*           INCREMENTING RECORD COUNT UNTIL SKIP COUNT IS EXHAUSTED.
*           IF BUFFER IS EXHAUSTED BEFORE SKIP COUNT THEN CALL *SKSF$SQ*
*           FOR BALANCE OF SKIP COUNT.  EXIT. 
*0        SET *UWD* EQUAL TO *WSA*. 
*         IF S/L DEVICE THEN CALL *FILL* PROCEDURE TO HANDLE ERROR AND
*           BOUNDARY CONDITIONS AND ENSURE AT LEAST ONE RECORD IS IN THE
*           BUFFER.  IF *FP* INDICATES A RECORD BOUNDARY THEN SET *SLC* 
*           TO UNUSED CHARACTERS CONVERTED FROM THE UBC FIELD OF THE S/L
*           CONTROL WORD.  ALSO FROM THE S/L CONTROL WORD SET *SLW* TO
*           THE LENGTH OF THE RECORD IN WORDS AND INCREMENT *OUT* BEYOND
*           THE S/L CONTROL WORD. 
*           NOW CALL *MOVE* PROCEDURE WITH PARAMETERS INDICATING THE
*           AMOUNT OF CONTIGUOUS DATA IN THE RECORD AND THE UNUSED
*           CHARACTERS IN THE LAST WORD AVAILABLE.  WHEN THE RECORD 
*           LENGTH EXCEEDS *LIMIT* THE *MOVE* ROUTINE WILL BE CALLED
*           TWICE.  WHEN *MOVE* COMPLETES A GETP IT WILL EXIT TO
*           STATEMENT LABEL *EXIT* OR STATEMENT LABEL *RXIT*. 
*     *RXIT*  SET *FP* TO END OF RECORD.
*     *EXIT*  RETURN TO USER. 
*         FOR PRU DEVICES LOOP, CALLING THE *FILL* PROCEDURE TO HANDLE
*         ERROR/BOUNDARY CONDITIONS AND TO ENSURE AT LEAST ONE PRU OF 
*         DATA IN THE BUFFER, AND CALLING THE *MOVE* ROUTINE TO TRANSFER
*         THE AMOUNT OF CONTIGUOUS DATA AVAILABLE.  IF THE DATA IN THE
*         BUFFER EXCEEDS *LIMIT* THEN *MOVE* WILL BE CALLED TWICE.  IF
*         *MOVE* SATISFIES A GETP REQUEST IT WILL EXIT TO STATEMENT 
*         LABELS *RXIT* OR *EXIT*.  A GET REQUEST WILL EXIT FROM THE
*         *FILL* PROCEDURE THROUGH STATEMENT LABEL *RXIT*.
*0D   REGISTERS USED
*         A127,B23456,X01234567 
*0D   OTHER CODE
*0        PROGRAMS- CLSV$SQ,ERR$RM,MOVE$RM,RSPT$SQ,SKSF$SQ
*         MACROS    SET.RM,F.RM,RCLF,CLCD.SQ,ON.RM,OFF.RM,INC.RM,DEC.RM,
*                   BUFSP,SYSY,RCL,BUFINC,RACLR 
*0D   NARRATIVE DESCRIPTION 
*#
          SPACE     1 
 #EORCS#  MICRO     1,,/0,0,1,4,1,1/ CODE AND STATUS EOR FLAG 
 #EOFCS#  MICRO     1,,/0,0,1,3,1,1/ CODE AND STATUS EOF FLAG 
          SPACE     1 
 #CSEOI#  EQU       01B      CODE AND STATUS END-OF-INFORMATION 
 #CSEOV#  EQU       02B      CODE AND STATUS END-OF-VOLUME
 #CSDCE#  EQU       10B      CODE AND STATUS DEVICE-CAPACITY-EXCEEDED 
 #CSDCP#  EQU       14B      CODE AND STATUS DEV-CAP-EX AND PARITY-ERROR
 #CSPAR#  EQU       04B      CODE AND STATUS PARITY-ERROR 
          SPACE     1 
 FWRD.RM  MICRO     1,,/36B/
 XREG.RM  MICRO     1,, 0 
 GET$S    SPACE     4,8 
 GET$S    CAP.RM                   FIRST-TIME ENTRY 
          SET.FOJ   G,B4,GET.S
          NZ        B3,=XRM$ABUF   ALLOCATE BUFFER, RETURN TO SKFL
          SB3       B4
          EQ        =XRM$ABUF      ALLOCATE BUFFER, RETURN TO GET.S 
 GET.S    SPACE     4,8 
          CAP.RM
 GET.S    BSS                      USUAL ENTRY
          SB4       B1
SKPNTRY   BSS       0 
          SA1       A0+"FWRD.RM"
          BX"XREG.RM" X1
          SET.RM    GSF,B4
          SX6       113B
          ON.RM     RSI,=YERR$RM   GET AFTER SUPPRESSED BUFFER OPERATION
          SX6       116B
          ON.RM     WPN,=YERR$RM   GET FOLLOWS PUT
          SAVE
          F.RM      IN,B2 
          F.RM      OUT,B3
          F.RM      LIMIT,B4
          F.RM      FIRST,B6
          F.RM      SLW,5 
          F.RM      SKP,4 
          SET.RM    GEN,0          CLEAR GEN
          F.RM      LOP,X1,-#GE#
          ZR        X1,GETSEQ 
          SET.RM    SPR,0          FIRST GET, READ-AHEAD ALLOWED
GETSEQ    BSS       0 
          SET.RM    UCP,0          CLEAR USER CHAR. POSITION
          F.RM      FP
          ZR        X1,MIDREC 
          SX2       X1-#EOI#
          SX6       100B
          ZR        X2,=XERR$RM    IF FP=EOI, ERROR 
          SX2       10B            SCOPE DEVICE READ CODE FOR CIO 
          OFF.RM    SOL,SCPCD      IF SCOPE DEVICE
          SX2       260B           S/L DEVICE READN CODE FOR CIO
 SCPCD    BSS       0 
          SET.RM    CCD,X2         SAVE THE CIO CODE
          F.RM      BCC,B5
          SB6       SKGT
          EQ        B5,B0,CLRUCP   JUMP IF BCC=0
          BUFINC    B,3,1,3 
          SB3       X3
 CLRBCC   BSS       0 
          SET.RM    SLW,0          IF FP=EOR, NO LEFT OVER DATA 
          SET.RM    SLC,0 
          SET.RM    BCC,0          CLEAR BUFFER CHARACTER POSITION
 CLRUCP   BSS       0 
          OFF.RM    GSF,CLRUCP1 
          SET.RM    RL,0
CLRUCP1   BSS       0 
          JP        B6
          SPACE     1 
SKGT$S    SB4       B0
          EQ        SKPNTRY 
 MIDREC   BSS       0 
          ON.RM     GPS,MID1       IF GETP-SKIP 
          ON.RM     PRD,SKGT1      IF GETP
 MID1     BSS       0 
          OFF.RM    SOL,MID2       IF SCOPE DEVICE
          SB3       B3+X5          *OUT* + *SLW*
          LT        B3,B4,MID25    IF NOT PAST *LIMIT*
          SB5       B3-B4          SUBTRACT *LIMIT* 
          SB3       B5+B6          ADD *FIRST*
          EQ        MID25 
          SPACE     1 
 MID2     BSS       0 
          RCL.RM    A0,AUTO 
          OFF.RM    EORCS,MID3     IF EOR NOT IN BUFFER 
          F.RM      IN,B2 
          SB3       B2             *OUT* = *IN* 
          SET.RM    OUT,B2         EMPTY BUFFER 
          SET.RM    EORCS,0 
 MID25    BSS       0 
          SB6       MID5
          EQ        CLRBCC
          SPACE     1 
 MID3     BSS       0 
          SET.RM    IN,B6          RESET POINTERS 
          SET.RM    OUT,B6
          SB2       B6
          SB3       B6
          SX3       B1             SKIP COUNT 
          SYSY      240B,RCL,3     SKIP TO EOR
          CLCD.SQ                  CLEAR EOR STATUS FOR SUBSEQUENT GET
 MID5     BSS       0 
          INC.RM    RC,1           INCREMENT RECORD COUNT 
          SET.RM    FP,#EOR#       END-OF-RECORD
          ON.RM     GSF,GET        IF NOT A SKIP REQUEST
          SX2       #SF#           SET LOP FOR SKIP 
          SB4       B0
         ZR         X4,EXITS       IF SKIP COUNT ZERO 
         EQ         SK1            PERFORM SKIP 
         SPACE      1 
 SKGT1    BSS       0 
          OFF.RM    IPF,NOIPF 
          SET.RM    GEN,137B       SET FLAGS IT INDICATE PARITY ERROR 
          SET.RM    PEF,1          IN THIS PARTIAL GET
          SET.RM    SES,3 
 NOIPF    BSS       0 
 SKGT     BSS       0 
          ON.RM     GSF,GET        IF NOT A SKIP REQUEST
 SK1      BSS       0 
          NE        B2,B3,SK2      IF *IN* " *OUT*
         SB6        EXITS 
          EQ        =YSKSF$SQ      SKIP RESIDUAL COUNT, RETURN TO USER
          SPACE     1 
 SK2      BSS       0 
          SA1       B3             LOAD S/L CONTROL WORD
          SX1       X1+B1          ADD IN S/L CONTROL WORD
          SB3       B3+X1          *OUT* + *SLW*
          LT        B3,B4,SK3      IF NOT PAST *LIMIT*
          SB5       B3-B4          SUBTRACT*LIMIT*
          SB3       B5+B6          ADD *FIRST*
 SK3      BSS       0 
          INC.RM    RC,1           INCREMENT RECORD COUNT 
          SB5       X4-1           DECREMENT SKIP COUNT 
          SET.RM    SKP,B5         STORE SKIP COUNT 
          SX4       B5
          SET.RM    OUT,B3
          NZ        B5,SK1         CONTINUE SKIPPING
          SET.RM    BLP,B3
         EQ         EXITS 
          SPACE     1 
 GET      BSS       0 
          SET.RM    FP,0           SET FP TO MID RECORD 
 .MD      IFNE      #BETA#,0
          F.RM      WSAD,2
 .MD      ELSE
          F.RM      WSA,2 
 .MD      ENDIF 
          SET.RM    UWD,X2
          OFF.RM    SOL,SCPGT      IF SCOPE DEVICE
          SB6       GT0 
          EQ        FILL           DELIVER AT LEAST 1 REC. TO BUFFER
 GT0      BSS       0 
          F.RM      SLW,B5         RESIDUAL WORDS THIS RECORD 
          NZ        B5,GT2         IF MID-RECORD
          SA1       B3             LOAD S/L CONTROL WORD
          SB5       X1             ISOLATE RECORD WORD COUNT
          MX2       30
          SX4       43691 
          BX1       -X2*X1
          IX4       X4*X1 
          SET.RM    SLW,B5         STORE RECORD WORD COUNT
          AX4       18+24          /6 = NUMBER OF CHAR
          SET.RM    SLC,X4         STORE UNUSED CHARACTERS
          BUFINC    B,3,1,4        POSITION OUT PAST S/L CONTROL WORD 
          SB3       X4
          SET.RM    OUT,X4
          BUFINC    B,3,5,4 
          SET.RM    BLP,X4
 GT2      BSS       0 
          SB4       B5+B3          *OUT* + WORDS RESIDUAL 
          F.RM      LIMIT,B5
          LT        B4,B5,GT4      LIMIT > OUT + SLW
          EQ        B4,B5,GT3      LIMIT = OUT + SLW
          SX4       B5-B3          WORDS AVAIL = LIMIT - OUT
          SB4       B0             UNUSED CHARS IN THIS PIECE 
          RJ        MOVE           MOVE MIN( THIS PIECE, PTL ) TO WSA 
 GT3      BSS       0 
          F.RM      FIRST,B3       OUT = FIRST
 GT4      BSS       0 
          F.RM      SLW,4          RECORD WORDS RESIDUAL
          F.RM      SLC,B4         UNUSED CHARS. IN THIS PIECE
          RJ        MOVE           MOVE MIN( THIS PIECE, PTL ) TO WSA 
 RXIT     BSS       0 
          SET.RM    FP,#EOR#       END-OF-RECORD
          INC.RM    RC,1           INCREMENT RECORD COUNT 
 EXIT    BSS        0 
          SX2       #GE#           SET LOP FOR GET
 EXITS   BSS        0 
          F.RM      GEN,X6
          NZ        X6,=XERR$RM    IF ERROR EXIT
          OFF.RM    SOL,OUTOK 
          ZR        B4,OUTOK       TRANSFER ON WORD BOUNDARY
          F.RM      FP,X1,-#EOR#
          NZ        X1,OUTOK
          SET.RM    SLW,0          IF AT EOR NO DATA LEFT OVER
          SET.RM    SLC,0 
          SET.RM    BCC,0 
          SB3       B3+B1          BUMP OUT POINTER 
          F.RM      LIMIT,B4
          NE        B4,B3,OUTOK    NOT AT LIMIT 
          F.RM      FIRST,B3       WRAP-AROUND
OUTOK     BSS       0 
          BX7       X"XREG.RM"
          SA7       A0+"FWRD.RM"
          SET.RM    OUT,B3
          RESTORE 
          SET.RM    LOP,X2         STORE LOP IN FIT 
          JP        B6             RETURN TO USER 
          SPACE     1 
 SCPGT    BSS       0 
          SB6       GT4A
          EQ        FILL
 GT4A     BSS       0 
          GE        B2,B3,GT5      IF *IN* \ *OUT*
          F.RM      LIMIT,B4
          SX4       B4-B3          WORDS AVAIL = LIMIT - OUT
          SB4       B0             UNUSED CHARS. THIS PIECE 
          RJ        MOVE           MOVE MIN( THIS PIECE, PTL ) TO WSA 
          F.RM      IN,B2          B2 CAN BE DESTROYED BY MOVE$RM 
 GT5      BSS       0 
          SX4       B2-B3          WORDS AVAIL = IN - OUT 
          SB4       B0             UNUSED CHARS. THIS PIECE 
          RJ        MOVE           MOVE MIN( THIS PIECE, PTL ) TO WSA 
          EQ        SCPGT          CONTINUE UNTIL ENDED BY FILL PROC. 
 FILL     EJECT     ENSURE DATA IN BUFFER, DETECT ERRORS/BOUNDARIES 
*#
*0        *FILL* IS A PROCEDURE TO ENSURE THAT THERE IS DATA IN THE 
*         BUFFER.  IT ALSO TAKES APPROPRIATE ACTION ON DETECTION OF 
*         ERROR AND FILE BOUNDARY CONDITIONS. 
*         FIRST SET THE PSEUDO-IN POINTER (*PIN*) EQUAL TO *IN*.
*         IF *PIN* IS EQUAL TO *OUT* AND THE FILE IS BUSY THEN GO INTO
*            PERIODIC RECALL AND START OVER.  IF THE FILE IS NOT BUSY 
*            THEN IF BITS 3-12 OF CODE AND STATUS ARE NON-ZERO CHECK
*                BITS 9-13 OF CODE AND STATUS FOR THE FOLLOWING:  
*                END OF INFORMATION - SET *FP* TO EOI AND GO TO *DXIT*. 
*                END OF VOLUME - CALL *CLSV$SQ*.
*                DEVICE CAPACITY EXCEEDED - ERROR 720.
*                NOT PARITY ERROR - ERROR 721.
*            NOW IF BIT 3 OF CODE AND STATUS IS ON WE HAVE THE FOLLOWING
*                BOUNDARY CONDITIONS TO CHECK AFTER TURNING BIT 3 OFF:  
*                BIT 4 OFF - END OF RECORD, GO TO *RXIT*. 
*                SET *FP* TO END-OF-PARTITION.
*     *DXIT*  IF DATA EXIT *DX* IS NON-ZERO TAKE DATA EXIT. 
*                GO TO *EXIT*.
*            NOW ISSUE CIO READ/READN REQUEST (PERIODIC RECALL) AND GO
*            TO START OF *FILL* PROCEDURE.
*         AT THIS POINT WE HAVE DATA IN THE BUFFER. 
*         IF THE COMPLETE BIT OF CODE AND STATUS IS ON THEN CHECK THE 
*            FOLLOWING: IF PARITY ERROR CALL *RPAR$SQ*.  IF THERE IS
*            ROOM FOR AT LEAST *MBL* MORE WORDS IN THE BUFFER THEN ISSUE
*            A READ/READN CIO REQUEST TO KEEP THE I/O GOING.
*         EXIT. 
*#
 BUSY     BSS       0 
          RCL.RM    1,COUNT 
 FILL     BSS       0 
          SA4       A0             LOAD CODE AND STATUS WORD
          F.RM      IN,B2 
          BX2       X4             SAVE CODE+STATUS FOR FIL4
          LX4       59
          NE        B2,B3,FIL4     IF BUFFER NOT EMPTY
          PL        X4,BUSY        IF FILE BUSY 
          LX4       1 
          MX3       59-13 
          BX3       -X3*X4
          AX3       9              ISOLATE BITS 13-9
          ZR        X3,FIL2        IF NO ERRORS 
          SB4       X3-#CSEOI#
          ZR        B4,FIL8        IF END-OF-INFORMATION
          SB4       X3-#CSEOV#
          SB5       FILL           RETURN TO TRY AGAIN
          NZ        B4,ENDV 
          BX7       X"XREG.RM"
          SA7       A0+"FWRD.RM"
          SAVE
          CLSV$SQ   GET 
          SA1       A0+"FWRD.RM"
          BX"XREG.RM" X1
          RESTORE 
          F.RM      OUT,B3         RESTORE OUT IN B3
          EQ        FILL
 ENDV     BSS 
          SB4       X3-#CSDCE#
          SX6       720B
          ZR        B4,=YERR$RM    DEVICE CAPACITY EXCEEDED 
          SB4       X3-#CSPAR#
          ZR        B4,FIL5        PARITY ERROR 
          SB4       X3-#CSDCP#
          SX6       721B
          NZ        B4,=YERR$RM    OTHER SCOPE ERROR
          EQ        FIL5           PARITY ERROR + DCE 
 FIL2     BSS       0 
          LX4       59-4           POSITION EOR BIT 
          LX1       X4,B1          AND EOF BIT
          BX1       X1*X4 
          MI        X1,EOF         IF END OF FILE 
          ON.RM     SOL,FIL3       IF S/L DEVICE DONT CHECK FOR EOR 
          PL        X4,FIL3        IF NOT END-OF-RECORD 
          MX3       1 
          BX7       -X3*X4         CLEAR END-OF-RECORD FLAG 
          LX7       5 
          SA7       A0
          EQ        RXIT           TAKE END-OF-RECORD EXIT
          SPACE     1 
 FIL3     BSS       0 
          F.RM      CCD            CIO READ/READN CODE
          SYSY      X1             KEEP THE I/O GOING 
          EQ        FILL           WAIT FOR *IN* TO MOVE
          SPACE     1 
 EOF      BSS       0 
          SET.RM    FP,#EOP#
 DXIT     BSS       0 
          SET.RM    SPR,0          DATA-EXIT TAKEN,RESUME READ-AHEAD
          BX7       X"XREG.RM"
          SA7       A0+"FWRD.RM"
          CLCD.SQ 
          RESTORE 
          F.RM      DX,B2          DATA EXIT ADDRESS
          NZ        B2,DX1         IF PRESENT 
          JP        B6
          SPACE     1 
 DX1      BSS       0 
          SX2       40B 
          SX7       B6
          LX2       21
          BX7       X7+X2 
          LX7       30
          SA7       B2             STORE EQ TO USER INTO DX ENTRY 
          BX7       X"XREG.RM"
          SA7       A0+"FWRD.RM"
          JP        B2+1           GO TO USER DATA EXIT 
          SPACE     1 
 FIL4     BSS       0 
          F.RM      FEC,X3
          ZR        X3,FIL6        NO ERROR CODE
          SB4       X3-#CSPAR#
          ZR        B4,FIL5        IF PARITY ERROR
          SB4       X3-#CSDCP#
          NZ        B4,FIL7        IF NOT PE OR PE AND DCE
 FIL5     BSS       0 
          F.RM      IN,B4          END OF BLOCK 
          SA1       B4
          SB2       X1             BEGINNING OF BAD BLOCK 
          NE        B2,B3,FIL7     IF ALL GOOD DATA NOT PROCESSED 
          F.RM      EO
          LX1       59-2
          PL        X1,NDISP       IF DISPLAY NOT REQUESTED 
*CALL /DPEDSQ/
          ON.RM     SOL,POSOK 
          SYSY      240B,R         SKIP TO EOR
 POSOK    BSS       0 
          F.RM      IN,B3          SET BUFFER EMPTY 
          SET.RM    OUT,B3
          CRMEP     ES=137B,SES=3 
 ACPTDAT  BSS       0 
          SX1       36000B
          SA2       A0
          BX7       -X1*X2
          SA7       A0             CLEAR ERROR STATUS 
          F.RM      OUT,B3
          SET.RM    GEN,137B
          EQ        FILL
 FIL6     BSS       0 
          PL        X4,FIL7        IF FILE BUSY 
          ON.RM     SOL,FIL9       IF S/L DEVICE
          LX4       56             POSITION EOR BIT 
          MI        X4,FIL7        IF EOR SET 
 FIL6A    BSS       0 
          BUFSP     B,2,3,2 
          F.RM      PRUSIZ
          IX3       X2-X1 
          MI        X3,FIL7        IF NO ROOM FOR 1 PRU OF DATA IN BUFF.
          LX4       4              POS COMPLETE BIT 
          PL        X4,FIL7        IF BUSY
          F.RM      CCD            READ/READN CODE
          SYSY      X1             KEEP CIO GOING 
 FIL7     BSS       0 
          JP        B6             RETURN 
          SPACE     1 
 FIL8     BSS       0 
          F.RM      RL
          NZ        X1,RXIT        IF RECORD MOVED
          SET.RM    FP,#EOI#       END-OF-INFORMATION 
          EQ        DXIT           TAKE DATA EXIT 
  
 FIL9     ON.RM     SPR,FIL7       READ AHEAD SUPPRESSED
          F.RM      FLEV,X3,-17B
          NZ        X3,FIL6A
          SET.RM    SPR,1          CODE/STATUS=EOF, SUPPRESS READ-AHEAD 
          EQ        FIL7
  
 MOVE     EJECT     MOVE MIN( AVAIL DATA, PTL ) TO WSA FROM BUFFER
*#
*0        *MOVE* IS A PROCEDURE TO MANAGE THE TRANSFER OF DATA FROM THE 
*         CIRCULAR BUFFER TO THE USERS WORKING STORAGE AREA.  FIRST,
*         CONTIGUOUS AVAILABLE DATA IS CONVERTED FROM WORDS AND UNUSED
*         CHARACTERS TO CHARACTERS.  IF WE ARE NOT DOING A PARTIAL GET
*            THEN SET STARTING AND DESTINATION CHARACTER POSITIONS TO 
*            ZERO AND CALL *MVCALL* TO MANAGE *RL* AND *PTL* FIELDS,
*            DETECT INSUFICIENT DATA ERROR, AND INTERFACE TO *MOVE$RM*. 
*            NOW UPDATE THE *OUT* POINTER AND, FOR S/L DEVICES, THE 
*            RECORD LENGTH RESIDUAL *SLW*.  IF THE INSUFICIENT DATA FLAG
*            IS ON SET *FP* TO EOR AND ISSUE ERROR 143.  EXIT.
*         FOR PARTIAL GETS WE SET THE MOVE COUNT TO THE MINIMUM OF THE
*         CONTIGUOUS DATA AVAILABLE AND *RPTL*.  SET SOURCE CHARACTER 
*         POSITION TO *BCC* AND DESTINATION CHARACTER POSITION TO *UCP* 
*         AND CALL *MVCALL* TO MANAGE *RL* AND *PTL* FIELDS, DETECT 
*         INSUFICIENT DATA ERROR, AND INTERFACE TO *MOVE$RM*.  NOW STORE
*         THE NEW VALUES FOR *BCC* AND *UCP*, UPDATE THE *OUT* POINTER
*         AND, FOR S/L DEVICES, THE RECORD LENGTH RESIDUAL *SLW*.  IF 
*         *PTL* DOES NOT EQUAL *RPTL* THE TRANSFER IS NOT COMPLETE AND
*         WE RETURN FOR MORE DATA.  ELSE IF THE TRANSFER IS COMPLETE
*         THEN IF S/L DEVICE AND *SLW* EQUALS ZERO GO TO *RXIT* FOR EOR 
*         HANDLING.  IF S/L DEVICE AND *SLW* NOT ZERO GO TO *EXIT*. 
*         IF SYSTEM DEVICE CALL *FILL* PROCEDURE TO DETECT EOR CONDITION
*         GO TO *EXIT*. 
*#
 MOVE     EQ        *+1S17
          ZR        X4,MOVE        RETURN IMMEDIATELY ON ZERO MOVE REQ
          IX5       X4+X4          *10
          LX4       3 
          IX2       X5+X4 
          SX3       B4             AVAIL WORDS CONVERTED TO CHARS.
          IX3       X2-X3 
          SX4       X3
          AX3       17
          ZR        X3,MV0         JP IF TRANSFER IS LT 2**17 CHAR
          SX4       1S17-1         MAX TRANSFER FOR MOVE$RM 
 MV0      BSS       0 
          ON.RM     PRD,MV1        IF PARTIAL GET 
          SB3       B0             SOURCE BCP 
          SB5       B0             DESTINATION BCP
          RJ        MVCALL         MOVE$RM CONTROLLER 
          RJ        SOLBLP         UPDATE SOME FIT FIELDS 
          EQ        MOVE
          SPACE     1 
 MV1      BSS       0 
          F.RM      PTL,1          CHARACTERS OF GETP ALREADY XFERED
          F.RM      RPTL,2         TOTAL CHARACTERS REQUESTED BY GETP 
          IX3       X2-X1 
          IX5       X3-X4          (RPTL-PTL)-AVAILABLE 
          PL        X5,MV2         IF LESS AVAILABLE THAN NEEDED
          BX4       X3             USE (RPTL - PTL) REQUEST RESIDUAL
 MV2      BSS       0 
          F.RM      BCC,B3         SOURCE BCP 
          F.RM      UCP,B5         DESTINATION BCP
          RJ        MVCALL         MOVE$RM CONTROLLER 
          SET.RM    BCC,X4         NEXT SOURCE BCP AFTER MOVE 
          SET.RM    UCP,B4         NEXT DESTINATION BCP AFTER MOVE
          RJ        SOLBLP         UPDATE SOME FIT FIELDS 
          F.RM      PTL,1 
          F.RM      RPTL,2
          IX3       X1-X2 
          NZ        X3,MOVE        PTL NOT SATISFIED, GET MORE DATA 
          SB6       EXIT
          OFF.RM    SOL,FILL       IF SCOPE DEVICE CHECK FOR EOR
          F.RM      SLW            RESIDUAL WORDS IN S/L RECORD 
          ZR        X1,RXIT        END-OF-RECORD
          EQ        EXIT           PARTIAL GET COMPLETE, NOT EOR
          SPACE     1 
 SOLBLP   EQ        *+1S17
          BUFINC    B,3,5,7 
          SB3       X7
          SET.RM    OUT,X7
          OFF.RM    SOL,SL1        IF SCOPE DEVICE DONT DECREMENT *SLW* 
          DEC.RM    SLW,B5         UPDATE RESIDUAL WORDS IN RECORD
 SL1      BSS       0 
          OFF.RM    ISD,SOLBLP     IF NOT EXCESS DATA 
          SET.RM    ISD,#NO#
          SET.RM    GEN,142B       SET ISD ERROR CODE 
          F.RM      SLW,5 
          SX4       B0             SET SKIP COUNT TO ZERO 
          F.RM      FIRST,B6
          F.RM      LIMIT,B4       RESTORE B4 TO LIMIT
          SET.RM    GSF,0          SET TO SKIP REST OF DATA 
          EQ        MID1           SKIP REMAINDER OF RECORD 
          SPACE     2 
 MVCALL   EJECT     INTERFACE WITH MOVE$RM, MAINTAIN SOME FIT FIELDS
*#
*0        *MVCALL* IS A PROCEDURE TO INTERFACE WITH *MOVE$RM*, MANAGE 
*         *RL* AND *PTL* COUNTERS, AND DETECT INSUFICIENT DATA ERROR. 
*         FIRST CHECK IF CHARACTERS TO BE MOVED PLUS *RL* EXCEEDS *MRL*.
*         IF IT DOES NOT EXCEED *MRL* INCREMENT *RL* BY THE AMOUNT TO BE
*         MOVED.  ELSE, SET CHARACTERS TO BE MOVED TO *MRL* - *RL*, 
*         SET *RL* TO *MRL*, AND SET THE INSUFICIENT DATA FLAG. 
*         IF THIS IS A GETP INCREMENT *PTL* BY THE CHARACTERS TO BE 
*         MOVED.  NOW GET THE SOURCE LOCATION TO THE *OUT* POINTER, THE 
*         DESTINATION LOCATION TO *UWD* AND CALL *MOVE$RM*.  NOW UPDATE 
*         *UWD* AND EXIT. 
*#
 MVCALL   EQ        *+1S17
          F.RM      RL,2
          IX2       X2+X4          RL + CHARACTERS TO BE MOVED
          F.RM      MRL,5 
          ZR        X5,MC1         IF MRL = 0 
          IX3       X5-X2          *MRL* - (*RL* + AVAIL) 
          PL        X3,MC1         IF *MRL* NOT EXCEEDED
          SET.RM    ISD,#YES#      EXCESS DATA
          IX4       X4+X3          MOVE MRL - RL CHARACTERS 
          BX2       X5             *RL* = *MRL* 
 MC1      BSS       0 
          SB4       X4             SAVE MOVE COUNT
          SET.RM    RL,X2          STORE MEW RECORD LEMGTH
          OFF.RM    PRD,MC2        IF NOT GETP
          INC.RM    PTL,X4         INCREMENT PARTIAL TRANSFER LENGTH
 MC2      BSS       0 
          F.RM      OUT,3          SOURCE LOCATION
          F.RM      UWD,5 
 .MD      IFNE      #BETA#,0
          F.RM      WSAB,X1        0=SCM WSA, 1=LCM WSA 
          LX1       21
          BX5       X5+X1          INCLUDE LCM FLAG IN DEST. ADDRESS
 .MD      ENDIF 
          SB6       MC3 
          EQ        =YMOVE$RM      MOVE THE DATA
 MC3      BSS       0 
          SET.RM    UWD,X5         ADDRESS TO RECEIVE NEXT CHARACTER
          F.RM      OUT,B3
          SA3       X3
          SB5       A3-B3          LOC OF NEXT WORD TO MOVE - *OUT* 
          EQ        MVCALL
* END /GETDS/ 
