*DECK FFSUCDA 
USETEXT TEXTFFS 
      PROC FFSUCDA (SRCBUF, NUMWORD, DSTBUF, NUMCHAR);
*CALL COPYRITE
# TITLE FFSUCDA - CONVERT DISPLAY TO ASCII                            # 
  
      BEGIN                          # FFSUCDA                        # 
  
# 
**    FFSUCDA - CONVERT DISPLAY TO ASCII
* 
*     TET TRAN                         02/88
* 
*     FFSUCDA CONVERTS A BUFFER OF DISPLAY CODE CHARACTERS INTO A 
*     BUFFER OF ASCII CHARACTER. EACH ZERO-BYTE TERMINATOR WILL BE
*     CONVERTED INTO A PAIR OF CR><LF>S.
* 
*     ENTRY   SRCBUF  - AN ARRAY CONTAINING TEXT TO BE CONVERTED. 
*             NUMWORD - LEN OF THE SOURCE BUFFER, IN CM WORDS.
*             DSTBUF  - ARRAY TO CONTAIN THE CONVERTED TEXT.
* 
*     EXIT    SRCBUF  - UNCHANGED.
*             NUMWORD - UNCHANGED.
*             DESBUF  - CONTAINS THE CONVERTED TEXT.
*             NUMCHAR - RETURNS THE NUMBER OF CHARACTERS (OCTETS) 
*                       IN DESBUF.
* 
*     METHOD
* 
*     LOOP UNTIL END OF INPUT BUFFER
*       SCAN FOR ZERO BYTE TERMINATOR,
*       CALL NETUCDA TO CONVERT A LINE OF DISPLAY CODE TO ASCII,
*       CALL NETUCAC TO ADD <CR><LF> TO THE CONVERTED LINE, 
*     END LOOP
* 
# 
  
# 
****  PROC FFSUCDA - XREF LIST
# 
  
      XREF
        BEGIN 
        PROC  NETUCDA;                 # CONVERT DISPLAY TO ASCII     # 
        PROC  NETUCAC;                 # COPY AN ASCII CHARACTER      # 
        PROC  FFSUCDC;                 # COPY AND DISPLAY CODE CHAR   # 
        END 
  
# 
*     PARAMETER DECLARATIONS
# 
      ITEM NUMWORD      I;             # INPUT BUFFER LEN, IN CM WORDS# 
      ITEM NUMCHAR      I;             # OUTPUT BUFFER LEN, IN CHARS  # 
  
      ARRAY SRCBUF [00:00] S(1);
        BEGIN 
        ITEM SRC$CHAR   C(00,00,240); 
        ITEM SRCWORD    U(00,00,60);
        END 
  
      ARRAY DSTBUF [00:00] S(1);
        BEGIN 
        ITEM DSTWORD    U(00,00,60);
        END 
  
# 
*     LOCAL VARIABLE DECLARATIONS 
# 
      ITEM ASCII$CR     U=X"0D0000000000000"; 
      ITEM ASCII$LF     U=X"0A0000000000000"; 
      ITEM CHARCNT      I;             # CHARACTER COUNT FOR A LINE   # 
      ITEM DSTINDEX     I;             # INDEX TO DESTINATION BUFFER  # 
      ITEM SRCINDEX     I;             # INDEX TO SOURCE BUFFER       # 
      ITEM BITINDEX     I;             # INDEX TO A BIT WITHIN A WORD # 
      ITEM BYTEINDEX    I;             # INDEX TO A BYTE WITHIN A WORD# 
      ITEM WORDINDEX    I;             # INDEX TO A WORD WITHIN A BUFF# 
      ITEM TEMPINDEX    I;             # TEMPORARY INDEX              # 
      ITEM I            I;             # LOOP INDEX                   # 
      ITEM J            I;             # LOOP INDEX                   # 
      ITEM DONE         B;
      ITEM ZBTERM       B;             # ZERO BYTE TERMINATOR         # 
      ITEM SAVELEN      I;
  
      ARRAY ONECHAR [00:00] S(1); 
        BEGIN 
        ITEM  THECHAR$C   C(00,00,01);
        ITEM  THECHAR$U   U(00,00,06);
        END 
  
  
      SAVELEN = NUMWORD;
      DSTINDEX = 0; 
      SRCINDEX  = 0;
  
      DONE = FALSE; 
  
      FOR I=I WHILE NOT DONE DO 
        BEGIN 
# 
*       LOCATE A ZERO BYTE TERMINATOR 
# 
        ZBTERM = FALSE; 
        CHARCNT = 0;
        FOR TEMPINDEX = SRCINDEX STEP 1 WHILE (NOT ZBTERM)
                                          AND (NOT DONE)
        DO
          BEGIN 
          FFSUCDC (SRCBUF, TEMPINDEX, ONECHAR, 0);
          IF THECHAR$U EQ 0            # THIS CAN BE A ZERO BYTE TERM # 
          THEN
            BEGIN 
            WORDINDEX = TEMPINDEX  / 10;
            BYTEINDEX = TEMPINDEX - WORDINDEX*10; 
            IF (BYTEINDEX LQ 8) 
            THEN                       # TWO OR MORE BYTES LEFT IN WRD# 
              BEGIN 
              BITINDEX = BYTEINDEX*6; 
              ZBTERM = B<BITINDEX,60-BITINDEX>SRCWORD[WORDINDEX] EQ 0;
              END 
            ELSE                       # ONLY ON BYTE LEFT            # 
              BEGIN 
              WORDINDEX = WORDINDEX + 1;
              ZBTERM = SRCWORD[WORDINDEX] EQ 0; 
              END 
            END 
  
          IF NOT ZBTERM 
          THEN
            BEGIN 
            CHARCNT = CHARCNT + 1;
            END 
# 
*         NO MATTER IF A ZERO-BYTE TERMINATOR IS ENCOUNTERED, IF THE
*         WHOLE BUFFER HAS BEEN SCANNED, SET DONE TO TRUE TO EXIT THE 
*         INNER LOOP. 
# 
          DONE = ((TEMPINDEX+1)/10) GQ SAVELEN; 
  
          END 
# 
*       CONVERT CHARCNT CHARACTERS INTO ASCII. A ZERO BYTE TERMINATOR 
*       IS CONVERTED TO A <CR><LF>. 
# 
        NETUCDA (SRCBUF, SRCINDEX, CHARCNT, DSTBUF, DSTINDEX, FALSE); 
        IF ZBTERM THEN
        BEGIN 
          NETUCAC (ASCII$CR, 0, DSTBUF, DSTINDEX);         # ADD <CR> # 
          NETUCAC (ASCII$LF, 0, DSTBUF, DSTINDEX);         # ADD <LF> # 
        END 
  
# 
*       UPDATE SRCBUF INDEX (NOTE THAT DSTBUF INDEX IS UPDATED BY 
*       NETUCDA), SKIP THE ZERO BYTE TERMINATOR,
# 
        SRCINDEX = (WORDINDEX + 1) * 10;
  
        DONE = (SRCINDEX / 10) GQ SAVELEN;
  
        END 
  
      NUMCHAR = DSTINDEX; 
  
      RETURN; 
  
      END                            # FFSUCDA #
  
      TERM
