*DECK CVT 
          IDENT  CVT
          BASE   D
 CVT      TITLE  CVT - FIP DATA CONVERSION ROUTINES 
          ENTRY  CVT
          COMMENT  FIP DATA CONVERSION ROUTINES 
          COMMENT  COPYRIGHT CONTROL DATA CORPORATION.  1982. 
          SPACE  4,10 
*****     CVT - FIP DATA CONVERSION ROUTINES. 
* 
*         E.E. NELSON              03/06/82.
* 
*         CVT SUPPLIES THE DATA CONVERSION ROUTINES FOR FIP.
*         CONVERSION IS BEING PERFORMED IN ASSEMBLY LANGUAGE TO 
*         PROVIDE BETTER CODE CONVERSION SPEED THAN IS POSSIBLE 
*         IN SYMPL. 
          EJECT 
***       CVT CALLING SEQUENCE. 
* 
*         CVT IS CALLED WITH THE SYMPL CONVENTION OF A1 CONTAINING
*         THE ADDRESS OF THE PARAMETER BLOCK.  THE PARAMETER BLOCK
*         HAS ONLY ONE PARAMETER WHICH IS THE ADDRESS OF THE
*         CONVERSION STATE ARRAY.  THE CONVERSION STATE ARRAY 
*         HAS ONE WORD PER VARIABLE.  THE VARIABLES ARE:  
* 
*         CVTTYPE,STATE,INPTR,INBLKBYT,INWDBYT, 
*                 OUTPTR,OUTBLKBYT,OUTWDBYT,CVTTBLPTR,CURINWD 
* 
*         WHERE 
* 
*         CVTTPYE   - CONVERSION TYPE   0 = WORD MOVE 
*                                       1 = CN -> C6
*                                       2 = CN -> C8
*                                       3 = C6 -> CN
*                                       4 = C8 -> CN
* 
*         STATE     - STATE OF CONVERSION   0 = NORMAL
*                                           1 = LAST CHAR WAS COLON 
*                                           2 = ZBYTE REQUIRED
*                                           3 = ZBYTE POSSIBLE
* 
* 
*         INPTR     - PREVIOUS INPUT WORD POINTER 
* 
*         INBLKBYT  - INPUT BLOCK BYTES INDICATES NUMBER OF BYTES 
*                     VALID WITHIN INPUT BLOCK. BYTES CONSIST OF: 
*                         60 BITS FOR CONVERSION TYPE 0 (WORD MOVE) 
*                         12 BITS FOR CONVERSION TYPES 1,2&4
*                         6  BITS FOR CONVERSION TYPE 3  (FROM C6)
* 
*         INWDBYT   - INPUT WORD BYTES INDICATES NUMBER OF BYTES
*                     VALID REMAINING WITHIN PREVIOUS INPUT WORD
* 
*         OUTPTR    - PREVIOUS OUTPUT WORD POINTER
* 
*         OUTBLKBYT - OUTPUT BLOCK BYTES INDICATES NUMBER OF BYTES
*                     UNUSED WITHIN OUTPUT BLOCK. BYTES CONSIST OF: 
*                         60 BITS FOR CONVERSION TYPE 0 (WORD MOVE) 
*                         12 BITS FOR CONVERSION TYPES 2,3&4
*                         6  BITS FOR CONVERSION TYPE 1 (TO C6) 
* 
*         OUTWDBYT  - OUTPUT WORD BYTES INDICATES NUMBER OF BYTES 
*                     USED WITHIN OUTPUT WORD 
* 
*         CVTTBLPTR - CONVERSION TABLE POINTER
* 
*         CURINWD   - PREVIOUS INPUT WORD SHIFTED SUCH THAT NEXT
*                     INPUT CHARACTER IS IN LEFT MOST POSITION. 
 CVT      SPACE  4,10 
**        SYMBOLS USED BY CVT.
  
  
 ASCOLON  EQU    72B               ASCII COLON
 ASUS     EQU    37B               ASCII UNIT SEPARATOR 
 NULLPRT  EQU    4000B             NULL PROTECTED BY BIT 11 SET 
 ASCBLNK  EQU    40B               ASCII BLANK
 BLANK    EQU    1R                DISPLAY CODE BLANK 
 COLAST   EQU    1                 COLON WAS LAST CHARACTER 
 ZREQ     EQU    2                 Z-BYTE REQUIRED STATE
 ZPOSS    EQU    3                 Z-BYTE POSSIBLE STATE
 CVT      TITLE  CVT - DATA CONVERSION. 
**        CVT - FIP DATA CONVERSION 
* 
*         CVT MOVES THE PARAMETERS TO REGISTERS.
*         THE SPECIFIED CONVERSION ROUTINE IS CALLED. 
*         THE CONTENTS OF REGISTERS ARE MOVED BACK TO THE PARAMETER 
*         BLOCK.
*         CVT RETURNS TO CALLER.
* 
*         ENTRY  (A1) = PARAMETER BLOCK POINTER (SEE CALLING SEQ.)
* 
*         USES   MOST REGISTERS AS INDICATED BY NOTE
* 
*         CALLS  C6N,C8N,NC6,NC8. 
* 
*         NOTE   THE PARAMETER BLOCK TO REGISTER MAPPING IS AS FOLLOWS
* 
*                A0 = CONVERSION STATE ARRAY
*                X0 = MASK REGISTER 
*                B0 = ZERO
* 
*                A1 = GENERAL USE 
*                X1 = GENERAL USE 
*                B1 = ONE 
* 
*                A2 = GENERAL USE 
*                X2 = GENERAL USE 
*                B2 = GENERAL USE 
* 
*                A3 = GENERAL USE 
*                X3 = GENERAL USE 
*                B3 = CVTTBLPTR 
* 
*                A4 = RESERVED
*                X4 = STATE 
*                B4 = INBLKBYT
* 
*                A5 = INPTR 
*                X5 = CONTENTS OF INPUT WORD
*                B5 = INWDBYT 
* 
*                A6 = GENERAL USE 
*                X6 = GENERAL USE 
*                B6 = OUTBLKBYT 
* 
*                A7 = OUTPTR
*                X7 = CONTENTS OF OUTPUT WORD 
*                B7 = OUTWDBYT
* 
*         CAUTION- THE WORD POINTED TO BY OUTPTR IS INERT SUCH THAT AN
*                  ASYNCHRONOUS PROCESS WILL NOT MODIFY THE WORD. 
* 
*                  THE OUTPTR IS ASSUMED TO BE THE START OUTPUT 
*                  ADDRESS - 1 AND OUTWDBYT IS ZERO.
* 
*                  THE OUTBLKBYT VALUE IS ASSUMED TO START AS A MULTIPLE
*                  OF THE BYTES POSSIBLE IN ONE WORD (5 OR 10). 
* 
*                  IF NO INPUT IS AVAILABLE THEN STATE MUST NOT BE
*                  NORMAL AND EOI CONDITION IS ASSUMED. 
* 
*                  THE INPTR IS ASSUMED TO BE THE START INPUT 
*                  ADDRESS- 1 AND INWDBYT IS ZERO 
  
  
CVT       SUBR                     ENTRY/EXIT 
          SB1    1                 B1 = 1 
          SA0    X1 
          SA4    A0+B1             X4 = STATE 
          SA5    A4+B1             INPTR
          SA2    A5+B1             INBLKBYT 
          SA5    X5                A5 = INPTR  X5 = (INPTR) 
          SB4    X2                B4 = INBLKBYT
          SA3    A2+B1             INWDBYT
          SA1    A3+B1             OUTPTR 
          SB5    X3                B5 = INWDBYT 
          SA2    A1+B1             OUTBLKBYT
          SA1    X1                GET CONTENTS OF OUTPTR 
          SB6    X2                B6 = OUTBLKBYT 
          SA3    A2+B1             OUTWDBYT 
          BX7    X1                X7 = CONTENTS OF OUTPTR
          SA7    A1                A7 = OUTPTR
          SA2    A3+B1             CVTTBLPTR
          SB7    X3                B7 = OUTWDBYT
          SA3    A2+B1             CURINWD
          SA1    A0                CVTTYPE
          SB3    X2                B3 = CVTTBLPTR 
          BX5    X3                X5 = CURINWD 
          SX7    B0                SET OUTPUT WORD TO BINARY ZEROES 
          ZR     B7,CVT1           IF NO BYTES IN OUTPUT WORD USED
          SA2    A7+B1
          BX7    X2                RESTORE OUTPUT WORD
 CVT1     SB2    X1                CONVERSION TYPE
          SB2    B2+B2             COMPUTE JUMP TABLE OFFSET
          JP     B2+CVT2           SELECT RETURN JUMP TO CONVERSION RTN.
  
 CVT2     RJ     CPY               WORD MOVE CALL 
          EQ     CVT3 
 +        RJ     NC6               CN -> C6 
          EQ     CVT3 
 +        RJ     NC8               CN -> C8 
          EQ     CVT3 
 +        RJ     C6N               C6 -> CN 
          EQ     CVT3 
 +        RJ     C8N               C8 -> CN 
          EQ     CVT3 
  
 CVT3     SA1    A0                CONVERSION ROUTINES RETURN HERE
          ZR     X1,CVT            IF WORD MOVE, RETURN--POINTERS SAVED 
          SX0    A7                SAVE OUTPTR
          ZR     B7,CVT4           IF NO BYTES IN OUTPUT WORD USED
          SA7    A7+B1             SAVE OUTPUT WORD 
 CVT4     BX7    X4 
          SA7    A0+B1             SAVE STATE 
          SX6    A5 
          SX7    B4 
          SA6    A7+B1             SAVE INPTR 
          SA7    A6+B1             SAVE INBLKBYT
          SX6    B5 
          BX7    X0 
          SA6    A7+B1             SAVE INWDBYT 
          SA7    A6+B1             SAVE OUTPTR
          SX6    B6 
          SX7    B7 
          SA6    A7+B1             SAVE OUTBLKBYT 
          SA7    A6+B1             SAVE OUTWDBYT
          BX6    X5 
          SA6    A7+2              SAVE CURINWD 
          EQ     CVT               RETURN TO CALLER 
  
 CPY      TITLE  CPY - DO WORD MOVE 
**        CPY - COPY BLOCK OF WORDS 
* 
*         CPY COPIES A BLOCK OF WORDS USING THE MOVE MACRO AND COMMON 
*         COMMON ROUTINE COMCMVE. 
* 
*         ENTRY  A5 = INPTR -- FROM STARTING LOCATION 
*                B4 = INBLKBYT -- MAX NUMBER OF WDS TO MOVE FROM INPTR
*                A7 = OUTPTR -- TO STARTING LOCATION
*                B6 = OUTBLKBYT -- MAX NUMBER OF WDS TO MOVE TO OUTPTR
*                A0 = CONVERSION TABLE ADDRESS (SEE CVT COMMENTS) 
* 
*         EXIT   INPTR,OUTPTR,INBLKBYT AND OUTBLKBYT HAVE BEEN UPDATED
*                  IN THE CONVERSION TABLE
*                MOVE HAS BEEN ACCOMPLISHED.
* 
  
 CPY      SUBR                     ENTRY/EXIT 
  
*         SET B3= NUM OF WORDS TO MOVE = MIN(INBLKBYT,OUTBLKBYT)
  
          SB2    B6-B4             OUTBLKBYT - INBLKBYT 
          SB3    B6 
          MI     B2,CPY1           IF INBLKBYT .GT. OUTBLKBYT 
          SB3    B4                B3 = MIN(INBLKBYT,OUTBLKBYT) 
 CPY1     SX6    B3+A5             UPDATE INPTR TO SHOW NUM WORDS MOVED 
          SX7    B4-B3             UPDATE INBLKBYT
          SA6    A0+2              SAVE INPTR 
          SB2    A7                SAVE OUTPTR
          SA7    A6+B1             SAVE INBLKBYT
          SX6    B3+B2             UPDATE OUTPTR TO SHOW NUM WORDS MOVED
          SX7    B6-B3             UPDATE OUTBLKBYT 
          SA6    A7+2              SAVE OUTPTR
          SA7    A6+B1             SAVE OUTBLKBYT 
  
          MOVE   B3,A5+B1,B2+B1 
  
          EQ     CPY               RETURN 
 C8N      TITLE  C8N - C8 TO CN CONVERSION. 
**        C8N - C8 TO CN CONVERSION 
* 
*         C8N CONVERTS CDC Z-BYTE 8/12 ASCII (C8) TO LCN
*         NORMALIZED ASCII (CN).
* 
*         IF NO OUTPUT SPACE AVAILABLE
*         THEN: 
*           RETURN WITH NO CHANGES. 
*         IF NO INPUT VALID (ASSUME EOI REACHED)
*         THEN: 
*           SET NORMAL STATE. 
*           RETURN. 
*         ADJUST PARAMETERS SUCH THAT:  
*           INBLKBYT = INBLKBYT - INWDBYT  (BYTES IN REMAINING WORDS) 
*           OUTWDBYT = 5 - OUTWDBYT  (UNUSED BYTES IN OUTPUT WORD)
*           OUTBLKBYT = OUTBLKBYT - OUTWDBYT  (UNUSED BYTES IN OUTBLK)
*         PERFORM CONVERSION. 
*         HANDLE SPECIAL CASES.  (SEE INLINE COMMENTS)
*         ADJUST PARAMETERS BACK TO INPUT STATE.
*         RETURN. 
* 
*         ENTRY  SEE CVT COMMENTS 
* 
*         EXIT   SEE CVT COMMENTS 
* 
*         NOTE   THE PARAMETERS ARE ADJUSTED TO MAXIMIZE THE
*                CONVERSION SPEED OF THE INNER LOOP.
  
  
 C8N      SUBR                     ENTRY/EXIT 
          ZR     B6,C8N            IF NO OUTPUT SPACE AVAILABLE 
          SX4    B0                SET NORMAL STATE 
          SB7    -B7
          MX0    -12               SET MASKS
          MX3    -8 
          SB7    B7+5              ADJUST OUTWDBYT
          SB6    B6-B7             ADJUST OUTBLKBYT 
          SB4    B4-B5             ADJUST INBLKBYT
          EQ     C8N02
  
* 
*         THE FOLLOWING CONVERSION CODE SHOULD BE 
*         OPTIMIZED TO MAXIMIZE CHARACTER CONVERSION RATE.
*         PLEASE NOTE THAT IN ORDER TO MAXIMIZE THE CONVERSION
*         RATE, A CONVERSION TABLE WAS NOT USED.  IF SEVERAL
*         ADDITIONAL SPECIAL CASES (OTHER THAN Z BYTE) ARE
*         REQUIRED, A CONVERSION TABLE MAY BE NEEDED. 
* 
  
 C8N01    LX5    12                POSITION INPUT WORD FOR NEXT BYTE
          BX2    -X0*X5            CHECK FOR NULL WITHOUT BIT 11 SET
          BX1    -X3*X5            OBTAIN NEXT C6 CHARACTER 
          SB5    B5-B1             DECREMENT INPUT WORD BYTES AVAIL 
          ZR     X2,C8N04          IF Z-BYTE
          BX7    X1+X7             INSERT INTO OUTPUT WORD
          SB7    B7-B1             DECREMENT OUTPUT WORD UNUSED BYTES 
          MX4    0                 SET NORMAL STATE 
          ZR     B7,C8N03          IF OUTPUT WORD FULL
          LX7    12                POSITION OUTPUT WORD FOR NEXT BYTE 
 C8N02    NZ     B5,C8N01          IF INPUT WORD NOT EMPTY
          ZR     B4,C8N08          IF NO BYTES WITHIN INPUT BLOCK 
          SB5    5                 ASSUME FULL INPUT WORD 
          SA5    A5+B1             OBTAIN NEXT INPUT WORD 
          SB4    B4-B5             CALCULATE REMAINING BYTES IN BLOCK 
          PL     B4,C8N01          IF READY WITH NEXT INPUT WORD
          SB5    B5+B4             SET PARITIAL INPUT WORD
          SB4    B0                SET BLOCK EMPTY
          EQ     C8N01
  
 C8N03    SA7    A7+B1             SAVE OUTPUT WORD 
          ZR     B6,C8N09          IF OUTPUT BLOCK FULL 
          MX7    0                 ZERO OUTPUT WORD 
          SB7    5                 SET FULL OUTPUT WORD 
          SB6    B6-B7             CALCULATE REMAINING BYTES IN BLOCK 
          EQ     C8N02
  
* 
*         HANDLE SPECIAL CASE OF Z-BYTE.
*         IF REMAINING BYTES IN WORD ARE ZERO 
*         THEN: 
*           BYPASS REMAINING BYTES. 
*           INSERT ASCII US IN OUTPUT STREAM. 
*         ELSE: 
*           INSERT ASCII NULL BYTE. 
* 
  
 C8N04    BX2    X5                COPY INPUT WORD
          SB2    B5                COPY INWDBYT 
 C8N05    ZR     B2,C8N07          IF INPUT WORD EMPTY
          LX2    12                POSITION INPUT WORD FOR NEXT BYTE
          BX1    -X0*X2            OBTAIN NEXT C8 CHARACTER 
          SB2    B2-B1             DECREMENT INPUT WORD BYTES AVAIL 
          ZR     X1,C8N05          IF Z-BYTE
          MX1    0                 INSERT NULL BYTE 
 C8N06    BX7    X1+X7             INSERT INTO OUTPUT WORD
          SB7    B7-B1             DECREMENT OUTPUT WORD UNUSED BYTES 
          ZR     B7,C8N03          IF OUTPUT WORD FULL
          LX7    12                POSITION OUTPUT WORD FOR NEXT BYTE 
          SX4    B0                SET NORMAL STATE 
          EQ     C8N02
  
 C8N07    BX5    X2                BYPASS REST OF INPUT WORD
          SB5    B0 
          SX1    ASUS              INSERT ASCII US
          EQ     C8N06
  
* 
*         INPUT BLOCK IS EMPTY. 
*         ADJUST PARAMETERS AND EXIT. 
* 
  
 C8N08    SB6    B6+B7             SHOW BYTES UNUSED IN OUTPUT BLOCK
          SB7    -B7
          SB7    B7+5              ADJUST TO BYTES USED IN OUTPUT WORD
          EQ     C8N               EXIT 
  
* 
*         OUTPUT BLOCK IS FULL. 
*         ADJUST PARAMETERS AND EXIT. 
* 
  
 C8N09    SB4    B4+B5             SHOW BYTES VALID IN INPUT BLOCK
          EQ     C8N               EXIT 
 NC8      TITLE  NC8 - CN TO C8 CONVERSION. 
**        NC8 - NORMALIZED ASCII (CN) TO C8 CONVERSION
* 
*         NC8 CONVERTS LCN NORMALIZED ASCII (CN) TO CDC Z-BYTE
*         8/12 ASCII (C8).
* 
*         IF NO OUTPUT SPACE AVAILABLE
*         THEN: 
*           RETURN WITH NO CHANGES. 
*         IF NO INPUT VALID (ASSUME EOI REACHED)
*         THEN: 
*           SET STATE TO NORMAL.
*           RETURN. 
*         ADJUST PARAMETERS SUCH THAT:  
*           INBLKBYT = INBLKBYT - INWDBYT  (BYTES IN REMAINING WORDS) 
*           OUTWDBYT = 5 - OUTWDBYT  (UNUSED BYTES IN OUTPUT WORD)
*           OUTBLKBYT = OUTBLKBYT - OUTWDBYT  (UNUSED BYTES IN OUTBLK)
*         PERFORM CONVERSION. 
*         HANDLE SPECIAL CASES.  (SEE INLINE COMMENTS)
*         ADJUST PARAMETERS BACK TO INPUT STATE.
*         RETURN. 
* 
*         ENTRY  SEE CVT COMMENTS 
* 
*         EXIT   SEE CVT COMMENTS 
* 
*         NOTE   THE PARAMETERS ARE ADJUSTED TO MAXIMIZE THE
*                CONVERSION SPEED OF THE INNER LOOP.
  
  
 NC8      SUBR                     ENTRY/EXIT 
          ZR     B6,NC8            IF NO OUTPUT SPACE AVAILABLE 
          NZ     B4,NC801          IF INPUT AVAILABLE 
          MX4    0                 SET NORMAL STATE 
          EQ     NC8               RETURN 
 NC801    SB7    -B7
          SB4    B4-B5             ADJUST INBLKBYT
          SB7    B7+5              ADJUST OUTWDBYT
          SB6    B6-B7             ADJUST OUTBLKBYT 
          MX0    -8                SET UP EIGHT BIT MASK
          SX3    ASUS              PRESET ASCII US
          EQ     NC804
  
* 
*         THE FOLLOWING CONVERSION CODE SHOULD BE 
*         OPTIMIZED TO MAXIMIZE CHARACTER CONVERSION RATE.
*         PLEASE NOTE THAT IN ORDER TO MAXIMIZE THE CONVERSION
*         RATE, A CONVERSION TABLE WAS NOT USED.  SHOULD ADDITIONAL 
*         SPECIAL CASES BE REQUIRED, A CONVERSION TABLE MAY BE
*         NEEDED. 
* 
  
 NC802    LX5    12                POSITION INPUT WORD FOR NEXT BYTE
          BX1    -X0*X5            OBTAIN NEXT CN CHARACTER 
          BX2    X1-X3             COMPARE TO ASCII US
          SB5    B5-B1             DECREMENT INPUT WORD BYTES AVAIL 
          ZR     X2,NC806          IF ASCII US INPUT
          ZR     X1,NC808          IF NULL INPUT
 NC803    BX7    X1+X7             INSERT INTO OUTPUT WORD
          SB7    B7-B1             DECREMENT OUTPUT WORD UNUSED BYTES 
          ZR     B7,NC805          IF OUTPUT WORD FULL
          LX7    12                POSITION OUTPUT WORD FOR NEXT BYTE 
 NC804    NZ     B5,NC802          IF INPUT WORD NOT EMPTY
          ZR     B4,NC809          IF NO BYTES WITHIN INPUT BLOCK 
          SB5    5                 ASSUME FULL INPUT WORD 
          SA5    A5+B1             OBTAIN NEXT INPUT WORD 
          SB4    B4-B5             CALCULATE REMAINING BYTES IN BLOCK 
          PL     B4,NC802          IF READY WITH NEXT INPUT WORD
          SB5    B5+B4             SET PARTIAL INPUT WORD 
          SB4    B0                SET BLOCK EMPTY
          EQ     NC802
  
 NC805    SA7    A7+B1             SAVE OUTPUT WORD 
          ZR     B6,NC810          IF OUTPUT BLOCK FULL 
          MX7    0                 ZERO OUTPUT WORD 
          SB7    5                 SET FULL OUTPUT WORD 
          SB6    B6-B7             CALCULATE REMAINING BYTES IN BLOCK 
          EQ     NC804
  
* 
*         PERFORM Z-BYTE INSERTION INTO THE OUTPUT STREAM.
* 
  
 NC806    SB7    B7-B1             DECREMENT OUTPUT WORD UNUSED BYTES 
          ZR     B7,NC805          IF OUTPUT WORD FULL
          LX7    12                ADD 12 MORE BITS OF ZERO 
          EQ     NC806
  
* 
*         PROTECT ASCII NULL FROM BEING MISTAKEN AS Z-BYTE
*         BY SETTING BIT 11.
* 
  
 NC808    SX1    NULLPRT           SET BIT 11 OF NULL 
          EQ     NC803
  
* 
*         INPUT BLOCK IS EMPTY. 
*         ADJUST PARAMETERS AND EXIT. 
* 
  
 NC809    SB6    B6+B7             SHOW BYTES UNUSED IN OUTPUT BLOCK
          SB7    -B7
          SB7    B7+5              ADJUST TO BYTES USED IN OUTPUT WORD
          EQ     NC8               EXIT 
  
* 
*         OUTPUT BLOCK IS FULL. 
*         ADJUST PARAMETERS AND EXIT. 
* 
  
 NC810    SB4    B4+B5             SHOW BYTES VALID IN INPUT BLOCK
          EQ     NC8               EXIT 
          SPACE  4,10 
 C6N      TITLE  C6N - C6 TO CN CONVERSION
**        C6N - C6 TO CN CONVERSION 
* 
*         C6N CONVERTS CDC INTERNAL DISPLAY CODE (C6) TO LCN
*         NORMALIZED ASCII (CN).
* 
*         IF NO OUTPUT SPACE AVAILABLE
*         THEN: 
*           RETURN WITH NO CHANGES. 
*         ADJUST PARAMETERS SUCH THAT:  
*           INBLKBYT = INBLKBYT - INWDBYT  (BYTES IN REMAINING WORDS) 
*           OUTWDBYT = 5 - OUTWDBYT  (UNUSED BYTES IN OUTPUT WORD)
*           OUTBLKBYT = OUTBLKBYT - OUTWDBYT  (UNUSED BYTES IN OUTBLK)
*         IF STATE IS Z-BYTE POSSIBLE 
*         THEN: 
*           GOTO SPECIAL CASE PROCESSING.  (SEE INLINE COMMENTS)
*         PERFORM CONVERSION. 
*         HANDLE SPECIAL CASES. 
*         ADJUST PARAMETERS BACK TO INPUT STATE.
*         RETURN. 
* 
*         ENTRY  SEE CVT COMMENTS 
* 
*         EXIT   SEE CVT COMMENTS 
* 
*         NOTE   THE PARAMETERS ARE ADJUSTED TO MAXIMIZE THE
*                CONVERSION SPEED OF THE INNER LOOP.
  
  
 C6N      SUBR                     ENTRY/EXIT 
          ZR     B6,C6N            IF NO OUTPUT SPACE AVAILABLE 
          SB7    -B7
          SB4    B4-B5             ADJUST INBLKBYT
          SB7    B7+5              ADJUST OUTWDBYT
          SB6    B6-B7             ADJUST OUTBLKBYT 
          MX0    -6                SET UP SIX BIT MASK
          SX2    X4-ZPOSS 
          SA1    B3                GET CONVERSION CHARACTER FOR NULL
          MX4    0                 SET NORMAL STATE 
          ZR     X2,C6N05          IF STATE WAS Z-BYTE POSSIBLE 
          EQ     C6N02
  
* 
*         THE FOLLOWING CONVERSION CODE SHOULD BE 
*         OPTIMIZED TO MAXIMIZE CHARACTER CONVERSION RATE.
* 
  
 C6N01    LX5    6                 POSITION INPUT WORD FOR NEXT BYTE
          BX2    -X0*X5            OBTAIN NEXT C6 CHARACTER 
          SA1    X2+B3             CONVERT TO CN
          SB5    B5-B1             DECREMENT INPUT WORD BYTES AVAIL 
          MI     X1,C6N04          IF SPECIAL CASE
          BX7    X1+X7             INSERT INTO OUTPUT WORD
          SB7    B7-B1             DECREMENT OUTPUT WORD UNUSED BYTES 
          MX4    0                 SET NORMAL STATE 
          ZR     B7,C6N03          IF OUTPUT WORD FULL
          LX7    12                POSITION OUTPUT WORD FOR NEXT BYTE 
 C6N02    NZ     B5,C6N01          IF INPUT WORD NOT EMPTY
          ZR     B4,C6N11          IF NO BYTES WITHIN INPUT BLOCK 
          SB5    10                ASSUME FULL INPUT WORD 
          SA5    A5+B1             OBTAIN NEXT INPUT WORD 
          SB4    B4-B5             CALCULATE REMAINING BYTES IN BLOCK 
          PL     B4,C6N01          IF READY WITH NEXT INPUT WORD
          SB5    B5+B4             SET PARTIAL INPUT WORD 
          SB4    B0                SET BLOCK EMPTY
          EQ     C6N01
  
 C6N03    SA7    A7+B1             SAVE OUTPUT WORD 
          ZR     B6,C6N12          IF OUTPUT BLOCK FULL 
          SB7    5                 SET FULL OUTPUT WORD 
          MX7    0                 ZERO OUTPUT WORD 
          SB6    B6-B7             CALCULATE REMAINING BYTES IN BLOCK 
          EQ     C6N02
  
* 
*         HANDLE SPECIAL CASES OF Z-BYTE AND 63 CHARACTER SET NULL
* 
*         IF NO BYTES REMAIN IN INPUT WORD (POSSIBLE 66 BIT Z-BYTE) 
*         THEN: 
*           IF INPUT BLOCK EMPTY
*           THEN: 
*             SET Z-BYTE POSSIBLE STATE.
*             TAKE NO INPUT AVAILABLE EXIT. 
*           IF NEXT INPUT WORD ZERO 
*           THEN: 
*             BYPASS NEXT INPUT WORD. 
*             INSERT ASCII US IN OUTPUT STREAM. 
*           ELSE: 
*             IF 63 CHARACTER SET CASE
*             THEN: 
*               INSERT ASCII NULL BYTE. 
*             ELSE: 
*               INSERT ASCII COLON IN OUTPUT STREAM.
*         ELSE: 
*           IF REMAINING BYTES IN WORD ARE ZERO 
*           THEN: 
*             BYPASS REMAINING BYTES. 
*             INSERT ASCII US IN OUTPUT STREAM. 
*           ELSE: 
*             IF 63 CHARACTER SET CASE
*             THEN: 
*               INSERT ASCII NULL BYTE. 
*             ELSE: 
*               INSERT ASCII COLON IN OUTPUT STREAM.
* 
  
 C6N04    NZ     B5,C6N09          IF INPUT WORD NOT EMPTY
          SX4    ZPOSS             ASSUME STATE OF Z-BYTE POSSIBLE
          ZR     B4,C6N11          IF INPUT BLOCK EMPTY 
          MX4    0                 NORMAL STATE 
 C6N05    SX2    B4-10
          MI     X2,C6N08          IF NEXT INPUT WORD NOT FULL
          SA2    A5+B1             OBTAIN NEXT INPUT WORD 
          NZ     X2,C6N08          IF NEXT INPUT WORD NOT ZERO
          SA5    A5+B1             BYPASS NEXT INPUT WORD 
          SB4    B4-10
 C6N06    SX1    ASUS              INSERT ASCII US
 C6N07    BX7    X1+X7             INSERT INTO OUTPUT WORD
          SB7    B7-B1             DECREMENT OUTPUT WORD UNUSED BYTES 
          ZR     B7,C6N03          IF OUTPUT WORD FULL
          LX7    12                POSITION OUTPUT WORD FOR NEXT BYTE 
          SX4    B0                SET NORMAL STATE 
          EQ     C6N02
  
 C6N08    LX1    12                STRIP OUT SPECIAL CASE 
          BX2    -X0*X1 
          SX1    ASCOLON           ASSUME INSERT OF ASCII COLON 
          SX2    X2-1 
          ZR     X2,C6N07          IF 64 CHARACTER SET
          SX1    B0                INSERT ASCII NULL
          EQ     C6N07
  
 C6N09    BX2    X5                COPY INPUT WORD
          SB2    B5                COPY INWDBYT 
 C6N10    LX2    6                 POSITION INPUT WORD FOR NEXT BYTE
          BX3    -X0*X2            OBTAIN NEXT C6 CHARACTER 
          NZ     X3,C6N08          IF NON-ZERO CHARACTER REMAINING
          SB2    B2-B1             DECREMENT INPUT WORD BYTES AVAIL 
          NZ     B2,C6N10          IF INPUT WORD NOT EMPTY
          BX5    X2                BYPASS REST OF INPUT WORD
          SB5    B0 
          EQ     C6N06
  
* 
*         INPUT BLOCK IS EMPTY. 
*         ADJUST PARAMETERS AND EXIT. 
* 
  
 C6N11    SB6    B6+B7             SHOW BYTES UNUSED IN OUTPUT BLOCK
          SB7    -B7
          SB7    B7+5              ADJUST TO BYTES USED IN OUTPUT WORD
          EQ     C6N               EXIT 
  
* 
*         OUTPUT BLOCK IS FULL. 
*         ADJUST PARAMETERS AND EXIT. 
* 
  
 C6N12    SB4    B4+B5             SHOW BYTES VALID IN INPUT BLOCK
          EQ     C6N               EXIT 
 NC6      TITLE  NC6 - CN TO C6 CONVERSION. 
**        NC6 - NORMALIZED ASCII (CN) TO C6 CONVERSION
* 
*         NC6 CONVERTS LCN NORMALIZED ASCII (CN) TO CDC INTERNAL
*         DISPLAY CODE (C6).
* 
*         IF NO OUTPUT SPACE AVAILABLE
*         THEN: 
*           RETURN WITH NO CHANGES. 
*         IF NO INPUT VALID (ASSUME EOI REACHED)
*         THEN: 
*           IF STATE IS Z-BYTE REQUIRED 
*           THEN: 
*             INSERT WORD OF ZERO BITS. 
*           SET STATE TO NORMAL.
*           RETURN. 
*         ADJUST PARAMETERS SUCH THAT:  
*           INBLKBYT = INBLKBYT - INWDBYT  (BYTES IN REMAINING WORDS) 
*           OUTWDBYT = 10 - OUTWDBYT  (UNUSED BYTES IN OUTPUT WORD) 
*           OUTBLKBYT = OUTBLKBYT - OUTWDBYT  (UNUSED BYTES IN OUTBLK)
*         PERFORM CONVERSION. 
*         HANDLE SPECIAL CASES.  (SEE INLINE COMMENTS)
*         ADJUST PARAMETERS BACK TO INPUT STATE.
*         RETURN. 
* 
*         ENTRY  SEE CVT COMMENTS 
* 
*         EXIT   SEE CVT COMMENTS 
* 
*         NOTE   THE PARAMETERS ARE ADJUSTED TO MAXIMIZE THE
*                CONVERSION SPEED OF THE INNER LOOP.
  
  
 NC6      SUBR                     ENTRY/EXIT 
          ZR     B6,NC6            IF NO OUTPUT SPACE AVAILABLE 
          NZ     B4,NC603          IF INPUT AVAILABLE 
          SX1    X4-ZREQ
          NZ     X1,NC601          IF NO Z-BYTE REQUIRED
          SA7    A7+B1             STORE WORD OF ZERO 
          SB6    B6-10             DECREMENT BYTES OF OUTPUT UNUSED 
 NC601    MX4    0                 SET NORMAL STATE 
          EQ     NC6               EXIT 
  
 NC603    SB4    B4-B5             ADJUST INBLKBYT
          SB7    -B7
          SB7    B7+10             ADJUST OUTWDBYT
          SB6    B6-B7             ADJUST OUTBLKBYT 
          MX0    -7                SET UP SEVEN BIT MASK
          SX1    X4-ZREQ
          ZR     X1,NC611          IF Z-BYTE REQUIRED STATE 
          EQ     NC605
  
* 
*         THE FOLLOWING CONVERSION CODE SHOULD BE 
*         OPTIMIZED TO MAXIMIZE CHARACTER CONVERSION RATE.
* 
  
 NC604    LX5    12                POSITION INPUT WORD FOR NEXT BYTE
          BX2    -X0*X5            OBTAIN NEXT CN CHARACTER 
          SA1    X2+B3             CONVERT TO C6
          SB5    B5-B1             DECREMENT INPUT WORD BYTES AVAIL 
          MI     X1,NC607          IF SPECIAL CASE
          BX7    X1+X7             INSERT INTO OUTPUT WORD
          SB7    B7-B1             DECREMENT OUTPUT WORD UNUSED BYTES 
          MX4    0                 SET NORMAL STATE 
          ZR     B7,NC606          IF OUTPUT WORD FULL
          LX7    6                 POSITION OUTPUT WORD FOR NEXT BYTE 
 NC605    NZ     B5,NC604          IF INPUT WORD NOT EMPTY
          ZR     B4,NC613          IF NO BYTES WITHIN INPUT BLOCK 
          SB5    5                 ASSUME FULL INPUT WORD 
          SA5    A5+B1             OBTAIN NEXT INPUT WORD 
          SB4    B4-B5             CALCULATE REMAINING BYTES IN BLOCK 
          PL     B4,NC604          IF READY WITH NEXT INPUT WORD
          SB5    B5+B4             SET PARTIAL INPUT WORD 
          SB4    B0                SET BLOCK EMPTY
          EQ     NC604
  
 NC606    SA7    A7+B1             SAVE OUTPUT WORD 
          ZR     B6,NC614          IF OUTPUT BLOCK FULL 
          SB7    10                SET FULL OUTPUT WORD 
          MX7    0                 ZERO OUTPUT WORD 
          SB6    B6-B7             CALCULATE REMAINING BYTES IN BLOCK 
          EQ     NC605
  
* 
*         HANDLE SPECIAL CASES OF DELETE, COLON AND Z-BYTE
* 
  
 NC607    LX1    12                STRIP OUT SPECIAL CASE 
          BX1    -X0*X1 
          ZR     X1,NC605          IF DELETE
          SX1    X1-3 
          ZR     X1,NC612          IF 64 CHAR SET COLON FOUND 
  
* 
*         A Z-BYTE MUST BE INSERTED IN THE OUTPUT STREAM. 
* 
*         IF LAST INPUT CHARACTER WAS A 64 CHAR SET COLON 
*         THEN: 
*           ADD ONE BLANK TO THE OUTPUT STREAM. 
*         SET REMAINDER OF OUTPUT WORD TO ZERO BITS.
*         IF FEWER THAN 12 BITS OF ZERO BITS ADDED
*         THEN: 
*           ADD ANOTHER WORD OF ZERO BITS.
*           IF WORD CAN NOT BE ADDED
*           THEN: 
*             SET Z-BYTE REQUIRED STATE AND GOTO EXIT.
*         ELSE: 
*           SET NORMAL STATE. 
* 
  
          SX1    X4-COLAST         TEST STATE 
          NZ     X1,NC609          IF LAST INPUT CHAR NOT 64 CHAR COLON 
          SX1    BLANK
          BX7    X1+X7             INSERT BLANK 
          SB7    B7-B1             DECREMENT OUTPUT WORD UNUSED BYTES 
          ZR     B7,NC608          IF OUTPUT WORD FULL
          LX7    6                 POSITION OUTPUT WORD FOR NEXT BYTE 
          EQ     NC609
  
 NC608    SA7    A7+B1             SAVE OUTPUT WORD 
          SX4    ZREQ              ASSUME STATE OF Z-BYTE REQUIRED
          ZR     B6,NC614          IF OUTPUT BLOCK FULL 
          MX7    0                 ZERO OUTPUT WORD 
          SB6    B6-10             CALCULATE REMAINING BYTES IN BLOCK 
          EQ     NC611
 NC609    SB7    B7-B1             DECREMENT OUTPUT WORD UNUSED BYTES 
          ZR     B7,NC608          IF ONLY ADDING 6 BITS OF ZERO
 NC610    LX7    6                 ADD 6 BITS OF ZERO 
          SB7    B7-B1             DECREMENT OUTPUT WORD UNUSED BYTES 
          NZ     B7,NC610          IF MORE TO FILL
 NC611    SX4    B0                SET NORMAL STATE 
          SB7    B0                MAKE SURE CHARACTER COUNT IS CLEAR 
          EQ     NC606             OUTPUT WORD FULL 
  
*         HANDLE 64 CHAR SET COLON THE SAME AS OTHER CHARACTERS,
*         EXCEPT SET STATE TO "COLAST" TO INDICATE LAST CHARACTER 
*         WAS A COLON.
* 
  
 NC612    SB7    B7-B1             DECREMENT OUTPUT WORD UNUSED BYTES 
          SX4    COLAST            SET FLAG--LAST CHAR WAS COLON
          ZR     B7,NC606          IF OUTPUT WORD FULL
          LX7    6                 POSITION FOR NEXT BYTE 
          EQ     NC605             CONTINUE WITH NEXT CHAR
  
* 
*         INPUT BLOCK IS EMPTY. 
*         ADJUST PARAMETERS AND EXIT. 
* 
  
 NC613    SB6    B6+B7             SHOW BYTES UNUSED IN OUTPUT BLOCK
          SB7    -B7
          SB7    B7+10             ADJUST TO BYTES USED IN OUTPUT WORD
          EQ     NC6               EXIT 
  
*         OUTPUT BLOCK IS FULL. 
*         ADJUST PARAMETERS AND EXIT. 
* 
  
 NC614    SB4    B4+B5             SHOW BYTES VALID IN INPUT BLOCK
          EQ     NC6               EXIT 
  
          END 
