IDENT 1TO,ITO PERIPH BASE MIXED SST *COMMENT 1TO - TERMINAL INPUT/OUTPUT. COMMENT COPYRIGHT CONTROL DATA SYSTEMS INC. 1992. TITLE 1TO - TERMINAL INPUT/OUTPUT. SPACE 4 *** 1TO - TERMINAL INPUT/OUTPUT. * * R. E. TATE. 70/09/13. * L. G. ALEXANDER. 77/04/01. * A. J. KOMOR. 77/11/01. * L. K. TUTTLE 81/11/02. SPACE 4 *** 1TO IS CALLED BY *IAF* TO PROCESS A QUEUE OF * REQUESTS FOR TERMINAL INPUT AND OUTPUT WHICH REQUIRE * DISK ACCESSES. THE QUEUE PASSED TO *1TO* IS SORTED IN * ORDER OF REQUEST TYPE, INPUT FIRST. *1TO* WILL ACCESS THE * EJT TO OBTAIN DISK INFORMATION. REQUESTS OF EACH * TYPE ARE THEN PROCESSED BY EQUIPMENT AND TRACK TO * MINIMIZE DISK TIME. IF THERE ARE REQUESTS FOR MORE THAN * ONE MASS STORAGE DEVICE, THE ENTRIES ARE PROCESSED ON * A DEVICE BASIS IN ORDER OF AVAILABLE CHANNELS. * * *1TO* MAY ALSO BE CALLED BY *1RO* TO PROCESS THE * FIRST BUFFER OF DATA ON A ROLLOUT. * * UPON *1TO* COMPLETION, THE REQUEST QUEUE IS * RETURN TO IAF. THE UPDATED POT POINTERS IN * IT ARE USED TO DROP DUMPED SOURCE INPUT POTS, AND TO * ASSIGN FILLED OUTPUT DATA POTS. SPACE 4,20 *** CALL. * * * FROM *IAF* - * *T 18/ *1TO*,6/ CP,12/ PP,6/ ,18/ RETURN ADDRESS * * CP IAF CONTROL POINT NUMBER. * PP POT POINTER TO FIRST POT OF REQUESTS. * * * CALL FROM *1RO*. * * 18/ *1TO*,6/ CP,24/ 0,12/ TN * * CP IAF CONTROL POINT NUMBER. * TN TERMINAL NUMBER / APPLICATION CONNECTION NUMBER. SPACE 4,20 *** *IAF* REQUEST QUEUE FORMAT. * * * FORMAT WHEN CALLED. * *T, 6/ FT,6/ RT,12/ EJTO,12/ NP,12/ FP,12/ TN * * FT FILE TYPE. * 0 = PRIMARY FILE. * 1 = ROLLOUT FILE. * RT REQUEST TYPE. * 0 = DUMP INPUT TO PRIMARY FILE. * 1 = OUTPUT TO TERMINAL. * EJTO EJT ORDINAL OF JOB. * NP NUMBER OF POTS TO DUMP TO PRIMARY FILE (INPUT). * FP FIRST POT FOR EITHER INPUT OR OUTPUT. * TN TERMINAL NUMBER / APPLICATION CONNECTION NUMBER. * * THE REQUEST UNDERGOES SIGNIFICANT CHANGE IN PRESET. * THE ENTRY AND EXIT FORMATS FOR PRESET ARE FOUND IN PRESET * HEADER DOCUMENTATION. * * * FORMAT ON TERMINATION - * *T 6/ RT,6/ NP,12/ 0,12/ LP,12/ FP,12/ TN * * RT REQUEST TYPE. * NP NUMBER OF POTS FILLED (OUTPUT ONLY). * LP LAST POT TO DROP OR ASSIGN (0 IF NONE TO DROP). * FP FIRST POT OF INPUT OR FOR OUTPUT (0 IF NONE TO DROP). * TN TERMINAL NUMBER / APPLICATION CONNECTION NUMBER. TEPS SPACE 4,10 ** TEPS - TABLE OF ENTRY POINTERS (SORTED). * * EACH ENTRY CONSISTS OF TWO BYTES - * THE FIRST BYTE CONTAINS THE POINTER TO THE REQUEST IN EBUF. * THE SECOND BYTE CONTAINS * FOR INPUT - THE SECTOR NUMBER OF THE CURRENT EOI. * FOR OUTPUT - THE WORD COUNT IN THE CURRENT SECTOR. SPACE 4,10 ** ABORT CONDITIONS. * * *1TO* WILL ABORT *IAF* IF THE FOLLOWING CONDITIONS ARE * ENCOUNTERED. A DAYFILE MESSAGE * 1TO ABORT NN, PPPP.* WILL * BE ISSUED WHERE *NN* = ERROR CODE AND *PPPP* = PARAMETER * POT POINTER. * * INPUT REQUESTS AFTER OUTPUT REQUESTS FROM IAF. (NN = 1) * NO REQUESTS IN THE QUEUE. (NN = 2) * REQUEST FOR A NON - MASS STORAGE DEVICE. (NN = 3) * *UTEM* REJECT OR UNEXPECTED EJT STATUS. (NN = 4) * ENTRY COUNT LOST WHILE SORTING QUEUE. (NN = 5) * PC = 0 ON SOURCE DUMP. (NN = 6) * PP = 0 ON OUTPUT REQUEST. (NN = 7) SPACE 4 ** ASSEMBLY VARIABLES FOR DEFINITION COMMON DECKS. WEI$ EQU 1 DEFINE VARIABLE BUFFER (FOR *COMPWEI*) SPACE 4 ** DEFINITION COMMON DECKS. SPACE 4 *CALL,COMPMAC *CALL COMSEJT *CALL,COMSMSP *CALL COMSJRO *CALL COMSPIM *CALL,COMSREM *CALL COMSTCM *CALL COMSWEI SPACE 4 **** DIRECT LOCATION ASSIGNMENTS. SPACE 2 S3 EQU 17 SCRATCH CELL FS EQU 20 - 24 FILE STATUS BYTES (5 LOCATIONS) CN EQU 25 - 31 TERMINAL TABLE VROT WORD (5 LOCATIONS) TN EQU 32 TERMINAL NUMBER TT EQU 33 - 34 TERMINAL TABLE ADDRESS (2 LOCATIONS) CT EQU 35 POT LENGTH SC EQU 36 NUMBER OF WORDS IN CURRENT SECTOR LW EQU 41 LAST WORD IN PREVIOUS SECTOR S2 EQU 42 SCRATCH CELL (OUTPUT PROCESSING) LN EQU 43 - 47 LINE NUMBER (5 LOCATIONS) IN EQU LN INPUT REQUEST COUNTER (PRS) OT EQU LN+1 OUTPUT REQUEST COUNTER (PRS) EC EQU LN+2 ENTRY COUNT (PRS) NW EQU 50 USER BLOCKSIZE IN CM WORDS. WL EQU 51 NUMBER OF WORDS OF OUTPUT IN BUFFER. PP EQU 52 POT POINTER PL EQU 53 LENGTH OF LAST POT S1 EQU PL SCRATCH CELL PC EQU 54 NUMBER OF POTS TO BE DUMPED PA EQU 60 - 61 POT ADDRESS (2 LOCATIONS) BC EQU 62 BUFFER COUNT BA EQU 63 CURRENT FWA OF BUFFER EP EQU 64 CURRENT ENTRY POINTER CB EQU 65 CONTROL BYTE INDEX WC EQU 66 WORD COUNT (POSITION) IN CURRENT SECTOR **** EJECT 1TO TITLE MAIN ROUTINE. ** 1TO - MAIN ROUTINE. * * THIS ROUTINE PROCESSES A LIST OF REQUESTS ON ONE OR MORE * EQUIPMENTS. IF MORE THAN ONE EQUIPMENT IS PRESENT ALL * LIST ENTRIES ARE SEARCHED FOR THE ONE WITH THE SMALLEST * DEVICE ACTIVITY. ONCE THIS SELECTION IS MADE THE * INPUT/OUTPUT OPERATION IS PERFORMED AND THE CHANNEL IS * RELEASED. FINALLY THE ENTRY PROCESSING IS COMPLETED BY * EITHER TERMINATING THE SOURCE PROCESSING (IF INPUT * PROCESSING) OR FILLING POTS (IF OUTPUT PROCESSING). * AFTER ALL ENTRIES IN THE LIST HAVE BEEN PROCESSED *IAF* * IS SENT NOTIFICATION THAT ALL ENTRIES ARE COMPLETE. ORG PPFW ITO LJM PRS PRESET ITO1 LDM ITOB REMAINING INPUT REQUESTS ADN 0 2TO LOADED FLAG ITOA EQU *-1 NJN ITO2 IF LOADING NOT NECESSARY RJM DRC DROP RESERVED CHANNEL EXECUTE 2TO AOM ITOA SET 2TO LOADED LDN 0 SET NO EQUIPMENT STD T5 ITO2 RJM CKN CHECK NEXT EQUIPMENT ZJN ITO3 IF SAME EQUIPMENT RJM CUA CHECK UNIT ACTIVITY * PROCESS ENTRY. ITO3 SETMS IO,(ND) LDM 4,EP SET TERMINAL NUMBER STD TN RJM STA SET TERMINAL TABLE ADDRESS ADN VROT CRD CN *VROT* LDM 3,EP SET POT POINTER STD PP LDM 1,EP SET TRACK STD T6 STD FS+2 LDM 2,EP SET SECTOR STD T7 STD FS+3 LDM CKNB SET EXTRA PARAMETER STD T1 LDM 1,T1 STD WC LDC 0 CHECK INPUT REQUEST COUNT ITOB EQU *-1 ZJN ITO4 IF NO INPUT REQUESTS REMAINING LDD WC SET CURRENT EOI STD T7 RJM IDP INPUT DATA PPOCESSING SOM ITOB DECREMENT INPUT REQUEST COUNT LDN 0 SET INPUT REQUEST PROCESSED UJN ITO5 CONTINUE PROCESSING QUEUE ITO4 RJM /2TO/ODP PROCESS OUTPUT REQUEST LDC 100 ADD PC * RETURN HERE AT END OF INPUT/OUTPUT PROCESSING. ITO5 STI EP SET REQUEST TYPE LDN 0 SET REQUEST PROCESSED STM 1,EP SOM TCRQ DECREMENT TOTAL COUNT OF REQUESTS ZJN ITO6 IF NO MORE ENTRIES LJM ITO1 PROCESS NEXT ENTRY * ALL ENTRIES ARE COMPLETED AND NOTIFICATION SENT TO *IAF*. ITO6 ENDMS LDD IA RETURN ENTRIES AND COMPLETE CRD IR ITO7 RJM SPA WRITE REQUEST POT CWM EBUF,CT ITOC EQU *-1 REQUEST QUEUE ADDRESS LDN VCPC*5 RAM ITOC RJM UPP UPDATE POT POINTER NJN ITO7 IF MORE POTS TO WRITE LDD IA CRD IR LDN 0 SET COMPLETION FOR *IAF* STD IR STD IR+1 LDD IR+3 SHN 6 ADD RA SHN 6 ADD IR+4 CWD IR * UJN DPP DROP PP DPP SPACE 4,10 ** DPP - DROP PP. DPP MONITOR DPPM DROP PP LJM PPR EXIT TO PP RESIDENT TRQC SPACE 4,10 TCRQ CON 0 TOTAL COUNT OF ALL REQUESTS ABT SPACE 4,10 ** ABT - ABORTS IAF. * * ENTRY (A) = ERROR CODE. * PARAMETER POT POINTER SET IN MESSAGE. * * CALLS C2D, DFM. * * MACROS MONITOR. ABT SUBR ENTRY RJM C2D STM ABTA+6 LDC ABTA ISSUE * 1TO ABORT NN, PPPP.* RJM DFM DAYFILE MESSAGE MONITOR ABTM LJM PPR EXIT TO PP RESIDENT ABTA DATA C* 1TO ABORT NN, PPPP.* CAB SPACE 4,10 ** CAB - COMPUTE ALLOWABLE BLOCKSIZE. * * ENTRY (TN) = TERMINAL NUMBER. * * EXIT (A) = BLOCKSIZE IN CM WORDS. * (NW) = SAME AS (A). * * USES CM - CM+4. CAB SUBR ENTRY/EXIT LDM PRCA SBD TN PJN CAB1 IF MUX TERMINAL LDD RA SHN 6 ADK VMST CRD CM LDD CM+1 SHN 6 ADD RA SHN 6 ADD CM+2 ADD TN CRD CM LDD CM+3 SHN -6 LPN 37 SHN 3 UJN CAB2 SET NETWORK TERMINAL BLOCKSIZE CAB1 LDK VOPL*VCPC SET MUX TERMINAL BLOCKSIZE CAB2 SBN 2 ALLOW FOR LINKAGE WORDS STD NW UJN CABX RETURN TTL 1TO - GENERAL SUBROUTINES. CKN SPACE 4,15 ** CKN - CHECK THE NEXT EQUIPMENT. * * ENTRY (T5) = CURRENT EST ORDINAL. * (CKNB) = POINTER TO LAST ENTRY ADDRESS. * * EXIT (A) .EQ. 0, IF THE SAME EST ORDINAL. * (A) .NE. 0, NO REQUEST OF SAME TYPE AND EQ FOUND. * (T5) = CURRENT EST ORDINAL. * (EP) = POINTER TO NEXT REQUEST. * * USES EP. CKN2 LDN 1 SET NOT FOUND CKN SUBR ENTRY/EXIT LDD T5 ZJN CKN2 IF NO EQUIPMENT TO MATCH LDN 2 ADVANCE TO NEXT ENTRY RAM CKNB LMM CUAD ZJN CKN2 IF END OF REQUESTS OF SAME TYPE LDM * NEXT ENTRY TO PROCESS - RESET BY *CUA* CKNB EQU *-1 STD EP LDM 1,EP ZJN CKN2 IF NEXT ENTRY ALREADY PROCESSED LDD T5 CURRENT EQUIPMENT LMI EP UJN CKNX EXIT CUA SPACE 4,10 ** CUA - CHECK UNIT ACTIVITY. * DETERMINES THE BEST EQUIPMENT TO PROCESS ENTRIES FOR WITHIN * AN INPUT OR OUTPUT GROUP. THIS DETERMINATION IS BASED ON * MASS STORAGE ACTIVITY. * * ENTRY (ITOB) = INPUT REQUESTS REMAINING. * (CUAA) = FWA OF OUTPUT REQUEST GROUP. * (CUAB) = LWA+1 OF ALL REQUESTS. * (CUAC) = FWA OF GROUP TO BE PROCESSED. * (CUAD) = LWA+1 OF GROUP TO BE PROCESSED. * * CUAA - CUAD CONTAIN POINTERS INTO *TEPS*. * * EXIT (EP) = CORRECT ENTRY POINTER. * (T5) = CORRECT EQUIPMENT. * (CKNB) = POINTER TO ENTRY POINTER IN *TEPS*. * * USES T1 - T5, CM - CM+4, EP. * * CALLS DRC. * * MACROS ENDMS, SFA. CUA SUBR ENTRY/EXIT RJM DRC DROP RESERVED CHANNEL LDM ITOB NJN CUA1 IF INPUT GROUP NOT PROCESSED LDC TEPS SET FWA OF OUTPUT REQUEST GROUP CUAA EQU *-1 (SET BY PRS) STM CUAC LDC TEPS SET LWA+1 OF ALL ENTRIES CUAB EQU *-1 (SET BY PRS) STM CUAD CUA1 LDC TEPS START SEARCH AT BEGINNING OF GROUP CUAC EQU *-1 STD T3 LCN 0 INITIALIZE EQUIPMENT STD T5 STD T2 INITIALIZE ACTIVITY COUNT * PROCESS ENTRY. CUA2 LDI T3 SET ENTRY ADDRESS STD EP LDM 1,EP ZJN CUA3 IF ENTRY ALREADY PROCESSED LDI EP LMD T5 ZJN CUA3 IF THIS EQUIPMENT ALREADY CHECKED LMD T5 STD T5 CHECK ACTIVITY SFA EST ADK EQDE CRD CM LDD CM+4 SHN 3 ADN DALL CRD CM LDD CM SBD T2 PJN CUA3 IF NOT BETTER THAN PREVIOUS BEST RAD T2 LDD EP STD T1 LDD T3 MOVE TEPS POINTER STD T4 LDD T2 ZJN CUA4 IF NO ACTIVITY ON DEVICE CUA3 LDN 2 CHECK NEXT ENTRY RAD T3 LMC * LWA+1 OF CURRENT GROUP CUAD EQU *-1 NJP CUA2 IF MORE ENTRIES LDD T1 SET BEST ENTRY STD EP LDI EP STD T5 CUA4 LDD T4 STM CKNB LJM CUAX EXIT DRC SPACE 4,10 ** DRC DROP RESERVED CHANNEL. * * ENTRY (T5) = EST ORDINAL IF CHANNEL RESERVED. * * MACROS ENDMS. DRC SUBR ENTRY/EXIT LDD T5 ZJN DRCX IF NO CHANNEL RESERVED ENDMS LDN 0 STD T5 UJN DRCX EXIT PRC SPACE 4,10 ** PRC - PROCESS *1RO* CALL. * * ENTRY (TN) = TERMINAL NUMBER. * (WC) = 0. * (PRCA) = LAST MUX TERMINAL NUMBER. * * EXIT TO *DPP*. * * USES CM - CM+4. * * CALLS LDP, UTT. * * MACROS DELAY, EXECUTE, MONITOR, PAUSE. PRC EXECUTE 2TO LOAD OUTPUT OVERLAY AOM /2TO/UTTA SKIP THE *UDA* CALL LDC IROB RJM /2TO/LDP LOAD POTS RJM /2TO/UTT UPDATE TERMINAL TABLE LDD PC PUT POT COUNT IN REQUEST STM PRCB+1 PRC1 LDD MA MAKE OUTPUT ASSIGNMENT CWM PRCB,ON LDK ZERL CRD CM MONITOR TSEM LDD CM+1 ZJP DPP IF *IAF* INACCESSIBLE OR ERROR LMC 7777 NJP DPP IF REQUEST ACCEPTED PAUSE ST LDC 3600 *TSEM* QUEUE FULL - DELAY AND RETRY STD T1 PRC2 DELAY SOD T1 ZJN PRC1 IF TIME TO REISSUE REQUEST UJN PRC2 CONTINUE TO DELAY PRCA CON 0 LAST MUX TERMINAL PRCB VFD 12/VASO,12/,12/,12/,12/ SPACE 4,10 ** COMMON DECKS. *CALL COMPC2D *CALL COMPSPA *CALL COMPSTA EJT$ EQU 1 SELECT EJT PROCESSOR IFP$ EQU 1 SELECT REMOTE INITIALIZATION CODE *CALL COMPGFP *CALL COMPUPP IDP TITLE INPUT DATA PROCESSING. ** IDP - INPUT DATA PROCESSING. * * ENTRY (PP) = POT POINTER. * (T5 - T7) = DISK PARAMETERS. * DRIVER LOADED. * * EXIT CHANNEL RELEASED. * (TESA) = UPDATED DISK INFORMATION. * INPUT DATA APPENDED TO PRIMARY FILE. * * USES BA, LP, PC, PL, PP. * * CALLS ABT, DPB, RPD, SLB, WES. * * MACROS ENDMS, MONITOR, SETMS. IDP SUBR ENTRY/EXIT LDM 2,EP SET LENGTH OF DATA IN LAST POT SHN -11 ADC LDNI STM IDPA LDM 2,EP SET NUMBER OF POTS TO PROCESS LPC 777 STM IDPB NJN IDP1 IF POTS TO DUMP * ABORT IAF ON ILLEGAL POT COUNT. ENDMS LDN 6 RJM ABT ABORT IAF * SET POT PARAMETERS. IDP1 LDC IBUF BUFFER ADDRESS STD BA IDPA LDN 0 LENGTH OF DATA IN LAST POT STD PL LDC 0 NUMBER OF POTS TO PROCESS IDPB EQU *-1 STD PC SET POT COUNT ADC -BUFP MJN IDP2 IF ROOM IN ONE BUFFER STM IDPB LDC BUFP ONE BUFFER FULL STD PC LDN 0 PROCESS ALL OF LAST POT STD PL UJN IDP3 PROCESS BUFFER IDP2 LDN 0 SET COMPLETE STM IDPB * APPEND INPUT TO PRIMARY FILE. IDP3 RJM RPD READ POT DATA TO PP BUFFER SETMS IO,(ND),IBUF LDC IBUF STD BA RJM SLB SET SECTOR LINKAGE BYTES LDC IBUF RESET BUFFER ADDRESS STD BA RJM DPB DUMP BUFFER TO DISK LDM IDPB ZJN IDP4 IF PROCESS COMPLETE LJM IDP1 LOOP FOR NEXT BUFFER IDP4 RJM WES WRITE EOI SECTOR * UPDATE TERMINAL TABLE. AOD CN+4 SET TERMINAL TABLE COMPLETE LDD TT UPDATE TERMINAL TABLE SHN 14 ADD TT+1 ADN VROT CWD CN LJM IDPX RETURN DPB SPACE 4,10 ** DPB - DUMP POT BUFFER TO DISK. * * ENTRY (BA) = BUFFER ADDRESS. * (BC) = BUFFER COUNT. * (T4) = CHANNEL. * (T5) = EQUIPMENT. * (T6) = CURRENT TRACK. * (T7) = CURRENT SECTOR. * * EXIT (T6) = CURRENT TRACK AFTER WRITE. * (T7) = NEXT SECTOR AFTER WRITE. * * USES BA, BC, T6, T7. * * CALLS POS, WDS. DPB SUBR ENTRY/EXIT DPB1 LDD BA WRITE DISK SECTOR LMC WCSF WRITE CONSECUTIVE SECTOR RJM WDS MJN DPBX IF FATAL DISK ERROR AOD T7 ADVANCE SECTOR LDI BA SET NEXT SECTOR TO WRITE SHN 6 PJN DPB2 IF NOT NEW TRACK SHN -6 STD T6 LDN 0 STD T7 DPB2 LDC 502 ADVANCE BUFFER POINTER RAD BA SOD BC DECREMENT BUFFER COUNT NJN DPB1 IF NOT LAST SECTOR UJN DPBX RETURN RPD SPACE 4,15 ** RPD - READ POT DATA TO PPU BUFFER. * * ENTRY (BA) = FWA PP BUFFER. * (PP) = FIRST POT POINTER. * (PC) = POT COUNT. * (PL) = LENGTH OF DATA IN LAST POT. * * EXIT ((BA)) = LOADED WITH DATA FROM POTS. * (BC) = NUMBER OF SECTORS READ (BUFFER COUNT). * REQUEST QUEUE ENTRY UPDATED. * WORD COUNT SET IN SECTOR CONTROL BYTES. * * USES BA, BC, T3, WC. * * CALLS SPA, UPP. RPD7 AOD BC COUNT BUFFER LDD WC SET WORD COUNT IN SECTOR CONTROL BYTES STI BA LDM RPDA ADVANCE BUFFER ADDRESS STD BA LDD PC NJN RPD1 IF NOT LAST POT LDD T3 SET POTS TO DROP IN QUEUE ENTRY STM 2,EP NJN RPDX IF POTS TO DROP STM 3,EP CLEAR FIRST POT POINTER RPD SUBR ENTRY/EXIT LDN 0 INITIALIZE BUFFER COUNT STD BC STD T3 RPD1 AOD BA SET FWA OF DATA IN BUFFER ADN 1 STM RPDA LDN 0 RESET WORD COUNT STD WC * READ NEXT POT TO BUFFER. RPD2 RJM SPA SET POT ADDRESS CRM *,CT RPDA EQU *-1 SOD PC DECREMENT POT COUNT NJN RPD3 IF NOT LAST POT LDD PL NJN RPD4 IF POT LENGTH PASSED RPD3 LDD PP SET LAST POT TO DROP STD T3 * ADVANCE TO NEXT POT. LDN VCPC RPD4 RAD WC ADVANCE WORD COUNT LDN VCPC*5 ADVANCE READ ADDRESS RAM RPDA RJM UPP UPDATE POT POINTER LDD PP ZJN RPD6 IF END OF CHAIN LDD WC SHN -6 NJN RPD5 IF FULL SECTOR LDD PC NJN RPD2 IF NOT LAST POT RPD5 LJM RPD7 TERMINATE SECTOR RPD6 STD PC TERMINATE DATA PROCESSING STM IDPB UJN RPD5 TERMINATE SECTOR SLB SPACE 4,10 ** SLB - SET SECTOR LINKAGE BYTES. * * NOTE - IT IS ASSUMED THAT THE SECTOR LIMIT OF THE * DEVICE WHICH THE PRIMARY FILE RESIDES UPON IS LESS THAN * THE MAXIMUM NUMBER OF SECTORS CONTAINED IN *BUFF*. * * ENTRY (BA) = BUFFER ADDRESS. * (T5) = EQUIPMENT. * (T6) = TRACK. * (T7) = SECTOR. * * EXIT ((BA)) = LINKAGE BYTES SET. * (BC) = TRUNCATED, IF ADDITIONAL TRACK UNAVAILABLE. * * USES CM - CM+4, T1, T2, T3. SLB SUBR ENTRY/EXIT LDM SLM SET LAST BUFFER ON THIS TRACK SBN 1 STD T3 SBD T7 SET NUMBER OF SECTORS REMAINING ON TRACK STD SC SBD BC PJN SLB1 IF ROOM ON PRESENT TRACK RJM SNT SET TRACK LINK STD CM+4 NJN SLB1 IF TRACK ASSIGNED LDD SC TRUNCATE DATA STD BC * SET LINKAGE BYTE. SLB1 LDD T7 SET SECTOR INDEX STD T1 LDD BC SET BUFFER COUNT STD T2 SLB2 LDD T1 LMD T3 NJN SLB3 IF NOT LAST BUFFER ON THIS TRACK STD T1 RESET SECTOR INDEX LDD CM+4 SET NEXT TRACK IN LINKAGE UJN SLB4 SLB3 AOD T1 ADVANCE SECTOR INDEX SLB4 STI BA SET SECTOR LINKAGE LDC 502 ADVANCE BUFFER ADDRESS RAD BA SOD T2 NJN SLB2 IF NOT LAST BUFFER LJM SLBX RETURN WES SPACE 4,10 ** WES - WRITE EOI SECTOR. * * ENTRY (T5) = EQUIPMENT. * (T6) = CURRENT TRACK. * (T7) = CURRENT SECTOR. * (TN) = TERMINAL NUMBER. * * EXIT EOI SECTOR WRITTEN, UPDATED DISK INFORMATION SET. * * CALLS STA, WEI. WES SUBR ENTRY/EXIT RJM STA SET TERMINAL TABLE ADDRESS ADN VUIT GET EJT CRD CM LDD CM+4 SFA EJT ADN PRFE CRD CM LDD CM+4 SET FIRST TRACK OF FILE IN EOI SECTOR STM BUFF+FTEI LDC BUFF WRITE EOI RJM WEI UJN WESX RETURN SPACE 4,10 ** COMMON DECKS. *CALL COMPSNT IF DEF,FA,1 ERR *FA* MUST NOT BE DEFINED FOR *COMPWEI* *CALL COMPWEI IBUF SPACE 4,10 ** INPUT BUFFER SPACE. IBUF EQU * INPUT BUFFER FWA TITLE PRESET. PRS SPACE 4,10 ** PRS - PRESET. * * ENTRY REQUEST QUEUE FORMAT FOR IAF REQUEST QUEUE - * *T 4/ ,1/ PFIC,1/ FT,6/ RT,12/ EJTO,12/ NP,12/ FP,12/ TN * * PFIC = PRIMARY FILE INITIAL CALL FLAG. * 1 = PRIMARY FILE INITIAL CALL. * 0 = PRIMARY OR ROLLOUT FILE CONTINUATION CALL. * FT = FILE TYPE. * 0 = PRIMARY FILE. * 1 = ROLLOUT FILE. * RT = REQUEST TYPE. * 0 = DUMP INPUT TO PRIMARY FILE. * 1 = OUTPUT TO TERMINAL. * EJTO = EJT ORDINAL OF JOB. * NP = NUMBER OF POTS TO DUMP TO PRIMARY FILE (INPUT). * FP = FIRST POT FOR EITHER INPUT OR OUTPUT. * TN = TERMINAL NUMBER. * * EXIT REQUEST QUEUE FORMAT FOR IAF REQUEST QUEUE - * *T, 12/ EQ,12/ TK,12/ P1,12/ P2,12/ TN * * EQ = EST ORDINAL. * TK = TRACK NUMBER. * INPUT - CURRENT EOI. * OUTPUT - FIRST SECTOR OF OUTPUT. * - FIRST CALL ON LIST, FROM *PRFE* IN EJT. * - CONTINUATION CALL, FROM SCHEDULE FIELD IN EJT. * P1 = INPUT - WORD COUNT IN LAST POT, THREE TOP BITS. * - NUMBER OF POTS TO DUMP, NINE BOTTOM BITS. * OUTPUT - FIRST SECTOR OF OUTPUT. * - FIRST CALL ON LIST, 1. * - CONTINUATION CALL, FROM SCHEDULE FIELD IN EJT. * P2 = FIRST POT POINTER. * INPUT - POT TO BEGIN DUMPING TO PRIMARY FILE. * OUTPUT - POT TO WRITE OUTPUT INTO. * TN = TERMINAL NUMBER. * * *TEPS* ENTRY - * * 12/ PTR,12/ EXP * * PTR = POINTER TO ENTRY. * EXP = EXTRA PARAMETER. * INPUT - SECTOR NUMBER OF CURRENT EOI. * OUTPUT - WORD COUNT IN CURRENT SECTOR OF OUTPUT, FROM * SCHEDULE FIELD ON CONTINUATION CALL. PRS RJM IFP INITIALIZE *COMPGFP* LDN VCPC SET LENGTH OF A POT STD CT LDD RA SHN 6 ADN VNTP CRD T5 SET FWA OF NETWORK TERMINALS LDD T5+2 SBN 1 SET LAST MULTIPLEXOR TERMINAL ADDRESS PJN PRS0 IF NETWORK TERMINALS DEFINED LDD RA GET MAXIMUM USER COUNT SHN 6 ADK VMNL CRD T5 LDD T5+4 ADK VPST-1 NUMBER OF PSEUDO TERMINALS PRS0 STM PRCA STORE LAST MUX TERMINAL NUMBER LDD IR+2 SHN -6 FORMAT MESSAGE RJM C2D CONVERT DIGITS STM ABTA+10 LDD IR+2 RJM C2D STM ABTA+11 LDD IR+2 NJP PRS4 IF IAF CALL * PROCESS *1RO* CALL. LDC PRCB SET ENTRY POINTER STD EP LDD IR+4 SET TERMINAL NUMBER STD TN STM PRCB+4 RJM STA SET TERMINAL TABLE ADDRESS ADK VUIT CRD FS ADN VROT-VUIT CRD CN LDD CN+4 CHECK OUTPUT AVAILABLE SHN 21-4 PJN PRS2 IF NO OUTPUT DATA * IF A FULL SECTOR OF DATA RESIDES IN THE *1RO* BUFFER AND IF * THE TERMINAL HAS A BLOCKSIZE OF GREATER THAN ONE SECTOR, * THEN *1TO* MUST MAKE A NULL OUTPUT ASSIGNMENT IN ORDER TO * AVOID SPLITTING WHAT COULD BE A LINE LESS THAN BLOCKSIZE * WORDS ACROSS TWO DOWNLINE BLOCKS BECAUSE THERE IS NO ROOM * IN THE BUFFER TO READ IN ADDITIONAL SECTORS. RJM CAB COMPUTE ALLOWABLE BLOCKSIZE LDM IROB+1 STD WL SHN -6 ZJN PRS1 IF ALL OUTPUT CONTAINED IN *1RO* BUFFER LDD WL SBD NW MJN PRS2 IF BLOCKSIZE EXCEEDS ONE SECTOR PRS1 LDK ZERL CRD CM LDD NW ADK 7+2 ADD ROUNDUP AND LINKAGE WORDS FACTORS SHN -3 ERRNZ VCPC-10 CODE DEPENDS ON POT SIZE OF 10B STD CM+1 MONITOR TGPM GET POTS LDD CM+1 STD PP STM PRCB+3 NJN PRS3 IF A POT WAS GIVEN PRS2 LJM PRC1 ASSIGN NULL OUTPUT PRS3 LMC 7777 NJN PRS3.1 IF NOT A FUNCTION REJECT LDC 3600 REISSUE REQUEST AFTER DELAY STD T1 PRS3.0 DELAY SOD T1 NJN PRS3.0 IF NOT TIME TO REISSUE REQUEST UJN PRS1 TRY AGAIN PRS3.1 LDN 0 STD WC SFA EJT,FS+4 ADN SCHE CRD CM LDD CM+3 MOVE CURRENT TRACK STD FS+2 LDD CM+4 MOVE CURRENT SECTOR STD FS+3 LJM PRC ENTER MAIN LOOP FOR *1RO* CALL * PRESET IAF REQUEST QUEUE CALL. PRS4 RJM SPA SET POT ADDRESS (PP= IR+2) CRM EBUF,CT READ UP ENTRIES PRSA EQU *-1 LDN VCPC*5 UPDATE POINTER RAM PRSA STD T2 RJM UPP UPDATE POT POINTER NJN PRS4 IF MORE ENTRIES TO READ STM 1,T2 SET TERMINATOR BYTE STD IN INITIALIZE INPUT REQUEST COUNT STD OT INITIALIZE OUTPUT REQUEST COUNT STD EC INITIALIZE ENTRY COUNT LDC EBUF ENTRY POINTER STD EP PRS5 LDM 1,EP GET EJTO ZJN PRS10 IF ALL ENTRIES PROCESSED SFA EJT READ EJT ADN JSNE CRD CM ADN SCHE-JSNE CRD FS ADN PRFE-SCHE CRD CN LDI EP LPN 77 ZJN PRS6 IF INPUT OPERATION * PROCESS OUTPUT REQUESTS. AOD OT COUNT OUTPUT REQUEST RJM POR PROCESS OUTPUT REQUEST UJN PRS7 COMPLETE PROCESSING * PROCESS INPUT REQUESTS. PRS6 AOD IN COUNT INPUT REQUEST LDD OT NJN PRS8 IF REQUESTS OUT OF ORDER RJM RIT RESERVE INPUT TRACKS * COMPLETE PROCESSING FOR BOTH REQUEST TYPES. PRS7 STM SNTB,EC SAVE SECTOR NUMBER OR WORD COUNT AOD EC LDN 5 RAD EP UJN PRS5 LOOP FOR NEXT ENTRY PRS8 LDN 1 REQUEST OUT OF ORDER PRS9 RJM ABT ABORT * SET LWA AND REQUEST COUNTS. PRS10 LDD IN NUMBER OF INPUT REQUESTS STM ITOB SHN 1 * 2 RAM CUAA SET FWA OF OUTPUT REQUEST POINTERS STM CUAD SET LWA+1 OF INPUT REQUEST POINTERS LDD IN SHN 2 ADD IN RAM GNEC LWA+1 OF INPUT REQUEST GROUP LDD OT NUMBER OF OUTPUT ENTRIES ADD IN TOTAL OF ALL REQUESTS NJN PRS11 IF REQUESTS LDN 2 NO REQUESTS UJN PRS9 ABORT PRS11 STM TCRQ SET TOTAL NUMBER OF REQUESTS SHN 1 * 2 RAM CUAB RJM SEP SORT ENTRY POINTERS LDN 0 INITIALIZE EST ORDINAL STD T5 LJM ITO1 ENTER MAIN LOOP CEQ SPACE 4,10 ** CEQ - CHECK EQUIPMENT. * * ENTRY (A) = EST ORDINAL. * (EP) = ENTRY ADDRESS. * * EXIT ((EP)) = EST ORDINAL+4000. * * USES T0 - T4. * * CALLS ABT. * * MACROS SFA. CEQ SUBR ENTRY/EXIT LMC 4000 SET NOT SORTED ENTRY FLAG STI EP SAVE EST LMC 4000 ZJN CEQ1 IF NOT MASS STORAGE SFA EST READ EST ENTRY ADK EQDE CRD T0 LDD T0 SHN 21-13 MJN CEQX IF MASS STORAGE CEQ1 LDN 3 NOT MASS STORAGE RJM ABT ABORT GNE SPACE 4,20 ** GNE - GET NEXT ENTRY. * * ENTRY (GNEA) = IF OUTPUT GROUP, NUMBER OF INPUT ENTRIES. * (GNEB) = FWA FOR ENTRIES IN THIS GROUP. * (GNEC) = LWA+1 FOR ENTRIES IN THIS GROUP. * * EXIT (T5) = SELECTED EQUIPMENT. * (T6) = SELECTED TRACK. * (CN+1) = POINTER TO SELECTED ENTRY. * (CN+2) = ENTRY NUMBER. * ENTRY MARKED AS PROCESSED. * * CALLS ABT. GNE SUBR ENTRY/EXIT GNEA LDN 0 (PROCESSING INPUT) * LDN N (PROCESSING OUTPUT, N = NUMBER OF INPUTS) STD CN+3 ENTRY NUMBER TO START AT LCN 0 STD T5 STD T6 LDC EBUF FWA ENTRIES GNEB EQU *-1 STD CN GNE1 LDI CN SHN 21-13 PJN GNE2 IF ALREADY PROCESSED SHN 13-21 LPC 3777 SET EQUIPMENT STD T0 SBD T5 MJN GNE4 IF BETTER CHOICE ZJN GNE3 IF SAME EQUIPMENT GNE2 AOD CN+3 INCREMENT ENTRY COUNT LDN 5 RAD CN LMC EBUF GNEC EQU *-1 NJN GNE1 IF GROUP NOT COMPLETED LDD T5 MARK ENTRY PROCESSED STI CN+1 LMC 7777 ZJN GNE5 IF NO ENTRY FOUND LJM GNEX EXIT GNE3 LDM 1,CN CHECK TRACK SBD T6 PJN GNE2 IF NOT A BETTER CHOICE GNE4 LDD T0 UPDATE EQ STD T5 LDM 1,CN UPDATE TK STD T6 LDD CN UPDATE POINTER STD CN+1 LDD CN+3 SAVE ENTRY NUMBER STD CN+2 UJN GNE2 CHECK NEXT ENTRY GNE5 LDN 5 NO ENTRY FOUND RJM ABT ABORT POR SPACE 4,10 ** POR - PROCESS OUTPUT REQUEST. * * ENTRY (FS - FS+4) = EJT ENTRY WORD *SCHE*. * (CN - CN+4) = EJT ENTRY WORD *PRFE*. * (CM - CM+4) = EJT ENTRY WORD *JSNE*. * * EXIT ((EP)) = FORMATTED REQUEST - EQ,TK,SC,FP,TN. * (A) = WORD COUNT. * * USES CM - CM+4. * * CALLS ABT, CEQ. * * MACROS MONITOR. POR SUBR ENTRY/EXIT LDI EP CHECK FILE TYPE SHN 21-6 PJN POR2 IF NOT ROLLOUT FILE OUTPUT LDD FS INSERT RO EQ INTO REQUEST RJM CEQ CHECK EQUIPMENT POR1 LDD FS+3 SET CURRENT TRACK STM 1,EP LDD FS+4 SET CURRENT SECTOR STM 2,EP LDD FS+2 SET WORD COUNT LPN 77 UJN PORX RETURN POR2 LPN 1 LMC LDNI STM PORA LDD CN+3 SET PRIMARY FILE EQUIPMENT RJM CEQ CHECK PRIMARY FILE EQUIPMENT LDN 0 CONTINUATION CALL PORA EQU *-1 (PRIMARY FILE INITIAL CALL) ZJN POR1 IF CONTINUATION CALL * START NEW OUTPUT ON PRIMARY FILE. LDM 1,EP SET EJT ADDRESS SFA EJT STD CM+4 SHN -14 STD CM+3 LDD CN+4 PRESET CT=FT STM 1,EP LDN FSMS PRESET CURRENT SECTOR = 1 STM 2,EP LDD MA SET I/O JOB STATUS CWM PORB,ON LDN 1 STD CM+1 MONITOR UTEM LDD CM+1 NJN POR4 IF OPERATION NOT COMPLETE LDD MA CHECK OLD STATUS CRD CM LDD CM+4 SBN IOJS ZJN POR3 IF IOJS STATUS SBN DOJS-IOJS NJN POR4 IF NOT DOJS STATUS POR3 LJM PORX EXIT POR4 LDN 4 RJM ABT ABORT PORB VFD 6/JSNE,6/5,6/1,42/IOJS RIT SPACE 4,10 ** RIT - REQUEST INPUT TRACKS. * * ENTRY (CN - CN+4) = EJT ENTRY WORD *PRFE*. * * EXIT (A) = SECTOR NUMBER OF EOI ON THE DEVICE. * TRT RESET TO NEW EOI. * * USES T0, T4, T5, CM - CM+4. * * CALLS ABT, CEQ, SEI. * * MACROS MONITOR. RIT SUBR ENTRY/EXIT LDD CN+4 MOVE PRIMARY FILE FIRST TRACK STD T6 LDD CN+3 MOVE PRIMARY FILE EQUIPMENT STD T5 RJM CEQ CHECK EQUIPMENT * CHECK FOR ROOM ON DISK. LDM 2,EP COMPUTE SECTOR COUNT SHN -11 STD T0 LDM 2,EP LPC 777 SHN 3 ADD T0 ADN 77 SHN -6 SECTOR COUNT STD T4 RJM SEI SET T7 LDD T6 SAVE CURRENT EOI POSITION STD CM+2 STM 1,EP LDD T5 STD CM+1 LDM SLM SBN 1 SBD T7 SBD T4 PJN RIT1 IF ROOM ON TRACK LMC -0 SET SECTORS NEEDED STD CM+4 SHN -14 STD CM+3 MONITOR RTCM UJN RIT2 CHECK NEXT ENTRY RIT1 LDD T7 SET NEW EOI POSITION ADD T4 STD CM+3 LDC -4000 RAD CM+2 MONITOR DTKM RIT2 LDD T7 LJM RITX EXIT SEP SPACE 4,10 ** SEP - SORT ENTRY POINTERS. * * ENTRY (EP) = LWA+1 ALL REQUESTS. * (IN) = INPUT REQUEST COUNT. * (OT) = OUTPUT REQUEST COUNT. * * EXIT ENTRIES SORTED BY EQUIPMENT AND TRACK, POINTERS * STORED IN THAT ORDER IN *TEPS*. * * USES T3, T4, T7, CN - CN+4. * * CALLS GNE. SEP SUBR ENTRY/EXIT LDC TEPS STD T7 SEP1 LDD IN ZJN SEP4 IF NO INPUT REQUESTS, SWITCH TO OUTPUT SEP2 RJM GNE GET NEXT ENTRY LDD CN+1 SET POINTER TO ENTRY STI T7 AOD T7 MOVE EOI SECTOR OR WORD COUNT LDM SNTB,CN+2 STI T7 AOD T7 SOD IN NJN SEP2 IF MORE ENTRIES OF THIS TYPE LDD OT CHECK OUTPUT REQUEST COUNT ZJN SEPX IF NO MORE REQUESTS * SWITCH TO OUTPUT REQUESTS. LDM ITOB RAM GNEA LDM GNEC STM GNEB SEP4 LDD EP STM GNEC LDD OT STD IN LDN 0 STD OT UJN SEP1 SORT OUTPUT REQUESTS SPACE 4,10 SPACE 4,10 ** COMMON DECKS. *CALL COMPSEI IFP HERE BUFFERS SPACE 4,10 ** PRESET BUFFERS. USE BUFFERS SNTB EQU * SECTOR NUMBER / WORD COUNT ERRPL SNTB+VRQB*VCPC-EBUF OVERFLOW INTO ENTRY BUFFER SPACE 4,10 OVERFLOW TTL 1TO - TERMINAL INPUT/OUTPUT. TITLE OUTPUT PROCESSING SUBROUTINES. QUAL 2TO IDENT 2TO,TTOX OUTPUT PROCESSING ROUTINES. *COMMENT 1TO - OUTPUT PROCESSING ROUTINES. COMMENT COPYRIGHT CONTROL DATA SYSTEMS INC. 1992. SPACE 4,10 *** *2TO* IS LOADED TO PROVIDE THE ROUTINES NECESSARY FOR * PROCESSING DOWNLINE OUTPUT. ORG IDP+5 TTO SUBR ENTRY/EXIT UJN TTOX RETURN TTL 1TO/2TO - OUTPUT DATA PROCESOR. ODP TITLE OUTPUT DATA PROCESSING. ** ODP - OUTPUT DATA PROCESSING. * * ENTRY (PP) = POT POINTER. * (EP) = POINTER TO ENTRY TO PROCESS. * (T4 - T7) = DISK INFORMATION. * (FS+2) = TRACK NUMBER OF FIRST SECTOR TO READ. * (FS+3) = SECTOR NUMBER OF FIRST SECTOR TO READ. * (WC) = POSITION TO START AT IN FIRST SECTOR. * * EXIT (T5) = EST ORDINAL. * * USES T1, BA, CB, WC, CM - CM+4, LN - LN+4. * * CALLS CAB, LDP, SDI, SPA, SUL, UTT. ODP SUBR ENTRY/EXIT LDC BUFF SET BUFFER ADDRESS STD BA LDC EBUF-2 SET CONTROL BYTE TABLE ADDRESS STD CB RJM CAB COMPUTE ALLOWABLE BLOCKSIZE LDD PP ZJP ODP5 IF NO POTS SUPPLIED RJM SPA SET POT ADDRESS OF USER TEXT POT CRD LN READ UP LINE NUMBER LDN LN CONVERT LINE NUMBER TO BINARY STD T1 RJM SUL LDD CM SHN 14 ADD CM+1 ZJN ODP1 IF START AT BEGINNING OF FILE LMC -0 SET LINE NUMBER TO SEARCH ON STM SSEA+1 STM SDIA+1 SHN -14 LMC ADCI STM SSEA STM SDIA RJM SDI SEARCH DISK FOR LINE NUMBER UJN ODP4 TRANSFER LINE TO POTS ODP1 RJM RDD READ THE FIRST SECTOR OF DATA PJN ODP2 IF NOT AN EMPTY FILE LDN 0 STD WL UJN ODP4 SEND A *0014* BYTE ONLY ODP2 STD SC SAVE SECTOR WORD COUNT SBD WC PJN ODP3 IF POINTER .LT. WC (ONLY VALID CONDITION) LDN 0 RESET WORD COUNT (NEEDED FOR RECOVERY) STD WC ODP3 RJM RAS READ ADDITIONAL SECTORS UP TO BLOCKSIZE ODP4 LDC BUFF RJM LDP LOAD POTS RJM UTT UPDATE TERMINAL TABLE LDI EP RESTORE EST ORDINAL STD T5 LJM ODPX RETURN ODP5 LDN 7 NO POT POINTER FOUND RJM ABT ABORT TITLE PRO - SUBROUTINES. TITLE OUTPUT PROCESSING SUBROUTINES. ANR SPACE 4,10 ** ANR - ASSURE NETWORK REQUIREMENTS. * * *ANR* ENSURES THAT NO MORE THAN BLOCKSIZE WORDS OF DATA ARE * EVER SENT TO THE TERMINAL IN A SINGLE DOWNLINE BLOCK. IF * THERE ARE LESS THAN BLOCKSIZE WORDS OF DATA REMAINING, ALL * DATA IS SENT. IF THERE ARE BLOCKSIZE OR MORE WORDS OF DATA, * *ANR* MAKES SURE THAT AS MANY WHOLE LINES AS POSSIBLE ARE * SENT WITHOUT EXCEEDING THE BLOCKSIZE LIMIT. A PARTIAL LINE * IS ONLY SENT IN THE CASE WHERE THE FIRST LINE OF DATA * IN THE BUFFER IS LONGER THAN BLOCKSIZE WORDS. * * ENTRY (BA) = BUFFER ADDRESS. * (NW) = USER BLOCKSIZE IN CM WORDS. * (WL) = NUMBER OF WORDS LOADED IN BUFFER. * * EXIT (A) = NUMBER OF WORDS TO SEND TO THE TERMINAL. * (NW) = SAME AS (A). * (CN+4) = OUTPUT AVAILABLE FLAG UPDATED. * * USES S1. ANR3 LDD NW ANR SUBR ENTRY/EXIT LDD WL SBD NW PJN ANR1 IF NUMBER WORDS IN BUFFER .GE. BLOCKSIZE LCN VOPR CLEAR OUTPUT AVAILABLE FLAG RAD CN+4 LDD WL SEND ALL THE DATA STD NW UJN ANRX RETURN * ADJUST THE NUMBER OF WORDS TO SEND TO THE TERMINAL TO * INCLUDE AS MANY COMPLETE LINES AS EXIST IN THE FIRST * BLOCKSIZE WORDS. IF NO COMPLETE LINES ARE FOUND, * (LINE IS LONGER THAN BLOCKSIZE WORDS) THEN SEND THE * FIRST BLOCKSIZE-1 WORDS OF THE LINE. ANR1 LDM PRCA SBD TN PJN ANR3 IF MUX TERMINAL LDD NW CHECK BACKWARDS THROUGH DATA FOR EOL STD WL ADD WC SHN 2 ADD NW ADD WC ADD BA ADN 1 STD S1 ANR2 LDI S1 ZJN ANR3 IF EOL FOUND LCN 5 RAD S1 SOD NW NJN ANR2 IF MORE WORDS LEFT TO CHECK SOD WL STD NW LJM ANRX SEND (BLOCKSIZE - 1) WORDS LDP SPACE 4,10 ** LDP - LOAD DATA INTO POTS. * * ENTRY (A) = BUFFER ADDRESS. * (WC) = WORD INDEX INTO FIRST SECTOR. * (PP) = FIRST POT TO FILL. * (EP) = ENTRY POINTER. * (NW) = USER BLOCKSIZE IN CM WORDS. * (WL) = NUMBER OF WORDS LOADED IN BUFFER. * * EXIT (WL) = NUMBER OF WORDS TRANSFERRED TO POTS. * (CN+4) = OUTPUT AVAILABLE FLAG UPDATED IF RAN OUT * OF POTS. * * USES BA, CM - CM+4, S1, S2, T3. * * CALLS ANR, SPA, UPP. LDP SUBR ENTRY/EXIT STD BA SAVE BUFFER ADDRESS LDN 0 INITIALIZE POT COUNT STD PC LDN 2 SET TO LEAVE ROOM FOR HEADER WORDS STD S2 RJM SPA PUT FIRST POT ADDRESS IN (PA - PA+1) LDK ZERL ZERO OUT SECOND WORD OF POT CHAIN HEADER CRD CM LDD PA SHN 14 LMD PA+1 ADN 1 CWD CM RJM ANR ASSURE NETWORK REQUIREMENTS STD WL NJN LDP1 IF DATA AVAILABLE TO TRANSFER STD T3 LDM 3,EP STM 2,EP AOD PC COUNT OUTPUT POT LJM LDP5 RETURN A *0014* CONTROL BYTE ONLY LDP1 LDD WC COMPUTE ADDRESS OF FIRST WORD TO TRANSFER SHN 2 ADD WC ADD BA ADN 2 STM LDPB LDK VCPC-2 STD S1 STD T3 UJN LDP3 ENTER TRANSFER LOOP LDP2 LDD S1 SHN 2 ADD S1 RAM LDPB LDK VCPC STD T3 STD S1 LDN 0 SET TO NOT LEAVE ROOM FOR HEADER WORDS STD S2 RJM UPP NJN LDP3 IF MORE POTS AVAILABLE LDD CN+4 SET OUTPUT AVAILABLE TO RECALL *1TO* SCN VOPR LMN VOPR STD CN+4 LDD WL SBD NW STD WL LJM LDPX RETURN LDP3 LDD NW SBD S1 STD NW PJN LDP4 IF AT LEAST ONE FULL POT TO TRANSFER ADD S1 STD T3 LDN 0 SET END OF DATA STD NW LDP4 RJM SPA ADD S2 CWM *,T3 TRANSFER WORDS INTO POT LDPB EQU *-1 LDD PP STM 2,EP AOD PC COUNT OUTPUT POT LDD NW SBN 1 PJP LDP2 IF MORE DATA TO TRANSFER LDD T3 SBD S1 ZJP LDPX IF DATA ENDS EXACTLY ON A POT BOUNDARY LDP5 LDK ZERL CRD CM LDN 2R"IB" ADD *0014* BYTE TO MARK END OF DATA STD CM LDD PA SHN 14 LMD PA+1 ADD T3 ADD S2 CWD CM LJM LDPX RETURN RAS SPACE 4,10 ** RAS - READ ADDITIONAL SECTORS. * * *RAS* CONTINUES TO READ SECTORS OF DATA INTO THE BUFFER * UNTIL EITHER BLOCKSIZE WORDS HAVE BEEN LOADED OR UNTIL * NO DATA REMAINS TO BE READ. * * ENTRY (BA) = BUFFER ADDRESS. * (SC) = SECTOR WORD COUNT. * (WC) = POSITION IN FIRST SECTOR. * (NW) = USER BLOCKSIZE IN CM WORDS. * (CB) = INDEX INTO CONTROL BYTE TABLE. * (CN - CN+4) = *VROT* WORD. * * EXIT (CB) = UPDATED TO POINT TO CONTROL BYTES OF LAST * SECTOR LOADED. * (WL) = NUMBER OF WORDS OF OUTPUT IN BUFFER. * * USES BA, SC, S1. * * CALLS RDD. RAS SUBR ENTRY/EXIT LDD SC SBD WC STD WL LDD NW GET BLOCKSIZE ADD WC STD S1 RAS1 LDD SC SBD S1 PJN RASX IF THIS PRU SATISFIES REQUIREMENT LMC -0 STD S1 LDD SC SHN -6 NJN RAS2 IF NOT EOR LDD CN+4 SHN 21-6 PJN RASX IF NOT LIST FILE RAS2 LDD SC UPDATE BUFFER ADDRESS SHN 2 ADD SC RAD BA ADC 502+1 SBD CB PJN RASX IF NO MORE BUFFER SPACE LCN 2 RAD CB RJM RDD READ DISK STD SC MJP RASX IF EOI RAD WL UJN RAS1 PROCESS NEXT SECTOR * THE CALCULATION IN ROUTINE *RAS* FOR NUMBER OF CM WORDS * NEEDED FOR A NETWORK TERMINAL MUST BE ALTERED IF THE * NUMBER OF WORDS IN A POT IS CHANGED. ERRNZ VCPC-10 NUMBER OF WORDS PER POT RDD SPACE 4,15 ** RDD - READ DATA FROM DISK. * * ENTRY (BA) = BUFFER ADDRESS. * (CB) = INDEX INTO CONTROL BYTE TABLE. * (T4) = CHANNEL. * (T5) = EQUIPMENT. * (T6) = TRACK. * (T7) = SECTOR. * * EXIT (A) = WORD COUNT = NEGATIVE IF EOI. * (T6 - T7) = UPDATED. * * USES T3, S2, S3. * * CALLS RDS. RDD4 LDN 0 SET EOI STI CB STM 1,CB RDD5 LCN 0 INDICATE EOI RDD SUBR ENTRY/EXIT LDI BA PRESERVE DATA OVERLAID BY CONTROL BYTES STD S2 LDM 1,BA STD S3 LDD BA READ SECTOR RJM RDS SHN -20 PRESERVE ERROR FLAG STD T3 LDM 1,BA MOVE CONTROL BYTES TO TABLE STM 1,CB LDI BA STI CB LDD S2 RESTORE ORIGINAL DATA INTO PLACE STI BA LDD S3 STM 1,BA LDD T3 NJN RDD4 IF READ ERROR LDI CB NJN RDD1 IF NOT EOF LDM 1,CB ZJN RDD5 IF EOI RDD1 STD T7 UPDATE SECTOR SHN 6 PJN RDD2 IF NOT NEW TRACK SHN -6 STD T6 SET NEW TRACK LDN 0 RESET SECTOR STD T7 RDD2 LDI CB ZJN RDD3 IF EOF LDM 1,CB RDD3 LJM RDDX RETURN SDI SPACE 4,15 ** SDI - SEARCH DISK FOR BEGINNING LINE. * * ENTRY (T4) = CHANNEL. * (T5) = EQUIPMENT. * (T6) = TRACK. * (T7) = SECTOR. * * EXIT (WC)= POSITION OF BEGINNING OF LINE NUMBER * (WL) = NUMBER OF CM WORDS IN LINE. * * USES FS+2, FS+3, LW, SC, T1, T3. * * CALLS RAS, RDD, SSE, SUL. SDI9 LDN 0 INDICATE NO LINE FOUND STD WL SDI SUBR ENTRY/EXIT LDN 0 PRESET LAST WORD STD WC PRESET CM WORD COUNT SDI1 STD LW SDI2 LDD T6 SAVE DISK INFORMATION STD FS+2 LDD T7 STD FS+3 RJM RDD READ DISK MJN SDI9 IF EOI ZJN SDI1 IF ZERO LENGTH SECTOR STD SC SAVE SECTOR WORD COUNT RJM SSE SEARCH SECTOR ZJN SDI2 IF NOT FOUND LDC BUFF+1 STD T1 LDD LW SDI3 ZJN SDI5 IF ZERO BYTE FOUND LDN 5 SDI4 RAD T1 AOD WC COUNT CM WORD LDI T1 UJN SDI3 CHECK NEXT WORD SDI5 AOD T1 RJM SUL SET LINE NUMBER LDD CM SHN 14 ADD CM+1 SDIA ADC * -(LINE NUMBER) PJN SDI6 IF FIND MADE LDN 5-1 UJN SDI4 LOOP SDI6 RJM RAS READ ADDITIONAL SECTORS UP TO BLOCKSIZE LDD LN+4 ZJN SDI10 IF NOT SINGLE LINE LDN 0 STD T3 SOD T1 SDI7 LDN 5 FIND NUMBER OF WORDS IN THE LINE RAD T1 AOD T3 LDI T1 ZJN SDI8 IF EOL FOUND LDD T3 SBD WL MJN SDI7 IF MORE WORDS TO CHECK SDI8 LDD T3 SAVE NUMBER OF WORDS STD WL SDI10 LJM SDIX RETURN SSE SPACE 4,15 ** SSE - SEARCH SECTOR FOR LINE NUMBER OF LAST LINE IN BUFFER. * * ENTRY (BUFF) = SECTOR TO SEARCH. * (A) = SECTOR WORD COUNT. * (LW) = LAST BYTE IN PREVIOUS SECTOR. * * EXIT (A) = 0, IF LINE NUMBER NOT FOUND. * (LW) = IF NUMBER FOUND, LAST BYTE OF PREVIOUS SECTOR. * IF NOT FOUND, LAST BYTE OF CURRENT SECTOR. * * USES LW, S2, T1, T2. * * CALLS SUL. SSE SUBR ENTRY/EXIT STD S2 SET PP WORD COUNT SHN 2 RAD S2 LDD LW SET LAST WORD FOR SEARCH STM BUFF+1 LDC BUFF+1-5 SET STARTING SEARCH ADDRESS STD T2 ADD S2 STD T1 * T1 CONTAINS THE ADDRESS OF BYTE FOUR OF THE SECOND TO LAST * CM WORD IN THE BUFFER. SSE1 LDI T1 ZJN SSE3 IF ZERO BYTE FOUND LCN 5 RAD T1 LMD T2 NJN SSE1 IF NOT AT BEGINNING OF BUFFER SSE2 LDM BUFF+1,S2 GET LAST BYTE IN BUFFER STD LW LDN 0 INDICATE FAILURE LJM SSEX EXIT SSE3 AOD T1 RJM SUL SET UP FOUND LINE NUMBER LDD CM SHN 14 ADD CM+1 SSEA ADC * -(LINE NUMBER) MJN SSE2 IF DATA NOT IN THIS SECTOR LDN 1 LJM SSEX EXIT SUL SPACE 4,10 ** SUL - SET UP LINE NUMBER. * * *SUL* CONVERTS A LINE NUMBER UP TO FIVE DIGITS LONG * FROM DISPLAY CODE INTO BINARY. * * ENTRY (T1) = ADDRESS OF FIRST BYTE OF LINE NUMBER. * * EXIT (T1) = UNCHANGED. * (CM - CM+1) = RESULT. * * USES T2. SUL SUBR ENTRY/EXIT LDN 0 CLEAR RESULT STD CM STD CM+1 LDI T1 SHN -6 SBN 1R+ PJN SULX IF NON-NUMERIC ADN 1R+-1R0 MJN SULX IF NON-NUMERIC STD CM+1 LDI T1 LPN 77 SBN 1R+ PJN SULX IF NON-NUMERIC ADN 1R+-1R0 SUL1 MJN SULX IF NON-NUMERIC STD T2 LDD CM+1 SHN 2 ADD CM+1 SHN 1 ADD T2 STD CM+1 LDM 1,T1 SHN -6 SBN 1R+ SUL2 PJN SULX IF NON-NUMERIC ADN 1R+-1R0 MJN SUL1 IF NON-NUMERIC STD T2 LDD CM+1 SHN 2 ADD CM+1 SHN 1 ADD T2 STD CM+1 LDM 1,T1 LPN 77 SBN 1R+ PJN SUL2 IF NON-NUMERIC ADN 1R+-1R0 SUL3 MJN SUL1 IF NON-NUMERIC STD T2 LDD CM+1 SHN 2 ADD CM+1 SHN 1 ADD T2 STD CM+1 SHN -14 STD CM LDM 2,T1 SHN -6 SBN 1R+ PJN SUL2 IF NON NUMERIC ADN 1R+-1R0 MJN SUL3 IF NON-NUMERIC STD T2 LDD CM SHN 14 ADD CM+1 SHN 10 ADD CM SHN 14 ADD CM+1 SHN 1 ADD T2 STD CM+1 SHN -14 STD CM LJM SULX RETURN UDA SPACE 4,10 ** UDA - UPDATE DISK ADDRESSES. * * ENTRY (FS+2) = TRACK NUMBER OF FIRST SECTOR LOADED. * (FS+3) = SECTOR NUMBER OF FIRST SECTOR LOADED. * (WC) = WORD INDEX INTO FIRST SECTOR. * (WL) = NUMBER OF WORDS TRANSFERRED TO POTS. * (CB) = INDEX TO CONTROL BYTES OF LAST SECTOR READ. * * EXIT (A) = 0, IF AT END OF DATA ON ROLLOUT FILE * (FS+2) = TRACK NUMBER OF SECTOR TO BE ACCESSED ON * THE NEXT CALL. * (FS+3) = SECTOR NUMBER OF SECTOR TO BE ACCESSED * ON THE NEXT CALL. * (WL) = CONTINUATION POINT IN SECTOR. UDA SUBR ENTRY/EXIT LCN 2 MARK END OF CONTROL BYTE TABLE RAD CB LDK 7777 STI CB STM 1,CB LDC EBUF-2 RESET INDEX TO START OF TABLE STD CB LDD WC RAD WL UDA1 LDI CB ZJN UDA2 IF EOF LDD WL SBM 1,CB MJN UDAX IF UPDATE COMPLETE STD WL NJN UDA2 IF DATA DOES NOT END ON SECTOR BOUNDARY LDM 1,CB SHN -6 NJN UDA2 IF LAST SECTOR WAS FULL LDD CN+4 SHN 21-6 MJN UDA2 IF LIST FILE LCN VOPR NO MORE DATA ON ROLLOUT FILE RAD CN+4 LDN 0 LJM UDAX EXIT UDA2 LDI CB UPDATE TRACK AND SECTOR NJN UDA3 IF NOT EOF LDM 1,CB UDA3 STD FS+3 SHN 6 PJN UDA4 IF NOT A NEW TRACK SHN -6 STD FS+2 LDN 0 STD FS+3 UDA4 LCN 2 RAD CB LJM UDA1 CHECK NEXT SECTOR UTT SPACE 4,10 ** UTT - UPDATE TERMINAL TABLE. * * ENTRY (CN - CN+4) = *VROT* WORD. * (FS+2) = TRACK NUMBER OF FIRST SECTOR LOADED. * (FS+3) = SECTOR NUMBER OF FIRST SECTOR LOADED. * (TT - TT+1) = TERMINAL TABLE ADDRESS. * (WC) = WORD INDEX INTO FIRST SECTOR. * (WL) = NUMBER OF WORDS TRANSFERRED TO POTS. * (CB) = INDEX INTO CONTROL BYTE TABLE. * * EXIT TERMINAL TABLE WORD *VROT* UPDATED. * SCHEDULE FIELD IN EJT UPDATED IF CONTINUATION. * * USES CM - CM+4. * * CALLS ABT, UDA. * * MACROS MONITOR. UTT SUBR ENTRY/EXIT LDD CN+4 CHECK FOR MORE OUTPUT SHN 21-4 PJN UTT2 IF NO MORE OUTPUT LDN 0 * LDN 1 (*1RO* CALL) UTTA EQU *-1 NJN UTT1 IF NO NEED TO UPDATE DISK ADDRESSES RJM UDA ZJN UTT2 IF NO MORE OUTPUT UTT1 LDD FS+3 STORE SECTOR STD CM+4 LDD FS+2 STORE TRACK STD CM+3 LDD WL STORE WORD COUNT STD CM+2 LDC SCHE*100+30D STD CM LDN 0 STD CM+1 LDD MA STORE MESSAGE BUFFER CWD CM UJN UTT3 UPDATE SCHEDULE FIELD UTT2 LDD MA CWM UTTB,ON SET REQUEST TO CHANGE JOB STATUS UTT3 LDD TT GET TERMINAL TABLE ADDRESS SHN 14 ADD TT+1 ADK VUIT CRD CM ADN VROT-VUIT CWD CN * UPDATE EJT - JOB STATUS OR SCHEDULE FIELD. SFA EJT,CM+4 SET EJT ADDRESS STD CM+4 SHN -14 STD CM+3 LDN 0 STD CM+2 LDN 1 STD CM+1 MONITOR UTEM LDD CM+1 NJN UTT4 IF REJECT LJM UTTX EXIT UTT4 LDN 4 UNEXPECTED EJT STATUS RJM ABT ABORT IAF UTTB VFD 6/JSNE,6/5,6/1,42/DOJS SPACE 4,10 QUAL * TITLE BUFFERS. USE BUFFERS BUFFERS SPACE 4,10 ** GENERAL BUFFERS. BUFF EQU * INPUT/OUTPUT BUFFER TEPS EQU EPFW-2*VCPC*VRQB EBUF EQU TEPS-VRQB*VCPC*5-2 REQUEST QUEUE BUFFER BUFL EQU EBUF-BUFF-2*12 *BUFF* LENGTH - MAXIMUM CONTROL * BYTE COUNT FOR PPU MEMORY ERRNG BUFL-VSEC*500 BUFFER AT LEAST MINIMUM SECTORS LONG IBUFL EQU EBUF-IBUF-2*12 INPUT BUFFER LENGTH ISEC EQU IBUFL/500B INPUT BUFFER IN SECTORS BUFP EQU ISEC*100B/VCPC NUMBER OF POTS IN INPUT BUFFER OVERFLOW /2TO/TTOX,IROB TTL 1TO - TERMINAL INPUT/OUTPUT. END