*DECK SHRTOUT 
USETEXT COMCBEG 
USETEXT COMADEF 
USETEXT COMACBX 
USETEXT COMAFET 
PROC SHRTOUT; 
# TITLE SHRTOUT - TERMINATE SHORT OUTPUT EXTENT.  # 
  
      BEGIN  # SHRTOUT #
  
# 
**    SHRTOUT - TERMINATE SHORT OUTPUT EXTENT.
* 
*     SHRTOUT TERMINATES A SHORT OUTPUT EXTENT OF PRU OR NON-PRU
*     TYPE WITH EOR OR EOI. 
* 
*     PROC SHRTOUT
* 
*     ENTRY 
* 
* 
*     EXIT
* 
* 
* 
* 
*     PROCESS    IF OUTPUT CONTROL WORDS REQUIRED 
*                THEN 
*                  CREATE OUTPUT CONTROL WORDS. 
*                  IF ZERO LENGTH PRU REQUIRED
*                  THEN 
*                    INSERT ZERO LENGTH PRU.
*                  IF OUTPUT FUNCTION IS WRITE (NO CONTROL WORDS OR 
*                                                EMBEDDED CONTROL WORDS)
*                    SET OUTPUT LEVEL = EOF 
*                    SET REQUEST-WRITER STATE.
*                ELSE 
*                  SAVE OUTPUT LEVEL. 
*                  SET REQUEST WRITER STATE.
*                UPDATE PUT FET POINTER.
*                CALCULATE BITS OUTPUT. 
*                SET NON-EXISTENT OUTPUT EXTENT.
*                ISSUE OUTPUT REQUEST.
* 
****  PROC SHRTOUT - XREF LIST BEGIN. 
# 
  
      XREF
        BEGIN 
        FUNC MODOUT I;               # MODULO OUTPUT BUFFER POINTER # 
        PROC OUTREQ;               # ISSUE OUTPUT REQUEST # 
        END 
  
# 
****  PROC SHRTOUT - XREF LIST END. 
# 
  
  
      ITEM BITS  I; 
      ITEM BLKBYTS I; 
      ITEM WORDS I; 
      BASED ARRAY WORD [0:0]; 
        BEGIN 
        ITEM  W60       U(00,00,60);
        END 
                                   CONTROL EJECT; 
  
      BLKBYTS = OTEXTBYT - OUTBLKBYT; 
      WORDS = (BLKBYTS + OTCHARPWD-1)/OTCHARPWD;
  
      IF OTCWS
      THEN
        BEGIN 
        P<CW> = PFETIN; 
        CWWORD = OTFULLCW;
        IF CVTTYPE EQ CNTOC6TYPE
        THEN
          BEGIN 
          CWBYTC = (BLKBYTS + 1)/2; 
          END 
  
        ELSE
          BEGIN 
          IF CVTTYPE EQ WORDTYPE
          THEN
            BEGIN 
            CWBYTC = BLKBYTS * 5; 
            END 
  
          ELSE
            BEGIN 
            CWBYTC = BLKBYTS; 
            END 
  
          END 
  
        CWBYTC = ((CWBYTC+4)/5)*5;  # ROUND UP BYTE COUNT # 
        CWUBC = 60 - (OUTWDBYT * OTBITSBYT);
        IF CWUBC EQ 60
        THEN
          BEGIN 
          CWUBC = 0;
          END 
  
        IF CWUBC GT OTBITSBYT 
        THEN
          BEGIN 
          P<WORD> = OUTPTR+1; 
          W60 = W60 * (2**(CWUBC-OTBITSBYT)); 
          END 
  
      CONTROL IFEQ OS$NOS;
        IF WORDS EQ 64
        THEN
          BEGIN 
          P<LVLCW> = MODOUT(65);
          LVLCWLVL = 0; 
          P<CW> = MODOUT(66); 
          CWWORD = OTFULLCW;
          CWUBC = 0;
          CWBYTC = 0; 
          P<LVLCW> = MODOUT(67);
          LVLCWLVL = INLEVEL; 
          PFETIN = MODOUT(68);
          END 
  
        ELSE
          BEGIN 
          P<LVLCW> = MODOUT(WORDS + 1); 
          LVLCWLVL = INLEVEL; 
          PFETIN = MODOUT(WORDS + 2); 
          END 
  
      CONTROL ENDIF;
      CONTROL IFEQ OS$NOSBE;
  
        IF WORDS EQ 64
        THEN
          BEGIN 
          P<CW> = MODOUT(65); 
          CWWORD = OTFULLCW;
          CWUBC = 0;
          CWBYTC = 0; 
          P<LVLCW> = MODOUT(66);
          LVLCWLVL = INLEVEL; 
          PFETIN = MODOUT(2 * 65);
          END 
  
        ELSE
          BEGIN 
          P<LVLCW> = MODOUT(WORDS + 1); 
          LVLCWLVL = INLEVEL; 
          PFETIN = MODOUT(PRUWDSIZE); 
          END 
  
      CONTROL ENDIF;
  
        IF INDATSTATE EQ DSEOI
          AND OTFUNC EQ CIO$WRITE 
        THEN
          BEGIN 
          OTLEVEL = EOF;
          OTIOSTATE = IOREQWRTR;
         END
        END 
  
      ELSE
        BEGIN 
        OTLEVEL = INLEVEL;
        PFETIN = MODOUT(WORDS); 
        OTIOSTATE = IOREQWRTR;
        END 
  
      OTTOTBITS = OTTOTBITS + BLKBYTS * OTBITSCHR;
      OUTBLKBYT = 0;
      OUTWDBYT = 0; 
      OTDATSTATE = DSNULL;
      OTWRAP = FALSE; 
  
      OUTREQ;                      # ISSUE OUTPUT REQUEST # 
  
      RETURN; 
  
      END  # SHRTOUT #
  
      TERM
