ON FILE 1 OF THIS TAPE YOU WILL FIND THE SOURCES AND KEYSHEETS. THE KEYSHEETS ARE THE INSTRUCTIONS FOR BUILDING THIS PRODUCT. PLEASE LOAD AND READ THE KEYSHEET FOR DIRECTIONS. KEYSHEETS ARE LISTED AS "FILENAME.KS" . CONIO.SR 5.LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1974 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ;CONFIGURATION AND REMOTE I/O MODULE FOR THE SLA PACKAGE ;SET MULT=0 FOR SINGLE DEVICE 4074/4073 DRIVER ;SET MULT=1 FOR MULT2IPLE 4074 DRIVER MULT=0 ;SET SLA=SLA DEVICE CODE IF SINGLE DEVICE 4074/4073 DRIVER ;IGNORED IF MULTIPLE 4074 .TITLE CONIO .ENT SDIAC,SDIB0,SDIB1,SDOA0,SDOA1 .ENT SDOB0,SDOB1,SLA SLA=30 .IFE MULT ;SINGLE LINE CASE .ENT SSKDZ SDIAC=DIAC 1,SLA SDIB0=DIB 0,SLA SDIB1=DIB 1,SLA SDOA0=DOA 0,SLA SDOA1=DOA 1,SLA SDOB0=DOB 0,SLA SDOB1=DOB 1,SLA SSKDZ=SKPDZ SLA .ENDC .IFN MULT ;MULTIPLE 4074 CASE .NREL DIAC 1,0 SDIAC: LDA 0,.-1 ;GET DUMMY INSTRUCTION, XCT ROUTINE JMP XCT1 ;WILL GET A^ND ADD IN DEVICE CODE DIB 0,0 SDIB0: LDA 1,.-1 JMP XCT0 DIB 1,0 SDIB1: LDA 0,.-1 JMP XCT1 DOA 0,0 SDOA0: LDA 1,.-1 JMP XCT0 DOA 1,0 SDOA1: LDA 0,.-1 JMP XCT1 DOB 0,0 SDOB0: LDA 1,.-1 JMP XCT0 DOB 1,0 SDOB1: LDA 0,.-1 JMP XCT1 ;INSTRUCTION BUILDING ROUTINES FOR MULTIPLE 4074'S ;STORES INSTRUCTION WITH DEVICE CODE IN LINE TABLE FROM WHICH ;IT IS EXECUTED (LOCATION FOLLOWING INSTRUCTION CONTAINS JMP 1,3) ;TASK LEVEL INSTRUCTIONS--(ALL USE AC0) ; AC0--I/O VALUE ; AC1--I/O INSTRUCTION ; AC2- -ADDRESS OF LCB FOR THIS LINE XCT0: STA 0,TXCT,2 ;SAVE I/O VALUE IN TASK LOC LDA 0,DEVC,2 ;GET DEVICE CODE ADD 0,1 ;COMBINE I/O INST & DEV CODE LDA 0,TXCT,2 ;RESTORE I/O VALUE STA 1,TXCT,2 ;PLANT INST IN TASK EXECUTE LOC JMP TXCT,2 ;EXECUTE & RTN T HROUGH LINE TBL ;INTERRUPT LEVEL INSTRUCTIONS--(ALL USE AC1) ; AC0--I/0 INSTRUCTION ; AC1--I/O VALUE ; AC2--ADDRESS OF LCB FOR THIS LINE XCT1: STA 1,IXCT,2 ;SAVE I/O VALUE IN INT LOC LDA 1,DEVC,2 ;GET DEVICE CODE ADD 1,0 ;COMBINE I/O INST & DEV CODE ~WLDA 1,IXCT,2 ;RESTORE I/O VALUE STA 0,IXCT,2 ;PLANT INST IN INT XCT LOCATION JMP IXCT,2 ;JUMP TO NEW INSTR. .ENDC .END F5SYM.SR 6w.LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1973,1974,1975,1976 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION **.NOCON 1 **.IFE ESW!NSW ?=????? ;NEED TO INCLUDE APPROPRIATE *F5SYM.SR **.ENDC ; *************************F*************** ; * * **.DO ASW ; * AOS FORTRAN 5 SYMBOL DEFINITIONS * **.ENDC X **.DO ESW ; * ECLIPSE FORTRAN 5 SYMBOL DEFINITIONS * **.ENDC X **.DO NSW ; * NOVA FORTRAN 5 SYMBOL DEFINITIONS * **.ENDC X **[X] ; * * ; **************************************** .TITLE F5SYM ; RUNTIME CONDITIONAL ASSEMBLY SWITCHES .DUSR F5SW= 1 ;FORTRAN 5 SWITCH .DUSR F4SW= 0 ;FORTRAN IV SWITCH ; FIXED STACK DISPLACEMENTS FROM FRAME POINTER (.FP) .DUSR FAC0= -4 ;SAVE ACCUMULATOR 0 l.DUSR FAC1= -3 ;SAVE ACCUMULATOR 1 .DUSR FAC2= -2 ;SAVE ACCUMULATOR 2 .DUSR FOFP= -1 ;SAVE FRAME POINTER .DUSR FRTN= 0 ;SAVE CARRY AND RETURN ADDRESS .DUSR FFLE= 1 ;FIRST FREE LOCATION .DUSR FLEN= FRTN-FAC0+1 ;LENGTH OF FIXED AREA ; STACK DISPLACE>LMENTS OF PASSED ARGUMENT ADDRESSES ; BACKWARD FROM FRAME POINTER (.FP) .DUSR ARG0= FAC1 ;RESULT OR ZERO-TH ARGUMENT .DUSR ARG1= FAC0 ;FIRST ARGUMENT .DUSR ARG2= ARG1-1 ;SECOND ARGUMENT .DUSR ARG3= ARG2-1 ;THIRD ARGUMENT .DUSR ARG4= ARG3-1 ;FOURTH ARTGUMENT .DUSR ARG5= ARG4-1 ;FIFTH ARGUMENT .DUSR ARG6= ARG5-1 ;SIXTH ARGUMENT .DUSR ARG7= ARG6-1 ;SEVENTH ARGUMENT .DUSR ARG8= ARG7-1 ;EIGHTH ARGUMENT .DUSR ARG9= ARG8-1 ;NINTH ARGUMENT .DUSR ARG10= ARG9-1 ;TENTH ARGUMENT .DUSR ARG11= ARG10-1 ;ELEVENTH ARGUMENT .DUSR ARG12= ARG11-1 ;TWELFTH ARGUMENT .DUSR ARG13= ARG12-1 ;THIRTEENTH ARGUMENT .DUSR ARG14= ARG13-1 ;FOURTEENTH ARGUMENT .DUSR ARG15= ARG14-1 ;FIFTEENTH ARGUMENT ; FORWARD FROM STACK MARKER (AC2 ON ENTRY FROM COMPILED CODE) .DUSR ARGN= %1 ;LAST ARGUMENT .DUSR ARGN1= ARGN+1 ;NEXT TO LAST ARGUMENT .DUSR ARGN2= ARGN1+1 ;NEXT TO NEXT TO LAST ARGUMENT ; INSTRUCTIONS TO TEST NUMBER OF ARGUMENTS PASSED .DISS SEA= ADCOR# 0,0,SZC ;SKIP IF NUMBER OF ARGS EVEN .DISS SOA= ADCOR# 0,0,SNC ;SKIP IF NUMBER OF ARGS ODD .DALC COA= ADCOR 0,0 ;BIAS CARRY ON # ARGS MOD 2 ; FORTRAN SWITCH FOR SCHEDULERS .DUSR FORTRAN= 1 .DUSR RTOS= 0 ; TELN -> RUNTIME TCB EXTENSION (MULTI-TASKING) .DUSR E.EV= 0 ;EVENT NUMBER !! **.DO ESW .DUSR E.FPS= E.EV+1 ;XFLOATING POINT STATUS !! .DUSR E.FPU= E.FPS+2 ;SPACE FOR FPAC !! .DUSR E.SP= E.FPU ;INITIAL .SP .DUSR E.GP= E.FPU+16. ;GLOBAL AREA POINTER **.ENDC NSW .DUSR E.FPU= E.EV+1 ;SPACE FOR FPAC AND TEMP !! .DUSR E.FPS= E.FPU+8. ;FLOATING POINT STATUS !! .DUSRF E.SP= E.FPS+1 ;STACK POINTER .DUSR E.FP= E.SP+1 ;FRAME POINTER .DUSR E.SSE= E.FP+1 ;END OF STACK POINTER .DUSR E.GP= E.SSE+1 ;GLOBAL AREA POINTER **[NSW] .DUSR E.RP= E.GP+1 ;RETURN TEMPORARY .DUSR E.SSR= E.RP+1 ;.SSE RESET .DUSR E.ZREL= E.SSR+1 ;ZRREL ADDRESS OF PROGRAM (!!) .DUSR E.RTN= E.ZREL+1 ;INSTRUCTION FOR RETURN (!!) .DUSR E.SIZ= E.RTN-E.EV+1 ;SIZE OF TCB EXTENSION **.DO RSW ; QUEUE ARRAY EXTENSION .DUSR QEPA= QTLN ;TASK'S ENTRY POINT .DUSR QMEM= QEPA+1 ;STACK SIZE .DUSR .QLEN= QMEM+1 ӏ;SIZE OF QUEUE ARRAY ; TASK STATUS BITS (TPRST) .DUSR TBSYS= 1B0 ;SYSTEM WAIT BIT !! .DUSR TBSUSP= 1B1 ;TASK SUSPEND BIT !! .DUSR TBXMT= 1B2 ;XMT,REC, AND OVERLAY BIT !! .DUSR TBRDOP= 1B3 ;READ OPERATOR BIT !! .DUSR TBWAKE= 1B7 ;EVENT WAKE BIT !!  **.DO ESW ; TCB STATUS BIT OFFSETS .DUSR TPSYS= (TPRST*16.)+0 ;SYSTEM BIT .DUSR TPSUSP= (TPRST*16.)+1 ;TASK SUSPEND BIT .DUSR TPXMT= (TPRST*16.)+2 ;TASK XMT/REC/OVERLAY BIT .DUSR TPRDOP= (TPRST*16.)+3 ;READ OPERATOR BIT .DUSR TPWAKE= (TPRST*16.)+7 ;EVE]HNT WAKE BIT **.ENDC **.ENDC ; .PT -> PARTITION TABLE .DUSR PTDEF= 0 ;DEFAULT PARTITION -1 POINTER !! .DUSR PTSIZ= PTDEF+1 ;SIZE OF PARTITION .DUSR PTEXT= PTSIZ+1 ;EXTENDER OF PARTITION .DUSR PTLEN= PTEXT-PTSIZ+1 ;LENGTH OF PARTITION ENTRY ; STRUCTURE OF HIGH WORD OF FPU STATUS REGISTER .DUSR FPANY= 1B0 ;SET IF ANY ERROR OCCURS .DUSR FPOVF= 1B1 ;EXPONENT OVERFLOW .DUSR FPUNF= 1B2 ;EXPONENT UNDERFLOW .DUSR FPDVZ= 1B3 ;DIVISION BY ZERO .DUSR FPMOF= 1B4 ;MANTISSA OVERFLOW **.DO ESW .DUSR FPTE= 1B5 ;TRAPS ENABLED **.ENDC NSW .DUSR FPIND= 1B13 ;FPU INTERRUPTS DISABLED .DUSR FPPPM= 1B14 ;PARALLEL PROCESSING MODE .DUSR FPDMD= 1B15 ;DIAGNOSTIC MODE **[NSW] ; GLOBAL ATTRIBUTE WORD BITS .DUSR FALIN= 1B0 ;LINE-ORIENTED !! .DUSR FAPRT= 1B1 ;PREP{ARED FOR PRINTING !! .DUSR FASEQ= 1B2 ;SEQUENTIAL FILE !! .DUSR FACON= 1B3 ;CONTIGUOUS FILE !! .DUSR FARAN= 1B4 ;RANDOM FILE .DUSR FAOUT= 1B11 ;OUTPUT ONLY !! .DUSR FAEXC= 1B12 ;EXCLUSIVE OPEN !! .DUSR FAINP= 1B13 ;INPUT ONLY !! .DUSR FAAPP= 1B14 ;OeXPEN WITH APPEND !! .DUSR FAMSK= 1B15 ;MASK DEVICE CHARACTERISTICS !! ; SYSTEM-DEFINED ACCUMULATORS **.DO ASW .DUSR E= 0 ;"ERROR" ACCUMULATOR .DUSR F= 2 ;"FREE" ACCUMULATOR **.ENDC RSW .DUSR E= 2 ;"ERROR" ACCUMULATOR **[RSW] ; ISA ERROR CODE OFFSET .DUSR EROFF= 3 ; RESERVED FRAME SLOT FOR CURRENT LINE NUMBER .DUSR LINNO= FFLE ; SPACE BETWEEN STACK AND HEAP (OR RDOS) **.DO ESW .DUSR ENZON= 16. ;NO MAN'S LAND: ; PSH(4), FAULT(5), RTER (<=7) **.ENDC NSW .DUSR ENZON= 64. ;NO MAN'S LAND *Y*[NSW] ; ERROR MESSAGE TEXT FILE HEADER OFFSETS .DUSR EHREV= 0 ;REVISION (VER/MOD) .DUSR EHLOW= 1 ;LOWEST ERROR CODE .DUSR EHMAX= 2 ;MAXIMUM NUMBER CODES .DUSR EHSIZ= EHMAX-EHREV+1 ;SIZE OF HEADER ; ERROR MESSAGE TEXT FILE PARAMETERS .DUSR ECDBS= 14B7 ;FORTRAN ERROR CODE BIAS .DUSR ETBSZ= 30. ;ERROR CODE INDEX TABLE SIZE ; (MAX NUMBER OF FORTRAN ERRORS) ; DEFAULT VALUES FOR CONDITIONAL ASSEMBLY SWITCHES .DUSR SW0= 0 .DUSR SW1= 0 .DUSR SW2= 0 .DUSR SW3= 0 .DUSR SW4= 0 .DUSR SW5= 0 .DUSR S RUNTIME FILE TABLE .DUSR CNTFL= 64. ;NUMBER OF FILES ALLOWED .DUSR FTLEN= -CNTFL-1 ;RECORD LENGTH TABLE .DUSR FTTCB= FTLEN-1 ;SINGLE TASK TCB .DUSR FTCV1= FTTCB-1 ;MILLISECONDS/TICK .DUSR FTCV2= FTCV1-1 ;TICKS/SECOND .DUSR FTCV3= FTCV2-1 ;TICKS/MINUTE .DUSR FTOVL= -1 ;OVERLAY CHANNEL NUMBER .DUSR FTLCK= 0 ;FILE LOCK TABLE !! **.DO ESW .DUSR FTCHN= FTLCK+(CNTFL+15./16.) ;CHIJANNEL TABLE **.ENDC NSW .DUSR FTCHN= FTLCK+CNTFL ;CHANNEL TABLE **[NSW] ;.DUSR FTEND= FTCHN+CNTFL +1 ;END OF FILE TABLE (?) .DUSR FTCON= FTTCB-FTCV3+1 ;NUMBER OF CONSTANTS ; .GP -> GLOBAL AREA DISPLACEMENTS .DUSR IOCBP= 0 ;POINTER TO I/O CONTROL BLOClK !! .DUSR ATTEQ= IOCBP+1 ;ATTRIBUTES FOR OPEN .DUSR LENEQ= ATTEQ+1 ;LOGICAL RECORD LENGTH .DUSR RECEQ= LENEQ+1 ;NUMBER OF CONTIGUOUS RECORDS .DUSR ESPSV= 4 ;SAVE .SP FOR ERROR RECOVERY !! .DUSR EFPSV= 5 ;SAVE .FP FOR ERROR RECOVERY !! .DUSR ERREQ= 6  ;ERROR RETURN ADDRESS !! .DUSR ENDEQ= 7 ;END-OF-FILE RETURN ADDRESS !! .DUSR IDEQ= ENDEQ+1 ;TASK IDENTIFIER .DUSR PRIEQ= IDEQ+1 ;TASK PRIORITY .DUSR STKEQ= ATTEQ ;STACK SIZE FOR TASK .DUSR DDLIST= PRIEQ+1 ;POINTER TO DATA-DESCRIPTOR LIST .DUSR DPCA= )DDLIST+1 ;ADDRESS OF CONSTANT .DUSR DPCC= DPCA+1 ;REPEAT COUNT FOR CONSTANT .DUSR DPCT= DPCC+1 ;DATA-TYPE OF CONSTANT  .DUSR GPEND= DPCT-IOCBP+1 ;GLOBAL AREA SIZE ; @.GP -> I/O CONTROL BLOCK (IOCB) ; SPECIAL FIXED LOCATIONS .DUSR IOTMP= 0 ;4-WORD F(LOATING-POINT TEMP !! ; ESPSV= 4 ;DEFINED IN GLOBAL AREA !! ; EFPSV= 5 ;DEFINED IN GLOBAL AREA !! ; ERREQ= 6 ;DEFINED IN GLOBAL AREA !! ; ENDEQ= 7 ;DEFINED IN GLOBAL AREA !! ; TEMPORARIES .DUSR SFSTA= ENDEQ+1 ;SAVED FPU STATUS (2 WORDS)(CVB) .DUSR E%qSIGN= SFSTA+2 ;SIGN OF EXPONENT (CVB) .DUSR ESEEN= ESIGN+1 ;EXPLICIT EXPONENT FLAG (CVB) .DUSR DSEEN= ESEEN+1 ;EXPLICIT DECIMAL PT. FLAG (CVB) .DUSR FDCNT= DSEEN+1 ;FRACTION DIGIT COUNT (CVB) .DUSR CH1= FDCNT+1 ;ADDR OF CHAR-GETTER #1 (CVB) .DUSR CH2= CH1+1 ;ADDR OF CHAR-GETTER #2 (CVB) .DUSR DEFLG= SFSTA ;D/E FORMAT FLAG (FWRITE) **.DO NSW .DUSR FWR1= ESIGN ;STATE SAVE (FWRITE) .DUSR FWR2= ESEEN ;STATE SAVE (FWRITE) .DUSR FWR3= DSEEN ;STATE SAVE (FWRITE) .DUSR GP4= FDCNT ;STATE SAVE (PUT) **.ENDsoC **.DO ESW .DUSR PCNT= CH2+1 ;PADDING BLANK COUNT (FREAD) **.ENDC NSW .DUSR PCNT= CH2+1 ;PAD BLANK COUNT (FREAD,FWRITE) **[NSW] .DUSR VLENG= PCNT+1 ;VARIABLE LENGTH (FREAD, FWRITE) .DUSR DPTR= PCNT ;DIGIT POINTER (FWRITE, CVD) **.DO NSW ; NOTE: "PCNT" AND "DPTR" DO NOT CONFLICT WITHIN FWRITE **.ENDC .DUSR GP1= VLENG+1 ;STATE SAVE (GET) .DUSR GP2= GP1+1 ;STATE SAVE (GET) .DUSR GP3= GP2+1 ;STATE SAVE (GET) .DUSR FMNUM= GP1 ;CALCULATED NUMBER (NFMT) .DUSR NUM.P= GP2 ;POTENTIAL RESCAN POINT (NFMT)p .DUSR FMRTN= GP3 ;LOCAL RETURN ADDR (NFMT) ; IOCB-LINKAGE .DUSR OSSE= GP3+1 ;VALUE OF PREVIOUS .SSE .DUSR OIOCB= OSSE+1 ;POINTER TO PREVIOUS IOCB ; FORMAT-ASSOCIATED DATA .DUSR FBYTE= OIOCB+1 ;FORMAT BYTE PTR(0=>UNFORMATTED) .DUSR FERSP= FBYTE+wx1 ;FORMAT-END RESCAN POINTER .DUSR FSTAK= FERSP+1 ;PTR INTO FORMAT STACKS .DUSR FLOOP= FSTAK+1 ;START OF LOOP-COUNT STACK .DUSR FRESC= FLOOP+16. ;START OF RESCAN-POINT STACK .DUSR FSCL= FRESC+16. ;SCALE FACTOR .DUSR FTYPE= FSCL+1 ;FORMAT TYPE CODE .DUSR FWDT= FTYPE+1 ;EXTERNAL FIELD WIDTH .DUSR FDWDT= FWDT+1 ;DECIMAL FIELD WIDTH .DUSR FTERM= FDWDT+1 ;"FORMAT TERMINATE" CALL .DUSR ZDISC= FTERM+1 ;"DISABLE " FLAG ; OUTPUT-CONVERSION DATA .DUSR NSIGN= ZDISC+1 ;SIGN OF NUMBER (-1 => NEGATIVE) .DUSR EXPON= NSIGN+1 ;DECIMAL EXPONENT .DUSR RSTOP= EXPON+1 ;SPEC ZERO WORD TO STOP ROUNDING .DUSR DIGBF= RSTOP+1 ;START OF DIGIT BUFFER .DUSR FDPTR= DIGBF+17. ;PTR AFTER LAST DIGIT IN BUFFER ; I/O TRANSFER CHARACTERISTICS .DUSR DTYPE= FDPTR+1 ;TYPE CG)ODE FOR CURRENT DATUM .DUSR CXSWT= DTYPE+1 ;COMPLEX SWITCH .DUSR ADATA= CXSWT+1 ;ADDRESS OF DATUM .DUSR REPTC= ADATA+1 ;REPEAT COUNT .DUSR IOCHN= REPTC+1 ;CHANNEL FOR CURRENT I/O ; ( 1B0 => ACCEPT-TYPE) ; ( -1 => ENCODE-DECODE) .DUSR LRECL= IOgUCHN+1 ;RECORD LENGTH ; ( 1B0 => LINE-ORIENTED) ; ( 1B1 => PRINT) .DUSR RDSWT= LRECL+1 ;READ SWITCH ( NON-0 => READ) .DUSR SPSWT= RDSWT+1 ;RECORD-SPILL SWITCH ; I/O BUFFER POINTERS .DUSR BUFS= SPSWT+1 ;I/O BUFFER START BYTE PTR .DUSR BUFP= BU!FS+1 ;FIRST PRINT POSITION BYTE PTR .DUSR BUFE= BUFP+1 ;I/O BUFFER END BYTE PTR .DUSR BUFC= BUFE+1 ;I/O BUFFER CURRENT BYTE PTR .DUSR BUFM= BUFC+1 ;I/O BUFFER MAXIMUM PTR ; I/O BUFFER (ALLOCATED AT END OF IOCB FIXED AREA) .DUSR CCW0= BUFM+1 ;1ST WODRRD OF CARRIAGE CONTROL .DUSR CCW1= CCW0+1 ;2ND WORD OF CARRIAGE CONTROL .DUSR IOCBL= CCW1+1 ;LENGTH OF IOCB FIXED AREA ; (START OF BUFFER) **.DO NSW ;NOVA-ONLY SYMBOLS AND MACROS GO HERE ; ECLIPSE INSTRUCTION MACRO DEFINITIONS .MACRO SAVE ;SA0VE STATE ON STACK **.DO (.ARGCT<>1) ** : ;SAVE ERROR **.ENDC ** .EXTD .SAVE ** JMP @.SAVE ** ^1 % .MACRO RTN ;RETURN STATE ON STACK **.DO (.ARGCT<>0) ** : ;RTN ERROR **.ENDC ** .EXTD .RETN ** JMP @.RETN % .MACRO PSH ;PUSH C(ACS->ACD) ONTO STACK **.DO[ (.ARGCT<>2)!(^1<0)!(^1>3)!(^2<0)!(^2>3) ** : ;PSH ERROR **.ENDC EXIT ** .EXTD .SP **.PUSH ?I **.DUSR ?I= ^1 **.DO ((^2-^1)&3)+1 ** ISZ .SP ** STA ?I,@.SP **.DUSR ?I= (?I+1)&3 **.ENDC **.DUSR ?I= .POP **[EXIT] % .MACRO POP ;POP STACK INTO C(ASC->ACD) **NB.DO (.ARGCT<>2)!(^1<0)!(^1>3)!(^2<0)!(^2>3) ** : ;POP ERROR **.ENDC EXIT ** .EXTD .SP **.PUSH ?I **.DUSR ?I= ^1 **.DO ((^1-^2)&3)+1 ** LDA ?I,@.SP ** DSZ .SP **.DUSR ?I= (?I-1)&3 **.ENDC **.DUSR ?I= .POP **[EXIT] % .MACRO LDB ;LOAD BYTE **.DO (.ARGCT<>12)!(^1<>2)!(^2<>0) ** : ;LDB ERROR **.ENDC ** .EXTD .GETBT ** JSR @.GETBT % .MACRO STB ;STORE BYTE **.DO (.ARGCT<>2)!(^1<>2)!(^2<>0) ** : ;STB ERROR **.ENDC ** .EXTD .PUTBT ** JSR @.PUTBT % .MACRO ADI ;ADD IMMEDIATE TO AC **.DO (.ARGCT<>2)!(^1<1)!(^1p>4) ** : ;ADI ERROR **.ENDC EXIT **.DO ^1 ** INC ^2,^2 **.ENDC **[EXIT] % .MACRO SBI ;SUBTRACT IMMEDIATE FROM AC **.DO (.ARGCT<>2)!(^1<1)!(^1>4) ** : ;SBI ERROR **.ENDC EXIT ** NEG ^2,^2 **.DO ^1-1 ** INC ^2,^2 **.ENDC ** COM ^2,^2 **[EXIT] % .MACRO BrLM ;BLOCK MOVE **.DO (.ARGCT<>0) ** : ;BLM ERROR **.ENDC ** NEGC 1,1 ;(ASSUMES AC1 >= 1) ** LDA 0,0,2 ;(DESTROYS AC0, PRESERVES CARRY) ** STA 0,0,3 ; ** INC 2,2 ; ** INC 3,3 ; ** INC 1,1,SZR ; ** JMP .-5 ; % ; FLOATING POINT MACRO DEFINITIONS J .MACRO LOAF ;WAIT FOR FPU TO FINISH ** SKPBZ FPU ; ** JMP .-1 ; % .MACRO FADS ;ADD SINGLE ** LOAF ; ** DOA ^1,FPU1 ; % .MACRO FSBS ;SUBTRACT SINGLE ** LOAF ; ** DOAS ^1,FPU1 ; % .MACRO FMLS ;MULTIPLY SINGLE ** LOAF ; ** DOAP ^1,FPU1 ; % = .MACRO FDVS ;DIVIDE SINGLE ** LOAF ; ** DOAC ^1,FPU1 ; % .MACRO FADTS ;ADD SINGLE FROM TEMP ** LOAF ; ** DOC 0,FPU1 ; % .MACRO FSBTS ;SUBTRACT SINGLE FROM TEMP ** LOAF ; ** DOCS 0,FPU1 ; % .MACRO FMLTS ;MULTIPLY SINGLE FROM TEMP ** LOAF d; ** DOCP 0,FPU1 ; % .MACRO FDVTS ;DIVIDE SINGLE FROM TEMP ** LOAF ; ** DOCC 0,FPU1 ; % .MACRO FLODS ;LOAD FPAC SINGLE ** LOAF ; ** DOBP ^1,FPU1 ; % .MACRO FSTRS ;STORE FPAC SINGLE ** LOAF ; ** DOBS ^1,FPU1 ; ** LOAF ; % .MACRO FMFT ;MO^VE FPAC TO TEMP ** LOAF ; ** NIOP FPU2 ; % .MACRO FMTF ;MOVE TEMP TO FPAC ** LOAF ; ** NIOC FPU2 ; % .MACRO FCOM ;NEGATE FPAC ** LOAF ; ** NIOC FPU1 ; % .MACRO FNORM ;NORMALIZE FPAC ** LOAF ; ** NIOS FPU2 ; % .MACRO FPLS ;MAKE FPAC POSITIVE ** LOAF ; ** NIOP FPU1 ; % .MACRO FADD ;ADD DOUBLE ** LOAF ; ** DOA ^1,FPU2 ; % .MACRO FSBD ;SUBTRACT DOUBLE ** LOAF ; ** DOAS ^1,FPU2 ; % .MACRO FMLD ;MULTIPLY DOUBLE ** LOAF ; ** DOAP ^1,FPU2 ; % .MACRO FDVD ;DIVIDE DOUBLE ** LOAF ; ** DOAC ^1,FPU2 ; % .MACRO FADTD ;ADD DOUBLE FROM TEMP ** LOAF ; ** DOC 0,FPU2 ; % .MACRO FSBTD ;SUBTRACT DOUBLE FROM TEMP ** LOAF ; ** DOCS 0,FPU2 ; % .MACRO FMLTD ;MULTIPLY DOUBLE FROM TEMP ** LOAF ; ** DOCP 0,FPU2 ; % .MACRO FDVPTD ;DIVIDE DOUBLE FROM TEMP ** LOAF ; ** DOCC 0,FPU2 ; % .MACRO FLODD ;LOAD FPAC DOUBLE ** LOAF ; ** DOBP ^1,FPU2 ; % .MACRO FSTRD ;STORE FPAC DOUBLE ** LOAF ; ** DOBS ^1,FPU2 ; ** LOAF ; % .MACRO FSCAL ;SCALE FPAC TO C(REG) ** LOAF ; ACD .DISS USLE= SUBZ# 0,0,SNC ;SKIP IF ACS <= ACD .DISS USGT= SUBZ# 0,0,SZC ;SKIP IF ACS > ACD .DISS USLT= ADCZ# 0,0,SNC ;SKIP IF ACS < ACD .DISS USGE= ADCZ# 0,0,SZC ;SKIP IF ACS >= ACD ; SIGNED INTEGER COMPARISONS **.DO ESW .MACRO SLT ** SGT ^2,^1 % .MACRO SLE ** SGE ^2,^1 % **.ENDC ; LIMITED SIGNED INTEGER COMPARISONS ; (THESE DO NOT WORK WHEN OPERANDS DIFFER BY >= 32K.) .DISS NSLE= SUBL# 0,0,SZC ;SKIP IF ACS <= ACD .DISS NSGT= SUBL# 0,0,SNC ;SKIP IF ACS > ACD .DISS NSLT= ADCL# 0,0+,SZC ;SKIP IF ACS < ACD .DISS NSGE= ADCL# 0,0,SNC ;SKIP IF ACS >= ACD ; SIGNED COMPARISONS TO ZERO .MACRO SEQZ ** MOV# ^1,^1,SZR % .MACRO SNEZ ** MOV# ^1,^1,SNR % .MACRO SGEZ ** MOVL# ^1,^1,SZC % .MACRO SLTZ ** MOVL# ^1,^1,SNC % .MACRO SGTZ ** AD3DO# ^1,^1,SBN % .MACRO SLEZ ** ADDO# ^1,^1,SEZ % ; SPECIAL MACROS .MACRO TOP ;LOAD FROM TOP OF STACK ** .EXTD .SP ** LDA ^1,@.SP % .MACRO PLOP ;STORE INTO TOP OF STACK ** .EXTD .SP ** STA ^1,@.SP % .MACRO DYNAMIC ;DYNAMICALLY OPEN A FILE **SM$>: .SYSTM ; ** .GCHNL ; ** JMP EM$+1 ; ** .SYSTM ; ** ^1 CPU ; ** JMP CH$ ; ** JMP EM$+2 ; **US$: ERUFT ; **CH$: LDA 3,US$ ; ** SUB# 2,3,SNR ; **EM$: JMP SM$ ; % .MACRO SCH.EDULER ;ENTER SCHEDULER STATE ** .EXTN .SCHED ; ** .SCHED ; ** S:TA 3,PCTMP ; ** JSR @.TSAVE ; % .MACRO HDATA ** .PUSH .RDX ** .RDX 16 ** .PUSH ?H ** .DUSR ?H = 1 ** .DO .ARGCT ** 0^?H ** .DUSR ?H = ?H+1 ** .ENDC ** .DUSR ?H = .POP ** .RDX .POP % .MACRO HDATX ;PRECISION-GENERIC VERSION ** **.DO DBLPREC==0 ** H|DATA ^1 ^2 ;2 WORDS FOR SINGLE PRECISION **.ENDC X ** **.DO DBLPREC==1 ** HDATA ^1 ^2 ^3 ^4 ;4 WORDS FOR DOUBLE PRECISION **.ENDC X ** ** : ;ERROR IN HDATX MACRO: ILLEGAL VALUE FOR DBLPREC **[X] % .MACRO QSAV ** ** .EXTD .RP ** STA 3,.RP ;SAVE RETURN ADDRESS ** **.DO ((^1+0)>0)*(^1+0) ;FOR POSITIVE ARGUMENT ** ISZ .RP ;BUMP RETURN ADDRESS BY 1 **.ENDC **.DO ((^1+0)<0)*(^1+0)*-1 ;FOR NEGATIVE ARGUMENT ** DSZ .RP ;BUMP BACK RETURN ADDRESS BY 1 **.ENDC % .MACRO QRET ** ** .EXTD .RP ** **.DO ((^1+0)>0)%*(^1+0) ;FOR POSITIVE ARGUMENT ** ISZ .RP ;BUMP RETURN ADDRESS BY 1 **.ENDC **.DO ((^1+0)<0)*(^1+0)*-1 ;FOR NEGATIVE ARGUMENT ** DSZ .RP ;BUMP BACK RETURN ADDRESS BY 1 **.ENDC ** ** JMP @.RP ;RETURN TO CALLER % ; MACROS FOR REPORTING RUNTIME ERRORS ; ; FORMATS: ; RT.ERR ;NON-I/O ERROR, CODE ALREADY IN AC E ; RT.ERR ;NON-I/O ERROR, CODE TO BE LOADED ; IO.ERR ;I/O ERROR, CODE ALREADY IN AC E ; IO.ERR ;I/O ERROR, CODE TO BE LOADED ; ; AN I/O ERROR IS ONE FOR WHICH AN IOCB MUST BE FREED. ;g THE SIMPLE FORMS ABOVE (WITHOUT "") CAN BE SKIPPED OVER, ; SINCE THEY ARE GUARANTEED TO GENERATE ONLY ONE WORD. ; THE OTHER FORMS LOAD THE CODE INTO ACCUMULATOR "E" BY MEANS ; OF THE NREL LITERAL FACILITY. THEY MAY NOT BE SKIPPED OVER. .MACRO RT.ERR ** **.DO .ARGCT>=2 **: ;ERROR: TOO MANY ARGUMENTS **.ENDC ** **.DO .ARGCT==1 ** LDC E,^1 ;LOAD ERROR CODE **.ENDC ** ** .EXTD .RTER ** JSR @.RTER ;CALL ERROR REPORTER % .MACRO IO.ERR ** **.DO .ARGCT>=2 **: ;ERROR: TOO MANY ARGUMENTS **.ENDC ** **.DO .ARGCT==1 ** LDC E,^1 ;LOAD ERROR CODE **.ENDC ** ** .EXTD .ERET ** JSR @.ERET ;CALL ERROR REPORTER % .MACRO FDEBL ;ENABLE DEVICES FORTRAN 5 USES ** **.DO ASW ;NO NEED TO ENABLE ANY DEVICES **.ENDC RSW **.DO ESW ELEF 0,FPU ;AC0 <- PHONY Fw#PU CODE .SYSTM ;CALL THE SYSTEM TO .DEBL ; ENABLE THE DEVICE NOP ;SWALLOW ERRORS **.ENDC NSW SUBZL 0,0 ;SET TO MUL/DIV DEVICE CODE ADCZL 1,1,SKP ;SET LOOP COUNT TO 4 FPU1-1 ;(MIN FPU DEV CODE)-1 .SYSTM ;CALL THE SYSTEM TO .DEBL ; ENABLE THE DEVICE NOP ;SWALLOW ERRORS MOVZR# 0,0,SNR ;IF FIRST TIME, LDA 0,.-5 ; GET FIRST FPU CODE - 1 INCC 0,0,SZC ;NEXT CODE, SKIP IF ODD ITERATION INC 1,1,SZR ;SKIP WHEN DONE JMP .-7 ;LOOP BACK FOR NEXT DwEV CODE **[NSW] **[RSW] % .MACRO FEXEC ;PERFORM .EXEC WITH FPU SAVE/RSTR ** **.DO ASW **: ;FEXEC NOT YET IMPLEMENTED **.ENDC ** **.DO ESW FPSH ;SAVE FLOATING POINT STATUS **.ENDC NSW FRST 3 ;SAVE FLOATING POINT STATUS PSH 3,3 ; **[NSW]( ADC 3,3 ;-1 ON STACK TO FLAG NO ERROR PSH 3,3 ; .SYSTM ;NOW DO THE EXEC .EXEC PLOP 2 ;IF ERROR, OVERWRITE FLAG WITH CODE FDEBL ;RE-ENABLE DEVICES POP 2,2 ;RETREIVE FLAG/CODE **.DO ESW FPOP ;RESTORE FLOATING POINT3 STATUS **.ENDC NSW POP 3,3 ;RESTORE FLOATING POINT STATUS FLST 3 ; **[NSW] COM# 2,2,SZR ;SKIP IF .EXEC ERROR-FREE % ; MACRO FOR RETURNING FROM THE CURRENT PROGRAM ; ; FORMATS: ; FRETURN ;FOR NORMAL RETURN ; FRETURN ;FOR ERROR REseTURN WITH CODE ; FRETURN () ;FOR ERROR RETURN WITH CODE ALREADY IN AC .MACRO FRETURN ** **.DO .ARGCT>0 ;IF ERROR RETURN ** .DO '^1'&-1B7=='(' ;IF STARTS WITH "(" ** .DO ^1<>E ;IF NOT YET IN CORRECT AC MOV ^1,E ;MOVE ERROR COMDE TO CORRECT AC ** .ENDC ** .ENDC X LDC E,^1 ;LOAD ERROR CODE ** [X] **.ENDC ** **.DO ASW ** ** .DO .ARGCT==0 SUBZR 2,2 ;SIGNAL NORMAL RETURN **ASSUME ?RFCF==1B0 ** .ENDC X LDC 2,?RFCF+?RFER+?RFEC ;SIGNAL ERROR TO CLI ** [X]  ?RETURN ** **.ENDC RSW ** .SYSTM ** .DO .ARGCT==0 .RTN ** .ENDC ERR .ERTN ** [ERR] ** **[RSW] ** HALT ;IF RETURN FAILS, HANG IT UP % .MACRO PARTITION ;SETS UP PARTITION SPECIFICATION TABLE ** .NOCON 1 ** .IFE .ARGCT ; IF NO ARGUMENTS PASSED THEN ** .IFE .MCALL ; IF THIS IS FIRST CALL THEN .TITLE IPART .ENT .IPART .NREL ** .RDX 10 **MINSIZ= GPEND+E.SIZ+FLEN+ENZON ;MINIMUM PARTITION SIZE .IPART: ** .ENDC ; GENERATE THE INITIAL STUFF ** .IFN .MCALL ; ELSE -1 .END M** .ENDC ; GENERATE END OF TABLE ** .ENDC ; ** .IFN .ARGCT ; ELSE ** .IFE ^1 ; IF FIRST ARGUMENT ZERO THEN 0 ;INDICATE DEFAULT PARTITION SIZE ** .ENDC ; GENERATE DEFAULT SIZE INDICATOR ** .IFN ^1 ; ELSE ** .IFL ^1-MINSIZ ; IF PARTITtION SIZE < MINIMUM THEN ; ERROR - PARTITION SIZE TOO SMALL ** .LOC 0 ;(ILLEGAL LOAD ADDRESS) ** .RDXO 10 MINSIZ ;MINIMUM PARTITION SIZE (DECIMAL) ** .RDXO 8 ** .ENDC EXIT ; GENERATE ERROR MESSAGE, EXIT ** .IFG 1+^1-MINSIZ ; ELSE ^1 ;PARTITION SIZE ** .ENDC ; GENERATE PARTITION SIZE ** .ENDC ; ** .IFN .ARGCT==1 ; IF ONLY ONE ARGUMENT GIVEN THEN -1 ;- (NUMBER OF PARTITIONS) ** .ENDC ; GENERATE A COUNT OF ONE ** .IFE .ARGCT==1 ; ELSE -^2 ;- (NUMBER OF PARTITIONS) ** .ENDC to; GENERATE THE GIVEN COUNT **[EXIT] ;(END OF EXPANSION WITH ERROR) ** .ENDC ; % ; .EOT ;END OF F5SYM.SR FMAC.SR 7.LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1975,1976 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ; FMAC.SR ; ; ADDITIONAL SYMBOL AND MACRO DEFINITIONS FOR ; FORTRAN IV AND 5 **.NOCON 0 ; ; DEFINE SYMBOLS LACKING IN FORTRAN IV ; .DO F4SW ; DEFINE SOME SWITCHES .DUSR NSW= ?NOVA ;NOVA SWITCH .DUSR ESW= ?ECLIPSE ;ECLIPSE SWITCH .DUSR ASW= 0 .DUSR RSW= ?OS?==?RDOS ;RDOS SWITCH ; DEFINE STACK DISPLACEMENTS OF PASSED ARGUMENT ADDRESSES .DUSR ARG0= FTSTR ;RESULT &OR 0TH ARG ADR SLOT .DUSR ARG1= ARG0+1 ;FRAME SLOT FOR 1ST ARG ADR .DUSR ARG2= ARG1+1 ;FRAME SLOT FOR 2ND ARG ADR .DUSR ARG3= ARG2+1 ;(ETC.) .DUSR ARG4= ARG3+1 .DUSR ARG5= ARG4+1 .DUSR ARG6= ARG5+1 .DUSR ARG7= ARG6+1 .DUSR ARG8= ARG7+1 .DUSR ARG9= ARG8+1 .DUSR ARG10= ARG9+1 .DUSR ARG11= ARG10+1 .DUSR ARG12= ARG11+1 .DUSR ARG13= ARG12+1 .DUSR ARG14= ARG13+1 .DUSR ARG15= ARG14+1 ; DEFINE INSTRUCTIONS TO TEST NUMBER OF ARGUMENTS PASSED .DISS SEA= MOVR# 0,0,SZC ;SKIP ON EVEN # ARGS .DISS SOA= MOVR# 0,0,S!NC ;SKIP ON ODD # ARGS .ENDC ; ; DEFINE SYMBOLS LACKING IN FORTRAN 5 ; .DO F5SW ; EQUIVALENCE "FRET" TO "RTN" .DO ESW .DUSR FRET= RTN .ENDC NSW .MACRO FRET ** RTN % [NSW] .ENDC ; ; DEFINE SYMBOLS AND MACROS COMMON TO BOTH ; ; DEFINE MrACRO TO STATE AND CHECK RUNTIME ASSEMBLY ASSUMPTIONS .MACRO ASSUME ** .IFE ^1 **: ;VIOLATED ASSUMPTION THAT ^1 ** .ENDC % ; DEFINE INSTRUCTION TO BUMP FRAME-POINTER-CONTAINING AC IN ; DIRECTION OF INCREASINGLY INDEXED ARGUMENT ADDRESSES .DO ESW&F4SW  ;(DEFINE ONLY FOR ECLIPSE) .DICD NXTARG= ADI 1,0 ;FORWARD IN FORTRAN IV .ENDC .DO F5SW .DO ESW .DICD NXTARG= SBI 1,0 ;BACKWARD IN FORTRAN 5 .ENDC NSW .MACRO NXTARG **.DO (.ARGCT<>2)!(^1<1)!(^1>4)!(^2<1)!(^2>4) ** : ;ERROR IN NXTARG MACRO **a.ENDC X ** ** SBI ^1,^2 **[X] % [NSW] .ENDC ; DEFINE INSTRUCTIONS TO MANIPULATE THE STACK AND FRAME POINTERS ; ; USAGE EXAMPLES: LDAFP 3 ; STASP@ 0 ; ISZSP@ .DO F4SW .DIAC LDAFP= LDA 0,FSP ;AC <- FRAME POINTER .MACRO STAFP ;NOT TO BE USEDs **ASSUME 0 % .MACRO ISZFP ;NOT TO BE USED **ASSUME 0 % .MACRO DSZFP ;NOT TO BE USED **ASSUME 0 % ; NOTE: IN THE FOLLOWING MACROS, THE EXTRA ARGUMENT ; IS TO ALLOW FOR "@". .MACRO LDASP ** LDA ^1 ^2 QSP % .MACRO STASP ** STA ^1 ^2 QSP % .MACdRO ISZSP ** ISZ ^1 QSP % .MACRO DSZSP ** DSZ ^1 QSP % .MACRO RL3FP ;RELOAD AC3 WITH THE FRAME POINTER % ;NOTE: AC3 ALWAYS HOLDS FSP ON ; RETURN FROM A SYSTEM CALL ; FOR COMPATIBILITY WITH PAST: .DUSR LD3FP= LDA 3,FSP ;AC3 <- FRAME POINTER .ENDC .DO F5SW ;NOTE: IN THE FOLLOWING MACROS THE EXTRA ARGUMENT ALLOWS FOR "@". .MACRO LDAFP ** .EXTD .FP ** LDA ^1 ^2 .FP % .MACRO STAFP ** .EXTD .FP ** STA ^1 ^2 .FP % .MACRO ISZFP ** .EXTD .FP ** ISZ ^1 .FP % .MACRO DSZFP ** .EXTD .FP ** DSZ ^1 .FP % .MACRO LDASP ** .EXTD .SP ** LDA ^1 ^2 .SP % .MACRO STASP ** .EXTD .SP ** STA ^1 ^2 .SP % .MACRO ISZSP ** .EXTD .SP ** ISZ ^1 .SP % .MACRO DSZSP ** .EXTD .SP ** DSZ ^1 .SP % .MACRO RL3FP **.DO RSW ;UNDER RDOS: LDAFP 3 ;RELOAD FRAM"E POINTER INTO AC3 **.ENDC % ; FOR COMPATIBILITY WITH PAST: .MACRO LD3FP LDA 3,.FP ;AC3 <- FRAME POINTER % .ENDC .MACRO TITL ;.TITLE AND SHOW ASSEMBLY ENVIRONMENT ** .TITLE ^1 ;% ; WHICH OPERATING SYSTEM? .DO ASW .MACRO TITL XXX% .ENDC CPU ;(PRESUME ECLIPSE) .DO RSW .MACRO TITL RDOS% .ENDC OS .DO RTOS .MACRO TITL RTOS% .ENDC OS ;UNKNOWN .MACRO TITL OS???% [OS] ; WHICH CPU? .DO ESW .MACRO TITL ECLIPSE% .ENDC CPU .DO NSW .MACRO TITL NOVA% .ENDC CPU ;UNKNOWN .MACRO TITL CPU???%W1 [CPU] ; WHICH LANGUAGE? .DO F4SW .MACRO TITL FORTRAN IV% .ENDC LANG .DO F5SW .MACRO TITL FORTRAN 5% .ENDC LANG ;UNKNOWN .MACRO TITL LANG???% [LANG] .MACRO TITL ** .TXTM 1 ;ALWAYS PACK LEFT TO RIGHT ** **.DO '^2'<>'' ;;IF SECOND ARG EXIST ]S ** .PUSH .LOC ;;PRESERVE . ** NREL ;;GO NREL ** .ENT ^2 ;;CREATE AN ENTRY SYMBOL ** ^2: ;;AND DEFINE IT ** .LOC .POP ;;RESTORE . **.ENDC % .MACRO TITLE ** ** TITL ^1 ^2 **.DO ASW ** .OB ^1.OB **.ENDC RSW ** .RB ^1.RB **[RSW] ** .EXTU ;***;WId"LL GO AWAY, HOPEFULLY ** .NOCON 1 ** NREL % .MACRO END ** ** LPOOL ;DEPOSIT REMAINING LITERALS ** ** .PUSH .NOCON ** .NOCON 1 ** .PUSH .RDXO ** .RDXO 10 ** .ZREL ZRELSIZE=. ** .NREL **.DO RSW NRELSIZE=. **.ENDC **.DO ASW UNRLSIZE=. ** .NREL 1 SNRLSIZE=. **.ENDC ** .RDXO .POP ** .NOCON .POP ** ** .END ^1 % .MACRO OBJCT ** **.PUSH .NOCON **.NOCON 1 ** **.DO ASW .OB ^1.OB **.ENDC RSW .RB ^1.RB **[RSW] ** **.NOCON .POP % .MACRO UNREL ;(DEFINITELY) UNSHARED NREL ** ** .NREL % .MACRO SNREL ;(PjOSSIBLY) SHARED NREL ** **.DO ASW ** .NREL 1 **.ENDC RSW ** .NREL ;(CAN'T BE SHARED) **[RSW] % .MACRO NREL ;DEFAULT CASE ** **;***; SNREL ;DEFAULT WILL BE SHARED ** UNREL ;***;BUT FOR NOW, UNSHARED % .MACRO NENTRY ;DEFINE NREL ENTRY(S) ** ** D.ENT ^1 ^2 ^3 ^4 ^5 ^6 ^7 ^8 ^9 ** .PUSH ?I ** ** .DUSR ?I=0 **.DO .ARGCT ** .DUSR ?I=?I+1 ** ^?I: **.ENDC ** ** .DUSR ?I=.POP % .MACRO MAKENTRY ;MACRO FOR DEFINING ZREL-TYPE ENTRIES ** ** .PUSH .NOMAC ** .NOMAC 1 ** ** .MACRO ^1 ;DEFINzE MACRO ^1 ** ** .ENT _^1 _^2 _^3 _^4 _^5 _^6 _^7 _^8 _^9 ** .PUSH ?I ** ** .PUSH .LOC ;REMEMBER WHERE WE ARE ** .ZREL ;GO INTO PAGE ZERO ** ** .DUSR ?I=0 **.DO .ARGCT ;DEFINE EACH SYMBOL ** .DUSR ?I=?I+1 ** _^?I^2 ^3 ^4 ^5 **.ENDC ** ** (."]TOP) ** .LOC .POP ;GO BACK TO WHERE WE WERE ** ** .DUSR ?I=.POP _% ** ** .NOMAC .POP % ; DEFINE THE ZREL-TYPE ENTRY MACROS MAKENTRY ZENTRY : MAKENTRY JMPENTRY = JMP @. MAKENTRY JSRENTRY = JSR @. .DO F4SW .MACRO ENTRY ;USER-CALLABLE ENTRY **, ** NENTRY ^1 ^2 ^3 ^4 ^5 ^6 ^7 ^8 ^9 % .ENDC .DO F5SW .MACRO ENTRY ;USER-CALLABLE ENTRY ** ** ZENTRY ^1 ^2 ^3 ^4 ^5 ^6 ^7 ^8 ^9 % .MACRO SENTRY ;FORTRAN STATEMENT ENTRY ** ** ZENTRY ^1 ^2 ^3 ^4 ^5 ^6 ^7 ^8 ^9 % .ENDC .MACRO ?P?1F ;INITIALIZATION OF FLAGS WORD ** **.DO .MCALL==0 ;;ONLY ONCE ON EACH PASS ** .DUSR ?P?FF = 0 **.ENDC % .MACRO DEFARGS ;DEFINE ARGUMENTS TO FORTRAN SUBROUTINE ** **.DO .MCALL==0 ;;IF FIRST TIME ** ?P?1F ;;MAY NEED TO INIT **.ENDC ** ** DEFPKT - ARG0 ARG1-ARG0 ;;START THE DEFINITION ** .DUSR ?P?FF = 1B1+0B2+0B3+0B4 ;;AND SET DEFARGS BUSY, DEFTMPS CLEAR % .MACRO DEFTMPS ;DEFINE TEMPORARIES FOR FORTRAN SUBROUTINE ** **.DO .MCALL==0 ;;IF FIRST TIME ** ?P?1F ;;MAY NEED TO INIT **.ENDC ** **.DO ?P?FF&1B1<>0 X;;IF DEFARGS BUSY ** DEFNEW SHOW=0 DUSR=0 ;;NEW LISTING CONTROLS ** DEFEND ?ARG? ;;REMEMBER ARG COUNT ** DEFOLD ;;BACK TO OLD ONES ** .DUSR ?P?FF = ?P?FF-1B1+1B2 ;;SIGNAL DEFARGS DONE **.ENDC ** **.DO ?P?FF&1B2==0 ;;IF DEFARGS NOT DONE **:;ERROR: MUST DO DEFARGS BEFORE DEFTMPS ** ?ARG? = 0 ;;OBLIGE FOR NOW **.ENDC ** **.DO F4SW ** TMP0 = FTSTR+?ARG? ;;DEFINE FIRST TEMP **.ENDC **.DO F5SW ** TMP0 = FFLE ;;DEFINE FIRST TEMP **.ENDC ** ** DEFPKT - TMP0 +1 ;;START TEMPS DEFINITION ** .DUSR ?P?FF = 0B1+1B2+1B3+0B4 ;;SET DEFARGS DONE, DEFTMPS BUSY % .MACRO FENTRY ;DEFINE ENTRY TO FORTRAN SUBROUTINE ** **.DO .MCALL==0 ;;IF FIRST TIME ** ?P?1F ;;MAY NEED TO INIT **.ENDC ** **.DO ?P?FF&1B3<>0 ;;IF DEFTMPS BUSY ** DEFNEW SHOW=0 DUSR=0 ;;NEW LISTING CO CNTROLS ** DEFEND ?TMP? ;;REMEMBER TEMPS COUNT ** DEFOLD ;;BACK TO OLD ONES ** .DUSR ?P?FF = ?P?FF-1B3+1B4 ;;SIGNAL DEFTMPS DONE **.ENDC ** **.DO ?P?FF==0 ;;IF BOTH ARE CLEAR **:;ERROR: MUST DO DEFARGS AND DEFTMPS BEFORE FENTRY **.ENDC ERROR ** **.DO ?qP?FF&1B4==0 ;;IF DEFTMPS NOT DONE **:;ERROR: MUST DO DEFTMPS AFTER DEFARGS AND BEFORE FENTRY **.ENDC ERROR ** **.GOTO SKIP ** **[ERROR] ** ?ARG? = 0 ;;OBLIGE ** ?TMP? = 0 ** **[SKIP] ** ** ISAENTRY ^1 ^2 ^3 ^4 ^5 ^6 ^7 ^8 ^9 ** % .MACRO ARGS ** ** ?ARG? = ^1 ;REMEMBER NUMBER OF ARGS % .MACRO TMPS ** ** ?TMP? = ^1 ;REMEMBER NUMBER OF TEMPS **.DO F4SW ** TMP0 = FTSTR+?ARG? ;NAME FIRST TEMP ** .DUSR FFLE = TMP0 ;(FOR COMPATIBILITY WITH PAST) **.ENDC **.DO F5SW ** TMP0 = FFLE ;NAME FIRST TEMP **.E7NDC % .MACRO ISAENTRY ** **.DO F4SW ** ?ARG?+?TMP? ;NUMBER OF STACK TEMPORARIES **.ENDC ** ** ENTRY ^1 ^2 ^3 ^4 ^5 ^6 ^7 ^8 ^9 ** **.DO F4SW ** .EXTD .FARL ** JSR @.FARL ;COPY ARG ADRS **.ENDC **.DO F5SW ** SAVE ?TMP? ;SAVE STATE AND ALLOC TEMPORARIES **.ENDC % .MACRO ISA.NORM ;ISA-STYLE NORMAL RETURN ** ** .EXTD .ISANORM ** JMP @.ISANORM % .MACRO ISA.ERR ;ISA-STYLE ERROR RETURN ** **.DO .ARGCT==1 ** LDC E,^1 ;LOAD UP THE ERROR CODE **.ENDC ** ** .EXTD .ISAERR ** JMP @.ISAERR % .DO F4SW .;MACRO IS1.NORM ** ISA.NORM % .MACRO IS1.ERR ** ISA.ERR % .ENDC .DO F5SW .MACRO IS1.NORM ** ** .EXTD .1SANORM ** JMP @.1SANORM % .MACRO IS1.ERR ** **.DO .ARGCT==1 ** LDC E,^1 ;LOAD UP THE ERROR CODE **.ENDC ** ** .EXTD .1SAERR ** JMP @.1SAERR % .E4NDC ; DEFINE LOAD IMMEDIATE INSTRUCTIONS USING NREL LITERAL FACILITY .MACRO LDC ;LOAD CONSTANT ** ** LDA ^1,LIT[^2 ^3 ^4 ^5 ^6 ^7 ^8 ^9] % .MACRO LDH ;LOAD HEX CONSTANT ** **.DO .ARGCT<>2 **: ;LDH ERROR, WRONG NUMBER OF ARGUMENTS **.ENDC ** ** .PUSH ?H ;SAVE ?H **; NOTE: TEMP USED MUST NOT BE USED IN LIT !!! ** .PUSH .RDX ;SAVE CURRENT RADIX ** .RDX 16 ;MAKE IT HEX ** .DUSR ?H = 0^2 ;SET HEX VALUE IN ?H ** .RDX .POP ;RESTORE RADIX ** LDC ^1,?H ** .DUSR ?H = .POP ;RESTORE ?H % ; .EOT ;END SXOF FMAC.SR FSCE.SR 7'.LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1974,1975 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ;************************************************************************ ; * ; NAME: FSCE (RELEASE OF SLA) t * ; * ; * ; * ; * ; * ; DESCRIPTION: * ; * ; THIS ROUTINE RELEASES THE SLA INTERRUPT SERVICE, * ; HARDWARE AND, IF OTHERWISE UNUSED, THE USER CLOCK * ; FSCE MUST BE CALLED ONCE FOR EACH SLA DEVICzE IN USE * ; * ; * ; CALLING SEQUENCE- * ; * ; CALL FSCE (LINE,IERR) * ; * ; WHERE LINE IS LINE # FOR MULTIPLE 4074 DRIVER ELSE IGNORED * ; IERR IS AN ARGUMENT WHICH RETURNS A VALUE * ; INDICATING THE RESULTS OF THE CALL * ; IERR = 1 -> NORMAL RETURN * ; IERR = 13 -> LINE # OUT OF RANGE * ; * ; * ; * ; OTHER ROUTINES OR LIBRARIES REQUIRED: * ; FSCGL * ; SLA.LB * ; * ; * ;************************`************************************************ ** .TITL FSCE ;(RELEASE SLA) .EXTN FSCGL .EXTN SLAE ; RELEASE ROUTINE .EXTN SLTBL ;LINE TABLE .EXTU .NREL ARGS 2 TMPS 0 LINE= ARG0 ;LINE # IERR= ARG1 ;ERROR CODE ISAENTRY FSCE ;DEFINE ENTRY, COPY ARGS ADDRS LDA 1,@LINE,3 ;AC1 = LINE # JSR @.SCGL MOV# 2,2,SNR ;IS LCB ADDRESS 0? JMP BAD ;YES, LINE WAS OUT OF RANGE LDA 0,ML2D ;GET MULT LCB TO DCT OFFSET LDA 1,.MULT ;TEST FOR MULTIPLE DEVICE MOV# 1,1,SZR ;IS IT ? JMP .+3 ;YES 2- MULT LDA 0,SL2D ;NO. GET SINGLE LCB TO DCT OFFSET LDA@ 2,LNTBL ;GET LINE TABLE ADDRESS INTO AC2 ADD 0,2 ;DCT ADDRESS NOW IN AC2 LDA 1,LNTBL ;LINE TABLE IN AC1 JSR@ .SLAE ;CALL ROUTINE ISA.NORM ;ISA NORMAL RETURN BAD: LDA 2,C13 ;ERROR CODE TO AC2 ISA.ERR ;ISA ERROR EXIT SL2D: -5 ;DISPLACEMENT LCB TO DCT SINGLE ML2D: -12 ;DISPLACEMENT LCB TO DCT MULTIPLE C13: 10. ;OUT OF RANGE ERROR CODE .SLAE: SLAE ;SLASP ENTRY(RESET SLA) .SCGL: FSCGL .MULT: MULT ;MULTIPLE DRIVER ASSEMBLY FLAG LN%CTBL: SLTBL ;SLA LINE TABLE .END FSCGL.SR 8.LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1975 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ;***************************************************************** ; ; NAME: FSCGL.SR (LINE TO LCB TRANSLATION) ; ; H; ; DESCRIPTION: ; ; THIS ROUTINE IS USED BY THE OTHER FSC ROUTINES ; TO RETRIEVE THE LCB ADDRESS ASSOCIATED WITH A ; PARTICULAR LINE. THIS IS NOT A FORTRAN CALLABLE ; ROUTINE. ; ; ; AC1 = LINE NUMBER ; AC2 = RETURNED WITH THE LCB ADDRESS OF THE LINE ;z = 0 IF LINE # OUT OF RANGE ; ; ;************************************************************************* .TITLE FSCGL ;(LINE TO LCB TRANSLATION) .ENT FSCGL .EXTN SLTBL .EXTU .NREL FSCGL: .IFN F4SW STA 3,@QSP; SAVE RETURN ADDR FOR FORT4 .ENDC F5SW STA 3,.RP ;SAVE RETURN ADDR FOR FORT5 [F5SW] LDA 3,LNTBL ;GET THE LINE TABLE ADDRESS LDA 0,-1,3 ;GET THE # OF LCBS FROM SLTBL-1 SUBZ# 0,1,SZC ;SKIP IF AC1 # OF LINES ADD 1,3 ;INDEXED ENTRY LDA 27,0,3 ;PICK UP THE LCB ADDRESS OUT: ** LDAFP 3 ;RESTORE FP .IFN F4SW JMP @FAC2,3 ;RETURN TO CALLER .ENDC F5SW JMP @.RP ;RETURN TO CALLER [F5SW] ERR: SUB 2,2 ;GET A 0 IN AC2 JMP OUT ;EXIT LNTBL: SLTBL .END FSCGP.SR 8.LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1974,1975 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ;************************************************************************ ; * ; NAME: FSCGP (GET AN LCB PARAMEBYTER VALUE) * ; * ; * ; * ; * ; DESCRIPTION: * ; * ; THIS ROUTINE ALLOWS THE USER A FORM OF "READ ONLY" * ; ACCESS TO ANY LCB PARAMETER IN HIS SYSTEM. IT IS THE ; RESPONSIBILITY OF THE USER TO INSURE THVAT THE PARAMETER ; VALUE IS CONCURRENT WITH HIS REVISION OF THE SLA PACKAGE. * ; * ; * ; CALLING SEQUENCE- * ; * ; CALL FSCGP (LINE, MPAR, NVAL, IERR) * ; * ; WHERE LINE IS THE LINE NUMBER BEING REFERENCED * ; MPAR} IS THE PARAMETER DISPLACEMENT VALUE * ; NVAL IS THE CONTENTS OF THE LCB AT "MPAR" * ; IERR RETURNS THE RESULT OF THE CALL * ; IERR = 1 NORMAL RETURN * ; IERR = 13 LINE # OUT OF RANGE * ; * ; * ; * ; * ; (OTHER ROUTINES OR LIBRARIES REQUIRED: * ; FSCGL * ; USER-BUILT SLA CONTROL TABLE * ; * ; * ;************************************************************************ ** .TITL FSCGP ;(GET LCB PARAMETER) .EXTN FSCGL .EXTU %.NREL ARGS 4 TMPS 0 ;OFFSETS FROM FRAME POINTER LINE= ARG0 ;LINE # MPAR= ARG1 ;DISPLACEMENT NVAL= ARG2 ;VALUE IERR= ARG3 ;IERR CODE ISAENTRY FSCGP ;DEFINE ENTRY AND COPY ;ARGUMENTS ADDRS ON TO STACK LDA 1,@LINE,3 ;LINE # IN AC1 JSR @.S>CGL ;GET ADDR OF LCB ** LDAFP 3 ;RESTORE FRAME POINTER MOV# 2,2,SNR ;= 0? JMP ER ;YES- ERROR EXIT LDA 1,@MPAR,3 ;DISPLACEMENT INTO AC1 ADD 1,2 ;ADDR OF VALUE LDA 0,0,2 ;GET THAT VALUE STA 0,@NVAL,3 ;SAVE FOR USER ISA.NORM ;ISA NORMAL RETURN yuuER: LDA 2,C13 ;AC2 IS ERROR CODE ISA.ERR ;ISA ERROR RETURN .SCGL: FSCGL C13: 10. ;OUT OF RANGE ERROR(13-3) .END FSCI.SR 9g.LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1974,1975 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ;************************************************************************ ; * ; NAME: FSCI (INITIALIZE SLA) ; + * ; * ; * ; * ; DESCRIPTION: * ;  * ; THIS ROUTINE INITIALIZES THE SLA LINE TABLE, * ; INTERRUPT SERVICE, HARDWARE, AND USER CLOCK, AND MUST BE ; CALLED ONCE FOR EACH SLA DEVICE USED IN THE SYSTEM. * ;  * ; * ; CALLING SEQUENCE- * ; * ; CALL FSCI (LINE,IERR) * ; * ; WHERE LINE IS LINE # FOR MULTIPLE 4074 DRIVER ; ELSE IGNORED * ; IERR IS AN ARGUMENT WHICH RETURNS A VALUE * ; INDICATING THE RESULTS OF THE C)ALL: * ; IERR = 1 -> NORMAL RETURN * ; IERR = 4 -> NO REAL TIME CLOCK * ; IERR = 13 -> LINE # OUT OF RANGE * ; IERR = 31 -> ILLEGAL DEVICE CODE * ; IERR = 38 -> DEVICE CODE IN USE * ; * ; * ; * ; OTHER ROUTINES OR LIBRARIES REQUIRED: * ; FSCGL * ; SLA.LB * ; * ; * ;************************************************************************ ** .TITL FSCI ;(INITIALIZE SLA) .EXTN FSCGL .EXTN SLAI ; INIT ROUTINE .EXTN SLTBL ;LINE TABLE .EXTU .NREL ARGS 2 TMPS 0 LINE= ARG0  ;LINE # IERR= ARG1 ;IERR CODE ISAENTRY FSCI ;DEFINE ENTRY AND COPY ARGS ADDRS LDA 1,@LINE,3 ;AC1 = LINE # JSR @.SCGL ;GET LCB ADDR MOV# 2,2,SNR ;IS LCB ADDRESS 0? JMP BAD ;YES, LINE WAS OUT Oy F RANGE LDA 0,ML2D ;GET MULT LCB OFFSET TO DCT LDA 1,.MULT ;TEST FOR MULTIPLE DEVICE MOV# 1,1,SZR ; IS IT? JMP .+3 ;YES - MULT LDA 0,SL2D ;GET SINGLE LCB TO DCT OFFSET LDA@ 2,LNTBL ;GET LINE TABLE ADDRESS IN AC2 ADD 0,2 ;DCT ADDRESS NOW IN AC2 LDA 1,LNTBL ;LINE TABLE IN AC1 JSR@ .SLAI ;CALL ROUTINE ISA.ERR ;ISA ERROR RETURN ISA.NORM ;ISA NORMAL RETURN BAD: LDA 2,C13 ;OUT OR RANGE ERROR ISA.ERR ;ISA ERROR RETURN SL2D: -5 ;DISPLACEMENT LCB TO DCT SINGLE ML2D: -12 ;DISPLACEMENT pLCB TO DCT MULTIPLE C13: 10. ;OUT OF RANGE ERROR CODE .SLAI: SLAI ;SLA ROUTINE .SCGL: FSCGL .MULT: MULT ;MULTIPLE DRIVER ASSEMBLY FLAG LNTBL: SLTBL ;SLA LINE TABLE .END FSCMS.SR 93.LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1974,1975 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ; ;************************************************************************ ; * ; NAME: FSCMS (CHECK MODEM STAT$US) * ; * ; * ; * ; * ; DESCRIPTION: * ; * ; THIS ROUTINE RETURNS WITH THE MODEM STATUS FOR THE * ; SPECIFIED LINE. * ; * ; * ; CALLING SEQUENCE- * ; * ; CALL FSCMS (LINE, IS0, IERR) * ; * ; WHERE LINE IS THE NUMBER OF THE LINE BEING USED * ; IS0 IS THE MODEM STATUS * ; IERR IS AN ARGUMENT WHICH RETURNS A VALUE * ; INDICATING THE RESULTS OF THE CALL: * ; IERR = 1 -> NORMAL RETURN * ; IERR =2 3 -> MODEM NOT READY * ; IERR = 13 -> LINE # OUT OF RANGE * ; * ; * ; * ; * ; OTHER ROUTINES OR LIBRARIES REQUIRED: * ; FSCGL * ; SLA.LB * ; * ; * ;************************************W************************************ ** .TITL FSCMS ;(CHECK MODEM STATUS) .EXTN FSCGL,SLAM .EXTU .NREL ARGS 3 ;ARGUMENTS TMPS 0 ;NO TEMPS ;OFFSETS FROM FRAME POINTER LINE= ARG0 ;LINE # IS0= ARG1 ;AC0 CODE IERR= ARG2 ;IERR CODE ISIAENTRY FSCMS ;DEFINE ENTRY & COPY ARGUMENTS ADDRS LDA 1,@LINE,3 ;LINE # IN AC1 JSR @.SCGL ;GET ADDR OF LCB LDA 0,C13 ;ERROR CODE IN AC0 MOV# 2,2,SNR ;LCB ADDR 0? JMP EXX ;YES, ERROR JSR @.SLAM ;GET MODEM STATUS ** LDAFP 3 ;RESTORE FP MOVZR Bq1,1 ;SCALE STATUS WORD MOVZR 1,1 STA 1,@IS0,3 ;SAVE FOR USER MOV# 0,0,SZR ;IF 0, MODEM NOT READY ISA.NORM ;ISA NORMAL RETURN EXX: MOV 0,2 ;ERR CODE TO AC2 ISA.ERR ;ISA ERROR RETURN .SLAM: SLAM ;SLA ENTRY .SCGL: FSCGL C13: 10. ;OUT OF RANGE ERROR(13-3) .END FSCRO.SR :".LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1974,1975 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ;************************************************************************ ; * ; NAME: FSCRO (OPEN LINE FOR RECEIVE) * ; * ; * ; * ; * ; DESCRIPTION: * ; * ; THIS ROUTINE INITIALIZES THE RECEIVER AND VARIOUS * ; CONTROL REGISTERS WITHIN THE "LCB". "FSCST" IS USED TO * ; WAIT FOR "ENQ" LINE BID FROM THE REMOTE TERMINAL. * ; * ; * ; CALLING SEQUENCE- * ; * ; CALL FSCRO (LINE, IERR) * ; * ; WHERE LINE IS THE NUMBER OF THE LINE BEING USED * ; IERR IS AN ARGUMENT WHICH RETURNS A VALUE * ; INDICATING THE RESULTS OF THE QCALL: * ; IERR = 1 -> NORMAL RETURN * ; IERR = 3 -> MODEM NOT READY * ; IERR = 13 -> LINE # OUT OF RANGE * ; IERR = 14 -> LINE ALREADY OPEN * ; * ; A CALL TO "FSCST" MUST BE ISSUED ON THE NORMAL RETURN. * ; * ; * ; * ; * ; OTHER ROUTINES OR LIBRARIES REQUIRED: * ; FSCGL * ; SLA.LB * ; * ; * ;************************************************************************ ** .TITL FSCRO ;(OPEN LINE FOR RECEIVE) .EXTN FSCG"L,SYNRO .EXTU .NREL ARGS 2 TMPS 0 ;OFFSETS FROM FRAME POINTER LINE= ARG0 ;LINE # IERR= ARG1 ;IERR CODE ISAENTRY FSCRO ;DEFINE ENTRY & COPY ARGUMENTS ADDRS LDA 1,@LINE,3 ;LINE # IN AC1 JSR @.SCGL ;GET ADDR OF LCB LDA 0,C13 ;ERROR CODE TO AC0 MOV# 2,2,SNR ;LCB ADDR 0? JMP BAD ;YES, ERROR LDA 0,LCMDE,2 ;GET MODE CODE LDA 1,C3 ;COMPARE TO 3 MOV# 0,0,SZR ;0? OK IF TRUE SUBZ# 0,1,SNR ;=3?,OK JMP OK ;GOOD JMP BAD1 ;NO,ALREADY BUSY OK: JSR @.SNRO ;DO RCV OPEN (SYNCP) JMP KBAD ;ERROR RETURN ISA.NORM ;ISA NORMAL RETURN BAD: MOV 0,2,SKP ;ERROR CODE TO AC2 BAD1: LDA 2,C14 ;LINE BUSY ERROR CODE ISA.ERR ;ISA ERROR EXIT .SNRO: SYNRO ;SYNCP ENTRY(RECV. OPEN) .SCGL: FSCGL C14: 11. ;LINE BUSY(14-3) C13: 10. ;OUT OF RANGE!V(13-3) C3: 3 ;MODE CODE .END FSCRX.SR Q.LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1974,1975 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ;************************************************************************ ; * ; NAME: FSCRX (RECEIVE ONE RECORiD) * ; * ; * ; * ; * ; DESCRIPTION: * ; * ; THIS ROUTINE HANDLES MESSAGE BLOCKS CONTAINING BOTH * ; VARIABLE AND FIXED LENGTH RECORDS. * ; * ; "FSCST" MUST BE CALLED WHEN INDICATION OF AN EMPTY * ; BUFFER IS GIVEN (IERR = 2), AND MUST NOT BE CALLED WHEN THE * ; ROUTINE RETURNS WITH A NORMAL INDICATOR (IERR = 1). IF THE * ; LINE BUFFER HAS NO VALID RECORDS, EMPTY RETURN IS TAKEN * ; AND THE USER MUST WAIT IN "FSCST" FOR A NEW BUFFER. IF LM* ; A RECORD IS LEFT IN THE BUFFER, SUBROUTINE TRANSLATES * ; EACH BYTE OF THE RECORD FROM LINE CODE TO ASCII (EXCEPT * ; RECORDS RECEIVED IN TRANSPARENT MODE) AND PLACES RECORD * ; IN THE USER AREA. "NBYTES" CONTAINS THE NUMBER * ; OF BYTES IN THE RECORD. IF RECORD IS FOLLOWED BY AN END- * ; OF-FILE MARK (I.E. "ETX"), "LCB" PARAMETER "LCLST" IS * ; SET TO ONE. IN ALL OTHER CASES,PARAMETER WILL BE ZERO. * ; PARAMETER "LCAC1" IS UPDATED TO CONTAIN RECEIVED BYTE * ; COUNT. IF RECORD WAS RECEIVED IN TRANSDPARENT MODE, THE * ; PARAMETER "LCCP4" IS SET TO 1. OTHERWISE, IT IS SET TO * ; ZERO. ; * ;************************************************************************ ;************************************************************************ ;  * ; * ; CALLING SEQUENCE- * ; * ; CALL FSCRX (LINE, NBUFF, NBYTES, KBYTES, IERR) * ; * ; WHERE LINE IS THE NUMBER OF THE LINE BEING USED * ; NBUFF IS AN INTEGER ARRAY INTO WHICH THE DATA * ; IS TO BE RECEIVED * ; NBYTES IS THE MAXIMUM BYTE COUNT REQUESTED * ; KBYTES IS THE COUNT OF BYTES RECEIVED ; IERR IS AN ARGUMENT WHICH RETURNS A VALUE * ; INDICATING THE RESULTS OF THE CALL: * ; IERR = 1 -> NORMAL RETURN * ; IERR = 2 -> BUFFER EMPTY * ; IE`RR = 3 -> MODEM NOT READY * ; IERR = 9 -> LINE NOT OPEN FOR RECEIVE * ; IERR = 10 -> RECORD SIZE EXCEEDS CALLER * ; BYTE COUNT * ; IERR = 13 -> LINE # OUT OF RANGE * ; * ; * ; * ; * ; OTHER ROUTINES OR LIB`mRARIES REQUIRED: * ; FSCGL * ; SLA.LB * ; * ; * ;************************************************************************ ** .TITL FSCRX ;(RECEIVE A RECORD) .EXTN FSCGL,SYNRX .EXTU .NREL ARGS 5 TMPS 0 ;OFFSETS FR2OM FRAME POINTER LINE= ARG0 ;LINE # NBUFF= ARG1 ;WORD ADDRESS OF DATA NBYTES= ARG2  ;BYTE COUNT KBYTES= ARG3 ;RETURNED BYTE COUNT IERR= ARG4 ;IERR CODE ISAENTRY FSCRX ;DEFINE ENTRY & COPY ARGUMENTS ADDRS LDA 1,@LINE,3 ;GET LINE # INTO AC1 JfSR @.SCGL ;GET ADDR OF LCB LDA 0,C13 ;ERROR CODE IN AC0 ** LDAFP 3 ;RESTORE FRAME POINTER MOV# 2,2,SNR ;LCB ADDR 0? JMP ER ;YES, ERROR LDA 0,NBUFF,3 ;AC0=BUFFER WD ADDR MOVZL 0,0 ;CHANGE TO BYTE PTR LDA 1,@NBYTES,3 ;AC1=BYTE COUNT JSR@ .SNRX ;CALL RCV ROUTINE JMP ER ;ERROR RETURN JMP EMPTB ;WE'RE EMPTY, BUFF SHIPPED ** LDAFP 3 ;AC3=FRAME PTR STA 1,@KBYTES,3 ;STORE RECEIVED BYTE COUNT ISA.NORM ;ISA NORMAL RETURN EMPTB: LDA 0,M1 ;MAKE AC0=-1 ER: MOV 0,2 ;ERROR CODE TO AC2 ISA.ERA,R ;ISA ERROR RETURN .SNRX: SYNRX ;SYNCP ENTRY(RECEIVE ONE RECORD) .SCGL: FSCGL M1: -1 C13: 10. ;OUT OF RANGE ERROR CODE .END LDA 0,M1 ;MAKE AC0=-1 FSCST.SR <.LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1974,1975 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ;************************************************************************ ; * ; NAME: FSCST (CHECK LINE STATUS) * ; * ; * ; * ; * ; DESCRIPTION: * ; * ; THIS ROUTINE IS USED TO WAIT FOR THE COMPLETION OF * ; TRANSMIT AND RECEIVE OPERATIONS, AND PERFORMS ALL LINE * ; PROTOCOL AS REQUIRED. THE BUSY RETURN(IERR=D2) FROM THIS * ; CALL IMPLIES THAT THE TRANSMIT OR RECEIVE OPERATION IS * ; NOT COMPLETE AND THAT "FSCST" MUST BE CALLED ONCE AGAIN. * ; * ; * ; CALLING SEQUENCE- * ; * ; CALL FSCST (LINE, IERR) * ; * ; WHERE LINE IS THE NUMBER OF THE LINE BEING USED * ; IERR IS AN ARGUMENT WHICH RETURNS A VALUE * ; INDICATING THE RESULTS OF THE CALL: * ; IERR = 1 -> NORMAL RETURN * ; IERR = 2 -> BUSY * ; IERR = 3 -> MODEM NOT READY * ; IERR = 4 -> RETRY C OUNT EXHAUSTED, * ; OPERATION FAILED, ; LINE IS CLOSED * ; IERR = 5 -> "EOT" RECEIVED, LINE CLOSED * ;  IERR = 6 -> DISCONNECT MESSAGE (DLE-EOT) * ; RECEIVED, LINE IS CLOSED * ; IERR = 7 -> REVERSE INTERRUPT ("RVI") * ; RECEIVEDas ON TRANSMIT * ; IERR = 13 -> LINE # OUT OF RANGE * ; * ; * ; * ; * ; OTHER ROUTINES OR LIBRARIES REQUIRED: * ; FSCGL * ; SLA.LB * ; * ; * ;***********************************************̘************************* ** .TITL FSCST ;(CHECK LINE STATUS) .EXTN SYNST,FSCGL .EXTU .NREL ARGS 2 TMPS 0 ;OFFSETS FROM FRAME POINTER LINE= ARG0 ;LINE # IERR= ARG1 ;IERR CODE ISAENTRY FSCST ;DEFINE ENTRY & COPY ARGUMENTS ADDRS LDA 1,@LI NE,3 ;AC1 = LINE # JSR @.SCGL ;GET ADDR OF LCB LDA 0,C13 ;ERROR CODE TO AC0 MOV# 2,2,SZR ;LCB ADDR 0? JSR@ .SNST ;CALL SYNST JMP XXBAD ;ERROR RETURN ADC 0,0,SKP ;BUSY-AC0=2-3(ERROR CODE) ISA.NORM ;ISA NORMAL EXIT XXBAD: MOV 0,2 ;ERROR CODEc TO AC2 ISA.ERR ;ERROR RETURN .SNST: SYNST ;SYNCP ENTRY(CHECK STATUS) .SCGL: FSCGL C13: 10. ;OUT OF RANGE(13-3) .END FSCTC.SR .LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1974,1975 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ;************************************************************************ ; * ; NAME: FSCTC (CLOSE A LINE WITHy EOT OR DLE-EOT) * ; * ; * ; * ; * ; DESCRIPTION: * ; FSCTC; * ; THIS ROUTINE SENDS AN "EOT" TO THE REMOTE TERMINAL AND * ; RESETS VARIOUS CONTROL REGISTERS WITHIN THE "LCB" * ; * ; FSCTD; * F; THIS ROUTINE SENDS A "DLE-EOT" TO THE REMOTE TERMINAL * ; AND RESETS VARIOUS CONTROL REGISTERS WITHIN THE "LCB". * ; * ; * ; CALLING SEQUENCE- * ; * ; CALL FSCTC (LINE, IERR) * ; OR * ; CALL FSCTD (LINE, IERR) z * ; * ; WHERE LINE IS THE NUMBER OF THE LINE BEING USED * ; IERR IS AN ARGUMENT WHICH RETURNS A VALUE * ; INDICATING THE RESULTS OF THE CALL: * ; IERR = 1 -> NORMAL RETURN * ; IERR = 3 -> MODEM NOT READY * ; IERR = 13 -> LINE NEUMBER OUT OF RANGE * ; * ; A CALL TO "FSCST" MUST BE ISSUED ON THE NORMAL RETURN. * ; * ; * ; * ; * ; OTHER ROUTINES OR LIBRARIES REQUIRED: * ; FSCGL * ; SLA.LB * ; * ; * ;*********~*************************************************************** ** .TITL FSCTC ;(CLOSE A LINE-EOT/DLE EOT) .EXTN FSCGL .EXTN SYNTC,SYNDT .EXTU .NREL ARGS 2 TMPS 1 ;OFFSETS FROM FRAME POINTER LINE= ARG0 ;LINE $ IERR= ARG1 ;IERR CODE TRADD= F0OFLE ;ADDRESS OF SELECTED ROUTINE ISAENTRY FSCTC ;DEFINE ENTRY,COPY ARGUMENTS ADDRS LDA 0,.SNTC JMP CLCOM ISAENTRY FSCTD ;DEFINE ENTRY LDA 0,.SNTD ;GET ROUTINE ADDRESS ;ARG0(LINE) IN AC1 CLCOM: STA 0,TRADD,3 LDA 1,@LINE,3 ;LINE # IN AC1 JSR @.SCGL ;GET ADDR OF LCB LDA 0,C13 ;ERROR CODE IN AC0 ** LDAFP 3 ;RESTORE FRAME PTR MOV# 2,2,SZR ;LCB ADDR 0? JSR@ TRADD,3 ;CALL CLOSE ROUTINE MOV 0,2,SKP ;ERROR CODE TO AC2 ISA.NORM ;ISA NORMAL RETURN ISA.ERR ;ISA ERROR RETURN .SNTC: kSYNTC ;SYNCP ENTRY(CLOSE WITH DLE-EOT) .SNTD: SYNDT ;SYNCP ENTRY(CLOSE WITH EOT) .SCGL: FSCGL C13: 10. ;OUT OF RANGE(13-3) .END FSCTE.SR  .LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1974,1975 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ;************************************************************************ ; * ; NAME: FSCTE (XMT BUFFER AND INNDICATE END-OF-FILE) * ; * ; * ; * ; * ; DESCRIPTION: * ; * ; THIS ROUTINE TRANSMITS CONTENTS OF THE LINE BUFFER * ; WITH THE END-OF-FILE ("ETX") INDICATOR. "FSCTE" MUST BE * ; CALLED AFTER LAST RECORD HAS BEEN TRANSMITTED VIA "FSCTX" * ; OR "FSCTT". "FSCST" MUST BE CALLED WHEN A NORMAL RETURN * ; IS INDICATED (IERR = 1). * ; * ; * ; CALLING SEQUENCE- * ; * ; CALL FSCTE (LINE, IERR) * ;  * ; WHERE LINE IS THE NUMBER OF THE LINE BEING USED * ; IERR IS AN ARGUMENT WHICH RETURNS A VALUE * ; INDICATING THE RESULTS OF THE CALL: * ; IERR = 1 -> NORMAL RETURN * ; IERR = 3 -> MODEM NOT READY * ; IERR = 8 -> LINE NOT OPEN FOR TRANSMIT * ; IERR = 12 -> LINE BUFFER EMPTY ON CALL, * ; NOTHING SENT * ; IERR = 13 -> LINE NUMBER OUT OF RANGE * ; * ; A CALL TO "FSCST" MUST BE ISSUED ON THE NORMAL RETURN. * ; * ; * ; * ;  * ; OTHER ROUTINES OR LIBRARIES hREQUIRED: * ; FSCGL * ; SLA.LB * ; * ; * ;************************************************************************ ** .TITL FSCTE ;(XMIT BUFFER AND INDICATE EOF) .EXTN SYNTE,FSCGL .EXTU .NREL ARGS 2 TMPS 0 ;OFFSETS{^ FROM FRAME POINTER LINE= ARG0 ;LINE # IERR= ARG1 ;IERR CODE ISAENTRY FSCTE ;DEFINE ENTRY,COPY ARGUMENTS ADDRS LDA 1,@LINE,3 ;LINE # IN AC1 JSR @.SCGL ;GET ADDR OF LCB LDA 0,C13 ;ERROR CODE TO AC0 MOV# 2,2,SZR ;LCB ADDR 0? JSR@ .SNTE JMP BAD ;ERROR RETURN ISA.NORM ;ISA NORMAL RETURN LDA 0,C12 ;BUFFER WAS EMPTY-GIVE 12 BAD: MOV 0,2 ;ERROR CODE TO AC2 ISA.ERR ;ISA ERROR EXIT .SNTE: SYNTE ;SYNCP ENTRY(XMIT WITH EOF) .SCGL: FSCGL C12: 9. ;BUFFER EMPTY(12-3) C13: 10. ;OUT OF RANusGE(13-3) .END FSCTO.SR $.LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1974,1975 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ;************************************************************************ ; * ; NAME: FSCTO (OPEN LINE FOR TRAپNSMIT) * ; * ; * ; * ; * ; DESCRIPTION: * ; * ; THIS ROUTINE SENDS "ENQ" TO THE REMOTE TERMINAL & * ; SETS UP THE RECEIVER FOR THE RESPONSE. VARIOUS CONTROL * ; REGISTERS WITHIN THE "LCB" ARE INITIALIZ5PED. * ; * ; * ; CALLING SEQUENCE- * ; * ; CALL FSCTO (LINE, IERR) * ; * ; WHERE LINE IS THE NUMBER OF THE LINE BEING USED * ; IERR IS AN ARGUMENT WHICH RETURNS A VALUE * ; INDICATING THE RESULT OF THE CALL: P * ; IERR = 1 -> NORMAL RETURN * ; IERR = 3 -> MODEM NOT READY * ; IERR = 13 -> LINE NUMBER OUT OF RANGE * ; IERR = 14 -> LINE ALREADY IN USE * ; * ; A CALL TO "FSCST" MUST BE ISSUED ON THE NORMAL RETURN. * ; * ; * KA; * ; * ; OTHER ROUTINES OR LIBRARIES REQUIRED: * ; FSCGL * ; SLA.LB * ; * ; * ;************************************************************************ ** .TITL FSCTO ;(OPEN LINE FOR XMIT) .EXTN SYNTO,FSGCGL .EXTU .NREL ARGS 2 TMPS 0 ;OFFSETS FROM FRAME POINTER LINE= ARG0 ;LINE # IERR= ARG1 ;IERR CODE ISAENTRY FSCTO ;DEFINE ENTRY ,COPY ARGUMENTS ADDRS LDA 1,@LINE,3 ;LINE # IN AC1 JSR @.SCGL ;GET ADDR OF LCB LDA 0,C13 ;ERROR CODE TO AC0 w MOV# 2,2,SNR ;LCB ADDR 0? JMP BAD ;YES, ERROR LDA 0,LCMDE,2 ;GET MODE CODE LDA 1,C3 ;COMPARE TO 3 MOVZR# 0,0,SZR ;=0 OR 1,OK SUBZ# 1,0,SNR ;=3,OK JMP OK ;GOOD JMP BAD1 ;NO,ALREADY BUSY OK: JSR @.SNTO ;DO RCV OPEN (SYNCP) JMP BAD ;ERROR RETURN ISA.NORM ;ISA NORMAL RETURN BAD: MOV 0,2,SKP ;ERROR CODE TO AC2 BAD1: LDA 2,C14 ;BUSY ERROR CODE ISA.ERR ;ISA ERROR RETURN .SCGL: FSCGL .SNTO: SYNTO ;SYNCP ENTRY(XMIT OPEN) C14: 11. ;LINE BUSY(14-3) C13: 10. ;OUT OF RANGE(13-3) C3:H 3 ;MODE CODE .END FSCTX.SR [.LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1974,1975 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ;************************************************************************ ; * ; NAME: FSCTX (XMT ONE RECORD-TRANS./NON TRANS.) * ; * ; * ; * ; * ; DESCRIPTION: * ; * ; THIS ROUTINE ATTEMPTS TO PLACE RECORD CONTAINED IN * ; "BUFF" (PACKED LEFT TO RIGHT)INTO LINE BUFFER. "FSCTT" * ; IS USED IF RECORD IS TO BE SENT USING TRANSPARENT TRANS- * ; MISSION. OTHERWISE, "FSCTX" USED TRANSLATING EACH BYTE * ; FROM ASCII TO LINE CODE WHEN PLACED IN THE LINE BUFFER. * ; THE NORMAL RETURN IS TAKEN IF RECORD HAS BEEN ACCEPTED; * ; THE USER MAY THEN PROCEED TO FETCH THE NEXT RECORD. * ; * ; IF CURRENT RECORD WILL NOT FIT INTO LINE BUFFER, * ; BUFFER IS TRANSMITTED, THE FULL RETURN IS INDICATED IN * ; "IERR",AND USER MUST CALL "FSCST" TO WAIT FOR COMPLETION * ; OF THE TRANSMISSION. "FSCST" MUST BE CALLED WHEN "IE(RR" * ; INDICATES THAT BUFFER WAS FULL, AND MUST NOT BE CALLED * ; ON A NORMAL RETURN. UPON SUCCESSFUL RETURN FROM "FSCST", * ; THE USER MUST ONCE AGAIN ATTEMPT TO PLACE THE RECORD * ; IN THE BUFFER. THIS ROUTINE NEVER BOTH INSERTS THE * ; RECORD INTO TMHE BUFFER AND TRANSMITS THE BUFFER. * ; * ; * ;************************************************************************ ;************************************************************************ ; * ; * ; CALLING SEQUENCE- * ; * ; CALL FSCTX (LINE, NBUFF, NBYTES, IERR) * ; OR * ; CALL FSCTT (LINE, NBUFF, NBYTES, IERR) * ; * ; WHERE LINE IS THE NUMBER OF THE LINE BEING USED * ; NBUFF IS AN INTEGER ARRAY CONTAINING THE DATA * ; WHICH  IS TO BE SENT * ; NBYTES IS THE BYTE COUNT OF CHARACTERS TO BE SENT * ; IERR IS AN ARGUMENT WHICH RETURNS A VALUE * ; INDICATING THE RESULTS OF THE CALL: * ; IERR = 1 -> NORMAL RETURN * ; IERR = 2 -> BUFFER FULL * ; IERR = 3 -> MODEM XNOT READY  * ; IERR = 8 -> LINE NOT OPEN FOR TRANSMISSION * ; IERR = 11 -> RECORD > MAX BUFFER LENGTH * ; IERR = 13 -> LINE NUMBER OUT OF RANGE * ; * ; * ; * ; * ; OTHER ROUTINES OR LIBRARIES REQUIRED: * ; FSCGL * ; SLA.LB * ; * ; * ;************************************************************************ ** .TITL FSCTX ;(XMIT RECORD-TRANS./NON-TRANS.) .EXTN FSCGL .EXTN SYNTX,SYNTT .EXTU .NREL ARGS 4 TMPS 1 ;OFFSETS FROM FR AME POINTER LINE= ARG0 ;LINE # NBUFF= ARG1 ;WORD ADDRESS OF DATA NBYTES= ARG2 ;DESIRED BYTE COUNT IERR= ARG3 ;IERR CODE TRADD= FFLE ;ADDRESS OF SELECTED ROUTINE ISAENTRY FSCTX ;DEFINE ENTRY, COPY ARGUMENTS ADDRS LDA 0,.SNTX JMP TXCOM ISAENTRY FSCTT ;DEFINE THIS ENTRY LDA 0,.SNTT ;GET ROUTINE ADDRESS ;ARG0(LINE) IN AC1 TXCOM: STA 0,TRADD,3 LDA 1,@LINE,3 ;LINE # IN AC1 JSR @.SCGL ;GET ADDR OF LCB LDA 0,C13 ;ERROR CODE TO AC0 ** LDAFP 3 ;RESTORE FRAME PTR MOV# 2,2,SNR ;LCB AKDDR 0? JMP BAD ;YES, ERROR LDA 0,NBUFF,3 ;AC0=BUFFER WORD ADDR MOVZL 0,0 ;CHAGE TO BYTE PTR LDA 1,@NBYTES,3 ;AC1=BYTE COUNT JSR@ TRADD,3 ;CALL XMT ROUTINE JMP BAD ;ERROR RETURN JMP BAD+1 ;FULL,BUFFER SHIP ISA.NORM ;ISA NORMAL EXIT BAD: NMOV 0,2,SKP ;ERROR CODE TO AC2 LDA 2,C2 ;FULL BUFFER CODE ISA.ERR ;ISA ERROR EXIT .SNTX: SYNTX ;SYNCP ENTRY(XMIT NON-TRANS) .SNTT: SYNTT ;SYNCP ENTRY(XMIT TRANS) .SCGL: FSCGL C2: -1 ;BUFFER FULL(2-3) C13: 10. ;OUT OF RANGE(13-3) .END FSCXI.SR S.LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1974,1975 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ;**************************************************************** ; ; NAME: FSCXI (INITIALIZE LINE FOR .IXMT) ; ; ; ; DESCRIPTION: ; ; THIS ROUTINE ENABLES THE .IXMT MESSAGE COMPLETION ; OPTION TO BE USED BY A LINE RUNNING UNDER THE 'FSC' ; PACKAGE. FSCXI MUST BE CALLED ONCE FOR EACH LINE ; USING THIS FACILITY. ; ; ; CALLING SEQUENCE: ; ; CALL FSCXI(LINE,KEY,IERR) ; ; WHERE LINE IS THE LINE BEING INITIALIZED ; KEY IS AN INTEGER ARRAY USED FOR SIGNALING THIS ; LINE. ; IERR RETURNS A VALUE INDICATING THE RESULT OF THE ; CALL. ; ; ; ;************************************************************************* *?* .TITL FSCXI ;(INITIALIZE LINE FOR .IXMT) .EXTN FSCGL .EXTN FSXMT,FSKEY .EXTU .NREL ARGS 3 TMPS 0 ;OFFSETS FROM FRAME POINTER LINE= ARG0 ;LINE # KEY= ARG1 ;MESSAGE KEY IERR= ARG2 ;IERR CODE ISAENTRY FSCXI ;DEFINE ENTRY , COPY ARGUMENTSy ADDRS LDA 1,@LINE,3 ;AC1 = LINE # JSR @.SCGL ;GET ADDR OF LCB LDAFP 3 ;RESTORE FRAME PTR MOV# 2,2,SNR ;LCB ADDR 0? JMP BAD ;YES, ERROR LDA 1,.XRUT ;NO,GET ADDR OF IXMT ROUTINE STA 1,LCRIX,2 ;PUT INTO LCB FOR RCV SIDE STA 1,LCTIX,2 ;PUT INTO LCB FOR XMT SIDE LDA 1,KEY,3 ;GET ARRAY SLOT LDA 0,@LINE,3 ;GET LINE # SUB 0,1 ;COMPUTE TOP OF ARRAY STA 1,@.FKEY ;SAVE IN IXMT ROUTINE ISA.NORM ;ISA NORMAL EXIT BAD: LDA 2,C13 ;OUT OF RANGE ENTRY POINT ISA.ERR ;ISA ERROR EXIT .FKEY: FSKEY s;TOP OF COMMUNICATE ARRAY .XRUT: FSXMT ;IXMT ROUTINE ADDRESS .SCGL: FSCGL C13: 10. ;OUT OF RANGE(13-3) .END FSCXL.SR %8.LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1974,1975 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ;************************************************************************ ; * ; NAME: FSCXL (LINE TO LCB TRANS[ LATION) * ; * ; * ; * ; * ; DESCRIPTION: * ; * ; THIS ROUTINE CAN BE USED TO RETRIEVE THE LCB ; ADDRESS ASSOCIATED WITH A PARTICULAR LINE ; * ; CALLING SEQUENCE- * ; * ; CALL FSCXL (LINE, LCBAD) * ; * ; WHERE LINE IS THE LINE NUMBER BEING REFERENCED * ; LCBAD IS THE LCB ADDRESS FOR THE LINE * ; LCBAD = 0 IF LINE # OUT OF RANGE * ; * ; * ; * ; * ; OTHER ROUTINES OR LIBRARIES REQUIRED: `L* ; USER-BUILT SLA CONTROL TABLE * ; * ; * ;************************************************************************ ** .TITL FSCXL ;(LINE TO LCB TRANSLATION) .EXTN SLTBL .EXTU .NREL ARGS 2 TMPS 0 ;OFFSETS FROM FRAME POINTER yLINE= ARG0 ;LINE NUMBER ADLCB= ARG1 ;LCB ADDRESS ISAENTRY FSCXL ;DEFINE ENTRY, COPY ARGUMENTS ADDRS LDA 0,@LINE,3 ;GET LINE # LDA 2,LNTBL ;AND LINE TABLE ADDR LDA 1,-1,2 ;EXTRACT # OF LINES (LCB'S) SUBZ# 1,0,SNC ;SKIP IF AC0>=AC1, ALL OK ADD: 0,2,SKP ;INDEXED ENTRY SUB 0,0,SKP ;RETURN 0 IF OUT OF RANGE LDA 0,0,2 ;PICK UP LCB ADDR STA 0,@ADLCB,3 ;SAVE FOR CALLER FRET ;RETURN TO CALLER LNTBL: SLTBL ;SLA LINE TABLE .END FSDVR.FR S.LCNS C COPYRIGHT (C) DATA GENERAL CORPORATION,1974,1975 C ALL RIGHTS RESERVED C LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION C SAMPLE FORTRAN PROGRAM ILLUSTRATING THE USE OF THE FSC PACKAGE C C CONTROL IS MAINTAINED THROUGH A CONTROL CAONSOLE WHICH IS RUN C BY A SEPERATE TASK: TTYTK C C EXTERNAL TTYTK C COMMON /XYZ/ IABORT, ITTY, NAME(10) C DIMENSION NBUFF(70) C C----- I/O CHANNELS C IOCH0 = 0 IOCH1 = 1 IOCH2 = 2 IOCH3 = 3 C C-- SLA PARAMETERS LINE = 0 LCLST = 20K C C--- NMAX =136 NTMAX = 80 IST2 = 0 IABORT = 0 ITTY = 0 C C----- OPEN I/O GOODIES C CALL OPEN (IOCH0, "$TTI", 2, IERR) CALL OPEN (IOCH1, "$TTO", 2, IERR) CALL OPEN (IOCH2, "$LPT", 2, IERR) C C----- INIT SLA C CALL FSCI (LINE,IERR) IF (IERR .NE. 1) STOP 9999 C C----- INIT 2NDARY TASK C CALL ITASK (TTYTK, 0, 0, IERR) IF (IERR .NE. 1) STOP 9999 C C----- STARTUP PROCEDURE C 90 CALL FSCMS (LINE, IS0, IETRR) IF (IERR .EQ. 13) GO TO 957 IF (IERR .EQ. 3) GO TO 355 C 99 WRITE (IOCH1) "READY" C C-- RTY OPENING FOR REC. 101 CALL FSCRO (LINE, IERR) IF (IERR .EQ. 14) GO TO 958 IF (IERR .EQ. 13) GO TO 957 IF (IERR .NE. 1) GO TO 355 C C-- SAMPLE LINE STATUS 110 CALL FSCST (LINE, IERR) IF (IERR .EQ. 13) GO TO 957 IF (IERR-2) 500, 121, 101 C 121 CALL FDELY(1) IF (IABORT .NE. 0) GO TO 800 IF (ITTY .NE. 0) GO TO 800 GO TO 110 C C-- NOT SET YET ݺ 355 WRITE (IOCH1) "DATASET NOT READY" C 360 CALL FSCMS (LINE, IS0, IERR) IF (IERR .EQ. 13) GO TO 957 IF (IERR .NE. 3) GO TO 99 CALL FDELY (1) IF (IABORT .NE. 0) GO TO 800 GO TO 360 C C----- GENERAL REC. LOOP C 500 WRI TE (IOCH1) "LINE OPEN" C 520 CALL FSCRX (LINE, NBUFF, NMAX, KBYTES, IERR) IF (IERR .EQ. 13) GO TO 957 IF (IERR-2) 525, 610, 600 C 525 WRITE (IOCH2, 01) NBUFF(2) 01 FORMAT (1X,S80) IST2 = 1 C CALL FSCGP (LINE, LCLST, ITEST, !IERR) IF (IERR .EQ. 13) GO TO 957 IF (ITEST .EQ. 0) GO TO 520 IST2 = 0 GO TO 520 C C--- LINE FAILURE 600 IF (IST2 .EQ. 0) GO TO 90 C IST2 = 0 WRITE (IOCH1) "LINE FAILED DURING RECEIVE" GO TO 90 C 610 CALL FSCST (LINE, IERR) IF (IERR .EQ. 13) GO TO 957 IF (IERR-2) 520, 625, 600 C 625 CALL FDELY(1) IF (IABORT .EQ. 0) GO TO 610 IST2 = 0 C C----- ABORTION C 800 IF (IABORT .EQ. 1) GO TO 900 IF (ITTY .EQ. 1 ) GO TO 950 C C[-- PLAY IT AGAIN SAM (WHAT DO YOU WANT) WRITE (IOCH1) "??" GO TO 90 C C--- DRIBBLE C 900 IABORT = 0 CALL FSCE (LINE, IERR) CALL RESET GO TO 9999 C C--- SOMEONES CALLING C 950 ITTY = 0 CALL OPEN (IOCH3,NAME,2,IERR) } IF (IERR .NE. 1) GO TO 975 C CALL FSCTO (LINE,IERR) IF (IERR .EQ. 14) GO TO 958 IF (IERR .EQ. 13) GO TO 957 IF(IERR.NE.1) GO TO 1024 ; CLOSE C 952 CALL FSCST (LINE,IERR) IF (IERR .EQ. 13) GO TO 957 IF (IERR-2) 96M0, 954, 1001 C 954 CALL FDELY(1) GO TO 952 C 957 WRITE (IOCH1) "LINE # OUT OF RANGE" GO TO 900 C 958 WRITE (IOCH1) "LINE IN USE" GO TO 900 C C--- TRANSMISSION SECTION C 960 WRITE (IOCH1) "LINE OPEN FOR TRANSMIT" C 961 READ (־IOCH3, 02, ERR=1150, END=970) NBUFF(1) 02 FORMAT (S80) C C 965 CALL FSCTX (LINE, NBUFF, NTMAX, IERR) IF (IERR .EQ. 13) GO TO 957 IF (IERR-2) 961, 966, 1001 C 966 CALL FSCST (LINE, IERR) IF (IERR .EQ. 13) GO TO 957 IF (IERR-2) 965, 967, 1001 C 967 CALL FDELY (1) GO TO 966 C 970 CALL FSCTE (LINE, IERR) IF (IERR .EQ. 13) GO TO 957 IF (IERR .NE. 1) GO TO 1001 C 972 CALL FSCST (LINE, IERR) IF (IERR .EQ. 13) GO TO 957 IF (IERR-2) 1100, 973, 1001 C 973 CALL FDELY(1) GO TO 972 C 975 WRITE (IOCH1) "FILE ERROR" GO TO 90 C 1001 WRITE (IOCH1) "LINE NOT OPEN OR XMT FAILURE" GO TO 1024 C 1010 WRITE (IOCH1) "END OF DATA" C 1024 CALL CLOSE(IOCH3, IERR) GO TO 90 110e0 CALL FSCTC (LINE, IERR) IF (IERR .EQ. 13) GO TO 957 IF (IERR .NE. 1) GO TO 1001 C 1102 CALL FSCST (LINE, IERR) IF (IERR .EQ. 13) GO TO 957 IF (IERR-2) 1010, 1105, 1001 C 1105 CALL FDELY (1) GO TO 1102 C 1150 CALL FSCTC (LINE, IERR) IF (IERR .EQ. 13) GO TO 957 IF (IERR .NE. 1) GO TO 1001 1152 CALL FSCST (LINE, IERR) IF (IERR .EQ. 13) GO TO 957 IF (IERR-2) 1001, 1154, 1001 C 1154 CALL FDELY (1) GO TO 1152 C C----- C 9999 CALL AKILL(0)  STOP END FSXMT.SR ' .LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1974,1975 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ;***************************************************************** ; ; NAME: FSXMT (ISSUE .IXMT SUPPORT ROUTINE) ; ; ; DESCRIPTION: ; ; THIS IS A SUPPORT ROUTINE FOR FSC PACKAGE ; TO INITIATE IXMT. ; ; CALLED FROM THE SLA PACKAGE UPON COMPLETION ; OF A SYNCP ACTION. ; ; USED ONLY ON THOSE LINES WHICH HAVE BEEN ; IXMT ACTIVATED VIA A CALL TO FSCXI. ; ; CALLED ONLY FROMȎ THE INTERRUPT HANDLER ; NOT RE-ENTRI. ; ; ; ;******************************************************************** .TITLE FSXMT ;ISSUE .IXMT SUPPORT ROUTINE .ENT FSXMT,FSKEY .EXTN .IXMT .NREL ; CALLED (FROM SLA INTERRUPT HANDLER) WITH LCB IN AC2 ; RETURNS WITH LCB IN AC2 FSXMT: STA 3,X3 ;SAVE AC3 (RETURN) STA 2,X2 ;SAVE AC2 (LCB) LDA 1,LCLAD,2 ;GET LINE # INTO THE RIGHT BYTE MOVS 1,1 LDA 0,FSKEY ;GET TOP OF COMMUN ARRAY ADD 1,0 ;COMPUTE SLOT FOR THIS IXMT SUBZL 1,1 ;MAKE NON-0 MESSSAGE .IXMT ;TRANSMIT (SMASHES ALL AC'S) JMP .+1 ;IGNORE ERROR LDA 2,X2 ;RESTORE LCB INTO AC2 JMP@ X3 ;...AND EXIT X2: 0 X3: 0 FSKEY: 0 ;ARRAY LOCATION FILLED IN... ;BY FSCXI .END LCB.SR (y.LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1973,1974,1975 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION .TITL LCBM ;OFFSETS FROM LCB TO DCT LOCATIONS (MULTIPLE 4074 ONLY) TXCT=-2 ;TASK EXECUTE BLOCK IXCT=-4 ;INTERRYUPT EXECUTE BLOCK ISAV=-5 ;LINE BASIS SAVE LOCATION DEVC=-6 ;DEVICE CODE LOCATION ;OFFSET FROM DCT TO LCB DTOL=12 ; LINE CONTROL BLOCK AND TRANSLATION DIRECTORY DEFINITIONS SLAMK=1B14 ;SLA INTERRUPT MASK SYNCT=7 ;SYN TRANSMISSION COUNT RPTCT=10. ;REPEAT ERROR COUNT RCVTO=3 ;RECEIVER TIMEOUT COUNT ; LINE CONTROL BLOCK -- PARAMETER DEFINITIONS ; COMMON LOCATIONS LCLAD=0 ;LINE ADDRESS IN LEFT BYTE LCRIH=LCLAD+1 ;RECEIVE INTERRUPT HANDLER LCTIH=LCRIH+1 ;TRANSMIT INTERRUPT HANDLER LCD\IR=LCTIH+1 ;TRANSLATION CODE DIRECTORY LCLCI=LCDIR+1 ;INITIAL VALUE FOR ERROR CHECK ROUTINE LCVRC=LCLCI+1 ;ERROR CHECK TYPE 0=2 BYTE 1=1 BYTE LCECK=LCVRC+1 ;LONGITUDINAL ERROR CHECK ROUTINE LCPGN=LCECK+1 ;PARITY GENERATION ROUTINE LCPCH=LCPGN+1 ;PARnITY CHECK ROUTINE LCSYN=LCPCH+1 ;SYN CHARACTER LCDLE=LCSYN+1 ;DLE CHARACTER LCMSK=LCDLE+1 ;LINE CODE MASK - 20000-EBC, 400-ASCII LCMDM=LCMSK+1 ;MODEM CONTROL 0 = NO, 1 = YES LCLCH=LCMDM+1 ;LINE CHARACTERISTICS (SEE THE ;MODE O SLA COMMAND FOR BIT DhEFINITIONS) ; BUFFER CONTROL POINTERS LCBP1=LCLCH+1 ;LINE BUFFER BYTE POINTER LCBC1=LCBP1+1 ;LINE BUFFER BYTE COUNT LCABP=LCBC1+1 ;ACTIVE BUFFER POINTER LCABC=LCABP+1 ;ACTIVE BUFFER COUNT LCABS=LCABC+1 ;ACTIVE BUFFER STATUS ; LINE AND DATASET R-EGISTERS LCHWS=LCABS+1 ;HARDWARE STATUS FOR MODEM CONTROL LCLST=LCHWS+1 ;LINE STATUS, ETX INDICATOR LCMDE=LCLST+1 ;LINE MODE, OPEN OR CLSD, RX OR TX LCACK=LCMDE+1 ;ACK CONTROL REGISTER LCERC=LCACK+1 ;ERROR RETRY COUNT ; ERROR COLLECTION LOCATIONS g LCRET=LCERC+1 ;RECEIVE ERROR TOTAL LCTET=LCRET+1 ;TRANSMIT ERROR TOTAL ; RECEIVER PARAMETERS LCRST=LCTET+1 ;RECEIVER STATUS FLAG LCRXC=LCRST+1 ;RECEIVE STATUS CODE LCRIX=LCRXC+1 ;RECEIVER IXMT EXIT ADDRESS LCRCA=LCRIX+1 ;RECEIVE CHECK ACCUMULATE 3* LCRCB=LCRCA+1 ;CHECK BYTE RECEIVE CONDITION LCRCC=LCRCB+1 ;RECEIVER CHECK WORD LCRVB=LCRCC+1 ;CURRENTLY RECEIVED BYTE LCRPV=LCRVB+1 ;PREVIOUSLY RECEIVED BYTE LCDBF=LCRPV+1 ;DOUBLE BYTE FLAG LCRRP=LCDBF+1 ;RESTART BYTE POINTER LCRRC=LCRRP+1 ;RESTART BYTE COUNT LCRBP=LCRRC+1 ;RECEIVER BUFFER POINTER LCRCT=LCRBP+1 ;RECEIVER BUFFER COUNT LCRBT=LCRCT+1 ;RECEIVER CONTROL BLOCK TABLE LCRTO=LCRBT+1 ;RECEIVER TIME OUT LCTRN=LCRTO+1 ;TRANSPARANCY FLAG ; TRANSMITTER PARAMETERS LCTST=LCTRN+1 ;TRANSMITTER STATUS LCTXC=LCTST+1 ;TRANSMIT STATUS CODE LCTIX=LCTXC+1 ;TRANSMIT IXMT EXIT ADDRESS LCTTI=LCTIX+1 ;TRANSPARENCY INDICATOR LCTCA=LCTTI+1 ;TRANSMIT CHECK ACCUMULATE LCTCC=LCTCA+1 ;TRANSMIT CHECK WORD LCTMS=LCTCC+1 ;MESSAGE BLOCK START LCTMC=LCTMS+1 ;CURRENT MESSAGE BLOCK COMMAND LCTBP=LCTMC+1 ;TRANSMIT BUFFER POINTER LCTBC=LCTBP+1 ;TRANSMIT BUFFER COUNT LCTB1=LCTBC+1 ;HOLDING BYTE 1 LCTC1=LCTB1+1 ;HOLDING COUNT 1 LCTB2=LCTC1+1 ;HOLDING BYTE 2 LCTC2=LCTB2+1 ;HOLDING COUNT 2 LCTBT=LCTC2+1 ;CUB RRENT TRANSMIT BYTE LCTSX=LCTBT+1 ;OPTION FLAG FOR SUPPRESSING XMIT OF ;STX FOLLOWING ITB IN NON-TRANSPARENT MODE ; RETURN AND SAVE LOCATIONS LCSLR=LCTSX+1 ;SLA RETURN TEMPORARY LCSL1=LCSLR+1 ;RETURN TEMPORARY LCCPR=LCSL1+1 ;CP RETURN TEMPORARYI LCRT1=LCCPR+1 ;RETURN TEMP 1 LCAC0=LCRT1+1 ;AC0 SAVE LOCATION LCAC1=LCAC0+1 ;AC1 SAVE LOCATION LCCP1=LCAC1+1 ;CP TEMP 1 LCCP2=LCCP1+1 ;CP TEMP 2 LCCP3=LCCP2+1 ;CP TEMP 3 LCCP4=LCCP3+1 ;CP TEMP 4 LCCP5=LCCP4+1 ;CP TEMP 5 LCBLN=LCCP5+1 ;LENGTH OFx LCB ; TRANSLATE DIRECTORY OFFSET DEFINITIONS ; THIS DIRECTORY POINTS TO CODE DEPENDENT DATA USED ; BY THE SLA PACKAGE AND IS FOUND AT THE BEGINNING OF ; SLADA OR SLADE. TDATL=0 ;ASCII TO LINE TABLE POINTER TDLTA=TDATL+1 ;LINE TO ASCII TABLE POINTnER TDNRB=TDLTA+1 ;NON-TRANSPARENT MODE RCB TDTRB=TDNRB+1 ;TRANSPARENT MODE RCB TDENQ=TDTRB+1 ;ENQ MESSAGE ADDRESS TDEOT=TDENQ+1 ;EOT MESSAGE ADDRESS TDDOT=TDEOT+1 ;DLE EOT MESSAGE ADDRESS TDAK0=TDDOT+1 ;ACK0 MESSAGE ADDRESS TDAK1=TDAK0+1 ;ACK1 MESSAGE ADDRESS TDNAK=TDAK1+1 ;NAK MESSAGE ADDRESS TDSYN=TDNAK+1 ;SYN MCB COMMAND TDSTX=TDSYN+1 ;STX MCB COMMAND TDETX=TDSTX+1 ;ETX MCB COMMAND TDETB=TDETX+1 ;ETB MCB COMMAND TDITB=TDETB+1 ;ITB MCB COMMAND TDCSX=TDITB+1 ;STX LINE CODE TDCEX=TDCSX+1 ;ETXHl LINE CODE TDCEB=TDCEX+1 ;ETB LINE CODE TDCIB=TDCEB+1 ;ITB LINE CODE MLT.SR (N.LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1974 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ;MULT FLAG SET TO ONE, INDICATE SLA ASSEMBLY FOR ; MULTIPLE 4074 SLA DRIVER. MULT=1 NF5SYM.SR .LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1976 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ; NF5SYM.SR ; ; SWITCH SETTINGS FOR RDOS NOVA FORTRAN 5 .DUSR ASW= 0 .DUSR RSW= 1 ;BUT RDOS .DUSR ESW= 0 ;NOT ECLIPSE .DUokSR NSW= 1 ;BUT NOVA PARF.SR )]M.LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1972,1973,1974,1975 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION **.NOCON 1 ; SET FORTRAN IV SWITCH FOR ASSEMBLY OF TASK MODULES AND OTHER ; ROUTINES .DUSR F4SW= 1 .DUSR F5SW=] 0 ; FORTRAN RUN-TIME PARAMETER TAPE ; DEFINE THE CURRENT STACK POINTER LOCATION .DUSR FSP= USP ; DEFINE THE FIXED STACK DISPLACEMENTS .DUSR FRTN= -170 ; DON'T MODIFY THE DISPLACEMENTS .DUSR FAC2= -171 ; FOR FRTN, FAC2, FAC1, FAC0 .DUSR FAC1= -172 h; AC1 .DUSR FAC0= -173 ; AC0 .DUSR FCRY= -174 ; CARRY .DUSR FEAD= -175 ; SUBROUTINE ENTRY ADDRESS .DUSR FPLP= -176 ; PARAMETER LIST POINTER .DUSR FOSP= -177 ; OLD STACK POINTER .DUSR FLGT= -200 ; STACK FRAME LENGTH .DUSR FFEL= 11 ; FIXED LENGTH OF T4HE STACK FRAME .DUSR FTSTR= -167 ; TEMPORARY STORAGE STARTING DISKP. .DUSR TMP= FTSTR .DUSR FZD= -200 ; FUDGE FACTOR FOR ZEROTH FORTRAN ; DISPLACEMENT .DUSR EMSK= 177B7 ; MASK FOR EXPONENT ; DEFINE THE RUN-TIME ERROR CODES ; FATAL ERRORS USE @"CODE2" WHERE THE "CODES" ARE ; GIVEN BELOW ; DEFINE THE ALC MAGIC .DUSR ENOP= @11 ; ALC NO-OP .DUSR EOS= 1B11 ; ERROR CODE OFFSET .DUSR FATAL= 1B1 ; FATAL ERROR BIT .DUSR FEMOF= 1.*EOS+ENOP ; STACK OVERFLOW .DUSR FECGT= 2.*EOS+ENOP ; COMPUTED GOTO ERROR .DUSR FEDV0= 4.*EOS+ENOP ; DIVISION BY ZERO .DUSR FEIOV= 5.*EOS+ENOP ; INTEGER OVERFLOW .DUSR FEIPR= 6.*EOS+ENOP ; INTEGER POWER OVERFLOW .DUSR FEFUF= 7.*EOS+ENOP ; FLOATING POINT UNDERFLOW .DUSR FEFOF= 8.*EOS+ENOP ; FLOATING POINT OVERFLOW .DUSR FEFMR= 9.*EOS+ENOP ; ILLEGAL FORMAT SYNTAX .DUSR FELER= 11.*EOS+ENOP ; LOGIC CONVERSION ERROR .DUSR FENER= 13.*EOS+ENOP ; NUMBER CONVERSION ERROR .DUSR FEIOR= 14.*EOS+ENOP ; I/O ERROR .DUSR FEFLD= 15.*EOS+ENOP ; FIELD ERROR .DUSR FESQR= 16.*EOS+ENOP ; SQUARE ROOT OF `NEGATIVE NUMBER .DUSR FELOG= 17.*EOS+ENOP ; LOG OF NEGATIVE NUMBER .DUSR FECLS= 18.*EOS+ENOP ; CHANNEL NOT OPEN .DUSR FEOPN= 19.*EOS+ENOP ; CHANNEL ALREADY OPEN .DUSR FECHN= 20.*EOS+ENOP ; N0 CHANNELS AVAILABLE .DUSR FEDOS= 21.*EOS+ENOP ; DOS EXCEPTIONAL STTATUS .DUSR FEEXP= 24.*EOS+ENOP ; EXPONENTIAL OVER/UNDERFLOW .DUSR FEOOB= 25.*EOS+ENOP ; ARRAY REFERENCE OUT OF BOUNDS. .DUSR FEPWR= 26.*EOS+ENOP ; -VE BASE FOR FLOATING POWER .DUSR FENSO= 27.*EOS+ENOP ; NUMBER STACK OVERFLOW .DUSR FEBNI= 28.*EOS+ENOP ; BATCKSPACE NOT IMPLEMENTED .DUSR FERST= 29.*EOS+ENOP ; ATTEMPT TO RESTORE CHANNEL ; STATUS NOT PREVIOUSLY SAVED .DUSR FEQTS= 30.*EOS+ENOP ; QUEUED TASK ERROR .DUSR FEFNR= 31.*EOS+ENOP ; SEEK ON NONRANDOM FILE .DUSR FEOVL= 32.*EOS+ENOP ; OVERLAY ABORTED .D"VUSR FEARG= 33.*EOS+ENOP ; ILLEGAL ARGUMENT .DUSR FEDEL= 34.*EOS+ENOP ; DELETE ERROR(FILE OPEN) .DUSR FEOVK= 35.*EOS+ENOP ; OVERLAY ERROR IN OVERLAY KILL .DUSR FEADR= 36.*EOS+ENOP ; UNDEFINED ENTRY .DUSR CDDSP= 3 ; SYSTEM ERROR DISPLACEMENT ; DEFINE THE FLOATING POINT INTERPRETER PARAMETERS .DUSR MAXPR= 10. ; MAXIMUM PRECISION ; (NO. OF WDS. OF MANTISSA MAX.) ; DEFINE THE FLOATING REGISTER EQUIVALENCES .DUSR SGN= -3 ; SIGN (BIT 15) ; (LEAVE AS MOST NEG. DISPLACE.) .DUSR EX= -2 ; EXPONENT (BITMeS 9-15) .DUSR PRC= -1 ; REGISTER PRECISION .DUSR MANT= 0 ; HIGH ORDER MANTISSA WORD ; DEFINE I/O CHANNEL ASSIGNMENT TABLE. .DUSR CHCNT= -1 ; CHANNEL COUNT .DUSR CATFL= 0 ; FLAGS + RDOS CHANNEL # .DUSR CATRL= CATFL+1 ; RECORD LENGTH (RANDOM ONLY) .DUISR CATLK= CATRL+1 ; LOCK WORD TO PREVENT CONFLICTS .DUSR CATBP= CATLK+1 ; BYTE POINTER TO FILENAME .DUSR CATL= CATBP+1 ; LENGTH OF I/O CAT ENTRIES .DUSR CATOP= 1B0 ; CLOSED SWITCH .DUSR CATMO= 1B1 ; MODE - 1 => BINARY **.DO ?HARD ; DEFINE THE NUMBER STACK DISPLACEMENTS .DUSR OP1S= 0 ; CURRENT STACK OPERAND - SIGN .DUSR OP1X= 0 ; EXPONENT .DUSR OP1M= 0 ; MANTISSA .DUSR OP2S= -4 ; LAST OPERAND - SIGN .DUSR OP2X= -4 ; EXPONENT .DUSR OP2M= -4 ; MANTISSA .DUSR OP3S= 4 ; NEXT OPERAND - SIGN .DUSR; OP3X= 4 ; EXPONENT .DUSR OP3M= 4 ; MANTISSA .DUSR REGL= 4 ; REGISTER LENGTH ; F.P. OFFSETS .DUSR FPW1= 0 .DUSR FPW2= 1 .DUSR FP2W1= -REGL .DUSR FP2W2= -REGL+1 **.ENDC **.DO ?SOFT ; DEFINE THE NUMBER STACK DISPLACEMENTS .DUSR OP1S= 0 ; CURRENT STAJCK OPERAND - SIGN .DUSR OP1X= 1 ; EXPONENT .DUSR OP1M= 2 ; MANTISSA .DUSR OP2S= -6 ; LAST OPERAND - SIGN .DUSR OP2X= -5 ; EXPONENT .DUSR OP2M= -4 ; MANTISSA .DUSR OP3S= 6 ; NEXT OPERAND - SIGN .DUSR OP3X= 7 ; EXPONENT .DUSR OP3M= 10 ; MANTISSA .DUSR REGL= 6 ; REGISTER LENGTH **.ENDC ; TASK EXTENSION PARAMETERS ; N.B. THESE MUST CORRESPOND TO THE FPZERO .BLK DEFINITIONS **.DO ?HARD **.DO ?ECLIPSE .DUSR FPUST= 0 ; INITIAL FPU STATUS .DUSR E.FPS= 0 ; FLOATING POINT STATUS .DUSR E.FPU= E.FPS+2  M; SPACE FOR FPAC .DUSR TNDSP= E.FPU+(4*REGL) **.ENDC **.DO ?NOVA .DUSR E.FPU= 0 ; SPACE FOR FPAC AND TEMP .DUSR E.FPS= E.FPU+(2*REGL) ; FLOATING POINT STATUS .DUSR TNDSP= E.FPS+1 **.ENDC **.ENDC **.DO ?SOFT .DUSR TNDSP= 0 ; NO SPACE FOR FPU STATUS **.ENDC .DUSR TAFSP= TNDSP+1 .DUSR TSP= TNDSP+2 .DUSR TOVFL= TNDSP+3 .DUSR TSV0= TNDSP+4 .DUSR TQSP= TNDSP+5 .DUSR TFLSP= TNDSP+6 ; MUST BE LAST DUE TO F.P. LOAD .DUSR TLEXN= TFLSP-TNDSP+1 ; LENGTH OF PAGE ZERO SAVE AREA .DUSR TCBEXT= TFLSP+1 ; FULL SIZE OF TcvCB EXTENSION **.DO ?NOVA&?HARD ; STRUCTURE OF FPU STATUS REGISTER .DUSR FPANY= 1B0 ; SET IF ANY ERROR OCCURS .DUSR FPOVF= 1B1 ; EXPONENT OVERFLOW .DUSR FPUNF= 1B2 ; EXPONENT UNDERFLOW .DUSR FPDVZ= 1B3 ; DIVISION BY ZERO .DUSR FPMOF= 1B4 ; MANTISSA OSVERFLOW .DUSR FPGTZ= 1B5 ; (FPAC) > 0 .DUSR FPEQZ= 1B6 ; (FPAC) = 0 .DUSR FPLTZ= 1B7 ; (FPAC) < 0 .DUSR FPIND= 1B13 ; FPU INTERRUPTS DISABLED .DUSR FPPPM= 1B14 ; PARALLEL PROCESSING MODE .DUSR FPDMD= 1B15 ; DIAGNOSTIC MODE .DUSR FPUST= FPIND+FPPPM ;м INITIAL FPU STATUS **.ENDC **.DO ?HARD ; FLOATING POINT MACRO DEFINITIONS **.DO ?NOVA .MACRO L?OAF ; WAIT FOR FPU TO FINISH ** SKPBZ FPU ** JMP .-1 % .MACRO F?AS ; ADD SINGLE ** L?OAF ** DOA ^1,FPU1 % .MACRO F?SBS ; SUBTRACT SINGLE ** L?OAF ** DOAS ^1,FPU1 % .MACRO F?MLS ; MULTIPLY SINGLE ** L?OAF ** DOAP ^1,FPU1 % .MACRO F?DVS ; DIVIDE SINGLE ** L?OAF ** DOAC ^1,FPU1 % .MACRO F?ATS ; ADD TEMP TO FPAC (SINGLE) ** L?OAF ** DOC 0,FPU1 % .MACRO F?ST1 ; SUBTRACT TEMP FROM FPAC (SINGLE) ** L?OAF ** DOCS 0,FPU1 % .MACRO F?MTS ; MULTIPLY SINGLE FROM TEMP ** L?OAF ** DOCP 0,FPU1 % .MACRO F?DTS ; FPAC := FPAC/TEMP (SINGLE) ** L?OAF ** DOCC 0,FPU1 % .MACRO F?LDS ; LOAD FPAC SINGLE ** L?OAF ** DOBP ^1,FPU1 % .MACRO F?STS ; STORE FPAC #SINGLE ** L?OAF ** DOBS ^1,FPU1 ** L?OAF % .MACRO F?MFT ; MOVE FPAC TO TEMP ** L?OAF ** NIOP FPU2 % .MACRO F?MTF ; MOVE TEMP TO FPAC ** L?OAF ** NIOC FPU2 % .MACRO F?SCL ; SCALE FPAC TO C(REG) ** L?OAF ** DOB ^1,FPU2 % .MACRO F?COM ; NEGATE FPA8C ** L?OAF ** NIOC FPU1 % .MACRO F?NRM ; NORMALIZE FPAC ** L?OAF ** NIOS FPU2 % .MACRO F?PLS ; MAKE FPAC POSITIVE ** L?OAF ** NIOP FPU1 % .MACRO F?AD ; ADD DOUBLE ** L?OAF ** DOA ^1,FPU2 % .MACRO F?SBD ; SUBTRACT DOUBLE ** L?OAF ** DOAS ^1,FPU2 % .MACRO F?MLD ; MULTIPLY DOUBLE ** L?OAF ** DOAP ^1,FPU2 % .MACRO F?DID ; DIVIDE DOUBLE ** L?OAF ** DOAC ^1,FPU2 % .MACRO F?ATD ; ADD TEMP TO FPAC (DOUBLE) ** L?OAF ** DOC 0,FPU2 % .MACRO F?ST2 ; SUBTRACT TEMP FROM FPAC (DOUBLE) ** L?OAF ** D OCS 0,FPU2 % .MACRO F?MTD ; MULTIPLY DOUBLE FROM TEMP ** L?OAF ** DOCP 0,FPU2 % .MACRO F?DTD ; FPAC := FPAC/TEMP (DOUBLE) ** L?OAF ** DOCC 0,FPU2 % .MACRO F?LDD ; LOAD FPAC DOUBLE ** L?OAF ** DOBP ^1,FPU2 % .MACRO F?STD ; STORE FPAC DOUBLE ** Lt?OAF ** DOBS ^1,FPU2 ** L?OAF % .MACRO F?LST ; LOAD STATUS REGISTER WITH C(REG) ** L?OAF ** DOA ^1,FPU % .MACRO F?RST ; READ/CLEAR STATUS INTO REG ** L?OAF ** DIAC ^1,FPU ** L?OAF % .MACRO F?CLS ; CLEAR FPAC SINGLE ** L?OAF ** NIOS FPU1 % .MACRO F?CLD ; CLEAR FPAC DOUBLE ** L?OAF ** NIOS FPU1 % .MACRO F?RHW ; READ FPAC HIGH WORD ** L?OAF ** DIA ^1,FPU1 ** L?OAF % .MACRO F?LDX ; LOAD EXPONENT ** L?OAF ** DOBC ^1,FPU2 % **.ENDC **.DO ?ECLIPSE .MACRO X?PND **.DO ^1>1 ** ^2 0,0,^1 **.ENDC **.DO ^1<2 ** STA ^1,.SV0 ** ^2 0,@.SV0 **.ENDC % .MACRO F?AS ; ADD SINGLE ** X?PND ^1,FAMS % .MACRO F?SBS ; SUBTRACT SINGLE ** X?PND ^1,FSMS % .MACRO F?MLS ; MULTIPLY SINGLE ** X?PND ^1,FMMS % .MACRO F?DVS ; DIVIDE SINGLE ** X?PND ^1,FDMS % .MACZfRO F?ATS ; ADD TEMP TO FPAC (SINGLE) ** FAS 1,0 % .MACRO F?ST1 ; SUBTRACT TEMP FROM FPAC (SINGLE) ** FSS 1,0 % .MACRO F?MTS ; MULTIPLY SINGLE FROM TEMP ** FMS 1,0 % .MACRO F?DTS ; FPAC := FPAC/TEMP (SINGLE) ** FDS 1,0 % .MACRO F?LDS ; LOAD FPfAC SINGLE ** X?PND ^1,FLDS % .MACRO F?STS ; STORE FPAC SINGLE ** X?PND ^1,FSTS % .MACRO F?MFT ; MOVE FPAC TO TEMP ** FMOV 0,1 % .MACRO F?MTF ; MOVE TEMP TO FPAC ** FMOV 1,0 % .MACRO F?SCL ; SCALE FPAC TO C(REG) ** .IFN ^1==0 ** FSCAL 0 **.ENDC ** .IFE ^1==0 ** XCH 0,^1 ** FSCAL 0 ** XCH 0,^1 **.ENDC % .MACRO F?COM ; NEGATE FPAC ** FNEG 0 % .MACRO F?NRM ; NORMALIZE FPAC ** FNOM 0 % .MACRO F?PLS ; MAKE FPAC POSITIVE ** FAB 0 % .MACRO F?AD ; ADD DOUBLE ** X?PND ^1,FAMD % .MACRO F?SBD Q ; SUBTRACT DOUBLE ** X?PND ^1,FSMD % .MACRO F?MLD ; MULTIPLY DOUBLE ** X?PND ^1,FMMD % .MACRO F?DID ; DIVIDE DOUBLE ** X?PND ^1,FDMD % .MACRO F?ATD ; ADD TEMP TO FPAC (DOUBLE) ** FAD 1,0 % .MACRO F?ST2 ; SUBTRACT TEMP FROM FPAC (DOUBLE) ** FSD) 1,0 % .MACRO F?MTD ; MULTIPLY DOUBLE FROM TEMP ** FMD 1,0 % .MACRO F?DTD ; FPAC := FPAC/TEMP (DOUBLE) ** FDD 1,0 % .MACRO F?LDD ; LOAD FPAC DOUBLE ** X?PND ^1,FLDD % .MACRO F?STD ; STORE FPAC DOUBLE ** X?PND ^1,FSTD % .MACRO F?CLS ; CLEAR FPAC SINGLE ** FSS 0,0 % .MACRO F?CLD ; CLEAR FPAC DOUBLE ** FSD 0,0 % .MACRO F?RHW ; READ FPAC HIGH WORD ** .IFN ^1==0 ** FRH 0 **.ENDC ** .IFE ^1==0 ** MOV 0,^1 ** FRH 0 ** XCH 0,^1 **.ENDC % .MACRO F?LDX ; LOAD EXPONENT **.DO ^1==0 ** FEXP 0 **.uENDC **.DO ^1>0 ** XCH 0,^1 ** FEXP 0 ** XCH 0,^1 **.ENDC % **.ENDC ; BONG ; DEFINE THE FORTRAN 4 INTERFACE TO THE NOVA F.P.BOX **.ENDC .MACRO N?ARG STA 3,@SP LDA 2,0,3 JSR @.MAD % .MACRO N?OUT LDA 2,@SP LDA 3,FSP JMP 1,2 % **.DO ?HARD .MACRO F?PwSH LDA 2,NSP **.DO ?ECLIPSE ADI REGL,2 **.ENDC **.DO ?NOVA INCR 2,2 INCL 2,2 INC 2,2 **.ENDC F?STD 2 STA 2,NSP % .MACRO F?POP LDA 2,NSP F?LDD 2 **.DO ?ECLIPSE SBI REGL,2 **.ENDC **.DO ?NOVA LDA 1,.+2 SUB 1,2,SKP REGL **.ENDC STA 2,NSP % .MA| CRO F?SNP ; SET SIGN BY ARG (IN LEFT BIT) LDA 2,@NSP MOVL 2,2 MOVL ^1,^1 MOVR 2,2 STA 2,@NSP % .MACRO F?SNG ; EXTRACT SIGN (INTO LEFT BIT ) LDA ^1,@NSP MOVL ^1,^1 SUBCR ^1,^1 %  .MACRO F?NEG LDA 2,@NSP ADDOR 2,2 STA 2,@NSP % .MACRO F?SNA K ; SIGN TO ^1 AND ABS TOP OF STACK LDA ^1,@NSP MOVL ^1,^1,SNC JMP .+4 MOVZR ^1,^1 STA ^1,@NSP SUBZR ^1,^1,SKP SUB ^1,^1 % ; ABS TOP OF STACK .MACRO F?AB **.IFN .ARGCNT==1 LDA ^1,@NSP MOVL ^1,^1 MOVZR ^1,^1 STA ^1,@NSP **.ENDC **.IFE .ARGCNT==1 ٜLDA 2,@NSP MOVL 2,2 MOVZR 2,2 STA 2,@NSP **.ENDC % .MACRO L?BYT (((77777&^1)/400)+(200*(^1<0)))% .MACRO C?PSH ; CPAC TO NUMBER STACK LDA 2,NSP LDA 3,.NDSP F?LDD 3 **.DO ?ECLIPSE ADI REGL,2 **.ENDC **.DO ?NOVA LDA 1,.+2 ADD 1,2,SKP REGL **.ENDC F?STD 2 **.DO ?ECLIPSE ADI REGL,2 ADI REGL,3 **.ENDC **.DO ?NOVA ADD 1,2 ADD 1,3 **.ENDC F?LDD 3 F?STD 2 STA 2,NSP LDA 3,FSP % .MACRO C?POP ; FROM NUMBER STACK TO CPACK LDA 2,NSP LDA 3,.NDSP F?LDD 2 F?MFT **.DO ?ECLIPSE SBI REGL,2 **.END C **.DO ?NOVA LDA 1,.+2 SUB 1,2,SKP REGL **.ENDC F?LDD 2 F?STD 3 **.DO ?ECLIPSE ADI REGL,3 **.ENDC **.DO ?NOVA ADD 1,3 **.ENDC F?MTF F?STD 3 **.DO ?ECLIPSE SBI REGL,2 **.ENDC **.DO ?NOVA SUB 1,2 **.ENDC STA 2,NSP LDA 3,FSP % **.ENDC .MACRO C?nONS **.DO ?HARD ** ^1B0+^2B7+L?BYT[^3] ** ^3B7+L?BYT[^4] **.IFN .ARGCT>5 ** ^4B7+L?BYT[^5] ** ^5B7+L?BYT[^6] **.ENDC **.ENDC **.DO ?SOFT ** I= 1 **.DO .ARGCT ** ^I ** I= I+1 **.ENDC **.ENDC % .MACRO F?SFP ; SQUARE THE FPAC **.DO ?ECLIPSE FMD 0,0 **.ENDhlC **.DO ?NOVA F?MFT ; TEMP := FPAC F?MTD ; FPAC := FPAC * TEMP **.ENDC % .EOT ; END OF PARF.SR PARFNS.SR )A.LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1975 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION .TITL PRFNS ; NOVA SOFT F.P. PARAMETER FILE .DUSR ?NOVA= 1 .DUSR ?ECLIPSE= 0 .DUSR ?SOFT= 1 .DUSR ?HARD= 0 .EOT ; END OF PARFNS.SR PARFX.SR .LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1976 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ; PARFX.SR ; TEMPORARY SOURCE UNTIL F4 IS REVISED ; DEFINES RDOS SWITCH ?RDOS AND ?OS? .DUSR ?OS?= 1 .DUSR ?RDOS= 1 SLACR.SR 4.LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1973,1974 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ; CRC ERROR CHECK ROUTINE ; THIS ROUTINE IS ONLY ENTERED BY THE INTERRUPT HANDLER ; AND IS NOT REENTRANT ; AC0 = BYTEQQ ON ENTRY AND RETURN ; AC1 = CRC WORD -- UPDATED ; AC2 = LCB, UNCHANGED AND NOT USED HERE ; AC3 = RETURN ADDRESS .TITLE SLACR .ENT SLACR,SLACP,SLACN,SLALP,SLATP,SLATN .EXTN SCTAB .NREL SLACR: STA 3,CRC3 ;STORE REGISTERS STA 2,CRC2 STA 0,CRC0  MOV 0,3 ;XOR DATA WORD AND CRC ANDZL 1,3 ;XOR ADD 1,0 ;XOR SUB 3,0 ;XOR MOV 0,2 ;SAVE IT LDA 3,MSK1 ;LOAD MASK FOR LOW ORDER 4 BITS AND 3,0 ;MASK MOVR 2,2 ;GET HIGH ORDER MOVR 2,2 ;4 BITS OF DATA CHARACTERS MOVR 2,2 MOVR 2,2 AND 3,2 ;MASK OFF 4` BITS LDA 3,TABLE ADD 0,3 LDA 0,0,3 ;INDEX INTO TABLE LDA 3,TAB16 ADD 2,3 LDA 2,0,3 ;INDEX INTO TABLE MOV 0,3 ;XOR ANDZL 2,3 ;XOR ADD 2,0 ;XOR SUB 3,0 ;XOR MOVS 1,1 ;GET HIGH ORDER CRC LDA 3,MSK2 ;LOAD BYTE MASK AND 3,1 ; MOV 1,3 ;XOR ANDZL 0,3 ;XOR ADD 0,1 ;XOR SUB 3,1 ;XOR LDA 0,CRC0 ;RESTORE REGISTERS LDA 2,CRC2 ; JMP @CRC3 ; MSK1: 17 MSK2: 377 CRC0: 0 CRC2: 0 CRC3: 0 ; TABLE FOR CRC 32 TAB16: .+22 TABLE: .+1 0 140301 140601 500 141401 1700 1200 141101 ; 143001 3300 3600 O143501 2400 142701 142201 2100 ; 0 146001 154001 12000 170001 36000 24000 162001 ; 120001 66000 74000 132001 50000 116001 104001 42000 ;PARITY GENERATOR, USES BIT IN SPECIAL CHARACTER ;TABLE TO GET CORRECT PARITY ; AC0 = CHARACTER IN RIGHT BYTE ; AC1 IS UNCHANGED ; AC2 IS UNCHANGED ; AC3 = RETURN ; RETURN BYTE IN AC0 WITH ODD PARITY ; THIS ROUTINE IS NOT REENTRANT AND IS ENTERED ONLY BY THE ; INTERRUPT HANDLER. ; PARITY GENERATE -- PUT ODD PARITY IN BIT 8 SLACP: STA 3,CRC3 ;SAVE RETURN STA 1,CRC2 ;SAVE AC1 LDA 3,TBASE ;GET SPEC CHAR TABLE ADD 0,3 ;CHARACTER IS OFFSET LDA 1,0,3 ;GET TABLE ENTRY ADDZL 1,1,SNC ;CHECK EVEN PARITY BIT (BIT 1) JMP .+4 ;BIT IS CLEAR, PARITY IS OK MOVS 0,0 ;CHAR INTO LEFT BYTE ADDOR 0,0 ;COMPYLIMENT TOP BIT MOVS 0,0 ;AND RESTORE TO RIGHT BYTE LDA 1,CRC2 ;RESTORE AC1 LDA 3,CRC3 ;RESTORE RETURN ;ENTRY POINT FOR NO PARITY GENERATION SLACN: JMP 0,3 ;RETURN ;PARITY TEST ROUTINE, 2 RETURN; R1 -- PARITY BAD ; R2 -- PARITY GOOD ;AC0 = (CHAR IN RIGHT BYTE ;AC1 = DESTROYED ;AC2 = UNCHANGED ;AC3 = RETURN ;NON-REENTRANT SLATP: STA 3,CRC3 ;SAVE RETURN LDA 3,TBASE ;GET SPECIAL CHAR TABLE ADD 0,3 ;CHARACTER IS OFFSET LDA 1,0,3 ;GET TABLE ENTRY LDA 3,CRC3 ADDZL 1,1,SNC ;TEST EVEN PARITY BIST ;NO PARITY TEST ENTRY POINT (GIVE R2) SLATN: JMP 1,3 ;GIVE RETURN 2 JMP 0,3 ;GIVE R1 TBASE: SCTAB ;SPECIAL CHARACTER TABLE ; LONGITUDINAL PARITY CHECK ROUTINE ; ENTERED ONLY BY THE INTERRUPT HANDLER ; AC0 - BYTE ON ENTRY AND RETURN ; AC1 - LRC'x WORD, WHICH IS RETURNED UPDATED ; AC2 - RETURNED UNCHANGED ; AC3 - RETURN ADDRESS ; THIS ROUTINE COMPUTES THE EXCLUSIVE OR (XOR) OF AC0 AND AC1 ; RETURNING THE RESULT IN AC1. IT MAY BE USED TO MAINTAIN EVEN ; OR ODD LONGITUDINAL PARITY DEPENDING ON̉ THE INITIAL VALUE OF ; AC1 ON THE FIRST CALL. I.E. IF 0, EVEN PARITY IS MAINTAINED ; IF ALL '1'S ODD PARITY IS COMPUTED. SLALP: STA 2,CRC2 ; SAVE AC2 MOV 0,2 ; COMPUTE (AC1) XOR (AC0) ANDZL 1,2 ; COMPUTE CARRIES ADD 0,1 ; ADD LRC AND THIS BYTE SUfxJB 2,1 ; SUBTRACT CARRIES OF PREVIOUS ADDITION LDA 2,CRC2 ; RESTORE AC2 JMP 0,3 ; AND RETURN .END SLADA.SR 5x.LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1973,1974 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ; ; CODE DEFINITIONS -- ASCII WITH ODD PARITY ; .DUSR SOH=1 .DUSR STX=2 .DUSR ETX=203 .DUSR EOT=4 .DUSR ENQ=205 .DhUSR ACK=206 .DUSR DLE=20 .DUSR NAK=25 .DUSR SYN=26 .DUSR ETB=227 .DUSR ITB=37 .DUSR ACK0=260 ;ZERO .DUSR ACK1=61 ;ONE .DUSR RVI=147 ;LESS THAN .DUSR WACK=73 ;SEMI-COLON .DUSR DLEL=DLE*256. ; ; TRANSLATE DIRECTORY TABLE FOR ASCII ; .TITLE SLADA  .ENT SLADA .EXTN SLARA,SLARC,SLARD,SLARF,SLARI,SLARM .EXTN SLARO,SLARP,SLART .EXTN SLRDB,SLREN .NREL SLADA: 0 ;ASCII TO LINE TABLE 0 ;LINE TO ASCII TABLE NTRCB ;NON-TRANPARENT MODE RCB TRCB ;TRANSPARENT MODE RCB MENQ ;ENQ MESSAGE MEOT  ;EOT MESSAGE MDEOT ;DLE EOT MESSAGE MACK0 ;ACK0 MESSAGE MACK1 ;ACK1 MESSAGE MNAK ;NAK MESSAGE 1000+SYN ;SYN MCB COMMAND 4000+STX ;STX MCB COMMAND 5000+ETX ;ETX MCB COMMAND 5000+ETB ;ETB MCB COMMAND 5000+ITB ;ITB MCB COMMAND STX ;STX LINE COvDE ETX ;ETX LINE CODE ETB ;ETB LINE CODE ITB ;ITB LINE CODE ; ; NON-TRANSPARENT MODE RECEIVER CONTROL BLOCK ; NTRCB: RCVTO ;RECEIVER TIMEOUT SLARP ;PRE-PROCESSING ROUTINE SLARO ;POST-PROCESSING ROUTINE ; ; TRANSPARENT MODE RECEIVER CONTROL BLOCK ; TRCB: RCVTO ;RECEIVER TIMEOUT SLRDB ;NO PRE-PROCESSING SLARI ;POST PROCESSING ; ; CANNED MESSAGES FOR IBM LINE PROTOCOL ; MENQ: 1000+ENQ 6000 0000 MEOT: 1000+EOT 6000 0000 MDEOT: 1000+SYN 7000+EOT 6000 0000 MACK0: 1000+SYN 7000+ACK0 XU6000 0000 MACK1: 1000+SYN 7000+ACK1 6000 0000 MNAK: 1000+NAK 6000 0000 .END @p SLADE.SR 6+.LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1973,1974,1976 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ; ; CODE DEFINITIONS -- EBCDIC ; .DUSR SOH=1 .DUSR STX=2 .DUSR ETX=3 .DUSR EOT=67 .DUSR ENQ=55 .DUSR ACK=56 |c.DUSR DLE=20 .DUSR NAK=75 .DUSR SYN=62 .DUSR ETB=46 .DUSR ITB=37 .DUSR ACK0=160 .DUSR ACK1=141 .DUSR RVI=174 .DUSR WACK=153 .DUSR DLEL=DLE*256. ; ; TRANSLATE DIRECTORY TABLE FOR EBCDIC ; ; .TITLE SLADE .ENT SLADE .EXTN SLARA,SLARC,SLARD,SLARF,SLARI,SLARM .EXTN SLARO,SLARP,SLART .EXTN SLRDB,SLREN .NREL SLADE: ATE ;ASCII TO LINE TABLE 1 ;NON 0 SAYS DO EBCDIC TO ASCII NTRCB ;NON-TRANPARENT MODE RCB TRCB ;TRANSPARENT MODE RCB MENQ ;ENQ MESSAGE MEOT ;EOT MESSAGE MDEOT ;DLE EOT MESGSAGE MACK0 ;ACK0 MESSAGE MACK1 ;ACK1 MESSAGE MNAK ;NAK MESSAGE 1000+SYN ;SYN MCB COMMAND 4000+STX ;STX MCB COMMAND 5000+ETX ;ETX MCB COMMAND 5000+ETB ;ETB MCB COMMAND 5000+ITB ;ITB MCB COMMAND STX ;STX LINE CODE ETX ;ETX LINE CODE ETB ;ETB LINE CODE ITB ;ITB LINE CODE ; ; NON-TRANSPARENT MODE RECEIVER CONTROL BLOCK ; NTRCB: RCVTO ;RECEIVER TIMEOUT SLARP ;PRE-PROCESSING ROUTINE SLARO ;POST-PROCESSING ROUTINE ; ; TRANSPARENT MODE RECEIVER CONTROL BLOCK ; TRCB: RCVTO ;RECEIVER TIMEOnUT SLRDB ;NO PRE-PROCESSING SLARI ;POST PROCESSING ; ; CANNED MESSAGES FOR IBM LINE PROTOCOL ; MENQ: 1000+ENQ 6000 0000 MEOT: 1000+EOT 6000 0000 MDEOT: 1000+SYN 7000+EOT 6000 0000 MACK0: 1000+SYN 7000+ACK0 6000 0000 MACK1: 1000+SYN 7000+ACK1 6000 0000 MNAK: 1000+NAK 6000 0000 ; ; ASCII TO EBCDIC CONVERSION TABLE ; ASSUMING HOLLERITH BASE ; .RDX 10 ATE: 0*256+1 2*256+3 55*256+45 46*256+47 22*256+5 37*256+11 12*256+13 14*256+15 16*256+17 18*256+19 60*256+61 50*256+38 24*256+25 63*256+39 28*256+29 30*256+31 64*256+79 ;4/21/76 127*256+123 91*256+108 80*256+125 77*256+93 92*256+78 107*256+96 75*256+97 240*256+241 242*256+243 244*256+245 246*256+247 248*256+249 122*256+94 76*256+126 110*256+111 124*256+193 194*256+195 196*256+197 198*256+199 200*256+201 209*256+210 211*256+212 213*256+214 215*256+216 217*256+226 227*256+228 229*256+230 231*256+232 233*256+74 ;4/21/76 224*256+90 ;4/21/76 95*256+109 ;4/21/76 121*256+129 ;4/21/76 130*256+131 132*256+133 134*256+135 136*256+137 145*256+146 147*256+148  149*256+150 151*256+152 153*256+162 163*256+164 165*256+166 167*256+168 169*256+192 ;4/21/76 106*256+208 ;4/21/76 161*256+7 ;4/21/76 .END SLAE.SR 7.LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1973,1974 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ; RESET SYNCHRONOUS LINE ADAPTER ; NON-REENTRANT CODE ; AC1 = LNTBL ; AC2 = DCT ADDRESS ; AC3 = RETURNED WITH USER S TACK POINTER (USP) .TITLE SLAE .ENT SLAE .EXTN SDOB0 .EXTN DEVCT .NREL SLAE: STA 3,IRTN ;SAVE RETURN ADDRESS LDA@ 0,DCNT ;GET # OF ACTIVE DEVICES MOV 0,0,SNR ;ANY? JMP EXIT ;NO, EXIT LDA 0,4,2 ;GET DEVICE CODE (DCT+4) STA 0,SLACD ;SAVE IT .LIFN MULT ;MULTIPLE 4074 CASE SUBZL 0,0 ;GET 1 LDA 1,3,2 ;POINTER TO LCB IN AC2 .ENDC .IFE MULT MOV 1,3 ;LINE TABLE ADDR LDA 0,-1,3 ;# OF LINES .ENDC STA 0,NLNS ;SAVE # OF LINES STA 1,LTADR ;SAVE PTR TO LCB(S) ILP: LDA@ 2,LTADR ;GET LCB ADDRESS COM# 2,2,SZR ;TEST IF MISSING MOV# 2,2,SNR ;OR ZERO JMP NOLCB ;THIS LCB NOT PRESENT LDA 1,LCLAD,2 ;GET LINE ADDRESS LDA 0,MODE0 ;GET MODE 0 COMMAND ADD 1,0 .IFN MULT JSR@ .+1 .ENDC SDOB0 ;RESET TRANSMITTER LDA 0,MODE1 ;GET MODE 1 COMMAND \LDA 1,LCLAD,2 ;GET LINE # ADD 1,0 .IFN MULT JSR@ .+1 .ENDC SDOB0 ;RESET RECEIVER NOLCB: ISZ LTADR ;INCREMENT LINE TABLE ADDRESS DSZ NLNS ;SEE IF DONE JMP ILP ;CONTINUE DSZ@ DCNT ;DECREASE # OF ACTIVES JMP DREM ;IF NOT ZERO SKIP RELEASE OF USR CLOCK .SYSTM ;RELEASE USER CLOCK .RUCLK JMP .+1 ;ERROR RETURN DREM: LDA 0,SLACD ;GET DEVICE CODE .SYSTM ;REMOVE INTERRUPT .IRMV JMP .+1 ;ERROR RETURN EXIT: LDA 3,USP ;RETURN USP IN AC3 JMP@ IRTN ;RETURN DCNT: DEVCT ;# OF ACTIVE DEVICES MODE0:{| 0 ;MODE 0 COMMAND MODE1: 40000 ;MODE 1 COMMAND IRTN: 0 ;RETURN ADDRESS LTADR: 0 ;LINE TABLE ADDRESS SLACD: 0 ;DEVICE CODE NLNS: 0 ;NUMBER OF LINES .END SLAI.SR 7Y.LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1973,1974,1975 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ; INITIALIZE SYNCHRONOUS LINE ADAPTER INTERRUPT HANDLER ; NON REENTRANT CODE ; AC1 = LNTBL ; AC2 = DCT ADDRESS ; AC3 = RETURNED WITH USER STACK POINTER (USP) .TITLE SLAI .EXTN DEVCT,SLAIC,SLASR .EXTN SDOB0 .ENT SLAI .NREL .NOLOC 1 .TXT /COPYRIGHT(C)DGC,1973,1974,1975,1976 ALL RIGHTS RESERVED/ .NOLOC 0 SLAI: STA 3,IRTN ;SAVE RETURN ADDRESS .IFN MULT SGUBZL 0,0 ;GET 1 STA 0,NLNS ;FORCE 1 LCB IF MULTIPLE LDA 1,3,2 ;POINTER TO LCB IN AC1 .ENDC .IFE MULT STA 1,3,2 ;STORE LINE TABLE ADDR IN DCT+3 MOV 1,3 ;GET # OF LINES LDA 0,-1,3 ;FROM LINE TABLE (SLTBL -1) STA 0,NLNS ;SAVE IN NLNS .ENDC STA 1,LTADR ;SAVE PTR TO LCB(S) MOV 2,1 ;DCT ADDRESS LDA 0,4,2 ;DEVICE CODE .SYSTEM .IDEF JMP EXIT ;ERROR RETURN FROM IDEF ISZ@ DCNT ;INCREMENT ACTIVE DEVICE COUNT ; INITIALIZE SLA HARDWARE ILP: LDA@ 2,LTADR ;GET LCB ADDRESS COM# 2,2,SZR ;TEST IF UMISSING MOV# 2,2,SNR ;OR IF ZERO JMP NOLCB ;ENTRY NOT PRESENT SUB 0,0 ;ZERO FLAGS STA 0,LCRST,2 ;ZERO RECEIVER BUSY FLAG STA 0,LCRXC,2 ;ZERO RECEIVER STATUS CODE STA 0,LCRTO,2 ;ZERO TIME OUT COUNTER STA 0,LCTST,2 ;ZERO TRANSMIT BUSY FLAG STA 0,LCMDE,2 ;ZERO LINE MODE STA 0,LCHWS,2 ;ZERO HARDWARE STATUS STA 0,LCLST,2 ;ZERO LINE STATUS STA 0,LCACK,2 ;ZERO ACK CONTROL REGISTER LDA 0,XADDR ;GET EXIT ROUTINE ADDRESS STA 0,LCRIX,2 ;SETUP RECEIVER IXMT EXIT STA 0,LCTIX,2 ;SETUP TRANSMIT IXMT EXIT `^.IFE MULT ;SINGLE DEVICE CASE LDA 3,LCLAD,2 ;GET LINE ADDRESS LDA 0,LCLCH,2 ;GET LINE CHARACTERISTICS ADD 3,0 ;ADD LINE ADDRESS SDOB0 ;INITIALIZE TRANSMITTER LDA 0,MODE1 ;GET MODE 1 COMMAND ADD 3,0 ;ADD LINE ADDRESS SDOB0 ;INITIALIZE RECEIVER LQDA 0,MODE2 ;DLE COMMAND LDA 1,LCDLE,2 ;GET DLE CODE ADD 3,0 ;ADD LINE ADRESS ADD 1,0 ;ADD DLE CODE SDOB0 ;PUT INTO SLA LDA 0,MODE3 ;SYN COMMAND LDA 1,LCSYN,2 ;GET SYN CODE ADD 3,0 ;ADD LINE ADDRESS ADD 1,0 ;ADD SYN CODE .ENDC .IFN MULT ;MULBHTIPLE 4074 CASE LDA 0,LCLCH,2 ;GET LINE CHARACTERISTICS JSR @ .+1 SDOB0 LDA 0,MODE1 ;GET MODE1 COMMAND JSR@ .+1 SDOB0 LDA 0,MODE2 ;DLE COMMAND LDA 1,LCDLE,2 ;GET DLE CODE ADD 1,0 ;COMBINE JSR@ .+1 SDOB0 LDA 0,MODE3 ;SYN COMMAND LD6YA 1,LCSYN,2 ;GET SYN CODE ADD 1,0 ;COMBINE JSR@ .+1 .ENDC SDOB0 ;PUT INTO SLA NOLCB: ISZ LTADR ;UP DATE POINTER DSZ NLNS ;TEST END OF TABLE JMP ILP ;CONTINUE ; INITIALIZE USER REAL TIME CLOCK .SYSTM ;GET CLOCK FREQUENCY .GHRZ JMP .+1 ;ERhROR RETURN MOV 0,2,SNR ;TEST FOR CLOCK JMP EXIT ;GIVE ERROR RETURN LDA@ 1,DCNT ;DEVICE COUNT IN AC1 MOVZR# 1,1,SZR ;USER CLOCK DEFINED ALREADY ? JMP EXIT-1 ;YES LDA 3,CTBL ;CONVERT TO 1 SECOND TIME ADD 0,3 ;FOR PROPER SERVICE LDA 0,0,3 ;TICS IN AC0 LDA 1,CLOCK ;GET CLOCK SERVICE ENTRY .SYSTM ;INITIALIZE CLOCK SERVICE .DUCLK ;BY CALLING USER CLOCK JMP .+2 ;ERROR RETURN ISZ IRTN ;NORMAL RETURN EXIT: LDA 3,USP ;STACK PTR IN AC3 JMP@ IRTN IRTN: 0 ;RETURN ADDRESS XADDR: SLASR ;EXIT ROUTINE DUMMY RETURN DCNT: DEVCT ;# OF ACTIVE DEVICES CLOCK: SLAIC ;CLOCK SERVICE ROUTINE CTBL: . ;FREQ. CONVERSION TABLE 10. ;1 = 10 HZ. 100. ;2 = 100 HZ. 1000. ;3 = 1000 HZ. 60. ;60 HZ LINE FREQ 50. ;50 HZ LINE FREQ LTADR: 0 ;LINE TABLE POINTER NLN0S: 0 ;NUMBER OF LINES MODE1: 40004 ;DISABLE RECEIVER, DATA TERMINAL READY MODE2: 100000 ;DLE LOAD MODE3: 140000 ;SYN LOAD .END SLAIS.SR 8U.LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1973,1974,1975,1976 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ; INTERRUPT SERVICE FOR SLA .TITLE SLAIS .ENT SLRIH,SLTIH,RSKED .ENT SLAIS,SLAIC,DEVCT .ENT SLRDB,SLREN | .EXTN SLAKI,.UIEX,.UCEX,SLTBL .EXTN SDIAC,SDIB0,SDOA1,SDOB0,SDOB1 .EXTN SCTAB .EXTN SLARL,SLARF,SLARM,SLARD,SLARS .EXTN SLARE,SLARC,SLARA,SLART .IFE MULT .EXTN SSKDZ .ENDC .NREL DEVCT: 0 ;# OF ACTIVE DEVICES RSKED: 0 ;FLAG TO INDICATE IF REWSCHED IS TO BE DONE SLLT: SLTBL ;SLA LINE TABLE ADDRESS ISRTN: 0 ;RETURN FROM INTERRUPT SERVICE LNMSK: 37400 ;MASK TO GET LINE ADDRESS ; USER CLOCK SERVICE ROUTINE ; ENTERED EACH SECOND AND DECREMENTS LCRTO IF NON-ZERO ; CALLS SLAK IF COUNT GOES TO aZERO SLAIC: STA 3,ICAC3 ;SAVE RETURN SUB 1,1 ;GET 0 STA 1,TOFLG ;CLEAR TIMEOUT FLAG LDA 3,SLLT ;GET LINE TABLE ADDRESS STA 3,ICLA ;SAVE IT LDA 2,-1,3 ;GET NUMBER OF LINES STA 2,ICNL ;SAVE IT ICLP: LDA@ 2,ICLA ;GET FIRST LCB ADDRESS ISZ ICLA ;POINT TO NEXT ADDRESS COM# 2,2,SZR ;CHECK FOR -1 MOV# 2,2,SNR ;OR ZERO JMP ICNLB ;GET NEXT LINE CONTROL BLOCK LDA 0,LCRTO,2 ;GET TIME OUT COUNT FROM LCB NEG 0,0,SNR ;SEE IF ZERO JMP ICNLB ;YES, GET NEXT LCB COM 0,0 ;SUBTRACT 1 STA 0,LCRTO,2 ;UPDATE REfCEIVER TIMEOUT MOV# 0,0,SZR ;TEST FOR TIMEOUT JMP ICNLB ;NO, NOT YET ISZ TOFLG ;SOMEBODY TIMED OUT, MUST RESCHED LDA 1,LCTST,2 ;GET TRANS. STATUS PMH 9 74 MOV# 1,1,SNR JMP .RCV ;RECEIVER TIMEOUT LDA 0,TTOCD ;TRANS. TIMEOUT CODE STA 0,LCRXC,2 ;SET CODE LDA 0,LCRT1,2 STA 0,TOTMP ;TEMP SAVE JSR @.SLT1 ;KILL TRANSMITTER LDA 0,TOTMP STA 0,LCRT1,2 ;RESTORE ORIG VALUE JMP ICNLB .RCV: LDA 1,LCRXC,2 LDA 3,C3 SUB 1,3,SNR ;STATUS = BAD CRC? JMP ALLDN ;YES, THEN SEND RESPONSE STA 0,LCRXC,2 ;EFNO, SET TIMEOUT CODE LDA 0,MD1K ;GET DISABLE RCV CODE LDA 1,LCLAD,2 ;GET LINE ADDR ADD 0,1 .IFN MULT ;IF MULTIPLE 4074 JSR@ .+1 .ENDC SDOB1 ;STOP RCVR JSR@ .SLAK ;STOP THE RECEIVER ALLDN: JSR@ LCRIX,2 ;ENTER RECEIVER EXIT ROUTINE ICNLB: DSZ ICNL ;TEST IF ALL LINES DONE JMP ICLP ;NO LDA 1,TOFLG ;FORCE RESCHEDULING IF ANYBODY TIMED OUT LDA 3,ICAC3 ;RESTORE AC3 .UCEX ;RETURN FROM CLOCK INTERRUPT TOFLG: 0 ;SET IF SOMEBODY TIMED OUT MD1K: 40004 ICAC3: 0 ICLA: 0 ;LINE TABLE ADDRESS ICNL: 0 ;NUMBER OF LINES .SLAK: SLAKI ;ENTRY INTO SLAK TO RESET PARAMS TTOCD: 16 ;TRANSMIT TIME OUT CODE TOTMP: 0 ;TEMP STORAGE C3: 3 .SLT1: SLT01 ; INTERRUPT SERVICE ENTRY POINT FOR SLA SLAIS: STA 3,ISRTN ;SAVE INTERRUPT RETURN STA 2,IDCT2 ;SAVE DCT IN AC!2 FOR RTOS RTN SUB 0,0 ;GET 0 STA 0,RSKED ;INITIALIZE RESCHEDULING FLAG .IFN MULT LDA 1,.DTOL ;OFFSET FROM DCT TO LCB, XCT ROUTINES ADD 1,2 ;EXPECT LCB ADDRESS JSR@ .+1 .ENDC SDIAC ;GET INTERRUPT INDICATORS INTO AC1 MOV 1,0 ;PUT INTO AC0 LDGA 1,LNMSK ;GET LINE MASK ANDS 0,1 ;LINE ADDRESS IN 1 LDA 2,IDCT2 ;RESTORE DCT IN AC2 LDA 2,3,2 ;GET LINE TABLE ADDRESS ADD 1,2 ;FIND OFFSET LDA 2,0,2 ;GET LCB ADDRESS MOV# 2,2,SNR ;SEE IF LEGAL JMP NOLCB ;NO MOVL# 0,0,SZC ;RECEIVE INTERRUPT? JMP@ LCRIH,2 ;GO TO RECEIVE SERVICE ADDL# 0,0,SZC ;TRANSMIT INTERRUPT? JMP@ LCTIH,2 ;GO TO TRANSMIT SERVICE ;ELSE FALL INTO... IHEND: LDA 2,IDCT2 ;RESTORE DCT TO AC2 FOR RTOS EXIT .IFN MULT ;MULTI-4074'S MUST GET DVC CODE INTO SKP LDA 0,4,2 ;DEVICE CO2DE IS AT DCT+4 LDA 1,SDZ ;GET DUMMY SKPDZ (NO DEV CODE) ADD 1,0 ;MAKE REAL INSTRUCTION STA 0,.+1 ;AND PUT IT... 0 ;HERE! .ENDC .IFE MULT SSKDZ ;TEST FOR MORE WORK .ENDC JMP SLAIS+4 ;MORE INTERRUPTS WAITING LDA 1,RSKED ;RESCHEDULE IF NON 0 LDA 3,ISRTN ;INTERRUPT RETURN MOV 2,0 ;/**** 3.02 BUG FIX RESCHED */ .UIEX NOLCB: MOVL# 0,0,SZC ;RECEIVE OR TRANSMIT? JMP IHEND ;RECIEVE MOVS 1,1 ;GET LINE NUMBER .IFN MULT JSR@ .+1 .ENDC SDOB1 ;CLEAR INTERRUPT, STOP TRANSMIT JMP IHEND ; Ǝ RECEIVE INTERRUPT HANDLER ; CODE IS NOT REENTRANT ; AC0 = RECEIVED BYTE ; AC2 = LCB SLRIH: LDA 1,LCRST,2 ;GET LINE STATUS MOV# 1,1,SNR ;SEE IF RECEIVING JMP IHEND ;NO LDA 1,C377 ;GET BYTE MASK AND 1,0 ;CLEAN UP BYTE LDA 1,LCRVB,2 ;GET OLD CURREcNT BYTE STA 1,LCRPV,2 ;SAVE AS PREVIOUS BYTE STA 0,LCRVB,2 ;STORE NEW CURRENT BYTE LDA 3,LCRBT,2 ;GET RCB POINTER JMP @1,3 ;DO PRE-PROCESSING SLRDB: LDA 3,SCTBP ;POINTER TO SPECIAL CHAR TABLE LDA 0,LCRVB,2 ;GET THIS BYTE ADD 0,3 ;NEW BYTE AS OFFSET t LDA 1,0,3 ;GET THIS ENTRY MOVL# 1,1,SZC ;CHECK SPECIAL CHAR BIT JMP SPEC ;POSSIBLE SPECIAL, CHECK FURTHER RETN: LDA 3,LCRBT,2 ;GET RCB POINTER SUB 1,1 ;GET 0 STA 1,LCDBF,2 ;PUT INTO DOUBLE-BYTE FLAG JMP@ 2,3 ;DO POST-PROCESSING CLDBF: SUB 1,1 ;GET 0 f STA 1,LCDBF,2 ;CLEAR DOUBLE BYTE FLAG SLREN: JMP IHEND ;EXIT TO INTERRUPT HANDLER SPEC: LDA 3,LCMSK,2 ;GET MODE MASK AND# 3,1,SNR ;CORRECT LINE CODE? JMP RETN ;NO, THIS IS NOT SPECIAL CHAR LDA 0,IDMSK ;17B6 - DISPATCH CODE ANDS 1,0 ;AC0 IS ID * 2 ?RLDA 1,DC56 ;2*[TABLE LENGTH (14)] *2 LDA 3,LCTRN,2 ;TRANSPARANCY INDICATOR MOV 3,3,SNR ;TRANSPARANT? ADD 1,0 ;NO MOVZR 1,1 ;TABLE LENGTH /2 LDA 3,LCDBF,2 ;WAS LAST BYTE A DLE? MOVL# 3,3,SZC ;TEST IT ADD 1,0 ;ADD IN OFFSET IF SO LDA 3,SCDPT ;TOP OF I SPECIAL CHAR DISPAT TBLS ADD 0,3 ;POINTS TO DISPATCH ENTRY LDA 0,0,3 ;CODE STA 0,LCRXC,2 ;INTO STATE WORD JMP@ 1,3 ;DISPATCH THROUGH TABLE ENTRY SCTBP: SCTAB ;SPECIAL CHARACTER TABLE IDMSK: 17B6 ;DISPATCH CODE MASK DC56: 56. ;DECIMAL 56, 2 X 14 X y2 C377: 377 IDCT2: 0 ;DCT SAVE ON INTERRUPT ENTRY .IFN MULT SDZ: SKPDZ,0 ;DUMMY SKIP (NO DEV CODE) .DTOL: DTOL ;DCB TO LCB OFFSET .ENDC ;SPECIAL CHARACTER DISPATCH TABLE ;NB. - CONTROL CHARACTERS IN ILLEGAL SITUATIONS OR ; COMBINATIONS WILL PRESUMABLY BE DETECTED BY CRC SCDPT: .+1 ;TOP OF DISPATCH TABLES ;SINGLE TRANSPARENT TRSIN: 0 ;STX RETN 0 ;ACK0 RETN 0 ;ACK1 RETN 0 ;RVI RETN 0 ;WACK RETN 0 ;ENQ RETN 0 ;ETX RETN 0 ;ETB RETN 0 ;ITB RETN 0 ;EOT RETN 0 ;NAK RETN 0 R;SOH RETN 0 ;DLE SLARL ;SET DOUBLE BYTE FLAG 0 ;SYN RETN ;DOUBLE TRANSPARENT TRDBL: 0 ;STX RETN 0 ;ACK0 RETN 0 ;ACK1 RETN 0 ;RVI RETN 0 ;WACK RETN 7 ;ENQ SLARF ;KILL RCV 5 ;ETX SLARM ;GET SET FOR CRC 6 ;ETB SLARM 100 ;ITB SLARM 0 ;EOT RETN ;HANDLED BY SYNST (?) 0 ;NAK RETN 0 ;SOH RETN 0 ;DLE SLARD ;CLEAR DOUBLE BYTE FLAG 0 ;SYN CLDBF ;IGNORE AND CLEAR DBF ;SINGLE NON-TRANSPARENT NTSIN: 0 ;STX SLARS ;SET STX BIT IN LCDBF 0 ;ACK0 RETN 0 ;ACK1 RETN 0 ;RVI RETN 0% ;WACK RETN 7 ;ENQ SLARE ;CHECKS FOR PRECEDING STX OR DLE (IF STX, CODE=15) 5 ;ETX SLARC ;SET FOR CRC 6 ;ETB SLARC 100 ;ITB SLARC 4 ;EOT SLARF 12 ;NAK SLARF 0 ;SOH SLARA 0 ;DLE SLARL 0 ;SYN SLREN ;FLUSH ;DOUBLE NON-TRANSPARENT (OPAQUE&}**2) NTDBL: 0 ;STX SLART ;SET TRANSPARENT MODE 10 ;ACK0 SLARF 11 ;ACK1 SLARF 14 ;RVI SLARF 13 ;WACK SLARF 15 ;ENQ SLARF 0 ;ETX RETN 0 ;ETB RETN 0 ;ITB RETN 4 ;EOT SLARF 0 ;NAK RETN 0 ;SOH RETN 0 ;DLE RETN 0 ;SYN RETN ; SERVICE TRANSMITTER INTERRUPT SLTIH: LDA 1,LCTBC,2 ;GET BUFFER COUNTER MOV# 1,1,SZR ;SEE IF EMPTY JMP SLTFB ;TRANSMIT OUT OF BUFFER LDA 1,LCTC1,2 ;GET HOLDING COUNT 1 MOV# 1,1,SZR ;SEE IF EMPTY JMP SLTH1 ;TRANSMIT FROM HOLDING 1 LDA 1,LCTC2,2 ;GET HOLDINGE COUNT 2 MOV# 1,1,SZR ;SEE IF EMPTY JMP SLTH2 ;TRANSMIT FROM HOLDING 2 SLTNC: LDA@ 1,LCTMC,2 ;GET MESSAGE BLOCK COMMAND STA 1,LCTBT,2 ;SAVE OUTPUT BYTE MOVS 1,1 ;COMMAND TO RIGHT HALF LDA 0,C.377 ;GET MASK ANDZR 0,1 ;AND GET COMMAND OFFSET LDA 3,SLzTB1 ;GET BASE OF EXECUTE TABLE ADD 1,3 ;GET COMMAND ENTRY ISZ LCTMC,2 ;POINT TO NEXT COMMAND JMP@ 0,3 ;AND EXECUTE THIS ONE ; TRANSMIT FROM BUFFER SLTFB: INC 1,1 ;UPDATE BUFFER COUNT STA 1,LCTBC,2 ;SAVE IT LDA 3,LCTBP,2 ;GET BUFFER BYTE POINTER PISZ LCTBP,2 ;UPDATE BYTE POINTER MOVZR 3,3 ;MAKE CORE ADDRESS LDA 0,0,3 ;GET BYTE WORD MOV# 0,0,SNC ;WHICH SIDE? MOVS 0,0 ;SWAP BYTE LDA 1,C.377 ;GET MASK AND 1,0 ;CLEAN OFF BYTE LDA 1,LCTTI,2 ;GET TRANSPARENCY INDICATOR MOV# 1,1,SNR ;TEST IF IN T! RANSPARENT MODE JMP SLTFD ;NO LDA 1,LCDLE,2 ;LOOK FOR DLE IN DATA STREAM SUBZ 0,1,SZR ;TEST FOR IT SUBO 1,1 ;NOT PRESENT MOVR 1,1,SKP ;SET DLE BIT SLTFD: JSR@ LCPGN,2 ;ADD PARITY IF REQUIRED STA 0,LCTBT,2 ;SAVE FOR TRANSMIT SLTFX: JSR SLXMD ;OUTPUT THE CHARACTER JMP@ SLTEN ;AND RETURN ; TRANSMIT FROM HOLDING 1 SLTH1: INC 1,1 ;UPDATE HOLDING 1 COUNT STA 1,LCTC1,2 ;AND SAVE LDA 0,LCTB1,2 ;GET HOLDING BYTE 1 JMP SLXMB ;GO TRANSMIT ; TRANSMIT FROM HOLDING 2 SLTH2: INC 1,1 ;UPDATE HOLDING 2 COU9!NT STA 1,LCTC2,2 ;AND SAVE LDA 0,LCTB2,2 ;GET HOLDING BYTE 2 ; ROUTINES AND ENTRY POINTS TO TRANSMIT A BYTE SLXMB: LDA 3,C.377 ;GET MASK AND 3,0 ;CLEAN OFF BYTE LDA 1,LCLAD,2 ;GET LINE ADDRESS ADD 0,1 ;ADD IT IN .IFN MULT JSR@ .+1 .ENDC SDOAY1 ;TRANSMIT IT JMP@ SLTEN ;RETURN FROM HANDLER SLTEN: IHEND ;INTERRUPT RETURN C.377: 377 ; AC1 HAS BIT 0, BIT 1 SET AS NECESSARY ; FOR CONTROL OF TRANSPARENT MODE AND DLE PREFIXING SLT2: LDA 3,SLTEN ;SETUP RETURN FROM INTERRUPT SLXMR: SUB 1,1 ;CLEAR DLE, END BITS SLXMD: LDA 0,LCTBT,2 ;GET BYTE TO TRANSMIT STA 3,LCTBT,2 ;SAVE RETURN FOR NOW LDA 3,C.377 ;GET MASK AND 3,0 ;CLEAN UP OUTPUT BYTE LDA 3,LCLAD,2 ;GET LINE ADDRESS ADD 3,1 ;ADD TO BITS 0,1 ADD 0,1 ;ADD IN BYTE .IFN MULT JSR@ .+1 3 .ENDC SDOA1 ;XMIT .IFN MULT ;MULTIPLE CASE LDA 0,C.377 ;MUST RESTORE CHAR TO AC0 FOR BCC AND 1,0 ;WAS IN AC1 WITH SLOP .ENDC LDA 1,LCTCC,2 ;GET ERROR CHECK WORD LDA 3,LCTCA,2 ;SEE IF ACCUMULATING CRC MOV# 3,3,SZR ;JUMP IF NO JSR@ LCECK,2 ;DO ERbROR CHECK STA 1,LCTCC,2 ;RESTORE ERROR CHECK JMP@ LCTBT,2 ;RETURN ; COMMAND EXECUTE TABLE SLTB1: .+1 ;TABLE STARTING ADDRESS SLT0 ;COMMAND ENTRY POINTS FOLLOW SLT1 SLT2 SLT3 SLT4 SLT5 SLT6 SLT7 SLT10 SLT11 SLT4T ;ENTERED IF NO "STX" HAS ǺTO BE XMITTED ; CODE 0 -- TURN OFF TRANSMITTER, SET DONE, IXMT SLT01: STA 3,LCRT1,2 ;SAVE RETURN TO SLAIC SLT0: LDA 0,LCMDM,2 ;GET MODEM WORD LDA 1,LCLAD,2 ;GET LINE ADDRESS ADD 0,1 ;HANDLE 2/4 WIRE CASE .IFN MULT JSR@ .+1 .ENDC SDOB1 ;STOP TRAANSMIT, DROP R-TO-S SUB 0,0 STA 0,LCTXC,2 ;GIVE ZERO STATUS CODE STA 0,LCTST,2 ;CLEAR BUSY STATUS STA 0,LCTCA,2 ;RESET ACCUMULATION FLAG STA 0,LCRTO,2 ;SET TIMEOUT = 0 (XMIT) ISZ@ .RSK ;INDICATE RESCHEDULING ON EXIT JSR@ LCTIX,2 ;ENTER TRANSMIT EXIT ROUTINE LDA 1,@.TTOC ;GET XMIT TIME OUT CODE LDA 0,LCRXC,2 ;GET CURRENT CONDITION SUB 0,1,SNR ;SKIP NOT XMIT TIMEOUT JMP @LCRT1,2 ;RETURN TO SLAIC JMP@ SLTEN ;NORMAL RETURN .RSK: RSKED .TTOC: TTOCD ; CODE 1 -- SEND SYN CHARS AND THEN CHAR SLT1: LDA 1,LCTBT,2 ;GET CHAR STA 1,LCTB2,2 ;SAVE IN HOLDING BYTE 2 DSZ LCTC2,2 ;PUT -1 IN HOLDING 2 COUNT LDA 1,LCSYN,2 ;GET SYN CHARACTER STA 1,LCTB1,2 ;SAVE IN HOLDING BYTE 1 LDA 1,SYNS ;GET SYN TRANSMIT COUNT JMP SLTH1 ;GO TRANSMIT SYNS: -SYNCT ;NUMBEceR OF SYN CHARACTERS ; CODE 2 -- SEND CHAR ; SEE ENTRY AT SLT2 ; CODE 3 -- SEND BUFFER SLT3: LDA@ 1,LCTMC,2 ;GET BUFFER BYTE POINTER ISZ LCTMC,2 ;BUMP COMMAND POINTER STA 1,LCTBP,2 ;SAVE BYTE POINTER LDA@ 1,LCTMC,2 ;GET BYTE COUNT ISZ LCTMC,2 ;BUMP COMMAND POINTER NEG 1,1,SZR ;TEST IF ZERO JMP SLTFB ;SEND FROM BUFFER JMP SLTNC ;GET NEXT COMMAND ; CODE 4 -- SEND CHAR, START CRC ACCUMULATION, AND SEND BUFFER SLT4: JSR SLXMR ;OUTPUT BYTE SLT4T: ISZ LCTCA,2 ;SET ACCUMULATE LDA@ 1,LCTMC,2 ;GET %BUFFER BYTE POINTER ISZ LCTMC,2 ;POINT TO NEXT MCB SLOT STA 1,LCTBP,2 ;SAVE IN TRANSMIT BUFFER POINTER LDA@ 1,LCTMC,2 ;GET BYTE COUNT ISZ LCTMC,2 ;POINT TO NEXT COMMAND NEG 1,1 ;NEGATE IT STA 1,LCTBC,2 ;SAVE AS BYTE COUNT JMP@ SLTEN ;RETURN ; COD{E 5 -- SEND CHAR, CRC1, CRC2 SLT5: JSR SLXMR ;TRANSMIT CHARACTER SLT5T: LDA 1,LCTCC,2 ;GET ERROR CHECK WORD SUB 0,0 ;CLEAN OUT CRC STA 0,LCTTI,2 ;CLEAR TRANSPARENCY FLAG LDA 0,LCLCI,2 ;*GET INITIAL CHECK WORD STA 0,LCTCC,2 ;RESET ERROR CHECK WORD LDA 0,LCVRC,2 ;*GET CHECK WORD SIZE MOV# 0,0,SZR ;*2 BYTES IF ZERO JMP SLT5L ;*1 BYTE STA 1,LCTB1,2 ;SAVE CRC WORD IN HOLDING 1 MOVS 1,1 ;GET CRC2 STA 1,LCTB2,2 ;SAVE IN HOLDING 2 DSZ LCTC1,2 ;MAKE HOLDING COUNTS -1 DSZ LCTC2,2 JMP@ SLTEN SLT5L: LDA 0,C.177 ;* SEVEN BIT MASK AND 1,0 ;* CLEAN BYTE INTO AC0 JSR@ LCPGN,2 ;* GET BYTE PARITY STA 0,LCTB1,2 ;* PUT INTO HOLDING 1 DSZ LCTC1,2 ;* -1 INTO HOLDING 1 COUNT JMP@ SLTEN ;* RETURN C.177: 177 ;* MASK ; CODE 6 -- SEND 4 PAD (ALL ONE'S) CHARACTERS SLT6: ADC 1,1 ;GET ALL ONES STA 1,LCTB1,2 ;PUT IN HOLDING 1 LDA 1,M2 ;GET PAD COUNT JMP SLTH1 ;GO TRANSMIT M2: -2 ;CHANGED FROM -4 IN REV 3.01 ; CODE 7 -- SEND DLE CHAR SLT7: LDA 1,MDBTS ;GET DLE & END BITS JMP SLTFX ;AND GO TRANSMIT MDBTS: 140000 ;DLE & END CONTROL BITS FOR SLA ; CODE 10 -- SEND DLE CHAR, ENTER TRANSPARENT MODE, ; START CRC ACCUMULATION, SEND BUFFER SLT10: LDA 0,LCDLE,2 ;GET DLE CODE LDA 1,LCTCC,2 ;GET ERROR CHECK WORD LDA 3,LCTCA,2 ;SEE IF NOW ACCUMULATING MOV# 3,3,SZR ;ON SECOND TEXT BLOCK? JSR@ LCECK,2 ;YES, INCLUDE DLE IN ERROR CHECK STA 1,LCTCC,2 ;AND INIT ERROR CHECK WORD SUBZR 1,1 ;SET BIT 0 = 1 STA 1,LCTTI,2 ;SET TRANSPARENCY FLAG JSR SLXMD ;SEND DLE CHAR JMP SLT4T ;AND START ACCUMULATION ; CODE 11 -- SEND DLE CHAR, LEAVE TRANSPARENT MODE, ; SEND CRC1, CRC2 SLT11: LDA 1,MDBTS ;GET DLE & END BITS JSR SLXMD ;SEND DLE CHAR JMP SLT5T ;DO OTHER WORK .END SLAR.SR 8.LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1973,1974 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ; MESSAGE RECEIVE ROUTINE ; AC0 = RBB ; AC2 = LCB .TITLE SLAR .ENT SLAR .ENT SLARA,SLARC,SLARD,SLARF,SLARI,SLARM .EgNT SLARL,SLARS,SLARE .ENT SLARO,SLARP,SLART .EXTN SDOB1,SLAS,SLAKI .EXTN SLRDB,SLREN,RSKED .NREL SLAR: STA 3,LCSLR,2 ;SAVE RETURN SUB 3,3 ;0 STA 3,LCTRN,2 ;CLEAR XPAR FLAG LDA 3,LCDIR,2 ;GET TRANSLATE DIRECTORY ADDRESS LDA 1,TDNRB,3 ;PICK UP NON-TRANSPARENT RCB JSR@ .SLAS ;START RECEIVER JMP@ LCSLR,2 ;AND RETURN .SLAS: SLAS ;START RECEIVER ROUTINE ; ; PRE-PROCESSING ENTRY POINT ; SLARP: LDA 1,LCRCB,2 ;GET BCC RECEIVE INDICATOR MOV# 1,1,SZR ;IT THIS BYTE A BCC JMP RCVCC ;YES LDA 1,LCSYN,2 I;GET SYN CODE SUB# 0,1,SNR ;IS THIS A SYN JMP@ RCVEN ;OUT JSR@ LCPCH,2 ;CHECK PARITY OF CHAR IN AC0 JMP RCVER ;RETURN 1 MEANS PARITY WAS BAD JSR RBP ;PARITY OK-DO RECEIVED BYTE PROCESSING LDA 1,LCRCA,2 ;GET ACCUMULATION FLAG MOV# 1,1,SNR ;TEST JMP@ RCVDB ;DO SPECIAL CHARACTER SCAN LDA 0,LCRVB,2 ;GET RECEIVED BYTE LDA 1,LCRCC,2 ;GET ERROR CHECK WORD JSR@ LCECK,2 ;UPDATE ERROR WORD STA 1,LCRCC,2 ;RESTORE ERROR WORD JMP@ RCVDB ;DO SPECIAL CHARACTER SCAN RCVDB: SLRDB ;DOUBLE BYTE SCAN RCVEN: SLREN ;EXIT FROM HANDLER RCVCC: LDA 1,LCVRC,2 ;GET CHECKWORD SIZE MOV# 1,1,SZR ;2 BYTES IF 0 JMP RCVRC ;1 BYTE LONG LDA 1,LCRCC,2 ;GET ERROR CHECK WORD JSR@ LCECK,2 ;DO ERROR CHECK STA 1,LCRCC,2 ;RESTORE ERROR CHECK WORD ISZ LCRCB,2 ;TEST FOR COMPLETE BCC JMP@ RCVEN ;EXIT AND GET BCC2 RCVCE: MOV# 1,1,SZR ;TEST FOR ERROR JMP RCVER ;BAD BCC WORD STA 1,LCRVB,2 ;RESET CURRENT BYTE TO ZERO STA 1,LCRCB,2 ;SAY BCC COMPLETE LDA 1,LCLCI,2 ;GET BLOCK CHECK INITIAL VAL STA 1,LCRCC,2 ;PUT INTO BCC WORD LDA d40,NTIBC ;GET ITB CODE LDA 1,LCRXC,2 ;GET STATUS CODE SUB# 0,1,SZR ;TEST FOR ITB LOOP JMP SLARF ;GO TERMINATE RECEIVE JMP SLARO ;*DO NORMAL POST PROCESSING RCVRC: MOV 0,1 ;*PUT THIS BYTE INTO AC1 LDA 0,LCRCC,2 ;*GET CURRENT CHECKBYTE LDA 3,.C177 ;*S2EVEN BIT MASK AND 3,0 ;*IN AC0 FOR LCPGN JSR@ LCPGN,2 ;*GET BYTE PARITY SUB 0,1 ;*DIFFERENCE IN AC1 JMP RCVCE ;*TEST FOR ERROR .C177: 177 ;MASK ; ; POST-PROCESSING ENTRY POINT ; SLARO: LDA 1,LCRCT,2 ;GET RECEIVE COUNT MOV# 1,1,SZR ;TEST FOR END M:COUNT JMP@ RCVEN ;OK, CONTINUE LDA 1,CTERR ;GET OVERRUN ERROR POSTS: STA 1,LCRXC,2 ;STORE IN STATUS WORD SLARF: LDA 0,MD1K ;GET MODEM COMMAND LDA 1,LCLAD,2 ;GET LINE ADDRESS ADD 0,1 ;COMBINE .IFN MULT JSR@ .+1 .ENDC SDOB1 JSR@ .SLAK ;KILL RECEIjVER LDA 1,LCRXC,2 ;SEE IF CRC CODE LDA 0,CCERR ;AND IF SO LET TIMEOUT SUB 0,1,SNR JMP @RCVEN ;RETURN, AND IGNORE REST, IF ANY ISZ@ .RSK ;INDICATE RESCHEDULING ON INT EXIT JSR@ LCRIX,2 ;ENTER RECEIVER EXIT ROUTINE JMP@ RCVEN ;RETURN .RSK: RSKED R CVER: LDA 1,CCERR ;GET ERROR CODE JMP POSTS .SLAK: SLAKI NTIBC: 100 ;ITB CODE WORD CCERR: 3 ;BCC ERROR CODE CTERR: 2 ;COUNT OVERRUN ERROR MD1K: 40004 ;DISABLE RCVR, LEAVE DAT TERM RDY ;SET TRANSPARENT MODE SLART: LDA 3,LCDIR,2 ;GET TRANSLATE DIRECT]ORY LDA 1,TDTRB,3 ;GET TRANSPARENT MODE RCB STA 1,LCRBT,2 ;SAVE IN LCB RCB POINTER SUBZL 1,1 ;GET 1 STA 1,LCTRN,2 ;SET XPAR MODE FLAG SLARA: SUB 1,1,SKP ;0 SLARS: SUBZL 1,1 ;1 STA 1,LCDBF,2 ;INTO DOUBLE BYTE FLAG ;SET BCC ACCUMULATION ON SUBZL 1,1 e;GET 1 STA 1,LCRCA,2 ;AND PLACE IN FLAG LDA@ 1,LCRBT,2 ;GET TIMEOUT COUNT STA 1,LCRTO,2 ;AND RESET RECEIVER TIMER JMP SLARO ;TEST COUNT ;SET BCC CHECK CONDITION SLARC: ADCZL 1,1 ;GET -2 STA 1,LCRCB,2 ;SHOW BCC COMING IN SUB 1,1 ;GET 0 STA 1,LCDBF,52 ;CLEAR DBL BYTE FLAG JMP@ RCVEN ;CONTINUE ;LEAVE TRANSPARENT MODE PROCESSING SLARM: ADCZL 1,1 ;GET -2 STA 1,LCRCB,2 ;SHOW BCC COMING IN LDA 3,LCDIR,2 ;GET TRANSLATE DIRECTORY POINTER LDA 1,TDNRB,3 ;GET NON-TRANSPARENT MODE RCB STA 1,LCRBT,2 ;SAVE IN LCB RCB POINTER SUB 1,1 ;GET 0 STA 1,LCTRN,2 ;CLEAR XPAR FLAG ;DOUBLE BYTE PRCESSING ;STORE PREVIOUS DLE ;DO A BCC ON CURRENT BYTE ;STORE CURRENT BYTE SLARD: LDA 0,LCDLE,2 ;GET DLE (DLE-DLE ENTRY POINT) JSR RBP ;DO RECEIVED BYTE PROCESSING SUB 0,W0 ;GET 0 STA 0,LCDBF,2 ;CLEAR DOUBLE BYTE FLAG ;TRANSPARENT MODE POST-PROCESSING SLARI: LDA 0,LCRVB,2 ;GET RECEIVED BYTE LDA 1,LCRCC,2 ;GET ERROR CHECK WORD JSR@ LCECK,2 ;UPDATE IT STA 1,LCRCC,2 ;RESTORE IT JSR RBP ;DO RECEIVED BYTE PROCESSING LDA3 1,LCRCB,2 ;IS A BCC COMING MOV# 1,1,SZR ;TEST JMP@ RCVEN ;YES, FORGET COUNT STA 1,LCRVB,2 ;ZERO CURRENT BYTE JMP SLARO ;SET DOUBLE BYTE FLAG (BIT 0 OF LCDBF) SLARL: LDA 0,LCDBF,2 ;GET MODE ADDOR 0,0 ;SET TOP BIT STA 0,LCDBF,2 ;AND RESTORE JMP @ RCEN ;RETURN TO INTERRUPT HANDLER RCEN: SLREN ;GOT AN ENQ, STATUS=15 IF LAST WAS STX, ELSE STATUS 7 SLARE: LDA 1,LCDBF,2 ;GET DOUBLE BYTE FLAG MOVR# 1,1,SNC ;STX FLAG SET? JMP SLARF ;NO, 7 THERE ALREADY LDA 1,C15 ;GET 15 JMP POSTS ;STORE IT AND FALL HINTO SLARF C15: 15 ;RECEIVED BYTE PROCESSING ; AC0= BYTE ; AC2= LCB ; AC3= RETURN ADDRESS ; ENTERED ONLY BY INTERRUPT HANDLER AND NOT REENTRANT RBP: LDA 1,LCRCT,2 ;GET RECEIVE BYTE COUNT MOV# 1,1,SNR ;TEST FOR ROOM JMP 0,3 ;RETURN, FULL STA 3,RBP3 hG;SAVE RETURN INC 1,1 ;UP DATE COUNT STA 1,LCRCT,2 ;AND SAVE LDA 3,LCRBP,2 ;GET BYTE POINTER ISZ LCRBP,2 ;UPDATE BYTE POINTER MOVZR 3,3,SNC ;MAKE ADDR, ODD OR EVEN? JMP RBP1 ;EVEN, JUST SAVE THIS BYTE AND EXIT LDA 1,0,3 ;GET PREVIOUS BYTE (IS IN LEFT) ADD 1,0,SKP ;PACK IN NEW BYTE RBP1: MOVS 0,0 ;PUT EVEN CHAR INTO LEFT BYTE STA 0,0,3 ;PUT INTO LINE BUFFER JMP@ RBP3 ;AND RETURN RBP3: 0 ;SAVE AC3 .END SLAS.SR 9.LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1973,1974 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ; START RECEIVER ROUTINE ; AC0= RBB ; AC1= RCB ; AC2= LCB ; AC3= RETURN .TITLE SLAS .ENT SLAS,SLASR,SLAK,SLAKK,SLADU,SLAKI .EXTN SDOB0 .EXTN SLAM .NREL SLAS: STA 3,LCRCC,2 ;SAVE RETURN FOR NOW MOV 0,3 ;GET RBB ADDRESS IN 3 LDA 0,0,3 ;PUT BYTE POINTER STA 0,LCRBP,2 ; INTO LCB BYTE POINTER LDA 0,1,3 ;PUT BYTE COUNT NEG 0,0 ;NEGATED STA 0,LCRCT,2 ;INTO LCB BYTE) COUNT STA 1,LCRBT,2 ;SAVE RCB ADDRESS JSR@ .SLAM ;GO CHECK MODEM STATUS STA 0,LCRST,2 ;SET RX FLAG IF MODEM IS ON SUBZL 1,1 ;GET A ONE STA 1,LCRXC,2 ;SETUP RECEIVE CODE MOV# 0,0,SNR ;TEST FOR MODEM ON JMP@ LCRCC,2 ;BAD NEWS, MODEM IS OFF LDA@ 0,LCRBT,2 ;GET TIME COUNT STA 0,LCRTO,2 ;INTO LCB LDA 0,LCSYN,2 ;SET SYN CHARACTER STA 0,LCRVB,2 ;AS CURRENT BYTE LDA 3,LCRCC,2 ;RESTORE RETURN SUB 0,0 ;GET ZERO STA 0,LCRCA,2 ;RESET CHECK ACCUMULATE STA 0,LCRCB,2 ;RESET CHECK RECEIVE CONDITION LDA 0,=LCLCI,2 ;* GET INITIAL CHECK WORD VALUE STA 0,LCRCC,2 ;ZERO CHECK WORD LDA 0,MD1 ;GET MODE COMMAND LDA 1,LCLAD,2 ;GET LINE ADRESS ADD 1,0 ;CREATE COMMAND .IFE MULT ;SINGLE LINE CASE SDOB0 ;TURN ON RCVR .ENDC .IFN MULT ;MULTIPLE 4074'S STA 3,ISAV,2 ;SAVE RTN ON LINE BASIS IN DCT JSR@ .+1 SDOB0 ;TURN ON RCVR LDA 3,ISAV,2 ;RESTORE RTN .ENDC SLASR: JMP 0,3 ;RETURN MD1: 40014 ;ENABLE RECEIVER .SLAM: SLAM ;MODEM CHECK ROUTINE ; KILL RECEIVER ; AC2= LCB SLAKK: LDA 0,MD0K ;MODEM COMCMAND TO DISABLE RCVR AND MOV 0,0,SKP ;DROP DATA TERMINAL READY (DTR) SLADU: ;ENTRY USED TO RAISE DTR SLAK: LDA 0,MD1K ;GET DISABLE RECEIVER COMMAND LDA 1,LCLAD,2 ;GET LINE ADDRESS ADD 1,0 ;CREATE COMPLETE COMMAND .IFE MULT SDOB0 ;KILL RCVR .ENDN@C .IFN MULT STA 3,ISAV,2 ;SAVE RETURN IN DCT JSR@ .+1 SDOB0 ;KILL RCVR LDA 3,ISAV,2 ;RESTORE RTN .ENDC SLAKI: SUB 0,0 ;GET ZERO STA 0,LCRST,2 ;RESET RECEIVER BUSY FLAG STA 0,LCRCA,2 ;ZERO ACCUMULATE FLAG STA 0,LCRCB,2 ;ACCUMULATE CONDITIOBN STA 0,LCRCC,2 ;AND CHECK WORD STA 0,LCDBF,2 ;CLEAR DOUBLE BYTE FLAG STA 0,LCTRN,2 ;CLEAR TRANSPARANT MODE FLAG LDA 1,LCRXC,2 ;SEE IF CRC ERROR CAUSED KILL LDA 0,C3 SUB 0,1,SNR ;DID IT? JMP 0,3 ;YES, RETURN WITHOUT RESETTING CLOCK SUB 0,0 ;NO,C™ONTINUE RESET CHECK LDA 1,LCMDE,2 ;IF MODE = XMIT OPEN (1) NEG 1,1 ;THEN DO NOT RESET CLOCK VALUE COM 1,1,SZR ;..IT IS USED BY XMITTER TIMEOUT STA 0,LCRTO,2 JMP 0,3 ;RETURN MD0K: 40000 ;DISABLE RECEIVER, DROP DATA TERM READY MD1K: 40004 ;DISABL.E RECEIVER, DATA TERMINAL READY C3: 3 .END SLAT.SR ;V.LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1973,1974 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ;TRANSMIT MESSAGE ; AC1 = MCB START ADDRESS ; AC2 = LCB ADDRESS ; AC3 = RETURN .TITLE SLAT .ENT SLAT .EXTN SDOA0,GSDOB0 .EXTN SLAM .NREL SLAT: STA 3,LCTXC,2 ;SAVE RETURN ADDRESS STA 1,LCTMC,2 ;SAVE COMMAND POINTER SUB 1,1 ;GET ZERO STA 1,LCTTI,2 ;RESET TRANSPARENCY STA 1,LCTCA,2 ;RESET CRC ACUMULATION STA 1,LCTBC,2 ;ZERO BUFFER BYTE COUNT STA 1,LCTC1,2 ;ZER,O HOLDING 1 COUNT STA 1,LCTC2,2 ;ZERO HOLDING 2 COUNT LDA 1,LCLCI,2 ;* GET INITIAL CHECKWORD STA 1,LCTCC,2 ;* INTO CHECK WORD JSR@ .SLAM ;CHECK MODEM STATUS LDA 3,LCTXC,2 ;RESTORE RETURN ADDRESS STA 0,LCTST,2 ;SET TX FLAG IF MODEM OK SUBZL 1,1 ;GET W=ONE STA 1,LCTXC,2 ;SET TRANSMIT CODE TO 1 MOV# 0,0,SNR ;IF THE STATUS WAS BAD JMP 0,3 ;RETURN IMMEDIATELY TO THE CALLER LDA 0,@LCRBT,2 ;PMH SET TRANSMIT TIMEOUT STA 0,LCRTO,2 LDA 0,RTS ;GET REQUEST TO SEND COMMAND .IFE MULT ;SINGLE DVC CODE LDA 1/,LCLAD,2 ;GET LINE ADDRESS ADD 1,0 ;ADD TOGETHER SDOB0 ;AND ISSUE COMMAND LDA 0,LCSYN,2 ;GET SYN CHARACTER ADD 1,0 ;CREATE FULL WORD SDOA0 ;TRANSMIT SYN JMP 0,3 ;AND RETURN .ENDC .IFN MULT ;MULTIPLE 4074'S STA 3,ISAV,2 ;SAVE RETURN BY LINE JSR@ .+1 SDOB0 ;ISSUE COMMAND LDA 0,LCSYN,2 ;GET SYN CHAR JSR@ .+1 SDOA0 ;TRANSMIT SYN JMP@ ISAV,2 ;AND RETURN .ENDC RTS: 10 ;REQUEST TO SEND .SLAM: SLAM .END SLAX.SR T[.LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1973,1974,1975 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ; RECEIVER AND TRANSMITTER STATUS ROUTINE ; AC2 = LCB ; AC0 = RECEIVER STATUS 0R -1 ON RETURN ; AC1 = TRANSMITTEX%R STATUS OR -1 ON RETURN .TITLE SLAX .ENT SLAX,SLAM .EXTN SDIB0 .NREL ; GET STATUS CODE SLAX: LDA 1,LCRST,2 ;GET RECEIVER STATE LDA 0,LCRXC,2 ;GET RECEIVER CODE MOV# 1,1,SZR ;TEST IF BUSY ADC 0,0 ;YES, AC0=-1 LDA 1,LCTST,2 ;GET TRANSMIT STRATE MOV# 1,1,SZR ;TEST IF BUSY JMP SLXTB ;YES LDA 1,LCTXC,2 ;GET TRANSMIT CODE JMP 0,3 ;RETURN SLXTB: ADC 1,1 ;TRANSMIT BUSY JMP 0,3 ;RETURN ; MODEM STATUS ROUTINE ; AC2 = LCB ; AC0 = 0 MODEM NOT READY (RETURNED) ; AC0 = 1 MODEM READY F(RETURNED) ; AC1 = MODEM STATUS (RETURNED) ; AC3 = USER STACK POINTER (RETURNED) SLAM: STA 3,LCSL1,2 ;SAVE RETURN IN LCB LDA 1,LCMDM,2 ;GET MODEM CONTROL FLAG MOV# 1,1,SNR ;TEST IF MODEM PRESENT JMP SLAMC ;NO, SET UP FAKE RESPONSE LDA 0,LCLAD,2 ;GE{9T THE LINE ADDRESS .IFN MULT ;MULTIPLE 4074'S JSR@ .+1 .ENDC SDIB0 ;GET LATEST STATUS STA 0,LCHWS,2 ;SETUP HARDWARE STATUS WORD LDA 1,DSRDY ;GET DATASET READY BIT AND 1,0,SZR ;TEST IF PRESENT SLAMC: SUBZL 0,0 ;SET MODEM READY RESPONSE LDA 3,USP ;RETURN USP IN AC3 LDA 1,LCHWS,2 ;GET MODEM STATUS IN AC1 JMP@ LCSL1,2 ;AND RETURN DSRDY: 10 ;DATASET READY BIT .END SLDVR.SR 8.LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1973,1974 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ; SLA DRIVER PROGRAM ; USES TWO TASKS: THE MAIN ONE AND ONE TO READ THE TTY ; ALL WAITING IS DONE THROUGH USE OF SYSTEM DELAY CALLS .TITL SLDVR .COMM TASK,2*400+10 .ENT SLDVR .EXTN .TASK .EXTN SLTBL,SLCB0,DCT .EXTN SYNTO,SYNTX,SYNTT,SYNTE,SYNTC .EXTN SYNRO,SYNRX,SYNST .EXTN SLAI,SLAE,SLAM .NREL .TXTM 1 SLDVR: LDA 0,CH0NM ;GET CH 0 NAME SUB 1,1 ;NO INHIBIT BITS .SYSTM ;OPEN 0 .OPEN 0 JMP ERRTN ;ERROR RETURN LDA 0,CH1NM ;GET CH 1 NAME .SYSTM ;OPEN 1 .OPEN 1 JMP ERRTN ;ERROR RETURN LDA 0,CH2NM ;GET CH 2 NAME .SYSTM ;OPEN IT .OPEN 2 JMP ERRTN ;ERROR RETURN LDA 1,LNTBL ;GET LINE TABLE ADDRESS LDA- 2,DCTP ;GET DCT ADDRESS JSR@ .SLAI ;INITIALIZE SLA JMP SLAIE ;ERROR RETURN .SYSTM ;GET CLOCK FREQUENCY .GHRZ ;INTO AC0 JMP ERRTN ;ERROR RETURN LDA 3,CTBL ;GET BASE OF TABLE - 1 ADDRESS ADD 0,3 ;ADD FREQ OFFSET LDA 0,0,3 ;GET PROPER TICK COUNT ~@STA 0,CWAIT ;SAVE FOR WT ROUTINE SUB 0,0 ;GET ZERO STA 0,TTFLG ;SET TTY INPUT FLAG 0 STA 0,ABFLG ;RESET THE ABORT FLAG STA 0,CH2ST ;SET CHANNEL TWO IDLE LDA 1,TSKA ;GET TASK ENTRY POINT .TASK ;START TTY INPUT TASK JMP ERRTN ;ERROR RETURN WTLP: LD5A 2,LCB0 ;GET LCB0 ADDRESS JSR@ .SLAM ;TEST MODEM STATUS MOV# 0,0,SNR ;ZERO IF BAD JMP NTRDY ;MODEM NOT READY WTLPR: LDA 0,RDYM ;GET READY MESSAGE .SYSTM ;PRINT IT .WRL 1 JMP ERRTN ;ERROR RETURN WTLC: LDA 2,LCB0 ;GET LCB0 ADDRESS JSR@ .RO ;TRY TO OuXPEN RECEIVE JMP NTRDY ;MODEM NOT READY WTRO: JSR@ .ST ;CHECK STATUS OF OPEN JMP WTLC ;SOME ERROR, MAYBE ERR1. TRY AGAIN JMP WTDLY ;BUSY, GO WAIT AND RELEASE CONTROL JMP RCOPN ;GO TO RECEIVE OPEN CODE WTDLY: JSR WT ;GO WAIT AND RELEASE CONTROL JMP WTRVO ;GO TEST STATUS AGAIN JMP@ .TSVC ;TTY MESSAGE RETURN. SERVICE IT JMP@ .TSVC ;ABORT MESSAGE RETURN. SERVICE IT ; MODEM NOT READY. WAIT HERE UNTIL IT IS NTRDY: LDA 0,NRDYM ;GET NOT READY MESSAGE .SYSTM ;PRINT IT .WRL 1 JMP ERRTN ;ERROR RETURN NTRDL: LDA 2,LCB0 ;GET LCB ADDRESS JSR@ .SLAM ;TEST MODEM STATUS MOV# 0,0,SZR ;0 IF NOT READY JMP WTLPR ;IT'S ON JSR WT ;WAIT SOME MORE JMP NTRDL ;NO MESSAGES IN JMP NTRDL ;ANY MESSAGE RETURN JMP@ .TSVC ;ABORT MESSAGE RETURN NRDYM: NRDY*2 ;POINTER TO NOT READY MESSAGE .TSVC: TTSVC ;TTY INPUT SERVICE SLAIE: LDA 0,IERM ;GET SLAI ERROR MESSAGE .SYSTM ;PRINT IT .WRL 1 ;ON THE TTY JMP ERRTN ;ERROR RETURN JMP@ .HRST ;AND RETURN TO SYSTEM .HRST: HRSET ; TAKE SYSTEM ERROR RETURN WITH ERROR IN AC2t ERRTN: .SYSTM ;TAKE ERROR RETURN HERE .ERTN ;THE CLI WILL CLOSE OPEN FILES ; LINE IS OPEN. THIS IS THE MAIN RECEIVE LOOP RCOPN: LDA 0,OPNM ;GET OPEN MESSAGE .SYSTM ;AND PRINT IT .WRL 1 JMP ERRTN ;ERROR RETURN RCLP: LDA 0,RBUFP ;GET RECEIVE BUFFER POINTER LDA 1,RMAX ;GET MAX COUNT LDA 2,LCB0 ;GET LCB POINTER JSR@ .RX ;RECEIVE MESSAGE JMP RCER ;ERROR ON LINE JMP RCDLY ;WAIT TO RECEIVE BLOCK STA 0,CH2ST ;SET CHANNEL TWO ACTIVE ADD 0,1 ;POINT TO END OF RECEIVED MESSAGE STA@ 1,.PTPTR ;SAVE :BYTE POINTER FOR PUT LDA 0,C15 ;GET CARRIAGE RETURN JSR@ .PUT ;APPEND A C.R. LDA 0,RBUFP ;GET RECEIVED TEXT POINTER .SYSTM ;WRITE TO CH 2 .WRL 2 JMP ERRTN ;ERROR RETURN LDA 2,LCB0 ;GET LCB POINTER LDA 0,LCLST,2 ;CHECK FOR END OF FILE MOV 0,0,SNR 1;1 IF SO JMP RCLP ;KEEP RECEIVING SUB 0,0 STA 0,CH2ST ;RESET CH 2 FLAG JMP RCLP ;KEEP RECEIVING OPNM: LOPN*2 .PUT: PUT .PTPTR: PTPTR RCER: LDA 0,CH2ST ;SEE IF 2 WAS ACTIVE MOV# 0,0,SNR ;1 IF SO JMP WTLP ;TRY TO OPEN RECEIVE AGAIN SUB 0,0 STA 0,CH2ST ;RESET CH 2 FLAG LDA 0,RCERM ;GET ERROR MESSAGE POINTER .SYSTM ;OUTPUT ON CHANNEL 1 .WRL 1 JMP ERRTN ;ERROR RETURN JMP WTLP ;CONTINUE TRYING RCDLY: JSR@ .ST ;CHECK ON LINE STATUS JMP RCER ;OOPS JMP RCWT ;KEEP WAITING JMP RCLP ;GO TRY TO GET NWEXT RECORD RCWT: JSR WT ;CALL THE WAIT ROUTINE JMP RCDLY ;NO MESSAGE RETURN JMP RCDLY ;ANY TTY MESSAGE RETURN SUB 0,0 ;ABORT MESSAGE RETURN. GET ZERO STA 0,CH2ST ;SET 2 IDLE JMP TTSVC ;SERVICE COMMAND CH0NM: CH0*2 ;CH 0 NAME POINTER CH1NM: CH1*2 ;CH 1 NAME POINTER CH2NM: CH2*2 ;CH 2 NAME POINTER IERM: IER*2 ;SLAI INIT ERROR MESSAGE RDYM: RDY*2 ;'READY' MESSAGE RCERM: RCM*2 ;RECEIVE ERROR MESSAGE RBUFP: RBUF*2 ;POINTER TO RECEIVE BUFFER RMAX: 140. ;MAX BYTE COUNT C15: 15 ;CARRIAGE RETURN TSKD)A: TTYTK ;TTY SERVICE TASK CTBL: CLTBL-1 ;TICK CONVERSION TABLE CWAIT: 0 ;100 MSEC. TIMEOUT COUNT TTFLG: 0 ;TTY SERVICE FLAG ABFLG: 0 ;ABORT MESSAGE FLAG CH2ST: 0 ;CHANNEL 2 ACTIVE FLAG LNTBL: SLTBL ;SLA LINE TABLE ADDRESS LCB0: SLCB0 ;LCB ADDRESS )IDCTP: DCT ;DCT ADDRESS .SLAI: SLAI ;SLA INITIALIZATION .SLAE: SLAE ;SLA TERMINATION .SLAM: SLAM ;MODEM STATUS .RO: SYNRO ;RECEIVE OPEN .RX: SYNRX ;RECEIVE .ST: SYNST ;STATUS CHECK ; SYSTEM WAIT ROUTINE ; ALL SUBROUTINES USE THIS ROUTINE TO WAI|mT FOR COMPLETION ; OF STATUS CHECKS. ; THERE ARE THREE RETURNS POSSIBLE ; NORMAL RETURN, NO MESSAGE WAITING FROM TTY ; ANY MESSAGE RETURN, OTHER THAN AN ABORT OR IMMEDIATE ACTION MSG ; ABORT MESSAGE RETURN, DEMANDS IMMEDIATE SERVICE WT: STA 3,WT3 ;SAVE RETURN ADDRESS STA 2,WT2 ;SAVE AC2 STA 1,WT1 ;SAVE AC1 LDA 1,CWAIT ;GET TIMEOUT COUNT .SYSTM ;CALL SYSTEM WAIT .DELAY JMP ERRTN ;ERROR RETURN LDA 2,TTFLG ;SEE IF MESSAGE IN  MOV# 2,2,SZR ;NON ZERO IF IT ARRIVED ISZ WT3 ;TAKE ANY MESSAGE RETURN LDA 2,ABFLG ;CHECK ACTION MESSAGE FLAG MOV# 2,2,SZR ;NON ZERO IF ACTION OR ABORT MESSAGE ISZ WT3 ;TAKE ABORT RETURN LDA 1,WT1 ;RESTORE AC1 LDA 2,WT2 ;RESTORE AC2 JMP@ WT3 ;RETURN WT1: 0 ;AC1 WT2: 0 ;AC2 WT3: 0 ;AC3 ; TTY SERVICE TASK ; THE TASK CALLS THE SYSTEM TO READ THE NEXT LINE, ; AND CHECKS INPUT TO SEE IF IMMEDIATE ACTION REQUIRED ; IT THEN WAITS FOR TTFLG TO BE CLEARED BY THE TTY SERVICE ROUTINE. ; THIS ALLOWS INCOMING TTY COMMANDS TO BE STACKED BY THE SYSTEM TTYTK: LDA 0,TTYBF ;GET TTY BUFFER POINTER .SYSTM ;GO READ IT .RDL 0 JMP ERRTN ;ERROR RETURN STA 0,TTA0 ;SAVE POINTER STA 1,TTA1 ;SAVE COUNT ISZ TTFLG ;SET FLAG LDA@ 0,.TTBF ;GET FIRST TWO CHARACTERS LDA 1,MASK ;GET CHARACTER MASK ANDS 1,0 ;GET FIRST CHARACT/ ER LDA 1,CMDH ;GET H COMMAND SUB# 1,0,SNR ;SEE IF EQUAL ISZ ABFLG ;SET ABORT FLAG TTYWT: LDA 1,TTFLG ;GET TTY FLAG MOV# 1,1,SNR ;SEE IF TTSVC HAS RESET IT JMP TTYTK ;YES, GET NEXT LINE LDA 1,CWAIT ;GET 100 MSEC TIMEOUT .SYSTM ;GO WAIT AGAIN .DELAYd JMP ERRTN ;ERROR RETURN JMP TTYWT ;TRY FLAG AGAIN TTYBF: TTBF*2 ;BUFFER BYTE POINTER TTA0: 0 ;BYTE POINTER TTA1: 0 ;RECEIVED BYTE COUNT ; TTY SERVICE AND COMMAND DECODE ROUTINE TTSVC: LDA 0,TTA0 ;GET BUFFER POINTER LDA 1,TTA1 ;GET COUNT ADD 0,1 ;POINT TO LAST BYTE + 1 STA@ 1,.PTPTR ;SAVE FOR PUT DSZ@ .PTPTR ;POINT TO LAST BYTE SUB 0,0 ;GET ZERO STA 0,TTFLG ;CLEAR FLAG STA 0,ABFLG ;RESET ABORT FLAG JSR@ .PUT ;PUT NULL AT END OF FILE NAME LDA@ 0,.TTBF ;GET COMMAND AND BLANK LDA 1,MASK ;G#ET CHARACTER MASK ANDS 1,0 ;CLEAN IT UP LDA 1,CMDH ;SEE IF HOME COMMAND SUB# 0,1,SNR ;TEST JMP H1 ;YES LDA 1,CMDS ;SEE IF SEND COMMAND SUB# 0,1,SNR ;TEST JMP S1 ;YES LDA 0,QMM ;GET ?? MESSAGE POINTER .SYSTM ;PRINT IT .WRL 1 JMP@ ERTN ;ERROR R_ETURN JMP@ .WTLP ;RETURN, TRY AGAIN MASK: 177400 ;BYTE MASK QMM: QM*2 ;BYTE POINTER TO ?? CMDH: "H ;HOME COMMAND CMDS: "S ;SEND FILE COMMAND .WTLP: WTLP ;MAIN WAIT LOOP .TTBF: TTBF ;TTY BUFFER TTBFF: TTBF1*2 ;BYTE POINTER TO FILE NAME LOPNM: LOPN*2 .GTPTR: GTPTR ; RESET EVERYTHING AND RETURN H1: LDA 1,LNTBL ;GET LINE TABLE ADDRESS LDA 2,DCTP ;GET DCT ADDRESS JSR@ .SLAE ;RESET THE SLA HRSET: .SYSTM ;CLOSE ALL FILES .RESET JMP@ ERTN ;ERROR RETURN .SYSTM ;RETURN TO SYSTEM .RTN ; SEND FILE+ AS REQUESTED S1: SUB 1,1 ;GET ZERO LDA 0,TTBFF ;GET POINTER TO FILE NAME .SYSTM ;TRY TO OPEN IT .OPEN 3 ;CHANNEL THREE JMP FLERR ;ERROR ON OPEN LDA 0,LNOM ;GET LINE NOT OPEN MSG POINTER STA 0,TXMSG ;AND SET UP OUTPUT POINTER LDA 2,LCB0 ;GET LCB JSR@ .TO ;TRY TO OPEN FOR TRANSMIT JMP FLCLS ;ERROR, GO CLOSE FILE JSR WAIT ;GO TO COMMON TRANSMIT WAIT LDA 0,TXFM ;GET TRANSMIT FAIL MSG POINTER STA 0,TXMSG ;AND SET UP OUTPUT POINTER LDA 0,LOPNM ;GET LINE OPEN MESSAGE .SYSTM ;PRINT IT .WRL 1 J+MP@ ERTN ;ERROR RETURN TXLP: JSR@ .READ ;GET A RECORD FROM FILE JMP LNERR ;FILE READ ERROR RETURN JMP ENDFL ;END OF FILE RETURN LDA 0,C40 ;GET CARD BUFFER WORD SIZE STA 0,CNTR ;SAVE IN COUNTER LDA 0,CDBUF ;GET CARD BUFFER WORD POINTER STA 0,CDPTR ;S^AVE IN POINTER LDA 0,SPACE ;GET BLANKS CLRL: STA@ 0,CDPTR ;CLEAN OUT BUFFER ISZ CDPTR ;UPDATE POINTER DSZ CNTR ;SEE IF CLEANING DONE JMP CLRL ;NO LDA 1,C80 ;GET MOVE COUNT STA 1,CNTR ;SAVE MOVE COUNT LDA 0,CBUFP ;GET CARD BUFFER BYTE POINTER STA@ 0hB,.PTP ;SAVE FOR PUT LDA 0,TBUFP ;GET TEXT BYTE POINTER STA@ 0,.GTPTR ;SAVE FOR GET MVLP: JSR@ .GET ;MOVE TEXT TO CARD BUFFER LDA 1,CR ;TEST FOR CARRIAGE RETURN SUB# 0,1,SNR JMP NOMOV LDA 1,FF ;TEST FOR FORM FEED SUB# 0,1,SNR JMP NOMOV MOV# 0,0,SNRy ;TEST FOR NULL JMP NOMOV LDA 1,TAB ;GET TAB CHARACTER SUB 0,1,SZR ;SEE IF TAB SIMULATE REQD JMP MVPT ;NO LDA 0,CNTR ;GET COUNT LDA 1,C7 ;GET MASK AND 0,1,SNR ;CNTR MOD 8 LDA 1,C8 ;8 SPACES REQUIRED STA 1,TBCNT ;SAVE SPACES REQUIRED TABLP: LDA 0,VUSPACE ;GET SPACE CHAR JSR PUT ;PUT INTO CARD BUFFER DSZ CNTR ;UPDATE MOVE COUNT JMP .+2 ;KEEP SPACING JMP NOMOV ;END OF CARD DSZ TBCNT ;CHECK TAB COUNT JMP TABLP ;KEEP SPACING JMP MVLP ;GET NEXT CHARACTER MVPT: JSR PUT DSZ CNTR ;DONE YET? JMP MVLP ;NO NOMOV: LDA 0,CBUFP ;GET BYTE POINTER LDA 1,C80 ;GET COUNT LDA@ 2,.LCB0 ;GET LINE CONTROL BLOCK JSR@ .TX ;WRITE OUT THIS CARD JMP TXERR ;TRANSMIT ERROR JSR WAITR ;WAIT AND RETRY CALL JMP TXLP ;KEEP GOING ; SEND LAST RECORD IN THIS TRANSMISSION ENDFL: LDA@ 2,.LCB0 ;GET LCB ADDRESS JSR@ .TE ;SEND ETX, FLUSH BUFFER JMP TXERR ;OOPS, TRANSMIT ERROR JSR WAIT ;WAIT JSR CLSLN ;CLOSE TRANSMIT LINE LDA 0,ENDM ;GET END DATA MESSAGE JMP FLTYP ;AND PRINT IT TXERR: LDA 0,TXMSG ;GET FAILURE MESSAGE J]MP FLTYP ;AND PRINT IT LNERR: JSR CLSLN ;CLOSE TRANSMIT LINE FLERR: LDA 0,FEM ;GET FILE ERROR MESSAGE FLTYP: .SYSTM ;TYPE OUT MESSAGE .WRL 1 JMP@ ERTN ;ERROR RETURN FLCLS: .SYSTM ;CLOSE INPUT FILE .CLOSE 3 JMP .+1 ;ERROR RETURN (IGNORE) JMP@ .WTLP +7;AND RETURN TO READY CLSLN: STA 3,CLSRT ;SAVE RETURN ADDRESS LDA@ 2,.LCB0 ;GET THE LCB JSR@ .TC ;SEND OUT EOT JMP TXERR ;TRANSMIT ERROR JSR WAIT ;WAIT FOR COMPLETION JMP@ CLSRT ;AND RETURN CLSRT: 0 ;RETURN ADDRESS .LCB0: LCB0 .READ: READ ERTN: ERRTN .TO: SYNTO .TX: SYNTX .TT: SYNTT .TE: SYNTE .TC: SYNTC .STT: SYNST .PTP: PTPTR .GET: GET LNOM: LNO*2 TXFM: TXF*2 TXMSG: 0 ;TRANSMIT FAIL MESSAGE POINTER CR: 15 ;CARRIAGE RETURN FF: 14 ;FORM FEED C40: 40. SPACE: " *400+" CNTR: 0 ;COUNTER TBUFP: TBUzF*2 ;TEXT BYTE POINTER CDPTR: 0 ;CARD BUFFER WORD POINTER CBUFP: CBUF*2 ;CARD BUFFER BYTE POINTER CDBUF: CBUF ;CARD BUFFER WORD POINTER C80: 80. ; TRANSMIT WAIT SUBROUTINES WAITR: NEG 3,3 ;WAIT AND RETRY PREVIOUS CALL INC 3,3 ;DECREMENT PC BY TH@REE INC 3,3 COM 3,3 WAIT: STA 3,WTRTN ;WAIT FOR TRANSMIT COMPLETION WAITS: JSR@ .STT ;CALL SYNCP STATUS JMP TXERR ;TRANSMIT ERROR JMP .+2 ;KEEP WAITING JMP@ WTRTN ;RETURN JSR@ .WT ;CALL SYSTEM WAIT JMP WAITS ;NORMAL RETURN JMP WAITS ;ANY MESSAGE R/ETURN .SYSTM ;ABORT RETURN .CLOSE 3 ;CLOSE INPUT CHANNEL JMP@ ERTN ;ERROR RETURN JMP@ .TTSV ;SERVICE MESSAGE .WT: WT ;SYSTEM WAIT .TTSV: TTSVC FEM: FE*2 ENDM: ENDD*2 WTRTN: 0 ;RETURN ADDRESS ; READ NEXT RECORD FROM INPUT FILE READ: STA 3,RDRTN ;hSAVE RETURN READA: LDA 0,TBUFP ;GET TEXT BYTE POINTER .SYSTM ;READ INPUT FILE .RDL 3 JMP READE ;READ ERROR STA 0,GTPTR ;SET UP GET POINTER JSR GET ;GET FIRST BYTE IN BUFFER MOV# 0,0,SNR ;SEE IF NULL JMP READA ;READ AGAIN READR: ISZ RDRTN ;TAKE NOR`MAL RETURN READF: ISZ RDRTN ;TAKE END OF FILE RETURN JMP@ RDRTN ;AND RETURN READE: LDA 0,EREOF ;SEE IF END OF FILE SUB# 0,2,SZR ;TEST JMP@ RDRTN ;NOT SO GOOD, ERROR EXIT JMP READF ;AND RETURN RDRTN: 0 ;RETURN ADDRESS EREOF: 6 ;END OF FILE CODE TBCNT": 0 ;TABS COUNTER C7: 7 C8: 8. TAB: 11 ;ASCII TAB ; PUT BYTE ROUTINE ; AC0 = BYTE ; AC3 = RETURN ; PTPTR = BYTE POINTER PUT: STA 3,PUT3 ;SAVE RETURN LDA 1,PTPTR ;GET BYTE POINTER ISZ PTPTR ;UPDATE IT LDA 2,C377 ;GET MASK AND 2,0 ;MASK OFF INPUT BYTE MOVZR 1,3,SZC ;MAKE CORE ADDRESS MOVS 2,2 ;REPOSITION MASK LDA 1,0,3 ;GET BYTE WORD AND 2,1,SNC ;CLEAN UP BYTE WORD MOVS 0,0 ;REPOSITION BYTE ADD 1,0 ;ADD IN BYTE STA 0,0,3 ;RESTORE IN BUFFER JMP@ PUT3 ;RETURN PTPTR: 0 ;PUT BYTE POINTER PUT3: 0 ;RETURN C377: 377 ;MASK ; GET BYTE ROUTINE ; AC0 = BYTE ; AC3 = RETURN ; GTPTR = BYTE POINTER GET: STA 3,GET3 ;SAVE RETURN ADDRESS LDA 3,GTPTR ;GET BYTE POINTER ISZ GTPTR ;UPDATE IT MOVZR 3,3 ;MAKE CORE ADDRESS LDA 1,C377 ;GET MASK LDA 0,0,3 ;GET WORD MOV# 0,0,SNC ;TEST FOR SWAP MOVS 0,0 ;SWAP AND 1,0 ;CLEAN UP BYTE JMP@ GET3 ;RETURN GET3: 0 ;RETURN ADDRESS GTPTR: 0 ;GET BYTE POINTER CH0: .TXT '$TTI' ;TELETYPE IN CH1: .TXT '$TTO' ;TELETYPE OUT CH2: .TXT '$LPT' ;LINE PRINTER IER: .TXT 'SLAI ERROR<15>' RDY: .TXT 'READY<15>' NRDY: .TXT 'DATASET NOT READY<15>' QM: .TXT '??<15>' ;ILLEGAL COMMAND LOPN: .TXT 'LINE OPEN<15>' LNO: .TXT 'LINE NOT OPEN<15>' FE: .TXT 'FILE ERROR<15>' ENDD: .TXT 'END OF DATA<15>' TXF: .TXT 'TRANSMISSION FAILURE<15>' RCM: .TXT 'LINE FAILED DURING RECEIVE<15>' CLTBL: 1. ;1 = 10 HZ. 10. ;2 = 100 HZ. 100. ;3 = 1000 HZ. RBUF: .BLK 71. ;RECEIVED TEXT BUFFER TTBF: .BLK 1 ;TTY INPUT BUFFER TTBF1: .BLK 66. TBUF: .BLK 66. ;INPUT FILE TEXT BUFFER CBUF: .BLK 40N. ;CARD BUFFER .END SLDVR SLERR.SR q.LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1973,1974,1976 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ; SLA LCB ERROR DUMP SUBROUTINE .TITL SLERR .ENT SLERR .EXTN SLCBD .EXTD SLECN .NREL .TXTM 1 ; ERROR DUMP SUBROUTINE SLERR: STA 0,AC0 ;SAVE AC0 STA 1,AC1 ;SAVE AC1 STA 2,AC2 ;SAVE AC2 STA 3,AC3 ;SAVE AC3 JSR CRET ;OUTPUT CARRIAGE RETURN LDA 0,AC0 ;PRINT OUT 4 SAVED AC'S JSR PRINT LDA 0,AC1 JSR PRINT LDA 0,AC2 JSR PRINT LDA 0,AC3 JSR PRINT JSR CR%ET ;DO ANOTHER C.R. JSR CRET ;INSERT CARRIAGE RETURN JSR LCBD ;AND DUMP JSR CRET ;INSERT CARRIAGE RETURN LDA 2,LCB ;GET LCB POINTER FROM LCBD LDA 0,LCBP1,2 ;GET BUFFER BYTE POINTER  MOVZR 0,0 ;MAKE A WORD POINTER STA 0,WD ;SETUP LINE BUFFER FOR DUMP $ LDA 0,LCBC1,2 ;GET BUFFER SIZE COUNT INCZR 0,0,SNR ;MAKE INTO WORD COUNT JMP ERR1 ;NO BUFFER DUMP STA 0,LNCT JSR DUMP ;GO DUMP ERR1: LDA 0,AC0 ;RESTORE AC'S LDA 1,AC1 LDA 2,AC2 JMP@ AC3 ;RETURN AC0: 0 AC1: 0 AC2: 0 AC3: 0 DUMP: STA 3,DUMPR ;SAVE DUMP RETURN DMP1: LDA 0,C8 ;GET COLUMN COUNTER STA 0,CLCT ;SAVE IT DMP2: LDA@ 0,WD ;GET NEXT WORD TO DUMP ISZ WD ;UPDATE POINTER JSR PRINT ;PRINT IT DSZ LNCT ;TEST IF WORD COUNT DONE JMP .+2 ;NO JMP DMP3 ;YES, END DSZ CLCT ;CHECK FOR END OF COLUMN JMP DMP2 ;CONTINUE ON THIS LINE JSR CRET ;END THIS LINE JMP DMP1 ;KEEP DUMPING DMP3: JSR CRET ;INSERT C. R. JMP@ DUMPR ;RETURN WD: 0 ;POINTER TO NEXT DUMP WORD DUMPR: 0 ;RETURN ADDRESS CLCT: 0 ;COLUMN COUNTER LNCT: 0 ;LINE COUNTER C8: 8. ; PRINT SINGLE LOCATION ; CONTENTS OF AC0 ARE PRINTED PRINT: STA 3,PRTN ;SAVE RETURN ADDRESS LDA 1,C3 ;GET COUNT STA 1,PCNT ;SAVE IT LDA 1,PWD3 ;GET ADDRESS OF LOWEST DIGITS STA 1,PWD ;SAVE IT LDA 3,C7 ;GET DIGIT MASK PR1: ADCZL 1,1 ;GET -2 STA 1,BCNT V;SAVE AS BYTE COUNT LDA 2,ZZ ;GET ZERO-ZERO PR2: MOV 0,1 ;GET 3 RIGHT HAND BITS AND 3,1 ;CLEAN THEM UP ADDS 1,2 ;SAVE THIS HALF MOVZR 0,0 ;POSITION NEXT OCTAL DIGIT MOVZR 0,0 MOVZR 0,0 ISZ BCNT ;IS THIS THE SECOND BYTE JMP PR2 ;NO STA@ 2,PWD ;SAVE COMPLETED WORD DSZ PWD ;POINT TO PREVIOUS WORD DSZ PCNT ;ALL THREE WORDS DONE? JMP PR1 ;NO LDA 0,PBUF ;GET PRINT BUFFER ADDRESS LDA 2,CHN ;GET CHANNEL NUMBER .SYSTM ;WRITE IT .WRL CPU ;TO CHANNEL JMP .+1 ;ERROR RETURN JMP@ PRTN ;RETURN PRTN: 0 ;RETURN ADDRESS PCNT: 0 ;PRINT WORD COUNTER PWD: 0 ;PRINT WORD POINTER BCNT: 0 ;BYTE COUNTER PBUF: PB*2 ;BYTE POINTER TO PRINT BUFFER PWD3: .+3 ;LAST WORD IN BUFFER PB: .TXT '000000 ' ;PRINT BUFFER ZZ: .TXT '00' ;ZERO-ZERO C3: 3 C7: 7 CHN: SLEPCN ;OUTPUT CHANNEL NUMBER ; OUTPUT A CARRIAGE RETURN CRET: STA 3,CRETR ;SAVE RETURN LDA 0,CR ;GET BYTE POINTER LDA 2,CHN ;GET CHANNEL NUMBER .SYSTM ;WRITE IT .WRL CPU ;TO CHANNEL CRETD: JMP .+1 ;ERROR RETURN JMP@ CRETR ;RETURN CRETR: 0 ;RETURN ADDRESS CR: CRTN*2 CRTN: .TXT '<15>' ;CARRIAGE RETURN CODE ; DUMP THE LCB LCBD: STA 3,LCBDR ;SAVE RETURN ADDRESS LDA@ 0,LCBA ;GET LCB ADDRESS STA 0,LCB ;SAVE IT FOR DUMP STA 0,WD ;SAVE IT LDA 0,LCBL ;GET LCB LENGTH STA 0,LCBCT LDA 0,TXPTR ;GET TEXT POINTER STA 0,TXP LCBD1: LDA 0,C6 ;SETUP COLUMN COUNT STA 0,CLCT LCBD2: LDA 0,TXP ;GET POINTER TO LCB IDENT LDA 2,CHN ;GET CHANNEL NUMBER .SYSTM ;PRINT IDENTIFIER .WRL CPU ;ON CHANNEL JMP CRETD ;ERROR LDA 1,C6 ;UPDATE TEXT POINTER ADD 0,1 STLdA 1,TXP LDA@ 0,WD ;GET LCB CONTENTS ISZ WD ;UPDATE POINTER JSR PRINT ;PRINT IT DSZ LCBCT ;CHECK FOR END OF LCB JMP LCBD3 ;STILL OK JSR CRET ;FINISH LINE JMP@ LCBDR ;RETURN LCBD3: DSZ CLCT ;CHECK FOR END OF LINE JMP LCBD2 ;CONTINUE JSR CRET ;END OqF LINE JMP LCBD1 LCBA: SLCBD ;USER LCB LCB: 0 ;LCB ADDRESS LCBDR: 0 LCBCT: 0 TXP: 0 C6: 6 LCBL: LCCP5+1 TXPTR: TEXT*2 ; LINE CONTROL BLOCK -- PARAMETER DEFINITIONS ; COMMON LOCATIONS TEXT: .TXT 'LAD ' ;LINE ADDRESS FOR THIS LCB .TXT 'RIH ' ;RECEIV<E INTERRUPT HANDLER .TXT 'TIH ' ;TRANSMIT INTERRUPT HANDLER .TXT 'DIR ' ;TRANSLATION DIRECTORY .TXT 'LCI ' ;ERROR CHECK INITIAL VALUE .TXT 'VRC ' ;ERROR CHECK LENGTH .TXT 'ECK ' ;ERROR CHECK ROUTINE .TXT 'PGN ' ;PARITY GEENRATE ROUTINE .TXT 'PCH ' ;PARITY CHECK ROUTINE .TXT 'SYN ' ;SYN CHARACTER .TXT 'DLE ' ;DLE CHARACTER .TXT 'MSK ' ;LINE CODE MASK .TXT 'MDM ' ;MODEM CONTROL FLAG .TXT 'LCH ' ;LINE CHARACTERISTICS ; BUFFER CONTROL POINTERS .TXT 'BP1 ' ;BUFFER 1 POINTER .TXT 'BC1 ' ;BUFFER 1 BYTE COUNT .TXT 'ABP ' ;ACTIVE BUFFER POINTER .TXT 'ABC ' ;ACTIVE BUFFER COUNT .TXT 'ABS ' ;ACTIVE BUFFER STATUS ; LINE AND DATASET REGISTERS .TXT 'HWS ' ;HARDWARE STATUS .TXT 'LST ' ;LINE STATUS .TXT 'MDE ' ;LINE MODE .TXT 'ACK ' ;ACK CONTROL RE;GISTER .TXT 'ERC ' ;ERROR RETRY COUNT ; ERROR COLLECTION LOCATIONS .TXT 'RET ' ;RECEIVE ERROR TOTAL .TXT 'TET ' ;TRANSMIT ERROR TOTAL ; RECEIVER PARAMETERS .TXT 'RST ' ;RECEIVER STATUS FLAG .TXT 'RXC ' ;RECEIVE STATUS CODE .TXT 'RIX ' ;RECEIVER IXMT EXIT ADDRESS .TXT 'RCA ' ;RECEIVE CRC ACCUMULATE .TXT 'RCB ' ;CRC BYTE RECEIVE CONDITION .TXT 'RCC ' ;RECEIVER CRC WORD .TXT 'RVB ' ;CURRENTLY RECEIVED BYTE .TXT 'RPV ' ;PREVIOUSLY RECEIVED BYTE .TXT 'DBF ' ;DOUBLE BYTE FLAG .TXT 'RRP ' ;RESTA ]RT BYTE POINTER .TXT 'RRC ' ;RESTART BYTE COUNT .TXT 'RBP ' ;RECEIVER BUFFER POINTER .TXT 'RCT ' ;RECEIVER BUFFER COUNT .TXT 'RBT ' ;RECEIVER CONTROL BLOCK TABLE .TXT 'RTO ' ;RECEIVER TIME OUT .TXT 'TRN ' ;TRANSPARANCY FLAG ; TRANSMITTER PARAMETEBRS .TXT 'TST ' ;TRANSMITTER STATUS .TXT 'TXC ' ;TRANSMIT STATUS CODE .TXT 'TIX ' ;TRANSMIT IXMT EXIT ADDRESS .TXT 'TTI ' ;TRANSPARENCY INDICATOR .TXT 'TCA ' ;TRANSMIT CRC ACCUMULATE .TXT 'TCC ' ;TRANSMIT CRC WORD .TXT 'TMS ' ;MESSAGE BLOCK START .TXT 'TMC ' ;CURRENT MESSAGE BLOCK COMMAND .TXT 'TBP ' ;TRANSMIT BUFFER POINTER .TXT 'TBC ' ;TRANSMIT BUFFER COUNT .TXT 'TB1 ' ;HOLDING BYTE 1 .TXT 'TC1 ' ;HOLDING COUNT 1 .TXT 'TB2 ' ;HOLDING BYTE 2 .TXT 'TC2 ' ;HOLDING COUNT 2 .TXT 'TBT ' ;CURRENT` TRANSMIT BYTE .TXT 'TSX ' ;STX OPTION FOR NON-XPARANT XMISSIONS ; RETURN AND SAVE LOCATIONS .TXT 'SLR ' ;SLA RETURN TEMPORARY .TXT 'SL1 ' ;RETURN TEMPORARY .TXT 'CPR ' ;CP RETURN TEMPORARY .TXT 'RT1 ' ;RETURN TEMP 1 .TXT 'AC0 ' ;AC0 SAVE LOCATION .TXT 'AC1 ' ;AC1 SAVE LOCATION .TXT 'CP1 ' ;CP TEMP 1 .TXT 'CP2 ' ;CP TEMP 2 .TXT 'CP3 ' ;CP TEMP 3 .TXT 'CP4 ' ;CP TEMP 4 .TXT 'CP5 ' ;CP TEMP 5 .END SLTAB.SR 0.LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1974,1976 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ; SPECIAL CHARACTER TABLE ; FOR ASCII AND EBCDIC .TITLE SLTAB .ENT SCTAB .NREL ;FORMAT ;BIT 0 -- SPECIAL FOR ASC/II OR EBCDIC (INC OR BITS 2,7) ;BIT 1 -- THIS EIGHT BIT ENTRY IS EVEN PARITY (FOR PARITY ; GENERATION AND CHECKING) ;BIT 2 -- SPECIAL CHARACTER FOR EBCDIC ;BITS 3-6 -- 4 BIT DISPATCH INTO SPEC CHAR ACTION TBL ;BIT 7 -- SPECIAL CHARACTER FOR ASCII ;BITS 8-15 -- EBCDIC TO ASCII TRANSLATION ; -- ASSUMING HOLLERITH AS BASE SPEC=1B0 ;POSSIBLE SPECIAL CHAR (DEPENDS ON LINE CODE) X=1B1 ;EVEN PARITY SA=1B7 ;SPECIAL CHAR FOR ASCII SE=1B2 ;SPECIAL CHARACTER FOR EBCDIC SCTAB: X!0 SPEC!SA!SE!13B6!1 ;SOH IN BOTH ASCII AND EBCDIC SPEC!SA!SE!0B6!2 ;STX IN BOTH X!SPEC!SE!6B6!3 ;ETX IN EBCDIC SPEC!SA!11B6!0 ;EOT IN ASCII X!11 ;HT X!0 177 ;DEL 0 X!0 X!0 13 ;VT X!14 ;FF 15 ;CR 16 ;SO X!17 ;SI SPEC!SA!SE!14B6!20 ;DLE IN BOTH X!21 ;DC1 X!22 ;DC2 23 ;DC3 X!0 SPEC!SA!12B6!0 ;NAK IN ASCII SPEC!SA!15B6!10 ;SYN IN ASCII (BS) X!0 X!30 ;CAN 31 ;EM 0 X!0 34 ;FS X!35 ;GS X!36 ;RS SPEC!SA!SE!10B6!37 ;ITB IN BOTH (US) 0 X!0 X!0 0 X!0 12 ;LF SPEC!SE!7B6!2G'7 ;ETB IN EBCDIC (EOB) X!33 ;ESC X!0 0 0 X!0 0 X!SPEC!SE!5B6!5 ;ENQ IN EBCDIC X!6  ;ACK 7 ;BELL X!0 SPEC!SA!2B6!0 ;PART 2 OF ACK1 IN ASCII (1) SPEC!SE!15B6!26 ;SYN IN EBCDIC X!0 0 X!0 X!0 SPEC!SE!11B6!4 ;EOT IN EBCDIC 0 X!0 X!0 S+PEC!SA!4B6!0 ;P2 OF WACK IN ASCII X!24 SPEC!SE!12B6!25 ;NAK IN EBCDIC 0 X!32 ;SUB 40 ;SPACE X!0 X!0 0 X!0 0 0 X!0 X!0 0 ; 4/21/76 133 ; 4/21/76 X!56 ;. 74 ;< X!50 ;( X!53 ;+ 41 ;VBAR TO ! 4/21/76 X!46 ;& 0 0 X!0 0 X!0 X!0 0 0 X!0 X!135 ;! TO VBAR 4/21/76 44 ;$ X!52 ;* 51 ;) 73 ;; X!136 ; 4/21/76 X!55 ;- SPEC!SE!2B6!57 ;P2 OF ACK1 IN EBCDIC (/) 0 X!0 0 X!0 X!0 SPEC!SA!3B6!0 ;P2 OF RVI IN ASCII 0 X!0 X!174 ; 4/21/76 SPUEC!SE!4B6!54 ;P2 OF WACK IN EBCDIC (,) X!45 ;% 137 ;UNDERBAR 76 ;> X!77 ;? SPEC!SE!1B6!0 ;P2 OF ACK0 IN EBCDIC X!0 X!0 0 X!0 0 0 X!0 X!0 140 ;\ 4/21/76 72 ;: X!43 ;# SPEC!SE!3B6!100 ;P2 OF RVI IN EBCDIC (@) X!47 ;' X!75 tj ;= 42 ;" ;THE FOLLOWING LETTERS FROM 201 THROUGH 251 ARE LOWER-CASE 0 X!141 ;A X!142 ;B SPEC!SA!6B6!143 ;ETX IN ASCII (C) X!144 ;D SPEC!SA!5B6!145 ;ENQ IN ASCII (E) 146 ;F X!147 ;G X!150 ;H 151 ;I 0 X!0 ; 4/21/76 0 X!uk0 X!0 0 X!0 152 ;J 153 ;K X!154 ;L 155 ;M X!156 ;N X!157 ;O SPEC!SA!7B6!160 ;ETB IN ASCII (P) 161 ;Q X!162 ;R X!0 0 ; 4/21/76 X!0 0 0 X!0 X!0 176 ; 4/21/76 163 ;S X!164 ;T 165 ;U X!166 ;V X!167 ;W u 170 ;X 171 ;Y X!172 ;Z  X!0 0 X!0 0 0 X!0 SPEC!SA!1B6!136 ;P2 OF ACK0 IN ASCII (TILDE) X!0 X!0 0 X!0 0 0 X!0 X!0 0 0 X!0 0 X!0 X!0 0 ; 4/21/76 X!173 ;LEFT CURLY BRACKET 4/21/76 101 ;A 102 ;B X!103 ;C 104 ;D X!105 ;E X!106 ;F 107 ;G 110 ;H X!111 ;I X!0 0 X!0 0 0 X!0 ; 4/21/76 175 ;RIGHT CURLY BRACKET 4/21/76 X!112 ;J X!113 ;K 114 ;L X!115 ;M 116 ;N 117 ;O2 X!120 ;P X!121 ;Q 122 ;R 0 X!0 0 X!0 X!0 0 134 ;BACKSLASH 4/21/76 X!0 ; 4/21/76 X!123 ;S 124 ;T X!125 ;U 126 ;V 127 ;W X!130 ;X X!131 ;Y 132 ;Z 0 X!0 0 X!0 X!0 0 X!60 ;0 61 ;1 62 ;2 X!63 ;3 YW64 ;4 X!65 ;5 X!66 ;6 67 ;7 70 ;8 X!71 ;9 X!0 0 X!0 0 0 X!0 .END SLTBA.SR .LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1973,1974,1975 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ;SAMPLE CONTROL TABLES FOR SINGLE LINE 4073/4074 SLA DRIVER ; PARAMETERS FOR SAMPLE PROGRAM 1 LCB ; USING ASCII, LRC-8 [ODD BLOCK PARITY] ; MODEM CONTROL WITH A FOUR WIRE LINE ; NOTE: MODEM CONTROL HARDWARE EXISTS ONLY ON THE 4074 .TITLE SLTBA .ENT SLTBL,SLCB0,SLB0,DCT .EXTN SLRIH,SLALP,SLTIH,SLADA,SLACP,SLATP,SLAIS .NREL SYN=26 DLE=20 ;SLA LINE TABLE 1 ! ;# OF LINES SLTBL: SLCB0 ;LCB ADDRESSES ;DEVICE CONTROL TABLE DTAB: .BLK 10 ;SAVE AREA DCT: DTAB ;SAVE AREA POINTER SLAMK+17B13+1B15 ;INTERRUPT MASK + NO CLK+ LPT INTS SLAIS ;SLA INTERRUPT SERVICE SLTBL ;LINE TABLE ADDR DCD: 30 ;SLA DEVICE C2ODE ;THE LCB SLCB0: 0 ;LINE ADDRESS SLRIH ;RCV INTERRUPT HANDLER SLTIH ;XMT " " SLADA ;ASCII TRANSLATION DIRECTORY -1 ;INITIAL VALUE FOR BCC [-1 = ODD, 0 = EVEN] 1 ;LRC IS 1 BYTE SLALP ;LONGITUDINAL CHECK ROUTINE SLACP ;VR"C GENERATE ROUTINE SLATP ;VRC CHECK ROUTINE SYN ;SYN CODE DLE ;DLE CODE 400 ;ASCII LINE CODE MASK 1B12+1 ;MODEM CONTROL [1=MODEM CONTROL, 1B12=4WIRE] 4 ;CHARACTER SIZE [4 = 8-BIT CHARS] SLB0*2 ;BUFFER BYTE POINTER 200. ; " " COUUNT .BLK 66 ;SPACE FOR THE REST OF THE LCB ;LINE BUFFER SLB0: .BLK 100. .END SLTBE.SR #.LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1973,1974,1975 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ;SAMPLE CONTROL TABLES FOR SINGLE LINE 4073/4074 SLA DRIVER ; PARAMETERS FOR SAMPLE PROGRAM 1 LCB ; USING EBCDIC, CRC-16, NO MODEM CONTROL .TITLE SLTBE .ENT SLTBL,SLCB0,SLB0,DCT .EXTN SLRIH,SLACR,SLTIH,SLADE,SLACN,SLATN,SLAIS .NREL SYN=62 DLE=20 ;SLA LINE TABLE 1 ;# OF LINES SLTBL: SLCB0 ;LCB ADDRESSES ;DEVICE CONTROL TABLE DTAB: .BLK 10 ;SAVE AREA DCT: DTAB ;SAVE AREA POINTER SLAMK+17B13+1B15 ;INTERRUPT MASK + NO CLK + LPT INTS SLAIS ;SLA INTERRUPT SERVICE SLTBL ;LINE TABLE ADDR DCD: 70 ;SLA DEVICE CODE ;THE LCB SLCB0: 0 ;LINE ADDRESS SLRIH ;RCV INTERRUPT HANDLER SLTIH ;XMT "r " SLADE ;EBCDIC TRANSLATION DIRECTORY 0 ;INITIAL VALUE FOR BCC 0 ;CRC IS 2 BYTES SLACR ;LONGITUDINAL CHECK ROUTINE SLACN ;NO VRC GENERATE ROUTINE SLATN ;NO VRC CHECK ROUTINE SYN ;SYN CODE DLE ;DLE CODE 20000 ;EBCDIC LINE COODE MASK 0 ;MODEM CONTROL [0 = NO MODEM CONTROL] 4 ;CHARACTER SIZE [4 = 8-BIT CHARS] SLB0*2 ;BUFFER BYTE POINTER 200. ; " " COUNT .BLK 66 ;SPACE FOR THE REST OF THE LCB ;LINE BUFFER SLB0: .BLK 100. .END SLTMM.SR .LCNS ;COPYRIGHT (C) DATA GENERAL CORPORATION,1976 ;ALL RIGHTS RESERVED ;LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION ;SAMPLE CONTROL TABLES FOR MULTIPLE 4074 SLA DRIVER ; PARAMETERS FOR SAMPLE PROGRAM, 2 LCB'S, 2 DCT'S ; USING ASCII, LRC-8/ODD ON BOTH LINES .TITLE SLTMM .ENT SLTBL,SLCB0,SLCB1,SLB0,SLB1,DCT,DC1 .EXTN SLRIH,SLALP,SLTIH,SLACR,SLACN .EXTN SLADA,SLACP,SLATP,SLAIS .NREL SYN=26 DLE=20 ;SLA LINE TABLE 2 SLTBL: SLCB0 SLTB1: SLCB1 DTAB: .BLK 10 ;SAVE AREA DCT: DTAB ;zuSAVE AREA POINTER SLAMK+75 ;INTERRUPT MASK SLAIS ;SLA INTERRUPT SERVICE SLTBL ;LINE TABLE LOCATION FOR THIS LCB DCD: 30 ;SLA DEVICE CODE SAV: 0 ;SAVE LOCATION FOR I/O ROUTINE IX: 0 ;INTERUPT XCT LOC JMP 1,3 ;RETURN TX: 0 ;TASK XCT LOCATION JMPf 1,3 ;RETURN SLCB0: 0 ;LINE ADDRESS SLRIH ;RCV INTERRUPT HANDLER SLTIH ;XMT " " SLADA ;ASCII TRANSLATION DIRECTORY -1 ;INITIAL VALUE FOR BCC [LRC] 1 ;LRC IS 1 BYTE SLALP ;LONGITUDINAL CHECK ROUTINE SLACP ;VRC GENERATE ROUTINE SLATP ;VRC CHECK ROUTINE SYN ;SYN CODE DLE ;DLE CODE 400 ;ASCII LINE CODE MASK 0 ;MODEM CONTROL [0=NO MODEM CONTROL] 4 ;CHARACTER SIZE [4 = 8-BIT CHARS] SLB0*2 ;BUFFER BYTE POINTER 400. ; " " COUNT .BLK 66 ;SPACE FOR THE! REST OF THE LCB ;DCT AND LCB FOR SECOND 4074 LINE DTB1: .BLK 10 ;SAVE AREA FOR THIS DEVICE DC1: DTB1 ;POINTER TO THE SAVE AREA SLAMK+75 ;INTERRUPT MASK SLAIS ;INTERRUPT SERVICE ROUTINE SLTB1 ;LOCATION IN LINE TABLE OF LCB FOR THIS 70 ;DEVICE CODE FOR THIS LINE 0 ;SAV 0 ;IX JMP 1,3 ;RETURN 0 ;TX JMP 1,3 ;RETURN SLCB1: 0 ;LINE ADDRESS [IN LEFT BYTE] SLRIH ;RCV INTERRUPT HANDLER SLTIH ;XMT " " SLADA ;ASCII TRANSLATION DIRECTORY -1 ;LRC INITIAL VALUE 1 ;1 BYTE CRKC SLALP ;LRC ROUTINE SLACP ;VRC GENERATION ROUTINE SLATP ;VRC CHECK ROUTINE SYN ;SYN CODE DLE ;DLE CODE 400 ;ASCII LINE CODE MASK 0 ;NO MODEM CONTROL 4 ;8. BIT CHARS SLB1*2 ;BUFFER BYTE ADDRESS 400. ;BUFFER BYTE COUNT .BLK 66 ;E = BYTE COUNT ; AC2 = LCB ; AC3 = RETURN ; TRANSMIT TEXT, TRANSPARENT WITH ETB SYNTT: STA 3,LCCPR,2 ;SAVE RETURN JSR @.SAV ;SAVE AC'S LDA 1,C4000 ;GET TRANSPARENT MCB OFFSET JMP CPTXC ;CONTINUE BELOW ; TRANSMIT TEXT, NON-TRANSPARENT WITH ETB SYN,wTX: STA 3,LCCPR,2 ;SAVE RETURN JSR @.SAV ;SAVE AC'S SUB 1,1 ;ZERO = NON-TRANSPARENT TEXT CPTXC: STA 1,LCCP4,2 ;SAVE TRANSPARENT FLAG OFFSET LDA 0,LCMDE,2 ;GET LINE MODE LDA 1,C2 ;GET TX OPENED CODE SUB# 0,1,SZR ;IS LINE TX OPEN? JMP @CPE5P ;NO, SORRFY LDA 0,LCABS,2 ;GET ACTIVE BUFFER STATE MOV# 0,0,SZR ;SEE IF BUFFER EMPTY JMP CPTXF ;NO, SEE IF FULL STA 0,ITBFG ;TURN OFF ITB FLAG LDA 0,LCBP1,2 ;GET BUFFER START ADDRESS LDA 1,LCBC1,2 ;GET BUFFER BYTE COUNT ADD 0,1 ;ADD TWO TOGETHER STA 1,LCABP,2 ;SAVE AS END OF SPACE POINTER INC 0,0 ;LEAVE TWO BYTES FOR RESPONSE INCZR 0,0 ;MAKE WORD ADDRESS POINTER STA 0,LCTMS,2 ;SAVE AS MCB START POINTER STA 0,LCABS,2 ;SAVE AS NEXT MCB SLOT POINTER LDA 0,TDSYN,3 ;GET SYN MCB COMMAND STA@ 0,LCABS,2 ;FILL FIRST MCB SLOT ISZ LCABS,2 ;POINT TO NEXT MCB SLOT LDA 0,TDSTX,3 ;GET STX MCB COMMAND LDA 1,LCCP4,2 ;GET TRANSPARENT OFFSET IF PRESENT ADD 1,0 ;ADD TO CREATE MCB COMMAND STA @0,LCABS,2 ;PUT INTO MCB CPTXF: LDA 0,LCABP,2 ;GET END SPACE POINTER LDA 1,LCAC1,2 ;GET CALLER BYTE COUNT NEG 1,1,SNR ;TEST FOR ZERO JMP CPRT3 ;JUST RETURN ADD 1,0 ;FIRST BYTE PTR, THIS CALL STA 0,LCABP,2 ;SAVE AS NEW END SPACE POINTER MOVZR 0,0 ;MAKE CORE ADDRESS LDA 1,M7 ;GET SPACE REQUIRED FOR MCB ADD 1,0 ;AC0 = MCB POINTER LIMIT LDA 1,LCABS,2 ;GET CURRENT MCB POINTER SUBZ# 1,0,SNC ;AND SEE IF LIMIT .GE. POINTER JMP CPTXS ;NO, GO SEND THIS BUFFER ISZ LCABS,2 ;POINT TO NEXT MCB SLOT LDA 0,ITBFG ;GET ITB FLAG MOV# 0,0,SNR ;IS IT SET JMP GTBBP ;NO ITBS YET LDA 0,LCTSX,2 ;CHECK THE STX OPTION MOV# 0,0,SNR ;CHECK IF NO STX (AFTER ITB BCC) OPTION JMP TXMCB ;NOT SELECTED LDA 1,LCCP4,2 ;CHECK FOR TRANSPARENCY MOV# 1,1,SZR ;NON-TRANSPARENT MODE? JMP TXMCB ;TRANSPARENT MODE LDA 0,NOSTX ;GET NOSTX CODE STA@ 0,LCAB9S,2 ;PUT INTO MCB JMP GTBBP-1 ;GO GET BUFFER BYTE POINTER TXMCB: LDA 0,TDSTX,3 ;GET STX MCB COMMAND LDA 1,LCCP4,2 ;GET TRANSPARENT OFFSET IF PRESENT ADD 1,0 ;ADD TO CREATE MCB COMMAND STA@ 0,LCABS,2 ;PUT INTO MCB ISZ LCABS,2 ;POINT TO NEXT MCB SLOT G0TBBP: LDA 0,LCABP,2 ;GET BUFFER BYTE POINTER STA@ 0,LCABS,2 ;PUT INTO MCB STA 0,LCCP2,2 ;SAVE AS CPPUT "TO" POINTER ISZ LCABS,2 ;POINT TO NEXT SLOT LDA 0,LCAC1,2 ;GET CALLER BYTE COUNT STA@ 0,LCABS,2 ;PUT INTO MCB STA 0,LCABC,2 ;SAVE FOR CPTXM COUNT f ISZ LCABS,2 ;POINT TO NEXT SLOT LDA 0,TDITB,3 ;GET ITB MCB COMMAND LDA 1,LCCP4,2 ;GET TRANSPARENCY OFFSET ADD 1,0 ;ADD TRANSPARENT OFFSET STA@ 0,LCABS,2 ;PUT INTO MCB ISZ ITBFG ;SET ITB FLAG LDA 0,LCAC0,2 ;GET CALLER BYTE POINTER STA 0,LCCP1,2 ;SA=OVE AS CPGET "FROM" POINTER LDA 0,TDATL,3 ;GET TRANSLATE ADDRESS TABLE STA 0,LCCP3,2 ;SAVE FOR CPTCD CPTXM: JSR CPGET ;GET NEXT BYTE FROM CALLER BUFFER LDA 1,LCCP4,2 ;GET TRANSPARENT INDICATOR MOV# 1,1,SNR ;AND DON'T TRANSLATE IF SET JSR CPTCD ;TRANSLATE TO LINE CODE JSR CPPUT ;PUT INTO LINE BUFFER DSZ LCABC,2 ;CHECK CALLER COUNT JMP CPTXM ;KEEP MOVING BYTES JMP CPRT3 ;ALL DONE CPTXS: LDA 0,LCTMS,2 ;GET MCB START POINTER SUB# 0,1,SZR ;COMPARE TO CURRENT MCB SLOT JMP CPTXB ;BUFFER IS NOT EMPTY LD{A 0,C8 ;THIS RECORD WILL NEVER FIT JMP CPRT1 ;GIVE USER AN ERROR ; SEND OUT CURRENT BUFFER, ETX OR ETB SYNTE: STA 3,LCCPR,2 ;SAVE RETURN ADDRESS JSR CPSAV ;SAVE AC'S LDA 0,LCMDE,2 ;GET CURRENT LINE MODE LDA 1,C2 ;GET TX OPENED CODE SUB# 0,1,SZR ;TE\)ST FOR TX OPENED CODE JMP CPER5 ;NO, LINE NOT OPENED LDA 0,LCTMS,2 ;GET MCB START ADDRESS LDA 1,LCABS,2 ;GET CURRENT MCB SLOT SUB# 0,1,SNR ;SEE IF ANY RECORDS IN JMP CPRT3 ;GIVE NORMAL RETURN LDA 0,TDETX,3 ;GET ETX CODE JMP CPTXT ;AND SHIP OUT BUFFEHR CPTXB: LDA 0,TDETB,3 ;GET ETB MCB COMMAND CPTXT: LDA 3,LCABS,2 ;GET MCB SLOT POINTER LDA 1,LCCP4,2 ;GET TRANSPARENT MCB OFFSET ADD 1,0 ;AND ADD IT IN STA 0,0,3 ;REPLACE ITB WITH ETB OR ETX LDA 0,PADS ;GET PADS MCB COMMAND STA 0,1,3 ;PUT INTO MCB SUB 0,0 ;GET END OF MCB COMMAND STA 0,2,3 ;FINISH OFF MCB LDA 1,LCTMS,2 ;GET MCB START POINTER JSR@ .SLAT ;TRANSMIT JMP @.CPTO ;AND GO STARTUP RECEIVER ; CLOSE LINE -- SYNTC>>SEND EOT, SYNDT>>SEND DLE/EOT MSG. SYNDT: STA 3,LCCPR,2 ;SAVE RETURN JCSR CPSAV ;SAVE AC'S LDA 1,TDDOT,3 ;GET DLE EOT MCB ADDR. JMP CPTCE ;XMIT,0 MODE, RTN SYNTC: STA 3,LCCPR,2 ;SAVE RETURN JSR CPSAV ;SAVE AC'S LDA 1,TDEOT,3 ;GET EOT MCB ADDRESS CPTCE: JSR@ .SLAT ;TRANSMIT SUB 0,0 ;GET ZERO STA 0,LCMDE,2 ;ZERO LINE MO=DE JMP CPRT2 ;AND RETURN .SLAT: SLAT ;TRANSMIT SUBROUTINE C2: 2 C4: 4 C5: 5 C8: 8. C377: 377 M7: -7 PADS: 6000 NOSTX: 12000 ;MCB COMMAND FOR NO STX. USED BY INTERRUPT SERVICE ; SAVE REGISTERS, RETURN WITH DIRECTORY POINTER IN AC3 CPSAV: STA 0,LCAC0Z1,2 ;SAVE AC0 IN LCB STA 1,LCAC1,2 ;SAVE AC1 IN LCB STA 3,LCRT1,2 ;SAVE RETURN ADDRESS JSR@ .SLAM ;GO CHECK MODEM STATUS MOV# 0,0,SNR ;TEST IF MODEM READY JMP CPMDM ;NO, NOT READY LDA 0,LCAC0,2 ;RESTORE AC0 LDA 1,LCAC1,2 ;RESTORE AC1 LDA 3,LCDIR,2 ;mGET TRANSLATION DIRECTORY JMP@ LCRT1,2 ;AND RETURN ; MODEM NOT READY, GIVE ERROR RETURN CPMDM: SUB 0,0 ;GET ZERO ERROR CODE STA 0,LCMDE,2 ;RESET LINE MODE JMP CPRT1 ;TAKE THE ERROR RETURN .SLAM: SLAM ;MODEM STATUS CHECK ROUTINE ; RETURN TO CALLE'R AFTER RESTORING AC'S CPRT3: ISZ LCCPR,2 ;RETURN TO CALL+3 CPRT2: ISZ LCCPR,2 ;RETURN TO CALL+2 LDA 0,LCAC0,2 ;RESTORE AC0 CPRT1: LDA 1,LCAC1,2 ;RETURN TO CALL+1 (ERROR=AC0) LDA 3,USP ;USER STACK POINTER IN AC3 JMP@ LCCPR,2 ;RETURN ; TRANSLATE CODESs -- TABLE ADDRESS IN LCCP3 ; AC0 = BYTE ; AC2 = LCB ; AC3 = RETURN CPTCD: STA 3,LCRT1,2 ;SAVE RETURN ADDRESS LDA 3,LCCP3,2 ;GET TRANSLATE TABLE ADDRESS MOVZL 3,3,SNR ;MAKE BYTE POINTER, TEST IF ZERO JMP CPGT2 ;NO TRANSLATE REQUIRED ADDZR 0,3 ;ADD C ODE OFFSET INTO TABLE JMP CPGT1 ;AND GO PICK UP BYTE CPER5: LDA 0,C5 ;ERROR 5 - LINE NOT TX OPEN JMP CPRT1 CPER6: LDA 0,C6 ;ERROR 6 - LINE NOT RX OPEN JMP CPRT1 ; GET BYTE ROUTINE ; AC0 = BYTE ON RETURN ; AC2 = LCB ; AC3 = RETURN ; LCCP1 = BYTE #POINTER CPGET: STA 3,LCRT1,2 ;SAVE RETURN LDA 3,LCCP1,2 ;GET BYTE POINTER ISZ LCCP1,2 ;UPDATE BYTE POINTER MOVZR 3,3 ;MAKE CORE ADDRESS CPGT1: LDA 0,0,3 ;BYTE WORD MOV# 0,0,SNC ;TEST ODD OR EVEN MOVS 0,0 ;SWAP CPGT2: LDA 1,C377 ;GET MASK AND 1,0 ;CLEAN UP BYTE JMP@ LCRT1,2 ;RETURN ; PUT BYTE ROUTINE ; AC0 = BYTE ; AC2 = LCB ; AC3 = RETURN ; LCCP2 = BYTE POINTER CPPUT: STA 3,LCRT1,2 ;SAVE RETURN LDA 3,LCCP2,2 ;GET BYTE POINTER ISZ LCCP2,2 ;UPDATE POINTER LDA 1,C377 ;GET MASK MOVZR 3,3Q,SZC ;MAKE CORE ADDRESS MOVS 1,1 ;POSITION MASK STA 3,LCCP5,2 ;SAVE CORE ADDRESS LDA@ 3,LCCP5,2 ;GET BYTE WORD AND 3,1,SNC ;CLEAN OFF UNWANTED BYTE MOVS 0,0 ;POSITION NEW BYTE ADD 1,0 ;CREATE NEW WORD STA@ 0,LCCP5,2 ;PUT INTO BUFFER JMP@ LCRT1,2 ;_RETURN ; RECEIVE DATA ; AC0 = BYTE POINTER ; AC1 = MAX COUNT ; AC2 = LCB ; AC3 = RETURN SYNRX: STA 3,LCCPR,2 ;SAVE RETURN JSR CPSAV ;SAVE AC'S LDA 0,LCMDE,2 ;GET MODE LDA 1,C4 ;GET RX OPEN CODE SUB 1,0,SZR ;IS LINE OPEN JMP CPER6 ;NO, SORRY Sr*TA 0,LCLST,2 ;ZERO RX ETX FLAG LDA 0,LCABS,2 ;GET ACTIVE BUFFER STATE MOV# 0,0,SZR ;IS IT EMPTY JMP CPRXG ;NO, GET MORE BYTES LDA 0,LCBP1,2 ;GET BUFFER START POINTER STA 0,LCABP,2 ;SETUP ACTIVE BUFFER LDA 0,LCBC1,2 ;GET BUFFER SIZE STA 0,LCRRC,2 ;PUvT INTO LCB RBB JSR@ .ACKN ;ACKNOWLEDGE ENQ OR LATEST BLOCK JMP@ .CPTO ;START RECEIVER .ACKN: CPAKN .CPTO: CPTOC C6: 6 C7: 7 CPRXG: LDA 0,LCABP,2 ;GET NEXT BYTE POINTER STA 0,LCCP1,2 ;SAVE FOR CPGET LDA 0,LCAC0,2 ;GET CALLER BYTE POINTER STA 0,LCCP2],2 ;SAVE FOR CPPUT LDA 0,LCAC1,2 ;GET MAX COUNT INC 0,0 ;MAKE IT MAX + 1 STA 0,LCABC,2 ;AND SAVE LDA 0,TDLTA,3 ;GET ADDRESS OF LTA TABLE STA 0,LCCP3,2 ;SAVE FOR CPTCD SUB 0,0 ;ZERO THE STA 0,LCCP4,2 ;TRANSPARENT RECORD INDICATOR CPRXS: JSR CPGET ;GET BYTE FROM LINE BUFFER LDA 1,LCDLE,2 ;GET DLE CODE SUB# 0,1,SNR ;TEST FOR DLE JMP CPRXT ;START OF TRANSPARENT TRANSMISSION CPRXN: LDA 3,LCDIR,2 ;GET DIRECTORY LDA 1,TDCSX,3 ;GET STX CODE SUB# 0,1,SNR ;TEST FOR STX JMP CPRXS ;YES,IGNORE LDA 1,TDCEX,3 ;GET ETX CODE SUB# 0,1,SNR ;TEST JMP CPRXX ;INDICATE ETX LDA 1,TDCEB,3 ;GET ETB SUB# 0,1,SNR ;TEST JMP CPRXB ;INDICATE ETB LDA 1,TDCIB,3 ;GET ITB SUB# 0,1,SNR ;TEST JMP CPRXI ;INDICATE ITB DSZ LCABC,2 ;DECREMENT RECEIVED COUNT JMP .+3 ;STILL OK CPRXE: LDA 0,C7 ;CALLER AREA TOO SMALL JMP CPRT1 ;ERROR RETURN LDA 1,LCCP3,2 ;TEST IF TRANSLATION NEEDED MOV 1,1,SNR ;LINE TO ASCII ADDRESS =0? JMP .+4 ;YES, NO TRANSLATE LDA 3,SCPTR ;NO, GET SPEC CHAR TBL (HAS XLATION) ADD 0,3 ;CHAR IS OFFSET  LDA 0,0,3 ;GET ENTRY FOR THIS CHAR LDA 3,K177 ;GET CHAR MASK AND 3,0 ;CLEAN UP BYTE JSR CPPUT ;PUT IN CALLER AREA JMP CPRXS ;CONTINUE BYTE TRANSFER SCPTR: SCTAB ;SPECIAL CHARACTER TABLE K177: 177 ; END OF RECORD HAS BEEN REACHED CPRXX: ISZ LCLST11,2 ;SET ETX RECEIVED FLAG CPRXB: SUB 0,0 ;GET ZERO STA 0,LCABS,2 ;SHOW BUFFER EMPTY CPRXI: LDA 0,LCCP1,2 ;GET NEXT BYTE POINTER STA 0,LCABP,2 ;SAVE IT LDA 0,LCABC,2 ;GET BYTES LEFT COUNT + 1 LDA 1,LCAC1,2 ;GET MAX COUNT SUB 0,1 ;MAX - LEFT - 1 INC 1,1 ;MAX - LEFT STA 1,LCAC1,2 ;STORE RECEIVED COUNT JMP CPRT3 ;RETURN ; TRANSPARENT RECEIVE PROCESSING CPRXT: JSR CPGET ;READ OVER STX ISZ LCCP4,2 ;SET TRANSPARENT RECORD RCVD FLG CPRXL: JSR CPGET ;GET NEXT TRANSPARENT BYTE LDA 1,LCDLE,2 ;TEST FOR DLE SUB# 0,1,SZR ;OF DLE DLE OR DLE END JMP CPRXU ;NO DLE HERE JSR CPGET ;GET SECOND DLE IN SEQUENCE LDA 1,LCDLE,2 ;GET DLE AGAIN SUB# 0,1,SZR ;IF ZERO, EAT A DLE JMP CPRXN ;MUST BE ETX, ETB OR ITB CPRXU: DSZ LCABC,2 ;CHECK FOR ROOM JMP .+2 ;OK JMP CPRXE ;NOT OK JSR CPPUT ;GIVE TO CALLER, AS IS JMP CPRXL ;AND CONTINUE ; STATUS ROUTINE ; TAKES CARE OF LINE TURN-AROUND AND PROTOCOL ; AC2 = LCB ; AC3 = RETURN SYNST: STA 3,LCCPR,2 ;SAVE RETURN JSR@ .CPSV ;SAVE AC'S JSR@ .SLAX ;GET RX AND TX ESTATUS COM# 0,0,SZR ;IS RECEIVER DONE? COM# 1,1,SNR ;IS TRANSMITTER DONE? JMP@ STRT2 ;NO MOVL# 0,0,SNC ;TEST FOR RECEIVER REQUEST FLAG JMP CPSGM ;NO RECEIVE REQUEST CPRSR: LDA 0,RRP ;GET RBB OFFSET IN LCB ADD 2,0 ;MAKE IT A POINTER JSR@ .SLAR ;AND >START UP THE RECEIVER JMP@ STRT2 ;AND RETURN BUSY CPSGM: LDA 1,LCMDE,2 ;GET MODE LDA 3,CPSTT ;GET JUMP TABLE ADDRESS ADD 1,3 ;ADD OFFSET JMP@ 0,3 ;AND JUMP CPSTT: .+1 CPRT3 ;LINE CLOSED CPST1 ;TRANSMIT OPEN CPST2 ;TRANSMIT CPST3 ;RECEIVE OPENE CPST4 ;RECEIVE RRP: LCRRP ;RBB OFFSET FOR RECEIVER STARTS .SLAR: SLAR ;START RECEIVER .SLAX: SLAX ;STATUS CHECK ROUTINE .CPSV: CPSAV ;AC SAVE ROUTINE ; TRANSMIT OPEN PROCESSING ; LINE MODE 1 CPST1: LDA 3,CPSTJ ;GET JUMP TABLE ADDRESS ADD 0,3 ;ADD IN LCRXC JMP@ 0,3 ;AND JUMP CPSTJ: .+1 CPSTE ;WAIT CPMDM ;MODEM CPSTE ;COUNT CPSTE ;CRC CPSTE ;EOT CPSTE ;ETX CPSTE ;ETB CPSTE ;ENQ CPSTS ;ACK0 CPSTE ;ACK1 CPSTE ;NAK CPSTE ;WACK CPSTE ;RVI CPSTE ;TTD CP.TO ;TRANSMIT TI,DME OUT ; ACK0 IS IN, OPEN TRANSMIT SUCCESSFUL CPSTS: JSR@ .CAK ;COMPLEMENT ACK REGISTER LDA 0,K2 ;GET TX MODE STA 0,LCMDE,2 ;UPDATE LINE MODE JMP@ STRT3 ;RETURN ; SEND ENQ MESSAGE CPSTE: LDA 3,LCDIR,2 ;GET DIRECTORY LDA 1,TDENQ,3 ;GET ENQ MCB ; H DECREMENT AND TEST RETRY COUNTER CPSTD: DSZ LCERC,2 ;TEST RETRY COUNT JMP CPSTK ;KEEP TRYING ; CLOSE LINE CPSTC: LDA 3,LCDIR,2 ;GET DIRECTORY LDA 1,TDEOT,3 ;GET EOT MCB JSR@ SLAT. ;SEND EOT MESSAGE CPSTF: SUB 0,0 ;CLOSE LINE STA 0,LCMDE,2 ;SET MODE = 0 SUBZL 0,0 ;GET ERROR CODE 1 JMP@ STRT1 ;GIVE ERROR RETURN ; KEEP TRYING CPSTK: JSR@ SLAT. ;SEND MESSAGE LDA 0,LCTST,2 ;GET TRANSMIT BUSY FLAG MOV# 0,0,SNR ;CHECK IF TRANSMITTER GOING JMP@ .MDM ;MODEM HAS DISCONNECTED JMP@ .CPRR ;RESET RECEGIVER ; TRANSMIT PROCESSING ; LINE MODE 2 CPST2: LDA 3,CPSTX ;GET JUMP TABLE ADDRESS JMP CPST1+1 CPSTX: .+1 CPSTE ;WAIT CPMDM ;MODEM CPSTE ;COUNT CPSTE ;CRC CPSTZ ;EOT CPSTE ;ETX CPSTE ;ETB CPSTE ;ENQ CPSTV ;ACK0 CPSTV ;ACK1 CPSTN ;NAK CPSTW ;WACK CPSTI ;RVI CPSTE ;TTD CP.TO ;TRANSMIT TIME OUT .CAK: CPCAK .CPRR: CPTRR STRT1: CPRT1 STRT2: CPRT2 STRT3: CPRT3 SLAT.: SLAT ; CLOSED LINE - ZERO MODE CPSTZ: LDA 0,K2 ;ERROR 2, EOT ARRIVED LDA 1,LCDLE,2 ;GET THE DLE CHARACTERz* LDA 3,LCRPV,2 ;GET PREVIOUS BYTE SUB# 1,3,SNR ;TEST FOR DLE-EOT (DISCONNECT) INC 0,0 ;YES SUB 1,1 ;GET ZERO STA 1,LCMDE,2 ;ZERO MODE JMP@ STRT1 ;ERROR RETURN ; VERIFY RESPONSE CPSTV: LDA 1,LCACK,2 ;GET ACK REGISTER ADDR 0,1,SZC ;XOR RXC TO ACK JMP CPSTN ;TRANSMISSION NOT SO GOOD JSR CPCAK ;COMPLEMENT ACK SUB 0,0 ;GET ZERO STA 0,LCABS,2 ;SHOW BUFFER EMPTY JMP@ STRT3 ;RETURN ; NAK RESPONSE CPSTN: LDA 1,LCTMS,2 ;GET MCB START ISZ LCTET,2 ;UPDATE TRANSMIT ERROR COUNT JMP .+1 ;IN CASE OF OVERFLOW JMP CPSTD ;AND RETRANSMIT ; WAIT RESPONSE CPSTW: LDA 3,LCDIR,2 ;GET DIRECTORY LDA 1,TDENQ,3 ;GET ENQ MESSAGE JMP CPSTK ;AND KEEP WAITING ; REVERSE INTERRUPT CPSTI: JSR CPCAK ;COMPLEMENT ACK REGISTER SUB 0,0 ;GET ZERO STA 0,LCABS,2 ;SH0OW BUFFER EMPTY LDA 0,K4 ;GET ERROR 4 JMP@ STRT1 ;GIVE ERROR RETURN ; TRANSMITTER TIME OUT - CODE 5 CP.TO: LDA 0,K5 ;GET TIME OUT CODE JMP @STRT1 ;TAKE ERROR RETURN K5: 5 ; RECEIVE OPEN PROCESSING ; LINE MODE = 3 CPST3: LDA 3,CPSTO ;GET JUMP TABLE ADDRESS ADD 0,3 ;ADD IN LCRXC JMP@ 0,3 ;AND GO JUMP CPSTO: .+1 CPSTQ ;WAIT CPMDM ;MODEM CPSTQ ;COUNT CPSTQ ;CRC CPSTZ ;EOT CPSTQ ;ETX CPSTQ ;ETB CPSTM ;ENQ CPSTQ ;ACK0 CPSTQ ;ACK1 CPSTQ ;NAK CPSTQ ;WACK CPSTQ ;RVI CPSTQ ;TTD ; ENQ IN, OPEN RECEIVE LINE CPSTM: LDA 0,K4 ;GET MODE 4 STA 0,LCMDE,2 ;SET RECEIVER OPENED JMP@ STRT3 ;RETURN ; NO ENQ RECEIVED YET CPSTQ: DSZ LCERC,2 ;TEST RETRY COUNT JMP @CPRS. ;GO RESTART RECEIVER JMP CPSTF ;SORRY, CLOSE LINE CPRS.: CPRӋSR ; RECEIVE PROCESSING ; LINE MODE 4 CPST4: LDA 3,CPSTR ;GET JUMP TABLE ADDRESS JMP CPST3+1 ;AND GO JUMP CPSTR: .+1 CPSTQ ;WAIT .MDM: CPMDM ;MODEM CPSTB ;COUNT CPSTU ;CRC CPSTZ ;EOT CPSTA ;ETX CPSTA ;ETB CPSTP ;ENQ CPSTB ;ACK0 CPST/B ;ACK1 CPSTB ;NAK CPSTB ;WACK CPSTB ;RVI CPSTL ;TTD K2: 2 K4: 4 ; BAD MESSAGE RECEIVED CPSTU: ISZ LCRET,2 ;UP RECEIVE ERROR TOTAL JMP .+1 ;IN CASE OF OVERFLOW CPSTB: LDA 3,LCDIR,2 ;GET DIRECTORY LDA 1,TDNAK,3 ;GET NAK MCB STA 1,LCTMS,2 ];SAVE AS LAST MSG SENT JMP CPSTD ;TEST RETRIES ; ACKNOWLEDGE MESSAGE (WHEN RECEIVE BUFFER GOES EMPTY) CPSTA: JSR CPCAK ;COMPLEMENT ACK REGISTER ISZ LCABS,2 ;SHOW BUFFER NOT EMPTY JMP@ STRT3 ;RETURN ; RESEND PREVIOUS RESPONSE CPSTP: DSZ LCERC,2 ;TEiST RETRY COUNT JMP .+2 ;STILL OK JMP CPSTC ;SORRY, CLOSE LINE LDA 1,LCTMS,2 ;LAST MSG MCB START JMP CPSTK ;RESEND LAST MESSAGE ; TEMPORARY TRANSMIT DELAY CPSTL: LDA 3,LCDIR,2 ;GET DIRECTORY LDA 1,TDNAK,3 ;GET NAK MESSAGE MCB JMP CPSTK ;AND RESPOΩND ; COMPLEMENT ACK CONTROL REGISTER CPCAK: SUBZL 0,0 ;GET 1 DSZ LCACK,2 ;IF 1, MAKE 0 STA 0,LCACK,2 ;IF 0, MAKE 1 JMP 0,3 ;RETURN ; SEND ACK0 OR ACK1 MESSAGE CPAKN: STA 3,LCRT1,2 ;SAVE RETURN LDA 3,LCDIR,2 ;GET DIRECTORY LDA 0,LCACK,2 ;GET ACQK REGISTER ADD 0,3 ;ADD IN ACK OFFSET LDA 1,TDAK0,3 ;GET ACK0 OR ACK1 MCB STA 1,LCTMS,2 ;SAVE AS LAST MSG SENT JSR@ SLAT. ;TRANSMIT LDA 0,LCTST,2 ;GET TRANSMIT BUSY FLAG MOV# 0,0,SNR ;CHECK IF TRANSMITTER GOING JMP@ .MDM ;MODEM HAS DISCONNECTED JM+P@ LCRT1,2 ;RETURN .END TTYTK.FR .LCNS C COPYRIGHT (C) DATA GENERAL CORPORATION,1974,1975 C ALL RIGHTS RESERVED C LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION C CONTROL CONSOLE READ TASK FOR FSDVR C S SEND FILE C H HALT C THE SPACE AFTER THE COMMAND CHARACTER IS NOT OPTIONAL C C TASK TTYTK C COMMON /XYZ/ IABORT, ITTY, NAME(10) C INTEGER STRING(12) C C----- I/O CHANNELS C IOCH0 = 0 IOCH1 = 1 C 100 READ (IOCH0, 1210) STRING 1210 FORMAT (12A2) C DO 200 I = 1, 10 200 NAME(I) = STRING(I+1) C IF (STRING(1) .EQ. "H ") IABORT = 1 ITTY = 1 C C-- 300 IF (ITTY .EQ. 0) GO TO 100 CALL FDELY(1) GO TO 300 C END SLA.KS qR/COPYRIGHT (C) DATA GENERAL CORPORATION, 1973, 1974, 1975, 1976 /ALL RIGHTS RESERVED / /LICENSED MATERIAL- PROPERTY OF DATA GENERAL CORPORATION / / / /KEYSHEET FOR MODELS 3233 AND 3513 / / / /NAME: SYNCHRONOUS LINE ADAPTER SUPPORT PACKAGE / / / /PAPERs} TAPE PRODUCT LIST: / / TAPE NUMBER FILE NUMBER / / 089-000168-03 SLERR.RB / 090-001301-04 LCB.SR / 090-001315-02 SLDVR.SR / 090-001316-04 SLTBA.SR / 090-001317-04 SLTBE.SR / 090-002798-00 CONIO.SR / 090-005351-00 SLTMM.SR / 090-005352-00 SLTMT.SR / 099-000088-04 SLAS.LB / 099-000088-04 SLAM.LB / / /TAPE LIST FOR BUILD PROCEDURE / / FILE NAME / / LCB.SR / SLERR.SR / SYNCP.SR / SLAI.SR / SLAE.SR / SLADA.SR / SLADE.SR / SLAR.SR / SLAT.SR / SLAIS.SR / SLACR.SR / SLAS.SR / U SLAX.SR / SLDVR.SR / SLTBA.SR / SLTBE.SR / SLTAB.SR / CONIO.SR / SNG.SR / MLT.SR / SLTMM.SR / SLTMT.SR / / / /BUILD PROCEDURE: / /BEFORE USING THESE COMMAND LINES YOU MUST CREATE A FILE CALLED /OPTIONS WHICH CONTAINS THE LISTING FILE ANȧD THE ERROR FILE IF ANY. /YOU CAN DO THIS BY TYPING: /XFER/A $TTI/I OPTIONS /MT0:0/L $LPT/E^Z /NOTE THE FILE OPTIONS MUST NOT CONTAIN A CARRIAGE RETURN. IT IS /ENDED BY TYPING (CONTROL Z). / /IF ANY OF THE OPTIONS ARE DEVICES (I.E. MAG TAPE), THE DEVICES /MUST BE INITED BEFORE THIS KEYSHEET IS EXECUTED. / /THESE PROCEDURES ASSUME THAT YOU HAVE THE FOLLOWING FILES ON THE /PRIMARY PARTITION OF THE DISK. / /NBID.SR /OSID.SR /MAC.SV /MACXR.SV /LFE.SV / /LINK THE FILES WE NEED SINCE WE ARE IN A SUBDIRECTORY. / UNLINK -.- / LINK NBID.SR/2 OSID.SR/2 MAC.SV/2 MACXR.SV/2 LFE.SV/2 / / /START ASSEMBLY PROCEDURES: / / /FIRST DELETE MAC.PS / DELETE MAC.PS / /MAKE NEW MAC.PS / MAC/S/N NBID OSID / / /ASSEMBLE SLAS.LB / MAC/F/Z @OPTIONS@ LCB/S SNG/S (SYNCP,SLAI,SLAE,SLADA,|SLADE,SLTAB,SLAR,^ SLAT,SLAIS,SLACR,SLAS,SLAX) / / DELETE SLAS.LB / /BUILD SLAS.LB / / LFE N SLAS.LB/O SYNCP SLAI SLAE SLADA SLADE SLTAB SLAR SLAT SLAIS SLACR ^ SLAS SLAX / / /ASSEMBLE SLAM.LB / MAC/F/Z @OPTIONS@ LCB/S MLT/S (SYNCP,SLAI,SLAE,SLADA,SLADE,SL(TAB,SLAR,^ SLAT,SLAIS,SLACR,SLAS,SLAX) / / MAC/F/Z @OPTIONS@ LCB/S SLERR / / DELETE SLAM.LB / /BUILD SLAM.LB / / LFE N SLAM.LB/O SYNCP SLAI SLAE SLADA SLADE SLTAB SLAR SLAT SLAIS SLACR ^ SLAS SLAX / / / /CLEAN UP DISK / / DELETE/V MAC.PS SYNCP.RB SLAI.RB ScwLAE.RB SLADA.RB SLADE.RB SLTAB.RB SLAR.RB ^ SLAT.RB SLAIS.RB SLACR.RB SLAS.RB SLAX.RB OPTIONS / / SLAMT.KS M/COPYRIGHT (C) DATA GENERAL CORPORATION, 1973, 1974, 1975, 1976 /ALL RIGHTS RESERVED. / / /LICENSED MATERIAL - PROPERTY OF DATA GENERAL CORPORATION / / /KEYSHEET FOR MODELS 3228M,3228H / /NAME: SYNCHRONOUS LINE ADAPTER SUPPORT PACKAGE / / /TAPE LIST: /; / TAPE NUMBER FILE NAME / / 089-000168-02 SLERR.RB / 090-001301-04 LCB.SR / 090-001315-02 SLDVR.SR / 090-001316-04 SLTBA.SR / 090-001317-04 SLTBE.SR / 090-002798-00 CONIO.SR / 090-002906-02 FSDVR.FR / 090-002907-01 TTYTK.FR / 090-005351-00 SLTMM.SR / 090-005352-00 SLTMT.SR / 099-000087-03 SLAS.LB / 099-000088-03 SLAM.LB / 099-000093-03 FSC4S.LB / 099-000094-03 FSC4M.LB / 099-000184-01 FSC5SN.LB / 099-000185-01 FSC5MN.LB / / /MAG TAPE PROCEDURE: / / EQUIV/P 071000027 MT0 INIT/F 071000027 DUqMP/V 071000027:0 SLERR.RB LCB.SR SLDVR.SR SLTBA.SR SLTBE.SR CONIO.SR ^ FSDVR.FR TTYTK.FR SLTMM.SR SLTMT.SR SLAS.LB SLAM.LB FSC4S.LB FSC4M.LB ^ FSC5SN.LB FSC5MN.LB RELEASE 071000027 / SLACT.KS $:/COPYRIGHT (C) DATA GENERAL CORPORATION, 1973, 1974, 1975, 1976 /ALL RIGHTS RESERVED. / / /LICENSED MATERIAL - PROPERTY OF DATA GENERAL CORPORATION / / /KEYSHEET FOR MODELS 3228C / /NAME: NOVA SYNCHRONOUS LINE ADAPTER SUPPORT PACKAGE / / /TAPE LIST: / / TAPE NUMBER FILE NAME / / 089-000168-02 SLERR.RB / 090-001301-04 LCB.SR / 090-001315-02 SLDVR.SR / 090-001316-04 SLTBA.SR / 090-001317-04 SLTBE.SR / 090-002798-00 CONIO.SR / 090-002906-02 FSDVR.FR / 090-002907-01 TTYTK.FR / 090-005351-00 SL2TMM.SR / 090-005352-00 SLTMT.SR / 099-000087-03 SLAS.LB / 099-000088-03 SLAM.LB / 099-000093-03 FSC4S.LB / 099-000094-03 FSC4M.LB / 099-000184-01 FSC5SN.LB / 099-000185-01 FSC5MN.LB / / /MAG TAPE PROCEDURE: / / EQUIV/P 070000043 CT0 INIT/F 070000043' DUMP/V 070000043:0 SLERR.RB LCB.SR SLDVR.SR SLTBA.SR SLTBE.SR CONIO.SR ^ FSDVR.FR TTYTK.FR SLTMM.SR SLTMT.SR SLAS.LB SLAM.LB FSC4S.LB FSC4M.LB ^ FSC5SN.LB FSC5MN.LB RELEASE 070000043 / FSC5N.KS ,/COPYRIGHT (C) DATA GENERAL CORPORATION, 1974, 1975, 1976 /ALL RIGHTS RESERVED / /LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION / / / /KEYSHEET FOR MODEL 3348 / / / /NAME: NOVA FORTRAN 5 INTERFACE / / / /PAPER TAPE PRODUCT LIST: / / TAPE NUMBER v FILE NAME / / 099-000184-01 FSC5SN.LB / 099-000185-01 FSC5MN.LB / / /TAPE LIST FOR BUILD PROCEDURE: / / FILE NAME / / LCB.SR / F5SYM.SR / NF5SYM.SR / SNG.SR / MLT.SR / FSCGP.SR / FSCMS.SR / FSCRO.SR / FSCRX.SR / FSCST.SR / FSCTR.SR / FSCTE.SR / FSCTO.SR / FSCTX.SR / FSCI.SR / FSCE.SR / FSCXL.SR / FSCXI.SR / FSXMT.SR / FMAC.SR / FSCGL.SR / / / /BUILD PROCEDURE: / /BEFORE USING THESE COMMAND LINES YOU MUST CREATE A FILE CALLED /OPTIONS WHICH CONTAINS THE LISTING FILE AND THE ERROR FILE IF ANY. /YOU CAN DO THIS BY TYPING: /XFER/A $TTI/I OPTIONS /MT0:0/L $LPT/E^Z /NOTE THE FILE OPTIONS MUST NOT CONTAIN A CARRIAGE RETURN. IT IS /ENDED BY TYPING (CONTROL Z). / /IF ANY OF THE OPTIONS ARE DEVICES (I.E. MAG TAPE), THE DDEVICES /MUST BE INITED BEFORE THIS KEYSHEET IS EXECUTED. / /THESE PROCEDURES ASSUME THAT YOU HAVE THE FOLLOWING FILES ON THE /PRIMARY PARTITION OF THE DISK. / /PARU.SR /NBID.SR /OSID.SR /MAC.SV /MACXR.SV /LFE.SV /SYS.LB / / /LINK THE FILES WE NEED SINCE WE ARE IN A SUBDIRECTORY. / UNLINK -.- / LINK PARU.SR/2 NBID.SR/2 OSID.SR/2 MAC.SV/2 MACXR.SV/2 LFE.SV/2 SYS.LB/2 / / /START THE ASSEMBLY PROCEDURES: / / /FIRST DELETE MAC.PS / DELETE MAC.PS / /MAKE NEW MAC.PS / / MAC/S/N NBID OSID PARU NF5SYM F5SYM FMAC / / /ASSEMBLE FSC5SN.LB / MAC/F/Z @OPTIONS@ SNG/S (FSCI,FSCE) / MAC/F/Z @OPTIONS@ LCB/S (FSCRO,FSCTO,FSCXI,FSXMT) / MAC/F/Z @OPTIONS@ (FSCGL,FSCGP,FSCMS,FSCRX,FSCST,FSCTC,FSCTE,FSCTX,FSCXL) / / DELETE FSC5SN.LB / /BUILD FSC5SN.LB / / LFE N FSC5SN.LB/O FSCGUP FSCMS FSCRO FSCRX FSCST FSCTC FSCTE FSCTO ^ FSCTX FSCI FSCE FSCGL FSCXL FSCXI FSXMT / / /ASSEMBLE FSC5MN.LB / MAC/F/Z @OPTIONS@ MLT/S (FSCI,FSCE) / / DELETE FSC5MN.LB / /BUILD FSC5MN.LB / / LFE N FSC5MN.LB/O FSCGP FSCMS FSCRO FSCRX FSCST FSCTC FSCTE FSCTqO ^ FSCTX FSCI FSCE FSCGL FSCXL FSCXI FSXMT / / /CLEAN UP DISK / / DELETE/V MAC.PS OPTIONS FSC-.RB FSXMT.RB / / FSC4.KS H/COPYRIGHT (C) DATA GENERAL CORPORATION, 1974, 1975, 1976 /ALL RIGHTS RESERVED / /LICENSED MATERIAL-PROPERTY OF DATA GENERAL CORPORATION / / / /KEYSHEET FOR MODEL 3348 AND 3515 / / / /NAME: FORTRAN IV INTERFACE / / / /PAPER TAPE PRODUCT LIST: / / FILE NAME / / 099-000093-03 FSC4S.LB / 099-000094-03 FSC4M.LB / / /TAPE LIST FOR BUILD PROCEDURE: / / FILE NAME / / PARF.SR / LCB.SR / SNG.SR / MLT.SR / FSCGP.SR / FSCMS.SR / FSCRO.SR / FSCRX.SR / FSCST.SR / FSCTR.SR / FSCTE.SR / FSCiTO.SR / FSCTX.SR / FSCI.SR / FSCE.SR / FSCXL.SR / FSCXI.SR / FSXMT.SR / PARFNS.SR / PARFX.SR / FMAC.SR / FSCGL.SR / / / /BUILD PROCEDURE: / /BEFORE USING THESE COMMAND LINES YOU MUST CREATE A FILE CALLED /OPTIONS WHICH CONTAINS THE LISTING FILE AND THE ERROR FILE IF ANY. /YOU CAN DO THIS BY TYPING: /XFER/A $TTI/I OPTIONS /MT0:0/L $LPT/E^Z /NOTE THE FILE OPTIONS MUST NOT CONTAIN A CARRIAGE RETURN. IT IS /ENDED BY TYPING (CONTROL Z). / /IF ANY OF THE OPTIONS ARE DEVICES (I.E. MAG TAPE), iTHE DEVICES /MUST BE INITED BEFORE THIS KEYSHEET IS EXECUTED. / /THESE PROCEDURES ASSUME THAT YOU HAVE THE FOLLOWING FILES ON THE /PRIMARY PARTITION OF THE DISK. / /PARU.SR /NBID.SR /OSID.SR /MAC.SV /MACXR.SV /LFE.SV /SYS.LB / /LINK THE FILES WE NEED SINCE WE ARE IN A SUBDIRECTORY. / UNLINK -.- / LINK PARU.SR/2 OSID.SR/2 MAC.SV/2 MACXR.SV/2 LFE.SV/2 SYS.LB/2 NBID.SR/2 / / /START ASSEMBLY PROCEDURES: / / /FIRST DELETE MAC.PS / DELETE MAC.PS / /MAKE NEW MAC.PS / MAC/S/N NBID OSID PARU PARFX PARFNS PARF FMAC / / /ASSEMBLE FSC4S.LB / MAC/F/Z @OPTIONS@ SNG/S (FSCI,FSCE) / MAC/F/Z @OPTIONS@ LCB/S (FSCRO,FSCTO,FSCXI,FSXMT) / MAC/F/Z @OPTIONS@ (FSCGL,FSCGP,FSCMS,FSCRX,FSCST,FSCTC,FSCTE,FSCTX,FSCXL) / DELETE FSC4S.LB / /BUILD FSC4S.LB / / LFE N FSC4S.LB/O FSCGP FSCMoyS FSCRO FSCRX FSCST FSCTC FSCTE FSCTO ^ FSCTX FSCI FSCE FSCGL FSCXL FSCXI FSXMT / / /ASSEMBLE FSC4M.LB / MAC/F/Z @OPTIONS@ MLT/S (FSCI,FSCE) / / DELETE FSC4M.LB / /BUILD FSC4M.LB / / LFE N FSC4M.LB/O FSCGP FSCMS FSCRO FSCRX FSCST FSCTC FSCTE FSCTO ^ FSCTX gFSCI FSCE FSCGL FSCXL FSCXI FSXMT / / /CLEAN UP DISK / / DELETE/V MAC.PS OPTIONS FSC-.RB FSXMT.RB / /