diff --git a/source/B65MCP/MARK00.esp_m b/source/B65MCP/MARK00.esp_m index 35c85ca..d9ef49a 100644 --- a/source/B65MCP/MARK00.esp_m +++ b/source/B65MCP/MARK00.esp_m @@ -1,7 +1,8 @@ ?EXECUTE B65ESP/DISK 00000010140621PK -?FILE CODE=B65MCP/DISK 00000020140621PK +?STACK=1000 00000020140722PK +?FILE CODE=B65MCP/DISK 00000030140621PK ?DATA CARD 00000080140621PK -$ LIST SINGLE PRT DEBUG DONSBUG INFO POOL 00000090140621PK +$ LIST PRT 00000090140724PK BEGIN 00000100 COMMENT MCP LISTING DIRECTORY 00001000 010000000 INDEPENDENT RUNNER FORWARD DECLARATION 00002000 @@ -798,7 +799,7 @@ COMMENT FOLLOWING IS THE FORMAT OF THE NORMAL AND STUFFED IRWS; 10140000 , MARKSTACKCW( TAG ~ MSCW 10151000 , DSBITF =47:1 10152000 , EBITF 10153000 - , STKNRF, 10154000 + , STKNRF 10154000 , VBITF = 19:1 10155000 , LLF = 18:5 10156000 , DFF = 13:14 10157000 @@ -2064,7 +2065,7 @@ PROCEDURE STANDARDDELINK (FIRSTENTRY, LASTENTRY, ENTRY); 16016000 PREVIOUSSTANDARD @ ENTRY; 16037000 END OF DELINKING STANDARD QUEUE; 16038000 REFERENCE LASTNAME; 17000000 -save reference procedure allocatenameq; forward; 17000100**KLUDGE +SAVE REFERENCE PROCEDURE allocatenameq; FORWARD; 17000100 QUEUE NAMEQUEUE:FIRSTNAME(PREVNAME,NEXTNAME,POINTERTONAME,CHARCOUNT); 17001000 VALUE POINTERTONAME, CHARCOUNT, PREVNAME, NEXTNAME; 17002000 REFERENCE PREVNAME, NEXTNAME; 17003000 @@ -2467,7 +2468,7 @@ COMMENT DEFINES FOR FIB; 19015000 , IRCORE = 500 # %TOTAL CORE 20003000 , IRPROCTIME = 1000 # 20004000 , IRIOTIME = 500 # 20005000 - , DOOFFSET = 0 # 20006000 + , D0OFFSET = 0 # 20006000 ; 20007000 REAL INDEPENDENTRUNNERLOK 20008000 ; 20009000 @@ -3824,4 +3825,2049 @@ DEFINE 24714000 ACCESSMODE = FILEACCESS.ACSSMODE#, %24718000 ACCESSOFF = FILEACCESS.ACSSOFF#, 24719000 ACCESSZ = FILEACCESS.ACSSZ#, 24720000 + ACCESSTYPE= FILEACCESS.ACSSTYPE#, 24720100 + ACTIONTAKEN=BOOLEAN(ATAKEN)#, 24720150 + ACTIVE = IOAREA[IOAW].ACTV#, 24721000 + ACTUALKEY = IOAREA[IOAW].ACTLKY#, 24722000 + ADD1TOBIT32=4294967296#, 24722100 + ADRSF = ADDRESSF#, 24723000 + AFTER = BOOLEAN(UNITFEATURE.MOTIONF)#, 24723100 + ALREADYOPEN = RECORDSTATUS.OPENBITS!0#, 24724000 + ATAKEN = FILESTATUS.EXCEPTIONT#, 24724010 + ARRAYROW = BOOLEAN(TANKDATA1.PNTR)#, 24724100 + BEFORE = NOT AFTER#, 24724200 + BFFRD = TANKDATA3.BUFFERD#, 24726000 + BEFOREACTION=BOOLEAN(IOAREA[IOAW].BFR)#, 24727000 + BFFRXHSTD = RECORDSTATUS.MTBUF#, 24728000 + BLCKDFNNY = TANKDATA1.BLKFUNNY#, 24729000 + BFRACTN = IOAREA[IOAW].BFR#, 24730000 + BLKDFNNY(P1,P2,SZ) = IF BLOCKEDFUNNY THEN 24731000 + REPLACE P1 BY P2 FOR SZ WORDS#, 24732000 + BLOCKED = BOOLEAN(TANKDATA1.BLKD)#, 24733000 + BLOCKEDFUNNY = BOOLEAN(TANKDATA1.BLKFUNNY)#, 24734000 + BLOCKSZ = TANKDATA2.BLOCKSIZE#, 24735000 + BUFFERED = BOOLEAN(BFFRD)AND NUMBEROFBUFFERS!0#, 24736000 + BUFFEREXHAUSTED = BOOLEAN(RECORDSTATUS.MTBUF)#, 24737000 + BUFFERSZ = TANKDATA3.BFFRSZ#, 24738000 + BUFFREQ = TANKDATA3.BUFFREQSTD#, 24739000 + CARRIAGECONTROL=RECORDSTATUS.UFEAT#, 24740000 + CHANNELNO = UNITFEATURE.ADDRESSF#, 24741000 + CHANNELSKIP=BOOLEAN(UNITFEATURE.SKIPF)#, 24742000 + CHARECORD = BOOLEAN(RECORDUNITS)#, 24742100 + CHERE = FILESTATUS.CLSHR#, 24743000 + CLOSEHERE = BOOLEAN(FILESTATUS.CLSHR)#, 24744000 + CONTGS = TANKDATA3.CNTGS#, 24745000 + CONTIGUOUS= BOOLEAN(TANKDATA3.CNTGS)#, 24746000 + CRRGCNTRL = BOOLEAN(CARRIAGECONTROL)#, 24747000 + DIRECTION = IOINFO.IOBACKWARD#, 24748000 + DISC = UNITYP=DISKFILE#, 24749000 + DISKREAD = @460#, % MEMORY PROTECT 24749100 + DISKWRITE = @040#, 24749200 + DIVORCEMOM(A)=A~A&DIVMOML(,)#, 24750000 + ENDOF = BOOLEAN(FILESTATUS.EOFB)#, 24751000 + ENDOFACTION = FILESTATUS.EOFACTION#, 24752000 + ENDOFTAKEN= ENDOF AND ACTIONTAKEN#, 24753000 + ENDOV = FILESTATUS.EOFB#, 24754000 + ENTERDIR = FILEACCESS.DRCTRYF#, 24755000 + EVENTNO = TANKDATA3.BEVNT#, 24756000 + EXPLICITADDRESS=BOOLEAN(FILEACCESS.EXPADRS)#, 24757000 + FFORTRAN = RECORDTYPE=6#, 24757100 + BIB0 = FIBSIZE#, 24757200 + FIBUZZ = IF FIBB(FIBLOCKF) THEN BEGIN 24758000 + WHILE BOOLEAN(READLOCK(1,LOCKER)) DO 24759000 + WAIT(IOEVENT[FILEVENT]); 24760000 + RESET(IOEVENT[FILEVENT]) END#, 24761000 + FILEDRCDSIZE=BOOLEAN(RECORDSTATUS.DRCDSIZE)#, 24761050 + FILEMTBUF = BOOLEAN(RECORDSTATUS.MTBUF)#, 24761100 + FILENOTOPEN = RECORDSTATUS.OPENBITS=0#, 24762000 + FILEVENT = LABELATT.EVNTNO#, 24763000 + FILEXCPTN = BOOLEAN(RECORDSTATUS.EXCEPTION)#, 24764000 + FIXEDL = RECORDTYPE=0#, 24764100 + FLINKED = RECORDTYPE=5#, 24764200 + FORMATD = RECORDTYPE=1#, 24764300 + FORMATI = RECORDTYPE=4#, 24764400 + FORMATTER = BOOLEAN(TANKDATA1.PNTR)AND PFOCRCSZ#, 24764450 + FORMATU = RECORDTYPE=3#, 24764500 + FORMATV = RECORDTYPE=2#, 24764600 + FORMSMESSAGE=LEBB(FRMS)#, 24764700 + GENSZ= 4#,% 24766000 + IMPLCTOPN = FILESTATUS.IMPOPEN#, 24767000 + IMPLICITOPEN=NOT BOOLEAN(IMPLCTOPN)#, 24768000 + INOUTPART = DSKS.MYUSEF#, 24769000 + INTERNALMODE = FILESTATUS.INTMODE#, 24770000 + IOCOMPLET = USER@(IOCB).USERIOFINISH#, 24771000 + IOCOMPLETE= BOOLEAN(WORD(USER@IOCB).(USERIOFINISH)#, 24772000 + IOCWSKLTN= IOINFO#, 24774000 + IOPENDING = NOT IOCOMPLETE#, 24775000 + IOTERMINATE=BEGIN TRACE(18);TRACE(21)END#, 24776000 + LABELEQTD = BOOLEAN(LABELATT.LBLEQTD)#, 24777000 + LABELTYPE = LABELATT.LABELTYP#, 24778000 + LASTBUFFER=IOAREA~*&ARRAYDESCL(,*,IOAREA[IOAL].BL)#, 24778100 + LASTLENGTH= TANKDATA1.SIZESZ#, 24778200 + LBLEQUATED= LABELATT.LBLEQTD#, 24779000 + LOCKOUT = FILESTATUS.LOCKOUTB#, 24780000 + MAGICNUMBER=150#, 24781000 + MAXGENNO= 9999#,% 24781100 + MAXNO = 549755813887#, 24782000 + MAXRECSZ = TANKDATA2.MAXRECSIZE#, 24783000 + MAXVERNO= 99#,% 24783100 + MINRECSZ = TANKDATA2.MINRECSIZE#, 24784000 + MLTBLCK = TANKDATA1.MLTBLK#, 24785000 + MULTIBLOCK= BOOLEAN(TANKDATA1.MLTBLK)#, 24786000 + NEXTBUFFER=IOAREA~*&ARRAYDESCL(,*,IOAREA[IOAL].FL)#, 24786100 + NOACTION = BOOLEAN(UNITFEATURE.REUSEF)#, 24786200 + NOLINES = UNITFEATURE.ADDRESSF#, 24786600 + NOMORE = BOOLEAN(WORD(USER@IOCB).USEREOFORTBIT)#, 24789000 + NOTOPEN = RECORDSTATUS.OPENBITS=0#, 24791000 + NUMBEROFBUFFERS = TANKDATA3.BUFFASSGND#, 24792000 + NUMLABELS = LABELATT.USERSIZE#, 24794000 + ONEREELREVERSE=BOOLEAN(DSKS.REVACTIONF)#, 24795000 + OPENINPUT = BOOLEAN(RECORDSTATUS.OPNIN)#, 24796000 + OPENIO = RECORDSTATUS.OPENBITS=3#, 24797000 + OPENOUTPUT = BOOLEAN(RECORDSTATUS.OPNOUT)#, 24798000 + OPNINPUT = RECORDSTATUS.OPNIN#, 24799000 + OPNOUTPUT = RECORDSTATUS.OPNOUT#, 24800000 + NOPTIONAL = LEBC.OPTIONALF#, 24801000 + OPTSPACE(SYZE)=GETSPACE(SYZE,0,0,0)#, 24802000 + PARITYERROR=BOOLEAN(WORD(USER@IOCB).USERPARITYBIT)#, 24802100 + PARITYERR = FILESTATUS.PARITYB#, 24802500 + PARITYACTION=FILESTATUS.PARACTION#, 24802600 + PASSED = IOAREA[IOAW].PSSD#, 24803000 + PFOCRCSZ = BOOLEAN(PFOC.DRCDSIZE)#, 24807000 + PFOCMTBUF = BOOLEAN(PFOC.MTBUF)#, 24808000 + PLMT(UT) = ((UT=CARDREADER OR UT=CARDPUNCH1 OR 24810000 + UT=CARDPUNCH2) AND BLOCKSZ>10 OR 24811000 + (UT=BUFFPRINTER OR UT=UNBUFFPRINTER) AND 24812000 + BLOCKSZ>17 24813000 + )#, 24814000 + PNCH(UT) = (UT=CARDPUNCH1 OR UT=CARDPUNCH2)#, 24814010 + POINTEREQD=ARRAYROW#, 24814050 + PRINTSPACE= @200#, 24814100 + PRNTR(UT) = (UT=BUFFPRINTER OR UT=UNBUFFPRINTER)#, 24816000 + PROPERIOACTION = RECORDSTATUS.OPNIN=PFOC.OPNIN#, 24817000 + PROTECTED = LEBC.FPRTCTD#, 24818000 + PRTY = BOOLEAN(FILESTATUS.PARITYB)#, 24819000 + PRTYACTN = FILESTATUS.PARACTION#, 24820000 + RANDOM = ACCESSTYPE=1#, 24821000 + RCRDSZ(A,B)=IF FIXEDL THEN MAXRECSZ ELSE IF FLINKED THEN 24821100 + IF WORDORIENTED THEN M[A.ADDRESSF].FRWRDLNK 24821200 + ELSE REAL(B,WORDSTO).FRWRDLNK ELSE 24821300 + CALCRECSZ(A,FIB)#, 24821400 + RECINBLK = IOAREA[IOAW].RCN#, 24824000 + RECORDMODE = TANKDATA1.SIZEMODE#, 24827000 + RECORDOFF = TANKDATA1.SIZEOFF#, 24828000 + RECORDSZ = TANKDATA1.SIZESZ#, 24829000 + RECORDUNITS=TANKDATA1.RCDUNTS#, 24830000 + RECORDTYPE= TANKDATA1.RCRDTYPE#, 24831000 + RECSIZE = TANKDATA2.MAXRECSIZE#, 24832000 + REQSPACE(SYZE)=GETSPACE(SYZE,0,0&SPACETYPE(0,1,1,0),0)#, 24833000 + REVERSED = BOOLEAN(DIRECTION)#, 24834000 + REVERSETYPE = UNITYP=DISKFILE OR MAGTAPE(UNITYP)#, 24835000 + REWRITE = BOOLEAN(IOAREA[IOAW].RWRT)#, 24836000 + REWRT = IOAREA[IOAW].RWRT#, 24837000 + ROTATEBUFFERS=IF BUFFERED THEN 24837100 + IOCB~REFERENCE(IOAREA~IOADESC~ 24837200 + IOAREA&ARRAYDESCL(,*,IOAREA[IOAL].FL))#, 24837300 + SIZEPROBLEM=FILESTATUS.DATAERRORB#, 24841000 + SKLTN = IOINFO.SKLTNIOCW#, 24843000 + SKLTNSTNDRD = IOINFO.SIOCWSTANDARD#, 24844000 + TANKEY = IOAREA[IOAW].ACTLKY#, 24845000 + TAPEFILE = MAGTAPE(IOINFO.UNITYPP)#, 24846000 + TAPEREWIND=@210#, 24847000 + TAPESPACE = @600#, 24847100 + UNBLOCKED = NOT BOOLEAN(TANKDATA1.BLKD)#, 24848000 + UNITNUMBER=IOINFO.UNITNUM#, 24849000 + UNITYP=IOINFO.UNITYPP#, 24850000 + UNLABELLED= LABELTYPE=1#, 24851000 + UNLOCKFIB = IF FIBB(FIBLOCKF) THEN BEGIN 24852000 + READLOCK(0,LOCKER); 24853000 + CAUSE(IOEVENT[FILEVENT]) END#, 24854000 + USASILABEL= LABELTYPE=0#, 24855000 + VERSZ= 2#,% 24856000 + WORDORIENTED=NOT CHARECORD#, 24856050 + WORDSLEFT = UNITSLEFT#, 24856100 + WORDSTO = CASE INTERNALMODE OF(1,.5,12,8,6,6)#, 24857000 + WORDSTORND= CASE INTERNALMODE OF (0,0,11,7,5,5)#, 24858000 + WRAPAROUND= LABELATT.WRPRND#; 24859000 +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%24860000 +SAVE PROCEDURE AVAILREMOVE (AVAILZLINK); 30000000 + VALUE AVAILZLINK; 30001000 + INTEGER AVAILZLINK; 30002000 + BEGIN COMMENT REMOVE AN AREA FROM THE AVAILABLE LIST; 30003000 + INTEGER MI ~ AVAILZLINK - M[AVAILZLINK].LENGTHZ + 1; 30004000 + INTEGER T; 30005000 + IF MI-1 = PREVADDR 30006000 + THEN BEGIN COMMENT THE AREA TO BE REMOVED IS THE LARGEST 30007000 + AREA THAT FOLLOWS A NON-OVERLAYABLE AREA. 30008000 + AVAILB CONTAINS THE NEW PREVADDR.; 30009000 + PREVADDR ~ M[MI] 30010000 + END; 30011000 + M[M[MI]].LINK ~ T ~ M[MI-1].LINK; 30012000 + COMMENT PREVIOUS POINTS AT NEXT; 30013000 + M[T+1] ~ M[MI]; 30014000 + COMMENT NEXT POINTS AT PREVIOUS; 30015000 + END OF AVAIL REMOVE; 30016000 +SAVE PROCEDURE ORDER (ADDRESS); 30017000 + VALUE ADDRESS; 30018000 + INTEGER ADDRESS; 30019000 + BEGIN COMMENT ORDER PLACES THE AREA WITH AVAILA AT ADDRESS IN 30020000 + THE AVAILABLE LIST ACCORDING TO THE ARGUMENT IN 30021000 + BITS 47:27 OF THE WORD AT ADDRESS.; 30022000 + INTEGER T; COMMENT THE LINK THIS LINK WILL POINT AT.; 30023000 + REAL RETRIES; 30023100 + IF NOT BOOLEAN (M[ADDRESS].PREOLAY) 30024000 + THEN BEGIN COMMENT UPDATE PREVADDR IF REQUIRED AND DETER- 30025000 + MINE HIGHEST STARTING POINT FOR LLLU OPERATOR.; 30026000 + IF M[ADDRESS].LENGTH > M[PREVADDR].LENGTH 30027000 + THEN PREVADDR ~ ADDRESS; 30028000 + MINDEX ~ AVAILI; 30029000 + END 30030000 + ELSE MINDEX ~ PREVADDR; 30031000 + M[ADDRESS + 1] ~ MINDEX ~ 30032000 + LISTLOOKUP (M[ADDRESS].AVAILKEY, M, MINDEX); 30033000 + M [ADDRESS].LINK ~ T ~ M[MINDEX].LINK; 30034000 + M [MINDEX].LINK ~ ADDRESS; 30035000 + M [T + 1] ~ ADDRESS; 30036000 + IF SPACEQHEAD !0 THEN 30036050 + IF ((RETRIES ~ ( STACK [T~SPACEQHEAD.FASTPLACE, 30036100 + AUTHORITYLINKPLACE]).RETRYCOUNT) =0 30036200 + OR STACK [T, REQUIREDPLACE] { M [ADDRESS].LENGTH) 30036250 + THEN BEGIN 30036300 + DELINKASTACK (T, SPACEQHEAD); 30036400 + CAUSE (AUTHORITYEVENT @(REFERENCE(STACK[T,*]))); 30036500 + END 30036600 + ELSE STACK [T, AUTHORITYLINKPLACE].RETRYCOUNT ~ RETRIES - 1; 30036650 + END OF ORDERING AVAILABLE LIST; 30037000 +DEFINE GETLEFTOFF (ADDRESS) = 30038000 + IF ADDRESS = LEFTOFF 30039000 + THEN LEFTOFF ~ M[M[ADDRESS].INUSELENGTH + ADDRESS].FRONTLINK; 30040000 + #; 30041000 +DEFINE CONSOLIDATE (ADDRESS, MINDEX) = 30042000 + BEGIN 30043000 + MLENGTH ~ M[ADDRESS].INUSELENGTH; 30044000 + IF BOOLEAN (M [MINDEX ~ ADDRESS + M[ADDRESS].INUSELENGTH +1] 30045000 + .AVAILABLE) 30046000 + THEN BEGIN 30047000 + MLENGTH ~ * + (T ~ M[MINDEX].LENGTH) + 1; 30048000 + AVAILREMOVE (MINDEX + T); 30049000 + END; 30050000 + IF BOOLEAN (M[ADDRESS - 1].AVAILABLE) 30051000 + THEN BEGIN COMMENT PREVIOUS AREA IS AVAILABLE; 30052000 + MLENGTH ~ * + (T ~ M[ADDRESS - 1].LENGTHZ)+1; 30053000 + MINDEX ~ ADDRESS - T - 1; 30054000 + AVAILREMOVE (ADDRESS-1); 30055000 + END 30056000 + ELSE MINDEX ~ ADDRESS; 30057000 + END 30058000 + #; 30059000 +SAVE BOOLEAN PROCEDURE TURNOVERLAYKEY (ADDRESSOFMOM); 30060000 + VALUE ADDRESSOFMOM; 30061000 + INTEGER ADDRESSOFMOM; 30062000 + BEGIN COMMENT IF THE SPACE POINTED AT BY MOM IS PRESENT AND 30063000 + NON-OVERLAYABLE, SET IT TO ITS PERMANENT STATE 30064000 + AND RETURN TRUE OTHERWISE RETURN FALSE; 30065000 + WORD MOM, ZLINK; 30066000 + INTEGER T, TA, I; 30067000 + BOOLEAN B; 30067100 + LABEL AWAY; 30067200 + IF B ~ UNLOCK (SPACELOCK) THEN BUZZCONTROL (SPACELOCK); 30068000 + MOM ~ M[ADDRESSOFMOM]; 30069000 + IF MOM.PBITF =1 30070000 + THEN BEGIN COMMENT MOM HAS SPACE TO CHANGE; 30071000 + T ~ (TA ~ MOM.ADDRESSF) - LINKSIZE - 1; 30072000 + DO I ~ * + M[TA ~ * -1].TAG UNTIL TA =T; 30072100 + IF I ! (LINKSIZE + 1) | MEMLINK 30072200 + THEN GO AWAY; 30072300 + T ~ * + 1; 30072400 + ZLINK ~ M[T ~ T + M[T].INUSELENGTH]; 30073000 + IF TURNOVERLAYKEY ~ ZLINK.SPACEOLAYLOCK =0 30074000 + THEN M[T].SPACEOLAYLOCK ~ ZLINK.OLAY; 30075000 + END; 30076000 +AWAY: 30076100 + IF B THEN UNLOCK (SPACELOCK); 30077000 + END TURNOVERLAYKEY; 30078000 +SAVE PROCEDURE MAKEPRESENTANDSAVE (DATA); 30078100 + WORD ARRAY DATA [*]; 30078200 + BEGIN 30078300 + WORD MPS; MONITOR DONMONITOR (MPS); MPS ~ DATA; %%%%%%%% 30078380 + DATA [0] ~ *; 30078500 +COMMENT * * * * * * FIX IOFINISH TURNOLAYKEY 2/17 30078599 + M[DATA.ADDRESSF + DATA.LENGTHF].SPACEOLAYLOCK ~ 0; 30078600 + END OF INSURING PRESENCE AND SAVING DATA; 30078800 +SAVE INTEGER PROCEDURE CONSOLIDATEANDORDER(ADDRESS); 30156000 + VALUE ADDRESS; 30157000 + INTEGER ADDRESS; 30158000 + BEGIN 30159000 + INTEGER MINDEX, T; 30160000 + WORD ZLINK; 30161000 + CONSOLIDATE (ADDRESS, MINDEX); 30162000 + ZLINK ~ M[MINDEX-1]; 30163000 + T ~ REAL(ZLINK.OLAY = 1 OR ZLINK.SPACEOLAYLOCK = 1); 30164000 + M[MINDEX] ~ 0 & AVAILA (, T,MLENGTH, , *); 30165000 + M[MINDEX ~ MLENGTH] ~ 0 & AVAILZ (,, MLENGTH); 30166000 + ORDER (MINDEX); 30167000 + CONSOLIDATEANDORDER ~ MINDEX; 30168000 + END OF CONSOLIDATING RETURNED AREA AND ORDERING IT IN LIST; 30169000 +SAVE INTEGER PROCEDURE FORGETSPACE(ADDRESS); 30170000 + VALUE ADDRESS; 30171000 + INTEGER ADDRESS; 30172000 + BEGIN COMMENT RETURN THE SPACE DESCRIBED BY THE IN-USE LINK 30173000 + POINTED AT BY ADDRESS TO THE AVAILABLE LIST. 30174000 + WHEN "ADDRESS" IS POSITVE CONSOLIDATION WITH 30175000 + ADJACENT AVAILABLE AREAS IS PERFORMED AND THE 30176000 + LIST IS RE-ORDERED AND THE NEW ADDRESS IS 30177000 + RETURNED. WHEN "ADDRESS" IS NEGATIVE CONSOLI- 30178000 + DATION AND ORDERING ARE NOT PERFORMED.; 30179000 + LABEL AWAY; 30180000 + INTEGER TADDR ~ ABS (ADDRESS) - LINKSIZE, 30181000 + FRONTLNK, 30182000 + 30183000 + T, COMMENT TEMPORARY; 30184000 + TRACTER, 30185000 + MINDEX; 30186000 + TRACTER~TRACE(0); 30186100 + MINDEX ~ TADDR -1; 30187000 + DO T ~ *+M[MINDEX].TAG UNTIL MINDEX ~ * +1 = ABS(ADDRESS); 30188000 + IF T ! (LINKSIZE +1) | MEMLINK 30189000 + THEN BEGIN 30190000 + FORGETSPACE ~ -MINDEX; 30191000 + GO AWAY; 30192000 + END; 30193000 + FRONTLNK ~ M[TADDR + M[TADDR].INUSELENGTH].FRONTLINK; 30194000 + IF FRONTLNK ! 0 30195000 + THEN BEGIN COMMENT REMOVE AREA FROM IN-USE LIST; 30196000 + M[FRONTLNK].BACKLINK ~ MINDEX ~ M[TADDR ].BACKLINK; 30197000 + M[MINDEX + M[MINDEX].INUSELENGTH].FRONTLINK ~ 30198000 + M[TADDR + M[TADDR ].INUSELENGTH].FRONTLINK; 30199000 + END 30200000 + ELSE BEGIN COMMENT AREA BEING FORGOTTEN WAS LAST ALLOCATED;30201000 + BACKALLOCATED ~ M[TADDR ].LINK; 30202000 + M[M[BACKALLOCATED].INUSELENGTH + BACKALLOCATED]. 30203000 + FRONTLINK ~ 0; 30204000 + END; 30205000 + GETLEFTOFF (TADDR); 30206000 + IF ADDRESS > 0 30207000 + THEN BEGIN COMMENT CONSOLIDATE WITH ADJACENT AVAILABLE 30208000 + AREAS AND ORDER NEW AREA IN LIST; 30209000 + FORGETSPACE ~ CONSOLIDATEANDORDER (TADDR); 30210000 + END 30211000 + ELSE FORGETSPACE ~ ADDRESS; 30212000 +AWAY: 30213000 + TRACE(TRACTER); 30214000 + UNLOCK (SPACELOCK); 30214100 + END OF FORGETSPACE; 30215000 +SAVE PROCEDURE OVERLAY (ADDRESS); VALUE ADDRESS; INTEGER ADDRESS; ; 30216000 +SAVE REAL PROCEDURE GETSPACE (SIZE, WHOFOR, TYPE, ADDRESS); 30217000 + VALUE SIZE, WHOFOR, TYPE, ADDRESS; 30218000 + INTEGER SIZE, WHOFOR, TYPE; 30219000 + REAL ADDRESS; 30220000 + BEGIN COMMENT 30221000 + ;30222000 + LABEL OVERSRCH, STARTSRCH, TRUBLE, AROUND, ALLDONE; 30223000 + LABEL RETRY; 30223100 + INTEGER S ~ SIZE + LINKSIZE, 30224000 + START, 30225000 + ARGS; 30226000 + INTEGER TRACTER; COMMENT SAVE AND RESTORE TRACE; 30227000 + BOOLEAN TRYAGAIN; 30227100 +SAVE INTEGER PROCEDURE TROUBLE (REQ); 30228000 + VALUE REQ; 30229000 + INTEGER REQ; 30230000 + BEGIN COMMENT TROUBLE IS RESPONSIBLE FOR CHASING THE LEFT-OFF 30231000 + LIST AND RETURNING WITH AN ADDRESS OF AN AREA 30232000 + THAT WILL SATISFY THE SIZE REQUIREMENT (REQ). 30233000 + IF AN ADEQUATE AREA CANNOT BE FOUND, A NEGATIVE 30234000 + VALUE IS RETURNED. 30235000 + ;30236000 + INTEGER LEFTOFFT ~ LEFTOFF, COMMENT THE NEXT ADDRESS IN THE30237000 + LEFT-OFF LIST.; 30238000 + R, COMMENT TEMPORARY REQ; 30239000 + MINDEX, 30240000 + INITIAL, COMMENT THE ABSOLUTE ADDRESS OF THE AREA 30241000 + BEING MADE AVAILABLE.; 30242000 + FINAL; COMMENT THE FINAL ADDRESS OF THE AREA 30243000 + BEING MADE AVAILABLE.; 30244000 + BOOLEAN FIRST, COMMENT WHEN TRUE THE SUCCEEDING AS 30245000 + WELL AS PRECEDING AREAS ARE EXAMINED 30246000 + FOR AVAILABILITY.; 30247000 + AVAILB; COMMENT TRUE WHEN THE ADDRESS OF AN 30248000 + IN-USE AREA HAS BEEN RECORDED FOR 30249000 + OVERLAY BECAUSE OF THE AVAILABILITY OF30250000 + AN ADJACENT AREA.; 30251000 + LABEL NEXT, 30252000 + EXIT; 30253000 + WORD TLINK; COMMENT TEMPORARY MEMORY LINK.; 30254000 + MONITOR DONMONITOR 30254100 + (R 30254200 + ,INITIAL 30254300 + ,FINAL 30254400 + , TLINK); 30254500 + IF TYPE.MAKEROOM = 0 30255000 + THEN BEGIN 30256000 + MINDEX ~ -1; 30257000 + GO EXIT; 30258000 + END; 30259000 +NEXT: COMMENT EXAMINE NEXT AREA IN LEFT=OFF LIST.; 30260000 + SETINTERVALTIMER; 30260100 + R ~ REQ; 30261000 + MINDEX ~ LEFTOFFT; 30262000 + FIRST ~ TRUE; 30263000 + DO BEGIN COMMENT BY-PASS NON-OVERLAYABLE ITEMS LEFT- 30264000 + OFF LIST.; 30265000 + IF LEFTOFFT !0 THEN 30266000 + IF NOT BOOLEAN ((TLINK ~ M[LEFTOFFT + M[LEFTOFFT] 30267000 + .INUSELENGTH]).SPACEOLAYLOCK) 30268000 + THEN MINDEX ~ LEFTOFFT ~ TLINK.FRONTLINK; 30269000 + END UNTIL BOOLEAN(TLINK.SPACEOLAYLOCK) OR LEFTOFFT = 0; 30270000 + IF MINDEX = 0 30271000 + THEN BEGIN COMMENT LEFT-OFF LIST HAS BEEN EXHAUSTED.; 30272000 + MINDEX ~ -(IF BOOLEAN (TYPE.SLEEPY) THEN 3 ELSE 5) 30273000 + + TYPE.PRINTNOMEM; 30274000 + GO EXIT; 30275000 + END; 30276000 + FINAL ~ M[MINDEX].INUSELENGTH + MINDEX; 30277000 + LEFTOFFT ~ TLINK.FRONTLINK; 30278000 + WHILE R > 0 30279000 + DO BEGIN COMMENT EXAMINE THIS AREA AND ADJACENT AREAS 30280000 + IN DESCENDING MEMORY LOCATIONS UNTIL R { 0 OR 30281000 + A NON-OVERLAYABLE AREA IS ENCOUNTERED.; 30282000 + AVAILB ~ FALSE; 30283000 + IF FIRST 30284000 + THEN BEGIN COMMENT THE FIRST TIME THE AREA SUC- 30285000 + CEEDING THE LEFT-OFF AREA MUST BE EX- 30286000 + AMINED FOR AVAILABILITY.; 30287000 + IF INITSWITCH 30287100 + THEN BEGIN 30287200 + LEFTOFF ~ MINDEX; 30287300 + INITSWITCH ~ FALSE; 30287400 + END; 30287500 + INITIAL ~ MINDEX; 30288000 + FIRST ~ FALSE; 30289000 + IF BOOLEAN ((TLINK ~ M[(FINAL ~ MINDEX + 30290000 + M[MINDEX].INUSELENGTH+1)]).AVAILABLE) 30291000 + THEN BEGIN 30292000 + INITIAL ~ MINDEX; 30293000 + FINAL ~ FINAL + TLINK.LENGTH +1; 30294000 + AVAILB ~ TRUE; 30295000 + R ~ R - TLINK.LENGTH 30296000 + - M[MINDEX].INUSELENGTH; 30297000 + END; 30298000 + END; 30299000 + IF BOOLEAN ((TLINK ~ M[MINDEX - 1]).AVAILABLE) 30300000 + THEN BEGIN COMMENT ALL AREAS PRECEDING IN-USE 30301000 + AREAS ARE EXAMINED FOR AVAILABILITY.; 30302000 + INITIAL ~ MINDEX - TLINK.LENGTHZ - 1; 30303000 + R ~ R - TLINK.LENGTHZ - 30304000 + (IF AVAILB THEN 1 ELSE M[MINDEX] 30305000 + .INUSELENGTH); 30306000 + AVAILB ~ TRUE; 30307000 + END 30308000 + ELSE INITIAL ~ MINDEX; 30308100 + R ~ R-(IF AVAILB THEN 1 ELSE M[MINDEX].INUSELENGTH); 30309000 + IF R > 0 30310000 + AND NOT BOOLEAN (M[INITIAL - 1].SPACEOLAYLOCK) 30311000 + THEN GO NEXT; 30312000 + MINDEX ~ INITIAL -1 - M[INITIAL -1].INUSELENGTHZ; 30313000 + END; 30314000 + IF BOOLEAN ((TLINK ~ M[INITIAL - 1]).AVAILABLE) 30315000 + THEN INITIAL ~ INITIAL - TLINK.LENGTHZ -1; 30316000 + MINDEX ~ INITIAL; 30317000 + DO IF AVAILB ~ BOOLEAN ( (TLINK ~ M[MINDEX]).AVAILABLE) 30318000 + THEN BEGIN 30319000 + AVAILREMOVE (MINDEX + TLINK.LENGTH); 30320000 + R ~ TLINK.LENGTH; 30321000 + END 30322000 + ELSE R ~ TLINK.INUSELENGTH 30323000 + UNTIL MINDEX ~ * + R + 1 > FINAL; 30324000 + MINDEX ~ INITIAL; 30325000 + DO IF NOT AVAILB ~ BOOLEAN ((TLINK ~ M[MINDEX]).AVAILABLE) 30326000 + THEN BEGIN 30327000 +GLOBALSTOP; 30327100 + OVERLAY (MINDEX + LINKSIZE); 30328000 + FORGETSPACE (-MINDEX - LINKSIZE); 30329000 + R ~ TLINK.INUSELENGTH; 30330000 + END 30331000 + ELSE R ~ TLINK.LENGTH 30332000 + UNTIL MINDEX ~ * + R + 1 > FINAL; 30333000 + MINDEX ~ INITIAL; 30334000 +EXIT: 30335000 + IF TROUBLE ~ MINDEX > 0 30336000 + THEN BEGIN COMMENT MAKE AREA LOOK AVAILABLE.; 30337000 + M[INITIAL] ~ 0 & AVAILA(,*, FINAL-INITIAL,, *); 30338000 + M[FINAL] ~ 0 & AVAILZ (,, FINAL - INITIAL); 30339000 + END; 30340000 + END OF TROUBLE; 30341000 +SAVE INTEGER PROCEDURE ALOCATE (SIZE, MINDEX); 30342000 + VALUE SIZE, MINDEX; 30343000 + INTEGER SIZE, MINDEX; 30344000 + BEGIN COMMENT ALOCATE ASSIGNS IN-USE LINKS FOR AN AREA OF SIZE30345000 + SOMEWWERE IN THE AREA STARTING AT MINDEX. NON- 30346000 + OVERLAYABLE AREAS ARE ASSIGNED AT THE FRONT OF 30347000 + AN AREA. THAT PORTION OF AN AREA THAT IS NOT 30348000 + USED IS RETURNED TO THE AVAILABLE LIST.; 30349000 + INTEGER AVLINK; 30350000 + IF (MLENGTH ~ M[MINDEX].LENGTH- SIZE - 1) { LINKSIZE 30351000 + THEN SIZE ~ SIZE + MLENGTH + 1; 30352000 + IF TYPE.OERLAY = 0 30353000 + THEN AVLINK ~ MINDEX + SIZE + 1 30354000 + ELSE BEGIN 30355000 + AVLINK ~ MINDEX; 30356000 + MINDEX ~ M[MINDEX].LENGTH - SIZE + AVLINK; 30357000 + IF LEFTOFF { 0 THEN LEFTOFF ~ MINDEX; 30358000 + END; 30359000 + M[MINDEX + SIZE] ~ 0 & LINKZ(, REAL(TYPE.OERLAY=1 AND 30360000 + ADDRESS!0),,,,, SIZE); 30361000 + IF MLENGTH > LINKSIZE 30362000 + THEN BEGIN 30363000 + M[AVLINK] ~ 0 & AVAILA 30364000 + (, M[AVLINK-1].OLAY, MLENGTH, ,*); 30365000 + COMMENT ORDER WILL SUPPLY LINK; 30366000 + M[AVLINK + MLENGTH] ~ 0 & AVAILZ 30367000 + (, , MLENGTH); 30368000 + ORDER (AVLINK); 30369000 + END; 30370000 + M[MINDEX] ~ 0 & LINKA (, WHOFOR, SIZE, *, BACKALLOCATED); 30371000 + M[MINDEX + 1] ~ 0 & LINKB 30372000 + (, % TAG =3 30373000 + , % USAGE 30374000 + *, % ADDRESS TYPE - ABSOLUTE FOR NOW 30375000 + ADDRESS, % OF MOM 30376000 + IF ADDRESS ! 0 THEN M[ADDRESS].ADDRESSF ELSE 0); % DISK 30377000 + COMMENT NUMEROUS UNANSWERED QUESTIONS.; 30378000 + M[MINDEX +2] ~ 0 & LINKC ( ); COMMENT UNUSED; 30379000 + M[BACKALLOCATED + M[BACKALLOCATED].INUSELENGTH].FRONTLINK ~ 30380000 + MINDEX; 30381000 + BACKALLOCATED ~ MINDEX; 30382000 + ALOCATE ~ MINDEX + LINKSIZE; 30383000 + END OF ALOCATE; 30384000 + TRACTER ~ TRACE(0); COMMENT TURN OFF & SAVE TRACE; 30385000 + BUZZCONTROL (SPACELOCK); 30385100 +RETRY: 30385200 + MINDEX ~ M[STOPPER + 1]; 30386000 + IF BOOLEAN (TYPE.OERLAY) 30387000 + THEN BEGIN COMMENT LOOK FOR AN AREA ADJACENT TO OVERLAY- 30388000 + ABLE STORAGE.; 30389000 + IF S { M[MINDEX].LENGTH 30390000 + AND BOOLEAN (M[MINDEX].PREOLAY) 30391000 + THEN BEGIN COMMENT START SEARCH IN OVERLAYABLE 30392000 + PORTION OF LIST; 30393000 + OVERSRCH: START ~ PREVADDR; 30394000 + ARGS ~ 1 & LLLUARG (1, S); 30395000 + END 30396000 + ELSE IF S > M[PREVADDR].LENGTH 30397000 + THEN GO TRUBLE 30398000 + ELSE BEGIN 30399000 + STARTSRCH: START ~ AVAILI; 30400000 + ARGS ~ 1 & LLLUARG (0, S); 30401000 + END 30402000 + END 30403000 + ELSE IF S > M[PREVADDR].LENGTH 30404000 + THEN IF S > M[MINDEX].LENGTH THEN GO TRUBLE ELSE GO 30405000 + OVERSRCH 30406000 + ELSE GO STARTSRCH; 30407000 + MINDEX ~ M[LISTLOOKUP(ARGS, M, START)].LINK; 30408000 + AVAILREMOVE (MINDEX + M[MINDEX].LENGTH); 30409000 + GO AROUND; 30410000 +TRUBLE: MINDEX ~ TROUBLE(S); 30411000 + IF MINDEX < 1 30412000 + THEN BEGIN 30413000 + SAVE PROCEDURE DAMMIT; 30413020 + BEGIN 30413040 + EVENT SPACESHOT; 30413160 + TRYAGAIN ~ FALSE; 30413200 + QUEUEMYSTACK (STACK[WHOFOR, PRIORITYPLACE], S, SPACERETRY, 30413400 + SPACESHOT, SPACEQHEAD); 30413500 + UNLOCK (SPACELOCK); 30413760 + WAIT (SPACESHOT); 30413780 + BUZZ (SPACELOCK); 30413800 + TRYAGAIN ~ TRUE; 30413810 + END OF QUEUEING UNSATISFIED REQUEST; 30413820 + SAVE PROCEDURE SPOUTIT; 30413840 + BEGIN 30413860 + END OF SPOUTIT; 30413980 + CASE ABS (MINDEX) OF 30413990 + BEGIN 30414000 + ; COMMENT - SHOULD NEVER HAPPEN 0;30415000 + ; COMMENT - NO OVERLAY, SPOUT OR SLEEP 1;30416000 + BEGIN 30417000 + SPOUTIT; DAMMIT; % 2 30418000 + END; 30419000 + BEGIN 30420000 + DAMMIT; % 3 30421000 + END; 30422000 + BEGIN 30423000 + SPOUTIT; 30424000 + END; 30425000 + BEGIN 30426000 + 30427000 + END; 30428000 + END 30429000 + END OF UNSATISFIED REQUESTS; 30429100 + IF TRYAGAIN THEN GO RETRY ELSE IF MINDEX < 0 THEN GO ALLDONE; 30430000 +AROUND: MINDEX ~ ALOCATE (S, MINDEX); 30431000 +ALLDONE: GETSPACE ~ MINDEX; 30436000 + UNLOCK (SPACELOCK); 30436100 + TRACE (TRACTER); COMMENT RESTORE TRACE; 30437000 + END OF GETSPACE; 30438000 +SAVE PROCEDURE MOMTOVECTOR (MOM, VECTOR, INDEX); 30439000 + VALUE COMMENT A COPY OR MOM DESCRIPTOR THAT IS AC- 30440000 + CEPTABLE TO PRESENCE BIT; 30441000 + COMMENT AN-UNINDEXED DESCRIPTOR THAT IS AC- 30442000 + CEPTABLE TO AN NXLN OPERATOR; 30443000 + INDEX; COMMENT THE INDEX FOR VECTOR WHERE MOM IS TO 30444000 + BE PLACED; 30445000 + WORD ARRAY MOM[*], 30446000 + VECTOR[*]; 30447000 + INTEGER INDEX; 30448000 + BEGIN 30449000 + MOM[0] ~ *; 30456000 + VECTOR[INDEX] ~ MOM & SETCOPYBIT (0); 30457000 + M [MOM.ADDRESSF - LINKSIZE +1].ADDRMOM ~ VECTOR.ADDRESSF+INDEX;30458000 + END MOM TO VECTOR OR QUEUE; 30459000 + 30460000 +SAVE PROCEDURE QUEUEMYSTACK (AUTHORITY, REQUIRED, COUNT, MYEVENT, HEAD);30461000 + VALUE AUTHORITY, COMMENT THE SORTKEY FOR THIS QUEUE; 30462000 + REQUIRED, COMMENT AN ADDITIONAL INFORMATION WORD FOR THE 30463000 + QUEUE ENTRY; 30464000 + COUNT; COMMENT A 10 BIT COUNTER IN THE STACK LINK 30465000 + WORD FOR THIS QUEUE; 30466000 + REAL HEAD ; COMMENT A GLOBAL REAL THAT CONTAINS THE BACK- 30467000 + WARD AND FORWARD LINKS FOR THE QUEUE. THE BACK 30468000 + WARD LINK POINTS TO THE ENTRY WITH THE HIGHEST 30469000 + AUTHORITY; 30470000 + EVENT MYEVENT; COMMENT THE EVENT THAT IS WAITED UPON AND 30471000 + CAUSED BY THE CALLER; 30472000 + REAL AUTHORITY, 30473000 + REQUIRED; 30474000 + INTEGER COUNT; 30475000 + BEGIN COMMENT PLACE MYEVENT, REQUIRED AND AUTHORITY IN MY30476000 + STACK AND PLACE MY STACK IN THE QUEUE POINTED AT30477000 + BY HEAD BASED ON AUTHORITY.; 30478000 + INTEGER FASTER, % THAN ME 30479000 + SLOWER, % THAN ME 30480000 + FASTEST, % ACCORDING TO HEAD 30481000 + SLOWEST, % DITTO 30482000 + I, % THE NEXT FASTEST ENTRY 30483000 + INDEX, % THE ENTRY FASTER THAN MINE 30484000 + ME ; % THE CALLERS (AND MY) STACK 30485000 + MONITOR DONMONITOR (ME, HEAD, 30485100 + SLOWER, 30485200 + FASTER, 30485300 + I); 30485400 + ARRAY MY [*]; 30486000 + REFERENCE MYREFERENCE = MY; 30486100 + LABEL AHEAD, AROUND; 30487000 + DEFINE AUTHORITYLINKL = READYWAITLINK#; 30488000 + MY ~ STACK [ME ~ SNR, *]; 30489000 + STOREITEM (AUTHORITYEVENT@(MYREFERENCE), MYEVENT); 30490000 + MY [AUTHORITYPLACE] ~ AUTHORITY; 30492000 + MY [REQUIREDPLACE] ~ REQUIRED; 30493000 + SLOWEST ~ HEAD.SLOWPLACE; 30495000 + IF I ~ FASTEST ~ HEAD.FASTPLACE = 0 30496000 + THEN BEGIN COMMENT AN EMPTY HEAD; 30497000 + %FASTER ~ SLOWER ~ 0; 30498000 + HEAD ~ 0 & AUTHORITYLINKL(ME, ME); 30499000 + GO AROUND; 30500000 + END; 30501000 + WHILE AUTHORITY { STACK [I, AUTHORITYPLACE] 30502000 + DO BEGIN COMMENT I"M HIGHER LOOK FOR LESSER OR LEAST; 30503000 + INDEX ~ I; 30504000 + IF I ~ STACK[I, AUTHORITYLINKPLACE].SLOWPLACE = 0 30505000 + THEN GO AHEAD; 30506000 + END; 30507000 + IF I = FASTEST 30508000 + THEN BEGIN COMMENT I"M FASTER THAN THE FASTEST - TELL EM;30509000 + STACK [SLOWER ~ FASTEST, AUTHORITYLINKPLACE]. 30510000 + FASTPLACE ~ ME; 30511000 + HEAD.FASTPLACE ~ ME; 30512000 + % FASTER ~ 0; 30513000 + GO AROUND; 30514000 + END 30515000 + ELSE BEGIN COMMENT THERE ARE HIGHER & LOWER AUTHORITIES; 30516000 + FASTER ~ INDEX; 30517000 + SLOWER ~ STACK [INDEX, AUTHORITYLINKPLACE].SLOWPLACE;30518000 + STACK[FASTER, AUTHORITYLINKPLACE].SLOWPLACE ~ ME; 30519000 + STACK[SLOWER,AUTHORITYLINKPLACE].FASTPLACE ~ ME; 30520000 + GO AROUND END; 30521000 +AHEAD: STACK [FASTER ~ SLOWEST, AUTHORITYLINKPLACE].SLOWPLACE ~ ME; 30522000 + HEAD.SLOWPLACE ~ ME; 30523000 + % SLOWER ~ 0; NOBODY IS SLOWER THAN ME 30524000 +AROUND: MY [AUTHORITYLINKPLACE] ~ 0 & AUTHORITYLINKL 30525000 + (FASTER, SLOWER, COUNT); 30526000 + END; 30527000 +PROCEDURE DELINKASTACK (WHOSE, HEAD); 30528000 + VALUE WHOSE; 30529000 + INTEGER WHOSE; COMMENT THE AUTHORITY TYPE STACK TO DELINK; 30530000 + REAL HEAD ; COMMENT THE HEAD OF THE AUTHORITY TYPE STACK; 30531000 + BEGIN COMMENT UNDO ALL THE GOOD WORK OF QUEUEMYSTACK; 30532000 + INTEGER SLOWEST, 30533000 + FASTEST, 30534000 + SLOWER, 30535000 + FASTER; 30536000 + REAL LINK; 30537000 + MONITOR DONMONITOR (HEAD 30537100 + ); 30537200 + ARRAY WHO [*]; 30538000 + LABEL AWAY; 30539000 + DEFINE ALP = WHO [AUTHORITYLINKPLACE]#; 30540000 + WHO ~ STACK [WHOSE, *]; 30541000 + SLOWEST ~ HEAD.SLOWPLACE; 30542000 + FASTEST ~ HEAD.FASTPLACE; 30543000 + IF SLOWEST = FASTEST 30544000 + THEN BEGIN COMMENT ONLY ONE ENTRY; 30545000 + IF WHOSE!SLOWEST THEN EXIT; % CALLER GOOFED 30546000 + HEAD ~ 0; 30547000 + END 30548000 + ELSE IF WHOSE=FASTEST 30549000 + THEN BEGIN COMMENT SLOWER OF WHOSE IS FASTEST; 30550000 + HEAD.FASTPLACE~SLOWER~WHO[AUTHORITYLINKPLACE]. 30551000 + SLOWPLACE; 30552000 + STACK [SLOWER, AUTHORITYLINKPLACE].FASTPLACE ~0;30553000 + END 30554000 + ELSE IF WHOSE = SLOWER 30555000 + THEN BEGIN COMMENT FASTER OF WHOSE IS SLOWEST; 30556000 + HEAD.SLOWPLACE ~ FASTER ~ ALP.FASTPLACE; 30557000 + STACK [SLOWER, AUTHORITYLINKPLACE]. 30558000 + SLOWPLACE ~ 0; 30559000 + END 30560000 + ELSE BEGIN 30561000 + FASTER ~(LINK ~ ALP).FASTPLACE; 30562000 + SLOWER ~ LINK.SLOWPLACE; 30563000 + STACK[FASTER, AUTHORITYLINKPLACE]. 30564000 + SLOWPLACE ~ SLOWER; 30565000 + STACK[SLOWER, AUTHORITYLINKPLACE]. 30566000 + FASTPLACE ~ FASTER 30567000 + END; 30568000 + ALP ~ 0; 30569000 + END OF DELINKING A QUEUE; 30570000 +SAVE INTEGER PROCEDURE GETAREA(SIZE); VALUE SIZE; INTEGER SIZE; 31000000 + COMMENT GETAREA SEARCHES BLOCKOFAREASQUE FOR A BLOCK OF A GIVEN SIZE 31001000 + AREA. IF BLOCK IS NOT IN THE QUEUE IT CALLS GETSPACE PROCEDURE31002000 + AND BUILDS UP AREASTATUS WORD FOR THE OBTAINED BLOCK- IT THEN 31003000 + MAKES ENTRY INTO THE QUEUE, IT RESETS BIT REPRESNTING THE 31004000 + FIRST AREA OF THE BLOCK AND RETURNS BASE ADDRESS OF THE BLOCK.31005000 + IF BLOCK IS IN QUEUE,IT FINDS BITNO REPRESENTING AVAILABLE 31006000 + AREA, RESETS THAT BIT IN AREASTATUSBITS FIELD AND RETURNS THE 31007000 + ADDRESS AS BASE ADDRESS OF BLOCK INDEXED BY (BITNO-1). 31008000 + SIZE -SIZE OF AREA IN NO. OF WORDS; 31009000 + BEGIN 31010000 + DEFINE AREASIZEF=AREASIZEFF#; 31011000 + REFERENCE BLOCKPOINTER; COMMENT CURRENT POINTER OF QUEUE; 31012000 + ARRAY QENTRY =BLOCKPOINTER [*]; 31013000 + REAL AREASTATUSWORD; COMMENT LOCAL FOR AREASTATUS ITEM; 31014000 + INTEGER BITNO; COMMENT BIT NO. FOR AVAILABLE AREA; 31015000 + INTEGER COREADDR, COMMENT GETSPACE ADDRESS; 31016000 +TRACTER,% MAR USED TO SHUT OFF TRACE IN THIS PROCEDURE 31017000 + COREAREASIZE; 31018000 + LABEL TRYANOTHER,LOOP; 31019000 + LABEL NOQUENTRY; 31020000 + FIELD SETFIELD=MAXNOOFAREAS-2:MAXNOOFAREAS-1; 31021000 +TRACTER~TRACE(0); 31022000 + IF FIRSTBLOCK=NULL THEN GO NOQUENTRY; 31023000 + BLOCKPOINTER~ FIRSTBLOCK; 31024000 +LOOP: 31025000 + AREASTATUSWORD~ AREASTATUS @ BLOCKPOINTER; 31026000 + IF SIZE=AREASTATUSWORD.AREASIZEF THEN COMMENT FOUND BLOCK; 31027000 + BEGIN 31028000 + BITNO~ FIRSTONE(AREASTATUSWORD.AREASTATUSBITSF )-1; 31029000 + IF BITNO!-1 THEN AREASTATUS@(BLOCKPOINTER)~ 31030000 + RESET(AREASTATUS@BLOCKPOINTER,BITNO) 31031000 + ELSE GO TRYANOTHER; 31032000 + END ELSE 31033000 + BEGIN 31034000 +TRYANOTHER: 31035000 + BLOCKPOINTER ~ NEXTBLOCK @ BLOCKPOINTER; 31036000 + IF BLOCKPOINTER!NULL THEN GO LOOP 31037000 + ELSE 31038000 + BEGIN 31039000 +NOQUENTRY: 31040000 + AREASTATUSWORD ~ 0; 31041000 + AREASTATUSWORD.SETFIELD ~ @77777777; 31042000 + BITNO~MAXNOOFAREAS-1; 31043000 + AREASTATUSWORD.AREASIZEF~ SIZE; 31044000 + COREAREASIZE~SIZE | MAXNOOFAREAS + 1; 31045000 + COREADDR~GETSPACE(COREAREASIZE,0,4,0); 31046000 + AREASTATUSWORD.BASEADDRF~COREADDR + 1; 31047000 + M [COREADDR] ~ 0; 31047100 + BLOCKPOINTER ~ ALLOCATE(BLOCKOFAREASQUE); 31048000 + INITIALIZETOZERO(QENTRY.ADDRESSF, 3); 31049000 + AREASTATUS@(BLOCKPOINTER)~AREASTATUSWORD; 31050000 + BLOCKOFAREASQUE ~ BLOCKPOINTER; 31051000 + END; 31052000 + END; 31053000 + INITIALIZETOZERO(COREADDR ~ AREASTATUSWORD.BASEADDRF + 31054000 + BITNO | SIZE, SIZE); 31055000 +TRACE(TRACTER); 31055100 + RETURN(COREADDR); 31056000 + END GETAREA; 31058000 +SAVE PROCEDURE FORGETAREA(SIZE,ADDRESS); VALUE SIZE,ADDRESS; 31059000 + INTEGER SIZE,ADDRESS; 31060000 + COMMENT FORGETAREA SEARCHES BLOCKOFAREASQUE FOR A BLOCK OF A GIVEN 31061000 + SIZE AREA. IF NO BLOCK IS FOUND THEN THE SIZE SPECIFIED MUST 31062000 + BE WRONG. WHEN THE BLOCK OF GIVEN SIZE IS FOUND IT CHECKS 31063000 + WHETHER SPECIFIED ADDRESS FALLS WITHIN THE BLOCK RANGE. WHEN 31064000 + THE RIGHT BLOCK IS FOUND,IT FINDS BITNO REPRESENTING AREA TO 31065000 + BE FORGOTTEN. IT SETS THAT BIT NO IN AREASTATUS ITEM OF QUEUE.31066000 + IF ALL THE AREAS WITHIN BLOCK ARE AVAILABLE IT CALLS 31067000 + FORGETSPACE TO FORGET THE BLOCK.NOTE QUEUE IS SEARCHED FROM 31068000 + THE END TO DEALLOCATE ADDITIONAL BLOCKS (OF GIVEN SIZE) AS 31069000 + SOON AS POSSIBLE: 31070000 + SIZE - SIZE OF AREA IN NO OF WORDS 31071000 + ADDRESS- BASE ADDRESS OF THE AREA; 31072000 + IF SIZE = 0 31073000 + THEN FORGETSPACE (ADDRESS) ELSE 31074000 + BEGIN 31075000 + DEFINE AREASIZEF=AREASIZEFF#; 31076000 + REFERENCE BLOCKPOINTER; COMMENT CURRENT POINTER OF QUEUE; 31077000 + REAL AREASTATUSWORD; COMMENT LOCAL FOR AREA STATUS ITEM; 31078000 + INTEGER BITNO; COMMENT BIT NO FOR AREA TO BE FORGOTTEN; 31079000 + LABEL LOOP,QUIT; 31080000 + BLOCKPOINTER ~ LASTBLOCK ; 31081000 +LOOP: 31082000 + AREASTATUSWORD~ AREASTATUS @ BLOCKPOINTER; 31083000 + IF SIZE=AREASTATUSWORD.AREASIZEF THEN 31084000 + BEGIN COMMENT BLOCK OF RIGHT SIZE; 31085000 + IF BITNO~ADDRESS-AREASTATUSWORD.BASEADDRF>0 THEN 31086000 + IF BITNO~BITNO DIV SIZE < MAXNOOFAREAS THEN 31087000 + BEGIN COMMENT BLOCK OF RIGHT SIZE AND ADDRESS; 31088000 + AREASTATUSWORD~ SET(AREASTATUSWORD,BITNO); 31089000 + COMMENT COUNT NO. OF BITS ON (NO OF AVAILABLE 31090000 + AREAS); 31091000 + BITNO~ ONES(AREASTATUSWORD.AREASTATUSBITSF); 31092000 + IF BITNO=MAXNOOFAREAS THEN 31093000 + BEGIN 31094000 + FORGETSPACE(AREASTATUSWORD.BASEADDRF-1); 31095000 + DELINK(BLOCKOFAREASQUE,BLOCKPOINTER) 31096000 + END ELSE 31097000 + AREASTATUS @(BLOCKPOINTER)~AREASTATUSWORD; 31098000 + GO QUIT; 31099000 + END; 31100000 + END; 31101000 + BLOCKPOINTER~ PRVSBLOCK @ BLOCKPOINTER; 31102000 + IF BLOCKPOINTER=NULL THEN 31103000 + BEGIN 31104000 +COMMENT BUILD A MESSAGE "WRONG SIZE OR ADDRESS FOR AREA"; 31105000 +%SPOUT(MSGAREA,DISPLAYONCON);% MAR 31106000 + END ELSE GO LOOP; 31107000 +QUIT: 31108000 + END FORGETAREA; 31109000 +SAVE 1 PROCEDURE INITIALIZEARRAY(FIRSTARRAY, LASTARRAY, LENGTH); 32000000 + VALUE LENGTH; 32001000 + INTEGER LENGTH; 32002000 + WORD ARRAY FIRSTARRAY,LASTARRAY [*]; 32003000 + BEGIN COMMENT GET SPACE AND INITIALIZE ALL DESCRIPTORS BETWEEN32004000 + FIRSTARRAY AND LASTARRAY (INCLUSIVE). (SEE COM- 32005000 + MENT AT "UNIT" ARRAY DECLARATION) "LENGTH" IS 32006000 + THE NUMBER OF WORDS GOTTEN FOR EACH ARRAY AND 32007000 + THE LENGTH FIELD OF THE ARRAY DESCRIPTOR. ;32008000 + INTEGER MOMF ~ NAME(FIRSTARRAY).ADRCPLF, 32009000 + MOML ~ NAME(LASTARRAY).ADRCPLF, 32010000 + T, 32011000 + A; 32012000 + MOMF ~ * + D0; 32013000 + MOML ~ * + D0; 32014000 + T ~ MOML - MOMF + 1; 32015000 + LENGTH~*|(FIRSTARRAY.DBITF+1); 32015100 + M[MOMF] ~ FIRSTARRAY & DATADESCRIPTOR 32016000 + (,1,0,*,*,*,*,*,LENGTH, A ~ 32017000 + GETSPACE (T | LENGTH, 0, 1, 0)); 32018000 + INITIALIZETOZERO (A, T | LENGTH); 32019000 + WHILE MOMF ~ * + 1 { MOML DO 32020000 + M[MOMF] ~ 0 & DATADESCRIPTOR 32021000 + (,1,0,*,*,*,*,*, LENGTH, A ~ A + LENGTH); 32022000 + END INITIALIZE ARRAYS; 32023000 +SAVE 1 PROCEDURE INITIALIZEQARRAY (QARRAYW, LENGTH); 32024000 + VALUE LENGTH; 32025000 + INTEGER LENGTH; 32026000 + WORD ARRAY QARRAYW [*]; 32027000 + BEGIN COMMENT GET "LENGTH" SPACE AND FILL IT WITH NULL DATA 32028000 + DESCRIPTORS; 32029000 + WORD DD; 32030000 + WORD WT1 = QARRAYW; 32031000 + INTEGER MOMQ ~ WT1.ADRCPLF, 32032000 + A; 32033000 + INTEGER I ~ LENGTH - 1; 32034000 + M[MOMQ] ~ 0 & DATADESCRIPTOR 32035000 + (,1,*,*,*,*,*,*, LENGTH, 32036000 + A ~ GETSPACE (LENGTH, 0, 1, 0)); 32037000 + DD ~ 0 & DATADESCRIPTOR (,1,1,*,*,*,*,*,*,*); 32038000 + DO QARRAYW[I] ~ DD UNTIL I ~1 - 1 < 0; 32039000 + END INITIALIZEQARRAY; 32040000 +SAVE 1 PROCEDURE INITIALIZE (P1, P2); 32041000 + VALUE P1; 32042000 + INTEGER P1; 32043000 + WORD P2; 32044000 + BEGIN 32045000 + DEFINE TIMEINCR = 32048000 + 1000 COMMENT THE TIME IN MICRO-SECONDS THAT 32049000 + SHOULD BE ADEQUATE TO INITIALIZE A PROCES- 32050000 + SORS STACK.; 32051000 + /BASICCLOCKUNIT 32052000 +| 0 COMMENT ************ CHECK-OUT; 32053000 + | 8 #, COMMENT MAXIMUM NUMBER OF PROCESSORS.; 32054000 + DD = DATADESCRIPTOR#, 32055000 + MINDEX = TIMEOUT#, 32056000 + MLENGTH = MAXADDR#,% 32057000 + T = NEXTADDR #, 32058000 + CODE = FIRSTADDR #, 32059000 + OLDS = NEXTROW #, 32059100 + STOPPIT = GLOBALSTOP#; 32060000 + FIELD PROCIDBITS = (MYSELF-1):1, 32061000 + MODULE = 19:6, 32062000 + SDBITS = 9:10, 32063000 + MOD2F = 0:1, 32064000 + DIV2F = 47:47; 32065000 + LAYOUT MSCW (35:16, 13:14); 32066000 + DEFINE TYPEINT = TYPEINTERROGATE#, PATHINT = TYPEINT#; 32067000 + DEFINE INITIALIZERARRAY (QARRAY, RARRAY, LENGTH) = 32068000 + REPLACE POINTER (RARRAY) BY POINTER (QARRAY) 32069000 + FOR LENGTH OVERWRITE;#; 32070000 + DEFINE MOVESTACK (NEWF) = 32071000 + BEGIN 32072000 + D[30] ~ F; COMMENT D[30] IS TEMPORARY FOR WHERE WE 32073000 + MOVE FROM; 32074000 + F ~ NEWF ~ SHEETENTRYSIZE + 2; 32075000 + COMMENT ALL PROCESSORS HAVE AN INITIAL S REG 32076000 + SETTING OF 8192. WHEN INITIALIZE IS INVOKED, IT32077000 + RUNS WITH A D[1] AND F OF 8193 AND THIS IS IM- 32078000 + MEDIATELY CHANGED TO A LOCATION SOME PLACE IN 32079000 + THE SECOND HALF OF MOD 0. THE EXACT LOCATION IS32080000 + BASED ON THE PROCESSOR ID.; 32081000 + D[1] ~ F; 32082000 + S ~ S + F - D[30]; 32083000 + M[F] ~ 0 & MARKSTACKCW (, 32084000 + REAL (SNR ! 0), 1, *, *, 1, 32085000 + IF SNR =0 THEN F ELSE SHEETENTRYSIZE +1); 32086000 + REPLACE POINTER (M[F+1]) BY POINTER (M[D[30] + 1]) 32087000 + FOR S - F OVERWRITE; 32088000 + D[30] ~ 0; 32089000 + END #; 32090000 +DEFINE MISSINGMODS = 32091000 + BEGIN COMMENT MISSINGMODS ALLOCATES MISSING MEMORY MODULES AS 32092000 + NON-OVERLAYABLE AREAS AND PRESENT MODULES AS 32093000 + OVERLAYABLE AREAS. WHEN MISSINGMODS IS INVOKED 32094000 + THE SITUATION IS THIS: 32095000 + 1. THERE ARE "HOLES" IN MEMORY. I.E. THERE ARE32096000 + ONE OR MORE INACTIVE MODULES SURROUNDED BY 32097000 + ONE OR MORE ACTIVE MODULES. 32098000 + 2. ACTIVE MODULES INCLUDE 0 AND THE HIGHEST 32099000 + AVAILABLE. 32100000 + 3. ZERO WORDS HAVE BEEN ALLOCATED AT THE HIGH-32101000 + EST POSSIBLE MEMORY LOCATION. 32102000 + 4. MEMMODS ARRAY (INDEXED BY MODULE) HAS BEEN 32103000 + INITIALIZED (1 IS ACTIVE MODULE). 32104000 + 5. THE REMAINDER OF THE HIGHEST MODULE IS A- 32105000 + VAILABLE FOR ALLOCATION. WE WILL DO THIS 32106000 + IN SUCH A WAY THAT THE ZERO WORD OF THE 32107000 + MODULE IS AVAILABLE FOR SOME "Z" LINK. ;32108000 + MINDEX ~ GETSPACE(16382-(LINKSIZE+1)|2,0,1,1).MODULE -1; 32109000 + MLENGTH ~ 16384; 32110000 + WHILE MINDEX } 1 DO 32111000 + BEGIN 32112000 + IF MEMMODS[MINDEX] = 0 32113000 + THEN BEGIN COMMENT THE MOD IS MISSING; 32114000 + IF MEMMODS[MINDEX -1] = 1 32115000 + THEN BEGIN COMMENT BUT THE ONE BELOW IT IS 32116000 + READY SO WE ALLOCATE THE MISSING 32117000 + ONE AS NON-OVERLAYABLE.; 32118000 + GETSPACE (MLENGTH, 0, 1, 0); 32119000 + MLENGTH ~ 16364; 32120000 + END OTHERWISE WE INCREASE THE AMOUNT WE 32121000 + GET WHEN WE CAN 32122000 + ELSE IF (MLENGTH ~ MLENGTH + 16364).MODULE > 7 32123000 + THEN STOP COMMENT DONT EXCEDE GETSPACE MAX;32124000 + END OTHERWISE ALLOCATE AS OVERLAYABLE SAVING FIRST 32125000 + WORD OF MODULE FOR Z LINK 32126000 + ELSE GETSPACE (16383 - LINKSIZE, 0, 1, 1); 32127000 + MINDEX ~ MINDEX - 1; 32128000 + END 32129000 + END #; 32130000 + DISALLOW; 32131000 + CASE FIRSTONE(ABS(P1))-21+REAL(NOT INITSWITCH).MPXINDICATOR OF 32132000 + BEGIN 32133000 + CASE FIRSTONE (P1.SDBITS) - 1 OF 32134000 + BEGIN 32135000 + STOPPIT; 32136000 + STOPPIT; 32137000 + STOPPIT; 32138000 + STOPPIT; 32139000 + STOPPIT; 32140000 + STOPPIT; 32141000 + STOPPIT; 32142000 + STOPPIT; 32143000 + STOPPIT; 32144000 + BEGIN 32145000 + STOPPIT; 32145050 + END IO FINISH; 32145100 + ; 32146000 + ; 32147000 + ; 32148000 + ; 32149000 + ; 32150000 + ; 32151000 + END MPX INTERRUPTS CASE; 32153000 + BEGIN COMMENT PROCESSOR TO PROCESSOR INTERRUPT; 32154000 + MOVESTACK (PROCSTACKSIZE | MYSELF + F); 32155000 + PROCMASK.PROCIDBITS ~ 1; COMMENT IDENTIFY MYSELF; 32156000 + IF TIMEOUT = 0 32157000 + THEN BEGIN COMMENT FIRST PROCESSOR SAYS HOW LONG32158000 + IT SHOULD TAKE TO INITIALIZE 32159000 + ALL PROCESSORS; 32160000 + TIMEOUT ~ SCANIN (TIMEOFDAYWORD)+ TIMEINCR;32161000 + INITSWITCH ~ TRUE; 32162000 + END; 32163000 + HEYOU; COMMENT ALL PROCESSORS HAVE BEEN IDLING OR 32164000 + EXECUTING THE CODE IN THIS COMPOUND 32165000 + STATEMENT.; 32166000 + COMMENT ONLY ONE PROCESSOR CAN SUCCESSFULLY 32167000 + COMPLETE THE TWO FOLLOWING STATEMENTS 32168000 + AND IT IS THE ONE THAT COMPLETES THE 32169000 + INITIALIZATION.; 32170000 + DO UNTIL SCANIN (TIMEOFDAYWORD) > TIMEOUT; 32171000 + BUZZCONTROL (SLAVEQUARTERS); 32172000 + IF LOCK(SLAVEQUARTERS) 32173000 + THEN BEGIN COMMENT GET MEMORY 32174000 + UNDER CONTROL.; 32175000 + MINDEX := INITIALIZEPCW := 0; 32176000 + MCPINFO ~ MCPINFO & 32177000 + NOTPRESENTARRAYDESCL(,*,3,0,MCPTOP := 32177040 + M[2]); 32177050 + COMMENT THE MCP LOADERS 32177100 + WILL ALWAYS PLACE THIS 32178000 + ADDRESS IN MEMORY[2] SO32179000 + THAT WE WILL KNOW WHERE32180000 + TO FIND THE MCP INFO 32181000 + SEGMENTS; 32182000 + SIMULATING := BOOLEAN(M[2]).BIT45 ; 32182100 + M[2] := 0; 32182200 + DO MINDEX ~ M[MINDEX].INUSELENGTH + MINDEX32183000 + + 1 UNTIL BOOLEAN(M[MINDEX].AVAILABLE);32184000 + PREVADDR ~ MINDEX; 32185000 + AVAILI ~ TEMPLINKS.ADDRESSF; 32186000 + COMMENT FIX FIRST AVAILABLE LINK; 32187000 + TEMPLINKS[0] ~ 0 & 32188000 + AVAILA (,*,LINKSIZE,, PREVADDR); 32189000 + TEMPLINKS [LINKSIZE] ~ 0 & 32190000 + AVAILZ (,, LINKSIZE); 32191000 + COMMENT FIX STOPPER; 32192000 + STOPPER ~ LINKSIZE + 1; 32193000 + TEMPLINKS [STOPPER] ~ 4"040000000001" & 32194000 + AVAILA (,*, LINKSIZE,,*); 32195000 + TEMPLINKS[STOPPER+1] ~ PREVADDR; 32196000 + TEMPLINKS[STOPPER+LINKSIZE] ~ 32197000 + 0 & AVAILZ (,, LINKSIZE); 32198000 + COMMENT UPDATE AVAILABLE AREA LINK; 32199000 + STOPPER ~STOPPER +TEMPLINKS.ADDRESSF; 32200000 + M[PREVADDR].LINK ~STOPPER; 32201000 + M[PREVADDR+1] ~ AVAILI; 32202000 + COMMENT SAVE INITIALIZATION CODE 32203000 + ADDRESS FOR LATER FORGETING;32204000 + SAVE1ADDRESS ~ PREVADDR - M[PREVADDR -1]. 32205000 + INUSELENGTHZ + 2; 32206000 + 32207000 + BACKALLOCATED ~ SAVE1ADDRESS - LINKSIZE; 32208000 + MEMMODS ~ MEMMODS&DD 32209000 + COMMENT IT SEEMS LIKE A REASONABLE PLACE;32210000 +( ,1,0,*,*,*,*,*,*, 12000); 32211000 + REPLACE POINTER(MEMMODS) BY 1 FOR 64 32212000 + OVERWRITE; 32213000 + COMMENT ASSUME ALL POSSIBLE MEMORY IS 32214000 + PRESENT AND MARK ABSENT MODS IN INVALID 32215000 + ADDRESS.; 32216000 + MEMMAX ~ M.LENGTHF; 32217000 + COMMENT LET INVALID ADDRESS WORK; 32218000 + MINDEX ~ 0; 32219000 + DO BEGIN 32220000 + M[MINDEX := MINDEX + 16384] := 0; 32220500 + IF BOOLEAN(MEMMODS[MINDEX.MODULE]) THEN 32220600 + M[MINDEX+1] := 0; %CHECK INTERLACING 32220700 + END UNTIL MINDEX = 1032192; 32221000 +COREFACTOR ~ TRUE; COMMENT * * * * * * * * * * ; 32221050 + AVAILABLECORE ~ MEMMAX - PREVADDR; 32221100 + COMMENT FIND HIGHEST POSSIBLE ADDRESS; 32222000 + MINDEX~MASKSEARCH(1,1,MEMMODS)|16384+16382;32223000 + M.LENGTHF ~MINDEX + 1; 32224000 + COMMENT WHEN THERE IS MAXIMUM MEMORY32225000 + THE LAST WORD IS NOT INDEXABLE THROUGH32226000 + M AND SO WE WASTE IT ALLCASES.; 32227000 + M[PREVADDR].LENGTH ~ MINDEX - PREVADDR; 32228000 + M[MINDEX] ~ 0 & AVAILZ (,,MINDEX-PREVADDR);32229000 + COMMENT NOW ALL MEMORY ABOVE INITIALIZA- 32230000 + TION AND INCLUDING MEMMAX LOOKS 32231000 + AVAILABLE. THIS MAY NOT BE TRUE 32232000 + BECAUSE OF MISSING MODS, BUT ALL 32233000 + THE SPACE ROUTINES WILL FUNCTION,32234000 + AND TO AVOID REPETITIVE CHECKS AS32235000 + TO WHETHER WE ARE AT THE END OF 32236000 + MEMORY WE WILL ALLOCATE 0 NON- 32237000 + OVERLAYABLE WORDS AT THE END OF 32238000 + MEMORY.; 32239000 + GETSPACE (0, 0, 1, 0); 32240000 + MEMMAX ~ MEMMAX -1; 32241000 + IF MINDEX ! MEMMAX 32242000 + THEN BEGIN COMMENT THERE ARE MISSING MODS.32243000 + REGARDLESS OF THE STATUS OF OTHER32244000 + MODS, 16375 WORDS CAN BE GOTTEN 32245000 + IN THE FINAL MOD AND THE FIRST 32246000 + WORD OF THE MOD WILL BE AVAILABLE32247000 + FOR SOME "Z" LINK.; 32248000 + MISSINGMODS; 32249000 + END; 32250000 + MINDEX ~ M.LENGTHF -1; 32251000 + DO BEGIN 32252000 + IF BOOLEAN(M[MINDEX].OLAY) 32253000 + THEN FORGETSPACE(MINDEX +LINKSIZE32254000 + -M[MINDEX].INUSELENGTHZ); 32255000 + MINDEX ~ MINDEX 32256000 + - M[MINDEX].INUSELENGTHZ -1;32257000 + END 32258000 + UNTIL MINDEX + LINKSIZE +1= SAVE1ADDRESS; 32259000 + REPLACE POINTER(MEMMODS) BY 0 FOR 64 WORDS;32260000 + T ~ D31; 32261000 + MONITORMASK ~ T.MONMASKF; 32262000 + D31 := MONITORVALUE := T.MONVALF; 32263000 + IF SIMULATING 32265000 + THEN BEGIN 32266000 + MINDEX ~ NAME(MON1TOR).SDIF; 32267000 + M[MINDEX] ~ M[NAME(SIM1TOR)]; 32268000 + END ELSE 32269000 + LOCK(MONITORLOCK); 32269100 + IF MAXSTACKS ~ (MEMMAX.MODULE +1) | 32270000 + STACKSPERMODULE > 1024 32271000 + THEN MAXSTACKS ~ 1024; 32272000 + STACK ~ 32273000 + STACK & DD(,1,0,*,*,*,*,*, MAXSTACKS, 32274000 + GETSPACE(MAXSTACKS, 0, 1, 0)) ; 32275000 + INITIALIZEARRAY(REPLY,REPLY,MAXSTACKS); 32275100 + MAXSTACKS ~ * -1; 32276000 + COMMENT ******** SOMETHING WILL EVENTUALLY HAVE TO BE DONE 32277000 + ABOUT THE FOLLOWING TWO STATEMENTS IN REGARDS 32278000 + TO NON-SEOUENTIALLY NUMBERED PROCESSORS 8/16; 32279000 + PROCSTACKSTARTW~ WORD(GETSPACE( 32280000 + PROCSTACKSIZE|FIRSTONE(PROCMASK),0,1,0)); 32281000 + STACKVECTOR [0] ~ 0 & DD(); 32282000 + REPLACE POINTER (STACKVECTOR[1]) BY 32283000 + POINTER (STACKVECTOR[0]) 32284000 + FOR MAXSTACKS - 1 OVERWRITE; 32285000 + STACKVECTOR [0] ~ STACKVECTOR [0] 32286000 + &DD(,1,0,*,*,*,*,*, 1+ 32287000 + M[0].INUSELENGTH, *); 32288000 + PERIPHERALINVALIDADDRESS := TRUE; 32288050 + MAXCHANNELS := 4"F"; 32288060 + FOR CODE := 0 STEP 1 UNTIL 3 DO 32288100 + BEGIN % MPX 32288150 + OLDS := S; 32288200 + SCANIN(0 & SCANINWORD(2, SET(0, CODE),32288250 + 1)); %MIGHT AS WELL READ R.D. 32288300 + S := OLDS; % TO DELETE IN ADDR CRAP 32288350 + END; 32288400 + MULTIPLEXORMASK := BOOLEAN(2|MAXCHANNELS); 32288420 + DCPSANDGCAS := 4"FFFFFFFFFF"; 32288440 + FOR CODE := 4 STEP 1 UNTIL 19 DO 32288450 + BEGIN % DCP 32288500 + OLDS := S; 32288550 + SCANOUT(0, 4"C0000" & SCANOUTWORD 32288600 + (2, CODE - 4, 0)); % HALT DCP 32288650 + S := OLDS; 32288700 + END; 32288750 + COMMENT DO THE GCA HERE---CODE GEQ 20; 32288800 + UNLOCK (SLAVEQUARTERS); 32289000 + 32290000 +COMMENT *** SOME QUEUE HEADS HAVE TO BE SMASHED AT INITIALISATION; 32292000 + ; 32293000 + WORDREADYQHEAD ~ 0; 32294000 + WORDSHEETQHEAD ~ 0; 32295000 + WORDTERMINATEQHEAD ~ 0; 32296000 +COMMENT *** END OF QUEUE HEAD SMASHING; 32297000 + INITIALIZEARRAY(STACKINUSE, IRPARAMETERLOK, 32297100 + MAXIRINDEXPLUS1); 32297200 + INITIALIZEARRAY(PRIORITYLEVEL,PRIORITYLEVEL,PRIORITYRANGE+1); 32297300 + 32297400 +COMMENT *** THE NUMBER OF INDEPENDENT RUNNER STACKS MAY BE A DEFINE OR32298000 + IT MAY BE A SYSTEM PARAMETER, FOR THE MOMENT, IT IS AN 32299000 + INITIALISED VARIABLE AS DEMONSTRATED BELOW; 32300000 + INDEPENDENTRUNNERSTACKS ~ 2; 32301000 +COMMENT STACKINUSE GIVES THE STACK NO OF EACH INDEPENDENT RUNNER 32302000 + WHICH IS CURRENTLY RUNNING AND WHICH DOES NOT REQUIRE MORE32303000 + THAN ONE STACK, IT MUST BE INITIALISED TO ZERO; 32304000 + 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 + ; 32307000 + FILLARRAY(IRPRIORITIES,IRDEFAULTPRIORITY,MAXIRINDEX);32308000 + IRPRIORITIES[CONTROLCARDINDICATOR] 32308200 + ~CONTROLCARDPRIORITY; 32308400 + IRPRIORITIES[INITIATEINDICATOR]~INITIATEPRIORITY; 32308600 + IRPRIORITIES[TERMINATEINDICATOR]~TERMINATEPRIORITY; 32308800 + IRPRIORITIES[DIRCOMPLEMENTINDICATOR] := 32308900 + DIRCOMPLEMENTPRIORITY; 32308950 +COMMENT FOLLOWING ARE INITIALIZATIONS OF SOME CONTROL WORDS; 32309000 + D2MSCW2~0&MARKSTACKWD(,*,1,*,READYENTRYSIZE-2,*,2,4);32310000 + IRMSCW2~0&MARKSTACKWD(,*,1,*,FIXEDIRSIZE-2,*,2,4); 32311000 + SHEETTOSCW~0&TOSCW(,0,0,0,0,SHEETENTRYSIZE+1,1,1,2); 32312000 + D2MSCW1~0&MARKSTACKWD(,1,1,*,D0OFFSET,*,1, 32313000 + READYENTRYSIZE-3); 32314000 + IRMSCW1~0&MARKSTACKWD(,1,1,*,D0OFFSET,*,1,FIXEDIRSIZE32315000 + -3); 32315100 + D1MSCW~0&MARKSTACKWD(,1,1,*,D0OFFSET,*,1,D1INFO-1); 32316000 + 32317000 + D2RCW1 ~ 0&RETURNCONTROLWORD(,*,*,*,*,*,*); 32318000 + IRTOSCW~0&TOSCW(,,,,,FIXEDIRSIZE+4,1,2,2); 32319000 + D2TOSCW~0&TOSCW(,,,,,READYENTRYSIZE+4,1,2,2); 32319100 + D03 := HARDWAREINTERRUPTPCW; 32320000 + END OF NON PROCESSOR INITIALIZATION; 32321000 + SNR ~ MYSELF; 32322000 + P1 ~ PROCSTACKSTART.ADDRESSF + (MYSELF-1)| 32323000 + PROCSTACKSIZE; 32324000 + MOVESTACK (P1); 32324100 + INITIALIZETOZERO (P1, SHEETENTRYSIZE); 32324900 + STACKVECTOR [MYSELF] ~ 32325000 + 0 & DD ( ,1,*,*,*,*,*,*, PROCSTACKSIZE, 32326000 + F - SHEETENTRYSIZE - 2); 32327000 + STACK [SNR, 0]~MYSELF; % PROCESSOR ID TO TOS 32328000 + WORDSTACK [MYSELF, 1] ~ 0 & 32329000 + MARKSTACKCW (,*,1, SNR, *,*,*); 32330000 + BOSR ~ STACKVECTOR[SNR].ADDRESSF; 32331000 + LOSR ~ BOSR + PROCSTACKSIZE - STACKOFLOWSIZE; 32332000 + MORETHANONEPROCESSOR ~ (NUMBEROFPROCESSORS ~ 32333000 + ONES(PROCMASK)) > 1; 32334000 + PROCSTACKSTART.LENGTHF ~ PROCSTACKSTART.LENGTHF+1; 32335000 + INITIALIZEARRAY(SHEETVECTOR,SHEETVECTOR, 32336000 + IF STACKVECTOR.LENGTHF<511 32336100 + THEN STACKVECTOR.LENGTHF|2 ELSE 1024); 32336200 +COMMENT *** THERE IS NO JUSTIFICATION FOR THIS; 32336400 + HOLDINITIALISE; 32337000 + END PROCESSOR TO PROCESSOR INTERRUPT; 32338000 + BEGIN COMMENT TIMER & STACK OVERFLOW; 32339000 + STOPPIT 32340000 + END; 32341000 + BEGIN COMMENT SYLLABLE DEPENDENT - CLASS 2; 32342000 + STOPPIT 32343000 + END; 32344000 + CASE FIRSTONE (P1.SDBITS) - 1 OF 32345000 + BEGIN 32346000 + STOPPIT; COMMENT MEMORY PROTECT; 32347000 + STOPPIT; COMMENT INVALID OPERATOR; 32348000 + STOPPIT; COMMENT DIVIDE BY ZERO; 32349000 + STOPPIT; COMMENT EXPONENT OVERFLOW; 32350000 + STOPPIT; COMMENT EXPONENT UNDEHFLOW; 32351000 + STOPPIT; COMMENT INVALID INDEX; 32352000 + STOPPIT; COMMENT INTEGER OVERFLOW; 32353000 + STOPPIT; COMMENT BOTTOM OF STACK; 32354000 + BEGIN COMMENT PRESENCE BIT - 32355000 + AS LONG AS P2 POINTS TO A WELL FORMED DATA 32356000 + DESCRIPTOR THAT DOES NOT REQUIRE I-O, WE SHOULD 32357000 + BE ABLE TO SATISFY PB INTERRUPTS DURING INITIAL-32358000 + IZATION. HOWEVER, IT SHOULD BE REMEMBERED 32359000 + THAT MOST ALLOCATION DURING INITIALIZATION IS 32360000 + NON-STANDARD. I.E. NON-OVERLAYABLE AND HIGH IN 32361000 + MEMORY. THIS PRESENCE BIT WILL CAUSE THE SAME 32362000 + TYPE OF ACTION. NOTE - OP NOT CONSIDERED .; 32363000 + ALLOW; 32364000 + M[P2.ADDRESSF] ~ M[P2.ADDRESSF] & DD 32365000 + (*,1,0,*,*,*,*,*,*, GETSPACE( M[P2.ADDRESSF]. 32366000 + LENGTHF , 0,1, P2.ADDRESSF)); 32367000 + INITIALIZETOZERO(M[P2.ADDRESSF].ADDRESSF, 32368000 + M[P2.ADDRESSF].LENGTHF); 32368100 + IF P2.TAG ! 1 32369000 + THEN P2~P2 & DD (*,1,1,*,*,*,*,*,*, 32370000 + M[P2.ADDRESSF].ADDRESSF); 32370100 + IF P1 < 0 32371000 + THEN RETURN(P2); 32372000 + 32373000 + END INITIALIZE PRESENCE BIT; 32374000 + STOPPIT; COMMENT SEQUENCE ERROR; 32375000 + END SYLLABLE DEPENDENT; 32376000 + CASE FIRSTONE(P1.SDBITS) OF 32377000 + BEGIN COMMENT ALARM INTERRUPTS; 32378000 + STOPPIT; 32379000 + STOPPIT; COMMENT OPERATOR LOOP; 32380000 + STOPPIT; COMMENT MEMORY PARITY; 32381000 + STOPPIT; COMMENT MPX PARITY; 32382000 + IF PERIPHERALINVALIDADDRESS THEN 32383000 + BEGIN COMMENT PERIPHERAL TYPE INVALID ADDRESS; 32383100 + IF CODE < 4 THEN 32383200 + MAXCHANNELS := RESET(MAXCHANNELS,CODE) ELSE 32383300 + DCPSANDGCAS := RESET(DCPSANDGCAS, CODE - 4 | 32383400 + REAL(CODE < 20)); 32383500 + END ELSE 32383600 + BEGIN COMMENT MEMORY TYPE INVALID ADDRESS; 32383700 + MEMMODS[MINDEX.MODULE] ~ 0; 32384000 + MEMMAX ~ MEMMAX - 16384; 32385000 + M[F+1] ~ IF M[F+1].PSRF = 0 32386000 + THEN M[F+1] & RETURNCONTROLWORD 32387000 + (*,*,5,M[F+1].PIRF-1,*,*,*) 32388000 + ELSE M[F+1] & RETURNCONTROLWORD 32389000 + (*,*,M[F+1].PSRF-1,*,*,*,*); 32390000 + M[F-1].INDEXF ~ 16383; 32391000 + COMMENT SET BACK PIR & PSR SO THAT THE 32392000 + INVOKING OPERATOR IS REPEATED AND32393000 + THE STACK IS PROPERLY CUT BACK. 32394000 + THE WORD AT 16383 IS AVAILABLE 32395000 + AND UNUSED AT THIS TIME.; 32396000 + END; 32397000 + STOPPIT; COMMENT STACK UNDERFLOW; 32398000 + STOPPIT; COMMENT INVALID OPERATOR; 32399000 + END ALARM INTERRUPTS; 32400000 + END MAJOR INTERRUPT CASE; 32401000 + 32402000 + END INITIALIZE; 32403000 + 32404000 + 33000000 + SAVE PROCEDURE HARDWAREINTERRUPT (P1,P2); VALUE P1,P2; 33001000 + INTEGER P1; COMMENT IDENTIFIES TYPE OF INTERRUPT; 33002000 + WORD P2; COMMENT USED BY PRESENCE BIT AND POSSIBLY OTHERS; 33003000 +COMMENT FURTHER GLOBALS ARE 33004000 + 33005000 + 33006000 + 33007000 + PROCEDURE MYFAULT ) NOTE THAT THESE NAMES 33008000 + MYDIVIDEBYZERO ) ACCESS PCWS STUFFED IN 33009000 + MYEXPONENTOVERFLOW ) KNOWN STACK LOCATIONS BY 33010000 + MYEXPONENTUNDERFLOW ) COMPILES,LINKAGE LOADERS ETC. 33011000 + MYINVALIDINDEX ) THEY ARE ASSOCIATED WITH E.G. 33012000 + MYINTEGEROVERFLOW ) ALGOL FAULT STATEMENTS THUS 33013000 + ) PCWS SHOULD HAVE CONTROL BIT ON33014000 + ) AND ACCESSED STATEMENTS SHOULD 33015000 + ) NOT INVOKE SYLLABLE DEPENDENT 33016000 + ) INTERRUPTS 33017000 + SIZE IS NUMBER OF WORDS REQUIRED, 33018000 + THERE ARE POTENTIALLY 8 TYPES ONLY TWO ARE DISTINGUISHED SO 33019000 + FAR(AND MUST BE GLOBALLY DEFINED): 33020000 + OVLAYABLE 33021000 + NONOVLAYABLE 33022000 + GREATESTTYPE MAXIMUM VALUE OF TYPE FOR GETSPACE 33023000 + MASSIN(DISKTYPE,DISKADDRESS,EVENT, SOME OTHER PARAMETERS) 33024000 + DISKTYPE CODEDISK 33025000 + OVERLAYDISK 33026000 + EVENT IS SET ON COMPLETION 33027000 + FIREUP TRANSFERS PROCESSES FROM EVENT QUEUE 33028000 + TO READYQ 33029000 + ; 33030000 +COMMENT THIS PROCEDURE HANDLES ALL INTERRUPTS 33031000 + IT USES AS BIBLE :- "INTERRUPT HANDLING AND ACCIDENTAL ENTRY"33032000 + , E.A. HAUK, JULY 25 1967 33033000 + (1) NOTE THAT THE PROCEDURE MAY EITHER EXIT ON COMPLETION OR 33034000 + CHANGE TO ANOTHER PROCESS(JOB). THUS ALL PROCESS INITIATION 33035000 + AND RE-ACTIVATION MAY BE HANDLED IN THIS PROCEDURE IF SUCH A 33036000 + COURSE PROVES DESIRABLE 33037000 + (2) NOTE THAT A SINGLE PROCESSOR USER PAYS A PRICE BECAUSE OF 33038000 + POTENTIAL MULTIPROCESSOR USERS. SOME ATTEMPT TO MINIMISE THIS 33039000 + PRICE MAY BE WORTHWHILE. SOURCE EDITING AND THE USE OF DEFINES 33040000 + MAY BE APPROPRIATE; 33041000 + 33042000 +BEGIN COMMENT MCS 1; 33043000 + REAL TRACTER ; 33044000 + PROCEDURE NOTYETCODED (X); VALUE X; REAL X; FORWARD; 33045000 + LAYOUT P1PARAMETER 33046000 + ( IOFFIELD = 0:1 % INT MASK FIELD FOR IOFINISH 33047000 + , MPXSPECFIELD= 3:4 % SPECIFIES MPXA OR MPXB 33048000 + , ALARMFIELD = 5:6 % ALARM TYPE 33049000 + , IFFIELD = 7:4 % MPX INTERFACE 33050000 + , INTFIELD = 9:10 % SD INTERRUPT TYPE 33051000 + , MPXFIELD = 20:1 % MPX INTERRUPT 33052000 + , SDFIELD = 24:1 % SYLLABLE DEP INT FLAG 33053000 + , RTBITF = 46:1 % RETURN BIT 33054000 + ) ; 33055000 + 33056000 + 33057000 + 33058000 + DEFINE INTERVALTIMERSPEC = @020000001# 33059000 + , STACKOVERFLOWSPEC = @020000002# 33060000 + , SYLLABLEDEPNDNT2SPEC= @040000000# 33061000 + , ALARMSPEC = @200000001# 33062000 + , PROCTOPROCSPEC = @010000000# 33063000 + , SYLABLEDEPENDENT2 = SYLLABLEDEPNDNT2SPEC# 33064000 + ; 33065000 + DEFINE LITERALFUNCTIONA = @ 743 # 33066000 + , LITERALFUNCTIONB = @ 745 # 33067000 + ; 33068000 + INTEGER MYSNR 33069000 + , MYF 33070000 + 33071000 + ; 33072000 + LABEL LOOKAROUND 33073000 + , AGAIN 33074000 + , FINI 33075000 + ; 33076000 + BOOLEAN FIRST )"TRUE IF FIRST TIME AT LOOKAROUND "(33077000 + RTBIT 33078000 + ; 33079000 + MONITOR JACKMONITOR(P1); 33080000 + WORD ACTUALCOPY = P2 33081000 + ; 33082000 + FIELD BITONEF = 1:1 33082100 + , BITTWOF = 2:1 33082200 + ; 33082300 +COMMENT THE FOLLOWING LOCAL PROCEDURES HANDLE ALL INTERRUPTS OTHER 33083000 + THAN INTERVAL TIMER, GCA AND IOFINISH, 33084000 + ; 33085000 + SAVE PROCEDURE PROCTOPROC; 33086000 + NOTYETCODED(PRTOPR); 33087000 + SAVE PROCEDURE STACKOVERFLOW; 33088000 + NOTYETCODED(STACKOVER); 33089000 + SAVE PROCEDURE SYLLABLEDEPENDENT2; 33090000 + KILLME(SYLABLEDEPENDENT2); 33091000 + SAVE PROCEDURE ALARM; 33092000 + NOTYETCODED(BLOWUP+P1.ALARMFIELD); 33093000 + SAVE PROCEDURE MEMORYPROTECT; 33094000 + NOTYETCODED(MEMPROTECT); 33095000 + SAVE PROCEDURE INVALIDOPERATOR; 33096000 + NOTYETCODED(INVALIDOP); 33097000 + SAVE PROCEDURE SEQUENCEERROR; 33098000 + NOTYETCODED(SEQERROR); 33099000 + SAVE PROCEDURE MLL1; 33100000 + NOTYETCODED(ML1); 33101000 + SAVE PROCEDURE MLL2; 33102000 + NOTYETCODED(ML2); 33103000 + SAVE PROCEDURE MLL3; 33104000 + NOTYETCODED(ML3); 33105000 + SAVE PROCEDURE MLL4; 33106000 + NOTYETCODED(ML4); 33107000 + SAVE PROCEDURE EXTERNALMPX; 33108000 + NOTYETCODED(EXTMPX); 33109000 + SAVE PROCEDURE MPXUNASSIGNED(SPEC); VALUE SPEC; INTEGER SPEC; 33110000 + NOTYETCODED(SPEC); 33111000 + SAVE PROCEDURE BOTTOMOFSTACK; 33112000 + NOTYETCODED(STACKBOTTOM); 33113000 + SAVE PROCEDURE ARITHMETICFAULT(WHICH); VALUE WHICH; 33114000 + INTEGER WHICH; COMMENT SPECIFIES INTERRUPT; 33115000 +COMMENT HANDLES DIVIDE BY ZERO,EXPONENT OVERFLOW,EXPONENT UNDERFLOW, 33116000 + INVALID INDEX AND INTEGER OVERFLOW 33117000 + THE PROCEDURE ACCESSES "MYCOURSE" (A DEFINE OR 33118000 + INTRINSIC ACCESSING A STACK LOCATION SET BY THE COMPILER. THE 33119000 + LINKAGE LOADER OR SOMETHING) 33120000 + MYCOURSE = UPTOYOU THE MCP DOES AS IT PLEASES 33121000 + = FINISH THE MCP MUST D-ES ME 33122000 + = CARRYON THE MCP IGNORES THIS INTRUPT33123000 + = TELLME THE MCP SETS SOME FLAGS 33124000 + = FAULTROUTINE ENTER GENERAL FAULT ROUTINE 33125000 + = SELECT ACCESS PCW APPROPRIATE TO 33126000 + INTERRUPT 33127000 + THESE CHOICES COULD BE LIMITED. GIVING A MORE 33128000 + UNIFORM APPROACH BUT USING MORE CORE STORAGE. THEY ALLOW ALGOL,33129000 + COBOL ETC. TO REACT DIFFERENTLY TO FAULT CONDITIONS - DO WE 33130000 + WANT THIS 33131000 + ALL CHOICES EXCEPT THE LAST TWO INVOLVE RETURN TO THE33132000 + INTERRUPT ROUTINE. HOWEVER BAD GO TOS ASSOCIATED WITH THE LAST 33133000 + TWO CHOICES (A LIKELY OCCURRENCE)MAY PREVENT SUCH A RETURN. 33134000 + HENCE THE BAD GO TO MECHANISM MUST CALL THE PROCEDURE 33135000 + WHATDOIDO (AMONG OTHER THINGS) 33136000 + NOTE THAT THE CONCEPT OF MASTER AND SLAVE PROCESSORS 33137000 + AS DESCRIBED BY DAHM IS CONSIDERED AN UNNECESSARY COMPLICATION 33138000 + IN THE HANDLING OF SYLLABLE DEPENDENT INTERRUPTS 33139000 + ; 33140000 + BEGIN 33141000 + INTEGER MYACTION 33142000 + ; 33143000 + LABEL BUZZ,LOOKFORJOB 33144000 + ; 33145000 + 33146000 + 33147000 + 33148000 + IF MYACTION ~ MYCOURSE=UPTOYOU OR MYACTION=FINISH THEN 33149000 + KILLME(WHICH) 33150000 + ELSE IF MYACTION =CARRYON THEN GO LOOKFORJOB 33151000 + ELSE IF MYACTION =TELLME THEN BEGIN SETOVERFLOWFF; 33152000 + GO LOOKFORJOB END 33153000 + ELSE IF MYACTION =FAULTROUTINE THEN 33154000 + MYFAULT(P2) 33155000 + ELSE 33155100 + CASE WHICH OF 33157000 + BEGIN 33158000 + MYDIVIDEBYZERO(P2); 33159000 + MYEXPONENTOVERFLOW(P2); 33160000 + MYEXPONENTUNDERFLOW(P2); 33161000 + MYINVALIDINDEX(P2); 33162000 + MYINTEGEROVERFLOW(P2); 33163000 + END CASE EXPRESSION; 33164000 +LOOKFORJOB: 33165000 + END ARITHMETICFAULT; 33166000 + SAVE WORD PROCEDURE PRESENCEBIT; 33167000 +COMMENT 33168000 + (1) THE PROCEDURE DOES NOT RUN AROUND MAKING ABSENT COPIES PRESENT 33169000 + MAYBE IT SHOULD; 33170000 + BEGIN COMMENT MCS 1; 33171000 + LABEL TOSLEEP 33172000 + ,FIN 33173000 + ,LOOKFORPREEMPT 33174000 + ,MOMPRESENT 33175000 + 33176000 + ; 33177000 + INTEGER 33178000 + TI1,TI2,TI3, 33179000 + IOCW, 33180000 + KIND )"WHETHER P2 IS OPERAND,DD,SEGDESC OR IRW "(33181000 + FIRSTLOC )"MULTIPLE DESCRIPTORS-LOCATION FIRST ARG "(33182000 + LASTLOC 33183000 + ; 33184000 + EVENT EVNN 33185000 + ; 33186000 + 33187000 + 33188000 + 33189000 + WORD 33190000 + MOM %HOLDS MOM (NOT COPY) 33191000 + , MOMLOCATION %INDEX INTO M FOR MOM 33192000 + , TW1 = TI2 33193000 + ; 33194000 + 33195000 + 33196000 + 33197000 + BOOLEAN ALREADYPRESENT; 33198000 + 33199000 + 33200000 + 33201000 + 33202000 + BOOLEAN NOCHANGE 33203000 + , OLAY 33203100 + ; 33204000 + ARRAY DISKADDRESSES[*] 33205000 + , IOCBREFERENCE [IOCBSIZE] 33206000 + ; 33207000 + REFERENCE IOCB = IOCBREFERENCE 33208000 + ; 33209000 + DEFINE FIXRECORDDESC(X) = WORD(AREADESC @ X).ADDRESSF # 33210000 + ; 33211000 + 33212000 + BUZZCONTROL(PBLOK); COMMENT *** BUZZ; 33213000 +COMMENT*** AT PRESENT THIS LOCK IS REDUNDANT. HOWEVER WHEN GROSS LOCK 33214000 + IS REMOVED, AN EVEN FINER LOCK MAY BE REQUIRED; 33215000 + ALREADYPRESENT~FALSE; 33216000 + RTBIT ~ BOOLEAN(P1.RTBITF); 33217000 + NOCHANGE~FALSE; 33218000 + IF (KIND ~ ACTUALCOPY.TAG) = SINGL 33219000 + THEN BEGIN COMMENT MCS 2MULTIPLE DESCRIPTORS; 33220000 + LASTLOC := MYF - REAL(ACTUALCOPY); 33221000 + FIRSTLOC := MYF - 1; 33222000 + UNLOCK(PBLOK); 33223000 + 33224000 + FOR TI1 := FIRSTLOC STEP -1 UNTIL LASTLOC DO 33225000 + BEGIN 33226000 + IF (TW1 := P2 := M[TI1]).TAG = DOUBL THEN 33227000 + BEGIN 33227100 + LASTLOC := * - 1; 33227200 + TI1 := * - 1; 33227300 + COMMENT P2 DOESN"T COUNT DOUBLES AS 2 33227400 + WORDS; 33227500 + END ELSE 33227600 + IF TW1.TAG = DATADESC THEN 33228000 + IF NOT BOOLEAN(REAL(TW1).PBITF) THEN 33229000 + M[TI1] ~ PRESENCEBIT; 33230000 + 33231000 + END; 33232000 + GO TO FIN; 33233000 + END MCS 2 MULTIPLE DESCRIPTORS 33234000 + ELSE 33235000 + 33236000 + IF (REAL(MOM~M[MOMLOCATION~(IF KIND=IRW 33237000 + THEN STACKVECTOR [ACTUALCOPY.STKNRF].ADDRESSF33238000 + +ACTUALCOPY.DISPF 33239000 + +ACTUALCOPY.SIRWDELTAF 33240000 + ELSE ACTUALCOPY.ADDRESSF)] 33241000 + ).LOCKBITF=1 AND KIND=SEGDESC) 33242000 + OR DESCRIPTORLOCK 33242100 + THEN 33243000 +COMMENT *** NOTE ABSOLUTE ADDRESSES, THIS IS A MESSY BUSINESS AND33244000 + SHOULD BE CHANGED IF POSSIBLE. NOTE THAT THE SIRW 33245000 + IS CHANGED INTO AN ABSOLUTE ADDRESS BECAUSE GETSPACE 33246000 + EXPECTS ONE; 33247000 + BEGIN COMMENT MCS 3; 33248000 + UNLOCK(PBLOK); 33249000 + WAIT(EVNT @ REFERENCE(IOCBREFERENCE ~ 33250000 + IOCBREFERENCE&REFERENCED 33251000 + (1,*,* 33251100 + ,TI3~IF KIND=SEGDESC 33251200 + THEN MOM.ADDRESSF 33251300 + ELSE MOM.ADDRESF 33251400 + ) 33251500 + )); 33252000 + TI2~WORD(AREADESC@IOCB).ADDRESSF+1; 33253000 + 33254000 +COMMENT *** MAYBE THIS CAN BE FIXED LATER; 33255000 + GO TOSLEEP; 33256000 + END MCS 3 33257000 + ELSE; 33258000 + 33259000 + 33260000 + 33261000 + 33262000 + UNLOCK(PBLOK); 33263000 + IF MOM.AITINDICATORF=1 AND KIND=DATADESC 33264000 + THEN BEGIN M[MOMLOCATION]~MOM~DOPEVECTOR(MOM); 33265000 + IF BOOLEAN(ACTUALCOPY.IBITF) THEN 33266000 + ACTUALCOPY~ MOM &DATADESCRIPTOR 33267000 + (*,*,1,1,*,*,*,*, 33268000 + ACTUALCOPY.INDEXF,*) ELSE 33269000 + ACTUALCOPY~MOM&DATADESCRIPTOR(*,*,1,*,*,*,*33270000 + ,*,*,*); 33271000 + GO LOOKFORPREEMPT; 33272000 + END; 33273000 + IF MOM.PBITF= 1 33274000 + THEN 33275000 + BEGIN COMMENT MCS 4; 33276000 + TI2~MOM.ADDRESSF; 33277000 + ALREADYPRESENT ~ TRUE; 33278000 +MOMPRESENT: IF KIND!IRW THEN PREsENCEBIT~ACTUALCOPY 33279000 + ~ACTUALCOPY&FIXDESC(1,*,TI2); 33280000 + IF NOT ALREADYPRESENT 33281000 + THEN 33282000 + BEGIN COMMENT MCS 4A ; 33283000 + MOM~MOM&FIXDESC(1,*,TI2); 33284000 + IF KIND=SEGDESC 33285000 + THEN MOM.LOCKBITF~0; 33286000 + M [MOMLOCATION] ~ MOM; 33287000 + TURNOVERLAYKEY(MOMLOCATION); 33288000 + END MCS 4A; 33288100 + IF NOCHANGE 33289000 + THEN 33290000 + BEGIN COMMENT MCS 4B; 33291000 + IF NOT ALREADYPRESENT THEN 33294000 + FORGETAREA(IOCBSIZE,TI333294100 + ); 33294200 + UNLOCK(MULTIPLEREFERENCELOK);33295000 + GO FIN; 33296000 + END MCS 4B; 33297000 + 33298000 +LOOKFORPREEMPT: % *** THERE WAS A CONDITIONAL CALL ON WHATDOIDO 33299000 + END MCS 4 33300000 + ELSE 33301000 + BEGIN COMMENT MCS 5 ; 33302000 +COMMENT ********** *************33303000 +******************* *************33304000 + DATA AND SEGMENT DESCRIPTORS ARE INTERPRETED AS FOLLOWS 33305000 + ***** DATA DESCRIPTORS ***** 33306000 + INTERPRETATION 33307000 +FIELD OLAYTYPEF 33308000 + MCPF FILETYPEF AITINDICATORF ADDRESF 33309000 + (MCPCODEF) 33310000 +BITS 19:1 18:1 17:1 16:17 33311000 + 0 0 0 >1 NON-MCP READ IN OLAYABLE 33312000 + FROM OLAY FILE 33313000 + 0 0 0 0 NON-MCP GET OLAYABLE 33314000 + 0 0 0 1 NON-MCP GET SAVE SPACE 33315000 + 0 0 1 * NON-MCP AIT REFERENCE 33316000 + 0 1 0 * NON-MCP READ ONLY 33317000 + FROM CODE FILE 33318000 + 0 1 1 * NOT USED 33319000 + 1 0 0 >1 NOT USED 33320000 + 1 0 0 0 MCP GET OLAYABLE SPACE 33321000 + 1 0 0 1 MCP GET SAVE SPACE 33322000 + 1 0 1 * MCP.AIT REFERENCE 33323000 + 1 1 0 * MCP READ ONLY 33324000 + FROM CODE FILE 33325000 + 1 1 1 * ADDRESS IS THAT OF IOCB 33326000 + SOMEBODY ELSE IS READING 33326100 + IN ARRAY.WAIT ON EVENT IN 33326200 + IOCB. (NOTE THIS IS A 33326300 + SPECIAL COMBINATION WHERE 33326400 + MEANINGS OF INDIVIDUAL 33326500 + BITS DO NOT APPLY). 33326600 + *****SEGMENT DESCRIPTORS ***** 33327000 + INTERPRETATION 33328000 +FIELD DICTIONARYF LOCKBITF ADDRESSF 33329000 +BITS 45:1 44:1 19:20 33330000 + 1 0 * DO DICTIONARY READ IN 33331000 + OVERLAYABLE PROGRAM FROM 33332000 + MCP CODE FILE 33333000 + 0 0 * D1 DICTIONARY.READ IN 33334000 + OVERLAYABLE FROM PROGRAM 33335000 + CODE FILE 33336000 + 0 1 * ) ADDRESS IS THAT OF IOCB 33337000 + 1 1 * ) SOMEBODY ELSE IS READING 33338000 + IN PROGRAM. WAIT ON EVENT 33339000 + IN IOCB 33340000 + DD FORMAT TO BE DETERMINED NON OLAYABLE FROM OLAY FILE 33343000 + DD FORMAT TO BE DETERMINED NON OLAYABLE FROM CODE FILE 33344000 + SD >1 * 0 READ IN OVERLABLE PROGRAM 33345000 + SD >1 * 1 READ NON OVERLAYABLE PROGRAM33346000 + ; 33347000 + TI1~MOM.LENGTHF; 33348000 +COMMENT *** MAYBE WE SHOULD CALL GETAREA SOMETIMES; 33349000 + TI2 ~GETSPACE 33350000 + ( TI1 ~(IF KIND=SEGDESC 33351000 + THEN TI1 33352000 + ELSE IF MOM.SZF = 1 33353000 + THEN TI1 | 2 33354000 + ELSE IF TI3~ MOM.SZF= 0 33355000 + THEN TI1 33356000 + ELSE (TI1 ~ (IF TI3 = 4 THEN 33357000 + (TI3~6) - 1 33358000 + ELSE IF TI3 = 3 THEN 33359000 + (TI3~8) - 1 33360000 + ELSE (TI3~12) - 1)) 33361000 + DIV TI3) 33362000 + , MYSNR 33363000 + ,0&SPACETYPE (1,1,1, 33364000 + REAL(NOT ( KIND = DATADESC AND REAL(MOM).ADDRESSF = 1))) 33365000 + 33366000 + ,MOMLOCATION 33367000 + ); 33368000 + IF KIND = SEGDESC OR MOM.ADDRESF > 1 OR 33369000 + MOM.DESCRIPTORLOCKF = 2 THEN 33369100 + 33370000 + BEGIN COMMENT MCS 6; 33371000 +IF(KIND=SEGDESC AND MOM.DICTIONARYF=1) OR 33372000 + (KIND=DATADESC AND MOM.MCPCODEF=3) 33373000 + THEN TI3 ~ MOM.ADDRESF+MCPDISKBASE 33374000 + ELSE 33375000 + BEGIN 33376000 + DISKADDRESSES~WORDSTACK 33377000 + [IF(OLAY~KIND=DATADESC AND MOM.FILETYPEF=0) 33377500 + THEN MYSNR 33378000 + ELSE WORDSTACK[MYSNR,PROCESSFAMILYLINKPLACE]. 33378500 + FATHERF 33378502 + , IF OLAY 33379000 + THEN OLAYFILEDESCRIPTORPLACE 33379500 + ELSE D1CODEFILEDESCPLACE 33380000 + ]; 33380800 + 33381000 + TI3~DISKADDRESSES 33382000 + [FIRSTROWINDEX + (TI3 := MOM.ADDRESF) 33383000 + DIV(IF OLAY THEN OLAYROWLENTH ELSE CODEROWLENTH)33384000 + ] 33385000 + +TI3 MOD(IF OLAY THEN OLAYROWLENTH ELSE CODEROWLENTH)33386000 + ; 33387000 + 33388000 + END; 33389000 + IOCW ~ @440 + REAL(KIND = SEGDESC); 33390000 + RESET(EVNN); 33391000 + DISKADDRESSES~DISKADDRESSES&ARRAYDESCL(3,TI1,TI2); 33392000 + MOM~MOM&POINTTOIOCB(*, 33393000 + WORD(DISKIO(DISKADDRESSES,-1,TI1,TI3,IOCW,EVNN))); 33394000 + M[MOMLOCATION]~MOM 33394100 + ~IF KIND=SEGDESC THEN MOM&LOKMOM(1,*) 33394200 + ELSE MOM&LOKMOM(*,7); 33394300 + UNLOCK(PBLOK); 33396000 + WAIT (EVNN); 33397000 + TI3 ~ MOM.ADDRESSF; 33398000 + 33399000 +TOSLEEP: NOCHANGE~ TRUE; 33400000 + BUZZCONTROL(MULTIPLEREFERENCELOK); COMMENT *** BUZZ; 33401000 + IF BOOLEAN (M[MOMLOCATION].PBITF) 33402000 + THEN BEGIN 33403000 + ALREADYPRESENT ~ TRUE; 33404000 + END; 33405000 + 33406000 + GO TO MOMPRESENT; 33407000 + END MCS 6 33408000 + ELSE BEGIN 33409000 + MOM~MOM&FIXDESC(1,*,TI2); 33410000 + INITIALIZETOZERO (TI2, TI1); 33411000 +COMMENT *** OPTIMISE LATER; 33412000 + GO TO MOMPRESENT; 33413000 + END; 33414000 + END MCS 5; 33415000 +FIN: 33416000 + RETURN(ACTUALCOPY); 33417000 + END MCS 1 PRESENCEBIT; 33418000 + PROCEDURE NOTYETCODED(SPEC); VALUE SPEC; 33419000 + REAL SPEC; COMMENT SPECIFIES MSSING CODE; 33420000 + BEGIN 33421000 +COMMENT MUST IMSERT CODE TO PRINT OUT MESSAGE HERE; 33422000 + KILLME(SPEC); 33423000 + END NOTYETCODED; 33424000 +%%%%% INTERRUPT PROCEDURE OUTER BLOCK CODE %%%% 33425000 +%%%%% %%%% 33426000 +%%%%% %%%% 33427000 +TRACTER~TRACE(0); 33428000 +IF SIMULATING THEN 33428990 + MONITORVALUE~D[31]; 33429000 + P1~P1; COMMENT ***** REDUNDANT- FOR MONITORING; 33430000 +COMMENT 33431000 + IF P1= INTERVALTIMERSPEC AND BUSY(GROSSLOK) 33432000 + THEN GO FINI 33433000 + ELSE IF LOCK(GROSSLOK) THEN KILLME(GROSSLOCK); 33434000 +COMMENT *** ELSE BUZZ(GROSSLOK) LATER; 33435000 +COMMENT GROSSLOK IS NOMINALLY SET AT ENTRY TO INTERRUPT 33436000 + PROCEDURE AND DETERMINES THAT ONLY ONE INTERRUPT33437000 + AT A TIME IS HANDLED. THIS MAY BE A TEMPORARY 33438000 + MEASURE IN WHICH CASE A LOCK LESS POWERFUL THAN 33439000 + GROSSLOK, WHICH PREVENTS OVERLAY ACTION, WILL BE33440000 + USED 33441000 + WHEN AN INTERRUPT GOES THROUGH THE LOCK, IT33442000 + MAY NOT BE INTERRUPTED (FOR HARDWARE OR 33443000 + SOFTWARE REASONS) BY ANYTHING EXCEPT INTERVAL 33444000 + TIMER. HENCE INTERVAL TIMER MUST NOT BUZZ THE 33445000 + LOCK IF IT HAS BEEN SET BY SOMEBODY ELSE- IN 33446000 + THIS CIRCUMSTANCE THE INTERVAL TIMER INTERRUPT 33447000 + IS LOST 33448000 + ; 33449000 + DISABLEOVERLAY; 33450000 +COMMENT THIS SHOULD 33451000 + (1) MAKE THE STACK NON OVERLAYABLE 33452000 + (2) MARK THE STACK APPROPRIATELY 33453000 + AT PRESENT IT DOES NOTHING. NOTE THAT THIS HAS TO MESH IN WITH 33454000 + GENERAL SCHEME FOR HANDLING ABSOLUTE ADDRESSES IN STACKS 33455000 + ; 33456000 + MYF ~ F; 33457000 + MYSNR~SNR; 33458000 +COMMENT *** ABSOLUTE ADDRESS; 33459000 +COMMENT * ** * * * * * * *; CASE P1.MPXFIELD | P1.IFFIELD OF 33460000 + BEGIN COMMENT MCS 2; 33461000 +COMMENT ALL NON MPX INTERRUPTS HERE; 33462000 + CASE P1.SDFIELD|FIRSTONE(P1.INTFIELD) OF 33463000 + 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 + BEGIN COMMENT MCS 3A; 33468000 + IF (COUNTFORTIMERINTERRUPTEVENT~*+1) 33469000 + = NUMBEROFPROCESSORS AND NOT 33470000 + BUSY(READYQ) 33470100 + THEN BEGIN COMMENT MCS 3B; 33471000 + COUNTFORTIMERINTERRUPTEVENT 33472000 + ~0; 33473000 + CAUSE (TIMERINTERRUPTEVENT);33474000 + END MCS 3B; 33475000 + END MCS 3A 33476000 + ELSE IF P1=STACKOVERFLOWSPEC THEN STACKOVERFLOW 33477000 + ELSE IF P1=SYLLABLEDEPNDNT2SPEC THEN 33478000 + SYLLABLEDEPENDENT2 33479000 + ELSE IF P1 } ALARMSPEC THEN ALARM 33480000 + ELSE STOP; 33481000 + MEMORYPROTECT; 33482000 + INVALIDOPERATOR; 33483000 + ARITHMETICFAULT(DZ); COMMENT DIVIDE BY ZERO; 33484000 + ARITHMETICFAULT(EO); COMMENT EXPONENT OVERFLOW; 33485000 + ARITHMETICFAULT(EU); COMMENT EXPONENT UNDERFLOW; 33486000 + ARITHMETICFAULT(II); COMMENT INVALID INDEX; 33487000 + ARITHMETICFAULT(IO); COMMENT INTEGER OVERFLOW; 33488000 + BOTTOMOFSTACK; 33489000 + BEGIN 33490000 + PRESENCEBIT; 33491000 + 33492000 + GO FINI; 33493000 + END; 33494000 + STOP; 33495000 + WHATDOIDO; 33496000 + GO FINI; 33497000 + END MCS 3 SYLLABLE DEPENDENT INTERRUPTS; 33498000 + MLL1; 33499000 + MLL2; 33500000 + MLL3; 33501000 + MLL4; 33502000 + EXTERNALMPX; 33503000 +COMMENT FIRST MPX UNASSIGNED INTERRUPT HANDLED HERE.IN-LINE CODE USED; 33504000 + NOTYETCODED(GCAINTERRUPT); 33505000 +COMMENT OTHER MPX UNASSIGNED INTERRUPTS HANDLED HERE; 33506000 + MPXUNASSIGNED(UA2); 33507000 + MPXUNASSIGNED(UA3); 33508000 +AGAIN: 33508100 + IOFINISH(P1.MPXSPECFIELD); 33509000 +COMMENT SKIP UNUSED BIT POSITIONS IN IFFIELD HERE; 33510000 + ;;;;; 33511000 +COMMENT REST OF THIS PROCEDURE DEVOTED TO IOFINISH. NOTE THE FOLLOWING:33512000 + (1) IOFINISH AND GCA INTERRUPTS ARE HANDLED BY CODE LOCAL33513000 + TO INTERRUPT PROCEDURE . ALL OTHER INTERRUPTS 33514000 + HANDLED BY PROCEDURE CALLS 33515000 + (2) CALLED PROCEDURES ARE DECLARED LOCAL TO THE 33516000 + INTERRUPT PROCEDURE 33517000 + (3) THERE MAY BE DUPLICATION OF CODE IN ORDER TO 33518000 + SPEED THE PROCESSING OF SOME INTERRUPTS 33519000 + ; 33520000 + STOP; 33522000 + END MCS CASE EXPRESSION; 33523000 + IF MULTIPLEXORMASK.BITONEF 33524000 + THEN IF (P1~SCANIN(LITERALFUNCTIONA))!1 33525000 + THEN GO AGAIN; 33526000 + IF MULTIPLEXORMASK.BITTWOF 33527000 + THEN IF (P1~SCANIN(LITERALFUNCTIONB))!2 33528000 + THEN GO AGAIN; 33529000 + WHATDOIDO; 33529100 +FINI: 33530000 + UNLOCK(GROSSLOK); 33531000 + ENABLEOVERLAY; 33532000 +TRACE(TRACTER); 33534998 + IF RTBIT THEN RETURN(ACTUALCOPY); 33535000 + END MCS 1 HARDWAREINTERRUPT; 33537000 + SAVE PROCEDURE WHATDOIDO; 33538000 +COMMENT IF THERE IS SOMETHING OF HIGHER PRIORITY IN THE READYQ THEN 33539000 + FIRE IT UP ELSE EXIT. SIMILAR TO WAIT AND HOLD 33540000 + ; 33541000 + BEGIN 33542000 + LABEL FINI 33543000 + ; 33544000 + REAL MYSNR 33545000 + , NEXTSTACKNO 33546000 + ; 33547000 + MONITOR JACKMONITOR(MYSNR); 33548000 + 33549000 + SETINTERVALTIMER; 33550000 + MYSNR ~ SNR; 33551000 +STACK[MYSNR,PRIORITYPLACE]~0;% *** TAKE OUT WHEN PRIORITY ALGORTHMS OK 33551100 + IF LOCK(READYQ) THEN GO FINIS; % *** WITH NO INTERVAL TIMER 33552000 + % *** PROBLEMS BUZZCONTROL 33552100 +COMMENT ***** SHOULD THIS BE BUZZ; 33553000 + IF NOTHINGTODO 33554000 + THEN GO FINI 33555000 + ELSE IF STACK[NEXTSTACKNO~NEXTSTACKINREADYQ,PRIORITYPLACE]33556000 + }STACK[MYSNR,PRIORITYPLACE] 33557000 + THEN BEGIN 33558000 + INSERTINQ(READYQ,DUMMYREF,MYSNR); 33559000 + MOVETONEXTINREADYQ; 33560000 + END 33561000 + ELSE ; 33562000 + 33563000 +FINI: UNLOCK(READYQ); 33564000 +FINIS: 33564100 + END WHATDOIDO; 33565000 + 33566000 + SAVE PROCEDURE EVENTHANDLER (THEEVENT,EVENTWORD1,WAITFLAG); 33567000 + VALUE EVENTWORD1,WAITFLAG; 33568000 + WORD THEEVENT %IRW OR INDEXED DD POINTING TO EVENT 33569000 + , EVENTWORD1 %FIRST WORD OF EVENT 33570000 + ; 33571000 + BOOLEAN WAITFLAG %TRUE IF WAIT, FALSE IF CAUSE 33572000 + ; 33573000 +COMMENT 33574000 + THE ESPOL INTRINSIC WAIT(WAITFLAG TRUE) OR CAUSE, LOCKS THE EVENT 33575000 + AND PASSES TO THIS PROCEDURE: 33576000 + AN IRW OR INDEXED DD POINTING TO THE EVENT 33577000 + THE FIRST WORD OF THE EVENT (WITH A DOUBLE TAG) 33578000 + A FLAG INDICATING WHETHER CAUSE OR WAIT IS REQUIRED 33579000 + 33580000 + 33581000 + WAIT ACTION: 33582000 + 1) THE INTERVAL TIMER IS RESET 33583000 + 2) IF THE READYQ IS EMPTY, THE NOTHING TO DO LOOP IS 33584000 + ENTERED. IN THE NOTHING TO DO LOOP: 33585000 + A THE READYQ IS BUZZED 33586000 + B IF READYQ NON EMPTY THEN GO TO 3 33587000 + C IF EVENT HAS HAPPENED,UNLOCK READYQ,E GO TO 4 33588000 + D OTHERWISE CALL STATUS AND GO TO A 33589000 + 3) IF THE READYQ IS NOT EMPTY 33590000 + A PUT THIS PROCESS IN EVENT QUEUE 33591000 + B UNLOCK EVENT (BY REPLACING FIRST WORD OF EVENT) 33592000 + C UNLOCK READYQ 33593000 + D MOVE TO NEW JOB 33594000 + E ON RETURN PROCESS ANY OUTSTANDING SOFTWARE 33595000 + INTERRUPTS 33596000 + 4) EXIT 33597000 + CAUSE ACTION 33598000 + 1) MOVE WAITQ TO READYQ 33599000 + 2) CHECK SOFTWARE INTERRUPT COUNT IN FIRST WORD OF EVENT 33600000 + IF ZERO GO TO OTHERWISE 33601000 + 3) FOR EACH STACK IN INTERRUPT QUEUE IN TURN 33602000 + A BUZZ SOFTWAREINTERRUPTLOCK 33603000 + B IS THE INTERRUPT ENABLED,IF NOT GO TO NEXT STACK33604000 + C OTHERWISE ENTER INTERRUPT IN SOFTWAREINTERRUPTQ 33605000 + D IF STACK ACTIVE THEN DO A HEYOU 33606000 + E UNLOCK SOFTWARE INTERRUPT LOCK 33607000 + 4) UNLOCK AND SET THE EVENT 33608000 + ; 33609000 + BEGIN 33610000 + LABEL LOOKFORNEWPROCESS 33611000 + , LOOKFORANOTHER 33612000 + ; 33613000 + EVENT THISEVENT=THEEVENT 33614000 + ; 33615000 + DEFINE NEXTINTERRUPTPCW = 33616000 + STACK[(NEXTSNR~NEXTSTACK.STKNRF), 33617000 + DISPPCW~NEXTSTACK.DISPF+NEXTSTACK.SIRWDELTAF]# 33618000 + 33619000 + 33620000 + ,UNLOCKEVENT=THEEVENT~EVENTWORD1&FIRSTEVENTWORD(,*,*,33621000 + *,*,*,0)# 33622000 + , PROCESSINHOLD = REFERENCE(WORD(NEXTSNR))# 33623000 + , EVENTWAITQ= EVENTWORD1 # 33624000 + ; 33625000 + WORD EVENTPOINTER=THEEVENT %PREVENTS PARAMETER ACTION 33626000 + , NEXTSTACK 33627000 + , INTERRUPTPOINTER 33628000 + ; 33629000 + REAL INTERRUPTQCOUNT 33630000 + , NEXTSNR 33631000 + , DISPPCW = NEXTSTACK 33632000 + , MYSNR 33633000 + ; 33634000 + REFERENCE REFERENCEINTERRUPTPOINTER=INTERRUPTPOINTER 33635000 + ; 33636000 + MONITOR JACKMONITOR(WAITFLAG); 33637000 +INTEGER IDLETI, REALTI; 33638000 +MONITOR DONMONITOR (REALTI, IDLETI); 33639000 + MYSNR~SNR; 33640000 +IF SIMULATING THEN BEGIN 33641100 +WAITFLAG ~ *; 33641200 +REALTI ~ REGISTERS[61]; 33642000 +IDLETI ~ REGISTERS[62]; 33643000 +END; 33643100 + IF WAITFLAG 33644000 + THEN 33645000 + BEGIN%%%%%%%%%%%%%%% %%%MCS 133646000 + % WAIT PROCESSING 33647000 + SETINTERVALTIMER; 33649000 + IF BOOLEAN(EVENTWORD1.HAPPENEDBITF) 33649100 + THEN BEGIN UNLOCKEVENT;GO FINI;END; 33649200 +LOOKFORNEWPROCESS: BUZZCONTROL(READYQ); 33650000 +COMMENT ***** SHOULD THIS BE BUZZ; 33651000 + IF NOTHINGTODO 33652000 + THEN 33653000 + BEGIN%%%%%%%%%%%%%%% %%%MCS 233654000 + % READYQ EMPTY 33655000 + UNLOCK(READYQ); 33655100 + UNLOCKEVENT; 33656000 + 33657000 + 33658000 +COMMENT *** 33659000 + ALLOW; 33660000 +COMMENT * * * * SIMULATOR ONLY; PAUSE; 33661000 + DISALLOW; 33662000 + IF HAPPENED(THISEVENT) 33663000 + THEN 33664000 + BEGIN%%%%%%%%%%%%%%% %%%MCS 333665000 + % CLEAN UP AND GET OUT 33666000 + UNLOCK(READYQ); 33667000 + 33668000 +COMMENT THE EVENT IS UNLOCKED WITH FIRST 33669000 + WORD RESTORED; 33670000 + END %%%%%%%%%%%%%%% %%%MCS 333671000 + ELSE LOOKFORSOMETHING; 33672000 + END %%%%%%%%%%%%%%% %%%MCS 233682000 + ELSE 33683000 + BEGIN%%%%%%%%%%%%%%% %%%MCS 533684000 + % SEND PROCESS TO SLEEP 33685000 + WORDSTACK[MYSNR,EVENTWAITQLINK] 33686000 + .FULLINDICATORF~1; 33687000 + IF EVENTWORD1.WAITQHEADF=0 33688000 + THEN 33689000 + %%%%%%%%%%%%%%%%%%%% %%%%%%% 33690000 + %FIRST IN QUEUE 33691000 + EVENTWORD1.WAITQHEADF~MYSNR 33692000 + ELSE 33693000 + BEGIN%%%%%%%%%% %%%MCS5133694000 + % SECOND AND SUBSEQUENT IN QUEUE 33695000 + 33696000 +WORDSTACK[MYSNR,EVENTWAITQLINK].BACKWARDLINKF~EVENTWORD1.WAITQTAILF; 33697000 +WORDSTACK[EVENTWORD1.WAITQTAILF,EVENTWAITQLINK].FORWARDLINKF~MYSNR; 33698000 + 33699000 + 33700000 + 33701000 + END; %%%%%%%%%% %%%MCS5133702000 + EVENTWORD1.WAITQTAILF~MYSNR; 33703000 + UNLOCKEVENT; 33704000 + MOVETONEXTINREADYQ; 33705000 +COMMENT A READYQ ALGORITAM:DELINKS,UNLOCKS,MOVES; 33706000 +COMMENT AT THIS POINT WE LOSE CONTROL SOME LOGGING 33707000 + ACTION IS REQUIRED; 33708000 +LOOKFORANOTHER: IFTHEREISASOFTWAREINTERRUPT 33709000 + THEN 33710000 + BEGIN%%%%%%%%%%%%%%% %%%MCS 633711000 + HANDLETHESOFTWAREINTERRUPT; 33712000 + GO LOOKFORANOTHER; 33713000 + END %%%%%%%%%%%%%%% %%%MCS 633714000 + END %%%%%%%%%%%%%%% %%%MCS 533715000 + END %%%%%%%%%%%%%%% %%%MCS 133716000 + ELSE 33717000 + BEGIN%%%%%%%%%%%%%%% %%%MCS 733718000 + % CAUSE PROCESSING 33719000 + IF EVENTWORD1.WAITQHEADF!0 33720000 + THEN 33721000 + BEGIN%%%%%%%%%%%%%%% %%%MCS 833722000 + BUZZCONTROL(READYQ); 33723000 + INSERTINQUEUE(WAITI,EVENTWAITQ); 33724000 + UNLOCK(READYQ); 33725000 + END ; %%%%%%%%%% %%%MCS 833726000 +end. end. end. end. end. end. end. end. end. end. end. end. end. end. 99999998140723PK ?END 99999999