|
DataMuseum.dkPresents historical artifacts from the history of: CR80 Hard and Floppy Disks |
This is an automatic "excavation" of a thematic subset of
See our Wiki for more about CR80 Hard and Floppy Disks Excavated with: AutoArchaeologist - Free & Open Source Software. |
top - download
Length: 49664 (0xc200)
Types: TextFile
Names: »RAMTST«
└─⟦70c9bac02⟧ Bits:30005090 8" CR80 Floppy CR80FD_0046 ( CR/D/1098 CR80 Test oc add =8 JAS Tilhører Holger Bay Version 790720 )
└─⟦324330f72⟧
└─ ⟦this⟧ »FH.RAMTST«
LIST
;----------------------------------------------------------------------
;
; TEST PROGRAMME FOR 32, 16 AND 4 K RAM BOARD
;
;----------------------------------------------------------------------
BEGIN USE BASE
MODULE
PMASK= TRUE
BS1= #EFD0 ; PROGRAM DEFAULT PROCESS START;
PRG1= #F800 ; PROGRAM START;
;
; DEVICE DEFINITIONS;
OC= 8 ; OPERATORS CONSOLE;
RAMTM= 7 ; RAM TEST MODULE;
;
; OC STATUS BITS;
BINP= 10 ;
BOUT= 11 ;
BPERR= 13 ;
; TEST MODULE REGISTERS;
COT= 0 ; COUNT;
ADR= 1 ; ADDRESS;
CNT= 2 ; CONTROL;
; SAVELOCATIONS:
BAS:= #0008 ;
PROGRAM:= #000A ;
LOCACTION:= #000F ;
LOCRETURN:= #0010 ;
CAUSE:= #0011 ;
DEVPR:= #0012 ;
CURADR:= #0014 ;
TOP:= #0015 ;
SAVE0:= #0016 ;
SAVE1:= #0017 ;
SAVE2:= #0018 ;
SAVE3:= #0019 ;
SAVE4:= #001A ;
SAVE5:= #001B ;
SAVE6:= #001C ;
SAVE7:= #001D ;
SAVE8:= #001E ;
TESTNR:= #001F ;
TESTOFF:= #0020 ;
SIZE:= #0021 ;
SIZE2:= #0022 ;
SIZE3:= #0023 ;
SIZE4:= #0024 ;
SAVE9:= #0025 ;
SAVE10:= #0026 ;
SAVEWR:= #0027 ;
SAVE11:= #0028 ;
SAVE12:= #0029 ;
SAVE13:= #002A ;
TADR:= #002B ;
SAVE14:= #002C ;
DEVICE:= #002D ;
SAVE15:= #002E ;
; MONITOR CALLS:
REGISTERS= #0040 ; ;###
USE PROG
TESTS: ; RAM TESTS:
;
TEST04: ; TEST ROUTINES, 4K:
MCPT2 ;
TEST1 ;
TEST2 ;
TEST3 ;
TEST4 ;
MSW04 ;
TEST6 ;
TEST7 ;
TEST8 ;
TEST9 ;
TESTCH ;
TEST2 ;
TEST3 ;
TEST4 ;
MSW04 ;
TEST6 ;
TEST7 ;
TEST8 ;
TEST9 ;
TESTEND1 ;
TESTEND2 ;
;
TEST16: ; TEST ROUTINES, 16K:
MCPT2 ;
TEST1 ;
TEST2 ;
TEST3 ;
TEST4 ;
MSW16 ;
TEST6 ;
TEST7 ;
TEST8 ;
TEST9 ;
TESTCH ;
TEST2 ;
TEST3 ;
TEST4 ;
MSW16 ;
TEST6 ;
TEST7 ;
TEST8 ;
TEST9 ;
TESTEND1 ;
TESTEND2 ;
;###
TEST32: ; TEST ROUTINES, 32K:
MCPT2 ;
TEST1 ;
TEST2 ;
TEST3 ;
TEST4 ;
MSW32 ;
TEST6 ;
TEST7 ;
TEST8 ;
TEST9 ;
TESTEND1 ;
TESTEND2 ;
;###
; PROCEDURE REFERENCES:
IGETADR: GETADR ;
IHEXIN: HEXIN ;
IHEXIN1: HEXIN1 ;
IHEXOUT: HEXOUT ;
INEXTLIN: NEXTLIN ;
IINCHAR: INCHAR ;
IOUTCHAR: OUTCHAR ;
IOUTTXNL: OUTTXNL ;
IOUTTEXT: OUTTEXT ;
ICHECKB: CHECKB ;
IADRFAULT: ADRFAULT ;
IDATFAULT: DATFAULT ;
IPAGFAULT: PAGFAULT ;
IMSWSET: MSWSET ;
ICLEAR: CLEAR ;
IALOAD: ALOAD ;
ICHECK: CHECK ;
ICHECKX: CHECKX ;
ISTARTW: STARTW ;
ISTARTR: STARTR ;
IREADTM: READTM ;
IWRWR: WRWR ;
IWRRE: WRRE ;
IREWR: REWR ;
IRERE: RERE ;
IINPAR: INPAR ;
IPAGTST: PAGTST ;
; LABEL REFERENCES:
ISTART: ;
IINCOMMAND: INCOMMAND ;
IERROR: ERROR ;
; CONSTANT REFERENCES:
RE00C: #E00C ;
RE000: #E000 ;
RAAAA: #AAAA ;
R8000: #8000 ;
R5555: #5555 ;
R4000: #4000 ;
R2000: #2000 ;
R1234: #1234 ;
R12AB: #12AB ;
RCDAB: #CDAB ;
R1000: #1000 ;
R2048: 2048 ;
R1024: 1024 ;
R015C: #015C ;
;
PROGPOINTER: BPRG1 ;
BOOTPOINTER: BBOOT ;
BASEPOINTER: BS1 ; ;###
LOCNT: ; LOCAL ACTION, SPEC FOR TIMOUT:
MOV R0 SAVE7 ;
MOV RE000 R0 ;
LDS R0 ;
MOV CAUSE R0 ; IF 0.CAUSE = 3
INEP R0 3 ; THEN
MOV SAVE7 R0 ;
JMP LOCNP ; RETURN(LOCRETURN+1);
MOV LOCRETURN R0 ;
ADDC 2 R0 ;
MOV R0 LOCRETURN ;
MOV SAVE7 R0 ;
JMPI LOCRETURN ; ELSE GOTO NO PAR. ACTION;
;
LOCMVM: ; LOCAL ACTION FOR MOVM, NO PAR.:
MOV R0 SAVE7 ;
MOV RE000 R0 ;
LDS R0 ;
MOV CAUSE R0 ;
IEQ R0 2 ; IF 0.CAUSE = 2 THEN
JMP LCNX ; RETURN
MOV SAVE7 R0 ; ELSE CONTINUE;
;
LOCMVMP: ; LOCAL ACTION FOR MOVM, PAR.:
SUB BAS R6 ; MAKE ADDR REL.;
; CONTINUE;
;
LOCACP: ; PAR. LOCAL ACTION:
MOV R0 SAVE7 ;
MOV RE000 R0 ;
LDS R0 ;
MOV R6 SAVE8 ;
MOV CAUSE R0 ;
INE R0 2 ; IF CAUSE <> PAR.ERR. THEN
JMP LCNP1 ; GOTO LOCAL ACTION NO PAR.ERR.
JMP S4 OUTTXNL ; WRITE(TEXT);
<:PARITY ERR AT ADD<0>:> ;
JMP LCNP3 ; GOTO WRITEADR;
;###
LOCNP: ; LOCAL ACTION, NO PARITY ERR STOP:
MOV R0 SAVE7 ; SAVE(R0);
MOV RE000 R0 ;
LDS R0 ;
MOV CAUSE R0 ; IF 0.CAUSE = 2 THEN
INE R0 2 ; BEGIN
JMP LCNP1 ; RESTORE(R0);
LCNX: ; RETURN:
MOV LOCRETURN R0 ;
ADDC 1 R0 ;
MOV R0 LOCRETURN ; RETURN(LOCRETURN);
MOV SAVE7 R0 ;
JMPI LOCRETURN ;
LCNP1: ; END;
INE R0 3 ; IF 0.CAUSE = 3 THEN
JMP LCNP2 ; BEGIN
MOV R6 SAVE8 ; SAVE(ADR);
JMP S4 OUTTXNL ; WRITE(TEXT);
<:TIMEOUT AT ADD<0>:> ;
LCNP3: ; WRITEADR:
MOV SAVE8 R4 ; RESTORE(ADDR);
MOV BAS R3 ;
ADD R3 R4 ; MAKE ADDR REL;
JMP S5 HEXOUT ; WRITE(ADDR);
JMPI IINCOMMAND ; GOTO INCOMMAND;
LCNP2: ; END;
JMP S4 OUTTXNL ; WRITE(TEXT);
<:PROGRAM ERR AT ADD<0>:> ;
MOV LOCRETURN R4 ;
JMP S5 HEXOUT ; WRITE(LOCRETURN);
JMPI IINCOMMAND ; GOTO INCOMMAND;
;###
LOCALL: ; SURVIVE ALL:
MOV R0 SAVE7 ; SAVE(R0);
MOV RE000 R0 ;
LDS R0 ; CLEAR LOCAL ACTION BIT;
MOV CAUSE R0 ; IF TIMEOUT OR PAR. ERR. THEN
IHS R0 2 ; GOTO RETURN;
JMP LCNX ;
JMP LCNP2 ; GOTO PROGRAM ERR.;
;
LOCSP: ; NO PAR. ACTION FOR DUMP:
MOV R0 SAVE7 ; SAVE(R0);
MOV RE000 R0 ;
LDS R0 ; CLEAR LOCAL ACTION BIT;
MOV CAUSE R0 ;
IEQ R0 2 ; IF CAUSE = 2 THEN
JMP LCNX ; GOTO RETURN
; ELSE CONTINUE;
;
;
LOCACT: ; NORMAL LOCAL ACTION:
JMP S4 OUTTXNL ; WRITE(TEXT);
<:LOCAL ACTION, CAUSE<0>:> ;
MOV CAUSE R4 ;
JMP S5 HEXOUT ; WRITE(CAUSE);
MOV BAS R0 ;
LDN R0 ; RESTART;
;
EMERGENCY: ; EMERGENCY ACTION:
JMP S4 OUTTXNL ; WRITE(TEXT);
<:EMERGENCY ACTION<0>:> ;
MOVC BPRG1 R0 ;
LDN R0 ; LOAD RAM TEST PROGRAM;
;
MREGS: ; MREGS:
SVP REGSRET ; SAVE PROCESS TO CONTINUE
; WITH REGSRET;
MOVC 0 R3 ; 0 => RE.ADDR;
MR0: ; MR0:
MOV 0. X3 R4 ; 0.ADR => REGISTER;
JMP S5 HEXOUT ; OUTPUT REGISTER;
ADDC 1 R3 ; INCR(RE.ADDR);
INE R3 9 ; IF ADDR <> 9 THEN
JMP MR0 ; GOTO MR0;
JMP S5 NEXTLIN ; NEW LINE;
MOV BAS R0 ;
LDN R0 ; RELOAD PROCESS;
;
REGSRET: ; REGSRET:
JMP 0. X7 ; RETURN;
;
;
;
;###
;----------------------------------------------------------------------
;
; S U B R O U T I N E S
;
;----------------------------------------------------------------------
;GETADR - GET ADDRESS
; CALL EXIT
;
;R0 DESTROYED
;R1 DESTROYED
;R2 0
;R3 ADDRESS
;R5 LINK DESTROYED
;R6 DESTROYED
;R7 LINK
GETADR: ; GETADR:
MOV R5 R7 ; SAVE(LINK);
G1: ; G1:
JMP S5 HEXIN ; GET HEX CHAR;
JMP G1 ; NOT HEX, GOTO G1;
MOV R1 R3 ;
MOVC 3 R2 ;
G0: ; GO:
JMP S5 HEXIN ; GET HEX CHAR;
JMP 0. X7 ; RETURN(ERROR);
SLL R3 4 ; VALUE*16=>VALUE;
ADD R1 R3 ; CHAR+VALUE=>VALUE;
SOB R2 G0 ; IF DECR(COUNT)<> 0 THEN
; GOTO G0;
JMP 1. X7 ; RETURN;
;HEXIN
; CALL EXIT
;
;R0 DESTROYED
;R1 HEX CHAR
;R5 LINK LINK
;R6 DESTROYED
HEXIN: ; HEXIN:
JMP S6 INCHAR ; GET CHAR;
HEXIN1: ; HEXIN1:
ADDC -<:::> R1 ; CHAR-<:::> => CHAR;
ILTP R1 <:A:>-<:::>; IF CHAR < <:A:>-<:::>
IGE R1 0 ; AND CHAR >= 0 THEN
JMP 0. X5 ; RETURN(ERROR);
HEXIN2: ;
ADDC <:::>-<:A:>+10 R1 ; CHAR+<:::>-<:A:>+10 =>CHAR;
ILT R1 10 ; IF CHAR<10 THEN
ADDC <:A:>-10-<:0:> R1 ; CHAR+<:A:>-10-<:0:> =>CHAR;
SGEP R1 16 ; IF CHAR<16 OR
SLT R1 0 ; >=0 THEN
JMP 1. X5 ; RETURN;
JMP 0. X5 ; RETURN(ERROR);
;###
;HEXOUT
; CALL EXIT
;
;R0 DESTROYED
;R1 DESTROYED
;R2 DESTROYED
;R4 BIN VALUE BIN VALUE
;R5 LINK LINK
;R6 DESTROYED
HEXOUT: ; HEXOUT:
MOVC 8#40 R1 ; ASCII(SP) => CHAR;
JMP S6 OUTCHAR ; OUTPUT CHAR;
MOVC 4 R2 ; 4 => COUNT;
H2: SLC R4 4 ; H2:
MOV R4 R1 ;
XTR R1 4 ; HEX(3:4) => VALUE;
ILT R1 10 ; IF VALUE < 10 THEN
ADDC <:0:>-<:A:>+10 R1 ; VALUE+<:0:>-<:A:>+10 =>VALUE
ADDC <:A:>-10 R1 ; VALUE+<:A:>-10 => CHAR;
JMP S6 OUTCHAR ; OUTPUT CHAR;
SOB R2 H2 ; IF DECR(COUNT)<>0 THEN
; GOTO H2;
JMP 0. X5 ; RETURN;
;NEXTLIN
; CALL EXIT
;
;R0 DESTROYED
;R1 DESTROYED
;R5 LINK LINK
;R6 DESTROYED
NEXTLIN: ; NEXTLIN:
MOVC 8#15 R1 ; ASCII(CR) => CHAR;
JMP S6 OUTCHAR ; OUTPUT CHAR;
MOVC 8#12 R1 ; ASCII(LF) => CHAR;
JMP S6 OUTCHAR ; OUTPUT CHAR;
MOVC 0 R1 ;
JMP S6 OUTCHAR ; OUTPUT 4 FILLERS;
JMP S6 OUTCHAR ;
JMP S6 OUTCHAR ;
JMP S6 OUTCHAR ;
JMP 0. X5 ; RETURN;
;###
;INCHAR INPUT A CHAR;
; CALL EXIT
;
;R0 DESTROYED
;R1 CHAR
;R6 LINK LINK
INCHAR: ; INCHAR:
MOVC OC R0 ; OC=>DEVICE;
SIO R0 R0 ; WAIT FOR INPUT READY;
IBZ R0 BINP ;
JMP INCHAR ;
IBN R0 BPERR ; IF <BREAK> THEN
JMPI ISTART ; GOTO START;
MOVC OC R0 ; OC=>DEVICE;
RIO R1 R0 ; READ(CHAR,DEVICE);
XTR R1 7 ; CONTINUE WITH OUTCHAR;
;
;
;OUTCHAR OUTPUT A CHAR;
; CALL EXIT
;
;R0 DESTROYED
;R1 CHAR CHAR
;R6 LINK LINK
OUTCHAR: ; OUTCHAR:
MOVC OC R0 ;
SIO R0 R0 ;
IBZ R0 BOUT ;
JMP OUTCHAR ;
MOVC OC R0 ; OC=>DEVICE;
WIO R1 R0 ; WRITE(CHAR,DEVICE);
JMP 0. X6 ; RETURN;
;###
;OUTTEXT OUTPUT A TEXTSTRING;
; CALL EXIT
;
;R0 DESTROYED
;R1 DESTROYED
;R4 ADDR ADDR(UPDATED) (RETURN)
;R5 DESTROYED
;R6 DESTROYED
OUTTXNL: ; OUTTEXT WITH NEWLINE:
JMP S5 NEXTLIN ; NEWLINE;
OUTTEXT: ; NEWCHAR:
MVP 0. X4 R1 ; 0.ADDR => CHAR;
XTR R1 7 ; CHAR(6:7) => CHAR;
JOZ R1 OUTTEXT1 ; IF CHAR=0 THEN GOTO RET;
JMP S6 OUTCHAR ; OUTCHAR;
MVP 0. X4 R1 ; 0.ADDR(15:8) =>
SWP R1 ; CHAR;
XTR R1 7 ; CHAR(6:7) => CHAR;
JOZ R1 OUTTEXT1 ; IF CHAR=0THEN GOTO RET;
JMP S6 OUTCHAR ; OUTCHAR;
ADDC 1 R4 ; ADDR+1 => ADDR;
JMP OUTTEXT ; GOTO NEWCHAR;
OUTTEXT1: ; RET:
JMP 1. X4 ; RETURN;
;CHECKB - CHECK FOR STOP FROM TERMINAL
; CALL EXIT
;
;R4 DESTROYED
;R5 DESTROYED
;R6 LINK LINK
CHECKB: ; CHECK FOR STOP:
MOVC OC R4 ;
SIO R5 R4 ; SENSE OC;
IBZ R5 BPERR ; IF INPUT NOT READY THEN
JMP 2. X6 ; RETURN(NOT STOP);
MOVC 3 R5 ;
CIO R5 R4 ; ENABLE INTERFACE;
JMP 0. X6 ; RETURN(STOP);
;###
;DATFAULT
; CALL EXIT
;
;R2 COUNT COUNT
;R3 ACT1 ACT1
;R4 ACT2 ACT2
;R5 LINK LINK
;R6 ADDR ADDR
;R7 DESTROYED
DATFAULT: ; DATAFAULT:
MOVC SAVE0+7 R7 ;
STC 7 ; STACK REGISTERS;
JMP S4 OUTTXNL ; WRITE(TEXT);
<:DATA FAULT AT ADR<0>:> ;
MOVC BAS R3 ;
MOV SAVE6 R4 ; 0.SAVER6+
ADD X3 R4 ; 0.BAS => ADDR;
JMP S5 HEXOUT ; WRITE(ADDR);
JMP S4 OUTTEXT ; WRITE(TEXT)
<: FAULT WORDS<0>:> ;
MOV SAVE3 R4 ;
JMP S5 HEXOUT ; WRITE(R3);
MOV SAVE4 R4 ;
JMP S5 HEXOUT ; WRITE(R4);
JMP S6 CHECKB ; CHECK FOR STOP;
MOVC 1 R2 ; STOP:
MOV R2 2. X7 ; 2 => 0.SAVER2;
UNS 6 ; NOT STOP: UNSTACK REGISTERS;
; END;
JMP 0. X5 ; RETURN;
;PAGFAULT
; CALL EXIT
;
;R1 TPAGE TPAGE
;R4 PAGE PAGE
;R5 LINK LINK
;R7 DESTROYED
PAGFAULT: ; PAGEFAULT:
MOVC SAVE0+7 R7 ;
STC 7 ; STACK REGISTERS;
JMP S4 OUTTXNL ; WRITE(TEXT);
<:PAGE FAULT AT<0>:> ;
MOV SAVE1 R4 ;
MOV R4 R3 ;
IEQ R3 1 ;
MOVC 2 R4 ;
IEQ R3 2 ;
MOVC 1 R4 ;
JMP S5 HEXOUT ; WRITE(TPAGE);
MOV SAVE4 R4 ; PAGE => ADDR;
JMP ADRF1 ; GOTO WRITEADDR;
;###
;ADRFAULT
; CALL EXIT
;
;R1 COUNT COUNT
;R5 LINK LINK
;R6 ADDR ADDR
;R7 DESTROYED
ADRFAULT: ; ADDRESSFAULT:
MOVC SAVE0+7 R7 ;
STC 7 ; STACK REGISTERS;
JMP S4 OUTTXNL ; WRITE(TEXT);
<:ADR FAULT AT ADR<0>:> ;
MOVC BAS R3 ;
MOV SAVE6 R4 ; 0.SAVER6+
ADD X3 R4 ; 0.BAS => ADDR;
ADRF1: ; WRITEADDR:
JMP S5 HEXOUT ; WRITE(ADDR);
JMP S6 CHECKB ; CHECK FOR STOP;
MOVC 1 R1 ; STOP:
MOV R1 1. X7 ; 1 => 0.SAVER1;
UNS 6 ; NOT STOP: UNSTACK REGISTERS;
; END;
JMP 0. X5 ; RETURN;
;
;
;MSWSET
; CALL EXIT
;
;R0,R1 DESTROYED
;R2 MSW MSW
;R3,R4 DESTROYED
;R5 LINK LINK
;R6,R7 DESTROYED
MSWSET: ; MODULE SWITCH SET:
MOV R5 R7 ; SAVE(LINK);
MSWSET1: ; SET SWITCH:
JMP S4 OUTTXNL ; WRITE(TEXT);
<:SET MSW: <0>:> ;
MOVC 7 R3 ; FOR BIT:=7 UNTIL 1 DO
MS1: ; BEGIN
MOVC <:0:> R1 ; <:0:> => CHAR;
MODN R3 ;
MODC 7 ;
IBN R2 0 ; IF MSW(7-BIT:1)=1 THEN
ADDC <:1:>-<:0:> R1 ; <:1:> => CHAR;
JMP S6 OUTCHAR ; OUTCHAR;
SOB R3 MS1 ; END;
MOVC <: :> R1 ;
JMP S6 OUTCHAR ; WRITE(<: :>);
JMP S6 INCHAR ; INCHAR;
INE R1 <:N:> ; IF CHAR <> CR THEN
JMP MSWSET1 ; GOTO SET SWITCH;
JMP 0. X7 ; RETURN;
;###
;ALOAD - LOAD ADDRESS INTO ADDRESS
; CALL EXIT
;
;R1 DESTROYED
;R2 0
;R5 LINK LINK
;R6 DESTROYED
ALOAD: ; LOAD ADDRESS INTO ADDRESS:
MOV BAS R6 ;
NEG R6 ; SET ADDR;
MOVC 0 R1 ; 0 = W;
MOV SIZE R2 ; FOR I:=1 UNTIL SIZE DO
ALOAD1: ; BEGIN
MOV R1 X6 ; W => 0.ADDR;
ADDC 1 R1 ; W+1 => W;
ADDC 1 R6 ; ADDR+1 => ADDR;
SOB R2 ALOAD1 ; END;
JMP 0. X5 ; RETURN;
;CHECK - CHECK FOR ADDRESS IN ADDRESS
; CALL EXIT
;
;R2 0
;R3 DESTROYED
;R4 DESTROYED
;R5 LINK DESTROYED
;R6 DESTROYED
;R7 DESTROYED
CHECK: ; CHECK FOR ADDRESS:
MOV R5 SAVE9 ; SAVE(LINK);
MOV BAS R6 ;
NEG R6 ; SET ADDR;
MOVC 0 R4 ; 0 => EXPW;
MOV SIZE R2 ; FOR I:=1 UNTIL SIZE DO
CHECK1: ; BEGIN
MOV X6 R3 ; 0.ADDR => W;
INE R3 R4 ; IF W <> EXPW THEN
JMP S5 DATFAULT ; DATAFAULT;
ADDC 1 R4 ; EXPW+1 => EXPW;
ADDC 1 R6 ; ADDR+1 => ADDR;
SOB R2 CHECK1 ; END;
JMPI SAVE9 ; RETURN;
;###
;CLEAR - SET RAM TO ALL ZEROES
; CALL EXIT
;
;R2 0
;R3 0
;R5 LINK LINK
;R6 DESTROYED
CLEAR: ; CLEAR RAM:
MOVC 0 R2 ; 0 => W;
CLEARX: ; SET VALUE:
MOV BAS R6 ;
NEG R6 ; SET ADDR;
MOV SIZE R3 ; FOR I:=1 UNTIL SIZE DO
CLEAR1: ; BEGIN
MOV R2 X6 ; W => 0.ADDR;
ADDC 1 R6 ; ADDR+1 => ADDR;
SOB R3 CLEAR1 ; END;
JMP 0. X5 ; RETURN;
;STARTW - START TEST MODULE, WRITE
; CALL EXIT
;
;R0 MODE MODE (MODE = PAUSE AND PAGE)
;R1 DESTROYED
;R5 LINK LINK
;R6 DESTROYED
;R7 DESTROYED
STARTW: ; START TEST MODULE, WRITE:
MODC -128 ; SELECT WRITE;
;STARTR - START TEST MODULE, READ
; CALL EXIT
;
;R0 MODE MODE (MODE = PAUSE AND PAGE)
;R1 DESTROYED
;R5 LINK LINK
;R6 DESTROYED
;R7 DESTROYED
STARTR: ; START TEST MODULE READ:
MOVC 128 R7 ; SELECT READ;
MOVC 0 R1 ; O => ADDR;
MOVC ADR<6+RAMTM R6 ;
WIO R1 R6 ; LOAD *ADDR*;
MOV SIZE R1 ; 0.SIZE
ADDC -1 R1 ; -1 =>
MOVC COT<6+RAMTM R6 ; *COUNT*;
WIO R1 R6 ;
ADD R0 R7 ;
MOVC CNT<6+RAMTM R6 ; LOAD *CONTROL*;
WIO R7 R6 ;
JMP 0. X5 ; RETURN;
;###
;CHECKX - CHECK WITH HEADING
; CALL EXIT
;
;R0 DESTROYED
;R1 DESTROYED
;R2 0
;R3 DESTROYED
;R4 DESTROYED
;R5 LINK LINK
;R6 DESTROYED
;R7 DESTROYED
CHECKX: ; CHECK WITH HEADING:
MOV BAS R6 ;
NEG R6 ; SET ADDR;
MOVC 0 R4 ; 0 => EXPW;
MOV SIZE R2 ; FOR I:=1 UNTIL SIZE DO
CHKX1: ; BEGIN
MOV X6 R3 ; 0.ADDR => W;
IEQ R3 R4 ; IF W <> EXPW THEN
JMP CHKX2 ; BEGIN
MOV R5 R3 ; SAVE(LINK);
JMP S6 HEAD ; HEADING;
MOV R3 R5 ; RESTORE(LINK);
JMP CHECK ; GOTO CHECK;
CHKX2: ; END;
ADDC 1 R4 ; EXPW+1 => EXPW;
ADDC 1 R6 ; ADDR+1 => ADDR;
SOB R2 CHKX1 ; END;
JMP 0. X5 ; RETURN;
;READTM - READ ERRORS FROM TEST MODULE
; CALL EXIT
;R5 LINK LINK
;R7 DESTROYED
READTM: ; READ TEST MODULE:
MOVC SAVE0+7 R7 ;
STC 7 ; STACK REGISTERS;
MOVC RAMTM R6 ;
RIO R3 R6 ; *STATUS* => ERR;
IBZ R3 14 ; IF ERR VALID THEN
JMP READTM1 ; BEGIN
JMP S6 HEAD ; HEADING;
READTM2: ; WHILE ERR VALID AND
JMP S6 CHECKB ; NOT STOP FROM OC DO
JMP READTM3 ; BEGIN
NOP ;
JMP S4 OUTTXNL ; WRITE(TEXT);
<:RST ERR<0>:> ;
READTM3: ;
MOV R3 R4 ;
JMP S5 HEXOUT ; WRITE(ERR);
MOVC RAMTM R6 ;
RIO R3 R6 ; *STATUS* => ERR;
SBZ R3 14 ;
JMP READTM2 ; END;
READTM1: ; END;
MOVC SAVE0 R7 ;
UNS 6 ; UNSTACK REGISTERS;
JMP 0. X5 ; RETURN; ;###
;HEAD - HEADING FOR DOUBLE ACCESS TEST
; CALL EXIT
;
;R0 DESTROYED
;R1 DESTROYED
;R2 DESTROYED
;R4 DESTROYED
;R5 DESTROYED
;R6 LINK DESTROYED
;R7 LINK
HEAD: ; HEADING:
MOV R6 R7 ; SAVE(LINK);
JMP S4 OUTTXNL ; WRITE(TEXT);
<:PAUSE,BLOCK=<0>:> ;
MOV SAVE10 R4 ;
JMP S5 HEXOUT ; WRITE(PAGE,PAUSE);
MOV SAVEWR R2 ;
IGE R2 2 ; IF 0.SAVEWR < 2 THEN
JMP HEAD1 ; BEGIN
JMP S4 OUTTEXT ; WRITE(TEXT1);
<: WR<0>:> ; END
JMP HEAD2 ; ELSE
HEAD1: ; BEGIN
JMP S4 OUTTEXT ; WRITE(TEXT1A);
<: RE<0>:> ;
HEAD2: ; END;
IBN R2 0 ; IF 0.SAVEWR IS EVEN THEN
JMP HEAD3 ; BEGIN
JMP S4 OUTTEXT ; WRITE(TEXT2);
<:/WR<0>:> ; END
JMP HEAD4 ; ELSE
HEAD3: ; BEGIN
JMP S4 OUTTEXT ; WRITE(TEXT2A);
<:/RE<0>:> ;
HEAD4: ; END;
JMP 0. X7 ; RETURN;
;###
;INPAR - INPUT A PARAMETER
; CALL EXIT
;
;R0 DESTROYED
;R1 DESTROYED
;R5 LINK LINK
;R6 DESTROYED
INPAR: ; INPARAMETER:
JMPI S6 IINCHAR ; INCHAR;
ADDC -<: :> R1 ; IF CHAR = <: :> THEN
JOZ R1 INPAR ; GOTO INPARAMETER;
ADDC -<:L:>+<: :> R1 ;
IEQ R1 <:W:>-<:L:>; IF CHAR = <:W:> THEN
JMP 1. X5 ; RETURN(W);
IEQ R1 <:R:>-<:L:>; IF CHAR = <:R:> THEN
JMP 0. X5 ; RETURN(R);
JMPI IERROR ; GOTO ERROR;
;###
;WRWR TEST
; CALL EXIT
;
;R0-R5 DESTROYED
;R6 LINK DESTROYED
;R7 DESTROYED
WRWR: ; WRITEWRITE:
MOV R6 SAVE11 ; SAVE(LINK);
MOVC 0 R0 ; 0 =>
MOV R0 SAVEWR ; 0.SAVEWR;
MOV SAVE10 R0 ; RESTORE(MODE);
JMPI S5 ISTARTW ; START TEST MODULE WRITE;
JMPI S5 IALOAD ; FOR I:=1,2 DO
JMPI S5 IALOAD ; LOAD ADDRESS INTO ADDRESS;
MOVC RAMTM R6 ;
RIO R1 R6 ; STOP TEST MODULE;
JMPI S5 ICHECKX ; CHECK FOR ADDRESS;
JMPI SAVE11 ; RETURN;
;WRRE TEST
; CALL EXIT
;
;R0-R5 DESTROYED
;R6 LINK DESTROYED
;R7 DESTROYED
WRRE: ; WRITEREAD:
MOV R6 SAVE11 ; SAVE(LINK);
JMPI S5 ICLEAR ; CLEAR RAM;
MOVC 1 R0 ; 1 =>
MOV R0 SAVEWR ; 0.SAVEWR;
MOV SAVE10 R0 ; RESTORE(MODE);
JMPI S5 ISTARTW ; START TEST MODULE WRITE;
MOVC 2 R1 ; FOR I:=1 UNTIL 2 DO
WRRE1: ; BEGIN
MOV BAS R6 ;
NEG R6 ; SET ADDR;
MOV SIZE R2 ; FOR J:=1 UNTIL SIZE DO
WRRE2: ; BEGIN
MOV X6 R3 ; 0.ADDR => W;
ADDC 1 R6 ; ADDR+1 => ADDR;
SOB R2 WRRE2 ; END;
SOB R1 WRRE1 ; END;
MOVC RAMTM R6 ;
RIO R1 R6 ; STOP TEST MODULE;
JMPI S5 ICHECKX ; CHECK FOR ADDRESS;
JMPI SAVE11 ; RETURN;
;###
;REWR TEST
; CALL EXIT
;
;R0-R5 DESTROYED
;R6 LINK DESTROYED
;R7 DESTROYED
REWR: ; READWRITE:
MOV R6 SAVE11 ; SAVE(LINK);
JMPI S5 ICLEAR ; CLEAR RAM;
MOVC 2 R0 ; 2 =>
MOV R0 SAVEWR ; 0.SAVEWR;
MOV SAVE10 R0 ; RESTORE(MODE);
JMPI S5 IALOAD ; LOAD ADDRESS;
JMPI S5 ISTARTR ; START TEST MODULE READ;
JMPI S5 IALOAD ; FOR I:=1,2 DO
JMPI S5 IALOAD ; LOAD ADDRESS;
JMPI S5 IREADTM ; READ ERRORS FROM TESTM.;
JMPI S5 ICHECKX ; CHECK FOR ADDRESS;
JMPI SAVE11 ; RETURN;
;RERE TEST
; CALL EXIT
;R0-R5 DESTROYED
;R6 LINK DESTROYED
;R7 DESTROYED
RERE: ; READREAD:
MOV R6 SAVE11 ; SAVE(LINK);
JMPI S5 ICLEAR ; CLEAR RAM;
MOVC 3 R0 ; 3 =>
MOV R0 SAVEWR ; 0.SAVEWR;
MOV SAVE10 R0 ; RESTORE(MODE);
JMPI S5 IALOAD ; LOAD ADDRESS;
JMPI S5 ISTARTR ; START TESTMODULE READ;
JMPI S5 ICHECKX ; FOR I:=1,2 DO
JMPI S5 ICHECKX ; CHECK FOR ADDRESS;
JMPI S5 IREADTM ; READ ERRORS FROM TESTM.;
JMPI SAVE11 ; RETURN;
;###
;PAGTST - TEST OF PAGESWITCH;
; CALL EXIT
;
;R0-R5 DESTROYED
;R6 LINK DESTROYED
;R7 DESTROYED
PAGTST: ; PAGETEST:
MOV R6 SAVE12 ; SAVE(LINK);
MOV BAS R6 ;
NEG R6 ; RESET ADDR;
MOVC 0 R3 ; 0 => PAGE;
PGT1: ; NEWPAGE:
MOV R3 R2 ; PAGE => MSW;
IEQ R3 1 ; IF PAGE = 1 THEN
MOVC 2 R2 ; 2 => MSW;
IEQ R3 2 ; IF PAGE = 2 THEN
MOVC 1 R2 ; 1 => MSW;
MOV R2 R4 ; MSW => CPAGE;
SLL R2 5 ; MSW*32 => MSW;
MOV SAVE13 R0 ; 0.FIRSTBIT+MSW
ADD R0 R2 ; => MSW;
MOV RE000 R0 ;
LDS R0 ;
MOVC SAVE0+7 R7 ;
STC 6 ; STACK REGISTERS;
JMPI S5 IMSWSET ; SET MODULE SWITCH;
MOVC SAVE0 R7 ;
UNS 6 ; UNSTACK REGISTERS;
MOVC 0 R1 ; FOR TPAGE:=0 UNTIL 3 DO
PGT2: ; BEGIN
MOV R1 R2 ; TPAGE => PPAGE;
MOV RE000 R0 ; #E000+PPAGE
SLL R2 2 ; *4
ADD R2 R0 ;
LDS R0 ; => PSW;
IEQ R1 R3 ; IF PAGE = TPAGE THEN
JMP PGT3 ; GOTO SP;
MOV X6 R0 ; 0.ADDR => W;
JMP PGT4 ; IF NOT TIMEOUT PAGEFAULT;
JMP PGT5 ; GOTO OK;
PGT3: ; SP:
MOV X6 R0 ; 0.ADDR => W;
JMP PGT5 ; IF NOT TIMEOUT GOTO OK;
PGT4: MOV RE000 R0 ;
LDS R0 ;
JMPI S5 IPAGFAULT ; PAGEFAULT;
PGT5: ; OK:
ADDC 1 R1 ;
ILT R1 4 ;
JMP PGT2 ; END;
ADDC 1 R3 ; PAGE+1 => PAGE;
ILT R3 4 ; IF PAGE <= 3 THEN
JMP PGT1 ; GOTO NEWPAGE;
MOV RE000 R0 ;
LDS R0 ; SET PAGE TO ZERO;
JMPI SAVE12 ; RETURN;
;###
;----------------------------------------------------------------------
;
; F U N C T I O N S
;
;----------------------------------------------------------------------
INSERTREGISS: ; INSERT REGISTER DUMP:
MOV PROGRAM R0 ; PROGRAM.CUR
ADDC MREGS R0 ; +RE.PROCEDURE
MODN BAS ;
MOV R0 REGISS ; =>REGISTERS(ABS);
JMP START ; GOTO START;
;----------------------------------------------------------------------
LOADDATA: ; LOADDATA:
JMPI S5 IGETADR ; GETADDRESS;
JMP ERROR ; IF ERROR THEN GOTO ERROR;
SUB R4 R3 ;
LD0: ; LD0:
JMPI S6 IINCHAR ; GET CHARACTER;
IEQP R1 <:L:> ; L - DECR(RE.ADDRESS);
ADDC -1 R3 ;
JMP LD0 ; GOTO LD0;
IEQ R1 <:S:> ; S - STOP INPUT;
JMP START ; GOTO START;
JMPI S5 IHEXIN1 ; CONVERT TO HEX;
JMP LD0 ; NO HEX CHAR: GOTO LD0;
MOV R1 R2 ;
MOVC 3 R4 ; 3 => COUNT;
LD1: ; LD1:
JMPI S5 IHEXIN ; GET HEX CHAR;
JMP ERROR ; IF ERROR THEN GOTO ERROR;
SLL R2 4 ; HEX*16 => HEX;
ADD R1 R2 ; CHAR+HEX => HEX;
SOB R4 LD1 ; IF DECR(COUNT) <> 0 THEN
; GOTO LD1;
MOV R2 0. X3 ; SAVE WORD;
ADDC 1 R3 ; INCR(RE.ADDRESS);
JMP LD0 ; GOTO NEW DATA(LD0);
;----------------------------------------------------------------------
FILL: ; FILL RAM WITH VALUE:
JMPI S5 IGETADR ; GET VALUE;
JMP ERROR ; ERROR: GOTO ERROR;
MOVC LOCNP R0 ; NO PARITY ACTION =>
MOV R0 LOCACTION ; 0.LOCAL ACTION;
MOV R3 R2 ; VALUE => FILLVALUE;
JMP S5 CLEARX ; FILL WITH FILLVALUE;
JMP INCOMMAND ; GOTO INCOMMAND;
;----------------------------------------------------------------------
ADRFILL: ; FILL RAM WITH ADDRESS:
MOVC LOCACP R0 ;
MOV R0 LOCACTION ; SET LOCAL ACTION;
JMPI S5 IALOAD ; FILL WITH ADDRESS;
JMP NEWCOM ; GOTO NEWCOMMAND;
;###
;----------------------------------------------------------------------
MLIST: ; DUMP, NO PAR. CHECK:
MOVC LOCSP R0 ; NO PAR ACTION =>
MOV R0 LOCACTION ; 0.LOCAL ACTION;
;----------------------------------------------------------------------
MEMDUMP: ; MEMDUMP:
JMPI S5 IGETADR ; GET START ADDRESS;
JMP ERROR ; IF ERROR;
MOV R3 CURADR ; ADDRESS => 0.CURADR;
JMPI S6 IINCHAR ; INCHAR;
MOVC #FFFF R3 ; #FFFF=>TOP;
SNEP R1 <: :> ; IF CHAR="SP" THEN
JMPI S5 IGETADR ; GET TOP ADDRESS;
JMP START ; ERROR: GOTO START;
MOV R3 TOP ; TOP=>0.TOP;
;
;......................................................................
;
CMEMDUMP: ; CONTINUE MEMDUMP:
JMPI S5 INEXTLIN ; NEW LINE;
MOV CURADR R4 ; 0.0.CURADR => RE.ADR;
JMPI S5 IHEXOUT ; OUTPUT RE.WORD;
MOVC <:L:> R1 ;
JMPI S6 IOUTCHAR ;
L1: ; NEXT:
MOV CURADR R3 ; 0.CURADR => RE.WORD;
MOV R3 R4 ;
MODN BAS ;
MOV 0. X4 R4 ; 0.CURADR => WORD;
JMPI S5 IHEXOUT ; OUTPUT WORD;
ADDC 1 R3 ; INCR(RE.WORD);
MOV R3 CURADR ; RE.WORD => 0.CURADR;
MOV TOP R4 ; 0.TOP=>TOP;
ILO R4 R3 ; IF TOP<CURADR THEN
JMP START ; GOTO START;
MOVC OC R0 ; OC=>DEVICE;
SIO R1 R0 ; SENSE(STATUS,DEVICE);
IBN R1 BPERR ; IF STATUS[BREAK] THEN
JMP START ; GOTO START;
XTR R3 3 ; IF RE.WORD(2:3)<>0
INE R3 0 ; THEN
JMP L1 ; GOTO NEXT;
JMP CMEMDUMP ; GOTO CONTINUE MEMDUMP;
;----------------------------------------------------------------------
ADRCHECK: ; CHECK FOR ADDRESS:
MOVC LOCACP R0 ;
MOV R0 LOCACTION ; SET LOCAL ACTION;
JMPI S5 ICHECK ; CHECK FOR ADDRESS;
JMP NEWCOM ; GOTO NEWCOMMAND;
;###
;----------------------------------------------------------------------
ENTERBASE: ; ENTER NEW BASE:
JMPI S5 IGETADR ; GET BASE ADDRESS;
JMP ERROR ; ERROR: GOTO ERROR;
MOV R3 R5 ;
SUB R4 R5 ; CHANGE TO BASE REL;
MOV PROGPOINTER R6 ; GET PROGRAM POINTER;
SUB R4 R6 ; CHANGE TO BASE REL;
MOVM X6 X5 ; MOV PROMBASE TO NEW BASE;
ADDC -16 R5 ;
MOV R3 BAS. X5 ; INSERT NEW BASE;
MOV R3 BAS+1. X5 ;
MOV R3 4. X5 ; SETUP R4 IN NEW BASE;
LDN R3 ; LOAD PROCESS(NEW BASE);
;----------------------------------------------------------------------
RUNPROG: ; RUNPROG:
JMPI S5 IGETADR ; GET PROCESS ADDRESS;
JMP ERROR ; ERROR: GOTO ERROR;
LDN R3 ; START PROCESS;
;----------------------------------------------------------------------
BOOT: ; ENTER BOOT LOADER:
MOV BOOTPOINTER R0 ; RE.BOOTBASE(ABS);
LDN R0 ; LOAD BOOT LOADER;
;----------------------------------------------------------------------
TIMEOUT: ; TIMOUT TEST:
MOVC LOCALL R0 ; SURVIVE ALL =>
MOV R0 LOCACTION ; 0.LOCAL ACTION;
JMPI S5 IGETADR ; GET ADDRESS;
JMP ERROR ; ERROR: GOTO ERROR;
SUB R4 R3 ; ADDRESS - 0.BASE
MOV R3 R4 ; => ADDRESS;
JMP S5 INPAR ; INPARAMETER;
JMP TIMEOUT4 ; R: GOTO SELECT READ;
; W: CONTINUE;
JMPI S5 IGETADR ; GET VALUE;
JMP ERROR ; ERROR: GOTO ERROR;
MODC 1 ; SELECT WRITE;
TIMEO4: MOVC 0 R2 ; SELECT READ:
MOV R4 R1 ; ADDRESS => ADDR;
TIMEOUT1: ; NEWREAD:
JON R2 TIMEOUT2 ; IF READ THEN
MOV X1 R3 ; 0.ADDR => W;
JMP TIMEOUT3 ; ELSE
TIMEOUT2: ;
MOV R3 X1 ; VALUE => 0.ADDR;
NOP ;
TIMEOUT3: ;
JMPI S6 ICHECKB ; CHECK FOR STOP FROM OC;
JMP NEWCOM ; STOP: GOTO NEWCOMMAND;
NOP ;
JMP TIMEOUT1 ; NOT STOP: GOTO NEWREAD;
JMP NEWCOM ; GOTO NEWCOMMAND;
;###
;----------------------------------------------------------------------
SEARCH: ; SEARCH FOR VALUE DIFF:
JMPI S5 IGETADR ; GET NORM VALUE;
JMP ERROR ; ERROR: GOTO ERROR;
MOVC LOCACP R0 ; PAR LOC ACTION =>
MOV R0 LOCACTION ; 0.LOCAL ACTION;
MOV BAS R6 ;
NEG R6 ; SET ADDR;
MOV R3 R4 ;
MOV SIZE R2 ; FOR I:=1 UNTIL SIZE DO
SEARCH1: ; BEGIN
MOV X6 R3 ; 0.ADDR => VALUE;
INE R3 R4 ; IF VALUE <> NORM VALUE THEN
JMPI S5 IDATFAULT ; DATAFAULT;
ADDC 1 R6 ; ADDR+1 => ADDR;
SOB R2 SEARCH1 ; END;
JMP NEWCOM ; GOTO NEWCOMMAND;
;----------------------------------------------------------------------
FIND: ; FIND VALUE:
JMPI S5 IGETADR ; GET VALUE;
JMP ERROR ; ERROR: GOTO ERROR;
MOVC LOCNP R0 ; NO PAR. ACTION =>
MOV R0 LOCACTION ; 0.LOCAL ACTION;
MOV BAS R6 ;
NEG R6 ; SET ADDR;
MOV SIZE R2 ; FOR I:=1 UNTIL SIZE DO
FIND1: ; BEGIN
MOV X6 R4 ; 0.ADDR => VAL;
INE R3 R4 ; IF VAL = VALUE THEN
JMP FIND2 ; BEGIN
MOVC SAVE0+7 R7 ;
STC 6 ; STACK REGISTERS;
JMPI S4 IOUTTXNL ; WRITE(TEXT);
<:VALUE FOUND AT ADR<0>:> ;
MOV SAVE6 R4 ;
MOV BAS R3 ;
ADD R3 R4 ; MAKE ADDR ABS;
JMPI S5 IHEXOUT ; WRITE(ADDR);
JMPI S6 ICHECKB ; CHECK FOR STOP;
MOVC 1 R2 ; STOP:
MOV R2 2. X7 ; 1 => 0.SAVER2;
UNS 6 ; NOT STOP: UNSTACK REGISTERS;
FIND2: ; END;
ADDC 1 R6 ; ADDR+1 => ADDR;
SOB R2 FIND1 ; END;
JMP NEWCOM ; GOTO NEWCOMMAND;
;###
;----------------------------------------------------------------------
;
; T E S T S
;
;----------------------------------------------------------------------
TEST1: ; READ MODULE TEST:
JMPI S4 IOUTTXNL ; WRITE(TEXT);
<:TIMING TEST<0>:> ;
MOVC 2#0000001 R2 ; 2#0000001 => MSW;
JMPI S5 IMSWSET ; SET MODULESWITCH;
MOVC LOCNP R0 ; NO PARITY CHECK =>
MOV R0 LOCACTION ; 0.LOCAL ACTION;
JMPI S5 ICLEAR ; CLEAR RAM;
MOV TADR R6 ; 0.TESTADR
MOVC BAS R5 ; -0.BAS
SUB X5 R6 ; => ADRABS;
TEST1A: ; READ:
MOV X6 R0 ; 0.ADRABS => W;
MOVC OC R1 ;
SIO R1 R1 ; SENSE TERMINAL;
IBZ R1 BPERR ; IF NOT "BREAK" THEN
JMP TEST1A ; GOTO READ;
JMP NEWCOM ; GOTO INCOMMAND;
;###
;----------------------------------------------------------------------
TEST2: ; ADDRESS CHECK:
JMPI S4 IOUTTXNL ; WRITE(TEXT);
<:ADDRESS CHECK<0>:> ;
MOVC LOCNP R0 ;
MOV R0 LOCACTION ; NO PAR CHECK => 0.LOCAL ACTION;
JMPI S5 ICLEAR ; CLEAR RAM;
MOV BAS R6 ;
NEG R6 ; SET ADDR;
MOV SIZE R1 ;
MOVC 0 R0 ; 0 => DATA;
TEST2A: ; FOR I:=1 UNTIL SIZE DO
; BEGIN
MOV X6 R2 ; 0.ADDR => W
INE R2 0 ; IF W <> 0 THEN
JMPI S5 IADRFAULT ; ADDRESSFAULT;
MOV R0 X6 ; DATA => 0.ADDR;
MOV X6 R2 ; 0.ADDR => W;
INE R2 R0 ; IF W <> DATA THEN
JMPI S5 IADRFAULT ; ADDRESSFAULT;
ADDC 1 R6 ; ADDR+1 => ADDR;
ADDC 1 R0 ; DATA+1 => DATA;
SOB R1 TEST2A ; END;
JMPI S5 ICHECK ; CHECK FOR ADDRESS IN ADDRESS;
MOVC LOCNT R0 ;
MOV R0 LOCACTION ; SPEC TIMEOUT => 0.LOCAL ACTION;
MOV RE000 R1 ;
MOV SIZE R6 ;
SUB R6 R1 ;
MOV BAS R5 ;
SUB R5 R6 ;
TEST2B: ; FOR I:=SIZE UNTIL #E000 DO
; BEGIN
MOV X6 R2 ; 0.ADDR => W;
JMPI S5 IADRFAULT ; IF NOT TIMEOUT ADDRESSFAULT;
ADDC 1 R6 ; ADDR+1 => ADDR;
SOB R1 TEST2B ; END;
JMP NEWCOM ; GOTO NEWCOMMAND;
;###
;----------------------------------------------------------------------
TEST3: ; DATATEST:
JMPI S4 IOUTTXNL ; WRITE(TEXT);
<:CHECKERBOARD TEST<0>:> ;
MOVC LOCNP R0 ; NO PAR. ACTION =>
MOV R0 LOCACTION ; 0.LOCAL ACTION;
MOV R5555 R0 ;
MOV RAAAA R1 ;
MOV BAS R6 ;
NEG R6 ; SET ADDR;
MOV R6 R7 ;
MOVC 8 R2 ; FOR I:=1 UNTIL 8 DO
TEST3A: ; BEGIN
MOVL R01 0. X7 ; SET CHECKERBOARD IN
ADDC 2 R7 ; 0,1.ADDR;
SOB R2 TEST3A ; END;
MOVC LOCMVM R3 ; NO PAR. ACTION FOR MOVM =>
MOV R3 LOCACTION ; 0.LOCAL ACTION;
MOV SIZE R2 ;
SRL R2 4 ;
ADDC -1 R2 ; FOR I:=1 UNTIL SIZE/16-1 DO
TEST3C: ; BEGIN
MOVM X6 X7 ; MOV 16 WORDS;
SOB R2 TEST3C ; END;
MOV BAS R6 ;
NEG R6 ; SET ADDR;
MOVC LOCACP R7 ; NORM LOC ACTION =>
MOV R7 LOCACTION ; 0.LOCAL ACTION;
MOV SIZE2 R2 ;
TEST3B: ; DO FOR ALL EVEN ADDRESSES
; BEGIN
MOVL 0. X6 R34 ; GET W0,W1;
IEQ R0 R3 ; IF W0,W1 IS NOT
INE R1 R4 ; CHECKERBOARD THEN
JMPI S5 IDATFAULT ; DATAFAULT;
ADDC 2 R6 ;
SOB R2 TEST3B ; END;
JMP NEWCOM ; GOTO NEWCOMMAND;
;###
;----------------------------------------------------------------------
TEST4: ; REFRESH TEST:
JMPI S4 IOUTTXNL ; WRITE(TEXT):
<:REFRESH TEST<0>:> ;
MOVC LOCACP R0 ; NORM LOC ACTION =>
MOV R0 LOCACTION ; 0.LOCAL ACTION;
MOVC 0 R0 ;
TEST4A: MOVC 10 R1 ; WAIT APP. 1 SEC;
TEST4B: SOB R1 TEST4B ;
SOB R0 TEST4A ;
MOV BAS R6 ;
NEG R6 ; SET ADDR;
MOV R5555 R0 ;
MOV RAAAA R1 ;
MOV SIZE2 R2 ;
TEST4C: ; DO FOR ALL EVEN ADDRESSES
; BEGIN
MOVL 0. X6 R34 ; 0.ADDR => W0,W1;
IEQ R0 R3 ; IF W0,W1 IS NOT
INE R1 R4 ; CHECKERBOARD THEN
JMPI S5 IDATFAULT ; DATAFAULT;
ADDC 2 R6 ; ADDR+2 => ADDR;
SOB R2 TEST4C ; END;
JMP NEWCOM ; GOTO NEWCOMMAND;
;###
;----------------------------------------------------------------------
MSW04: ; MODULE SWITCH TEST, 4K:
JMPI S4 IOUTTXNL ; WRITE(TEXT);
<:MSW TEST<0>:> ;
MOVC LOCNT R0 ; SPEC TIMEOUT =>
MOV R0 LOCACTION ; 0.LOCAL ACTION;
MOVC 0 R2 ;
MOVC 14 R3 ; FOR 4KMODULE:=0 UNTIL 13 DO
MSW04A: ; BEGIN
MOV BAS R6 ;
NEG R6 ; SET START ADR;
MOVC SAVE0+7 R7 ;
STC 6 ; STACK REGISTERS;
JMPI S5 IMSWSET ; SET MODULE SWITCH;
MOVC SAVE0 R7 ;
UNS 6 ; UNSTACK REGISTERS;
MOV R2 R4 ; MODULE
SLL R4 11 ; *1024 => ADR1;
ADD R6 R4 ; MAKE ADR1 ABS;
MOVC 14 R1 ; FOR M:=0 UNTIL 13 DO
MSW04B: ; BEGIN
INE R6 R4 ; IF ADR1=ADDR THEN
JMP MSW04C ; BEGIN
MOV X6 R0 ; 0.ADDR => W;
JMP MSW04D ; IF TIMEOUT THEN
JMPI S5 IADRFAULT ; ADDRESSFAULT;
JMP MSW04D ; END
MSW04C: ; ELSE BEGIN
MOV X6 R0 ; 0.ADDR => W;
JMPI S5 IADRFAULT ; IF NOT TIMEOUT THEN
; ADDRESSFAULT;
MSW04D: ; END;
MOV R1000 R0 ;
ADD R0 R6 ; ADDR+#1000 => ADDR;
SOB R1 MSW04B ; END;
ADDC 2 R2 ; MSW+2 => MSW;
SOB R3 MSW04A ; END;
MOVC 0 R2 ; 0 =>
MOV R2 SAVE13 ; 0.FIRSTBIT;
JMPI S6 IPAGTST ; PAGETEST;
JMP NEWCOM ; GOTO NEWCOMMAND;
;###
;----------------------------------------------------------------------
MSW16: ; MODULE SWITCH TEST, 16K:
JMPI S4 IOUTTXNL ; WRITE(TEXT);
<:MSW TEST<0>:> ;
MOVC LOCNT R0 ; SPEC TIMEOUT =>
MOV R0 LOCACTION ; 0.LOCAL ACTION;
MOVC 0 R2 ;
MOVC 4 R3 ; FOR MODULE:=0 UNTIL 3 DO
MSW16A: ; BEGIN
MOV BAS R6 ;
NEG R6 ; SET START ADR;
MOVC SAVE0+7 R7 ;
STC 6 ; STACK REGISTERS;
JMPI S5 IMSWSET ; SET MODULE SWITCH;
MOVC SAVE0 R7 ;
UNS 6 ; UNSTACK REGISTERS;
MOV R2 R4 ; MODULE
SLL R4 11 ; *1024 => ADR1;
ADD R6 R4 ; MAKE ADR1 ABS;
MOVC 4 R1 ; FOR M:=0 UNTIL 3 DO
MSW16B: ; BEGIN
IEQ R6 R4 ; IF ADR1<>ADDR THEN
JMP MSW16C ; BEGIN
MOV X6 R0 ; 0.ADDR => W;
JMP MSW16D ; IF TIMEOUT THEN
JMPI S5 IADRFAULT ; ADDRESSFAULT;
JMP MSW16D ; END
MSW16C: ; ELSE BEGIN
MOV X6 R0 ; 0.ADDR => W;
JMPI S5 IADRFAULT ; IF NOT TIMEOUT THEN
; ADDRESSFAULT;
MSW16D: ; END;
MOV R1000 R0 ;
ADD R0 R6 ; ADDR+#1000 => ADDR;
SOB R1 MSW16B ; END;
ADDC 2 R2 ; MSW+2 => MSW;
SOB R3 MSW16A ; END;
;###
MOVC 0 R2 ;
MOVC 3 R3 ; FOR 16KMODULE:=0 UNTIL 2 DO
MS16A: ; BEGIN
MOV BAS R6 ;
NEG R6 ; SET START ADR;
MOVC SAVE0+7 R7 ;
STC 6 ; STACK REGISTERS;
ADDC 1 R2 ; MSW+1 => MSW;
JMPI S5 IMSWSET ; SET MODULE SWITCH;
MOVC SAVE0 R7 ;
UNS 6 ; UNSTACK REGISTERS;
MOV R2 R4 ; MODULE
SLL R4 11 ; *1024 => ADR1;
ADD R6 R4 ; MAKE ADR1 ABS;
MOVC 3 R1 ; FOR M:=0 UNTIL 2 DO
MS16B: ; BEGIN
INE R6 R4 ; IF ADR1=ADDR THEN
JMP MS16C ; BEGIN
MOV X6 R0 ; 0.ADDR => W;
JMP MS16D ; IF TIMEOUT THEN
JMPI S5 IADRFAULT ; ADDRESSFAULT;
JMP MS16D ; END
MS16C: ; ELSE BEGIN
MOV X6 R0 ; 0.ADDR => W;
JMPI S5 IADRFAULT ; IF NOT TIMEOUT THEN
; ADDRESSFAULT;
MS16D: ; END;
MOV R4000 R0 ;
ADD R0 R6 ; ADDR+#4000 => ADDR;
SOB R1 MS16B ; END;
ADDC 8 R2 ; MSW+8 => MSW;
SOB R3 MS16A ; END;
MOVC 2#00001 R2 ; 2#00001 =>
MOV R2 SAVE13 ; 0.FIRSTBIT;
JMPI S6 IPAGTST ; PAGETEST;
JMP NEWCOM ; GOTO NEWCOMMAND;
;###
;----------------------------------------------------------------------
MSW32: ; MODULE SWITCH TEST, 32K:
JMPI S4 IOUTTXNL ; WRITE(TEXT);
<:MSW TEST<0>:> ;
MOVC LOCNT R0 ; SPEC TIMEOUT =>
MOV R0 LOCACTION ; 0.LOCAL ACTION;
MOVC 0 R2 ;
MOVC 8 R3 ; FOR MODULE:=0 UNTIL 7 DO
MSW32A: ; BEGIN
MOV BAS R6 ;
NEG R6 ; SET START ADR;
MOVC SAVE0+7 R7 ;
STC 6 ; STACK REGISTERS;
JMPI S5 IMSWSET ; SET MODULE SWITCH;
MOVC SAVE0 R7 ;
UNS 6 ; UNSTACK REGISTERS;
MOV R2 R4 ; MODULE
SLL R4 11 ; *1024 => ADR1;
ADD R6 R4 ; MAKE ADR1 ABS;
MOVC 8 R1 ; FOR M:=0 UNTIL 7 DO
MSW32B: ; BEGIN
IEQ R6 R4 ; IF ADR1<>ADDR THEN
JMP MSW32C ; BEGIN
MOV X6 R0 ; 0.ADDR => W;
JMP MSW32D ; IF TIMEOUT THEN
JMPI S5 IADRFAULT ; ADDRESSFAULT;
JMP MSW32D ; END
MSW32C: ; ELSE BEGIN
MOV X6 R0 ; 0.ADDR => W;
JMPI S5 IADRFAULT ; IF NOT TIMEOUT THEN
; ADDRESSFAULT;
MSW32D: ; END;
MOV R1000 R0 ;
ADD R0 R6 ; ADDR+#1000 => ADDR;
SOB R1 MSW32B ; END;
ADDC 2 R2 ; MSW+2 => MSW;
SOB R3 MSW32A ; END;
MOVC 2#00001 R2 ; 2#00001 =>
MOV R2 SAVE13 ; 0.FIRSTBIT;
JMPI S6 IPAGTST ; PAGETEST;
;###
MOVC 2#1110001 R2 ; 2#1110001 => MSW;
JMPI S5 IMSWSET ; SET MODULE SWITCH;
MOV R8000 R4 ;
MOV BAS R6 ;
SUB R6 R4 ; SET ADDR1;
NEG R6 ; SET ADDR;
MOVC 16 R1 ; FOR I:=1 UNTIL 16 DO
MSW32I: ; BEGIN
MOV RE00C R0 ;
LDS R0 ; 3 => PAGE(PSW);
ILO R1 9 ; IF ADDR < ADDR THEN
JMP MSW32J ; BEGIN
MOV X6 R0 ; 0.ADDR => W;
JMP MSW32L ; IF NOT TIMEOUT ADRFAULT;
JMP MSW32K ; END ELSE
MSW32J: ; BEGIN
MOV X6 R0 ; 0.ADDR => W;
JMP MSW32K ; IF TIMEOUT THEN
MSW32L: ;
MOV RE000 R0 ;
LDS R0 ;
JMPI S5 IADRFAULT ; ADRFAULT;
MSW32K: ; END;
MOV R1000 R0 ; ADDR + #1000
ADD R0 R6 ; => ADDR;
SOB R1 MSW32I ; END;
MOV RE000 R0 ;
LDS R0 ; SET TO PAGE ZERO;
JMP NEWCOM ; GOTO NEWCOMMAND;
;###
;----------------------------------------------------------------------
TEST6: ; SPEED TEST:
JMPI S4 IOUTTXNL ; WRITE(TEXT);
<:SPEED TEST<0>:> ;
MOVC 2#0000001 R2 ; 2#0000001 => MSW;
JMPI S5 IMSWSET ; SET MODULE SWITCH;
MOVC LOCMVMP R0 ; PAR.CHECK FOR MOVM =>
MOV R0 LOCACTION ; 0.LOCAL ACTION;
MOV SIZE3 R0 ; FOR I:=1 UNTIL 32M/SIZE DO
TEST6A: ; BEGIN
MOV BAS R6 ;
MOV SIZE2 R7 ;
SUB R6 R7 ; SET ADDR1;
NEG R6 ; SET ADDR;
MOV SIZE4 R1 ; FOR J:=1 UNTIL SIZE/512 DO
TEST6B: ; BEGIN
MOVM X6 X7 ; MOV 16 WORDS;
MOVM X6 X7 ; MOV 16 WORDS;
MOVM X6 X7 ; MOV 16 WORDS;
MOVM X6 X7 ; MOV 16 WORDS;
MOVM X6 X7 ; MOV 16 WORDS;
MOVM X6 X7 ; MOV 16 WORDS;
MOVM X6 X7 ; MOV 16 WORDS;
MOVM X6 X7 ; MOV 16 WORDS;
MOVM X6 X7 ; MOV 16 WORDS;
MOVM X6 X7 ; MOV 16 WORDS;
MOVM X6 X7 ; MOV 16 WORDS;
MOVM X6 X7 ; MOV 16 WORDS;
MOVM X6 X7 ; MOV 16 WORDS;
MOVM X6 X7 ; MOV 16 WORDS;
MOVM X6 X7 ; MOV 16 WORDS;
MOVM X6 X7 ; MOV 16 WORDS;
SOB R1 TEST6B ; END;
SOB R0 TEST6A ; END;
MOVC 7 R1 ;
JMPI S6 IOUTCHAR ; OUTPUT BELL;
JMP NEWCOM ; GOTO NEWCOMMAND;
;###
;----------------------------------------------------------------------
TEST7: ; FAST ADDR INVERT TEST:
JMPI S4 IOUTTXNL ; WRITE(TEXT);
<:FAST ADDR INVERT TEST<0>:>;
MOVC LOCACP R0 ;
MOV R0 LOCACTION ;
JMPI S5 IALOAD ; SET ADDR IN ADDR;
MOV BAS R6 ;
MOV SIZE R7 ;
ADDC -1 R7 ;
SUB R6 R7 ; SET ADDR1;
NEG R6 ; SET ADDR;
MOV SIZE2 R1 ;
TEST7A: ; FOR I:=1 UNTIL SIZE/2 DO
; BEGIN
MOV X6 R4 ; 0.ADDR => W;
MOV X6 X7 ; 0.ADDR => 0.ADDR1;
XCH R6 R7 ;
MOV X6 R3 ; 0.ADDR1 => W1;
XCH R6 R7 ;
INE R4 R3 ; IF W <> W1 THEN
JMPI S5 IADRFAULT ; ADDRESSFAULT;
ADDC 1 R6 ; ADDR+1 => ADDR;
ADDC -1 R7 ; ADDR1-1 => ADDR1;
SOB R1 TEST7A ; END;
JMP NEWCOM ; GOTO NEWCOMMAND;
;###
;----------------------------------------------------------------------
TEST8: ; BIT EXERCISE:
JMPI S4 IOUTTXNL ; WRITE(TEXT);
<:BIT EXERCISE<0>:> ;
MOVC LOCACP R0 ;
MOV R0 LOCACTION ;
MOVC 0 R0 ; FOR BIT:=0 UNTIL 15 DO
TEST8A: ; BEGIN
MOV BAS R6 ;
NEG R6 ; SET ADDR;
MOV SIZE R2 ; FOR I:=1 UNTIL SIZE DO
TEST8B: ; BEGIN
MOVC 0 R4 ; 0 => W;
SETS R4 R0 ; 1 => W(BIT:1);
MOV R4 X6 ; W => 0.ADDR;
MOV X6 R3 ; 0.ADDR => W1;
INE R3 R4 ; IF W <> W1 THEN
JMPI S5 IDATFAULT ; DATAFAULT;
ADDC 1 R6 ; ADDR+1 => ADDR;
SOB R2 TEST8B ; END;
ADDC 1 R0 ;
IBZ R0 4 ;
JMP TEST8A ; END;
JMP NEWCOM ; GOTO NEWCOMMAND;
;###
;----------------------------------------------------------------------
TEST9: ; BYTE ADDRESSSING TEST:
JMPI S4 IOUTTXNL ; WRITE(TEXT);
<:BYTE TEST<0>:> ;
MOVC LOCACP R0 ;
MOV R0 LOCACTION ;
MOV BAS R6 ;
NEG R6 ; SET ADDR;
MOV R1234 R0 ; #1234 => WORD;
MOVC 0 R1 ; 0 => BYTEADDR;
MOV SIZE R2 ; FOR I:=1 UNTIL SIZE DO
TEST9A: ; BEGIN
MOV R0 X6 ; WORD => 0.ADDR;
MOVC #AB R3 ; #AB => BYTE;
MOV R1 R5 ;
MODN BAS ;
MOVB R3 0. X5 ; BYTE => 0.BYTEADDR(ABS);
MOV R12AB R4 ; #12AB => EXPW;
MOV 0. X6 R3 ; 0.ADDR => W;
INE R4 R3 ; IF EXPW <> W THEN
JMPI S5 IDATFAULT ; DATAFAULT;
MOVC #CD R3 ; #CD => BYTE;
MOV R1 R5 ;
MODN BAS ;
MOVB R3 1. X5 ; BYTE => 1.BYTEADDR(ABS);
MOV RCDAB R4 ; #CDAB => EXPW;
MOV 0. X6 R3 ; 0.ADDR => W;
INE R4 R3 ; IF EXPW <> W THEN
JMPI S5 IDATFAULT ; DATAFAULT;
MOV R1 R5 ;
MODN BAS ;
MOVB 0. X5 R3 ; 0.BYTEADDR(ABS) => W;
MOVC #AB R4 ; #AB => EXPW;
INE R4 R3 ; IF EXPW <> W THEN
JMPI S5 IDATFAULT ; DATAFAULT;
MOV R1 R5 ;
MODN BAS ;
MOVB 1. X5 R3 ; 1.BYTEADDR(ABS) => W;
MOVC #CD R4 ; #CD => EXPW;
INE R4 R3 ; IF EXPW <> W THEN
JMPI S5 IDATFAULT ; DATAFAULT;
ADDC 1 R6 ; ADDR+1 => ADDR;
ADDC 2 R1 ; BYTEADDR+2 => BYTEADDR;
SOB R2 TEST9A ; END;
JMP NEWCOM ; GOTO NEWCOMMAND;
;###
;----------------------------------------------------------------------
TESTD: ; TEST DOUBLE ACCESS:
MOV SIZE R2 ;
IBN R2 15 ; IF 0.SIZE >= 32 K THEN
JMP ERROR ; GOTO ERROR;
JMPI S4 IOUTTXNL ; WRITE(TEXT);
<:DOUBLE ACCESS TEST<0>:> ;
JMPI S4 IOUTTXNL ; WRITE(TEXT);
<:RST: SUBBUS, CPU: MAINBUS<0>:>
MOVC LOCACP R0 ;
MOV R0 LOCACTION ;
IBZ R2 14 ; IF 0.SIZE < 16 K THEN
MODC #10 ; 16 => MODE ELSE
MOVC 0 R0 ; 0 => MODE;
TESTD1: ; NEWMODE:
MOV R0 SAVE10 ; SAVE(MODE);
JMPI S6 IWRWR ; TEST WRITEWRITE;
JMPI S6 IWRRE ; TEST WRITEREAD;
JMPI S6 IREWR ; TEST READWRITE;
JMPI S6 IRERE ; TEST READ READ;
MOV SAVE10 R0 ; RESTORE(MODE);
ADDC 2 R0 ; MODE+2 => MODE;
IBZ R0 7 ; IF MODE < 128 THEN
JMP TESTD1 ; GOTO NEWMODE;
JMP NEWCOM ; GOTO NEWCOMMAND;
;###
;----------------------------------------------------------------------
PAGEMODE: ; PAGEMODE TEST:
MOV SIZE R1 ; IF 0.SIZE = 16 K
IBZ R1 14 ; THEN
JMP ERROR ; GOTO ERROR;
JMPI S4 IOUTTXNL ; WRITE(TEXT);
<:BLOCKMODE TEST<0>:> ;
MOVC LOCACP R0 ;
MOV R0 LOCACTION ;
MOVC 1 R0 ; 1 =>
MOV R0 SAVE10 ; 0.MODE;
JMPI S6 IWRWR ; TEST WRITEWRITE;
JMPI S6 IWRRE ; TEST WRITEREAD;
JMPI S6 IREWR ; TEST READWRITE;
JMPI S6 IRERE ; TEST READREAD;
JMP NEWCOM ; GOTO NEWCOMMAND;
;----------------------------------------------------------------------
BLOCKTIME: ; BLOCKMODE TIMING TEST:
MOV SIZE R1 ; IF 0.SIZE
IBZ R1 14 ; <> 16 K THEN
JMP ERROR ; GOTO ERROR;
JMPI S4 IOUTTXNL ; WRITE(TEXT);
<:BLOCKMODE TIMING TEST<0>:>;
MOVC LOCACP R0 ;
MOV R0 LOCACTION ;
MOVC 1 R0 ; BLOCKMODE =>
MOV R0 SAVE10 ; 0.MODE;
JMPI S5 ISTARTW ; START RST WRITE;
BLKT0: ; TEST:
JMPI S6 ICHECKB ; IF BREAK FROM OC THEN
JMP BLKT1 ; GOTO STOP
NOP ;
JMP BLKT0 ; GOTO TEST;
JMPI S5 IREADTM ; READ ERRORS FROM RST;
JMP NEWCOM ; GOTO NEWCOMMAND;
;###
;----------------------------------------------------------------------
PARTDOUBLE: ; PART OF DOUBLE ACCESS TEST:
MOV SIZE R0 ; IF 0.SIZE
IBN R0 15 ; >= 32 K THEN
JMP ERROR ; GOTO ERROR;
MOVC LOCACP R0 ;
MOV R0 LOCACTION ;
JMPI S5 IINPAR ; INPARAMETER;
MODC 2 ; R: TEST MODULE READ;
MOVC 0 R4 ; W: TEST MODULE WRITE;
JMPI S5 IINPAR ; INPARAMETER;
ADDC 1 R4 ; R: CPU READ;
; W: CPU WRITE;
JMPI S5 IGETADR ; GET PAGE,PAUSE;
JMP ERROR ; ERROR: GOTO ERROR;
XTR R3 7 ;
MOV R3 SAVE10 ; SAVE(MODE);
JMP S6 PD1 ; SET RETURN ADDRESS;
JMP NEWCOM ; GOTO NEWCOMMAND;
PD1: ; SELECT TEST:
MOD R4 ;
JMP LOC+1 ;
JMPI IWRWR ;
JMPI IWRRE ;
JMPI IREWR ;
JMPI IRERE ;
;###
;----------------------------------------------------------------------
TESTCH: ; CHANGE ACCESS:
JMPI S4 IOUTTXNL ; WRITE(TEXT);
<:CHANGE BUS ACCESS: <0>:> ;
JMPI S6 IINCHAR ; INCHAR;
ADDC -<:N:> R1 ; IF CHAR <> <:N:>
JON R1 TESTCH ; THEN GOTO CHANGE ACCESS;
JMP ON ; GOTO NEW TEST;
;
;
TESTEND1: ; TESTEND:
JMPI S4 IOUTTXNL ; WRITE(TEXT);
<:RAM TEST END<0>:> ;
JMP INCOMMAND ; GOTO INCOMMAND;
;
;
TESTEND2: ; TEST END CATCH:
MOVC TESTNR R6 ; TESTNO => ADDR;
DEC 0. X6 ; 0.ADDR-1 => 0.ADDR;
JMP INCOMMAND ; GOTO INCOMMAND;
;
;
ON: ; NEW TEST:
MOVC TESTNR R6 ;
INC 0. X6 ; 0.TESTNO+1 => 0.TESTNO;
REP: ; SAME TEST:
MOD TESTNR ;
MOD TESTOFF ;
JMPI TESTS ; GOTO TEST(TESTNO,SIZE);
;###
;----------------------------------------------------------------------
;
; I / O C O M M A N D S
;
;----------------------------------------------------------------------
;DEVSET - SET DEVICE AND COMMAND
; CALL EXIT
;
;R0-R1 DESTROYED
;R2 DEVICE AND COMMAND
;R3 DEVICE
;R4 LINK LINK
;R5-R7 DESTROYED
DEVSET: ; SET DEVICECOMMAND;
JMPI S5 IGETADR ; GET COMMAND;
JMP ERR1 ; ERR1: GOTO ERROR;
SLL R3 6 ; COMMAND < 6
MOV DEVICE R2 ; + 0.DEVICE
ADD R3 R2 ; => DEVICE AND COMMAND;
JMP 0. X4 ; RETURN;
;INTTABLE - INITIATE INTERRUPT TABLE
; CALL EXIT
;
;R0-R2 DESTROYED
;R3 IBASE IBASE
;R4-R5 DESTROYED
;R6 LINK LINK
INTTABLE: ; SET INTERRUPT TABLE:
MOV R015C R0 ; #015C(JMP LOC) => INTADR;
MOV BAS R4 ;
MOV R0 R5 ; INTADR -
SUB R4 R5 ; 0.BASE => RELADR;
NEG R4 ;
MOVC 0 R1 ; 0 => PROCWORD;
MOVC 64 R2 ; FOR I:=1 UNTIL 64 DO
INTTABLE1: ; BEGIN
MOV R1 0. X4 ; PROCWORD => 0.(I-1-0.BASE);
MOV R3 0. X5 ; IBASE => 0.RELADR;
INCD R4 R5 ; RELADR+1 => RELADR;
SOB R2 INTTABLE1 ; END;
ADDC -64 R4 ; - 0.BASE => RELADR;
MOV R0 0. X4 ; JMP LOC => 0.RELADR;
MOV R0 1. X4 ; JMP LOC => 1.RELADR;
MOV R0 2. X4 ; JMP LOC => 2.RELADR;
MOV R0 3. X4 ; JMP LOC => 3.RELADR;
JMP 0. X6 ; RETURN;
;----------------------------------------------------------------------
;###
;----------------------------------------------------------------------
DEV: ; ENTER DEVICE NO:
JMPI S5 IGETADR ; GET DEVICE NO;
JMP ERR1 ; ERROR: GOTO ERR1;
XTR R3 6 ; DEVICE NO (5:6) =>
MOV R3 DEVICE ; 0.DEVICE;
JMP IO ; GOTO IOCOMMANDS;
;----------------------------------------------------------------------
SENSE: ; SENSE DEVICE:
JMP S4 DEVSET ; SET DEVICECOMMAND;
SIO R4 R2 ; GET CONTENT;
JMPI S5 IHEXOUT ; WRITE(CONTENT);
JMP IO ; GOTO IOCOMMANDS;
;----------------------------------------------------------------------
READ: ; READ DEVICE:
JMP S4 DEVSET ; SET DEVICECOMMAND;
RIO R4 R2 ; GET CONTENT;
JMPI S5 IHEXOUT ; WRITE(CONTENT);
JMP IO ; GOTO IOCOMMANDS;
;----------------------------------------------------------------------
CONTROL: ; CONTROL DEVICE:
JMP S4 DEVSET ; SET DEVICECOMMAND;
MOV R2 R4 ; SAVE (DEVICECOMMAND);
JMPI S5 IGETADR ; GET WORD;
JMP ERR1 ; ERROR: GOTO ERR1;
CIO R3 R4 ; WORD => *DEVICECOMMAND*;
JMP IO ; GOTO IOCOMMANDS;
;----------------------------------------------------------------------
WRITE: ; WRITE DEVICE:
JMP S4 DEVSET ; SET DEVICECOMMAND;
MOV R2 R4 ; SAVE(DEVICECOMMAND);
JMPI S5 IGETADR ; GET WORD;
JMP ERR1 ; ERROR: GOTO ERR1;
WIO R3 R4 ; WORD => *DEVICECOMMAND*;
JMP IO ; GOTO IOCOMMANDS;
;###
;----------------------------------------------------------------------
CONTSENSE1: ; CONTINUOUS SENSE, NO OUTPUT:
MODC 1 ;
CONTREAD1: ; CONTINUOUS READ, NO OUTPUT:
MODC 1 ;
CONTSENSE: ; CONTINUOUS SENSE:
MODC 1 ;
CONTREAD: ; CONTINUOUS READ:
MOVC 0 R0 ;
MOV R0 SAVE15 ;
JMP S4 DEVSET ; SET DEVICECOMMAND;
MOV R2 R3 ;
CTR1: ; WHILE NOT "BREAK" DO
; BEGIN
MOV SAVE15 R0 ; IF READ
IBZ R0 0 ; THEN
RIO R4 R3 ; READ DEVICE
IBN R0 0 ; ELSE
SIO R4 R3 ; SENSE DEVICE;
IBZP R0 1 ; IF OUTPUT THEN
; BEGIN
JMPI S5 INEXTLIN ; NEWLINE;
JMPI S5 IHEXOUT ; WRITE(WORD);
; END;
MOVC OC R0 ;
SIO R0 R0 ; SENSE OC;
IBZ R0 BPERR ;
JMP CTR1 ; END;
JMP IO ; GOTO IOCOMMANDS;
;----------------------------------------------------------------------
CONTCONTROL: ; CONTINUOUS CONTROL:
MODC 1 ;
CONTWRITE: ; CONTINUOUS WRITE:
MOVC 0 R0 ;
MOV R0 SAVE15 ;
JMP S4 DEVSET ; SET DEVICECOMMAND;
MOV R2 R4 ;
JMPI S5 IGETADR ; GET WORD;
JMP ERR1 ; ERROR: GOTO ERR1;
MOV SAVE15 R1 ;
CTW1: ; WHILE NOT "BREAK" DO
; BEGIN
IBZ R1 0 ; IF WRITE THEN
WIO R3 R4 ; WRITE(WORD,DEVICE)
IBN R1 0 ; ELSE
CIO R3 R4 ; CONTROL(WORD,DEVICE);
MOVC OC R0 ;
SIO R0 R0 ; SENSE OC;
IBZ R0 BPERR ;
JMP CTW1 ; END;
JMP IO ; GOTO IOCOMMANDS;
;###
;----------------------------------------------------------------------
ALLINT: ; GET ALL INTERRUPTS:
MOD BAS ;
DEVINT: ; GET INTERRUPT FROM DEVICE:
MOVC 0 R3 ;
INT3: ; WAIT:
JMP S6 INTTABLE ; SET INTERRUPT TABLE;
MOV BAS R0 ;
MOV R015C R5 ;
SUB R0 R5 ;
MOV R0 OC. X5 ; RESERVE INTERRUPT FROM OC;
MOD DEVICE ;
MOV R0 0. X5 ; RESERVE INTERRUPT FROM DEVICE;
SVP INT0 ;
MOVC 0 R0 ;
LDN R0 ; START INTERRUPT WAIT PROCESS;
INT0: ; REENTRY FROM INTERRUPT:
MOV DEVPR R2 ;
JOZ R2 INT3 ; IF INTERRUPT = TIMER THEN
; GOTO WAIT;
SRL R2 2 ;
INE R2 OC ; IF DEVICE = OC THEN
JMP INT1 ; BEGIN
SIO R0 R2 ; SENSE OC;
IBZ R0 BPERR ; IF NOT "BREAK" THEN
JMP INT3 ; GOTO WAIT;
SVP INT2 ; SAVE PROCESS FOR LOC. ACTION;
JMP IO ; GOTO IOCOMMANDS;
INT2: JMP START ;
INT1: ; END;
JMPI S4 IOUTTXNL ; WRITE (TEXT);
<:DEV<0>:> ;
MOV R2 R4 ;
JMPI S5 IHEXOUT ; WRITE(DEVICE);
JMPI S4 IOUTTEXT ; WRITE(TEXT);
<: P <0>:> ;
MOV DEVPR R1 ;
XTR R1 2 ;
ADDC <:0:> R1 ;
JMPI S6 IOUTCHAR ; WRITE(PRIORITY);
JMP INT3 ; GOTO WAIT;
;###
;----------------------------------------------------------------------
IO: ; IOCOMMANDS:
JMPI S4 IOUTTXNL ; WRITE(TEXT);
<:. <0>:> ;
IO1: ; COMM:
JMPI S6 IINCHAR ; INCHAR;
ADDC -<: :> R1 ;
JOZ R1 IO1 ; IF CHAR = <: :> THEN GOTO COMM;
SVP IO2 ; SAVE PROCESS FOR LOC. ACTION;
JMP IO3 ;
IO2: JMP IO ;
IO3: ;
ADDC -<:L:>+<: :> R1 ;
IEQ R1 <:D:>-<:L:>; D - SET DEVICE NO;
JMP DEV ;
IEQ R1 <:S:>-<:L:>; S - SENSE DEVICE;
JMP SENSE ;
IEQ R1 <:C:>-<:L:>; C - CONTROL DEVICE;
JMP CONTROL ;
IEQ R1 <:R:>-<:L:>; R - READ DEVICE;
JMP READ ;
IEQ R1 <:W:>-<:L:>; W - WRITE DEVICE;
JMP WRITE ;
IEQ R1 <:E:>-<:L:>; E - CONTINUOUS READ;
JMP CONTREAD ;
IEQ R1 <:F:>-<:L:>; F - CONTINUOUS SENSE;
JMP CONTSENSE ;
IEQ R1 <:H:>-<:L:>; H - CONT. READ, NO OUTPUT;
JMP CONTREAD1 ;
IEQ R1 <:I:>-<:L:>; I - CONT SENSE, NO OUTPUT;
JMP CONTSENSE1 ;
IEQ R1 <:L:>-<:L:>; L - CONTINUOUS WRITE;
JMP CONTWRITE ;
IEQ R1 <:M:>-<:L:>; M - CONTINUOUS CONTROL;
JMP CONTCONTROL;
IEQ R1 <:A:>-<:L:>; A - WAIT FOR ALL INTERRUPTS;
JMP ALLINT ;
IEQ R1 <:G:>-<:L:>; G - WAIT FOR DEVICE INTERR.
JMP DEVINT ;
IEQ R1 <:X:>-<:L:>; X - RETURN TO TESTS;
JMP START ;
;
ERR1: ; ERR1:
MOVC <:?:> R1 ;
JMPI S6 IOUTCHAR ; WRITE(<:?:>;
JMP IO ; GOTO IOCOMMANDS;
;###
;----------------------------------------------------------------------
;
; C O M M A N D D E C O D I N G
;
;----------------------------------------------------------------------
NEWCOM: ; NEWCOMMAND:
JMPI S4 IOUTTXNL ; WRITE(TEXT);
<:TEST END<0>:> ;
INCOMMAND: ; INCOMMAND:
START: ; START:
MOV BAS R4 ; GET BASE;
INIT: ; INIT:
MOVC OC R0 ;
MOVC 3 R1 ;
CIO R1 R0 ; ENABLE TERMINAL IF;
JMPI S5 INEXTLIN ; NEWLINE;
MOVC <:::> R1 ;
JMPI S6 IOUTCHAR ;
MOVC <: :> R1 ;
JMPI S6 IOUTCHAR ; OUTPUT (<:: :>);
;###
STR1: ; STR1:
JMPI S6 IINCHAR ; GET COMMAND;
ADDC -27 R1 ;
IEQ R1 27-27 ; ESC - MONITOR CONTROL;
JMP BOOT ;
IEQ R1 <: :>-27 ; SPACE - GOTO STR1;
JMP STR1 ;
ADDC 27-<:L:> R1 ;
IEQ R1 <:B:>-<:L:>; B - ENTER NEW BASE;
JMP ENTERBASE ;
IEQ R1 <:X:>-<:L:>; X - RUN PROGRAM;
JMP RUNPROG ;
SVP STR2 ; SAVE PROCESS;
JMP STR3 ;
STR2: JMP INIT ;
STR3: MOVC LOCACT R0 ; INSERT LOCAL ACTION ADDRESS;
MOV R0 LOCACTION ;
IEQ R1 <:R:>-<:L:>; R - INSERT REGISTER DUMP;
JMP INSERTREGS ;
IEQ R1 <:D:>-<:L:>; D - MEMORY DUMP;
JMP MEMDUMP ;
IEQ R1 <:L:>-<:L:>; L - MEMORY DUMP, NO PAR. CHECK;
JMP MLIST ;
IEQ R1 <:C:>-<:L:>; C - CONTINUE MEMORY DUMP;
JMP CMEMDUMP ;
IEQ R1 <:P:>-<:L:>; P - LOAD DATA;
JMP LOADDATA ;
IEQ R1 <:F:>-<:L:>; F - FILL RAM;
JMP FILL ;
IEQ R1 <:E:>-<:L:>; E - FILL RAM WITH ADDRESS;
JMP ADRFILL ;
IEQ R1 <:U:>-<:L:>; U - CHECK FOR ADDRESS;
JMP ADRCHECK ;
IEQ R1 <:S:>-<:L:>; S - SEARCH FOR DATA;
JMP SEARCH ;
IEQ R1 <:G:>-<:L:>; G - FIND DATA;
JMP FIND ;
IEQ R1 <:N:>-<:L:>; N - NEW TEST;
JMP ON ;
IEQ R1 <:V:>-<:L:>; V - SAME TEST AGAIN;
JMP REP ;
IEQ R1 <:Z:>-<:L:>; Z - START FROM TEST1;
JMP MCPT1 ;
IEQ R1 <:A:>-<:L:>; A - TEST DOUBLE ACCESS;
JMP TESTD ;
IEQ R1 <:M:>-<:L:>; M - BLOCKMODE TEST;
JMP PAGEMODE ;
IEQ R1 <:K:>-<:L:>; K - BLOCKMODE TIMING TEST;
JMP BLOCKTIME ;
IEQ R1 <:T:>-<:L:>; T - TIMEOUT TEST;
JMP TIMEOUT ;
IEQ R1 <:O:>-<:L:>; O - PART OF DOUBLE ACCESS;
JMP PARTDOUBLE ;
IEQ R1 <:I:>-<:L:>; I - I/O COMMANDS;
JMP IO ;
;
ERROR: ; ERROR:
MOVC <:?:> R1 ;
JMPI S6 IOUTCHAR ; OUTPUT <:?:>;
JMP START ; GOTO START; ;###
MCPT: ; AFTER MASTERCLEAR:
MOVC OC R0 ;
MOVC 3 R1 ;
CIO R1 R0 ; ENABLE INTERFACE;
SIO R1 R0 ; SENSE INTERFACE;
IBZ R1 BPERR ; IF NOT "BREAK" THEN
JMP MCPT ; GOTO AFTER MASTERCLEAR;
MCPT1: ; READY:
JMPI S4 IOUTTXNL ; WRITE(TEXT);
<:RAM TEST START, SIZE: <0>:>
JMPI S5 IGETADR ; GET SIZE;
JMP MCPTER ; ERROR: GOTO MCERR;
SLC R3 4 ;
IEQ R3 8 ;
JMP T32 ;
IEQ R3 4 ;
JMP T16 ;
IEQ R3 1 ;
JMP T04 ;
MCPTER: ; MCERR:
JMPI S4 IOUTTXNL ; WRITE(TEXT);
<:ILLEGAL<0>:> ;
JMP MCPT1 ;
T32: ; 32K RAM TEST:
MOVC #FF R2 ; #FF => TAD;
MOVC TEST32-TESTS R1 ; SET TEST;
MOV R1024 R0 ; SET COUNT;
JMP TX ; GOTO INIT TEST;
T16: ; 16K RAM TEST:
MOVC #7F R2 ; #7F => TAD;
MOVC TEST16-TESTS R1 ; SET TEST;
MOV R2048 R0 ; SET COUNT;
JMP TX ; GOTO INIT TEST;
T04: ; 4K RAM TEST:
MOVC #3F R2 ; #3F => TAD;
MOVC TEST04-TESTS R1 ; SET TEST
MOV R2000 R0 ; SET COUNT;
TX: ; INIT TEST:
SLC R3 12 ;
MOV R3 SIZE ; SET SIZE;
SRL R3 1 ;
MOV R3 SIZE2 ; SET HALF SIZE;
MOV R0 SIZE3 ; SET 0.COUNT;
SWP R3 ;
MOV R3 SIZE4 ;
MOV R2 TADR ; TAD => 0.TESTADR;
MOV R1 TESTOFF ; SET TEST;
MCPT2: ; START OF TEST:
JMPI S4 IOUTTXNL ; WRITE(TEXT);
<:RAM TEST READY<0>:> ;
MOVC 0 R0 ; 0 =>
MOV R0 TESTNR ; 0.TEST NO;
MOV BASEPOINTER R4 ; SET BASE IN R4;
JMP INIT ; GOTO INIT;
;###
IF LOC LT (#FFD0 - PRG1) THEN #FFFF,REPEAT #FFD0-PRG1-LOC
ELSE MESSAGE LOC FI
PBASE: 0, 0, 0, 0, BS1, 0, 0, 0
BS1, BS1, PRG1, INITP, 0, #E000, 0, LOCACT
MCPOINT:
0, 0, 0, BS1, 0, 0, 0, 0
BS1, BS1, PRG1, MCL, 0, #E000, 0, LOCACT
BOOTBASE:
#0118, #0001, #0001, #0000, #0001, #0001, #FFFF, #002A
#0000, #0000, #F590, #F6B5, #0000, #E000, EMACT, #FFFF
EMACT:= EMERGENCY+PRG1
BPRG1:= PRG1+PBASE
BBOOT:= PRG1+BOOTBASE
USE BASE
INITP:= INIT+PRG1
MCL:= MCPT+PRG1
END ;###
«eof»