*COMDECK BSCTIP 
  
  
  
_$J+? 
  
_***********************************************************************
*                                                                      *
*         PTS3STOPOUTPUT - CLEARS TCB TEXTPROCESSING FIELDS            *
*                                                                      *
*                                                                      *
***********************************************************************?
_$G-,R-,I-     NON RECURSIVE
               INTERRUPTABLE? 
_***********************************************************************
*                                                                      *
**OVERVIEW:  PTS3STOPOUTPUT WILL CLEAR THE OUTPUT TEXTPROCESSING FIELDS*
*            SAVED IN THE TCB BETWEEN EXECUTIONS OF PTT3OTEXT.         *
*                                                                      *
**INPUT:     T5TCB WILL EITHER BE B1TCB OR S7TCB                       *
*                                                                      *
**OUTPUT:    INITIALIZED FIELDS IN THE TCB                             *
*                                                                      *
**EXTERNAL REFERENCES:                                                 *
*                                                                      *
*            PTS3TRESET                                                *
*            PTT3OTEXT                                                 *
*                                                                      *
***********************************************************************?
  
PROCEDURE PTS3STOPOUTPUT(T5TCB : B0BUFPTR); 
BEGIN 
WITH T5TCB'.BSTCB DO
  BEGIN 
  PBRELZRO(BSS5SBUF,BEDBSIZE);              _RELEASE ANY SOURCE BUFFERS?
  PBRELZRO(BSS5DBUF,BEDBSIZE);              _RELEASE ANY DESTINATION BF?
  BSS5CBUF  := NIL;                         _CLEAR CURRENT BUFFER PTR  ?
  BSSDCRB   := FALSE;                       _RESET L/R BYTE FLAG       ?
  BSSFC     := FALSE;                       _RESET F.C. STORED FLAG    ?
  BSSFOLD   := FALSE;                       _RESET LINE FOLD FLAG      ?
  BSSXLINE  := 0;                           _RESET NO OF LINES COUNT   ?
  BSSWEIGHT := 0;                           _RESET ACCT DATA COUNT     ?
  BSSXCHAR  := 0;                           _RESET CHARACTER COUNT     ?
  BSSLNPG   := 0;                           _RESET CURR LINE POSITION  ?
  END;
END;
_***********************************************************************
*                                                                      *
*                             PTS3BSCML                                *
*                                                                      *
*                        BISYNC TIP MAIN LEVEL                         *
*                                                                      *
***********************************************************************?
_$G-,R-,I-     NON RECURSIVE
               INTERRUPTABLE? 
_***********************************************************************
*                                                                      *
**OVERVIEW:  THE MAIN LEVEL OF THE BSC TIP HANDLES INPUT AND OUTPUT    *
*            TRAFFIC AT THE CONNECTION LEVEL.  A SIMULATED CONSOLE,    *
*            LINE PRINTER, CARD READER AND AN OPTIONAL CARD PUNCH ARE  *
*            SUPPORTED ON A LINE.    THE BSC ML WILL INITIATE THE      *
*            OUTPUT BID LOGIC BY SENDING AN OUTPUT REQUEST WLE TO THE  *
*            BSC L2 WHENEVER OUTPUT DATA IS AVAILABLE AND INPUT IS NOT *
*            ACTIVE.     THE OUTPUT DEVICE IS SELECTED ACCORDING TO    *
*            THE FOLLOWING ALGORITHM - INTERACTIVE OVER BATCH OUTPUT   *
*            AND ALTERNATING BETWEEN PRINTER AND PUNCH FILES.          *
*            ONCE AN OUTPUT FILE IS STARTED, IT WILL MONOPOLIZE THE    *
*            OUTPUT CHANNEL UNTIL IT IS FINISHED OR AN ABORT SITUATION *
*            OCCURRES.                                                 *
*                                                                      *
*            OUTPUT MAY BE INTERRUPTED BY INPUT FROM THE TERMINAL      *
*            IN WHICH CASE THE OUTPUT WILL BE SUSPENDED AND RESUMED    *
*            AFTER THE INPUT IS FINISHED.   THE BSC ML WILL ALWAYS     *
*            ALLOW THE FIRST INPUT DATA TO COME IN.    THE FIRST DATA  *
*            IS USED TO IDENTIFY THE INPUT CONNECTION.   THE BSC ML    *
*            WILL THEN MAKE A DECISION TO EITHER ACCEPT THE INPUT      *
*            STREAM OR REJECT IT.    THE BASIS FOR REJECTING AN INPUT  *
*            STREAM IS THAT A TCB IS NOT CONFIGURED, THE CONNECTION    *
*            HAS NOT BEEN STARTED BY THE HOST, INPUT REGULATION IS ON, *
*            OR BUFFER REGULATION IS ON.  AFTER THE INPUT IS PERMITTED,*
*            THE BSC ML WILL SIMPLY COLLECT THE DATA, TEXT PROCESS THE *
*            DATA, AND SEND THE TEXT PROCESSED DATA TO THE BIP.        *
*            INPUT BUFFER REGULATION IS CHECKED WHEN INPUT IS ACTIVE.  *
*            THE BSC L2 WILL BE NOTIFIED VIA A WLE WHEN REGULATION     *
*            IS ON.    THE BSC ML WILL THEN USE A TIMER TO CHECK THE   *
*            REGULATION FROM TIME TO TIME IN ORDER TO NOTIFY THE BSC   *
*            L2 WHEN REGULATION IS OFF.                                *
*                                                                      *
**CALLING PROCEDURE:                                                   *
*            PBMON                                                     *
*                                                                      *
** INPUT:    BWWLENTRY[OPS] WORK LIST ENTRY                            *
*                                                                      *
** OUTPUT:   ACTION PERFORMED ACCORDING TO THE BSC ML ALGORITHM        *
*                                                                      *
** EXTERNAL REFERENCES:                                                *
*                                                                      *
*            PBTMRSRVS,PBQUEMAINT,PBULTS,PBDLTS                        *
*                                                                      *
*                                                                      *
*                                                                      *
*                                                                      *
***********************************************************************?
PROCEDURE PTS3BSCML;
CONST 
_***********************************************************************
*                                                                      *
*     SERVICE MODULE WORK CODES                                        *
*                                                                      *
***********************************************************************?
      S3LNEVENT = D0LINE;                   _LINE EVENT                ?
  
*CALL BSCWCS
_***********************************************************************
*                                                                      *
*     BSC WORK CODES FROM MAIN LEVEL AND TIMER TO MAIN LEVEL           *
*                                                                      *
***********************************************************************?
       S3ITIME   = A0WK11;                  _INPUT TIMEOUT             ?
       S3OTIME   = A0WK12;                  _OUTPUT TIMEOUT            ?
       S3OSTOP   = A0WK13;                  _ICMD TERMINATE OUTPUT SEEN?
       S5IN      = S3ITIME;                 _INPUT TIMEOUT             ?
       S5OUT     = S3OTIME;                 _OUTPUT TIMEOUT            ?
       S5NIL     = 0;                       _NO WORKCODE               ?
  
       S5SVM     = B0SMWL;                  _SERVICE MODULE WRKLST INDX?
       S5L2      = B0L2BSC;                 _BSC L2 WORKLIST INDEX     ?
_***********************************************************************
*                                                                      *
*     BSC MAIN LEVEL LINE STATES                                       *
*                                                                      *
***********************************************************************?
      S5DOWN     = 0;                       _DOWN                      ?
      S5DNDIS    = 1;                       _DISABLE COMMAND RECEIVED  ?
      S5IDLE     = 2;                       _IDLE STATE                ?
      S5OUTBID   = 3;                       _OUTPUT BID                ?
      S5OUTRESP  = 4;                       _WAITING FOR OUTPUT RESPONS?
      S5OUTMIT   = 5;                       _WAITING FOR OUTPUT DATA   ?
      S5OUTEND   = 6;                       _WAITING FOR OUTPUT        ?
                                            _TERMINATION               ?
      S5INMODE   = 7;                       _INPUT REQUESTED           ?
      S5INACTIVE = 8;                       _INPUT ACTIVE              ?
      S5INEND    = 9;                       _WAITING FOR INPUT TO      ?
                                            _TERMINATE                 ?
_***********************************************************************
*                                                                      *
*     BSC MAIN LEVEL MISCELLANEOUS CONSTANTS                           *
*                                                                      *
***********************************************************************?
_ 
* * *     INPUT WORK CODES
? 
       T2INMODE  = 0;                       _INPUT MODE                ?
       T2INDATA  = 1;                       _INPUT DATA                ?
       T2INCOM   = 2;                       _INPUT COMPLETE            ?
       T2INBORT  = 3;                       _INPUT ABORT               ?
       T2INTBORT = 4;                       _INPUT TERMINAL ABORT      ?
       T3ITIME   = 5;                       _INPUT TIMEOUT             ?
  
_ 
* * *     OUTPUT WORK CODES 
? 
       T2OMODE   = 0;                       _OUTPUT MODE               ?
       T2ODATA   = 1;                       _OUTPUT DATA REQUEST       ?
       T2OCOM    = 2;                       _OUTPUT COMPLETE           ?
       T2OBORT   = 3;                       _OUTPUT ABORT              ?
       T2OTBORT  = 4;                       _OUTPUT TERM ABORT         ?
       T3QUEOUT  = 5;                       _OUTPUT DATA ARRIVED       ?
  
_ 
* * *     OTHERS
? 
       T5DBC     = 0;                       _DUMMY DBC                 ?
       T5DC3     = 3;                       _CP SELECTION IS DC3       ?
       T5BEGIN   = 2;                       _BEGINNING STATE INDEX     ?
  
TYPE
      S7CANDID   = (S5ALL,S5PART);          _INDEX FOR PTS3OSELECT     ?
      S7TMACT    = (S5GET,S5RELEASE,        _INDEX FOR TIMER           ?
                    S5SET,S5CLEAR); 
      S7TTYP     = PACKED RECORD
                   CASE I : INTEGER OF
                     1: (SP : B0BUFPTR);    _BUFFER POINTER            ?
                     2: (SI : INTEGER);     _INTEGER                   ?
                     3: (ST : B7PKTPTR);    _TIMER PACKET POINTER      ?
                     END; 
      T7DEV      = 0..3;                    _DEVICE TYPE - CONSOLE,CR  ?
                                            _LINE PRINTER, CARD PUNCH  ?
      T7DATA =   PACKED RECORD
                   T5TYP  : B04BITS;
                   T5NUL  : B04BITS;
                   T5IND  : B08BITS;
                 END; 
  
*CALL BSCLCBML
VAR 
      S3IDENT   : PACKED ARRAY [1..6]       _BSC MAIN LEVEL IDENTIFIER ?
                  OF CHAR;
      S3DBGI    : INTEGER;                  _INDEX TO NEXT WORKLIST    ?
      S3DBGA    : ARRAY [0..24] OF BWTIPWLE;_SAVED WORKLIST ENTRY ARRAY?
      S3TPCB      : B0BUFPTR;               _TEXTPROCESSING CONTROL BLK?
      S3INPTR     : B0BUFPTR;               _INPUT POINTER             ?
      S3LCBPTR    : BZLCBPTR;               _LCB POINTER               ?
      S3LCBEXT    : 'S0LCBEXT;              _LCB EXTENSTION            ?
      S3EVENT     : B06BITS;                _WORK CODE                 ?
      S3INWC      : B03BITS;                _INPUT WORK CODE           ?
      S3OUTWC     : B03BITS;                _OUTPUT WORK CODE          ?
      S3INPUT,                              _INPUT ROUTINE INDEX       ?
      S3OUTPUT,                             _OUTPUT ROUTINE INDEX      ?
      S3OUTSELECT : BOOLEAN;                _OUTPUT BID INDEX          ?
      S3WTCOUNT   : B08BITS;                _WAIT COUNT                ?
      S3CONINX    : ARRAY[BOOLEAN] OF       _CONSOLE CANNED MSG INDEX  ?
                    INTEGER;                _2780(0) OR 3780(1)        ?
      S3CPINX     : ARRAY[BOOLEAN,BOOLEAN]  _CARD PUNCH CANNED MSG INDX?
                    OF INTEGER;             _2780(0) OR 3780(1)        ?
                                            _DC2(0) OR DC3(1)          ?
      S3OBUF      : B0BUFPTR;               _OUTPUT BUFFER POINTER     ?
      S3TBUF       : S7TTYP;                _TIMER BUFFER POINTER      ?
      HALINO  : B0LINO;                     _LINE NUMBER               ?
      S3ITCB      : B0BUFPTR; 
  
      S5CANLIM    : ARRAY[T7DEV] OF INTEGER;_OUTPUT CANNED MSG LIMIT   ?
VALUE 
      S3IDENT     = (#BSCTIP#);             _BSC MAIN LEVEL IDENTIFIER ?
      S3CONINX    = (1,2);                  _CONSOLE CANNED MSG INDEX  ?
      S3CPINX     = (3,3,4,5);              _CP CANNED MESSAGE INDEX   ?
      S5CANLIM    = (2,1,1,1);              _OUTPUT CANNED MESSAGE     ?
                                            _LIMIT                     ?
_$J+? 
_***********************************************************************
*                                                                      *
*                             PTS3SEND                                 *
*                                                                      *
*                    GENERATE AND SEND A WORKLIST ENTRY                *
*                                                                      *
***********************************************************************?
_$G-,R-,I-     NON RECURSIVE
               INTERRUPTABLE? 
_***********************************************************************
*                                                                      *
**OVERVIEW:  PTS3SEND WILL GET THE RIGHT LINE NUMBER AND GENERATE      *
*            A WORKLIST ENTRY ACCORDING TO THE INPUT PARAMETERS.       *
*            THE WORKLIST ENTRY WILL BE SENT TO THE INDICATED PARTY.   *
*                                                                      *
**INPUT:     S7PARTY,S7WC,S7PTR                                        *
*                                                                      *
**OUTPUT:    NONE                                                      *
*                                                                      *
**EXTERNAL REFERENCES:                                                 *
*                                                                      *
*            PBLSPUT                                                   *
*                                                                      *
***********************************************************************?
PROCEDURE PTS3SEND(S7PARTY : B08BITS; S7WC : B06BITS; 
                   S7PTR : B0BUFPTR); 
BEGIN 
  WITH BWWLENTRY[OPS].B0EWLQ DO             _WITH WORKLIST ENTRY       ?
  BEGIN 
    MMLINO  := HALINO.BDLINO;               _GET LINE NUMBER           ?
    MMWKCOD := S7WC;                        _PUT PROVIDED WORK CODE    ?
    MMIBP   := S7PTR;                       _PUT PROVIDED POINTER      ?
  END;
  PBLSPUT(BWWLENTRY[OPS],BYWLCB[S7PARTY]);  _SEND WORKL[ST ENTRY       ?
END; _PTS3SEND? 
_$J+? 
_***********************************************************************
*                                                                      *
*                             PTS3TRESET                               *
*                                                                      *
*                    RESET THE OUTPUT CHANNEL ON A CONNECTION          *
*                                                                      *
***********************************************************************?
_$G-,R-,I-     NON RECURSIVE
               INTERRUPTABLE? 
_***********************************************************************
*                                                                      *
**OVERVIEW:  PTS3TRESET WILL PUT A CONNECTION AWAY FROM OUTPUT CHANNEL *
*            OUTPUT DATA WILL BE DISCARDED AND ANY RECONFIGURE/DELETE  *
*            COMMAND WILL BE RESPONDED.                                *
*                                                                      *
**INPUT:     S7TCB                                                     *
*                                                                      *
**OUTPUT:    NONE                                                      *
*                                                                      *
**EXTERNAL REFERENCES:                                                 *
*                                                                      *
*            PBLSPUT                                                   *
*                                                                      *
***********************************************************************?
PROCEDURE PTS3TRESET(VAR S7TCB : B0BUFPTR); 
  
VAR 
       S3HTCB : B0BUFPTR;                   _WORK AREA, TCB PTR        ?
  
BEGIN 
IF S7TCB " NIL
THEN
  WITH S7TCB'.BSTCB DO                      _INPUT TCB                 ?
  BEGIN 
    WITH BWWLENTRY[OPS].CMSMLEY DO
      IF BSS3DELETE                         _DELETE TCB CMD OUTSTANDING?
      THEN
      BEGIN 
  
        S3HTCB := S3LCBPTR'.BZTCBPTR;       _GET FIRST TCB FROM LCB    ?
        IF S3HTCB = S7TCB                   _IF TCB TO BE DELETED IS   ?
        THEN                                _ FIRST THEN, UPDATE TCB   ?
          S3LCBPTR'.BZTCBPTR := BSCHAIN     _ POINTER SO IT IS FIRST   ?
        ELSE                                _TCB TO BE DELETED IS NOT  ?
        BEGIN                               _FIRST                     ?
          WHILE S3HTCB'.BSTCB.BSCHAIN       _LOOP TO FIND TCB WHICH    ?
                               " S7TCB      _ POINTS TO TCB TO BE      ?
            DO S3HTCB := S3HTCB'.BSTCB.     _ DELETED.                 ?
                                 BSCHAIN; 
          S3HTCB'.BSTCB.BSCHAIN := BSCHAIN; _DELETED TCB FROM CHAIN    ?
        END;   _IF S3HTCB = S7TCB?
  
        CMPTR   := S7TCB;                   _TCB POINTER               ?
        CMWKCOD := D0TCB;                   _TCB EVENT                 ?
        CMDATA  := D5DELE;                  _DELETE                    ?
        PBLSPUT(BWWLENTRY[OPS],BYWLCB       _TELL SVM ACTION COMPLETE  ?
                              [B0SMWL]);
        PBRELZRO(BSS5SBUF,BEDBSIZE);        _RELEASE PARTIAL TRANS-    ?
        PBRELZRO(BSS5DBUF,BEDBSIZE);        _ MISSION BLOCKS (IN TP)   ?
      END;
    WITH S3LCBEXT' DO                       _GET LCB                   ?
      IF BZS3OTCB = S7TCB                   _IF TCB IS OUTPUT TCB      ?
      THEN                                  _THEN                      ?
      BEGIN 
        BZS3OTCB    := NIL;                 _REMOVE IT AS THE          ?
        BZS3OACTIVE := FALSE;               _CURRENT OUTPUT TCB        ?
        PTS3STOPOUTPUT(S7TCB);              _RESET TEXTPROCESS FIELDS  ?
      END; _IF BZS3OTCB?
  
    PBRELZRO(BSS3OBUF,BEDBSIZE);            _RELEASE ANY OUTPUT        ?
                                            _BUFFERS                   ?
  END; _WITH S7TCB? 
END; _PROCEDURE PTS3TRESET? 
_$J+? 
_***********************************************************************
*                                                                      *
*                             PTS3OGET                                 *
*                                                                      *
*                                                                      *
*                                                                      *
***********************************************************************?
_$G-,R-,I-     NON RECURSIVE
               INTERRUPTABLE? 
_***********************************************************************
*                                                                      *
**OVERVIEW:  PTS3OGET WILL CALL QUEUE MAINTENANCE ROUTINES TO GET      *
*            AN OUTPUT DATA FOR THE CURRENT OUTPUT TCB.    IF PM FOUND *
*            A FLAG WILL BE SET.    THE COMMANDS OBTAINED FROM THE     *
*            QUEUE WILL BE ACTIONED AT THIS TIME.                      *
*                                                                      *
**INPUT:     S3LCBPTR                                                  *
*                                                                      *
**OUTPUT     BSS3OBUF                                                  *
*                                                                      *
**EXTERNAL REFERENCES:                                                 *
*                                                                      *
*            PBQUEMAINT,PTS3CMD                                        *
*                                                                      *
***********************************************************************?
PROCEDURE PTS3OGET; 
BEGIN 
  WITH S3LCBEXT'.BZS3OTCB'.BSTCB,           _GET CURRENT OUTPUT TCB    ?
       S3LCBEXT' DO                         _AND LCB EXTENSION         ?
  IF BSS3OBUF = NIL                         _IF NO DATA LEFT IN TIP    ?
  THEN
    PBQUEMAINT(BZS3OTCB,BSS3OBUF,K4GET);
END; _PROCEDURE PTS3OGET? 
_$J+? 
_***********************************************************************
*                                                                      *
*                             PTS3TIME                                 *
*                                                                      *
*                        INTERFACE TO TIMER SERVICES                   *
*                                                                      *
***********************************************************************?
_$G-,R-,I-     NON RECURSIVE
               INTERRUPTABLE? 
_***********************************************************************
*                                                                      *
**OVERVIEW:  PTS3TIME WILL GET A TIMER BUFFER, RELEASE THE TIMER       *
*            BUFFER, SET TIMER OR CLEAR TIMER ACCORDING THE INPUT      *
*            PARAMETER.    THERE IS ONLY ONE TIMER PER LINE AT THE     *
*            MAIN LEVEL.   ON THE INPUT SIDE IT IS USED TO CHECK THE   *
*            REGULATION CONDITION AND ON THE OUTPUT SIDE IT IS USED TO *
*            INITIATE A RETRY OF THE OUTPUT DATA.    AS THE TIMING     *
*            CONSIDERATION IS NOT CRITICAL AND THE LINE CONDITION      *
*            IS WELL CONTROLLED BY THE STATE WORD IN THE LCB. THERE    *
*            IS NO WAIT COUNT MECHANISM TO AVOID RACE PROBLEM.         *
*            ALSO THE INPUT AND OUTPUT TIMERS ARE FIXED AT 10 SECONDS  *
*                                                                      *
**INPUT:     S7ACT,S7WC                                                *
*                                                                      *
**OUTPUT:    NONE                                                      *
*                                                                      *
**EXTERNAL REFERENCES:                                                 *
*                                                                      *
*            PBTMRSRVS                                                 *
*                                                                      *
***********************************************************************?
PROCEDURE PTS3TIME(S7ACT : S7TMACT; S7WC : B06BITS);
CONST 
      S5TMSIZE   = 8;                       _TIMER PACKET SIZE         ?
      S5THRSEC   = 0909;                    _THREE SECOND TIMER VALUE  ?
BEGIN 
  WITH S3LCBEXT' DO 
  CASE S7ACT OF 
_ 
* * *     GET A BUFFER FOR TIMER
? 
  S5GET :                                   _GET TIMER                 ?
  BEGIN 
    S3TBUF.SP := PBGET1BUF(B0S8);           _GET A 8 WORD BUFFER       ?
    PBCLR(S3TBUF.SP,S5TMSIZE);              _CLEAR BUFFER              ?
    BZS3TIME := S3TBUF.ST;                  _BSC ML GET THE TIMER      ?
    WITH BZS3TIME' DO 
    BEGIN 
      BKWLINDEX := B0MLBSC;                 _SET WORKLIST ENTRY INDEX  ?
      BKTIME    :=S5THRSEC;                 _USE THREE SECOND TIMER    ?
      BK1USRWRD := BWWLENTRY[OPS].B0EWLQ.   _SET LINE NUMBER           ?
                    MMLINO; 
    END; _WITH S3TMPTR? 
  END; _S5GET?
_ 
* * *     RELEASE TIMER BUFFER
? 
  S5RELEASE :                               _RELEASE TIMER             ?
  BEGIN 
    S3TBUF.ST  := BZS3TIME;                 _GET TIMER BUFFER          ?
    BZS3TIME   := NIL;                      _CLEAR TIMER POINTER       ?
    S3TBUF.SP'.BCCHAINS[8] := NIL;          _CLEAR TIMER BUF CHAIN     ?
    PBRELZRO(S3TBUF.SP,B0S8);               _RELEASE TIMER BUF         ?
  END; _S5RELEASE?
_ 
* * *     SET TIMER 
? 
  S5SET : 
                                            _SET TIMER                 ?
  BEGIN 
    WITH BZS3TIME' DO                       _GET TIMER PACKET          ?
    BEGIN 
      BKTYPE   := BKSET;                    _SET TIMER                 ?
      BKWKCODE := S7WC;                     _SET WORKCODE              ?
    END; _WITH BZS3TIME?
    PBTMRSRVS(BZS3TIME);                    _CALL TIMER SERVICES       ?
    BZS3TRUN := TRUE; 
  END; _S5SET?
_ 
* * *     CLEAR TIMER 
? 
  S5CLEAR :                                 _CLEAR TIMER               ?
    IF BZS3TRUN                             _IF TIMER IS RUNNING       ?
    THEN
    WITH BZS3TIME' DO                       _WITH TIMER PACKET         ?
    BEGIN 
      BKWKCODE := S7WC;                     _SET WORK CODE             ?
      BKTYPE   := BKCANCEL;                 _CANCEL COMMAND            ?
      PBTMRSRVS(BZS3TIME);                  _CALL TIMER SERVICES       ?
      BZS3TRUN := FALSE;                    _NOT RUNNING NOW           ?
    END; _WITH BZS3TIME?
  END; _CASE S7ACT? 
END; _PROCEDURE PTS3TIME? 
_$J+? 
_***********************************************************************
*                                                                      *
*                             PTS3OSELECT                              *
*                                                                      *
*                        SELECT AN OUTPUT CONNECTION                   *
*                                                                      *
***********************************************************************?
_$G-,R-,I-     NON RECURSIVE
               INTERRUPTABLE? 
_***********************************************************************
*                                                                      *
**OVERVIEW:  PTS3OSELECT WILL SELECT AN OUTPUT CONNECTION FROM PRINTER *
*            GROUP (CONSOLE AND PRINTER) OR PUNCH GROUP (CARD PUNCH)   *
*            OR ALL CONNECTIONS                                        *
*                                                                      *
**INPUT:     S7INDEX,S3LCBEXT                                          *
*                                                                      *
**OUTPUT:    BZS3OTCB                                                  *
*                                                                      *
**EXTERNAL REFERENCES:                                                 *
*                                                                      *
*            PTS3OGET                                                  *
*                                                                      *
***********************************************************************?
PROCEDURE PTS3OSELECT(S7INDEX : S7CANDID);
VAR 
      S3NOTFOUND : BOOLEAN;                 _OUTPUT CN NOT FOUND YET   ?
BEGIN 
  WITH S3LCBEXT' DO                         _GET LCB                   ?
  BEGIN 
    BZS3OTCB   := S3LCBPTR'.BZTCBPTR;       _GET THE FIRST TCB         ?
    S3NOTFOUND := TRUE;                     _START TO LOOK FOR OUTPUT  ?
                                            _CONNECTION                ?
    WHILE (BZS3OTCB " NIL) &                _LOOP WHEN THERE ARE MORE  ?
           S3NOTFOUND DO                    _TCBS AND NOT FOUND YET    ?
    BEGIN 
      WITH BZS3OTCB'.BSTCB DO               _THIS TCB                  ?
        IF (S7INDEX = S5ALL) !              _IF LOOK FOR ALL CONNECTION?
           (BZS3PUTURN = (BSDEVTYP = N1CP)) _OR THIS TCB IS IN THE     ?
        THEN                                _GROUP LOOKED FOR          ?
        BEGIN 
          PTS3OGET;                         _GET OUTPUT DATA           ?
          IF BSS3OBUF = NIL                 _IF NO OUTPUT              ?
          THEN
            BZS3OTCB := BSCHAIN             _GO ON TO NEXT TCB         ?
          ELSE
            S3NOTFOUND := FALSE;            _OUTPUT AVAILABLE - FOUND  ?
        END _IF S7INDEX?
        ELSE                                _TCB IS NOT IN THE RIGHT   ?
          BZS3OTCB := BSCHAIN;              _GROUP,GO TO NEXT          ?
    END; _WHILE BZS3OTCB? 
  END; _WITH S3LCBEXT?
END; _PTS3OSELECT?
_$J+? 
_***********************************************************************
*                                                                      *
*                             PTS3OBID                                 *
*                                                                      *
*                        OUTPUT INITIATION LOGIC                       *
*                                                                      *
***********************************************************************?
_$G-,R-,I-     NOR RECURSIVE
               INTERRUPTABLE? 
_***********************************************************************
*                                                                      *
**OVERVIEW:  PTS3OBID WILL CHOOSE AN OUTPUT CONNECTION WHEN IT GETS    *
*            CONTROL.    A STARTED AND INTERRUPTED OUTPUT CONNECTION   *
*            WILL BE RESTARTED AND THE ROUTINE WILL INITIATE OUTPUT BID * 
*            FOR THE CONNECTION.   IF THE DEVICE IS NOT READY AND THE  *
*            OUTPUT BID IS REJECTED, THE ROUTINE WILL SET THE LINE     *
*            STATE TO IDLE AND SET AN OUTPUT TIMER FOR A RETRY LATER.  *
*            THE ABOVE PROCEDURE WILL BE REPEATED UNTIL THE OUTPUT     *
*            FILE IS FINISHED OR ABORTED.    AT THE END OF AN OUTPUT   *
*            SESSION THE ROUTINE WILL LOOK FOR ANOTHER FILE.  IN ORDER *
*            TO PREVENT AN OUTPUT CONNECTION FROM MONOPLIZING THE LINE *
*            THE ROUTINE WILL ALTERNATE OUTPUT FILES BETWEEN PRINTER   *
*            AND PUNCH GROUPS.   THE PRINTER GROUP CONSISTS OF CONSOLE *
*            AND PRINTER AND CONSOLE TAKES PRECEDENCE OVER PRINTER.    *
*            THE PUNCH GROUP CONSISTS OF ONLY THE CARD PUNCH.          *
*                                                                      *
*            IF AN OUTPUT CONNECTION IS REJECTED BEFORE ANY OUTPUT     *
*            DATA IS ACCEPTED BY THE TERMINAL, THE ROUTINE WILL SWITCH *
*            TO ANOTHER OUTPUT CONNECTION IN A DIFFERENT GROUP.        *
*            AN OUTPUT TIMER WILL BE SET TO REQUEST A LATER RETRY OF   *
*            THE BUSY OUTPUT DEVICE.                                   *
*                                                                      *
*                                                                      *
*                                                                      *
**INPUT:     S3LCBPTR,S3EVENT,BZS3OTCB,BZS3OACTIVE                     *
*                                                                      *
**OUTPUT:    BZS3OTCB                                                  *
*                                                                      *
**EXTERNAL REFERENCES:                                                 *
*                                                                      *
*            PTS3OSELECT,PTS3TIME,PTS3SEND                             *
*                                                                      *
***********************************************************************?
PROCEDURE PTS3OBID; 
CONST 
      S5GPN     = 2;                        _MAXIMUM NUMBER OF OUTPUT  ?
                                            _GROUPS                    ?
BEGIN 
WITH S3LCBEXT' DO 
IF BZS3WAIT                                 _IF STALLING OUTPUT        ?
THEN                                        _ THEN                     ?
  BZS3STATE := S5IDLE                       _ JUST GO BACK TO IDLE     ?
ELSE
  IF (BZS3OTCB " NIL) & BZS3OACTIVE         _IF OUTPUT WAS ALREADY     ?
  THEN                                      _STARTED                   ?
    BEGIN 
      BZS3STATE := S5OUTBID;                _BID FOR OUTPUT NOW        ?
      PTS3SEND(S5L2,S3OUTQEST,NIL);         _TELL BSC L2 TO BID FOR THE?
                                            _LINE                      ?
    END _IF S3EVENT?
  ELSE
    BEGIN                                   _STIMULATE A NEW CYCLE     ?
      BZS3OACTIVE := FALSE;                 _OUTPUT NOT ACTIVE NOW     ?
      BZS3GROUP   := 0;                     _CLEAR OUTPUT GROUP COUNT  ?
      BZS3OTCB    := NIL;                   _NO OUTPUT TCB NOW         ?
      WHILE (BZS3GROUP < S5GPN) &           _KEEP LOOKING FOR OUTPUT   ?
            (BZS3OTCB = NIL) DO             _TILL ALL CONNECTION TRIED ?
      BEGIN                                 _OR A CONNECTION QUALIFIES ?
        PTS3OSELECT(S5PART);                _ONE OUTPUT GROUP AT A TIME?
        IF BZS3OTCB = NIL                   _IF OUTPUT NOT FOUND       ?
        THEN                                _THEN                      ?
        BEGIN 
          BZS3GROUP  := BZS3GROUP + 1;      _INCREMENT FAIL COUNT      ?
          BZS3PUTURN := NOT BZS3PUTURN;     _SWITCH TO DIFFERENT GROUP ?
        END 
        ELSE                                _OUTPUT FOUND              ?
        BEGIN 
          BZS3STATE := S5OUTBID;            _OUTPUT BID STATE          ?
          PTS3SEND(S5L2,S3OUTQEST,NIL);     _TELL BSC L2 TO BID FOR THE?
                                            _LINE                      ?
        END; _IF BZS3OTCB?
      END; _WHILE BZS3GROUP?
      IF BZS3OTCB = NIL                     _IF NO OUTPUT AT ALL       ?
      THEN
      BEGIN 
        BZS3GROUP := 0;                     _CLEAR OUTPUT GROUP COUNT  ?
        BZS3STATE := S5IDLE;                _IDLE AND WAIT FOR A0QUEOUT?
      END; _IF BZS3OTCB?
    END; _IF BZS3OTCB?
END; _PROCEDURE PTS3OBID? 
_$J+? 
_***********************************************************************
*                                                                      *
*                             PTS3ITEXT                                *
*                                                                      *
*                    BSC MAIN LEVEL INPUT TEXTPROCESSING               *
*                                                                      *
***********************************************************************?
_$G-,R-,I-     NON RECURSIVE
               INTERRUPTABLE? 
_***********************************************************************
*                                                                      *
**OVERVIEW:    PTS3ITEXT SETS UP THE TEXTPROCESSING CONTROL BLOCK FOR  *
*              A GIVEN TCB AND A GIVEN INPUT DATA BLOCK.    IT CALLS   *
*              THE TEXTPROCESSING STATE PROGRAM TO CONVERT THE INPUT   *
*              DATA INTO PRUBS AND SENDS THE PRUBS UP TO THE BIP.      *
*                                                                      *
**INPUT:       S3ITCB,S3INBUF                                          *
*                                                                      *
**OUTPUT:      NONE                                                    *
*                                                                      *
**EXTERNAL REFERENCES:                                                 *
*                                                                      *
*              PBULTS,PBDLTS                                           *
*                                                                      *
***********************************************************************?
PROCEDURE PTS3ITEXT(VAR S3ITCB,S3INBUF : B0BUFPTR); 
CONST 
      T5ACCTWD    = 4;                      _ACCOUNTING WORD IN BUFFER ?
      T5CR26     = 1;                       _CARD READER IN 026        ?
      T5FCD      = 13;                      _BUFFER FCD                ?
      T5RADDC    = 9;                       _FILE REG FOR RADDC CHECK  ?
      T5MAXL     = 80;                      _RADDC STATE INSTR MAX VAL ?
VAR 
       T3ABUF   : B0BUFPTR;                 _BUFFER POINTER 1          ?
       T3CBUF   : B0BUFPTR;                 _BUFFER POINTER 2          ?
      T3PBUF   : B0BUFPTR;                  _PREVIOUS BUFFER PTR       ?
      T3LCD    : INTEGER;                   _WORK LCD                  ?
BEGIN 
  S3TPCB := PBGET1BUF(BETPSIZE);            _GET A BUFFER FOR TPCB     ?
  PBCLR(S3TPCB,TPBUFLENGTH);                _CLEAR IT                  ?
  WITH S3TPCB'.BGMLCB,                      _WITH TPCB AND TCB         ?
       S3ITCB'.BSTCB DO 
  BEGIN 
    NCSTAI := T5BEGIN;                      _STATE POINTER TABLE INDEX ?
    NCFSBA := S3INBUF;                      _SOURCE BUF IS INPUT DATA  ?
    NCTPF1 [T5RADDC] := T5MAXL;             _SET RADDC MAX VALUE FOR TP?
_ 
* * *     CONSOLE 
? 
    IF BSDEVTYP = N1CON                     _CONSOLE                   ?
    THEN
    BEGIN 
      ADDR(S3CSPT,NCSPTA);                  _CONSOLE STATE PROGRAM ADDR?
      ADDR(ECASK,NCCXLTA);                  _EBCDIC TO ASCII TRANSLATE ?
    END; _IF BSDEVTYP?
_ 
* * *     CARD READER 
? 
    IF BSDEVTYP = N1CR                      _IF CARD READER            ?
    THEN                                    _THEN                      ?
    BEGIN 
      ADDR(S3ISPT,NCSPTA);                  _CARD READER STATE PROGRAM ?
      NCCXLTA := BY4XLTA[BSSP26];           _TRANSLATION TABLE         ?
    END; _IF BSDEVTYP?
_ 
* * *     COMMON PARAMETERS FOR INPUT TEXTPROCESSING
? 
    NCSJOBON := BSSJOBON;                   _JOB CARD SEEN FLAG        ?
    NCSTR  := BSSTR;                        _TRANSPARENT DATA MODE FLAG?
    NCSP26 := (BSSUBDT = T5CR26);           _026 OR 029 DEFAULT FLAG   ?
    NCSDC64 := NOT CSET63;                  _DISPLAY CODE 64 SYSTEM    ?
    NCIBFCD := T5FCD;                       _BUFFER FCD                ?
_ 
* * *     CALL INPUT TEXTPROCESSING STATE PROGRAM 
? 
    PTTPINF(S3TPCB');                       _CALL TEXTPROCESSING STATE ?
                                            _PROGRAM                   ?
    BSSJOBON := NCSJOBON;                   _PUT BACK JOB CARD SEEN FLG?
    T3PBUF := NIL;                          _SEARCH THE BUFFER CHAIN   ?
    T3ABUF := NCFDBA; 
    T3CBUF := NCFDBA;                       _TO DISCARD EMPTY BUFFERS  ?
    WHILE T3CBUF " NIL DO                   _CREATED IN THE TEXTPROCESS?
    BEGIN                                   _A BUFFER IS EMPTY IF THE  ?
      IF T3CBUF'.BFLCD @ T3CBUF'.BFFCD      _LCD IS LESS THAN/EQUAL TO ?
      THEN                                  _THE FCD AND DOES NOT EQUAL?
        IF NOT T3CBUF'.BFEOR                _FBYTE (USED FOR FIRMWARE  ?
        THEN                                _ALLOCATION) AND NO EOR OR ?
          IF NOT T3CBUF'.BFEOI              _EOI FLAG BITS ARE SET     ?
          THEN
            IF T3CBUF'.BFLCD " FBYTE
            THEN
              BEGIN 
              PBREL1BUF (T3CBUF,BEDBSIZE);  _RELEASE THE EMPTY BUFFER  ?
              IF T3PBUF = NIL               _IF WE  JUST RELEASED THE  ?
              THEN                          _FIRST BUFFER IN THE CHAIN ?
                T3ABUF := T3CBUF            _THEN RESET T3ABUF         ?
              ELSE                          _ELSE RESET THE CHAIN WORD ?
                T3PBUF'.BCCHAINS[DBUFLEN] := T3CBUF;
              GOTO 10;                      _DO NOT RESET C OR P BUF   ?
              END;
    T3PBUF := T3CBUF; 
    T3CBUF := T3CBUF'.BCCHAINS[DBUFLEN];
10: END; _WHILE T3CBUF " NIL? 
    BSSTR    := NCSTR;                      _TRANSPARENT DATA MODE FLAG?
    BSSP26   := (NCCXLTA =                  _CODE SET IS 26 FLAG       ?
                 BY4XLTA[TRUE]);
    B1BUFF := T3ABUF;                       _DEST BUFFER PTR           ?
    PBREL1BUF(S3TPCB,BETPSIZE);             _RELEASE TPCB BUFFER       ?
    WHILE B1BUFF " NIL DO                   _GO THROUGH BUFFERS        ?
    BEGIN 
      T3PBUF := NIL;
      WHILE (T3ABUF " NIL) &                _LOOK FOR THE END OF A PRUB?
            (NOT T3ABUF'.BFSEOB) DO 
        BEGIN 
        T3PBUF := T3ABUF;                   _REMEMBER PREVIOUS BUFFER  ?
        T3ABUF := T3ABUF'.BCCHAIN[DBUFLENG];
        END; _WHILE?
      IF T3ABUF " NIL                       _IF THE LAST BUFFER OF A   ?
      THEN                                  _PRUB FOUND                ?
      BEGIN 
        B1BUFF'.BFEOI := T3ABUF'.BFEOI;     _MOVE EOI AND ETX FLAG     ?
        B1BUFF'.BFEOR := T3ABUF'.BFEOR;     _MOVE EOR FLAG             ?
        B1BUFF'.BFFCD := DBC;               _SET BDC                   ?
        T3CBUF := T3ABUF'.BCCHAIN[DBUFLEN]; 
        T3ABUF'.BCCHAIN [DBUFLEN] := NIL;   _CUT OFF REST OF CHAIN     ?
        IF BSDEVTYP = N1CR                  _IF CARD READER            ?
        THEN
        BEGIN 
          T3LCD := T3ABUF'.BFLCD;           _GET LCD LOCAL             ?
          B1BUFF'.BIINT [T5ACCTWD] := ORD 
            (T3ABUF'.BFDATAC [T3LCD]);      _GET ACCOUNTING DATA       ?
          T3ABUF'.BFLCD := T3LCD - 1;       _REMOVE ACCOUNTING CHAR    ?
          IF T3PBUF " NIL 
          THEN
            PTEBREL (T3PBUF'.               _RELEASE NOW POSSIBLY      ?
                     BCCHAINS [DBUFLEN]);   _ EMPTY TRAILING BUFFER    ?
          END;
        T3ABUF := T3CBUF;                   _GET REST OF INPUT         ?
      END; _T3ABUF " NIL? 
      B1FLGWD.KTWORD := $212;               _SET FLAG WORD             ?
      PBULTS (S3ITCB, B1BUFF, B1FLGWD);     _CALL UPLINE TIP SERVICES  ?
      B1BUFF := T3ABUF;                     _GET NEXT BUFFER           ?
    END; _WHILE B1BUFF " NIL? 
  END; _WITH S3TPCB?
END; _PROCEDURE PTS3ITEXT?
_$J+? 
_***********************************************************************
*                                                                      *
*                             PTS3AUTO                                 *
*                                                                      *
*                    BSC MAIN LEVEL AUTO RECOGNITION                   *
*                                                                      *
***********************************************************************?
_$G-,R-,I-     NON RECURSIVE
               INTERRUPTABLE? 
_***********************************************************************
*                                                                      *
**OVERVIEW:    PTS3AUTO  SETS UP THE TEXTPROCESSING CONTROL BLOCK FOR  *
*              A GIVEN TCB AND A GIVEN INPUT DATA BLOCK.    IT CALLS   *
*              THE TEXTPROCESSING STATE PROGRAM TO CONVERT THE INPUT   *
*              CONFIGURATION CARD INTO ASCII FORMAT AND THEN CALLS     *
*              THE CONFIGUARATION CARD PROCESSOR TO PROCESS IT         *
*                                                                      *
**INPUT:       S3ITCB,S3INBUF                                          *
*                                                                      *
**OUTPUT:      NONE                                                    *
*                                                                      *
**EXTERNAL REFERENCES:                                                 *
*                                                                      *
*              PTCNFCARD                                               *
*                                                                      *
***********************************************************************?
PROCEDURE PTS3AUTO(VAR S3ITCB,S3INBUF : B0BUFPTR);
CONST 
      T5FCD      =  15;                     _BUFFER FCD                ?
      T5SLSH     = $2F;                     _ASCII SLASH CHARACTER     ?
      T5STAR     = $2A;                     _ASCII STAR  CHARACTER     ?
VAR 
      T3BUF      : B0BUFPTR;                _BUFFER POINTER 1          ?
BEGIN 
  S3TPCB := PBGET1BUF(BETPSIZE);            _GET A BUFFER FOR TPCB     ?
  PBCLR(S3TPCB,TPBUFLENGTH);                _CLEAR IT                  ?
  WITH S3TPCB'.BGMLCB DO                    _WITH TPCB                 ?
  BEGIN 
    NCSTAI := T5BEGIN;                      _STATE POINTER TABLE INDEX ?
    NCFSBA := S3INBUF;                      _SOURCE BUF IS INPUT DATA  ?
    ADDR(S3CSPT,NCSPTA);                    _CONSOLE STATE PROGRAM ADDR?
    ADDR(ECASK,NCCXLTA);                    _EBCDIC TO ASCII TRANSLATE ?
_ 
* * *     COMMON PARAMETERS FOR INPUT TEXTPROCESSING
? 
    NCSDC64 := NOT CSET63;                  _DISPLAY CODE 64 SYSTEM    ?
    NCIBFCD := T5FCD;                       _BUFFER FCD                ?
_ 
* * *     CALL INPUT TEXTPROCESSING STATE PROGRAM 
? 
    PTTPINF(S3TPCB');                       _CALL TEXTPROCESSING STATE ?
                                            _PROGRAM                   ?
    T3BUF    := NCFDBA;                     _PRUBS                     ?
    PBREL1BUF(S3TPCB,BETPSIZE);             _RELEASE TPCB BUFFER       ?
  END; _WITH S3TPCB?
_ 
* * *     PROCESS CONFIGURATION CARD
? 
  WITH S3ITCB'.BSTCB,T3BUF' DO              _WITH AUTO REC TCB AND     ?
                                            _THE CONFIG CARD IN ASCII  ?
  BEGIN 
    BFDATAC[BFFCD-1] := CHR(T5STAR);        _STORE STAR CHAR           ?
    BFDATAC[BFFCD-2] := CHR(T5SLSH);        _STORE SLASH CHAR          ?
    BFFCD            := BFFCD - 2;          _UPDATE FCD TO SLASH       ?
  
    PTCNFCARD(S3LCBP,T3BUF);                _CALL CONFIG CARD PROCESSOR?
  
    IF T3BUF " NIL                          _IF BAD  CONFIG CARD       ?
    THEN                                    _THEN                      ?
    BEGIN 
      IF BSTCLASS " 0                       _IF WE KNOW THE TERM CLASS ?
      THEN                                  _THEN                      ?
      BEGIN 
        B1TCB := S3ITCB;                    _SET GLOBAL TCB POINTER    ?
        PTS3TCBINIT;                        _INITIALIZE TCB FIELDS     ?
        PTT3OTEXT(S3ITCB,T3BUF);            _TEXT PROCESS AND QUEUE    ?
                                            _THE BAD RESPONSE          ?
      END 
      ELSE                                  _NO IDEA ABOUT TERM CLASS  ?
        PBRELCHN(T3BUF,BEDBSIZE);           _RELEASE THE BAD RESPONSE  ?
    END 
    ELSE                                    _GOOD CONFIG CARD          ?
      PBREL1BUF(BSLCBP'.BZTCBPTR,BEDBSIZE); _RELEASE AUTO REC TCB      ?
  END; _WITH S3ITCB',S3INBUF'?
END; _PROCEDURE PTS3AUTO? 
_$J+? 
_***********************************************************************
*                                                                      *
*                             PTS3OUTPUT                               *
*                                                                      *
*                        OUTPUT EVENT HANDLER                          *
*                                                                      *
***********************************************************************?
_$G-,R-,I-     NON RECURSIVE
               INTERRUPTABLE? 
_***********************************************************************
*                                                                      *
**OVERVIEW:  THIS ROUTINE GETS CONTROL AFTER THE OUTPUT BID IS         *
*            INITIATED BY PTS3OBID.        THE OUTPUT DATA IS SENT TO  *
*            THE BSC L2 AND WILL BE RELEASED AFTER SUCCESSFULLY        *
*            DELIVERED.     AT THE END OF AN OUTPUT FILE, THE CONTROL  *
*            WILL BE GIVEN TO THE PTS3OBID FOR NEXT OUTPUT FILE.       *
*                                                                      *
**INPUT:     S3EVENT,BZS3OTCB,BZS3OSTATE,S3LCBPTR,S3INPTR              *
*                                                                      *
**OUTPUT:    BZS3OSTATE,BZS3OACTIVE,BSS3OCAN,WLE TO THE BSC L2         *
*                                                                      *
**EXTERNAL REFERENCES:                                                 *
*                                                                      *
*            PTS3TIMER,PTS3OGET,PBRELZRO,PTS3SEND,PTS3TRESET           *
*                                                                      *
*                                                                      *
***********************************************************************?
PROCEDURE PTS3OUTPUT; 
VAR 
      S3OBUF   : B0BUFPTR;                  _OUTPUT BUFFER POINTER     ?
BEGIN 
  WITH S3LCBEXT' DO 
  
  CASE S3OUTWC OF                           _WORK LIST ENTRY CODE      ?
  
_ 
* * *    OUTPUT MODE
? 
  T2OMODE :                                 _OUTPUT MODE               ?
    IF BZS3STATE = S5OUTBID                 _OUTPUT BID STATE          ?
    THEN
    WITH BZS3OTCB'.BSTCB DO                 _OUTPUT TCB                ?
    BEGIN                                   _GET AN OUTPUT DATA        ?
      IF BZS3OTCB = NIL                     _IF NO OUTPUT TCB ASSIGNED ?
      THEN                                  _THEN THERE IS NO OUTPUT   ?
        BSS3OBUF := NIL                     _AVAILABLE                 ?
      ELSE
        PTS3OGET;                           _ELSE GET SOME OUTPUT      ?
      IF BSS3OBUF = NIL                     _IF OUTPUT DATA NOT        ?
      THEN                                  _AVAILABLE                 ?
      BEGIN 
        PTS3SEND(S5L2,S3OUTRESET,NIL);      _SEND L2 OUTPUT RESET      ?
        BZS3OACTIVE := FALSE;               _RELEASE OUTPUT CHANNEL    ?
        BZS3STATE   := S5OUTEND;            _WAITING FOR TERMINATION   ?
      END 
      ELSE
      BEGIN 
        BZS3STATE   := S5OUTRESP;           _OUTPUT RESPONSE STATE     ?
        BZS3OACTIVE := TRUE;                _OUTPUT NOW ACTIVE         ?
        IF BSSXCAN = 0                      _IF NO CANNED MESSAGE      ?
        THEN                                _THEN                      ?
          S3OBUF := BSS3OBUF                _GET OUTPUT DATA           ?
        ELSE                                _OTHERWISE -               ?
        BEGIN 
          BSS3OCAN := TRUE;                 _SET CANNED MSG FLAG       ?
          S3OBUF   := BYS3ACT[BSSXCAN];     _GET CANNED MSG            ?
        END;
        PTS3SEND(S5L2,S3OUTDATA,S3OBUF);    _SEND OUTPUT DATA TO BSC L2?
      END; _IF BSS3OBUF?
    END; _WITH B2S3OTCB?
_ 
* * *    OUTPUT TERMINAL NOT READY
? 
  T2OTBORT :  
    IF BZS3STATE = S5OUTEND                 _IF TERMINATION EXPECTED   ?
    THEN
    BEGIN 
      PTS3TRESET(BZS3OTCB);                 _PROCESS ANY OUTSTANDIN CMD?
      S3OUTSELECT := TRUE;                  _SELECT NEXT OUTPUT FILE   ?
    END 
    ELSE
      BEGIN 
        BZS3STATE := S5IDLE;                _IDLE STATE                ?
        BZS3WAIT := TRUE;                   _DISALLOW NEW LINE BID     ?
        PTS3TIME(S5SET,S5OUT);              _SET TIMER TO STIMULATE    ?
      END;                                  _RETRY LATER               ?
_ 
* * *    OUTPUT COMPLETE
? 
  T2OCOM :  
    WITH BZS3OTCB'.BSTCB DO                 _GET OUTPUT TCB            ?
    BEGIN 
      BZS3OACTIVE := FALSE;                 _UNLOCK OUTPUT CHANNEL     ?
      IF BZS3STATE = S5OUTRESP              _IF NORMAL PROCESS         ?
      THEN
      BEGIN 
        IF BSS3OBUF'.BFEOI & NOT BSS3AUTO   _IF EOI BLOCK (NOT AUTOREC)?
         & BSBATCH                          _BATCH DEVICE              ?
        THEN                                _THEN                      ?
          IF BSBATCH & NOT BSSTERMOUT 
          THEN                              _BATCH DEVICE AND          ?
                                            _ NO TERMINATE OUTPUT ICMD ?
          PBPEOI(BZS3OTCB,D9EOI);           _SEND ACCOUNTING DATA      ?
        PBRELZRO(BSS3OBUF,BEDBSIZE);        _RELEASE OUTPUT BUFFERS    ?
        BZS3OTCB := NIL;                    _CLEAR OUTPUT TCB POINTER  ?
      END 
      ELSE
        IF BZS3STATE = S5OUTEND             _ABNORMAL TERMINATION      ?
        THEN
        BEGIN 
          PTS3TRESET(BZS3OTCB);             _PROCESS OUTSTANDING CMD   ?
        END;
      BZS3WAIT  := TRUE;                    _DONT ALLOW NEW LINE BID   ?
      PTS3TIME(S5SET,S5OUT);                _ UNTIL DELAY COMPLETE     ?
      BZS3STATE := S5IDLE;
    END; _WITH BZS3OTCB?
_ 
* * *    OUTPUT ABORT 
? 
  T2OBORT : 
  BEGIN 
    IF BZS3STATE = S5OUTEND                 _IF EXPECTING TERMINATION  ?
    THEN                                    _THEN PROCESS ANY          ?
      PTS3TRESET(BZS3OTCB);                 _ OUTSTANDING COMMANDS     ?
    BZS3STATE := S5IDLE;                    _IDLE STATE                ?
    BZS3WAIT  := TRUE;                      _DISALLOW NEW LINE BID     ?
    PTS3TIME(S5SET,S5OUT);                  _ UNTIL DELAY IS COMPLETE  ?
  END;   _T2OBORT?
_ 
* * *    OUTPUT DATA REQUEST
? 
  T2ODATA :                                 _OUTPUT DATA ACKNOWLEDGED  ?
                                            _AND REQUEST FOR MORE      ?
    IF BZS3STATE = S5OUTRESP                _IF WAITING FOR L2 RESPONSE?
    THEN
    WITH BZS3OTCB'.BSTCB DO                 _WITH OUTPUT TCB           ?
    BEGIN 
      IF BSS3OCAN                           _IF LAST OUTPUT IS CANNED  ?
                                            _MESSAGE                   ?
      THEN                                  _THEN                      ?
        BSS3OCAN := FALSE                   _CLEAR CANNED MSG FLAG     ?
      ELSE                                  _LAST OUTPUT IS DATA       ?
      BEGIN 
        IF BSS3OBUF'.BFEOI & NOT BSS3AUTO   _IF EOI BLOCK (NOT AUTOREC)?
         & BSBATCH                          _BATCH DEVICE              ?
        THEN                                _THEN                      ?
          IF BSBATCH & NOT BSSTERMOUT 
          THEN                              _BATCH DEVICE AND          ?
                                            _ NO TERMINATE OUTPUT ICMD ?
          PBPEOI(BZS3OTCB,D9EOI);           _SEND ACCOUNTING DATA      ?
        PBRELZRO(BSS3OBUF,BEDBSIZE);        _RELEASE LAST OUTPUT BUFFER?
      END;
      PTS3OGET;                             _GET NEXT DATA             ?
      IF BSS3OBUF = NIL                     _IF OUTPUT DATA NOT        ?
                                            _AVAILABLE                 ?
      THEN                                  _THEN                      ?
          BZS3STATE := S5OUTMIT             _WAITING FOR NEXT OUTPUT   ?
      ELSE                                  _OUTPUT DATA AVAILABLE     ?
        PTS3SEND(S5L2,S3OUTDATA,BSS3OBUF);  _SEND OUTPUT DATA TO BSC L2?
    END; _WITH BZS3OTCB?
_ 
* * *    NEW DATA ARRIVED 
? 
  T3QUEOUT :  
    IF (BZS3OTCB = S3INPTR) &               _IF DATA CAME TO THE OUTPUT?
       (BZS3STATE = S5OUTMIT)               _CONNECTION AND  IS BEING  ?
    THEN                                    _WAITED FOR                ?
    BEGIN 
      PTS3OGET;                             _GET IT                    ?
      WITH BZS3OTCB'.BSTCB DO               _WITH OUTPUT TCB           ?
        IF BSS3OBUF " NIL                   _OUTPUT DATA AVAILABLE     ?
        THEN
        BEGIN 
          BZS3STATE := S5OUTRESP;           _WAITING FOR RESPONSE      ?
          PTS3SEND(S5L2,S3OUTDATA,          _SEND DATA DOWN TO L2      ?
                   BSS3OBUF); 
        END;
    END;   _IF BZS3OTCB?
  END; _CASE S3OUTWC? 
END; _PROCEDURE PTS3OUTPUT? 
_$J+? 
_***********************************************************************
*                                                                      *
*                             PTS3INPUT                                *
*                                                                      *
*                        INPUT EVENT HANDLER                           *
*                                                                      *
***********************************************************************?
_$G-,R-,I-     NON RECURSIVE
               INTERRUPTABLE? 
_***********************************************************************
*                                                                      *
**OVERVIEW:  THIS ROUTINE GETS CONTROL WHEN INPUT IS INITIATED FROM    *
*            THE TERMINAL VIA THE INPUT MODE WLE ISSUED BY THE BSC L2. *
*            THE FIRST INPUT DATA WILL BE USED TO IDENTIFY THE INPUT   *
*            CONNECTION.   IF THE INPUT CONNECTION IS OPEN AND         *
*            REGULATION IS NOT ON, PTS3INPUT WILL SEND AN INPUT        *
*            GRANT WLE TO THE BSC L2.        OTHERWISE, PTS3INPUT WILL *
*            REJECT FURTHER INPUT AND DISCARD THE FIRST INPUT DATA.    *
*            AFTER INPUT BECOMES ACTIVE     PTS3INPUT WILL ACCEPT      *
*            INPUT DATA, TEXTPROCESS IT AND SEND IT TO THE BIP.   THE  *
*            REGULATION CONDITION IS CHECKED FROM TIME TO TIME AND     *
*            THE BSC L2 WILL BE NOTIFIED OF ANY CHANGES VIA            *
*            WLES.   AFTER THE INPUT IS COMPLETED,   PTS3OBID WILL     *
*            GET CONTROL IN ORDER TO RESUME OR INITIATE AN OUTPUT FILE.*
*                                                                      *
**INPUT:      S3EVENT,S3LCBPTR,BZS3STATE,S3INPTR                       *
*                                                                      *
**OUTPUT:    S3OUTSELECT                                               *
*                                                                      *
**EXTERNAL REFERENCES :                                                 * 
*                                                                      *
*            PTS3TIMER,PBULTS,PTS3ITEXT,PTS3TRESET,PTS3SEND            *
*                                                                      *
$**********************************************************************?
PROCEDURE PTS3INPUT;
VAR 
      S3INDEX    : INTEGER;                 _INDEX REGISTER            ?
      S3ITCB     : B0BUFPTR;                _INPUT TCB POINTER         ?
      S3INPOK    : BOOLEAN;                 _INPUT OK FLAG             ?
  
  
  
_$J+? 
_***********************************************************************
*                                                                      *
*                             PTS5FINDCN                               *
*                                                                      *
*                       INPUT CONNECTION SEARCH                        *
*                                                                      *
$**********************************************************************?
_$G-,R-,I-     NON RECURSIVE
               INTERRUPTABLE? 
_***********************************************************************
*                                                                      *
**OVERVIEW: PTS5FINDCN RECOGNIZES THE INPUT CONNECTION FROM THE        *
*             FIRST INPUT DATA AND RETURN THE CORRESPONDING TCB        *
*             TO THE CALLER                                            *
*                                                                      *
**INPUT:    S3INBUF                                                    *
*                                                                      *
**OUTPUT:   S3ITCB                                                     *
*                                                                      *
**EXTERNAL REFERENCES: NONE                                            *
*                                                                      *
*                                                                      *
*                                                                      *
***********************************************************************?
PROCEDURE PTS5FINDCN(VAR S3INBUF,S3ITCB : B0BUFPTR);
CONST 
      S1DLE     = $10;                      _EBCDIC DLE                ?
      S1SLSH    = $61                       _EBCDIC /                  ?
      S1STAR    = $5C;                      _EBCDIC *                  ?
VAR 
      S3INDEX   : INTEGER;                  _INDEX REGISTER            ?
      S3CNTYP   : N0DEVTYP;                 _DEVICE TYPE               ?
BEGIN 
  WITH S3INBUF' DO
  BEGIN 
    IF BFDATAC[BFFCD] = CHR(S1DLE)          _IF DLE PRECEDED           ?
    THEN
      S3INDEX := BFFCD + 2                  _IGNORE DLE STX            ?
    ELSE                                    _NO DLE                    ?
      S3INDEX := BFFCD + 1;                 _IGNORE STX                ?
    IF (BFDATAC[S3INDEX]   = CHR(S1SLSH)) & _IF THE FIRST TWO CHARACTER?
       (BFDATAC[S3INDEX+1] = CHR(S1STAR))   _ARE /* THEN THIS IS       ?
    THEN
      S3CNTYP := N1CON                      _CONSOLE INPUT             ?
    ELSE                                    _ELSE                      ?
      S3CNTYP := N1CR;                      _CARD READER INPUT         ?
    S3ITCB := S3LCBPTR'.BZTCBPTR;           _GET TCB                   ?
    WHILE (S3ITCB " NIL) & (S3ITCB'.BSTCB.  _FIND THE TCB              ?
           BSDEVTYP " S3CNTYP) DO 
      S3ITCB := S3ITCB'.BSTCB.BSCHAIN;
  END; _WITH S3INBUF? 
END; _PROCEDURE PTS5FINDCN? 
_$J+? 
_***********************************************************************
*                                                                      *
*                             PTS3INPUT                                *
*                                                                      *
*                        INPUT EVENT HANDLER                           *
*                                                                      *
***********************************************************************?
_$G-,R-,I-     NON RECURSIVE
               INTERRUPTABLE? 
_***********************************************************************
*                                                                      *
**OVERVIEW:  THIS ROUTINE GETS CONTROL WHEN INPUT IS INITIATED FROM    *
*            THE TERMINAL VIA THE INPUT MODE WLE ISSUED BY THE BSC L2. *
*            THE FIRST INPUT DATA WILL BE USED TO IDENTIFY THE INPUT   *
*            CONNECTION.   IF THE INPUT CONNECTION IS OPEN AND         *
*            REGULATION IS NOT ON, PTS3INPUT WILL SEND AN INPUT        *
*            GRANT WLE TO THE BSC L2.        OTHERWISE, PTS3INPUT WILL *
*            REJECT FURTHER INPUT AND DISCARD THE FIRST INPUT DATA.    *
*            AFTER INPUT BECOMES ACTIVE     PTS3INPUT WILL ACCEPT      *
*            INPUT DATA, TEXTPROCESS IT AND SEND IT TO THE BIP.   THE  *
*            REGULATION CONDITION IS CHECKED FROM TIME TO TIME AND     *
*            THE BSC L2 WILL BE NOTIFIED OF ANY CHANGES VIA            *
*            WLES.   AFTER THE INPUT IS COMPLETED,   PTS3OBID WILL     *
*            GET CONTROL IN ORDER TO RESUME OR INITIATE AN OUTPUT FILE.*
*                                                                      *
**INPUT:      S3EVENT,S3LCBPTR,BZS3STATE,S3INPTR                       *
*                                                                      *
**OUTPUT:    S3OUTSELECT                                               *
*                                                                      *
**EXTERNAL REFERENCES :                                                *
*                                                                      *
*            PTS3TIMER,PBULTS,PTS3ITEXT,PTS3TRESET,PTS3SEND            *
*                                                                      *
***********************************************************************?
BEGIN _PROCEDURE PTS3INPUT? 
WITH S3LCBEXT' DO 
  
  CASE S3INWC OF
  
_ 
* * *     INPUT IS COMING IN
? 
  T2INMODE :                                _INPUT MODE                ?
    IF (BZS3STATE = S5IDLE) !               _IF IDLE OR OUTPUT BID     ?
       (BZS3STATE = S5OUTBID)               _STATE                     ?
    THEN                                    _THEN                      ?
      BZS3STATE := S5INMODE;                _SET STATE TO INPUT        ?
_ 
* * *    INPUT DATA 
? 
  T2INDATA :                                _INPUT DATA                ?
  BEGIN 
    IF BZS3STATE = S5INMODE                 _IF WAITING FOR FIRST DATA ?
    THEN
    BEGIN 
      S3ITCB  := S3LCBPTR'.BZTCBPTR;        _GET THE FIRST TCB         ?
      IF S3ITCB = NIL                       _IF THE FIRST AUTO-REC     ?
                                            _INPUT DATA                ?
      THEN
      BEGIN 
        BZS3STATE := S5INEND;               _IGNORE INPUT              ?
        PTS3SEND(S5L2,S3INRESET,NIL);       _TERMINATE INPUT           ?
      END 
      ELSE
      IF S3ITCB'.BSTCB.BSS3AUTO             _IF INPUT DATA AT AUTO-REC ?
                                            _TIME                      ?
      THEN                                  _THEN                      ?
      BEGIN 
        PTS3AUTO(S3ITCB,S3INPTR);           _CALL AUTO REC PROCESSOR   ?
        BZS3STATE := S5INEND;               _EVALUATE ONLY THE FIRST   ?
                                            _AUTO-REC INPUT DATA       ?
        PTS3SEND(S5L2,S3INGRANT,NIL);       _GIVE PERMISSION TO L2     ?
      END _IF S3ITCB? 
      ELSE
      BEGIN                                 _INPUT DATA FROM CON OR CR ?
        PTS5FINDCN(S3INPTR,S3ITCB);         _GET CONNECTION FROM INPUT ?
                                            _DATA                      ?
        IF S3ITCB = NIL                     _IF CN NOT FOUND           ?
        THEN
          S3INPOK := FALSE                  _THEN NOT OK TO INPUT      ?
        ELSE                                _IF CN FOUND             ?
          WITH S3ITCB'.BSTCB DO 
          S3INPOK := BSS3ION &              _ AND INPUT OPEN           ?
                     ((BSDEVTYP = N1CON) !  _ AND CONSOLE OR           ?
                 (PTREGL(S3ITCB) = RGNONE));_ REGULATION IS NOT ACTIVE ?
                                            _ THEN OK TO INPUT         ?
  
        IF S3INPOK
          THEN
          BEGIN 
            PTS3ITEXT(S3ITCB,S3INPTR);      _TEXTPROCESS INPUT DATA    ?
            BZS3STATE := S5INACTIVE;        _INPUT ACTIVE              ?
            PTS3SEND(S5L2,S3INGRANT,NIL);   _GIVE PERMISSION FOR MORE  ?
            BZS3ITCB := S3ITCB;             _DATA                      ?
          END 
          ELSE
          BEGIN                             _NOT OK FOR INPUT          ?
            BZS3STATE := S5INEND;           _TERMINATE INPUT STATE     ?
            PTS3SEND(S5L2,S3INRESET,NIL);   _ASK BSC L2 TO TERMINATE IT?
          END; _IF S3INPOK? 
      END; _IF S3ITCB?
    END _IF BZS3STATE = S5INMODE? 
    ELSE                                    _NOT INPUT MODE STATE      ?
      IF BZS3STATE = S5INACTIVE             _IF INPUT ACTIVE           ?
      THEN                                  _THEN                      ?
      BEGIN 
        PTS3ITEXT(BZS3ITCB,S3INPTR);        _TEXTPROCESS INPUT DATA    ?
        IF NOT BZS3REG                      _IF THERE WAS NO REGULATION?
        & (PTREGL (BZS3ITCB) " RGNONE)
                                            _BUT NOW A REGULATION      ?
        THEN                                _CONDITION EXISTS THEN     ?
        BEGIN 
          BZS3REG := TRUE;                  _SET REGULATION FLAG       ?
          PTS3TIME(S5SET,S5IN);             _SET TIMER FOR RECHECK     ?
          PTS3SEND(S5L2,S3ISTOP,NIL);       _ASK BSC L2 TO REGULATE    ?
                                            _INPUT DATA                ?
        END; _IF NOT BZS3REG? 
      END; _IF BZS3STATE? 
    PBRELZRO(S3INPTR,BEDBSIZE);             _RELEASE INPUT DATA        ?
  END; _S2INDATA? 
_ 
* * *    INPUT COMPLETE 
? 
  T2INCOM : 
    IF (BZS3STATE = S5INEND) !              _IF EXPECTING TERMINATION  ?
       (BZS3STATE = S5INMODE) !             _OR INPUT IS COMING        ?
       (BZS3STATE = S5INACTIVE)             _OR INPUT ACTIVE           ?
    THEN                                    _THEN                      ?
    BEGIN 
      PTS3TRESET(BZS3ITCB);                 _PROCESS OUTSTANDING CMD   ?
      S3OUTSELECT := TRUE;                  _INITIATE OUTPUT BID LOGIC ?
      BZS3ITCB := NIL;                      _CLEAN UP POINTER          ?
      BZS3REG  := FALSE;                    _RESET POSSIBLE REGUL FLAG ?
      BZS3WAIT := FALSE;                    _OK TO LINE BID IMMEDIATELY?
      PTS3TIME(S5CLEAR,S5NIL);              _STOP OUTPUT DELAY TIMER   ?
    END; _IF BZS3STATE? 
_ 
* * *    INPUT ABORT
? 
  T2INBORT :  
  BEGIN 
    IF BZS3STATE = S5INEND                  _IF EXPECTING TERMINATION  ?
    THEN                                    _THEN                      ?
    BEGIN 
      PTS3TRESET(BZS3ITCB);                 _PROCESS OUTSTANDING CMD   ?
      BZS3STATE := S5IDLE;                  _SET STATE TO IDLE         ?
    END    _IF BZS3STATE...?
    ELSE
    BEGIN 
      PTS3SEND(S5L2,S3LNDOWN,NIL);          _TELL L2 LINE IS NO GOOD   ?
      BZS3STATE := S5DOWN;                  _LINE STATE IS DOWN        ?
      BWWLENTRY[OPS].CMSMLEY.CMDATA         _SET OPTIONAL DATA FIELD   ?
        := D5INOP;                          _TO INOPERATIVE            ?
      PTS3SEND(S5SVM,S3LNEVENT,NIL);        _LINE INOP MSG TO SVM      ?
      S3ITCB := S3LCBPTR'.BZTCBPTR;         _TCB                       ?
      IF (S3ITCB " NIL) & 
         (S3ITCB'.BSTCB.BSS3AUTO) 
      THEN                                  _AUTO REC TCB              ?
        PBREL1BF(S3LCBPTR'.BZTCBPTR,BEDBSIZE);
    END; _IF BZS3STATE = S5INEND ELSE?
    BZS3REG  := FALSE;                      _RESET POSSIBLE REGUL FLAG ?
  END; _S2IBORT?
_ 
* * *    INPUT TERMINAL ABORT 
? 
  T2INTBORT : 
  BEGIN 
    IF BZS3STATE = S5INEND                  _IF EXPECTING TERMINATION  ?
    THEN                                    _THEN                      ?
    BEGIN 
      PTS3TRESET(BZS3ITCB);                 _PROCESS OUTSTANDING CMD   ?
      BZS3ITCB := NIL;                      _CLEAN UP POINTER          ?
    END;  _IF BZS3STATE = S5INEND?
    S3OUTSELECT := TRUE;                    _INITIATE OUTPUT BID LOGIC ?
    BZS3WAIT    := FALSE;                   _OK TO LINE BID NOW        ?
    BZS3REG     := FALSE;                   _RESET POSSIBLE REGUL FLAG ?
    PTS3TIME(S5CLEAR,S5NIL);                _STOP OUTPUT DELAY TIMER   ?
  END; _S2INTBORT?
_ 
* * *    INPUT TIMEOUT
? 
  T3ITIME : 
  BEGIN 
    IF (BZS3STATE = S5INACTIVE) & BZS3REG   _IF INPUT ACTIVE AND       ?
    THEN                                    _REGULATION WAS ON         ?
      IF PTREGL (BZS3ITCB) " RGNONE         _IF REGULATION STILL ACTIVE?
      THEN                                  _THEN                      ?
        PTS3TIME(S5SET,S5IN)                _SET TIMER FOR RECHECK     ?
      ELSE
      BEGIN 
        BZS3REG := FALSE;                   _NO MORE REGULATION        ?
        PTS3SEND(S5L2,S3ISTART,NIL);        _ASK BSC L2 TO ALLOW       ?
                                            _MORE INPUT DATA           ?
      END; _IF PTREGL?
  
  END; _S3ITIME?
  END; _CASE S3INWC?
  
END; _PROCEDURE PTS3INPUT?
_$J+? 
_***********************************************************************
*                                                                      *
*                             PTS3WLCONTROL                            *
*                                                                      *
*                        PROCESS THE WORKLIST ENTRIES                  *
*                                                                      *
***********************************************************************?
_$G-,R-,I-     NON RECURSIVE
               INTERRUPTABLE? 
_***********************************************************************
*                                                                      *
**OVERVIEW:  PTS3WLCONTROL WILL PREPROCESS A WLE AND ACTION ON         *
*            SERVICES MESSAGES AND COMMANDS.     IF THE WLE RELATES    *
*            TO THE INPUT/OUTPUT THEN THE ROUTINE WILL SET INPUT/      *
*            OUTPUT INDEXES IN ORDER TO PASS CONTROL TO THE INPUT/     *
*            OUTPUT ROUTINES.                                          *
*                                                                      *
**INPUT:     S3EVENT,S3INPTR,S3LCBPTR                                  *
*                                                                      *
**OUTPUT:    S3INPUT,S3OUTPUT,S3OUTSELECT                              *
*                                                                      *
**EXTERNAL REFERENCES:                                                 *
*                                                                      *
*            PTS3SEND,PTS3TIME,PTS3TRESET                              *
*                                                                      *
***********************************************************************?
  
PROCEDURE PTS3WLCONTROL;
  
VAR 
      S3TACT   : BOOLEAN;                   _NEED  TERM ACTION         ?
      S3WTCB   : B0BUFPTR;                  _TCB POINTER               ?
  
_***********************************************************************
*                                                                      *
*         PTS3PRERESET - PREPROCESS TCB RESET                          *
*                                                                      *
***********************************************************************?
  
PROCEDURE PTS3PRERESET; 
BEGIN 
S3TACT    := TRUE;                          _RESPOND IMMEDIATELY       ?
WITH S3LCBEXT' DO 
  CASE BZS3STATE OF 
    S5INACTIVE:                             _INPUT ACTIVE STATE        ?
      IF BZS3ITCB = S3INPTR                 _INPUT TCB                 ?
      THEN
        BEGIN 
        S3TACT    := FALSE;                 _DELAY RESPONSE            ?
        BZS3STATE := S5INEND;               _WAITING FOR TERMINATION   ?
        PTS3SEND(S5L2,S3INRESET,NIL);       _ASK BSC L2 TO TERMINATE   ?
        END; _S5INACTIVE? 
  
    S5OUTMIT,S5OUTRESP,S5OUTBID:            _OUTPUT STATE              ?
      IF BZS3OTCB = S3INPTR                 _OUTPUT TCB                ?
      THEN
        BEGIN                               _DELAY RESPONSE UNTIL INPUT?
        S3TACT    := FALSE;                 _TERMINATED                ?
        BZS3STATE := S5OUTEND;              _WAITING FOR TERMINATION   ?
        PTS3SEND(S5L2,S3OUTRESET,NIL);      _ASK BSC L2 TO TERMINATE   ?
        END; _S5OUTMIT,S5OUTRESP,S5OUTBID?
  
    S5INEND:                                _AWAITING INPUT TERMINATE?
      IF BZS3ITCB = S3INPTR 
      THEN
        S3TACT := FALSE;                    _DELAY RESPONSE UNTIL I/O ? 
                                            _TERMINATED               ? 
    S5OUTEND:                               _AWAITING OUTPUT TERMINATE? 
      IF BZS3OTCB = S3INPTR                 _OUTPUT TCB               ? 
      THEN
        S3TACT := FALSE;                    _DELAY RESPONSE UNTIL I/O ? 
                                            _ TERMINATES              ? 
  END;   _CASE BZSTATE OF?
  
IF S3TACT                                   _IF ACTION NOW             ?
THEN                                        _THEN                      ?
  PTS3TRESET(S3INPTR);                      _SEND REPLY                ?
END; _ PROCEDURE PTS3PRERESET ? 
BEGIN 
IF S3EVENT = A0SMEN 
THEN
  
_ 
* * *    ENABLE LINE
? 
BEGIN 
  WITH S3LCBPTR'
  DO
  BEGIN 
    BZBSCEXT := PBGET1BF(B0S16);            _GET 16-WORD BUFFER        ?
    S3LCBEXT := BZBSCEXT;                   _LCB EXTENSION POINTER     ?
    PBCLR(S3LCBEXT,16);                     _CLEAR LCB EXTENSION       ?
    WITH S3LCBEXT'
    DO
    BEGIN 
      BZS3STATE := S5IDLE;                  _IDLE STATE                ?
    END;
    PTS3SEND(S5L2,S3ENA,NIL);               _TELL L2 THAT LINE ENABLED ?
    PTS3TIME(S5GET,S5NIL);                  _GET A TIMER               ?
    IF BZAUTO                               _IF AUTO-REC LINE          ?
    THEN
    BEGIN 
      S3ITCB := PBGET1BUF(BEDBSIZE);        _GET A BUFFER FOR AUTO-REC ?
      BZTCBPTR := S3ITCB;                   _ATTACH IT TO LCB          ?
      WITH S3ITCB'.BSTCB DO                 _WITH THE TCB              ?
      BEGIN 
        PBCLR(S3ITCB,DBUFLENGTH);           _CLEAR THE TCB             ?
        BSLCBP   := S3LCBPTR;               _SET UP LCB POINTER        ?
        BSS3AUTO := TRUE;                   _AUTO-REC TCB FLAG         ?
      END; _WITH S3ITCB?
    END 
    ELSE
    BEGIN 
      WITH BWWLENTRY[OPS].CMSMLEY DO
      BEGIN 
        CMWKCODE := D0LINE;                 _LINE EVENT                ?
        CMDATA   := D5OPER;                 _LINE OPERATIONAL          ?
      END;
      PBLSPUT(BWWLENTRY[OPS],BYWLCB         _TELL SVM LINE IS          ?
        [B0SMWL]);                          _OPERATIONAL               ?
    END;
  END;
END 
ELSE
WITH S3LCBEXT'
DO
  
CASE S3EVENT OF 
  
  
_ 
* * *    DISABLE LINE 
? 
  A0SMDA :  
  BEGIN 
    BZS3STATE := S5DNDIS;                   _DISABLE STATE             ?
    PTS3SEND(S5L2,S3DIS,NIL);               _TELL L2 TO DISABLE LINE   ?
    PTS3TIME(S5CLEAR,S5NIL);                _CLEAR TIMER               ?
    PTS3TIME(S5RELEASE,S5NIL);              _RELEASE TIMER             ?
  END; _A0SMDA? 
  
_ 
* * *     TCB BUILT 
? 
  A0SMTCB : 
  BEGIN 
    WITH S3INPTR'.BSTCB DO                  _WITH TCB DO               ?
    BEGIN 
      IF BSDEVTYP = N1CON                   _IF CONSOLE TCB            ?
      THEN                                  _THEN                      ?
        BSSXCAN := S3CONINX[BSTCLASS        _SET CANNED MSG INDEX      ?
                            = N03780];      _                          ?
      IF BSDEVTYP = N1CP                    _IF CARD PUNCH             ?
      THEN
        BSSXCAN := S3CPINX[(BSTCLASS =      _SET OUTPUT CANNED         ?
                            N03780),        _MESSAGE INDEX             ?
                           (BSTA = T5DC3)]; _                          ?
    END; _WITH S3INPTR'.BSTCB?
  END; _A0SMTCB?
  
_ 
* * *    DELETE TCB 
? 
  A0SMDLTCB:  
  BEGIN 
    WITH S3INPTR'.BSTCB DO
    BEGIN 
      BSS3ION := FALSE;                     _INPUT CHANNEL CLOSED      ?
      BSS3DELETE := TRUE;                   _DELETE TCB FLAG           ?
    END; _WITH S3INPTR? 
    PTS3PRERESET;                           _PREPROCESS TCB RESET      ?
  END; _A0SMDLTCB?
  
_ 
* * *    NEW OUTPUT DATA HAS ARRIVED
? 
  A0QUEOUT :                                _NEW OUTPUT DATA           ?
  BEGIN 
    IF BZS3STATE = S5IDLE                   _IF THE LINE IS IDLE       ?
    THEN                                    _THEN                      ?
      S3OUTSELECT := TRUE                   _INITIATE OUTPUT BID       ?
    ELSE                                    _ELSE                      ?
      IF BZS3STATE = S5OUTMIT               _IF WAITING FOR OUTPUT DATA?
      THEN                                  _                          ?
      BEGIN 
        S3OUTPUT := TRUE;                   _INITIATE OUTPUT ROUTINE   ?
        S3OUTWC  := T3QUEOUT;               _OUTPUT WC IS NEW DATA     ?
      END; _IF BZS3STATE? 
    WITH S3INPTR'.BSTCB DO
    IF BSDEVTYP = N1CON                     _OUTPUT IMPLIES INPUT OK   ?
    THEN                                    _FOR THE CONSOLE           ?
      BSS3ION := TRUE;                      _MARK ACCORDINGLY          ?
  END;   _A0QUEOUT? 
  
_ 
* * *    LINE TIMEOUT 
? 
  A0TIMEOUT:                                _TIMEOUT WLE               ?
    PTS3SEND(S5L2,A0TIMEOUT,NIL);           _PASS IT TO LEVEL 2        ?
_ 
* * *    HARDWARE ERROR 
         NOTE:  INPUT AND OUTPUT BUFFERS ARE NOT RELEASED WHEN
                THE HARDWARE ERROR IS DETECTED BUT RATHER WHEN THE
                LINE IS DISABLED. 
? 
  A0HARDERR :                               _HARD ERROR WLE            ?
  BEGIN 
    IF (BZS3STATE " S5DOWN) &               _IF THE LINE IS NOT ALREADY?
       (BZS3STATE " S5DNDIS)                _DOWN                      ?
    THEN                                    _THEN                      ?
    BEGIN 
      BZS3STATE := S5DOWN;                  _LINE STATE IS DOWN        ?
      BWWLENTRY[OPS].CMSMLEY.CMDATA         _SET OPTIONAL DATA FIELD   ?
        := D5INOP;                          _TO INOPERATIVE            ?
      PTS3SEND(S5SVM,S3LNEVENT,NIL);        _LINE INOP MSG TO SVM      ?
      PTS3SEND(S5L2,S3LNDOWN,NIL);          _TELL L2 OF ERROR CONDITION?
    END; _IF BZS3STATE? 
  END; _ A0HARDERR? 
  
_ 
* * *    CONNECTION BROKEN
? 
  A0TIP:  
  BEGIN 
    IF S3WTCOUNT = D5FREE 
    THEN                                    _NO LONGER CONNECTED       ?
    BEGIN 
      WITH S3INPTR'.BSTCB 
      DO                                    _RELEASE ANY PARTIAL TRANS-?
      BEGIN                                 _ MISSION BLOCKS IN TEXTPR ?
        PBRELZRO(BSS5SBUF,BEDBSIZE);
        PTS3STOPOUTPUT(S3INPTR);            _STOP OUTPUT AND           ?
        PTS3PRERESET;                       _PREPROCESS TCB RESET      ?
        PBRELZRO(BSS5DBUF,BEDBSIZE);
        BSS3ION := FALSE;                   _TURN OFF INPUT            ?
      END;
    END;
  END; _A0TIP?
  
  
_ 
* * *    ICMD TERMINATE OUTPUT
? 
  S3OSTOP : 
  BEGIN 
    S3TACT := TRUE;                         _ACTION IMMEDIATELY        ?
    IF BZS3OTCB = S3INPTR                   _IF OUTPUT IS CURRENTLY    ?
    THEN                                    _SELECTED FOR THIS CN THEN ?
      IF (BZS3STATE = S5OUTMIT) !           _IF OUTPUT ACTIVE THEN     ?
         (BZS3STATE = S5OUTRESP)
      THEN
      BEGIN 
        BZS3STATE := S5OUTEND;              _WAIT FOR TERMINATION      ?
        PTS3SEND(S5L2,S3OUTRESET,NIL);      _TELL L2 TO TERMINATE      ?
        S3TACT := FALSE;                    _ACTION CMD LATER          ?
      END 
      ELSE
        IF BZS3STATE = S5OUTEND             _IF OUTPUT ACTIVE BUT IS IN?
        THEN                                _THE PROCESS OF TERMINATING?
          S3TACT := FALSE;                  _THEN WAIT FOR THE NORMAL  ?
                                            _END                       ?
    IF S3TACT                               _IF IT IS OKAY TO RESPOND  ?
    THEN                                    _THEN                      ?
      PTS3TRESET(S3INPTR);                  _DO IT                     ?
  END; _S3OSTOP?
  
_ 
* * *    INPUT TIMEOUT
? 
  S3ITIME : 
  BEGIN 
    BZS3TRUN := FALSE;                      _TIMER NOT RUNNING         ?
    IF BZS3STATE = S5INACTIVE               _IF INPUT ACTIVE           ?
    THEN                                    _                          ?
    BEGIN 
      S3INPUT := TRUE;                      _CALL INPUT ROUTINE TO     ?
                                            _CHECK REGULATION CONDITION?
      S3INWC := T3ITIME;                    _INPUT WC IS TIME OUT      ?
    END; _IF BZS3STATE? 
  END; _S3ITIME?
  
_ 
* * *    OUTPUT TIMEOUT 
? 
  S3OTIME : 
  BEGIN 
    BZS3TRUN := FALSE;                      _TIMER NOT RUNNING         ?
    BZS3WAIT := FALSE;                      _ALLOW LINE BID            ?
    IF BZS3STATE = S5IDLE                   _IDLE STATE                ?
    THEN
      S3OUTSELECT := TRUE;                  _IT IS TIME FOR OUTPUT     ?
                                            _RETRY                     ?
  END; _S3OTIME?
  
  
_ 
* * *    INPUT WLE FROM L2
? 
  S2INMODE,S2INDATA,S2INCOM,S2INBORT, 
  S2INTBORT : 
  BEGIN 
    S3INPUT := TRUE;                        _WAKE UP INPUT ROUTINE     ?
    S3INWC  := S3EVENT - S2INMODE;          _CALCULATE INPUT WC        ?
  END; _S2INMODE,S2INDATA,...?
  
_ 
* * *    OUTPUT WLE FROM L2 
? 
  S2OMODE,S2ODATA,S2OCOM,S2OBORT, 
  S2OTBORT :  
  BEGIN 
    S3OUTPUT := TRUE;                       _WAKE UP OUTPUT ROUTINE    ?
    S3OUTWC := S3EVENT - S2OMODE;           _CALCULATE OUTPUT WORKCODE ?
  END; _S2OMODE,S2ODATA,...?
  
_ 
* * *    LINE DISABLED REPLY FROM LEVEL 2 
? 
  S2LNDIS :                                 _LINE DISABLED REPLY FROM  ?
                                            _L2 THEN RELEASE ALL       ?
  BEGIN                                     _INTERNALLY HELD DATA      ?
    PBREL1BUF(S3LCBPTR'.BZBSCEXT,B0S16);    _RELEASE LCB EXT BUFFER    ?
    S3WTCB := S3LCBPTR'.BZTCBPTR;           _GET THE FIRST TCB         ?
    IF (S3WTCB " NIL) &                     _IF THERE IS A TCB         ?
        S3WTCB'.BSTCB.BSS3AUTO              _AND IT IS AN AUTOREC TCB  ?
    THEN                                    _THEN                      ?
      PBREL1BF(S3LCBPTR'.BZTCBPTR,BEDBSIZE);
    BWWLENTRY[OPS].CMSMLEY.CMDATA           _SET OPTIONAL DATA FIELD   ?
      := D5DISA;                            _TO DISABLED               ?
    PTS3SEND (S5SVM,S3LNEVENT,NIL);         _TELL SVM LINE DISABLED    ?
  END; _ S2LNDIS? 
  
_ 
* * *    STOP OUTPUT REQUEST FROM L2 (NO OUTPUT DATA WAS AVAILABLE) 
? 
  S2OSTOP : 
  BEGIN 
    BZS3STATE := S5OUTEND;                  _WAITING FOR TERMINATION   ?
    PTCOMMAND(BZS3OTCB,D8OS,D9BI);          _OUTPUT STOPPED/INTERRUPT  ?
    PTS3SEND(S5L2,S3OUTRESET,NIL);          _TELL L2 TO TERMINATE      ?
  END; _S2OSTOP?
  
END; _CASE S3EVENT OF?
END; _PROCEDURE PTS3WLCONTROL?
_$J+? 
_***********************************************************************
*                                                                      *
*                             PTS3BSCML                                *
*                                                                      *
*                        BISYNC TIP MAIN LEVEL                         *
*                                                                      *
***********************************************************************?
_$G-,R-,I-     NON RECURSIVE
               INTERRUPTABLE? 
_***********************************************************************
*                                                                      *
**OVERVIEW:  THE MAIN LEVEL OF THE BSC TIP HANDLES INPUT AND OUTPUT    *
*            TRAFFIC AT THE CONNECTION LEVEL.  A SIMULATED CONSOLE,    *
*            LINE PRINTER, CARD READER AND AN OPTIONAL CARD PUNCH ARE  *
*            SUPPORTED ON A LINE.    THE BSC ML WILL INITIATE THE      *
*            OUTPUT BID LOGIC BY SENDING AN OUTPUT REQUEST WLE TO THE  *
*            BSC L2 WHENEVER OUTPUT DATA IS AVAILABLE AND INPUT IS NOT *
*            ACTIVE.     THE OUTPUT DEVICE IS SELECTED ACCORDING TO    *
*            THE FOLLOWING ALGORITHM - INTERACTIVE OVER BATCH OUTPUT   *
*            AND ALTERNATING BETWEEN PRINTER AND PUNCH FILES.          *
*            ONCE AN OUTPUT FILE IS STARTED, IT WILL MONOPOLIZE THE    *
*            OUTPUT CHANNEL UNTIL IT IS FINISHED OR AN ABORT SITUATION *
*            OCCURRES.                                                 *
*                                                                      *
*            OUTPUT MAY BE INTERRUPTED BY INPUT FROM THE TERMINAL      *
*            IN WHICH CASE THE OUTPUT WILL BE SUSPENDED AND RESUMED    *
*            AFTER THE INPUT IS FINISHED.   THE BSC ML WILL ALWAYS     *
*            ALLOW THE FIRST INPUT DATA TO COME IN.    THE FIRST DATA  *
*            IS USED TO IDENTIFY THE INPUT CONNECTION.   THE BSC ML    *
*            WILL THEN MAKE A DECISION TO EITHER ACCEPT THE INPUT      *
*            STREAM OR REJECT IT.    THE BASIS FOR REJECTING AN INPUT  *
*            STREAM IS THAT A TCB IS NOT CONFIGURED, THE CONNECTION    *
*            HAS NOT BEEN STARTED BY THE HOST, INPUT REGULATION IS ON, *
*            OR BUFFER REGULATION IS ON.  AFTER THE INPUT IS PERMITTED,*
*            THE BSC ML WILL SIMPLY COLLECT THE DATA, TEXT PROCESS THE *
*            DATA, AND SEND THE TEXT PROCESSED DATA TO THE BIP.        *
*            INPUT BUFFER REGULATION IS CHECKED WHEN INPUT IS ACTIVE.  *
*            THE BSC L2 WILL BE NOTIFIED VIA A WLE WHEN REGULATION     *
*            IS ON.    THE BSC ML WILL THEN USE A TIMER TO CHECK THE   *
*            REGULATION FROM TIME TO TIME IN ORDER TO NOTIFY THE BSC   *
*            L2 WHEN REGULATION IS OFF.                                *
*                                                                      *
**CALLING PROCEDURE:                                                   *
*            PBMON                                                     *
*                                                                      *
** INPUT:    BWWLENTRY[OPS] WORK LIST ENTRY                            *
*                                                                      *
** OUTPUT:   ACTION PERFORMED ACCORDING TO THE BSC ML ALGORITHM        *
*                                                                      *
** EXTERNAL REFERENCES:                                                *
*                                                                      *
*            PBTMRSRVS,PBQUEMAINT,PBULTS,PBDLTS                        *
*                                                                      *
*                                                                      *
*                                                                      *
*                                                                      *
***********************************************************************?
  
BEGIN _PROCEDURE PTS3BSCML? 
S3DBGA [S3DBGI] := BWWLENTRY[OPS].B0TIPWLE; _SAVE WORKLIST ENTRY       ?
S3DBGI          := (S3DBGI + 1) MOD 25;     _UPDATE INDEX INTO ARRAY   ?
_ 
* * *    PICK UP PARAMETERS FROM WORK LIST ENTRY
? 
  WITH BWWLENTRY[OPS].B0EWLQ DO 
  BEGIN 
    HALINO.BDLINO := MMLINO;                _LINE NUMBER               ?
    PBLCBP(MMLINO,S3LCBPTR);                _GET LCB ADDRESS           ?
    S3EVENT   := MMWKCOD;                   _WORK CODE                 ?
    S3WTCOUNT := MMWTCOUNT;                 _GET WAIT COUNT FIELD      ?
    S3INPTR   := MMIBP;                     _INPUT POINTER             ?
  END;
  S3LCBEXT    := S3LCBPTR'.BZBSCEXT;        _GET BSC EXTENSION TO LCB  ?
  S3INPUT     := FALSE;                     _CLEAR INPUT INDEX         ?
  S3OUTPUT    := FALSE;                     _CLEAR OUTPUT INDEX        ?
  S3OUTSELECT := FALSE;                     _CLEAR OUTPUT SELECT INDEX ?
_ 
* * *    CALL WORKLIST ENTRY PROCESSOR
? 
  PTS3WLCONTROL;
  IF S3INPUT                                _IF INPUT PROCESS NEEDED   ?
  THEN                                      _THEN                      ?
    PTS3INPUT                               _CALL INPUT PROCESS        ?
  ELSE                                      _ELSE                      ?
    IF S3OUTPUT                             _IF OUTPUT PROCESS NEEDED  ?
    THEN                                    _THEN                      ?
      PTS3OUTPUT;                           _CALL OUTPUT PROCESS       ?
  IF S3OUTSELECT                            _IF OUTPUT SELECT NEEDED   ?
  THEN                                      _THEN                      ?
    PTS3OBID;                               _CALL OUTPUT SELECT PROCESS?
END; _PTS3BSCML?
_$J+? 
_***********************************************************************
*                                                                      *
*                             PTT3OTEXT                                *
*                                                                      *
*                    BSC MAIN LEVEL OUTPUT MESSAGE PROCESS             *
*                                                                      *
***********************************************************************?
_$G-,R-,I-     NON RECURSIVE
               INTERRUPTABLE? 
_***********************************************************************
*                                                                      *
**OVERVIEW:  PTT3OTEXT WILL PROCESS DOWNLINE DATA AND COMMANDS.        *
*            THIS ROUTINE MAY BE CALLED BY BIP DIRECTLY TO CONVERT     *
*            PRUBS INTO TRANSMISSION BLOCKS OR TO PROCESS DOWNLINE     *
*            COMMANDS                                                  *
*                                                                      *
**INPUT:     T3TCB,T3BUF                                               *
*                                                                      *
**OUTPUT:    T3BUF                                                     *
*                                                                      *
**EXTERNAL REFERENCES:                                                 *
*                                                                      *
*            PTT5OTEXT                                                 *
*                                                                      *
***********************************************************************?
PROCEDURE PTT3OTEXT(VAR T3TCB,T3BUF : B0BUFPTR);
CONST 
      PSFC       = P1;                      _PFC                       ?
      SSFC       = P2;                      _SFC                       ?
_ 
* * *     WORK CODE TO BSC TIP
? 
       S3OSTOP   = A0WK13;                  _ICMD TERMINATE OUTPUT SEEN?
TYPE
      T7DATA =   PACKED RECORD
                   T5TYP  : B04BITS;
                   T5NUL  : B04BITS;
                   T5IND  : B08BITS;
                 END; 
VAR 
      T3BLK      : T7DATA;                  _BLOCK TYPE                ?
      T3PFC      : INTEGER;                 _PRIMARY FUNCTION CODE     ?
      T3SFC      : INTEGER;                 _SECONDARY FUNCTION CODE   ?
      T3CANMSG    : B0BUFPTR;               _POINTER TO CANNED MSG    ? 
_$J+? 
_***********************************************************************
*                                                                      *
*                             PTT5OTEXT                                *
*                                                                      *
*                        BSC ML OUTPUT TEXTPROCESSING                  *
*                                                                      *
$**********************************************************************?
_$G-,R-,I-     NON RECURSIVE
               INTERRUPTABLE? 
_***********************************************************************
*                                                                      *
**OVERVIEW:  PTTSOTEXT WILL PROCESS A PRUB AND GENERATE NONE OR        *
*            SEVERAL TRANSMISSION BLOCKS                               *
*                                                                      *
**INPUT:     T3TCB,T3BUF                                               *
*                                                                      *
**OUTPUT:    T5SBUF                                                    *
*                                                                      *
**EXTERNAL REFERENCES: NONE                                            *
*                                                                      *
*                                                                      *
*                                                                      *
***********************************************************************?
PROCEDURE PTT5OTEXT;
CONST 
_ 
* * *    BUFFER 
? 
      T9ACCT         = 4;                   _POSITION OF ACCT DATA     ?
      T9LCDMAX       = $7D;                 _MAXIMUM LCD               ?
_ 
* * *    TRANSMISSION BLOCKS
? 
      T9RES4         = 4;                   _RESERVE SPACE FOR STX,CRC ?
                                            _CRC AND ETB/ETX           ?
      T9RES6         = 6;                   _RESERVE SPACE FOR DLE,STX ?
                                            _DLE,ETB/ETX AND 2 CRC     ?
      T9PAD          = $FF;                 _PAD CHAR FOR XMIS BLOCK   ?
_ 
* * *    DISPLAY CODE CHARACTERS
? 
      T9SLSH         = $28;                 _/                         ?
      T9STAR         = $27;                 _*                         ?
      T9E            = $05;                 _E                         ?
      T9O            = $0F;                 _O                         ?
      T9I            = $09;                 _I                         ?
      T9DEOL         = $FF;                 _END OF LINE               ?
      T9DBNK         = $2D;                 _BLANK                     ?
      T9DEOR         = $40;                 _EOR                       ?
      T9DONE         = $1C;                 _ONE                       ?
_ 
* * *     ASCII CHARACTERS
? 
      T9ABNK         = $20;                 _ASCII BLANK               ?
      T9AEOL         = $1F;                 _END OF LINE CHARACTER     ?
_ 
* * *    STATE PROGRAM INDEX
? 
      T9FSTI         = 2;                   _INITIAL STATE INDEX       ?
      T9FCD          = 8;                   _BUFFER FCD                ?
      T93780         = N03780;
      T9MAX2BLK      = $1F;                 _2780 MAXIMUM BLANK COMPRES?
      T9MAX3BLK      = $3F;                 _3780 MAXIMUM BLANK COMPRES?
      T9BLK2BASE     = $80;                 _2780 BLANK COMPRES BASE   ?
      T9BLK3BASE     = $40;                 _3780 BLANK COMPRES BASE   ?
TYPE
_ 
* * *    DATA 
? 
      TPCHAR =   PACKED RECORD
                 CASE I : INTEGER OF
                 1: (T5CD1, 
                     T5CD2    : B08BITS); 
                 2: (T5INT    : INTEGER); 
                 3: (T5CH1, 
                     T5CH2    : CHAR);
                 END; 
_ 
* * *    BUFFER POINTERS
? 
      TPBUFP =   PACKED RECORD
                 CASE I : INTEGER OF
                 1: (T5PTR    : B0BUFPTR);
                 2: (T5SET    : SETWORD); 
                 3: (T5INT    : INTEGER); 
                 END; 
VAR 
_ 
* * *    DATA 
? 
      T5DBC    : DBDBC;                     _BDC                       ?
      T5BLK    : BLKTYPE;                   _BLOCK TYPE                ?
      T5FCD    : TPCHAR;                    _FCD                       ?
      T5ACCT   : TPCHAR;                    _ACCOUNTING DATA           ?
_ 
* * *    FLAGS
? 
      T5CONTINUE     : BOOLEAN;             _CONTINUE TEXT PROCESSING  ?
_ 
* * *     TEXTPROCESSING
? 
      T5TPCB   : B0BUFPTR;                  _TPCB POINTER              ?
_ 
* * *    BUFFER POINTERS
? 
      T5NSBUF   : B0BUFPTR;                 _NEW/NEXT SOURCE BUFFER PTR?
      T5EBUF    : B0BUFPTR; 
      T5FBUF    : B0BUFPTR; 
      T5GBUF    : B0BUFPTR; 
      T5SP1,
      T5SP2     : TPBUFP;                   _WORKING BUFFER POINTERS   ?
_ 
* * *     TEXTPROCESSING PARAMETERS 
? 
      T5BASE     : ARRAY[BOOLEAN] OF        _BLANK COMPRESSION BASE    ?
                   INTEGER;                 _2780(0) OR 3780(1)        ?
  
      T5LIM      : ARRAY[BOOLEAN] OF        _BLANK COMPRESSION LIMIT   ?
                   INTEGER;                 _2780(0) OR 3780(1)        ?
  
      T5RES      : ARRAY[BOOLEAN] OF        _PROTOCOL OVERHEAD         ?
                   INTEGER;                 _CHARACTER NUMBERS         ?
                                            _2780(0) OR 3780(1)        ?
  
      T5BNKCHR   : ARRAY[BOOLEAN] OF        _BLANK CHARACTER IN        ?
                   CHAR;                    _DISPLAY(0) OR ASCII(1)    ?
  
      T5EOLC     : ARRAY[BOOLEAN] OF        _END OF LINE CHARACTER     ?
                   B08BITS;                 _DISPLAY(0) OR ASCII(1)    ?
  
VALUE 
_ 
* * *     TPCB PARAMETERS 
? 
      T5BASE     = (T9BLK2BASE,T9BLK3BASE); _BLANK COMPRESSION BASE    ?
      T5LIM      = (T9MAX2BLK,T9MAX3BLK);   _BLANK COMPRESSION LIMIT   ?
      T5RES      = (T9RES6,T9RES4);         _PROTOCOL CHAR OVERHEAD    ?
      T5BNKCHR   = (T9DBNK,T9ABNK);         _BLANK CHARACTER           ?
      T5EOLC     = (T9DEOL,T9AEOL);         _END OF LINE CHARACTER     ?
  
_$J+? 
_***********************************************************************
*                                                                      *
*                             PTS5STORE                                *
*                                                                      *
*                 STORE A GIVEN CHARACTER INTO A GIVEN BUFFER          *
*                                                                      *
***********************************************************************?
_$G-,R-,I-     NON RECURSIVE
               INTERRUPTABLE? 
_***********************************************************************
*                                                                      *
**OVERVIEW:  IF A GIVEN BUFFER IS FULL THEN THE ROUTINE WILL GET       *
*            A NEW BUFFER, CHAIN IT TO THE OLD BUFFER, MOVE THE OLD    *
*            BUFFER POINTER TO THE NEW BUFFER AND FINALLY STORE THE    *
*            GIVEN CHARACTER INTO THE BUFFER.     IF THERE ARE STILL   *
*            MORE SPACES IN THE GIVEN BUFFER THE ROUTINE WILL SIMPLY   *
*            STORE THE GIVEN CHARACTER INTO THE BUFFER.                *
*                                                                      *
**INPUT:     S5BUF,S5DATA                                              *
*                                                                      *
**OUTPUT:    NONE                                                      *
*                                                                      *
**EXTERNAL REFERENCES: NONE                                            *
*                                                                      *
***********************************************************************?
PROCEDURE PTS5STORE(VAR S5BUF : B0BUFPTR; S5DATA : B08BITS);
VAR 
      S5NBUF     : B0BUFPTR;                _NEW BUFFER POINTER        ?
BEGIN 
  IF S5BUF'.BFLCD = T9LCDMAX                _IF THIS BUFFER IS FULL    ?
  THEN
  BEGIN 
    S5NBUF := PBGET1BUF(BEDBSIZE);          _GET A NEW BUFFER          ?
    S5NBUF'.BFLCD := S5NBUF'.BFFCD - 1;     _UPDATE LCD                ?
    S5BUF'.BCCHAIN[DBUFLENG] := S5NBUF;     _CHAIN TO OLD BUFFER       ?
    S5BUF := S5NBUF;                        _UPDATE INPUT BUFFER POINT ?
  END; _IF S5BUF'.BFLCD?
  WITH S5BUF' DO                            _WITH THE DATA BUF         ?
  BEGIN 
    BFLCD := BFLCD + 1;                     _INCREMENT LCD             ?
    BFDATAC[BFLCD] := CHR(S5DATA);          _STORE DATA INTO BUF       ?
  END;
END; _PROCEDURE PTS5STORE?
_$J+? 
_***********************************************************************
*                                                                      *
*                             PTT5OTEXT                                *
*                                                                      *
*                        BSC ML OUTPUT TEXTPROCESSING                  *
*                                                                      *
$**********************************************************************?
_$G-,R-,I-     NON RECURSIVE
               INTERRUPTABLE? 
_***********************************************************************
*                                                                      *
**OVERVIEW:  PTT5OTEXT WILL PROCESS A PRUB AND GENERATE NONE OR        *
*            SEVERAL TRANSMISSION BLOCKS                               *
*                                                                      *
**INPUT:     T3TCB,T3BUF                                               *
*                                                                      *
**OUTPUT:    T5SBUF                                                    *
*                                                                      *
**EXTERNAL REFERENCES: NONE                                            *
*                                                                      *
*                                                                      *
*                                                                      *
***********************************************************************?
BEGIN 
  T5TPCB := PBGET1BUF(BETPSIZE);            _GET A TPCB                ?
  PBCLR(T5TPCB,TPBUFLENGTH);                _CLEAR TPCB                ?
  T5CONTINUE := TRUE;                       _GO AND DO TEXTPROCESSING  ?
  WITH T3BUF' DO
  BEGIN 
    T5DBC.DBCHAR := BFDATAC[DBC];           _GET DBC                   ?
    T5BLK.BTCHR  := BFDATAC[BTPT];          _GET BLOCK TYPE            ?
    BFFCD        := DBC + 1;                _ADJUST FCD                ?
  END;
  WITH T3TCB'.BSTCB,T5TPCB'.BGMLCB DO 
  BEGIN 
_ 
* * *    CONSOLE
? 
    IF BSDEVTYP = N1CON                     _CONSOLE                   ?
    THEN
    BEGIN 
      NCTEOJ   := (T5BLK.BTYPE = HTMSG);    _EOJ IF MSG BLK            ?
      NCTFCSS  := TRUE;                     _NEED FORMSCONTROL         ?
                                            _SINGLE SPACE              ?
      NCSPTA    := BYCNSPTA;                _STATE PROGRAM ADDRESS     ?
      NCCXLTA   := BYOXLTA[B9ASCII];        _CODE TRANSLATION TABLE    ?
      NCTFEPRES := (NOT T5DBC.DBDLFE);      _SET FORMAT EFFECTORS FLAG ?
                                            _ASCII                     ?
    END _IF BSDEVTYP? 
_ 
* * *    BATCH DEVICES
? 
    ELSE
    BEGIN 
      IF T5DBC.DBBEOI                       _EVALUATE EOI AND EOJ FROM ?
      THEN                                  _DBC                       ?
        IF T5DBC.DBBEOR 
        THEN
          NCTEOJ := TRUE                    _EOJ IF EOI AND EOR ON DBC ?
        ELSE
          NCTEOI := TRUE;                   _EOI IF EOI AND NOT EOR ON ?
                                            _DBC                       ?
      IF BSFTYPE = B9TRANS                  _IF TRANSPARENT FILE       ?
      THEN
      BEGIN 
        NCSPTA   := BYXPSPTA;               _ STATE PROGRAM ADDRESS   ? 
        NCT06FLG := TRUE;                   _TRANSPARENT FILE FLAG    ? 
      END 
      ELSE
      BEGIN 
        NCNOXL := TRUE;                     _TURN ON TRANSLATION FLAG  ?
_ 
* * *     CARD PUNCH
? 
        IF BSDEVTYP = N1CP                  _IF CARD PUNCH             ?
        THEN
        BEGIN 
          NCSPTA := BYCPSPTA;               _ STATE PROGRAM ADDRESS   ? 
          NCCXLTA := BYOXLTA[BSFTYPE];      _CODE TRANSLATION TABLE    ?
          BEGIN 
            T5GBUF := T3BUF;
            WHILE T5GBUF'.BCCHAIN[DBUFLENG]  _GET THE LAST BUFFER ON   ?
                  " NIL DO
              T5GBUF := T5GBUF'.BCCHAIN      _SOURCE                   ?
                               [DBUFLENG];
            IF T5DBC.DBBEOR & NOT NCTEOJ     _PROCESS EOR BLOCK        ?
            THEN
            BEGIN 
              PTS5STORE(T5GBUF,T9DEOR);      _STORE EOR                ?
              IF T5DBC.DBBLEVNO < 8          _IF SINGLE DIGIT LEVEL NO ?
              THEN
              BEGIN 
                PTS5STORE(T5GBUF,T9DBNK);    _FIRST LEVEL NO IS BLANK  ?
                IF T5DBC.DBBLEVNO = 0 
                THEN                         _IF 0                     ?
                  PTS5STORE(T5GBUF,T9DBNK)   _BLANK FOR 2ND LEVEL NO   ?
                ELSE                         _NON-ZERO                 ?
                  PTS5STORE(T5GBUF,T5DBC.    _SECOND LEVEL NUMBER      ?
                                 DBBLEVNO); 
              END _IF T5DBC?
              ELSE
              BEGIN 
                PTS5STORE(T5GBUF,T9DONE);   _STORE ONE AS THE FIRST    ?
                                            _LEVEL NUMBER              ?
                PTS5STORE(T5GBUF,T5DBC.     _STORE SECOND LEVEL NUMBER ?
                          DBBLEVNO - 8 ); 
              END;
              PTS5STORE(T5GBUF,T9DEOL);     _STORE END OF LINE         ?
            END 
            ELSE
            IF NCTEOI                       _EOI                       ?
            THEN
            BEGIN                           _STORE /*EOI               ?
              PTS5STORE(T5GBUF,T9SLSH); 
              PTS5STORE(T5GBUF,T9STAR); 
              PTS5STORE(T5GBUF,T9E);
              PTS5STORE(T5GBUF,T9O);
              PTS5STORE(T5GBUF,T9I);
              PTS5STORE(T5GBUF,T9DEOL); 
            END; _IF NCTEOI?
          END; _IF T5DATA?
        END _IF BSDEVTYP? 
_ 
* * *    LINE PRINTER 
? 
        ELSE
        BEGIN 
          NCCXLTA := BYLPXLTA[BSFTYPE       _CODE TRANSLATION TABLE    ?
                               = B9ASCII];
          IF BSSUPCC                        _SUPPRESS CARRIAGE CONTROL ?
          THEN
          BEGIN 
            NCTFCSS  := TRUE;               _NEED SINGLE SPACE FORMS   ?
                                            _CONTROL FOR EACH LINE     ?
            NCSPTA := BYSUPSPTA;            _ STATE PROGRAM ADDRESS   ? 
          END 
          ELSE
          BEGIN 
            NCT06FLG := BSSFC;              _FORMSCONTROL INFORMATION  ?
            NCTFOLD  := BSSFOLD;            _LINE FOLD INFORMATION     ?
            NCT1CWD  := BSSLNPG;            _CURRENT LINE POSITION     ?
            NCSPTA   := BYLPSPTA[BSFTYPE    _STATE PROGRAM ADDRESS     ?
                                  = B9ASCII]; 
          END;
        END; _IF BSDEVTYP?
      END; _IF T5DBC.DBBXPT?
    END; _IF BSDEVTYP?
_ 
* * *    PREPARE SOURCE BUFFERS FOR TEXTPROCESSING
? 
    IF T3BUF'.BFLCD < T3BUF'.BFFCD          _IF INPUT SOURCE BUF EMPTY ?
    THEN
      IF BSS5SBUF = NIL                     _IF OLD SOURCE BUF EMPTY   ?
      THEN
        IF NCTEOI ! NCTEOJ                  _IF EOI OR EOJ THEN        ?
        THEN
          NCFSBA := T3BUF                   _TEXTPROCESS WITH INPUT BUF?
        ELSE
        BEGIN 
          T5CONTINUE:= FALSE;              _DO NOT TEXTPROCESS        ? 
          PBRELZRO(T3BUF,BEDBSIZE); 
        END 
      ELSE
      BEGIN 
        NCFSBA := BSS5SBUF;                 _TEXTPROCESS ON OLD SOURCE ?
        PBRELZRO(T3BUF,BEDBSIZE);           _ONLY                      ?
      END 
    ELSE
      IF BSS5SBUF = NIL                     _IF OLD SOURCE EMPTY       ?
      THEN
        NCFSBA := T3BUF                     _TEXTPROCESS ON NEW INPUT  ?
      ELSE
      BEGIN                                 _OLD SOURCE NOT EMPTY      ?
        T5GBUF := BSS5SBUF; 
        WHILE T5GBUF'.BCCHAIN[DBUFLENG] "   _GET THE LAST BUFFER ON    ?
              NIL  DO                       _OLD SOURCE BUFFER         ?
          T5GBUF := T5GBUF'.BCCHAIN 
                            [DBUFLENG]; 
        T5GBUF'.BCCHAIN[DBUFLENG] :=        _CHAIN INPUT SOURCE BUFFER ?
                                  T3BUF;    _TO THE OLD SOURCE         ?
        NCFSBA := BSS5SBUF; 
      END;
    IF T5CONTINUE                           _IF OK TO TEXTPROCESS      ?
    THEN
    BEGIN 
      NCT3780  := (BSTCLASS = T93780);      _2780 OR 3780              ?
      NCTBASE  := T5BASE[NCT3780];          _BLANK COMPRESSION BASE    ?
      NCTLIM   := T5LIM[NCT3780];           _BLANK COMPRESSION LIMIT   ?
      NCTPL    := BSPGLENG;                 _PAGE LENGTH               ?
      NCTRN    := BSMR;                     _2780 RECORD NUMBER        ?
      NCIBFCD  := T9FCD;                    _BUFFER FCD                ?
      NCTXLINE := BSSXLINE;                 _SPARE RECORD NO. IN DEST  ?
      NCTCOMPRES := BSBCOMP;                _BLANK COMPRESSION FLAG    ?
      NCTWEIGHT:= BSSWEIGHT;                _ACCUMULATED ACCT WEIGHT   ?
      NCCNT2   := BSSXCHAR;                 _SPARE SPACE IN DEST BUFFER?
      NCBLKL   := BSXBZ                     _ALLOWABLE SPACE IN        ?
                  - T5RES[T5DBC.DBBXPT];    _TRANSMISSION BLOCK        ?
      NCCNTL   := BSPGWIDTH;                _PAGE WIDTH                ?
      NCSTAI   := T9FSTI;                   _INITIAL STATE INDEX       ?
      IF BSS5DBUF " NIL                     _IF UNFINISHED DESTINATION ?
                                            _BUFFER EXISTS             ?
      THEN                                  _THEN                      ?
      BEGIN 
        NCFDBA := BSS5DBUF;                 _UNFINISHED DEST BUFFER    ?
        NCDBP  := BSS5CBUF;                 _CURRENT DEST CHAR POSITION?
        NCDCRB := BSSDCRB;                  _LEFT OR RIGHT BYTE FLAG   ?
      END;
      NCSCHR   := T5BNKCHR[BSFTYPE = B9ASCII];_BLANK CHARACTER         ?
      NCTEOLC  := T5EOLC[BSDEVTYP = N1CON]; _END OF LINE CHARACTER     ?
_ 
* * *     CALL TEXT PROCESSING STATE PROGRAM
? 
  
      PTTPINF(T5TPCB'); 
  
_ 
* * *    PROCESS SOURCE BUFFERS 
? 
      IF NCTEOI ! NCTEOJ                    _IF EOI OR EOJ             ?
      THEN                                  _RELEASE ALL SOURCE BUFFERS?
        T5NSBUF := NIL
      ELSE                                  _NON-EOI AND NON EOI       ?
      BEGIN 
        T5SP1.T5PTR := NCSBP;               _GET CURRENT SOURCE POINTER?
        T5SP2.T5SET := T5SP1.T5SET -        _GET CURRENT SOURCE BUFFER ?
                   BEDBSIZE'.BEMSK.BASET; 
        T5NSBUF := T5SP2.T5PTR; 
        IF NCEOSR                           _IF END OF SOURCE          ?
        THEN
          IF NCTBACK                        _IF BACKSPACE NEEDED       ?
          THEN
            T5NSBUF'.BFFCD := T5NSBUF'.     _LEAVE THE LAST CHARACTER  ?
                                 BFLCD      _IN THE BUFFER             ?
          ELSE
            T5NSBUF := T5NSBUF'.BCCHAIN     _LEAVE BUFFERS NEXT TO     ?
                             [DBUFLENG]     _CURRENT                   ?
        ELSE
        BEGIN 
          T5FCD.T5INT := (T5SP1.T5INT -     _CALCULATE FCD             ?
                          T5SP2.T5INT)*2; 
          IF NCRIGHTC                       _ADJUST FCD IF CURRENT CHAR?
          THEN                              _IS ON THE RIGHT BYTE      ?
            T5FCD.T5INT := T5FCD.T5INT+1; 
          IF NCTBACK                        _IF BACKSPACE ON SOURCE    ?
          THEN                              _NEEDED                    ?
            IF T5FCD.T5CD2 = T5SP2.T5PTR'   _IF CURRENT CHAR IS THE    ?
                             .BFFCD         _FIRST ON THE BUFFER       ?
            THEN
            BEGIN 
              T5NSBUF := NCFSBA;            _GET THE BUFFER BEFORE THE ?
              WHILE T5NSBUF'.BCCHAIN        _CURRENT BUFFER            ?
                    [DBUFLENG] " T5SP2. 
                    T5PTR DO
                T5NSBUF := T5NSBUF'.
                       BCCHAIN[DBUFLENG]; 
              T5FCD.T5CD2 := T5NSBUF'.      _KEEP THE LAST CHARACTER   ?
                               BFLCD; 
            END 
            ELSE
              T5FCD.T5INT := T5FCD.T5INT    _BACKSPACE ON CURRENT BUF  ?
                             - 1; 
          T5NSBUF'.BFFCD := T5FCD.T5CD2;    _UPDATE FCD FOR UNPROCESSED?
                                            _SOURCE DATA               ?
        END; _IF NCEOSR?
      END; _IF NCTEOI?
      T5GBUF := NCFSBA;                     _GET SOURCE BUFFERS        ?
      WHILE T5GBUF " T5NSBUF DO             _RELEASE ALL THE PROCESSED ?
        PBREL1BUF(T5GBUF,BEDBSIZE);         _PORTION                   ?
      BSS5SBUF := T5NSBUF;                  _PUT UNPROCESSED BACK INTO ?
                                            _TCB                       ?
      T3BUF := NIL;               _CLEAR SOURCE BUF POINTER            ?
_ 
* * *    PROCESS DESTINATION BUFFERS
? 
      T5EBUF := NCFDBA;                     _GET DESTINATION BUFFER    ?
      T5FBUF := T5EBUF; 
      IF T5EBUF " NIL                       _IF NOT NIL                ?
      THEN
      BEGIN 
        IF T5EBUF'.BFLCD < T5EBUF'.BFFCD    _IF DUMMY BLOCK            ?
        THEN
          PBRELZRO(T5EBUF,BEDBSIZE)         _RELEASE ALL BUFFERS       ?
        ELSE
        WHILE T5FBUF " NIL DO               _KEEP PROCESSING WHEN THE  ?
        BEGIN                               _DESTINATION CHAIN IS NOT  ?
                                            _ENDED                     ?
          WHILE (T5FBUF " NIL) & NOT        _GET THE LAST BUFFER OF THE?
                 T5FBUF'.BFSEOB DO          _CURRENT TRANSMISSION BLOCK?
            T5FBUF := T5FBUF'.BCCHAIN 
                             [DBUFLENG];
          IF T5FBUF " NIL                   _IF THE CURRENT TRANSMISSIO?
          THEN                              _COMPLETE                  ?
          BEGIN 
            IF NOT T5EBUF'.BFPMMSG          _IF NOT PM                 ?
            THEN
            WITH T5FBUF' DO                 _WITH THE LAST BUFFER      ?
            BEGIN 
              T5ACCT.T5CH2 := BFDATAC       _GET THE LAST CHARACTER    ?
                             [BFLCD];       _WHICH IS ACCT WEIGHT RIGHT?
              BFDATAC[BFLCD] := CHR(T9PAD); _BYTE, AND REPLACE WITH PAD?
              IF BFFCD = BFLCD              _IF THE LAST BUFFER CONTAIN?
              THEN                          _ONLY ONE CHARACTER        ?
              BEGIN 
                T5GBUF := T5EBUF;           _POINTER TO THE BEGINNIG   ?
                WHILE T5GBUF'.BCCHAIN       _TRACE DOWN THE TRANSMISSIO?
                  [DBUFLENG] " T5FBUF DO    _TO GET THE BUFFER NEXT TO ?
                  T5GBUF := T5GBUF'.        _THE LAST                  ?
                      BCCHAIN[DBUFLENG];
                T5ACCT.T5CH1 :=             _GET THE LAST CHARACTER    ?
                  T5GBUF'.BFDATAC           _OF THE SECOND TO LAST     ?
                  [T5GBUF'.BFLCD];          _BUFFER WHICH IS ACCTING   ?
                                            _WEIGHT LEFT BYTE          ?
                T5GBUF'.BFDATAC             _REPLACE IT WITH PAD       ?
                  [T5GBUF'.BFLCD] :=        _CHARACTER                 ?
                   CHR(T9PAD);              _                          ?
              END 
              ELSE                          _THERE ARE 2 OR MORE CHAR  ?
              BEGIN                         _IN THE LAST BUFFER        ?
                T5ACCT.T5CH1 := BFDATAC     _MOVE SECOND TO LAST CHAR  ?
                             [BFLCD - 1];   _TO ACCT WEIGHT LEFT BYTE  ?
                BFDATAC[BFLCD-1] := CHR(    _REPLACE WITH PAD CHARACTER?
                                    T9PAD); 
              END; _IF BFFCD? 
              T5EBUF'.BIINT[T9ACCT] :=      _PUT ACCOUNTING            ?
                          T5ACCT.T5INT; 
                                            _INTERFACE                 ?
              T5EBUF'.BIINT[2] := BIINT[2]; _MOVE FLAG WORD TO THE     ?
                                            _FRONT                     ?
            END; _WITH T5FBUF?
            T5GBUF := T5FBUF'.BCCHAIN       _GET THE CHAIN AFTER THE   ?
                             [DBUFLENG];    _CURRENT TRANSMISSION BLOCK?
            T5FBUF'.BCCHAIN[DBUFLENG]       _BREAK CHAIN               ?
                   := NIL;
_ 
* * *    PUT THE CURRENT TRANSMISSION IN QUEUE
? 
            PBQUEMAINT(T3TCB,T5EBUF,K4PUT); 
                                            _INTO QUEUE                ?
            T5EBUF := T5GBUF;               _POINTER TO THE REMAINING  ?
            T5FBUF := T5GBUF;               _CHAIN                     ?
          END _IF T5FBUF? 
        END; _WHILE T5FBUF? 
      END; _IF T5EBUF?
      BSS5DBUF := T5EBUF;                   _UNFINISHED TRANSMISSION   ?
                                            _BLOCK                     ?
_ 
* * *    COPY INFORMATION BACK TO TCB 
? 
      BSS5CBUF  := NCDBP;                   _CURRENT CHAR POSITION     ?
      BSSDCRB   := NCDCRB;                  _LEFT OR RIGHT BYTE FLAG   ?
      BSSXLINE  := NCTXLINE;                _NUMBER OF LINES LEFT      ?
      BSSWEIGHT := NCTWEIGHT;               _ACCUMULATED ACCT WEIGHT   ?
      BSSXCHAR  := NCCNT2;                  _NUMBER OF CHARACTERS LEFT ?
      BSSLNPG   := NCT1CWD;                 _CURRENT LINE POSITION     ?
      BSSFC     := NCT06FLG;                _F.C. STORED INTO PREVIOUS ?
                                            _LINE ALREADY FLAG         ?
      BSSFOLD   := NCTFOLD;                 _LINE FOLD FLAG            ?
    END; _ IF T5CONTINUE? 
    PBREL1BUF(T5TPCB,BETPSIZE);             _RELEASE TPCB BUFFER       ?
  END; _WITH T5TCB? 
END; _PROCEDURE PTT5OTEXT?
  
  
  
  
  
  
_***********************************************************************
*                                                                      *
*         PTS3COPY - COPY SOURCE BUFFER TO DESTINATION BUFFER          *
*                                                                      *
***********************************************************************?
PROCEDURE PTS3COPY (S2SOURCE,S2DEST : B0BUFPTR);
CONST 
      S2FCDLCD  = 1;                        _INDEX TO FCD LCD          ?
VAR 
      S2LWORD,                              _INDEX TO LAST DATA WORD   ?
      S2I      : INTEGER;                   _INDEX FOR COPYING         ?
BEGIN 
  WITH S2SOURCE' DO                         _SOURCE POINTER FOR COPYING?
  BEGIN 
    S2LWORD := (BFLCD/2) + 1;               _SET UP END OF COPY INDEX  ?
    FOR S2I := S2FCDLCD TO S2LWORD DO       _COPY REST OF SOURCE BUFFER?
      S2DEST'.BIINT[S2I] := BIINT[S2I];     _INTO DESTINATION BUFFER   ?
  END; _WITH S2SOURCE?
END; _PROCEDURE PTS3COPY? 
  
_$J+? 
_***********************************************************************
*                                                                      *
*                             PTT3OTEXT                                *
*                                                                      *
*                    BSC MAIN LEVEL OUTPUT MESSAGE PROCESS             *
*                                                                      *
***********************************************************************?
_$G-,R-,I-     NON RECURSIVE
               INTERRUPTABLE? 
_***********************************************************************
*                                                                      *
**OVERVIEW:  PTT3OTEXT WILL PROCESS DOWNLINE DATA AND COMMANDS.        *
*            THIS ROUTINE MAY BE CALLED BY BIP DIRECTLY TO CONVERT     *
*            PRUBS INTO TRANSMISSION BLOCKS OR TO PROCESS DOWNLINE     *
*            COMMANDS                                                  *
*                                                                      *
**INPUT:     T3TCB,T3BUF                                               *
*                                                                      *
**OUTPUT:    T3BUF                                                     *
*                                                                      *
**EXTERNAL REFERENCES:                                                 *
*                                                                      *
*            PTT5OTEXT                                                 *
*                                                                      *
*                                                                      *
***********************************************************************?
BEGIN _PROCEDURE PTT3OTEXT? 
WITH T3TCB'.BSTCB,T3BUF' DO 
BEGIN 
  T3BLK.T5TYP := ORD(BFDATAC[BTPT]);        _GET BLOCK TYPE CHARACTER  ?
  T3PFC        := ORD (BFDATAC [PSFC]);     _GET PFC                   ?
  T3SFC        := ORD (BFDATAC [SSFC]);     _GET SFC                   ?
_ 
* * *     PROCESS ACCORDING TO BLOCK TYPE 
? 
  CASE T3BLK.T5TYP OF                       _CASE ON  BLOCK TYPE       ?
_ 
* * *      INTERRUPT COMMAND - ICMD 
? 
  HTICMD :  
  BEGIN 
  IF T3PFC = D7TERMINAT                     _IF THIS IS A TEMINATE     ?
  THEN                                      _ ICMD                     ?
  BEGIN 
    BSSTERMOUT  := TRUE;                    _SET ICMD,TERM IN PROCESS  ?
  
    PBRELZRO(BSS3OBUF,BEDBSIZE);            _RELEASE ANY OUTPUT BUFFERS?
    PTS3STOPOUTPUT(T3TCB);                  _CLEAR TEXTFIELDS IN TCB   ?
  
    WITH BWWLENTRY[OPS].B0EWLQ DO           _PREPARE WORKLIST ENTRY    ?
    BEGIN 
      MMLINO  := BSLCBP'.BZLINO.BDLINO;     _SET UP LINE NUMBER        ?
      MMWKCOD := S3OSTOP;                   _SET UP WORK CODE          ?
      MMIBP   := T3TCB;                     _SET UP TCB POINTER        ?
    END; _WITH BWWLENTRY? 
  
    PBLSPUT(BWWLENTRY[OPS],                 _INFORM ML PASCAL OF ICMD, ?
            BYWLCB[B0MLBSC]);               _SO SESSION CAN BE TERMD   ?
  END;  _IF T3FC.P0FC = D7TERMINAT? 
    PBREL1BUF(T3BUF,BEDBSIZE);              _RELEASE ICMD BUFFER       ?
  END; _HTICMD? 
_ 
* * *      DATA 
? 
  HTMSG,HTBLK :                             _MSG OR BLK BLOCK          ?
  
  IF BSSTERMOUT 
  THEN
    PBRELZRO(T3BUF,BEDBSIZE)
  ELSE
  BEGIN 
    PTT5OTEXT;                              _CREATE TRANSMISSION DATA  ?
                                            _TRANSMISSION BLOCKS       ?
  END; _HTMSG,HTBLK?
_ 
* * *       COMMANDS
? 
  HTCMD:  
  
  IF BSSTERMOUT                             _IF TERMINATE OUTPUT CMD   ?
  THEN                                      _THEN                      ?
  BEGIN 
    IF T3PFC = D8TO                         _IF TERM OUTPUT MARKER     ?
    THEN                                    _THEN                      ?
    BEGIN 
      BSSTERMOUT := FALSE;                  _CLEAR TERMINATE CONDITION ?
      IF BSBATCH
      THEN                                  _BATCH DEVICE              ?
        PBPEOI(T3TCB,D9IOT);                _SEND ACCOUNTING DATA      ?
    END;   _IF T3PFC? 
    PBRELZRO(T3BUF,BEDBSIZE); 
  END 
  ELSE
  BEGIN 
    CASE T3PFC OF                           _CASE ON COMMAND TYPE      ?
  
_ 
* * *     BATCH COMMANDS
? 
  
    D8CTRL,D8BD,D8BF:                       _TERMINAL/FILE CHARISTICS  ?
    BEGIN 
  
      PTDLCMD (T3TCB, T3BUF);               _PROCESS DL BATCH COMMAND  ?
  
      IF BSLACEC                            _IF LACE CARD COMMAND      ?
      THEN
      BEGIN 
        BSLACEC      := FALSE;              _CLEAR LACE CARD FLAG      ?
        T3BUF        := PBGET1BUF           _GET A DUMMY BUFFER        ?
                          (BEDBSIZE); 
        ADDR(S7LACE,T3CANMSG);              _MOVE LACE MESSAGE T       ?
        PTS3COPY(T3CANMSG,T3BUF);           _ DUMMY BUFFER             ?
        PTT5OTEXT;                          _CREATE TRANSMISSION DATA  ?
      END;   _IF BSLACEC? 
  
      IF BSLIMCD                            _IF LIMIT CARD COMMAND     ?
      THEN
      BEGIN 
        BSLIMCD      := FALSE;              _CLEAR LIMIT FLAG          ?
        T3BUF        := PBGET1BUF           _GET A DUMMY BUFFER        ?
                          (BEDBSIZE); 
        ADDR(S7LIMIT,T3CANMSG);             _MOVE LIMIT CARD MESSAGE   ?
        PTS3COPY(T3CANMSG,T3BUF);           _ TO DUMMY BUFFER          ?
        PTT5OTEXT;                          _CREATE TRANSMISSION DATA  ?
      END; _IF BSLIMCD? 
    END; _TPBD,TPBF?
_ 
* * *     BATCH START INPUT COMMAND 
? 
    D8SI:                                   _BATCH START INPUT         ?
    BEGIN 
      BSS3ION := TRUE;                      _INPUT ALLOWED             ?
      PBRELZRO(T3BUF,BEDBSIZE);             _RELEASE BUFFER            ?
    END; _D8SI? 
_ 
* * *     BATCH ABORT INPUT COMMAND 
? 
    D8AI:                                   _BATCH ABORT INPUT         ?
    BEGIN 
      BSS3ION := FALSE;                     _INPUT NOT ALLOWED         ?
      PBRELZRO(T3BUF,BEDBSIZE);             _RELEASE BUFFER            ?
    B1FLGWD.KTWORD := $100;                 _SET TERMINATE INPUT FLAG  ?
    PBULTS (T3TCB, NIL, B1FLGWD);           _CALL BIP TO TERMINATE INP ?
    END; _D8AI? 
    END; _CASE T3PFC? 
  END; _IF BSSTERMOUT?
  END; _CASE T3BLK? 
END; _WITH T3TCB'?
END; _PROCEDURE PTT3OTEXT?
_$J+? 
_***********************************************************************
*                                                                      *
*                             PTS3TCBINIT                              *
*                                                                      *
*                        BSC ML TCB INITIALIZATION                     *
*                                                                      *
$**********************************************************************?
_$G-,R-,I-     NON RECURSIVE
               INTERRUPTABLE? 
_***********************************************************************
*                                                                      *
**OVERVIEW: PTS3TCBINIT IS CALLED FROM SVM WHEN A TCB IS CONFIGURED    *
*                                                                      *
**INPUT:     B1TCB                                                     *
*                                                                      *
**OUTPUT:    NONE                                                      *
*                                                                      *
**EXTERNAL REFERENCES: NONE                                            *
*                                                                      *
*                                                                      *
*                                                                      *
***********************************************************************?
PROCEDURE PTS3TCBINIT;
CONST 
      T2TBSIZE       = 400;                 _2780 TRANSMISSION BLOCK   ?
                                            _SIZE                      ?
      T3TBSIZE       = 512;                 _3780 TRANSMISSION BLOCK   ?
                                            _SIZE                      ?
      T2MRN          = 7;                   _2780 MULTI RECORD NUMBER  ?
      T5PGWIDTH      = 80;                  _BSC DEFAULT PAGE WIDTH    ?
VAR 
      S53780     : BOOLEAN;                 _FLAG FOR TERM CLASS       ?
      S5XBZ      : ARRAY [BOOLEAN] OF 
                   INTEGER;                 _TRANSMISSION BLOCK SIZE   ?
VALUE 
      S5XBZ      = (T2TBSIZE,T3TBSIZE); 
  
BEGIN 
WITH B1TCB'.BSTCB DO
BEGIN 
  S53780 := (BSTCLASS = N03780);            _GET 2780 OR 3780 INFO     ?
  IF S53780                                 _IF THIS IS A 3780 TERMINAL?
  THEN                                      _THEN SET THE BLANK        ?
    BSBCOMP := TRUE;                        _COMPRESSION FLAG TRUE     ?
  IF BSXBZ = 0                              _IF TRANSMISSION BLOCK SIZE?
                                            _NOT SET                   ?
  THEN                                      _THEN                      ?
  BEGIN 
    BSXBZ := S5XBZ[S53780];                 _SET BLOCK SIZE            ?
  END;
  IF BSMR = 0                               _IF MRN NOT SET            ?
  THEN                                      _THEN                      ?
    BSMR := T2MRN;                          _SET MRN DEFAULT VALUE     ?
  IF BSPGWIDTH = 0                          _IF PAGE WIDTH NOT SET     ?
  THEN                                      _THEN                      ?
    BSPGWIDTH := T5PGWIDTH;                 _SET DEFAULT PAGE WIDTH    ?
  BSSLNPG := BSPGLENGTH;                    _SET LINE POSITION IN PAGE ?
  IF BSDEVTYPE = N1CON                      _IF CONSOLE                ?
  THEN
    BSFTYPE := B9ASCII;                     _DEFAULT FILE TYPE         ?
END; _WITH B1TCB'.BSTCB?
END; _PROCEDURE PTS3TCBINIT?
