ASMB,R,L,C HED @QUE - PARMB SETUP & QUEING SUBR.*(C) HEWLETT-PACKARD CO. 1976* NAM @QUE,6 91705-16101 REV.A 751230 SPC 1 ****************************************************************** * * (C) COPYRIGHT HEWLETT-PACKARD COMPANY 1976. ALL RIGHTS * * * RESERVED. NO PART OF THIS PROGRAM MAY BE PHOTOCOPIED, * * * REPRODUCED OR TRANSLATED TO ANOTHER PROGRAM LANGUAGE WITHOUT* * * THE PRIOR WRITTEN CONSENT OF HEWLETT-PACKARD COMPANY. * ****************************************************************** SPC 1 * * @QUE * SOURCE: 91705-18101 REV.A * BINARY: 91705-16101 REV.A * JIM HARTSELL * AUG. 14, 1974 * MODIFIED BY: C.C.H. (12-30-75]) [DERIVED FROM: 91705-18001 REV.B] * * RE-ENTRANT SUBROUTINE FOR RTE-C SATELLITE * RESIDENT LIBRARY. * * CALLING SEQUENCE: (CALLED BY @REFA) * * JSB @QUE * OCT FCN CODE * OCT USER CALL ADDRESS * DEF PARMB BUFFER * DEF REPLY BUFFER * DEF DATA ADDR (RETURNED) * DEF DATA LENGTH (RETURNED) * DEF PARMB LENGTH (RETURNED) * ERROR RETURN (REQUEST REJECTED) * NORMAL RETURN (REQUEST ACCEPTED) * * FOR ERROR RETURN: FLAG WORD = "REPLY RECEIVED" * (A) = -1 QUEUE IS FULL (RFA BUSY), (B)=0. * (A) = 0 ERROR CODE IN REPLY BUFFER AND * (B) = ASSIGNED QUEUE ENTRY ADDR. * * FOR NORMAL RETURN: FLAG WORD = "PARMB READY" * (B) = ADDR OF ASSIGNED QUEUE ENTRY. * ENT @QUE,%DORM,%ACT,%LU,%CPFL,%TIME * EXT $LIBR,$LIBX,@DEQ * A EQU 0 B EQU 1 * **************************************** * * BEGIN TEMPORARY DATA BLOCK. * TDB NOP DEC 19 LENGTH OF BLOCK. RETRN NOP RETURN ADDR OF CALLER. TEMP1 NOP TEMPORARY DATA. TEMP2 NOP TEMP3 NOP QENT NOP ADDR OF CURRENT QUEUE ENTRY. P.PTR NOP USER CALL PARAM POINTER. B.PTR NOP PARMB RELATIVE BYTE POINTER. U.PTR NOP PTR TO CALLER RETURN PARAMS. STREM NOP STREAM TYPE. TTAGA NOP TIME-TAG ADDRESS. * PASSED PARAMETERS: FCN NOP FUNCTION CODE. CALL NOP ADDR OF USER CALL. PARMB NOP ADDR OF PARMB AREA. REPLY NOP ADDR OF REPLY BUFFER AREA. DADR NOP DATA ADDRESS. DLEN NOP DATA LENGTH. PLEN NOP PARMB LENGTH. * * END OF TEMPORARY DATA BLOCK. * **************************************** * * @QUE NOP ENTRY POINT. * JSB $LIBR SAVE TEMPORARY DATA. DEF TDB * JSB $LIBR DISABLE INTERRUPT SYSTEM. NOP * LDB PAV FETCH PARAMETERS. STB TEMP1 LDB MD7 LOOP LDA @QUE,I STA TEMP1,I ISZ @QUE ISZ TEMP1 INB,SZB JMP LOOP LDA PARMB GET PARAMETER BUFFER ADDRESS. ADA D33 FORM TIME-TAG-ENTRY ADDRESS. STA TTAGA SAVE THE ADDRESS IN THE TDB. * LDA @QUE STA RETRN SET RETURN ADDRESS. * * CLEAN OUT DEAD QUEUE ENTRIES. * LDA %ACT HEAD OF ACTIVE LIST. SCAN LDA A,I ADDR OF NEXT QUEUE ENTRY. SZA,RSS JMP LOCAT QUIT IF DONE. * STA TEMPX SAVE ADDR OF QUEUE ENTRY. ADA B2 GET IT'S ID SEG ADDR. LDB A,I CPB XEQT,I SAME AS CURRENT PROG? JMP DEAD YES. GO KILL THE ENTRY. * ADB D15 NO. GET PROGRAM STATUS. STB TEMP2 LDA B,I AND B17 SZA JMP ALIVE PROGRAM IS SCHEDULED. * LDA TEMP2 PROG DORMANT. CHECK ADA B2 IF IN TIME LIST. LDA A,I ALF,SLA JMP ALIVE IN TIME LIST. * DEAD JSB $LIBX INTERRUPTS BACK ON. DEF *+1 DEF *+1 * JSB @DEQ PROG DEAD. KILL IT'S ENTRY. TEMPX NOP QUEUE ENTRY ADDRESS. B1 OCT 1 * NOP JSB $LIBR INTERRUPTS BACK OFF. NOP * ALIVE LDA TEMPX GO TO NEXT ENTRY. JMP SCAN * * ***** QUEUE THE NEW REQUEST ***** * REMOVE THE LAST ENTRY FROM THE DORMANT LIST AND * LINK IT TO THE END OF THE ACTIVE LIST IN THE * PARMB QUEUE. EXIT FROM THE PRIVILEDGED CODE WITH * (A) = 0 IF NEW ENTRY WAS ADDED, OR * (A) = -1 IF ACTIVE LIST FULL (RFA BUSY). * LOCAT CLB (INTERRUPTS STILL OFF) STB QENT SET FOR "NONE ASSIGNED". CCA QUEUE IS FULL IF DORMANT LIST LDB .DORM IS EMPTY. SZB,RSS JMP Q1 REJECT WITH A = -1. * LDA %ACT FIND LAST ENTRY IN CLB ACTIVE LIST. JSB FIND * STB TEMP1 SAVE ADDR OF LAST ACTIVE ENTRY. * LDA %DORM FIND LAST ENTRY IN JSB FIND DORMANT LIST. * STB TEMP1,I LINK INTO ACTIVE LIST. STB QENT SAVE ADDRESS IN TDB. CLB STB A,I DELETE ENTRY FROM DORMANT LIST. LDA QENT CLEAR FLAG WORD IN NEW ENTRY. INA STB A,I * CLA EXIT WITH (A) = 0 Q1 JSB $LIBX ENABLE INTERRUPT SYSTEM. DEF *+1 DEF *+1 * SSA JMP REJCT REJECT IF QUEUE IS FULL: (A)=-1. * * ENTER PARAMETERS INTO QUEUE ENTRY. * LDA QENT ENTRY ADDRESS (WORD 1) ADA B2 STA TEMP1 ADDR OF WORD 3. * LDB XEQT,I MOVE ID SEGMENT ADDR. STB TEMP1,I ISZ TEMP1 * ADB B6 MOVE PRIORITY. LDA B,I STA TEMP1,I ISZ TEMP1 * ADB B6 MOVE PROGRAM NAME. STB TEMP2 LDB MD3 JSB MOVE * LDA PAV MOVE FUNCTION CODE. LDB A,I STB TEMP1,I ISZ TEMP1 * INA MOVE ADDR OF USER CALL. LDB A,I STB TEMP1,I ISZ TEMP1 * ADA B2 MOVE REPLY BUFR ADDR. LDB A,I STB TEMP1,I ISZ TEMP1 * DLD %TIME GET CURRENT TIME (RTE-II STYLE) DST TEMP1,I INSERT INTO QUEUE ENTRY, DST TTAGA,I AND INTO PARAMETER BUFFER. * * INITIALIZE PARMB: STREAM, SUB-STREAM, FUNCTION CODE. * LDA FCN DETERMINE STREAM TYPE. CLB CPA D9 JMP SST GETLU STREAM = 0. INB CPA D10 JMP SST DLIST STREAM = 1. ADB B2 SZA,RSS JMP SST PROGL STREAM = 3. INB ADA MD5 SSA JMP SST PTOPC STREAM = 4. INB CPA D158 JMP SST DEXEC STREAM = 5. INB ADA MD158 SSA JMP SST RFA STREAM = 6. INB OPCMD STREAM = 7. SST STB STREM LDA BIT11 IOR 1 STA PARMB,I STORE STREAM TYPE. ISZ PARMB * LDA QENT STA PARMB,I SUB-STREAM (QUEUE ENTRY ADDR). ISZ PARMB * LDA FCN STA PARMB,I FUNCTION CODE. ISZ PARMB * * INITIALIZE DYNAMIC POINTERS. * LDA CALL ADDR OF USER CALL RETURN ADDR. INA STA P.PTR POINTER TO USER CALL PARAMETERS. * LDA B2 STA B.PTR PARMB BYTE POINTER. * LDA UPARM ADDR OF CALLER RETURN PARAMS. STA U.PTR * LDA STREM SZA,RSS CHECK FOR GETLU. JMP PTP2 * CPA B4 CHECK FOR PTOPC. JMP .PTOP * CPA B1 CHECK FOR DLIST. JMP .DLST * CPA B3 CHECK FOR DOWN-LOAD. JMP .DNLD * CPA B7 CHECK FOR REMOTE CONTROL. JMP .RMCN * * STORE SPARE WORD, DATA FLAG = 0. * LDA B202L STA PARMB,I 202*000 ISZ PARMB ALF,ALF STA PARMB,I 000*202 ISZ PARMB CLA STA PARMB,I 000*000 * * PERFORM COMMON PARMB ENTRY STORAGE ACCORDING TO * CLASS OF CALL (RFA, REXEC). * LDA STREM CPA B6 JMP .RFA * .EXEC JSB GET.P FETCH DESTINATION CODE. AND M377 ALF,ALF POSITION. LDB PARMB ADB MD1 IOR B,I STA B,I STORE IN PARMB. * LDA B202 STORE REQ CODE IN PARMB, JSB STBYT WITH SIGN BIT CLEARED. JSB GET.P ELA,CLE,ERA JSB STWRD * CPA B1 JMP RC1 READ. CPA B2 JMP RC1 WRITE. CPA B3 JMP RC3 I/O CONTROL. CPA D10 JMP RC10 SCHEDULE. CPA D11 JMP RC11 TIME. CPA D12 JMP RC12 EXECUTION TIME. CPA D13 JMP RC13 I/O STATUS. * LDB REPLY ILLEGAL RCODE. ADB B2 LDA AS.RQ STA B,I INB LDA AS.RQ+1 STA B,I JMP REJCT * .RFA LDB P.PTR SET UP POINTER TO CR PARAMETER ADB B4 FOR DCRET,DPURG,DOPEN,DNAME. LDA FCN CPA D151 MOVE DESTINATION PARAM AND JMP .RFA0 FILE NAME TO DCB AREA. INB CPA D158 JMP .RFA0 CPA D152 JMP .RFA0 INB CPA D150 JMP .RFA0 JMP .RFA1 * .RFA0 STB TEMP3 POINTER TO ICR PARAM. JSB MVNAM LDA TEMP3 CHECK IF ICR SPECIFIED. CMA,INA ADA CALL,I ADA MD1 SSA JMP .RFA1 NO. CONTINUE. * LDB TEMP3,I YES. SAVE DESTINATION IN DCB RSS LDB B,I CHASE INDIRECTS. RBL,CLE,SLB,ERB JMP *-2 INB AND CHECK IT. LDB B,I DEST. PARAM. STB TEMP1,I STORE IN DCB (TEMP1 SET BY MVNAM) LDA MD18 SZB JMP MSSNG+1 ILLEGAL. ERROR -18. * .RFA1 LDA FCN DSTAT BYPASS. CPA D162 JMP .RFA2 * JSB STRNG STORE FILE NAME IN PARMB. ISZ P.PTR SKIP OVER IERR PARAM. * .RFA2 LDA FCN ADA MD150 ADA RTBL LDA A,I JMP A,I * RTBL DEF *+1 GO TO UNIQUE PROCESSING FOR DEF .CRET THE PARTICULAR RFA CALLS. DEF .PURG DEF .OPEN DEF .WRIT DEF .READ DEF .POSN DEF .WIND DEF .CLOS DEF .NAME DEF .CONT DEF .LOCF DEF .APOS DEF .STAT * * UNIQUE PROCESSING FOR INDIVIDUAL REMOTE EXEC CALLS. * RC1 JSB INTGR STORE CONTROL WORD. JSB GET.A JSB RPARM STORE BUFFER ADDR. JSB STLEN STORE BUFFER LENGTH. JMP OPT2 * RC3 JSB INTGR STORE CONTROL WORD. JMP OPT1 * RC10 JSB STRNG STORE PROGRAM NAME. JSB OPTN STORE OPTIONAL PARAMS. JSB OPTN JMP OPT3 * RC11 JMP READY * RC12 JSB STRNG STORE PROG NAME. JSB INTGR IRESL JSB INTGR MTPLE JSB INTGR IOFST: CHECK SIGN. SSA JMP READY INITIAL OFFSET VERSION. JSB INTGR MINS JSB INTGR ISECS JSB INTGR MSECS JMP READY ABSOLUTE START TIME VERSION. * RC13 JSB INTGR STORE CONTROL WORD. JMP READY * * UNIQUE PROCESSING FOR INDIVIDUAL RFA CALLS. * .CRET ISZ P.PTR SKIP OVER FILE NAME. LDA B204 STORE 2-WORD SIZE ARRAY. JSB STBYT JSB GET.A STA TEMP3 ISZ TEMP3 LDA A,I JSB STWRD LDA TEMP3,I JSB STWRD JSB INTGR STORE FILE TYPE. JMP OPT2 * .PURG ISZ P.PTR SKIP OVER FILE NAME. JMP OPT2 * .OPEN ISZ P.PTR SKIP OVER FILE NAME. OPT3 JSB OPTN OPT2 JSB OPTN STORE OPTIONAL PARAMS. OPT1 JSB OPTN JMP READY PARMB COMPLETE. * .CLOS EQU OPT1 * .READ JSB GET.A JSB RPARM RETURN DATA BUFR ADDRESS. JSB STLEN STORE LENGTH. JMP OPT2 * .WRIT EQU .READ * .POSN JSB INTGR STORE RECORD NUMBER. JMP OPT1 * .WIND JMP READY * .NAME ISZ P.PTR JSB STRNG STORE NEW NAME. JMP OPT2 * .CONT JSB INTGR STORE CONTROL WORD. JMP OPT1 * .LOCF JMP READY * .APOS JSB INTGR STORE RECORD NUMBER. JMP OPT2 * .STAT JSB GET.A JSB RPARM RETURN DATA BUFR ADDRESS. LDA D124 STORE LENGTH STA PARMB,I IN DATA-FLAG AND JSB RPARM GIVE IT TO CALLER. JMP READY * * PERFORM PARMB ENTRY STORAGE FOR PROGRAM TO PROGRAM * COMMUNICATION. * .PTOP CLA CLEAR SPARE WORDS. STA PARMB,I ISZ PARMB STA PARMB,I ISZ PARMB LDA FCN FOR POPEN, MOVE PROG NAME CPA B1 TO PCB AREA. JSB MVNAM * LDA MD3 JSB NWRDS MOVE PCB TO PARMB. * ISZ P.PTR SKIP OVER IERR PARAM. LDB P.PTR MOVE P.PTR TO ITAG PARAM. LDA FCN CPA B4 JMP PTP1 ADB B2 STB P.PTR * PTP1 LDA MD10 MOVE ITAG TO PARMB. JSB NWRDS * LDA FCN IF READ/WRITE, PROCESS CPA B1 BUFFER ADDRESS, LENGTH. JMP PTP2 CPA B4 JMP PTP2 * LDA P.PTR BACK UP TO IBUF PARAM. ADA MD3 STA P.PTR JSB GET.A RETURN DATA BUFFER ADDRESS. JSB RPARM JSB GET.P GET BUFFER LENGTH. JSB RPARM RETURN IT TO CALLER. STA PARMB,I STORE IN PARMB. * PTP2 LDA UPARM POINT TO PLEN PARAM. ADA B2 STA U.PTR * PTP3 LDA D35 RETURN PARMB SIZE. JMP RDY GO DISPATCH. * * PERFORM PARMB ENTRY STORAGE FOR SPECIAL DLIST CALL * (USED ONLY BY REMAC). * .DLST ISZ PARMB SKIP OVER SPARE WORD. JSB GET.A RETURN DATA BUFFER ADDRESS. JSB RPARM JSB GET.P GET BUFFER LENGTH. JSB RPARM RETURN IT TO CALLER. STA PARMB,I STORE IN PARMB. * LDA P.PTR IF NOT NEW REQUEST, ADA B4 LEAVE REST OF PARMB ALONE. LDA A,I LDA A,I SZA JMP PTP3 * ISZ PARMB * LDA MD3 STORE FILTER. JSB NWRDS JSB MVWRD SECURITY. JSB MVWRD LABEL. JSB MVWRD TYPE. JSB MVWRD NEW REQ CODE. * JMP PTP3 * * PERFORM PARMB ENTRY STORAGE FOR SPECIAL DOWN-LINK * LOAD CALL (USED ONLY BY APLDR). * .DNLD LDA PARMB BACK UP PARMB POINTER. ADA MD1 STA PARMB JSB MVWRD STORE STATUS WORD. SZA QUIT OF NOT NEW REQUEST. JMP PTP2 ISZ PARMB SKIP SPARE WORDS. ISZ PARMB ISZ P.PTR ISZ P.PTR LDA MD3 JSB NWRDS MOVE FILE NAME. * CLA CLEAR LABEL, SECURITY. LDB MD4 .DNL STA PARMB,I ISZ PARMB INB,SZB JMP .DNL * JMP PTP2 * * PERFORM PARMB ENTRY STORAGE FOR SPECIAL REMOTE * CONTROL OF CENTRAL (USED ONLY BY REMAC). * .RMCN ISZ PARMB SKIP OVER SPARE WORD. CLA CLEAR REQ/REPLY SWITCH. STA PARMB,I ISZ PARMB JSB MVWRD STORE LEN PARAM. LDA MD19 JSB NWRDS MOVE ASCII COMMAND. JMP PTP2 * * PARMB AND QUEUE ENTRY COMPLETE AND * READY FOR DISPATCHING (WELL...ALMOST). * READY CLA STORE TERMINATION BYTE. JSB STBYT * LDA UPARM POINT TO PLEN PARAM. ADA B2 STA U.PTR * LDA B.PTR COMPUTE PARMB SIZE. ADA MD1 CLE,ERA ADA B6 RDY JSB RPARM RETURN PARMB LENGTH. * LDB QENT INB ADDR OF FLAG WORD. LDA B1 STA B,I "PARMB READY" FLAG. * * EXIT TO CALLER VIA NORMAL RETURN. * LDB QENT ADDR OF ASSIGNED QUEUE ENTRY. JSB $LIBX RESTORE TEMPORARY DATA BLOCK DEF TDB AND RETURN TO CALLER. DEC 1 NORMAL RETURN. * * REQUEST REJECTED DUE TO PARAMETER ERRORS. * MSSNG LDA MD10 NOT ENOUGH OR ERROR IN PARAMS. CLE STORE CODE IN A-REG SLOT LDB STREM FOR RFA/DEXEC; IERR SLOT CPB B4 FOR PTOPC. CCE LDB REPLY ADB B2 SEZ INB STA B,I * * EXIT TO CALLER VIA ERROR RETURN. * REJCT LDB QENT (ZERO IF QUEUE FULL) SZB,RSS WAS A QUEUE ENTRY ASSIGNED? JMP REJ NO. (A) = -1. INB YES, SET FLAG = "REPLY RECEIVED" LDA B3 STA B,I LDB QENT * REJ JSB $LIBX RESTORE TEMP DATA BLOCK. DEF TDB DEC 0 ERROR RETURN. HED @QUE - UTILITY SUBROUTINES. * * MOVE FILE/PROGRAM NAME TO DCB/PCB. * MVNAM NOP JSB GET.A GET DCB/PCB ADDR. STA TEMP1 ISZ P.PTR JSB PCHEK JMP MSSNG JSB GET.A GET FILE/PROG NAME ADDR. STA TEMP2 LDB MD3 MOVE THE NAME. JSB MOVE LDA P.PTR RESET PARAM POINTER. ADA MD3 STA P.PTR JMP MVNAM,I * * MOVE N WORDS. (B) = NEGATIVE WORD COUNT. * (TEMP1) = DESTINATION ADDR * (TEMP2) = SOURCE ADDR * MOVE NOP LDA TEMP2,I STA TEMP1,I ISZ TEMP1 ISZ TEMP2 INB,SZB JMP MOVE+1 JMP MOVE,I * * STORE N-WORD PARAMETER INTO PTOPC WORD-ORIENTED * PARMB (NO CONTROL BYTES). * NWRDS NOP (A)= NEG WORD COUNT. STA TEMP1 JSB PCHEK IS PARAM SPECIFIED? JMP MSSNG NO. JSB GET.A PARAMETER ADDRESS. NWD LDB A,I STB PARMB,I INA ISZ PARMB ISZ TEMP1 JMP NWD JMP NWRDS,I * * SUBROUTINE TO MOVE NEXT PARAMETER VALUE * INTO WORD-ORIENTED PARMB. * MVWRD NOP JSB PCHEK JMP MSSNG JSB GET.P STA PARMB,I ISZ PARMB JMP MVWRD,I * * STORE INTEGER PARAM FROM USER CALL INTO PARMB. * INTGR NOP JSB PCHEK IS THE PARAM SPECIFIED? JMP MSSNG NO. LDA B202 YES, STORE CONTROL BYTE. JSB STBYT JSB GET.P FETCH PARAM VALUE. JSB STWRD STORE IN PARMB. JMP INTGR,I (A) HAS THE VALUE. * * STORE OPTIONAL INTEGER PARAM (IF SPECIFIED) FROM * USER CALL INTO PARMB. * OPTN NOP JSB PCHEK IS PARAM SPECIFIED? JMP OPTN,I NO (LEAVE P.PTR ALONE). JSB INTGR YES, STORE IT. JMP OPTN,I (A) HAS THE VALUE. * * STORE 6 CHAR ASCII STRING FROM USER CALL * INTO PARMB. * STRNG NOP JSB PCHEK IS PARAM SPECIFIED? JMP MSSNG NO. * LDA B6 STORE CONTROL BYTE. JSB STBYT LDA MD3 STA TEMP2 WORD COUNTER. JSB GET.A STA TEMP3 STRING START ADDR. * STR LDA TEMP3,I FETCH ASCII CHARACTERS. ALF,ALF JSB STBYT STORE LEFT BYTE. LDA TEMP3,I JSB STBYT STORE RIGHT BYTE. * ISZ TEMP3 BUMP TO NEXT INPUT WORD. ISZ TEMP2 DONE? JMP STR NO. JMP STRNG,I YES, EXIT. * * STORE A-REGISTER CONTENTS INTO NEXT CALLER * RETURN PARAMETER. * RPARM NOP LDB U.PTR,I STA B,I ISZ U.PTR JMP RPARM,I * * STORE USER BUFFER LENGTH IN PARMB, DATA-FLAG, * AND QUEUE ENTRY. * STLEN NOP JSB INTGR STORE IN PARMB. * SZA,RSS JMP MSSNG SPECIFIED, BUT ZERO. SSA,RSS NEGATIVE? JMP STL NO. * CMA,INA YES, MAKE POSITIVE. INA ROUND UP. ERA,CLE,ELA RAR CONVERT TO WORD COUNT. * STL STA PARMB,I STORE IN DATA-FLAG. JSB RPARM PASS BACK TO CALLER. JMP STLEN,I EXIT. * * TEST WHETHER THE USER HAS SPECIFIED * A PARAMETER. * JSB PCHEK * ERROR RETURN (PARAM NOT GIVEN) * NORMAL RETURN * PCHEK NOP LDA P.PTR PARAM ADDR CMA,INA LDB CALL RETURN ADDR ADA B,I ADA MD1 SSA,RSS ISZ PCHEK JMP PCHEK,I * * GET VALUE OF NEXT PARAM IN USER CALL * GET.P NOP JSB GET.A FETCH PARAM ADDR. LDA A,I GET PARAM VALUE. JMP GET.P,I * * GET ADDRESS OF NEXT PARAM IN USER CALL * AND BUMP PARAM POINTER. * GET.A NOP LDA P.PTR,I GET PARAMETER ADDRESS. RSS RESOLVE LDA A,I INDIRECT RAL,CLE,SLA,ERA ADDRESSES. JMP *-2 ISZ P.PTR BUMP PARAM POINTER. JMP GET.A,I * * STORE WORD (IN A-REG) IN PARMB. * STWRD NOP STA TEMP2 SAVE WORD. ALF,ALF JSB STBYT STORE LEFT BYTE. LDA TEMP2 JSB STBYT STORE RIGHT BYTE. LDA TEMP2 RESTORE WORD. JMP STWRD,I RETURN. * * STORE BYTE IN NEXT BYTE OF PARMB. * STBYT NOP (A) = BYTE RIGHT JUSTIFIED. AND M377 ISOLATE NEW BYTE. STA TEMP1 SAVE. LDB B.PTR FORM WORD ADDR OF PARMB. CLE,ERB (E) = LEFT/RIGHT FLAG. ADB PARMB * LDA B,I INSERT NEW BYTE INTO PARMB. SEZ,RSS ALF,ALF AND M377L IOR TEMP1 SEZ,RSS ALF,ALF STA B,I * ISZ B.PTR BUMP RELATIVE BYTE POINTER. JMP STBYT,I RETURN. * * SUBROUTINE TO FIND END OF LIST * IN THE PARMB REQUEST QUEUE. THIS ROUTINE * IS CALLED WITH THE INTERRUPT SYSTEM DISABLED. * ENTRY: (A) = ADDR OF PTR TO TOP OF LIST. * JSB FIND * RETURN: (A) = ADDR OF LAST-1 ENTRY * (B) = ADDR OF ENTRY * FIND NOP * F1 LDB A,I FETCH NEXT ENTRY. SZB,RSS DESIRED ENTRY? JMP F2 YES. STA TEMP2 NO, KEEP TRACK. STB A JMP F1 LOOP. * F2 LDB A ADDR OF LAST ENTRY. LDA TEMP2 ADDR OF LAST-1 ENTRY. JMP FIND,I EXIT. HED @QUE - STORAGE FOR CONSTANTS. XEQT OCT 1717 ID SEG ADDR OF CURRENT PROGRAM. PAV DEF FCN FWA OF PASSED PARAMS. UPARM DEF DADR B2 OCT 2 B3 OCT 3 B4 OCT 4 B6 OCT 6 B7 OCT 7 B17 OCT 17 D9 DEC 9 D10 DEC 10 D11 DEC 11 D12 DEC 12 D13 DEC 13 D15 DEC 15 D33 DEC 33 D35 DEC 35 D124 DEC 124 D150 DEC 150 D151 DEC 151 D152 DEC 152 D158 DEC 158 D162 DEC 162 MD1 DEC -1 MD3 DEC -3 MD4 DEC -4 MD5 DEC -5 MD7 DEC -7 MD10 DEC -10 MD18 DEC -18 MD19 DEC -19 MD150 DEC -150 MD158 DEC -158 B202 OCT 202 B202L OCT 101000 B204 OCT 204 M377 OCT 377 M377L OCT 177400 BIT11 OCT 4000 AS.RQ ASC 2,RQ %LU NOP LU OF REMOTE COMPUTER. %CPFL NOP "CENTRAL-DOWN" FLAG. %TIME OCT 0,0 CURRENT TIME--RTE-II FORMAT. * * ************************* * * REQUEST QUEUE (INTERRUPTS OFF WHEN LIST PTRS CHANGED). * QSIZE EQU 12 %DORM DEF .DORM ADDR OF HEAD OF DORMANT LIST. %ACT DEF .ACT ADDR OF HEAD OF ACTIVE LIST. .DORM DEF RQ1 HEAD OF DORMANT LIST. .ACT NOP HEAD OF ACTIVE LIST. * * QUEUE ENTRY: * * WORD 1 = LINK WORD * WORD 2 = FLAG WORD: 1 = PARMB READY * 2 = PARMB SENT * 3 = REPLY RECEIVED * WORD 3 = ID SEG ADDR OF USER * WORD 4 = PRIORITY OF USER PROGRAM * WORD 5-7= USER PROGRAM NAME * WORD 8 = FUNCTION CODE * WORD 9 = ADDR OF USER CALL +1 * WORD 10 = ADDR OF REPLY BUFFER * WORD11-12=REQUEST TIME-TAGS. * RQ1 DEF RQ2 QUEUE INITIALIZED WITH ALL BSS QSIZE-1 ENTRIES IN DORMANT LIST. RQ2 DEF RQ3 BSS QSIZE-1 RQ3 DEF RQ4 BSS QSIZE-1 RQ4 DEF RQ5 BSS QSIZE-1 RQ5 DEF RQ6 BSS QSIZE-1 RQ6 DEF RQ7 BSS QSIZE-1 RQ7 OCT 0 BSS QSIZE-1 * ************************* * SIZE EQU * END