*DECK DB$CBEG 
USETEXT UTCITTX 
USETEXT UTCDFTX 
      PROC DB$CBEG; 
  
 #
  
  *   DB$CBEG - BEGIN CST BUILDING (CHECK CORE)  PAGE  1
  *   STEVEN P. LEVIN                            DATE  08/13/75 
  
  DC  PURPOSE 
  
      BEGIN CST BUILDING BY CHECKING FOR SUFFICIENT CORE AVAILABLE
      BASED ON MINIMAL NEEDS.  TAKE AN ERROR EXIT IF NOT AVAILABLE. 
  
  DC  ENTRY CONDITIONS
  
      THE FOLLOWING COMMON ITEMS SHOULD HAVE BEEN GIVEN VALID VALUES: 
      MASWAARE - MASTER DIRECTORY AREA DIRECTORY WORD ADDRESS 
      SBMAXCAP - SUBSCHEMA MAXIMUM MAPPING CAPSULE LENGTH IN WORDS
      SBMAXENT - SUBSCHEMA MAXIMUM SUBENTRY LENGTH IN WORDS 
      SCMAXENT - SCHEMA MAXIMUM SUBENTRY LENGTH IN WORDS
      SCNUMARE - SCHEMA TOTAL NUMBER OF AREA ENTRIES
      THE MASTER DIRECTORY FILE AND ITS FIT DB$FTMD SHOULD BE USABLE. 
  
  DC  EXIT CONDITIONS 
  
      UPON NORMAL RETURN FROM DB$CBEG, IT WILL BE VERIFIED THAT ENOUGH
      CORE IS AVAILABLE TO BUILD A CONDENSED SCHEMA/SUBSCHEMA TABLE 
      (CST) BASED ON MINIMAL NEEDS.  (NOTE, IT MAY DEVELOP LATER THAT 
      MINIMAL NEEDS DO NOT SUFFICE.)  TO DO THIS VERIFICATION, THE
      MASTER DIRECTORY AREA DIRECTORY CONTROL WORD WILL BE READ.
      IF AN ERROR IS FOUND DURING DB$CBEG PROCESSING, THE CST BUILDER 
      WILL BE ABORTED THROUGH A CALL TO THE ERROR MODULE, DB$CERR.
  
  DC  CALLING ROUTINES
  
      DB$CBLD - CONDENSED SCHEMA/SUBSCHEMA TABLE BUILDER MAIN MODULE
  
  DC  CALLED ROUTINES 
  
      DB$CERR - ERROR MESSAGE AMD RETURN HANDLER FOR FATAL ERRORS 
      DB$MGOS - FUNCTION TO GET CMM OVERFLOW STATISTICS 
      DB$WGET - CALL CYBER RECORD MANAGER TO DO A WORD ADDRESSABLE GET
  
  DC  NON-LOCAL VARIABLES 
  
      MASSZARE - MASTER DIRECTORY AREA DIRECTORY SIZE (- CONTROL WORD)
  
* DC  DESCRIPTION 
  
      CALL DB$WGET TO READ THE MD AREA DIRECTORY CONTROL WORD TO CORE.
      GET COMMON MEMORY MANAGER OVERFLOW STATISTICS FROM DB$MGOS. 
      CALCULATE MINIMAL MANAGED MEMORY BLOCK CORE WORD REQUIREMENTS.
      IF THE MINIMAL MEMORY NEEDS ARE TOO MUCH, CALL DB$CERR TO ABORT.
      IF THE MINIMAL MEMORY NEEDS ARE AVAILABLE, RETURN FROM DB$CBEG. 
      (NOTE THAT AS BLOCKS GROW, IT MAY BECOME APPARENT LATER THAT
      MINIMAL NEEDS ARE NOT TRULY ENOUGH SINCE CORE MAY BE EXHAUSTED.)
  
 #
        CONTROL EJECT;
  
        BEGIN                # DB$CBEG #
  
# THE FOLLOWING ARE EXTERNALLY REFERENCED PROCEDURES AND ARRAYS # 
  
        XREF PROC DB$CEMD;   # MASTER DIRECTORY CRM ERROR HANDLER # 
        XREF PROC DB$CERR;   # ERROR HANDLER FOR FATAL ERRORS # 
        XREF FUNC DB$MGOS U; # GET CMM OVERFLOW STATISTICS #
        XREF PROC DB$WGET;   # CALL CRM TO DO A WORD ADDRESSABLE GET #
        XREF ARRAY DB$FTMD;; # MASTER DIRECTORY FILE INFORMATN. TABLE#
  
        CONTROL NOLIST;      # COMDECKS: UTCDFDCLS AND UTCITDCLS #
        CONTROL LIST;        # RESUME THE LISTING OF THE SOURCE CODE #
  
        ITEM COREMINI I;     # CORE MINIMUM NUMBER OF WORDS NEEDED #
  
# THE FOLLOWING LOCAL ARRAY IS FOR THE MD AREA DIRECTORY CONTROL WORD#
  
        ARRAY MDADIREC[0:0] P(DFMDADCW);         # MD AREA DIRECTORY #
  
          BEGIN              # MDADIREC ARRAY # 
*CALL MDARDDCLS 
          END                # MDADIREC ARRAY # 
  
# THE FOLLOWING LOCAL BASED ARRAY IS FOR CMM GET OVERFLOW STATISTICS #
  
        BASED ARRAY GOSTATIS[0:0] P(15);         # GET OVERFLOW STATS#
  
          BEGIN              # GOSTATIS BASED ARRAY # 
  
            ITEM GOSDABA  U(0,0,60);   # DYNAMIC AREA BASE ADDRESS #
            ITEM GOSHHA   U(1,0,60);   # HIGHEST HIGH ADDRESS VALUE # 
            ITEM GOSCURFL U(2,0,60);   # CURRENT FIELD LENGTH VALUE # 
            ITEM GOSMAXFL U(3,0,60);   # MAXIMUM FIELD LENGTH VALUE # 
            ITEM GOSUTILZ U(4,0,60);   # CURRENT UTILIZATION LEVEL #
            ITEM GOSLEVTR U(5,0,60);   # CURRENT LEVEL OF TRIGGER # 
            ITEM GOSCONWD U(6,0,60);   # MAXIMUM CONTIGUOUS WORDS # 
            ITEM GOSCONTR U(7,0,60);   # CURRENT CONTIGUOUS TRIGGER # 
            ITEM GOSOVERF U(8,0,60);   # OVERFLOW ACTION STACK COUNT #
            ITEM GOSFIXBL U(9,0,60);   # FIXED-POSITION BLOCKS COUNT #
            ITEM GOSVARBL U(10,0,60);  # VARIABLE-POSITION BLOCKS # 
            ITEM GOSFIXWD U(11,0,60);  # FIXED-POSITION WDS ALLOCATED#
            ITEM GOSVARWD U(12,0,60);  # VARIABLE-POSITION WORDS #
            ITEM GOSFREAR U(13,0,60);  # NUMBER OF FREE AREAS # 
            ITEM GOSFREWD U(14,0,60);  # NUMBER OF FREE WORDS # 
  
          END                # GOSTATIS BASED ARRAY # 
        CONTROL EJECT;
  
# CALL DB$WGET TO READ MASTER DIRECTORY AREA DIRECTORY CONTROL WORD # 
  
        XCALL DB$WGET(DB$FTMD,MDADIREC,DFMDADCW,MASWAARE,DB$CEMD);
        IF MDADNBAR[0] NQ SCNUMARE     # CHECK SCHEMA NUMBER OF AREAS#
          THEN XCALL DB$CERR("7101CBEG",SCNUMARE);         # ABORT #
        MASSZARE = SCNUMARE * DFMDADEN;          # AREA DIRECTOR SIZE#
  
# GET COMMON MEMORY MANAGER OVERFLOW STATISTICS FROM DB$MGOS #
  
        P<GOSTATIS> = DB$MGOS;         # POINT TO OVERFLOW STATISTICS#
  
# CALCULATE MINIMAL MANAGED MEMORY BLOCK CORE WORD REQUIREMENTS # 
  
        IF SBMAXCAP GQ SBMAXENT        # CHECK WHICH SIZE IS GREATER #
          THEN COREMINI = (1 + SBMAXCAP);        # HEADER+MAX CAPSULE#
          ELSE COREMINI = (1 + SBMAXENT);        # HEAD+MAX SUBENTRY #
        COREMINI = COREMINI + (1 + SCMAXENT) + (1 + MASSZARE) 
                   + (DFBLOCKS - 3) * (1 + DFPRUSIZ) + DFFUDGE; 
  
# IF THE MINIMAL MEMORY NEEDS ARE TOO MUCH, CALL DB$CERR TO ABORT # 
  
        IF COREMINI GR GOSFREWD[0]     # ABORT IF NEED TOO MUCH CORE #
          THEN XCALL DB$CERR("7102CBEG",(((COREMINI - GOSFREWD[0])
                                        / DFPRUSIZ) + 1) * DFPRUSIZ); 
  
# THE MINIMAL MEMORY NEEDS ARE AVAILABLE, SO RETURN FROM DB$CBEG #
  
        RETURN;              # SUFFICIENT MINIMAL CORE IS AVAILABLE # 
  
        END                  # DB$CBEG #
  
      TERM
