*DECK DB$SR18 
USETEXT UTMPTTX 
USETEXT MD10CTX 
USETEXT MDBCMTX 
  PROC DB$SR18; 
    BEGIN 
 #
* *   DB$SR18 - INITIALIZE FOR RESTART MOD RUN   PAGE  1
* *   M. D. SAXE                                 DATE  03/23/76 
* *   A W LO                                     DATE 3/31/77 
* *   J. G. SERPA                                DATE  07/25/80 
  
  DC  PURPOSE 
  
      TO READ FROM THE OLD MD THE SCHEMA INFORMATION, AREA DIRECTORY, 
      AREA INFORMATION, VERSION DIRECTORY, VERSION INFORMATION, DATABASE
      PROCEDURE LIST, PERMANENT FILE INFORMATION (PIT), SUBSCHEMA/CST 
      DIRECTORY, CHECKSUM LIST, CONSTRAINT USE AND KEY INFORMATION
      TABLES. 
  
  DC  ENTRY CONDITIONS
  
      NAME OF THE SCHEMA TO BE MODIFIED MUST BE STORED IN SCHNAME.
  
  DC  EXIT CONDITIONS 
  
      THE SCHEMA INFORMATION, AREA DIRECTORY, AREA INFORMATION, VERSION 
      DIRECTORY, VERSION INFORMATION, DATABASE PROCEDURE LIST, PERMANENT
      FILE INFORMATION (PIT), SUBSCHEMA/CST DIRECTORY AND CHECKSUM
      LIST, KEY INFORMATION AND CONSTRAINT USE TABLES OF THE SCHEMA 
      BEING MODIFIED ARE READ FROM THE OLD MD INTO MEMORY.
  
  DC  CALLING ROUTINES
  
      DB$STD - SYNTAX TABLE DRIVER
  
  DC  CALLED ROUTINES 
  
 #
      XREF
        BEGIN 
 #                                                                     #
        PROC DB$DIAG;        # DIAGNOSTIC PROCESSOR                    #
        PROC DB$EROD;        # ERROR PROC FOR OLD MD CRM ERRORS        #
        PROC DB$FTOD;        # FIT FOR THE OLD MASTER DIRECTORY        #
        FUNC DB$MDSC;        # RETURNS SCHEMA DIRECTORY ENTRY          #
                             # OFFSET IN SCHEMA DIRECTORY              #
        PROC DB$NO;          # STD NO RETURN                           #
        PROC DB$UALC;        # ALLOCATE A CMM BLOCK                    #
        PROC DB$UAWS;        # ADJUSTS BLOCKS OF MEMORY                #
        PROC DB$WGET;        # GET FROM WORD ADDRESSABLE FILE          #
        PROC DB$YES;         # STD YES RETURN                          #
 #                                                                     #
        END 
 #
  
  DC  NON-LOCAL VARIABLES 
  
 #
  
      BASED ARRAY MDSCENTRY [0] S;
        BEGIN 
*CALL MDSCDDCLS 
        END 
  
      BASED ARRAY DBPROC [0:0] S(1);;  # DATA BASE PROCEDURE TABLE     #
  
      BASED ARRAY ARDIR [0:0] S(1);;   # AREA DIRECTORY TABLE          #
  
      BASED ARRAY ARINFO [0:0] S(1);;  # AREA INFORMATION TABLE        #
  
      BASED ARRAY CSTSSTBL S(1); # SUB-SCHEMA DIRECTORY                #
        BEGIN 
*CALL MDSBDDCLS 
        END 
  
      BASED ARRAY KEYINFOT [0:0] S(1);;  # KEY INFORMATION TABLE       #
  
      BASED ARRAY MDCUT [0:0] S(1);;     # CONSTRAINT USE TABLE        #
  
      BASED ARRAY VERINFO [0:0] S(1);;  # VERSION INFORMATION TABLE    #
  
      BASED ARRAY VERSDIR [0:0] S(1);;  # VERSION DIRECTORY TABLE      #
  
  
#     LOCAL ITEMS                                                      #
  
      ITEM MDTBLWA;          # TEMPORARY CELL THAT CONTAINS THE        #
                             # BEGINNING WORD ADDRESS FOR A READ OF A  #
                             # WORD ADDRESSABLE FILE.                  #
      ITEM OFFSET;           # TABLE OFFSET FOR PARTIAL READ, USED FOR #
                             # TABLE LENGTH CONTROLLED (TLC) TABLES    #
      ITEM PTLSIZE;          # SIZE OF PARTIAL READ                    #
  
      ITEM SCDROS;           # OFFSET OF THE SCHEMA DIRECTORY ENTRY    #
                             # (SCHEMA BEING PROCESSED)                #
      ITEM TBLESIZE;         # TEMPORARY CELL THAT CONTAINS THE NUMBER #
                             # WORDS TO BE READ (DB$WGET).             #
      ITEM VERSIZE;          # VERSION SIZE                            #
  
  
  
  
#     B E G I N   D B $ S R 1 8   E X E C U T A B L E   C O D E .      #
  
  
 #
  
 DC   DESCRIPTION 
  
      PRESET -DB PROC LIST FOUND- FLAG
 #
      DBPRFLG = FALSE;
 #
      STORE THE OFFSET OF THE SCHEMA DIRECTORY ENTRY OF THE 
      SCHEMA TO BE MODIFIED. FUNCTION DB$MDSC IS USED TO PASS BACK THE
      OFFSET. 
 #
      SCDROS = DB$MDSC; 
 #
      CHECK TO SEE IF AN OFFSET WAS PASSED BACK. IF NEGATIVE THE SOUGHT 
      AFTER SCHEMA DIRECTORY WAS NOT FOUND. 
 #
      IF SCDROS LS 0 THEN 
        BEGIN 
          DB$DIAG(115,SCHNAME);        # ISSUE A DIAGNOSTIC MESSAGE # 
          SCFATAL = 1;
          DB$NO;
        END 
 #
      POINT THE SCHEMA DIRECTORY BASED ARRAY TO THE FIRST ENTRY IN THE
      SCHEMA DIRECTORY. 
 #
      P<MDSCENTRY> = SCDRBP + 1;
 #
      IF SCHEMA IS ALREADY WRITTEN TO NEW MD, ISSUE DIAGNOSTIC
      MESSAGE AND SET FATAL ERROR FLAG. 
 #
      IF MDSCWRTFLG[SCDROS] 
      THEN
        BEGIN 
        DB$DIAG(148,SCHNAME); 
        SCFATAL = 1;
        DB$NO;
        END 
 #
      READ THE SCHEMA INFORMATION TABLE INTO WSA IN COMMON. 
 #
      P<MDSCENTRY> = SCDRBP + 1;
      DB$WGET 
         (DB$FTOD,MDSCINFO,MDSCSISZ[SCDROS],MDSCWASC[SCDROS],DB$EROD);
 #
      READ THE AREA DIRECTORY TABLE INTO MANAGED MEMORY.
 #
      P<MDSCENTRY> = SCDRBP + 1;    # POSITION SCHEMA DIRECTORY TABLE  #
      NBRAFTIMG = MDSCNBAFTIM[SCDROS];  # NBR OF AFTER IMAGE RECORDS   #
      TBLESIZE = MDSCADSZ[SCDROS];  # LENGTH OF AREA DIRECTORY TABLE   #
      MDTBLWA = MDSCWAAD[SCDROS];   # WORD ADDRESS OF AREA DIRECTORY   #
 #
      ADJUST WORK SPACE FOR AREA DIRECTORY TABLE. 
 #
      DB$UAWS(LOC(ARDIRBP),TBLESIZE); 
      P<ARDIR> = ARDIRBP + 1;      # POSITION AREA DIRECTORY TABLE    # 
      DB$WGET(DB$FTOD,ARDIR,TBLESIZE,MDTBLWA,DB$EROD);  # READ ADT     #
 #
      READ THE AREA INFORMATION TABLE INTO MANAGED MEMRORY. 
 #
      P<MDSCENTRY> = SCDRBP + 1;      # POSITION SCHEMA DIRECTORY      #
      MDTBLWA = MDTBLWA + TBLESIZE;   # WA OF AREA INFORMATION TABLE   #
      TBLESIZE = MDSCAISZ[SCDROS];    # LENGTH OF AREA INFORMATION     #
 #
      ADJUST WORK SPACE FOR AREA INFORMATION TABLE. 
 #
      DB$UAWS(LOC(ARINFOBP),TBLESIZE);
      P<ARINFO> = ARINFOBP + 1;      # POSITION AREA DIRECTORY TABLE   #
      DB$WGET(DB$FTOD,ARINFO,TBLESIZE,MDTBLWA,DB$EROD); 
 #
      READ IN THE VERSION DIRECTORY TABLE (VDT).
      POINT THE VDT TO THE APPROPRIATE BLOCK OF MANAGED MEMORY. 
 #
      P<MDSCENTRY> = SCDRBP + 1;
      VERSCNT = MDSCNOVER[SCDROS];      # NUMBER OF VERSIONS           #
      TBLESIZE = VERSCNT * DFMDVDEN;    # LENGTH OF THE VDT            #
      MDTBLWA = MDSCWAVD[SCDROS];      # WA OF VDT                     #
      DB$UAWS(LOC(VERDIRBP),TBLESIZE);  # ADJUST SIZE OF BLOCK FOR VDT #
      P<VERSDIR> = VERDIRBP + 1;
      DB$WGET(DB$FTOD,VERSDIR,TBLESIZE,MDTBLWA,DB$EROD);  # READ IN VDT#
 #
      READ IN THE VERSION INFORMATION TABLE (VIT).
      POINT THE VIT TO THE APPROPRIATE BLOCK OF MANAGED MEMORY. 
 #
      P<MDSCENTRY> = SCDRBP + 1;
      MDTBLWA = MDSCWAVD[SCDROS] + MDSCNOVER[SCDROS];   # WA OF VIT    #
      VERSIZE = MDSCNBARS[SCDROS] * DFMDVIEN; 
      TBLESIZE = MDSCNOVER[SCDROS] * VERSIZE; 
  
      PTLSIZE = TBLESIZE;                # PARTIAL SIZE IS FULL SIZE   #
      P<TLC> = B<42,18>VERINFBP;
      TLCUSED[0] = 0; 
      TLCPAD[0] = DFTLCPAD; 
                                   # RECOMPUTE THE TABLE LIMITS        #
  
                                         # DISK SEGMENT WORD LENGTH    #
      TLCDSWL[0] = ((DFTLCTMAX / (VERSIZE *2)) +1) * VERSIZE; 
  
                                         # BUILD SEGMENT BEGINNING WORD#
      TLCBSBW[0] = TLCDSWL[0] +DFVITHDR;
  
                                         # MAXIMUM TABLE LENGTH        #
      TLCTMXL[0] = TLCBSBW[0] + TLCDSWL[0]; 
  
      OFFSET = 0;                        # TLC OFFSET FOR FIRST READ   #
      IF PTLSIZE GR TLCTMXL[0]
      THEN                               # TABLE IS TOO LARGE TO FIT   #
        BEGIN 
        PTLSIZE = TLCTMXL[0];            # REDUCE THE PARTIAL SIZE     #
        END 
      FOR TBLESIZE = TBLESIZE - PTLSIZE STEP - PTLSIZE UNTIL 0
      DO
        BEGIN 
  
        DB$UAWS(LOC(VERINFBP),PTLSIZE);       # ALLOCATE MAXIMUM TABLE #
                                              # OR A NEW SEGMENT BLOCK #
        P<VERINFO> = LOC(TLC) + TLCHLEN[0] + OFFSET;
        DB$WGET(DB$FTOD,VERINFO,PTLSIZE,MDTBLWA,DB$EROD); 
        MDTBLWA = MDTBLWA + PTLSIZE;
        PTLSIZE = TLCTMXL[0] - TLCBSBW[0];
        IF PTLSIZE GR TBLESIZE
          AND TBLESIZE GR 0 
        THEN
          BEGIN 
          PTLSIZE = TBLESIZE; 
          END 
        OFFSET = TLCBSBW[0];
        END 
  
      TLCPAD[0] = DFVITPD;         # RESTORE VIT PAD SIZE              #
 #
      READ IN THE PERMANENT FILE INFORMATION TABLE (PIT). 
      POINT THE PIT TO THE APPROPRIATE BLOCK OF MANAGED MEMORY. 
 #
      P<MDSCENTRY> = SCDRBP + 1;
      TBLESIZE = MDSCPITSZ[SCDROS]       # LENGTH OF PIT               #
                 +  MDSCPITSX[SCDROS] * 2**18;
  
      MDTBLWA = MDSCWAPIT[SCDROS];       # WA OF PIT                   #
  
      PTLSIZE = TBLESIZE;                # PARTIAL SIZE IS FULL SIZE   #
      P<TLC> = B<42,18>PITBP; 
      TLCUSED[0] = 0; 
      TLCPAD[0] = DFTLCPAD; 
      OFFSET = 0;                        # TLC OFFSET FOR FIRST READ   #
      IF PTLSIZE GR TLCTMXL[0]
      THEN                               # TABLE IS TOO LARGE TO FIT   #
        BEGIN 
        PTLSIZE = TLCTMXL[0];            # REDUCE THE PARTIAL SIZE     #
        END 
      FOR TBLESIZE = TBLESIZE - PTLSIZE STEP - PTLSIZE UNTIL 0
      DO
        BEGIN 
  
        DB$UAWS(LOC(PITBP),PTLSIZE);          # ALLOCATE MAXIMUM TABLE #
                                              # OR A NEW SEGMENT BLOCK #
        P<PFINFO> = LOC(TLC) + TLCHLEN[0] + OFFSET; 
        DB$WGET(DB$FTOD,PFINFO,PTLSIZE,MDTBLWA,DB$EROD);
        MDTBLWA = MDTBLWA + PTLSIZE;
        PTLSIZE = TLCTMXL[0] - TLCBSBW[0];
        IF PTLSIZE GR TBLESIZE
          AND TBLESIZE GR 0 
        THEN
          BEGIN 
          PTLSIZE = TBLESIZE; 
          END 
        OFFSET = TLCBSBW[0];
        END 
  
      TLCPAD[0] = DFPITPD;         # RESTORE PIT PAD SIZE              #
 #
      READ IN THE KEY INFORMATION TABLE (KIT).
      POINT THE KIT TO THE APPROPRIATE BLOCK OF MANAGED MEMORY. 
 #
      P<MDSCENTRY> = SCDRBP + 1;
      TBLESIZE = MDSCKITSZ[SCDROS];    # LENGTH OF KIT                 #
      MDTBLWA = MDSCKITWA[SCDROS];     # WA OF KIT                     #
      DB$UAWS(LOC(KEYINFOBP),TBLESIZE);  # ADJUST BLOCK FOR KIT        #
      P<KEYINFOT> = KEYINFOBP + 1;
      DB$WGET(DB$FTOD,KEYINFOT,TBLESIZE,MDTBLWA,DB$EROD);  #READ IN KIT#
 #
      CHECK IF CONSTRAINTS EXIST FOR THIS SCHEMA. IF THERE ARE
      CONSTRAINTS, ALLOCATE SPACE FOR THE CONSTRAINT USE TABLE, AND 
      THEN READ IT INTO CORE. 
 #
      P<MDSCENTRY> = SCDRBP + 1;
      TBLESIZE = MDSCCUTSZ[SCDROS];    # LENGTH OF CUT                 #
      IF TBLESIZE NQ 0                 # IF THE CUT SIZE IS NOT ZERO   #
      THEN
        BEGIN 
        MDTBLWA = MDSCCUTWA[SCDROS];   # WORD ADDRESS OF CUT           #
        IF CUTBP EQ 0                  # IF THE CUT NOT YET ALLOCATED  #
        THEN
          BEGIN 
          DB$UALC(LOC(CUTBP),TBLESIZE,0);  # ALLOCATE CUT              #
          END 
        ELSE
          BEGIN 
          DB$UAWS(LOC(CUTBP),TBLESIZE);    # ADJUST BLOCK SIZE         #
          END 
        P<MDCUT> = CUTBP + 1;          # POSITION CONSTRAINT USE TABLE #
        DB$WGET(DB$FTOD,MDCUT,TBLESIZE,MDTBLWA,DB$EROD); # READ IN CUT #
        END 
 #
      PREPARE TO READ IN CHECKSUM BLOCK BY DETERMINING WORDS NEEDED 
      AND ADJUSTING SPACE TO NEEDS
 #
      P<MDSCENTRY> = SCDRBP + 1;
      TBLESIZE = MDSCCSLSZ[SCDROS]; 
      MDTBLWA = MDSCCSLWA[SCDROS];
      DB$UAWS (LOC(MDCHKSMBP),TBLESIZE);
 #
      POINT THE B.ARRAY AND COPY CHECKSUM LIST INTO MEMORY. 
 #
      P<MDSCCKSUM> = B<42,18> MDCHKSMBP + 1;
      DB$WGET(DB$FTOD,MDSCCKSUM,TBLESIZE,MDTBLWA,DB$EROD);
 #
      PREPARE TO READ THE DATA BASE PROCEDURE LIST INTO MANAGED MEMORY. 
      STORE THE SIZE IN WORDS OF PROCEDURE LIST INTO A TEMPORARY CELL.
 #
      P<MDSCENTRY> = SCDRBP + 1;
      TBLESIZE = MDSCDPSZ[SCDROS];
  
 #
      IF DBP TABLE EXISTS THEN
 #
  
      IF TBLESIZE - DFMDDPCW GR 0 THEN
        BEGIN 
 #
      SET FLAG TO SHOW DB PROC LIB ENTRY WAS FOUND
 #
        DBPRFLG = TRUE; 
  
 #
      STORE WA OF DBP LIST IN TEMPORARY CELL
 #
  
        MDTBLWA = MDSCWADP[SCDROS]; 
  
 #
      STORE LENGTH OF DBP LIST LESS THE CONTROL WORDS IN TEMPORARY CELL 
 #
  
        TBLESIZE = TBLESIZE - DFMDDPCW; 
  
 #
      ADJUST WORK BLOCK SPACE OF DBP TABLE
 #
  
        DB$UAWS(LOC(DBPROCBP),TBLESIZE);
  
 #
      POINT BASED ARRAY BACK TO SCHEMA DIRECTORY
 #
  
        P<MDSCENTRY> = SCDRBP + 1;
        TBLESIZE = MDSCDPSZ[SCDROS];
        P<DBPROC> = DBPROCBP + 1; 
        DB$WGET(DB$FTOD,DBPROC,TBLESIZE,MDTBLWA,DB$EROD); 
      END 
 #
      PREPARE TO READ THE SUB-SCHEMA DIRECTORY INTO MANAGED MEMORY. 
  
      STORE THE LENGTH IN WORDS OF THE SUB-SCHEMA DIRECTORY INTO A
      TEMPORARY CELL. 
 #
      P<MDSCENTRY> = SCDRBP + 1;
      TBLESIZE = MDSCSSSZ[SCDROS];
 #
      STORE THE WORD ADDRESS OF THE SUB-SCHEMA DIRECTORY INTO A 
      TEMPORARY CELL. 
 #
      MDTBLWA = MDSCWASB[SCDROS]; 
 #
      ADJUST WORK SPACE OF MANAGED MEMORY BLOCK FOR SUBSCHEMA DIRECTORY 
 #
      DB$UAWS(LOC(CSTDIRBP),TBLESIZE);
 #
      POINT THE SUB-SCHEMA BASED ARRAY TO THE BLOCK OF CORE.
 #
      P<CSTSSTBL> = CSTDIRBP + 1; 
      P<MDSCENTRY> = SCDRBP + 1;
 #
      READ THE SUB-SCHEMA INTO CORE.
 #
      DB$WGET(DB$FTOD,CSTSSTBL,TBLESIZE,MDTBLWA,DB$EROD); 
 #
      RESET THE BASED ARRAYS. CRM CALL MAY OF CHANGED THE LOCATION OF 
      THE REQUESTED BLOCKS OF CORE. 
 #
 #
      INITIALIZE THE SUB-SCHEMA COUNTER 
 #
      CSTDCNT = MDSBNBSB[0];
      SCHDIRP = SCDROS; 
      AREACNT = MDSCNBARS[SCDROS];
 #
      STORE THE SCHEMA LFN SPECIFIED IN THE MOD CLAUSE INTO THE SCHEMA
      INFORMATION TABLE.
 #
      MDSISCLF[0] = FILENAM;
      FILENAM = 0;
      DB$YES; 
    END 
  TERM; 
