diff --git a/source/B65MCP/MARK00.esp_m b/source/B65MCP/MARK00.esp_m index 471ff27..1704d60 100644 --- a/source/B65MCP/MARK00.esp_m +++ b/source/B65MCP/MARK00.esp_m @@ -1527,7 +1527,7 @@ FIELD IDNO =47:10, COMMENT USER IDENTIFICATION NO.; 13265000 USERPARITYBIT =22:1, % PARITY ACTION TO BE TAKEN BY USER 13269200 USEREOFORTBIT =21:1, % END OF FILE OR END OF TAPE ACTION 13269400 USERIOFINISH =20:1, % USER I/O FINISHED 13269600 - USERSPECIALID =19:1 , % SPECIAL ACTION TO BE TAKEN 13269800 + USERSPECIALIO =19:1 , % SPECIAL ACTION TO BE TAKEN 13269800 USERIOBIT =18:1; % USER I/O 13270000 COMMENT FIELDS FOR MISC WORD OF IOCB; 13270100 FIELD 13270200 @@ -1885,7 +1885,7 @@ LAYOUT DISKADDRESSL(EUNOF, DISKADDRF); 14025000 , MAPADDRESSF = 39:20 14028000 , ADDRESSF 14029000 ) 14030000 - , FIRSTMAPWORDRIME( 14031000 + , FIRSTMAPWORDPRIME( 14031000 MAPAREAF = 47:28 14032000 , ADDRESSF 14033000 ) 14034000 @@ -3867,7 +3867,7 @@ DEFINE 24714000 EVENTNO = TANKDATA3.BEVNT#, 24756000 EXPLICITADDRESS=BOOLEAN(FILEACCESS.EXPADRS)#, 24757000 FFORTRAN = RECORDTYPE=6#, 24757100 - BIB0 = FIBSIZE#, 24757200 + FIB0 = FIBSIZE#, 24757200 FIBUZZ = IF FIBB(FIBLOCKF) THEN BEGIN 24758000 WHILE BOOLEAN(READLOCK(1,LOCKER)) DO 24759000 WAIT(IOEVENT[FILEVENT]); 24760000 @@ -3891,7 +3891,7 @@ DEFINE 24714000 INOUTPART = DSKS.MYUSEF#, 24769000 INTERNALMODE = FILESTATUS.INTMODE#, 24770000 IOCOMPLET = USER@(IOCB).USERIOFINISH#, 24771000 - IOCOMPLETE= BOOLEAN(WORD(USER@IOCB).(USERIOFINISH)#, 24772000 + IOCOMPLETE= BOOLEAN(WORD(USER@IOCB).USERIOFINISH)#, 24772000 IOCWSKLTN= IOINFO#, 24774000 IOPENDING = NOT IOCOMPLETE#, 24775000 IOTERMINATE=BEGIN TRACE(18);TRACE(21)END#, 24776000 @@ -4988,7 +4988,7 @@ COMMENT STACKINUSE GIVES THE STACK NO OF EACH INDEPENDENT RUNNER 32302000 FILLARRAY(STACKINUSE,0,MAXIRINDEX); 32305000 COMMENT IRPRIORITIES GIVES PRIORITY OF EACH INDEPENDENT RUNNER, 32306000 THOSE RUNNERS ASSIGNED INDICATORS MUST HAVE PRIORITIES 32306200 - ASSIGNED.OTHER RUNNERS WILL HAvE DEFAULT PRIORITIES 32306400 + ASSIGNED.OTHER RUNNERS WILL HAVE DEFAULT PRIORITIES 32306400 ; 32307000 FILLARRAY(IRPRIORITIES,IRDEFAULTPRIORITY,MAXIRINDEX);32308000 IRPRIORITIES[CONTROLCARDINDICATOR] 32308200 @@ -5404,7 +5404,7 @@ COMMENT *** MAYBE THIS CAN BE FIXED LATER; 33255000 BEGIN COMMENT MCS 4; 33276000 TI2~MOM.ADDRESSF; 33277000 ALREADYPRESENT ~ TRUE; 33278000 -MOMPRESENT: IF KIND!IRW THEN PREsENCEBIT~ACTUALCOPY 33279000 +MOMPRESENT: IF KIND!IRW THEN PRESENCEBIT~ACTUALCOPY 33279000 ~ACTUALCOPY&FIXDESC(1,*,TI2); 33280000 IF NOT ALREADYPRESENT 33281000 THEN 33282000 @@ -5606,7 +5606,7 @@ COMMENT ALL NON MPX INTERRUPTS HERE; 33462000 BEGIN COMMENT MCS 3; 33464000 COMMENT ALL NON MPX,NON SYLLABLE DEPENDENT INTERRUPTS HERE; 33465000 IF P1 = PROCTOPROCSPEC THEN PROCTOPROC 33466000 - ELSE IF P1=INTERvALTIMERsPEc THEN 33467000 + ELSE IF P1=INTERVALTIMERSPEC THEN 33467000 BEGIN COMMENT MCS 3A; 33468000 IF (COUNTFORTIMERINTERRUPTEVENT~*+1) 33469000 = NUMBEROFPROCESSORS AND NOT 33470000 @@ -6866,7 +6866,7 @@ WORDMON ~ WORD (ANAME); %%%%%% 38416000 ARRAY SEGZERO2[*]; 38491000 BEGIN COMMENT EMPTY THE PARAMETER QUEUE. ALL PARAMETERS FOR 38492000 THIS RUN ARE NOW KNOWN AND THE INFORMATION FOR THEM 38493000 - EXISTS AS INDIvIDUAL ENTRIES IN THE PARAMETER QUEUE. 38494000 + EXISTS AS INDIVIDUAL ENTRIES IN THE PARAMETER QUEUE. 38494000 THESE ENTRIES EXIST EITHER IN THE AREA DESCRIBED 38495000 BY THE ORIGINAL FPB DESCRIPTOR (AS SUPPLIED BY THE 38496000 COMPILER (AS SUPPLIED BY CONTROL CARD)) OR IN INDIV- 38497000 @@ -7631,7 +7631,7 @@ WRAPUP: 40279000 MISC @ ( IOCB ) ~ RD; 40311000 IF UNTTYPE=CONN THEN% 40312000 IF INPUT(IOCW) THEN LINKINTOKEYINQ% 40312100 - ELSE IF (SEvNT@IOCB).TAG=1 THEN CAUSE(EVNT@IOCB)% 40312200 + ELSE IF (SEVNT@IOCB).TAG=1 THEN CAUSE(EVNT@IOCB)% 40312200 ELSE LINKINTOSPOUTQ% 40312300 ELSE% 40312400 CAUSE(EVNT @ IOCB); 40313000 @@ -9468,7 +9468,7 @@ COMMENT BUILD MESSAGE "UNIT NOT READY"; 50088000 END; 50089000 NOTREADY: 50090000 COMMENT MAKE OLDSTATUS OF THE UNIT NOT READY; 50091000 - OLDSTATUSWORD[VECTORNO]~OLDSTATUSWORD[VEcTORNO] AND 50093000 + OLDSTATUSWORD[VECTORNO]~OLDSTATUSWORD[VECTORNO] AND 50093000 NOT BITWORD; 50094000 %SPOUT(MSGAREA,DISPLAYONPER);% MAR 50097000 UTABLEENTRY.UNITERRORFIELD~0; 50098000 @@ -9517,3 +9517,2666 @@ COMMENT MEMORY PROTECT ERROR; 50125300 BEGIN 50127000 ; COMMENT NO UNIT; 50128000 BEGIN COMMENT DISK FILE; 50129000 + IF BOOLEAN(UERROR.EUBUSY) THEN 50130000 + BEGIN COMMENT DISK ELECTRONICS UNIT NOT READY; 50131000 + UNITMASK~ @400; 50132000 +COMMENT BUILD MESSAGE "EU NOT READY"; 50133000 + ERRORSET~8; 50133500 + GO DISPLAYMSGANDTRY; 50134000 + END; 50135000 + IF MEMACCESSERRORTOG THEN 50136000 + IF BOOLEAN(UERROR.RDWLOOREOF) THEN 50137000 + BEGIN COMMENT READ ERROR; 50138000 + ERRORSET~ 4096 |7 +9; 50139000 + GO SETERROR; 50140000 + END ELSE 50144000 +MPXMEMACCESS: 50145000 + BEGIN % MEMORY ACCESS ERROR 50146000 + ERRORSET~7; 50147000 + GO CLEARERROR; 50148000 + END; 50149000 + IF BOOLEAN(UERROR.OPUNOTREADY) THEN 50150000 + BEGIN % OPERATING UNIT NOT READY 50150200 +COMMENT DURING TRANSFER STORAGE UNIT WAS CROSSED FROM 50150400 + A READY S.U. TO A NOT READY S.U.; 50150600 + ERRORSET~11; 50150800 + GO SETERROR; 50150900 + END; 50150950 + IF BOOLEAN(UERROR.UTIMEOUT) THEN 50151000 + BEGIN % TIME OUT 50152000 + ERRORSET~15; 50153000 + GO SETERROR; 50154000 + END; 50155000 + IF BOOLEAN(UERROR.RDWLOOREOF) THEN 50156000 +WRITELOCK: 50157000 + BEGIN 50158000 + ERRORSET~9; 50159000 +COMMENT BUILD MESSACE "WRITE-LOCK"; 50160000 + GO SETERROR; 50161000 + END; 50162000 + END; 50163000 + ; COMMENT SPO; 50164000 + ; COMMENT DISPLAY; 50165000 + COMMENT PAPER TAPE READER; 50166000 + BEGIN 50167000 + IF BOOLEAN(UERROR.RDENDOFTAPE) THEN 50168000 + BEGIN % BEGINNING OR END OF TAPE 50168200 + ERRORSET~8; 50168400 + END ELSE 50168600 + IF BOOLEAN(UERROR.INCOMPLETERECORD) THEN 50169000 + BEGIN % INCOMPLETE RECORD 50170000 + ERRORSET~10; 50171000 + END; 50171500 + IF MEMACCESSERRORTOG THEN 50172000 + IF BOOLEAN(UERROR.READPARITY) THEN 50173000 + BEGIN 50174000 + ERRORSET~ 4096 |7 +9; 50175000 +COMMENT *********** WRITE SPECIAL RETRY PROCEDURE; 50176000 + END ELSE 50177000 + GO MPXMEMACCESS; 50178000 + BEGIN % MEMORY ACCESS ERROR 50178200 + ERRORSET~7; 50178300 + END; 50178400 +DISPLAYMSG: 50179000 + BEGIN 50180000 +COMMENT BUILD MESSAGE "UNIT I/O ERROR"; 50181000 + GO SETERROR; 50182000 + END; 50183000 + END; 50184000 + COMMENT PAPER TAPE PUNCH; 50185000 + BEGIN 50186000 + IF BOOLEAN(UERROR.RDENDOFTAPE) THEN 50187000 + BEGIN % PAPER TAPE RUNNING LOW 50187200 + ERRORSET~8; 50187400 + END ELSE 50187600 + IF BOOLEAN(UERROR.INCOMPLETERECORD) THEN 50188000 + BEGIN % INCOMPLETE RECORD 50189000 + ERRORSET~10; 50190000 + END; 50190200 + GO COMMONCODE; 50190600 + END; 50191000 + GO PRINTER; COMMENT BUFFERED PRINTER; 50193000 +PRINTER: 50195000 + BEGIN 50196000 + IF BOOLEAN(UERROR.ENDOFPAGE) THEN 50197000 + BEGIN 50198000 + COMMENT IGNORE END OF PAGE IF NO SPACE OR SKIP; 50199000 + IF IOCW.IOUNITFIELD=0 THEN GO COMMONCODE; 50200000 + M[WORD(AREADESC @ IOCB)]~ 0 & IOCWL(@200, 50201000 + 0 & IOCWPRINTERL(0,1)); 50202000 + ERRORSET~12; 50202500 + GO CLEARERROR; 50203000 + END; 50204000 + IF MEMACCESSERRORTOG THEN 50204500 + IF BOOLEAN(UERROR.PRINTERBITTRANSFER) THEN 50205000 + BEGIN 50205100 +COMMENT BIT TRANSFER ERROR; 50205200 + ERRORSET~4096 | 7 +8; 50205300 + END ELSE 50205900 + IF BOOLEAN(UERROR.PRINTCHECK) THEN 50206000 + BEGIN 50207000 +COMMENT BUILD MESSAGE "UNIT PRINT CHECK"; 50208000 +MSGWITHERRCOUNT: % SPOUT(MSGAREA,DISPLAYONPER);% MAR 50209000 +COMMENT TOTALUNITERROR~ * +1; 50210000 + ERRORSET~4096 | 10; 50211000 + GO COMMONCODE; 50212000 + END; 50213000 + END; 50217000 + ; COMMENT DUMMY; 50218000 + BEGIN COMMENT CARD READER; 50219000 +CARDREAD: 50220000 + IF BOOLEAN(UERROR.READCHECK) THEN 50221000 + BEGIN COMMENT READ CHECK ON CARD READER; 50222000 +COMMENT BUILD MESSAGE "UNIT READ CHECK"; 50224000 + MESSER(0 & WHOCALLSL(STDIOERRSEC,4),U); 50224500 + ERRORSET~8; 50225000 + END ELSE 50226000 + IF MEMACCESSERRORTOG THEN 50227000 + IF BOOLEAN(UERROR.READPARITY) THEN 50228000 + BEGIN COMMENT VALIDITY ERROR; 50229000 +COMMENT BUILD MESSAGE "INVALID CHARACTER IN COL"; 50230000 + ERRORSET~ 4096|7 + 9; 50231000 + END ELSE 50232000 + BEGIN % MEMORY ACCESS ERROR- TREAT AS READ CHECK 50233000 + ERRORSET~7; 50234000 + END; 50235000 + GO NOTREADY; 50236000 + END; 50238000 + GO CARDPUNCH; COMMENT CARD PUNCH I; 50240000 +CARDPUNCH: 50242000 + BEGIN COMMENT CARD PUNCH II; 50243000 + IF BOOLEAN(UERROR.PUNCHCHECK) THEN 50244000 + IF MEMACCESSERRORTOG THEN 50245000 + BEGIN % PUNCH CHECK 50247000 + ERRORSET~4096 |10 + 7; 50248000 + GO MSGWITHERRCOUNT; 50249000 + END ELSE 50250000 + BEGIN % MEMORY ACCESS ERROR 50250200 + ERRORSET~10; 50250400 + GO CLEARERROR; 50250600 + END; 50250800 + END; 50251000 + ; COMMENT DUMMY; 50252000 + BEGIN COMMENT MAGNETIC TAPE TRANSPORT; 50252010 + IF MEMACCESSERRORTOG AND 50252020 + BOOLEAN(UERROR.RDOVERFLOW) THEN 50252023 + BEGIN % PARITY ERROR OR MEMORY ACCESS ERROR 50252025 + ERRORSET~ 4096 |7 + 11; 50252030 +COMMENT *********************************************** 50252035 + TAPEPARITYRETRY(RD); 50252040 + GO SETERROR; 50252045 + END; 50252050 + IF BOOLEAN(UERROR.RDNONPRESENT) THEN 50252060 + BEGIN 50252070 +COMMENT NON-PRESENT OPTIONS; 50252080 + MESSER(0 & WHOCALLSL(STDIOERRSEC,0),U); 50252083 + ERRORSET~13; 50252085 + GO SETERROR; 50252090 + END; 50252100 + IF BOOLEAN(IOCW.IOREADBIT) THEN 50252180 + BEGIN COMMENT ERROR ON READ OPERATION; 50252190 + IF BOOLEAN(UERROR.RDENDOFTAPE) THEN 50252200 + BEGIN 50252230 +COMMENT BEGINNING OF TAPE OR END OF TAPE; 50252250 + ERRORSET~8; 50252265 + USER @(IOCB).USEREOFORTBIT~1; 50252267 + END ELSE 50252270 + IF BOOLEAN(UERROR.RDWLOOREOF) THEN 50252275 + BEGIN % END OF FILE 50252280 + ERRORSET~9; 50252290 + USER @(IOCB).USEREOFORTBIT~1; 50252295 + END ELSE 50252320 + IF BOOLEAN(UERROR.INCOMPLETERECORD) THEN 50252360 + BEGIN 50252370 +COMMENT RECORD SHORTER THEN MEMORY ALLOCATED; 50252380 + ERRORSET~10; 50252390 + END ELSE 50252400 + IF BOOLEAN(UERROR.RDOVERFLOW) THEN 50252410 + BEGIN 50252420 +COMMENT RECORD LONGER THEN MEMORY ALLOCATED; 50252430 + ERRORSET~11; 50252440 + END ELSE 50252450 + IF BOOLEAN(UERROR.RDBLANKTAPE) THEN 50252530 + BEGIN 50252540 +COMMENT READ OR SPACED SIX FEET OF BLANK TAPE; 50252550 + ERRORSET~15; 50252560 + USER @(IOCB).USERSPECIALIO ~1; 50252580 + END; 50252600 + END ELSE 50252650 + IF BOOLEAN(UERROR.RDWLOOREOF) THEN 50252700 + BEGIN % NO WRITE RING ON UNIT 50252750 + ERRORSET~9; 50252780 + USER @(IOCB).USERSPECIALIO ~1; 50252784 + MESSER(0 & WHOCALLSL(STDIOERRSEC,5),U); 50252786 + END; 50252790 +CHECKUSER: 50252800 + GO SETERROR; 50252850 + END; 50252900 + END; 50253000 +COMMONCODE: 50254000 + MISC @(IOCB)~RD; 50255000 + DELINK(IOQUE,FIRSTIO[U],U); 50259000 + CAUSE(EVNT @(IOCB)); 50265000 +CLEARERROR: 50266000 + UTABLEENTRY.UERRORSTATUSBITS~0; 50267000 + UNIT[U]~UTABLEENTRY; 50267500 + STARTIO(U); 50268000 +KILLIT: 50269000 + USER @(IOCB).IOERRORRECOVERY~0; 50270000 +SETMEMPARITYERR: 50271000 +INCOMPLETE: 50272000 +ENDOFFILE: 50273000 +COMMENT 50274000 + BREAKTOG~ BREAKTOG-1; 50275000 + HOLD; 50275500 + END IOERROR; 50276000 +REAL PROCEDURE GETUSERDISK(SEGMENTS, ORIGINALSPEED); 52000000 + VALUE SEGMENTS, ORIGINALSPEED; 52001000 + REAL SEGMENTS, ORIGINALSPEED; 52002000 +COMMENT FIND AN AREA OF DISK "SEGMENTS" LARGE, PREFERABLY ON AN 52003000 + EU OF "SPEED" DISK. 52004000 + IF "SPEED" IS NEGATIVE, ITS ABSOLUTE VALUE IS AN EU UNIT 52005000 + NUMBER FROM WHICH THE REOUESTED SEGMENTS SHOULD BE 52006000 + ASSIGNED; 52007000 + BEGIN 52008000 + LABEL FOUND, TRYAGAIN, SEARCH, GETNEXTSPEED, GOTIT; 52009000 + REAL DISKUNIT, T, I, ORIGINALUNIT, INDEX, STOPPER, MAXINDEX, K, J, 52010000 + SPEED := ORIGINALSPEED, T1; 52011000 + BOOLEAN FAILED; 52012000 + ARRAY ROW[*]; 52013000 + LAYOUT DISKSEARCHL(UNITTYPE, DENSITYF); 52014000 +REAL GETDISK; 52015000 +MONITOR STEVEMONITOR(SEGMENTS,SPEED,DISKUNIT,STOPPER,GETDISK); 52016000 +GETDISK:=*;SEGMENTS:=*;SPEED:=*;%FOR MONITOR 52017000 +RETURN(MCPTOP+10);COMMENT TEMP FOR SIMULATION**************************;52018000 + PROCURE(USERDISKLOCK); 52019000 + IF SPEED < 0 THEN 52020000 + ORIGINALSPEED := SPEED := UNIT[ORIGINALUNIT := DISKUNIT := 52021000 + ABS(SPEED)].DENSITYF 52022000 + ELSE 52023000 +TRYAGAIN: 52024000 + ORIGINALUNIT := DISKUNIT := NEXTEU[SPEED]; 52025000 +SEARCH: 52026000 + FOR I := MASKSEARCH(0&USERDISKHEADWORD(*,DISKUNIT,*), 52027000 + 0&USERDISKHEADWORD(*,4"FF",*), GETUSERDISKHEAD) 52028000 + STEP -1 WHILE (T := GETUSERDISKHEAD[I]).EUNOF = DISKUNIT DO 52029000 + IF T.ADDRESSF } SEGMENTS THEN GO FOUND; 52030000 + FAILED := TRUE; 52031000 +COMMENT THE FOLLOWING DOES NOT COMPILE... YET 52032000 + IF DISKUNIT ! 0 THEN 52033000 + IF DISKUNIT := MASKSEARCH(0&DISKSEARCHL(DISKFILE,SPEED),0& 52034000 + DISKSEAHCHL(4"FF", 4"F"), UNIT[DISKUNIT-1]) > 0 THEN 52035000 + IF DISKUNIT ! ORIGINALUNIT THEN 52036000 + GO SEARCH 52037000 + ELSE 52038000 + GO GETNEXTSPEED; 52039000 + IF DISKUNIT := MASKSEARCH(0&DISKSEARCHL(DISKFILE,SPEED),0& 52040000 + DISKSEARCHL(4"FF", 4"F"), UNIT) > ORIGINALUNIT THEN 52041000 + GO SEARCH; 52042000 +GETNEXTSPEED: 52043000 + IF SPEED := IF ORIGINALSPEED { 1 THEN (SPEED + 1) MOD 4 ELSE 52044000 + CASE (SPEED + 4 | ORIGINALSPEED) - 8 OF ( 52045000 + 2,0,3,1, 52046000 + 3,0,1,2 52047000 + ) ! ORIGINALSPEED THEN 52048000 + GO TRYAGAIN; 52049000 + COMMENT WE HAVE TRIED.... OH HOW WE HAVE TRIED, BUT IT JUST 52050000 + DID NOT WORK; 52051000 + LIBERATE(USERDISKLOCK); 52052000 +GETDISK:=ABS(REAL(NOT FALSE)); 52053000 + RETURN(NOUSERDISK(SEGMENTS, SPEED)); 52054000 +FOUND: 52055000 + ROW := USERDISKLIST[INDEX := T.USERDISKINDEXF, *]; 52056000 + STOPPER := 0&DISKADDRESSL(REAL(NOT BOOLEAN(DISKUNIT)), *); 52057000 + FOR J := MAXINDEX := ROW.LENGTHF - 1 STEP - 1 WHILE 52058000 + (T := ROW[J]) ! STOPPER DO 52059000 + IF T.DISKAREASIZEF } SEGMENTS THEN 52060000 + GO TO GOTIT; 52061000 + COMMENT USER DISK FAILURE IF WE GET HERE; 52062000 +GETDISK:=REAL(NOT FALSE); 52063000 + HOLD; 52064000 +GOTIT: 52065000 + IF T.DISKAREASIZEF = SEGMENTS THEN 52066000 + BEGIN 52067000 + FOR K := J - 1 STEP -1 WHILE T1 := ROW[K] ! STOPPER DO 52068000 + ROW[K+1] := T1; 52069000 + ROW[K+1] := STOPPER; 52070000 + IF J = MAXINDEX THEN 52071000 + BEGIN COMMENT THE ROW IS EMPTY NOW; 52072000 + END 52073000 + END 52074000 + ELSE 52075000 + ROW[J] := (T.DISKADDRESSF + SEGMENTS) & DISKAREAWORDL( 52076000 + T.DISKAREASIZEF - SEGMENTS, *); 52077000 + IF J > 0 THEN 52078000 + IF ROW[J-1] = STOPPER THEN 52079000 + FORGETUSERDISKHEAD[MASKSEARCH(0&USERDISKHEADWORD(INDEX), 52080000 + 0&USERDISKHEADWORD(REAL(NOT FALSE)), 52081000 + FORGETUSERDISKHEAD)].ADDRESSF := ROW[J+1]; 52082000 + IF SEGMENTS = GETUSERDISKHEAD[I].ADDRESSF THEN 52083000 + BEGIN 52084000 + J := 0; 52085000 + FOR K := MAXINDEX STEP -1 WHILE T1 := ROW[K] ! STOPPER DO 52086000 + IF J < T1 := T1.DISKAREASIZEF THEN 52087000 + J := T1; 52088000 + GETUSERDISKHEAD[I].ADDRESSF := J; 52089000 + END; 52090000 + LIBERATE(USERDISKLOCK); 52091000 +GETDISK:=T.DISKADDRESSF; 52092000 + RETURN(T.DISKADDRESSF); 52093000 + END GETUSERDISK; 52094000 +PROCEDURE FORGETUSERDISK(DKADDR, SEGMENTS); 52095000 + VALUE DKADDR, SEGMENTS; 52096000 + REAL DKADDR, SEGMENTS; 52097000 + COMMENT RETURN "SEGMENTS" STARTING AT "DKADDR"; 52098000 + BEGIN 52099000 + REAL I, J, K, L, N, T, INDEX, STOPPER, MAXINDEX, 52100000 + RIGHTENDADDRESS ~ DKADDR + SEGMENTS, 52101000 + DISKUNIT ~ DKADDR.EUNOF; 52102000 + LABEL PUTITBACK, CLEANUP; 52103000 + ARRAY ROW[*]; 52104000 + BOOLEAN STOPPERINSERT, LEFTENDCHECK; 52105000 +REAL FORGETDISK; 52106000 +MONITOR STEVEMONITOR (INDEX,DISKUNIT,RIGHTENDADDRESS,DKADDR,FORGETDISK, 52107000 + SEGMENTS, STOPPER); 52108000 +FORGETDISK:=*;DKADDR:=*;RIGHTENDADDRESS:=*;DISKUNIT:=*;%FOR MONITOR 52109000 + PROCURE(USERDISKLOCK); 52110000 + STOPPER ~ 0&DISKADDRESSL(REAL(NOT BOOLEAN(DISKUNIT)), *); 52111000 + FOR I ~ MASKSEARCH(0&DISKADDRESSL(DISKUNIT,*),0&DISKADDRESSL(4"FF", 52112000 + *), FORGETUSERDISKHEAD) STEP - 1 WHILE (T ~ FORGETUSERDISKHEAD[I])52113000 + .EUNOF ! DISKUNIT DO 52114000 + IF T.DISKADDRESSF < DKADDR THEN GO PUTITBACK; 52115000 + T ~ FORGETUSERDISKHEAD[I+1]; 52116000 +PUTITBACK: 52117000 + ROW ~ USERDISKLIST[INDEX ~ T.USERDISKINDEXF, *]; 52118000 + FOR J ~ MAXINDEX ~ ROW.LENGTHF - 1 STEP - 1 WHILE T ~ ROW[J] ! 52119000 + STOPPER DO 52120000 + IF T.DISKADDRESSF = RIGHTENDADDRESS THEN 52121000 + BEGIN 52122000 + SEGMENTS ~ * + T ~ T.DISKAREASIZEF; 52123000 + ROW[J] := STOPPER; 52124000 + STOPPERINSERT ~ TRUE; 52125000 + RIGHTENDADDRESS ~ * + T; 52126000 + END ELSE 52127000 + IF T.DISKADDRESSF + T.DISKAREASIZEF = DKADDR THEN 52128000 + BEGIN 52129000 + ROW[J].DISKAREASIZEF ~ SEGMENTS ~ T.DISKAREASIZEF + 52130000 + SEGMENTS; 52131000 + RIGHTENDADDRESS ~ (DKADDR ~ ROW[J].DISKADDRESSF) + 52132000 + SEGMENTS; 52133000 + GO TO CLEANUP; 52134000 + END ELSE 52135000 + IF T.DISKADDRESSF < DKADDR THEN 52136000 + BEGIN 52137000 + REPLACE POINTER(ROW[0],*) BY POINTER(ROW[1],*) FOR 52138000 + I WORDS; 52139000 + ROW[J] ~ DKADDR & DISKAREAWORDL(SEGMENTS, *); 52140000 + GO TO CLEANUP; 52141000 + END; 52142000 + ROW[J] ~ DKADDR & DISKAREAWORDL(SEGMENTS, *); 52143000 + LEFTENDCHECK ~ TRUE; 52144000 +CLEANUP: 52145000 + IF J = MAXINDEX AND I < FORGETUSERDISKHEAD.LENGTHF - 1 THEN 52146000 + IF RIGHTENDADDRESS = FORGETUSERDISKHEAD[I+1]. 52147000 + DISKADDRESSF THEN 52148000 + BEGIN 52149000 + ROW[J].DISKAREASIZEF ~ SEGMENTS + L ~ USERDISKLIST[ 52150000 + K ~ FORGETUSERDISKHEAD[I+1].USERDISKINDEXF, T ~ 52151000 + MASKSEARCH(STOPPER, REAL(NOT FALSE), 52152000 + USERDISKLIST[I+1,*]) + 1].DISKAREASIZEF; 52153000 + IF T = MAXINDEX THEN 52154000 + BEGIN COMMENT THE ROW IS EMPTY NOW; 52155000 + END 52156000 + ELSE 52157000 + BEGIN 52158000 + USERDISKLIST[K,T] ~ STOPPER; 52159000 + FORGETUSERDISKHEAD[I+1].DISKADDRESSF ~ 52160000 + USERDISKLIST[K,T+1]; 52161000 + IF GETUSERDISKHEAD[N ~ MASKSEARCH( 52162000 + 0&USERDISKHEADWORD(K,*),0&USERDISKHEADWORD( 52163000 + REAL(NOT FALSE),*), GETUSERDISKHEAD)]. 52164000 + ADDRESSF = L THEN 52165000 + BEGIN 52166000 + J := 0; 52167000 + FOR T := MAXINDEX STEP -1 WHILE L := 52168000 + USERDISKLIST[K,T] ! STOPPER DO 52169000 + IF L := L.DISKAREASIZEF > J THEN 52170000 + J := L; 52171000 + GETUSERDISKHEAD[N].ADDRESSF := J; 52172000 + END; 52173000 + END; 52174000 + IF LEFTENDCHECK AND I > 0 THEN 52175000 + IF (T ~ FORGETUSERDISKHEAD[I-1]).EUNOF = DISKUNIT THEN 52176000 + IF DKADDR = (L ~ USERDISKLIST[K ~ T.USERDISKINDEXF, 52177000 + MAXINDEX]).DISKADDRESSF + L.DISKAREASIZEF THEN 52178000 + BEGIN 52179000 + USERDISKLIST[K,MAXINDEX].DISKAREASIZEF ~ L ~ 52180000 + L.DISKAREASIZEF + SEGMENTS; 52181000 + ROW[J] ~ STOPPER; 52182000 + IF J = MAXINDEX THEN 52183000 + BEGIN COMMENT THIS ROW IS EMPTY; 52184000 + END; 52185000 + IF GETUSERDISKHEAD[N ~ MASKSEARCH( 52186000 + 0&USERDISKHEADWORD(K,*),0&USERDISKHEADWORD( 52187000 + REAL(NOT FALSE),*), GETUSERDISKHEAD)]. 52188000 + ADDRESSF < L THEN 52189000 + GETUSERDISKHEAD[N].ADDRESSF := L; 52190000 + END; 52191000 + END; 52192000 + IF STOPPERINSERT THEN 52193000 + BEGIN 52194000 + FOR L ~ N ~ MAXINDEX STEP - 1 UNTIL 0 DO 52195000 + IF ROW[L] ! STOPPER THEN 52196000 + BEGIN 52197000 + ROW[N] ~ ROW[L]; N ~ N - 1; 52198000 + END; 52199000 + REPLACE POINTER(ROW[0]) BY STOPPER FOR N WORDS; 52200000 + END; 52201000 + IF T ~ ROW[0] ! STOPPER THEN 52202000 + BEGIN COMMENT FULL ROW; 52203000 + IF N ~ MASKSEARCH(0, REAL(NOT FALSE), 52204000 + USERDISKDOPEVECTOR) < 0 THEN 52205000 + BEGIN COMMENT SPACE EXPANSION REQUIRED; 52206000 + END; 52207000 + USERDISKLIST[N,*] ~ DUMMYAREA&ARRAYDESCL(0,MAXINDEX+1,0); 52208000 + REPLACE POINTER(USERDISKLIST[N,0]) BY STOPPER FOR L ~ 52209000 + MAXINDEX DIV 2 WORDS, POINTER(ROW[0]) FOR L WORDS; 52210000 + REPLACE POINTER(ROW[0]) BY STOPPER FOR L WORDS; 52211000 + REPLACE POINTER(FORGETUSERDISKHEAD[0]) BY 52212000 + POINTER(FORGETUSERDISKHEAD[1]) FOR I WORDS; 52213000 + FORGETUSERDISKHEAD[I-1] ~ T & USERDISKHEADWORD(N,*); 52214000 + T ~ 0; 52215000 + FOR L ~ MAXINDEX - L STEP 1 UNTIL MAXINDEX DO 52216000 + IF T < K ~ USERDISKLIST[N,L].DISKAREASIZEF THEN 52217000 + T ~ K; 52218000 + FOR L ~ MASKSEARCH(0&USERDISKHEADWORD(L,*), 52219000 + 0&USERDISKHEADWORD(REAL(NOT FALSE), *), 52220000 + GETUSERDISKHEAD) STEP - 1 WHILE GETUSERDISKHEAD[L]. 52221000 + EUNOF ! DISKUNIT DO; 52222000 + REPLACE POINTER(GETUSERDISKHEAD[0]) BY 52223000 + POINTER(GETUSERDISKHEAD[1]) FOR L WORDS; 52224000 + GETUSERDISKHEAD[L] ~ T & USERDISKHEADWORD(N,DISKUNIT,*); 52225000 + END; 52226000 + FORGETUSERDISKHEAD[I] ~ ROW[L ~ MASKSEARCH(STOPPER, 52227000 + REAL(NOT FALSE), ROW) + 1] & USERDISKHEADWORD(INDEX,*); 52228000 + T ~ 0; 52229000 + FOR L ~ L STEP 1 UNTIL MAXINDEX DO 52230000 + IF T < K ~ ROW[L].DISKAREASIZEF THEN 52231000 + T ~ K; 52232000 + GETUSERDISKHEAD[MASKSEARCH(0&USERDISKHEADWORD(INDEX,*), 52233000 + 0&USERDISKHEADWORD(REAL(NOT FALSE),*), GETUSERDISKHEAD)] ~ 52234000 + T; 52235000 + LIBERATE(USERDISKLOCK); 52236000 + EXIT; 52237000 +FORGETDISK:=1; 52238000 + END FORGETUSERDISK; 52239000 +REAL PROCEDURE NOUSERDISK(SEGMENTS, SPEED); 52240000 + VALUE SEGMENTS, SPEED; 52241000 + REAL SEGMENTS, SPEED; 52242000 + COMMENT THIS PROCEDURE MANAGES TO OBTAIN THE DISK REQUIRED BY 52243000 + CAUSING FILES TO BE UNLOADED TO BACKUP; 52244000 + BEGIN 52245000 + REAL DISKPUNT;%FOR MONITOR ONLY 52246000 +MONITOR STEVEMONITOR(DISKPUNT); 52247000 +DISKPUNT :=1;%FOR MONITOR ONLY 52248000 + HOLD; 52249000 + END; 52250000 +PROCEDURE RELEASEHEADER(HEADER, CODE); 55000000 + VALUE HEADER, CODE; 55001000 + WORD HEADER; 55002000 + REAL CODE; 55002500 + COMMENT A CALL ON THIS PROCEDURE WILL RELEASE THE CALLER"S USE OF 55003000 + A DISK FILE HEADER. DEPENDING ON THE VALUES OF CODE, AND 55004000 + VARIOUS BITS IN THE HEADER ITSELF, OTHER WONDEROUS THINGS WILL 55005000 + HAPPEN. 55006000 + ; 55007000 + BEGIN 55008000 + REAL COUNT, T, INDEX = HEADER; 55009000 + ARRAY HDR[*]; 55010000 +REAL RELHDR; 55011000 +MONITOR STEVEMONITOR(HEADER, CODE, COUNT, RELHDR); 55012000 +RELHDR:=*;CODE:=*;INDEX:=*;%MONITOR 55013000 +COMMENT SOME PEOPLE PASS ME A DESCRIPTOR, SO I MUST FIND THE 55013100 + ACTUAL INDEX; 55013150 + IF HEADER.TAG ! SINGL THEN 55013200 + IF HEADER := MASKSEARCH(HEADER, 4"80FFFFFFFFFF" & 55013250 + SETTAG(DATADESC), DISKFILEHEADERSDOPEVECTOR) 55013300 + < 0 THEN 55013350 + STOP; COMMENT THE CALLER BLEW IT; 55013500 +EXIT;%DON"T SCREW UP ANYTHING DIRECTORYSEARCH DIDN"T DO 55013600 + HDR := DISKFILEHEADERS[INDEX, *]; 55014000 + PROCURE(HEADERLOCK); 55015000 + IF HEADERUPDATED(HDR) OR COUNT := OPENCOUNT(HDR) - 1 = 0 THEN 55016000 + BEGIN 55017000 + T := READLOCK(IF COUNT = 0 THEN 0 ELSE INDEX, HDR[0]); 55018000 + DISKWAIT(HDR, -1, HEADERSIZE(HDR), M[HDR.ADDRESSF - 1]. 55019000 + DISKADDRESSF, @40); 55020000 + HDR[6] := T; 55021000 + END DISK COPY UPDATING; 55022000 + IF COUNT ! 0 THEN 55023000 + BEGIN 55024000 + OPENCOUNT(HDR) := COUNT; 55025000 + END 55026000 + ELSE IF INDEX ! 0 THEN 55027000 + BEGIN 55028000 + DISKFILEHEADERS[INDEX, *] := HDR & ARRAYDESCL(0,0,0); 55029000 + FORGETSPACE(HDR.ADDRESSF); 55030000 + END; 55031000 + LIBERATE(HEADERLOCK); 55032000 +RELHDR:=1; 55033000 + EXIT; 55034000 + END RELEASEHEADER; 55035000 + REAL PROCEDURE SCRAMBLEINX(P, MODULUS); 55036000 + VALUE P, MODULUS; 55037000 + POINTER P; 55038000 + REAL MODULUS; 55039000 + BEGIN 55040000 + REAL S, I, J; 55041000 + J~ (J~ REAL(P, 1))-(I~ J MOD 4); 55042000 + IF I>0 THEN S~ REAL(P, I); 55043000 + IF J>0 THEN 55044000 + FOR I~ I+1 BY 4 UNTIL J DO 55045000 + S~ S+REAL(P+I, 4); 55046000 + RETURN(S MOD MODULUS); 55047000 + END CALCULATE SCRAMBLE INDEX; 55048000 +REAL PROCEDURE SUBDIRECTORYSEARCH(HDR, NMP); 55049000 + VALUE NMP; 55050000 + ARRAY HDR[*]; 55051000 + POINTER NMP; 55052000 + COMMENT THIS IS THE GUTS OF THE SEARCH MECHANISM OF 55053000 + DIRECTORYSEARCH. 55054000 + HDR IS A CORE AREA CONTAINING A DIRECTORY HEADER AND AN I/O 55055000 + BUFFER AREA. 55056000 + NMP IS A POINTER TO THE NAME WHICH IS HOPED TO EXIST AT THIS 55057000 + LEVEL IN THE DIRECTORY. IT IS IN THE FORM 55058000 + "NXX...X" 55059000 + WHERE N IS THE NUMBER OF CHARACTERS IN THE NAME. 55060000 + THE NAME SOUGHT IS FOUND, SUBDIRECTORYSEARCH RETURNS THE 55061000 + INDEX INTO HDR OF THE DIRECTORY ENTRY ASSOCIATED WITH THAT 55062000 + NAME. OTHERWISE, IT RETURNS A NEGATIVE NUMBER, WHICH 55063000 + MAY HAVE SIGNIFICANCE AT A LATER DATE. 55064000 + ; 55065000 + BEGIN 55066000 + LAYOUT LEFTJUSTIFY(8|(6-I):8|I), FIRSTCHR(47:8); 55067000 + REAL I, J, MODX, INDEX, NOMEN, CHRS; 55068000 + REAL RWSZ := ROWSIZE(HDR); 55069000 + ARRAY TNAME[3]; 55070000 + LABEL RESTART, OUT; 55071000 + DEFINE WHATSTHEADDRESS(RECORDNO) = 55072000 + HDR[FIRSTROWINDEX + (MODX ~ RECORDNO | 55073000 + SEGMENTSPERDIRECTORYBITE) DIV RWSZ] + MODX MOD RWSZ # 55074000 + ; 55075000 +REAL SUBSRCH; 55076000 +MONITOR STEVEMONITOR(MODEX,SUBSRCH,INDEX,NOMEN); 55077000 +MONITOR STEVEMONITOR(SUBDIRECTORYSEARCH); 55078000 +SUBSRCH:=*; 55079000 + IF J := NMP.SZF ! EBCDIC THEN 55080000 + BEGIN 55081000 + I := 6; 55082000 + CHRS := REAL(NMP,1); 55083000 + IF J = BCL THEN 55084000 + REPLACE POINTER(TNAME,8) + 1 BY NMP + 1 FOR CHRS WITH 55085000 + BCLTOEBC 55086000 + ELSE 55087000 + REPLACE POINTER(TNAME,8) + 1 BY NMP + 1 FOR CHRS WITH 55088000 + HEXTOEBC; 55089000 + TNAME[0] := * & FIRSTCHR(CHRS); 55090000 + END; 55091000 + INDEX := (HEADERSIZE(HDR) + 29) DIV 30 - 1; 55092000 + NOMEN := 0&LEFTJUSTIFY(REAL(NMP, I ~ MIN(CHRS ~ REAL(NMP,1)+1,6))); 55093000 + IF MODX := SCRAMBLEMOD(HDR) > 1 THEN 55094000 + MODX := SCRAMBLEINX(NMP, MODX); 55095000 + IF MODX ! HDR[INDEX + 3] THEN 55096000 + DISKWAIT(HDR, INDEX-1, DIRECTORYBITE, 55097000 + WHATSTHEADDRESS(MODX), @440); 55098000 +RESTART: 55099000 + FOR I := INDEX+4 STEP 5 WHILE NOT BOOLEAN(HDR[I]) DO 55100000 + IF NOMEN IS HDR[I+2] THEN 55101000 + IF NMP = POINTER(HDR[I+2], 8) FOR CHRS THEN 55102000 + BEGIN 55103000 + SUBDIRECTORYSEARCH := I; 55104000 + GO OUT; 55105000 + END; 55106000 + IF HDR[I] = 3 THEN 55107000 + BEGIN 55108000 + DISKWAIT(HDR, INDEX-1, DIRECTORYBITE, WHATSTHEADDRESS( 55109000 + HDR[INDEX]), @440); 55110000 + GO RESTART; 55111000 + END; 55112000 + SUBDIRECTORYSEARCH := -1; 55113000 +OUT: 55114000 +SUBSRCH:=1; 55115000 + END SUBDIRECTORYSEARCH; 55116000 +REAL PROCEDURE DIRECTORYSEARCH(NMP, CODE, LOCKIT); 55117000 + VALUE NMP, CODE, LOCKIT; 55118000 + POINTER NMP; 55119000 + REAL CODE; 55120000 + BOOLEAN LOCKIT; 55121000 + COMMENT DIRECTORYSEARCH WILL ATTEMPT TO FIND THE FILE WHOSE 55122000 + STANDARDFORM NAME IS POINTED TO BY NMP. THE FORM OF THIS NAME 55123000 + IS: 55124000 + NMXXX...XXMXX...XX... 55125000 + WHERE N IS THE NUMBER OF NAMES AND M IS THE CHARACTER COUNT 55126000 + FOR A NAME. 55127000 + IF SUCCESSFUL IN FINDING THE FILE, DIRECTORYSEARCH WILL SET 55128000 + UP THE FILE HEADER AS A ROW IN "DISKFILEHEADERS" AND RETURN 55129000 + THE ROW INDEX OF THIS HEADER. 55130000 + IF UN-SUCCESSFUL, A NEGATIVE NUMBER WILL BE RETURNED. THE 55131000 + DCODE1 FIELD OF THIS NUMBER WILL CONTAIN THE NUMBER OF THE 55132000 + NAME ON WHICH THE SEARCH FAILED, THE ADDRESS FIELD WILL CONTAIN55133000 + A CODE INDICATING THE REASON THE SEARCH FAILED (I.E. NO FILE, 55134000 + NON-DIRECTORY FOUND WHEN DIRECTORY REQUIRED, SECURITY BLOCK). 55135000 + ; 55136000 + BEGIN 55137000 + REAL DEPTH := REAL(NMP, 1); 55138000 + REAL I, J, SIZE, DKADDR; 55139000 + LABEL THEEND; 55140000 + BOOLEAN FILE, ALREADYTHERE; 55141000 + ARRAY HDR[*]; 55142000 + DEFINE 55143000 + EVENTT = HEADEREVENTS[INDEX] #, 55144000 + HDRINFO = HDR[J] #, 55145000 + NOBODYTHERE = - NOSUCHFILE #, 55146000 + UNMOGLICH = - NOTAVALIDFILENAME #, 55147000 + WRONGEN = - FILEWITHWRONGGENEOLOGY #; 55148000 +REAL DIRSRCH; 55149000 +MONITOR STEVEMONITOR (CODE,LOCKIT,DIRSRCH,SIZE,DEPTH,DKADDR); 55150000 +MONITOR STEVEMONITOR (DIRECTORYSEARCH); 55151000 +DIRSRCH:=*;DEPTH:=*; 55152000 + PROCURE(DIRECTORYLOCK); 55154000 + HDR := SYSTEMDIRECTORY; 55155000 + NMP := NMP + 1; 55156000 +GO TO THEEND; % * KLUDGE FOR SIMULATING * 55156010 + FOR I := 0 STEP 1 UNTIL DEPTH DO 55157000 + BEGIN 55158000 + IF J := SUBDIRECTORYSEARCH(HDR, NMP) < 0 THEN 55159000 + BEGIN 55160000 + DIRECTORYSEARCH := NOBODYTHERE & DIRECTORYSEARCHCODES(I); 55161000 + GO TO THEEND; 55162000 + END; 55163000 + IF HDRINFO.FILEKINDF ! DIRECTORY AND I ! DEPTH THEN 55164000 + BEGIN 55165000 + DIRECTORYSEARCH := UNMOGLICH & DIRECTORYSEARCHCODES(I); 55166000 + GO TO THEEND; 55167000 + END; 55168000 + DKADDR := HDR[J+1]; 55169000 + IF I = 0 OR HDR.LENGTHF < SIZE := (HDRINFO.HEADERSIZEF + 29) 55170000 + DIV 30 + DIRECTORYBITE OR FILE := HDRINFO.FILEKINDF > 55171000 + DIRECTORY THEN 55172000 + BEGIN 55173000 + IF I ! 0 THEN 55174000 + FORGETSPACE(HDR.ADDRESSF); 55175000 + HDR := HDR & ARRAYDESCL(0, IF FILE THEN SIZE := HDRINFO. 55176000 + HEADERSIZEF ELSE SIZE, 1); 55177000 + END; 55178000 + IF ALREADYTHERE := J := HDR[0] ! 0 THEN 55179000 + DISKWAIT(HDR, -1, SIZE, DKADDR, @440); 55180000 + BEGIN 55181000 + END; 55182000 + END; 55183000 + IF NOT ALREADYTHERE THEN 55184000 + M[HDR.ADDRESSF - 1] := DKADDR & SETTAG(MEMLINK); 55185000 +THEEND: 55186000 + LIBERATE(DIRECTORYLOCK); 55187000 +DIRSRCH:=1; 55188000 + END DIRECTORYSEARCH; 55189000 +SAVE 1 PROCEDURE PERIPHERALINITIALIZE; 59000000 + BEGIN 59001000 + COMMENT THIS PROCEDURE EVENTUALLY WILL RE BUILD THE DIRECTORY, 59002000 + BUILD THE ESPDISK AND USERDISK MAPS, ETC. IT WILL ALSO CONTAIN59003000 + THE DCP INITIALIZATION CODE (WHATEVER THAT IS). RIGHT NOW ALL 59004000 + IT DOES IS BUILD THE PERIPHERAL TABLES, REWIND TAPES AND WRITE 59005000 + HALT LOAD MESSAGES ON THE SUPERVISORY CONSOLES THAT HAPPEN TO 59006000 + BE IN RECEIVE MODE; 59007000 + SAVE ARRAY TUNITS, IOAREA, DISKS [256]; 59008000 + REAL I, UNID, MAXU, TOTALEU, T1, J, UMPXD, FIRSTREADY, T, 59011000 + DIRECTORYHEADERSIZE := 30, %THE ":= 30" IS TEMPORARY 59011100 + DISKUSERW = MAXU, SWITCHES = UMPXD; 59012000 + POINTER TP; 59013000 + ARRAY SLCDESC[*]; 59014000 + WORD WIPEOUTPCW = PERIPHERALINITIALIZE; 59015000 + DEFINE TYPEINT = TYPEINTERROGATE #, 59016000 + PATHINT = TYPEINTERROGATE #, 59017000 + TYPECNTR = TUNITS #; 59018000 + DEFINE INITIALIZERARRAY(QARRAY, RARRAY, LENGTH) = 59019000 + REPLACE POINTER(RARRAY) BY POINTER(QARRAY) 59020000 + FOR LENGTH OVERWRITE #; 59021000 + DEFINE STATE (I) = BOOLEAN(SCANIN(0 & USTATUSWORD(I.DIV32F, 59021100 + ,*,*))).[I.MOD32F+1:1] #; 59021200 + DEFINE UNITREALLYOUTTHERE= UNID>0#;% 59021300 + FIELD DUNITF = DIAGNOSTICUNIT.MOD32F:1, 59022000 + BITF = I.MOD32F:1; 59023000 + PROCEDURE DISKMAPPER; 59024000 + BEGIN 59025000 + SAVE ARRAY LLLARRAY[LLLROWS, LLLCHUNK]; 59026000 + WORD ARRAY DOPEVECTOR1 = DISKFILEHEADERS [*], 59026100 + DOPEVECTOR2 = USERDISKLIST [*]; 59026200 + COMMENT THESE ARE USED TO CREATE THE DOPE 59026300 + VECTORS FOR THE GLOBAL TWO DIMENSIONAL ARRAYS TO59026400 + WHICH THEIR ADDRESSES ARE EQUATED. 59026500 + ; 59026600 + ARRAY SWITCHPOINTS[*]; 59026700 + BOOLEAN READY; 59027000 +MONITOR STEVEMONITOR( SWITCHES,UNID,T1,READY,NEXTADDR); 59027100 +SAVE %SO THE MONITOR DOESNT MAKE IT A SEGMENT 59027990 + BOOLEAN PROCEDURE TESTSWITCH(USERW, SWITCH); 59028000 + VALUE USERW, SWITCH; 59029000 + REAL USERW, SWITCH; 59030000 + BEGIN 59031000 +BOOLEAN NTRDY; MONITOR STEVEMONITOR (NTRDY); 59031100 + IOAREA[0] := SET(DECIMAL(SWITCH), 38); % TEST S. U. 59032000 +IF NOT SIMULATING THEN IOAREA[0]~*&IOCWL(@440,*);%KLUDGE FOR DFC 1 & 2 59032010 +NTRDY := %FOR MONITOR ONLY 59032990 + TESTSWITCH ~ BOOLEAN(WAITIO(IOAREA, USERW, REAL(NOT FALSE)59033000 + ).RDNOTREADY); 59034000 + END; 59035000 + DEFINE CHECKFOROVERFLOW = 59036000 + IF NEXTADDR ~ * + 2 } MAXADDR THEN 59037000 + BEGIN 59038000 + LLLARRAY[NEXTROW ~ * + 1, 0] ~ 0; 59039000 + MAXADDR ~ (NEXTADDR ~ LLLARRAY[NEXTROW, *].ADDRESSF) 59040000 + + LLLCHUNK; 59041000 + END 59042000 + #; 59043000 + DOPEVECTOR1 := DOPEVECTOR1 & ARRAYDESCL(0, 59074100 + HEADERSTOSTARTWITH, 0); 59074150 + DOPEVECTOR2 := DOPEVECTOR2 & ARRAYDESCL(0, 59074200 + TOTALEU | EUFACTOR, 0); 59074250 + INITIALIZEARRAY(SYSTEMDIRECTORY, SYSTEMDIRECTORY, 59074300 + DIRECTORYHEADERSIZE + DIRECTORYBITE); 59074320 + DOPEVECTOR1[0] := SYSTEMDIRECTORY & ARRAYDESCL(,*,*); 59074340 + COMMENT NOTE THE TWO NAMES FOR THE SAME AREA; 59074360 + M[DOPEVECTOR1.ADDRESSF + DOPEVECTOR1.LENGTHF]. 59074380 + SPACEOLAYLOCK := 0; %MAKE IT SAVE AT HIGH MEMORY END 59074390 + DOPEVECTOR1[1] := 0 & DATADESCRIPTOR(,*); 59074400 + REPLACE POINTER(DOPEVECTOR1[2],*) BY 59074420 + POINTER(DOPEVECTOR1[1],*) FOR HEADERSTOSTARTWITH 59074450 + - 2 OVERWRITE; 59074480 + DOPEVECTOR2[0] := 0 & DATADESCRIPTOR(,*,*,*,*,*,*,*, 59074500 + USERDISKLISTROWSIZE, 1); 59074520 + REPLACE POINTER(DOPEVECTOR2[1],*) BY 59074550 + POINTER(DOPEVECTOR2[0],*) FOR TOTALEU | EUFACTOR 59074580 + - 1 OVERWRITE; 59074600 + M[DOPEVECTOR2.ADDRESSF + DOPEVECTOR2.LENGTHF]. 59074640 + SPACEOLAYLOCK := 0; %MAKE IT SAVE AT HIGH MEMORY END 59074680 + GETUSERDISKHEAD := FORGETUSERDISKHEAD := 59074700 + GETUSERDISKHEAD & ARRAYDESCL(0,TOTALEU|EUFACTOR,1); 59074800 +COMMENT KLUDGE IT UP FOR DIRECTORY SEARCHERS; 59074900 +DISKFILEHEADERS[0,10]:=IF SIMULATING THEN 0&DISKADDRESSL(DISKB,*) ELSE 59074950 +1250 & DISKADDRESSL(MCPDISKUNITNO,*); 59074960 + TOTALEU ~ * - 1; 59076000 + MAXADDR ~ NEXTROW ~ -1; 59077000 + LASTADDR := IOAREA.ADDRESSF; %FOR THE FIRST STORE 59077100 + FOR J ~ 0 STEP 1 UNTIL TOTALEU DO 59078000 + BEGIN 59079000 + IOAREA[0] := SET(0, 38); %TEST DISK TYPE 59080000 + SWITCHES := (SWITCHPOINTS := 59080050 + CASE T1 := WAITIO(IOAREA, DISKUSERW := 0 & 59080100 + USERL(*,,UNID := DISKS[J], ), REAL(NOT FALSE))59080200 + .RDDISKFILETYPEF OF ( 59080300 + DISKFILE1C5, 59080400 +IF SIMULATING THEN DISKFILESIM ELSE 59080500 + DISKFILE1AX, 59080600 + DISKFILE1C3, 59080700 + DISKFILE1C4 59080800 + )).LENGTHF - 1; 59080900 + UNIT[UNID].DENSITYF := T1; 59080950 + READY := FALSE; 59080960 + FOR I := 0 STEP 4 UNTIL SWITCHES DO 59081000 + IF TESTSWITCH(DISKUSERW, SWITCHPOINTS[I]) THEN 59082000 + IF READY THEN 59083000 + BEGIN 59084000 + CHECKFOROVERFLOW; 59085000 +T1 := %FOR MONITORING 59085010 + M[NEXTADDR] ~ 0 & FIRSTMAPWORD( 59086000 + UNID, SWITCHPOINTS[FIRSTREADY], *); 59087000 +T1 := %FOR MONITORING 59087010 + M[NEXTADDR+1] ~ SWITCHPOINTS[I] - 59088000 + SWITCHPOINTS[FIRSTREADY]; 59089000 + M[LASTADDR].ADDRESSF := 59090000 + LASTADDR := NEXTADDR; 59091000 + READY ~ FALSE; 59093000 + END 59094000 + ELSE 59095000 + ELSE 59096000 + IF NOT READY THEN 59097000 + BEGIN 59098000 + READY ~ TRUE; 59099000 + FIRSTREADY ~ I; 59100000 + END; 59101000 + END; 59102000 + CHECKFOROVERFLOW; 59103000 + FIRSTADDR := LLLARRAY[0,*].ADDRESSF; 59104000 + M[NEXTADDR] ~ 0 & FIRSTMAPWORDPRIME(REAL(NOT FALSE), *); 59105000 +IF FIRSTADDR = NEXTADDR THEN EXIT; % BECAUSE SOMETHING SCREWED UP 59105100 + M[LASTADDR].ADDRESSF ~ NEXTADDR; 59106000 + DISKMAPARRAY := LLLARRAY; 59106100 + GIVEBACKDISK(MCPDISKBASE, MCPINFO.ADDRESF + 59107000 + (MCPINFOSIZE DIV 30)); 59108000 + EXIT; 59108100 + END DISKMAPPER; 59109000 + MCPARRAYINFOT[0]~1; 59600000 + WIPEOUTPCW := NEXTADDR := 0; 59601000 + FOR I ~ 0 STEP 1 UNTIL 255 DO 59603000 + IF UNID ~ SCANIN(0&TYPEINT(I,,*,*)) ! 0 THEN 59604000 + BEGIN 59605000 + MAXU ~ I; 59606000 + TUNITS[I] := 0 & UNITINITIALIZE(UNID, (T := 59607000 + SCANIN(0 & PATHINT(I,*,*,*))).MPXDESIGNATOR59608000 + , T); 59609000 + END; 59620000 + MAXUNIT ~ MAXU; 59621000 + INITIALIZEARRAY(OLDSTATUSWORD, OLDSTATUSWORD, 1 + 59622000 + MAXVECTORNO := ((MAXU := * + 1) + 30).DIV32F - 1); 59623000 + INITIALIZEARRAY(UNIT,TRANSACTION,MAXU); 59624000 + MAXCHANNELS ~ FIRSTONE(MAXCHANNELS); 59625000 + INITIALIZEQARRAY(FIRSTIO, MAXU); 59626000 + INITIALIZEQARRAY(FIRSTUNIT, MAXCHANNELS); 59627000 + INITIALIZERARRAY(FIRSTIO, LASTIO, MAXU); 59628000 + INITIALIZEARRAY(LASTUNIT,LASTUNIT,MAXCHANNELS); 59629000 + INITIALIZERARRAY(FIRSTUNIT, LASTUNIT, MAXCHANNELS); 59630000 +COMMENT ALL UNITS ARE LEFT MARKED NOT READY SO THAT 59631000 + STATUS WILL REACT TO THEM AND TAKE THE PROPER ACTION;59632000 + REPLACE POINTER(UNIT[0]) BY POINTER(TUNITS[0]) 59633000 + FOR MAXU WORDS; 59634000 + INITIALIZEARRAY(TYPEINDX, TYPEINDX, (MAXUNITTYPE+1) DIV 6 59635000 + + 1); 59636000 + INITIALIZEARRAY(MNEMTOUNIT, MNEMTOUNIT, MAXUNIT 59637000 + DIV 6 + 1); 59638000 + COMMENT MARK FILE IDS NOT READY; 59639000 + REPLACE POINTER(TYPECNTR) BY 0 FOR MAXU WORDS; 59643000 + FOR I := 0 STEP 1 UNTIL MAXUNIT DO 59644000 + BEGIN 59645000 + IF UNID := UNIT[I].UNITTYPE = DISKFILE THEN 59651000 + BEGIN 59652000 + IF STATE[I] THEN 59652100 + BEGIN 59652400 + DISKS[TOTALEU] ~ I; 59653000 + IF TOTALEU ~ * + 1 = 1 THEN 59654000 + MCPDISKBASE ~ 0 & DISKADDRESSL(I, *); 59655000 +IF TOTALEU = 2 THEN DISKB ~ I; %KLUDGE FOR KLUDGED DIRECTORYSEARCH 59655100 + END 59655200 + ELSE UNIT[I] := UNID := 0 %NOT REALLY A DISK 59655300 + END 59657000 + ELSE 59658000 + IF UNID = SPO THEN 59659000 + BEGIN 59660000 + IOAREA[0] := SET(0, 38); %TEST 59661000 + IF WAITIO(IOAREA, 0&USERL(*,,I,*), REAL(NOT 59662000 + FALSE)).CONSOLEIDF = 0 THEN 59662100 + UNIT[I] := UNID := 0 %NO DISPLAY ATTACHED 59662200 + END 59664000 + ELSE 59665000 + IF MAGTAPE(UNID) THEN 59666000 + BEGIN 59668000 + IOAREA[0]~0&IOCWL(TAPEREWIND,0); 59669000 + WAITIO(IOAREA,0&USERL(*,,I,*),REAL(NOT FALSE)); 59671000 + UNIT[I]~*&UNITL(1,,,1); 59671100 + END; 59676000 + IF UNITREALLYOUTTHERE THEN% 59676100 + BEGIN% 59676200 + UNIT[I].UNITTYPECNTRF~TYPECNTR[UNID]~*+1;% 59676300 + IF MINUNIT<0 THEN MINUNIT~I;% 59676400 + END;% 59676500 + END; 59677000 + INITIALIZEARRAY(LOGHDR,LOGHDR,LOGHDRSZ);% 59678000 + INITIALIZEARRAY(LOGBUF,LOGBUF,SEGMENTSZ+1);% 59678100 + INITIALIZEARRAY(CHANNELLOCKS,CHANNELLOCKS,% 59679000 + MAXPSUEDOCHANNELS); 59679002 + INITIALIZEARRAY(CHANNELGUIDE,CHANNELGUIDE,% 59679100 + MAXPSUEDOCHANNELS); 59679102 + INITIALIZEQARRAY(PICQ, MAXPSUEDOCHANNELS);% 59679200 + INITIALIZEARRAY(SCREEN,SCREEN,NOOFSCREENSRQD); 59680000 + T ~ NAME(TYPEINDX).ADDRESSF; 59681000 + FOR I~ NAME(DICA).ADDRESSF STEP 1 UNTIL T DO 59682000 + M[I] ~ M[1] & STRINGDESCRIPTOR(*, *, *, *, *, *, 59683000 + EBCDIC,M[I].LENGTHF | CHRS, *); 59684000 + FOR I := 1 STEP 1 UNTIL MAXUNITTYPE DO 59686000 + REPLACE POINTER(TYPEINDX[I+1], *) BY 0 & BINEL( 59687000 + TYPECNTR[I]+REAL(POINTER(TYPEINDX[I],*),1)) FOR 1; 59688000 + FOR I := 0 STEP 1 UNTIL MAXUNIT DO 59689000 + IF T ~ UNIT[I].UNITTYPE > 0 THEN 59690000 + REPLACE POINTER(MNEMTOUNIT[TI(T) + 59691000 + UNIT[I].UNITTYPECNTRF-1],*)BY 0&BINEL(I)FOR 1;59692000 +% ***** NEED THE FOLLOWING KLUDGE UNTIL WE DYNAMICALLY SET SCREENS 59692200 + SCREEN[0]~UNITBL[TI(CONN),1];% 59692201 + INITIALIZERARRAY(SCREEN[0],SCREEN[1],NOOFSCREENSRQD-1);% 59692202 + 59693000 + DIAGNOSTICUNIT ~ MASKSEARCH(0&UNITINITIALIZE( 59694000 + DIAGNOSTICUNITTYPE),0&UNITINITIALIZE(4"FF"),UNIT); 59695000 + DIAGNOSTICARRAY[0] := 0&USERL(*,,DIAGNOSTICUNIT,*); 59699100 + DIAGNOSTICARRAY[1] := -0; 59699200 + DIAGNOSTICARRAY[2] := MONITER := MONITER&ARRAYDESCL(3, 59699300 + DIAGNOSTICARRAY.LENGTHF - IOCBSIZE, 59699400 + DIAGNOSTICARRAY.ADDRESSF + IOCBSIZE); 59699500 + DIAGNOSTICARRAY[2].LENGTHF := MONITER.LENGTHF - 1; 59699550 + STOREITEM(EVNT @ REFERENCE(DIAGNOSTICARRAY), 59699600 + MONITORFINISH); 59699700 + IOAREA[0] := SET(0 & IOCWL(@300, *), 32); 59699720 +IF NOT SIMULATING THEN BEGIN 59699735 + WAITIO(IOAREA, 0 & USERL(*,,DIAGNOSTICUNIT,*), 59699740 + REAL(NOT FALSE)); 59699760 + MONITORVALUE := MCPINFO[10].MONVALF; 59700000 + MONITORMASK := MCPINFO[10].MONMASKF; 59700100 +STOP(3"721127",3"700007"); %SEE IF MONITOR IS RIGHT 59700105 +END IF NOT SIMULATING; 59700110 + UBITSTABLESIZE := (MAXUNIT + 47) DIV 48; 59700200 + MCPDISKUNITNO := MCPDISKBASE.EUNOF; 59700300 + UNLOCK(MONITORLOCK); % IT IS OK TO MONITOR NOW 59700400 + REPLACE TP:POINTER(IOAREA[1], 8) BY CLEARSCREEN, 59701000 + POINTER(OUTPUTMESS[BEGMCPID], 8) UNTIL = NUL, 59702000 + HOME LINEFEED, FORMATTEDDATEPOINTER UNTIL = NUL, 59703000 + NUL FOR 5; 59703100 + IOAREA[0] ~ 0 & IOCWL(@40, *); 59704000 + SLCDESC := IOAREA & ARRAYDESCL(3, TP.INDEXSTF, *); 59704200 + FOR I ~ 0 STEP 1 UNTIL MAXUNIT DO 59705000 + IF UNIT[I].UNITTYPE = SPO THEN 59706000 + WAITIO(SLCDESC,0&USERL(*,,I,*),REAL(NOT 59707000 + FALSE)); 59707010 + FOR I := MAXCHANNELS STEP -1 UNTIL 1 DO 59707100 + IF MULTIPLEXORMASK.[I:1] THEN 59707150 + SCANOUT(0, SET(1 & SCANOUTWORD(4,*,*), I)); 59707200 + PROCURE(DIRECTORYLOCK); 59710000 + PROCURE(USERDISKLOCK); 59711000 + DISKMAPPER; 59713000 + END PERIPHERALINITIALIZE; 59799900 + BOOLEAN PROCEDURE GIVEBACKDISK(DISKADDRESS, SIZE); 59800000 + VALUE DISKADDRESS, SIZE; 59801000 + REAL DISKADDRESS, SIZE; 59802000 + BEGIN 59803000 + REAL T, T1; 59804000 + DEFINE LLLARRAY = DISKMAPARRAY#; 59805000 + DEFINE CHECKFOROVERFLOW = 59806000 + IF NEXTADDR ~ * + 2 } MAXADDR THEN 59807000 + BEGIN 59808000 + LLLARRAY[NEXTROW ~ * + 1, 0] ~ 0; 59809000 + MAXADDR ~ (NEXTADDR ~ LLLARRAY[NEXTROW, *].ADDRESSF) 59810000 + + LLLCHUNK; 59811000 + END 59812000 + #; 59813000 +REAL GBD;MONITOR STEVEMONITOR(GBD,T,T1,NEXTADDR); GBD := 0; 59813010 + IF (T ~ M[LASTADDR ~ LISTLOOKUP(DISKADDRESS, MEMORY, 59814000 + FIRSTADDR)]).MAPADDRESSF + T1 ~ M[LASTADDR + 1] < 59815000 + DISKADDRESS + SIZE THEN 59816000 + RETURN(1); COMMENT WE ARE GIVING BACK DISK WHICH 59817000 + WE DO NOT HAVE; 59818000 + IF T1 = SIZE THEN 59819000 +T1:= %FOR MONITORING 59819010 + M[LASTADDR + 1] ~ 0 COMMENT IF MEMORY EVER IS A 59820000 + PROBLEM, HERE IS WHERE SOME 59821000 + GETS WASTED; 59822000 + ELSE 59823000 + IF T.MAPADDRESSF + T1 = DISKADDRESS + SIZE THEN 59824000 +T1:= %FOR MONITORING 59824010 + M[LASTADDR + 1] ~ T1 - SIZE 59825000 + ELSE IF T.MAPADDRESSF = DISKADDRESS THEN 59826000 + BEGIN 59827000 + M[LASTADDR].MAPADDRESSF ~ DISKADDRESS + SIZE; 59828000 +T:=M[LASTADDR];T1:=%FOR MONITORING 59828010 + M[LASTADDR+1] ~T1 - SIZE; 59829000 + END 59830000 + ELSE BEGIN 59831000 +T1:= %FOR MONITORING 59831010 + M[LASTADDR+1] ~ DISKADDRESS - T.MAPADDRESSF; 59832000 + CHECKFOROVERFLOW; 59833000 + M[LASTADDR].ADDRESSF ~ NEXTADDR; 59834000 +T := %FOR MONITORING 59834010 + M[NEXTADDR] ~ T & FIRSTMAPWORDPRIME(DISKADDRESS 59835000 + + SIZE, *); 59836000 +T1:= %FOR MONITORING 59836010 + M[NEXTADDR+1] ~ (T.MAPADDRESSF + T1) - 59837000 + DISKADDRESS - SIZE; 59838000 + END; 59839000 +GBD:=1; %FOR MONITORING 59839010 + END GIVE BACK DISK SPACE SOMEONE OWNS; 59840000 +PROCEDURE DIRECTORYCOMPLEMENT(DIRECTRY); 59842000 + ARRAY DIRECTRY[*]; 59843000 + COMMENT THIS PROCEDURE CHASES THROUGH A DIRECTORY, AND ALL THAT 59844000 + DWELL THEREIN, AND TAKES ALL DISK SPACE CLAIMED FROM THE 59845000 + AVAILABLE DISK TABLE. 59846000 + IT ALSO RESOLVES ANY FUNNY STUFF IN THE HEADER. 59847000 + ; 59848000 + BEGIN 59849000 + ARRAY HDR[200]; 59850000 + REAL I, J, T, T1, K, SIZE, INDEX, LIMIT, 59851000 + WHOAMI := DIRECTRY[0]; 59852000 + LABEL BACK; 59853000 + DEFINE BUZZREPORTBACK = 59857000 + WHILE BOOLEAN(K ~ READLOCK(1, DIRECTORYCOMPLEMENTREPORTBACK)) 59858000 + DO #; 59859000 +REAL DISKCOMP; 59859100 +MONITOR STEVEMONITOR(INDEX,DISKCOMP, T, LIMIT,SIZE, T1,WHOAMI); 59859200 +DISKCOMP:=*; WHOAMI:=*; 59859300 + INDEX := (HEADERSIZE(DIRECTRY) + 29) DIV 30; 59860000 +GO ENDIT; % TEMPORARILY 59860100 +BACK: 59861000 + FOR I := INDEX + 4 STEP 5 WHILE NOT BOOLEAN(T := DIRECTRY[I]) DO 59862000 + BEGIN 59863000 + DISKWAIT(HDR, -1, IF T.FILEKINDF > DIRECTORY THEN (T1 := 59864000 + (T.HEADERSIZEF + 29) DIV 30) + DIRECTORYBITE ELSE T1 := 59865000 + T.HEADERSIZEF, J := DIRECTRY[I+1], @440); 59866000 +COMMENT CONSISTANCY CHECKING AND HEADER DIDILING GO HERE; 59867000 + PROCURE(DISKRETURNLOCK); 59868000 + GIVEBACKDISK(J, T1 DIV 30); 59869000 + SIZE := ROWSIZE(HDR); 59870000 + LIMIT := NUMBEROFROWS(HDR) - CRUNCHED(HDR) + FIRSTROWINDEX - 1;59871000 + FOR J := FIRSTROWINDEX STEP 1 UNTIL LIMIT DO 59872000 + IF T1 := HDR[J] ! 0 THEN 59873000 + GIVEBACKDISK(T1, SIZE); 59874000 + IF BOOLEAN(CRUNCHED(HDR)) THEN 59875000 + BEGIN 59876000 + END; 59877000 + LIBERATE(DISKRETURNLOCK); 59878000 + IF T.FILEKINDF { DIRECTORY THEN 59879000 + IF WHOAMI < 0 THEN 59880000 + BEGIN COMMENT I AM THE CONTROLING PROCESS; 59881000 + BUZZREPORTBACK; 59882000 + DIRECTORYCOMPLEMENTREPORTBACK := 59884000 + RESET(K, T1 := FIRSTONE(K + 1) - 1); 59885000 + IF HDR[0] := T1 > 0 THEN 59886000 + FORK(DIRECTORYCOMPLEMENT, HDR) 59887000 + ELSE 59888000 + DIRECTORYCOMPLEMENT(HDR); 59889000 + END 59890000 + ELSE 59891000 + DIRECTORYCOMPLEMENT(HDR); 59892000 + END; 59893000 + IF T > 0 THEN 59894000 + BEGIN 59895000 + DISKWAIT(DIRECTRY, INDEX-1, DIRECTORYBITE, 59896000 + DIRECTRY[FIRSTROWINDEX + (K := DIRECTRY[INDEX] | 59897000 + SEGMENTSPERDIRECTORYBITE) DIV T := ROWSIZE(DIRECTRY)] + 59898000 + K MOD T, @440); 59899000 + GO BACK; 59900000 + END; 59901000 + IF WHOAMI > 0 THEN 59902000 + BEGIN 59903000 + BUZZREPORTBACK; 59904000 + DIRECTORYCOMPLEMENTREPORTBACK := SET(K, WHOAMI); 59905000 + END; 59906000 + IF WHOAMI < 0 THEN 59906100 + IF DIRECTRY.ADDRESSF = SYSTEMDIRECTORY.ADDRESSF THEN 59906150 + BEGIN 59906200 +ENDIT: COMMENT SQUASH LINKED LISTS INTO USER DISK TABLES; 59907000 + LIBERATE(USERDISKLOCK); 59908000 + LIBERATE(DIRECTORYLOCK); 59909000 + FORGETDOPEVECTORS(DISKMAPARRAY); 59910000 + FORGETSPACE(DISKMAPARRAY.ADDRESSF); 59910100 + END; 59911000 + DISKCOMP := 1; 59912000 + END DIRECTORYCOMPLEMENT; 59929000 +SAVE PROCEDURE UPDATEUNITBITSTABLE(TABLENAME, U); 60000000 + VALUE U; 60001000 + INTEGER U; 60002000 +BOOLEAN ARRAY TABLENAME[*]; 60003000 + COMMENT FOR A GIVEN TABLE (OLDSTATUSWORD,STATUSMASKWORD,ETC) AND UNIT 60004000 + NO, THE PROCEDURE FINDS THE RIGHT INDEX IN THE TABLE AND 60005000 + SETS (OR RESETS FOR NEGATIVE UNIT NO) BIT CORRESPONDING TO 60006000 + UNIT NO. 60007000 + NOTE EACH WORD HAS ONLY 32 BIT POSITIONS. 60008000 + TABLENAME - -ARRAY NAME FOR A GIVEN TABLE. 60009000 + U -LOGICAL UNIT NO; 60010000 + BEGIN 60011000 + FIELD UBITNOF = ABS(U) MOD 32:1; 60012000 + TABLENAME[ABS(U) DIV 32].UBITNOF ~ NOT BOOLEAN(U.SIGNBITF); 60013000 + END UPDATEUNITBITSTABLE; 60019000 +PROCEDURE ARRAYDEC(NOOFDIMS,NOOFARRAYS,TYPE); 65000000 + VALUE NOOFDIMS,NOOFARRAYS,TYPE; 65001000 + INTEGER NOOFDIMS,NOOFARRAYS,TYPE; 65002000 + COMMENT ENTERS DIMENSION INFORMATION FOR EACH ARRAY INTO ARRAYINFOT. 65003000 + A SPECIAL DESCRIPTOR IS MADE FOR EACH ARRAY(SEE SARRAYDESCL 65004000 + LAYOUT) .AITINDICATOR BIT IS TURNED ON SO THAT PRESENCEBIT 65005000 + COULD TAKE SPECIAL ACTION. IN 65006000 + CASE ARRAYINFOT GETS FULL INVALID INDEX INTERRUPT WILL OCCUR 65007000 + AND THEN ARRAYINFOT WILL BE EXTENDED. NOTE THAT VARIABLE NO OF65008000 + PARAMETERS ARE PASSED. 65009000 + NOOFDIMS - WHAT IT SAYS. 65010000 + NOOFARRAYS- NO OF ARRAYS IN A SINGLE LIST HAVING SAME DIMENSIONS.65011000 + E.G. A,B,C[2,3,4] 65012000 + TYPE - CODE SPECIFYING DIFFERENT KINDS OF ARRAY 65013000 + IF TYPE IS NEGATIVE THEN ARRAY IS FOR MCP 65014000 + ; 65015000 + BEGIN 65016000 + WORD ARRAY ARRAYLIST[*]; COMMENT DESC POINTING TO LIST OF 65017000 + ARRAYS IN STACK; 65018000 + ARRAY ARRAYINFOT[*], COMMENT ARRAY INFORMATION TABLE; 65019000 + DIMINFO[*]; COMMENT DESC POINTING TO WHERE 65020000 + DIMENSION INFORMATION STARTS IN STACK;65021000 + REAL DIMINFOSIZE, % NO OF DIMENSIONS 65022000 + INDEX, 65023000 + FREG, COMMENT F REG SETTING; 65023100 + ARRAYINFOTI; COMMENT LAST USED INDEX OF ARRAYINFOT;65024000 + WORD MSCW; COMMENT MARK STACK CONTROL WORD; 65025000 + LABEL CUTSTACK,QUIT; 65026000 + BOOLEAN LOBOUNDTOG; COMMENT TRUE IF LOWER BOUND IS PASSED;65027000 +COMMENT LOCK THE STACK & WAKE UP DESCRIPTORS FOR ARRAYLIST AND DIMINFO;65028000 +COMMENT SET LOBOUNDTOG IF LOWER BOUND IS PASSED FOR OWN ARRAY; 65029000 + FREG~F; 65029100 + DIMINFOSIZE~ ( 1 + REAL(LOBOUNDTOG)) | NOOFDIMS; 65029200 + ARRAYINFOT~IF BOOLEAN(TYPE.SIGNBITF) THEN MCPARRAYINFOT 65030000 + ELSE WORDSTACK[SNR,AITDESCRIPTORPLACE]; 65031000 + IF DATADESC ! ARRAYINFOT.TAG THEN 65031100 + BEGIN 65031300 + ARRAYINFOT~ARRAYINFOT & 65031350 + DATADESCRIPTOR(,,,,,,,,AITSIZE,0); 65031400 + ARRAYINFOT[0]~1; 65031500 + WORDSTACK[SNR,AITDESCRIPTORPLACE] ~ARRAYINFOT & 65031600 + ARRAYDESCL(2, ,); 65031700 + END; 65031800 + IF ((ARRAYINFOTI~ARRAYINFOT[0]) + DIMINFOSIZE) } 65031900 + (INDEX~WORD(ARRAYINFOT).LENGTHF) THEN 65032000 + BEGIN % EXTEND AIT TABLE 65032100 + INDEX~INDEX + AITSIZE; 65032200 + MSCW~ARRAYINFOTI + DIMINFOSIZE; 65032250 + DIMINFO~DIMINFO & DATADESCRIPTOR(,,,,,,,, INDEX ,0); 65032300 + FOR INDEX~0 STEP 1 UNTIL ARRAYINFOTI DO 65032500 + DIMINFO[INDEX]~ARRAYINFOT[INDEX]; 65032600 + FORGETSPACE(WORD(ARRAYINFOT).ADDRESS); 65032700 + IF BOOLEAN(TYPE.SIGNBITF) THEN 65032800 + MCPARRAYINFOT~DIMINFO ELSE 65032900 + WORDSTACK[SNR,AITDESCRIPTORPLACE]~DIMINFO & 65032920 + ARRAYDESCL(2, ,); 65032930 + ARRAYINFOT~DIMINFO; 65032940 + END; 65032960 + INDEX~FREG-DIMINFOSIZE-REAL(NOOFDIMS=1); 65033000 + DIMINFO~DIMINFO & ARRAYDESCL(,DIMINFOSIZE,INDEX); 65034000 + ARRAYLIST~ARRAYLIST & ARRAYDESCL(,NOOFARRAYS,INDEX-NOOFARRAYS);65035000 + DIMINFOSIZE~DIMINFOSIZE-1; 65036000 + IF (INDEX~DIMINFO[DIMINFOSIZE]) {0 THEN 65038000 + BEGIN 65039000 +COMMENT BUILD MESSAGE "DEC-ERROR- ARRAY DIMENSION= " ;65040000 + GO QUIT; 65041000 + END; 65042000 + IF NOOFDIMS=1 AND INDEX{256 THEN 65043000 + BEGIN COMMENT ARRAY NOT TO BE SEGMENTED; 65044000 + ARRAYLIST[0]~0 & DATADESCRIPTOR(,,,,,,,TYPE.DOUBLEBIT, 65045000 + INDEX,TYPE.LSAVEBIT); 65046000 + GO CUTSTACK; 65047000 + END; 65048000 + ARRAYLIST[0]~ARRAYLIST[0] & SARRAYDESCL(,DIMINFO[0],TYPE. 65049000 + SIGNBITF,,1,ARRAYINFOTI,ABS(TYPE)); 65050000 + IF NOOFDIMS=1 THEN 65051000 + BEGIN 65052000 + ARRAYLIST[0].SBITF~1; 65053000 + INDEX~DIMINFO[0]; 65054000 + DIMINFO[0]~INDEX DIV 256; 65055000 + ARRAYINFOT[ARRAYINFOTI]~INDEX~INDEX MOD 256; 65056000 + DIMINFO[0]~ * + REAL(INDEX>0); 65057000 + ARRAYINFOTI~ARRAYINFOTI +1; 65058000 + ARRAYLIST[0].LENGTHF~DIMINFO[0]; 65059000 + GO CUTSTACK; 65060000 + END; 65061000 + FOR INDEX~1 STEP 1 UNTIL DIMINFOSIZE DO 65062000 + BEGIN 65063000 + ARRAYINFOT[ARRAYINFOTI]~DIMINFO[INDEX]; 65064000 + ARRAYINFOTI~ARRAYINFOTI + 1; 65065000 + END; 65066000 +CUTSTACK: 65067000 + IF NOOFDIMS=1 THEN DIMINFOSIZE~ DIMINFOSIZE + 1; 65067500 + ARRAYINFOT[ARRAYINFOTI- 1].SIGNBITF~1; 65068000 + ARRAYINFOT[0] ~ ARRAYINFOTI; 65069000 + NOOFARRAYS~NOOFARRAYS-1; 65070000 + IF NOOFARRAYS>0 THEN 65071000 + FOR INDEX~1 STEP 1 UNTIL NOOFARRAYS DO 65072000 + ARRAYLIST[INDEX] ~ ARRAYLIST[0]; 65073000 +COMMENT CUTTING BACK STACK; 65073200 + DIMINFOSIZE~DIMINFOSIZE+1; 65074000 + MSCW~M[FREG]; 65075000 + INDEX~MSCW.DFF; 65076000 + M[FREG].DFF~DIMINFOSIZE; 65077000 + MSCW.DFF~INDEX-DIMINFOSIZE; 65078000 + M[INDEX~FREG-DIMINFOSIZE]~MSCW; 65079000 + M[INDEX+1]~M[FREG+1]; 65080000 + M[FREG+1]~DUMMYFORCUTTINGSTACKPCW & SETTAG(RCW); 65081000 +COMMENT UNLOCK STACK; 65082000 +QUIT: EXIT; 65083000 + END ARRAYDEC; 65084000 +SAVE 65085000 +WORD PROCEDURE DOPEVECTOR(MOMDESC); 65086000 + VALUE MOMDESC; WORD MOMDESC; 65087000 + COMMENT 65088000 + BUILDS UP DOPE VECTOR TABLE AT PRESENCE TIME. OBTAINS DIMENSION65089000 + SIZE FROM ARRAY INFORMATION TABLE(ARRAYINF0T) AND GETS SPACE 65090000 + FOR IT. IF NEXT ENTRY IN ARRAYINFOT IS NOT THE LAST DIMENSION, 65091000 + IT BUILDS UP SPECIAL ARRAY DESCRIPTORS(SEE SARRAYDESCL LAYOUT) 65092000 + OTHERWISE 65093000 + IT BUILDS UP NORMAL DATA DESCRIPTORS WITW LAST DIMENSION IN THE65094000 + LENGTH FIELD. SUBSEQUENTLY REGULAR PRESENCE BIT ACTION WILL 65095000 + OCCUR TO BRING IN THE RIGHT ROW. ADDRESS OF DOPEVECTABLE IS 65096000 + RETURNED. 65097000 + MOMDESC - ORIGINAL MOM DESCRIPTOR 65098000 + ; 65099000 + BEGIN 65100000 + REAL DOPEVECTADDR; COMMENT ADDRESS POINTS DOPEVECTABLE; 65101000 + INTEGER AITINDEX, COMMENT POINTS TO AIT LOCATION WHICH HAS 65102000 + DIMENSION INFORMATION; 65103000 + I, COMMENT INDEX FOR DOPE VECTOR TABLE; 65104000 + LASTDOPEVECSIZE, COMMENT SIZE OF LAST SEG. OF 65105000 + SEGMENTED ARRAY; 65106000 + TYPE=AITINDEX, COMMENT ARRAY TYPE CODE; 65107000 + DOPEVECTSIZE; COMMENT DOPE VECTOR TABLE SIZE; 65108000 + ARRAY AIT[*]; COMMENT ARRAY IMFORMATION TABLE; 65109000 + WORD ARRAY DOPEVECTABLE[*]; COMMENT ARRAY FOR CREATING DOPE 65110000 + VECTOR TABLE; 65111000 + WORD DOPEVECT=DOPEVECTABLE; 65112000 + AITINDEX~MOMDESC.AITINDEXF; 65113000 + AIT~IF BOOLEAN(MOMDESC.MCPARRAYBIT) THEN 65114000 + MCPARRAYINFOT ELSE WORDSTACK[SNR,AITDESCRIPTORPLACE]; 65115000 + DOPEVECTSIZE~MOMDESC.LENGTHF; 65116000 + DOPEVECTADDR~GETSPACE(DOPEVECTSIZE,SNR,4,0); 65117000 + DOPEVECTABLE~DOPEVECTABLE & ARRAYDESCL(,DOPEVECTSIZE, 65118000 + DOPEVECTADDR); 65119000 + IF (I+AIT[AITINDEX]) <0 THEN 65120000 + BEGIN 65121000 + IF BOOLEAN(MOMDESC.SBITF) THEN 65122000 + BEGIN 65123000 + LASTDOPEVECSIZE~ABS(I); 65124000 + DOPEVECT.SBITF~1; 65125000 + I~256; 65126000 + END; 65127000 + TYPE~MOMDESC.ARRAYTYPEF; 65128000 + DOPEVECTABLE[0]~0 & DATADESCRIPTOR(,,,,,,,TYPE.DOUBLEBIT, 65129000 + I,TYPE.LSAVEBIT); 65130000 + END ELSE 65131000 + DOPEVECTABLE[0]~MOMDESC & SARRAYDESCL(,I,,,,AITINDEX+1,); 65132000 + DOPEVECTSIZE~DOPEVECTSIZE-1; 65133000 + FOR I~ 1 STEP 1 UNTIL DOPEVECTSIZE 65134000 + DO 65135000 + DOPEVECTABLE[I] ~ DOPEVECTABLE[0]; 65136000 + IF LASTDOPEVECSIZE>0 THEN 65137000 + DOPEVECTABLE[DOPEVECTSIZE].LENGTHF~LASTDOPEVECSIZE; 65138000 + RETURN(WORD(DOPEVECT)); 65139000 + END DOPEVECTOR; 65140000 +SAVE PROCEDURE BLOCKEXIT; 65174000 + COMMENT BLOCKEXIT IS CALLED JUST PRIOR TO EXITING A BLOCK. BLOCKEXIT 65175000 + FORGETS SPACE GOTTEN FOR THE BLOCK; 65176000 + BEGIN 65177000 + REAL LIMIT, COMMENT STACK SEARCH LIMIT; 65180000 + ADDR, COMMENT ADDRESS FOR GETSPACE; 65181000 + I; 65182000 + WORD STK; COMMENT FOR ACCESSING MSCW; 65183000 + LABEL QUIT; 65184000 +REAL BLKEXIT,DISP,STKBASE; %FOR MONITORING ONLY 65184100 +MONITOR STEVEMONITOR(BLKEXIT,DISP); 65184200 +REAL TRACTER;TRACTER~TRACE(0);% TURNS OFF TRACE 65184300 +COMMENT LOCK STACK; 65185000 +STKBASE ~ %FOR MONITOR CALCULATIONS 65186000 + STK ~ (LIMIT ~ F - 1) - M[F].DFF + 3; 65187000 +BLKEXIT ~ LIMIT - STKBASE + 1; %MONITOR 65188000 + FOR I~STK STEP 1 UNTIL LIMIT DO 65190000 + BEGIN 65191000 + STK~M[I]; 65192000 + IF STK.TAG=6 THEN GO QUIT; 65193000 + IF STK.TAG=DATADESC AND STK.PCBITSF=2 THEN 65194000 + BEGIN COMMENT DATA DESCRIPTOR WITH ONLY P BIT ON; 65195000 + IF M[ADDR~STK.ADDRESS].TAG=DATADESC THEN 65196000 + 65197000 + FORGETDOPEVECTORS(STK); 65198000 + FORGETSPACE(ADDR); 65199000 +DISP ~ I - STKBASE + 2; %7ONITOR THE DISPLACEMENT FROM LL 65199100 + END; 65200000 + END; 65201000 +QUIT: 65202000 +COMMENT UNLOCK STACK; 65203000 +TRACE(TRACTER);% RESTORES TRACE 65203900 + END BLOCKEXIT; 65204000 +PROCEDURE FORGETDOPEVECTORS(DD); WORD ARRAY DD[*]; 65205000 + COMMENT FORGETDOPEVECTORS WILL MAKE RECURSIVE CALLS ON ITSELF UNTIL 65206000 + THE WHOLE CHAIN OF DOPE VECTORS ARE FORGOTTEN 65207000 + DD -DATA DESCRIPTOR FOR DOPE VECTOR TABLE; 65208000 + BEGIN 65209000 + INTEGER I, COMMENT INDEX FOR LOOP; 65210000 + ADDR, COMMENT DESCRIPTOR ADDRESS; 65211000 + LENGTH; COMMENT LENGTH OF TABLE; 65212000 + WORD DDV; COMMENT CONTENT OF DD LOCATION; 65213000 + 65214000 + LENGTH ~ DD.LENGTHF - 1; 65215000 + FOR I~0 STEP 1 UNTIL LENGTH DO 65216000 + BEGIN 65217000 + DDV ~ DD[I]; DDV.CBITF ~ 1; 65218000 + IF BOOLEAN(DDV.PBITF) THEN 65219000 + IF M[ADDR~DDV.ADDRESS].TAG=DATADESC THEN 65220000 + BEGIN 65221000 + FORGETDOPEVECTORS(DDV); 65222000 + FORGETSPACE(ADDR); 65223000 + END ELSE 65224000 + FORGETSPACE(ADDR); 65225000 + END; 65226000 + END FORGETDOPEVECTORS; 65227000 +PROCEDURE GOTOSOLVER(SIRW); VALUE SIRW; REAL SIRW; 65228000 + COMMENT SOLVES BADGOTO PROBLEM; 65229000 + BEGIN 65230000 + INTEGER FREG, COMMENT F REG. SETTING; 65231000 + FINALF, COMMENT FINAL F VALUE; 65232000 + LIMIT, COMMENT LIMIT FOR SEARCHING STACK; 65233000 + DISP, COMMENT TOTAL DISPLACEMENT; 65233500 + ADDR, COMMENT ADDRESS FOR FORGETSPACE; 65234000 + I; COMMENT INDEX; 65235000 + BOOLEAN BADLABELFOUNDTOG; 65235500 + WORD STK, COMMENT CONTENTS OF STACK LOCATION; 65236000 + MSCW; COMMENT CURRENT MKST WORD; 65237000 + LABEL SEARCHAGAIN,LOOPEND,SKIPFORGETPART; 65238000 + IF SIRW=0 THEN EXIT; COMMENT USE TERMINATE WHEN AVAILABLE; 65238999 + 65239000 + FINALF ~ STACKVECTOR[SIRW.STKNRF].ADDRESS + SIRW.DISPF ; 65240000 +COMMENT LOCK STACK; 65241000 + FREG ~F; 65242000 +SEARCHAGAIN: 65243000 + LIMIT~FREG-1; 65244000 + MSCW~M[FREG]; 65244500 + ADDR~MSCW.DFF; COMMENT TEMP STORAGE OF DISPLACEMENT; 65244700 + IF (FREG~FREG-ADDR) {FINALF THEN BADLABELFOUNDTOG~TRUE ; 65245000 + I~FREG+2; 65248000 + DISP~DISP+ADDR; 65248500 + FOR I~I STEP 1 UNTIL LIMIT DO 65249000 + BEGIN 65250000 + STK ~ M[I]; 65251000 + IF STK.TAG=6 THEN IF BADLABELFOUNDTOG THEN GO LOOPEND 65252000 + ELSE GO SEARCHAGAIN 65252100 + ELSE 65252200 + IF BADLABELFOUNDTOG THEN GO SKIPFORGETPART ELSE 65252300 + IF STK.TAG=DATADESC AND STK.PCBITSF=2 THEN 65253000 + BEGIN COMMENT DATA DESCRIPTOR WITH P BIT ON; 65254000 + IF M[ADDR ~STK.ADDRESS].TAG=DATADESC THEN 65255000 + FORGETDOPEVECTORS(STK); 65256000 + FORGETSPACE(ADDR); 65257000 + END; 65258000 +SKIPFORGETPART: 65259000 + END; 65260000 + GO SEARCHAGAIN; 65261000 +LOOPEND: 65262000 + I~I+1; 65263000 + STK~M[FINALF+SIRW.SIRWDELTAF]; COMMENT PCW FOR LABEL; 65264000 + ADDR~I-FREG; 65265000 + DISP~DISP-ADDR; 65265500 + FREG~F; 65266000 + MSCW~M[FREG]; 65267000 + MSCW.DFF~ADDR; 65268000 + M[I]~MSCW; 65269000 + M[I+1]~ STK & SETTAG(RCW); 65270000 + MSCW.DFF~DISP; 65270100 + M[FREG]~MSCW; 65270200 + M[FREG+1]~DUMMYFORCUTTINGSTACKPCW & SETTAG(RCW); 65270300 +COMMENT UNLOCK STACK; 65271000 + END GOTOSOLVER; 65272000 +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%70000000 +% I/O INTRINSICS %70001000 +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%70002000 +SAVE EVENT ARRAY IOEVENT[192]; 70003000 +SAVE ARRAY IOEVENTS[5]; 70004000 +EVENT IOEVNT; 70005000 +PROCEDURE WAITON(IOCB);REFERENCE IOCB; 70006000 +BEGIN %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%70007000 + % WAITON IS DESIGNED TO "SAVE" EVENTS, UTILIZING JUST ONE %70008000 + % PER FILE ... THERE ARE TIMING PROBLEMS %70009000 + % ONE BUFFER AND DIRECT-ACCESS %70010000 + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%70011000 + LABEL HR; 70012000 + HR: 70013000 + WAIT(EVNT@IOCB); 70014000 + IF IOPENDING THEN 70015000 + BEGIN 70016000 + RESET(EVNT@IOCB); 70017000 +STOP; %%%%% 70018000 + IF IOPENDING THEN GO TO HR; 70019000 + END; 70020000 + IOCOMPLET~0; 70020100 +END WAITON; 70021000 +INTEGER PROCEDURE EVENTNUMBER; 70022000 +BEGIN %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%70023000 + % EVENTNUMBER PROCURES AN EVENT FOR A FILE %70024000 + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%70025000 + EVENT EVNT; 70026000 + LABEL STRT,XIT; 70027000 + LAYOUT IOEVENTSL((I-1):1~1); 70028000 + REAL I,T; 70029000 + STRT: 70030000 + WHILE BOOLEAN(READLOCK(1,IOEVENTS[4])) DO WAIT(IOEVNT); 70031000 + RESET(IOEVNT); 70032000 + T~-1; 70033000 + WHILE T~T+1<4 DO 70034000 + IF I~FIRSTONE(REAL(NOT BOOLEAN(IOEVENTS[I])))!0 THEN GO XIT; 70035000 + READLOCK(0,IOEVENTS[4]); 70036000 + CAUSE(IOEVNT); 70037000 + % SLEEP(1,EVNT); 70038000 + RESET(EVNT); 70039000 + GO TO STRT; 70040000 + XIT: 70041000 + IOEVENTS[T]~*&IOEVENTSL(); 70042000 + READLOCK(0,IOEVENTS[4]); 70043000 + CAUSE(IOEVNT); 70044000 + RESET(IOEVENT[EVENTNUMBER~(I-1)+T|48]) 70045000 +END EVENTNUMBER; 70046000 +PROCEDURE FORGETEVENT(NMBR);VALUE NMBR;REAL NMBR; 70047000 +BEGIN 70048000 + LAYOUT IOEVENTSL(I:1~0); 70049000 + REAL I~NMBR MOD 48; 70050000 + WHILE BOOLEAN(READLOCK(1,IOEVENTS[4])) DO WAIT(IOEVNT); 70051000 + RESET(IOEVNT); 70052000 + RESET(IOEVENT[NMBR]); 70053000 + IOEVENTS[NMBR DIV 48]~*&IOEVENTSL(); 70054000 + READLOCK(0,IOEVENTS[4]); 70055000 + CAUSE(IOEVNT); 70056000 +END FORGET EVENT; 70057000 +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%70058000 +WORD PROCEDURE SETUPTANK(NAREAS,AR,ASIZE,BCKWRD,SKLTN,FEVENT,UNMBR);70059000 + VALUE AR,ASIZE,BCKWRD,SKLTN,UNMBR; 70060000 + REAL NAREAS,AR,ASIZE,BCKWRD,SKLTN,UNMBR; 70061000 + EVENT FEVENT; 70062000 +BEGIN %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%70063000 + % SETS UP BUFFERS AND LINKS THEM TOGETHER %70064000 + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%70065000 + FIELD CBIT=1:1; 70066000 + BOOLEAN CNTGS~BOOLEAN(BCKWRD.CBIT); 70067000 + LABEL OUT; 70068000 + REAL I,T~NAREAS,P~AR-1; 70069000 + REAL FRST,CRLC,LSTLC; 70070000 +PROCEDURE BUILDIOAREA(ADDRESS);VALUE ADDRESS;INTEGER ADDRESS; 70071000 +BEGIN %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%70072000 + % BUILDS IOAREA: IOCB + LINKS + BUFFER %70073000 + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%70074000 + ARRAY IOAREA[*]; 70075000 + LAYOUT USERL(18:1~1,UNITNOF); 70075100 + WORD ARRAY IOAREAWA=IOAREA[*]; 70076000 + IOAREA~IOAREA&ARRAYDESCL(,ASIZE,ADDRESS); 70077000 + REPLACE POINTER(IOAREA) BY 0 FOR ASIZE OVERWRITE; 70078000 + IOAREA[0]~0&USERL(,UNMBR); 70079000 + STOREITEM(EVNT@REFERENCE(IOAREA),FEVENT); 70080000 + IOAREAWA[2]~IOAREA~IOAREA& 70081000 + ARRAYDESCL(,ASIZE-IOTANKSZ,IOAREA.ADDRESSF+IOTANKSZ-1); 70082000 + IOAREA[0]~SKLTN; 70083000 + DIVORCEMOM(IOAREA); 70084000 +END BUILDIOAREA; 70085000 + IF CNTGS THEN I~REQSPACE(ASIZE|NAREAS); 70086000 + BUILDIOAREA(FRST~CRLC~LSTLC~(IF CNTGS THEN I ELSE 70087000 + REQSPACE(ASIZE))); 70088000 + WHILE T~T-1>0 DO 70089000 + BEGIN 70090000 + IF CNTGS THEN I~I~ASIZE ELSE 70091000 + IF T>P THEN 70092000 + IF I~OPTSPACE(ASIZE)<0 THEN 70093000 + BEGIN NAREAS~NAREAS-1;GO TO OUT END ELSE 70094000 + ELSE I~REQSPACE(ASIZE); 70095000 + BUILDIOAREA(I); 70096000 + M[LSTLC+IOAL].FL~CRLC~I; 70097000 + IF BOOLEAN(BCKWRD) THEN M[I+IOAL].BL~LSTLC; 70098000 + LSTLC~CRLC; 70099000 + OUT: 70100000 + END; 70101000 + IF NAREAS>1 THEN 70102000 + BEGIN 70103000 + M[LSTLC+IOAL].FL~FRST; 70104000 + IF BOOLEAN(BCKWRD) THEN M[FRST+IOAL].BL~LSTLC; 70105000 + END; 70106000 + SETUPTANK~IOEVENTS&ARRAYDESCL(,ASIZE,FRST); 70107000 +END SETUPTANK; 70108000 +PROCEDURE ATTRIBUTEHANDLER=(0,42)(FIB,TYPE,ARGH); 70109000 + VALUE TYPE,ARGH; 70110000 + REAL TYPE,ARGH; 70111000 + ARRAY FIB[*]; 70112000 +BEGIN %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%70113000 + % ATTRIBUTEHANDLER CHANGES VARIOUS FILE ATTRIBUTES %70114000 + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%70115000 + ARRAY IOAREA,LEB,NULEB[*],NLEB[31]; 70116000 + POINTER PTEMP,PBGN; 70116010 + FIELD PTYPE=30:6,TYPEF=TYPE:1; 70117000 + FIELD INTNAME=43:1; 70118000 + LAYOUT 70119000 + BLCKNG(RCRDTYPE,SIZEMODE,SIZEOFF,SIZESZ), 70120000 + ENDL(0:1); 70121000 + POINTER NAMES=ARGH,PLEB,PNLB; 70122000 + BOOLEAN MSG; 70123000 + REAL 70124000 + T, 70125000 + U, 70126000 + I, 70127000 + FIB0, 70128000 + MSK ~4"FFFFFFFFFFF", 70129000 + BTYPES~4"F776", 70130000 + PTYPES~4"9540", 70131000 + CARE~4"FFFFFFFFFFF"; 70132000 + WORD ARRAY FIBW=FIB[*]; 70133000 + IOAREA~IOADESC; 70134000 + FIB0~FIBSIZE; 70135000 + FIBUZZ; 70136000 + IF BOOLEAN(CARE.TYPEF) THEN 70137000 + IF BOOLEAN(MSK.TYPEF)EQV ALREADYOPEN THEN 70138000 + BEGIN TRACE(18);TRACE(21); END; 70138100 + %IF NOT LABELEQTD THEN GETFPB(FIB); 70139000 + LEB~LBLEQTN&DATADESCRIPTOR(); 70140000 + MAKEPRESENTANDSAVE(LEB); 70140100 + LBLEQTN~LEB; 70140200 + CASE TYPE OF 70143000 + BEGIN %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%70144000 + BEGIN % FILE.TITLE 070145000 + PLEB~NAMES; 70145010 + PNLB~(PTEMP~(PBGN~POINTER(NLEB,8))+3)+1; 70145020 + REPLACE PBGN+1 BY 1 FOR 1 CORRECTLY; 70145030 + WHILE TRUE DO 70145040 + BEGIN 70145050 + REPLACE PNLB:PNLB BY PLEB:PLEB WHILE IN EBCDICALPHANUMERIC; 70145060 + REPLACE PBGN+2 BY REAL(PBGN+2,1)+1 FOR 1 CORRECTLY; 70145070 + REPLACE PTEMP BY DELTA(PTEMP+1,PNLB) FOR 1 CORRECTLY; 70145080 + IF PLEB=8"/" THEN 70145090 + BEGIN 70145100 + PLEB~PLEB+1; 70145110 + PNLB~(PTEMP~PNLB)+1; 70145120 + END ELSE 70145130 + BEGIN 70145140 + REPLACE PBGN BY DELTA(PBGN,PNLB)FOR 1 CORRECTLY; 70145150 + GO OUT; 70145160 + END; 70145170 + END; 70145180 + OUT: 70145190 + IF ((I~REAL(PBGN,1))+5)DIV 6>(REAL(PLEB~POINTER(LEB[U~( 70146000 + (T~LEB[0]).FXD+ONES(T.OPTMASK))],8),1)+5)DIV 6 THEN 70147000 + BEGIN 70148000 + NULEB~*&ARRAYDESCL(0,U+((I+5)DIV 6),0); 70149000 + REPLACE POINTER(NULEB,8) BY PLEB FOR U WORDS,PBGN FOR I; 70150000 + MAKEPRESENTANDSAVE(NULEB); 70151000 + LBLEQTN~NULEB; 70151100 + DIVORCEMOM(NULEB); 70152000 + FORGETSPACE(LEB.ADDRESSF); 70153000 + END ELSE 70154000 + BEGIN 70155000 + REPLACE POINTER(LEB[U],8) BY PBGN FOR I; 70156000 + LBLEQTN~LEB 70157000 + END; 70158000 + END; 70158050 + BEGIN % FILE.REEL 170159000 + MSG~(ARGH>9999 OR ARGH<0); 70160000 + GEN1~*&GENEALOGY1(*,*,1,ARGH); 70161000 + END; 70162000 + BEGIN % FILE.DATE 270163000 + MSG~(ARGH<0 OR ARGH DIV 1000>99); 70164000 + GEN2.CRTNDATE~ARGH; 70165000 + END; 70166000 + BEGIN % FILE.CYCLE 370167000 + MSG~(ARGH>9999 OR ARGH<0); 70168000 + GEN1.CYCLE~ARGH; 70169000 + END; 70170000 + BEGIN % FILE.VERSION 470171000 + MSG~(ARGH>99 OR ARGH<0); 70172000 + GEN1.GENVERSN~ARGH; 70173000 + END; 70174000 + BEGIN % FILE.SAVEFACTOR 570175000 + MSG~(ARGH>999 OR ARGH<0); 70176000 + GEN2.SAVFACTOR~ARGH; 70177000 + END; 70178000 + BEGIN % FILE.DENSITY 670179000 + MSG~ARGH>3 OR ARGH<0; 70180000 + LEBC~*&LEBCNTRL(*,*,*,1,ARGH); 70182000 + END; 70183000 + BEGIN % FILE.PARITY 770184000 + MSG~(ARGH>1 OR ARGH<0); 70185000 + LEBC.LPARITY~ARGH; 70186000 + END; 70187000 + BEGIN % FILE.KIND 870188000 + T~TYPE; 70189000 + TYPE~ARGH.MOD32F; 70190000 + MSG~(BOOLEAN(PTYPES.TYPEF)OR BOOLEAN(BTYPES.TYPEF)OR 70191000 + ARGH.DIV32F>7 OR ARGH<0); 70192000 + LEBC.PTYPEL~ARGH; 70193000 + TYPE~T; 70194000 + END; 70195000 + BEGIN % FILE.LABELTYPE 970196000 + MSG~(ARGH>2 OR ARGH<0); 70197000 + LEBC.LABELTYPEL~ARGH; 70198000 + LEBC.LABELTYPES~1; 70199000 + END; 70200000 + BEGIN % FILE.EXTMODE 1070201000 + MSG~ARGH>4 OR ARGH<0; 70202000 + LEBC.EXTFORML~ARGH; 70203000 + END; 70204000 + BEGIN % FILE.OPTIONAL 1170205000 + MSG~(ARGH>1 OR ARGH<0); 70206000 + LEBC.OPTIONALF~ARGH; 70207000 + END; 70208000 + BEGIN % FILE.PROTECTION 1270209000 + MSG~(ARGH>2 OR ARGH<0); 70210000 + LEBC.FPRTCTD~ARGH; 70211000 + END; 70212000 + BEGIN % FILE.FILETYPE 1370213000 + MSG~ARGH>5 OR ARGH<0; 70214000 + BLK1.FILETYPEL~T; 70218000 + END; 70219000 + BEGIN % FILE.BLOCKSIZE 1470220000 + MSG~(ARGH<0 OR ARGH>65535); 70221000 + BLK1.BLOCKSZL~ARGH; 70222000 + END; 70223000 + BEGIN % FILE.MAXRECSIZE 1570224000 + MSG~(ARGH<0 OR ARGH>65535); 70225000 + BLK1.MAXRECSZL~ARGH; 70226000 + END; 70227000 + BEGIN % FILE.MINRECSIZE 1670228000 + BLK2.MINRECSZL~ARGH; 70229000 + MSG~(ARGH<0 OR ARGH>65535); 70230000 + END; 70231000 + BEGIN % FILE.AREASIZE 1770232000 + MSG~ARGH<0 OR ARGH>65535; 70233000 + DSKS.AREASIZE~ARGH; 70234000 + END; 70235000 + BEGIN % FILE.AREAS 1870236000 + MSG~ARGH<0 OR ARGH>1023; 70237000 + DSKS.NUMAREAS~ARGH; 70238000 + END; 70239000 + BEGIN % FILE.ACCESS 1970240000 + MSG~ARGH<0 OR ARGH>2; 70241000 + DSKS.ACCSSTYPEF~ARGH; 70242000 + END; 70243000 + BEGIN % FILE.MYUSE 2070244000 + MSG~ARGH<0 OR ARGH>3; 70245000 + DSKS.MYUSEF~ARGH; 70246000 + END; 70247000 + BEGIN % FILE.OTHERUSE 2170247100 + MSG~ARGH<0 OR ARGH>3; 70247200 + DSKS.OTHERUSEF~ARGH; 70247300 + END; 70247400 + BEGIN % FILE.FLEXIBLE 2270248000 + MSG~ARGH<0 OR ARGH>1; 70249000 + DSKS.FLEXIBLEF~ARGH; 70250000 + END; 70251000 + BEGIN % FILE.PACKED 2370252000 + MSG~ARGH<0 OR ARGH>1; 70253000 + DSKS.PACKEDF~ARGH; 70254000 + END; 70255000 + BEGIN % FILE.SPEED 2470256100 + MSG~ARGH>2 OR ARGH<0; 70256110 + DSKS.SPEEDF~ARGH; 70256120 + END; 70256130 + BEGIN % FILE.BUFFERED 2570256140 + MSG~ARGH>1 OR ARGH<0; 70256150 + BFFRD~ARGH; 70256160 + END; 70256170 + BEGIN % FILE.BUFFERS 2670256180 + MSG~ARGH>63 OR ARGH<0; 70256190 + BUFFREQ~ARGH; 70256200 + END; 70256210 + BEGIN % FILE.DIRECTION 2770256220 + MSG~ARGH>1 OR ARGH<0; 70256230 + DSKS.DIRECTIONF~ARGH; 70256240 + END; 70256250 + BEGIN % FILE.ERRECOVERY 2870256260 + MSG~ARGH>1 OR ARGH<0; 70256270 + FILESTATUS.ERRLEVEL~ARGH; 70256280 + END; 70256290 + BEGIN % FILE.INTMODE 2970256300 + MSG~ARGH>4 OR ARGH<0; 70256310 + INTERNALMODE~ARGH; 70256320 + END; 70256330 + BEGIN % FILE.OPEN 3070256340 + MSG~BOOLEAN(ARGH)EQV ALREADYOPEN; 70256350 + IF BOOLEAN(ARGH)THEN OPEN(FIB,0) ELSE 70256360 +% CLOSE(FIB,0) 70256370 + ; 70256380 + END; 70256390 + BEGIN % FILE.PRESENT 3170256400 + OPEN(FIB,3); 70256410 +% RETURN 70256420 + MSG~TRUE; 70256430 + END; 70256440 + BEGIN % FILE.SIZEMODE 3270256450 + MSG~ARGH>4 OR ARGH<0; 70256460 + RECORDMODE~ARGH; 70256470 + END; 70256480 + BEGIN % FILE.SIZEOFFSET 3370256490 + MSG~ARGH>65535 OR ARGH<0; 70256500 + RECORDOFF~ARGH; 70256510 + END; 70256520 + BEGIN % FILE.SIZE2 3470256530 + MSG~ARGH>65535 OR ARGH<0; 70256540 + RECORDSZ~ARGH; 70256550 + END; 70256560 + MSG~TRUE; % FILE.STATE 3570256570 + MSG~TRUE; % FILE.EOF 3670256580 + MSG~TRUE; % FILE.PARITYERR 3770256590 + MSG~TRUE; % FILE.SIZERR 3870256600 + MSG~TRUE; % FILE.LOCKOUT 3970256610 + MSG~TRUE; % FILE.NULINPUT 4070256620 + MSG~TRUE; % FILE.BREAK 4170256630 + BEGIN % FILE.STATUS 4270256640 + OPEN(FIB,STATUSV); 70256650 +% RETURN 70256660 + MSG~TRUE; 70256670 + END; 70256680 + BEGIN % FILE.WRAPAROUND 4370256690 + MSG~ARGH>1 OR ARGH<0; 70256700 + WRAPAROUND~1; 70256710 + END; 70256720 + END; %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%70257000 + IF MSG THEN IOERRMESSL(1,TYPE,POINTER(LEB[(T+LEBC).FXD+ 70258000 + ONES(T.OPTMASK)],8)); 70259000 + DIVORCEMOM(IOAREA); 70260000 + DIVORCEMOM(LEB); 70261000 + TURNOVERLAYKEY(LBLEQTN.ADDRESSF); 70261100 + UNLOCKFIB; 70262000 +END ATTRIBUTEHANDLER; 70263000 +REAL PROCEDURE ATTRIBUTEGRABBER=(0,41)(FIB,TYPE,ARGH); 70263100 + VALUE TYPE; 70263110 + ARRAY FIB[*]; 70263120 + REAL TYPE; 70263130 + WORD ARGH; 70263140 +BEGIN %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%70263150 + % ATTRIBUTEGRABBER GRABS FILE ATTRIBUTES ... SERIOUSLY %70263160 + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%70263170 + ARRAY IOAREA,LEB[*]; 70263180 + BOOLEAN MSG; 70263190 + FIELD TYPEF=TYPE:1; 70263200 + POINTER NAMES=ARGH,PLEB,PNLB; 70263210 + REAL 70263220 + FIB0, 70263230 + U, 70263240 + T, 70263250 + CARE ~4"FFFFFFFFFFF", 70263260 + MSK ~4"FFFFFFFFFFF"; 70263270 + WORD ARRAY FIBW=FIB[*]; 70263280 + FIBUZZ; 70263290 + FIB0~FIBSIZE; 70263300 + IOAREA~IOADESC; 70263310 + IF BOOLEAN(CARE.TYPEF) THEN 70263320 + IF BOOLEAN(MSK.TYPEF)EQV NOTOPEN THEN 70263330 + BEGIN TRACE(18);TRACE(21) END; 70263340 + % IF NOT LABELEQTD THEN GETFPB(FIB); 70263350 + LEB~LBLEQTN&DATADESCRIPTOR(); 70263360 + MAKEPRESENTANDSAVE(LEB); 70263370 + LBLEQTN~LEB; 70263380 + CASE TYPE OF 70263390 + BEGIN %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%70263400 + BEGIN % FILE.TITLE 070263410 + PNLB~NAMES; 70263420 + THRU REAL((PLEB~POINTER(LEB[U~((T~LEB[0]).FXD+ONES(T.OPTMASK))]70263430 + ,8)+3)-1,1)DO 70263440 + REPLACE PNLB:PNLB BY PLEB:PLEB+1 FOR REAL(PLEB,1),8"/"; 70263450 + REPLACE PNLB-1 BY 8"." 70263460 + END; 70263470 + RETURN(GEN1.REEL); % FILE.REEL 170263480 + RETURN(GEN2.CRTNDATE); % FILE.DATE 270263490 + RETURN(GEN1.CYCLE); % FILE.CYCLE 370263500 + RETURN(GEN1.GENVERSN); % FILE.VERSION 470263510 + RETURN(GEN2.SAVFACTOR); % FILE.SAVEFACTOR 570263520 + RETURN(LEBC.DENSITYL); % FILE.DENSITY 670263530 + RETURN(LEBC.LPARITY); % FILE.PARITY 770263540 + RETURN(LEBC.PTYPEL); % FILE.KIND 870263550 + RETURN(LABELTYPE); % FILE.LABELTYPE 970263560 + RETURN(LEBC.EXTFORML); % FILE.EXTMODE 1070263570 + RETURN(LEBC.OPTIONALF); % FILE.OPTIONAL 1170263580 + RETURN(LEBC.FPRTCTD); % FILE.PROTECTION 1270263590 + RETURN(BLK1.FILETYPEL); % FILE.FILETYPE 1370263600 + RETURN(BLK1.BLOCKSZL); % FILE.BLOCKSIZE 1470263610 + RETURN(BLK1.MAXRECSZL); % FILE.MAXRECSIZE 1570263620 + RETURN(BLK2.MINRECSZL); % FILE.MINRECSIZE 1670263630 + RETURN(DSKS.AREASIZE); % FILE.AREASIZE 1770263640 + RETURN(DSKS.NUMAREAS); % FILE.NUMAREAS 1870263650 + RETURN(DSKS.ACCSSTYPEF); % FILE.ACCESS 1970263660 + RETURN(DSKS.MYUSEF); % FILE.MYUSE 2070263670 + RETURN(DSKS.OTHERUSEF); % FILE.OTHERUSEF 2170263680 + RETURN(DSKS.FLEXIBLEF); % FILE.FLEXIBLE 2270263690 + RETURN(DSKS.PACKEDF); % FILE.PACKED 2370263700 + RETURN(DSKS.SPEEDF); % FILE.SPEED 2470263710 + RETURN(BFFRD); % FILE.BUFFERED 2570263720 + RETURN(NUMBEROFBUFFERS); % FILE.BUFFERS 2670263730 + RETURN(DIRECTION); % FILE.DIRECTION 2770263740 + RETURN(FILESTATUS.ERRLEVEL); % FILE.ERRECOVERY 2870263750 + RETURN(INTERNALMODE); % FILE.INTMODE 2970263760 + RETURN(REAL(ALREADYOPEN)); % FILE.OPEN 3070263770 + BEGIN % FILE.PRESENT 3170263780 + OPEN(FIB,3); 70263790 +% RETURN 70263800 + MSG~TRUE; 70263810 + END; 70263820 + RETURN(RECORDMODE); % FILE.SIZEMODE 3270263830 + RETURN(RECORDOFF); % FILE.SIZEOFFSET 3370263840 + RETURN(RECORDSZ); % FILE.SIZE2 3470263850 + RETURN(FIRSTONE(FILESTATUS.STATEF)); % FILE.STATE 3570263860 + RETURN(ENDOV); % FILE.EOF 3670263870 + RETURN(FILESTATUS.PARITYB); % FILE.PARITYERR 3770263880 + RETURN(FILESTATUS.DATAERRORB); % FILE.SIZERR 3870263890 + RETURN(FILESTATUS.LOCKOUTB); % FILE.LOCKOUT 3970263900 + RETURN(FILESTATUS.NOINPUTB); % FILE.NULINPUT 4070263910 + RETURN(FILESTATUS.BREAKB); % FILE.BREAK 4170263920 + BEGIN % FILE.STATUS 4270263930 + OPEN(FIB,STATUSV); 70263940 +% RETURN 70263950 + MSG~TRUE; 70263960 + END; 70263970 + RETURN(WRAPAROUND); % FILE.WRAPAROUND 4370263980 + END; 70263990 + IF MSG THEN IOERRMESSL(2,TYPE,POINTER(LEB[(T~LEBC).FXD+ 70264000 + ONES(T.OPTMASK)],8)); 70264010 + DIVORCEMOM(IOAREA); 70264020 + DIVORCEMOM(LEB); 70264030 + TURNOVERLAYKEY(LBLEQTN.ADDRESSF); 70264040 + UNLOCKFIB; 70264050 +END ATTRIBUTE GRABBER; 70264060 +WORD PROCEDURE MAKEFIB=(0,26)(BUFFERS,LOGICALUNITTYPE,NAMES); 70264070 + VALUE BUFFERS,LOGICALUNITTYPE; 70264080 + REAL BUFFERS,LOGICALUNITTYPE; 70264090 + POINTER NAMES; 70264100 +BEGIN %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%70264110 + % BUILD AN FIB FOR SIMPLE I/O %70264120 + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%70264130 + ARRAY 70264140 + FIB[10+REAL(LOGICALUNITTYPE=DISKFILE)], 70264150 + LEB[5+((REAL(NAMES,1)+5)DIV 6)]; 70264160 + LAYOUT 70264170 + FIBSZL(FIBFXD~9,39-DISKHDRF:1,39-SORTWORDF:1~1) 70264180 + , RECORDSTATSL(MTBUF~1,SIO~1) 70264190 + , FILESTATSL(EOFACTION~1,PARACTION~1) 70264200 + , LEBCL(FXD~5,FPRTCTD~1,LPARITY~1) 70264210 + , DISKSPCL(DRCTRYF~1,FLEXIBLEF~1,SPEEDF,NUMAREAS~20) 70264220 + ; 70264230 + REAL FIB0; 70264240 + WORD ARRAY FIBW=FIB[*]; 70264250 + FIB0~FIBSIZE~0&FIBSZL(,REAL(LOGICALUNITTYPE=DISKFILE),); 70264260 + RECORDSTATUS~0&RECORDSTATSL(,); 70264270 + FILESTATUS~0&FILESTATSL(,); 70264280 + BUFFREQ~BUFFERS; 70264290 + SORTWORD~SNR; 70264300 + LEBC~LOGICALUNITTYPE&LEBCL(,,); 70264310 + DSKS~0&DISKSPCL(,,,); 70264320 + REPLACE POINTER(LEB[5],8) BY NAMES FOR REAL(NAMES,1); 70264330 + LBLEQTN~LEB; 70264340 + MAKEFIB~FIB; 70264350 + DIVORCEMOM(FIB); 70264360 + DIVORCEMOM(LEB); 70264370 +END MAKEFIB; 70264371 +REAL PROCEDURE WRITEALABEL=(0,48)(LEB,U,LBLS,VSN,TYPE,BCNT,RCNT); 70266000 + VALUE U,LBLS,VSN,TYPE,BCNT,RCNT; 70266100 + REAL U,LBLS,VSN,TYPE,BCNT,RCNT; 70266200 + ARRAY LEB[*]; 70267000 +BEGIN %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%70268000 + % THIS PROCEDURE BUILDS THE USASI FILE HEADERS. THE FORMATS %70269000 + % ARE: %70270000 + % %70271000 + % # CHARS NAME %70272000 + % %70273000 + % VOLUME HEADER LABEL %70274000 + % %70275000 + % 4 "VOL1" %70276000 + % 6 VOLUME SERIAL NUMBER %70277000 + % 1 ACCESSIBILITY %70278000 + % 17 FILE SET ID (MULTIPLE FILE ID) %70279000 + % 2 "65" %70280000 + % 1 TAPE TYPE %70281000 + % 6 RFE %70282000 + % 14 OWNER %70283000 + % 28 RFE %70284000 + % 1 LABEL STANDARD LEVEL (1) %70285000 + % %70286000 + % FIRST FILE HEADER %70287000 + % %70288000 + % 4 "HDR1" %70289000 + % 17 FILE IDENTIFIER %70290000 + % 6 SET IDENTIFIER (FIRST 6 CHARACTERS OF %70291000 + % FILE SET ID) %70292000 + % 4 FILE SECTION NUMBER (RELATIVE REEL NUMBER) %70293000 + % 4 FILE SEQUENCE NUMBER (WITHIN SET) %70294000 + % 4 GENERATION NUMBER %70295000 + % 2 GENERATION VERSION %70296000 + % 6 CREATION DATE (BYYDDD) %70297000 + % 6 EXPIRATION DATE (BYYDDD) %70298000 + % 1 ACCESSIBILITY %70299000 + % 6 BLOCK COUNT %70300000 + % 7 RECORD COUNT %70301000 + % 6 " B6500" %70302000 + % 7 RFE %70303000 + % %70304000 + % SECOND FILE HEADER %70305000 + % %70306000 + % 4 "HDR2" %70307000 + % 1 RECORD FORMAT %70308000 + % STANDARD: %70309000 + % F = FIXED LENGTH %70310000 + % D = VARIABLE IN DECIMAL IN FIRST 4 %70311000 + % CHARACTERS %70312000 + % V = VARIABLE IN BINARY IN FIRST 4 %70313000 + % CHARACTERS %70314000 + % U = UNDEFINED %70315000 + % EXTENSIONS: %70316000 + % I - INTERNAL %70317000 + % L = LINKS %70318000 + % Z = FORTRAN FUNNY %70319000 + % 5 BLOCK LENGTH IN EXTERNAL FORM (MAXIMUM) %70320000 + % 5 RECORDLENGTH IN EXTERNAL FORM (MAXIMUM) %70321000 + % 1 DENSITY %70322000 + % 0 = 200 %70323000 + % 1 = 556 %70324000 + % 2 = 800 %70325000 + % 3 = 1600 %70326000 + % 1 VOLUME SWITCH (0 IF FIRST VOLUME OF A FILE) %70327000 + % 1 PARITY %70328000 + % 0 = ALPHA (EVEN) %70329000 + % 1 = BINARY (ODD) %70330000 + % 1 EXTERNAL FORM: %70331000 + % 0 - UNSPECIFIED (WORDS) %70332000 + % 1 - EBCDIC %70333000 + % 2 - BCL %70334000 + % 3 - ASCII %70335000 + % 1 PROTECTION %70336000 + % 5 MINIMUM RECORD LENGTH %70337000 + % 25 TBS %70338000 + % 2 OFFSET TO DATA (6 IF PROTECTED) %70339000 + % 28 RFE %70340000 + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%70341000 + % %70342000 + % FIRST END-OF-FILE LABEL %70343000 + % %70344000 + % SAME AS FIRST FILE HEADER EXCEPT FOR FIRST 4 %70345000 + % CHARACTERS "EOF1" %70346000 + % %70347000 + % SECOND END-OF-FILE LABEL %70348000 + % %70349000 + % SAME AS SECOND FILE HEADER EXCEPT FOR FIRST 4 %70350000 + % CHARACTERS "EOF2" %70351000 + % %70352000 + % END-OF-VOLUME LABEL %70353000 + % %70354000 + % SAME AS FIRST END-OF-FILE LABEL EXCEPT FOR FIRST 4 %70355000 + % CHARACTERS "EOV1" %70356000 + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%70357000 + REAL T, 70358000 + EOT, 70359000 + I, 70360000 + N, 70361000 + TAPETYPE~IF UNIT[U].UNITTYPE=13OR UNIT[U].UNITTYPE=29 70362000 + THEN 1 ELSE 0, 70363000 + RSLT, 70364000 + X, 70365000 + Z; 70366000 + LABEL XIT,WRAPUP; 70367000 + ARRAY LABELAREA[IF TAPETYPE=1 THEN 11 ELSE 15], 70368000 + NAMES[IF TAPETYPE=1 THEN 5 ELSE 7]; 70369000 + POINTER PLEB~POINTER(LEB), 70370000 + PNMS, 70371000 + PLABELAREA, 70372000 + PLBL~POINTER(LEB[(T~LEBC).FXD+ONES(T.OPTMASK)],8)+2; 70373000 + FIELD USASIL=5:1,ENDL=1:1,VLML=0:1; 70374000 + FIELD INTNAME=44:1; 70375000 + DEFINE NNL(S,E) =(IF TAPETYPE=1THEN S ELSE E)#; 70376000 + IF TAPETYPE=1 THEN PLABELAREA~POINTER(LABELAREA[1],6) ELSE 70377000 + PLABELAREA~POINTER(LABELAREA[1],8); 70378000 + N~REAL(PLBL-1,1); 70379000 + WHILE N~N-1>2 DO PLBL~PLBL+1+REAL(PLBL,1); 70380000 + IF TAPETYPE=1 THEN REPLACE PNMS~POINTER(NAMES,6)BY 70381000 + PLBL FOR (X~REAL(PLBL,1))+1+(IF N=0THEN 0ELSE 70382000 + REAL(PLBL+1+X,1)+1) 70383000 + WITH EBCTOBCL[*] 70384000 + ELSE REPLACE PNMS~POINTER(NAMES,8)BY PLBL FOR 70385000 + (X~REAL(PLBL,1)) +1+(IF N=0THEN 0ELSE 70386000 + REAL(PLBL+1+X,1)+1); 70387000 + IF BOOLEAN(LBLS.USASIL)THEN 70388000 + BEGIN 70389000 + IF MAGTAPE(U)THEN 70390000 + LABELAREA[0]~0&TAPEIOCWL(0,REAL(TAPETYPE=1 AND 70391000 + BOOLEAN(T.LPARITY+1)),REAL(TAPETYPE!1),T.DENSITYL, 70392000 + T.LPARITY) 70393000 + ELSE 70394000 + LABELAREA[0]~0&PRINTIOCWL(,1,REAL(T.EXTFORML=1),0,1); 70395000 + IF BOOLEAN(LBLS.VLML)AND NOT BOOLEAN(LBLS.ENDL) THEN 70396000 + BEGIN 70397000 + REPLACE PLABELAREA BY 70398000 + NNL(6"VOL1",8"VOL1") FOR 4 CORRECTLY, 70399000 + VSN FOR 6 CORRECTLY, % SERIAL # 70400000 + % TRANSLATION 70401000 + NNL(6" ",8" ") FOR 1 CORRECTLY, 70402000 + PNMS+1 FOR REAL(PNMS,1), 70403000 + NNL(6" ",8" ")FOR 17-REAL(PNMS,1), 70404000 + NNL(6"65",8"65") FOR 2 CORRECTLY, 70405000 + TYPE FOR 1 CORRECTLY, 70406000 + NNL(6" ",8" ")FOR 48, 70407000 + NNL(6"1",8"1") FOR 1 CORRECTLY; 70408000 + IF REAL(BOOLEAN(RSLT~WAITIO(LABELAREA,USAH,ERAH(UNEXP,0) 70409000 + ).RDERROR)AND BOOLEAN(3"377376"))!0 THEN 70410000 + BEGIN WRITEALABEL~RSLT;GO TO XIT END; 70411000 + EOT~RSLT.RDENDOFTAPE; 70412000 + IF N=1 THEN REPLACE PLABELAREA+11 BY 0 FOR 17; 70413000 + END; 70414000 + REPLACE PLABELAREA BY 70415000 + (IF BOOLEAN(LBLS.ENDL)THEN 70416000 + IF BOOLEAN(LBLS.VLML)THEN 70417000 + NNL(6"EOV1",8"EOV1") ELSE 70418000 + NNL(6"EOF1",8"EOF1") 70419000 + ELSE NNL(6"HDR1",8"HDR1")) FOR 4 CORRECTLY, 70420000 + PNMS+(X~IF N=1 THEN REAL(PNMS,1)ELSE 0)+1 FOR 70421000 + REAL(PNMS+X,1), % FILE ID 70422000 + NNL(6" ",8" ")FOR 17-REAL(PNMS+X,1), 70423000 + IF N=1 THEN 0 ELSE REAL(PNMS+1,MIN(6,REAL(PNMS+1,1))) 70424000 + FOR 6 CORRECTLY, % SET ID 70425000 + NNL(6" ",8" ")FOR IF N=1THEN 6ELSE 70426000 + 6-REAL(PNMS,1), 70427000 + GEN1.REEL FOR 4 DIGITS, % SECTION # 70428000 + 1 FOR 4 DIGITS, % SEQUENCE # 70429000 + GEN1.CYCLE FOR 4 DIGITS, % GENERATION # 70430000 + GEN1.GENVERSN FOR 2 DIGITS, % VERSION # 70431000 + NNL(6" ",8" ") FOR 1 CORRECTLY, 70432000 + (Z~IF(X~GEN2).CRTNDATE=0THEN TODAYSDATE ELSE X.CRTNDATE) 70433000 + FOR 5 DIGITS, 70434000 + NNL(6" ",8" ") FOR 1 CORRECTLY, 70435000 + ((X~Z MOD 100+X.SAVFACTOR+3649)MOD 365 % EXPIRATION DATE 70436000 + +(X DIV 365+Z DIV 100-10)|1000+1)FOR 5 DIGITS, 70437000 + NNL(6" ",8" ") FOR 1 CORRECTLY, 70438000 + BCNT FOR 6 DIGITS, % BLOCK COUNT 70439000 + RCNT FOR 7 DIGITS, % RECORD COUNT 70440000 + NNL(6" B6500",8" B6500")FOR 6 CORRECTLY, 70441000 + NNL(6" ",8" ")FOR 7 CORRECTLY; 70442000 + IF REAL(BOOLEAN(RSLT~WAITIO(LABELAREA,USAH,ERAH(UNEXP,0) 70443000 + ).RDERROR)AND BOOLEAN(3"377376"))!0 THEN 70444000 + BEGIN WRITEALABEL~RSLT;GO TO XIT END; 70445000 + EOT~RSLT.RDENDOFTAPE; 70446000 + IF BOOLEAN(LBLS.ENDL)AND BOOLEAN(LBLS.VLML)THEN GO TO XIT; 70447000 + %%%%% HDR2 70448000 + X~U; 70449000 + U~T.FXD+T.INTNAME; 70450000 + REPLACE PLABELAREA BY 70451000 + (IF BOOLEAN(LBLS.ENDL)THEN NNL(6"EOF2",8"EOF2")ELSE 70452000 + NNL(6"HDR2",8"HDR2"))FOR 4 CORRECTLY, 70453000 + NNL(CASE (Z~BLK1).FILETYPEL OF 70454000 + (6"F",6"D",6"V",6"U",6"I",6"L",6"Z"), 70455000 + CASE Z OF(8"F",8"D",8"V",8"U",8"I",8"L",8"Z")) 70456000 + FOR 1 CORRECTLY, 70457000 + Z.BLOCKSZL FOR 5 DIGITS, % BLOCK.LENGTH 70458000 + Z.MAXRECSZL FOR 5 DIGITS, % RECORD LENGTH 70459000 + (IF T.DENSITYL=0 THEN 2ELSE IF T.DENSITYL=2THEN 0 ELSE 70460000 + T.DENSITYL)FOR 1 CORRECTLY, % DENSITY 70461000 + REAL(GEN1.REEL!1)FOR 1 CORRECTLY, % SENTINEL 70462000 + T.LPARITY FOR 1 CORRECTLY, % PARITY 70463000 + T.EXTFORML FOR 1 CORRECTLY, % EXTERNAL FORM 70464000 + T.FPRTCTD FOR 1 CORRECTLY, % PROTECTION 70465000 + BLK2.MINRECSZL FOR 5 DIGITS, % MIN RECORD SIZE 70466000 + NNL(6" ",8" ")FOR 25, 70467000 + (IF BOOLEAN(T.FPRTCTD)THEN NNL(8,6)ELSE 0) 70468000 + FOR 2 CORRECTLY, % BUFFER OFFSET 70469000 + NNL(6" ",8" ")FOR 28; 70470000 + U~X; 70471000 + IF REAL(BOOLEAN(RSLT~WAITIO(LABELAREA,USAH,ERAH(UNEXP,0) 70472000 + ).RDERROR)AND BOOLEAN(3"377376"))!0 THEN 70473000 + BEGIN WRITEALABEL~RSLT;GO TO XIT END; 70474000 + EOT~RSLT.RDENDOFTAPE; 70475000 + END ELSE 70476000 + ; 70477000 + WRAPUP: 70478000 + WRITEALABEL~EOT; 70479000 + XIT: 70480000 +END WRITEALABEL; 70481000 +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%70482000 +PROCEDURE OPEN(FIB,TYPEV); 70483000 + VALUE TYPEV; 70484000 + ARRAY FIB[*]; 70485000 + REAL TYPEV; 70486000 +BEGIN %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%70487000 + % OPEN MAKES A SOWS EAR OUT OF A SILK PURSE %70488000 + % TYPEV = %70489000 + % 0 - NORMAL OPEN %70490000 + % 1 - REEL SWITCH %70491000 + % 2 - SEARCH (FILE.STATUS) %70492000 + % 3 - ASSIGN IF AVAILABLE (FILE.PRESENT) %70493000 + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%70494000 + WORD LBLSW=FIB,TEMPW,LBLDSCW; %70495000 + ARRAY DHEADER,IOAREA,LABELAREA,LEB[*]; %70496000 + ARRAY LBLDSC=LBLDSCW[*]; 70497000 + DEFINE OUTPUTL=INPUTL#; 70498000 + DEFINE SEARCHV = 2#; 70499000 + DEFINE SKLTN = IOINFO#; 70500000 + FIELD DISKF=47:1; 70501000 + LABEL HR,OUT,CLOSET,TAPEL,CMN,XIT; 70502000 + LABEL SETUP; 70503000 + LABEL RETRYL; 70504000 + LAYOUT 70505000 + BTL(1:1,0:1), 70506000 + INPUTL(IOREADBIT~1,IOTRANSLATE,IOFRAMESIZE,IOMEMPROTECT~1,70507000 + IOBACKWARD); % FORMAT INPUT IOCW 70508000 + POINTER PNMS,PLBL; 70509000 + POINTER PC; 70510000 + REAL 70511000 + FIB0, 70512000 + FRSLT, 70513000 + T, 70514000 + U, 70515000 + UNT, 70516000 + UTYPE, 70517000 + LBLSZ, 70518000 + P, 70519000 + TUSZ, 70520000 + FINDWORD, 70521000 + TAPETYPE, 70522000 + RSLT; 70523000 + EVENT EVNT; 70524000 + REFERENCE IOCB; 70525000 + WORD IOCBW=IOCB; 70525100 + WORD ARRAY FIBW=FIB[*]; 70526000 + VALUE ARRAY CARDCODES ~ ( 70527000 + % A-I 70528000 + 3"0000440042004100", 3"4040402040104004", 70529000 + 3"3002400100000000", 0, 70530000 + % "-"-R 70531000 + 3"2000240022002100", 3"2040202020102004", 70532000 + 3"2002200100000000", 0, 70533000 + % S-Z 70534000 + 3"0000000012001100", 3"1040102010101004", 70535000 + 3"1002100100000000", 0, 70536000 + % 0-9 70537000 + 3"1000040002000100", 3"0040002000100004", 70538000 + 3"0002000100000000", 0 ); 70539000 + MONITOR BOBMONITOR(FINDWORD,RSLT,U,UTYPE); 70540000 + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%70541000 + PROCEDURE WRITEUSERSLABELS(MASK);VALUE MASK;REAL MASK; 70542000 + BEGIN 70543000 + WORD LBLDSCW; 70544000 + ARRAY LBLDSC=LBLDSCW[*]; 70545000 +REAL 70546000 + P, 70547000 + LABELNO; 70548000 + LBLDSCW~LBLSW; 70549000 + LBLDSCW.SIRWDELTAF~LBLSW.SIRWDELTAF+1; 70550000 + TEMPW~LBLSW; 70551000 + LBLSW~LBLDSCW; 70552000 + LBLDSC~FIB; 70553000 + MAKEPRESENTANDSAVE(LBLDSC); 70554000 + LBLSW~TEMPW; 70555000 + P~((LBLDSC.LENGTHF+CASE(P~LBLDSC.SZF)OF(0,0,11,7,5)) 70556000 + DIV CASE P OF (1,.5,12,8,6))DIV NUMLABELS; 70557000 + LABELAREA~*&ARRAYDESCL(,P,M[LBLDSC.ADDRESSF].ADDRESSF); 70558000 + % BEFORE USE ROUTINES 70559000 + THRU NUMLABELS DO 70560000 + BEGIN 70561000 + LABELAREA[0]~SKLTN; 70562000 + IF INTERNALMODE=3THEN REPLACE POINTER(LABELAREA[1],6)BY 6"UHL",70563000 + LABELNO~LABELNO+1 FOR 1 CORRECTLY 70564000 + ELSE 70565000 + REPLACE POINTER(LABELAREA[1],8)BY 8"UHL", 70566000 + LABELNO+LABELNO+1 FOR 1 CORRECTLY; 70567000 + LABELAREA~*&ARRAYDESCL(,P-1,*); 70568000 + IOREQUEST(IOCB~IOQUE(USAH,-@377777,REFERENCE(LABELAREA),EVNT));70569000 + WAIT(EVNT); 70570000 + RESET(EVNT); 70571000 + IF REAL(BOOLEAN(RSLT~REAL(BOOLEAN((MISC@IOCB).RDERROR)OR 70572000 + BOOLEAN(RSLT)))AND BOOLEAN(MASK))!0 THEN 70573000 + BEGIN 70574000 + TRACE(18); 70575000 + TRACE(0); 70576000 + PUTUNT(1,1,0,0); 70577000 + GO TO RETRYL; 70578000 + END; 70579000 + FORGETAREA(6,WORD(IOCB).ADDRESSF); 70580000 + LABELAREA~*&ARRAYDESCL(,P,LABELAREA.ADDRESSF+P-1); 70581000 + END; 70582000 + % USE ROUTINES 70583000 + DIVORCEMOM(LABELAREA); 70584000 + TURNOVERLAYKEY(LBLDSC.ADDRESSF); 70585000 + DIVORCEMOM(LBLDSC); 70586000 + END WRITEUSERSLABELS; 70587000 +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%70588000 + IF ALREADYOPEN THEN %%%%%%%%%%%%%%%%%%%%%%%%% ALREADY OPEN% 70589000 + TRACE(21) 70590000 + ELSE 70591000 + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% CLOSED APPROP. 70592000 + BEGIN 70593000 + % GET FPB 70594000 + LEB~LBLEQTN&DATADESCRIPTOR(); 70595000 + MAKEPRESENTANDSAVE(LEB); 70596000 + LBLEQTN~LEB; 70597000 + RETRYL: 70598000 + IF TYPEV=REGOPEN THEN 70599000 + IF INOUTPART{INV THEN 70600000 + BEGIN %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% INPUT 70601000 + OPNINPUT~1; 70602000 + U~(FINDWORD~FINDINPUT(LEB,0)).REPINFOF; 70603000 +%%%% FIND INPUT HAS TO CHECK LABEL TYPE 70604000 + IF FINDWORD<0 THEN IF TYPEV!SEARCHV THEN TRACE(21)ELSE GO XIT; 70605000 + IF FRSLT~(FINDWORD.REPVALF)=OFV THEN 70606000 + BEGIN % OPTIONAL 70607000 + IF BOOLEAN(NOPTIONAL)THEN TRACE(21); 70608000 + RECORDSTATUS.EXCEPTION~1; 70609000 + ENDOV~1; 70610000 + FILESTATUS.OPT~1; 70611000 + GO TO XIT 70612000 + END ELSE 70613000 + IF FRSLT=FRV THEN 70614000 + BEGIN % FINAL REEL 70615000 + RECORDSTATUS.EXCEPTION~1; 70616000 + ENDOV~1; 70617000 + GO TO XIT 70618000 + END ELSE 70619000 + BEGIN %********************************************************%70620000 + FIB0~FIBSIZE; 70621000 + PNMS~POINTER(LEB[LEBC.FXD+ONES(LEBC.OPTMASK)],8); 70622000 + OPENTIME~*-SCANIN(TIMEOFDAYWORD); 70623000 + % FILE OPEN MESSAGE 70624000 + % HOUSEKEEPING Q 70625000 + IF BOOLEAN(FINDWORD.DISKF)THEN 70626000 + BEGIN %***************************************% DISK FILE 170627000 + SKLTNSTNDRD~DISKREAD; 70628000 + DISKCOMMONL: 70629000 + DHEADER~DISKHEADER~DISKFILEHEADERS[U,*]; 70630000 + IF DHEADER[1].LOGICALMODEF=BCL AND INTERNALMODE>BCL THEN 70631000 + IOERRMESSL(0,1,PNMS); % TRANSLATION PROB70632000 + IF DHEADER[2].RCRDTYPE!RECORDTYPE THEN IOERRMESSL(0,4,PNMS); 70633000 + % USERS LABELS 70634000 + IF REVERSED THEN IF RECORDTYPE>2THEN IOERRMESSL(0,5,PNMS); 70635000 + % COMPATIBILITY 70636000 + UNITYP~DISKFILE; 70637000 + UNITNUMBER~U; 70638000 + GO TO BUFFERSL; 70639000 + END; 70640000 + GETUNT; 70641000 + IF UTYPE~(UNT.UNITTYPE)=CARDREADER THEN 70642000 + BEGIN %***************************************% CARD READER 70643000 + SKLTNSTNDRD~0&INPUTL(,REAL(LCNTRL.EXTFORML=BCL), 70644000 + REAL(INTERNALMODE!BCL)); 70645000 + IF LCNTRL.EXTFORML=BCL AND INTERNALMODE>BCL THEN % TRANS PROB 70646000 + IOERRMESSL(0,1,PNMS); 70647000 + % BLOCKSIZE CHECK Q 70648000 + UNT.UNITASSIGNED~1; 70649000 + UNIT[U]~UNT; 70650000 + UNITYP~UTYPE; 70651000 + UNITNUMBER~U; 70652000 + % USERS LABELS 70653000 + IF REVERSED THEN IOERRMESSL(0,5,PNMS); 70654000 + UINFOW[U]~LBLSW; 70655000 + END ELSE 70656000 + IF MAGTAPE(UTYPE)THEN 70657000 + IF FRSLT=0 THEN % NO SPECIAL MSG 70658000 + BEGIN %***************************************% MAGNETIC TAPE 70659000 + SETUP: 70660000 + TAPETYPE~IF UTYPE=13 OR UTYPE=29 THEN 1 ELSE 2; 70661000 + SKLTN~0&TAPEIOCWL(1, 70662000 + T~REAL(TAPETYPE=1 AND LCNTRL.LPARITY=0),% TRANSLATE 70663000 + IF TAPETYPE=1THEN REAL(INTERNALMODE!BCL AND T=1)ELSE 1, 70664000 + % FRAMESIZE 70665000 + LCNTRL.DENSITYL, % DENSITY 70666000 + LCNTRL.LPARITY); % PARITY 70667000 + UNITYP~UTYPE; 70668000 + UNITNUMBER~U; 70669000 + IF RECORDTYPE>1 THEN IOERRMESSL(0,2,PNMS); % BAD RECORD TYPE 70670000 +% IF BOOLEAN((UNT~UNIT[U]).ULABELLED)THEN USERFIB~WORD(NAME(FIB))70671000 +% ELSE UINFOW[U]~WORD(NAME(FIB)); 70672000 + UNT.UNITASSIGNED~1; 70673000 + UNIT[U]~UNT; 70674000 + IF LCNTRL.EXTFORML=BCL AND INTERNALMODE>BCL THEN % TRANS PROB 70675000 + IOERRMESSL(0,1,PNMS); 70676000 + IF REVERSED THEN IF RECORDTYPE>2THEN IOERRMESSL(0,5,PNMS); 70677000 + IF RECORDTYPE=7 THEN 70678000 + BEGIN % DEPENDENT SPEC 70679000 + IF LCNTRL.LABELTYPEL!0 THEN IOERRMESSL(0,3,PNMS); 70680000 + RECORDTYPE~LBLK1.FILETYPEL; 70681000 + BLOCKSZ~LBLK1.BLOCKSZL; 70682000 + MAXRECSZ~LBLK1.MAXRECSZL; 70683000 + MINRECSZ~LBLK2.MINRECSZL; 70684000 + END; 70685000 + IF LCNTRL.LABELTYPEL=0 THEN 70686000 + BEGIN % B6500 USASI LBL 70687000 + IF LBLK1.FILETYPEL!RECORDTYPE THEN IOERRMESSL(0,4,PNMS); 70688000 + % BLOCK SIZE 70689000 + % RECORD SIZE 70690000 + END ELSE 70691000 + IF LCNTRL.LABELTYPEL=1 THEN % B5500 LABEL 70692000 + BEGIN 70693000 + % RECORD TYPE 70694000 + END ELSE 70695000 + IF LCNTRL.LABELTYPEL=2 THEN 70696000 + BEGIN 70697000 + END ELSE 70698000 + ; 70699000 + % MEMORY DUMP 70700000 + IF NUMLABELS!0 THEN % USERS LABELS 70701000 + IF LCNTRL.LABELTYPEL=0 THEN % B6500 USASI 70702000 + BEGIN 70703000 + LBLDSCW~LBLSW; 70704000 + LBLDSCW.SIRWDELTAF~LBLSW.SIRWDELTAF+1; 70705000 + TEMPW~LBLSW; 70706000 + LBLSW~LBLDSCW; 70707000 + LBLDSC~FIB; 70708000 + LBLSW~TEMPW; 70709000 + MAKEPRESENTANDSAVE(LBLDSC); 70710000 + P~((LBLDSC.LENGTHF+CASE (P~LBLDSC.SZF)OF(0,0,11,7,5)) 70711000 + DIV CASE P OF(1,.5,12,8,6))DIV NUMLABELS; 70712000 + LABELAREA~*&ARRAYDESCL(,P,M[LBLDSC.ADDRESSF].ADDRESSF); 70713000 + THRU NUMLABELS DO 70714000 + BEGIN 70715000 + LABELAREA[0]~SKLTN; 70716000 + LABELAREA~*&ARRAYDESCL(,P-1,*); 70717000 + IOREQUEST(IOCB~IOQUE(USAH,-@377777,REFERENCE(LABELAREA),EVNT));70718000 + WAIT(EVNT); 70719000 + RESET(EVNT); 70720000 + IF REAL(BOOLEAN(RSLT~(MISC@IOCB).RDERROR)AND 70721000 + BOOLEAN(3"376776"))!0 THEN 70722000 + BEGIN 70723000 + CLOSET: 70724000 + TRACE(18); 70725000 + TRACE(0); 70726000 + GO TO OUT; 70727000 + END; 70728000 + FORGETAREA(6,WORD(IOCB).ADDRESSF); 70729000 + IF BOOLEAN(RSLT.RDWLOOREOF)THEN GO OUT; 70730000 + LABELAREA~*&ARRAYDESCL(,P,LABELAREA.ADDRESSF+P); 70731000 + END; 70732000 + LABELAREA~*&ARRAYDESCL(,P,M[LBLDSC.ADDRESSF].ADDRESSF); 70733000 + HR: 70734000 + LABELAREA[0]~*&IOCWL(TAPESPACE,*); 70735000 + IF REAL(BOOLEAN(RSLT~WAITIO(LABELAREA,USAH,ERAH(UNEXP,3"1001") 70736000 + ).RDERROR)AND BOOLEAN(3"376776"))!0 THEN GO TO CLOSET; 70737000 + IF RSLT.RDWLOOREOF=0 THEN GO TO CLOSET; 70738000 + LABELAREA[0]~SKLTN; 70739000 + OUT: 70740000 + DIVORCEMOM(LABELAREA); 70741000 + TURNOVERLAYKEY(LBLDSC.ADDRESSF); 70742000 + DIVORCEMOM(LEB); 70743000 + TURNOVERLAYKEY(LBLEQTN.ADDRESSF); 70744000 + GO TO INXITL; 70745000 + END ELSE 70746000 + IF LCNTRL.LABELTYPEL=2 THEN 70747000 + BEGIN % B5500 70748000 + IF LMISC<0THEN % USERS LABEL 70749000 + BEGIN 70750000 + LABELAREA~*&ARRAYDESCL(0,16,0); 70751000 + LABELAREA[0]~*&IOCWSPACEL(,1,1); % BACK SPACE 70752000 + IF BOOLEAN(RSLT~WAITIO(LABELAREA,USAH,ERAH(UNEXP,0))) THEN 70753000 + GO TO CLOSET; 70754000 + FORGETSPACE(LABELAREA.ADDRESSF); 70755000 + LABELAREA~*&ARRAYDESCL(0,LMISC.BCNTL,0); 70756000 + LABELAREA[0]~SKLTN; 70757000 + IF BOOLEAN(RSLT~WAITIO(LABELAREA,USAH,ERAH(UNEXP,0))) THEN 70758000 + GO TO CLOSET; 70759000 + IF INTERNALMODE=3 THEN PLBL~POINTER(LABELAREA[8],6) ELSE 70760000 + PLBL~POINTER(LABELAREA[10],8)+4; 70761000 + LBLDSCW.SIRWDELTAF~LBLSW.SIRWDELTAF+1; 70762000 + P~LMISC.BCNTL DIV (LBLSZ~IF INTERNALMODE=3 THEN 8 ELSE 6); 70763000 + T~0; 70764000 + TUSZ~0; 70765000 + WHILE T~T+1{NUMLABELS AND P!0 DO 70766000 + BEGIN 70767000 + REPLACE POINTER(LBLDSC,*)+(TUSZ+LBLSZ)BY PLBL:PLBL FOR P:P 70768000 + WHILE!4"FF"; 70769000 + TUSZ~TUSZ+LBLSZ|11; 70770000 + END; 70771000 + GO TO HR 70772000 + END; 70773000 + END; 70774000 + LABELAREA~*&ARRAYDESCL(0,2,0); 70775000 + GO TO HR; 70776000 + END ELSE 70777000 + IF FRSLT=ILV THEN % "IL" MESSAGE 70778000 + BEGIN % IGNORE LABEL 70779000 + CMN: 70780000 + IF BOOLEAN(UNT.ULABELLED)THEN GO TO SETUP; 70781000 + SKLTN~0&TAPEIOCWL(1,0,REAL(TAPETYPE!1),0,1); 70782000 + LABELTYPE~1; 70783000 + % USERS LABELS 70784000 + END ELSE 70785000 + IF FRSLT=ULV THEN GO TO CMN % "UL" MESSAGE 70786000 + ELSE TRACE(21) 70787000 + ELSE 70788000 + IF UTYPE=PAPERTAPERDR THEN 70789000 + BEGIN %***************************************% PAPER TAPE 70790000 + IF LEBC.EXTFORML=SINGLE THEN LEBC.EXTFORML~INTERNALMODE; 70791000 + SKLTN~0&PPRTIOCWL(1,REAL(LEBC.EXTFORML=BCL), 70792000 + REAL(INTERNALMODE!BCL), 70793000 + IF LEBC.EXTFORML=BCL THEN 1 ELSE 70794000 + IF LEBC.EXTFORML=5 THEN 0 ELSE 2); 70795000 + IF REVERSED THEN IOERRMESSL(0,5,PNMS); 70796000 + % USERS LABELS 70797000 + UNITYP~UTYPE; 70798000 + UNITNUMBER~U; 70799000 + END ELSE 70800000 + TRACE(21); 70801000 + INXITL: 70802000 + % IF USERS THEN GETUSERS(ABFI); 70803000 + END; 70804000 + END ELSE 70805000 + IF INOUTPART=OUTV THEN 70806000 + BEGIN %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% OUTPUT 70807000 + OPNOUTPUT~1; 70808000 + %%%%%% NEW DISK FILE 70809000 + IF LEBC.PTYPEL=1 AND DSKS.AREASIZE!0 THEN GO TO DISKL; 70810000 +% U~(FINDWORD~FINDOUTPUT(LBLEQTN,0)).LENGTHF; 70811000 + IF BOOLEAN(FINDWORD.DISKF) THEN 70812000 + %***************************************% DISK 70813000 + IF FINDWORD.REPVALF=OUV THEN 70814000 + BEGIN % NEW OUTPUT FILE 70815000 + %%%%%% GENERAL OUDK 70816000 + DISKL: 70817000 + IF DSKS.NUMAREAS=0 THEN DSKS.NUMAREAS~20; 70818000 + IF DSKS.AREASIZE=0 THEN DSKS.AREASIZE~1000; 70819000 + SKLTNSTNDRD~DISKWRITE; 70820000 + UNITYP~UTYPE~DISKFILE; 70821000 + % BUILDAHEADER 70822000 + DHEADER[1]~LEBC.EXTFORML&HEADERINFOONE( 70823000 + 1 % UPDATE 70824000 + , 1 % OPEN COUNT 70825000 + , 1 % FILE KIND 70826000 + , 30 % HEADER SIZE 70827000 + ); 70828000 + DHEADER[2]~FILEACCESS&HEADERINFOTWO( 70829000 + DSKS.PACKEDF % PACKED 70830000 + , LEBC.FPRTCTD 70831000 + , DSKS.DRCTRYF 70832000 + , RECORDTYPE % RECORD TYPE 70833000 + ); 70834000 + DHEADER[3]~TANKDATA2; 70835000 + DHEADER[5]~(IF BOOLEAN(DSKS.PACKEDF)THEN 70836000 + ((MAXRECSZ|DSKS.AREASIZE+ 70837000 + CASE INTERNALMODE OF(0,0,11,7,5,5))DIV 70838000 + CASE INTERNALMODE OF(1,.5,12,8,6,6)+29)DIV 30 70839000 + ELSE 70840000 + ((BLOCKSZ+CASE INTERNALMODE OF (0,0,11,7,5,5))DIV 70841000 + CASE INTERNALMODE OF(1,.5,12,8,6,6)+29)DIV 30 70842000 + |(DSKS.AREASIZE DIV (BLOCKSZ DIV MAXRECSZ)) 70843000 + )&ROWINFO(DSKS.NUMAREAS); 70844000 + DHEADER[6]~1&NAMEQUALIFICATIONINFO(GEN2.SAVFACTOR,TODAYSDATE); 70845000 + DHEADER[7]~TODAYSDATE; 70846000 + % ENTERUSERFILE(LEB,DHEADER); 70847000 + % USERS LABELS 70848000 + GO TO BUFFERSL; 70849000 + END ELSE 70850000 + BEGIN % OLD OUTPUT FILE 70851000 + SKLTNSTNDRD~DISKWRITE; 70852000 + GO TO DISKCOMMONL; 70853000 + END; 70854000 + IF REVERSED THEN IOERRMESSL(0,6,PNMS); 70855000 + GETUNT; 70856000 + UNT.UNITASSIGNED~1; 70857000 + IF UTYPE~UNT.UNITTYPE=CARDPUNCH1 OR UTYPE=CARDPUNCH2 THEN 70858000 + BEGIN %***************************************% CARD PUNCH 70859000 + IF LEBC.EXTFORML=SINGLE THEN LEBC.EXTFORML~INTERNALMODE; 70860000 + IF INTERNALMODE=BCL AND LEBC.EXTFORML>BCL THEN % TRANS PROB 70861000 + IOERRMESSL(0,1,PNMS); 70862000 + SKLTNSTNDRD~0&OUTPUTL(0,REAL(LEBC.EXTFORML=BCL), 70863000 + REAL(INTERNALMODE!BCL)); 70864000 + UNITYP~UTYPE; 70865000 + UNITNUMBER~U; 70866000 + IF USASILABEL THEN 70867000 + BEGIN 70868000 + IF BOOLEAN(WRITEALABEL(LBLEQTN,U,33,0,1,BLOCKCOUNT,RECORDCOUNT)70869000 + )THEN 70870000 + BEGIN 70871000 + % IRRECOVERABLE PUNCH CHECK 70872000 + PNCHCKL: 70873000 + UNIT[U]~UNT; 70874000 + % MESSAGE Q 70875000 + PUTUNT(1,1,0,0); 70876000 + GO TO RETRYL; 70877000 + END; 70878000 + UNT.ULABELLED~0; 70879000 + END ELSE 70880000 + IF NOT UNLABELLED THEN 70881000 + BEGIN 70882000 + LABELAREA~*&ARRAYDESCL(0,IF INTERNALMODE=3THEN 11 ELSE 15,0); 70883000 + LABELAREA[0]~0; 70884000 + IF LEBC.EXTFORML!BCL THEN 70885000 + REPLACE PLBL:PLBL~POINTER(LABELAREA[1],6) BY 70886000 + 6"70",6"00", 70887000 + 6"||M090M0",6"00" 70888000 + ELSE 70889000 + REPLACE PLBL:PLBL~POINTER(LABELAREA[1],6) BY 70890000 + 6"70",6"00", 70891000 + 6"||M090M0K0",6"00"; 70892000 + PC~POINTER(CARDCODES,6); 70893000 + THRU REAL(PNMS~PNMS+2,1) DO 70894000 + REPLACE PLBL:PLBL BY PC+2|REAL(PNMS~PNMS+1,1).MOD64F 70895000 + FOR 2; 70896000 + IF BOOLEAN(WAITIO(LABELAREA,USAH,ERAH(UNEXP,0)))THEN 70897000 + GO TO PNCHCKL; 70898000 + FORGETSPACE(LABELAREA.ADDRESSF); 70899000 + UNT.ULABELLED~1; 70900000 + END ELSE 70901000 + UNT.ULABELLED~0; 70902000 + UNIT[U]~UNT; 70903000 + IF NUMLABELS!0 THEN WRITEUSERSLABELS(REAL(NOT FALSE)); 70904000 + END CARD PUNCH ELSE 70905000 + IF MAGTAPE(UTYPE) THEN 70906000 + BEGIN %***************************************% MAGNETIC TAPE 70907000 + TAPETYPE~IF UTYPE=13 OR UTYPE=29 THEN 1 ELSE 70908000 + IF UTYPE=14 OR UTYPE=30 THEN 2 ELSE 3; 70909000 + SKLTN~0&TAPEIOCWL(, 70910000 + T~REAL(TAPETYPE=1 AND NOT BOOLEAN(LEBC.LPARITY)), 70911000 + IF TAPETYPE=1THEN REAL(INTERNALMODE=EBCDIC AND BOOLEAN(T))70912000 + ELSE 1, 70913000 + % LEB DENSITY MAINTAINED CORRECTLY (+4) 70914000 + LEBC.DENSITYL, 70915000 + LEBC.LPARITY); 70916000 + UNITYP~UTYPE; 70917000 + UNITNUMBER~U; 70918000 +% IF BOOLEAN(UNT.ULABELLED)THEN USERFIB~WORD(NAME(FIB)) 70919000 +% ELSE UINFOW[U]~WORD(NAME(FIB)); 70920000 + IF USASILABEL THEN 70921000 + BEGIN 70922000 + IF BOOLEAN(WRITEALABEL(LBLEQTN,U,33,UINFO[U],1,BLOCKCOUNT, 70923000 + RECORDCOUNT)) THEN 70924000 + BEGIN 70925000 + PERR: 70926000 + % MESSAGE 70927000 + UNIT[U]~UNT; 70928000 + PUTUNT(1,1,0,0); 70929000 + GO TO RETRYL; 70930000 + END; 70931000 + UNT.ULABELLED~1; 70932000 + END ELSE 70933000 + UNT.ULABELLED~0; 70934000 + IF NUMLABELS!0 THEN 70935000 + BEGIN 70936000 + WRITEUSERSLABELS(3"377376"); 70937000 + LABELAREA~*&ARRAYDESCL(0,1,0); 70938000 + % TAPE MARK 70939000 + LABELAREA[0]~SET(SKLTN,35-REAL(SIMULATING)); % TAPE MARK 70940000 + IF REAL(BOOLEAN(RSLT~WAITIO(LABELAREA,USAH,ERAH(UNEXP,0) 70941000 + ).RDERROR)AND BOOLEAN(3"377376"))!0 THEN 70942000 + GO TO PERR; 70943000 + END; 70944000 + UNIT[U]~UNT; 70945000 + END TAPE ELSE 70946000 + IF PRNTR(UTYPE)THEN 70947000 + BEGIN %***************************************% PRINTER 70948000 + % ONLY SET UP FOR BCL PRINTER 70949000 + IF LEBC.EXTFORML=SINGLE THEN LEBC.EXTFORML~INTERNALMODE; 70950000 + SKLTN~0&OUTPUTL(0,1,REAL(INTERNALMODE!BCL)); 70951000 + UNITYP~UTYPE; 70952000 + UNITNUMBER~U; 70953000 + IF NOT UNLABELLED THEN 70954000 + BEGIN 70955000 + LABELAREA[0]~0&IOCWL(@200,0&IOCWPRINTERL(1)); 70956000 + IF BOOLEAN(WAITIO(LABELAREA,USAH,ERAH(UNEXP,0)))THEN 70957000 + BEGIN 70958000 + PRINTERRL: 70959000 + % MESSAGE 70960000 + UNIT[U]~UNT; 70961000 + PUTUNT(1,1,0,0); 70962000 + GO TO RETRYL; 70963000 + END; 70964000 + LBLDSC[0]~SKLTN&IOCWPRINTERL(0,2); 70965000 + IF BOOLEAN(WRITEALABEL(LBLEQTN,1,33,0,1,BLOCKCOUNT, 70966000 + RECORDCOUNT)) THEN 70967000 + GO TO PRINTERRL; 70968000 + IF BOOLEAN(WAITIO(LBLDSC,USAH,ERAH(UNEXP,0)))THEN 70969000 + GO TO PRINTERRL; 70970000 + END; 70971000 + CARRIAGECONTROL~1; 70972000 + UNIT[U]~UNT; 70973000 + END PRINTER ELSE 70974000 + IF UTYPE=PAPERTAPEPNCH THEN 70975000 + BEGIN %***************************************% PAPER TAPE PUNCH70976000 + IF LEBC.EXTFORML=SINGLE THEN LEBC.EXTFORML~INTERNALMODE; 70977000 + SKLTN~0&PPRTIOCWL(0,REAL(LEBC.EXTFORML=BCL), 70978000 + REAL(INTERNALMODE!BCL), 70979000 + IF LEBC.EXTFORML=BCL THEN 1 ELSE 70980000 + IF LEBC.EXTFORML=5 THEN 0 ELSE 2); 70981000 + UNITYP~UTYPE; 70982000 + UNITNUMBER~U; 70983000 + UNIT[U]~UNT; 70984000 + % PUNCH LEADER 70985000 + % 15 FEET OF LEADER (MINIMUM 4 FEET - PER BURROUGHS SPECS)70986000 + % 10 CHARACTERS PER INCH 70987000 + LABELAREA~*&ARRAYDESCL(0,2,0); 70988000 + LABELAREA[0]~SET(SKLTN,43); 70989000 + LABELAREA~*&ARRAYDESCL(2,1800 DIV 70990000 + (IF LEBC.EXTFORML!BCL THEN 6 ELSE 8),*); 70991000 + IF BOOLEAN(WAITIO(LABELAREA,USAH,ERAH(UNEXP,0)))THEN 70992000 + BEGIN 70993000 + % MESSAGE 70994000 + PUTUNT(1,1,0,0); 70995000 + GO TO RETRYL; 70996000 + END; 70997000 + LABELAREA~*&ARRAYDESCL(0,2,*); 70998000 + FORGETSPACE(LABELAREA.ADDRESSF); 70999000 + END ELSE 71000000 + TRACE(21); 71001000 + END ELSE 71002000 + TRACE(21); 71003000 + END; 71004000 + BUFFERSL: 71005000 + IF NUMBEROFBUFFERS=0 THEN 71006000 + BEGIN % SET UP IOAREAS 71007000 + % ALTERNATE AREA 71008000 + IF BLOCKSZ=0 THEN BLOCKSZ~(MAXRECSZ+ 71009000 + CASE INTERNALMODE OF (0,0,11,7,5,5))DIV 71010000 + WORDSTO; 71011000 + % CONVERT CHARS TO WORDS 71012000 + FILEVENT~EVENTNUMBER; 71013000 + FRSLT~REAL((U~BUFFREQ)|(RSLT~IOTANKSZ+BLOCKSZ+ 71014000 + (IF RECORDTYPE!0 AND OPENINPUT THEN MAXRECSZ-MINRECSZ 71015000 + ELSE 0)){MAGICNUMBER); 71016000 + IOADESC~SETUPTANK(U,2,RSLT, 71017000 + 0&BTL(FRSLT,REAL((UNITYP=DISKFILE OR PRNTR(UNITYP)) AND 71018000 + NUMBEROFBUFFERS!1)), 71019000 + IOINFO&IOINFOL(*),IOEVENT[FILEVENT],UNITNUMBER); 71020000 + NUMBEROFBUFFERS~RSLT~U; 71021000 + BFFRD~REAL(U>1); 71022000 + END; 71023000 + IF CRRGCNTRL AND BUFFERED AND PRNTR(UNITYP) THEN 71024000 + BEGIN 71025000 + IOAREA~IOADESC; 71026000 + IOAREA~*&ARRAYDESCL(,*,IOAREA[IOAL].BL); 71027000 + BFRACTN~1 71028000 + END; 71029000 + IF OPENINPUT THEN 71030000 + BEGIN 71031000 + IOAREA~IOADESC; 71032000 + IOCB~REFERENCE(IOAREA); 71033000 + THRU NUMBEROFBUFFERS DO 71034000 + BEGIN 71035000 + IOREQUEST(IOCB); 71036000 + IOCB~REFERENCE(IOAREA~*&ARRAYDESCL(,*,IOAREA[IOAL].FL)); 71037000 + END; 71038000 + IF NOT ARRAYROW THEN WAITON(IOCB); 71039000 + BFFRXHSTD~1; 71039100 + IF NOT ARRAYROW THEN 71039200 + BEGIN 71039300 + LBLDSCW~LBLSW; 71040000 + LBLDSCW.SIRWDELTAF~LBLSW.SIRWDELTAF-1; 71041000 + TEMPW~LBLSW; 71042000 + LBLSW~LBLDSCW; 71043000 + FIB~*&STRINGDESCRIPTOR(,1,,,,,EBCDIC,MAXRECSZ, 71044000 + IOAREA.ADDRESSF+IOTANKSZ); 71045000 + LBLSW~TEMPW; 71046000 + END; 71046100 + END; 71047000 + % BREAK OUT 71048000 + XIT: 71049000 + IOCBW~0; 71049100 + DIVORCEMOM(IOAREA); 71050000 + DIVORCEMOM(LBLDSC); 71051000 +END OPEN; 71052000 +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%71053000 +INTEGER PROCEDURE CALCRECSZ(BUFDESC,FIB);ARRAY BUFDESC,FIB[*]; 71054000 +BEGIN %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%71055000 + % USED WITH RECORDTYPES D,V, AND I %71056000 + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%71057000 + ARRAY DUMMYA[*]; 71058000 + POINTER BUFDESCP=BUFDESC; 71059000 + WORD ARRAY FIBW=FIB[*]; 71060000 + IF WORDORIENTED THEN 71061000 + BEGIN 71062000 + IF REVERSED THEN 71063000 + BEGIN 71064000 + DUMMYA~*&ARRAYDESCL( 71065000 + ,MAXRECSZ 71066000 + ,REAL(WORD(AREADESC@REFERENCE(IOADESC))).ADDRESSF+1+ 71067000 + BLOCKSZ-MISC@REFERENCE(IOADESC).WORDCOUNTF 71068000 + ); 71069000 + WHILE DUMMYA.ADDRESSF