4;qgYk)48d)|{\͙3ԕR CIj+$od*ɚ0,CseY '\\556 MXTASK) THEY ARE ALSO OFFSET QTAB ; BACKWARDS BY MXTASK. QTAB ; QTAB ; THE FOLLOWING I/O LIST IS zE ERR ; BRANCH TO ERROR PROCESSOR .IFF # ; ERROR BRANCH LOCATION MUST BE SPECIFIED .ENDC .NLIST MEB .ENDM DQSC$ S6: DQSC$ LS2,ER2 .PAGE ; NCKP$ MACRO TO PROHIBIT CHECKPOINTING OF THE CALLING TASK .MACRO NCKP$ .LIST MEB EMT NOCKE .NLIST MEB .ENDM NCKP$ NCKP$ .PAGE ; CKP$ MACRO TO ALLOW CHECKPOINTING OF THE CALLING {.PAGE ; MOVE N ARGUMENTS FROM THE BUF INTO THE CALLING TASKS RECEIVING ADDRE .MACRO PUTA CLER,BUF,NN .LIST MEB .IF NB NN MOV #NN,-(SP) ; PLACE NUMBER OF ARG ON STACK .IFF # ; NUMBER OF ARGUMENTS MUST BE SPECIFIED .ENDC .IF NB BUF MOV #BUF,-(SP) .IFF # ; BUFFER ADDRESS IS A REQUIRED PARAMETER .ENDC EMT PUTE$ ERRM CLER .NLIST MEB .ENDM PUTA | .WORD LUN ; LOGICAL DEVICE NUMBER OR FILE NUMBER .IFF #; LOGICAL UNIT NUMBER MUST BE DEFINED AND BE A POSITIVE NUMBER .ENDC .BYTE PRIR ; CALL PRIORITY .BYTE EXT ; EXIT TYPE .WORD 0 ; CALL ERROR CODE .WORD NRES ; POINTER TO NORMAL RESUME LOCATION AFTER I/O .WORD ERES ; POINTER TO RESUME LOCATION AFTER I/O ERROR .BYTE TMD ; TRANSFER MODE .BYTE FUNC ; FUNCTION .WORD NWD ; NUMBER OF WORDS TO BE TRANSMITTED .WORD 0 ;}USED IFF WHEN OVERLAY TASKS EXISTS. QTAB ; IT PROVIDES FOR THE MAINTENANCE OF A DISK COPY OF THE TASK QTAB ; TABLES, THEREBY PERMITTING RECOVERY AFTER A SHUTDOWN. THE QTAB ; FUNCTION CAN BE ASSUMED TO BE A WRITE(1) ' ANY USER USING A QTAB ; READ(0) WILL RESET THE FUNCTION TO A WRITE. QTAB ; QTAB .IFNZ OVRLAY ; ONLY IF HAVE OVERLAYS QTAB~TASK .MACRO CKP$ .LIST MEB EMT CKPE .NLIST MEB .ENDM CKP$ CKP$ .PAGE ; SGLD$ LOAD TASK SEGMENT .MACRO SGLD$ SGNM,CLER,ERES .LIST MEB .IF NB SGNM MOV #SGNM,-(SP) .IFF ; SEGMENT TITLE MUST BE SPECIFIED .ENDC .IF NB ERES MOV #ERES,-(SP) .IFF ; I/O ERROR RETURN LOCATION MUST BE SPECIFIED .ENDC  PUTA ERR2,BU,2 .PAGE .MACRO IOCL$ IOCL,LUN,BLUN,ERES,NRES,NWD,BUF,EXT,TMD,FUNC,PRIR .LIST MEB .BOUND .IF NB IOCL IOCL: .WORD 1 ; THREAD WORD .IFF ; # ; THE I/O CONTROL LIST SYMBOL MUST BE DEFINED .ENDC .WORD 0 ; CALLING TASK'S NUMBER .IF NB LUN .WORD LUN ; LOGICAL DEVICE NUMBER OR FILE NUMBER .IFF #; LOGICAL ACTUAL NUMBER OF WORDS TRANSMITTED .WORD BUF ; POINTER TO I/O BUFFER .WORD 0 ; SYSTEM VIRTUAL ADDRESS OF I/O BUFFER .WORD 0 ; KPAR6 STORAGE .IF NB BLUN .WORD BLUN ; BACKUP LOGICAL DEVICE NUMBER OR FILE NUMBER .IFF #; BACKUP LOGICAL UNIT NUMBER MUST BE DEFINED AND BE A POSITIVE NUMBER .ENDC .WORD REC ; LOGICAL RECORD NUMBER .BYTE 0 ; AREA NUMBER .BYTE 0 ; NUMBER OF LOGICAL RECORDS TO BE TRANSFERRED .WORD 0 ; CURR .BOUND $TKFLS: .WORD 1 ; THREAD WORD QTAB .BYTE 1,1 ; DEVICE CODE, EXIT TYPE QTAB .WORD 0 ; NO EXIT ROUTINE QTAB .BYTE 0 ; NO ERROR TASK QTAB .BYTE 1 ; DISK PRIORITY QTAB .WORD 0,0 ; ERROR WORD, RESERVED FOR DISCIO QTAB .WORD TKFLBF EMT TST (SP)+ .IF NB CLER BNE CLER .IFF # ; THE CALL ERROR LOCATION MUST BE SPECIFIED .ENDC .NLIST MEB .ENDM SGLD$ SGLD$ SG11,ERR2,ERR3 SG11: .ASCII /SEGNAM/ .PAGE ; MOVE N ARGUMENTS FROM THE CALLING TASKS ADDRESS SPACE INTO BUF .MACRO GETA CLER,BUF,NN .LIST MEB .IF NB NN MOV #NN,-(SP) ; PLACE NUMBER OF ARG ON STACK UNIT NUMBER MUST BE DEFINED AND BE A POSITIVE NUMBER .ENDC .BYTE PRIR ; CALL PRIORITY .BYTE EXT ; EXIT TYPE .WORD 0 ; CALL ERROR CODE .WORD NRES ; POINTER TO NORMAL RESUME LOCATION AFTER I/O .WORD ERES ; POINTER TO RESUME LOCATION AFTER I/O ERROR .BYTE TMD ; TRANSFER MODE .BYTE FUNC ; FUNCTION .WORD NWD ; NUMBERENT RECORD BLOCK NUMBER .WORD 0 ; CURRENT RECORD LENGTH .WORD 0 ; PREVIOUS RECORD BLOCK NUMBER .WORD 0 ; PREVIOUS RECORD LENGTH .WORD 0 ; NEXT RECORD BLOCK NUMBER .WORD 0 ; NEXT RECORD LENGTH .NLIST MEB .ENDM IOCLF$ IOCLF$ TA,3,4,EA,NA,10,BU,2,3,4,24 .PAGE ; OPEN CALL MACRO FOR ROS3.1 .MACRO OPN$ IOCL,CLER,ERES,NRES,ACCS .LIST MEB .IF NB IOCL .IF NB CLER .IF NB NRES MOV #NRES,IOCL+$NR ; SET NORMAL RESUME ; ADDRESS OF BUFFER FOR TRANSFER QTAB .WORD 0,TKFLBF ; 2 WORDS FOR THE ASR'S FROM THE TASK. 5/14/73 TKFLBF: .WORD NDISCS+4 ; FILE ID NUMBER QTAB .BYTE 0 ; USE SPECIFIED SECTOR AND WORD COUNT QTAB $TKFLF: .BYTE 1 ; I/O FUNCTION - WRITE 5/14/73 .WORD 0,0,0 ; RESERVED QTAB .WORD 0 ; RELATIVE START SECTOR .IFF # ; NUMBER OF ARGUMENTS MUST BE SPECIFIED .ENDC .IF NB BUF MOV #BUF,-(SP) ; PLACE BUFFER ADDRESS ON STACK .IFF # ; BUFFER ADDRESS IS A REQUIRED PARAMETER .ENDC EMT GETE TST (SP)+ ; TEST RETURNED CODE .IF NB CLER BNE CLER .ENDC .NLIST MEB .ENDM GETA GETA ERR2,BU,2 ERR2: NOP ERR3: NOP .PAGE ; MOVE N OF WORDS TO BE TRANSMITTED .WORD 0 ; ACTUAL NUMBER OF WORDS TRANSMITTED .WORD BUF ; POINTER TO I/O BUFFER .WORD 0 ; SYSTEM VIRTUAL ADDRESS OF I/O BUFFER .WORD 0 ; KPAR6 STORAGE .BYTE 0 ; ACCESS CONTROL .BYTE 0 ; AREA NUMBER .IF NB BLUN .WORD BLUN ; BACKUP LOGICAL DEVICE NUMBER OR FILE NUMBER .IFF #; BACKUP LLOCATION .ENDC .IF NB ERES MOV #ERES,IOCL+$ER ; SET ERROR RESUME LOCATION .ENDC .IF NB ACCS MOV #ACCS,IOCL+$ACC ; SET ACCESS REQUESTED .ENDC MOV #2,IOCL+$EX ; SET CALL TYPE TO SEQUENTIAL MOV #IOCL,-(SP) EMT OPNE$ MOV (SP)+,IOCL+$ERWD ; SAVE RETURNED CODE IN LIST BEQ . + 4 JMP CLER ; JUMP TO ERROR ROUTINE .IFF # ; THE FIRST TWO MACRO PARAMETERS MUST BE DEFINED .ENDC .IFF # ; THE FIRST TWO MACRO PARAMETERS MUST BE DEFINED QTAB .WORD $TKFLN ; NUMBER OF WORDS TO TRANSFER QTAB .ENDC QTAB ; QTAB ; QTAB TASKS: .WORD NLTASK ; LARGEST TASK NUMBER CURRENTLY IN SYSTEQTAB ; QTAB ; NOTE: ROS WI ARGUMENTS FROM THE BUF INTO THE CALLING TASKS RECEIVING ADDRE .MACRO PUTA CLER,BUF,NN .LIST MEB .IF NB NN MOV #NN,-(SP) ; PLACE NUMBER OF ARG ON STACK .IFF # ; NUMBER OF ARGUMENTS MUST BE SPECIFIED .ENDC .IF NB BUF MOV #BUF,-(SP) .IFF # ; BUFFER ADDRESS IS A REQUIRED PARAMETER .ENDC EMT PUTE TST (SP)+ ; TEST RETURNED CODE .IF NB CLOGICAL UNIT NUMBER MUST BE DEFINED AND BE A POSITIVE NUMBER .ENDC .NLIST MEB .ENDM IOCL$ AA: IOCL$ TD,3,4,EA,NA,10,BU,2 .PAGE ; I/O CONTROL LIST MACRO FOR ROS3.1 .MACRO IOCLF$ IOCL,LUN,BLUN,ERES,NRES,NWD,BUF,EXT,TMD,FUNC,PRIR,REC .LIST MEB .BOUND .IF NB IOCL IOCL: .WORD 1 ; THREAD WORD .IFF ; # ; THE I/O CONTROL LIST SYMBOL MUST BE DEFINED .END.ENDC .NLIST MEB .ENDM OPN$ START: OPN$ TA,CALER,EORS,NRRS,3 .PAGE ; CLOSE CALL MACRO FOR ROS3.1 .MACRO CLS$ IOCL,CLER,ERES,NRES .LIST MEB .IF NB IOCL .IF NB CLER .IF NB NRES MOV #NRES,IOCL+$NR ; SET NORMAL RESUME LOCATION .ENDC .IF NB ERES MOV #ERES,IOCL+$ER ; SET ERROR RESUME LOCATION .ENDC MOV #IOCL,-(SP) ; PLACE LIST ADDRESS ON STACK EMT CLSE$ MOV (SP)+,IOCL+$ERWD ; SAVE RETURNED CODE IN LIST BEQ . + 4 JMP CLL BE CONSIDERED TASK 0 ; QTAB HEADER = . ; TASK HEADER ADDRESS (THREAD WORDS) . = .+TASMAX+TASMAX+2 ; TABLE ; QTAB .IFNZ OVRLAY ; ONLY IF HAVE OVERLAY TASKS QTAB IFD = .-MXTASK-MXTASK ; TASK FILE DIRECTORY NUMBER . = .+MAXOVR+MAXOVR+2 ; HERE SINCE IT IS A FULL WOER BNE CLER .ENDC .NLIST MEB .ENDM PUTA PUTA ERR2,BU,2 .PAGE .MACRO IOCL$ IOCL,LUN,BLUN,ERES,NRES,NWD,BUF,EXT,TMD,FUNC,PRIR .LIST MEB .BOUND .IF NB IOCL IOCL: .WORD 1 ; THREAD WORD .IFF ; # ; THE I/O CONTROL LIST SYMBOL MUST BE DEFINED .ENDC .WORD 0 ; CALLING TASK'S NUMBER .IF NB LUN .WORD C .WORD 0 ; CALLING TASK'S NUMBER .IF NB LUN .WORD LUN ; LOGICAL DEVICE NUMBER OR FILE NUMBER .IFF #; LOGICAL UNIT NUMBER MUST BE DEFINED AND BE A POSITIVE NUMBER .ENDC .BYTE PRIR ; CALL PRIORITY .BYTE EXT ; EXIT TYPE .WORD 0 ; CALL ERROR CODE .WORD NRES ; POINTER TO NORMAL RESUME LOCATION AFTER I/O .WORD ERES LER ; JUMP TO ERROR ROUTINE .IFF # ; THE FIRST TWO MACRO PARAMETERS MUST BE DEFINED .ENDC .IFF # ; THE FIRST TWO MACRO PARAMETERS MUST BE DEFINED .ENDC .NLIST MEB .ENDM CLS$ AJ: CLS$ TA,CALER,EORS,NRRS .PAGE ; INPUT CALL MACRO FOR ROS3.1 .MACRO INP$ IOCL,CLER,LUN,BLUN,ERES,NRES,NWD,BUF,EXT,MOD,PRI,REC .LIST MEB .IF NB IOCL .IF NB CLER .IF NB LUN MOV #LUN,IOCL+$LUN ; SET LOGICAL UNIT NUMBER .ENDC .IF NB BLUN MOV #BLUN,RD TABLE ; QTAB .ENDC ; QTAB TSTAT = . ; TASK STATUS TABLE . = .+TASMAX+1 TSTAT2: ;BIT SET ORIENTED TASK STATUS TABLE S64 ;EXTENSION FOR ROS 3.1 S64 .BLKB TASMAX+1 ; S64 LUN ; LOGICAL DEVICE NUMBER OR FILE NUMBER .IFF #; LOGICAL UNIT NUMBER MUST BE DEFINED AND BE A POSITIVE NUMBER .ENDC .BYTE PRIR ; CALL PRIORITY .BYTE EXT ; EXIT TYPE .WORD 0 ; CALL ERROR CODE .WORD NRES ; POINTER TO NORMAL RESUME LOCATION AFTER I/O .WORD ERES ; POINTER TO RESUME LOCATION AFTER I/O ERROR .BYTE TMD ; TRANSFER MOD ; POINTER TO RESUME LOCATION AFTER I/O ERROR .BYTE TMD ; TRANSFER MODE .BYTE FUNC ; FUNCTION .WORD NWD ; NUMBER OF WORDS TO BE TRANSMITTED .WORD 0 ; ACTUAL NUMBER OF WORDS TRANSMITTED .WORD BUF ; POINTER TO I/O BUFFER .WORD 0 ; SYSTEM VIRTUAL ADDRESS OF I/O BUFFER .WORD 0 ; KPAR6 STORAGE .IF NB BLUN .WORD BLUN IOCL+$BLU ; SET BACKUP LOGICAL UNIT NUMBER .ENDC .IF NB ERES MOV #ERES,IOCL+$ER ; SET ERROR RESUME LOCATION .ENDC .IF NB NRES MOV #NRES,IOCL+$NR ; SET NORMAL RESUME LOCATION .ENDC .IF NB NWD MOV #NWD,IOCL+$NW ; SET NUMBER OF WORDS TO BE TRANSFERED .ENDC .IF NB BUF MOV #BUF,IOCL+$BUF ; SET POINTER TO DATA BUFFER .ENDC .IF NB EXT MOV #EXT,IOCL+$EX ; SET CALL TYPE .ENDC .IF NB MOD MOV #MOD,IOCL+$MOD ; SET MODE OF TRANSFER S64 IRC: ;NUMBER OF REQUESTS CURRENTLY S64 ;OUTSTANDING ISSUED BY THE TASK. S64 ;"ABORT INHIBIT COUNTER" S64 ;(NOT INCREMENTED FOR NON RESUME S64 ;REQUESTS WITH NON LOCAL L+STS S64 .BLKB TASMAX+1 ; E .BYTE FUNC ; FUNCTION .WORD NWD ; NUMBER OF WORDS TO BE TRANSMITTED .WORD 0 ; ACTUAL NUMBER OF WORDS TRANSMITTED .WORD BUF ; POINTER TO I/O BUFFER .WORD 0 ; SYSTEM VIRTUAL ADDRESS OF I/O BUFFER .WORD 0 ; KPAR6 STORAGE .BYTE 0 ; ACCESS CONTROL .BYTE 0 ; AREA NUMBER .IF NB BLUN .WORD BLUN ; BACKUP LOGICAL DEVICE NUMBER OR FILE NUMBER .IFF #; BACKUP LOGICAL UNIT NUMBER MUST BE DEFINED AND BE A POSITIVE NUMBER .ENDC .WORD REC ; LOGICAL RECORD NUMBER .BYTE 0 ; AREA NUMBER .BYTE 0 ; NUMBER OF LOGICAL RECORDS TO BE TRANSFERRED .WORD 0 ; CURRENT RECORD BLOCK NUMBER .WORD 0 ; CURRENT RECORD LENGTH .WORD 0 ; PR .ENDC .IF NB PRI MOV #PRI,IOCL+$PRI ; SET I/O CALL PRIORITY .ENDC .IF NB REC MOV #REC,IOCL+$REC ; SET RECORDS FIRST BLOCK NUMBER .ENDC MOV #IOCL,-(SP) ; PLACE LIST ADDRESS ON STACK EMT INPE$ MOV (SP)+,IOCL+$ERWD ; SAVE RETURNED CODE IN LIST BEQ . + 4 JMP CLER ; JUMP TO ERROR ROUTINE .IFF # ; THE FIRST TWO MACRO PARAMETERS MUST BE DEFINED .ENDC .IFF # ; THE FIRST TWO MACRO PARAMETERS MUST BE DEFINED .ENDC .NLIST MEB S64 ; QTAB IOSTAT = . ; TASK I/O STATUS TABLE . = .+TASMAX+1 ; QTAB TPRTY = . ; TASK PRIORITY TABLE . = .+TASMAX+1 ; QTAB .IFNZ OVRLAY ; ONLY IF HAVE OVERLAY TAS ; BACKUP LOGICAL DEVICE NUMBER OR FILE NUMBER .IFF #; BACKUP LOGICAL UNIT NUMBER MUST BE DEFINED AND BE A POSITIVE NUMBER .ENDC .NLIST MEB .ENDM IOCL$ AA: IOCL$ TD,3,4,EA,NA,10,BU,2 .PAGE ; I/O CONTROL LIST MACRO FOR ROS3.1 .MACRO IOCLF$ IOCL,LUN,BLUN,ERES,NRES,NWD,BUF,EXT,TMD,FUNC,PRIR,REC .LIST MEB .BOUND .IF NB IOCL IOCL: .WORD 1 ; THREAD WORD .IFF EVIOUS RECORD BLOCK NUMBER .WORD 0 ; PREVIOUS RECORD LENGTH .WORD 0 ; NEXT RECORD BLOCK NUMBER .WORD 0 ; NEXT RECORD LENGTH .NLIST MEB .ENDM IOCLF$ IOCLF$ TA,3,4,EA,NA,10,BU,2,3,4,24 .PAGE ; OPEN CALL MACRO FOR ROS3.1 .MACRO OPN$ IOCL,CLER,ERES,NRES,ACCS .LIST MEB .IF NB IOCL .IF NB CLER .IF NB NRES MOV #NRES,IOCL+$NR ; .ENDM INP$ AB: INP$ TA,CALER,4,5,EORS,NRRS,5,BU,2,1,3,5 .PAGE ; OUTPUT CALL MACRO FOR ROS3.1 .MACRO OUT$ IOCL,CLER,LUN,BLUN,ERES,NRES,NWD,BUF,EXT,MOD,PRI,REC .LIST MEB .IF NB IOCL .IF NB CLER .IF NB LUN MOV #LUN,IOCL+$LUN ; SET LOGICAL UNIT NUMBER .ENDC .IF NB BLUN MOV #BLUN,IOCL+$BLU ; SET BACKUP LOGICAL UNIT NUMBER .ENDC .IF NB ERES MOV #ERES,IOCL+$ER ; SET ERROR RESUME LOCATION .ENDC .IF NB NRES MOV #NRES,IOCL+$NR ; SKS QTAB BSIZE = .-MXTASK ; NUMBER OF MEMORY BLOCKS . = .+MAXOVR+1 AREA = .-MXTASK ; DISC AREA TABLE ;66 ; QTAB SUBQUE: ;SUBSEQUENT REQUEST QUEUE THREAD HEADER S62 .BLKW TASMAX+TASMAX+2 ; S63 RESQUE: ;RESUME REQUEST QUEUE THREAD HEADER S ; # ; THE I/O CONTROL LIST SYMBOL MUST BE DEFINED .ENDC .WORD 0 ; CALLING TASK'S NUMBER .IF NB LUN .WORD LUN ; LOGICAL DEVICE NUMBER OR FILE NUMBER .IFF #; LOGICAL UNIT NUMBER MUST BE DEFINED AND BE A POSITIVE NUMBER .ENDC .BYTE PRIR ; CALL PRIORITY .BYTE EXT ; EXIT TYPE .WORD 0 ; CALL ERROR CODE .WORD NRSET NORMAL RESUME LOCATION .ENDC .IF NB ERES MOV #ERES,IOCL+$ER ; SET ERROR RESUME LOCATION .ENDC .IF NB ACCS MOV #ACCS,IOCL+$ACC ; SET ACCESS REQUESTED .ENDC MOV #2,IOCL+$EX ; SET CALL TYPE TO SEQUENTIAL MOV #IOCL,-(SP) EMT OPNE$ MOV (SP)+,IOCL+$ERWD ; SAVE RETURNED CODE IN LIST BEQ . + 4 JMP CLER ; JUMP TO ERROR ROUTINE ET NORMAT RESUME LOCATION .ENDC .IF NB NWD MOV #NWD,IOCL+$NW ; SET NUMBER OF WORDS TO BE TRANSFERED .ENDC .IF NB BUF MOV #BUF,IOCL+$BUF ; SET POINTER TO DATA BUFFER .ENDC .IF NB EXT MOV #EXT,IOCL+$EX ; SET CALL TYPE .ENDC .IF NB MOD MOV #MOD,IOCL+$MOD ; SET MODE OF TRANSFER .ENDC .IF NB PRI MOV #PRI,IOCL+$PRI ; SET I/O CALL PRIORITY .ENDC .IF NB REC MOV #REC,IOCL+$REC ; SET RECORDS FIRST BLOCK NUMBER .ENDC MOV 62 .BLKW TASMAX+TASMAX+2 ; S63 SUBQK5: .BLKW TASMAX+TASMAX+2; SUBQUE SVA KPAR5 VALUE ;66 RESQK5: .BLKW TASMAX+TASMAX+2; RESQUE SVA KPAR5 VALUE ;66 ; QTAB .=.+2 ; MAKE SURE WORD AVAIL. FOR ROUND UP. QTAB ; QTAB .ENDC .EES ; POINTER TO NORMAL RESUME LOCATION AFTER I/O .WORD ERES ; POINTER TO RESUME LOCATION AFTER I/O ERROR .BYTE TMD ; TRANSFER MODE .BYTE FUNC ; FUNCTION .WORD NWD ; NUMBER OF WORDS TO BE TRANSMITTED .WORD 0 ; ACTUAL NUMBER OF WORDS TRANSMITTED .WORD BUF ; POINTER TO I/O BUFFER .WORD 0 ; SYSTEM VIRTUAL ADDRESS OF I/O BUFFER .IFF # ; THE FIRST TWO MACRO PARAMETERS MUST BE DEFINED .ENDC .IFF # ; THE FIRST TWO MACRO PARAMETERS MUST BE DEFINED .ENDC .NLIST MEB .ENDM OPN$ START: OPN$ TA,CALER,EORS,NRRS,3 .PAGE ; CLOSE CALL MACRO FOR ROS3.1 .MACRO CLS$ IOCL,CLER,ERES,NRES .LIST MEB .IF NB IOCL .IF NB CLER .IF NB NRES MOV #NRES,IOCL+$NR ; SET NORMAL RESUME LOCATION .ENDC #IOCL,-(SP) ; PLACE LIST ADDRESS ON STACK EMT OUTE$ MOV (SP)+,IOCL+$ERWD ; SAVE RETURNED CODE IN LIST BEQ . + 4 JMP CLER ; JUMP TO ERROR ROUTINE .IFF # ; THE FIRST TWO MACRO PARAMETERS MUST BE DEFINED .ENDC .IFF # ; THE FIRST TWO MACRO PARAMETERS MUST BE DEFINED .ENDC .NLIST MEB .ENDM OUT$ AC: OUT$ TA,CALER,5,4,EORS,NRRS,5,BU,2,1,3,5 .PAGE ; I/O MACRO CALL .MACRO IOM$ IOCL,CLER,LUN,ERES,NRES,FCT .LIST MEB .IF NB IOCL .IF VEN ;TAKE CARE OF ODD BYTES .PAGE .SBTTL QUEUE - QUEUE A TASK ;*********************************************************************** ; * ; THERE ARE FOUR QUEUEING SERVICES PROVIDED: ;66 ; QUEUE,QLOCA,QCOMA,QREGA ;66 ; Q U E U E * ; .WORD 0 ; KPAR6 STORAGE .IF NB BLUN .WORD BLUN ; BACKUP LOGICAL DEVICE NUMBER OR FILE NUMBER .IFF #; BACKUP LOGICAL UNIT NUMBER MUST BE DEFINED AND BE A POSITIVE NUMBER .ENDC .WORD REC ; LOGICAL RECORD NUMBER .BYTE 0 ; AREA NUMBER .BYTE 0 ; NUMBER OF LOGICAL RECORDS TO BE TRANSFERRED .WORD 0 ; CURRENT RECORD BLOCK NUMBER .IF NB ERES MOV #ERES,IOCL+$ER ; SET ERROR RESUME LOCATION .ENDC MOV #IOCL,-(SP) ; PLACE LIST ADDRESS ON STACK EMT CLSE$ MOV (SP)+,IOCL+$ERWD ; SAVE RETURNED CODE IN LIST BEQ . + 4 JMP CLER ; JUMP TO ERROR ROUTINE .IFF # ; THE FIRST TWO MACRO PARAMETERS MUST BE DEFINED .ENDC .IFF # ; THE FIRST TWO MACRO PARAMETERS MUST BE DEFINED .ENDC NB CLER .IF NB LUN MOV #LUN,IOCL+$LUN ; SET LOGICAL UNIT NUMBER .ENDC .IF NB ERES MOV #ERES,IOCL+$ER ; SET ERROR RESUME LOCATION .ENDC .IF NB NRES MOV #NRES,IOCL+$NR ; SET NORMAL RESUME LOCATION .ENDC .IF NB FCT MOV #FCT,IOCL+$FCT SET FUNCTION CODE .ENDC MOV #IOCL,-(SP) ; PLACE LIST ADDRESS ON STACK EMT IOE$ MOV (SP)+,IOCL+$ERWD ; SAVE RETURNED CODE IN LIST BEQ . + 4 JMP CLER ; JUMP TO ERROR ROUTINE .IFF # ; THE FIRST TWO * ; PROGRAM IDENTIFICATION. QUEUE - QUEUE A SOFTWARE TASK; * ; CATALOG NUMBER * ; * ; PURPOSE. SUBROUTINE QUEUE IS RESPONSIBLE FOR PLACING A * ; TASK IN THE SPECIFIED PRIORITY THREAD. A TASK CANNOT BE * ; THREADED VIA QUEUE UNLESS IT IS INACTIVE AND THE THREAD WORD * ; IN T .WORD 0 ; CURRENT RECORD LENGTH .WORD 0 ; PREVIOUS RECORD BLOCK NUMBER .WORD 0 ; PREVIOUS RECORD LENGTH .WORD 0 ; NEXT RECORD BLOCK NUMBER .WORD 0 ; NEXT RECORD LENGTH .NLIST MEB .ENDM IOCLF$ IOCLF$ TA,3,4,EA,NA,10,BU,2,3,4,24 .PAGE ; OPEN CALL MACRO FOR ROS3.1 .MACRO OPN$ IOCL,CLER,ERES,NRES,ACCS .LIST MEB .IF .NLIST MEB .ENDM CLS$ AJ: CLS$ TA,CALER,EORS,NRRS .PAGE ; INPUT CALL MACRO FOR ROS3.1 .MACRO INP$ IOCL,CLER,LUN,BLUN,ERES,NRES,NWD,BUF,EXT,MOD,PRI,REC .LIST MEB .IF NB IOCL .IF NB CLER .IF NB LUN MOV #LUN,IOCL+$LUN ; SET LOGICAL UNIT NUMBER .ENDC .IF NB BLUN MOV #BLUN,IOCL+$BLU ; SET BACKUP LOGICAL UNIT NUMBER .ENDC .IF NB ERES MOV #ERE MACRO PARAMETERS MUST BE DEFINED .ENDC .IFF # ; THE FIRST TWO MACRO PARAMETERS MUST BE DEFINED .ENDC .NLIST MEB .ENDM IOM$ .PAGE .MACRO REW$ IOCL,CLER,LUN,ERES,NRES IOM$ IOCL,CLER,LUN,ERES,NRES,REWE$ .ENDM REW$ AD: REW$ TA,CALER,4,EORS,NRRS .PAGE ; FORWARD SPACE RECORD CALL MACRO .MACRO FSR$ IOCL,CLER,LUN,ERES,NRES IOM$ IOCL,CLER,LUN,ERES,NRES,FSRE$ IOM$ IOCL,CLER,LUN,ERES,NRES,BSRE$ .ENDM FSR$ AE: FSR$ TA,CALER,4,EORS,NRRS .PAGE HE PROGRAM HEADER IS EMPTY (NOMINAL VALUE OF 1). THE * ; PROGRAM REQUESTING THE QUEUEING CAN SELECT WHETHER QUEUE * ; RETURNS TO IT OR TO THE TASK DISPATCHER (DSPTCH). THE * ; CALLING PROGRAM MAY ALSO TRANSMIT A ONE WORD ARGUMENT TO * ; THE QUEUED PROGRAM. * ; * ; PROGRAM USAGE. THE ASSEMBLER LINKAGE TO SUBROUTINE * ; NB IOCL .IF NB CLER .IF NB NRES MOV #NRES,IOCL+$NR ; SET NORMAL RESUME LOCATION .ENDC .IF NB ERES MOV #ERES,IOCL+$ER ; SET ERROR RESUME LOCATION .ENDC .IF NB ACCS MOV #ACCS,IOCL+$ACC ; SET ACCESS REQUESTED .ENDC MOV #2,IOCL+$EX ; SET CALL TYPE TO SEQUENTIAL MOV #IOCL,-(SP) EMT OPNE$ MOV (SP)+,IOCL+$ERWD ; SAVE RETURNED CODE IN LIST S,IOCL+$ER ; SET ERROR RESUME LOCATION .ENDC .IF NB NRES MOV #NRES,IOCL+$NR ; SET NORMAL RESUME LOCATION .ENDC .IF NB NWD MOV #NWD,IOCL+$NW ; SET NUMBER OF WORDS TO BE TRANSFERED .ENDC .IF NB BUF MOV #BUF,IOCL+$BUF ; SET POINTER TO DATA BUFFER .ENDC .IF NB EXT MOV #EXT,IOCL+$EX ; SET CALL TYPE .ENDC .IF NB MOD MOV #MOD,IOCL+$MOD ; BACKSPACE RECORD CALL MACRO .MACRO BSR$ IOCL,CLER,LUN,ERES,NRES .ENDM BSR$ AF: BSR$ TA,CALER,4,EORS,NRRS .PAGE ; FORWARD SPACE FILE CALL MACRO .MACRO FSF$ IOCL,CLER,LUN,ERES,NRES IOM$ IOCL,CLER,LUN,ERES,NRES,FSFE$ .ENDM FSF$ AO: FSF$ TA,CALER,4,EORS,NRRS .PAGE ; BACK SPACE FILE CALL MACRO .MACRO BSF$ IOCL,CLER,LUN,ERES,NRES IOM$ IOCL,CLER,LUN,ERES,NRES,BSFE$ .ENDM BSF$ AG: BSF$ TA,CALER,4,EORS,NRRS .PAGE ; WRITE END OF FILE C QUEUE IS: * ; * ; MOV ITASK,-(SP) PUSH * ; MOV IPRTY,-(SP) ARGUMENTS ; MOV IARG,-(SP) ONTO ; MOV IRTRN,-(SP) STACK ; EMT QUEUE THEN CALL QUEUE * ; TST (SP)+ TEST ERROR CODE * BEQ . + 4 JMP CLER ; JUMP TO ERROR ROUTINE .IFF # ; THE FIRST TWO MACRO PARAMETERS MUST BE DEFINED .ENDC .IFF # ; THE FIRST TWO MACRO PARAMETERS MUST BE DEFINED .ENDC .NLIST MEB .ENDM OPN$ START: OPN$ TA,CALER,EORS,NRRS,3 .PAGE ; CLOSE CALL MACRO FOR ROS3.1 .MACRO CLS$ IOCL,CLER,ERES,NRES .LIST MEB .IF NB IOCL .IF NB CLER .IF NB; SET MODE OF TRANSFER .ENDC .IF NB PRI MOV #PRI,IOCL+$PRI ; SET I/O CALL PRIORITY .ENDC .IF NB REC MOV #REC,IOCL+$REC ; SET RECORDS FIRST BLOCK NUMBER .ENDC MOV #IOCL,-(SP) ; PLACE LIST ADDRESS ON STACK EMT INPE$ MOV (SP)+,IOCL+$ERWD ; SAVE RETURNED CODE IN LIST BEQ . + 4 JMP CLER ; JUMP TO ERROR ROUTINE .IFF # ; THE FIRST TWO ALL MACRO .MACRO EOF$ IOCL,CLER,LUN,ERES,NRES IOM$ IOCL,CLER,LUN,ERES,NRES,EOFE$ .ENDM EOF$ AH: EOF$ TA,CALER,4,EORS,NRRS NRRS: NOP ; NORMAL RESUME EORS: NOP ; ERROR RESUME CALER: NOP ; CALL ERROR THRE: .WORD 3 ERRWD: .WORD 240 ; ERROR WORD EA: .WORD 0 NA: .WORD 0 BU: .WORD 0,0,0 .PAGE ; CREATE FILE MACRO .MACRO CF$ LST,CLER .LIST MEB MOV #LST,-(SP) ; PLACE LIST ADDRESS ON STACK EMT Q$ ERPR LST,CLER ; BNE XXX BRANCH IF ERROR WAS ENCOUTNERED * ; * ; THE FORTRAN EQUIVALENT CALL IS: * ; * ; CALL QUEUE( ITASK, IPRTY, IARG, IRTRN, IERR) *QUEU ; * ; ITASK IS THE NUMBER OF THE TASK TO BE QUEUED NRES MOV #NRES,IOCL+$NR ; SET NORMAL RESUME LOCATION .ENDC .IF NB ERES MOV #ERES,IOCL+$ER ; SET ERROR RESUME LOCATION .ENDC MOV #IOCL,-(SP) ; PLACE LIST ADDRESS ON STACK EMT CLSE$ MOV (SP)+,IOCL+$ERWD ; SAVE RETURNED CODE IN LIST BEQ . + 4 JMP CLER ; JUMP TO ERROR ROUTINE .IFF # ; THE FIRST TWO MACRO PARAMETERS MUST BE DEFINED .ENDC MACRO PARAMETERS MUST BE DEFINED .ENDC .IFF # ; THE FIRST TWO MACRO PARAMETERS MUST BE DEFINED .ENDC .NLIST MEB .ENDM INP$ AB: INP$ TA,CALER,4,5,EORS,NRRS,5,BU,2,1,3,5 .PAGE ; OUTPUT CALL MACRO FOR ROS3.1 .MACRO OUT$ IOCL,CLER,LUN,BLUN,ERES,NRES,NWD,BUF,EXT,MOD,PRI,REC .LIST MEB .IF NB IOCL .IF NB CLER .IF NB LUN MOV #LUN,IOCL+$LUN ; SET LOGICAL .NLIST MEB .ENDM CF$ CF$ LST4,CLER4 .PAGE ; CREATE FILE LIST MACRO .MACRO CFL$ LIST,FNA,ERES,NRES,TYP,PROT,AREA,RSIZ,NREC .LIST MEB LIST: .WORD 1 ; THREAD WORD .WORD 0 ; RESERVED .RAD50 /FNA/ ; FILE NAME .BYTE 0 ; PRIORITY .BYTE 2 ; EXIT TYPE .WORD 0 ; ERROR WORD .WORD NRES ; NORMAL RESUME LOCATION .WORD ERES ; ERROR RESUME LOCATION .IF GT TYP .IF GT 5-TYP .BYTE TYP ; FILE TYPE ( * ; IPRTYIS THE PRIORITY LEVEL AT WHICH THE TASK EXECUTES * ; = 0, QUEUE WILL GET THE ASSIGNED PRIORITY FROM THE * ; TASK TABLE * ; > 0, PRIORITY LEVEL SPECIFIED BY CALLING PROGRAM * ; < 0, ILLEGAL * ; IRTRN IS ZERO IF THE CALLING PROGRAM WANTS CONTROL RETURNED * ; TO IT; ONE IF THE DISPATCHER SHOULD E .IFF # ; THE FIRST TWO MACRO PARAMETERS MUST BE DEFINED .ENDC .NLIST MEB .ENDM CLS$ AJ: CLS$ TA,CALER,EORS,NRRS .PAGE ; INPUT CALL MACRO FOR ROS3.1 .MACRO INP$ IOCL,CLER,LUN,BLUN,ERES,NRES,NWD,BUF,EXT,MOD,PRI,REC .LIST MEB .IF NB IOCL .IF NB CLER .IF NB LUN MOV #LUN,IOCL+$LUN ; SET LOGICAL UNIT NUMBER .ENDC .IF NB BLUN MOV #BLUN,IOCL+$BLU ; SEUNIT NUMBER .ENDC .IF NB BLUN MOV #BLUN,IOCL+$BLU ; SET BACKUP LOGICAL UNIT NUMBER .ENDC .IF NB ERES MOV #ERES,IOCL+$ER ; SET ERROR RESUME LOCATION .ENDC .IF NB NRES MOV #NRES,IOCL+$NR ; SET NORMAT RESUME LOCATION .ENDC .IF NB NWD MOV #NWD,IOCL+$NW ; SET NUMBER OF WORDS TO BE TRANSFERED .ENDC .IF NB BUF MOV #BUF,IOCL+$BUF ; SET POINTE1 THRU 4) .IFF # ; THE FILE TYPE MUST BE 1 THRU 4 .ENDC .IFF # ; THE FILE TYPE MUST BE 1 THRU 4 .ENDC .IF GT PROT .IF GT 11-PROT .BYTE PROT ; PROTECTION CODE (1 THRU 8) .IFF # ; THE PROTECTION CODE MUST BE 1 THRU 8 .ENDC .IFF # ; THE PROTECTION CODE MUST BE 1 THRU 8 .ENDC .IF NB RSIZ .WORD RSIZ ; RECORD SIZE .IFF .IF EQ 4-TYP .WORD 0 ; RECORD SIZE .IFF # ; THE RECORD SIZE MUST BE INPUT FOR FILE TYPES 1 TXECUTE THE * ; HIGHEST TASK AFTER REQUEUING THE CALLER; -1 IF THE * S49 ; DISPATCHER SHOULD BE CALLED AFTER SUSPENDING THE CALLER. * S49 ; IARG IS A WORD THAT WILL BE TRANSMITTED TO THE QUEUED TASK * ; IERR IS AN ERROR INDICATOR * ; -1 = TASK QUEUED BUT HAD BEEN ABORTED *QUEU ; 0 = QUEUE SUCCESSFUL * ; 1 = ILLEGAT BACKUP LOGICAL UNIT NUMBER .ENDC .IF NB ERES MOV #ERES,IOCL+$ER ; SET ERROR RESUME LOCATION .ENDC .IF NB NRES MOV #NRES,IOCL+$NR ; SET NORMAL RESUME LOCATION .ENDC .IF NB NWD MOV #NWD,IOCL+$NW ; SET NUMBER OF WORDS TO BE TRANSFERED .ENDC .IF NB BUF MOV #BUF,IOCL+$BUF ; SET POINTER TO DATA BUFFER .ENDC .IF NB EXT MOV #EXT,IOCL+$EX R TO DATA BUFFER .ENDC .IF NB EXT MOV #EXT,IOCL+$EX ; SET CALL TYPE .ENDC .IF NB MOD MOV #MOD,IOCL+$MOD ; SET MODE OF TRANSFER .ENDC .IF NB PRI MOV #PRI,IOCL+$PRI ; SET I/O CALL PRIORITY .ENDC .IF NB REC MOV #REC,IOCL+$REC ; SET RECORDS FIRST BLOCK NUMBER .ENDC MOV #IOCL,-(SP) ; PLACE LIST ADDRESS ON STACK EMT OUTE$ HRU 3 .ENDC .ENDC .WORD NREC ; NUMBER OF RECORDS TO BE ESTABLISHED .NLIST MEB .ENDM CFL$ CFL$ LST4,FIL4,ERE4,NRE4,2,3,1,64,4 CLER4: NOP ERE4: NOP NRE4: NOP .PAGE ; DELETE FILE MACRO .MACRO DF$ LST,CLER .LIST MEB .IF NB LST MOV #LST,-(SP) ; PLACE LIST ADDRESS ON STACK .IFF # ; LIST ADDRESS IS A REQUIRED PARAMETER .ENDC EMT Q$ ERPR LST,CLER .NLIST MEB .ENDM DF$ DF$ LST4,CLER4 .PAGE ; DL TASK THREAD WORD (NOT 1) *QUEU ; 2 = TASK STATUS NOT 0 OR 7(QUIESCENT OR ABORTED *QUEU ; 3 = TASK WAS ABORTED DURING LAST EXECUTION PERIOD, AND * ; I/O IS STILL IN PROGRESS (TASK NOT QUEUED) * ; 4 = TASK DISABLED * ; 5 = ILLEGAL TASK NUMBER * ; 6 = NOT QUEUED SINCE SPECIFIED PRIORITY LEVEL WILL NOT *QUEU ; ; SET CALL TYPE .ENDC .IF NB MOD MOV #MOD,IOCL+$MOD ; SET MODE OF TRANSFER .ENDC .IF NB PRI MOV #PRI,IOCL+$PRI ; SET I/O CALL PRIORITY .ENDC .IF NB REC MOV #REC,IOCL+$REC ; SET RECORDS FIRST BLOCK NUMBER .ENDC MOV #IOCL,-(SP) ; PLACE LIST ADDRESS ON STACK EMT INPE$ MOV (SP)+,IOCL+$ERWD ; SAVE RETURNED CODE IN LIST BEQ . + 4 MOV (SP)+,IOCL+$ERWD ; SAVE RETURNED CODE IN LIST BEQ . + 4 JMP CLER ; JUMP TO ERROR ROUTINE .IFF # ; THE FIRST TWO MACRO PARAMETERS MUST BE DEFINED .ENDC .IFF # ; THE FIRST TWO MACRO PARAMETERS MUST BE DEFINED .ENDC .NLIST MEB .ENDM OUT$ AC: OUT$ TA,CALER,5,4,EORS,NRRS,5,BU,2,1,3,5 .PAGE ; I/O MACRO CALL .MACRO IOM$ IOCL,CLER,LUN,ERES,NRES,FCT .LIST MEB ISABLE SCHEDULER .MACRO MSK$ .LIST MEB EMT MSKE$ .NLIST MEB .ENDM MSK$ MSK$ .PAGE ; ENABLE SCHEDULER .MACRO UMSK$ .LIST MEB EMT UNME$ .NLIST MEB .ENDM UMSK$ UMSK$ .PAGE ; CONVERT FROM BINARY TO ASCII MACRO .MACRO BASC$ BVAL,ASCB .LIST MEB .IF NB BVAL MOV BVAL,-(SP) ; PLACE BINARY INTEGER ON STACK .IFF # ; BINARY INTEGER IS REQUIRED .ENDC .IF NB ASCB MOV #ASCB,-(SP) ; PLACE STRING BUFFER SUPPORT OVERLAY TASKS *QUEU ; 7 = NOT QUEUED SINCE RPOM'S QPART TABLE IS FULL *QUEU ; * ; * ; REGISTERS R1 - R4 ARE USED BY QUEUE AND ARE NOT SAVED UNLESS * ; THE RGSAVE EQUATE PARAMETER IS SET TO 1. * ; ; JMP CLER ; JUMP TO ERROR ROUTINE .IFF # ; THE FIRST TWO MACRO PARAMETERS MUST BE DEFINED .ENDC .IFF # ; THE FIRST TWO MACRO PARAMETERS MUST BE DEFINED .ENDC .NLIST MEB .ENDM INP$ AB: INP$ TA,CALER,4,5,EORS,NRRS,5,BU,2,1,3,5 .PAGE ; OUTPUT CALL MACRO FOR ROS3.1 .MACRO OUT$ IOCL,CLER,LUN,BLUN,ERES,NRES,NWD,BUF,EXT,MOD,PRI,REC .LIST MEB .IF NB IOCL .IF NB CL .IF NB IOCL .IF NB CLER .IF NB LUN MOV #LUN,IOCL+$LUN ; SET LOGICAL UNIT NUMBER .ENDC .IF NB ERES MOV #ERES,IOCL+$ER ; SET ERROR RESUME LOCATION .ENDC .IF NB NRES MOV #NRES,IOCL+$NR ; SET NORMAL RESUME LOCATION .ENDC .IF NB FCT MOV #FCT,IOCL+$FCT SET FUNCTION CODE .ENDC MOV #IOCL,-(SP) ; PLACE LIST ADDRESS ON STACK EMT IOE$ MOV (SP)+,IOCL+$ ADDRESS ON STACK .IFF # ; STRING BUFFER ADDRESS IS A REQUIRED PARAMETER .ENDC EMT BTAE$ .NLIST MEB .ENDM BASC$ BASC$ BINUM,ASTBUF .PAGE ; CONVERT ASCII TO BINARY MACRO .MACRO ASCB$ ASCB,BVAL,ERES .LIST MEB .IF NB ASCB MOV #ASCB,-(SP) ;PLACE STRING BUFFER ADDRESS ON STACK .IFF # ; STRING BUFFER ADDRESS IS A REQUIRED PARAMETER .ENDC EMT ATBE$ .IF NB BVAL MOV (SP)+,BVAL ; REMOVE BINARY INTEGER FROM STACK .IFF # * ; QLOCA,QCOMA,QREGA ARE DESCRIBED IN THE ROS 3.1 ;66 ; ASSEMBLY LANGUAGE PROGRAMMER,S REFERENCE MANUAL ;66 ; * ; PROGRAMMER 55 & 54 * ; DATE 07.20.71 * ; REVISION * ; ER .IF NB LUN MOV #LUN,IOCL+$LUN ; SET LOGICAL UNIT NUMBER .ENDC .IF NB BLUN MOV #BLUN,IOCL+$BLU ; SET BACKUP LOGICAL UNIT NUMBER .ENDC .IF NB ERES MOV #ERES,IOCL+$ER ; SET ERROR RESUME LOCATION .ENDC .IF NB NRES MOV #NRES,IOCL+$NR ; SET NORMAT RESUME LOCATION .ENDC .IF NB NWD MOV #NWD,IOCL+$NW ; SET NUMBER OF WORDS TO BE TRANSFERWD ; SAVE RETURNED CODE IN LIST BEQ . + 4 JMP CLER ; JUMP TO ERROR ROUTINE .IFF # ; THE FIRST TWO MACRO PARAMETERS MUST BE DEFINED .ENDC .IFF # ; THE FIRST TWO MACRO PARAMETERS MUST BE DEFINED .ENDC .NLIST MEB .ENDM IOM$ .PAGE .MACRO REW$ IOCL,CLER,LUN,ERES,NRES IOM$ IOCL,CLER,LUN,ERES,NRES,REWE$ .ENDM REW$ AD: REW$ TA,CALER,4,EORS,NRRS .PAGE ; FORWARD ; BINARY INTEGER IS REQUIRED .ENDC ERRM ERES .NLIST MEB .ENDM ASCB$ ASCB$ ASTBUF,BINUM,ERPROC BINUM: .WORD 256 ASTBUF: .WORD 0,0,0 R50BUF: .WORD 0,0,0 ERPROC: NOP .PAGE ; CONVERT ASCII TO RAD50 .MACRO ASCR$ ASCB,RADB .LIST MEB .IF NB ASCB MOV #ASCB,-(SP) ; PLACE ASCII BUFFER ADDRESS ON STACK .IFF # ; ASCII BUFFER ADDRESS IS REQUIRED .ENDC .IF NB RADB MOV #RADB,-(SP) ; PLACE RAD50 BUFFER ADDRESS ON STACK . * ;*********************************************************************** ; .PAGE .DEF QUEUE ; 13/8/73 .REF MFLAG ; 13/8/73 .REF SAVE ; S61 $KTSK = 200 ;KTASK BIT SET IN HEADER S61 .IFNZ $KT11C .REF PPASV5,PERED .ENDC .IF NB BUF MOV #BUF,IOCL+$BUF ; SET POINTER TO DATA BUFFER .ENDC .IF NB EXT MOV #EXT,IOCL+$EX ; SET CALL TYPE .ENDC .IF NB MOD MOV #MOD,IOCL+$MOD ; SET MODE OF TRANSFER .ENDC .IF NB PRI MOV #PRI,IOCL+$PRI ; SET I/O CALL PRIORITY .ENDC .IF NB REC MOV #REC,IOCL+$REC ; SET RECORDS FIRST BLOCK NUMBER .ENDC SPACE RECORD CALL MACRO .MACRO FSR$ IOCL,CLER,LUN,ERES,NRES IOM$ IOCL,CLER,LUN,ERES,NRES,FSRE$ IOM$ IOCL,CLER,LUN,ERES,NRES,BSRE$ .ENDM FSR$ AE: FSR$ TA,CALER,4,EORS,NRRS .PAGE ; BACKSPACE RECORD CALL MACRO .MACRO BSR$ IOCL,CLER,LUN,ERES,NRES .ENDM BSR$ AF: BSR$ TA,CALER,4,EORS,NRRS .PAGE ; FORWARD SPACE FILE CALL MACRO .MACRO FSF$ IOCL,CLER,LUN,ERES,NRES IOM$ IOCL,CLER,LUN,ERES,NRES,FSFE$ IFF # ; RAD50 BUFFER ADDRESS IS REQUIRED .ENDC EMT ASRE$ .NLIST MEB .ENDM ASCR$ ASCR$ ASTBUF,R50BUF .PAGE ; CONVERT RAD50 TO ASCII .MACRO RASC$ RADB,ASCB .LIST MEB .IF NB ASCB MOV #ASCB,-(SP) ; PLACE ASCII BUFFER ADDRESS ON STACK .IFF # ; ASCII BUFFER ADDRESS IS REQUIRED .ENDC .IF NB RADB MOV #RADB,-(SP) ; PLACE RAD50 BUFFER ADDRESS ON STACK .IFF # ; RAD50 BUFFER ADDRESS IS REQUIRED .ENDC EMT RACE$ .NLISTPASV6,SVPPA .ENDC .IFNZ OVRLAY ; QUEU .REF QOVLAY,PUSHR,POPR ; QUEU .ENDC QUEU ; NARG = 12.+SAVES ;66 IERR = NARG ;66 IERR = NARG ; MOV #IOCL,-(SP) ; PLACE LIST ADDRESS ON STACK EMT OUTE$ MOV (SP)+,IOCL+$ERWD ; SAVE RETURNED CODE IN LIST BEQ . + 4 JMP CLER ; JUMP TO ERROR ROUTINE .IFF # ; THE FIRST TWO MACRO PARAMETERS MUST BE DEFINED .ENDC .IFF # ; THE FIRST TWO MACRO PARAMETERS MUST BE DEFINED .ENDC .NLIST MEB .ENDM OUT$ AC: OUT$ TA,CALER,5,4,EORS,NRRS,5,BU,2,1,3,5 .ENDM FSF$ AO: FSF$ TA,CALER,4,EORS,NRRS .PAGE ; BACK SPACE FILE CALL MACRO .MACRO BSF$ IOCL,CLER,LUN,ERES,NRES IOM$ IOCL,CLER,LUN,ERES,NRES,BSFE$ .ENDM BSF$ AG: BSF$ TA,CALER,4,EORS,NRRS .PAGE ; WRITE END OF FILE CALL MACRO .MACRO EOF$ IOCL,CLER,LUN,ERES,NRES IOM$ IOCL,CLER,LUN,ERES,NRES,EOFE$ .ENDM EOF$ AH: EOF$ TA,CALER,4,EORS,NRRS NRRS: NOP ; NORMAL RESUME EORS: