*DECK DB$CECM 
USETEXT UTMPTTX 
USETEXT UTCDFTX 
      PROC DB$CECM(CALLNUMB,LENGTH);
 #
  *   DB$CECM - ERROR HANDLER FOR CMM OVERFLOW   PAGE  1
  *   STEVEN P. LEVIN                            DATE  11/19/75 
  
  DC  PURPOSE 
  
      HANDLE THE ERROR STATE CAUSED WHEN THE COMMON MEMORY MANAGER
      (CMM) ENTERS OVERFLOW MODE DURING THE BUILDING OF A CST.
  
  DC  ENTRY CONDITIONS
  
      THE PARAMETER CALLNUMB IS AN INTEGER GIVING THE NUMBER OF THE 
      CALL OF THIS OVERFLOW-ACTION PROC TRIGGERED FROM A CMM REQUEST. 
      THE PARAMETER LENGTH IS THE NUMBER OF WORDS COMPRISING THE CMM
      REQUEST WHICH TRIGGERED CMM TO MAKE THIS CALL TO DB$CECM. 
      THE MANAGED MEMORY BLOCK POINTER WORDS IN COMMON FOR BLOCKS THAT
      ARE ALLOCATED BY THE CST BUILDER SHOULD HAVE VALID VALUES.
  
  DC  EXIT CONDITIONS 
  
      ON NORMAL RETURN FROM DB$CECM (OCCURS ONLY IF CALLNUMB = 1), ALL
      EXISTING MANAGED MEMORY BLOCKS ALLOCATED BY THE CST BUILDER WILL
      BE SHRUNK TO JUST ONE WORD (FOR THE HEADER).  THE COMMON ITEM 
      OVERFLOW WILL BE SET TO TRUE TO INDICATE THAT CMM OVERFLOW HAS
      BEEN HANDLED AT THE EXPENSE OF DAMAGING (SOME) EXISTING BLOCKS. 
      THUS, THESE BLOCKS MUST BE FREED BY THE CST BUILDER, RATHER THAN
      BEING USED, AFTER CMM COMPLETES THE REQUEST TRIGGERING OVERFLOW.
      IF DB$CECM DOES NOT RETURN NORMALLY, IT WILL BE BECAUSE DB$USHR 
      CALLED DB$UABN DUE TO AN ABNORMALITY, CMM ABORTED AFTER DB$USHR 
      CALLED IT, OR DB$CECM FOUND AN ABORT SITUATION (CALLNUMB NOT 1).
      IN THE LATTER CASE, THE CST BUILDER CAN DO NO MORE TO FREE CORE.
  
  DC  CALLING ROUTINES
  
      CMM CALLS DB$CECM WHEN IT ENTERS OVERFLOW MODE IN CST BUILDING. 
      DB$CBLD PUSHES THE LOC OF DB$CECM ON THE OVERFLOW-ACTION STACK. 
  
  DC  CALLED ROUTINES 
  
      DB$CERR - ERROR MESSAGE AND RETURN HANDLER FOR FATAL ERRORS 
      DB$USHR - SHRINK A MANAGED MEMORY BLOCK TO JUST A 1-WORD HEADER 
  
  DC  NON-LOCAL VARIABLES 
  
      THE ITEM OVERFLOW IN COMMON IS SET TO TRUE IF CALLNUMB IS 1.
      THROUGH CALLS TO DB$USHR, AND HENCE TO DB$UADR, IF CALLNUMB IS
      1, THE CONTENTS OF, ADDRESS WORDS FOR, AND POINTER WORDS FOR
      MANAGED MEMORY BLOCKS MAY BE CHANGED UPON RETURN FROM DB$CECM.
  
  DC  DESCRIPTION 
  
      IF CALLNUMB IS NOT 1, CALL DB$CERR TO ABORT THE MD UTILITY RUN. 
      SET OVERFLOW TO TRUE, AND CALL DB$USHR TO SHRINK MEMORY BLOCKS. 
      RETURN (TO CMM) WITH CST BUILDER MANAGED MEMORY BLOCKS SHRUNK.
 #
        CONTROL EJECT;
  
        BEGIN                # DB$CECM #
  
# THE FOLLOWING ARE FORMAL PARAMETERS IN THE ORDER THEY ARE PASSED #
  
        ITEM CALLNUMB I;     # NUMBER OF THE CALL OF PROC DB$CECM # 
        ITEM LENGTH I;       # NUMBER OF WORDS COMPRISING CMM REQUEST#
  
# THE FOLLOWING ARE EXTERNALLY REFERENCED PROCEDURES #
  
        XREF PROC DB$CERR;   # ERROR HANDLER FOR FATAL ERRORS # 
        XREF PROC DB$USHR;   # SHRINK MANAGED MEMORY BLOCK TO 1 WORD #
  
        CONTROL NOLIST;      # UNLISTED COMDECKS: UTCDFDCLS UTMPTDCLS#
        CONTROL LIST;        # RESUME THE LISTING OF THE SOURCE CODE #
  
# ******************************************************************** #
  
# IF CALLNUMB IS NOT 1, CALL DB$CERR TO ABORT THE MD UTILITY RUN #
  
        IF CALLNUMB NQ 1     # ABORT IF THIS IS NOT THE FIRST CALL #
          THEN XCALL DB$CERR("7331CECM",((LENGTH / DFPRUSIZ) + 1) 
                                        * DFPRUSIZ);       # ABORT #
  
# SET OVERFLOW TO TRUE, AND CALL DB$USHR TO SHRINK MEMORY BLOCKS #
  
        OVERFLOW = TRUE;     # MEMORY OVERFLOW IS DAMAGING TO BLOCKS #
        IF CALPOINT NQ 0 THEN XCALL DB$USHR(LOC(CALPOINT)); 
        IF CHKSMBP  NQ 0 THEN XCALL DB$USHR(LOC(CHKSMBP));
        IF CITPOINT NQ 0 THEN XCALL DB$USHR(LOC(CITPOINT)); 
        IF EXTPOINT NQ 0 THEN XCALL DB$USHR(LOC(EXTPOINT)); 
        IF PLOPOINT NQ 0 THEN XCALL DB$USHR(LOC(PLOPOINT)); 
        IF POPPOINT NQ 0 THEN XCALL DB$USHR(LOC(POPPOINT)); 
        IF SCHPOINT NQ 0 THEN XCALL DB$USHR(LOC(SCHPOINT)); 
        IF SUBPOINT NQ 0 THEN XCALL DB$USHR(LOC(SUBPOINT)); 
        IF WORPOINT NQ 0 THEN XCALL DB$USHR(LOC(WORPOINT)); 
  
# RETURN (TO CMM) WITH CST BUILDER MANAGED MEMORY BLOCKS NOW SHRUNK # 
  
        RETURN;              # CST BUILDER MEMORY BLOCKS NOW SHRUNK # 
  
        END                  # DB$CECM #
  
      TERM
