*COMDECK BSCLV2 
_$J+? 
PROCEDURE PTS2BSC;
_ 
  
  
  
                      BBBBBBBBBB         SSSSSSSS         CCCCCCCC
                     BBBBBBBBBBBB      SSSSSSSSSSS      CCCCCCCCCCC 
                    BBBBBBBBBBBBB    SSSSSSSSSSSSS    CCCCCCCCCCCCC 
                   BBBBBB  BBBBBB   SSSSSS  SSSSSS   CCCCCC  CCCCCC 
                  BBBBBB  BBBBBB   SSSSSS           CCCCCC
                 BBBBBBBBBBBBBB     SSSSSSSS       CCCCCC 
                BBBBBBBBBBBB          SSSSSSSS    CCCCCC
               BBBBBB  BBBBBB           SSSSSS   CCCCCC 
              BBBBBB  BBBBBB   SSSSSS  SSSSSSS  CCCCCC  CCCCCC
             BBBBBBBBBBBBBB   SSSSSSSSSSSSSSS   CCCCCCCCCCCCC 
            BBBBBBBBBBBBBB     SSSSSSSSSSSSS     CCCCCCCCCCC
           BBBBBBBBBBBB         SSSSSSSSS         CCCCCCCC
  
  
  
  
                              LLLLLL             222222222
                             LLLLLL            222222222222 
                            LLLLLL           222222  222222 
                           LLLLLL           222222   222222 
                          LLLLLL                   222222 
                         LLLLLL                22222222 
                        LLLLLL              22222222
                       LLLLLL            22222222 
                      LLLLLL           22222222 
                     LLLLLLLLLLLLLL   22222222222222
                    LLLLLLLLLLLLLL   22222222222222 
  
  
  
  
                      TTTTTTTTTTTTTT   IIIIIIIIIIIIII   PPPPPPPPPP
                     TTTTTTTTTTTTTT   IIIIIIIIIIIIII   PPPPPPPPPPPP 
                    TTTTTTTTTTTTTT   IIIIIIIIIIIIII   PPPPPPPPPPPPP 
                       TTTTTT           IIIIII       PPPPPP  PPPPPP 
                      TTTTTT           IIIIII       PPPPPP  PPPPPP
                     TTTTTT           IIIIII       PPPPPPPPPPPPPP 
                    TTTTTT           IIIIII       PPPPPPPPPPPP
                   TTTTTT           IIIIII       PPPPPP 
                  TTTTTT           IIIII       PPPPPP 
                 TTTTTT       IIIIIIIIIIIIII   PPPPPP 
                TTTTTT       IIIIIIIIIIIIII   PPPPPP
               TTTTTT       IIIIIIIIIIIIII   PPPPPP 
  
  
  
  
? 
_$J+? 
CONST 
*CALL BSCWCS
_***********************************************************************
*                                                                      *
*     BSC WORK CODES FROM INPUT STATE TO LEVEL 2                       *
*                                                                      *
***********************************************************************?
      S2ENQ      = A0WK11;                  _ENQ                       ?
      S2ACK0     = A0WK12;                  _ACK0                      ?
      S2ACK1     = A0WK13;                  _ACK1                      ?
      S2WACK     = A0WK14;                  _WACK                      ?
      S2ETB      = A0WK15;                  _DATA ETB                  ?
      S2ETX      = A0WK16;                  _DATA ETX                  ?
      S2BAD      = A0WK17;                  _BAD DATA                  ?
      S2TTD      = A0WK18;                  _TTD                       ?
      S2NAK      = A0WK19;                  _NAK                       ?
      S2RVI      = A0WK20;                  _RVI                       ?
      S2BUF      = A0WK21;                  _BUFFER THRESHOLD          ?
      S2EOT      = A0WK22;                  _EOT                       ?
      S2LNEOT    = A0WK23;                  _DLE EOT                   ?
  
  
_***********************************************************************
*                                                                      *
*     BSC WORK CODES FROM MUX OR TIMER TO LEVEL 2                      *
*                                                                      *
***********************************************************************?
      S1TOEOT    = A0WK24;                  _TIMEOUT - DELAY AFTER
                                              SENDING EOT              ?
      S1TINPUT   = A0WK25;                  _TIMEOUT - INPUT           ?
      S1TIEND    = A0WK26;                  _TIMEOUT - INPUT END       ?
      S1TWACK    = A0WK27;                  _TIMEOUT - WACK            ?
      S1TODELAY  = A0WK28;                  _TIMEOUT - OUTPUT DELAY    ?
      S1TORESP   = A0WK29;                  _TIMEOUT - OUTPUT RESET    ?
      S1TOENQ    = A0WK30;                  _TIMEOUT - ENQ             ?
      S3CLEAR    = A0WK31;                  _SPECIAL WORK CODE FOR     ?
                                            _ NTS TESTING ONLY         ?
      S1TOINPS   = $40;                     _TIMEOUT - TIMER SET IN 
                                              INPUT STATES (BSCL2I)    ?
      S1TOIDLE   = $41;                     _TIMEOUT WHILE IDLE        ?
  
      S6ACK0     = FALSE;                   _ACK 0                     ?
      S2CONSTANT = 4;                       _INPUT STATES START INDEX  ?
      S2MAXTTDS = 5;                        _NO. CONSECUTIVE OUTPUT 
                                              DELAYS (TTD/NAK) BEFORE 
                                              DOWNLINE EOT ISSUED      ?
      S2MAXBADAK = 16;                      _MAX NUMBER OF BAD ACKS    ?
      S2MAXENQS  = 16;                      _MAXIMUM ENQS ALLOWED      ?
      S2MAXINPTO = 16;                      _MAX INPUT TIMEOUTS ALLOWED?
      S2MAXNORES = 16;                      _MAX ENQS SENT W/O RESPONSE?
_$J+? 
TYPE
_***********************************************************************
*                                                                      *
*      BSC TYPES                                                       *
*                                                                      *
***********************************************************************?
_ 
*  BSC LEVEL 2 LINE STATES
? 
      S0STST     = (S2DOWN,                 _DOWN                    ?
                    S2DWNDIS,               _DOWN DISABLED             ?
                    S2DWNHRD,               _DOWN HARD                 ?
                    S2IDLE,                 _IDLE                      ?
                    S2INPACT,               _INPUT ACTIVE              ?
                    S2INPDLY,               _INPUT DELAY               ?
                    S2INPEND,               _INPUT END                 ?
                    S2INPMOD,               _INPUT MODE                ?
                    S2INPRQS,               _INPUT REQUEST             ?
                    S2INPSTOP,              _INPUT STOP                ?
                    S2INP1ABRT,             _INPUT ABORT 1             ?
                    S2OUTBID,               _OUTPUT BID                ?
                    S2OUTDLY,               _OUTPUT DELAY              ?
                    S2OUTHLD,               _OUTPUT HOLD               ?
                    S2OUTMOD,               _OUTPUT MODE               ?
                    S2OUTRSP,               _OUTPUT RESPONSE           ?
                    S2OUTTRN,               _OUTPUT TRANSMIT           ?
                    S2OUT1ABRT,             _OUTPUT ABORT              ?
                    S2OSTPD);               _OUTPUT STOPPED            ?
_ 
*** TYPES OF ERRORS 
? 
      S0ET       = (S2NOERR,                _NO ERROR                  ?
                    S2BADRSP,               _BAD RESPONSE              ?
                    S2TMOT,                 _TIMEOUT                   ?
                    S2PROTOCOL);            _PROTOCOL ERROR            ?
_ 
*  BSC LEVEL 2 TIMERS 
? 
      S0TMTP     = (S2NOTIM,                _NO TIMER SET              ?
                    S2DLYTIM,               _DELAY TIME                ?
                    S2ENDTIM,               _END TIME                  ?
                    S2ENQTIM,               _ENQ TIMER                 ?
                    S2INTIM,                _INPUT TIME                ?
                    S2RSPTIM,               _RESPONSE TIME             ?
                    S2WAKTIM,               _WACK TIME                 ?
                              S2EOTTIM,     _EOT TIME                  ?
                              S2IDLTIM);    _IDLE TIME                 ?
_ 
* ACTION REQUESTS FOR MAIN LEVEL
? 
      S0MLRQ     = (S4NIL,                  _NONE                      ?
                    S4INCOMPL,              _INPUT COMPLETE            ?
                    S4INDATA,               _INPUT DATA                ?
                    S4INMODE,               _INPUT MODE                ?
                    S4INBORT,               _INPUT ABORT               ?
                    S4INTBORT,              _INPUT TERM ABORT          ?
                    S4LNDIS,                _LINE DISABLED             ?
                    S4LNDOWN,               _LINE DOWN                 ?
                    S4LNENAB,               _LINE ENABLED              ?
                    S4OCOMPL,               _OUTPUT COMPLETE           ?
                    S4ODATA,                _OUTPUT DATA REQUEST       ?
                    S4OMODE,                _OUTPUT MODE               ?
                    S4OBORT,                _OUTPUT ERROR ABORT        ?
                    S4OTBORT,               _OUTPUT TERMINAL ABORT     ?
                    S4OSTOP);               _STOP OUTPUT               ?
_ 
*     ACTION REQUESTS FOR TERMINAL I/O
? 
      S0TMTM     = (S5NIL,                  _NIL                       ?
                    S5ACKMSG,               _ACK                       ?
                    S5ENQMSG,               _ENQ                       ?
                    S5EOTMSG,               _EOT                       ?
                    S5NAKMSG,               _NAK                       ?
                    S5TTDMSG,               _TTD                       ?
                    S5WAKMSG,               _WACK                      ?
                    S5INPUT,                _INPUT                     ?
                    S5OUTDATA,              _OUTPUT DATA               ?
                    S5DISABLE,              _DISABLE LINE              ?
                    S5TERMIO);              _TERMINATE I/O             ?
_ 
*  PARAMETER FOR CE ERROR MESSAGE 
? 
      S0ERST     = (S2NONE, 
                    S2MINOR,                _MINOR ERROR               ?
                    S2SERIOUS);             _SERIOUS ERROR             ?
_ 
*  LEVEL 2 STATE ACTIVITY NEEDED
? 
      S0L2AT     = (S4NOSTATE,              _FLAG INDICATING STATE     ?
                                            _ PROCESSING REQUIRED      ?
                    S4STATE);               _FLAG INDICATING NOT       ?
                                            _ REQUIRED                 ?
_ 
*** CE COMMAND PACKET 
? 
      SACEERR = PACKED RECORD CASE X : INTEGER OF 
      2 : (SATYPE    : INTEGER;             _CE ERROR CODE             ?
           SALINO    : INTEGER;             _LINE NUMBER               ?
           SAEVENT   : B08BITS;             _EVENT                     ?
           SASP1     : B03BITS;             _DUMMY FIELD               ?
           SASTATE   : S0STST;              _STATE                     ?
           SASP2     : B08BITS;             _DUMMY FIELD               ?
           SACOUNT   : B08BITS);            _ERROR COUNT               ?
      3 : (SABSC2    : ARRAY [0..3]         _DUMMY FILED FOR MOVING    ?
                       OF INTEGER)
      END;
_$J+? 
*CALL,BSCLCBL2
_$J+? 
_***********************************************************************
*                                                                      *
*     BSC LEVEL 2 VARIABLES                                            *
*                                                                      *
***********************************************************************?
VAR 
  
      S2IDENT   : PACKED ARRAY [1..6]       _BSC LEVEL 2 IDENTIFIER    ?
                  OF CHAR;
      S2DBGI    : INTEGER;                  _INDEX TO NEXT WORKLIST    ?
      S2DBGA    : ARRAY [0..24] OF BWTIPWLE;_SAVED WORKLIST ENTRY ARRAY?
      S2EVENT   : INTEGER;                  _WORK CODE RECEIVED BY L2  ?
      S2LINO    : INTEGER;                  _LINE NUMBER               ?
      S2BUFFPTR : B0BUFPTR;                 _INPUT BUFFER POINTER      ?
      S2LCB     : BZLCBP;                   _LCB POINTER               ?
      S2LCBEXT  : 'S0LCBEXT;                _LCB EXTENTION POINTER     ?
      S2WTCOUNT : B08BITS;                  _WAIT COUNT FROM WORKLIST  ?
      S2ACK     : BOOLEAN;                  _ACK0 OR ACK1 WORK AREA    ?
      S2MLACT   : S0MLRQ;                   _INDEX TO ML WKLST ARRAY   ?
      S2L2ACT   : S0L2AT;                   _INDEX FOR L2 ACTIVITY     ?
      S2TERMACT : S0TMTM;                   _INDEX FOR CANNED MSG      ?
      S2ERR     : S0ERST;                   _INDEX FOR CE ERROR MSG    ?
      S2ERSTATE : S0STST;                   _ERROR STATE               ?
      S2TIMER   : S0TMTP;                   _INDEX FOR SET-RESET ARRAY ?
      S2CECMD   : SACEERR;                  _CE ERR MSG WORKAREA       ?
      S2CMDPKT  : NKINCOM;                  _I-O COMMAND PACKET        ?
      S2MLSV    : BWWORKLIST;               _DELAYED WL TO MAIN LEVEL  ?
      S2CECODES : ARRAY[S0ERST] OF INTEGER; _CE ERROR MSGS             ?
      S2TICKS   : ARRAY[S0TMTP] OF INTEGER; _TIMES IN 3.3 MS TICKS     ?
      S2TMCODE  : ARRAY[S0TMTP] OF INTEGER; _TIMER WORKCODES           ?
      S2MLWC    : ARRAY[S0MLRQ] OF INTEGER; _MAIN LEVEL WORKCODES      ?
      S2CMD     : ARRAY[S0TMTM] OF INTEGER; _TERMINAL COMMANDS         ?
      S2ENDOUT  : NKINCOM;                  _COMMAND PACKET FOR ENDOUT ?
_$J+? 
VALUE 
      S2IDENT    = (#BSCLV2#);              _BSC LEVEL 2 IDENTIFIER    ?
_ 
* * * TIME INCREMENTS FOR LEVEL 2 TIMERS
? 
      S2TICKS    = (0,                      _NO TIME                   ?
                    4,                      _DELAY TIME                ?
                    7,                      _END TIME                  ?
                    7,                      _ENQ TIME                  ?
                    7,                      _INPUT TIME                ?
                    7,                      _RESPONSE TIME             ?
                    4,                      _WACK TIME                 ?
                              1,            _EOT TIME                  ?
                              7);           _IDLE TIME                 ?
_ 
* * * MAIN LEVEL WORKCODES
? 
      S2MLWC     = (0,                      _S2NIL                     ?
                    S2INCOM,                _INPUT COMPLETE            ?
                    S2INDATA,               _INPUT DATA                ?
                    S2INMODE,               _INPUT MODE                ?
                    S2INBORT,               _INPUT ABORT               ?
                    S2INTBORT,              _INPUT TERM ABORT          ?
                    S2LNDIS,                _LINE DISABLED             ?
                    S2LNDOWN,               _LINE DOWN                 ?
                    S2LNENAB,               _LINE ENABLED              ?
                    S2OCOM,                 _OUTPUT COMPLETE           ?
                    S2ODATA,                _OUTPUT DATA               ?
                    S2OMODE,                _OUTPUT MODE               ?
                    S2OBORT,                _OUTPUT ABORT              ?
                    S2OTBORT,               _OUTPUT TERMINAL ABORT     ?
                    S2OSTOP);               _STOP OUTPUT               ?
_ 
* * * TERMINAL COMMANDS 
? 
      S2CMD   =    (NKINOUT,                _NIL                       ?
                    NKINOUT,                _ACK                       ?
                    NKINOUT,                _ENQ                       ?
                    NKINOUT,                _EOT                       ?
                    NKINOUT,                _NAK                       ?
                    NKINOUT,                _TTD                       ?
                    NKINOUT,                _WACK                      ?
                    NKINPT,                 _INPUT                     ?
                    NKINOUT,                _OUTPUT DATA               ?
                    NKDISL,                 _DISABLE LINE              ?
                    NKENDOUT);              _TERMINATE I/O             ?
_ 
* * * TIMER WORKCODES 
? 
S2TMCODE      = (S1TOINPS,                  _TIMEOUT FROM TIMER SET IN
                                              INPUT STATES (BSCL2I)    ?
                 S1TODELAY,                 _DELAY TIMEOUT             ?
                 S1TIEND,                   _INPUT END TIMEOUT         ?
                 S1TOENQ,                   _ENQ TIMEOUT               ?
                 S1TINPUT,                  _INPUT TIMEOUT             ?
                 S1TORESP,                  _RESPONSE TIMEOUT          ?
                 S1TWACK,                   _WACK TIMEOUT              ?
                              S1TOEOT,      _EOT TIMEOUT               ?
                              S1TOIDLE);    _IDLE TIMEOUT              ?
_ 
* * * ERROR CODES FOR CE ERROR MESSAGES 
? 
S2CECODES     = (CENTUSD,                   _NO ERROR                  ?
                 CEX7MINOR,                 _MINOR ERROR               ?
                 CEX7SERIOUS);              _SERIOUS ERROR             ?
S2ENDOUT = ($0B00,$0,$0); 
_$J+? 
_***********************************************************************
*                                                                      *
*                           PTS2ERROR                                  *
*                                                                      *
*                 BSC ERROR HANDLING ROUTINE                           *
*                                                                      *
***********************************************************************?
_R-,G-,I-?
_***********************************************************************
*                                                                      *
** OVERVIEW    THIS ROUTINE HANDLES A VARIETY OF UNEXPECTED            *
*             EVENTS WHICH ARE RECOGNIZED AS ERROR CONDITIONS          *
*             BY THE BSC TIP                                           *
*                                                                      *
** INPUT -    BZS2STATE                                                *
*             S2EVENT                                                  *
*             S2MLACT                                                  *
*             S2TIMER                                                  *
*             S2TERMACT                                                *
*                                                                      *
** CALLING PROGRAM -                                                   *
*             PTS2STATE                                                *
*             PTS2EVENT                                                *
*                                                                      *
** OUTPUT -   S2MLACT                                                  *
*             S2TERMACT                                                *
*                                                                      *
** EXTERNAL SUBROUTINES -                                              *
*                                                                      *
***********************************************************************?
PROCEDURE PTS2ERROR;                        _ERROR HANDLING ROUTINE    ?
VAR 
      S2PRCL    : BOOLEAN;                  _PROTOCOL FLAG             ?
      S2LMTCHK  : BOOLEAN;                  _FLAG FOR LIMIT CHECK      ?
BEGIN                                       _                          ?
_ 
* * *   INITIALIZE LOCAL VARIABLES
? 
  S2LMTCHK := TRUE;                         _NO LIMIT CHECKING         ?
  S2PRCL   := TRUE;                         _NO PROTOCOL ERROR         ?
  
  
  WITH S2LCBEXT' DO                         _POINTER TO LCB EXTENTION  ?
  BEGIN                                     _                          ?
    BZS2RETRY := BZS2RETRY + 1;             _INCREMENT RETRY COUNT     ?
    CASE S2EVENT OF                         _DETERMINE EVENT           ?
_ 
* * *   BAD DATA RECEIVED FROM TERMINAL 
? 
S2BAD:                                      _BAD DATA                  ?
  IF (BZS2STATE = S2INPACT)                 _IF INPUT WAS ACTIVE       ?
  & (BZS2ERTYPE = S2NOERR)                  _ AND NO ERR DETECTED      ?
  THEN                                      _THEN                      ?
  BEGIN                                     _                          ?
    BZS2ERTYPE := S2BADRSP;                 _SET ERR AS BAD DATA       ?
    S2PRCL     := FALSE;                    _SET PROTOCOL ERROR FLAG ON?
  END;   _S2BAD?
_ 
* * *   NAK RECEIVED FROM TERMINAL
? 
S2NAK:  
  IF (BZS2STATE " S2INPACT)                 _IF CURRENTLY OUTPUTTING   ?
  & (BZS2ERTYPE = S2NOERR)                  _ AND NO ERROR DETECTED    ?
  THEN                                      _THEN                      ?
  BEGIN 
    BZS2ERTYPE := S2BADRSP;                 _SET ERROR AS BAD RESPONSE ?
    S2PRCL     := FALSE;                    _SET PROTOCOL ERROR FLAG ON?
  END;   _S2NAK?
_ 
* * *   INPUT TIMEOUT 
? 
S1TOINPS:                                   _TIMER SET IN BSCL2I       ?
  IF BZS2ERTYPE = S2NOERR                   _IF 1ST TIME FOR TIMEOUT   ?
  THEN
  BEGIN                                     _ FLAGGED THEN MARK AS A   ?
    BZS2ERTYPE := S2TMOT;                   _ TIMEOUT                  ?
    S2ERSTATE  := BZS2STATE;                _ SAVE THE CURRENT STATE   ?
    BZS2STATE  := S2IDLE;                   _ SET STATE TO IDLE        ?
    S2ERR      := S2SERIOUS;                _ MARK ERROR AS SERIOUS    ?
    S2LMTCHK   := FALSE;                    _ DONT DO LIMIT CHKING     ?
    S2PRCL     := FALSE;                    _ NOT PROTOCOL ERROR       ?
  END;   _IF BZS2ERTYPE...? 
_ 
* * *   INPUT TIMEOUT 
? 
S1TINPUT:                                   _TIMER SET IN BSCLV2       ?
  BEGIN 
    BZS2INRETRY := BZS2INRETRY + 1; 
    S2LMTCHK    := FALSE;                   _DONT DO LIMIT OR PROTOCOL ?
    S2PRCL      := FALSE;                   _CHECKING                  ?
    IF BZS2INRETRY @ S2MAXINPTO             _ALLOW MAXIMUM INPUT TIME  ?
    THEN
    BEGIN                                   _OUTS TO OCCUR BEFORE ERROR?
      S2TERMACT := S5INPUT;                 _KEEP WAITING FOR INPUT    ?
      S2TIMER   := S2INTIM; 
    END 
    ELSE                                    _IF INRETRY > MAXWACKS     ?
    BEGIN                                   _ERROR HAS OCCURRED        ?
      S2ERR      := S2SERIOUS;              _IT IS A SERIOUS ERROR     ?
      BZS2ERTYPE := S2TMOT;                 _FOR CE ERROR MESSAGE      ?
      S2ERSTATE  := BZS2STATE;              _SAVE STATE AND TYPE OR ERR?
      BZS2STATE  := S2IDLE;                 _RESET STATE TO IDLE       ?
      S2MLACT    := S4INBORT;               _ALERT MAIN LEVEL TO BRING ?
      S2TERMACT  := S5EOTMSG;               _LINE DOWN AND SHIP EOT    ?
    END;   _IF BZS2INRETRY...?
  END;   _S1TINPUT? 
_ 
* * *   OUTPUT TIMEOUT
? 
S1TORESP: 
  IF BZS2ERTYPE = S2NOERR                   _IF 1ST TIME FOR TIMEOUT   ?
  THEN                                      _THEN                      ?
  BEGIN                                     _                          ?
    BZS2ERTYPE := S2TMOT;                   _MARK AS TIMEOUT           ?
    S2PRCL     := FALSE;                    _SET PROTOCOL ERROR FLAG   ?
  END;   _S1TORESP? 
  
END;   _CASE S2EVENT? 
_ 
* * *   CHECK FOR PROTOCOL ERROR
? 
IF S2PRCL                                   _IF PROTOCOL ERROR         ?
THEN                                        _THEN                      ?
BEGIN 
  BZS2ERTYPE := S2PROTOCOL;                 _MARK IT AS SUCH           ?
_ 
* * *   CHECK IF MINOR ERROR HAS OCCURRED TEN TIMES 
? 
  IF (BZS2MINOR = 0)                        _IF FIRST TIME             ?
   ! (BZS2RETRY > (BZS2MINOR + 10))         _OR TENTH TIME             ?
  THEN                                      _THEN                      ?
  BEGIN 
    BZS2MINOR := BZS2RETRY;                 _SET NEW MINOR COUNT       ?
    S2ERR     := S2MINOR;                   _CE ERROR CODE = MINOR     ?
  END;   _IF (BZS2MINOR...? 
END;   _IF S2PRCL?
_ 
* * *   CHECK FOR RETRY LIMIT EXCEEDED
? 
IF S2LMTCHK                                 _IF CHECKING IS REQUIRED   ?
THEN
BEGIN 
  IF BZS2LIMIT = 0                          _IF RETRY LIMIT NOT SET    ?
  THEN                                      _THEN                      ?
  BEGIN 
    IF BZS2RETRY > 60                       _IF WEVE TRIED 60 TIMES    ?
    THEN                                    _THEN                      ?
    BEGIN 
      S2ERSTATE := BZS2STATE;               _SET CE ERROR STATE        ?
      S2ERR     := S2SERIOUS;               _CE ERROR CODE = SERIOUS   ?
      BZS2RETRY := 0;                       _START COUNTING MINOR      ?
      BZS2MINOR := 0;                       _ ERRORS ALL OVER AGAIN    ?
    END;
  END 
  ELSE                                      _BZS2LIMIT " 0             ?
    IF BZS2RETRY > BZS2LIMIT                _IF WEVE EXCEEDED LIMIT    ?
    THEN                                    _THEN                      ?
    BEGIN 
      S2ERSTATE := BZS2STATE;               _SET CE ERROR STATE        ?
      S2ERR     := S2SERIOUS;               _CE ERROR CODE = SERIOUS   ?
    END;   _IF BZS2RETRY > ...? 
END;   _IF S2LMTCHK?
_ 
* * *   ABORT OUTPUT IF SERIOUS ERROR 
? 
IF (BZS2STATE = S2OUTRSP)                   _IF CURRENTLY OUTPUTTING   ?
 & (S2ERR     = S2SERIOUS)                  _ AND SERIOUS ERROR        ?
THEN
BEGIN 
  BZS2STATE := S2IDLE;
  S2MLACT   := S4OBORT;                     _TELL ML OUTPUT ABORTED    ?
  S2TERMACT := S5EOTMSG;                    _SEND EOT TO TERMINAL      ?
END;  _IF BZS2STATE = S2OUTRSP...?
  
END;   _WITH S2LCBEXT?
  
  
END;   _PROCEDURE PTS2ERROR?
_$J+? 
_***********************************************************************
*                                                                      *
*                             PTS2EVENT                                *
*                                                                      *
*               PROCESSES LINE STATE INSENSITIVE EVENTS                *
*                                                                      *
***********************************************************************?
_R-,G-,I-?
_***********************************************************************
*                                                                      *
** OVERVIEW - THIS PROCEDURE HANDLES THE EVENTS WHICH CAUSE SIMILAR    *
*             RESULTS REGARDLESS OF THE CURRENT STATE.  THEY INCLUDE   *
*             S3CLEAR                                                  *
*             S3ENA                                                    *
*             S3DIS                                                    *
*             S3LNDOWN                                                 *
*             S3INRESET                                                *
*             S3OUTDATA                                                *
*             S3OUTRESET                                               *
*             S2EOT                                                    *
*             S2LNEOT                                                  *
*             S1TINPUT                                                 *
*             S1TIEND                                                  *
*             S1TWACK                                                  *
*             S1TWACK                                                  *
*             S1TODELAY                                                *
*             S1TORESP                                                 *
*                                                                      *
** INPUTS -   S2EVENT                                                  *
*             S2LCB                                                    *
*             BZS2STATE                                                *
*             S2BUFFER                                                 *
*             S2WTCOUNT                                                *
*                                                                      *
** CALLING PROGRAM -                                                   *
*             PTS2BSC                                                  *
*                                                                      *
** OUTPUT -   S2TERMACT                                                *
*             S2L2ACT                                                  *
*             BZS2STATE                                                *
*             S2MLACT                                                  *
*             BZS2ETX                                                  *
*                                                                      *
** EXTERNAL SUBROUTINES -                                              *
*             PBTMRSRVS                                                *
*             PBREL1BF                                                 *
*                                                                      *
***********************************************************************?
PROCEDURE PTS2EVENT;                        _EVENT PROCESSOR 2         ?
BEGIN 
WITH S2LCB', S2LCBEXT' DO                   _WITH BSC LCB AND BSC      ?
  BEGIN                                     _ LCB EXTENSION            ?
  S2L2ACT := S4STATE; 
  CASE S2EVENT OF 
  
_***********************************************************************
*                                                                      *
*     CLEAR RESETS THE STATE TO IDLE FOR NTS TESTING                   *
*                                                                      *
***********************************************************************?
    S3CLEAR:  
      BEGIN 
      BZS2STATE := S2IDLE;
      S2TERMACT := S5EOTMSG;
      S2MLACT := S4LNENAB;
      S2L2ACT := S4NOSTATE; 
      END; _S3CLEAR?
  
_***********************************************************************
*                                                                      *
*     ENABLE LINE REQUEST FROM MAIN LEVEL                              *
*                                                                      *
***********************************************************************?
S3ENA:                                      _BSC ENABLE LINE           ?
  BEGIN 
    BZTOUTPUT := TRUE;                      _SET TERM OUTPUT ON T/O    ?
    BZTINPUT  := TRUE;                      _SET TERM INPUT ON T/O     ?
    BZS2STATE := S2IDLE;                    _INITIALIZE L2 STATE       ?
    BZS2LIMIT := BZRETRY;                   _INITIALZE RETRY LIMIT     ?
    S2TERMACT := S5INPUT;                   _ALLOW INPUT ON LINE       ?
    S2MLACT   := S4LNENAB;                  _TELL ML LINE ENABLED      ?
    S2L2ACT   := S4NOSTATE;                 _NO FURTHER PROC REQD      ?
  END;   _S3ENA?
  
_***********************************************************************
*                                                                      *
*     DISABLE LINE COMMAND FROM MAIN LEVEL                             *
*                                                                      *
***********************************************************************?
S3DIS:                                      _DISABLE LINE              ?
  BEGIN 
  IF BZS2STATE = S2DOWN                     _IF THE LINE IS DOWN       ?
  THEN                                      _THEN                      ?
    BEGIN                                   _TELL MAIN LEVEL THE       ?
    S2MLACT := S4LNDIS;                     _ LINE IS DIISLED          ?
    S2TERMACT := S5DISABLE;                 _AND DISABLE THE LINE      ?
    END  _IF BZS2STATE...?                  _REQUEST                   ?
  ELSE                                      _ELSE IF STATE IS NOT      ?
    BEGIN                                   _ DOWN THEN                ?
    IF BZS2STATE " S2DWNHRD                 _IF THE LINE IS NOT ALREADY?
                                            _ DOWN DUE TO A HARD ERROR ?
    THEN                                    _ THEN SELECT TERMINATE    ?
      S2TERMACT := S5TERMIO;                _ I/O REQUEST              ?
    BZS2STATE := S2DWNDIS;                  _SET THE STATE TO DISABLED ?
    END; _IF BZS2STATE...?                  _ BY HOST                  ?
  S2L2ACT := S4NOSTATE;                     _NO FURTHER L2 STATE       ?
  END; _S3DIS?                              _ PROCESSING NEEDED        ?
  
_***********************************************************************
*                                                                      *
*     HARD ERROR NOTIFICATION FROM MUX VIA MAIN LEVEL                  *
*                                                                      *
***********************************************************************?
S3LNDOWN:                                   _HARD ERROR                ?
  BEGIN 
  IF NOT ((BZS2STATE = S2DOWN)              _ IF LINE IS NOT ALREADY   ?
    !  (BZS2STATE = S2DWNHRD)               _ DOWN                     ?
    !  (BZS2STATE = S2DWNDIS))
  THEN
    BEGIN 
    BZS2STATE := S2DWNHRD;                  _INDICATE A HARD ERROR     ?
    S2TERMACT := S5TERMIO;                  _ TERMINATE I/O REQUEST    ?
    END; _IF NOT ((BZS2STATE...?
  S2L2ACT := S4NOSTATE;                     _NO L2 STATE PROCESSING    ?
  END; _S3LNDOWN?                           _ REQUIRED                 ?
  
_***********************************************************************
*                                                                      *
*     INPUT RESET COMMAND FROM MAIN LEVEL                              *
*                                                                      *
***********************************************************************?
S3INRESET:                                  _INPUT RESET               ?
  BEGIN 
  IF BZS2STATE IN [S2INPMOD,S2INPACT,S2INPDLY] _IF INPUT IN PROGRESS   ?
  THEN                                      _INDICATE AN ABORT IS IN   ?
  BEGIN                                     _ PROGRESS AND WAIT FOR    ?
    BZS2STATE := S2INP1ABRT;                _ NEXT INPUT TO COMPLETE   ?
    S2L2ACT   := S4NOSTATE;                 _NO FURTHER PROCESSING REQD?
    S2TIMER   := S2INTIM;                   _SET TIMER IF NO INPUT     ?
  END;  _IF (BZS2STATE...?
  END; _S3INRESET?
  
_***********************************************************************
*                                                                      *
*     OUTPUT DATA REQUEST FROM MAIN LEVEL                              *
*                                                                      *
***********************************************************************?
S3OUTDATA:                                  _OUTPUT DATA               ?
  BEGIN 
  BZS2TTD := 0;                             _ CLEAR NO. OUTPUT DELAYS  ?
  IF (BZS2STATE = S2OUTTRN)                 _IF OUTPUT IS ACTIVE IN THE?
    !  (BZS2STATE = S2OUTDLY)               _ LINE                     ?
  THEN                                      _THEN PROCESS THE OUTPUT   ?
    BEGIN                                   _ DATA                     ?
    BZS2OUTDATA := S2BUFFPTR;               _OUTPUT BUFFER POINTER     ?
    BZS2ETX     := S2BUFFPTR'.BFSETX;       _ETX TRANSMISSION BFR FLAG ?
    BZS2ERTYPE  := S2NOERR;                 _CLEAR ERROR INDICATORS    ?
    BZS2RETRY   := 0; 
    BZS2MINOR   := 0; 
    END; _IF (BZS2STATE...? 
  END; _S3OUTDATA?
  
_***********************************************************************
*                                                                      *
*     OUTPUT RESET REQUEST FROM MAIN LEVEL                             *
*                                                                      *
***********************************************************************?
S3OUTRESET:                                 _OUTPUT RESET              ?
  BEGIN 
  CASE BZS2STATE OF                         _IF OUTPUT ACTIVE BUT NOT  ?
    S2OUTTRN, S2OSTPD:                      _ CURRENTLY IN PROGRESS    ?
    BEGIN 
      BZS2STATE := S2IDLE;                  _SET STATE TO IDLE         ?
      S2TERMACT := S5EOTMSG;                _SEND EOT TO TERMINAL      ?
      S2MLACT   := S4OBORT;                 _TELL ML OUTPUT ABORTED    ?
    END;   _S2OUTTRN? 
_ 
* IN OUTPUT MODES (WAITING FOR REPLY FROM TERMINAL) 
? 
    S2OUTBID, S2OUTDLY, S2OUTHLD, S2OUTRSP: _IF OUTPUT IS CURRENTLY    ?
    BEGIN 
      BZS2STATE := S2OUT1ABRT;              _ ACTIVE WAIT FOR OUTPUT   ?
      S2TIMER   := S2RSPTIM;                _SET RESPONSE TIMER        ?
    END;   _S2OUTBID,S2OUTDLY...? 
    END; _CASE BZS2STATE?                   _ TO COMPLETE BEFORE       ?
  S2L2ACT := S4NOSTATE;                     _ SENDING EOT              ?
  END; _S3OUTRESET?                         _NO FURTHER L2 STARE       ?
                                            _ PROCESSING NEEDED        ?
  
_***********************************************************************
*                                                                      *
*     EOT OR DLE EOT INPUT FROM TERMINAL                               *
*                                                                      *
***********************************************************************?
S2EOT, S2LNEOT:                             _EOT OR DLE EOT            ?
  BEGIN 
  CASE BZS2STATE OF 
    S2INPMOD, S2INPRQS, S2INPACT,           _IF TERMINAL ABNORMALLY    ?
      S2INPDLY, S2INPSTOP, S2INP1ABRT:      _ ENDED ITS INPUT THEN     ?
      BEGIN                                 _ TELL MAIN LEVEL          ?
      S2MLACT := S4INTBORT; 
      END; _S2INPMOD? 
    S2INPEND :  
      S2MLACT := S4INCOMPL;                 _TELL MAIN LEVEL INPUT IS  ?
                                            _ COMPLETE                 ?
    S2OUTBID, S2OUTDLY, S2OUTHLD,           _IF TERMINAL ABNORMALLY    ?
      S2OUTRSP, S2OUT1ABRT:                 _ ENDED ITS OUTPUT THEN    ?
      BEGIN                                 _ TELL MAIN LEVEL          ?
      S2MLACT := S4OTBORT;
      END; _S2OUTBID...?                    _OTHERWISE IGNORE THE EOT?
    END; _CASE BZS2STATE? 
  BZS2STATE := S2IDLE;                     _SET STATE TO IDLE        ?
  S2TERMACT := S5INPUT;                    _ALLOW INPUT              ?
  S2L2ACT   := S4NOSTATE;                  _NO FURTHER LEVL2 ACTIVITY?
  END; _S2EOT,S23LNEOT? 
  
_***********************************************************************
*                                                                      *
*     INPUT ENDED, BAD DATA, BUFFER THRESHOLD EXCEEDED OR TTD          *
*                                                                      *
***********************************************************************?
NMINEND,S2BAD,S2BUF,S2TTD:  
  BEGIN 
    PBRELZRO(S2BUFFPTR,BEDBSIZE);           _RELEASE THE RECEIVED      ?
  END; _S2BAD, S2BUF?                       _ BUFFERS IF ANY           ?
  
_***********************************************************************
*                                                                      *
*     TIMEOUT AFTER EOT SENT DOWNLINE                                  *
*                                                                      *
***********************************************************************?
S1TOEOT:  
  BEGIN 
    S2L2ACT := S4NOSTATE;                   _NO PTS2STATE PROCESSING   ?
  END; _S1TOEOT?
  
_***********************************************************************
*                                                                      *
*     TIMEOUT FROM TIMER SET IN INPUT STATE PROGRAM (BSCL2I)           *
*                                                                      *
***********************************************************************?
S1TOINPS: 
  BEGIN 
    PTS2ERROR;                              _CALL ERROR ROUTINE        ?
    S2TERMACT := S5INPUT;                   _ALLOW TERMINAL TO INPUT   ?
    S2L2ACT := S4NOSTATE;                   _NO PTS2STATE PROCESSING   ?
  END; _S1TOINPS? 
END; _CASE S2EVENT OF?
END; _WITH S2LCB...?
END; _PROCEDURE PTS2EVENT?
_$J+? 
_***********************************************************************
*                                                                      *
*                             PTS2STATE                                *
*                                                                      *
*              PROCESS LINE STATE SENSITIVE EVENTS                     *
*                                                                      *
***********************************************************************?
_R-,G-,I-?
_***********************************************************************
*                                                                      *
** OVERVIEW - THIS PROCEDURE HANDLES EVENTS WHICH REQUIRE ACTIONS      *
*             BASED ON THE STATE OF THE PROGRAM                        *
*                                                                      *
** INPUTS -   S2EVENT                                                  *
*             S2LCB                                                    *
*             BZS2STATE                                                *
*             S2BUFFER                                                 *
*                                                                      *
** CALLING PROGRAM -                                                   *
*             PTS2BSC                                                  *
*                                                                      *
** OUTPUT -   S2L2ACT                                                  *
*             BZS2STATE                                                *
*             S2MLACT                                                  *
*             S2TERMACT                                                *
*             BZS2ETX                                                  *
*             BZS2ACK                                                  *
*             S2TIMER                                                  *
*                                                                      *
** EXTERNAL SUBROUTINES -                                              *
*             PTS2ERROR                                                *
*                                                                      *
***********************************************************************?
PROCEDURE PTS2STATE;                        _PROCESS EVENTS BASED ON   ?
BEGIN 
WITH S2LCB', S2LCBEXT' DO                   _ THE CURRENT STATE OF THE ?
  BEGIN                                     _ PROGRAM                  ?
  CASE BZS2STATE OF 
_$J+? 
_***********************************************************************
*                                                                      *
*     IDLE STATE                                                       *
*                                                                      *
***********************************************************************?
S2IDLE: 
  BEGIN 
  IF S2EVENT = S3OUTQEST                    _IF THERE IS OUTPUT FOR THE?
  THEN                                      _ TERMINAL THEN BID FOR THE?
    BEGIN                                   _ LINE, SET UP TIMER AND   ?
    BZS2STATE := S2OUTBID;                  _ WAIT FOR A RESPONSE      ?
    S2TERMACK := S5ENQMSG;
    S2TIMER := S2ENQTIM;
    S2ENDOUT.NKLINO := S2LINO;              _TERMINATE OUTPUT ON THIS  ?
    PBCOIN(S2ENDOUT);                       _LINE BEFORE LINE BID      ?
    BZS2ERTYPE := S2NOERR;                  _CLEAR ERRORS              ?
    BZS2MINOR := 0; 
    BZS2RETRY := 0; 
    END _IF S2EVENT = S2OUTRQS? 
  ELSE                                      _OTHERWISE IF TERMINAL     ?
    IF S2EVENT = S2ENQ                      _ HAS INPUT RESPOND WITH   ?
    THEN                                    _ ACK0, UPDATE ACK SENSE,  ?
    BEGIN 
      BZS2STATE  := S2INPMOD;               _ STATE = INPUT MODE       ?
      S2TERMACT  := S5ACKMSG;               _ SEND ACK TO TERMINAL     ?
      BZS2ACK    := S6ACK0;                 _ INITIALIZE ACK SENSE     ?
      S2MLACT    := S4INMODE;               _ TELL ML INPUT MODE       ?
      S2TIMER    := S2INTIM;                _ SET INPUT TIMER ON       ?
  
      BZS2ERTYPE := S2NOERR;                _ CLEAR ALL ERROR FLAGS    ?
      BZS2MINOR  := 0;                      _ AND COUNTERS             ?
      BZS2RETRY  := 0;                      _                          ?
      BZS2INRETRY := 0;                     _RESET INPUT RETRY COUNT   ?
    END _IF S2EVENT = S2ENQ?
    ELSE                                    _OTHERWISE                 ?
      IF S2EVENT = S2ACK0                   _IF WE RECEIVE ACK0        ?
      THEN                                  _WHILE IDLE                ?
      BEGIN 
        S2TERMACK := S5EOTMSG;              _SEND AN EOT               ?
      END _IF S2EVENT = S2ACK0? 
      ELSE                                  _OTHERWISE IF ENQ TIMER HAS?
        IF S2EVENT = S1TOENQ                _EXPIRED WHILE IDLE THEN WE?
        THEN                                _ARE IN IDLE TIMEOUT       ?
        BEGIN 
          BZS2RETRY := BZS2RETRY + 1;       _COUNT HOW MANY ENQS SENT  ?
          IF BZS2RETRY > S2MAXENQS          _IS GREATER THAN LIMIT     ?
          THEN                              _THEN THE TERMINAL HAS GONE?
          BEGIN                             _SEND INPUT ABORT WORKLIST ?
            S2MLACT := S4INBORT;            _TO MAIN LEVEL TO TAKE DOWN?
          END                               _LINE CLEANLY              ?
          ELSE _IF BZS2RETRY? 
          BEGIN                             _OTHERWISE TRY TO WAKE UP  ?
            S2TERMACK := S5ENQMSG;          _THE TERMINAL AGAIN BY     ?
            S2TIMER := S2ENQTIM;            _SENDING AN ENQ            ?
          END 
        END _IF S2EVENT = S1TOENQ?
        ELSE                                _IF THE TERMINAL HAS BEEN  ?
          IF S2EVENT = S1TOIDLE             _IDLE FOR 20 SECONDS THEN  ?
          THEN
          BEGIN 
            BZS2RETRY := 0;                 _COUNTER FOR ENQS SENT     ?
            S2TERMACK := S5ENQMSG;          _SEND AN ENQ MESSAGE       ?
            S2TIMER := S2ENQTIM;            _SET TIMER FOR THIS MESSAGE?
          END; _IF S2EVENT = S1TOIDLE?
  END; _S2IDLE? 
  
_***********************************************************************
*                                                                      *
*     OUTPUT BID STATE                                                 *
*                                                                      *
***********************************************************************?
S2OUTBID: 
  CASE S2EVENT OF 
_ 
* ENQ - TERMINAL BIDDING FOR LINE 
? 
    S2ENQ:                                  _IF TERMINAL IS BIDDING    ?
      BEGIN                                 _ FOR LINE                 ?
      S2ENDOUT.NKLINO := S2LINO;            _ TERMINATE OUTPUT ON THIS ?
      PBCOIN(S2ENDOUT);                     _ LINE BEFORE RESPONDING   ?
      IF BZS2PRIMARY                        _THEN IF PRIMARY STATION   ?
      THEN                                  _ SEND ENQ MESSAGE AND     ?
        BEGIN                               _ SET TIMER                ?
        S2TERMACT := S5ENQMSG;
        S2TIMER   := S2ENQTIM;
        END _IF BZS2PRIMARY?
      ELSE                                  _OTHERWISE TURN LINE       ?
        BEGIN                               _ AROUND TO ACCEPT INPUT   ?
        BZS2STATE := S2INPMOD;
        S2TERMACT := S5ACKMSG;
        S2MLACT := S4INMODE;
        S2TIMER := S2INTIM; 
        BZS2ACK := S6ACK0;
        BZS2ERTYPE := S2NOERR;
        BZS2RETRY := 0; 
        BZS2MINOR := 0; 
        BZS2INRETRY := 0;                   _RESET INPUT RETRY COUNT   ?
        END; _IF BZS2PRIMARY? 
      END; _S2ENQ?
_ 
* ACK0 - CORRECT RESPONSE FROM TERMINAL 
? 
    S2ACK0:                                 _IF WE GET THE CORRECT     ?
      BEGIN                                 _ RESPONSE FROM THE        ?
      BZS2STATE := S2OUTTRN;                _ TERMINAL THEN PREPARE    ?
      S2MLACT := S4OMODE;                   _ TO OUTPUT DATA, TELL     ?
      S2TIMER := S2DLYTIM;                  _ MAIN LEVEL TO PROCEED    ?
      BZS2ACK := S6ACK0;
      BZS2ERTYPE := S2NOERR;
      BZS2RETRY := 0; 
      BZS2MINOR := 0; 
      END; _S2ACK0? 
  
_ 
* NAK, WACK - TERMINAL WON'T ACCEPT DATA
? 
    S2NAK,                                  _IF TERMINAL WONT ACCEPT   ?
    S2WACK:                                 _ DATA RIGHT NOW THEN,     ?
    BEGIN                                   _ GIVE UP FOR NOW.         ?
      BZS2STATE := S2IDLE;                  _ SET STATE TO IDLE        ?
      S2MLACT   := S4OTBORT;                _ TELL ML OF ABORT         ?
      S2TERMACT := S5EOTMSG;                _ ALLOW TERMINAL TO INPUT  ?
    END;  _S2NAK, S2WACK? 
  
_ 
* ACK1 - WRONG ACK FROM TERMINAL
? 
     S2ACK1:  
      BEGIN 
        BZS2STATE := S2IDLE;                _SET STATE TO IDLE        ? 
        S2TERMACT := S5EOTMSG;              _SEND EOT TO TERMINAL     ? 
        S2MLACT   := S4OBORT;               _TELL ML OUTPUT ABORTED   ? 
      END;
  
_ 
* TTD, RVI, BAD DATA, BUFFER THRESHOLD, ENQ 
? 
     S2TTD,S2RVI, 
      S2BAD, S2BUF:                         _ ARE RECEIVED THEN        ?
      BEGIN 
      S2TERMACT := S5ENQMSG;                _ SEND HIM ENQ            ? 
      S2TIMER := S2ENQTIM;
      PTS2ERROR;
      END; _S2ACK1'...? 
  
_ 
*   ENQ TIME OUT
? 
     S1TOENQ:                               _EXPIRED WHILE IDLE THEN WE?
      BEGIN 
      BZS2RETRY := BZS2RETRY + 1;           _COUNT HOW MANY ENQS SENT  ?
      IF BZS2RETRY > S2MAXENQS              _IF GREATER THAN LIMIT     ?
       THEN                                 _THEN THE TERMINAL IS GONE ?
        BEGIN                               _SEND INPUT ABORT WORKLIST ?
        S2MLACT := S4INBORT;                _TO MAIN LEVEL TO TAKE THE ?
        END                                 _LINE DOWN CLEANLY         ?
       ELSE _IF BZS2RETRY?
        BEGIN                               _OTHERWISE TRY TO WAKE UP  ?
        S2TERMACK := S5ENQMSG;              _THE TERMINAL AGAIN BY     ?
        S2TIMER := S2ENQTIM;                _SENDING AN ENQ            ?
        END 
      END;
  END; _CASE S2EVENT OF?
  
_***********************************************************************
*                                                                      *
*     INPUT MODE STATE                                                 *
*                                                                      *
***********************************************************************?
S2INPMOD: 
  CASE S2EVENT OF 
_ 
* ENQ 
? 
    S2ENQ:  
      BEGIN                                 _IF TERMINAL DID NOT       ?
      S2TERMACT := S5ACKMSG;                _GET LAST ACK CORRECTLY    ?
      S2TIMER := S2INTIM;                   _RESEND IT                 ?
      BZS2INRETRY := 0;                     _RESET INPUT RETRY COUNT   ?
      END; _S2ENQ?
_ 
* ETX 
? 
    S2ETX:                                  _IF END OF INPUT SEND      ?
      BEGIN                                 _ DATA TO MAIN LEVEL       ?
      BZS2STATE := S2INPRQS;                _ AND TELL TERMINAL        ?
      S2MLACT := S4INDATA;                  _ TO INPUT                 ?
      BZS2ETX := TRUE;
      END; _S2ETX?
_ 
* ETB 
? 
    S2ETB:                                  _IF END OF BLOCK SEND      ?
      BEGIN                                 _ DATA TO MAIN LEVEL       ?
      BZS2STATE := S2INPRQS;                _ AND TELL TERMINAL        ?
      S2MLACT := S4INDATA;                  _ INPUT                    ?
      BZS2ETX := FALSE; 
      END; _S2ETB?
_ 
* TTD 
? 
    S2TTD:                                  _IF TEMPORARY TEXT DELAY   ?
      BEGIN 
      S2TERMACT := S5NAKMSG;                _ SEND NAK TO TERMINAL     ?
      S2TIMER := S2INTIM;                   _ AND START TIMER          ?
      BZS2INRETRY := 0;                     _RESET INPUT RETRY COUNT   ?
      END; _S2TTD?
_ 
* BUFFER THRESHOLD EXCEEDED 
? 
    S2BUF:  
    BEGIN                                   _IF OK TO INPUT THEN       ?
      S2TERMACT := S5INPUT;                 _ ALLOW TERMINAL TO INPUT  ?
      S2TIMER   := S2INTIM;                 _ AND SET INPUT TIMER      ?
    END; _S2BUF?
_ 
* BAD DATA BLOCK
? 
     S2BAD: 
      BEGIN 
        S2TERMACT := S5NAKMSG;              _SEND NAK TO TERMINAL     ? 
        S2TIMER   := S2INTIM; 
        PTS2ERROR;                          _CALL ERROR ROUTINE       ? 
      END;
_ 
* UNEXPECTED EVENTS 
? 
    S2ACK0, S2ACK1, S2WACK, S2NAK, S2RVI,   _IF UNEXPECTED EVENT CALL  ?
      S1TINPUT:                             _ERROR HANDLING ROUTINE   ? 
      BEGIN 
      S2TERMACT := S5INPUT;                 _SET TERMINAL TO INPUT    ? 
      S2TIMER   := S2INTIM;                 _SET INPUT TIMER           ?
      PTS2ERROR;                            _ CALL ERROR ROUTINE       ?
      END; _S2ACK0...?
    END; _CASE S2EVENT OF?
  
_***********************************************************************
*                                                                      *
*     INPUT REQUEST STATE                                              *
*                                                                      *
***********************************************************************?
S2INPRQS: 
  CASE S2EVENT OF 
_ 
* INPUT GRANT 
? 
    S3INGRANT:                              _IF MAIN LEVEL IS READY    ?
      BEGIN                                 _ FOR INPUT                ?
      IF BZS2ETX                            _IF END OF TEXT            ?
      THEN                                  _THEN                      ?
        BEGIN 
        BZS2STATE := S2INPEND;              _INPUT HAS TERMINATED      ?
        S2TIMER := S2ENDTIM;
        END _IF BZS2ETX?
      ELSE                                  _OTHERWISE (ETX NOT SET)   ?
        BEGIN 
        BZS2STATE := S2INPACT;              _INPUT IS ACTIVE           ?
        S2TIMER := S2INTIM; 
        END; _IF BZS2ETX? 
      BZS2ACK := NOT BZS2ACK;               _UPDATE ACK SENSE          ?
      S2TERMACK := S5ACKMSG;                _TELL TERMINAL ACK         ?
      BZS2ERTYPE := S2NOERR;                _CLEAR ERROR TYPE          ?
      BZS2RETRY := 0;                       _ RETRY COUNT AND          ?
      BZS2MINOR := 0;                       _ MINOR CUOUNT             ?
      END; _S2INGRNT? 
_ 
* INPUT RESET 
? 
    S3INRESET:                              _IF EVENT IS INPUT RESET   ?
    BEGIN 
      BZS2STATE := S2IDLE;                  _SET STATE TO IDLE         ?
      S2TERMACT := S5EOTMSG;                _SEND EOT TO TERMINAL      ?
      S2MLACT   := S4INBORT;                _TELL ML INPUT ABORTED     ?
    END;   _S3INRESET?
    END; _CASE S2EVENT OF?
  
_***********************************************************************
*                                                                      *
*     INPUT ACTIVE STATE                                               *
*                                                                      *
***********************************************************************?
S2INPACT:                                   _INPUT ACTIVE              ?
  CASE S2EVENT OF 
_ 
* INPUT STOP
? 
    S3ISTOP:                                _IF MAIN LEVEL IS REQUEST- ?
      BZS2STATE := S2INPDLY;                _ ING THAT INPUT BE STOPPED?
                                            _ REMEMBER FOR NEXT INPUT  ?
_ 
* ENQ 
? 
    S2ENQ:                                  _IF LAST REPLY LOST THEN   ?
    BEGIN                                   _OUR LAST ACK WAS LOST     ?
      S2TERMACT := S5ACKMSG;                _ SO SEND IT AGAIN         ?
      S2TIMER   := S2INTIM;                 _ AND SET INPUT TIMER      ?
      BZS2INRETRY := 0;                     _RESET INPUT RETRY COUNT   ?
    END; _S2ENQ?
_ 
* ETX 
? 
    S2ETX:                                  _IF INPUT IS THROUGH       ?
      BEGIN 
      BZS2STATE := S2INPEND;                _ REMBER                   ?
      S2MLACT := S4INDATA;                  _TELL MAIN LEVEL WE HAVE   ?
      BZS2ACK := NOT BZS2ACK;               _INPUT AND SEND ACK TO     ?
                                            _TERMINAL                  ?
      S2TERMACT := S5ACKMSG;                _TELL TERMINAL ACK         ?
      S2TIMER := S2ENDTIM;                  _START END TIMER           ?
                                            _CLEAR LCB ERROR COUNTS    ?
      BZS2ERTYPE := S2NOERR;
      BZS2RETRY := 0; 
      BZS2MINOR := 0; 
      END; _S2ETX?
_ 
* ETB 
? 
    S2ETB:                                  _IF END OF BLOCK           ?
      BEGIN                                 _THEN TELL MAIN LEVEL      ?
      S2MLACT := S4INDATA;                  _ WE HAVE INPUT DATA       ?
      BZS2ACK := NOT BZS2ACK;               _UPDATE ACK SENSE          ?
      S2TERMACT := S5ACKMSG;                _TELL TERMINAL ACK         ?
      S2TIMER := S2INTIM;                   _START INPUT TIMER         ?
      BZS2ERTYPE := S2NOERR;                _CLEAR LCB ERROR COUNTS    ?
      BZS2RETRY := 0; 
      BZS2MINOR := 0;                       _MINOR PROTOCOL ERROR      ?
      BZS2INRETRY := 0;                     _RESET INPUT RETRY COUNT   ?
      END; _S2ETB:? 
_ 
* TTD 
? 
    S2TTD:                                  _IF TERMINAL REQUESTS A    ?
      BEGIN                                 _ DELAY THEN ACKNOWLEDGE   ?
      S2TERMACT := S5NAKMSG;                _ WITH NAK                 ?
      S2TIMER := S2INTIM;                   _START INPUT TMER          ?
      BZS2INRETRY := 0;                     _RESET INPUT RETRY COUNT   ?
      END; _S2TTD?
_ 
* WACK TIMER EXPIRATION 
? 
    S1TWACK:                                _IF WACK TIMER HAS EXPIRED ?
      BEGIN                                 _THEN                      ?
      S2TERMACT := S5ACKMSG;                _TELL TERMINAL ACK         ?
      S2TIMER := S2INTIM;                   _START INPUT TIMER         ?
      END; _S2WACK? 
_ 
* BUFFER THRESHOLD EXCEEDED 
? 
    S2BUF:                                  _IF EVENT IS BUFFER THEN   ?
                                            _ THRESHOLD                ?
    BEGIN 
      S2TERMACT := S5INPUT;                 _ ALLOW TERMINAL TO INPUT  ?
      S2TIMER   := S2INTIM;                 _ AND SET INPUT TIMER      ?
    END; _S2BUF?
_ 
* BAD DATA BLOCK
? 
    S2BAD:  
      BEGIN 
        S2TERMACT := S5NAKMSG;              _ TELL TERMINAL NAK       ? 
        S2TIMER   := S2INTIM; 
        PTS2ERROR;                          _ CALL ERROR ROUTINE      ? 
      END;
_ 
* UNEXPECTED EVENT
? 
    S2ACK0, S2ACK1, S2WACK,                 _IF EVENT IS UNEXPECTED   ? 
      S2NAK, S2RVI, S1TINPUT:               _THEN                      ?
      BEGIN 
      S2TERMACT := S5INPUT;                 _ TURN INPUT BACK ON      ? 
      PTS2ERROR;                            _ CALL ERROR ROUTINE       ?
      END; _S2BAD...?                       _ AND TELL TERMINAL INPUT  ?
  END; _CASE S2EVENT OF?
  
_***********************************************************************
*                                                                      *
*     INPUT DELAY STATE                                                *
*                                                                      *
***********************************************************************?
S2INPDLY:                                   _INPUT DELAY               ?
  CASE S2EVENT OF 
_ 
* ENQ 
? 
    S2ENQ:                                  _IF TERMINAL LOST THE LAST ?
      BEGIN                                 _ REPLY THEN RESEND THE    ?
      S2TERMACT := S5ACKMSG;                _ LAST ACK                 ?
      BZS2INRETRY := 0;                     _RESET INPUT RETRY COUNT   ?
      S2TIMER := S2INTIM; 
      END; _S2ENQ?
_ 
* ETX 
? 
    S2ETX:  
      BEGIN                                 _IF THIS IS THE END OF     ?
      BZS2STATE := S2INPEND;                _ TEXT THEN TELL MAIN      ?
      S2MLACT := S4INDATA;                  _ LEVEL WE HAVE SOME DATA  ?
      BZS2ACK := NOT BZS2ACK;               _ UPDATE THE ACK SENSE     ?
      S2TERMACT := S5ACKMSG;                _ SEND THE ACK MESSAGE,    ?
      S2TIMER := S2ENDTIM;                  _ START THE END TIMER,     ?
      BZS2ERTYPE := S2NOERR;                _ AND CLEAR ERRORS         ?
      BZS2RETRY := 0;                       _NOTE:  THIS INPUT IS NOT  ?
      BZS2MINOR := 0;                       _ SENT THE WACK REPLY SINCE?
      END; _S2ETX?                          _ IT IS THE LAST           ?
_ 
* ETB 
? 
    S2ETB:                                  _IF TERMINAL SENDS ETB     ?
      BEGIN                                 _ REMEMBER WE HAVE SENT    ?
      BZS2STATE := S2INPSTOP;               _ THE WACK                 ?
      S2MLACT := S4INDATA;                  _TELL MAIN LEVEL WE HAVE   ?
      BZS2ACK := NOT BZS2ACK;               _ DATA AND UPDATE ACK SENSE?
      S2TERMACT := S5WAKMSG;                _SEND THE TERMINAL A WAIT  ?
                                            _ MESSAGE                  ?
      S2TIMER := S2INTIM;                   _START THE INPUT TIMER     ?
      BZS2ERTYPE := S2NOERR;                _CLEAR ERRORS              ?
      BZS2RETRY := 0; 
      BZS2MINOR := 0; 
      BZS2INRETRY := 0;                     _RESET INPUT RETRY COUNT   ?
      END; _S2ETB?
_ 
* TTD 
? 
    S2TTD:                                  _IF TERMINAL SENDS         ?
      BEGIN                                 _ TEMPORARY TEXT DELAY     ?
      S2TERMACT := S5NAKMSG;                _SEND NAK MESSAGE          ?
      S2TIMER := S2INTIM;                   _START INPUT TIMER         ?
      BZS2INRETRY := 0;                     _RESET INPUT RETRY COUNT   ?
      END; _S2TTD?
_ 
* INPUT START FROM MAIN LEVEL 
? 
    S3ISTART:                               _IF MAIN LEVEL SENDS       ?
                                            _ INPUT START THEN         ?
      BZS2STATE := S2INPACT;                _ INPUT IS ACTIVE          ?
_ 
* BUFFER THRESHOLD EXCEEDED 
? 
    S2BUF:                                  _IF BUFFER THRESHOLD HAS   ?
      S2TERMACT := S5INPUT;                 _ BEEN EXCEEDED THEN TURN  ?
                                            _ ON INPUT TO WAIT FOR ENQ ?
_ 
* UNEXPECTED EVENT/ 
? 
    S2BAD, S2ACK0, S2ACK1, S2WACK,          _ IF INPUT IS UNEXPECTED   ?
      S2NAK, S2RVI, S1TINPUT: 
      BEGIN 
      S2TERMACT := S5INPUT;                 _WAIT FOR NEXT INPUT       ?
      PTS2ERROR;                            _ CALL ERROR ROUTINE       ?
      END; _S2BAD...? 
    END; _CASE S2EVENT OF?
  
_***********************************************************************
*                                                                      *
*     INPUT STOP STATE                                                 *
*                                                                      *
***********************************************************************?
S2INPSTOP:                                  _INPUT STOP                ?
  CASE S2EVENT OF 
_ 
* INPUT START FROM MAIN LEVEL 
? 
    S3ISTART:                               _IF MAIN LEVEL TELLS US TO ?
      BEGIN 
      BZS2STATE := S2INPACT;                _ RESTART INPUT            ?
      S2TIMER   := S2INTIM;                 _ START A TIMER AND        ?
      IF BZS2TMCODE = S1TWACK               _ IF TIMING FOR WACK THEN  ?
      THEN                                  _ ACKNOWLEDGE              ?
        S2TERMACT := S5ACKMSG;
                                            _ ELSE OUTPUT MIGHT BE IN  ?
                                            _ PROGRESS SO LETS         ?
      END;                                  _ WAIT FOR AN ENQ TO ARRIVE?
_ 
* ENQ 
? 
    S2ENQ:                                  _IF THE PREVIOUS WACK      ?
                                            _ WAS LOST WAIT FOR WACK   ?
                                            _ TIMER TO EXPIRE BEFORE   ?
      BEGIN 
      S2TIMER := S2WAKTIM;                  _ RESENDING IT             ?
      BZS2INRETRY := 0;                     _ RESET INPUT RETRY COUNT  ?
      END;
_ 
* WACK TIMER EXPIRED
? 
    S1TWACK:                                _IF WACK TIMER EXPIRES     ?
      BEGIN                                 _SEND TERMINAL ANOTHER     ?
      S2TERMACT := S5WAKMSG;                _ WACK AND RESTART TIMER   ?
      S2TIMER := S2INTIM; 
      END; _S1TWACK?
_ 
* UNEXPECTED EVENT
? 
    S2BAD, S2ACK0, S2ACK1, S2WACK, S2TTD,   _IF UNEXPECTED EVENT       ?
      S2NAK, S2RVI, S2BUF, S1TINPUT:        _ IS RECEIVED              ?
      BEGIN                                 _ THEN                     ?
      S2TERMACT := S5INPUT;                 _WAIT FOR NEXT INPUT       ?
      PTS2ERROR;                            _CALL ERROR ROUTINE        ?
      END; _S2BAD...? 
    END; _CASE S2EVENT OF?
  
_***********************************************************************
*                                                                      *
*     INPUT END STATE                                                  *
*                                                                      *
***********************************************************************?
S2INPEND:                                   _INPUT END                 ?
  CASE S2EVENT OF 
_ 
* ENQ 
? 
    S2ENQ:                                  _IF TERMINAL SENDS AN ENQ  ?
      BEGIN                                 _THEN                      ?
      S2TERMACT := S5ACKMSG;                _RESEND ACK MESSAGE        ?
      S2TIMER := S2ENDTIM;                  _START END TIMER           ?
      END; _S2ENQ?
_ 
* INPUT END TIMER 
  
? 
    S1TIEND :                               _ END OF TRANSMISSION      ?
      BEGIN                                 _THEN                      ?
      BZS2STATE := S2IDLE;                  _TERMINAL IS IDLE          ?
      S2MLACT := S4INCOMPL;                 _TELL MAIN LEVEL INPUT IS  ?
                                            _ COMPLETE                 ?
      S2TERMACT := S5EOTMSG;                _ FORCE LINE TO IDLE       ?
      END; _S2EOT...? 
_ 
* * *   MORE DATA 
? 
    S2ETB,                                  _DATA WITHOUT ETX          ?
    S2ETX:                                  _DATA WITH ETX             ?
    BEGIN 
      PBRELZRO(S2BUFFPTR,BEDBSIZE);         _RELEASE ALL DATA BUFFERS  ?
      S2TERMACT := S5EOTMSG;                _FORCE TERMINAL TO STOP    ?
      BZS2STATE := S2IDLE;                  _SET STATE TO IDLE         ?
      S2MLACT   := S4INCOMPL;               _TELL ML INPUT COMPLETE    ?
    END;   _S2ETB, S2ETX? 
_ 
* * *   OTHER UNEXPECTED EVENTS 
? 
    S2ACK0, S2ACK1, S2WACK,                 _IF AN UNEXPETED EVENT     ?
      S2BAD, S2NAK, S2RVI, S2BUF:           _ OCCURS                   ?
      BEGIN 
        S2TERMACT := S5INPUT;               _WAIT FOR NEXT INPUT       ?
        S2TIMER   := S2ENDTIM;              _SET END TIMER             ?
      END; _S2ACK0, S2ACK1...?
    S2TTD:  
    BEGIN 
      S2TERMACT := S5NAKMSG;
      S2TIMER := S2ENDTIM;
    END; _S2TTD?
    END; _CASE S2EVENT OF?
  
_***********************************************************************
*                                                                      *
*     INPUT ABORT 1 STATE                                              *
*                                                                      *
***********************************************************************?
S2INP1ABRT:                                 _INPUT ABORT               ?
BEGIN 
  IF (S2EVENT = S2ETX)                      _IF EVENT IS DATA          ?
   ! (S2EVENT = S2ETB)                      _                          ?
  THEN
    PBRELZRO(S2BUFFPTR,BEDBSIZE);           _RELEASE DATA BUFFERS      ?
  
  BZS2STATE := S2IDLE;                      _SET STATE TO IDLE         ?
  S2TERMACT := S5EOTMSG;                    _SEND EOT TO TERMINAL      ?
  S2MLACT   := S4INBORT;                    _TELL ML INPUT ABORTED     ?
END;   _S2INP1ABRT? 
  
_***********************************************************************
*                                                                      *
*     OUTPUT TRANSMIT STATE                                            *
*                                                                      *
***********************************************************************?
S2OUTTRN:                                   _OUTPUT TRANSMIT           ?
  IF S2EVENT = S3OUTDATA                    _IF EVENT IS OUTPUT DATA   ?
  THEN                                      _THEN STATE BECOMES        ?
  BEGIN 
    BZS2TTD := 0;                           _ CLEAR NO. OUTPUT DELAYS  ?
    BZS2STATE   := S2OUTRSP;                _ OUTPUT RESPONSE          ?
    S2TERMACT   := S5OUTDATA;               _ SEND TERM OUTPUT DATA    ?
    S2TIMER     := S2RSPTIM;                _ RESPONSE TIMER REQD      ?
  END    _IF S2EVENT...?
  ELSE
    IF S2EVENT = S1TODELAY                  _IF OUTPUT IS DELAYED      ?
    THEN
    BEGIN 
      BZS2TTD := BZS2TTD + 1;               _ INCREMENT NO. OUTPUT
                                              DELAYS (TTD/NAK)         ?
      IF BZS2TTD > S2MAXTTDS
      THEN                                  _ WAITED LONG ENOUGH,      ?
      BEGIN                                 _  STOP OUTPUT             ?
        BZS2STATE := S2OSTPD; 
        S2MLACT := S4OSTOP;                 _ TELL ML OUTPUT STOPPED   ?
      END 
      ELSE                                  _ ISSUE TTD AND AWAIT NAK  ?
      BEGIN 
        BZS2STATE := S2OUTDLY;
        S2TERMACT := S5TTDMSG;
        S2TIMER := S2RSPTIM;
      END;
    END;
  
_***********************************************************************
*                                                                      *
*     OUTPUT DELAY STATE                                               *
*                                                                      *
***********************************************************************?
S2OUTDLY:                                   _OUTPUT DELAY              ?
  CASE S2EVENT OF                           _IF EVENT IS OUTPUT DATA   ?
_ 
* OUTPUT DATA COMMAND FROM MAIN LEVEL 
? 
    S3OUTDATA:                              _ THEN HOLD OUTPUT         ?
    BEGIN 
      BZS2STATE := S2OUTHLD;                _SET STATE TO HOLDING      ?
      S2TIMER   := S2RSPTIM;                _SET REPONSE TIMER         ?
    END; _S3OUTDATA?
_ 
* NAK 
? 
    S2NAK:                                  _IF TERMINAL SENDS A NAK   ?
      BEGIN                                 _ THEN WAIT IN THE OUTPUT  ?
      BZS2STATE := S2OUTTRN;                _ TRANSMIT STATE FOR A     ?
      S2TIMER := S2DLYTIM;                  _ DELAY BEFORE SENDING     ?
      END; _S2NAK?                          _ ANOTHER TTD              ?
_ 
* UNEXPECTED EVENT
? 
    S2ENQ, S2ACK0, S2ACK1, S2WACK,          _IF WE GET AN UNEXPECTED   ?
      S2ETB,S2ETX,S2BAD,S2TTD,S2RVI:        _ INPUT THEN TREAT AS IF   ?
      BEGIN                                 _ WE GOT A NAK AND         ?
      BZS2STATE := S2OUTTRN;                _ RETRANSMIT THE OUTPUT    ?
      S2TIMER := S2DLYTIM;
      END; _S2ENQ...? 
_ 
* RESPONSE TIMEOUT
? 
    S1TORESP:                               _IF WE DON:T GET THE NAK   ?
      BEGIN                                 _ BACK FROM THE TERMINAL   ?
      S2TERMACT := S5TTDMSG;                _ THEN RESEND THE TTD AND  ?
      S2TIMER := S2RSPTIM;                  _ WAIT FOR THE NAK AGAIN   ?
      END; _S1ORESP?
    END; _CASE S2EVENT OF?
  
_***********************************************************************
*                                                                      *
*     OUTPUT HOLD STATE                                                *
*                                                                      *
***********************************************************************?
S2OUTHLD:                                   _OUTPUT HOLD               ?
  CASE S2EVENT OF                           _IF WE ARE ALREADY HOLDING ?
    S2ENQ, S2ACK0, S2ACK1,                  _ OUTPUT AND THE DELAY     ?
      S2WACK, S2ETX, S2ETB, S2BAD, S2TTD,   _ TIMER EXPIRES OR THE     ?
      S2NAK, S2RVI, S1TORESP:               _ TERMINAL TRANSMITS       ?
      BEGIN                                 _ OUTPUT                   ?
      BZS2STATE := S2OUTRSP;
      S2TERMACT := S5OUTDATA; 
      S2TIMER := S2RSPTIM;
      END; _S2ENQ...? 
    END; _CASE S2EVENT OF?
  
_***********************************************************************
*                                                                      *
*     OUTPUT RESPONSE STATE                                            *
*                                                                      *
***********************************************************************?
S2OUTRSP:                                   _OUTPUT RESPONSE           ?
  CASE S2EVENT OF 
_ 
* ACK0, ACK1
? 
    S2ACK0, S2ACK1:                         _IF EVENT IS ACK           ?
      BEGIN                                 _THEN                      ?
      S2ACK := (S2EVENT = S2ACK0);
      IF BZS2ACK = S2ACK                    _IF ACK SENSE IS AS        ?
      THEN                                  _ EXPECTED                 ?
        IF BZS2ETX                          _IF THE LAST FRAME WAS THE ?
        THEN                                _ ETX BLOCK                ?
        BEGIN                               _THEN THE STATE BECOMES    ?
          BZS2STATE := S2IDLE;              _ IDLE                     ?
          S2TERMACT := S5EOTMSG;            _ SEND EOT TO END FILE     ?
          S2MLACT   := S4OCOMPL;            _ TELL MAIN LEVEL THAT OUT-?
        END   _IF BZETX?                    _ PUT IS COMPLETE          ?
        ELSE                                _ELSE IF THE LAST BLOCK    ?
          BEGIN                             _ WAS NOT THE ETX THEN     ?
          BZS2RETRY := 0;                   _ CLEAR THE RETRY COUNTER  ?
          BZS2STATE := S2OUTTRN;            _ CONTINUE THE OUTPUT      ?
          S2MLACT := S4ODATA;               _ASK THE MAIN LEVEL FOR    ?
          S2TIMER := S2DLYTIM;              _ OUTPUT DATA.  START THE  ?
          BZS2ACK := NOT BZS2ACK;           _ DELAY TIMER AND UPDATE   ?
          END  _IF BZS2ETX?                 _ THE ACK SENSE            ?
      ELSE                                  _IF ACK SENSE NOT CORRECT  ?
        BEGIN 
        BZS2RETRY := BZS2RETRY + 1;         _IF WE HAVE NOT GOTTEN GOOD?
        IF BZS2RETRY > S2MAXBADAK           _ACKS IN SO MANY ATTEMPTS  ?
        THEN                                _THEN                      ?
        BEGIN 
          S2ERR     := S2SERIOUS;           _MARK ERROR AS SERIOUS     ?
          S2ERSTATE := BZS2STATE;           _SAVE CURRENT STATE        ?
          BZS2STATE := S2IDLE;              _GO IDLE                   ?
          S2MLACT   := S4OBORT;             _SEND ML OUTPUT ABORT      ?
          S2TERMACT := S5EOTMSG;            _SEND TERMINAL AN EOT      ?
        END 
        ELSE                                _ELSE                      ?
        BEGIN 
          S2TERMACT := S5OUTDATA;           _RETRANSMIT                ?
          S2TIMER   := S2RSPTIM;            _AND WAIT FOR RESPONSE     ?
        END;  _IF BZS2RETRY?
        END; _IF BZS2ACK = S2EVENT? 
      END; _S2ACK0...?
_ 
* RVI 
? 
    S2RVI:                                  _ IF EVENT IS RVI          ?
      BEGIN                                 _THEN                      ?
      IF BZS2ETX                            _IF THE ETX BLOCK WAS SENT ?
      THEN                                  _   THEN                   ?
      BEGIN                                 _                          ?
        BZS2STATE := S2IDLE;                _SET STATE TO IDLE         ?
        S2TERMACT := S5EOTMSG;              _SEND EOT MESSAGE TO TERM  ?
        S2MLACT   := S4OCOMPL;              _TELL MAIN LEVEL THAT OUT- ?
      END   _IF BZETX?                      _ PUT IS COMPLETE          ?
      ELSE                                  _IF THE ETX BLOCK WAS NOT  ?
        BEGIN                               _ SENT THEN OUTPUT IS NOT  ?
        BZS2STATE := S2OUTTRN;              _ COMPLETE. REQUEST OUTPUT ?
        S2MLACT := S4ODATA;                 _ FROM MAIN LEVEL, START   ?
        S2TIMER := S2DLYTIM;                _ DELAY TIMER AND UPDATE   ?
        BZS2ACK := NOT BZS2ACK;             _ ACK SENSE.               ?
        END; _IF BZS2ETX? 
      END; _S2RVI?
_ 
* WACK
? 
    S2WACK:                                 _IF THE TERMINAL REQUESTS  ?
      BEGIN                                 _ OUTPUT TO WAIT AND THE   ?
      IF BZS2ETX                            _ ETX BLOCK WAS SENT THEN  ?
      THEN                                  _THEN                      ?
      BEGIN                                 _                          ?
        BZS2STATE := S2IDLE;                _SET STATE TO IDLE         ?
        S2TERMACT := S5EOTMSG;              _SEND EOT MESSAGE TO TERM  ?
        S2MLACT   := S4OCOMPL;              _TELL MAIN LEVEL THAT OUT- ?
      END   _IF BZETX?                      _ PUT IS COMPLETE          ?
      ELSE _IF BZS2ETX?                     _IF THE ETX BLOCK HAS NOT  ?
      BEGIN                                 _ BEEN SENT THEN INCOMPLETE?
        S2TERMACT := S5ENQMSG;              _SEND TERMINAL ENQ         ?
        S2TIMER   := S2RSPTIM;              _SET TIMEOUT VALUE         ?
      END;  _IF BZS2ETX?
      END; _S2WACK? 
_ 
* NAK 
? 
    S2NAK:                                  _IF TERMINAL SENDS A NAK   ?
      BEGIN                                 _ SEND TERMINAL            ?
      S2TERMACK := S5OUTDATA;               _ OUTPUT DATA MESSAGE      ?
      S2TIMER := S2RSPTIM;                  _START OUTPUT REQUEST      ?
      PTS2ERROR;                            _ CALL ERROR ROUTINE       ?
      END; _S2NAK?                          _ TIMER                    ?
_ 
* UNEXPECTED EVENT
? 
    S2ENQ,S2BAD,S2TTD,                      _IF UNEXPECTED EVENT       ?
      BEGIN                                 _REQUEST                   ?
      S2TERMACT := S5ENQMSG;                _ RETRANSMITTAL AND        ?
      S2TIMER := S2RSPTIM;                  _ START TIMER              ?
      PTS2ERROR;                            _ CALL ERROR ROUTINE       ?
      END; _S2ENQ...? 
_ 
* RESPONSE TIMEOUT
? 
    S1TORESP:                               _IF NO RESPONSE IN 3 SECS  ?
      BEGIN 
      BZS2RETRY := BZS2RETRY + 1;           _IF WE HAVE NOT GOTTEN     ?
      IF BZS2RETRY > S2MAXNORES             _A RESPONSE TO SO MANY ENQS?
      THEN                                  _THEN                      ?
      BEGIN 
        S2ERR     := S2SERIOUS;             _MARK ERROR AS SERIOUS     ?
        S2ERSTATE := BZS2STATE;             _SAVE CURRENT STATE        ?
        BZS2STATE := S2IDLE;                _GO IDLE                   ?
        S2MLACT   := S4OBORT;               _SEND ML OUTPUT ABORT      ?
        S2TERMACT := S5EOTMSG;              _SEND TERMINAL AND EOT     ?
      END 
      ELSE                                  _ELSE                      ?
      BEGIN 
        S2TERMACT := S5ENQMSG;              _SEND TERMINAL AN ENQ      ?
        S2TIMER   := S2RSPTIM;              _SET TIMEOUT VALUE         ?
      END;  _IF BZS2RETRY?
      END;  _S1TORESP?
  END; _S2OUTRSP? 
  
_***********************************************************************
*                                                                      *
*     OUTPUT ABORT 1 STATE                                             *
*                                                                      *
***********************************************************************?
S2OUT1ABRT:                                 _OUTPUT ABORT 1            ?
BEGIN 
  IF (S2EVENT = S2ETX)                      _IF EVENT IS DATA          ?
   ! (S2EVENT = S2ETB)                      _                          ?
  THEN
    PBRELZRO(S2BUFFPTR,BEDBSIZE);           _RELEASE DATA BUFFERS      ?
  
  BZS2STATE := S2IDLE;                      _SET STATE TO IDLE         ?
  S2TERMACT := S5EOTMSG;                    _SEND EOT TO TERMINAL      ?
  S2MLACT   := S4OBORT;                     _TELL ML OUTPUT ABORTED    ?
END;   _S2OUT1ABRT? 
  
_***********************************************************************
*                                                                      *
*     DOWN HARD STATE                                                  *
*                                                                      *
***********************************************************************?
S2DWNHRD:                                   _ DOWN HARD                ?
  IF S2EVENT = NMINEND                      _IF EVENT IS INPUT         ?
  THEN                                      _ TERMINATED THEN          ?
    BEGIN                                   _STATE BECOMES             ?
    BZS2STATE := S2DOWN;                    _ DOWN                     ?
    S2MLACT := S4LNDOWN;                    _NOTIFY MAIN LEVEL         ?
    END; _IF S2EVENT = S2INPTRM?            _ LINE IS DOWN             ?
  
_***********************************************************************
*                                                                      *
*     DOWN DISABLED STATE                                              *
*                                                                      *
***********************************************************************?
S2DWNDIS:                                   _DOWN DISABLED             ?
  IF S2EVENT = NMINEND                      _IF EVENT IS INPUT         ?
  THEN                                      _ TERMINATED               ?
    BEGIN                                   _THEN STATE BECOMES DOWN   ?
    BZS2STATE := S2DOWN;                    _ NOTIFY MAIN LEVEL        ?
    S2MLACT := S4LNDIS;                     _ THAT LINE IS DISABLED    ?
    S2TERMACT := S5DISABLE;                 _DISABLE COMMAND TO MUX    ?
    END; _IF S2EVENT = NMINEND? 
  END; _CASE BZS2STATE OF?
END; _WITH S2LCB...?
END; _PTS2STATE?
_$J+? 
_***********************************************************************
*                                                                      *
*                             PTS2POST                                 *
*                                                                      *
*          PROCESS OUTGOING WORK LIST ENTRIES AND COMMANDS             *
*                                                                      *
***********************************************************************?
_R-,G-,I-?
_***********************************************************************
*                                                                      *
** OVERVIEW - BASED ON PARAMETERS SET IN PTS2STATE AND PTS2EVENT THIS  *
*             ROUTINE SENDS WORKLIST ENTRIES TO BSC MAIN LEVEL,        *
*             COMMANDS TO THE TERMINAL AND CALLS TIMER SERVICES.       *
*                                                                      *
** INPUTS -   BZS2STATE                                                *
*             S2EVENT                                                  *
*             S2MLACT                                                  *
*             S2TERMACT                                                *
*             BZS2ACK                                                  *
*             BZS2ERTYPE                                               *
*             BZL2LIMIT                                                *
*             BZS2RETRY                                                *
*                                                                      *
** CALLING PROGRAM -                                                   *
*             PTS2BSC                                                  *
*                                                                      *
** OUTPUTS -  WLE TO BSC MAIN LEVEL                                    *
*             TERMINAL COMMAND/MESSAGE                                 *
*             BZWTCOUNT                                                *
*             BZS2RETRY                                                *
*             BZS2ERTYPE                                               *
*             BZS2MINOR                                                *
*             S2ERSTATE                                                *
*             BZS2ERTYPE                                               *
*             S2ERR                                                    *
*                                                                      *
** EXTERNAL SUBROUTINES -                                              *
*             PBCOIN                                                   *
*             PBTMRSRVS                                                *
*             PBREL1BF                                                 *
*                                                                      *
***********************************************************************?
PROCEDURE PTS2POST; 
  
CONST 
      T4TIME = 7;                           _3-SECOND OUTPUT TIMER     ?
  
VAR 
      S2CANI     : PACKED ARRAY[S0TMTM,     _ARRAY OF INDEXES TO PICK  ?
                   BOOLEAN] OF B08BITS;     _UP CANNED MESSAGE         ?
  
VALUE 
      S2CANI     = (0,0,1,2,3,3,4,4,5,5,
                    6,6,7,7,0,0,0,0,0,0); 
BEGIN 
_ 
      A SPECIAL CHECK IS MADE IF THE EOT MESSAGE IS TO BE SENT DOWNLINE.
      IF SO, ANY WORKLIST TO THE BSC MAIN LEVEL IS DELAYED UNTIL A TIME-
      OUT FOLLOWING THE EOT TRANSMISSION (OR UNTIL RECEIPT OF THE 
      NEXT WORKLIST ENTRY).  THIS PROCEDURE PREVENTS
      MAIN LEVEL RETURNING A WORKLIST WHICH MIGHT CAUSE THE SENDING OF
      ANOTHER DOWNLINE MESSAGE, E.G. ENQ, WHILE THE EOT IS STILL IN 
      PROCESS (AND A SUBSEQUENT HALT 20). 
                                                                       ?
WITH S2LCBEXT' DO 
BEGIN 
  IF S2TERMACT = S5EOTMSG 
  THEN                                      _EOT TO BE SENT DOWNLINE   ?
  BEGIN 
    BZS2MLACT := S2MLACT;                   _SAVE INDEX TO ML WL ARRAY ?
    BZS2MMIBP := S2BUFFPTR;                 _SAVE BUFF PTR FROM WL     ?
    S2MLACT := S4NIL;                       _SET UP TO NOT ISSUE WL    ?
    S2TIMER := S2EOTTIM;                    _TIMEOUT AFTER EOT SENT    ?
    S2LCB'.BZTINPUT := FALSE;               _PREVENT TERMINATE INPUT
                                              ON TIMEOUT               ?
  END;
_ 
* * * SEND MAIN LEVEL A WORKLIST
? 
  IF S2MLACT " S4NIL                        _IF MAIN LEVEL NEEDS TO BE ?
  THEN                                      _INFORMED OF AN EVENT THEN ?
  BEGIN                                     _                          ?
    WITH BWWLENTRY[OPS].B0EWLQ DO           _PUT WORKCODE INTO ENTRY   ?
    BEGIN                                   _LINE NUMBER AND BFR PTR   ?
      MMWKCOD := S2MLWC[S2MLACT];           _ALREADY THERE             ?
      PBLSPUT(BWWLENTRY[OPS],               _SEND IT TO THE MAIN LEVEL ?
              BYWLCB[B0MLBSC]); 
    END;  _WITH BWWLENTRY?
  END;  _IF S2MLACT...? 
_ 
* * * SET UP COMMAND PACKET AND CANNED MESSAGE
? 
  IF S2TERMACT " S5NIL                      _IF TERMINAL ACTION IS     ?
  THEN                                      _  REQUIRED THEN           ?
    WITH S2CMDPKT DO                        _SET UP COMMAND PACKET     ?
    BEGIN                                   _                          ?
      NKCMD   := S2CMD[S2TERMACT];          _ I/O COMMAND              ?
      NKLINO  := S2LINO;                    _ LINE NUMBER              ?
      IF S2TERMACT = S5OUTDATA              _IF OUTPUT DATA REQUIRED   ?
      THEN                                  _THEN                      ?
        NKOBP := BZS2OUTDATA                _OUTPUT BUFFER IS DATA     ?
      ELSE
        NKOBP := BYS2CAN[S2CANI[S2TERMACT,  _OTHERWISE SEND CANNED     ?
                                BZS2ACK]];  _MSG WHEN NEEDED           ?
      NKWKFLG := FALSE;                     _NO WRKLST RETURN REQUIRED ?
      NKISTAI := S2CONSTANT;                _INITIAL INPUT STATE INDEX ?
      NKISPTA := S2SYTABL;                  _INPUT STATE PTR TABLE ADDR?
      PBCOIN(S2CMDPKT);                     _ISSUE COMMAND             ?
      IF S2TERMACT = S5TERMIO               _IF TERMINATE INPUT/OUTPUT? 
      THEN
      BEGIN 
        NKWKFLG  := TRUE;                   _WRKLST RETURN REQUIRED    ?
        NKRELBFS := TRUE;                   _RELEASE ALL INPUT BFRS    ?
        NKWKCOD  := NMINEND;                _ MAKE INPUT ENDED W/L    ? 
        NKWLINDX := B0L2BSC;                _ MAKE IT TO L2           ? 
        NKCMD    := NKENDIN;                _ END INPUT COMMAND       ? 
        PBCOIN(S2CMDPKT);                   _ ISSUE COMMAND PACKET    ? 
      END; _IF S2TERMACT = S5TERMIO?
    END;  _WITH S2CMDPKT...?
_ 
* * * SET UP TIMER PACKET 
? 
  WITH BLTIMTBL'[S2LCB'.BZLINO.BDPORT] DO   _INDEX TO TIME-ARRAY      ? 
  BEGIN 
    BLTIME := 0;                            _RESET TIMER               ?
    BLTRESET := S2TICKS[S2TIMER];           _SET INPUT TIMER VALUE     ?
    S2LCB'.BZWTCOUNT :=                     _BUMP TMR CONTENTION CTR   ?
      S2LCB'.BZWTCOUNT + 1; 
    IF S2TIMER " S2NOTIME                   _TIMER REQUIRED            ?
    THEN
    BEGIN 
      BLTIME := T4TIME;                     _SET OUTPUT TIMER          ?
    END 
    ELSE _IF S2TIMER " S2NOTIME?
    IF BZS2STATE = S2IDLE                   _IF CURRENT STATE IS IDLE  ?
    THEN                                    _WHILE NO TIMER IS SET     ?
    BEGIN                                   _THEN SET TIMER TO EXPIRE  ?
      BLTIME := 41;                         _IN 20 SECONDS AND SET TIME?
      S2TIMER := S2IDLTIM;                  _REASON TO IDLE TIMEOUT    ?
    END; _IF BZS2STATE = S2IDLE?
    BZS2TMCODE := S2TMCODE [S2TIMER];       _SET REASON FOR TIMER      ?
  END;
_ 
* * * SET UP CE ERROR MESSAGE 
? 
  IF S2ERR " S2NONE                         _IF A CE ERROR MESSAGE     ?
  THEN                                      _NEEDS TO BE SENT THEN     ?
    WITH S2CECMD DO                         _BUILD CE ERROR MSG        ?
    BEGIN 
      SATYPE := S2CECODES[S2ERR];           _CE ERROR CODE             ?
      SALINO  := S2LINO;                    _ LINE NUMBER              ?
      SAEVENT := S2EVENT;                   _ EVENT (WORKCODE)         ?
      SASTATE := S2ERSTATE;                 _ STATE AT TIME OF ERROR   ?
      SACOUNT := BZS2RETRY;                 _ RETRY COUNT              ?
      CNCEOVL[OPS].CNCECODE  := SABSC2[0];  _MOVE CE ERROR MESSAGE INTO?
      CNCEOVL[OPS].SABSC1[1] := SABSC2[1];  _ INTERFACE AREA           ?
      CNCEOVL[OPS].SABSC1[2] := SABSC2[2];
      CNCEOVL[OPS].SABSC1[3] := SABSC2[3];
      PNCEFILE(7);                          _SEND CE ERR MSG TO HOST   ?
    END;  _WITH SACE DO?
END;  _WITH S2LCBEXT...?
END;  _PROCEDURE PTS2POST?
_***********************************************************************
*                                                                      *
*                               PTS2BSC                                *
*                                                                      *
*                     BSC MAIN LEVEL PROCEDURE                         *
*                                                                      *
***********************************************************************?
_R-,G-,I-?
_***********************************************************************
*                                                                      *
** OVERVIEW - THIS PROCEDURE CALLS THE SUBROUTINES NECESSARY TOO       *
*             PROCESS THE INPUT AND THE STATE                          *
*                                                                      *
** INPUT -    WORK LIST ENTRY                                          *
*                                                                      *
** CALLING PROGRAM -
*             STATE PROGRAM                                            *
*             BSC MAIN LEVEL                                           *
*             PBTMRSRVS - TIMER SERVICES                               *
*                                                                      *
** OUTPUT -   WORK LIST ENTRY TO STATE PROGRAM                         *
*             WORK LIST ENTRY TO MAIN LEVEL                            *
*             LCB PARAMETERS                                           *
*                                                                      *
** EXTERNAL SUBROUTINES -                                              *
*             PBREL1BUF                                                *
*             PBGET1BUF                                                *
*             PBCOIN                                                   *
*             PBTMRSRVS                                                *
*             PBLLCP                                                   *
*             PTS2EVENT                                                *
*             PTS2STATE                                                *
*             PTS2POST                                                 *
*                                                                      *
***********************************************************************?
BEGIN 
S2DBGA [S2DBGI] := BWWLENTRY[OPS].B0TIPWLE; _SAVE WORKLIST ENTRY       ?
S2DBGI          := (S2DBGI + 1) MOD 25;     _UPDATE INDEX INTO ARRAY   ?
_ 
* * * UNRAVEL WORKLIST ENTRY IN LOCAL VARIABLES 
? 
  WITH BWWLENTRY[OPS].B0EWLQ DO             _OPS WORKLIST ENTRY        ?
  BEGIN 
    S2LINO    := MMLINO;                    _ LINE NUMBER              ?
    S2EVENT   := MMWKCOD;                   _ EVENT (WORKCODE)         ?
    S2BUFFPTR := MMIBP;                     _ INPUT BUFFER POINTER     ?
    S2WTCOUNT := MMWTCOUNT;                 _ TIMER WAIT COUNT         ?
  END;  _WITH BWWLENTRY...? 
_ 
* * * INITIALIZE FLAGS AND WORK AREAS 
? 
  PBLCBP(S2LINO,S2LCB);                     _GET LCB POINTER           ?
  S2LCBEXT    := S2LCB'.BZBSCEXT;           _GET LCB EXT POINTER       ?
  S2ERR       := S2NONE;                    _CLEAR THE ERROR FLAG      ?
  S2MLACT     := S4NIL;                     _CLEAR ML WRKLST INDEX     ?
  S2TERMACT   := S5NIL;                     _CLEAR TERMINAL MSG INDEX  ?
  S2TIMER     := S2NOTIME;                  _CLEAR TIMER INDEX         ?
  WITH S2LCBEXT' DO 
  BEGIN 
    IF BZS2MLACT " S4NIL
    THEN                                    _DELAYED WL FOR ML (SAVED 
                                              WHEN EOT SENT DOWNLINE)  ?
    BEGIN 
      WITH S2MLSV.B0EWLQ DO                 _ISSUE DELAYED WL TO ML    ?
      BEGIN 
        MMWKCOD := S2MLWC[BZS2MLACT]; 
        MMLINO := S2LINO; 
        MMIBP := BZS2MMIBP; 
        PBLSPUT(S2MLSV,BYWLCB[B0MLBSC]);
      END;
      BZS2MLACT := S4NIL; 
      S2LCB'.BZTINPUT := TRUE;              _RETURN TO ORIGINAL VALUE  ?
    END;
  END;
  IF S2EVENT = A0TIMEOUT
  THEN
  BEGIN 
    IF S2LCB'.BZWTCOUNT " S2WTCOUNT         _EXPECTED TIMEOUT          ?
    THEN
      GOTO 999;                             _NO, RETURN TO MONITOR     ?
   _ELSE? 
      S2EVENT := S2LCBEXT'.BZS2TMCODE;      _GET REASON FOR TMCODE     ?
  END;
_ 
* * * PROCESS THE EVENT(WORKCODE) ACCORDING TO THE STATE
? 
  PTS2EVENT;                                _PROCESS EVENT (WORKLIST)  ?
  
  
  IF S2L2ACT  = S4STATE                     _IF FURTHER PROCESSING OF  ?
  THEN                                      _ EVENT IS REQUIRED THEN   ?
    PTS2STATE;                              _ CALL THE STATE PROCESSOR ?
  
  PTS2POST;                                 _CALL THE POST PROCESSOR   ?
  
999:  
END;  _PROCEDURE PTS2BSC? 
_$J+? 
_***********************************************************************
*                                                                      *
*                              PTS2MJX                                 *
*                                                                      *
*                   CREATE OPS LEVEL WORKLIST ENTRY WITHH OBT          *
*                                                                      *
***********************************************************************?
_R-,I-,G-?
_***********************************************************************
*                                                                      *
** OVERVIEW - THIS PROCEDURE RECEIVES A MUX LEVEL WORKLIST ENTRY       *
*             AND PASSES IT ON TO THE BSC L2 PROGRAM UNALTERED.        *
*                                                                      *
** INPUT -    WORK LISTT ENTRY                                         *
*                                                                      *
** CALLING PROGRAM -                                                   *
*             FIRMWARE                                                 *
*                                                                      *
** OUTPUT - WORKLIST ENTRY TO LEVEL 2 BSC                              *
*                                                                      *
** EXTERNAL SUBROUTINES -                                              *
*             NONE                                                     *
*                                                                      *
***********************************************************************?
PROCEDURE PTS2MJX;
  
BEGIN 
  WITH BWWLENTRY[MUX2].B0EWLQ DO            _SEND THIS WORKLIST TO THE ?
  PBLSPUT(BWWLENTRY[MUX2],BYWLCB[B0L2BSC]); _OPS LEVEL BSC L2 PROGRAM  ?
END;   _PROCEDURE PTS2MJX?
