*COMDECK PBLOAD 
_$J+  PAGE EJECT? 
_*****************************
*                            *
*          PBLOAD            *
*   LOAD A CANNED MSG        *
*                            *
*****************************?
_$R-,G-,I+    NON INTERRUPTABLE 
              NON RECURSIVE     ? 
_***********************************************************************
*                                                                      *
**OVERVIEW- PBLOAD LOADS A CANNED MESSAGE INTO A BUFFER.  THE          *
*           MESSAGE IS LOADED A CHARACTER AT A TIME UNTIL A            *
*           RIGHT BRACKET (1) IS REACHED OR UNTIL THE STOP             *
*           INDEX IS REACHED.  PBLOAD SETS THE LCD.                    *
*                                                                      *
**INPUT- MESSAGE TO LOAD, BUFFER TO CONTAIN MESSAGE AND START/         *
*        STOP INDICES FOR LOADING THE MESSAGE INTO THE BUFFER.         *
**OUTPUT- THE CANNED MESSAGE IS LOADED.                                *
*                                                                      *
**EXTERNAL SUBROUTINES- NONE                                           *
*                                                                      *
**NOTE- TYPE CHECKING IS DEFEATED FOR PBLOAD TO ALLOW CANNED           *
*       MESSAGES OF VARYING LENGTHS TO BE PASSED.                      *
*                                                                      *
***********************************************************************?
PROCEDURE PBLOAD(BFR : B0BUFPTR; VAR MSG : J0ML23;
                 START,STOP : INTEGER); 
VAR I : INTEGER;
BEGIN 
  IF NIL " BFR THEN                         _CHECK FOR NIL BUFFER      ?
  WITH BFR' DO
  BEGIN 
    I := 0; 
    WHILE (START @ STOP) & (#]# " MSG[I]) DO_CHECK FOR END-OF-LOAD     ?
    BEGIN 
      BFDATAC[START] := MSG[I];             _LOAD CHARACTER            ?
      I := I+1;                             _BUMP MSG INDEX            ?
      START := START+1;                     _BUMP BFR INDEX            ?
    END;
    BFLCD := START-1;                       _SET LCD                   ?
  END; _WITH? 
END; _PBLOAD? 
_$J+? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*                  PNCLOAD                                            * 
*                                                                     * 
*        LOAD A CANNED MESSAGE                                        * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_$R-,G-,I-? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
** OVERVIEW -  PNCLOAD LOADS A CANNED MESSAGE INTO THE BUFFER POINTED * 
*              TO BY B1LBF STARTING AT WORD INDEX B1IW                * 
*                                                                     * 
** INPUTS   -  ADDRESS OF CANNED MESSAGE                              * 
*              LENGTH OF CANNED MESSAGE                               * 
*                                                                     * 
** OUTPUTS  -  CANNED MESSAGE LOADED INTO BUFFER                      * 
*              WORD INDEX UPDATED PAST MESSAGE                        * 
*                                                                     * 
** SPECIAL NOTE -                                                     * 
*              PNCLOAD DEFEATS TYPE CHECKING SO THAT MESSAGES OF      * 
*              DIFFERENT LENGTHS MAY BE LOADED                        * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PNCLOAD (VAR MSG : B0CANNED;LENGTH : INTEGER);
  
VAR 
      I : INTEGER;                          _LOOP COUNTER              ?
  
BEGIN 
FOR I := 1 TO LENGTH DO                     _FOR EACH WORD OF CANNED MG?
  BEGIN 
  B1LBF'.BIINT[B1IW] := MSG[I];             _STORE WORD INTO BUFFER    ?
  B1IW               := B1IW + 1;           _BUMP WORD INDEX           ?
  END;
END; _PROCEDURE PNCLOAD?
