*COMDECK COMCMTP  MEMORY MACROS 
          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 CORP. 1970.
          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 @ *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) < 0 IF TABLES NOT MOVED.
*                (X4) = PREVIOUS LENGTH 
* 
*         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.
  
  
 ATS      PS                 ENTRY/EXIT 
 ATS1     SA4    LTAB+A0     CURRENT LENGTH 
          SA2    FTAB+A0     CURRENT FWA
          IX6    X1+X4       NEW LENGTH 
          SA3    A2+B1       NEXT TABLE FWA 
          IX7    X3-X2       ROOM BETWEEN TABLES
          SA6    A4          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    A4 
          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+B1
          SA6    A7+B1
  
*         COMPUTE REMAINING TABLE SPACE.
  
          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*AL) + 1
  
          SA1    FTAB-1+B2   (X0) = LWA+1 LAST TABLE
          SB6    B2-B1
          BX0    X1 
 ATS3     SB6    B6-B1       I = I+1
          SA2    FTAB+B6     FWA(I) 
          SX4    B5          LA (LENGTH AVAILABLE)
          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*AL)
          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,ATS5     IF NO MOVE REQUIRED
          RJ     MVE=        MOVE TABLE 
 ATS5     NE     B6,B1,ATS3  LOOP 
          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 
          BX7    X5-X5       FLAG TABLES MOVED
          IX4    X3-X1
          EQ     ATS         RETURN 
  
 ATS6     SA3    TO          PROCESS TABLE OVERFLOW 
          SB2    X3 
          JP     B2 
  
 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 
 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
