*DECK DB$UALC 
USETEXT UTMPTTX 
USETEXT UTCDFTX 
USETEXT CUGBATX 
      PROC DB$UALC(LOCPOINT,AMOUNT,PAD);
 #
  *   DB$UALC - ALLOCATE A MANAGED MEMORY BLOCK  PAGE  1
  *   STEVEN P. LEVIN                            DATE  10/14/75 
  
  DC  PURPOSE 
  
      ALLOCATE A VARYING-POSITION TYPE 1 MANAGED MEMORY BLOCK IN CORE,
      ZERO THE WORDS ALLOCATED, AND SET UP THE FIRST WORD AS A HEADER.
  
  DC  ENTRY CONDITIONS
  
      PARAMETER LOCPOINT IS THE LOCATION OF THE BLOCK POINTER WORD. 
      PARAMETER AMOUNT IS THE INITIAL SPACE IN USE (0 OR MORE WORDS). 
      PARAMETER PAD IS THE BLOCK EXTRA PAD FACTOR (0 OR MORE WORDS).
      COMMON ITEM OVERFLOW IS TRUE IF OVERFLOW WAS DAMAGING TO BLOCKS.
  
  DC  EXIT CONDITIONS 
  
      UPON NORMAL RETURN FROM DB$UALC, A MANAGED MEMORY BLOCK WILL
      HAVE BEEN ALLOCATED WITH THE WORD LOCATED AT LOCPOINT SERVING AS
      THE BLOCK POINTER WORD FOR THE COMMON MEMORY MANAGER (CMM).  THE
      INITIAL SPACE IN USE WORD SIZE WILL BE AS INDICATED BY AMOUNT (0
      OR MORE WORDS).  THE PHYSICAL BLOCK SIZE REQUESTED FROM CMM WILL
      INCLUDE 1 WORD FOR THE BLOCK HEADER, AMOUNT WORDS FOR SPACE IN
      USE, AND PAD WORDS (0 OR MORE) FOR FUTURE INCREASES IN SPACE IN 
      USE.  ALL WORDS PHYSICALLY ALLOCATED WILL BE ZEROED, AND THE
      FIRST WORD OF THE BLOCK ALLOCATED BY CMM WILL BE SET UP AS A
      BLOCK HEADER WORD.  MANAGED MEMORY BLOCK FIRST-USABLE-ADDRESS 
      WORDS (AS NEEDED) WILL BE UPDATED FOR CURRENT CORE CONDITIONS.
      IF DB$UALC DOES NOT RETURN NORMALLY, IT WILL BE BECAUSE IT CALLS
      DB$UABN TO HANDLE A PARAMETER OR OVERFLOW ABNORMALITY, CMM CALLS
      AN OVERFLOW ACTION ROUTINE WHICH DOES NOT RETURN NORMALLY, OR 
      CMM ITSELF ABORTS.  IF DB$UABN IS CALLED TO HANDLE AN OVERFLOW
      ABNORMALITY, THE BLOCK WILL HAVE BEEN ALLOCATED, BUT THE HEADER 
      WILL NOT HAVE BEEN SET UP AND OTHER WORDS WILL NOT HAVE BEEN
      ZEROED.  SUCH A BLOCK SHOULD BE FREED IF DB$UABN DOES NOT ABORT.
  
  DC  CALLING ROUTINES
  
      DB$CBLD - CONDENSED SCHEMA/SUBSCHEMA TABLE BUILDER MAIN MODULE
  
  DC  CALLED ROUTINES 
  
      DB$MV1A - CALL CMM TO ALLOCATE A VARYING-POISITION TYPE 1 BLOCK 
      DB$UABN - HANDLE ABNORMALITIES IN MANAGED MEMORY BLOCK MODULES
      DB$UADR - UPDATE MANAGED MEMORY BLOCK FIRST-USABLE-ADDRESS WORDS
  
  DC  NON-LOCAL VARIABLES 
  
      THE WORD LOCATED AT LOCPOINT WILL BE SET UP AS A MANAGED MEMORY 
      BLOCK POINTER WORD BY THE COMMON MEMORY MANAGED (CMM).  ALL 
      WORDS PHYSICALLY ALLOCATED IN THE BLOCK WILL BE ZEROED, AND THE 
      FIRST WORD OF THE BLOCK ALLOCATED BY CMM WILL BE SET UP AS A
      BLOCK HEADER WORD.  DB$UADR WILL UPDATE MANAGED MEMORY BLOCK
      FIRST-USABLE-ADDRESS WORDS (AS NEEDED) FOR CURRENT CORE LAYOUT. 
  
  DC  DESCRIPTION 
  
      IF POINTER WORD IS NOT 0 OR AMOUNT < 0 OR PAD < 0, CALL DB$UABN.
      COMPUTE THE NEW BLOCK LENGTH, ALLOCATE IT, AND CHECK OVERFLOW.
      ZERO ALL WORDS IN THE BLOCK.  SET UP THE FIRST WORD AS A HEADER.
      CALL DB$UADR TO UPDATE MEMORY BLOCK FIRST-USABLE-ADDRESS WORDS. 
      RETURN FROM DB$UALC WITH A NEW MANAGED MEMORY BLOCK ALLOCATED.
 #
  
  
  
        BEGIN                # DB$UALC #
  
*CALL MDABTDCLS 
  
# THE FOLLOWING ARE FORMAL PARAMETERS IN THE ORDER THEY ARE PASSED #
  
        ITEM LOCPOINT U;     # LOCATION OF POINTER WORD FOR NEW BLOCK#
        ITEM AMOUNT I;       # INITIAL SPACE IN USE TO BE ALLOCATED # 
        ITEM PAD I;          # BLOCK EXTRA PAD FACTOR IN WORDS #
  
# THE FOLLOWING ARE EXTERNALLY REFERENCED PROCEDURES #
  
        XREF PROC DB$CALL;   # CALL A VARIABLE PROCEDURE             #
        XREF PROC DB$MABI;   # DBMSTRD INTERNAL ERROR,  ABORT        #
        XREF PROC DB$MABT;   # DBMSTRD ABORT, MEMORY OVERFLOW        #
        XREF PROC DB$MV1A;   # CALL CMM TO ALLOCATE VARY TYPE 1 BLOCK # 
        XREF PROC DB$UADR;   # UPDATE MANAGED MEMORY USABLE ADDRESSES#
  
  
# THE FOLLOWING ITEMS ARE LOCAL TO DB$UALC #
  
        ITEM INDEX I;        # A GENERAL INDEX AND INDUCTION VARIABLE#
        ITEM LENGTH I;       # PHYSICAL LENGTH IN WORDS OF NEW BLOCK #
  
  
  
  
#     B E G I N   D B $ U A L C   E X E C U T A B L E   C O D E .      #
  
  
# IF POINTER WORD IS NOT ZERO OR AMOUNT < 0 OR PAD < 0, CALL DB$UABN #
  
        P<GETENTRY> = LOCPOINT;        # POINT TO BLOCK POINTER WORD #
        IF GETUNSIG[0] NQ 0 
          OR AMOUNT LS 0
          OR PAD LS 0 
        THEN
          BEGIN 
          DB$MABI("DB$UALC");      # INTERNAL ERROR, NO RETURN         #
  
          END 
  
# COMPUTE THE NEW BLOCK LENGTH, ALLOCATE IT, AND CHECK FOR OVERFLOW # 
  
        LENGTH = 1 + AMOUNT + PAD;     # HEADER + SPACE IN USE + PAD #
        XCALL DB$MV1A(LENGTH,GETENTRY);          # DB$MV1A CALLS CMM #
        IF OVERFLOW 
        THEN
          BEGIN 
          IF OVLLEVEL EQ 3
          THEN
            BEGIN 
            DB$CALL(OVERFERR,"7201UALC",LOCPOINT);
            END 
          DB$MABT(DFMMOVER,"DB$UALC");
          END 
  
# ZERO ALL WORDS IN THE BLOCK, AND SET UP THE FIRST WORD AS A HEADER #
  
        P<PUTENTRY> = B<42,18> GETUNSIG[0] - 1;  # POINT TO BLOCK - 1#
        FOR INDEX = 1 THRU LENGTH DO PUTUNSIG[INDEX] = 0;  # ZERO # 
        P<TLC> = B<42,18> GETUNSIG[0];  # POINT TO HEADER              #
        TLCCT = FALSE;       # A BASIC HEADER IS INITIALIZED.          #
        TLCPAD[0] = PAD;     # BLOCK EXTRA PAD FACTOR IN WORDS         #
        TLCUSED[0] = AMOUNT; # SPACE ACTUALLY USED IN BLOCK            #
        TLCLEN[0] = LENGTH;  # PHYSICAL BLOCK LENGTH (COUNTS HEADER)   #
  
# CALL DB$UADR TO UPDATE MEMORY BLOCK FIRST-USABLE-ADDRESS WORDS #
  
        XCALL DB$UADR;       # UPDATE MENAGED MEMORY USABLE ADDRESSES#
  
# RETURN FROM DB$UALC WITH A NEW MANAGED MEMORY BLOCK NOW ALLOCATED # 
  
        RETURN;              # NEW MANAGED MEMORY BLOCK NOW ALLOCATED # 
  
        END                  # DB$UALC #
  
      TERM
