Google
 

Trailing-Edge - PDP-10 Archives - bb-bt99h-bb - ftn10.ctl
There are 2 other files named ftn10.ctl in the archive. Click here to see a list.
;
;   FTN10.CTL -- Patch and rebuild FORTRAN-10-V10
;   Version 1(1)
;
;	April 1985 /TGS
;1	February 24, 1986 /HAH add FORPRM and MTHHST to source deletion
 
;
;		    COPYRIGHT (c)  1985 BY
;	    Digital Equipment Corporation, Maynard, MA.
;
;   This software is furnished under a license and may be  used
;   and  copied  only  in  accordance  with  the  terms of such
;   license and with  the  inclusion  of  the  above  copyright
;   notice.   This software or any other copies thereof may not
;   be provided  or  otherwise	made  available  to  any  other
;   person.   No  title  to  and  ownership  of the software is
;   hereby transferred.
;
;   The information in	this  software	is  subject  to  change
;   without  notice and should not be construed as a commitment
;   by Digital Equipment Corporation.
;
;   Digital  assumes  no  responsibility   for	 the   use   or
;   reliability  of  its  software  on	equipment  which is not
;   supplied by Digital.
;
;
;   This .CTL  file  applies  the  patches  to the  modules  of
;   FORTRAN-10-V10 and rebuilds the Fortran Compiler, FORLIB.REL,
;   FORO10.EXE and FORDDT.REL.
;
;   For this .CTL file to run, the connected directory must  be
;   the patching directory (Logical name PAT:).
;
;   NOTE: If the dummy file FTNDBM.FLG is present on PAT:, this
;   .CTL file will build FORTRAN-10 with DBMS.
;


START::

.R PEPB
*INITIALIZE FORTRAN-10-V10
*EXIT
;

.PA REL:=ASL:

;
;	Delete any source modules that may be left in PAT:
;

.DELETE PAT:BLIO.BLI,PAT:BUILD.BLI,PAT:DEFLT.BLI,PAT:ERROR0.BLI,PAT:ERROVA.BLI
.DELETE PAT:ERROVB.BLI,PAT:ERROVC.BLI,PAT:ERROVD.BLI,PAT:ERROVG.BLI
.DELETE PAT:ERROVR.BLI,PAT:ERRTB3.MAC,PAT:F72BNF.SYN,PAT:FMTLEX.BLI
.DELETE PAT:FRMBNF.SYN,PAT:LEFT72.BLI,PAT:LEFTFM.BLI,PAT:NUMIO1.BLI
.DELETE PAT:OUTZ.BLI,PAT:OWNDM.MAC,PAT:QTAB1.MAC,PAT:SCAN0.BLI,PAT:SCNR.BLI
.DELETE PAT:TBL.BLI,PAT:TRACE1.BLI,PAT:ACT0.BLI,PAT:ACT1.BLI,PAT:ALCBLO.BLI
.DELETE PAT:ARRXPN.BLI,PAT:ASHELP.BLI,PAT:CANNON.BLI,PAT:CGDO.BLI
.DELETE PAT:CGEXPR.BLI,PAT:CGSTMN.BLI,PAT:CMPBLO.BLI,PAT:CMPLEX.BLI
.DELETE PAT:CNSTCM.MAC,PAT:CODETA.BLI,PAT:COMMAN.MAC,PAT:COMSUB.BLI
.DELETE PAT:DATAST.BLI,PAT:DEBUG.BLI,PAT:DEFPT.BLI,PAT:DGCMN.MAC
.DELETE PAT:DNPT.MAC,PAT:DOPT.MAC,PAT:DOALC.BLI,PAT:DOXPN.BLI,PAT:DRIVER.BLI
.DELETE PAT:ERR3.MAC,PAT:ERROUT.BLI,PAT:EXOSUP.MAC,PAT:EXPRES.BLI
.DELETE PAT:FAZ1.BLI,PAT:FDDT.MAC,PAT:FIRST.BLI,PAT:FLTGEN.MAC,PAT:FORMAT.BLI
.DELETE PAT:GCMNSB.BLI,PAT:GFOPDF.MAC,PAT:GLOBAL.BLI,PAT:GNRCFN.BLI
.DELETE PAT:GOPT2.BLI,PAT:GOPTIM.BLI,PAT:GRAPH.BLI,PAT:INOUT.BLI,PAT:INPT.BLI
.DELETE PAT:IOFLG.BLI,PAT:IOPT.BLI,PAT:JOBD.MAC,PAT:LEXAID.BLI,PAT:LEXICA.BLI
.DELETE PAT:LEXNAM.BLI,PAT:LEXSUP.BLI,PAT:LISTNG.BLI,PAT:LISTOU.BLI,LEXCLA.BLI
.DELETE PAT:MAIN.BLI,PAT:MEMCMP.BLI,PAT:MOVA.BLI,PAT:OPGNTA.MAC,PAT:OPTAB.BLI
.DELETE PAT:OPTMAC.BLI,PAT:OUTMOD.BLI,PAT:P2S1.BLI,PAT:P2S2.BLI,PAT:P3R.BLI
.DELETE PAT:PEEPOP.BLI,PAT:PH2S.BLI,PAT:PH3G.BLI,PAT:PHA2.BLI,PAT:PHA3.BLI
.DELETE PAT:PNROPT.BLI,PAT:REGAL2.BLI,PAT:REGUTL.BLI,PAT:RELBUF.BLI
.DELETE PAT:REQREL.BLI,PAT:REVHST.MAC,PAT:SKSTMN.BLI,PAT:SRCA.BLI,PAT:STA0.BLI
.DELETE PAT:STA1.BLI,PAT:STA2.BLI,PAT:STA3.BLI,PAT:STREGA.BLI,PAT:TABLES.BLI
.DELETE PAT:TSTR.BLI,PAT:UNEND.BLI,PAT:UTIL.BLI,PAT:VER5.BLI,PAT:VLTPPR.BLI
.DELETE PAT:FORDDT.MAC
.DELETE FORBOT.MAC,FORCNV.MAC,FORCOM.MAC,FORCHR.MAC,FORDBM.MAC
.DELETE FORDST.MAC,FORDUM.MAC,FORERR.MAC,FORFMT.MAC,FORHST.MAC
.DELETE FORINI.MAC,FORIO.MAC,FORMEM.MAC,FORMSC.MAC,FORMSG.MAC
.DELETE FORNML.MAC,FOROP.MAC,FOROPN.MAC,FOROTS.MAC,FORPSE.MAC
.DELETE FORPL2.MAC,FORRMS.MAC,FORRTF.MAC,FORSRT.MAC,FORXIT.MAC
.DELETE FORPL1.FOR,MTHTRP.MAC,MTHSNG.MAC,MTHDBL.MAC
.DELETE MTHGDB.MAC,MTHCPX.MAC,MTHCDX.MAC,MTHCGX.MAC,MTHMSG.MAC
.DELETE MTHDUM.MAC,MTHARG.MAC,MTHCNV.MAC,FDBML5.MAC,FDBMH5.MAC
.DELETE PAT:FORPRM.MAC,PAT:MTHHST.MAC

.PATH UNV:=ASL:
.PATH ASL:/SEARCH

;
;	Apply patches to the source modules
;

.TYPE PAT:FTN10.SUP

.R ASL:UPDATE
*@PAT:FTN10.SUP


BUILC::

;
; Make sure any REQUIRE files are on the patching directory
;

.COPY =ASL:F72BNF.SYN
.COPY =ASL:FRMBNF.SYN
.COPY =ASL:LOOK72.BLI
.COPY =ASL:LOOKFM.BLI
.COPY =ASL:ASHELP.BLI
.COPY =ASL:FIRST.BLI
.COPY =ASL:FMTLEX.BLI
.COPY =ASL:IOFLG.BLI
.COPY =ASL:LEXAID.BLI
.COPY =ASL:LEXNAM.BLI
.COPY =ASL:OPTMAC.BLI
.COPY =ASL:REQREL.BLI
.COPY =ASL:TABLES.BLI


;	FIRST BUILD THE SYNTAX TABLE BUILDERS AND SYNTAX TABLES



;	COMPILE AND LOAD THE TABLE BUILDING PROGRAM.

.R ASL:BLIS10
*BUILD=ASL:BUILD.BLI

;	COMPILE ALL I/O UTILITIES.

.R ASL:MACRO
*ERRTB3=ASL:ERRTB3.MAC
*QTAB1=ASL:QTAB1.MAC

.R ASL:BLIS10
*BLIO=ASL:BLIO.BLI
*DEFLT=ASL:DEFLT.BLI
*ERROR0=ASL:ERROR0.BLI
*NUMIO1=ASL:NUMIO1.BLI
*OUTZ=ASL:OUTZ.BLI
*SCAN0=ASL:SCAN0.BLI
*SCNR=ASL:SCNR.BLI
*TBL=ASL:TBL.BLI
*TRACE1=ASL:TRACE1.BLI


BLDCK::

;	LOAD THE BUILDER WITH I/O UTILITIES AND EXECUTE



;	LOAD IT

.TYPE BLD.CMD

.R ASL:LINK
*@BLD.CMD

;	BUILD STATEMENT SYNTAX TABLES
;	  BUILD REQUIRES _ NOT =

.RUN ASL:BUILD
*META72.BLI,F72BNF.BLI_F72BNF.SYN
*0
*N

;	BUILD FORMAT SYNTAX TABLES
;	  BUILD REQUIRES _ NOT =

.RUN ASL:BUILD
*METAFM.BLI,FRMBNF.BLI_FRMBNF.SYN
*0
*N

;	DO THE COMPILATIONS FOR THE LOOK AHEAD TABLE BUILDERS.

.R ASL:BLIS10
*LEFT72=ASL:LEFT72.BLI
*LEFTFM=ASL:LEFTFM.BLI


PKLOD::

;	LOAD, SAVE, AND EXECUTE THE GENERAL SYNTAX LOOK AHEAD BUILDER



;	LOAD IT

.TYPE LEFT72.CMD

.NOERROR
.R ASL:LINK
*@LEFT72.CMD
.ERROR

.RUN ASL:LEFT72
*3=ASL:LOOK72.BLI
*0

;	LOAD, SAVE, AND EXECUTE THE FORMAT LOOK AHEAD TABLE BUILDER

.TYPE LEFTFM.CMD

.NOERROR
.R ASL:LINK
*@LEFTFM.CMD
.ERROR

.RUN ASL:LEFTFM
*3=ASL:LOOKFM.BLI
*0

;	REMOVE THE TABLES FROM FRMBNF.BLI AND F72BNF.BLI THAT ARE
;	  UNNECESSARY FOR PHASE 1

.TECO F72BNF.BLI
*NLEFTBUILD^[JSBIND^[0L.U0S;^[0L
*<I!^[0LQ0-."E0;'-L>
*NLEFTBUILD^[N^[-L.U0S;^[-L
=<I!^[0LQ0-."E0;'-L>EX^[^[

.DELETE F72BNF.BAK

.TECO FRMBNF.BLI
*NLEFTBUILD^[JSBIND^[0L.U0S;^[0L
=<I!^[0LQ0-."E0;'-L>EX^[^[

.DELETE FRMBNF.BAK


;	IT IS RECOMMENDED THAT IF AN INSTALLATION IS NOT MODIFYING THE SYNTAX
;	  TABLES THAT THE BUILDING PROCESS BE STARTED HERE AT P0BEG.




P0BEG::

;	**********	PHASE 0		**********	FORTRA



;	MAKE THE COMPILATION AND ASSEMBLY SWITCH DEFINITION FILES
;	  TO GENERATE THE COMPILER FOR TOPS-10, MULTIPLE SEGMENT

.COPY DBUGIT.REQ = TTY:
*BIND DBUGIT=0;		! NO DEBUG CODE IN PHASE 1
*^Z

.COPY FT1SEG.REQ = TTY:
*GLOBAL BIND FT1SEG=0;		! NOT SINGLE SEGMENT
*^Z

.COPY FTTENX.REQ = TTY:
*GLOBAL BIND FTTENEX=0;	! TOPS-10
*^Z

.COPY FTTENX.MAC = TTY:
*UNIVERSAL FTTENX
*	.DIRECTIVE .NOBIN
*	FTTENX==0		; TOPS-10
*	END
*^Z


;	START THE COMPILES
;	USE FIELD IMAGE MACTEN, UUOSYM, SCNMAC, SCAN, WILD, AND HELPER

.R ASL:MACRO
*FTTENX=ASL:FTTENX.MAC
*GFOPDF=ASL:GFOPDF.MAC

.R ASL:MACRO
*COMMAN=ASL:COMMAN.MAC
*ERR3=ASL:ERR3.MAC
*EXOSUP=ASL:EXOSUP.MAC
*JOBD=ASL:JOBD.MAC
*OWNDM=ASL:OWNDM.MAC
*REVHST=ASL:REVHST.MAC

.R ASL:BLIS10
*ERROVA=ASL:ERROVA.BLI
*GLOBAL=ASL:GLOBAL.BLI
*INOUT=ASL:INOUT.BLI
*MAIN=ASL:MAIN.BLI
*UNEND=ASL:UNEND.BLI


P0END::

;	LOAD PHASE 0



;	BUILD DEBUGGING VERSION OF FORTRA.EXE

.TYPE DA.CMD

.DELETE DORTRA.EXE
.R ASL:LINK
*@DA.CMD
.RENAME DORTRA.EXE=ASL:FORTRA.EXE

;	BUILD SHARABLE FORTRA.EXE

.TYPE A.CMD

.R ASL:LINK
*@A.CMD
.GET ASL:FORTRA
.CORE




P1BEG::

;	**********	PHASE 1		**********	FORTB



.R ASL:MACRO
*CNSTCM=ASL:CNSTCM.MAC
*FLTGEN=ASL:FLTGEN.MAC

.R ASL:BLIS10
*ARRXPN=ASL:ARRXPN.BLI
*DOXPN=ASL:DOXPN.BLI
*ERROUT=ASL:ERROUT.BLI
*ERROVB=ASL:ERROVB.BLI
*EXPRES=ASL:EXPRES.BLI
*FAZ1=ASL:FAZ1.BLI
*GNRCFN=ASL:GNRCFN.BLI
*SRCA=ASL:SRCA.BLI
*VLTPPR=ASL:VLTPPR.BLI


FORMC::



.R ASL:BLIS10
*ACT0=ASL:ACT0.BLI
*ACT1=ASL:ACT1.BLI
*CODETA=ASL:CODETA.BLI
*DRIVER=ASL:DRIVER.BLI
*FORMAT=ASL:FORMAT.BLI
*LEXSUP=ASL:LEXSUP.BLI
*LISTNG=ASL:LISTNG.BLI
*STA0=ASL:STA0.BLI
*STA1=ASL:STA1.BLI
*STA2=ASL:STA2.BLI
*STA3=ASL:STA3.BLI

;	LEXICA.BLI REQUIRES 75K OF CORE TO COMPILE

.R ASL:BLIS10
*LEXCLA=ASL:LEXCLA.BLI
*LEXICA=ASL:LEXICA.BLI


P1END::

;	LOAD PHASE 1



;	BUILD DEBUGGING VERSION OF FORTB.EXE

.TYPE DB.CMD

.DELETE DORTB.EXE

.NOERROR
.R ASL:LINK
*@DB.CMD
.RENAME DORTB.EXE=ASL:FORTB.EXE

;	BUILD SHARABLE FORTB.EXE

.TYPE B.CMD

.NOERROR
.R ASL:LINK
*@B.CMD
.GET ASL:FORTB
.CORE




P2SBE::

;	**********	PHASE 2S	**********	FORTC



.R ASL:MACRO
*DOPT=ASL:DOPT.MAC

.R ASL:BLIS10
*ERROVC=ASL:ERROVC.BLI
*GOPT2=ASL:GOPT2.BLI
*INPT=ASL:INPT.BLI
*MEMCMP=ASL:MEMCMP.BLI
*P2S1=ASL:P2S1.BLI
*SKSTMN=ASL:SKSTMN.BLI


P2S2C::



.R ASL:MACRO
*DGCMN=ASL:DGCMN.MAC

.R ASL:BLIS10
*CANNON=ASL:CANNON.BLI
*COMSUB=ASL:COMSUB.BLI
*GOPTIM=ASL:GOPTIM.BLI
*P2S2=ASL:P2S2.BLI
*PH2S=ASL:PH2S.BLI
*UTIL=ASL:UTIL.BLI


P2SEN::

;	LOAD PHASE 2S



;	BUILD DEBUGGING VERSION OF FORTC.EXE

.TYPE DC.CMD

.DELETE DORTC.EXE
.R ASL:LINK
*@DC.CMD
.RENAME DORTC.EXE=ASL:FORTC.EXE

;	BUILD SHARABLE FORTC.EXE

.TYPE C.CMD

.R ASL:LINK
*@C.CMD
.GET ASL:FORTC
.CORE




P2BEG::

;	**********	PHASE 2		**********	FORTD



.R ASL:MACRO
*DNPT=ASL:DNPT.MAC

.R ASL:BLIS10
*DEFPT=ASL:DEFPT.BLI
*ERROVD=ASL:ERROVD.BLI
*GCMNSB=ASL:GCMNSB.BLI
*GRAPH=ASL:GRAPH.BLI
*IOPT=ASL:IOPT.BLI
*MOVA=ASL:MOVA.BLI
*PHA2=ASL:PHA2.BLI
*PNROPT=ASL:PNROPT.BLI
*TSTR=ASL:TSTR.BLI
*VER5=ASL:VER5.BLI


P2END::

;	LOAD PHASE 2



;	BUILD DEBUGGING VERSION OF FORTD.EXE

.TYPE DD.CMD

.DELETE DORTD.EXE
.R ASL:LINK
*@DD.CMD
.RENAME DORTD.EXE=ASL:FORTD.EXE

;	BUILD SHARABLE FORTD.EXE

.TYPE D.CMD

.R ASL:LINK
*@D.CMD
.GET ASL:FORTD
.CORE




P3GBE::

;	**********	PHASE 3G	**********	FORTE



.R ASL:BLIS10
*ALCBLO=ASL:ALCBLO.BLI
*CMPBLO=ASL:CMPBLO.BLI
*CMPLEX=ASL:CMPLEX.BLI
*DATAST=ASL:DATAST.BLI
*DOALC=ASL:DOALC.BLI
*ERROVR=ASL:ERROVR.BLI
*OUTMOD=ASL:OUTMOD.BLI
*PH3G=ASL:PH3G.BLI
*REGAL2=ASL:REGAL2.BLI
*REGUTL=ASL:REGUTL.BLI
*RELBUF=ASL:RELBUF.BLI
*STREGA=ASL:STREGA.BLI


P3GEN::

;	LOAD PHASE 3G



;	BUILD DEBUGGING VERSION OF FORTE.EXE

.TYPE DE.CMD

.DELETE DORTE.EXE
.R ASL:LINK
*@DE.CMD
.RENAME DORTE.EXE=ASL:FORTE.EXE

;	BUILD SHARABLE FORTE.EXE

.TYPE E.CMD

.R ASL:LINK
*@E.CMD
.GET ASL:FORTE
.CORE




P3RBE::

;	**********	PHASE 3R	**********	FORTF



.R ASL:BLIS10
*P3R=ASL:P3R.BLI

;	LOAD PHASE 3R

;	BUILD DEBUGGING VERSION OF FORTF.EXE

.TYPE DF.CMD

.DELETE DORTF.EXE
.R ASL:LINK
*@DF.CMD
.RENAME DORTF.EXE=ASL:FORTF.EXE

;	BUILD SHARABLE FORTF.EXE

.TYPE F.CMD

.R ASL:LINK
*@F.CMD
.GET ASL:FORTF
.CORE




P3BEG::

;	**********	PHASE 3		**********	FORTG



.R ASL:MACRO
*OPGNTA=ASL:OPGNTA.MAC

.R ASL:BLIS10
*CGDO=ASL:CGDO.BLI
*CGEXPR=ASL:CGEXPR.BLI
*CGSTMN=ASL:CGSTMN.BLI
*DEBUG=ASL:DEBUG.BLI
*ERROVG=ASL:ERROVG.BLI
*LISTOU=ASL:LISTOU.BLI
*OPTAB=ASL:OPTAB.BLI
*PEEPOP=ASL:PEEPOP.BLI
*PHA3=ASL:PHA3.BLI


P3END::

;	LOAD PHASE 3



;	BUILD DEBUGGING VERSION OF FORTG.EXE

.TYPE DG.CMD

.DELETE DORTG.EXE
.R ASL:LINK
*@DG.CMD
.RENAME DORTG.EXE=ASL:FORTG.EXE

;	BUILD FORTG.EXE

.TYPE G.CMD

.R ASL:LINK
*@G.CMD
.GET ASL:FORTG
.CORE


;	**********	MULTI-SEGMENT BUILDING PHASES COMPLETE	**********




PSNGL::

;	MAKE THE SINGLE SEGMENT TOPS-10 COMPILER



.COPY FT1SEG.BAK = FT1SEG.REQ

.COPY FT1SEG.REQ = TTY:
*GLOBAL BIND FT1SEG = 1;	! SINGLE SEGMENT
*^Z

;	RECOMPILE MAIN.BLI AS ONESEG.REL

.R ASL:BLIS10
*ONESEG=ASL:MAIN.BLI

;	CLEAN UP

.COPY FT1SEG.REQ = FT1SEG.BAK
.DELETE FT1SEG.BAK

;	BUILD SHARABLE SINGLE SEGMENT COMPILER

.TYPE ALL.CMD

.R ASL:LINK
*@ALL
.GET ASL:SINGLE
.CORE



MTHLIB::

.RUN ASL:MACRO
*=M10REL.MAC,MTHPRM.MAC
*MTHTRP.REL=MTHTRP.MAC
*MTHSNG.REL=MTHSNG.MAC
*MTHDBL.REL=MTHDBL.MAC
*MTHGDB.REL=MTHGDB.MAC
*MTHCPX.REL=MTHCPX.MAC
*MTHCDX.REL=MTHCDX.MAC
*MTHCGX.REL=MTHCGX.MAC
*MTHMSG.REL=MTHMSG.MAC
*MTHDUM.REL=MTHDUM.MAC
*MTHARG.REL=MTHARG.MAC
*MTHCNV.REL=MTHCNV.MAC

MMLIB::

! Create TWOSEG MTHLIB and index
! MTHLIB will contain locals

.TYPE MTHLIB.CCL

.RUN SYS:MAKLIB
*@MTHLIB


BOTS::

CREL::

; Compile FOROTS

.R ASL:MACRO
*FORPRM=F10REL.MAC,FORPRM.MAC
*FORBOT.REL=FORBOT.MAC
*FORCNV.REL=FORCNV.MAC
*FORCOM.REL=FORCOM.MAC
*FORCHR.REL=FORCHR.MAC
*FORDBM.REL=FORDBM.MAC
*FORDST.REL=FORDST.MAC
*FORDUM.REL=FORDUM.MAC
*FORERR.REL=FORERR.MAC
*FORFMT.REL=FORFMT.MAC
*FORHST.REL=FORHST.MAC
*FORINI.REL=FORINI.MAC
*FORIO.REL=FORIO.MAC
*FORMEM.REL=FORMEM.MAC
*FORMSC.REL=FORMSC.MAC
*FORMSG.REL=FORMSG.MAC
*FORNML.REL=FORNML.MAC
*FOROP.REL=FOROP.MAC
*FOROPN.REL=FOROPN.MAC
*FOROTS.REL=FOROTS.MAC
*FORPSE.REL=FORPSE.MAC
*FORPL2.REL=FORPL2.MAC
*FORRMS.REL=FORRMS.MAC
*FORRTF.REL=FORRTF.MAC
*FORSRT.REL=FORSRT.MAC
*FORXIT.REL=FORXIT.MAC

.RUN DSK:FORTRA
*FORPL1.REL=FORPL1.FOR/OPT/NOWARN:CHO
*^Z


MFLIB::

; Create TWOSEG FORLIB and index

; FORLIB will contain locals

.TYPE F10LIB.CCL

; CKS - Use MAKLIB 2C because it has a newer SCAN than DEC:
; which works on .SFD's

.R ASL:MAKLIB
*@F10LIB.CCL


MFOTS::

; Create FOROTS



; Build and initialize

.TYPE F10OTS.CCL

.R ASL:LINK
*@F10OTS.CCL
.GET FORO10
.CORE


DIR2::

; Show checksum directories of all output files




BDDT::

; Generate FORDDT for the 10



.COPY FDDT.MAC=TTY:
*	TOPS20==0	;TOPS-10
*^Z

; Build FORDDT

.R ASL:MACRO
*FORDDT=ASL:FDDT.MAC,ASL:FORDDT.MAC

;	If flag file FTNDBM.FLG is present on PAT:, make DBMSF.EXE and
;	DBMSF.REL for FORTRAN-10 with DBMS.

.PRO<777>FTNDBM.FLG
.IF (ERROR) .GOTO CHECK

;	Here for DBM/Fortran

.ERROR %

; These files must exist to be built into DBMSF.EXE

.COPY =ASL:DBSFOR.REL
.COPY =ASL:DBSANY.REL
.COPY =ASL:DBS10.REL
.COPY =ASL:SCHIO1.REL
.DIR DBSFOR.REL, DBSANY.REL, DBS10.REL, SCHIO1.REL, FORDBM.REL

.ERROR ?

.TYPE FDBM5.CCL
.R ASL:MAKLIB
*@FDBM5.CCL

.EX FDBM5.FOR

.TYPE DBCS1F.CMD
.R ASL:LINK
*@DBCS1F

;
;See what we got
;

.ERROR %

.DIR /CHECKSUM DBMSF.EXE

.ERROR ?

CHECK::

;	DELETE UNNEEDED OUTPUT FILES

.DELETE FORBOT.REL,FORCNV.REL,FORCOM.REL,FORCHR.REL,FORDBM.REL
.DELETE FORDST.REL,FORDUM.REL,FORERR.REL,FORFMT.REL,FORHST.REL
.DELETE FORINI.REL,FORIO.REL,FORMEM.REL,FORMSC.REL,FORMSG.REL
.DELETE FORNML.REL,FOROP.REL,FOROPN.REL,FOROTS.REL,FORPSE.REL
.DELETE FORPL2.REL,FORRMS.REL,FORRTF.REL,FORSRT.REL,FORXIT.REL
.DELETE FORPL1.REL,MTHTRP.REL,MTHSNG.REL,MTHDBL.REL
.DELETE MTHGDB.REL,MTHCPX.REL,MTHCDX.REL,MTHCGX.REL,MTHMSG.REL
.DELETE MTHDUM.REL,MTHARG.REL,MTHCNV.REL

;
;	Signal success
;

.R PEPB
*SIGNAL-SUCCESS FORTRAN-10-V10
*EXIT
.GOTO EXIT

;
;	Signal failure on error
;

%ERR::
.GOTO ERROR
%CERR::
.GOTO ERROR
%TERR::
ERROR::
.R PEPB
*SIGNAL-FAILURE FORTRAN-10-V10
*EXIT

EXIT::
%FIN::
     
;	[END OF FTN10.CTL]