*DECK DB$CBLD 
USETEXT UTMPTTX 
USETEXT UTCITTX 
USETEXT UTCDFTX 
      PROC DB$CBLD; 
 #
  *   DB$CBLD - CST BUILDER MAIN MODULE          PAGE  1
  *   STEVEN P. LEVIN                            DATE  08/06/75 
  
  DC  PURPOSE 
  
      THIS IS THE CONDENSED SCHEMA/SUBSCHEMA TABLE (CST) BUILDER MAIN 
      MODULE.  IT CONTROLS THE FLOW OF EXECUTION IN BUILDING A CST. 
  
  DC  ENTRY CONDITIONS
  
      THE MASTER DIRECTORY FILE SHOULD HAVE ALL RELEVANT INFORMATION
      NEEDED FOR THE SCHEMA TO WHICH THE SUBSCHEMA USED TO BUILD THE
      CST BELONGS.  SCHEMA AND SUBSCHEMA DATA DESCRIPTION LANGUAGE
      (DDL) DIRECTORIES SHOULD BE AVAILABLE FOR CST BUILDER USE.
      THE FOLLOWING COMMON ITEMS SHOULD HAVE BEEN GIVEN VALID VALUES: 
      PCSBLFN  - SUBSCHEMA LOGICAL FILE NAME (LFN)
      PCSBNAME - SUBSCHEMA NAME 
      PCSCDATE - MASTER DIRECTORY SCHEMA JULIAN DATE OF CREATION
      PCSCIDNT - MASTER DIRECTORY SCHEMA IDENTIFIER 
      PCSCLFN  - SCHEMA LOGICAL FILE NAME (LFN) 
      PCSCNAME - SCHEMA NAME
      PCSCTIME - MASTER DIRECTORY SCHEMA TIME OF CREATION 
      PCWAAREA - WORD ADDRESS OF AREA DIRECTORY IN MASTER DIRECTORY 
      PCWACST  - WORD ADDRESS OF NEW CST ENTRY IN THE MASTER DIRECTORY
      THOUGH NOT USED EXPLICITLY BY DB$CBLD, OTHER CST BUILDER MODULES
      ALSO NEED THE MASTER DIRECTORY CREATOR TO SUPPLY THE FOLLOWING: 
      DBPROCBP - DATA BASE PROC TABLE MANAGED MEMORY BLOCK POINTER WD.
      DB$FTMD  - EXTERNAL ARRAY CONTAINING THE MASTER DIRECTORY FIT 
      ERRCNT   - ERROR COUNT FOR THE MASTER DIRECTORY UTILITY DBMSTRD 
      MDCHKSMBP- MD CHECKSUM LIST MANAGED MEMORY BLOCK POINTER WORD 
      OVLLEVEL - CURRENT OVERLAY LEVEL NUMBER 
      WRNMSGCTR- WARNING MESSAGE COUNTER FOR MASTER DIRECTORY UTILITY 
  
  DC  EXIT CONDITIONS 
  
      ON NORMAL DB$CBLD RETURN (PCSTATWD=0), A NEW CST WILL BE IN THE 
      MD FILE STARTING AT WORD ADDRESS PCWACST.  THE FIELDS PCCAPLNG
      (MAPPING CAPSULE TABLE LENGTH), PCSBCKSM, PCSBDATE, PCSBTIME
      (SUBSCHEMA CHECKSUM, DATE, AND TIME, RESPECTIVELY), AND PCSIZCST
      (CST LENGTH EXCLUDING CAPSULES) IN COMMON WILL BE PROPERLY SET. 
      IF DB$CBLD DOES NOT RETURN NORMALLY (PCSTATWD CONTAINS NON-ZERO 
      FATALITY LEVEL), IT WILL BE BECAUSE A SUBMODULE FOUND AN ERROR
      SO BAD THAT THE CST BUILDER OR THE ENTIRE RUN MUST BE ABORTED.
      THE CST BUILDER SUBMODULE WHICH FINDS THE ERROR CALLS DB$CERR.
      DB$CERR HANDLES ERROR MESSAGE FORMING FOR OUTPUT, SETS CERTAIN
      COMMON ITEMS WHICH INDICATE THE ERROR OCCURRED, AND THEN GOES TO
      THE LABEL DB$CBLE IN DB$CBLD TO RETURN TO THE CALLER OF DB$CBLD.
      HOWEVER, SOME CST BUILDER SUBMODULES MAY CALL GENERAL MASTER
      DIRECTORY UTILITY MODULES (SUCH AS MEMORY BLOCK HANDLER MODULES)
      WHICH MAY CALL DB$MABT.  IF IT IS CALLED, DB$MABT ABORTS THE
      ENTIRE RUN IMMEDIATELY.  THUS, CONTROL MAY NOT RETURN THROUGH 
      DB$CBLD, DEPENDING ON THE REASON(S) FOR THE SPECIFIC ABORT. 
  
  DC  CALLING ROUTINES
  
      THE MASTER DIRECTORY CREATOR CALLS DB$CBLD TO BUILD A CONDENSED 
      SCHEMA/SUBSCHEMA TABLE (CST) FOR EACH NEW SUBSCHEMA PROCESSED.
      ERROR MODULE DB$CERR GOES TO THE LABEL DB$CBLE FOR ERROR RETURN.
  
  DC  CALLED ROUTINES 
  
      DB$CARE - BUILD AN AREA WORK BLOCK IN THE WORK BLOCK CORE BLOCK 
      DB$CBEG - BEGIN CST BUILDING BY CHECKING FOR SUFFICIENT CORE
      DB$CCHK - COMPARE CHECKSUMS IN MD, CURRENT SCHEMA, AND SUBSCHEMA
      DB$CCLS - CLOSE THE SUBSCHEMA AND SCHEMA DIRECTORY FILES
      DB$CCON - BUILD A CONSTRAINT WORK BLOCK IN WORK BLOCK CORE BLOCK
      DB$CCPP - PREPROCESS SUBSCHEMA AND SCHEMA FOR CONSTRAINT INFO 
      DB$CEND - END CST BUILD BY WRITING PARTS OTHER THAN WORK BLOCKS 
      DB$CFIL - FUNCTION TO BLANK OR BINARY ZERO CHARACTER FILL STRING
      DB$COPN - OPEN THE SUBSCHEMA AND SCHEMA DIRECTORY FILES 
      DB$COUT - PUT SUCCESSFUL COMPLETION STATISTICS ON OUTPUT FILE 
      DB$CPRE - PREPARE TO BUILD WORK BLOCKS WITH NEEDED INITIALIZING 
      DB$CREC - BUILD A RECORD WORK BLOCK IN THE WORK BLOCK CORE BLOCK
      DB$CREL - BUILD A RELATION WORK BLOCK IN WORK BLOCK MEMORY BLOCK
      DB$MDOE - DELETE A CMM OVERFLOW-ACTION STACK TRIGGER/PROC ENTRY 
      DB$MPOE - FUNCTION TO PUSH A CMM OVERFLOW-ACTION STACK ENTRY
      DB$UALC - ALLOCATE A MANAGED MEMORY BLOCK FOR WORKING STORAGE 
      DB$UAWS - ADJUST THE WORK SPACE USABLE IN A MANAGED MEMORY BLOCK
      DB$UFRE - FREE A MANAGED MEMORY BLOCK USED AS WORKING STORAGE 
      SECOND  - FORTRAN LIBRARY SUBPROGRAM FOR CENTRAL PROCESSOR TIME 
  
  DC  NON-LOCAL VARIABLES 
  
      CALPOINT - CONSTRAINT AREA LIST BLOCK MANAGED MEMORY POINTER WRD
      CHKSMBP  - CURRENT CHECKSUM LIST BLOCK MANAGED MEMORY POINTER WD
      CITPOINT - CONSTRAINT INTEGRITY TABLE BLOCK MANAGED MEM PNTR WRD
      CURCMMID - CURRENT CMM OVERFLOW-ACTION STACK ENTRY IDENTIFIER 
      CURIDENT - CURRENT DATA BASE ELEMENT MASTER DIRECTORY IDENTIFIER
      CURNAME  - CURRENT DATA BASE ELEMENT NAME (BLANK IF NONE) 
      CURORDNL - CURRENT WORK BLOCK ORDINAL (0 IF NONE BEING BUILT) 
      CURSCRAT - CURRENT SCRATCH USE NAME 
      CURTYPE  - CURRENT DATA BASE ELEMENT TYPE (0 IF NONE) 
      EXTPOINT - EXTENSION BLOCK MANAGED MEMORY POINTER WORD
      LENTHCST - WORD LENGTH OF THE CST IN THE MASTER DIRECTORY FILE
      LENTOCON - WORD LENGTH TO THE FIRST CONSTRAINT WORK BLOCK 
      LENTOOPT - WORD LENGTH TO THE PROCEDURE OPTION TABLE
      LENTOREC - WORD LENGTH TO THE FIRST RECORD WORK BLOCK 
      LENTOREL - WORD LENGTH TO THE FIRST RELATION WORK BLOCK 
      MASWAARE - WORD ADDRESS IN MASTER DIRECTORY OF AREA DIRECTORY 
      MASWACST - WORD ADDRESS IN THE MASTER DIRECTORY OF NEW CST ENTRY
      NAMESCHE - BLANK-FILLED SCHEMA NAME 
      NAMESUBS - BLANK-FILLED SUBSCHEMA NAME
      OUTTIME  - CP TIME IN SECONDS AT CST BUILDER START (FOR OUTPUT) 
      OVERFERR - MANAGED MEMORY OVERFLOW ERROR SPECIAL PROC ADDRESS 
      OVERFLOW - MANAGED MEMORY OVERFLOW DAMAGING TO BLOCKS FLAG
      PCCAPLNG - LENGTH IN WORDS OF THE NEW CST MAPPING CAPSULE TABLE 
      PCSBCKSM - CHECKSUM OF THE SUBSCHEMA DIRECTORY DERIVED BY DDL 
      PCSBDATE - JULIAN DATE OF CREATION OF THE SUBSCHEMA 
      PCSBTIME - TIME OF CREATION OF THE SUBSCHEMA
      PCSIZCST - LENGTH IN WORDS OF CST EXCLUDING MAP CAPSULE TABLE 
      PCSTATWD - CST BUILDER ERROR STATUS WORD (0 IFF NO ERROR) 
      PLOPOINT - PRIVACY LOCK TABLE BLOCK MANAGED MEMORY POINTER WORD 
      POPPOINT - PROC OPTION TABLE BLOCK MANAGED MEMORY POINTER WORD
      SBCURRAD - SUBSCHEMA CURRENT MAIN ENTRY ADDRESS 
      SBNEXTAD - SUBSCHEMA NEXT MAIN ENTRY WORD ADDRESS 
      SCHPOINT - SCHEMA BLOCK MANAGED MEMORY POINTER WORD 
      SCIDENT  - MASTER DIRECTORY UTILITY SCHEMA IDENTIFIER 
      STATMAST - MASTER DIRECTORY FILE STATUS (1 IF OK AND IN USE)
      STATSCHE - SCHEMA DIRECTORY FILE STATUS (1 IF NOT OPENED) 
      STATSUBS - SUBSCHEMA DIRECTORY FILE STATUS (1 IF NOT OPENED)
      SUBPOINT - SUBSCHEMA BLOCK MANAGED MEMORY POINTER WORD
      WORPOINT - WORK BLOCK MAIN BLOCK MANAGED MEMORY POINTER WORD
      IN ADDITION, THE MASTER DIRECTORY FILE MAY BE MODIFIED BY SOME
      CST BUILDER SUBMODULES, THOUGH NOT DIRECTLY BY DB$CBLD ITSELF,
      WHEN THE NEW CST BEING BUILT IS WRITTEN TO THE MASTER DIRECTORY.
  
  DC  DESCRIPTION 
  
      DB$CBLD IS THE CONDENSED SCHEMA/SUBSCHEMA TABLE (CST) BUILDER 
      MAIN MODULE.  A CST IS CREATED AND WRITTEN TO THE MASTER
      DIRECTORY FILE FOR EACH NEW SUBSCHEMA ENTRY INDICATED IN MASTER 
      DIRECTORY INPUT SYNTAX.  THE CST BUILDER (DB$CBLD) IS CALLED ONE
      TIME FOR EACH NEW SUBSCHEMA ENTRY TO BUILD ONE NEW CST FOR IT.
      A CST IS AN INFORMAITON STRUCTURE USED BY CDCS IN LIEU OF 
      DIRECTLY ACCESSING A SCHEMA OR A SUBSCHEMA WHEN CDCS EXECUTES.
      ONCE A CST IS BUILT, CDCS CAN GENERATE A RUN-UNIT STATUS BLOCK
      (RSB) AND OTHER PERTINENT CDCS STRUCTURES DIRECTLY FROM A CST.
      DB$CBLD CONTROLS THE FLOW OF EXECUTION IN BUILDING A CST BY 
      SETTING SOME ITEMS IN COMMON, CALLING OTHER MODULES, CONTROLLING
      ALLOCATION AND FREEING OF MANAGED MEMORY BLOCKS, AND SO FORTH.
  
      INITIALIZE COMMON ITEMS WHICH SHOULD BE INITIALIZED IMMEDIATELY.
      CALL DB$MPOE TO PUSH A CMM OVERFLOW-ACTION STACK ENTRY. 
      CALL DB$COPN TO OPEN THE SUBSCHEMA AND SCHEMA DIRECTORY FILES.
      CALL DB$CBEG TO BEGIN BUILDING BY CHECKING FOR SUFFICIENT CORE. 
      CALL DB$UALC ONCE FOR EACH MANAGED MEMORY BLOCK TO BE ALLOCATED.
      CALL DB$CCHK TO COMPARE CHECKSUMS IN MD, SCHEMA, AND SUBSCHEMA. 
      CALL DB$CPRE TO PREPARE TO BUILD WORK BLOCKS BY INITIALIZING. 
      IF SCHEMA CONSTRAINTS, CALL DB$CCPP TO PREPROCESS CONSTRAINTS.
      CALL DB$CARE ONCE FOR EACH AREA WORK BLOCK TO BE BUILT IN CORE. 
      CALL DB$UAWS ONCE FOR EACH BLOCK WHOSE LENGTH IS TO BE ADJUSTED.
      CALL DB$CREC ONCE FOR EACH RECORD WORK BLOCK TO BE BUILT. 
      CALL DB$CREL ONCE FOR EACH RELATION WORK BLOCK TO BE BUILT. 
      CALL DB$CCON ONCE FOR EACH CONSTRAINT WORK BLOCK TO BE BUILT. 
      CALL DB$CEND TO END CST BUILDING BY WRITING FURTHER CST PARTS.
      CALL DB$UFRE ONCE FOR EACH MANAGED MEMORY BLOCK TO BE FREED.
      CALL DB$CCLS TO CLOSE THE SUBSCHEMA AND SCHEMA DIRECTORY FILES. 
      CALL DB$MDOE TO DELETE A CMM OVERFLOW-ACTION STACK ENTRY. 
      CALL DB$COUT TO PUT SUCCESSFUL COMPLETION STATISTICS ON OUTPUT. 
      SET ITEMS IN COMMON WHICH INDICATE SUCCESSFUL BUILDING OF A CST.
      RETURN.  IF ALL WENT OK, A NEW CST IS IN THE MASTER DIRECTORY.
 #
        CONTROL EJECT;
  
        BEGIN                # DB$CBLD #
  
        XDEF LABEL DB$CBLE;  # XDEF SO DB$CERR CAN JUMP INTO DB$CBLD #
  
# THE FOLLOWING ARE EXTERNALLY REFERENCED PROCS, FUNCTIONS AND ARRAYS#
  
        XREF PROC DB$CARE;   # BUILD AN AREA WORK BLOCK IN CORE # 
        XREF PROC DB$CBEG;   # BEGIN BY CHECKING FOR SUFFICIENT CORE #
        XREF PROC DB$CCHK;   # COMPARE MD AND (SUB)SCHEMA CHECKSUMS # 
        XREF PROC DB$CCLS;   # CLOSE THE SUBSCHEMA AND SCHEMA FILES # 
        XREF PROC DB$CCON;   # BUILD A CONSTRAINT WORK BLOCK IN CORE #
        XREF PROC DB$CCPP;   # PREPROCESS FOR CONSTRAINT INFORMATION #
        XREF PROC DB$CECM;   # ERROR HANDLER FOR CMM OVERFLOW ACTION #
        XREF PROC DB$CEND;   # END BY WRITING NON-WORK-BLOCK PARTS #
        XREF PROC DB$CERR;   # ERROR HANDLER FOR FATAL ERRORS # 
        XREF FUNC DB$CFIL C(30);       # BLANK OR ZERO CHARACTER FILL#
        XREF PROC DB$COPN;   # OPEN THE SUBSCHEMA AND SCHEMA FILES #
        XREF PROC DB$COUT;   # PUT SUCCESSFUL STATISTICS ON OUTPUT #
        XREF PROC DB$CPRE;   # PREPARE TO BUILD WORK BLOCKS IN CORE # 
        XREF PROC DB$CREC;   # BUILD A RECORD WORK BLOCK IN CORE #
        XREF PROC DB$CREL;   # BUILD A RELATION WORK BLOCK IN CORE #
        XREF PROC DB$MDOE;   # DELETE CMM OVERFLOW-ACTION STACK ENTRY#
        XREF FUNC DB$MPOE U; # PUSH A CMM OVERFLOW-ACTION STACK ENTRY#
        XREF PROC DB$UALC;   # ALLOCATE A MANAGED MEMORY BLOCK #
        XREF PROC DB$UAWS;   # ADJUST MANAGED MEMORY BLOCK WORK SPACE#
        XREF PROC DB$UFRE;   # FREE A MANAGED MEMORY BLOCK IN CORE #
        XREF PROC SECOND;    # FORTRAN LIBRARY SUBPROGRAM FOR CP TIME#
        XREF ARRAY DB$RA0;;  # COMPASS ENTRY POINT AT ADDRESS RA + 0 #
  
        CONTROL NOLIST;      #UTCDFDCLS UTCITDCLS UTMPTDCLS UTMPCDCLS#
*CALL UTMPCDCLS 
        CONTROL LIST;        # RESUME THE LISTING OF THE SOURCE CODE #
  
# THE FOLLOWING ITEM IS LOCAL TO DB$CBLD #
  
        ITEM LIMIT I;        # A GENERAL LIMIT FOR USE WITH FOR LOOPS#
        CONTROL EJECT;
  
# INITIALIZE COMMON ITEMS WHICH SHOULD BE INITIALIZED IMMEDIATELY # 
  
        XCALL SECOND(OUTTIME,DB$RA0);  # CP TIME USED PUT IN OUTTIME #
        PCCAPLNG[0] = 0;     # CST MAPPING CAPSULE TABLE WORD LENGTH #
        PCSBCKSM[0] = 0;     # CHECKSUM OF THE SUBSCHEMA DIRECTORY #
        PCSBDATE[0] = 0;     # JULIAN DATE OF CREATION OF SUBSCHEMA # 
        PCSBTIME[0] = 0;     # TIME OF CREATION OF THE SUBSCHEMA #
        PCSIZCST[0] = 0;     # CST WD LENGTH EXCLUDING CAPSULE TABLE #
        PCSTATWD[0] = 0;     # RETURN ERROR STATUS - 0 FOR NO ERROR # 
        CALPOINT = 0;        # CONSTRAINT AREA LIST BLOCK POINTER WRD#
        CHKSMBP = 0;         # CURRENT CHECKSUM LIST BLOCK POINTER WD#
        CITPOINT = 0;        # CONSTRAINT INTEGRITY TABLE BLCK POINTR#
        CURCMMID = 0;        # CURRENT CMM OVERFLOW-ACTION ENTRY ID # 
        CURIDENT = 0;        # CURRENT MASTER DIRECTORY IDENTIFIER #
        CURNAME = " ";       # CURRENT DATA BASE ELEMENT NAME - NONE #
        CURORDNL = 0;        # CURRENT WORK BLOCK ORDINAL - 0 = NONE #
        CURSCRAT = " ";      # CURRENT SCRATCH USE NAME # 
        CURTYPE = 0;         # CURRENT DATA BASE ELEMENT TYPE - NONE #
        EXTPOINT = 0;        # EXTENSION BLOCK MANAGED MEMORY POINTER#
        LENTHCST = 0;        # WORD LENGTH OF THE CST IN THE MAST DIR#
        MASWAARE = PCWAAREA[0];        # MASTER DIRECT WA OF AREA DIR#
        MASWACST = PCWACST[0];         # MASTER DIRECT WA OF NEW CST #
        NAMESCHE = DB$CFIL(PCSCNAME[0],DFNAMECH," ");      # " "-FILL#
        NAMESUBS = DB$CFIL(PCSBNAME[0],DFNAMECH," ");      # " "-FILL#
        OVERFERR = LOC(DB$CERR);       # OVERFLOW ERROR-HANDLING PROC#
        OVERFLOW = FALSE;    # MEMORY OVERFLOW NOT DAMAGING TO BLOCKS#
        PLOPOINT = 0;        # PRIVACY LOCK TABLE BLOCK POINTER WORD #
        POPPOINT = 0;        # PROC OPTION TABLE BLOCK POINTER WORD # 
        SCHPOINT = 0;        # SCHEMA BLOCK MANAGED MEMORY POINTER WD#
        SCIDENT = PCSCIDNT[0];         # MASTER DIRECT SCHEMA IDENTIF#
        STATMAST = 1;        # MASTER DIRECTORY FILE STATUS - 1 = OK #
        STATSCHE = 1;        # SCHEMA DIRECTORY FILE STATUS - UNOPEN #
        STATSUBS = 1;        # SUBSCHEMA DIRECTORY FILE STATUS UNOPEN#
        SUBPOINT = 0;        # SUBSCHEMA BLOCK MANAGED MEMORY POINTER#
        WORPOINT = 0;        # WORK BLOCK MAIN BLOCK POINTER WORD # 
  
# PUSH OVERFLOW ENTRY. OPEN DDL DIRECTORIES. BEGIN BY CHECKING CORE. #
  
        CURCMMID = DB$MPOE(DFTRIGLV,DFTRIGWD,DB$CECM);     # PUSH # 
        XCALL DB$COPN(PCSBLFN[0],PCSCLFN[0],PCSCDATE[0],PCSCTIME[0]); 
        XCALL DB$CBEG;       # BEGIN BY CHECKING FOR SUFFICIENT CORE #
  
# CALL DB$UALC ONCE FOR EACH MANAGED MEMORY BLOCK TO BE ALLOCATED # 
  
        XCALL DB$UALC(LOC(SCHPOINT),SCMAXENT,0); # SCHEMA WSA BLOCK # 
        XCALL DB$UALC(LOC(SUBPOINT),SBMAXENT,0); # SUBSCHEMA BLOCK #
        XCALL DB$UALC(LOC(CHKSMBP),0,DFPRUSIZ);  # CURR CHECKSUM LIST#
        XCALL DB$UALC(LOC(EXTPOINT),MASSZARE,0); # EXTENSION BLOCK #
        XCALL DB$UALC(LOC(CALPOINT),0,DFPRUSIZ); # CONSTRNT AREA LIST#
        XCALL DB$UALC(LOC(CITPOINT),0,DFPRUSIZ); # CONSTR INTEG TABLE#
        XCALL DB$UALC(LOC(PLOPOINT),0,DFPRUSIZ); # PRIVACY LOCK TABLE # 
        XCALL DB$UALC(LOC(POPPOINT),0,DFPRUSIZ); # PROC OPTION TABLE #
        XCALL DB$UALC(LOC(WORPOINT),0,DFPRUSIZ); # WORK BLOCK MAIN #
        CONTROL EJECT;
  
# CALL DB$CCHK TO COMPARE CHECKSUMS IN THE MD, SCHEMA, AND SUBSCHEMA #
  
        XCALL DB$CCHK;       # COMPARE MD AND (SUB)SCHEMA CHECKSUMS # 
  
# CALL DB$CPRE TO PREPARE TO BUILD WORK BLOCKS BY INITIALIZING #
  
        XCALL DB$CPRE;       # PREPARE TO BUILD WORK BLOCKS IN CORE # 
  
# IF SCHEMA HAS CONSTRAINTS, CALL DB$CCPP TO PREPROCESS CONSTRAINTS # 
  
        IF SCNUMCON GR 0     # IF THE SCHEMA HAS CONSTRAINT ENTRIES # 
          THEN               # CONSTRAINT PREPROCESSING MUST BE DONE #
            BEGIN 
              CURTYPE = 7;   # BASIC AREA DURING CONSTR PREPROCESSING#
              SBCURRAD = 0;  # SUBSCHEMA CURRENT MAIN ENTRY ADDRESS # 
              SBNEXTAD = SBFWADDR + SBFIRARE;    # SUBSCHEMA 1ST AREA#
              XCALL DB$CCPP; # PREPROCESS FOR CONSTRAINT INFORMATION #
            END 
  
# CALL DB$CARE ONCE FOR EACH AREA WORK BLOCK TO BE BUILT IN CORE #
  
        CURTYPE = 1;                   # CURRENT TYPE IS BASIC AREA # 
        SBCURRAD = 0;                  # SUBSCHEMA CURRENT ADDRESS #
        SBNEXTAD = SBFWADDR + SBFIRARE;          # SUBSCHEMA 1ST AREA#
        FOR CURORDNL = 1 THRU SBNUMARE DO XCALL DB$CARE;   # BASIC #
        CURTYPE = 5;                   # CURRENT TYPE - EXTENDED AREA#
        LIMIT = SBNUMARE + CONNBEXA;   # BASIC AREAS + EXTENDED AREAS#
        FOR CURORDNL = SBNUMARE + 1 THRU LIMIT DO XCALL DB$CARE;
        CURIDENT = 0;        # CURRENT MASTER DIRECTORY IDENTIFIER #
        CURTYPE = 0;         # CURRENT DATA BASE ELEMENT TYPE - NONE #
        LENTOREC = LENTHCST; # WORD LENGTH TO FIRST RECORD WORK BLOCK#
  
# CALL DB$UAWS ONCE FOR EACH BLOCK WHOSE WORK SPACE IS TO BE ADJUSTED#
  
        XCALL DB$UAWS(LOC(EXTPOINT),-MASSZARE);  # EXTENSION BLOCK #
        IF CONSTNUM GR 0                         # CONSTRNT AREA LIST#
          THEN XCALL DB$UAWS(LOC(CALPOINT),-(SBNUMARE + CONNBEXA)); 
  
# CALL DB$CREC ONCE FOR EACH RECORD WORK BLOCK TO BE BUILT IN CORE #
  
        CURTYPE = 2;         # CURRENT DATA BASE ELEMENT TYPE IS REC #
        SBNEXTAD = SBFWADDR + SBFIRREC;          # SUBSCHEMA 1ST REC #
        FOR CURORDNL = 1 THRU SBNUMREC DO XCALL DB$CREC;   # RECORDS #
        LENTOREL = LENTHCST; # WORD LENGTH TO 1ST RELATION WORK BLOCK#
  
# CALL DB$CREL ONCE FOR EACH RELATION WORK BLOCK TO BE BUILT IN CORE #
  
        CURTYPE = 4;         # CURRENT DATA BASE ELEMENT TYPE IS REL #
        SBNEXTAD = SBFWADDR + SBFIRREL;          # SUBSCHEMA 1ST REL #
        FOR CURORDNL = 1 THRU SBNUMREL DO XCALL DB$CREL;   # RELATION#
        LENTOCON = LENTHCST; # WORD LENGTH TO CONSTRAINT WORK BLOCK 1#
  
# CALL DB$CCON ONCE FOR EACH CONSTRAINT WORK BLOCK TO BE BUILT #
  
        CURTYPE = 6;                   # CURRENT TYPE IS CONSTRAINT # 
        FOR CURORDNL = 1 THRU CONSTNUM DO XCALL DB$CCON;   # CONSTRNT#
        CURNAME = " ";       # CURRENT DATA BASE ELEMENT NAME - NONE #
        CURORDNL = 0;        # CURRENT WORK BLOCK ORDINAL - 0 = NONE #
        CURSCRAT = " ";      # CURRENT SCRATCH USE NAME # 
        CURTYPE = 0;         # CURRENT DATA BASE ELEMENT TYPE - NONE #
        LENTOOPT = LENTHCST; # WORD LENGTH TO PROCEDURE OPTION TABLE #
  
# CALL DB$CEND TO END CST BUILDING BY WRITING FURTHER CST PARTS TO MD#
  
        XCALL DB$CEND;       # END BY WRITING NON-WORK-BLOCK PARTS #
  
# CALL DB$UFRE ONCE FOR EACH MANAGED MEMORY BLOCK IN CORE TO BE FREED#
  
        XCALL DB$UFRE(LOC(SCHPOINT));  # FREE SCHEMA WSA MEMORY BLOCK#
        XCALL DB$UFRE(LOC(SUBPOINT));  # FREE SUBSCHEMA MEMORY BLOCK #
        XCALL DB$UFRE(LOC(CHKSMBP));   # FREE CURR CHECKSUM LIST WSA #
        XCALL DB$UFRE(LOC(EXTPOINT));  # FREE EXTENSION MEMORY BLOCK #
        XCALL DB$UFRE(LOC(CALPOINT));  # FREE CONSTRNT AREA LIST WSA #
        XCALL DB$UFRE(LOC(CITPOINT));  # FREE CONSTR INTEG TABLE WSA #
        XCALL DB$UFRE(LOC(PLOPOINT));  # FREE PRIVACY LOCK TABLE WSA #
        XCALL DB$UFRE(LOC(POPPOINT));  # FREE PROC OPTION TABLE BLOCK#
        XCALL DB$UFRE(LOC(WORPOINT));  # FREE WORK BLOCK MAIN BLOCK # 
  
# CLOSE DDL DIRECTORIES, DELETE OVERFLOW ENTRY, AND OUTPUT STATISTICS#
  
        XCALL DB$CCLS;       # CLOSE THE SUBSCHEMA AND SCHEMA FILES # 
        XCALL DB$MDOE(CURCMMID);       # DELETE OVERFLOW-ACTION ENTRY#
        CURCMMID = 0;        # CURRENT CMM OVERFLOW-ACTION ENTRY ID # 
        OVERFERR = 0;        # NO OVERFLOW ERROR SPECIAL PROC ADDRESS#
        OVERFLOW = FALSE;    # MEMORY OVERFLOW NOT DAMAGING TO BLOCKS#
        XCALL DB$COUT;       # PUT SUCCESSFUL STATISTICS ON OUTPUT #
  
# SET ITEMS IN COMMON WHICH INDICATE SUCCESSFUL BUILDING OF A NEW CST#
  
        PCCAPLNG[0] = LENTHCST - LENTOCAP;       # CAPSULE TABLE SIZE#
        PCSBCKSM[0] = SBCHKSUM;        # SUBSCHEMA DIRECTORY CHECKSUM#
        PCSBDATE[0] = SBJULIAN;        # SUBSCHEMA CREATE JULIAN DATE#
        PCSBTIME[0] = SBTIME;          # SUBSCHEMA TIME OF CREATION # 
        PCSIZCST[0] = LENTOCAP;        # CST SIZE EXCEPT CAPSULE TABL#
  
# PROC DB$CERR GOES TO THE LABEL DB$CBLE FOR A FATAL ERROR RETURN # 
  
        DB$CBLE: RETURN;     # CST IS BUILT OR FATAL ERROR WAS FOUND #
  
        END                  # DB$CBLD #
  
      TERM
