*COMDECK TIPSUBS
_$J+? 
_$I+,G-,R-
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*                           P T C T C H R                             * 
*                                                                     * 
*               COUNT CHARCATERS IN CHAIN OF BUFFERS                  * 
*                                                                     * 
*                                                                     * 
** INPUT:  PARAMETER 1 = POINTER TO BUFFER CHAIN, CAN BE NIL          * 
*                                                                     * 
** OUTPUT: FUNCTION RETURN VALUE IS NUMBER OF CHARACTERS IN CHAIN     * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
FUNCTION PTCTCHR _(H0BUF : B0BUFPTR) : INTEGER? ; 
  
VAR  H0FCD : INTEGER; 
     H0CNT : INTEGER; 
  
BEGIN 
H0CNT := 0;                                 _CLEAR COUNT INITIALLY     ?
WHILE H0BUF " NIL DO
  BEGIN 
  H0FCD := H0BUF'.BFFCD;                    _GET FCD LOCAL             ?
  H0CNT := H0BUF'.BFLCD - H0FCD + H0CNT + 1;_ADD CHAR IN CUR BUF TO CNT?
  H0BUF := H0BUF'.BCCHAINS [DBUFLEN];       _GET ADDRESS NEXT BUFFER   ?
  END;
PTCTCHR := H0CNT;                           _RETURN COUNT TO CALLER    ?
END; _FUNCTION PTCTCHR? 
  
_$I-,G-,R-
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*                          P T G E T S E T                            * 
*                                                                     * 
*                 GET SET (SETINT) FROM GIVEN INTEGER                 * 
*                                                                     * 
*                                                                     * 
** INPUT:  PARAMETER 1 - NUMBER OF BIT TO BE SET IN PARM2             * 
*                                                                     * 
** OUTPUT: PARAMETER 2 - SET (PARM2 := 2 ** (PARM1 MOD 16)            * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PTGETSET _(H0INT : INTEGER; VAR H0SET : B0OVERLAY)? ; 
  
VAR 
  H0REC : B0OVERLAY;
  
BEGIN 
H0REC.BAINT := H0INT;                       _GET PARAMATER MOD 16      ?
H0SET.BASET := BITMASK [H0REC.BAHEX.B0H4];  _GENERATE PROPER BIT MASK  ?
END; _PROCEDURE PTGETSET? 
  
_$I-,G-,R-
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*                          P T C H A I N                              * 
*                                                                     * 
*             CHAIN BUFFER AT END OF GIVEN BUFFER CHAIN               * 
*                                                                     * 
*                                                                     * 
** INPUT:  PARAMETER 1 - POINTER TO CHAIN                             * 
*                                                                     * 
*          PARAMETER 2 - POINTER TO BUFFER(S) TO BE ADDED TO CHAIN    * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PTCHAIN _(H0BUF : B0BUFPTR; VAR H0CHN : B0BUFPTR)? ;
  
VAR 
  H0WBP : 'B0BUFPTR;
  
BEGIN 
ADDR (H0CHN, H0WBP);                        _SET PTR TO START OF CHAIN ?
WHILE H0WBP' " NIL DO 
  ADDR (H0WBP''.BCCHAINS [DBUFLEN], H0WBP); _LOCATE END OF CHAIN       ?
H0WBP' := H0BUF;                            _ADD BUFFER(S) TO END CHAIN?
END; _PROCEDURE PTCHAIN?
  
_$I-,G-,R-
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*                       P B F C O P Y                                 * 
*                                                                     * 
*          COPY CHARACTERS FROM ONE GIVEN BUFFER INTO ANOTHER         * 
*                                                                     * 
*                                                                     * 
** INPUT:  PARAMETER 1 - SOURCE BUFFER POINTER.                       * 
*                        COPIES FROM FCD TO LCD OF FIRST BUFFER ONLY  * 
*                                                                     * 
*          PARAMETER 2 - DESTINATION BUFFER POINTER.                  * 
*                                                                     * 
*                        OPTION 1: NO DESTINATION BUFFER, PBFCOPY     * 
*                                  WILL GET IT AND USE THE DFLT FCD   * 
*                                                                     * 
*                        OPTION 2: DESTINATION BUFFER ASSIGNED,       * 
*                                  PBFCOPY WILL USE THE FCD OF THE    * 
*                                  GIVEN BUFFER.                      * 
*                                                                     * 
** OUTPUT: PARAMETER 2 - DESTINATION BUFFER POINTER.                  * 
*                        COULD HAVE A BUFFER OR CHAIN OF BUFFERS.     * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PBFCOPY _(H0SRCP : B0BUFPTR; VAR H0DESP : B0BUFPTR)? ;
  
VAR 
  H0REGA   : INTEGER;                       _ADDRESS OF THE FIRST      ?
                                            _ PARAMETER FOR FIRMWARE   ?
  
BEGIN 
IF H0DESP = NIL                             _NO DEST. BUFFER IS        ?
THEN                                        _ GIVEN                    ?
  H0DESP := PBGET1BF(BEDBSIZE);             _GET ONE                   ?
_ 
* * * *  ESCAPE TO FIRMWARE FOR THE COPY FUNCTION 
? 
RETADR (H0REGA);           _                 GET RETURN ADDRESS        ?
INST   ($C400, H0REGA,     _ LDA   H0REGA    RETURN ADD TO A-REG       ?
        $09FD,             _ INA   -2        GET ADDR OF 1ST PARAMETER ?
        $E400, PFCOPY,     _ LDQ   PFCOPY    FM COPY ROUTINE           ?
        $0BA2);            _ EMS   Q         ESCAPE TO FIRMWARE        ?
END;  _PROCEDURE PBFCOPY? 
  
  
_$I-,G-,R-
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*                       P T E B R E L                                 * 
*                                                                     * 
*          TEST FOR AND RELEASE AN EMPTY DATA BUFFER (LCD < FCD)      * 
*                                                                     * 
** INPUT:  PARAMETER 1 - POINTER TO BUFFER (MAY BE NIL)               * 
*                                                                     * 
** OUTPUT: PARAMETER 1 - POINTER TO NEXT BUFFER IN CHAIN              * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PTEBREL _(VAR H0BUF : B0BUFPTR)? ;
  
BEGIN 
IF H0BUF " NIL
THEN                                        _BUFFER POINTER PASSED     ?
  IF H0BUF'.BFLCD < H0BUF'.BFFCD
  THEN                                      _BUFFER IS EMPTY           ?
    PBREL1BF (H0BUF, BEDBSIZE);             _RELEASE IT                ?
END;
  
_$I-,G-,R-
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*                       P T A D D C H R                               * 
*                                                                     * 
*          ADD A GIVEN CHARACTER AS LAST CHARACTER OF CHAIN,          * 
*          PROVIDING THE CHARACTER IS NOT ALREADY THERE. THIS         * 
*          CAN BE USED TO ADD UNIT-SEPARATOR OR PACER-PROMPT          * 
*                                                                     * 
** INPUT:  PARAMETER 1 - CHARACTER TO BE ADDED, THE CHARACTER IS      * 
*                        NOT ADDED IF IT IS ALREADY THERE             * 
*                                                                     * 
*          PARAMETER 2 - BUFFER (CHAIN) POINTER (MAY BE NIL)          * 
*                                                                     * 
** OUTPUT: PARAMETER 2 - BUFFER (CHAIN) POINTER (WILL NOT BE NIL)     * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PTADDCHR _(H0CHAR : CHAR; VAR H0BUF : B0BUFPTR)? ;
  
VAR 
  H0LBP     : B0BUFPTR;                     _POINTER LAST BUFFER IN CHN?
  H0ECP     : 'B0BUFPTR;                    _POINTER TO END CHAIN WORD ?
  H0LCD     : INTEGER;                      _LCD OF LAST BUFFFER IN CHN?
  H0LCHR    : CHAR;                         _LAST CHARACTER IN CHAIN   ?
  
BEGIN 
ADDR (H0BUF, H0ECP);                        _POINTER TO END CHAIN WORD ?
IF H0BUF = NIL
THEN                                        _NO BUFFER PASSED,         ?
  GOTO 10;                                  _GO GET ONE                ?
REPEAT
  H0LBP := H0ECP';                          _LOCATE LAST BUFFER IN CHN ?
  ADDR (H0LBP'.BCCHAINS [DBUFLEN], H0ECP);
UNTIL H0ECP' = NIL; 
WITH H0LBP' DO                              _INDEX TO LAST BUFFER      ?
  BEGIN 
  H0LCD  := BFLCD;                          _GET LCD AND               ?
  H0LCHR := BFDATAC [H0LCD];                _LAST CHAR FROM BUFFER     ?
  END;
IF H0CHAR " H0LCHR
THEN                                        _CHARACTER IS NOT THERE    ?
  BEGIN                                     _GO ADD IT                 ?
  IF H0LCD = J1LSTCHAR
  THEN                                      _LAST BUFFER IS FULL       ?
    BEGIN 
10: 
    H0LBP  := PBGET1BF (BEDBSIZE);          _GET A NEW BUFFER          ?
    H0ECP' := H0LBP;                        _ADD TO END OF CHAIN       ?
    H0LCD  := J1FRSTCHAR - 1;               _GET LCD FOR NEW BUFFER    ?
    END;
  H0LCD := H0LCD + 1;                       _BUMP LCD                  ?
  WITH H0LBP' DO
    BEGIN 
    BFLCD           := H0LCD;               _INSERT UPDATED LCD        ?
    BFDATAC [H0LCD] := H0CHAR;              _STORE CHARACTER           ?
    END;
  END;
END; _PROCEDURE PTADDCHR? 
  
  
