COMCMTP 
COMMON
          CTEXT  COMCMTP - MANAGED TABLE PROCESSORS.
          SPACE  4
          IF     -DEF,FTAB,1
 TABLES   HERE
          SPACE  4
          IF     -DEF,QUAL$,1 
          QUAL   COMCMTP
          BASE   D
*         COMMENT  COPYRIGHT CONTROL DATA SYSTEMS INC.  1992. 
          SPACE  4
***       COMCMTP - MANAGED TABLE PROCESSORS. 
*         G. R. MANSFIELD.  70/12/20. 
          SPACE  4
***              COMCMTP CONTAINS ROUTINES FOR PROCESSING MANAGED 
*         TABLES.  MACROS FOR CALLS AND GENERATION ARE CONTAINED
*         IN COMCMTM. 
* 
* 
*                THE MANAGED TABLE PROCESSORS ALLOW THE PARTIONING OF 
*         CENTRAL MEMORY INTO VARIABLE REGIONS (CALLED TABLES). 
*         THESE TABLES ARE REFERENCED BY POINTERS WHICH INDICATE
*         THE FIRST ADDRESS OF THE TABLE AND THE TABLE LENGTH.
*         MEMORY IS ALLOCATED TO EACH TABLE AS IT IS REQUIRED AND 
*         THE USER MAY DELETE SPACE FROM THE TABLES.  THE USER IS 
*         EXPECTED TO PROVIDE CERTAIN CONSTANTS FOR USE BY THE
*         TABLE PROCESSORS.  EACH TABLE IS ALLOWED AT LEAST 1 WORD
*         OF EXPANSION SPACE TO ALLOW A DUMMY WORD BETWEEN EACH 
*         TABLE.  THIS ALLOWS EFFICIENT SEARCH METHODS TO BE USED.
* 
* 
* 
* 
*         *MEML* = LOWEST ADDRESS OF MANAGED MEMORY.
*         *TOV*  = ADDRESS OF TABLE OVERFLOW PROCESSOR. 
* 
*         DATA PROVIDED BY *COMCMTM*. 
* 
*         *NTAB* = NUMBER OF MANAGED TABLES.
*         *FTAB* = START OF TABLE ADDRESSES.
*         *LTAB* = START OF TABLE LENGTHS.
*         *F.TNAM* = ADDRESS POINTER FOR TABLE *TNAM*.
*         *L.TNAM* = LENGTH POINTER FOR TABLE *TNAM*. 
*         *C.TNAM* = WORDS/ENTRY FOR SEARCH ROUTINES. 
* 
*         DATA DYNAMICALLY CHANGABLE. 
* 
*         (TN) = NUMBER OF MANAGED TABLES.  SET TO *NTAB* BY
*                *COMCMTM*.  VALUE MUST BE .LE. *NTAB* DURING USE.
*         (TO) = TABLE OVERFLOW PROCESSOR.  SET TO *TOV* BY 
*                *COMCMTM*. 
*         (LM) = LOW MEMORY LIMIT.  VALUE SET TO *MEML* BY *COMCMTM*. 
*                IF THIS VALUE IS RAISED, *MTU* SHOULD BE CALLED
*                TO ALLOW ROOM FOR CHANGE.
*         (F.TEND) = HIGH MEMORY LIMIT.  VALUE MUST BE INITIALIZED
*                BY USER.  IF THIS VALUE IS LOWERED, *MTD* SHOULD 
*                BE CALLED TO ALLOW ROOM FOR CHANGE.
 ADW      SPACE  4
***       ADW - ADD WORD TO TABLE.
* 
*         ENTRY  (A0) = TABLE NUMBER. 
*                (X1) = WORD. 
* 
*         EXIT   (X1) = WORD. 
*                (X6) = WORD. 
*                (A6) = ADDRESS OF WORD.
*                (X2) = FWA TABLE.
*                (X3) = LENGTH OF TABLE.
* 
*         USES   X - 1, 2, 3, 4, 6, 7.
*                B - NONE.
*                A - 1,2,3,4,6,7. 
* 
*         CALLS  ATS. 
  
  
 ADW1     BX6    X1          PLACE ENTRY IN TABLE 
          IX7    X2+X3
          SA6    X7 
          SX3    X3+B1
  
 ADW      PS                 ENTRY/EXIT 
          SA2    FTAB+A0     SET TABLE DIFFERENTIAL 
          SA4    A2+B1
          IX7    X4-X2
          SA3    LTAB+A0     CURRENT LENGTH 
          SX6    X3+B1       ADD NEW ENTRY
          IX7    X6-X7
          SA6    A3          UPDATE LENGTH
          NG     X7,ADW1     IF ROOM FOR ENTRY + 1 WORD 
          BX6    X1          SAVE ENTRY 
          LX7    X3          RESTORE LENGTH 
          SA6    ADWA 
          SA7    A3 
          ALLOC  A0,1        ALLOCATE 1 WORD
          SA1    ADWA        RESTORE ENTRY
          SX3    X3-1        SET ORIGINAL LENGTH
          EQ     ADW1        PROCESS ENTRY
  
 ADWA     CON    0
 AMU      SPACE  4
***       AMU - ACCUMULATE MEMORY USED. 
* 
*         ENTRY  NONE.
* 
*         EXIT   MU = MAX(MU,CURRENT ASSIGNED LENGTH) 
* 
*         USES   X - 1, 2, 3, 6.
*                B - 2. 
*                A - 1, 2, 6. 
* 
*         CALLS  NONE.
  
  
 AMU1     IX6    X6+X2       ACCUMULATE LENGTH
          SB2    B2-B1
          SA2    A2+B1       NEXT TABLE 
          NE     B2,B1,AMU1  LOOP FOR ALL TABLES
          SA1    MU          SET MAX LENGTH 
          IX3    X6-X1
          NG     X3,AMU 
          SA6    A1 
  
 AMU      PS                 ENTRY/EXIT 
          SA1    TN          (B2) = NUMBER OF TABLES
          MX6    0           CLEAR ACCUMULATION 
          SB2    X1 
          SA2    LTAB        FIRST TABLE
          EQ     AMU1 
 ATS      SPACE  4
***       ATS - ALLOCATE TABLE SPACE. 
* 
*         ENTRY  (A0) = TABLE INDEX.
*                (X1) = CHANGE (+ OR -) TO TABLE SIZE.
* 
*         EXIT   (X1) = CHANGE. 
*                (X2) = FWA OF TABLE. 
*                (X3) = NEW LENGTH OF TABLE.
*                (X7) .LT. 0 IF TABLES MOVED. 
* 
*         IF TABLES NOT MOVED - 
*         USES   X - 2, 3, 4, 6, 7. 
*                B - NONE.
*                A - 2, 3, 4, 6.
* 
*         IF TABLES MOVED - 
*         USES   X - 0, 1, 2, 3, 4, 5, 6, 7.
*                B - 2, 3, 4, 5, 6, 7.
*                A - 1, 2, 3, 4, 6, 7.
* 
*         RESTORES X - 0, 1, 5. 
*                  B - 2, 3, 4, 5, 6, 7. (EXCEPT -0)
* 
*         CALLS  AMU, MVE, TOV. 
* 
*         ENTRY CONDITIONS FOR USER ROUTINE *TOV*.
* 
*                (B1) = 1.
*                (B5) = COMPLEMENT OF NUMBER OF WORDS REQUIRED. 
*                (B6) = RETURN ADDRESS TO CONTINUE PROCESSING, I.E.,
*                       EXIT FROM *TOV* VIA  * JP B6 *  INSTRUCTION.
* 
*                THE LOCATION *TOV* MUST CONTAIN EXECUTABLE CODE. 
*                *TOV* IS ENTERED VIA A *JP*, NOT VIA *RJ*. 
* 
*         EXIT CONDITIONS FOR *TOV*.
* 
*                ONLY B1 MUST BE PRESERVED. 
* 
*                A POINTER WORD MUST BE INCREMENTED BY THE NUMBER OF
*                WORDS NEWLY AVAILABLE.  IF *TN* HAS NOT BEEN ALTERED 
*                DURING EXECUTION, THE ADDRESS OF THE POINTER WORD IS 
*                *F.TEND*.
*                IF *TN* HAS CHANGED, THE ADDRESS OF THE POINTER WORD 
*                IS FTAB-1 PLUS THE CONTENTS OF *TN*. 
  
  
 ATS      PS                 ENTRY/EXIT 
 ATS1     SA2    FTAB+A0     CURRENT FWA
          SA3    LTAB+A0     CURRENT LENGTH 
          SA4    A2+B1       NEXT TABLE FWA 
          IX6    X1+X3       NEW LENGTH 
          IX7    X4-X2       ROOM BETWEEN TABLES
          SA6    A3          SET NEW LENGTH 
          IX7    X6-X7
          BX3    X6 
          NG     X7,ATS      RETURN IF ROOM FOR CHANGE + 1 WORD 
          IX7    X6-X1       SET PREVIOUS LENGTH
  
*         INITIALIZE FOR TABLE MOVE.
  
          BX6    X0          SAVE (X0)
          SA7    A3 
          SA6    ATSB 
          BX7    X1          SAVE (X1)
          LX6    X5          SAVE (X5)
          SA7    A6+B1
          SA6    A7+B1
          SX7    B2          SAVE B REGISTERS 
          SX6    B3 
          SA7    A6+B1
          SA6    A7+B1
          SX7    B4 
          SX6    B5 
          SA7    A6+B1
          SA6    A7+B1
          SX7    B6 
          SX6    B7 
          SA7    A6+1 
          SA6    A7+1 
  
*         COMPUTE REMAINING TABLE SPACE.
  
 ATS1.1   SA2    TN          (B2) = NUMBER OF TABLES
          SB2    X2 
          IX4    X1+X2       LENGTH = NUMBER OF TABLES + INCREASE 
          SB3    B2-1 
 ATS2     SB3    B3-B1       LENGTH = LENGTH + TABLE LENGTH 
          SA3    LTAB+B3
          IX4    X4+X3
          NZ     B3,ATS2     LOOP FOR ALL TABLES
          SA2    LM          SET AVAILABLE LENGTH 
          SA3    FTAB-1+B2
          IX6    X3-X2
          SB4    X4          (B4) = TOTAL ASSIGNED LENGTH 
          IX7    X6-X4
          SB5    X7          (B5) = REMAINING SPACE 
          NG     X7,ATS6     IF NO REMAINING SPACE
          RJ     MTD         MOVE TABLES DOWN 
          SA1    ATSB+1      INCREMENT SIZE OF REQUESTED TABLE
          SA2    LTAB+A0
          IX6    X2+X1
          SA6    A2 
  
*         REALLOCATE TABLES.
*         ALLOCATE INTERSPACE.  (LA/2N) + ((TL*LA)/2) + 1 
  
          SA1    FTAB-1+B2   (X0) = LWA+1 LAST TABLE
          SB6    B2-B1
          BX0    X1 
 ATS3     LE     B6,B1,ATS5  IF TABLE RELOCATION COMPLETE 
          SB6    B6-B1       I = I-1
          SX4    B5          LA (LENGTH AVAILABLE)
          SA2    FTAB+B6     FWA(I) 
          SA1    LTAB+B6     TL (LENGTH OF TABLE) 
          SX3    B2-B1       N  (NUMBER OF TABLES)
          AX5    X4,B1       LA/2 
          IX6    X4/X3       L1 = LA/N
          ZR     B4,ATS4     IF NO TABLES ASSIGNED, L = L1
          SX3    B4          AL (TOTAL ASSIGNED LENGTH) 
          IX7    X5*X1       (LA/2)*TL
          AX6    1           L1 = LA/2N 
          IX7    X7/X3       L2 = (TL*LA)/2 
          IX6    X6+X7       L = L1+L2
 ATS4     SX6    X6+B1       L = L+1
          IX4    X0-X6       FWA(I+1)-L 
          UX1    X1          RESET LENGTH 
          IX7    X4-X1       FWA(I) = FWA(I+1)-L-TL 
          BX3    X7          DESTINATION = FWA(I) 
          SA7    A2 
          LX0    X7          FWA(I+1) = FWA(I)
          BX4    X2-X3       CHECK MOVE DIFFERENTIAL
          ZR     X4,ATS3     IF NO MOVE REQUIRED
          RJ     MVE=        MOVE TABLE 
          EQ     ATS3        CONTINUE RELOCATING TABLES 
  
 ATS5     RJ     AMU         ACCUMULATE MEMORY USED 
  
*         RESTORE REGISTERS.
  
          SA1    ATSA        COUNT MOVES
          SX6    X1+B1
          SA6    A1 
          SA2    ATSB        RESTORE (X0) 
          SA1    A2+B1       RESTORE (X1) 
          BX0    X2 
          SA3    A1+B1       RESTORE (X5) 
          SA2    A3+B1       RESTORE B REGISTERS
          BX5    X3 
          SB2    X2 
          SA3    A2+B1
          SB3    X3 
          SA4    A3+B1
          SB4    X4 
          SA2    A4+B1
          SB5    X2 
          SA3    A2+B1
          SB6    X3 
          SA4    A3+B1
          SB7    X4 
          SA2    FTAB+A0     SET TABLE FWA
          SA3    LTAB+A0     SET TABLE LENGTH 
          SX7    -B1         FLAG TABLES MOVED
          EQ     ATS         RETURN 
  
 ATS6     SA3    TO          PROCESS TABLE OVERFLOW 
          SB2    X3 
          SX6    A0          PRESERVE (A0) FROM USER DEPREDATIONS 
          SB6    ATS7        PASS RETURN ADDRESS TO USER
          SA6    ATSC 
          JP     B2 
  
*         RETURN FROM USER ROUTINE *TOV*. 
  
 ATS7     SA1    ATSC        RESTORE (A0), (X1) 
          SA0    X1+
          SA1    ATSB+1 
          JP     ATS1.1      RE-COMPUTE WITH NEW MEMORY 
  
 ATSA     CON    0           COUNT OF TABLE MOVES 
  
 ATSB     CON    0,0,0       (X0, X1, X5) SAVE
          CON    0,0,0,0,0,0 (B2 - B7) SAVE 
 ATSC     CON    0           (A0) SAVE IF TABLE OVERFLOW
 EQS      SPACE  4
***       EQS -  EQUALITY SEARCH TABLE. 
* 
*         ENTRY  (X6) = ENTRY FOR SEARCH. 
*                (B7) = WORD COUNT/ENTRY. 
*                (A0) = TABLE NUMBER. 
* 
*         EXIT   (X2) = ENTRY FOUND.
* 
*         USES   X - 1,2,3,7. 
*                B - NONE.
*                A - 1,2,6. 
* 
*         CALLS  NONE.
  
  
 EQS      PS                 ENTRY/EXIT 
          SA1    FTAB+A0     SET TABLE PARAMETERS 
          SA2    LTAB+A0
          IX3    X1+X2       SET SEARCH KEY IN LWA+1
          SA6    X3 
          NO
          SA1    X1          FIRST ENTRY
 +        BX2    X1-X6       COMPARE ENTRIES
          SA1    A1+B7       NEXT ENTRY 
          NZ     X2,*        LOOP TO MATCH
          SX7    A1-B7       CHECK SEARCH 
          BX2    X7-X3
          ZR     X2,EQS      RETURN IF NOT FOUND
          SA2    A1-B7       RETURN ENTRY 
          EQ     EQS
 MES      SPACE  4
***       MES - MASKED EQUALITY SEARCH TABLE. 
* 
*         ENTRY  (X6) = ENTRY FOR SEARCH. 
*                (X0) = MASK. 
*                (B7) = WORD COUNT/ENTRY. 
*                (A0) = TABLE NUMBER. 
* 
*         EXIT   (X2) = ENTRY FOUND.
* 
*         USES   X - 1,2,3,4,7. 
*                B - NONE.
*                A - 1,2,6. 
* 
*         CALLS  NONE.
  
  
 MES1     BX4    X0*X2
          SA1    A1+B7       NEXT ENTRY 
          BX2    X6-X1       COMPARE ENTRIES
          NZ     X4,MES1     LOOP TO MATCH
          SX7    A1-B7       CHECK SEARCH 
          BX2    X7-X3
          ZR     X2,MES      RETURN IF NOT FOUND
          SA2    X7+         RETURN ENTRY 
  
 MES      PS                 ENTRY/EXIT 
          SA1    FTAB+A0     SET TABLE PARAMETERS 
          SA2    LTAB+A0
          IX3    X1+X2       SET SEARCH KEY IN LWA+1
          SA6    X3 
          SA1    X1          FIRST ENTRY
          BX2    X6-X1
          EQ     MES1 
 MTD      SPACE  4
***       MTD - MOVE TABLES DOWN. 
* 
*         ENTRY  NONE.
* 
*         EXIT   (B2) = NUMBER OF TABLES. 
* 
*         USES   X - 0, 1, 2, 3, 4, 7.
*                B - 2, 3.
*                A - 1,2,3,7. 
* 
*         CALLS  MVE=.
  
  
 MTD      PS                 ENTRY/EXIT 
          SA1    LM          LOW MEMORY LIMIT 
          SA2    TN          (B2) = NUMBER OF TABLES
          BX0    X1 
          SB2    X2 
          SB3    1
 MTD1     SA2    FTAB-1+B3   ORIGIN = PREVIOUS FWA
          SA3    LTAB-1+B3   WORD COUNT = LENGTH + 1
          BX4    X2-X0       MOVE DIFFERENTIAL
          SX1    X3+B1
          SX7    X0          SET NEW FWA
          IX0    X0+X1       NEXT FWA 
          SB3    B3+B1       ADVANCE TABLE NUMBER 
          ZR     X4,MTD2     IF NO MOVE REQUIRED
          SA7    A2 
          MOVE   X1,X2,X7    MOVE MEMORY BLOCK
 MTD2     LT     B3,B2,MTD1  LOOP TO LAST TABLE 
          EQ     MTD         RETURN 
 MTU      SPACE  4
***       MTU - MOVE TABLES UP. 
* 
*         ENTRY  NONE.
* 
*         EXIT   NONE.
* 
*         USES   X - 0, 1, 2, 3, 7. 
*                B - 3. 
*                A - 1, 2, 7. 
* 
*         CALLS  MVE. 
  
  
 MTU1     SB3    B3-B1       DECREMENT TABLE COUNT
          SA2    FTAB+B3
          SA1    LTAB+B3
          IX7    X0-X1       NEW FWA = L - LENGTH 
          LX0    X7          L = NEW FWA
          SA7    A2 
          BX3    X0          MOVE TABLE 
          RJ     MVE= 
          NZ     B3,MTU1
  
 MTU      PS                 ENTRY/EXIT 
          SA1    F.TEND      (X0) = LWA+1 ALL TABLES (L)
          SB3    NTAB-1      (B3) = NUMBER OF TABLES - 1
          BX0    X1 
          EQ     MTU1 
          SPACE  4
          BASE   *
 QUAL$    IF     -DEF,QUAL$ 
          QUAL   *
 ADW      EQU    /COMCMTP/ADW 
 AMU      EQU    /COMCMTP/AMU 
 ATS      EQU    /COMCMTP/ATS 
 EQS      EQU    /COMCMTP/EQS 
 MES      EQU    /COMCMTP/MES 
 MTD      EQU    /COMCMTP/MTD 
 MTU      EQU    /COMCMTP/MTU 
 QUAL$    ENDIF 
          ENDX
