*COMDECK COMCBUB
 BUB      CTEXT  COMCBUB - BURST/BUILD CHARACTERS WITH BLANK SQUEEZE. 
 BUB      SPACE  4,10 
          IF     -DEF,QUAL$,1 
          QUAL   COMCBUB
          BASE   D
 BUB      SPACE  4,10 
***       BUB - BURST/BUILD CHARACTERS WITH BLANK SQUEEZE.
*         P CLARE  77/01/20 
 BUB      SPACE  4,10 
***       BUB - BURST/BUILD CHARACTERS WITH BLANK SQUEEZE.
* 
* 
*         THIS ROUTINE, VIA A LEFT-TO-RIGHT SCAN, BURSTS CONSECUTIVE
*         CHARACTERS FROM A PACKED (10 CHARACTER PER WORD) SOURCE 
*         LINE, AND BUILDS THEM INTO A SINGLE *GROUP* OF CHARACTERS.
*         IN ADDITION, *COMCBUB* IGNORES BLANKS.  NOTE THAT THE *GROUP* 
*         THAT RESULTS FROM A SINGLE *BUB* CALL MAY BE MORE 
*         THAN 1 CM WORD LONG, OR EVEN POSSIBLY OF ZERO LENGTH. 
* 
*         *COMCBUB* IS PRIMARILY INTENDED TO BE USED WITH *COMATOK* 
*         AND *COMCTOK*, THE GENERAL PURPOSE ENTOKENING DISCIPLINE
*         (MORE LIKE SCHEME).  *COMCTOK* CALLS *BUB* TO PERFORM 
*         EACH *TOGEL* /GROUP,...,SQZ/. 
* 
*         THE FORMAT OF THE RESULTING *GROUP* IS DEFINED AT 
*         ASSEMBLY-TIME (DESCRIBED BELOW UNDER *ASSEMBLY-TIME OPTIONS*).
* 
*         CHARACTERS IN THE INPUT SOURCE LINE ARE EXTRACTED FROM
*         LEFT-TO-RIGHT AND BUILT INTO THE RESULTANT *GROUP* BASED
*         ON A CHARACTER SHIFT MASK (IN (X1) ON ENTRY) THAT SPECIFIES 
*         WHICH CHARACTERS CAN POTENTIALLY OCCUR IN THIS *GROUP*, I.E.
*         THE CHARACTER SHIFT MASK DEFINES WHICH CHARACTERS ARE 
*         **ALLOWED** WITHIN THIS *GROUP*.
* 
*         (X1) HAS A BIT POSITION FOR EACH CHARACTER IN THE HOST
*         CHARACTER SET (CURRENTLY, ONLY DISPLAY CODE IS SUPPORTED. 
*         *ASCII* SUPPORT HAS BEEN DESIGNED, BUT NOT IMPLEMENTED...YET).
*         *BUB* WILL BURST/BUILD ALL THE CHARACTERS THAT HAVE THEIR 
*         RESPECTIVE BIT IN (X1) *ON* INTO A SINGLE *GROUP*.
* 
*         IT WORKS LIKE THIS...  AS EACH CHARACTER IS BURST FROM THE
*         INPUT SOURCE LINE, ITS BINARY VALUE IS USED AS A LEFT-SHIFT 
*         FOR (X1).  IF THE SHIFTED (X1) IS .MI., THEN THIS CHARACTER 
*         IS BUILT INTO THE *GROUP* DEFINED BY (X1).  AND ALTERNATELY,
*         IF SHIFTED (X1) IS .PL., THEN THIS CHARACTER IS NOT IN THE
*         *GROUP* SO *BUB* RETURNS TO ITS CALLER. 
* 
*         THE PROBLEM WITH MAPPING THE 64D DISPLAY CODE CHARACTERS, 
*         ONE PER BIT, INTO A 60D BIT WORD IS THAT WE HAVE 4 CHARACTERS 
*         TOO MANY.  BECAUSE THE LEFT-SHIFT HARDWARE SHIFTS MODULO 60D
*         (I.E. LX1 60D = LX1 00, LX1 61D = LX1 01, ETC), THIS MEANS
*         THAT 4 PAIRS OF CHARACTERS MAP INTO EACH OTHERS BITS. 
* 
*         I.E. --               : = @     00B = 60D OR 74B
*                               A = \     01B = 61D OR 75B
*                               B = ^     02B = 62D OR 76B
*                               C = ;     03B = 63D OR 77B
* 
*         CONCEPTUALLY, THERE IS NOTHING WRONG WITH THIS AS LONG AS 
*         THE PROGRAMMER DOESNT CARE WHETHER THESE CHARACTERS ARE 
*         EQUIVALENT.  UNFORTUNATELY, FEW PEOPLE ARE WILLING TO 
*         PUT UP WITH AN EQUALITY LIKE -A = @-. 
* 
*         *BUB* CIRCUMVENTS THIS PROBLEM BY USING WHAT IS CALLED A
*         ROTATED CHARACTER SET, *RCS*, REPRESENTATION FOR DISPLAY
*         CODE.  THE TRICK IN THIS *RCS* TECHNIQUE IS TO TREAT THE
*         CHARACTER SET AS CIRCULAR, AND THEN TO ROTATE THE ENTIRE
*         CHARACTER SET SO AS TO FIND 4 PAIRS OF CONSECUTIVE CHARACTERS 
*         THAT THE PROGRAMMER DOES NOT MIND BEING EQUIVALENT (FOR THE 
*         PURPOSE OF *GROUP*ING). 
* 
*         FOR EXAMPLE, CONSIDER DISPLAY CODE -- 
* 
*                        ;    : 
*                       77   00 
*                \  76           01  A
*                    .           .
*                N  16           13  K
*                       15   14 
*                        M    L 
* 
*         IT HAPPENS THAT  : = 00B, BUT THIS IS NOT **IMPERATIVE** AND
*         IS IN FACT QUITE INCONVENIENT DUE TO THE PROBLEM DESCRIBED
*         ABOVE.  WE COULD (AND DO) CHOOSE A DIFFERENT CHARACTER TO HAVE
*         THE VALUES 00B.  THE ONLY IMPORTANT THING IS THAT WE DO NOT 
*         CHANGE THE ORDER OF CHARACTERS ON THE WHEEL.
* 
*         IF WE CHOOSE A CHARACTER IN THE MIDDLE OF THE ALPHABETICS 
*         (-M-, FOR EXAMPLE), THEN ALL OUR TROUBLES VANISH INTO THIN
*         AIR --
* 
*                        L    M 
*                       77   00 
*                K  76           01  N
*                    .           .
*                    .           .
*                0  16           13  X
*                       15   14 
*                        Z    Y 
* 
*         NOW THE OVERLAPPING CHARACTER PAIRS FALL IN THE MIDDLE OF THE 
*         ALPHABETICS: I+M, J+N, K+O, L+P TO BE EXACT.
* 
*         THE CHARACTER THAT IS CHOSEN TO HAVE THE VALUE 00B IS CALLED
*         THE BIAS CHARACTER, *BICH*, AND IS DEFINED VIA AN ASSEMBLY
*         TIME OPTION (DEFAULT *BICH* = 1RM). 
* 
*         USING THE DEFAULT *BICH*, CHARACTERS ARE MAPPED INTO (X1) 
*         AS FOLLOWS -- 
* 
*         BIT   59 58 57 56 55 54 53 ... 47 46 45 44 43 ... 37 36 35 34 
*         CHAR  IM JN KO LP  Q  R  S      Y  Z  0  1  2      8  9  +  - 
* 
*         BIT   33 32 ... 09 08 07 06 05 04 03 02 01 00 
*         CHAR   *  /      ;  :  A  B  C  D  E  F  G  H 
* 
*         THE FORMULA FOR CONVERTING DISPLAY CODE (DPC) INTO THE ABOVE
*         *RCS* IS -- 
* 
*                RCS = DPC+10000B-BICH         (DEFAULT *BICH* = 1RM) 
* 
*         THE LOWER 6 BITS OF *RCS* SPECIFY THE LEFT SHIFT COUNT, *LS*, 
*         FOR (X1).  IT CAN BE SEEN THAT THE CHARACTERS 'M' (LS=0) AND
*         'I' (LS=60D) MAP INTO THE SAME BIT IN (X1).  THIS IS ALSO TRUE
*         FOR THE CHARACTER PAIRS 'N' (LS=1) AND 'J' (LS=61D),
*         'O' (LS=2) AND 'K' (LS=62D), AND 'P' (LS=3) AND 'L' (LS=63D). 
* 
* 
*         IN THE SECTIONS THAT FOLLOW, *ASSEMBLY-TIME DEPENDENCIES* 
*         ARE DEFINED TO BE THE INTERFACES THAT THE *COMCBUB* INSTALLER 
*         MUST PROVIDE.  *ASSEMBLY-TIME OPTIONS* ARE THOSE INTERFACES 
*         WHICH ARE OPTIONAL, I.E. INTERFACES WHICH HAVE DEFAULT
*         CONDITIONS. 
* 
*         ASSEMBLY-TIME DEPENDENCIES -- 
* 
**********************************************************************
* 
*         THE INSTALLER MUST PROVIDE THE FOLLOWING COMDECKS --
*                COMADEF   COMAREG
* 
************************************************************************
* 
*         ASSEMBLY-TIME OPTIONS --
* 
************************************************************************
* 
*         BICH - BIAS CHARACTER.            (DEFAULT =1RM)
* 
*         *BICH* SPECIFIES THE CHARACTER THAT IS TO OCCUPY BIT 59 
*         OF (X1), I.E. THE CHARACTER THAT HAS AN *RCS* VALUE OF 00B. 
* 
************************************************************************
* 
*         *BB.XXXL* AND *BB.XXXP* ARE SYMBOLS THAT DEFINE A *COMADEF* 
*         STRUCTURE THAT DESCRIBES THE FORM OF THE *GROUP*S THAT *BUB*
*         WILL GENERATE.  FOR EXAMPLE, SUPPOSE THE CALLING PROGRAM IS 
*         USING *BUB* TO GENERATE TOKENS FOR INPUT SOURCE LINE
*         CHARACTERS.  THE *BB.* STRUCTURE WOULD DESCRIBE/DEFINE WHAT 
*         HOST TOKENS LOOK LIKE.  SEE *COMADEF* AND *BB.* DEFINITIONS 
*         BELOW.
* 
************************************************************************
 DEFS     SPACE  4,10 
**        MISCELLANEOUS SYMBOL DEFINITIONS. 
  
  
          IF     -DEF,BICH,1
 BICH     =      1RM
  
          IF     -DEF,CHAR,1
 CHAR     =      6           NR OF BITS IN CHARACTER
 BB.      SPACE  4,10 
**        BB. - *BUB* GROUP STRUCTURE.
* 
*         *BB.* SYMBOLS ARE OF THE FORM --
* 
*                BB.XXXL  AND  BB.XXXP
* 
*         WHERE FIELDS *XXX* ARE -- 
* 
*         TOC  = TOKEN CHARACTERS.  *TOC* DESCRIBE/DEFINES THE
*                LOCATION WITHIN PACKING REGISTER (X6) THAT *BUB* 
*                IS TO PLACE *GROUP*ED CHARACTERS.  *BB.TOCL* IS
*                THE LENGTH (IN BITS) OF THIS FIELD, AND *BB.TOCP*
*                IS THE LOWEST (I.E. RIGHT-MOST) BIT POSITION IN THIS 
*                FIELD.  DEFAULTS --  BB.TOCL = 60D, AND BB.TOCP = 00B. 
* 
*         TOT  = TOKEN TYPE.  EACH *GROUP* CAN BE ASSIGNED A TOKEN OR 
*                *GROUP* TYPE AT EXECUTION TIME.  SEE (X6) ON ENTRY.
*                THIS FIELD DESCRIBE/DEFINES WHERE *BUB* IS TO PLACE
*                THE TOKEN TYPE IN PACKING REGISTER (X6).  THIS FIELD 
*                IS NORMALLY THE COMPLEMENT TO *TOC*.  THAT IS, 
*                BB.TOCL+BB.TOTL = 60D, I.E. A FULL WORD. 
*                DEFAULTS --  BB.TOTL = 0, AND BB.TOTP = 0. 
  
  
 .BB      IF     -DEF,BB.TOCP 
  
          DESCRIBE BB.
 TOC      DEFINE 60 
 TOT      DEFINE 0
 .BB      ENDIF 
 BUB      SPACE  4,10 
**        BUB - BURST/BUILD WITH BLANK SQUEEZE. 
* 
* 
*         THE DISCUSSIONS OF *BUB*S ENTRY AND EXIT CONDITIONS ARE EACH
*         DIVIDED INTO 3 SECTIONS: MISCELLANEOUS, SOURCE INPUT, AND 
*         *GROUP* OUTPUT.  THERE EXIST SUBTLETIES IN THESE ENTRY/EXIT 
*         CONDITIONS THAT, ALTHOUGH HOPEFULLY NOT INCONSISTENT, DO
*         UNFORTUNATELY MAKE AN UNDERSTANDING OF HOW TO USE THIS
*         CHARACTER ACCESS METHOD NON-TRIVIAL.
* 
*         THIS DIFFICULTY ARISES SOLEY DUE TO EFFICIENCY CONSIDERATIONS.
*         *BUB* IS DESIGNED TO BE **VERY** FAST.  THIS UNFORTUNATELY
*         IMPLIES THAT SOME OF THE REGISTER CONVENTIONS ARE ORIENTED
*         MORE TOWARD THE INSTACK LOOP THAN TO A HUMAN. 
* 
*         FOR EXAMPLE, (X4), THE REGISTER THAT IS USED WITHIN *BUB* 
*         TO HOLD/MANIPULATE INDIVIDUAL CHARACTERS MAY, UPON ENTRY, 
*         ALREADY CONTAIN A CHARACTER TO PROCESS.  THIS IS BECAUSE
*         *BUB* IS DESIGNED TO BE CALLED REPETITIVELY BY SOME EXECUTIVE 
*         THAT IS PERFORMING A TRANSFORMATION UPON SOME CHARACTER 
*         STRING (E.G. GENERATING TOKENS).
* 
*         IN THIS CIRCUMSTANCE, IT IS NOT DIFFICULT TO CONCEIVE OF SOME 
*         OF *BUB*S EXIT CONDITIONS BEING USED AS *BUB*S ENTRY
*         CONDITIONS ON A SUBSEQUENT CALL.  THEREFORE, BECAUSE (X4) 
*         USUALLY CONTAINS A CHARACTER ON EXIT FROM *BUB*, IT IS LIKELY 
*         THAT *BUB* WILL BE CALLED AGAIN WITH (X4) AS AN ENTRY 
*         CONDITION.  COMO SAVVY... 
* 
*         BY WAY OF INTRODUCTION, WE CAN MENTION THAT (A5,X5) CONTAIN 
*         THE SOURCE INPUT CHARACTERS IN PACKED (10 CHAR PER WORD)
*         FORMAT AND (A6,X6) CONTAIN THE *GROUP* OUTPUT CHARACTERS
*         IN A FORMAT THAT IS DETERMINED BY THE *BB.XXXL* AND *BB.XXXP* 
*         ASSEMBLY-TIME OPTIONS.
* 
* 
*         ENTRY  MISCELLANEOUS -- 
* 
*                (B1) = 1 
*                (X0) = CHARACTER EXTRACT MASK (I.E. MX0 -CHAR).
*                (X1) = CHARACTER SHIFT MASK THAT DEFINES WHICH 
*                       CHARACTERS CAN OCCUR IN THIS *GROUP*.  THAT IS, 
*                       *BUB* WILL STOP IF IT ENCOUNTERS A SOURCE INPUT 
*                       CHARACTER **NOT** SPECIFIED IN (X1).
* 
*                       NOTE ALSO THAT (X1) **MUST** BE BIASED BY 
*                       *BICH*  (SEE *ASSEMBLY-TIME OPTIONS*).  THIS
*                       MEANS THAT THE *BICH* BIAS CHARACTER OCCUPIES 
*                       BIT 1S59 IN (X1).  SEE *COMCBUB* PREAMBLE.
* 
*                SOURCE INPUT --
* 
*                (X4) = 1ST SOURCE INPUT CHAR TO CHECK TO SEE IF IN THE 
*                       *GROUP* DEFINED IN (X1), -R- FORMAT.  ELSE .MI. 
*                       IF EMPTY, I.E. NEED TO EXTRACT A CHAR FROM (X5) 
*                       FIRST.
* 
*                (A5,X5) = A+C OF SOURCE WORD TO BEGIN BURST/BUILDING 
*                       FROM.  (X5) CONTAINS THE SOURCE INPUT CHARACTERS
*                       IN PACKED (I.E. 10 CHARS PER WORD) FORMAT WITH
*                       THE 1ST CHAR TO EXTRACT IN THE HIGH ORDER CHAR
*                       POSITION (BITS 54 THRU 59). 
* 
*                       NOTE THAT IF (X4) .PL., THEN (X5) IS NOT TOUCHED
*                       UNTIL (X4) HAS BEEN PROCESSED.
* 
*                       NOTE ALSO THAT IF (X5) IS EXHAUSTED DURING THIS 
*                       *BUB* CALL, THEN (A5) IS INCREMENTED AND *BUB*
*                       CONTINUES BURST/BUILDING WITH FRESHLY LOADED
*                       (X5). 
* 
*                (B6) = BIT COUNTER FOR (X5).  (B6) CONTAINS THE NR 
*                       OF BITS IN (X5) REMAINING TO BU/BU.  IF (B6) IS 
*                       OR BECOMES .LE. 0, THEN (X5) IS EMPTY (BY 
*                       DEFINITION) AND THE NEXT SOURCE WORD IS LOADED
*                       INTO (A5,X5). 
* 
*                       IF (B6) IS 60D, THEN (X5) IS FULL.
* 
*                (B7) = SOURCE LINE REMAINING BIT COUNTER.
*                       (B7) CONTAINS THE NR OF **BITS** REMAINING IN 
*                       THE ENTIRE SOURCE LINE.  A BIT COUNT IS USED
*                       INSTEAD OF A WORD COUNT SO THAT *BUB* CAN BU/BU 
*                       SOURCE LINES THAT DO NOT END ON A WORD BOUNDARY 
*                       (A MOST COMMON OCCURENCE IN CDC-LAND).
* 
*                       NOTE THAT (B7) ARE **NOT** CHECKED UPON ENTRY,
*                       AND IN FACT ARE ONLY CHECKED WHEN (B6) INDICATE 
*                       THAT (X5) IS EMPTY.  ONE CAN THINK OF THIS
*                       (B6)/(B7) RELATIONSHIP AS (B6) HAVING PRECEDENCE
*                       OVER (B7).
* 
*                       ALTHOUGH THIS IS PERHAPS NOT THE MOST HUMAN 
*                       REGISTER RELATIONSHIP, IT IS THE MOST SPEED 
*                       EFFICIENT ONE FOR *BUB*S INSTACK LOOP.
* 
*                *GROUP* OUTPUT --
* 
*                (X6) = PACKING REGISTER FOR *GROUP* OUTPUT WORDS.
*                       *BUB* WILL CONTINUE TO PACK SOURCE INPUT
*                       CHARACTERS TO (X6) AS LONG AS HE KEEPS
*                       ENCOUNTERING CHARACTERS THAT HAVE BEEN SPECIFIED
*                       VIA (X1) .AND. AS LONG AS (X6) IS NOT FULL. 
* 
*                       UPON ENTRY, (B3) SPECIFIES THE LEFT-SHIFT COUNT 
*                       FOR THE NEXT CHARACTER IN (X4) THAT *BUB* IS
*                       TO PACK INTO (X6).  REMEMBER THAT A CHARACTER 
*                       IN (X4) IS IN -R- FMT.  I.E. -- 
* 
*                           BX4  -X0*X5      (X4) = CHAR, IN -R- FMT
*                           LX3  X4,B3
*                           BX6  X6+X3       MERGE (X4) INTO (X6) 
* 
*                       WILL PACK A CHARACTER TO (X6).
* 
*                       CHARACTERS ARE PACKED INTO (X6) FROM LEFT-TO- 
*                       RIGHT, BEGINNING AT LEFT-MOST CHARACTER POSITION
*                       IN *BB.TOCP/BB.TOCL* FIELD.  (X6) IS **FULL**,
*                       BY DEFINITION, WHEN THIS *BB.TOCP/BB.TOCL* FIELD
*                       IS **FULL** (I.E. WHEN (B3) .LE. *BB.TOCP*).
* 
*                       WHEN THIS OCCURS, (X6) WILL BE STORED BY
*                       INCREMENTING (A6).  THE *BB.TOCP/BB.TOCL* FIELD 
*                       IN (X6) IS THEN CLEARED AND BURST/BUILDING
*                       CONTINUES.  NOTE THAT *BUB* **NEVER** TOUCHES 
*                       ANYTHING BUT *BB.TOCP/BB.TOCL* FIELD IN (X6). 
* 
*                       IN THIS WAY THEN, (X6) UPON ENTRY, MAY CONTAIN
*                       A TOKEN OR GROUP TYPE IN *BB.TOTP/BB.TOTL*
*                       FIELD AND THIS TOKEN TYPE WILL BE PROPAGATED
*                       INTO EVERY TOKEN *BUB* BUILDS INTO (X6).
* 
*                                   ** LIMITATION **
* 
*                       (X6) MUST NOT BE FULL UPON ENTRY (I.E. (B3) .LT.
*                       *BB.TOCP*), AS *BUB* PACKS A CHARACTER TO (X6)
*                       **BEFORE** CHECKING FOR *(X6) FULL*.
* 
*                                       * * * 
* 
*                       NOTE THAT IF (X6) IS LEFT PARTIALLY FILLED WHEN 
*                       *BUB* SENSES AN EXITING CONDITION, THEN (X6) IS 
*                       STORED OUT BEFORE EXITING.
* 
*                (A6)+1 = ADDR TO STORE THE NEXT *GROUP* OUTPUT WORD
*                       (OR TOKEN) GENERATED BY THIS *BUB* CALL,
*                       I.E. (X6) IS STORED OUT BY INCREMENTING (A6). 
* 
*                (B3) = LEFT-SHIFT COUNT FOR 1ST CHARACTER *BUB* BUILDS 
*                       INTO (X6).  I.E. IF (X6) IS TO BE CONSIDERED
*                       EMPTY UPON ENTRY, THEN -- 
* 
*                           (B3) = BB.TOCP+BB.TOCL-CHAR 
* 
*                       WHERE *BB.TOCP* = RIGHT-MOST BIT POSITION THAT
*                                         *BUB* CAN BUILD CHARACTERS
*                                         INTO (X6).
*                             *BB.TOCL* = LEN (IN BITS) OF FIELD WITHIN 
*                                         (X6) TO BUILD CHARACTERS. 
*                             *CHAR*    = LEN (IN BITS) OF A SINGLE 
*                                         CHARACTER.  CURRENTLY ONLY
*                                         6 BIT OR LESS SUPPORTED.
* 
*         EXIT   (B1) = 1 
*                (X0) = AS ON ENTRY.
*                (X1) = AS ON ENTRY.
*                (X4) = CHAR THAT TERMINATED THIS *GROUP*, IN -R- FMT.
*                       I.E. 1ST CHAR ENCOUNTERED THAT WAS NOT CHARACTER
*                       RANGE SPECIFIED VIA (X1). 
*                (A5,X5) = A+C OF CURRENT SOURCE WORD.  (X5) IS SHIFTED 
*                          SO THAT NEXT CHAR TO EXTRACT IS IN LEFT-MOST 
*                          CHARACTER POSITION (I.E. BITS 59 THRU 54 FOR 
*                          DISPLAY CODE, 6 BIT).  THEREFORE, (X4) IS
*                          IN BITS 5 THRU 0.
*                (B6) = NR OF BITS REMAINING TO EXTRACT FROM (X5).
*                       I.E. DOES **NOT** INCLUDE CHAR IN (X4). 
*                (B7) = .GE. 0 IF NR OF BITS REMAINING TO BURST/BUILD 
*                       IN THIS SOURCE LINE.  ELSE .LT. 0 IF DONE.
*                (A6) = ADDR OF MOST RECENT TOKEN GENERATED.
*                (X6) = PACKING REGISTER.  (X6) CAN ONLY BE DETERMINED
*                       BY QUERYING (B3). 
*                (B3) = LEFT-SHIFT COUNT FOR NEXT CHARACTER THAT WOULD
*                       HAVE (BUT WASNT) GENERATED TO (X6). 
* 
*                       THEREFORE, IF (B3) = BB.TOCP+BB.TOCL-CHAR 
*                       THEN *BB.TOCP/BB.TOCL* FIELD IN (X6) IS EMPTY.
*                       ELSE IF (B3) .GE. BB.TOCP, THEN (X6) CONTAINS 
*                       MOST RECENT TOKEN BUILT AND STORED AT (A6). 
* 
*         USES   X - 2,3,4,5,6,7
*                A - 2,3,5,6
*                B - 2,3,4,5,6,7
* 
*         CALLS  NONE 
  
  
 BUB      SUBR               ** ENTRY/EXIT ** 
  
*         INITIALIZATION. 
  
          SA3    60D         (A3) = NR OF BITS IN A WORD (CONSTANT) 
          SA2    =10H 
          SB4    BB.TOCP     (B4) = LOWEST BIT POSITION THAT WE CAN 
*                                   SHIFT CHARS INTO (X6) 
          SB5    1R +10000B-BICH
          SB7    A3-B7       (B7) = -(BIT COUNT - 60D)
          MI     X4,BUB3     IF (X4) DOES NOT CONTAIN A USEABLE CHAR
          SB6    B6+CHAR
          EQ     BUB4 
  
*         BURST/BUILD LOOP  ** INSTACK ** 
  
 BUB2     SB7    B7+A3
          SA5    A5+B1
          GE     B7,B0,BUB5  IF NO MORE SOURCE WORDS TO BU/BU 
          IX7    X5-X2
          SB6    A3 
          ZR     X7,BUB2     IF NEXT SOURCE WORD IS ALL BLANK, IGNORE...
  
 BUB3     LX5    CHAR 
          LE     B6,B0,BUB2  IF SOURCE WORD (X5) IS EXHAUSTED 
          BX4    -X0*X5 
  
 BUB4     SB6    B6-CHAR
          SB2    X4+10000B-BICH 
          LX7    X1,B2
          EQ     B2,B5,BUB3  IF NEXT CHAR TO PACK IS A BLANK (55B)
          LX3    X4,B3
          PL     X7,BUB6     IF NEXT CHAR TO PACK NOT IN THIS GROUP 
          SB3    B3-CHAR
          BX6    X6+X3
          GE     B3,B4,BUB3  IF PACKING REGISTER (X6) NOT FULL
  
*         HERE IF PACKING REGISTER (X6) IS FULL.
  
          MX3    -BB.TOTL 
          SA6    A6+B1
          SB3    BB.TOCP+BB.TOCL-CHAR 
          LX3    BB.TOTP-0
          BX6    -X3*X6      CLEAR *TOC*
          EQ     BUB3        BACK INTO THE FIRE...
  
*         HERE AT LAST/FINAL WORD.
* 
*           1. IF HAVE NOT PROCESSED LAST/FINAL WORD YET, THEN WE NEED
*              TO GO BACK AND BURST/BUILD IT. 
* 
*           2. IF HAVE ALREADY BU/BU THE LAST/FINAL WORD, THEN DONE...
  
 BUB5     SB6    A3-B7
          GT     B6,B0,BUB3  IF NEED TO PROCESS FINAL SOURCE WORD 
  
*         FINAL PROCESSING...(X6) MIGHT NEED TO BE STORED OUT.
  
 BUB6     SB4    B3-BB.TOCP-BB.TOCL+CHAR
          SB7    A3-B7       RESTORE (B7) TO A CIVIL FORM 
          ZR     B4,EXIT.    IF (X6) IS EMPTY, DONE...
          SA6    A6+1 
          EQ     EXIT.
 BUB      SPACE  4,10 
          BASE   *
 QUAL$    IF     -DEF,QUAL$ 
          QUAL   *
 BUB      =      /COMCBUB/BUB 
 QUAL$    ENDIF 
 COMCBUB  ENDX
