$! Vax compatibility command file built on Wed Jun 12 16:12:12 1985
$ was_verify = 'f$verify(1)'
$!
$! ** Compile ARCH
$!
$ xcc ARCH.C 
$ xas ARCH.S -d
$ mcr tkb 
BIN:ARCH=ARCH.OBJ,C:C/LB
/
TASK	= ...ARC
//
$ set protection=(world=re) BIN:ARCH.EXE;
$ delete ARCH.OBJ;
$ ARCH :== $BIN:ARCH
$!
$! ** Compile ARCHC
$!
$ xcc ARCHC.C 
$ xas ARCHC.S -d
$ mcr tkb 
BIN:ARCHC=ARCHC.OBJ,C:C/LB
/
TASK	= ...ARC
//
$ set protection=(world=re) BIN:ARCHC.EXE;
$ delete ARCHC.OBJ;
$ ARCHC :== $BIN:ARCHC
$!
$! ** Compile ARCHX
$!
$ xcc ARCHX.C 
$ xas ARCHX.S -d
$ mcr tkb 
BIN:ARCHX=ARCHX.OBJ,C:C/LB
/
TASK	= ...ARX
//
$ set protection=(world=re) BIN:ARCHX.EXE;
$ delete ARCHX.OBJ;
$ ARCHX :== $BIN:ARCHX
$!
$! ** Compile BUILD
$!
$ !! copy BUILD.H BUILD.H
$ xcc BUILD0.C 
$ xas BUILD0.S -d
$ xcc BUILD1.C 
$ xas BUILD1.S -d
$ xcc BUILD2.C 
$ xas BUILD2.S -d
$ xcc BUILD3.C 
$ xas BUILD3.S -d
$ xcc BUILD4.C 
$ xas BUILD4.S -d
$ xcc BUILD5.C 
$ xas BUILD5.S -d
$ mcr tkb 
BIN:BUILD=BUILD0.OBJ,BUILD1.OBJ,BUILD2.OBJ
BUILD3.OBJ,BUILD4.OBJ,BUILD5.OBJ
C:C/LB
/
TASK	= ...BUI
STACK	= 2000
//
$ set protection=(world=re) BIN:BUILD.EXE;
$ delete BUILD0.OBJ;
$ delete BUILD1.OBJ;
$ delete BUILD2.OBJ;
$ delete BUILD3.OBJ;
$ delete BUILD4.OBJ;
$ delete BUILD5.OBJ;
$ BUILD :== $BIN:BUILD
$!
$! ** Compile COMM
$!
$ xcc COMM.C 
$ xas COMM.S -d
$ mcr tkb 
BIN:COMM=COMM.OBJ,C:C/LB
/
TASK	= ...COM
//
$ set protection=(world=re) BIN:COMM.EXE;
$ delete COMM.OBJ;
$ COMM :== $BIN:COMM
$!
$! ** Compile CPP
$!
$ !! copy CPPDEF.H CPPDEF.H
$ !! copy CPP.H CPP.H
$ xcc CPP1.C 
$ xas CPP1.S -d
$ xcc CPP2.C 
$ xas CPP2.S -d
$ xcc CPP3.C 
$ xas CPP3.S -d
$ xcc CPP4.C 
$ xas CPP4.S -d
$ xcc CPP5.C 
$ xas CPP5.S -d
$ xcc CPP6.C 
$ xas CPP6.S -d
$ mcr tkb 
BIN:CPP=CPP1.OBJ,CPP2.OBJ,CPP3.OBJ
CPP4.OBJ,CPP5.OBJ,CPP6.OBJ
C:C/LB
/
STACK	= 2000
//
$ set protection=(world=re) BIN:CPP.EXE;
$ delete CPP1.OBJ;
$ delete CPP2.OBJ;
$ delete CPP3.OBJ;
$ delete CPP4.OBJ;
$ delete CPP5.OBJ;
$ delete CPP6.OBJ;
$ CPP :== $BIN:CPP
$!
$! ** Compile DETAB
$!
$ xcc DETAB.C 
$ xas DETAB.S -d
$ mcr tkb 
BIN:DETAB=DETAB.OBJ,C:C/LB
/
TASK	= ...DET
//
$ set protection=(world=re) BIN:DETAB.EXE;
$ delete DETAB.OBJ;
$ DETAB :== $BIN:DETAB
$!
$! ** Compile DIFF
$!
$ xcc DIFF.C 
$ xas DIFF.S -d
$ mcr tkb 
BIN:DIFF=DIFF.OBJ,C:C/LB
/
TASK	= ...DIF
//
$ set protection=(world=re) BIN:DIFF.EXE;
$ delete DIFF.OBJ;
$ DIFF :== $BIN:DIFF
$!
$! ** Compile ECHO
$!
$ xcc ECHO.C 
$ xas ECHO.S -d
$ mcr tkb 
BIN:ECHO=ECHO.OBJ,C:C/LB
/
TASK	= ...ECH
//
$ set protection=(world=re) BIN:ECHO.EXE;
$ delete ECHO.OBJ;
$ ECHO :== $BIN:ECHO
$!
$! ** Compile ENTAB
$!
$ xcc ENTAB.C 
$ xas ENTAB.S -d
$ mcr tkb 
BIN:ENTAB=ENTAB.OBJ,C:C/LB
/
TASK	= ...ENT
//
$ set protection=(world=re) BIN:ENTAB.EXE;
$ delete ENTAB.OBJ;
$ ENTAB :== $BIN:ENTAB
$!
$! ** Compile FIXDOC
$!
$ xcc FIXDOC.C 
$ xas FIXDOC.S -d
$ mcr tkb 
BIN:FIXDOC=FIXDOC.OBJ,C:C/LB
/
TASK	= ...FXD
//
$ set protection=(world=re) BIN:FIXDOC.EXE;
$ delete FIXDOC.OBJ;
$ FIXDOC :== $BIN:FIXDOC
$!
$! ** Compile GETCMD
$!
$ xcc GETCMD.C 
$ xas GETCMD.S -d
$ mcr tkb 
BIN:GETCMD=GETCMD.OBJ,C:C/LB
/
TASK	= ...GTC
//
$ set protection=(world=re) BIN:GETCMD.EXE;
$ delete GETCMD.OBJ;
$ GETCMD :== $BIN:GETCMD
$!
$! ** Compile GETKWK
$!
$ xcc GETKWK.C 
$ xas GETKWK.S -d
$ mcr tkb 
BIN:GETKWK=GETKWK.OBJ,C:C/LB
/
TASK	= ...GTK
//
$ set protection=(world=re) BIN:GETKWK.EXE;
$ delete GETKWK.OBJ;
$ GETKWK :== $BIN:GETKWK
$!
$! ** Compile GETRNO
$!
$ xcc GETRNO.C 
$ xas GETRNO.S -d
$ mcr tkb 
BIN:GETRNO=GETRNO.OBJ,C:C/LB
/
TASK	= ...GTR
//
$ set protection=(world=re) BIN:GETRNO.EXE;
$ delete GETRNO.OBJ;
$ GETRNO :== $BIN:GETRNO
$!
$! ** Compile GREP
$!
$ xcc GREP.C 
$ xas GREP.S -d
$ mcr tkb 
BIN:GREP=GREP.OBJ,C:C/LB
/
TASK	= ...GRE
//
$ set protection=(world=re) BIN:GREP.EXE;
$ delete GREP.OBJ;
$ GREP :== $BIN:GREP
$!
$! ** Compile KWIK
$!
$ xcc KWIK.C 
$ xas KWIK.S -d
$ xcc SORTS.C 
$ xas SORTS.S -d
$ mcr tkb 
BIN:KWIK=KWIK.OBJ,SORTS.OBJ,C:C/LB
/
TASK = ...KWI
//
$ set protection=(world=re) BIN:KWIK.EXE;
$ delete KWIK.OBJ;
$ delete SORTS.OBJ;
$ KWIK :== $BIN:KWIK
$!
$! ** Compile LINEPR
$!
$ xcc LINEPR.C 
$ xas LINEPR.S -d
$ mcr tkb BIN:LINEPR=LINEPR.OBJ,C:C/LB
$ set protection=(world=re) BIN:LINEPR.EXE;
$ delete LINEPR.OBJ;
$ LINEPR :== $BIN:LINEPR
$!
$! ** Compile MC
$!
$ xcc MC.C 
$ xas MC.S -d
$ mcr tkb 
BIN:MC=MC.OBJ,C:C/LB
/
TASK	=	...MCX
UNITS	=	10
ACTFIL	=	10
//
$ set protection=(world=re) BIN:MC.EXE;
$ delete MC.OBJ;
$ MC :== $BIN:MC
$!
$! ** Compile NM
$!
$ xcc NM.C 
$ xas NM.S -d
$ mcr tkb 
BIN:NM=NM.OBJ,C:C/LB
/
TASK	= ...NMX
//
$ set protection=(world=re) BIN:NM.EXE;
$ delete NM.OBJ;
$ NM :== $BIN:NM
$!
$! ** Compile OD
$!
$ xcc OD.C 
$ xas OD.S -d
$ mcr tkb 
BIN:OD=OD.OBJ,C:C/LB
/
TASK	= ...ODX
//
$ set protection=(world=re) BIN:OD.EXE;
$ delete OD.OBJ;
$ OD :== $BIN:OD
$!
$! ** Compile PR
$!
$ xcc PR.C 
$ xas PR.S -d
$ mcr tkb 
BIN:PR=PR.OBJ,C:C/LB
/
TASK	= ...PRX
//
$ set protection=(world=re) BIN:PR.EXE;
$ delete PR.OBJ;
$ PR :== $BIN:PR
$!
$! ** Compile RNOIDX
$!
$ xcc RNOIDX.C 
$ xas RNOIDX.S -d
$ mcr tkb 
BIN:RNOIDX=RNOIDX.OBJ,C:C/LB
/
TASK	= ...FIX
//
$ set protection=(world=re) BIN:RNOIDX.EXE;
$ delete RNOIDX.OBJ;
$ RNOIDX :== $BIN:RNOIDX
$!
$! ** Compile SCAT
$!
$ xcc SCAT.C 
$ xas SCAT.S -d
$ mcr tkb 
BIN:SCAT=SCAT.OBJ,C:C/LB
/
TASK	= ...CAT
//
$ set protection=(world=re) BIN:SCAT.EXE;
$ delete SCAT.OBJ;
$ SCAT :== $BIN:SCAT
$!
$! ** Compile SCOPY
$!
$ xcc SCOPY.C 
$ xas SCOPY.S -d
$ mcr tkb BIN:SCOPY=SCOPY.OBJ,C:C/LB
$ set protection=(world=re) BIN:SCOPY.EXE;
$ delete SCOPY.OBJ;
$ SCOPY :== $BIN:SCOPY
$!
$! ** Compile SORTC
$!
$ xcc SORTC.C 
$ xas SORTC.S -d
$ xcc QKSORT.C 
$ xas QKSORT.S -d
$ mcr tkb 
BIN:SORTC=SORTC.OBJ,QKSORT.OBJ,C:C/LB
/
TASK 	= ...SOR
ACTFIL	= 6
UNITS	= 6
//
$ set protection=(world=re) BIN:SORTC.EXE;
$ delete SORTC.OBJ;
$ delete QKSORT.OBJ;
$ SORTC :== $BIN:SORTC
$!
$! ** Compile T
$!
$ !! copy T.H T.H
$ xcc T1.C 
$ xas T1.S -d
$ xcc T2.C 
$ xas T2.S -d
$ xcc T3.C 
$ xas T3.S -d
$ xcc T4.C 
$ xas T4.S -d
$ xcc T5.C 
$ xas T5.S -d
$ xcc T6.C 
$ xas T6.S -d
$ xcc T7.C 
$ xas T7.S -d
$ mcr tkb 
BIN:T=T1.OBJ,T2.OBJ,T3.OBJ
T4.OBJ,T5.OBJ,T6.OBJ
T7.OBJ,C:C/LB
/
TASK	= ...TXX
//
$ set protection=(world=re) BIN:T.EXE;
$ delete T1.OBJ;
$ delete T2.OBJ;
$ delete T3.OBJ;
$ delete T4.OBJ;
$ delete T5.OBJ;
$ delete T6.OBJ;
$ delete T7.OBJ;
$ T :== $BIN:T
$!
$! ** Compile TR
$!
$ xcc TR.C 
$ xas TR.S -d
$ mcr tkb 
BIN:TR=TR.OBJ,C:C/LB
/
TASK	=	...TRX
//
$ set protection=(world=re) BIN:TR.EXE;
$ delete TR.OBJ;
$ TR :== $BIN:TR
$!
$! ** Compile UNIQ
$!
$ xcc UNIQ.C 
$ xas UNIQ.S -d
$ mcr tkb 
BIN:UNIQ=UNIQ.OBJ,C:C/LB
/
TASK	= ...UNI
//
$ set protection=(world=re) BIN:UNIQ.EXE;
$ delete UNIQ.OBJ;
$ UNIQ :== $BIN:UNIQ
$!
$! ** Compile UNITS
$!
$ xcc UNITS.C 
$ xas UNITS.S -d
$ xcc ATOF.C 
$ xas ATOF.S -d
$ mcr tkb 
BIN:UNITS=UNITS.OBJ,ATOF.OBJ,C:DTOA
C:C/LB
/
TASK	= ...UNI
//
$ set protection=(world=re) BIN:UNITS.EXE;
$ delete UNITS.OBJ;
$ delete ATOF.OBJ;
$ UNITS :== $BIN:UNITS
$!
$! ** Compile WC
$!
$ xcc WC.C 
$ xas WC.S -d
$ mcr tkb 
BIN:WC=WC.OBJ,C:C/LB
/
TASK	= ...WCX
//
$ set protection=(world=re) BIN:WC.EXE;
$ delete WC.OBJ;
$ WC :== $BIN:WC
$!
$! ** Compile XRF
$!
$ !! copy XRF.H XRF.H
$ xcc XRF0.C 
$ xas XRF0.S -d
$ xcc XRF1.C 
$ xas XRF1.S -d
$ xcc XRF2.C 
$ xas XRF2.S -d
$ xcc XRF3.C 
$ xas XRF3.S -d
$ xcc XRFI.C 
$ xas XRFI.S -d
$ xcc XRFD.C 
$ xas XRFD.S -d
$ create XRF.TMP
;
; OVERLAY DESCRIPTION FOR XRF
; BOB DENNY	29-MAY-81
;
.ROOT	XRF0-XRF2-XRFD-C:C/LB-*(X1,X2,X3)
;
X1:	.FCTR	XRFI-X1L1-X1L2-X1L3
X1L1:	.FCTR	C:C/LB:CONCAT:FWILD
; Note: CTIME requires several other library modules:
X1L2:	.FCTR	C:C/LB:TIME:CTIME:LOCALT:$$RTIME:$$UTIME
X1L3:	.FCTR	C:C/LB:CALLOC:MUL$L:$$DIV2:EIS$I
;
X2:	.FCTR	XRF1-X2L
X2L:	.FCTR	C:C/LB:EIS$I
;
X3:	.FCTR	XRF3-X3L
X3L:	.FCTR	C:C/LB:SPRINT
.END

$EOD
$ mcr tkb 
BIN:XRF=XRF.TMP/MP
TASK = ...XRF
STACK = 1500
//
$ set protection=(world=re) BIN:XRF.EXE;
$ delete XRF.TMP;
$ delete XRF0.OBJ;
$ delete XRF1.OBJ;
$ delete XRF2.OBJ;
$ delete XRF3.OBJ;
$ delete XRFI.OBJ;
$ delete XRFD.OBJ;
$ XRF :== $BIN:XRF
$ if .not. 'was_verify' then set noverify