*COMDECK X25PAD 
_$J+  PAGE EJECT? 
  
  
  
  
  
  
  
  
_ 
                 XX      XX       22222222   55 
                 XX      XX      2222222222  5555555555 
                 XXX    XXX      2       22  5555555555 
                  XXX  XXX               22  55 
                   XX  XX               22   55 
                    XXXX               22    55 
                     XX               22     555555555
                    XXXX             22       555555555 
                   XX  XX           22               55 
                  XXX  XXX         22                55 
                 XXX    XXX       22         5       55 
                 XX      XX  ..  2222222222  5555555555 
                 XX      XX  ..  2222222222   55555555
  
  
  
                  PPPPPPPPP        AA       DDDDDDDDD 
                  PPPPPPPPPP      AAAA      DDDDDDDDDD
                  PP      PP     AA  AA       DD     DD 
                  PP      PP    AA    AA      DD      DD
                  PPPPPPPPPP   AA      AA     DD      DD
                  PPPPPPPPP    AAAAAAAAAA     DD      DD
                  PP           AAAAAAAAAA     DD      DD
                  PP           AA      AA     DD     DD 
                  PP           AA      AA   DDDDDDDDDD
                  PP           AA      AA   DDDDDDDDD 
  
  
  SSSSSSSS   UU      UU  BBBBBBBBB      TTTTTTTTTT  IIIIII  PPPPPPPPP 
 SSSSSSSSSS  UU      UU  BBBBBBBBBB     TTTTTTTTTT  IIIIII  PPPPPPPPPP
 SS      SS  UU      UU  BB      BB         TT        II    PP      PP
  SS         UU      UU  BB      BB         TT        II    PP      PP
   SSS       UU      UU  BBBBBBBB           TT        II    PPPPPPPPPP
      SSS    UU      UU  BBBBBBBB           TT        II    PPPPPPPPP 
        SS   UU      UU  BB      BB         TT        II    PP
 SS      SS  UU      UU  BB      BB         TT        II    PP
 SSSSSSSSSS   UUUUUUUU   BBBBBBBBBB         TT      IIIIII  PP
  SSSSSSSS     UUUUUU    BBBBBBBBB          TT      IIIIII  PP
? 
  
  
  
_$J+  PAGE EJECT? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*              X25 PACKET ASSEMBLY/DISASSEMBLY SUB TIP                * 
*                                                                     * 
*                          PXPADTIP                                   * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_$R-,G-,I-     NON-RECURSIVE
               INTERRUPTABLE? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
** OVERVIEW:                                                          * 
*              THE PAD SUBTIP WILL DRIVE ASYNCHRONOUS INTERACTIVE     * 
*              TERMINALS WHICH ARE CONNECTED TO A PACKET-SWITCHED-    * 
*              NETWORK (PSN) USING X.25 PROTOCOL VIA A PACKET         * 
*              ASSEMBLY/DISASSEMBLY FACILITY.                         * 
*                                                                     * 
*              THERE ARE TWO TYPES OF PACKET, ONE IS A DATA PACKET    * 
*              CONTAINING THE IVT DATA, THE OTHER IS A PAD MESSAGE    * 
*              PACKET CONTAINING REDEFINITION AND INTERROGATION OF    * 
*              PAD CHARACTERISTICS.  PAD SUBTIP WILL SEND A PAD       * 
*              MESSAGE PACKET TO SET THE CDC RECOMMENDED X.3          * 
*              PARAMETER TO PSN PAD WHEN THE TCB CONNECTION IS        * 
*              ESTABLISHED.                                           * 
*                                                                     * 
*              WHEN THE UPLINE DATA PACKET IS QUEUED BY THE PACKET    * 
*              LEVEL (LEVEL 3), THE PAD SUBTIP WILL DISASSEMBLE       * 
*              THE PACKET INTO ONE OR MORE UPLINE NETWORK BLOCKS      * 
*              AND SEND BLOCKS TO THE HOST.  THE RECEIVED DOWNLINE    * 
*              NETWORK BLOCK FROM HOST WILL BE ASSEMBLED BY SUBTIP    * 
*              INTO ONE OR MORE DOWNLINE DATA PACKETS AND QUEUED TO   * 
*              THE PACKET LEVEL (LEVEL 3).                            * 
*                                                                     * 
*              ANY WORKLIST ENTRY SENT TO THE X25TIP WHICH REQUIRES   * 
*              PAD SUBTIP PROCESSING RESULTS IN THE X25TIP MAKING     * 
*              A DIRECT CALL TO THE PAD SUBTIP.                       * 
*                                                                     * 
*              NO REENTRANT LOGIC EXISTS IN THIS TIP.                 * 
*                                                                     * 
*                                                                     * 
*              INPUT TO THE PAD SUBTIP:                               * 
*                                                                     * 
*                  I)  WORKLIST ENTRY                                 * 
*                                                                     * 
*                     WORK CODE  ORIGINATOR                 RECEIVER  * 
*                     ---------  ----------                 --------  * 
*                                           WL          DC            * 
*                     L3FRGQ      LEVEL 3   ---> X25TIP ---> SUBTIP   * 
*                                           WL          DC            * 
*                     L3FRGR      LEVEL 3   ---> X25TIP ---> SUBTIP   * 
*                                                                     * 
*                                           WL          DC            * 
*                     L5SMDA      SVM       ---> X25TIP ---> SUBTIP   * 
*                                           WL          DC            * 
*                     L5SMDLTCB   SVM       ---> X25TIP ---> SUBTIP   * 
*                                           WL          DC            * 
*                     L5TCB       SVM       ---> X25TIP ---> SUBTIP   * 
*                      (CMDATA = D5FREE)                              * 
*                                                                     * 
*                                           WL          DC            * 
*                     L5QUEOUT    BIP       ---> X25TIP ---> SUBTIP   * 
*                                 (DOWNLINE                           * 
*                                  TIP                                * 
*                                  SERVICE)                           * 
*                                                                     * 
*                                           WL          DC            * 
*                     L5TIMEOUT   TIMER     ---> X25TIP ---> SUBTIP   * 
*                                 ROUTINE                             * 
*                                                                     * 
*                                           WL          DC            * 
*                     L5ULPKT     SUBTIP    ---> X25TIP ---> SUBTIP   * 
*                                                                     * 
*                                           WL          DC            * 
*                     L5SETPAD    SVM       ---> X25TIP ---> SUBTIP   * 
*                                                                     * 
*                                           WL          DC            * 
*                     L3INVCLR    XPORT     ---> X25TIP ---> SUBTIP   * 
*                                                                     * 
*                 II)  INPUT DATA                                     * 
*                                                                     * 
*                     UPLINE FRAGMENT FROM THE TERMINAL               * 
*                       (UPLINE IVT DATA PACKET)                      * 
*                                                                     * 
*                     UPLINE FRAGMENT FROM THE PAD                    * 
*                       (UPLINE PAD MESSAGE PACKET)                   * 
*                                                                     * 
*                     DOWNLINE NETWORK BLOCK FROM THE HOST            * 
*                                                                     * 
*                     TERMINAL RESPONSE DATA FROM THE BIP             * 
*                                                                     * 
*                                                                     * 
*              OUTPUT FROM THE PAD SUBTIP:                            * 
*                                                                     * 
*                  I)  WORKLIST ENTRY                                 * 
*                                                                     * 
*                     WORK CODE    ORIGINATOR               RECEIVER  * 
*                     ---------    ----------               --------  * 
*                                                 WL                  * 
*                     TPFRGQ         SUBTIP  -------------> LEVEL 3   * 
*                                                 WL                  * 
*                     TPSTARTIN      SUBTIP  -------------> LEVEL 3   * 
*                                                 WL                  * 
*                     TPSTOPIN       SUBTIP  -------------> LEVEL 3   * 
*                                            WL         DC            * 
*                     L5ULPKT        SUBTIP  --> X25TIP --> SUBTIP    * 
*                                                                     * 
*                 II)  OUTPUT DATA                                    * 
*                                                                     * 
*                     UPLINE NETWORK BLOCK                            * 
*                       (DIRECT CALL TO THE UPLINE TIP SERVICE)       * 
*                                                                     * 
*                     DOWNLINE FRAGMENT TO LEVEL 3                    * 
*                       (DOWNLINE IVT DATA OR PAD MESSAGE PACKET)     * 
*                                                                     * 
*     ***  NOTE                                                       * 
*                                                                     * 
*        DC :  DIRECT CALL                                            * 
*        WL :  WORKLIST ENTRTY                                        * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PXPADTIP; 
  
CONST 
  
*CALL X25CON01
  
_ 
* * *  DOWNLINE CMD BLOCK FORMATS.
? 
      X0PFC        = P1;                    _PFC BYTE                  ?
  
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*              PAD DATA PACKET CONST                                  * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
  
      X0DATA       = 13;                    _THE FIRST DATA POSITION   ?
                                            _ OF THE DATA PACKET       ?
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*              PAD MESSAGE PACKET CONST                               * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
      X0MCODE      = 13;                    _LOCATION OF PAD MESSAGE   ?
                                            _ CODE IN A PACKET         ?
  
_ 
* * *  TYPE AND CODING OF PAD MESSAGE FIELD.
? 
      X0PARIND     = 0;                     _PARAMETER INDICATION      ?
      X0CLEAR      = 1;                     _INVITATION TO CLEAR       ?
      X0SET        = 2;                     _SET PARAMETER             ?
      X0BREAK      = 3;                     _INDICATION OF BREAK       ?
      X0READ       = 4;                     _READ PARAMETER            ?
      X0ERROR      = 5;                     _ERROR                     ?
      X0SETREAD    = 6;                     _SET AND READ PARAMETER    ?
  
_ 
* * *  PAD PARAMETER REFERENCE. 
? 
      X0ESCAPE     = 1;                     _ESCAPE FROM DATA TRANSFER ?
                                            _ STATE                    ?
      X0ECHO       = 2;                     _ECHO                      ?
      X0DTFWD      = 3;                     _SELECTION OF DATA FORWARD ?
                                            _ SIGNAL                   ?
      X0IDLETMRDLY = 4;                     _SELECTION OF IDLE TIMER   ?
                                            _ DELAY                    ?
      X0DEVICECTL  = 5;                     _ANCILLARY DEVICE CONTROL  ?
      X0SERVSIGNAL = 6;                     _SUPPRESSION OF PAD SERVICE?
                                            _ SIGNAL                   ?
      X0PADRECEIPT = 7;                     _SELECTION OF PAD OPERATION?
                                            _ OF RECEIPT OF BREAK FROM ?
                                            _ TERMINAL                 ?
      X0DISCARD    = 8;                     _DISCARD OUTPUT            ?
      X0CRPADDING  = 9;                     _PADDING AFTER CARRIAGE    ?
                                            _ RETURN                   ?
      X0LINEFOLD   = 10;                    _LINE FOLDING              ?
      X0LNSPEED    = 11;                    _TRANSMISSION SPEED OF DTEC?
      X0FLOWCTL    = 12;                    _FLOW CONTROL OF PAD BY THE?
                                            _ DTE-C                    ?
      X0LFINSERT   = 13;                    _LF INSERTION AFTER CR     ?
      X0LFPADDING  = 14;                    _PADDING AFTER LINE FEED   ?
      X0EDITING    = 15;                    _EDITING BY THE PAD        ?
      X0CHARDEL    = 16;                    _CHARACTER DELETION        ?
      X0LNDELETE   = 17;                    _LINE DELETION             ?
      X0LNDISPLAY  = 18;                    _LINE DISPLAY              ?
_ 
* * *  PAD PARAMETER VALUE. 
? 
_          * * *  DISCARD OUTPUT OPTIONS (X0DISCARD)  * * *            ?
  
      X08NODISCARD = 0;                     _DO NOT DISCARD OUTPUT     ?
      X08DISCARD   = 1;                     _DISCARD OUTPUT            ?
  
_ 
* * *  ERROR PAD MESSAGE. 
? 
      X0LESSBITS   = 0;                     _RECEIVED PAD MESSAGE      ?
                                            _ CONTAINED LESS THAN EIGHT?
                                            _ BITS.                    ?
      X0UNKNOWN    = 1;                     _UNRECOGNIZED MESSAGE CODE ?
                                            _ IN RECEIVED PAD MESSAGE. ?
      X0INCOMP     = 2;                     _PARAMETER FIELD FORMAT OF ?
                                            _ RECEIVED PAD MESSAGE WAS ?
                                            _ INCORRECT OR INCOMPATIBLE?
                                            _ WITH MESSAGE CODE.       ?
      X0UNRELATED  = 3;                     _RECEIVED PAD MESSAGE DID  ?
                                            _ NOT CONTAIN AN INTEGRAL  ?
                                            _ NUMBER OF OCTETS.        ?
  
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*              TEXT PROCESSING CONST                                  * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_ 
* * *  OUTPUT TEXT PROCESSING ENTRY STATES. 
? 
      X0SLL        = 1;                     _START OF LOGICAL LINE     ?
      X0OUTXPT     = 2;                     _TRANSPARENT STATE         ?
      X0STRHCFF    = 3;                     _STORE HC OR FF STATE      ?
      X0NEXTDATA   = 4;                     _PROCESS NEXT DATA STATE   ?
  
_ 
* * *  INPUT TEXT PROCESSING ENTRY STATE. 
? 
      X0XSBLK      = 1;                     _START OF LOGICAL LINE     ?
      X0XSSPL      = 2;                     _START OF PHYSICAL LINE    ?
      X0XSXPT      = 3;                     _TRANSPARENT STATE         ?
      X0XSNXT      = 6;                     _START MIDDLE OF BLOCK     ?
  
      X0FILL       = 6;                     _6 LINE FEEDS IN BETWEEN   ?
                                            _ PAGES IF PAGE OPTION ON  ?
      X0NUL        = 0;                     _                          ?
  
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*              MISCELLANEOUS PAD SUBTIP CONST                         * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_ 
* * *  LOCATION OF M-BIT AND Q-BIT IN PACKET. 
? 
      X0QM         = 4; 
      X0MAXPKT     = 6; 
  
_ 
* * *  CHARACTER RECOGNITION STATES 
  
?     X0SPEED      = 0;                     _SPEED RECOGNITION IGNORED ?
      X0CHREC      = 1;                     _CHAR RECOGNITION ACTIONED ?
      X0FORGETIT   = 2;                     _GET RID OF DATA BUFFER    ?
  
_ 
* * *  TIMER VALUE USED WHEN WAITING FOR CLEAR REQUEST
* * *  RESPONSE TO INVITATION TO CLEAR. 
? 
      X0TIMVAL     = 32767;                 _APPROX 1.45 MINUTES       ?
  
TYPE
  
  
*CALL X25TYP02
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*              PAD SUBTIP PACKET DEFINITION                           * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_ 
* * *  DEFINITION OF PACKET FLAGS.
? 
      X0PADDEF   = PACKED RECORD
  
                   XBSP1     : INTEGER;     _WORD 1: LCD AND FCD       ?
                   XBSP2     : B010BITS;    _WORD 2: BUFFER FLAGS      ?
                   XBLFEPL   : BOOLEAN;     _BLK-BLOCK BY #LF# CHAR    ?
                   XBEBLK    : BOOLEAN;     _LAST BUFFER FOR BLK-BLOCK ?
                   XBSP5     : B02BITS;     _SPARE                     ?
                   XBENDPKT  : BOOLEAN;     _T : THE LAST BUFFER FOR   ?
                                            _    A PACKET              ?
                   XBSP7     : B01BIT;      _RESERVED FOR THE SYSTEM   ?
                   XBSP8     : INTEGER;     _WORD 3: QUEUE CHAIN       ?
                   XBSP9     : B03BITS;     _SPARE                     ?
                   XBFRGQBIT : BOOLEAN;     _PACKET TYPE (Q - BIT)     ?
                                            _T : PAD PACKET            ?
                                            _F : DATA PACKET           ?
                   XBSP10    : B03BITS;     _SPARE                     ?
                   XBFRGMBIT : BOOLEAN;     _PACKET CHAIN (M - BIT)    ?
                                            _T : MORE PACKET CHAINED   ?
                                            _F : LAST PACKET           ?
                   XBSP11    : B08BITS;     _SPARE                     ?
                 END;  _ X0PADDEF ? 
  
      X0PADPTR = 'X0PADDEF; 
  
_ 
* * *  ACCESSING SYSTEM BUFFER DEFINITION AND SUBTIP DEFINITION.
? 
      X0BUFFER   = PACKED RECORD  CASE X0TAG1 : INTEGER OF
  
                 1: (X1BUFACSS : B0BUFPTR); _ACCESS THE GLOBAL BUFFER  ?
                                            _ DEFINITIONS              ?
                 2: (X1PADACSS : X0PADPTR); _ACCESS THE SUBTIP BUFFER  ?
                                            _ DEFINITIONS              ?
                 3: (X1TMRACSS : B7PKTPTR); _TIMER PACKET DEFINITION   ?
                                            _ USING 8 WORD BUFFER      ?
                 END;  _ X0BUFFER ? 
  
_ 
* * *  MESSAGE CODE DEFINITION. 
? 
      X0MSGCODE  = PACKED RECORD  CASE X0TAG2 : INTEGER OF
  
                 1: (X1SP9     : CHAR;      _UNUSED                    ?
                     X1MOCTET  : CHAR);     _MSSAGE CODE OCTET IN PAD  ?
                                            _ PACKET                   ?
                 2: (X1SP10    : B012BITS;  _UNUSED                    ?
                     X1MSGCODE : B04BITS);  _VALUE OF MESSAGE CODE     ?
                 END;  _ X0MSGCODE ?
  
_ 
* * *  PARAMETER REFERENCE AND VAULE IN PAD MESSAGE PACKET. 
? 
      X0PARM     = PACKED RECORD  CASE X0TAG3 : INTEGER OF
  
                 1: (X1CHRREF : CHAR;       _PARAMETER REFERENCE       ?
                     X1CHRVAL : CHAR);      _PARAMETER VALUE           ?
  
                 2: (X1ERROR  : BOOLEAN;    _ERROR BIT IN PARM REF     ?
                     X1REF    : B07BITS;    _7 BITS OF PARM REF        ?
                     X1VAL    : B08BITS);   _8 BITS OF PARM VALUE      ?
  
                 3: (X1REFVAL : INTEGER);   _INTEGER OVERLAY           ?
                 END;  _ X0PARM ? 
  
_ 
* * *  PAD M-BIT AND Q-BIT POSITION.
? 
      X0QMBITS   = PACKED RECORD  CASE X0TAG4 : INTEGER OF
  
                 1: (X1QMWORD : INTEGER);   _WORD CONTAINS Q AND M BITS?
  
                 2: (X1SP20   : B03BITS;    _SPARE                     ?
                     X1QBIT   : BOOLEAN;    _Q-BIT                     ?
                     X1SP21   : B03BITS;    _SPARE                     ?
                     X1MBIT   : BOOLEAN;    _M-BIT                     ?
                     X1SP22   : B08BITS);   _UNUSED                    ?
                 END;  _ X0QMBITS ? 
  
  
VAR 
      X1TIPIDENT   : PACKED                 _PAD SUBTIP IDENTIFIER     ?
                      ARRAY [1..6] OF CHAR; _ IN CORE MEMORY           ?
_ 
* * *  INPUT AND OUTPUT WORKLIST ENTRY WORKING AREA.
? 
      X1INWKLST    : X0PARAMS;              _SAVE INPUT WORKLIST       ?
      X1OUTWKLST   : X0PARAMS;              _SAVE OUTPUT WORKLIST      ?
  
_ 
* * *  PAD SUBTIP GLOBAL POINTERS.
? 
      DUMPTR       : B0BUFPTR;              _DUMMY BUFFER POINTER      ?
      X1TCBADDR    : B0BUFPTR;              _TCB ADDRESS               ?
      X1LCBADDR    : BZLCBP;                _LCB ADDRESS               ?
  
_ 
* * *  UPLINE AND DOWNLINE PACKET POINTERS. 
? 
      X1DLFRGMT    : B0BUFPTR;              _DOWNLINE PACKET POINTER   ?
      X1UPLPKT     : B0BUFPTR;              _UPLINE PCAKET POINTER     ?
      X1ULPACKET   : B0BUFPTR;              _NEXT UPLINE PACKET POINTER?
  
_ 
* * *  M - BIT AND Q - BIT IN PACKET. 
? 
      X1QMBITS     : X0QMBITS;
  
_ 
* * *  PAD MESSAGE PACKET POINTER AND MESSAGE CODE. 
? 
      X1PADPKT     : X0BUFFER;              _PACKET POINTER            ?
      X1PADMSG     : INTEGER;               _PAD MESSAGE               ?
  
_ 
* * *  POINTER FOR THE TERMINAL RESPONSE MESSAGE. 
? 
      X1TMLRSPMSG  : B0BUFPTR;
  
_ 
* * *  USED FOR RELEASING TEXT PROCESSING SOURCE DATA BUFFERS.
? 
      X1NCFSBA     : B0BUFPTR;              _FIRST SOURCE BUFFER PTR   ?
      X1NCSBP      : B0OVERLAY;             _CURRENT SOURCE BUFFER PTR ?
      X1NCEOSR     : BOOLEAN;               _END OF BUFFER FLAG        ?
      X1NCRIGHTC   : BOOLEAN;               _LEFT OR RIGHT CHAR IN WORD?
  
_ 
* * *  TIMER PACKET ACCESS. 
? 
      X1TMRPKT     : X0BUFFER;
  
_ 
* * *  MISCELLANEOUS VARIABLES. 
? 
      X1PKTCNT     : INTEGER;               _OUTSTANDING UPLINE        ?
                                            _ PACKET COUNT             ?
      X1CURPOS     : INTEGER;               _TYPE OF CURPOS REQUIRED   ?
      X1PADTYPE    : PACKED ARRAY [X0PARIND .. X0SETREAD] OF BOOLEAN; 
      X1MSGPKT     : B0BUFPTR;              _DOWNLINE PAD MESSAGE PTR  ?
  
_ 
* * *  ULTS (BIP) INTERFACE FLAG. 
? 
      X1FLGWRD     : KTULTSFLG; 
  
_ 
* * *  UPLINE BLOCK POINTER.
? 
      X1ULBLOCK    : B0BUFPTR;
  
_ 
* * *  BLOCK TYPE OF THE DOWNLINE BLOCK.
? 
      X1BLKTYPE    : INTEGER; 
  
_ 
* * *  RECEIVED INDICATION OF BREAK FLAG FOR TRUSTED PATH.
? 
      X1SECURITY   : BOOLEAN; 
  
VALUE 
  
      X1TIPIDENT   = (#PADTIP#);            _IDENTIFIER CHARACTERS     ?
  
      X1PADTYPE    = (0, 1, 1, 0, 1, 0, 1); 
      DUMPTR       = 0; 
  
_$J+  PAGE EJECT? 
_ 
* * * *  PAD SUBTIP LEVEL II PROCEDURE FORWARD DEFINES
? 
  
PROCEDURE PXPINPUTTP;                                           FORWARD;
PROCEDURE PXPPADPROCESS;                                        FORWARD;
PROCEDURE PXPOUTPUTTP;                                          FORWARD;
PROCEDURE PXPRELSRC;                                            FORWARD;
PROCEDURE PXPQUEFRG     (X9WKCODE : B06BITS; X9TIP : INTEGER);  FORWARD;
PROCEDURE PXPFMDLFRG;                                           FORWARD;
PROCEDURE PXPDLHANDLER;                                         FORWARD;
PROCEDURE PXPSPM;                                               FORWARD;
PROCEDURE PXCPADVALUE  (X9SEND : BOOLEAN);                      FORWARD;
_$J+  PAGE EJECT? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*              CHECK OUTPUT STATUS  ( PXPCHECKOUT )  : LEVEL II       * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
** OVERVIEW:                                                          * 
*              THIS ROUTINE CALLS THE DOWNLINE HANDLER ROUTINE        * 
*              IF THE PADTIP IS NOT WAITING FOR THE UPLINE AUTO       * 
*              INPUT DATA OR THE PADTIP IS NOT PROCESSING ANY         * 
*              OUTPUT.  THIS ROUTINE WILL KEEP ON CALLING THE         * 
*              DOWNLINE HANDLER ROUTINE UNTIL THE NETWORK QUEUE       * 
*              IS EXHAUSTED.                                          * 
** INPUT:                                                             * 
*              TCB ADDRESS                  : X1TCBADDR               * 
** OUTPUT:                                                            * 
*              NONE                                                   * 
*                                                                     * 
** CALLING PROGRAM:                                                   * 
*                                                                     * 
*              PAD SUBTIP WORKLIST HANDLER  : PXPADTIP                * 
*                                                                     * 
** SUBROUTINE CALL:                                                   * 
*                                                                     * 
*     EXTERNAL SUBROUTINE                                             * 
*              CHECK IF A BUFFER AVAILABLE  : PB1BFAVAIL              * 
*                                                                     * 
*     INTERNAL SUBROUTINE                                             * 
*              DOWNLINE HANDLER             : PXPDLHANDLER            * 
*                                                                     * 
** NOTES:                                                             * 
*              THE DOWNLINE FRAGMENT REQUEST FLAG (BSXFRGREQ)         * 
*              IS ONLY RESET BY THE FORM DOWNLINE FRAGMENT            * 
*              ROUTINE (PXPFMDLFRG)                                   * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PXPCHECKOUT;
  
VAR 
      OUTOK : BOOLEAN;                      _IT IS OK TO GENERATE MORE ?
                                            _ PACKETS FOR TRANSPORT    ?
BEGIN 
WITH  X1TCBADDR'.BSTCB  DO
  BEGIN 
  IF BSXFRGREQ                              _FRAGMENT REQUEST FROM     ?
  THEN                                      _ LEVEL 3                  ?
    IF BSAUREC = FALSE                      _ CHRACTER RECOGNITION IS  ?
    THEN                                    _ NOT IN PROGRESS          ?
    BEGIN 
    OUTOK := ((BSXEOB ! BSFLDPLX)           _END OF BLOCK OR PLATO MODE?
                &                           _  AND                     ?
              NOT (BSXEPAGE ! BSXBREAK));   _NOT IN PAGE WAIT  OR      ?
                                            _ NO BREAK IND OUTSTANDING ?
    IF OUTOK                                _AND END OF BLOCK RECEIVED ?
    THEN
      IF PB1BFAVAIL (B0THMUX)               _AND BUFFERS AVAILABLE     ?
      THEN                                  _THEN WHILE                ?
        WHILE (BSQPTR.BABUFPTR " NIL)       _D/L DATA FOUND IN TCB     ?
                      &                     _AND                       ?
              (BSXDLSRC        = NIL) DO    _NO D/L DATA TAKEN YET, DO ?
          PXPDLHANDLER;                     _PROCESS D/L DATA FROM QUE ?
    IF BSXDLSRC " NIL 
    THEN                                    _D/L SOURCE AVAILABLE      ?
      IF OUTOK                              _GO FOR IT                 ?
      THEN
        PXPFMDLFRG;                         _CREATE PACKET(S)          ?
    END; _ IF BSXFRGREQ                                                ?
  END;  _ WITH X1TCBADDR                                               ?
END;  _ PROCEDURE PXPCHECKOUT : CHECK OUTPUT STATUS                    ?
_$J+  PAGE EJECT? 
_ 
** PROCEDURE NAME - P X P C U R S O R 
* 
** OVERVIEW       - THIS PROCEDURE CREATES THE DOWNLINE BLOCK IMAGE 
*                   CONTAINING CURSOR POSITIONING DATA. 
? 
PROCEDURE PXPCURSOR;
  
VAR 
      X6CURPOS  : ARRAY [0..3] OF INTEGER;
      X6CPTYPE  : ARRAY [1..3] OF INTEGER;
      X6CPLFCD  : ARRAY [1..3] OF INTEGER;
  
VALUE 
      X6CURPOS  = ($0602,$002C,$0D0A,$1F00);
      X6CPTYPE  = ($0D1F,$0A1F,$0D0A);
      X6CPLFCD  = ($0502,$0502,$0602);
  
BEGIN 
IF X1TCBADDR'.BSTCB.BSNINCP = FALSE         _IF OK TO POSITION CURSOR  ?
THEN
  BEGIN 
_ 
* * * *  CREATE D/L BLOCK IMAGE FOR CURSOR POSITION 
? 
  X6CURPOS [0] := X6CPLFCD [X1CURPOS];      _INSERT PROPER LCD/FCD     ?
  X6CURPOS [2] := X6CPTYPE [X1CURPOS];      _INSERT REQUESTED CURPOS   ?
  ADDR (X6CURPOS [0], X1TMLRSPMSG);         _ADDRESS OF CURPOS MESSAGE ?
  PXPFMDLFRG;                               _TP CURSOR POSITION BLOCK  ?
  END; _X1TCBADDR.BSTCB.BSNINCP?
END;
_$J+ PAGE EJECT?
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*              DOWNLINE HANDLER  ( PXPDLHANDLER )  : LEVEL II         * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
** OVERVIEW:                                                          * 
*              THE DOWNLINE HANDLER ROUTINE GETS A DOWNLINE NETWORK   * 
*              BLOCK FROM BIP AND SENDS THE BLOCK TO THE FORM         * 
*              DOWNLINE FRAGMENT ROUTINE.  THE ROUTINE KEEPS THE      * 
*              AUTO INPUT BUFFER IF AUTO INPUT MODE IS DEFINED        * 
*              IN THE DBC. THE DOWNLINE NETWORK BLOCK POINTER WILL    * 
*              BE STORED IN TCB (BSXDLSRC).                           * 
** INPUT:                                                             * 
*              TCB ADDRESS                  : X1TCBADDR               * 
** OUTPUT:                                                            * 
*              DOWNLINE NETWORK BLOCK       : X4DLBLOCK (BSXDLSRC)    * 
*                                                                     * 
** CALLING PROGRAM:                                                   * 
*                                                                     * 
*              CHECK FOR STATUS OF OUTPUT   : PXPCHECKOUT             * 
*                                                                     * 
** SUBROUTINE CALL:                                                   * 
*                                                                     * 
*     EXTERNAL SUBROUTINE                                             * 
*              BIP QUEUE MAINTENANCE        : PBQUEMAINT              * 
*              DOWNLINE COMMAND PROCESSOR   : PTDLCMD                 * 
*              RELEASE CHAIN OF BUFFERS     : PBRELCHN                * 
*              GET A BUFFER                 : PBGET1BF                * 
*                                                                     * 
*     INTERNAL SUBROUTINE                                             * 
*              FORM DOWNLINE FRAGMENT       : PXPFMDLFRG              * 
*                                                                     * 
** NOTES:                                                             * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PXPDLHANDLER; 
  
VAR 
      X4DLBLOCK     : B0BUFPTR;             _DOWNLINE NETWORK BLOCK    ?
      X4INDEX       : INTEGER;
      X4DBC         : DBDBC;                _LOCAL DBC FIELD           ?
      DUMPTR        : B0BUFPTR;             _DUMMY BUFPTR              ?
  
BEGIN 
WITH  X1TCBADDR'.BSTCB  DO
  BEGIN 
_ 
  * * *  CALL BIP TO GET THE DOWNLINE NETWORK 
  * * *  BLOCK FROM DOWNLINE DATA QUEUE.
? 
  PBQUEMAINT (X1TCBADDR,                    _TCB ADDRESS               ?
              X4DLBLOCK,                    _RETURN WITH DL DATA PTR   ?
              K4GETNB);                     _DO NOT SEND BACK          ?
_ 
  * * *  WORK WITH THE DOWNLINE DATA BLOCK. 
? 
  IF X4DLBLOCK " NIL                        _RECEIVED DOWNLINE BLOCK   ?
  THEN
    BEGIN 
    X1BLKTYPE := X4DLBLOCK'.BIINT[BTWD];    _EXTRACT BLOCK TYPE FROM   ?
                                            _ DOWNLINE DATA BUFFER     ?
    IF X1BLKTYPE = HTCMD                    _DOWNLINE CMD BLOCK        ?
    THEN
      BEGIN 
      DUMPTR  := NIL; 
      PBQUEMAIN (X1TCBADDR,                 _TCB ADDRESS               ?
                 DUMPTR,                    _NIL                       ?
                 K4PUTBC);                  _TELL BIP TO SEND BACK     ?
      PTDLCMD (X1TCBADDR,X4DLBLOCK);        _PROCESS COMMAND           ?
      END   _ IF X1BLKTYPE = CMDBLOCK                                  ?
    ELSE                                    _X1BLKTYPE " CMDBLOCK      ?
      IF (X1BLKTYPE @ HTMSG) &              _LOOK FOR DOWNLINE BLK OR  ?
         (X4DLBLOCK'.BFLCD > DBC)           _ NOT EMPTY BLOCK OR       ?
                                            _ MSG TYPE BLOCK           ?
      THEN
        BEGIN 
_ 
        * * *  RECEIVED DOWNLINE BLK/MSG BLOCK. 
? 
        X4DBC.DBCHAR := X4DLBLOCK'.         _EXTRACT DBC FIELD FROM    ?
                             BFDATAC[DBC];
        BSXDLBLOCK   := X1BLKTYPE;          _SAVE DOWNLINE BLOCK TYPE  ?
        X4DLBLOCK'.                         _RESET BUFFER FCD          ?
               BFFCD := DBC;
        BSXDLSRC     := X4DLBLOCK;          _INITIALIZE DL SRC BUF PTR ?
        END   _ IF BLK OR MSG TYPE BLOCK                               ?
      ELSE                                  _DOWNLINE BLOCK IS NOT     ?
        BEGIN 
        PBRELCHN (X4DLBLOCK, BEDBSIZE);     _ EMPTY BLOCK              ?
        PBQUEMAIN(X1TCBADDR,                _TCB ADDRESS               ?
                  X4DLBLOCK,                _NIL                       ?
                  K4PUTBC);                 _TELL BIT TO SEND BACK     ?
        END;
    END;  _ IF X4DLBLOCK " NIL                                         ?
  END;  _ WITH X1TCBADDR                                               ?
END; _ PROCEDURE PXPDLHANDLER : DOWNLINE HANDLER                       ?
_$J+  PAGE EJECT? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*              FORM DOWNLINE FRAGMENT  ( PXPFMDLFRG )  : LEVEL II     * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
** OVERVIEW:                                                          * 
*              THE FORM DOWNLINE FRAGMENT RECEIVES THE DOWNLINE       * 
*              NETWORK BLOCK OR THE TERMINAL RESPONS DATA.  IT        * 
*              CALLS THE OUTPUT TEXT PROCESS ROUTINES TO TEXT         * 
*              PROCESS THE RECEVING DATA.  THE RESULT OF OUTPUT       * 
*              TEXT PROCESSING THIS ROUTINE CALLS THE QUEUE           * 
*              DOWNLINE FRAGMENT ROUTINE TO QUEUE THE FRAGMENT        * 
*              (TEXT PROCESSED DATA) TO THE PACKET LEVEL (LEVEL 3).   * 
** INPUT                                                              * 
*              TCB ADDRESS                  : X1TCBADDR               * 
*              DOWNLINE TERMINAL RESPONSE   : X1TMLRSPMSG             * 
*                OR                                                   * 
*              DOWNLINE NETWORK BLOCK       : BSXDLSRC                * 
** OUTPUT                                                             * 
*              WORKCODE                     : X8L3WKC                 * 
*              DOWNLINE FRAGMENT            : X1DLFRGMT               * 
*                                                                     * 
** CALLING PROGRAM:                                                   * 
*                                                                     * 
*              DOWNLINE HANDLER             : PXPDLHANDLER            * 
*              INPUT TEXT PROCESSING        : PXPINPUTTP              * 
*              FORM UPLINE BLOCK            : PXPFMULBLK              * 
*                                                                     * 
** SUBROUTINE CALL:                                                   * 
*                                                                     * 
*     EXTERNAL SUBROUTINE                                             * 
*              NONE                                                   * 
*                                                                     * 
*     INTERNAL SUBROUTINE                                             * 
*              OUTPUT TEXT PROCESS          : PXPOUTPUTTP             * 
*              QUEUE DOWNLINE FRAGMENT      : PXPQUEFRG               * 
*                                                                     * 
** NOTES:                                                             * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PXPFMDLFRG; 
  
VAR 
      X2DLPKT : B0BUFPTR; 
      X2PECHO : BOOLEAN;
      X2PNOCP : BOOLEAN;
      X2WORK  : INTEGER;
  
BEGIN 
WITH X1TCBADDR'.BSTCB DO
  BEGIN 
  X2DLPKT := BSXDLSRC;                      _SET STARTING BUFFER PTR   ?
  X2WORK  := 1;                             _INITIALIZE BUFFER COUNT   ?
  WHILE X2DLPKT " NIL DO
    BEGIN 
    X2WORK  := X2WORK + 1;                  _BUMP NUMBER OF BUFFERS    ?
    X2DLPKT := X2DLPKT'.BCCHAINS[DBUFLENGTH]; _NEXT CHAINED BUFFER PTR ?
    END;
  
_     NOTE: PACKET SIZE IS ASSUMED TO BE 64 CHARACTERS OR GREATER      ?
_           TO REACH THE REQUIRED ADDITIONAL BUFFER COUNT.             ?
  
  IF PBNBFAVAIL (X2WORK, B0THMUX) = FALSE   _BUFFERS NOT AVAILABLE     ?
  THEN
    BEGIN 
    BSLCCBPTR'.LCCB.LCNOBUF := TRUE;        _TRY LATER                 ?
    GOTO 99;
    END;
  PXPOUTPUTTP;
  IF X1DLFRGMT " NIL                        _QUEUE DOWNLINE PACKET     ?
  THEN                                      _ TO PACKET LEVEL (LEVEL 3)?
    BEGIN 
    X2DLPKT := BSDLPACKET;
    IF X2DLPKT = NIL                        _NO DOWNLINE PACKET        ?
    THEN
      BSDLPACKET := X1DLFRGMT 
    ELSE
      BEGIN 
      WHILE X2DLPKT'.BCCHAINS[QCHN] " NIL DO _LOOK FOR LAST PACKET     ?
        X2DLPKT := X2DLPKT'.BCCHAINS[QCHN]; _GET NEXT PACKET           ?
      X2DLPKT'.BCCHAINS[QCHN] := X1DLFRGMT; 
      END;
    BSXFRGREQ  := FALSE;
    IF BSECHOPLEX ! BSCURPOS                _IF ECHPLEX OR NO CP       ?
    THEN                                    _CHECK IF PAD ECHOING AND  ?
      BEGIN                                 _AND IF NOT ECHO ON INPUT  ?
      X2PECHO := BSPADVALUES[X0ECHO] = CHR(1);
      X2PNOCP := BSPADVALUES[X0LFINSERT] = CHR(4);
      IF (X2PECHO = BSXNECHO) ! (X2PNOCP = BSNINCP) 
      THEN                                  _INPUT                     ?
        PXCPADVALUES (FALSE);               _ECHOPLEX AFFECTS CURSOR   ?
      END _BSECHOPLEX ! BSCURPOS? 
    ELSE                                    _CLEAR BSXNECHO FLAG       ?
      BEGIN 
      BSXNECHO := FALSE;                    _CLEAR NO-ECHO-NEXT-INPUT  ?
      BSNINCP  := FALSE;                    _CLEAR NO CP NEXT INPUT    ?
      END; _ELSE BSECHOPLEX ! BSNINCP?
    END; _WITH X1TCBADDR'.? 
  END;
  
99: 
END;  _ PROCEDURE PXPFMDLFRG : FORM DOWNLINE FRAGMENT                  ?
_$J+  PAGE EJECT? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*              FORM PAD MESSAGE  ( PXPFMPADMSG )  : LEVEL II          * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
** OVERVIEW:                                                          * 
*              THE FORM PAD MESSAGE SETS UP Q-BIT AND M-BIT IN        * 
*              THE DOWNLINE PAD PACKET AND SENDS IT TO THE DOWNLINE   * 
*              FRAGMENT QUEUEING ROUTINE.                             * 
** INPUT:                                                             * 
*              TCB ADDRESS                  : X1TCBADDR               * 
*              DOWNLINE PAD MESSAGE         : X1PADPKT                * 
** OUTPUT:                                                            * 
*              FRAGMENT QUEUED WORKLIST TO  : TPFRGQ                  * 
*               PACKET LEVEL (LEVEL 3)                                * 
*              DOWNLINE PAD MESSAGE PACKET  : X1DLFRGMT               * 
*                                                                     * 
** CALLING PROGRAM:                                                   * 
*                                                                     * 
*              PAD PROCESS                  : PXPPADPROCESS           * 
*              SET PSN X.3 PARAMETER        : PXPSETX3                * 
*                                                                     * 
** SUBROUTINE CALL:                                                   * 
*                                                                     * 
*     EXTERNAL SUBROUTINE                                             * 
*              NONE                                                   * 
*                                                                     * 
*     INTERNAL SUBROUTINE                                             * 
*              QUEUE DOWNLINE FRAGMENT      : PXPQUEFRG               * 
*                                                                     * 
** NOTES:                                                             * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PXPFMPADMSG;
  
VAR 
      X7MSGCODE  : X0MSGCODE;               _PAD MESSAGE CODE FIELD    ?
      X7DLPKT    : B0BUFPTR;                _DOWNLINE PACKET POINTER   ?
  
BEGIN 
X1DLFRGMT          := X1PADPKT.X1BUFACSS;   _LOCAL COPY                ?
X7MSGCODE.X1MOCTET := X1DLFRGMT'.           _EXTRACT MESSAGE CODE      ?
                          BFDATAC[X0MCODE]; _ OCTET                    ?
IF X1PADTYPE[X7MSGCODE.X1MSGCODE]           _CHECK FOR SET, READ OR    ?
THEN                                        _ SETREAD MESSAGE          ?
  BEGIN 
  REPEAT                                    _LOOP THRU PAD PACKETS     ?
    X1PADPKT.X1PADACSS'.                    _PAD MESSAGE               ?
                    XBFRGQBIT := TRUE;
    X1PADPKT.X1PADACSS'.                    _SET M-BIT                 ?
                    XBFRGMBIT :=
                          X1PADPKT.X1BUFACSS'.BCCHAINS[QCHN] " NIL; 
    X1PADPKT.X1BUFACSS   :=                 _ADDRESS OF NEXT PACKET    ?
        X1PADPKT.X1BUFACSS'.BCCHAINS[QCHN]; _ IN CHAIN                 ?
  UNTIL  X1PADPKT.X1BUFACSS = NIL;          _UNTIL CHECK ALL THE PACKET?
                                            _ IN CHAIN                 ?
  X7DLPKT := X1TCBADDR'.BSTCB.BSDLPACKET; 
  IF X7DLPKT = NIL
  THEN
     X1TCBAD'.BSTCB.BSDLPACKET := X1DLFRGMT 
  ELSE
    BEGIN 
    WHILE X7DLPKT'.BCCHAINS[QCHN] " NIL DO
      X7DLPKT := X7DLPKT'.BCCHAINS[QCHN]; 
    X7DLPKT'.BCCHAINS[QCHN] := X1DLFRGMT; 
    END;
  END;  _ IF MSG CODE = X0SET OR X0READ OR X0SETREAD                   ?
END;  _ PROCEDURE PXPFMPADMSG : FORM PAD MESSAGE                       ?
_$J+  PAGE EJECT? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*      SEND PAD MESSAGE FOR SET PARAMETER(S)  (PXPSPM) :LEVEL II      * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
** OVERVIEW:                                                          * 
*              GIVEN THE PAD MESSAGE INFORMATION IN THE BUFFER,       * 
*              PXPSPM SENDS A SET TYPE PAD MESSAGE.                   * 
** INPUT:                                                             * 
*              PAD MESSAGE BUFFER ADDRESS   : X1PADPKT                * 
*              PAD MESSAGE LCD/FCD IN THE BUFFER                      * 
*              PAD MESSAGE INFORMATION IN THE BUFFER                  * 
** OUTPUT:                                                            * 
*              SET TYPE PAD MESSAGE IS SENT.                          * 
*                                                                     * 
** CALLING PROGRAM:                                                   * 
*                                                                     * 
*              RESUME OUTPUT AT TO OR RO    : PXPDLHANDLER            * 
*              DISCATD OUTPUT AT ICMD       : PXPADTIP                * 
*                                                                     * 
** SUBROUTINE CALL:                                                   * 
*                                                                     * 
*     INTERNAL SUBROUTINE                                             * 
*              FORM PAD MESSAGE             : PXPFMPADMSG             * 
*                                                                     * 
** NOTES:                                                             * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PXPSPM; 
BEGIN 
WITH X1PADPKT.X1BUFACSS' DO 
  BEGIN 
  BIINT[X0MCODE/2+1]  := X0SET;             _PAD MESSAGE CODE          ?
  BCCHAIN[QCHN]       := NIL; 
  BCCHAIN[DBUFLENGTH] := NIL; 
  END;
PXPFMPADMSG;                                _FORM PAD MESSAGE          ?
END;  _ PROCEDURE PXPSPM : SEND PAD MESSAGE FOR SET                    ?
_$J+  PAGE EJECT? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*              FORM UPLINE BLOCK  ( PXPFMULBLK )  : LEVEL II          * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
** OVERVIEW:                                                          * 
*              THIS ROUTINE PASSES THE UPLINE NETWORK DATA TO         * 
*              UPLINE TIP SERVICE.  IT ALSO CHECK FOR RESPONSES       * 
*              IN X1FLGWRD IF MSG-BLOCK WAS SEND.                     * 
*                                                                     * 
** INPUT:                                                             * 
*              TCB ADDRESS                  : X1TCBADDR               * 
*              ULTS FLAG WORD IN TCB        : X1FLGWRD                * 
** OUTPUT:                                                            * 
*              UPLINE BLOCK POINTER         : X1ULBLOCK               * 
*              ULTS FLAG WORD IN TCB        : X1FLGWRD                * 
*                                                                     * 
** CALLING PROGRAM:                                                   * 
*                                                                     * 
*              UPLINE HANDLER               : PXPULHANDLER            * 
*              INPUT TEXT PROCESSING        : PXPINPUTTP              * 
*                                                                     * 
** SUBROUTINE CALL:                                                   * 
*                                                                     * 
*     EXTERNAL SUBROUTINE                                             * 
*              UPLINE TIP SERVICE           : PBULTS                  * 
*              DOWNLINE QUEUE MAINT.        : PBQUEMAINT              * 
*              GET A BUFFER                 : PBGET1BF                * 
*              RELEASE CHAIN OF BUFFERS     : PBRELCHN                * 
*                                             PBRELZRO                * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PXPFMULBLK; 
  
VAR 
      X6SECHAR  : CHAR;                     _SECURITY CHARACTER        ?
      X6DATA    : CHAR;                     _CURRENT DATA CHARACTER    ?
      X6STOP    : BOOLEAN;
      X6INDEX   : INTEGER;                  _DATA INDEX                ?
  
BEGIN 
WITH X1TCBADDR'.BSTCB DO
  BEGIN 
  IF BSCURPOS                               _POSITIONING SELECTED      ?
  THEN
    IF X1CURPOS " 0                         _ACTION NOT NONE           ?
    THEN
      IF NOT BSXPT                          _NOT IN TRANSPARENT MODE   ?
      THEN
        IF BSPADVALUES[X0LFINSERT] " CHR(4) _PAD NOT PERFORMING ACTION ?
        THEN
          IF (ORD (X1UPLPKT) +              _AND NO PACKETS OUTSTANDING?
              ORD (X1ULPACKET)) = 0 
          THEN
            IF BSLCCBPTR'.LCCB.LCDPQR = NIL _AND NO DOWNLINE PACKETS   ?
            THEN
              PXPCURSOR;                    _SEND CURSOR POSITION DATA ?
_ 
  * * *  CHECK FOR TRUSTED PATH BEFORE SEND DATA TO BIP.
? 
  X6SECHAR := CHR(BSSECHAR);                _CONVERT IT TO CHARACTER   ?
  X6INDEX  := $D;                           _THE FIRST DATA POSITION   ?
  X6DATA   := X1ULBLOCK'.BFDATAC[X6INDEX];  _EXTRACT DATA              ?
  IF X1SECURITY = FALSE                     _NO TRUSTED PATH TO BE     ?
  THEN                                      _ CHECKED                  ?
    BEGIN 
    IF X6DATA = X6SECHAR                    _SEEING SECURITY CHAR      ?
    THEN                                    _ BUT DO NOT ACTION IT     ?
      IF X1ULBLOCK'.BFLCD = X6INDEX         _RESET KTCKSPC SO THAT     ?
      THEN                                  _ BIP DOES NOT CONFUSE     ?
        X1FLGWRD.KTCKSPC := FALSE;          _ WITH TRUSTED PATH        ?
    END 
  ELSE                                      _NEED TO CHECK FOR         ?
    BEGIN                                   _ SECURITY CHARACTER       ?
    X1SECURITY := FALSE;
    IF BSSECHAR " 0                         _SECURITY CHARACTER        ?
    THEN                                    _ ASSIGNED                 ?
      BEGIN 
      IF X6DATA = X6SECHAR                  _CHECK FOR SECURITY CHAR   ?
      THEN
        BEGIN 
10:     X1ULBLOCK'.BFLCD := $D;             _ONLY SECURITY DATA IN     ?
                                            _ THIS UPLINE BLOCK        ?
        PBRELZRO (X1ULBLOCK'.               _RELEASE UPLINE DATA       ?
                    BCCHAINS[DBUFLENGTH],   _ BUFFERS EXPECT THE       ?
                                 BEDBSIZE); _ FIRST BUFFER             ?
        X1FLGWRD.KTWORD  := 0;
        X1FLGWRD.KTCKSPC := TRUE;           _CHECK FOR SPECIAL         ?
        X1ULBLOCK'.BFXPT := FALSE;          _CLEAR THE XTP FLAG IN BUF ?
        X1SECURITY       := BSXPT;          _IN TRANSPARENT MODE       ?
                                            _NEED TO END TRANSPARENT   ?
        END   _ IF X6DATA = X6SECHAR                                   ?
      ELSE
        BEGIN 
        IF BSXPT = FALSE                    _IN NON-TRANSPARENT WITH   ?
        THEN                                _ FULL ASCII MODE, IT IS   ?
          IF BSFLASCII                      _ POSSIBLE THAT THERE ARE  ?
          THEN                              _ SOME NON USER DATA BEFORE?
            BEGIN                           _ DETECTING SECURITY DATA  ?
            X6STOP := FALSE;
            REPEAT
              IF ORD(X6DATA) \ $20          _USER DATA FOUND           ?
              THEN
                X6STOP := TRUE
              ELSE
                BEGIN 
                X6INDEX := X6INDEX + 1;     _NEXT DATA CHARACTER       ?
                IF X1ULBLOCK'.BFLCD         _INDEX WENT OVER THE LAST  ?
                                 < X6INDEX  _ DATA IN THE FIRST BUFFER ?
                THEN                        _CHECK ONLY FOR THE FIRST  ?
                  X6STOP := TRUE            _ BUFFER IN CHAIN          ?
                ELSE
                  BEGIN 
                  X6DATA := X1ULBLOCK'.BFDATAC[X6INDEX];
                  IF X6DATA = X6SECHAR      _CHECK FOR SECURITY DATA   ?
                  THEN
                    BEGIN 
                    X1ULBLOCK'.BFDATAC[$D] := X6SECHAR; 
                    GOTO 10;
                    END;
                  END;  _ ELSE BFLCD < X6INDEX                         ?
                END;  _ ELSE X6DATA \ $20                              ?
            UNTIL X6STOP; 
            END;  _ IF BSFLASCII                                       ?
        END;  _ ELSE X6DATA = X6SECHAR                                 ?
      END;  _ IF BSSECHAR " 0                                          ?
    END;  _ IF X1SECURITY                                              ?
  PBULTS (X1TCBADDR,                        _CALLING ULTS WITH TCB ADDR?
          X1ULBLOCK,                        _ UPLINE NETWORK BLOCK     ?
          X1FLGWRD);                        _ FLAG WORD FOR ULTS       ?
  BSNINCP := BSNINCP & X1FLGWRD.KTCAN;      _CLEAR NINCP IF NOT CANCEL ?
  IF BSECHOPLEX                             _ DO WE ECHOPLEX INPUT     ?
  THEN
    BEGIN 
    IF BSXNECHO                             _ NO-ECHO-NEXT-INPUT       ?
    THEN
      BEGIN 
      IF BSXIVT = FALSE                     _ WAS INPUT IVT COMMAND    ?
      THEN
        BEGIN 
        IF X1FLGWRD.KTCAN = FALSE           _ WAS LAST INPUT CANCEL    ?
        THEN
          BEGIN 
          BSXNECH0 := FALSE;                _ CLEAR NO ECHO NEXT INPUT ?
          PXCPADVALUES (FALSE);             _ ECHOPLEX NEXT INPUT      ?
          END;
        END 
      ELSE
        BEGIN 
        BSXIVT := FALSE;                    _ CLEAR IVT COMMAND        ?
        IF BSPADVALUES[X0ECHO] = CHR (1)    _ INPUT IN ECHOPLEX MODE   ?
        THEN                                _ YES                      ?
          PXCPADVALUES (FALSE);             _ DO NOT ECHO NEXT INPUT   ?
        END;
      END 
    ELSE
      BEGIN 
      BSXIVT := FALSE;                      _ CLEAR IVT COMMAND FLAG   ?
      IF BSPADVALUES[X0ECHO] = CHR (0)      _ PAD IN NO ECHO MODE      ?
      THEN
        PXCPADVALUES (FALSE);               _ PUT INPUT IN ECHO MODE   ?
      END;
    END 
  ELSE
    BEGIN 
    BSXNECHO := FALSE;                      _ CLEAR NO ECHO FLAGE      ?
    IF BSPADVALUES[X0ECHO] = CHR (1)        _ PAD IN NO-ECHO MODE      ?
    THEN
      BEGIN 
      BSXNECHO := TRUE;                     _ NO ECHOPLEX MODE         ?
      PXCPADVALUES (FALSE);                 _ PUT INPUT IN NO ECHO MODE?
      BSXNECHO := FALSE;                    _ CLEAR NO ECHO FLAGE      ?
      END;
    END;
  X1CURPOS := 0;                            _CLEAR CURPOS REQUEST      ?
  BSXLNCNT := 0;                            _DECLARE PAGE/SCREEN EMPTY ?
  IF BSXULBLOCL = HTMSG                     _THE LAST UPLINE BLOCK     ?
  THEN                                      _ WAS MSG-TYPE BLOCK       ?
    BEGIN 
_ 
    * * *  CHECK FOR THE RESPONSE (TCB FLAG WORD) FROM ULTS.
? 
_ 
    * * *  BREAK SEEN  * * *
? 
    BSXBREAK := X1FLGWRD.KTBRKSEEN;         _GET BREAK RECEIVED FLAG   ?
    BSXSECURITY := BSXBREAK;                _SAVE FOR TRUSTED PATH     ?
_ 
    * * *  USER BREAK 1 OR 2  * * * 
? 
    IF X1FLGWRD.KTUBS " 0                   _USER BREAK 1 OR 2 SEEN    ?
    THEN
      BEGIN 
      PBRELZRO (BSXDLSRC, BEDBSIZE);        _RELEASE SOURCE BUFFER     ?
      BSXDLBLOCK    := HTMSG;               _DEFAULT                   ?
      BSXEOB        := TRUE;                _SET END OF BLOCK          ?
      BSXEPAGE      := FALSE;               _CLEAR IT PAGE WAITING     ?
      BSXBREAK      := FALSE;               _CLEAR IT BREAK SEEN       ?
      BSXPLAST      := FALSE;               _CLEAR PL FLAG             ?
      BSXTPOUT      := 0;                   _CLEAR OUTPUT TP STATE     ?
      BSXTPFLAGS    := 0;                   _CLEAR OUTPUT TP           ?
                                            _ SAVED FLAGS              ?
      END;  _ IF KTUB1 OR KTUB2                                        ?
_ 
    * * *  TERMINAL RESPONSE  * * * 
? 
    IF X1FLGWRD.KTRESP                      _TML RESPONSE TO BE SENT   ?
    THEN
      BEGIN 
      IF BSAUREC                            _IF IN AUTO REC            ?
      THEN
        BEGIN 
        X1CURPOS := 3;                      _CR/LF CURSOR POSITION TYPE?
        BSXRECCH := X0SPEED;                _SET TO SPEED CHECK IGNORE ?
        END 
      ELSE                                  _IF NOT IN AUTO REC        ?
        BEGIN 
        BSXEOB := TRUE;                     _SET END OF BLOCK          ?
        PXPCHECKOUT;                        _LOCATE THE OUTPUT         ?
        END;
      END;  _ IF X1FLGWRD.KTRESP                                       ?
    END;  _ IF NOT BLK BLOCK SENT UPLINE                               ?
  END;  _ WITH X1TCBADDR                                               ?
END;  _PROCEDURE PXPFMULBLK : FORM UPLINE BLOCK                        ?
_$J+  PAGE EJECT? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*              INPUT TEXT PROCESS  ( PXPINPUTTP )  : LEVEL II         * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
** OVERVIEW:                                                          * 
*              THIS ROUTINE CALLS FIRMWARE INTERFACE PROGRAM TO       * 
*              TEXT PROCESS UPLINE DATA PACKETS AND CREATES UPLINE    * 
*              BLK OR MSG BLOCK OR SAVE THE TEXT PROCESSED DATA FOR   * 
*              NEXT TIME.                                             * 
*                                                                     * 
** INPUT:                                                             * 
*              TCB ADDRESS                  : X1TCBADDR               * 
*              UPLINE DATA PACKET           : X1UPLPKT                * 
** OUTPUT:                                                            * 
*              UPLINE DATA BLOCK            : X1ULBLOCK               * 
*                                                                     * 
** CALLING PROGRAM:                                                   * 
*                                                                     * 
*              UPLINE HANDLER               : PXPULHANDLER            * 
*                                                                     * 
** SUBROUTINE CALL:                                                   * 
*                                                                     * 
*     EXTERNAL SUBROUTINE                                             * 
*              CLEAR BUFFER                 : PBCLR                   * 
*              GET A BUFFER                 : PBGET1BF                * 
*              RELEASE A BUFFER             : PBREL1BF                * 
*              RELEASE CHAIN OF BUFFERS     : PBRELCHN                * 
*              TEXT PROCESSING              : PTTPINF                 * 
*               INTERFACE PROGRAM                                     * 
*                                                                     * 
*     INTERNAL SUBROUTINE                                             * 
*              FORM DOWNLINE FRAGMENT       : PXPFMDLFRG              * 
*              FORM UPLINE BLOCK            : PXPFMULBLK              * 
*              RELEASE TEXT PROCESSED       : PXPRELSRC               * 
*               SOURCE BUFFERS                                        * 
*                                                                     * 
** NOTES:                                                             * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PXPINPUTTP; 
  
CONST 
      X6DFTBSIZ  = 100;                     _DEFAULT VALUE FOR SIZE OF ?
                                            _ SUB BLOCK                ?
  
VAR 
      X6TPCBP    : B0BUFPTR;                _POINTER TO INPUT TEXT     ?
                                            _ PROCESSING CONTROL BLOCK ?
      X6ULDATA   : B0BUFPTR;                _UPLINE TEXT PROCESSED DATA?
      X6WORK     : B0OVERLAY;               _TEMP WORK VARIABLE        ?
      X61PTR     : B0BUFPTR;                _WORKING BUFFER POINTER    ?
      X6BLOCK    : X0BUFFER;                _WORKING CURRENT DEST.     ?
                                            _ BUFFER POINTER           ?
      X6DBP      : B0OVERLAY;               _CURRENT DESTINATION WORD  ?
                                            _ POINTER                  ?
      X6SUBBLK   : INTEGER;                 _SIZE OF SUB BLOCK         ?
      X61INT     : INTEGER;                 _FOR INDEX COUNTER         ?
      X6CHAR     : CHAR;                    _DISCARD FORWARD CHAR      ?
                                            _ IF IN FULL ASCII MODE    ?
      X6LCD      : B08BITS;                 _ADJUSTED BUFFER LCD       ?
      X6PROCESS  : BOOLEAN;                 _PROCESSING UPLINE PACKET  ?
      X61FLG     : BOOLEAN;                 _KEEPING *NCRINCH*         ?
                                            _ OR KEEPING *NCXEND*      ?
      X62FLG     : BOOLEAN;                 _KEEPING *NCXHH*           ?
  
      X6BLKSIZ   : ARRAY [1..5] OF PACKED RECORD
                     X6UPPER : B08BITS;     _UPPER SUB BLOCK SIZE LIMIT?
                     X6MULTI : B08BITS;     _ AND MULTIPLCATION VALUE  ?
                     END; 
  
      X6STATE    : ARRAY [BOOLEAN]          _NON TRANSPARENT MODE      ?
                               OF INTEGER;  _ ENTRY STATE              ?
  
      X6BLKTYPE  : ARRAY [BOOLEAN]          _DEFINE TYPE OF UPLINE     ?
                               OF INTEGER;  _ NETWORK BLOCK MSG OR BLK ?
  
VALUE 
      X6BLKSIZ   = ($1605,                  _PW @  22 : BKSIZ = PW * 5 ?
                    $1C04,                  _PW @  28 : BKSIZ = PW * 4 ?
                    $2503,                  _PW @  37 : BKSIZ = PW * 3 ?
                    $3802,                  _PW @  56 : BKSIZ = PW * 2 ?
                    $FF01);                 _PW @ 255 : BKSIZ = PW * 1 ?
  
      X6STATE    = (X0XSBLK,                _START OF BLOCK            ?
                                            _ (START OF LOGICAL LINE)  ?
                    X0XSSPL);               _START OF PHYSICAL LINE    ?
  
      X6BLKTYPE  = (HTBLK,                  _BLK-TYPE BLOCK            ?
                    HTMSG);                 _MSG-TYPE BLOCK            ?
  
_$J+ PAGE EJECT?
_ 
** PROCEDURE NAME - P X C H R E C 
* 
*OVERVIEW         - THIS PROCEDURE CHECKS THE CHARACTER ENTERED IN
*                   RESPONSE TO THE AUTO-REC IVT COMMAND AND SETS 
*                   FIELD BSCODE IN THE TCB TO THE CORRESPONDING
*                   CODE SET. 
? 
PROCEDURE PXCHREC;
  
VAR 
      TESTCHAR : CHAR;
  
BEGIN 
WITH  X1TCBADDR'.BSTCB  DO
  BEGIN 
  TESTCHAR := CHR($00); 
  IF X1ULBLOCK'.BFFCD @ X1ULBLOCK'.BFLCD    _DATA IN INPUT BUFFER      ?
  THEN
    TESTCHAR := X1ULBLOCK'.BFDATAC[X0DATA]; 
  IF TESTCHAR = CHR($22)                    _TYPEWRITER-PAIRED ")"     ?
  THEN
    BSCODE := N0TYPEPAPL                    _TYPEWRITER PAIRED APL     ?
  ELSE
    BEGIN 
    IF TESTCHAR = CHR($2A)                  _BIT-PAIRED ")"            ?
    THEN
      BSCODE := N0BITPAPL                   _BIT-PAIRED APL            ?
    ELSE
      IF TESTCHAR " CHR($29)
      THEN
        BSCODE := N0ASCII;                  _DEFAULT TO ASCII          ?
    END;
  END;  _ WITH X1TCBADDR...?
END;  _ END OF PXCHREC ?
_$J+ PAGE EJECT?
_ 
* * * * * * *  S T A R T   O F   P X P I N P U T T P
? 
BEGIN 
WITH  X1TCBADDR'.BSTCB  DO
  BEGIN 
_ 
  * * *  REMEMBER THE CONDITION OF BREAK FOR TRUSTED PATH.
? 
  X1SECURITY := BSXSECURITY;
_ 
  * * *  CHECK FOR STATUS OF INPUT TEXT PROCESSING CONTROL BLOCK. 
? 
  X6TPCBP := BSXINTPCB; 
  IF X6TPCBP = NIL                          _NO TPCB ON THIS CONNECTION?
  THEN
    BEGIN 
    X6TPCB := PBGET1BF (BETPSIZE);          _GET BUFFER FOR TPCB       ?
    PBCLR (X6TPCB, TPBUFLEN);               _CLEAR TPCB FIELDS         ?
    END;
  
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*               SET UP TPCB FIELDS FOR INPUT TEXT PROCESS             * 
*                                                                     * 
? 
  X6PROCESS := TRUE;
  WITH  X6TPCB'.BGMLCB  DO
  WHILE  X6PROCESS  DO
    BEGIN 
_ 
    * * *  INITIALIZE TPCB COMMON FIELDS FOR BOTH NON TRANSPARENT MODE
    * * *  AND TRANSPARENT MODE.
? 
    NCXMBIT := X1QMBITS.X1MBIT;             _M-BIT IN UPLINE PACKET    ?
    NCFSBA  := X1UPLPKT;                    _UPLINE PACKET             ?
    NCBFCD  := DATA;                        _BUFFER FCD                ?
    ADDR (XINTP1, NCSPTA);
    IF BSXPT
    THEN
      BEGIN 
_ 
      * * *  INITIALIZE TPCB FIELDS FOR TRANSPARENT MODE. 
? 
      NCSTAI   := X0XSXPT;                  _ENTRY FOR XPT STATE       ?
      NCRPRT   := (BSPARITY " B7NPAR) &     _STRIP PARITY BIT IF ZERO, ?
                  (BSPARITY " B7IPAR);      _ODD, OR EVEN PARITY       ?
      NCXTCHR  := BSXDBCHAR;                _DELIMIT BY CHARACTER      ?
      NCXXPT   := TRUE;                     _TRANSPARENT MODE          ?
      NCXTO    := BSXDBTIM;                 _TRANSPARENT TIME OUT OPT. ?
      NCUOPC   := BSXSTIME;                 _STICKY XPARENT TIMEOUT    ?
      NCXMULTI := BSMXPT;                   _SET MULTI TRANSPARENT MODE?
      NCUOPB   := (BSPARITY = B7IPAR);      _IGNORE PARITY ON XPT DELIM?
      WITH X6WORK DO
      BEGIN 
      BAINT       := BSXCHAR;               _TRANSPARENT DELIMITER CHAR?
      BABOOL.B0B7 := (BABOOL.B0B7) &        _CLEAR PARITY BIT IF       ?
                     (BSPARITY " B7IPAR);   _          PARITY = IGNORE ?
      NCS2CHR     := BA1CHAR;               _STORE TRANSPARENT DELIM   ?
      IF NCXMULTI = TRUE                    _IN MULTI-TRANSPARENT MODE ?
      THEN
        BEGIN 
        BAINT       := BSMXCHAR;            _MULTI XPT DELIM CHARACTER ?
        BABOOL.B0B7 := (BABOOL.B0B7) &      _CLEAR PARITY BIT IF       ?
                       (BSPARITY " B7IPAR); _          PARITY = IGNORE ?
        NCS3CHR     := BA1CHAR;             _STORE MULTI XPT DELIMITER ?
        END; _IF NCXMULTI?
      END;   _WITH X6WORK?
      NCBLKL   := $FFF; 
      IF BSXCNT " 0                         _DELIMIT CHAR COUNT EXIST  ?
      THEN
        NCBLKL := BSXCNT;                   _SET TRANSPARENT COUNT     ?
      IF NCCNT2 = 0                         _CHECK FOR CHARACTER COUNT ?
      THEN                                  _ FOR TRANSPARENT          ?
        NCCNT2 := NCBLKL;                   _ CHARACTER COUNT          ?
      END  _ IF TRANSPARENT MODE                                       ?
    ELSE
      BEGIN 
_ 
      * * *  INITIALIZE TPCB FIELDS FOR NON TRANSPARENT INPUT.
? 
      NCSTAI  := X6STATE[BSXPLAST];         _ENTRY TO INPUT STATE      ?
                                            _ DEPEND UPON LAST EVENT   ?
      IF NCDBP " NIL                        _STARTING MIDDLE OF BLOCK  ?
      THEN
        NCSTAI := X0XSNXT;
      NCRPRT   := TRUE;                     _STRIP PARITY BIT          ?
      NCSCHR   := CHR(BSBSCHAR);            _BACKSPACE CHARACTER       ?
      NCS2CHR  := CHR(BSEBCHAR);            _END OF BLOCK CHARATER     ?
      IF BSINDEV " B8BLKMODE                _IF NOT IN BLOCK MODE      ?
      THEN
        NCS2CHR := CHR(BSBSCHAR);           _NO END OF BLOCK CHARACTER ?
      NCS3CHR  := CHR(BSELCHAR);            _END OF LOGICAL LINE CHAR  ?
      NCXIDEV  := BSINDEV = B8KEYBOARD;     _SET INPUT DEVICE TYPE     ?
_ 
      * * *  SET UP THE SIZE OF SUB BLOCK.
? 
      X6SUBBLK := BSPGWIDTH;                _SET PAGE WIDTH            ?
      IF X6SUBBLK = 0                       _PAGE WIDTH NOT SET        ?
      THEN                                  _DEFAULT TO 100 CHARACTERS ?
        X6SUBBLK := X6DFTBSIZ;              _ FOR SIZE OF SUB BLOCK    ?
      X61INT := 0;                          _LOOP THRU SUB BLOCK SIZE  ?
      REPEAT                                _ TABLE TO GET PROPER SIZE ?
        X61INT := X61INT + 1;               _ OF SUB BLOCK             ?
      UNTIL  X6BLKSIZ[X61INT].X6UPPER \ X6SUBBLK; 
      NCBLKL := X6BLKSIZ[X61INT].X6MULTI * X6SUBBLK;
      NCCNT1 := X0MAXPKT;                   _MAXIMUM UPLINE BLOCK      ?
      IF NCCNT2 = 0                         _CURRENT CHARACTER COUNT   ?
      THEN                                  _ FOR BLOCKING             ?
        NCCNT2 := NCBLKL; 
      NCXFASCII := BSFLASCII;               _FULL ASCII MODE           ?
      NCXLF     := BSUBZ = 0;               _CHECK FOR *LF* CHARACTER  ?
      NCCXLTA   := X1INXLT[BSCODE];         _SET TRANSLATION TABLE     ?
      NCNOXL    := NCCXLTA " 0;             _CODE TRANSLATE ACTIVE     ?
      NCXSPEDIT := BSSPEDIT;                _SET SPECIAL EDIT MODE     ?
      END;  _ ELSE IN NON TRANSPARENT MODE                             ?
_ 
    * * *  CALL FIRMWARE INTERFACE PROGRAM TO TEXT PROCESS
    * * *  UPLINE PACKET. 
? 
    PTTPINF (X6TPCBP'); 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*               CHECK FOR THE RESULTS FROM INPUT STATE PROGRAM        * 
*                                                                     * 
? 
_ 
    * * *  FIRST TRY TO RELEASE UPLINE SOURCE DATA BUFFER.
? 
    X1NCFSBA          := NCFSBA;            _FIRST SOURCE BUFFER PTR   ?
    X1NCSBP.BABUFPTR  := NCSBP;             _CURRENT SOURCE BUFFER PTR ?
    X1NCEOSR          := NCEOSR;            _END OF BUFFER FLAG        ?
    X1NCRIGHTC        := NCRIGHTC;          _LEFT OR RIGHT CHAR IN WORD?
    PXPRELSRC;                              _RELEASE SOURCE BUFFER AND ?
                                            _ UPDATE BUFFER FCD IF SOME?
                                            _ SOURCE BUFFER LEFT       ?
    X1UPLPKT          := X1NCFSBA;          _RESET SOURCE POINTER      ?
_ 
    * * *  WORK ON UPLINE DESTINATION DATA. 
? 
    IF NCXXPT 
    THEN
      BEGIN 
_ 
      * * *  TEXT PROCESSED TRANSPARENT INPUT DATA. 
? 
      IF NCXNODT                            _NO DATA IN DEST. BUFFER   ?
      THEN                                  _ ONLY DBC FILL CHAR       ?
        PBRELCHN (NCFDBA, BEDBSIZE)         _RELEASE THEM              ?
      ELSE                                  _DATA EXISTS               ?
        BEGIN 
        X1FLGWRD.KTBLKT  :=                 _SET UPLINE NETWORK        ?
                         X6BLKTYPE[NCXMSG]; _ BLOCK TYPE               ?
        BSXULBLOCK       := X1FLGWRD.KTBLKT;
        X1FLGWRD.KTSEND  := NCXMSG;         _SEND FLAG                 ?
        X61INT           := NCCNT2;         _KEEP CURRENT TRANSPARENT  ?
                                            _ CHARACTER COUNT          ?
        IF NCXMSG                           _MSG BLOCK TO BE SENT      ?
        THEN
          BEGIN 
          BSXEOB := TRUE;                   _END OF BLOCK-ALLOW OUTPUT ?
          X61INT := 0;                      _CLEAR COUNT               ?
          END;  _NCXMSG =TRUE?
_ 
        * * *  SET UP UPLINE BLOCK FOR ULTS IN BIP. 
? 
        X1ULBLOCK := NCFDBA;
_ 
        * * *  SEND A BLOCK.
? 
        PXPFMULBLK; 
        IF X1SECURITY                       _NEED TO TERMINATE         ?
        THEN                                _ TRANSPARENT MODE IF      ?
          BEGIN                             _ SECURITY CHARACTER WAS   ?
          NCXEND := TRUE;                   _ FOUND AND CONNECTION     ?
          PBRELZRO (BSXDLSRC, BEDBSIZE);    _ TERMINATION WILL OCCUR   ?
          X1SECURITY := FALSE;
          END;
        END;  _ ELSE NCXNODT = FALSE                                   ?
_ 
      * * *  CHECK FOR INPUT MODE CHANGE. 
? 
      X61FLG := NCXEND;                     _END OF TRANSPARENT MODE   ?
      X62FLG := NCXHH;                      _FIRST DELIMIT CHAR SEEN   ?
_ 
      * * *  CLEAR TPCB FOR NEXT USE. 
? 
      PBCLR (X6TPCBP, TPBUFLEN);
      IF X61FLG                             _INPUT MODE CHANGED FROM   ?
      THEN                                  _ TRANSPARENT MODE TO      ?
        BEGIN                               _ NON TRANSPARENT MODE     ?
        BSXEPAGE := FALSE;
        BSXBREAK := FALSE;
        BSXPT    := FALSE;                  _CHANGE, TO NON XPT MODE   ?
        BSXPLAST := FALSE;                  _NEXT NON XPT ENTRY STATE  ?
                                            _ WILL BE START OF LL      ?
        BSXEOB   := TRUE;                   _END OF BLOCK              ?
        PXPCHECKOUT;                        _LOCATE MORE OUTPUT        ?
        PXCPADVALUES (FALSE);               _RE-COMPUTE PAD VALUES     ?
        END 
      ELSE                                  _STILL IN TRANSPARENT MODE ?
        BEGIN 
        NCXHH  := X62FLG;                   _RESTORE XHH SEEN FLAG     ?
        NCCNT2 := X61INT;                   _RESTORE XPT CHAR COUNT    ?
        END;
_ 
      * * *  CHECK FOR STATUS OF UPLINE SOURCE PACKET.  IF NO MORE
      * * *  SOURCE DATA LEFT TO TEXT PROCESS, GET OUT OF WHILE LOOP. 
? 
      X6PROCESS := X1UPLPKT " NIL;
_ 
      * * *  END OF TRANSPARENT INPUT.
? 
      END 
    ELSE
      BEGIN 
_ 
      * * *  TEXT PROCESSED NON TRANSPARENT INPUT DATA. 
? 
      IF NCXNODT                            _NO DATA IN THE BUFFER     ?
      THEN                                  _ ONLY DBC FILL CHAR       ?
        PBRELCHN (NCFDBA, BEDBSIZE)         _FORGET THEM               ?
      ELSE
        BEGIN                               _DATA EXISTS               ?
_ 
        * * *  LOOP THRU DESTINATION BUFFERS TO EXTRACT A BLOCK 
        * * *  IF IT IS POSSIBLE AND SEND IT AS A BLK BLOCK.
? 
        X6ULDATA          := NCFDBA;        _FIRST DESTINATION UPLINE  ?
        X6BLOCK.X1BUFACSS := X6ULDATA;      _ DATA BUFFER POINTER      ?
        WHILE  X6BLOCK.X1BUFACSS " NIL  DO
          BEGIN 
          IF X6BLOCK.X1PADACSS'.            _NOT END OF BLK-BLOCK      ?
                             XBEBLK = FALSE 
          THEN
            X6BLOCK.X1BUFACSS :=            _GET NEXT BUFFER IN CHAIN  ?
                    X6BLOCK.X1BUFACSS'. 
                       BCCHAINS[DBUFLENGTH] 
          ELSE                              _FIND BLK-BLOCK INDICATION ?
            BEGIN 
            X1FLGWRD.KTBLKT  := HTBLK;      _SEND BLK-BLOCK UPLINE     ?
            X1FLGWRD.KTSEND  := X6BLOCK.    _SET IF BLK WAS CAUSED     ?
                                X1PADACSS'. _ BY *LF* CHARACTER        ?
                                    XBLFEPL;
            X1ULBLOCK         := X6ULDATA;
_ 
            * * *  UPDATE BUFFER POINTERS FOR THE NEXT BLOCK. 
? 
            X6ULDATA        := X6BLOCK.X1BUFACSS'.BCCHAINS[DBUFLENGTH]; 
            X6BLOCK.X1BUFACSS'.BCCHAINS[DBUFLENGTH] := NIL; 
            X6BLOCK.X1BUFACSS                       := X6ULDATA;
_ 
            * * *  SEND UPLINE BLK-BLOCK. 
? 
           IF BSAUREC = FALSE               _NOT IN CHARACTER SET      ?
           THEN                             _ RECOGNITION              ?
             BEGIN
             BSXULBLOCK := HTBLK; 
             PXPFMULBLK;                    _SEND IT                   ?
             END
           ELSE                             _CHARACTER SET RECOGNITION ?
             BEGIN                          _ IS IN PROGRESS           ?
             IF BSXRECCH = X0CHREC          _WAITING FOR CHARACTER SET ?
             THEN                           _ RECOGNITION              ?
               BEGIN
               PXCHREC;                     _CHECK IT OUT              ?
               BSXRECCH := X0FORGETIT;      _IGNORE REST OF INCOMING   ?
                                            _ DATA UNTIL MSG BLOCK     ?
               END; 
             PBRELCHN (X1ULBLOCK, BEDBSIZE); _DO NOT SEND IT TO HOST   ?
             END; 
            END;  _ ELSE XBEBLK = TRUE                                 ?
          END;  _ WHILE X6BLOCK " NIL                                  ?
_ 
        * * *  DETERMIN WHETHER TO SEND THE REST OF DATA AS UPLINE
        * * *  MSG BLOCK OR KEEP THE TEXT PROCESSED DATA FOR NEXT TIME. 
? 
        X61PTR   := NIL;                    _USED FOR NCDBP            ?
        X61FLG   := FALSE;                  _USED FOR NCRINCH          ?
        X61INT   := 0;                      _USED FOR NCLCDFCD         ?
        BSXPLAST := FALSE;
        IF X6ULDATA = NIL                   _NO MORE DEST. BUFFER LEFT ?
        THEN                                _ PROBABLY SENT ALL AS BLK ?
          BEGIN                             _ BLOCK                    ?
          X6PROCESS := FALSE;               _NO MORE TEXT PROCESSING   ?
          BSXPLAST  := TRUE;                _NEXT ENTRY WILL BE START  ?
          END                               _ OF PHYSICAL LINE         ?
        ELSE                                _SOME MORE DEST. BUFFER    ?
          BEGIN                             _ LEFT                     ?
          IF NCXEOLL = FALSE                _NOT END OF LIGICAL LINE   ?
          THEN
            BEGIN 
            X61INT   := NCCNT2;             _SAVE CHARACTER COUNT      ?
            END 
          ELSE                              _END OF LOGICAL LINE       ?
            BEGIN 
            X1ULBLOCK       := X6ULDATA;    _SET UPLINE NETWORK BLOCK  ?
            BSXULBLOCK      := HTMSG; 
            X1FLGWRD.KTBLKT := HTMSG;       _SEND MSG-TYPE BLOCK       ?
            X1FLGWRD.KTSEND := TRUE;        _SEND RIGHT AWAY           ?
            X1FLGWRD.                       _SET PAGE TRUN OPTION      ?
                  KTCKPGTRN := BSXEPAGE;
_ 
            * * *  CHECK FOR IVT COMMAND IN FULL ASCII MODE.
? 
            X6CHAR := X6ULDATA'.            _ EXTRACT FIRST CHARACTER  ?
                      BFDATAC[X0DATA];      _   IN UPLINE DATA         ?
            IF X6CHAR = CHR(BSCNTRLCHAR)    _ CHECK IVT CONTROL CHAR   ?
            THEN
              IF BSXNECHO 
              THEN
                BSXIVT := TRUE;             _ SET IVT FLAG TRUE        ?
            IF BSFLASCII                    _ IN FULL ASCII MODE       ?
            THEN                            _ DISGARD THE LAST CHAR    ?
              BEGIN                         _  WHICH IS FORWARD SIGNAL ?
              X6LCD := X6ULDATA'.BFLCD - 1; 
              X6ULDATA'.BFLCD := X6LCD; 
              END;
            X6ULDATA        := NIL; 
            BSXEPAGE        := FALSE; 
_ 
            * * *  SEND UPLINE MSG-BLOCK. 
? 
           IF BSAUREC = FALSE               _NOT IN CHARACTER SET      ?
           THEN                             _ RECOGNITION              ?
             BEGIN
             IF NCXEOB                      _END OF BLOCK SEEN         ?
             THEN 
                BEGIN 
                X1CURPOS := BSCPEL;         _USE EL CURSOR POSITIONING ?
                IF BSINDEV = B8BLKMODE      _BUT IF IN BLOCK MODE THEN ?
                THEN
                  X1CURPOS := BSCPEB;       _USE EB CURSOR POSITIONING ?
                END;
             PXPFMULBLK;                    _SHIP IT                   ?
             END
           ELSE                             _CHARACTER SET RECOGNITION ?
             BEGIN                          _ IS IN PROGRESS           ?
             IF BSXRECCH = X0SPEED          _IF AT SPEED CHECK IGNORE  ?
             THEN 
               BEGIN
               PXPCURSOR;                   _SEND TWO LFS              ?
               PXPCURSOR; 
               BSXRECCH := X0CHREC;         _STATE TO CHAR REC         ?
               END
             ELSE 
               BEGIN
               IF BSXRECCH = X0CHREC        _IF AT CHAR REC            ?
               THEN 
                 BEGIN
                 PXPCURSOR; 
                 PXCHREC;                   _CHECK CHAR FOR CODE SET   ?
                 END; 
               BSXRECCH := X0SPEED;         _SET DEFAULT               ?
               BSAUREC := FALSE;            _RESET AUTO REC SEEN IVT   ?
               BSXEOB := TRUE;              _SET END OF BLOCK          ?
               PXPCHECKOUT;                 _LOCATE THE OUTPUT         ?
               END; 
             PBRELCHN(X1ULBLOCK, BEDBSIZE); 
             END; 
            END;  _ ELSE END OF LOGICAL LINE NCXEOLL = TRUE            ?
          END;  _ ELSE X6ULDATA " NIL                                  ?
        END;  _ ELSE NCXNODT = FALSE                                   ?
_ 
      * * *  DETERMINE WHETHER TO TEXT PROCESS MORE INPUT DATA OR NOT.
      * * * 
      * * *  IT ALSO CHECK FOR THE END OF BLOCK CONDITION AND IT WILL 
      * * *  TRY TO PROCESS DOWNLINE DATA IF IT IS THE END OF BLOCK.
? 
      BSXEOB   := NCXEOB; 
      IF X1FLGWRD.KTRESP                    _IF TERMINAL RESPONSE WAS  ?
      THEN                                  _ SENT FOR IVT COMMAND     ?
        BSXEOB := TRUE;                     _PROCESS ANYMORE DL DATA   ?
      PBCLR (X6TPCBP, TPBUFLEN);            _CLEAR INPUT TPCB          ?
                                            _ FOR NEXT USE             ?
      X6PROCESS := X1UPLPKT " NIL;          _ANY SOURCE LEFT TO PROCESS?
      IF BSXEOB                             _END OF BLOCK              ?
      THEN
        BEGIN 
        IF X6PROCESS = FALSE
        THEN
          PBREL1BF(X6TPCB,BETPSIZE);        _RELEASE TPCB              ?
_ 
        * * *  TRY TO PROCESS OUTPUT DATA.
? 
        PXPCHECKOUT;                        _LOCATE MORE OUTPUT        ?
        END  _ IF END OF BLOCK                                         ?
      ELSE  _ NOT END OF BLOCK                                         ?
        BEGIN 
        IF X6ULDATA " NIL                   _PARTIAL DATA.  RECEIVED   ?
        THEN                                _ PHYSICAL LINE OVER PACKET?
          BEGIN                             _ BOUNDARY                 ?
          X61PTR := X6ULDATA;               _FIRST PARTIAL DESTINATION ?
                                            _ BUFFER POINTER           ?
          WHILE  X61PTR'.BCCHAINS           _LOOKING FOR THE ADDRESS OF?
                     [DBUFLENGTH] " NIL  DO _ LAST BUFFER IN PARTIAL   ?
            X61PTR := X61PTR'.BCCHAINS      _ DESTINATION BUFFER CHAIN ?
                              [DBUFLENGTH]; 
_ 
          * * *  CALCULATE THE WORD POINTER WHICH IS THE NEW
          * * *  WRITE POSITION FOR FM.  NEW BUFFER IS PROVIDED 
          * * *  IF THE LAST BUFFER IS FULL.
? 
          IF X61PTR'.BFLCD = $7D            _DESTINATION BUFFER IS FULL?
          THEN                              _GET A BUFFER AND SET      ?
            BEGIN                           _ BUFFER LCD AND FCD       ?
            X61PTR'.BCCHAINS[DBUFLENGTH] := PBGET1BF (BEDBSIZE);
            X61PTR := X61PTR'.BCCHAINS[DBUFLENGTH]; 
            X61PTR'.BIINT[1] := $0B0C;
            END;
          X6DBP.BABUFPTR := X61PTR; 
          WITH  X6DBP  DO 
            BEGIN                           _FIND THE LEFT/RIGHT       ?
            X61FLG := ((BABUFPTR'.BFLCD     _ POSITION IN DESTINATION  ?
                               MOD 2) = 0); _ WORD FOR NEXT CHARACTER  ?
                                            _ TO BE STORED             ?
            BAINT  := BAINT +               _FIND THE LOCATION OF WARD ?
                         BABUFPTR'.BFLCD    _ WHICH THE LAST CHARACTER ?
                                     DIV 2; _ WAS STORED               ?
            IF X61FLG = FALSE               _NEST DATA SHOULD BE STORED?
            THEN                            _ AT LEFT BYTE OF THE NEXT ?
              BAINT := BAINT + 1;           _ WORD                     ?
            END;  _ WITH  X6DBP                                        ?
_ 
          * * *  RESTORE NECESSARY VARIABLES BACK INTO TPCB.
? 
          X61PTR'.                          _LCD TO END OF BUFFER      ?
              BFLCD := $7D; 
          NCFDBA    := X6ULDATA;            _FIRST DESTINATION BUFFER  ?
          NCDBP     := X6DBP.BABUFPTR;      _CURRENT WORD POINTER      ?
          NCLCDFCD  := X61PTR'.BIINT[1];    _RESET LCD AND FCD FOR FM  ?
          NCRINCH   := X61FLG;              _LEST OR RIGHT BYTE FLAG   ?
                                            _ FOR CURRENT WORD LOCATION?
          NCCNT2    := X61INT;              _CHARACTER COUNT           ?
          END;  _ X6ULDATA " NIL                                       ?
        END;  _ ELSE NOT END OF BLOCK                                  ?
      END;  _ ELSE NON TRANSPARENT INPUT                               ?
_ 
    * * *  CLEAR FLAG WORD FIELDS FOR ULTS. 
? 
    X1FLGWRD.KTWORD  := 0;
    X1FLGWRD.KTCKSPC := TRUE; 
_ 
*                                                                     * 
*               END OF WHILE LOOP                                     * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
    END;  _ WHILE X6PROCESS                                            ?
  BSXINTPCB := X6TPCBP; 
  END;  _ WITH X1TCBADDR                                               ?
END;  _PROCEDURE PXPINPUTTP : INPUT TEXT PROCESS                       ?
_$J+  PAGE EJECT? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*              OUTPUT TEXT PROCESS  ( PXPOUTPUTTP )  : LEVEL II       * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
** OVERVIEW:                                                          * 
*              THE OUTPUT TEXT PROCESS ROUTINE SETS UP THE OUTPUT     * 
*              TEXT PROCESS CONTROL BLOCK AND IT CALLS THE TEXT       * 
*              PROCESSING INTERFACE PROGRAM TO TEXT PROCESS THE       * 
*              RECEVING DATA.  AFTER THE TEXT PROCESSING IS DONE      * 
*              THIS ROUTINE PACKETIZES THE TEXT PROCESSED DATA AND    * 
*              SETS M-BIT.                                            * 
*                                                                     * 
*                 M-BIT IN THE PACKET SET TO 1:                       * 
*                                                                     * 
*                   THE PACKET IS FILLED WITH DATA AND THERE ARE      * 
*                   ONE OR MORE PACKETS CHAIN TO IT.                  * 
*                                                                     * 
*                 M-BIT IN THE PACKET SET TO 0:                       * 
*                                                                     * 
*                   THE PACKET DOES NOT HAVE TO BE FULL BUT IT MUST   * 
*                   BE THE LAST PACKET IN CHAIN OR THE ONLY ONE       * 
*                   PACKET FOR THE TRANSMITTAL.                       * 
*                                                                     * 
*                 THE Q-BIT WILL BE ALWAYS SET TO 0 .                 * 
*                   (DOWNLINE DATA PACKET)                            * 
** INPUT:                                                             * 
*              TCB ADDRESS                  : X1TCBADDR               * 
*              UNPROCESSED DATA             : X1TMLRSPMSG OR BSXDLSRC * 
** OUTPUT:                                                            * 
*              DOWNLINE PACKET              : X1DLFRGMT               * 
*                                                                     * 
** CALLING PROGRAM:                                                   * 
*                                                                     * 
*              FORM DOWNLINE FRAGMENT       : PXPFMDLFRG              * 
*                                                                     * 
** SUBROUTINE CALL:                                                   * 
*                                                                     * 
*     EXTERNAL SUBROUTINE                                             * 
*              TEXT PROCESSING              : PTTPINF                 * 
*               INTERFACE PROGRAM                                     * 
*                                                                     * 
*     INTERNAL SUBROUTINE                                             * 
*              RELEASE TEXT PROCESSED       : PXPRELSRC               * 
*               SOURCE BUFFER                                         * 
*                                                                     * 
** NOTES:                                                             * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PXPOUTPUTTP;
  
CONST 
  X8FIVTS   = 1;                            _FIRST INPUT STATE IVT     ?
  X8FXPTS   = 2;                            _FIRST INPUT STATE XPT     ?
  X8F8XPTS  = 3;                              _ 8-BIT TRANSPARENT TEXT ?
  X8DBCCP   = 2;                            _DBC POSITION CURPOS MSG   ?
  X8DBCSAV  = 5;                            _DBC POSITION PARTIAL SRCE ?
  X8PARMSK  = 3;                            _CLA PARITY MASK           ?
_ 
* * * *  TEXT PROCESSOR FILE REGISTER CONSTANTS 
? 
  X8LNCNT   = 3;                            _LINE COUNTER              ?
  X8PGLEN   = 4;                            _PAGE LENGTH               ?
  X8CRIDL   = 5;                            _CARRIAGE RETURN IDLE COUNT?
  X8LFIDL   = 6;                            _LINE FEED IDLE COUNT      ?
  X8ECRLF   = 7;                            _EMBEDDED CR/LF CHARACTERS ?
  X8CRLF    = 8;                            _PRE/POST PRINT CR/LF CHARS?
  X8HCLR    = 9;                            _CLEAR/HOME CHARACTERS     ?
  X8POSTLFS = 12;                           _NUMBER OF POST PRINT LFS  ?
  X8PARTY   = $A;                           _PARITY TYPE               ?
  
VAR 
  X8LSTPKT  : B0BUFPTR;                     _LAST GENERATED PACKET     ?
  X8WORKPTR : X0BUFFER;                     _WORK PACKET POINTER       ?
  X8OUTPCB  : NCLCB;                        _OUTPUT TEXT PROCESS CB    ?
  X8PDBC    : INTEGER;                      _POSITION DBC IN SOURCE    ?
  X8DBC     : DBDBC;                        _DATA BLOCK CLARIFIER      ?
  X8WRK     : B0OVERLAY;                    _TEMP WORK VARIABLE        ?
  X8TCCHRS  : ARRAY [N0M33..N0T4014] OF 
              RECORD
                X8TCCT : ARRAY [X8ECRLF..   _EMBEDDED CR/LF, CURSOR-POS?
                         X8HCLR] OF INTEGER;_CR/LF, HOME/CLEAR CHARS   ?
              END;
  
VALUE 
  X8TCCHRS = ($0D0A,$0D0A,0,                _M33:  CR/LF, CR/LF,  0/0  ?
              $0D0A,$0D0A,$1918,            _713:  CR/LF, CR/LF, EM/CAN?
              $0D0A,$0D0A,$0C0C,            _721:  CR/LF,CR/LF,FF/FF   ?
              0,0,0,                        _2741:  N/A                ?
              $4742,$000A,$4852,            _M40:  -G/-B,  0/NL, -H/-R ?
              $000D,$000D,$121C,            _2000:  0/NL,  0/NL,DC2/FS ?
              $0D0A,$0D0A,$5B5B,            _X364: CR/LF, CR/LF, -[/-[ ?
              $0D0A,$0D0A,$1B1B);           _4014: CR/LF, CR/LF, ESC/..?
  
BEGIN 
WITH X1TCBADDR'.BSTCB, X8OUTPCB, X8DBC DO   _INDEX TO TCB AND WORK VARS?
  BEGIN 
_ 
* * * *  INITIALIZE SOME OF THE REQUIRED TPCB FIELDS
? 
  ADDR (X25OTP, NCSPTA);                    _INSERT STATE PROGRAM TABLE?
  NCFDBA     := NIL;                        _CLEAR DESTINATION PTR     ?
  NCDBP      := NIL;                        _CLEAR WORK DESTINATION    ?
  NCSBP      := NIL;                        _AND SOURCE BUFFER PTRS    ?
  NCTPML [3] := X8FIVTS;                    _PRESET FOR IVT INPUT      ?
  NCTPML [8] := DATA;                       _FCD OF FIRST BUFFER       ?
  NCBLKL     := BSLCCBPTR'.LCCB.LCDPL + 1;  _X25 PACKET SIZE           ?
  NCNOXL     := FALSE;                      _SET IF NEED TO TRANSLATE  ?
  WITH X8WRK DO 
    BEGIN 
    BAINT := BSPARITY;
    BABOOL.B0B3 := FALSE;                   _MASK OFF UPPER TWO BITS TO?
    BABOOL.B0B2 := FALSE;                   _ OBTAIN CLA PARITY        ?
    NCTPF1[X8PARTY] := BAINT;               _SET PARITY, FIELD IS USED ?
                                            _ BY X25PAR INSTRUCTION    ?
    END;  _WITH X8WRK?
_ 
* * * *  LOCATE SOURCE DATA TO BE TEXT PROCESSED, GET THE DBC 
? 
  IF X1TMLRSPMSG " NIL
  THEN                                      _INTERNAL RESPONSE MESSAGE ?
    BEGIN 
    NCFSBA := X1TMLRSPMSG;
    NCSCF  := TRUE;                         _TP SUPPRESS CHAIN FLAG    ?
    X8PDBC := X8DBCCP;
    END 
  ELSE                                      _NOT INTERNAL, GET D/L SRC ?
    BEGIN 
    X8PDBC := DBC;                          _LIKELY POSITION OF DBC    ?
    NCFSBA := BSXDLSRC; 
    IF BSXTPOUT " 0 
    THEN                                    _PARTIAL SOURCE AVAILABLE  ?
      BEGIN 
      NCSTAI     := BSXTPOUT;               _INSERT SAVED TP STATE     ?
      X8PDBC     := X8DBCSAV;               _POSITION OF SAVED DBC     ?
      NCCRCP     := BSXTPFLAGS;             _SAVED ADDITIONAL TP FLAGS ?
      END;
    END;
  DBCHAR := NCFSBA'.BFDATAC [X8PDBC];       _GET DBC LOCAL             ?
  IF BSNINCP = FALSE                        _CHECK TCB NO CP FLAG      ?
  THEN
    BSNINCP := DBDLNCP;                     _RESET NO CP FLAG          ?
  IF BSXNECHO = FALSE                       _ CHECK DBC NO-ECHO FLAG   ?
  THEN
    BSXNECHO := DBDLNECHO;                  _ RESET DBC NO-ECHO FLAG   ?
  IF DBDLXPT
  THEN
_ 
* * * *  SET UP FOR TRANSPARENT TEXT PROCESSING 
? 
    BEGIN 
    IF(BSPARITY = B7NPAR) !                   _ CHECK TEXT NO PARITY   ?
      (BSPARITY = B7IPAR) 
    THEN
      BEGIN 
      NCTPML [3] := X8F8XPTS;                 _ INSERT NO/PARITY XPT   ?
      END 
    ELSE
      BEGIN 
      NCTPML [3] := X8FXPTS;                  _ INSERT PARITY XPT      ?
      NCCXLTA    := 0;                        _ NO XLATE ON XPT DATA   ?
      END;
    END 
  ELSE
_ 
* * * *  SET UP FOR NON-TRANSPARENT TEXT PROCESSING 
? 
    BEGIN 
    NCUOPS           := BSOUTDEV;           _NCUOP7=PT, NCUOP8=DP DEV. ?
    IF BSTCLASS = N0X364                    _TERMINAL CLASS 7 DISPLAYS ?
    THEN                                    _SET BOTH NCUOP7 AND NCUOP8?
      IF BSOUTDEV = B8DISPLAY               _TO ENABLE SPECIAL LINE    ?
      THEN                                  _FOLDING THAT THE VT100    ?
        NCUOPS := B8VTDISPLAY;              _NEEDS                     ?
    NCUOP2           := DBDLFE;             _GET FORMAT EFFECTOR FLAG  ?
    NCCNTL           := BSPGWIDTH;          _SET PAGE WIDTH            ?
    NCTPF1 [X8PGLEN] := BSPGLENGTH;         _SET PAGE LENGTH           ?
    IF NCTPF1 [X8PGLEN] " 0 
    THEN                                    _PAGEING REQUESTED IF      ?
      BEGIN                                 _NON ZERO PAGE LENGTH      ?
      NCUOP3 := BSPGWAIT;                   _GET PAGE WAIT FLAG        ?
      IF BSPGWAIT = FALSE 
      THEN                                  _PAGE WAIT OFF,            ?
        NCTPF1 [X8PGLEN] :=                 _ALLOW FOR ONE MORE LINE   ?
        NCTPF1 [X8PGLEN] + 1;               _ON PAGE (IN CASE OF PRNTR)?
      END;
    NCTPF1 [X8CRIDL] := BSCRIDLES;
    NCTPF1 [X8LFIDL] := BSLFIDLES;          _SET CR/LF IDLES           ?
    WITH X8TCCHRS [BSTCLASS] DO 
      BEGIN 
      NCTPF1 [X8ECRLF] := X8TCCT [X8ECRLF]; _GET EMBEDDED CR/LF CHARS  ?
      NCTPF1 [X8CRLF]  := X8TCCT [X8CRLF];  _GET CURSOR POSITION CR/LF ?
      NCTPF1 [X8HCLR]  := X8TCCT [X8HCLR];  _GET HOME/CLEAR SCREEN CHRS?
      END;
    NCRPRT           := TRUE;               _STRIP PARITY              ?
    NCCXLTA := X1OUXLT[BSCODE];             _SET TRANSLATION TABLE     ?
    NCTPF1 [X8LNCNT] := BSXLNCNT;           _SET CURRENT LINE COUNT    ?
    IF NCTPF1 [X8LNCNT] = 0 
    THEN                                    _JUST RECEIVED INPUT       ?
      BEGIN 
      BSXCHRCNT        := BSPGWIDTH;        _RESET CHAR POSITION COUNT ?
      BSXDRLF          := TRUE;             _DROP LEADING LFS IN NO CP ?
      BSXATEND         := FALSE;            _CLEAR CURSUR AT LEFT FLAG ?
      NCTPF1 [X8LNCNT] := 1;
      END;
    NCCNT1 := BSXCHRCNT;                    _SET CHAR POSITION COUNTER ?
    NCUOP4 := BSXDRLF;
    NCUOP5 := BSXATEND;                     _GET CURSUR AT LEFT FLAG   ?
    IF BSXPOST                              _IF POST PRINT LF TO GO    ?
    THEN
      NCTPF1[X8POSTLFS] := 1;               _THEN SET FILE REGISTER    ?
    IF X1TMLRSPMSG = NIL
    THEN                                    _NOT CURPOS MESSAGE        ?
      PTADDCHAR (CHR (I9US), NCFSBA);       _FORCE TRAILING UNIT SEPRTR?
    END; _IF DBDLXPT ELSE?
_ 
* * * *  PERFORM TEXT PROCESSING
? 
  PTTPINF (X8OUTPCB);                       _CALL TEXTPROCESSOR        ?
_ 
* * * *  RELEASE TEXT PROCESSED SOURCE, ADJUST FCD IF SOURCE LEFT 
? 
  IF X1TMLRSPMSG " NIL
  THEN                                      _INTERNAL MESSAGE          ?
    X1TMLRSPMSG := NIL                      _CLEAR CURPOS MSG POINTER  ?
  ELSE
    BEGIN 
    X1NCFSBA := NCFSBA;                     _FIRST SOURCE BUFFER PTR   ?
    IF DBDLXPT
    THEN
      BEGIN 
      PBRELCHN (X1NCFSBA, BEDBSIZE);        _RELEASE XPT SOURCE        ?
      BSXDLSRC := NIL;                      _CLEAR D/L SOURCE POINTER  ?
      IF BSXDLBLOCK = HTMSG                 _D/L XPT MSG BLOCK RECEIVED?
      THEN
        BSXEPAGE := BSPGWAIT;               _PERFORM PAGE WAIT IF SET  ?
      END _IF DBDLXPT THEN? 
    ELSE
      BEGIN 
      X1NCSBP.BABUFPTR := NCSBP;            _CURRENT SOURCE BUFFER PTR ?
      X1NCEOSR         := NCEOSR;           _END OF SOURCE BUFFER FLAG ?
      X1NCRIGHTC       := NCRIGHTC;         _RIGHT CHARACTER FLAG      ?
      PXPRELSRC;                            _RELEASE TP-ED SOURCE      ?
      BSXLNCNT         := NCTPF1 [X8LNCNT]; _GET NR LINES LEFT ON PAGE ?
      BSXCHRCNT        := NCCNT1;           _GET CHAR POSITION COUNTER ?
      BSXDRLF          := NCUOP4;           _GET DROP LEADING LF FLAG  ?
      BSXATEND         := NCUOP5;           _GET CURSUR AT LEFT FLAG   ?
                                            _IF POST PRINT LF NOT YET  ?
      BSXPOST          := NCTPF1[X8POSTLFFS] > 0; _PRINTED, SET FLAG   ?
      BSXEPAGE         := NCUOP6;           _GET PAGE WAIT CONDITION   ?
      BSXTPOUT         := 0;                _CLEAR NEXT TP STATE       ?
      BSXDLSRC         := X1NCFSBA;         _SAVE LEFT OVER SOURCE     ?
      IF X1NCFSBA " NIL 
      THEN
_ 
* * * *  REMAINING SOURCE LEFT, SAVE IN TCB FOR RE-ENTRY OF TP
? 
        BEGIN 
        BSXTPOUT   := NCSTAI;               _SAVE RE-ENTRY STATE IN TCB?
        BSXTPFLAGS := NCCRCP;               _SAVE ADDITIONAL TP FLAGS  ?
        WITH X1NCFSBA' DO 
          BFDATAC [X8DBCSAV] := DBCHAR;     _SAVE DBC IN PARTIAL SOURCE?
        END;
      END; _IF DBDLXPT ELSE?
    END; _IF X1TMLRSPMSG " NIL ELSE?
_ 
* * * *  TEXT PROCESSING JOB COMPLETE, PICK UP GENERATED PACKETS
? 
  X1DLFRGMT := NCFDBA;                      _GET FIRST GENERATED FRGMNT?
  IF X1DLFRGMT " NIL
  THEN
    IF X1DLFRGMT'.BFLCD < X0DATA            _AND IS EMPTY,             ?
    THEN
      BEGIN 
      PBRELZRO(X1DLFRGMT,BEDBSIZE);         _RELEASE IT                ?
      PBQUEMAINT (X1TCBADR,                 _TCB ADDRESS               ?
                  DUMPTR,                   _NIL                       ?
                  K4PUTBC);                 _TELL BIP TO BACK IT       ?
      END 
    ELSE
_ 
* * * *  NEW PACKET(S) GENERATED, QUEUE THEM IN TCB 
? 
      BEGIN 
      X8LSTPKT            := X1DLFRGMT; 
      X8WORKPTR.X1BUFACSS := X8LSTPKT;
      REPEAT                                _LOOP THOUGH PACKETS       ?
        WITH  X8WORKPTR  DO 
          BEGIN 
          X1BUFACSS'.BCCHAINS[QCHN] := NIL; _CLEAR QUEUE CHAIN         ?
          X1PADACSS'.XBFRGQBIT := FALSE;    _DATA PACKET               ?
          X1PADACSS'.XBFRGMBIT := TRUE;     _MORE PACKET FOLLOWS       ?
          IF X1PADACSS'.XBENDPKT            _LAST BUFFER IN PACKET     ?
          THEN
_ 
          * * * FOUND THE LAST BUFFER IN PACKET.
? 
            BEGIN 
            X8LSTPKT'.                      _CHAIN NEXT PACKET TO IT   ?
              BCCHAINS[QCHN] := X1BUFACSS'. _IF NO MORE AFTER THIS     ?
                                BCCHAINS    _IT WILL HAVE NIL          ?
                                [DBUFLENGTH]; 
            X1BUFACSS'.                     _CLEAR BUFFER CHAIN OF THE ?
              BCCHAINS[DBUFLENGTH] := NIL;  _LAST BUFFER IN PACKET     ?
            X1BUFACSS      := X8LSTPKT'.    _NEXT BUFFER WHICH IS THE  ?
                               BCCHAINS     _FIRST BUFFER IN NEXT      ?
                                  [QCHN];   _PACKET                    ?
            IF X1BUFACSS " NIL              _NEXT BUFFER AVEILABLE     ?
            THEN
              X8LSTPKT := X1BUFACSS;
            END   _ IF X8WORKPTR.XBENDPKT?
          ELSE                              _NOT XBENDPKT              ?
_ 
          * * *  NOT THE LAST BUFFER IN PACKET. 
          * * *  SET M AND Q BITS (SET M-BIT TO 1 AND Q-BIT TO 0).
? 
            X1BUFACSS := X1BUFACSS'.BCCHAINS_GET NEXT BUFFER           ?
                              [DBUFLENGTH]; 
          END;  _  WITH X8WORKPTR?
      UNTIL X8WORKPTR.X1BUFACSS = NIL;      _ALL PACKETS DONE          ?
_ 
    * * *  CHANGE THE M-BIT IN THE LAST PACKET TO 0 TO INDICATE 
    * * *  THAT IT IS THE LAST PACKET FOR THIS TRANSMISSION.
? 
      X8LSTPKT'.BIINT[4] := 0;
      END; _IF X1DLFRGMT'.BFLCD < X0DATA? 
  END; _WITH X1TCBADDR', ... DO?
END;  _ PROCEDURE PXPOUTPUTTP : OUTPUT TEXT PROCESS                    ?
_$J+  PAGE EJECT? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*              PAD PROCESS  ( PXPPADPROCESS )  : LEVEL II             * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
** OVERVIEW:                                                          * 
*              THE PAD PROCESS ROUTINE PROCESSES THE UPLINE PAD       * 
*              MESSAGE PACKET.  IT ONLY ACTIONS THE INDICATION OF     * 
*              BREAK AT THIS TIME.  RECEVING THE INDICATION OF        * 
*              BREAK, THIS ROUTINE SENDS PAD MESSAGE TO RESET THE     * 
*              VALUE OF THE PARAMETER REFERENCE 8 TO ZERO, AND        * 
*              RETURNS THE BREAK SEEN INDICATION TO ITS CALLEE.       * 
** INPUT:                                                             * 
*              TCB ADDRESS                  : X1TCBADDR               * 
*              UPLINE PAD MESSAGE PACKET    : X6ULPADPKT              * 
** OUTPUT:                                                            * 
*              PAD MESSAGE TYPE             : X6PADTYPE               * 
*              DOWNLINE PAD MESSAGE PACKET  : X6PADPACKET             * 
*                                                                     * 
** CALLING PROGRAM:                                                   * 
*                                                                     * 
*              FORM UPLINE BLOCK            : PXPFMULBLK              * 
*                                                                     * 
** SUBROUTINE CALL:                                                   * 
*                                                                     * 
*     EXTERNAL SUBROUTINE                                             * 
*              RELEASE CHAIN OF BUFFERS     : PBRELCHN                * 
*                                             PBRELZRO                * 
*                                                                     * 
*     INTERNAL SUBROUTINE                                             * 
*              FORM PAD MESSAGE             : PXPFMPADMSG             * 
*                                                                     * 
** NOTES;                                                             * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PXPPADPROCESS;
  
  
VAR 
      X6MSGCODE    : X0MSGCODE;             _PAD MESSAGE CODE OVERLAY  ?
      X6PARM       : X0PARM;                _PARAMETER REFERENCE AND   ?
                                            _ VALUE                    ?
      X6PARIND     : BOOLEAN; 
      X6CLEAR      : BOOLEAN; 
      X6ERROR      : INTEGER; 
  
BEGIN 
X6MSGCODE.X1MOCTET := X1UPLPKT'.            _EXTRACT PAD MESSAGE FROM  ?
                          BFDATAC[X0MCODE]; _ PAD PACKET               ?
X1PADMSG           := 0;
  
CASE  X6MSGCODE.X1MSGCODE  OF 
_ 
  * * *  PARAMETER INDICATION.
? 
  X0PARIND:                                 _MESSAGE CODE = 0          ?
  
    BEGIN 
    X6PARIND := TRUE; 
    END;  _ X0PARIND                                                   ?
_ 
  * * *  INVITATION TO CLEAR. 
? 
  X0CLEAR:                                  _MESSAGE CODE = 1          ?
  
    BEGIN 
    X6CLEAR  := TRUE; 
    END;  _ X0CLEAR                                                    ?
_ 
  * * *  INDICATION OF BREAK. 
? 
  X0BREAK:                                  _MESSAGE CODE = 3          ?
  
    BEGIN 
    X1UPLPKT            := X1UPLPKT'.       _EXTRACTED THE FIRST BUFFER?
                            BCCHAINS        _ IN THE UPLINE PACKET     ?
                              [DBUFLENGTH]; 
    X6MSGCODE.X1MOCTET  := CHR(0);
    X6PARM.X1CHRREF     := CHR(0);
    X6PARM.X1CHRVAL     := CHR(0);
    X6MSGCODE.X1MSGCODE := X0SET;           _MSG CODE := SET PARAMETER ?
    X6PARM.X1ERROR      := FALSE;           _NO ERROR                  ?
    X6PARM.X1REF        := X0DISCARD;       _SET VALUE IN OUTPUT       ?
    X6PARM.X1VAL        := X08NODISCARD;    _ DISCARD PARAMETER REF    ?
                                            _ TO 0 (NO DISCARD)        ?
    WITH  X1PADPKT.X1BUFACSS'  DO 
      BEGIN 
      BFDATAC[X0MCODE]     := X6MSGCODE.    _MESSAGE CODE              ?
                                  X1MOCTET; 
      BFDATAC[X0MCODE + 1] := X6PARM.       _PARAMETER REFERENCE       ?
                                  X1CHRREF; 
      BFDATAC[X0MCODE + 2] := X6PARM.       _PARAMETER VALUE           ?
                                  X1CHRVAL; 
      BFFCD                := X0MCODE;      _PACKET FCD                ?
      BFLCD                := X0MCODE + 2;  _PACKET LCD                ?
      BCCHAINS[QCHN]       := NIL;
      BCCHAINS[DBUFLENGTH] := NIL;
      END;  _ WITH X6PADPACKET                                         ?
_ 
    * * *  RETURN TO CALLEE WITH THE INDICATION OF BREAK AND
    * * *  PASS THE PAD MESSAGE TO THE FORM PAD MSG ROUTINE 
    * * *  TO PACKTIZE THE PAD MESSAGE. 
? 
    X1PADMSG := X0BREAK;                    _NOTIFY BREAK INDICATION   ?
    PXPFMPADMSG;                            _PACKTIZE THE MESSAGE      ?
    END;  _ X0BREAK                                                    ?
_ 
  * * *  PAD ERROR MESSAGE INDICATION.
? 
  X0ERROR:                                  _MESSAGE CODE = 5          ?
  
    BEGIN 
    X6ERROR  := X1UPLPKT'.BIINT[8]; 
    END;  _ X0ERROR                                                    ?
  
  END;  _ CASE X6MSGCODE.X1MSGCODE                                     ?
  PBRELZRO (X1UPLPKT, BEDBSIZE);            _RELEASE UNNECESSARY BUFFER?
  
END;  _ PROCEDURE PXPPADPROCESS : PROCESS PAD MESSAGE                  ?
_$J+  PAGE EJECT? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*              QUEUE DOWNLINE FRAGMENT  ( PXPQUEFRG )  : LEVEL II     * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
** OVERVIEW:                                                          * 
*              THE QUEUE DOWNLINE FRAGMENT ROUTINE MAKES WORKLIST     * 
*              ENTRY.                                                 * 
*                                                                     * 
** INPUT:                                                             * 
*              TCB ADDRESS                  : X1TCBADDR               * 
*              WORKCODE                     : X9L3WKC                 * 
*              FRAGMENT POINTER             : X1DLFRGMT               * 
** OUTPUT:                                                            * 
*              WORKLIST ENTRY               : BWWLENTRY[OPS] WLE      * 
*                                                                     * 
*                 1)  DOWNLINE IVT DATA PACKET AND PAD MESSAGE        * 
*                     PACKET TRANSFER.                                * 
*                                                                     * 
*                     WORKCODE : TPFRGQ                               * 
*                                                                     * 
*                        ********************                         * 
*                        *       * WORKCODE *                         * 
*                        ********************                         * 
*                        * FRAGMENT POINTER *                         * 
*                        ********************                         * 
*                        *   TCB  ADDRESS   *                         * 
*                        ********************                         * 
*                                                                     * 
*                 2)  START/STOP INPUT REGULATION.                    * 
*                                                                     * 
*                     WORKCODE : TPSTARTIN  (START INPUT)             * 
*                                TPSTOPIN   (STOP  INPUT)             * 
*                                                                     * 
*                        ********************                         * 
*                        *       * WORKCODE *                         * 
*                        ********************                         * 
*                        *      UNUSED      *                         * 
*                        ********************                         * 
*                        *   TCB  ADDRESS   *                         * 
*                        ********************                         * 
*                                                                     * 
*                 3)  PROCESS OUTSTANDING PACKETS.                    * 
*                                                                     * 
*                     WORKCODE : L5ULPKT                              * 
*                                                                     * 
*                        ********************                         * 
*                        *       * WORKCODE *                         * 
*                        ********************                         * 
*                        *   LCB  ADDRESS   *                         * 
*                        ********************                         * 
*                        *   TCB  ADDRESS   *                         * 
*                        ********************                         * 
*                                                                     * 
** CALLING PROGRAM:                                                   * 
*                                                                     * 
*              REGULATION PROCESS       : PXPREGLPROCESS              * 
*              FORM PAD MESSAGE         : PXPFMPADMSG                 * 
*              FORM DOWNLINE FRAGMENT   : PXPFMDLFRG                  * 
*              UPLINE PACKET HANDLER    : PXPULHANDLER                * 
*                                                                     * 
** SUBROUTINE CALL:                                                   * 
*                                                                     * 
*     EXTERNAL SUBROUTINE                                             * 
*              CREATE A WORKLIST ENTRY  : PBLSPUT                     * 
*                                                                     * 
*     INTERNAL SUBROUTINE                                             * 
*              NONE                                                   * 
*                                                                     * 
*                                                                     * 
** NOTES:                                                             * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PXPQUEFRG _ (X9WKCODE : B06BITS; X9TIP : INTEGER) ? ; 
  
BEGIN 
  X1OUTWKLST.XAWC      := X9WKCODE;         _WORKCODE                  ?
  X1OUTWKLST.XABFRPTR  := X1DLFRGMT;        _DOWNLINE FRAGMENT POINTER ?
  X1OUTWKLST.XATCBLCCB := X1TCBADDR;        _TCB ADDRESS               ?
_ 
  * * *  MAKE WORKLIST ENTRY TO PACKET LEVEL (LEVEL 3). 
? 
  PBLSPUT (X1OUTWKLST.XAWORKLIST,           _WORKLIST                  ?
           BYWLCB[X9TIP]);
END;  _ PROCEDURE PXPQUEFRG  : QUEUE DOWNLINE FRAGMENT                 ?
_$J+  PAGE EJECT? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*              RELEASE SOURCE BUFFERS  ( PXPRELSRC )  : LEVEL  II     * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
** OVERVIEW:                                                          * 
*              THIS ROUTINE RELEASES THE TEXT PROCESSED SOURCE        * 
*              BUFFERS.  IF SOME UNTEXT PROCESSED DATA LEFT IT        * 
*              WILL UPDATE BUFFER FCD.                                * 
** INPUT:                                                             * 
*              TCB ADDRESS                  : X1TCBADDR               * 
*              FIRST SOURCE POINTER         : X1NCFSBA                * 
*              CURRENT SOURCE POINTER       : X1NCSBP                 * 
*              END OF BUFFER FLAG           : X1NCEOSR                * 
*              LEFT OR RIGHT CHAR FLAG      : X1NCRIGHTC              * 
** OUTPUT:                                                            * 
*              UPDATED SOURCE POINTER       : X1NCFSBA                * 
*                                                                     * 
** CALLING PROGRAM:                                                   * 
*                                                                     * 
*              INPUT TEXT PROCESS           : PXPINPUTP               * 
*              OUTPUT TEXT PROCESS          : PXPOUTPUTP              * 
*                                                                     * 
** SUBROUTINE CALL:                                                   * 
*                                                                     * 
*     EXTERNAL SUBROUTINE                                             * 
*              RELEASE BUFFER               : PBREL1BF                * 
*                                                                     * 
*     INTERNAL SUBROUTINE                                             * 
*              NONE                                                   * 
*                                                                     * 
** NOTES:                                                             * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PXPRELSRC;
  
VAR 
      X9MASKPTR : B0OVERLAY;                _MASKED BUFFER POINTER     ?
      X9BUFPTR  : B0BUFPTR;                 _UNTEXT PROCESSED DATA     ?
      X9ADDONE  : ARRAY [BOOLEAN] OF INTEGER; 
  
VALUE 
      X9ADDONE     = (0, 1);
  
BEGIN 
  X9MASKPTR.BASET := X1NCSBP.BASET  -       _MASK OFF TO EVEN BUFFER   ?
                         BEDBSIZE'.         _ BOUNDARY                 ?
                           BEMSK.BASET; 
  X9BUFPTR        := X9MASKPTR.BABUFPTR;
  IF X1NCEOSR                               _AT THE BUFFER BOUNDARY    ?
  THEN
    X9BUFPTR :=                             _MOVE TO NEXT BUFFER       ?
              X9BUFPTR'.BCCHAINS[DBUFLENGTH]
  ELSE                                      _SOMEWHERE IN BUFFER       ?
    X9BUFPTR'.BFFCD :=                      _SET BUFFER FCD FOR        ?
      (X1NCSBP.BAINT - X9MASKPTR.BAINT) * 2 _ THE NEXT TIME            ?
         + X9ADDONE[X1NCRIGHTC];
  WHILE  X1NCFSBA " X9BUFPTR  DO            _RELEASE TEXT PROCESSED    ?
    PBREL1BF (X1NCFSBA, BEDBSIZE);          _ DOWNLINE SOURCE BUFFRES  ?
END;  _ PROCEDURE PXPRELSRC : RELEASE TEXT PROCESSED SOURCE BUFFERS    ?
_$J+  PAGE EJECT? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*              COMPUTE PAD VALUES  ( PXCPADALUES )  : LEVEL   II      * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
** OVERVIEW:                                                          * 
*              THIS PROCEDURE MAPS CCP IVT SETTINGS TO CCITT X.3      * 
*              PAD PARAMETER VALUES. WHEN THE CCP X25 PAD FIRST       * 
*              ACCEPTS THE CALL ALL PAD VALUES ARE SENT, SUBSEQUENT   * 
*              TIMES ONLY CHANGES ARE FORWARDED TO THE ITI PAD        * 
*                                                                     * 
** INPUT:                                                             * 
*              A BOOLEAN FLAG WHICH CONTROLS THE SENDING OF ONLY      * 
*              CHANGES OR ALL SETTINGS                                * 
*                                                                     * 
** OUTPUT:                                                            * 
*              A PAD MESSAGE IF CHANGES OCCUR OR IF *X6SEND* TRUE     * 
*                                                                     * 
** CALLING PROGRAMS(S):                                               * 
*                                                                     * 
*                                                                     * 
** SUBROUTINE CALL:                                                   * 
*             PXPSPM                                                  * 
** NOTES:                                                             * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PXCPADVALUES _(X9SEND : BOOLEAN)? ; 
  
CONST 
 DEL   = $7F; 
 CAN   = $18; 
 NOACTION = 0;
 CRACTION = 1;
 LFACTION = 2;
 CRLFACTION = 3;
  
VAR 
  X6SIGNALS : PACKED ARRAY [0..31] OF CHAR; 
  X6INT     : INTEGER;
  X6VALUE   : INTEGER;
  X6INDEX   : INTEGER;
  CPACTION  : INTEGER;
  FWDCHAR   : INTEGER;
  
VALUE 
  X6SIGNALS = ($0040,$4010,$1004,$0404, 
               $4020,$2020,$2002,$4040, 
               $4040,$0840,$4040,$4040, 
               $0840,$4004,$4040,$4040);
  
BEGIN 
X6INDEX := X0MCODE/2 + 2; 
X1PADPKT.X1BUFACSS := NIL;                  _NO BUFFER GOTTEN          ?
FWDCHAR := DEL;                             _MAKE USE IT'S NOT A CR    ?
WITH X1TCBADDR'.BSTCB DO
  BEGIN 
  FOR X6INT := X0ESCAPE TO X0LNDISPLAY DO   _CCITT STANDARD PARAMTERS  ?
    BEGIN 
    X6VALUE := 0;                           _DEFAULT VALUE = 01        ?
    CASE X6INT OF 
  
      X0ESCAPE:                             _PAD RECALL USING CHARACTER?
      IF NOT BSXPT
      THEN                                  _ALLOW IF NOT IN XPARENT   ?
        X6VALUE := 1;                       _MODE                      ?
  
      X0ECHO:                               _ECHO                      ?
      IF BSECHOPLEX                         _MAP CCP ATTRIBUTE TO PAD  ?
      THEN
        IF BSXNECHO = FALSE 
        THEN
          X6VALUE := 1; 
  
      X0DTFWD:                              _DATA FORWARDING SIGNAL    ?
      BEGIN 
      IF BSXPT                              _IF TRANSPARENT MODE       ?
      THEN
        BEGIN 
        IF BSFLDPLX = FALSE                 _USE *BSXCHAR* IF NOT IN   ?
        THEN                                _FULL DUPLEX MODE (PLATO)  ?
          X6VALUE := BSXCHAR;               _ELSE USE NO FORWARDING CHR?
        END _ BSXPT ? 
      ELSE
        BEGIN 
        X6VALUE := BSELCHAR;                _USE *BSELCHAR*  AND       ?
        CPACTION := BSCPEL;                 _SAVE CURSOR POSTIONING    ?
        IF BSINDEV = B8BLKMODE              _BUT IF BLOCK MODE USE     ?
        THEN
          BEGIN 
          X6VALUE := BSEBCHAR;              _*BSEBCHAR*  AND SAVE      ?
          CPACTION := BSCPEB;               _EOB CURSOR POSTIONING     ?
          END;
        FWDCHAR := X6VALUE; 
        IF X6VALUE = DEL
        THEN
          X6VALUE := CAN; 
        END; _ ELSE BSXPT ? 
      X6VALUE := ORD(X6SIGNAL[X6VALUE]);    _GET CORRECT FWDING SIGNAL ?
      END;
  
      X0IDLETMRDLY:                         _IDLE TIMER DELAY          ?
      IF (BSFLDPLX & BSXPT)                 _IF FULLDUPLEX AND XPT THEN?
      THEN                                  _IF IN PLATO MODE SET TIME ?
        BEGIN                               _TO 1/20 SEC               ?
        X6VALUE :=1;                        _USE THE CHARACTER COUNT   ?
        IF BSXCNT > 1                       _FIELD TO DISTINGUISH PLATO?
        THEN                                _MODE                      ?
          X6VALUE :=4;                      _ELSE USE TIMER OF 1/5 SEC ?
        END;                                _TO SEND A PACKET          ?
  
      X0DEVICECTL:                          _ANCILLARY DEVICE CONTROL  ?
      IF BSRGLIN                            _MAP TO INPUT FLOW CONTROL ?
      THEN
        X6VALUE := 1; 
  
      X0SERVSIGNAL:                         _CONTROL OF PAD SIGNALS    ?
      GOTO 99;                              _DO NOT MODIFY             ?
  
      X0PADRECEIPT:                         _OPERATION ON BREAK        ?
      X6VALUE := 1 + 4 + 16;
  
      X0DISCARD:                            _DISCARD OUTPUT            ?
      IF NOT X9SEND                         _NORMAL DELIVERY           ?
      THEN                                  _ONLY SEND FIRST TIME      ?
        GOTO 99;
  
      X0CRPADDING:                          _PADDING AFTER CR          ?
      BEGIN 
_     X6VALUE := 0;      ?                  _IGNORE ALWAYS DONE BY TIP ?
      END;
  
      X0LINEFOLD:                           _LINE FOLDING              ?
      BEGIN 
_     X6VALUE := 0;      ?                  _NO LINE FOLDING           ?
      END;
  
      X0LNSPEED:                            _BINARY SPEED              ?
      GOTO 99;                              _NOT CHANGEABLE            ?
  
      X0FLOWCTL:                            _FLOW CONTROL OF PAD       ?
      IF BSRGLOUT                           _MAPPED TO CCP ATRIBUTE    ?
      THEN                                  _OUTPUT FLOW CONTROL       ?
        X6VALUE := 1; 
  
      X0LFINSERT:                           _LINEFEED INSERTION        ?
      IF BSCURPOS &                         _CURSOR POSITIONING        ?
         (BSXPT = FALSE) &                  _AND NOT IN XPARENT MODE   ?
         (BSNINCP = FALSE)                  _AND OK TO POSITION CURSOR ?
      THEN                                  _IN TRANSPARENT MODE       ?
        IF (FWDCHAR = I9CR) & (CPACTION = LFACTION) 
        THEN                                _LF AFTER AFTER CR REQUIRED?
          IF BSPADVALUES[X0ECHO] = CHR(1)   _AND PAD ECHOING THEN      ?
          THEN
            X6VALUE := 4;                   _HAVE THE PAD DO IT        ?
  
      X0LFPADDING:                          _LINEFEED PADDING          ?
      BEGIN 
_     X6VALUE := 0       ?                  _ALWAYS DONE BY CCP        ?
      END;
  
      X0EDITING:                            _EDITING                   ?
      BEGIN 
_     X6VALUE := 0       ?
      END;
  
      X0CHARDEL:                            _CHARACTER DELETE          ?
      GOTO 99;                              _DO NOT CHANGE             ?
  
      X0LNDELETE:                           _LINE DELETE               ?
      GOTO 99;                              _DO NOT CHANGE             ?
  
      X0LNDISPLAY:                          _LINE DISPLAY              ?
      GOTO 99;                              _DO NOT CHANGE             ?
  
    END; _CASE? 
  
    IF (X9SEND = TRUE) ! (BSPADVALUES[X6INT]" CHR(X6VALUE)) 
    THEN
      BEGIN 
      IF X1PADPKT.X1BUFACSS = NIL 
      THEN
        X1PADPKT.X1BUFACSS := PBGET1BUF (BEDBSIZE); 
      BSPADVALUES[X6INT] := CHR(X6VALUE);   _SAVE CURRENT SETTING      ?
      X1PADPKT.X1BUFACSS'.BIINT[X6INDEX] := X6INT*$100 + X6VALUE; 
      X6INDEX := X6INDEX + 1; 
      END;
99: 
    END; _ FOR ?
  IF X1PADPKT.X1BUFACSS " NIL               _IF CHANGES MADE           ?
  THEN
    BEGIN                                   _SET FCD/LCD               ?
    X1PADPKT.X1BUFACSS'.BIINT[1] := (X6INDEX * 2 - 3) * $100 + $0D; 
    PXPSPM;                                 _SHIP IT OUT               ?
    END;
  END; _ WITH ? 
END; _ PROCEDURE PXCPADVALUES ? 
_$J+? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*     SEND PAD MESSAGE WHEN LCN CONNECTED  (PXPSETX3)   : LEVEL II    * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
** OVERVIEW:                                                          * 
*              THIS ROUTINE SENDS A PAD MESSAGE FOR SETTING PAD       * 
*              PARAMETERS WHEN AN LCN IS CONNECTED.                   * 
*                                                                     * 
** INPUT:                                                             * 
*              TCB ADDRESS                  : X1TCBADDR               * 
*              X.3 PARAMETER SETTING TABLE  : PADTABLE                * 
*                                             (VALUES SET BY MPEDIT)  * 
*              GRPTCB'.BSPADPAR (HEX STRING): PAD PARAMETER LIST      * 
*                                             (SET BY CNF/TE SUP MSG) * 
*                                                                     * 
** OUTPUT:                                                            * 
*              PAD MESSAGE FOR SETTING PAD PARAMETERS SENT            * 
*                                                                     * 
** CALLING PROGRAM:                                                   * 
*              PAD MAIN PROGRAM                                       * 
*                                                                     * 
** SUBROUTINE CALL:                                                   * 
*     EXTERNAL SUBROUTINE                                             * 
*              GET A DATA BUFFER            : PBGET1BF                * 
*     INTERNAL SUBROUTINE                                             * 
*              SEND PAD PARAMETER MESSAGE   : PXPSPM                  * 
*                                                                     * 
** NOTE:                                                              * 
*                                                                     * 
*         PROCESSING DEPENDS ON SETTING OF BSPADPAR[1] IN GROUP TCB:  * 
*           IF THE VALUE IS $FFFF (DEFAULT),                          * 
*             THE SETTINGS FOUND IN PADTABLE ARE TO BE SENT.          * 
*           IF THE VALUE IS 0 (SET BY CNF/TE),                        * 
*             NO PAD PARAMETER MESSAGE IS SENT.                       * 
*           IF THE VALUE IS NEITHER OF THE ABOVE (SET BY CNF/TE),     * 
*             THE STRING IN BSPADPAR[1] AND THE FOLLOWING (UNTIL 0    * 
*             WORD) ARE THE PAD PARAMETER SETTINGS TO BE SENT.        * 
*                                                                     * 
*         PADTABLE STRUCTURE SET BY MPEDIT IS:                        * 
*                                                                     * 
*           LIST OF COMMON SETTINGS                                   * 
*           A PSN MARKER (IF ANY SETTINGS)                            * 
*           LIST OF SPECIAL SETTINGS FOR THE PSN                      * 
*           NEXT PSN MARKER (IF ANY SETTINGS)                         * 
*           LIST OF SPECIAL SETTINGS FOR THE PSN                      * 
*           ........                                                  * 
*           ........                                                  * 
*           END OF TABLE MARKER.                                      * 
*                                                                     * 
*         PSN MARKER VALUE FOR A PSN IS                               * 
*            $7F00 - 1 + BZTRANSTYPE IN SUBLCB.                       * 
*                                                                     * 
*            (7F00 FOR DATAPAC -- 7FFE FOR PSN255)                    * 
*                                                                     * 
*         END OF TABLE MARKER VALUE IS    7FFF.                       * 
*                                                                     * 
*         ENTRIES FOR PSN-S MUST BE SET UP IN THE ASCENDING ORDER     * 
*         OF THE MARKER VALUES.                                       * 
*                                                                     * 
*         PARAMETER   PARAMETER                                       * 
*         REFERENCE     VALUE                                         * 
*          NUMBER                                                     * 
*                                 COMMON PARAMETER SETTINGS           * 
*                                  SEE PXCPADVALUES PROCEDURE         * 
*                                                                     * 
*                                 PARAMETERS FOR SPECIFIC PSN FOLLOW  * 
*           ($7F)      ($01)     ** ($7F01) TELENET MARKER            * 
*            $00        $21         ($0021) NATIONAL TELENET MARKER   * 
*            $39        $01         ($3901) REAL TERMINAL MODE        * 
*                                                                     * 
*           ($7F)      ($FF)     ** ($7FFF) END OF TABLE MARKER       * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PXPSETX3; 
  
CONST 
      X7MARK     = $7F00;                   _PADTABLE MARKER/END       ?
  
VAR 
      X7MSGPKT   : B0BUFPTR;                _DOWNLINE PAD MESSAGE      ?
                                            _ PACKET POINTER           ?
      X7GRPTCB   : B0BUFPTR;                _GROUP TCB POINTER         ?
      X7PSN      : INTEGER;                 _PSN MARKER VALUE          ?
      X7INDEX    : INTEGER;                 _ARRAY INDEX               ?
      X7ITI      : INTEGER;                 _INDEX FOR PAD TABLE       ?
  
BEGIN 
X7GRPTCB := X1TCBADDR'.BSTCB.BSLCBP'.BZSLCBPTR;  _SUBLCB POINTER       ?
X7PSN    := X7MARK - 1                           _PSN MARKER VALUE     ?
             + X7GRPTCB'.BZXSLCB.BZTRANSTYPE; 
X7GRPTCB := X7GRPTCB'.BZXSLCB.BZGRPTCB[N0XPAD];  _PAD GRPTCB POINTER   ?
X7ITI    := X7GRPTCB'.BSTCB.BSPADPAR[1];    _FIRST WORD OF PAD PARAMTER?
IF (X7GRPTCB = NIL) ! (X7ITI = 0)           _IF NO PAD PAR MSG OPTION  ?
THEN
  GOTO 99;                                  _EXIT                      ?
X7INDEX  := 1;
X7MSGPKT := PBGET1BF (BEDBSIZE);
IF X7ITI = $FFFF                            _IF DEFAULT PAD PAR OPTION ?
THEN
_ 
* * *  COPY PAIRS OF REFERENCE NUMBER AND VALUE SETTING FOR CCITT.
? 
  BEGIN 
  WHILE PADTBLP'.PSNDEF[X7INDEX] < X7MARK DO
    BEGIN 
    X7MSGPKT'.BIINT[X7INDEX + 7] :=         _COPY THEM                 ?
                    PADTBLP'.PSNDEF[X7INDEX]; 
    X7INDEX := X7INDEX + 1; 
    END;
  X7ITI := X7INDEX;                         _LOOK FOR MORE PSN PARAMS  ?
_ 
* * *  LOOK FOR MATCHING MARKER, HIGHER MARKER OR END OF PADTABLE.
? 
  WHILE   PADTBLP'.PSNDEF[X7ITI] < X7PSN  DO
    X7ITI := X7ITI + 1; 
_ 
* * *  COPY MORE PSN PARAMETERS IF MATCHING MARKER IS FOUND.
? 
  IF PADTBLP'.PSNDEF[X7ITI] = X7PSN 
  THEN
    BEGIN 
    X7ITI := X7ITI + 1; 
    WHILE PADTBLP'.PSNDEF[X7ITI] < X7MARK  DO 
      BEGIN 
      X7MSGPKT'.BIINT[X7INDEX + 7] :=       _COPY THEM                 ?
                      PADTBLP'.PSNDEF[X7ITI]; 
      X7INDEX := X7INDEX + 1; 
      X7ITI   := X7ITI + 1; 
      END;
    END;
  END 
ELSE                                        _PAD PARAMETERS SPECIFIED  ?
  BEGIN 
  WHILE X7GRPTCB'.BSTCB.BSPADPAR[X7INDEX] " 0  DO 
    BEGIN 
    X7MSGPKT'.BIINT[X7INDEX + 7] :=         _COPY THEM                 ?
                    X7GRPTCB'.BSTCB.BSPADPAR[X7INDEX];
    X7INDEX := X7INDEX + 1; 
    END;
  END;
IF X7INDEX > 1
THEN
  BEGIN 
  X7MSGPKT'.BIINT[1] := (X7INDEX * 2 + 11) * $100 + $D; 
  X1PADPKT.X1BUFACSS := X7MSGPKT;           _SET BUFFER POINTER        ?
  PXPSPM;                                   _SEND USER PAD SETTINGS    ?
  END 
ELSE
  PBRELCHN (X7MSGPKT, BEDBSIZE);            _NO USER PAD SETTINGS      ?
PXCPADVALUES (TRUE);                        _MAP IVT SETTINGS TO PAD   ?
  
99: 
  
END;  _ PROCEDURE PXPSETX3                                             ?
_$J+ PAGE EJECT?
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*              SEND INVITATION TO CLEAR  ( PXPINVCLR )                * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
** OVERVIEW:                                                          * 
*              THIS PROCEDURE INITIATES CALL CLEARING WITH AN         * 
*              INVITATION TO CLEAR PAD MESSAGE.  A TIMER PACKET IS    * 
*              SET UP AND SENT TO TIMER SERVICES.  THIS ENSURES THAT  * 
*              IF THE PAD DOES NOT RESPOND WITH A CLEAR INDICATION IN * 
*              1:45 MINUTES, THEN CCP WILL TERMINATE THE CALL WITH    * 
*              A CLEAR REQUEST.                                       * 
*                                                                     * 
** INPUT:                                                             * 
*              TCB ADDRESS                  : X1TCBADDR               * 
** OUTPUT:                                                            * 
*              INVITATION TO CLEAR SENT                               * 
*              CLEAR REQUEST TIMER SET UP                             * 
*                                                                     * 
** CALLING PROGRAM:                                                   * 
*                                                                     * 
*              PAD SUBTIP WORKLIST HANDLER  : PXPADTIP                * 
*                                                                     * 
** SUBROUTINE CALL:                                                   * 
*                                                                     * 
*     EXTERNAL SUBROUTINE                                             * 
*              GET A DATA BUFFER            : PBGET1BF                * 
*              TIMER SERVICES               : PBTMRSRVS               * 
*                                                                     * 
*     INTERNAL SUBROUTINE                                             * 
*              FORM DOWNLINE PAD MESSAGE    : PXPFMPADMSG             * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PXPINVCLR;
BEGIN 
X1MSGPKT := PBGET1BUF(BEDBSIZE);            _GET A BUFFER FOR MSG      ?
X1MSGPKT'.BIINT[1] := X0MCODE * $100 + X0MCODE;       _LCD AND FCD     ?
X1MSGPKT'.BIINT[7] := X0CLEAR;              _INVITATION TO CLEAR       ?
X1MSGPKT'.BCCHAINS[QCHN] := NIL;
X1MSGPKT'.BCCHAINS[DBUFLENGTH] := NIL;
X1PADPKT.X1BUFACSS := X1MSGPKT; 
PXPFMPADMSG;
_ 
* * * *  CALL TIMER SERVICE ROUTINE TO SET CLEAR REQUEST TIMER
? 
WITH X1TCBADDR'.BSTCB.BSLCCBPTR'.LCCB DO
  BEGIN 
  X1TMRPKT.X1BUFACSS := LCTMRPKT;           _TIMER PACKET POINTER      ?
  IF X1TMRPKT.X1BUFACSS = NIL               _TIMER IS NOT RUNNING      ?
  THEN
    BEGIN 
    X1TMRPKT.X1BUFACSS :=                   _GET 8 WORD BUFFER FOR     ?
                  PBGET1BF(B0S8);           _TIMER PACKET              ?
    WITH X1TMRPKT.X1TMRACSS'  DO
      BEGIN 
      BKWLINDEX := B0X25TIP;                _WORKLIST INDEX FOR X25TIP ?
      BKWKCODE  := L5SENDCLR;               _WORKCODE TO BE RETURNED   ?
      BKTIME    := X0TIMVAL;                _SET TIMER VALUE           ?
      BKTYPE    := BKSET;                   _SET TIMER                 ?
      BKUSRBYTE := LCCNTYPE;                _TIMER FOR PAD SUBTIP      ?
      BK1UPTR   := X1TMRPKT.X1BUFACSS;      _TIMER PACKET POINTER      ?
      END;
    LCTMRPKT := X1TMRPKT.X1BUFACSS;         _COPY TIMER PACKET POINTER ?
                                            _TO TCB                    ?
    END;  _X1TMRPKT = NIL?
  X1TMRPKT.X1TMRACSS'.BK2UPTR :=            _TCB ADDRESS               ?
                          X1TCBADDR;
  PBTMRSRVS (X1TMRPKT.X1TMRACSS);           _CALL TIMER SERVICE        ?
  END;
END;  _PROCEDURE PXPINVCLR? 
_$J+ PAGE EJECT?
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*              RELEASE TCB BUFFERS  ( PXPTCBRELBUF )  : LEVEL II      * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
** OVERVIEW:                                                          * 
*              THIS PROCEDURE CALLS THE PAD SUBTIP BUFFER RELEASE     * 
*              ROUTINE TO RELEASE INPUT AND OUTPUT RELATED BUFFERS    * 
** INPUT:                                                             * 
*              TCB ADDRESS                  : X1TCBADDR               * 
*                (INPUT AND OUTPUT BUFFER                             * 
*                 POINTERS)                                           * 
** OUTPUT:                                                            * 
*              NONE                                                   * 
*                                                                     * 
** CALLING PROGRAM:                                                   * 
*                                                                     * 
*              PAD SUBTIP WORKLIST HANDLER  : PXPADTIP                * 
*                                                                     * 
** SUBROUTINE CALL:                                                   * 
*                                                                     * 
*     EXTERNAL SUBROUTINE                                             * 
*              RELEASE CHAIN OF BUFFERS     : PBRELCHN                * 
*                                             PBRELZRO                * 
*                                                                     * 
*     INTERNAL SUBROUTINE                                             * 
*              NONE                                                   * 
*                                                                     * 
*                                                                     * 
** NOTES:                                                             * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PXPTCBRELBUF; 
  
VAR 
      X3RELBUF  : B0BUFPTR; 
  
BEGIN 
  
PBRELZRO (X1TCBADDR'.BSTCB.BSXDLSRC,        _RELEASE DOWNLINE SOURCE   ?
                               BEDBSIZE);   _ DATA BUFFERS             ?
_ 
* * *  RELEASE QUEUED UPLINE PACKET.
? 
WHILE  X1TCBADDR'.BSTCB.BSXFSTPKT " NIL  DO 
  BEGIN 
  X3RELBUF := X1TCBADDR'.BSTCB.BSXFSTPKT'.BCCHAINS[QCHN]; 
  PBRELCHN (X1TCBADDR'.BSTCB.BSXFSTPKT, BEDBSIZE);
  X1TCBADDR'.BSTCB.BSXFSTPKT := X3RELBUF; 
  END;
X1TCBADDR'.BSTCB.BSXLSTPKT := NIL;
_ 
* * *  RELEASE ANY PARTIAL INPUT QUEUED OFF THE TPCB AND THE TPCB 
? 
X3RELBUF := X1TCBADDR'.BSTCB.BSXINTPCB; 
IF X3RELBUF " NIL                           _IF TPCB EXISTS            ?
THEN
  BEGIN 
  PBRELZRO (X3RELBUF'.BGMLCB.NCSCBA, BEDBSIZE);   _RELEASE PARTIAL DATA?
  PBREL1BF (X1TCBADDR'.BSTCB.BSXINTPCB, BETPSIZE);_RELEASE TPCB        ?
  END;
END;  _ PROCEDURE PXPTCBRELBUF : RELEASE TCB BUFFERS                   ?
_$J+ PAGE EJECT?
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*              UPLINE HANDLER  ( PXPULHANDLER )  : LEVEL II           * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
** OVERVIEW:                                                          * 
*              THIS ROUTINE CHECK FOR TYPE OF INCOMING PACKET AND     * 
*              IF SUBTIP STARTS TO HAVING TOO MANY UPLINE PACKET      * 
*              QUEUED FROM PACKET LEVEL, IT WILL NOTIFY TO HOLD       * 
*              INCOMING PACKET TO PACKET LEVEL.                       * 
*                                                                     * 
** INPUT:                                                             * 
*              TCB ADDRESS                  : X1TCBADDR               * 
*              UPLINE PACKET POINTER        : BSXFSTPKT               * 
** OUTPUT:                                                            * 
*              UPLINE PAD PACKET            : X1PADPKT                * 
*               (FOR PAD PROCESSOR)                                   * 
*              UPLINE DATA PACKET           : X1UPLPKT                * 
*              WORKCODE                     : TPSTARTIN               * 
*                                             TPSTOPIN                * 
*                                             L5ULPKT                 * 
*                                                                     * 
** CALLING PROGRAM:                                                   * 
*                                                                     * 
*              PAD SUBTIP WORKLIST HANDLER  : PXPADTIP                * 
*                                                                     * 
** SUBROUTINE CALL:                                                   * 
*                                                                     * 
*     EXTERNAL SUBROUTINE                                             * 
*              NONE                                                   * 
*                                                                     * 
*     INTERNAL SUBROUTINE                                             * 
*              INPUT TEXT PROCESS           : PXPINPUTTP              * 
*              PROCESS PAD MESSAGE PACKET   : PXPPADPROCESS           * 
*              FORM UPLINE BLOCK            : PXPFMULBLK              * 
*              QUEUE DOWNLINE FRAGMENT      : PXPQUEFRG               * 
*                                                                     * 
** NOTES:                                                             * 
*              #X1ULBLOCK# AND #X1FLGWRD# ARE CLEARED BY              * 
*              PROCEDURE PXPFMULBLK.                                  * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PXPULHANDLER; 
  
VAR 
      X3PROCESS   : BOOLEAN;
  
BEGIN 
WITH  X1TCBADDR'.BSTCB  DO
  BEGIN 
  X1ULPACKET := BSXFSTPKT;                  _COPY UPLINE PACKET POINTER?
  X3PROCESS  := X1ULPACKET " NIL;           _UPLINE PACKET PROCESSING  ?
                                            _ FLAG                     ?
_ 
  * * *  KEEP ON PROCESSING UPLINE PACKET UNTIL EXHAUSTED PACKETS 
  * * *  OR SUBTIP MUST GIVE UP CONTROL INORDER FOR BIP TO PROCESS
  * * *  UPLINE DATA WHICH QUEUED BY SUBTIP.
? 
  WHILE  X3PROCESS  DO
    BEGIN 
    X1UPLPKT   := X1ULPACKET;               _EXTRACT FIRST PACKET IN   ?
    X1ULPACKET := X1ULPACKET'.              _ CHAIN AND UPDATE PACKET  ?
                          BCCHAINS[QCHN];   _ POINTER                  ?
_ 
    * * *  CLEAR FLAG WORD FIELDS FOR ULTS. 
? 
    X1FLGWRD.KTWORD  := 0;
    X1FLGWRD.KTCKSPC := TRUE; 
_ 
    * * *  CHECK FOR TYPE OF PACKET (Q - BIT).
    * * * 
    * * *    Q-BIT = 1 : PAD MESSAGE PACKET.
    * * *    Q-BIT = 0 : PAD DATA PACKET. 
? 
    X1QMBIT.X1QMWORD :=                     _EXTRACT Q AND M BITS      ?
                     X1UPLPKT'.BIINT[X0QM]; 
    X1PADPKT.X1BUFACSS := X1UPLPKT; 
    IF X1QMBIT.X1QBIT = FALSE               _DATA PACKET               ?
    THEN
      BEGIN 
      BSXEOB := FALSE;
      PXPINPUTTP;                           _TEXT PROCESS UPLINE DATA  ?
                                            _ PACKET                   ?
      END 
    ELSE                                    _PAD MESSAGE PACKET        ?
      BEGIN 
      X1PADMSG := 0;
_ 
      * * *  PROCESS PAD MESSAGE PACKET.
? 
      PXPPADPROCESS;                        _PROCESS PAD MESSGAE       ?
_ 
      * * *  CHECK FOR OUTCOME OF THE PAD MESSAGE.
      * * *    (SUBTIP WILL CALL ULTS RECEIPT OF THE BREAK INDICATION)
? 
      IF X1PADMSG = X0BREAK 
      THEN
        BEGIN 
        X1ULBLOCK         := NIL; 
        X1FLGWRD.KTUBREAK := TRUE;          _SET BREAK SEEN FLAG       ?
        BSXULBLOCK        := HTMSG;         _CHECK FOR RESULT FROM ULTS?
_ 
        * * *  NOTIFY TO ULTS (BIP).
? 
        X1SECURITY := FALSE;
        PXPFMULBLK; 
        END;  _ IF INDICATION OF BREAK                                 ?
      END;  _ ELSE PAD MESSAGE PACKET                                  ?
_ 
    * * *  DETERMINE WHETHER TO PROCESS MORE PACKETS OR NOT.
? 
    X3PROCESS := X1ULPACKET " NIL;
  
    IF X1UPLPKT " NIL                       _COULD NOT PROCESS PACKET  ?
    THEN                                    _PUT PACKET BACK TO IN     ?
      BEGIN                                 _ FRONT OF OUTSTANDING     ?
                                            _ PACKET CHAIN             ?
      X1UPLPKT'.                            _RESTORE Q AND M BITS      ?
            BIINT[X0QM] := X1QMBITS.        _ INTO LEFT OVER PACKET    ?
                                  X1QMWORD; 
      X1UPLPKT'.
         BCCHAINS[QCHN] := X1ULPACKET;
      X1ULPACKET        := X1UPLPKT;
      X3PROCESS         := FALSE; 
      END;
    END;  _ WHILE X3PROCESS                                            ?
_ 
  * * *  CHECK FOR STATUS OF OUTSTANDING PACKET.
? 
  BSXFSTPKT := X1ULPACKET;                  _RESTORE PKT PTR TO TCB    ?
_ 
  * * *  COUNT THE NUMBER OF OUTSTANDING UPLINE PACKET. 
? 
  X1PKTCNT := 0;
  WHILE  X1ULPACKET " NIL  DO               _LOOP THRU PACKETS         ?
    BEGIN 
    X1PKTCNT   := X1PKTCNT + 1; 
    X1ULPACKET := X1ULPACKET'.BCCHAINS[QCHN]; 
    END;
_ 
  * * *  CHECK FOR THE NUMBER OF OUTSTANDING PACKET (UNPROCESSED
  * * *  UPLINE PACKETS). 
  * * * 
  * * *  IF THE NUMBER OF OUTSTANDING PACKETS IS 6 OR MORE, SUBTIP
  * * *  SENDS *TPSTOPIN* TO LEVEL 3.  IF *TPSTOPIN* WAS SENT AND 
  * * *  THE NUMBER OF OUTSTANDING PACKETS BECOMES LESS THAN OR 
  * * *  EQUAL TO 6, SUBTIP SENDS *TPSTARTIN* TO LEVEL 3 FOR MORE 
  * * *  UPLINE PACKETS.
  * * * 
? 
  IF BSXWAIT                                _LVL 3 WAITING FOR PAD TO  ?
  THEN                                      _ START INPUT              ?
    IF X1PKTCNT @ X0MAXPKT                  _OK TO ACCEPT MORE PACKETS ?
    THEN
      BEGIN 
      BSXWAIT   := FALSE; 
      X1DLFRGMT := NIL; 
      PXPQUEFRG (TPSTARTIN, B0XTRANS);      _SEND START INPUT TO XPORT ?
      END;
  IF X1PKTCNT > X0MAXPKT                    _MAXIMUM PACKET COUNT      ?
  THEN
    IF BSXWAIT = FALSE                      _LEVEL 3 HAS NOT NOTIFIED  ?
    THEN                                    _ TO HOLD UPLINE PACKETS   ?
      BEGIN 
      BSXWAIT   := TRUE;
      X1DLFRGMT := NIL; 
      PXPQUEFRG (TPSTOPIN, B0XTRANS);       _SEND STOP INPUT TO XPORT  ?
      END;
_ 
  * * *  CHECK FOR THE EXISTANCE OF OUTSTANDING PACKETS.
? 
  IF X1PKTCNT " 0                           _THERE IS OUTSTANDING      ?
  THEN                                      _ PACKETS                  ?
    BEGIN 
    X1DLFRGMT := BSLCBP;
    PXPQUEFRG (L5ULPKT, B0X25TIP);          _WORKCODE TO PAD SUBTIP    ?
    END;
  END;  _ WITH  X1TCBADDR                                              ?
END;  _PROCEDURE PXPULHANDLER : UPLINE HANDLER                         ?
_$J+  PAGE EJECT? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*              PAD SUBTIP MAIN PROGRAM (WORKLIST HANDLER)             * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
** OVERVIEW:                                                          * 
*              X25 PACKET ASSEMBLY / DISASSEMBLY INTERFACE.           * 
*                                                                     * 
*              THE RECEIVED WORKLIST ENTRY IS COPIED TO INTERNAL      * 
*              VARIABLES (X1INWKLST) FOR USE WITHIN THE SUBTIP.       * 
*              IF THE RECEIVED WORK CODE IS EXPECTED, THE PROCESS     * 
*              CONTROL WILL BE PASSED TO ONE OF THE LEVEL II          * 
*              ROUTINES (REFER TO INTERNAL SUBROUTINES), OTHERWISE    * 
*              NO ACTION WILL BE TAKEN.                               * 
** INPUT:                                                             * 
*              BWWLENTRY[OPS] WORKLIST ENTRY                          * 
*                                                                     * 
*                    WORK CODE        DESCRIPTION         ORIGINATOR  * 
*                    ---------  ----------------------    ----------- * 
*                 1) L3FRGQ     UPLINE FRAGMENT WAS       X25 LEVEL 3 * 
*                               QUEUED FROM LEVEL 3.                  * 
*                 2) L3FRGR     SEND DOWNLINE FRAGMENT    X25 LEVEL 3 * 
*                               TO LEVEL 3.                           * 
*                 3) A0QUEOUT   DOWNLINE NETWORK BLOCK    BIP         * 
*                     (L5QUEOUT) IS QUEUED.                (DOWNLINE  * 
*                                                           TIP       * 
*                                                           SERVICE ) * 
*                 4) L5SMEN     ENABLE LINE REQUEST.      SVM         * 
*                               (NO ACTION IS TAKEN                   * 
*                                AT THIS RELEASE)                     * 
*                 5) L5SMDA     DISABLE LINE REQUEST.     SVM         * 
*                                                                     * 
*                 6) L5SMDLTCB  RECONFIGURE TERMINAL      SVM         * 
*                               REQUEST.                              * 
*                                                                     * 
*                 7) L5TCB      FREE UP TCB.              SVM         * 
*                       (CMDATA = D5FREE)                             * 
*                 8) L5TIMEOUT  EXPIRATION OF TIMER.      TIMER       * 
*                                                          ROUTINE    * 
*                 9) L5ULPKT    NEED TO PROCESS           PAD SUBTIP  * 
*                               OUTSTANDING UPLINE                    * 
*                               PACKETS.                              * 
*                 10)L3INVCLR   SEND INVITATION TO CLEAR  X25 LEVEL 3 * 
** CALLING PROGRAM:                                                   * 
*                                                                     * 
*              X25 TIP              : PX25TIP                         * 
*                                                                     * 
** SUBROUTINE CALLS:                                                  * 
*                                                                     * 
*     EXTERNAL SUBROUTINE                                             * 
*              LOOK FOR THE ADDRESS : PBLCBP                          * 
*              OF LCB.                                                * 
*              RELEASE BUFFER       : PBREL1BF                        * 
*                                                                     * 
*     INTERNAL SUBROUTINE                                             * 
*              UPLINE HANDLER       : PXPULHANDLER                    * 
*              CHECK OUTPUT STATUS  : PXPCHECKOUT                     * 
*              REGULATION PROCESS   : PXPREGLPROCESS                  * 
*              RELEASE TCB BUFFER   : PXPTCBRELBUF                    * 
*                                                                     * 
** NOTES:                                                             * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
BEGIN                                       _START OF MAIN PROGRAM     ?
X1INWKLST.XAWORKLIST := BWWLENTRY[OPS];     _SAVE WORKLIST INTO LOCAL  ?
                                            _ FIELDS                   ?
WITH  X1INWKLST  DO                         _WORK ON RECEIVED WORKLIST ?
                                            _ ENTRY.                   ?
  BEGIN 
  X1TCBADDR := XATCBLCCB;                   _GET TCB ADDRESS           ?
  
  CASE XAWC OF                              _CASE ON EXPECTED WORKCODE ?
  
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
* *   W O R K C O D E   F R O M   P A C K E T   L E L E L             * 
*                                              ( X25 LEVEL 3 )        * 
*                                                                     * 
? 
_ 
* * * *  DOWNLINE FRAGMENT REQUEST. (L3FRGR)
? 
    L3FRGR:                                 _DOWNLINE FRAGMENT REQUEST ?
  
      BEGIN 
      WITH  X1TCBADDR'.BSTCB  DO
        BEGIN 
        IF XANEWCN                          _PACKET LEVEL RECEIVED     ?
        THEN                                _ CALL REQUEST PACKET      ?
          BEGIN 
          BSXDLBLOCK   := HTMSG;            _RESET LAST DL BLOCK RECV. ?
          BSXULBLOCK   := HTMSG;            _RESET LAST UL BLOSK SEND  ?
          BSXEOB       := TRUE;             _SET END OF BLECK          ?
          PXPSETX3;                         _SEND PAD MESSAGE          ?
          END;  _ NEW CONNECTION                                       ?
        BSXFRGREQ := TRUE;                  _REMEMBER THE REQUEST      ?
        END;  _ WITH  X1TCBADDR                                        ?
      PXPCHECKOUT;                          _TRY TO PROCESS DOWNLINE   ?
                                            _ NETWORK BLOCK            ?
      END;  _ L3FRGR                                                   ?
_ 
* * * *  UPLINE FRAGMENT QUEUED. (L3FRGQ) 
? 
    L3FRGQ:                                 _UPLINE FRAGMENT QUEUED    ?
  
      BEGIN 
      PXREGLCHK (XAWC,                      _CALL SUBTIP AID PROGRAM   ?
                 X1TCBADDR,                 _ TO CHECK CCP REGULATION  ?
                 NIL);                      _ NO TIMER PACKET POINTER  ?
      WITH  X1TCBADDR'.BSTCB  DO
        BEGIN 
_ 
        * * *  CHECK FOR EMPTY UPLINE PACKET. 
? 
        IF XABFRPTR'.BFLCD < XABFRPTR'.BFFCD
        THEN                                _FOUND EMPTY UPLINE PACKET ?
          PBRELCHN (XABFRPTR, BEDBSIZE)     _IGNORE THE PACKET         ?
        ELSE
          BEGIN 
          IF BSECHOPLEX                     _IF ECHOPLEX SELECTED      ?
          THEN
            IF BSPADVALUES[X0ECHO] = CHR(0) _AND PAD NOT ECHOING       ?
            THEN
              PXCPADVALUES (FALSE);         _RE-COMPUTE PAD VALUES     ?
_ 
          * * *  ASSIGN THE FIRST AND LAST PACKET POINTERS. 
? 
          IF BSXFSTPKT = NIL                _NO OUTSTANDING UPLINE PKT ?
          THEN
            BSXFSTPKT := XABFRPTR 
          ELSE                              _SOME PACKET LEFT FROM LAST?
            BSXLSTPKT'.BCCHAINS[QCHN]       _ TIME, QUEUE CHAIN THEM   ?
                               := XABFRPTR; 
          BSXLSTPKT := XABFRPTR;            _LAST PACKET IN CHAIN      ?
_ 
          * * *  PROCESS UPLINE PACKETS.
? 
          PXPULHANDLER;                     _CHECK FOR TYPE OF UPLINE  ?
                                            _ FRAGMENT                 ?
          END; _ IF XABFRPTR'.BFLCD < BFFCD                            ?
_ 
        * * *  PROCESSED INPUT DATA NOW TRY TO PROCESS OUTPUT DATA. 
? 
        IF XAREQ                            _LEVEL 3 REQUESTING MORE   ?
        THEN                                _DOWNLINE PACKETS          ?
          BSXFRGREQ := TRUE;
        PXPCHECKOUT;                        _LOCATE MORE OUTPUT        ?
        END;  _ WITH X1TCBADDR                                         ?
      END;  _ L3FRGQ                                                   ?
  
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
* *   W O R K C O D E   F R O M   B I P                               * 
*                                      ( BIP DOWNLINE TIP SERVICE )   * 
*                                                                     * 
? 
_ 
* * * *  DOWNLINE NETWORK BLOCK QUEUED. (L5QUEOUT)
? 
    L5QUEOUT:                               _DOWNLINE DATA QUEUED BY   ?
                                            _ DOWNLINE TIP SERVICE     ?
      BEGIN 
      PXPCHECKOUT;                          _TRY TO PROCESS DOWNLINE   ?
                                            _ NETWORK BLOCK            ?
      END;  _ L5QUEOUT                                                 ?
  
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
* *   W O R K C O D E   F R O M   S E R V I C E   M O D U L E         * 
*                                                                     * 
? 
_ 
* * * *  NO ACTION FOR
                 A0SMEN (L5SMEN)
                 A0SMDA (L5SMDA)
? 
  
_ 
* * * *  DELETE TCB REQUEST. (L5SMDLTCB)
? 
    L5SMDLTCB:                              _DELETE TCB REQUEST        ?
  
      BEGIN 
      IF X1TCBADDR'.BSTCB.BSXTMRPKT " NIL   _TIMER PACKET EXIST        ?
      THEN
        BEGIN 
_ 
        * * *  CLEAR TCB POINTER IN TIMER PACKET
        * * *  SINCE TCB WILL BE DELETED. 
? 
        X1TMRPKT.X1BUFACSS          := X1TCBADDR'.BSTCB.BSXTMRPKT;
        X1TMRPKT.X1TMRACSS'.BK2UPTR := NIL; 
        END;  _ IF BSXTMRPKT " NIL                                     ?
      PXPTCBRELBUF; 
      END;  _ L5SMDLTCB                                                ?
_ 
* * * *  FREE UP TCB. 
? 
    L5TCB:                                  _FROM X25TIP    - D5FREE   ?
_   L3TCB:                                   FORM LEVEL 3   - D5DOWN   ?
  
      BEGIN 
      PXPTCBRELBUF; 
      END;  _ L5TCB                                                    ?
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
* *   W O R K C O D E   F R O M   T I M E R   S E R V I C E           * 
*                                                                     * 
? 
_ 
* * * *  REGULATION TIMER TIMEOUT. (L5TIMEOUT)
? 
    L5TIMEOUT:                              _REGULATION TIMER TIME OUT ?
  
      BEGIN 
      PXREGLCHK (XAWC,                      _CALL SUBTIP AID PROGRAM   ?
                 NIL,                       _ TO CHECK CCP REGULATION  ?
                 XABFRPTR);                 _ NO TCB ADDRESS           ?
      END;  _ L5TIMEOUT                                                ?
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
* *   P A D   S U B T I P   I N T E R N A L   W O R K C O D E         * 
*                                                                     * 
? 
_ 
* * * *  UPLINE PACKET STILL OUTSTANDING. (L5ULPKT) 
? 
    L5ULPKT:  
  
      BEGIN 
      PXPULHANDLER;                         _PROCESS OUTSTANGING       ?
                                            _ UPLINE PACKET            ?
      END;  _ L5ULPKT                                                  ?
_ 
* * * *  SEND A SET PAD PARAMETER MESSAGE TO PAD
? 
    L5SETPAD: 
  
      BEGIN 
      PXCPADVALUES (FALSE);                 _RE-COMPUTE PAD VALUES     ?
      END;  _L5SETPAD?
_ 
* * * *  INITIATE CALL CLEARING WITH INVITATION TO CLEAR MSG
? 
    L3INVCLR:                               _INVITATION TO CLEAR       ?
  
      BEGIN 
      PXPINVCLR;                            _SEND INV TO CLEAR         ?
      END;  _L3INVCLR?
    END;  _ CASE XAWC                                                  ?
  END;  _ WITH  X1INWKLST                                              ?
END;  _ PROCEDURE PXPADTIP : PAD SUBTIP WORKLIST HANDLER               ?
_$J+  PAGE EJECT? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*           TABLE FOR PAD X.3 REFERENCE PARAMETER AND VALUE           * 
*                                                                     * 
*                        PADTABLE (LEVEL I)                           * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_$R-,G-,I-     NON-RECURSIVE
               INTERRUPTABLE? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
** OVERVIEW:                                                          * 
*              THIS PROCEDURE IS TO KEEP THE PAD X.3 CCITT AND ITI    * 
*              PARAMETERS WHICH ARE USED TO SET X.3 PARAMETER         * 
*              VALUES IN PSN PAD ACCORDING TO THE CDC RECOMMENDED     * 
*              PAD REFERENCE VALUE SETTING WHEN THE USER LOGS IN.     * 
*                                                                     * 
*              ONE OF X25 PAD SUBTIP ROUTINE *PXPSETX3* (LEVEL II)    * 
*              USES THE TABEL TO GENERATE THE DOWNLINE PAD MSG        * 
*              PACKET (SET COMMAND, Q-BIT SET TO 1)                   * 
*                                                                     * 
*              THIS TABLE IS CONSISTED OF 2 PARTS, THE FIRST IS       * 
*              CCITT PARAMETER SETTING, THE SECOND IS ITI             * 
*              PARAMETER SETTING FOR EACH PSN.                        * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PADTABLE; 
  
VAR 
      PSNDEF : ARRAY [1..30] OF INTEGER;
  
BEGIN 
_ 
* * *  THE TABLE *PSNDEF* IS INITIALIZED BY MP-EDIT STATAMENTS. 
? 
END;  _ PROCEDURE PADTABLE                                             ?
