|
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 - metrics - download
Length: 48640 (0xbe00)
Types: TextFile
Names: »AMUSRC«
└─⟦11f8993e7⟧ Bits:30005537 8" CR80 Floppy CR80FD_0244 ( foto )
└─⟦6247f461d⟧
└─⟦this⟧ »AMU.AMUSRC«
LIST; A M O S M A S T E R C L E A R U T I L I T I E S FR/791015
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; IDENTIFICATION: CSS/395/PGM
; VERSION: 01
; DATED: 791015/FR
;
; THE AMOS_MASTERCLEAR_UTILITIES PROGRAM (AMU) RESIDING IN THE UPPER
;2K_WORDS PROM OF MEMORY SECTION 0 WILL SERVE THE USER OF THE CR80 WITH
;A RANGE OF UTILITIES. THIS AIM NOT ONLY AT PROGRAMMERS BUT ALSO AT
;MAINTENANCE PERSONNEL.
; ONLY MEMORY LOCATIONS:
; #200-#221 INCL
;WILL BE DESTROYED UPON EITHER MASTER CLEAR OR EMERGENCY ACTION, THOUGH
;ONLY AS LONG AS THE USER RESTRICT HIMSELF TO THE FOLLOWING UTILITIES:
; COPY, DUMP, IO_UTILITIES, MEMORY_CHECK, PATCH, SEARCH
; XECUTE, SET_PARITY (,AND OPTIONS).
; HOWEVER THE AMU_PROGRAM WILL NEVER CLAIM BUT THE LOWER #247 WORDS OF
;MEMORY EXCEPT FOR THE CPU_TEST WHICH REQUIRES AN ADDITIONAL 4K_RAM
;STARTING AT #1000.
;THIS IMPLIES THAT FD_BOOT_FILES CAN HAVE THEIR LOADING ADDRESS (START)
;FROM #0248 AND UPWARDS. (CROSSING PAGE_BOUNDARIES DURING FD_LOAD WILL
;RESULT IN A PAGE SHIFT AND CONTINUATION FROM #0000 THAT PAGE).
;
; U S E R ' S M A N U A L
; -------------------------
;
;UTILITIES
;---------
;
; BOOT_LOAD:
; B F/X <DRIVE_NO> (F= FD, X= DMA)
; COPY_MEMORY:
; C* <SOURCE>[.<REL_OFFSET>][+<COUNT>] <OBJECT>[/<PAGE>]
; DUMP:
; D* <START_ADDRESS>[.<REL_OFFSET>] <END_ADDRESS>
; D* <START_ADDRESS>[.<REL_OFFSET>][+<NO_OF_WORDS>]
; IO:
; I S (<MOD_BY>) <DEV_ADDRESS>[+<REPEATS>]
; I R (<MOD_BY>) <DEV_ADDRESS>[+<REPEATS>]
; I C (<MOD_BY>) <DEV_ADDRESS>[+<REPEATS>] <OUTPUT_WORD>
; I B (<MOD_BY>) <DEV_ADDRESS>[+<REPEATS>] <OUTPUT_WORD>,....
; I W (<MOD_BY>) <DEV_ADDRESS>[+<REPEATS>] <OUTPUT_WORD>
; I V (<MOD_BY>) <DEV_ADDRESS>[+<REPEATS>] <OUTPUT_WORD>,....
; LOAD_FILE:
; L F/X <DRIVE_NO> (F= FD, X= DMA)
; MEMORY_CHECK:
; M* <START_ADDRESS>[.<REL_OFFSET>][+<NO_OF_WORDS>] [<PATTERN>]
; PATCH:
; P* <START_ADDRESS>[.<REL_OFFSET>] [<PATCH_DATA>]
; MULTI_PATCH:
; P* <START_ADDRESS>[.<REL_OFFSET>][+<NO_OF_WORDS>] <PATTERN>
; RETURN_CALLING_PROCESS:
; R
; SEARCH:
; S* <START_ADDRESS>[.<REL_OFFSET>][+<NO_OF_WORDS>] <PATTERN>
; TEST_CPU:
; T* <CPU_PROM_ADDRESS>
; UNIT_MAPPER:
; U
; WAIT_INTERRUPT:
; W [<DEVICE_ADDRESS>]
; XECUTE:
; X* <PROCESS_BASE_ADDRESS>
; SET_PARITY:
; Z
;
; SWITCH_CPU:
; Q <CPU_NO>
; OPTIONS:
; O
; PRINT_CONTROL
; LOOP_CONTROL (CPU TEST)
;
;
;
;LEGEND:
;-------
; BREAK
; BREAK FROM THE OPERATOR'S CONSOLE WILL IMMEDIATELY STOP ANY
; PRINT-OUT ON THE OC AND RETURN TO THE MAIN_LINE SELECTION MODE.
;
; MEMORY_SECTION
; IF A PAGE OTHER THAN PAGE 0 IS DESIRED, IT MUST FOLLOW IMMEDI-
; ATELY AFTER THE COMMAND, I.E.
; <COMMAND><PAGE> <....
; ONLY COMMANDS MARKED WITH '*' CAN HAVE PAGE SELECTION.
;
; <---> HEXADECIMAL DATA_WORD:
; AN ENTERED HEXADECIMAL DATA WORD CAN BE ANY COMBINATION OF
; HEXA-DECIMAL CHARACTERS. THOUGH ONLY THE LAST ENTERED FOUR ARE
; ACCEPTED. ZEROES WILL AUTOMATICALLY BE FILLED IN IF LESS THAN
; FOUR HEX CHARACTERS HAVE BEEN ENTERED.
; HEX DATA_WORDS ARE SEPARATED BY ANYTHING BUT '0123456789ABCDEF'
; AND CARRIAGE RETURN <CR>.
; <CR> FLAGS END_OF_DATA.
; <---><DEL> IMPLIES THAT THE ENTERED HEXADECIMAL (WORD (ONE) IS
; REJECTED.
; NOTE THAT +0 ALWAYS IS INTERPRETED AS 64K (ONE PAGE).
;
; [----] OPTIONAL FIELD.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; CPU TEST ;
; INSTRUCTION SET KERNEL
; ----------------------
; 0 - UNTIL TEXT TO BE WRITTEN ON OC
; 1 - DURING WRITE-OUT
; 2 - REST OF INITIALIZATION BEFORE '>'
; 3 ESSENTIAL TO CPU_TEST PROGRAMS
;
;MOV
; 0 MOVC [M] C[N]8 R3
; 1 MOV R3 R3
; 2 MOV B8 R3
; 0 MOV R3 B8
; 3 MOV B6.X2 R3
; 3 MOV R2 B6.X2
; 0 MOVL B6.X2 R22
; 0 MOVL R22 B6.X2
; 0 MOV P8 R3
; 1 MVP P6.X2 R2
;JUMP
; 1 JMP S2 L[N]8
; 0 JMP L[N]10
; 1 JMP B6.X2
; 1 JMPI B6
; 0 JMPI [S2] P6
; 0 SOB R3 LN8
;ARIT/LOG
; 0 ADDC C[N]8 R3
; 3 ADD R3 R3
; 3 SUB R3 R3
; 1 SBN/Z R3 C4
; 1 SBZP R3 C4
; 3 SLC R3 C4
; 1 XTR R3 C4
; 1 SWP R3
; 3 INE R3 R3
; 3 INE X3 X3
; 1 IEQ/INE R3 [M] C4
; 3 SHS/SLO R2 C4
;I/O
; 3 CIO R3 R3
; 1 SIO R3 R3
; 3 RIO R3 R3
; 1 WIO R3 R3
;SPECIAL
; 0 SVP L4
; 0 RESS X3 C4
; 2 SVS R3
; 3 LDS R3
;
;NOTE THIS PROGRAM INTERFACE THE CPU_TEST_PROGRAM CSM/100. IT ASSUMES:
; - THE CPU_TEST_PROGRAM STARTS WITH '#0158'='JMP LOC'
; - IT REPLACES THE FIRST LOCATION OF THE CPU_TEST
; 'JMP S4 OUTSTRING'
; WHEREUPON CONTROL IS LEFT OVER TO THE CPU_TEST,
; - THE KEY TO RE-INITIALIZATION IS MEM[B5555, BAAAA], WHICH ARE
; TO BE INITIALIZED PROPERLY BY THE CPU_TEST_PROGRAM,
; - NOTE THAT THE NAMES FILES BEING GENERATED BY THIS PROGRAM
; IS USED BY THE CPU_TEST_PROGRAM. THUS THESE ENTRIES MUST NOT
; BE CHANGED IN ORDER TO HAVE THE CPU_TEST WOTK PROPERLY.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
BEGIN MODULE CPUPROM
AREASWITCH= 1
FDSUPPORT= TRUE
CPUPROM= #F800
USE BASE
BIT0=0, BIT1=1, BIT2=2, BIT3=3, BIT4=4, BIT5=5, BIT6=6
BIT7=7, BIT8=8, BIT9=9, BIT10=10, BIT11=11, BIT12=12,
BIT13=13, BIT14=14, BIT15=15
; CPU_TEST_CONTROL_BLOCK LAY-OUT
LOC= 0 ; ------------------------------
CTCBID: LOC= LOC+1 ; IDENTIFICATION OF TEST
CTCBCNT:LOC= LOC+1 ; NUMBER OF DATA IN TEST RUN
CTCBRST:LOC= LOC+1 ; RESET VALUE (IF 0 THEN FIRST AREA COPIED)
CTCBDATA:LOC=LOC+1 ; DATA AREA:
; 1ST AREA (CNT) WORDS, EXPECTED DATA
; 2ND AREA, INPUT DATA AREA
;FF\f
; MEMORY LAY-OUT (ABS)
LOC= 0 ; --------------------
CPUMEM:
CPUIVT: LOC= LOC+4 ; INTERRUPT VECTOR TABLE INDEX - PRIORITY
CPUIVR: LOC= LOC+1 ; RESET BASE, INTERRUPT SERVE PROCESS
LOC= LOC+2 ;
CPUMSG: LOC= LOC+1 ; USED FOR "OTHER'S" MESSAGE (ADDREESS DUMMY)
CPUCPU: LOC= LOC+8 ; CPU MESSAGE AREA
LOC= LOC+#10 ;
CPUDUMMY: LOC= LOC+#1F ; BASE LOOSER'S DUMMY PROCESS.
; USED FOR SVP FROM OTHER CPUS UPON FIRST
; CPU_INTERRUPT;
LOC= LOC+1 ; SPECIAL MON_CALL CASE (0-63)
CPUMON: LOC= LOC+192 ; MONITOR TABLE (ABS PROGRAM ADDRESS
LOC= LOC+128 ; RESERVED PROGRAM AREA (MON 0-63)
CPUIVB: LOC= LOC+64 ; INTERRUPT VECTOR TABLE (PROCESS BASE)
LOC= LOC+32 ; BASE DUMMY INTERRUPT PROCESS
LOC= LOC+32 ;
CPUBASE: LOC= LOC+256 ; PROCESS AREA CPU TEST PROGRAM
CPUWORK: ; WORK AREA
MASTERCLEARBASE:=#FFE0 ;
; ASCII CHARACTERS
; ----------------
NIL= 0 ; NIL CHARACTER
LF= <:<10>:> ; LINE_FEED
CR= <:<13>:> ; CARRIAGE_RETURN
YES= <:Y:> ;
DEL= #7F ; DELETE
EOT= #FF ; END_OF_TEXT (PROCEDURE OUT_STRING)
;FF\f
; PROCESS DESCRIPTOR
LOC= 0 ; ------------------
XR0: ABSMCE50 ;
XR1: CPUDUMMY ;
XR2: 0-0 ;
XR3: CPUBASE ;
XR4: 0-0 ;
XR5: RELPROMBASE ;
XR6: 0-0
XR7: 0-0
XBASE: CPUBASE ; PROCESS BASE CPU TEST PROGRAM
XMOD: CPUBASE ; MODIFY REGISTER NORMAL STATE
XPROG: PROGRAMSTART ;
XPRPC: PROGRAMGO ;
XTIMER: #7FFF ; TIMER REGISTER
XPSW: #E000 ; PROGRAM STATUS WORD (PSW)
;******************* END OF PROCESS DESCRIPTOR *************************
XOLDPRC:MASTERCLEARBASE ; PROCESS LINK ADDRESS (ABS)
XLOCACT:LOCALACT ; LOCAL INTERRUPT ACTION PROCEDURE ADDRESS
XLOCRET:0-0 ; LOCAL INTER'T RETURN ADDRESS
XCAUSE: #FFFF ; CAUSE:
; 0 - LOCAL TIMER
; 1 - TRAP
; 2 - PARITY ERROR
; 3 - TIME OUT
XDEVICE:0-0 ; IF INTERRUPT THEN DEV_ADDR ELSE #FFFF
XTIMRS: #8000 ; FAST TIMER PRESET VALUE
XMONRET:0-0 ;
;NOTE THAT THE FD_UTILITIES USES 256 WORDS BELOW OWN BASE AS DEDICATED
; MEMORY BUFFER;
; WORK AREA
; ---------
PGMEVALUATE: ; TRUE => EVALUATE TEST RESULTS AND PRINT
; MISMATCHES ON THE OC.
PRINTOUT: TRUE ;
PGMLOOP: 0, 0 ; NO_OF_LOOPS_LEFT-1 (LONG_INTEGER);
;
TCBASE: #1000 ; START CPU_TEST PROGRAM (RAM_COPY)
;NOTE HAS TO BE WITHIN 32 K FROM "OWN" BASE.
XABS= (LOC+1-XR0)/2
ENDOFDATA:
;FF\f
SB12SV: LOC= LOC+1 ; DEDICATED SB1200 (WRITE_NEWLINE)
SB14SV: LOC= LOC+1 ; DEDICATED SB1400 (IN_HEXA)
SB15SV: LOC= LOC+1 ; DEDICATED SB1500 (WRITE_HEXA)
SB16SV: LOC= LOC+1 ; DEDICATED SB1600 (GET_ADDRESS)
SB17SV: LOC= LOC+2 ; DEDICATED SB1700 (SET_PARITY)
UT50SV: LOC= LOC+1 ;
UT13PATTERN: ; 2 (MEMORY_CHECK)
UT17SV: ; 1 (SEARCH)
UT20SV: ; 2 ((IO_UTILITIES)
LOC= LOC+2
;************** END OF DUMP/PATCH/SEARCH UTILITIES *******************
;
;CPU_TEST PROGRAMS
;-----------------
LOC= LOC+(#24-LOC)
TCREFWORK:
REFWORK: LOC= LOC+1 ; REFERENCE CPU_TEST PROGRAM WORK_AREA.
MAISV: LOC= LOC+2 ; DEDICATED MAIN LINE
B5555: LOC= LOC+1 ;
BAAAA: LOC= LOC+1 ;
CP06:
CP20INS:
CPWORK: LOC= LOC+4 ; WORK AREA FOR CPU_TEST PROGRAMS
CP46P: LOC= LOC+1 ;
CP46: LOC= LOC+1 ;
PGMNEXT:LOC= LOC+1 ; REF TABLE PGMPOOL - CURRENT TEST PGM REF
;
TCPOOL: ; REF(TEST_PROGRAM), REF(DATA_AREA)
LOC=0
TCPPROG: LOC= LOC+1 ;
TCPDATA: LOC= LOC+1 ;
LOC= LOC+TCPOOL
;
;FF\f
LOC=TCREFWORK
;FD_UTILITIES WORK
;-----------------
FDMEMBUF:= XR0-256 ; I/O BUFFER 256 POSITIONS BELOW OWN BASE
;
FDMODE: LOC= LOC+1 ; MODE_OF_OPERATION:
FD10SV: LOC= LOC+1 ; DEDICATED FD1000 (FD_BOOT)
; 'F'-'O' - FD
; 'X'-'O' REMOTE FD VIA DMA
FD10DRV: LOC= LOC+1 ; FD DRIVE_NO (0-3)
FDZERO: ;
FDTRACK: LOC= LOC+1 ; CURRENT TRACK POSITION OF FD_HEAD
FD20SV: LOC= LOC+1 ; DEDICATED FD2000 (FD_READ_BLOCK)
FD20CTL: LOC= LOC+1 ;
FD30SV: LOC= LOC+1 ; DEDICATED FD3000 (FD_TRANSFER)
FDRECOUNT: LOC= LOC+1 ; NO OF RESTORE_ATTEMPTS ON FD (<16).
;
FDCLOAD: LOC= LOC+1 ; CURRENT LOAD ADDRESS (OUTPUT_AREA)
FDCPAGE: LOC= LOC+1 ; CURRENT MEMORY SECTION
;
FDBLOCKNO: LOC= LOC+1 ; CURRENT BLOCK NO
;
FDAREAS=10 ; MAX AREAS PER FILE
FDBENTRY: ; FD BOOT_FILE DIR ENTRY
LOC= 0
FDAREASIZE: LOC= LOC+1 ; AREA_SIZE
FDSECTORS: LOC= LOC+1 ; SECTORS PER BLOCK
FDHIBLOCK: LOC= LOC+1 ; HIGHEST BLOCK ALLOCATED
FDBLOCKS: LOC= LOC+1 ; BLOCKING_FACTOR: BLOCKS PER AREA
FDAREA: LOC= LOC+FDAREAS; 1ST AREA ADDRESS (-1 IF NON-ALLOCATED)
FDLOAD: LOC= LOC+1 ; FIRST ADDRESS (LOAD ADDRESS)
FDPAGE: LOC= LOC+1 ; MEMORY SECTION (PAGE)
FDBASE: LOC= LOC+1 ; BASE ADDRESS
FDCOUNT: LOC= LOC+1 ; WORD COUNT OF FILE
FDCHECKSUM: LOC= LOC+1 ; CHECKSUM OF BOOT FILE
FDCHECK: LOC= LOC+1 ; CHECK_SUM OF DIRECTORY ENTRY
FDENTRYLENGTH: ;
LOC= FDBENTRY+FDAREA+1
FDDIRBUF: LOC= LOC+FDENTRYLENGTH
FDEND: ;
;******************* END OF DESTROYED AREA *****************************
LOC= ENDOFDATA
;FF\f
USE PROG
PROGSTART:
;CPU_TEST PROGRAM CONSTANTS
MODC -1
P5555: #5555 ;
PAAAA: #AAAA ;
;
MAINLINE: MAINLOOP ; RETURN LINK FROM CPU_TEST SEQUENCES.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; OC AV24 CHARACTERISTICS
;;;;;;;;;;;;;;;;;;;;;;;;;;
OCIRDY:= 10 ; OC INPUT READY
OCORDY:= 11 ; OC OUTPUT READY
OCBREAK:= 13 ;
OCPARITY:= 14 ;
OCENB:= 3 ; ENABLE (USED BY CIO)
OC= 1 ;
OCADR: OC ; ADDRESS OF OPERATOR'S CONSOLE (OC)
;
FD= 2
FDADR: FD ; DISKETTE (DEFAULT) IO ADDRESS
DMAADR: 7 ; DMA IO ADDRESS
DISKADR: 0-0 ;
SB16PAGE: #E000, #E004, #E008, #E00C
MSEC: 500 ;
;FF\f
;SUBROUTINES:
BREAKCHECK: SB1350 ; BREAK_CHECK R:(LINK/LINK+1);
COPY: SB1900 ; COPY I:(SOURCE, OBJECT);
GETADDRESS: SB1600 ; GET_ADDRESS O:(REF(LOWER, UPPER));
GETHEXA: SB1400 ; GET_HEXADECIMAL O:(DELIMITER, BINARY);
INCHAR: SB1100 ; READ_SINGLE_CHAR O:(CHAR);
OUTCHAR: SB1250 ; WRITE_SINGLE_CHAR I:(CHAR);
OUTHEXA: SB1500 ; WRITE_HEXADECIMAL U:(BINARY);
OUTNL: SB1200 ; WRITE_NEWLINE;
OUTSTRING: SB1300 ; OUT_STRING I:(REF(STRING));
SETPARITY: SB1700 ;
;
UTILITIES: UT5000 ;UTILITIES:
COPYMEMORY: UT1900 ;
DUMP: UT1500 ;
IO: UT2000 ;
MEMCHECK: UT1300 ;
OPTIONS: OPT00 ;
PATCH: UT1600 ;
SWITCHCPU: UT2800 ; Q
RETURNCALLER:MCE90 ;
SEARCH: UT1700 ;
TESTCPU: TEC00 ;
UNITS: UT2900 ;
WAITINTERRUPT:UT2500 ;
XECUTE: UT1800 ;
;
ERROR: UT5090 ;
NOLIST IF FDSUPPORT THEN LIST
BOOTLOAD: UT3000 ;
LOADFILE: UT3100 ;
FDBLOAD: FD1000 ;
FDREADBLOCK:FD2000 ; FD_READ_BLOCK I:(REF(DIR_ENTRY));
FDWAITCMDCOMPLETE:
FDTRANSFER: FD3000 ; FD_TRANSFER I:(REF(BUFFER));
FDCOPY: FD3100 ; FD_MEM_COPY
FDCONTROL: FD3500 ; FD_CONTROL_IO I:(COMMAND);
NOLIST ELSE LIST
BOOTLOAD:= ERROR ;
LOADFILE:= ERROR ;
NOLIST FI LIST
0, REPEAT (#30-LOC)
;FF\f
; C O M M O N L O C A L A C T I O N
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE SERVE_LOCAL_INTERRUPT;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
LOCALACT: ;NORMAL_LOCAL_ACTION:
SVP ;
MOV XLOCRET R0 ; GET CAUSING POSITION;
MOVC #FFFF R2 ; PRESET CAUSE_VALUE;
MOVC XCAUSE R7 ;
XCH X7 R2 ; GET CAUSE AND RESET FIELD;
MOVC XPSW R7 ; POINT PROCESS_PSW;
RELS X7 BIT11 ; RESET LOCAL_INTERRUPT FLAG;
;
JMP LOC10 ;***BY-PASS LOCAL TIMER_INTERRUPT***
SNE R2 0 ; IT .NOT. TIMER_INTERRUPT
JMP LOC40 ; THEN
LOC10: MOV XPSW R7 ;
SETS R7 BIT15 ; DISABLE TIMER_INTERRUPTS;
LDS R7 ; RE-ESTABLISH PSW;
JMPI S4 OUTSTRING, <:<13>LOCAL INTERRUPT, CAUSE=:>, EOT
JMPI S6 OUTHEXA ;
JMPI S6 UTILITIES ;
;RETURN:
JMPI S6 GETHEXA ; GET REUTNR_OFFSET;
MOV XLOCRET R0 ;
ADD R2 R0 ; COMPUTE NEW START LOCATION
LOC40: ;RETURN_CAUSING_LOCATION:
MOVC XBASE R4 ; POINT "OWN" BASE;
ADD XPROG-XBASE.X4 R0 ; ADJUST WAKE-UP LOCATION;
MOV R0 XPRPC ;
LDN X4 ; RETURN INTERRUPTED LOCATION;
;///////////////////////////////////;
;FF\f
; E M E R G E N C Y A C T I O N E N T R Y P O I N T
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
EMERGENCY:
SVP ;
MOVC #E000 R0 ; FORCE
LDS R0 ; MEMORY SECTION 0;
MODN XBASE
MOVC MASTERCLEARBASE R4 ; POINT PROMMED AMU_BASE;
MOV XBASE. X4 R6 ; GET BASE THAT PROCESS;
MOV XBASE R0 ;
SUB R0 R6 ; SET-UP POINTER TO RAM_BASE;
MOVM X4 X6 ; CREATE
MOVM X4 X6 ; AMU_PROCESS;
ADDC -2*16 R6 ; POINT START PROCESS_DESCRIPTOR;
MOVC LOC50 R0 ;
ADD XPROG. X6 R0 ; COMPUTE START_ADDRESS;
MOV R0 XPRPC. X6 ;
MOV XBASE. X6 R7 ; GET BASE RAM_RESIDENT AMU_PROC;
LDP R7 ; LEAVE CAUSING PROCESS
;*** BY ACTIVATING AMU_PROCESS;
;************** ENTRY POINT UPON EMERGENCY WAKE UP *********************
LOC50: ;ENTRY_POINT FROM EMERGENCY:
JMPI S4 OUTSTRING, <:<13>EMERGENCY ACTION BY :>, EOT
MOV XOLDPRC R2 ; GET CAUSING PROCESS_BASE;
JMPI S6 OUTHEXA ;
LOC90: JMPI S6 UTILITIES ; ACTIVATE UTILITIES;
JMP LOC90 ; ENSURE NO RETURN;
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE READ_CHAR O:(CHAR);
; R0 - CHAR (LEAST SIGN 8 BITS)
; R6 LINK KEPT
; R7 - DESTROYED
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;IN_CHAR:
SB1100: ; REPEAT
MOV OCADR R7 ; GET DEVICE ADDRESS
MOVC OCENB R0 ;
CIO R0 R7 ; ENABLE OC;
SIO R0 R7 ; GET STATUS OF OC-DEVICE;
SBN R0 OCIRDY ; UNTIL INPUT_FLAG HIGH;
JMP SB1100 ;
RIO R0 R7 ; GET CHAR FROM OC;
XTR R0 7 ; ISOLATE CHAR, REMOVE PARITY;
;
JMP SB1250 ; ECHOE CHARACTER;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE NEW_LINE;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
SB1200: ;WRITE_NEWLINE:
MOVC CR R0 ;
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE WRITE_SINGLE_CHAR I:(CHAR);
; R0 CHAR KEPT
; R6 LINK KEPT
; R7 - DESTROYED
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;OUT_CHAR:
SB1250: ; REPEAT
MOV OCADR R7 ; GET DEVICE ADDRESS;
SIO R7 R7 ; SENSE(STATUS, DEVICE);
IBNP R7 OCBREAK ; IF FRAMING ERROR
IBN & R7 OCIRDY ; .AND. INPUT_READY
JMP & UT5010 ;*** THEN BREAK-POINT;
SBN R7 OCORDY ; UNTIL OUTPUT_FLAG=READY
JMP SB1250 ;
;
MOV OCADR R7 ; RE-ESTABLISH DEVICE ADDRESS
WIO R0 R7 ; WRITE ON OC;
MOV R0 R7 ;
XTR R7 8 ; ISOLATE CHAR;
INE R7 CR ; IF NOT CARRIAGE_RETURN
; THEN
JMP X6 ; RETURN
; ELSE
MOV R6 SB12SV ; ESTABLISH RETURN LINK;
ADDC LF-CR R0 ;
JMP S6 SB1250 ; OUT_CHAR (<LF>);
ADDC NIL-LF R0 ;
JMP S6 SB1250 ; OUT_CHAR (<NIL>);
JMP S6 SB1250 ; OUT_CHAR (<NIL>);
JMP S6 SB1250 ; OUT_CHAR (<NIL>);
JMP S6 SB1250 ; OUT_CHAR (<NIL>);
JMP S6 SB1250 ; OUT_CHAR (<NIL>);
ADDC CR-NIL R0 ;
JMPI SB12SV ; RETURN CALLER;
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE WRITE_STRING I:(REF(STRING));
; R1-3,5 - KEPT
; R4 LINK DESTROYED
; R0,6,7 - DESTROYED
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;OUT_STRING:
SB1300: ; REPEAT
MVP 0. X4 R0 ; GET NEXT SET OF CHARS
IEQ R0 EOT ; IF END_OF_TEXT
JMP 1. X4 ; THEN RETURN CALLER;
JMPI S6 OUTCHAR ; WRITE_CHAR (CHAR);
SWP R0 ; POSITION 2ND CHAR;
JMPI S6 OUTCHAR ; WRITE_CHAR (CHAR);
ADDC 1 R4 ; ADJUST POINTER;
JMP SB1300 ; UNTIL END_OF_TEXT;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE BREAK_CHECK R:(LINK/LINK+1);
;
; R0-5 - KEPT
; R6 LINK KEPT
; R7 - STATUS OF OC
; RETURN:
; LINK BREAK DETECTED
; LINK+1 NO BREAK DETECTED
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
SB1350: ;BREAK_CHECK:
MOV OCADR R7 ; GET DEVICE ADDRESS;
SIO R7 R7 ; SENSE(STATUS, DEVICE);
SBZ R7 OCBREAK ; IF FRAMING ERROR
SBN R7 OCIRDY ; .AND. INPUT READY
JMP 1. X6 ; THEN
MOV OCADR R7 ; GET DEVICE ADDRESS
RIO R7 R7 ; READ ERRONEOUS CHAR;
JMP 0. X6 ; END;
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; MEMORY_CHECK UTILITY
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
UT1300: ;MEMORY:
MOV P5555 R0 ; INITIALIZE TEST PATTERN
MOV R0 UT13PATTERN ;
MOV PAAAA R0 ;
MOV R0 UT13PATTERN+1
JMPI S6 GETADDRESS ; GET START_ADDRESS;
SNE R0 CR ; IF PATTERN
JMP UT1310 ; THEN
JMPI S6 GETHEXA ; GET PATTERN
MOV R2 UT13PATTERN
INE R0 CR ; IF 2ND PATTERN_PARAM
JMPI S6 GETHEXA ; GET 2ND PATTERN;
MOV R2 UT13PATTERN+1
UT1310: ; END GETTING PARAMETERS;
MOV R3 R6 ;
MOVC UT1350 R0 ;*
MOV R0 XLOCACT ; REPLACE TO LOCAL ACTION PROCESS;
UT1320: ; REPEAT
MOV UT13PATTERN R0 ; GET TEST PATTERN;
MOV UT13PATTERN+1 R1 ;
MOV XPROG R2 ; GET OWN PROG_ADDRESS;
MODN XBASE
ADDC UT1330 R2 ;* COMPUTE BASE_REL OFFSET;
SVS R7 ; SAVE OWN PSW;
LDS R4 ; SWITCH TO OTHER PAGE
SHS R5 R2 ; IF UPPER PART OF MEMORY
JMP UT1335 ; THEN
MOVL 0. X5 R23 ; SAVE CONTENT DURING TEST;
MOVL R01 0. X5 ; INSERT TEST PATTERN;
MOVC 4096/2 R0 ; REPEAT
SOB R0 LOC ; UNTIL 2-4 MSEC ELAPSED;
MOVL 0. X5 R01 ; GET PATTERN FROM RAM;
MOVL R23 0. X5 ; RE-ESTABLISH CONTENT;
JMP UT1340 ; ELSE
UT1330: NOP ;
UT1335: MOVL 0. X5 R23 ; SAVE CONTENT DURING TEST;
MOVL R01 0. X5 ; INSERT TEST PATTERN;
MOVC 4096/2 R0 ; REPEAT
SOB R0 LOC ; UNTIL 2-4 MSEC ELAPSED;
MOVL 0. X5 R01 ; GET PATTERN FROM RAM;
MOVL R23 0. X5 ; RE-ESTABLISH CONTENT;
UT1340: ; END PERFORMING TEST;
LDS R7 ; RETURN OWN PAGE;
MOV UT13PATTERN R2 ;
MOV UT13PATTERN+1 R3 ;
SNEP R0 R2 ; IF MISMATCH IN 1ST
SNE R1 R3 ; .OR. 2ND WORD
JMP UT1390 ;
UT1350: ; .OR. LOCAL_INTERRUPT
; THEN
LDS R7 ; RESET LOCAL_INT'PT FLAG;
MOV PRINTOUT R2 ;
SEQ R2 TRUE ; IF PRINT_OUT
JMP UT1390 ; THEN
SVP ; SAVE REGISTERS DURING PRINT;
MOVC XCAUSE R2 ;
IEQ X2 -1 ; IF LOCAL INTERRUPT
JMP UT1370 ; THEN
SEQP X2 2 ; IF PARITY_ERROR
SEQ X2 3 ; .OR. TIME-OUT
JMP LOCALACT ; THEN
MOVC -1 R0 ;
XCH R0 X2 ;
SEQ R0 2 ;
JMP UT1360 ;
JMPI S4 OUTSTRING, <:PARITY ERROR:>, EOT
JMP UT1380 ;
UT1360: ;
JMPI S4 OUTSTRING, <:TIME-OUT:>, EOT
JMP UT1380 ;
UT1370: ; ELSE
JMPI S4 OUTSTRING, <:MISMATCH:>, EOT
UT1380: ;
JMPI S4 OUTSTRING, <: AT :>, EOT
MOV XBASE R2 ;
ADD R5 R2 ;
JMPI S6 OUTHEXA ;
JMPI S6 OUTNL ;
MOVC XR0 R7 ; POINT TOP SAVED REG_STACK;
UNS 6 ; RE-ESTABLISH REGS CONTENT;
UT1390: ; END SERVING MISMATCH;
ADDC 2 R5 ; ADJUST POINTER NEXT SEQUENCE;
ADDC -1 R6 ;
INE R6 0 ;
SOB R6 UT1320 ; UNTIL WHOLE MEMORY AREA CHECKED;
JMP UT5020 ; RETURN UTILITIES_MAIN_LINE;
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE GET_HEXADECIMAL O:(DELIMITER, BINARY_NUMBER);
;
; R0 - LAST ENTERED CHARACTER (DELIMITER)
; R1 - TRUE IF DATA ENTERED ELSE FALSE
; R2 - ENTERED BINARY_NUMBER (DEFAULT 0)
; R3-5 - KEPT
; R6 LINK DESTROYED
; R7 - DESTROYED
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
SB1400: ;GET_HEXA:
MOV R6 SB14SV ; SAVE LINK;
MOVC FALSE R1 ; RISE NO_HEXA_YET FLAG;
MOVC 0 R2 ; RESET VALUE;
SB1410: ; REPEAT
JMPI S6 INCHAR ; GET NEXT CHARACTER;
SEQ R0 DEL ; IF CHAR = 'DELETE'
JMP SB1450 ; THEN
MOVC <:*:> R0 ;
JMPI S6 OUTCHAR ; FLAG DELETED;
JMP SB1400+1 ; ALLOWE RE-ENTERING DATA;
SB1450: ; ELSE
MOV R0 R6 ;
ADDC -(1+<:9:>) R6 ;
SHS R6 <:A:>-(1+<:9:>); IF .NOT. '9' < CHAR < 'A'
JMP SB1490 ; THEN
ADDC (1+<:9:>)+10-<:A:> R6 ; ADJUST AS IF 'A'-'F';
ILT R6 10 ; IF CHAR < <:A:>
ADDC -(10-<:A:>)-<:0:> R6 ; ADJUST AS IF '0'-'9';
IHS R6 16 ; ENSURE '0' <= CHAR <= 'F';
JMP SB1490 ; END GETTING VALID HEXA;
SLL R2 4 ; INSERT
ADD R6 R2 ; NEWLY HEXA;
MOVC TRUE R1 ; FLAG HEX CHAR ENTERED;
JMP SB1410 ;
SB1490: ; UNTIL SEPARATOR MET;
INEP R0 CR ;
INE R1 TRUE ;
JMP SB1410 ;
JMPI SB14SV ; RETURN CALLER;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE WRITE_HEXADECIMAL I:(BINARY );
;
; R0-1,7 - DESTROYED
; R2 BINARY KEPT
; R3-5 - KEPT
; R6 LINK DESTROYED
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
SB1500: ;WRITE_HEXA:
MOV R6 SB15SV ; ESTABLISH RETURN LINK;
MOVC 4 R1 ; FOR I:=1 UNTIL 4
SB1510: ; DO
SLC R2 4 ; POSITION LEFT-MOST 4-BIT;
MOV R2 R0 ;
XTR R0 4 ; ISOLATE PATTERN;
IGE R0 10 ; IF ABOVE 10
ADDC <:A:>-<:0:>-10 R0 ; THEN ADJUST;
ADDC <:0:> R0 ; MAKE HEXADECIMAL
JMPI S6 OUTCHAR ; WRITE_SINGLE_CHAR (CHAR);
SOB R1 SB1510 ; END FOR_UNTIL;
MOVC <: :> R0 ; FORCE SPACE BETWEEN WORDS;
JMPI S6 OUTCHAR ;
JMPI SB15SV ; RETURN CALLER;
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE GET_ADDRESS
;
; R0-2,7 - DESTROYED
; R3 - '+'-FIELD (DEFAULT 1)
; R4 - PSW FOR SPECIFIED PAGE (DEFAULT 0)
; R5 - REF(FIRST_ADDRESS)
; R6 LINK DESTROYED
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
SB1600: ;GET_ADDRESS:
MOV R6 SB16SV ;
JMPI S6 INCHAR ; GET PAGE (IF ANY)
ADDC 0-<:0:> R0 ; MAKE DECIMAL
SHS R0 4 ; IF -1 < PAGE < 4
MOD R0 ; THEN ADJUST FOR PAGE:
MOV SB16PAGE R4 ; GET MASKED PSW WITH PAGE BITS;
;
JMPI S6 GETHEXA ; GET START ADDRESS;
MOV R2 R5 ;
SUB XBASE R5 ; COMPENSATE OWN BASE;
MOVC 0 R2 ;
IEQ R0 <:.:> ; IF OFF_SET DESIRED
JMPI S6 GETHEXA ; THEN
ADD R2 R5 ; ADJUST START_ADDRESS;
MOVC 1 R2 ; PRESET OPTIONAL '+'-FIELD;
IEQ R0 <:+:> ; IF '+'-FIELD
JMPI S6 GETHEXA ; THEN GET VALUE;
MOV R2 R3 ; SET UP LOOP_CONTROL;
JMPI SB16SV ; RETURN CALLER
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE SET_PARITY
;
; R0-5,7 - DESTROYED
; R6 LINK DESTROYED
;
; NOTE - OWN BASE HAS TO BE MULTIPLA 512.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
SB1700: ;SET_PARITY:
MOV R6 SB17SV ;
MOV R6 SB17SV+1 ; RESET PARITY ERROR FLAG;
JMP S4 SB1710 ; BY-PASS LOCAL INTERRUPT ROUTINE;
;-----------------------------------;LOCAL_INTERRUPT:
LDS R7 ; RESET BIT_11 (LOCAL INTERRUPT)
MOV XCAUSE R1 ; GET INTERRUPTING CAUSE;
SEQ R1 2 ; IF PARITY ERROR
JMP SB1705 ; THEN
MOV R1 SB17SV+1 ;
LDS R6 ;
JMP SB1750 ; RETURN MAIN LINE FROM INTER'T;
SB1705: ; END SERVING PARITY_ERROR;
IEQ R1 3 ; IF TIME_OUT
JMP SB1760 ; THEN CONTINUE NEXT SECTION;
JMP LOCALACT ; CAUSE NEITHER 2/3
;
;-----------------------------------;
SB1710: ;
MOV R4 XLOCACT ; SET-UP OWN LOCAL_ACTION;
;
MOVC 4 R2 ; FOR I:=0 UNTIL PAGE 3
SB1720: ; DO
MOD R2
MOV SB16PAGE-1 R6 ; GET CURRENT PSW;
MOVC 128 R3 ; FOR I:=1 UNTIL 128 BLOCKS
SVS R7 ; DO
SB1730: MOV R3 R5 ;
SLL R5 9 ; ESTABLISH CORRECT START;
MOVC 512 R4 ; FOR I:=1 UNTIL 512 WORDS
LDS R6 ; DO
SB1740: MOV 0. X5 R0 ; RE-ESTABLISH
SB1750: MOV R0 0. X5 ; PARITY;
ADDC 1 R5 ; ADJUST POINTER;
SOB R4 SB1740 ; UNTIL ALL 1024 WORDS DONE;
SB1760: SOB R3 SB1730 ; UNTIL ALL 64 MODULES DONE;
LDS R7 ; RETURN "OWN" PAGE;
SOB R2 SB1720 ; UNTIL ALL PAGES DONE;
MOVC LOCALACT R0 ;
MOV R0 XLOCACT ; RE-ESTABLISH;
MOV SB17SV+1 R0 ;
SEQ R0 2 ; IF PARITY ERROR
JMPI SB17SV ; THEN
JMPI S4 OUTSTRING, <:, MEM PARITY ERROR:>, EOT;
JMPI SB17SV ; RETURN CALLER;
;
;FF\f
; U T I L I T I E S
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; DUMP_UTILITY
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
UT1500: ;DUMP:
JMPI S6 GETADDRESS ; GET START_ADDRESS, NO_OF WORDS;
ADD R5 R3 ; COMPUTE ENDING ADDRESS;
IEQ R0 CR ; IF END_ADDRESS
JMP UT1520 ; THEN
JMPI S6 GETHEXA ; GET ENDING ADDRESS
MOV R2 R3 ;
MODN XBASE
ADDC 1 R3 ; MAKE REL "OWN" BASE;
UT1520: ; END SERVING END_ADDRESS;
SRL R5 4 ;
SLL R5 4 ; ROUND START ADDRESS;
SUB R5 R3 ; FOR I:=1 UNTIL NO_OF_WORDS
UT1540: ; DO
MOV R5 R0 ;
XTR R0 3 ; COMPUTE MODULO 8;
IEQP R0 8 ; IF (ADDRESS MOD 8) .EQ. 8
MOVC <: :> R0 ; THEN
JMPI S6 OUTCHAR ; INSERT XTRA SPACE;
JON R0 UT1580 ; IF (ADDRESS MOD 16) .EQ. 0
JMPI S6 OUTNL ; WRITE_NEWLINE;
MOV XBASE R2 ;
ADD R5 R2 ; COMPUTE ADDRESS NEXT DUMP;
JMPI S6 OUTHEXA ; WRITE_HEXADECIMAL (ADDRESS)
UT1580: ; END IF NEW LINE;
SVS R7 ; SAVE OWN PSW;
LDS R4 ; SWITH TO RELEVANT PAGE;
MOV 0. X5 R2 ; GET NEXT WORD
LDS R7 ; RE-ESTABLISH OWN PSW;
JMPI S6 OUTHEXA ; WRITEN
ADDC 1 R5 ; ADJUST POINTER;
SOB R3 UT1540 ; END FOR_UNTIL;
JMP UT5010 ; RETURN UTILITIES_MAIN_LINE;
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PATCH_UTILITY
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
UT1600: ;PATCH:
JMPI S6 GETADDRESS ; GET START_ADDRESS, NO_OF WORDS;
IEQ R3 1 ; IF MULTIPATCH
JMP UT1660 ; THEN
JMPI S6 GETHEXA ; GET_HEXA (PATCH_PATTERN);
UT1620: ; FOR I:=1 UNTIL COUNT
SVS R7 ; SAVE OWN PSW;
LDS R4 ; SWITH TO RELEVANT PAGE;
IEQ R1 TRUE ; IF VALID PATCH DATA
MOV R2 0. X5 ; PATCH;
LDS R7 ; RE-ESTABLISH OWN PSW;
ADDC 1 R5 ; ADJUST POINTER;
SOB R3 UT1620 ; END MULTI-PATCH LOOP;
JMP UT1690 ; ELSE
UT1650: ; REPEAT
JMPI S6 GETHEXA ; GET NEXT PATCH VALUE
SVS R7 ; SAVE OWN PSW;
LDS R4 ; SWITH TO RELEVANT PAGE;
IEQ R1 TRUE ; IF PATCH DATA
MOV R2 0. X5 ; REPLACE OLD VALUE;
LDS R7 ; RE-ESTABLISH OWN PSW;
ADDC 1 R5 ; ADJUST POINTER;
UT1660: INE R0 CR ;
JMP UT1650 ; UNTIL LAST_CHAR .EQ. CR/NL;
UT1690: JMP UT5020 ; RETURN UTILITIES_MAIN_LINE;
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; SEARCH_UTILITY
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
UT1700: ;
JMPI S6 GETADDRESS ; GET START_ADDRESS, NO_OF WORDS;
JMPI S6 GETHEXA ; GET SEARCH PARAMETER;
UT1720: ; REPEAT
SVS R7 ; SAVE OWN PSW;
LDS R4 ; SWITH TO RELEVANT PAGE;
SEQP X5 R2 ; IF MATCH
LDS R7 ; RE-ESTABLISH OWN PAGE;
JMP UT1740 ; THEN
LDS R7 ; RE-ESTABLISH OWN PSW;
SVP ; SAVE REGISTERS DURING PRINT-OUT;
JMPI S4 OUTSTRING, <:MATCH AT :>, EOT
MOV XBASE R2 ;
ADD R5 R2 ; COMPUTE PATTERN_ADDRESS;
JMPI S6 OUTHEXA ;
JMPI S6 OUTNL ;
MOVC XR0 R7 ; POINT TOP REG_STACK (PROC_DESC);
UNS 6 ;
UT1740: ; END SERVING MATCH;
ADDC 1 R5 ; ADJUST POINTER
SOB R3 UT1720 ; UNTIL FILE END
JMP UT5020 ; RETURN UTILITIES_MAIN_LINE;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; XECUTE_UTILITY
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
UT1800: ;
JMPI S6 GETADDRESS ; GET PAGE/BASE OF PROCESS
ADD XBASE R5 ; COMPUTE BASE_ADDRESS;
LDS R4 ; SWITCH TO RELEVANT PAGE;
LDN R5 ; ACTIVETE PROCESS
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; COPY
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
UT1900: ;COPY_MOMORY
JMPI S6 GETADDRESS ; GET PAGE/SOURCE_ADDRESS/COUNT
JMPI S6 GETHEXA ; GET OBJECT_ADDRESS
SUB XBASE R2 ; ADJUST FOR OWN BASE
IEQ R0 <:/:> ; IF PAGE TO BE SPECIFIED
JMPI S6 INCHAR ; GET SPECIFIED PAGE;
ADDC -<:0:> R0 ;
JMP S6 SB1900 ; COPY SOURCE TO OBJECT_AREA;
JMP UT5010 ; RETURN UTILITIES_MAIN_LINE;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE COPY I:(REF(SOURCE), REF(OBJECT), PAGE);
; R0 OBJECT MEMORY_SECTION DESTR
; R1 - DESTR
; R2 REF(START OBJECT_AREA) DESTR
; R3 WORDS TO COPY DESTR
; R4 PSW FOR SOURCE_AREA KEPT
; R5 REF(START SOURCE_AREA) DESTR
; R6 LINK KEPT
; R7 - DESTR
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
SB1900: ; COPY
SHS R0 4 ; IF VALID SPECIFIED PAGE
MOD R0 ; USE IT
MOV SB16PAGE R0 ; SET-UP RELEVANT PSW_PATTERN;
SVS R7 ; SAVE OWN PSW;
UT1950: ; REPEAT
LDS R4 ; SWITCH TO SOURCE SECTION;
MOV 0. X5 R1 ; GET WORD;
LDS R0 ; SWITCH TO ALTERNATIVE PAGE;
MOV R1 X2 ;
INCD R5 R2 ; ADJUST ADDRESSES;
SOB R3 UT1950 ; UNTIL SOURCE_AREA COPIED;
LDS R7 ; RE-ESTABLISH "OWN" MEM_SECTION;
JMP X6 ; RETURN CALLER;
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; IO_UTILITIES
;
; USING: UT20SV, PGMLOOP[0:1]
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
UT2000: ;IO:
MOVC 0 R3 ;
MOV R3 UT20SV+1 ; DEFAULT NO MODIFICATION;
MOV R3 PGMLOOP+1 ; RESET LOOP_COUNT (LONG_INTEGER);
JMPI S4 OUTSTRING
<:O::>, EOT
JMPI S6 INCHAR ; GET IO_TYPE;
ADDC -<:O:> R0 ;
MOV R0 UT20SV ;
;
JMPI S6 GETADDRESS ;
SEQ R0 <:):> ; IF MODIFICATION ACTIVE
JMP UT2010 ; THEN
ADD XBASE R5 ; RE-ESTABLISH ENTERED DATA;
MOV R5 UT20SV+1 ;
JMPI S6 GETADDRESS ; GET DEVICE_ADDRESS, REPEATS;
UT2010: ; END GETTING MODIFICATION;
ADD XBASE R5 ; BEWARE WAS BASE_REL;
SEQ R0 <:_:> ; IF LONG_INTEGER
JMP UT2020 ; THEN
JMPI S6 GETHEXA ;
IEQ R2 0 ; IF LEAST SIGNIFICANT PART 0
ADDC -1 R3 ; THEN ADJUST MOST SIGN;
MOV R3 PGMLOOP+1 ; PREPARE MOST SIGNIFICANT PART;
MOV R2 R3 ; SET UP LEAST SIGNIFICANT PART;
UT2020: ; END GETTING LONG INTEGER;
MOV UT20SV R4 ;
; CASE IO_TYPE OF
IEQ R4 <:S:>-<:O:>, JMP UT2050
IEQ R4 <:R:>-<:O:>, JMP UT2060
JMPI S6 GETHEXA ; GET ADDITIONAL PARAMETER;
IEQ R4 <:C:>-<:O:>, JMP UT2070
IEQ R4 <:B:>-<:O:>, JMP UT2075
IEQ R4 <:W:>-<:O:>, JMP UT2080
IEQ R4 <:V:>-<:O:>, JMP UT2085
JMPI ERROR ;
;
UT2050: ;SIO:
JMP S6 UT2090 ;
MOD R7 ;
SIO R2 R5 ;
JMP UT2140 ;
UT2060: ;RIO:
JMP S6 UT2090 ;
MOD R7 ;
RIO R2 R5 ;
JMP UT2140 ;
UT2070: ;CIO:
MOD R7 ;
CIO R2 R5 ;
JMP UT2180 ;
UT2075: ;CIO: SINGLE_STEP
JMP S6 UT2090 ;
MOD R7 ;
CIO R2 R5 ;
JMP UT2160 ;
UT2080: ;WIO:
JMP S6 UT2090 ;
MOD R7 ;
WIO R2 R5 ;
JMP UT2180 ;
UT2085: ;WIO: SINGLE_STEP
JMP S6 UT2090 ;
MOD R7 ;
WIO R2 R5 ;
JMP UT2160 ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
UT2090: ;COMMON_INITIALIZATION:
MOVC 0 R4 ;
MOV UT20SV+1 R7 ;
SNE R7 0 ; IF NO MODIFICATION
ADDC 1 R6 ; THEN ADJUST POINTER;
MOV R6 UT20SV ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
UT2100: ; REPEAT
MOV UT20SV+1 R7 ; GET MODIFICATION REGISTER;
JMPI UT20SV ; EXECUTE RELEVANT IO_INSTR;
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
UT2140: ;WRITE_IO_RESULTS:
MOV PRINTOUT R7 ;
SEQ R7 TRUE ; IF PRINT_OUT
JMP UT2180 ; THEN
JMPI S6 OUTHEXA ; DUMP STATUS
ADDC 1 R4 ; MAINTAIN DATA COUNT
MOV R4 R0 ;
XTR R0 3 ; ISOLATE BUT LOWER 3;
IEQ R0 0 ; IF (COUNT MOD 8) EQ 0
JMPI S6 OUTNL ; THEN TIME FOR NEW LINE;
JMP UT2180 ;
UT2160: ;GET_NEXT_PARAMETER:
JMPI S6 GETHEXA ;
UT2180: ;
SOB R3 UT2100 ; PERFORM LEAST_SIGN LOOP_CONTROL;
JMPI S6 BREAKCHECK ; BREAK_CHECK
JMP UT2190 ; R:(BREAK OCCURED);
MOV PGMLOOP+1 R6 ; GET MOST SIGNIFICANT PART
ADDC -1 R6 ; MAINTAIN COUNTER;
INEP R6 #FFFF ;
MOV R6 PGMLOOP+1 ;
JMP UT2100 ; UNTIL LONG_INTER ZEROED; (-1);
UT2190: ;END_OF_IO_UTILITY:
JMP UT5010 ; RETURN UTILITIES_MAIN_LINE;
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; WAIT_INTERRUPT
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
UT2500: ;WAIT_INTERRUPT:
JMPI S6 GETHEXA ; GET_HEXA) DEVICE);
XTR R2 6 ; ISOLATE DEVICE_NO;
MOV XBASE R5 ; "OWN" PROCESS BASE;
SVP UT2520 ;
JMP UT2540 ; CONTINU PROCESSING;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; WAIT DUMMY INTERRUPT ;
; EXECUTED BY DUMMY PROCESS ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
UT2520: ;WAIT_DUMMY_INTERRUPT:
; REPEAT
LDM 2#110 ; OPEN FOR I/O INTERRUPTS;
MOV OCADR R7 ;
SIO R0 R7 ; SENSE(STATUS, DEVICE);
SBZ R0 OCIRDY ; CHECK IF FRAMING ERROR
IBZ R0 OCBREAK ; SINCE LAST CHECK
JMP UT2520 ; UNTIL BREAK OCCURED;
LDM 2#111 ; CLOSE WINDOW AGAIN;
RIO R4 R7 ; RESET FLAGS;
JMPI S4 OUTSTRING, <:MISSING INTERRUPT<13>:>, EOT
LDN R5 ; ACTIVATE MASTER PROCESS
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; INITIALIZE INTERRUPT TABLES ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
UT2540: ;CONTINUATION:
IEQP R1 TRUE ; IF DATA ENTERED THEN
MODC & CPUIVB+64
MODN & XBASE ; COMPENSATE FOR DEFAULT ALL;
MOD XBASE
MOVC 0 R0 ; SET UP PROCESS EXPECTING INT'PT;
NEG R5 ; POINT TOP OF MEMORY SECTION 0;
MOVC CPUIVB R4 ; POINT INTERUPT_VECTOR_TABLE;
ADD R5 R4 ;
MOVC 64 R7 ; FOR I:=1 UNTIL MAX_DEVICES
UT2550: ; DO
MOV R0 0. X4 ; INSERT BASE IN INTER_RUPT_TAB;
ADDC 1 R4 ; ADJUST POINTER;
SOB R7 UT2550 ; UNTIL TABLE PREPARED;
;
MOVC CPUIVB R3 ; PREPARE ALL PRIORITY LEVEL2
MOV R3 CPUIVT+0.X5; WITH
MOV R3 CPUIVT+1.X5; ADDRESS OF SAME
MOV R3 CPUIVT+2.X5; INTERRUPT
MOV R3 CPUIVT+3.X5; VECTOR TABLE;
ADDC 64 R3 ; BASE DUMMY PROCESS;
MOV R3 CPUIVR.X5 ; PREPARE SYSTEM BASE WITH "OWN";
;
;MOVC XR0 R7 ; POINT TOP OWN PROCESS;
MOVM X7 X4 ; CREATE
MOVM X7 X4 ; DUMMY PROCESS;
ADDC -2*16 R4 ; DUMMY PROCESS;
MOV R3 XBASE. X4 ; PREPARE BASE
MOV R3 XMOD. X4 ; AND MOD REGISTER;
;
UT2560: ;
;REARM_INTERRUPT_TABLE:
MODN XBASE
MOVC CPUIVB R5 ; POINT START INTERRUPT TABLE;
MOV XBASE R1 ;
MOV R1 0. X5 ; PREPARE FOR TIMER;
MOD OCADR
MOV R1 0. X5 ; OPERATOR'S CONSOLE
MOD R2 ; SELECTED DEVICE;
MOV R1 0. X5 ;
;
SVP UT2580 ;
LDN R3 ; ACTIVATE DUMMY INTERRUPT_PROC;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; INTERRUPT OCCURED ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
UT2580: ;WAKE_UP:
MOV OCADR R7 ;
SIO R0 R7 ; SENSE(STATUS, DEVICE);
IBNP R0 OCBREAK ; TEST WAS INTERRUPTED BY BREAK
RIO & R0 R7 ; EMPTY OC_RX_BUFFER;
JMP & UT5020 ; TERMINATE TEST;
; ELSE
MOV XDEVICE R2 ;
IEQ R2 #FFFF ; IF CPU_INTERRUPT OR LDP
JMPI ERROR ; THEN ERROR
; ELSE
MOV PRINTOUT R0 ;
SNE R0 TRUE ; IF PRINT-OUT
IEQ R2 0 ; .AND.NOT. TIMER_INTERRUPT
JMP UT2590 ; THEN
SRL R2 2 ; ISOLATE DEVICE_NO;
SNE R2 R7 ; IF .NOT. OC_INTERRUPT
JMP UT2590 ; THEN
JMPI S4 OUTSTRING, <:IO INTERRUPT, DEV=:>, EOT
JMPI S6 OUTHEXA ;
JMPI S4 OUTSTRING, <:, PRIO=:>, EOT
MOV XDEVICE R0 ;
XTR R0 2 ; ISOLATE PRIORITY;
ADDC <:0:> R0 ; CONVERT TO ASCII
JMPI S6 OUTCHAR ;
JMPI S6 OUTNL ;
UT2590: ; END PRINTING;
JMP UT2560 ; UNTIL BREAK OCCURED;
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; SWITCH_CPU
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
UT2800: ;SWITCH_CPU:
JMPI S6 INCHAR ; GET NEW MASTER CPU_NO;
ADDC -<:0:> R0 ;
IHS R0 8 ; IF INVALID
JMPI ERROR ; THEN FLAG SO;
JMP S6 SB2800 ; SEND_CPU_MESSAGE;
JMP UT5010 ; RETURN UTILITIES_MAIN_LINE;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PROCEDURE SEND_CPU_MESSAGE I:(CPU_NO);
; THE PROCEDURE WILL PREPARE THE CPU_MESSAGE_AREA SUCH THAT THE
; SPECIFIED CPU WILL CONTINUE WHILE CURRENT ONE GOES ASLEEP.
; THE SPECIFIED CPU IS AWAKENED BY A CPU_INTERRUPT.
; N O T E NO CHECK IS PERPORMED TO VERIFY THE EXISTANCE OF THE OTHER.
;
; R0 CPU TO BE ACTIVATED DESTROYED
; R2,3,7 - DESTROYED
; R4 - POINTER TO TOP OF PAGE 0
; R6 LINK KEPT
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
SB2800: ;SEND_CPU_MESSAGE:
MODN XBASE
MOVC #0000 R4 ; POINT TOP OF MEMORY "OWN" PAGE;
MOVC CPUDUMMY R7 ;
MOVC CPUMSG R2 ; OTHER'S CPU'S MESSAGE;
MOD R2
MOV R7 0. X4 ; INSERT DUMMY_BASE IN MESSAGE;
SETS R2 BIT15 ; FORCE MESSAGE RESERVED;
MOVC 8 R3 ; FOR U:=1 UNTIL 8 CPU'S
SB2810: ; DO
MOV R2 CPUCPU.X4 ; INSERT POINTER;
ADDC 1 R4 ; ADJUST ADDRESS;
SOB R3 SB2810 ; UNTIL CPU MESSAGE_AREA DONE;
ADDC -8 R4 ; RE-ESTABLISH POINTER
;
MOV XBASE R2 ; USE "OWN" BASE_REGISTER
ADDC XBASE R2 ; AS POINTER;
MOD R0
MOV R2 CPUCPU.X4 ;
;
SVP SB2820 ; PREPARE OTHER CPU'S PROCESS;
JMP SB2825 ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; OTHER CPU'S FAITH ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
SB2820: ;OTHER'S_FAITH:
LDM 2#101
JMP LOC ; WAIT FOR CPU_&NTERRUPT;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; CREATE LOOSER'S SLEEPING PROCESS ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
SB2825: ;MASTER_PROCESS_CONTINUATION:
ADD R7 R4 ; POINT DUMMY CPU_PROCESS;
;MOVC XR0 R3 ;
MOVM X3 X4 ; CREATE DUMMY
MOVM X3 X4 ; CPU_INTERRUPT SERVICE PROCES;
ADDC -32 R4 ;
MOV R7 XBASE. X4 ; PREPARE BASE
MOV R7 XMOD. X4 ; AND MOD_REGISTERS;
SUB R7 R4 ;
;
SVS R2 ;
LDM 2#101 ;
CPU ; ACTIVATE ALL CPU'S
MOV MSEC R7 ;
SOB R7 LOC ; WAIT 1 MSEC;
LDS R2 ; RE-ESTABLISH OLD PSW;
JMP X6 ; RETURN CALLER;
;FF\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; UNIT_MAPPER
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
UT2900: ;MAP_CPU'S:
JMPI S4 OUTSTRING, <:<13>CPU: :>, EOT
SVS R5 ;
MOV R5 R0 ;
SWP R0 ;
XTR R0 3 ; ISOLATE "OWN" CPU_NO;
JMP S6 SB2800 ; SEND_CPU_MESSAGE("OWN"_CPU);
;
MOVC 8 R3 ; FOR I:=1 UNTIL 8 CPU'S
UT2930: ; DO
MOVC <:1:> R0 ; CPU EXIST BY DEFAULT;
SOZ CPUCPU.X4 ; IF NO_MESSAGE ACCEPTED
MOVC <:.:> R0 ; THEN FLAG SO;
JMPI S6 OUTCHAR ;
ADDC 1 R4 ;
SOB R3 UT2930 ; END MAPPING CPU'S;
JMP S4 UT2950 ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; SERVE MISSING MODULE/TIME_OUT ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;TIME_OUT:
MOV XCAUSE R6 ;
IEQ R6 2 ; IF PARITY_ERROR
JMP UT2940 ; THEN OK;
INE R6 3 ; IF TIME_OUT
JMP LOCALINT ;*** THEN IT DESERVES SPECIAL CARE;
MOVC <:.:> R0 ; FLAG MISSING 4K_RAM/IO_MODULE;
UT2940: ;PRINT_RESULT:
LDS R5 ; RE-ESTAB "OWN" PSW, LOWER BIT11;
MOV R3 R6 ;
XTR R6 4 ; IF (COUNT MOD 16) .EQ. 0
IEQ R6 7 ; IF (COUNT MOD 16) .EQ. 7
ADDC <: :><8 R0 ; THEN INSERT EXTRA SPACE;
IEQ R6 15 ; IF (COUNT MOF 16) .EQ. 15
ADDC <:/:><8 R0 ; THEN ADJUST;
JMPI S6 OUTCHAR ; PRINT CURRENT CHAR;
SRL R0 8 ; POSITION EVENTUAL SECOND CHAR;
INE R0 0 ; IF ANY 2ND CHAR
JMPI S6 OUTCHAR ; THEN PRINT AS WELL;
ADDC 1 R3 ; MAINTAIN CURRENT MODULE_NO;
SHS R3 64 ; IF STILL MODULES LEFT
JMP 1. X4 ; THEN RETURN SERVE
JMP 0. X4 ; ELSE DONE WITH THIS SECTION;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; MAP RAM'S ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
UT2950: ;MAP_RAM'>:
MOV R4 XLOCACT ; SET_UP OWN LOCAL_ACTION;
JMPI S4 OUTSTRING, <:<13>RAM: :>, EOT
MOVC 0 R3 ; FOR I:=1 UNTIL 4*16 4K_RAM'S
JMP S4 UT2960 ; DO
JMP UT2970 ; **EXIT WHEN RAM'S TESTED;
UT2960: MOVC <:1:> R0 ; SET-UP UNIT_EXIST;
MOV R3 R6 ;
SRL R6 4 ; POSITION MEMORY_SECTION;
MOD R6
MOV SB16PAGE R6 ; SET-UP PAGE;
MOV R3 R7 ;
SLL R7 12 ; COMPUTE CORRECT ADDRESS;
SUB XBASE R7 ;
LDS R6 ; SWITCH TO RELEVANT PAGE;
MOV 0. X7 R6 ; TEST RELEVANT 4K_RAM;
JMP UT2940 ; UNTIL ALL MODULES SERVED;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; MAP IO_MODULES ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
UT2970: ;MAP IO_MODULES:
JMPI S4 OUTSTRING, <:<13>IO: :>, EOT
MOVC 0 R3 ; FOR I:=0 UNTIL 63 IO_MODULES
JMP S4 UT2980 ; DO
JMP UT2990 ; **EXIT WHEN ALL IO_MODULES DONE;
UT2980: MOVC <:1:> R0 ; DEFAULT EXESTING MODULE;
SIO R6 R3 ; SENSE(STATUS, DEVICE);
JMP UT2940 ; UNTIL ALL MODULES SERVED;
;
UT2990: ;
JMP UT5010 ; RETURN UTILITIES_MAIN_LINE;
;FF\f
; E X E R C I Z E O P T I O N S
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
OPT00: ;OPTIONS:
JMPI S6 OUTNL ;
JMPI S4 OUTSTRING, <:PRINT-OUT ?<62>:>, EOT
JMPI S6 INCHAR ;
ADDC TRUE-YES R0 ;
MOV R0 PRINTOUT ;
;
MOVC 0 R0 ;
MOV R0 PGMNEXT ; RESET TEST_PGM_CONTROL;
;
JMPI S6 OUTNL ;
JMPI S4 OUTSTRING, <:NO OF TESTS <62>:>, EOT
JMPI S6 GETHEXA ; GET FIRST PART OF COUNT
MOV R2 R3 ;
MOVC 0 R2 ; PRESET MOST SIGNIFICANT
INEP R0 CR ; IF LEAST SIGNIFICANT TOO
JMPI & S6 GETHEXA ;
XCH & R3 R2 ; POSITION;
ADDC -1 R3 ; ADJUST LEAST SIGNIFICANT PART;
IEQ R3 -1 ; IF LOWER PART OVERFLOW
ADDC -1 R2 ; THEN ADJUST MOST SIGNIFICANT;
MOV R2 PGMLOOP+1 ; SAVE MOST SIGNIFICANT PART
MOV R3 PGMLOOP ; LEAST SIGNIFICANT AS WELL;
JMP UT5020 ; RETURN UTILITIES MAIN LINE;
;FF\f
UT5000: ;UTILITIES:
MOV R6 UT50SV ; SAVE RETURN ADDRESS;
UT5010: ;
JMPI S6 OUTNL ;
UT5020: ;
MOVC LOCALACT R0 ;
MOV R0 XLOCACT ; RE-ESTABLISH TO COMMON LOCAL
;
MOVC <:<62>:> R0 ;
JMPI S6 OUTCHAR ; WRITE '>'
JMPI S6 INCHAR
ADDC -<:O:> R0 ;
JMP S6 UT5050 ; ESTABLISH LINK
JMP UT5010 ;
UT5050: ;
; CASE CHAR OF
IEQ R0 <:B:>-<:O:>, JMPI BOOTLOAD
IEQ R0 <:C:>-<:O:>, JMPI COPYMEMORY
IEQ R0 <:D:>-<:O:>, JMPI DUMP
IEQ R0 <:I:>-<:O:>, JMPI IO
IEQ R0 <:L:>-<:O:>, JMPI LOADFILE
IEQ R0 <:M:>-<:O:>, JMPI MEMCHECK
IEQ R0 <:O:>-<:O:>, JMPI OPTIONS
IEQ R0 <:P:>-<:O:>, JMPI PATCH
IEQ R0 <:Q:>-<:O:>, JMPI SWITCHCPU
IEQ R0 <:R:>-<:O:>, JMPI RETURNCALLER
IEQ R0 <:S:>-<:O:>, JMPI SEARCH
IEQ R0 <:T:>-<:O:>, JMPI TESTCPU
IEQ R0 <:U:>-<:O:>, JMPI UNITS
IEQ R0 <:W:>-<:O:>, JMPI WAITINTERRUPT
IEQ R0 <:U:>-<:O:>, JMPI UNITS
IEQ R0 <:X:>-<:O:>, JMPI XECUTE
IEQ R0 <:Z:>-<:O:>, JMPI SETPARITY
IEQ R0 <:<:>-<:O:>, JMPI UT50SV
UT5090: ;ERROR:
MOVC <:?:> R0 ;
JMPI S6 OUTCHAR ;
JMP UT5010 ;
NOLIST IF FDSUPPORT THEN LIST
;FF\f
$FDLOAD
NOLIST FI LIST
;FF\f
; I N I T I A L I Z E C P U T E S T P R O G R A M
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Q;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
TEC00: ;TEST_CPU:
MOVC B5555 R5 ;
MOVL 0. X5 R23 ;
MOV P5555 R0 ;
MOV PAAAA R1 ;
INE R0 R2 ; IF B5555_FIELD NOT CORRECT
JMP TEC10 ; .OR.
SNE R1 R3 ; BAAAA_FIELD NOT CORRECT
JMP TEC90 ; THEN
TEC10: ;
;
JMPI S6 GETADDRESS ; GET POSITION OF (PROMMED)
; CPU_TEST SEQUENCES;
MOVC #1000 R3 ; SET-UP COUNT (4K PROM);
MOVC 0 R0 ; OBJECT_SECTION 0;
MOV TCBASE R2 ; GET "BASE" CPU_TEST PROGRAMS;
MOV XBASE R7 ;
SUB R7 R2 ; MAKE REL "OWN" BASE;
JMPI S6 COPY ; COPY CPU_TEST PROGRAMS
; TO MEMORY #1000 UPWARDS;
MOV XBASE R3 ;
MOV TCBASE R1 ; GET START OF CPU_TEST_PROGRAMS;
SUB R3 R1 ; SET-UP CPU-TEST-"OWN=_BASE;
MOV TCBASE R2 ;
MOV XPROG R7 ;
SUB R7 R2 ; SET-UP CPU_TEST-"OWN"_PROG;
MOV R1 R7 ;
MOV 0. X7 R0 ; GET FIRST STATEMENT;
INE R0 #0158 ; IF NOT 'JMP LOC'
JMPI ERROR ; THEN ERRORONEOUS MODULE;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; RAM RESIDENT VERSION ACCEPTED ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
JMP S4 LOC+2 ; BY-PASS INSTRUCTION;
JMPI S4 OUTSTRING
MVP 0. X4 R0 ; GET INSTRUCTION
MOV R0 0. X7 ; INSERTED AS FIRST OF AREA;
MOV R2 R6 ;
JMP S5 LOC+1 ; ESTABLISH LINK BACK;
JMP X6 ; ACTIVATE RAM_RESIDING PART;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;RETURN_FROM_CUP_TEST:
; R0,4,6,7 DESTROYED
; R4 REF CPU_TEST PROGRAM_TABLE
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; SET-UP CPU_TEST CONTROL ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
ADD R1 R4 ; ADJUST REF(CPU_TEST_PGMS);
MOV R1 R7 ;
MOVC TCPOOL R6 ;
TEC20: ; REPEAT
MOVL 0. X4 R01 ;
IEQ R0 #BE ; IF TEST UNDEFINED (TRAP)
SUB R0 R0 ; THEN FORCE DUMMY TEST;
IEQ R0 0 ; IF DUMMY TEST
JMP TEC30 ; THEN
IBZ R0 BIT15 ; IF NOT END_OF_TEST_FILE
ADD R2 R0 ; ADJUST TO REL "ACTUAL" PROG;
TEC30: ; END ADJUSTING PROG_REL;
ADD R7 R1 ; ADJUST TO REL "ACTUAL" BASE;
MOVL R01 0. X6 ; MAKE
ADDC 2 R4 ; REFERENCES
ADDC 2 R6 ; RELATIVE;
IBZ R0 BIT15 ;
JMP TEC20 ; UNTIL CPU_TEST AREA INITIALIZED;
;
MOVC 0 R7 ;
MOV R7 PGMLOOP ; INITIALIZE COUNTERS
MOV R7 PGMLOOP+1 ;
MOV R7 PGMNEXT ; AND CURRENT TEST PGM POINTER;
TEC90: JMPI S6 OUTNL ;
;CONTINUE WITH CPU_TEST MAIN_LINE:
;FF\f
; C P U T E S T P R O G R A M - M A I N L I N E
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; FOR I:=1 UNTIL TEST_LOOP_COUNT
; DO
; REPEAT UNTIL TABLE SCANNED
MAINLOOP:
MOV PGMEVALUATE R0 ; GET CHECK/PRINT-OUT FLAG
MOV PGMNEXT R6 ; GET REF(CUR'T TEST_PGM_NDX);
MOV TCPOOL+TCPPROG.X6 R4 ; GET REF(CUR'T TEST_PGM_ADR);
SNE R0 TRUE ; IF EVALUATION
IEQ R4 0 ; .AND. VALID TEST_PROGRAM
JMP MAI50 ; THEN
;-----------------------------------;
; EVALUATE TEST RESULTS ;
;-----------------------------------;
MOV TCPOOL+TCPDATA.X6 R4 ; GET REF(ASSOCIATED DATA_AREA)
MOVC CTCBDATA R5 ; OFF-SET TO EXPECTED DATA;
ADD R4 R5 ; REF (EXPECTED_DATA_AREA);
MOV REFWORK R7 ; POINT WORK AREA;
MOV CTCBCNT.X4 R3 ; FORI:=1 UNTIL NO_WORDS
MAI10: ; DO
IEQ X5 X7 ; IF DISCREPANCY
JMP MAI20 ; THEN
MOV R7 MAISV ;
MOV R4 MAISV+1 ;
JMPI S4 OUTSTRING, <:TEST :>, EOT
MOV MAISV+1 R4 ;
MOV CTCBID.X4 R2 ; GET TEST IDENTIFICATION
JMPI S6 OUTHEXA ;
JMPI S4 OUTSTRING, <: WORD :>, EOT
MOV MAISV+1 R4 ;
MOV CTCBCNT.X4 R2 ; COMPUTE WORD
SUB R3 R2 ; NUMBER;
JMPI S6 OUTHEXA ;
JMPI S4 OUTSTRING, <: TO BE :>, EOT
MOV X5 R2 ; GET ACTUAL RESULT
JMPI S6 OUTHEXA
JMPI S4 OUTSTRING, <:- WAS :>, EOT
MOV MAISV R7 ;
MOV X7 R2 ; GET EXPECTED
JMPI S6 OUTHEXA ; GET EXPECTED
JMPI S6 OUTNL ; WRITE_NEWLINE;
MOV MAISV+1 R4 ;
MOV MAISV R7 ; RE-ESTABLISH POINTER;
MAI20: ; END DISCREPANCY;
ADDC 1 R5, ADDC 1 R7 ;
SOB R3 MAI10 ; END FOR_UNTIL;
;-----------------------------------;
; CHECK IF BREAK OCCURED ;
;-----------------------------------;
MAI50:
JMPI S6 BREAKCHECK ; BREAK_CHECK
JMPI & S6 UTILITIES ;*** R:(BREAK OCCURED);
;-----------------------------------;
; SEARCH NEXT TEST SEQUENCE ;
;-----------------------------------;
MOV PGMNEXT R6 ; GET REF(TEST_PGM TABLE INDEX);
MAI55: ; REPEAT
ADDC 2 R6 ; POINT NEXT TEST_RECORD;
MOV TCPOOL+TCPPROG.X6 R7 ; GET REF(TEST_PROGRAM);
IEQ R7 0 ; IF VALID TEST
JMP MAI55 ; THEN
MOV R6 PGMNEXT ; SAVE REFERENCE;
SBZ R7 BIT15 ; IF STILL TEST PROGRAMS LEFT
JMP MAI80 ; THEN
MOV TCPOOL+TCPDATA.X6 R4 ; GET REF(ASSOCIATED DATA);
MOVL CTCBCNT.X4 R01 ; GET NO_WORDS, RESET VALUE;
ADD R0 R4 ; ADJUST FOR EXPECTED_AREA;
MOV R4 R5 ;
MOV REFWORK R6 ; POINT WORK AREA;
IEQ R1 0 ; IF WHOLE AREA EQUAL 'R1'
JMP MAI65 ; THEN
MAI60: ; REPEAT
MOV R1 X6 ; INITIALIZE AREA;
ADDC 1 R6 ; ADJUST POINTER;
SOB R0 MAI60 ; UNTIL AREA COVERED;
JMP MAI70 ; ELSE
MAI65: ; REPEAT
MOV CTCBDATA.X4 R2 ; GET NEXT WORD
MOV R2 X6 ; COPIED;
ADDC 1 R4, ADDC 1 R6 ; ADJUST POINTERS;
SOB R0 MAI65 ; END COPYING AREA;
MAI70: ;
ADDC CTCBDATA R5 ; ADJUST POINTER TO INPUT;
MOVL 0. X5 R01 ;
MOVL 2. X5 R23 ;
MOV 4. X5 R4 ;
MOV REFWORK R6 ; POINT WORK AREA;
JMP X7 ; EXECUTE TEST PROGRAM;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; EXECUTE TEST SEQUENCE ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;TEST_PROGRAM_ENTRY:
; R0-4:FIRST 5 WORK_WORDS
; R5 - REF(WORK_AREA)
; R6 - REF(OUTPUT_AREA)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; MAINTAIN LONG_INTEGER ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
MAI80: ; END TABLE_SCAN;
MOVC 0 R6 ; RE-ADJUST TO TOP
MOV R6 PGMNEXT ; PROGRAM_INDEX;
MOVC PGMLOOP R6 ; REF(TEST_LOOP_COUNT);
MOVL 0. X6 R01 ; GET NO_TEST LEFT (LONG INT);
ADDC -1 R0 ; ADJUST LEAST SIGNIFICANT;
IEQ R0 -1 ; IF LEAST_SIGN'T BELOW
ADDC -1 R1 ; THEN ADJUST MOST_SIGNIFI'T;
SNEP R0 -1 ;
IEQ R1 -1 ; CPU_LOOP_TEST
JMP TESTEND ;
;
MOVL R01 0. X6 ; SAVE;
JMPI MAINLINE ; END CPU_TEST_LOOP;
; E N D P R O G R A M
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
TESTEND:
MOVC <:*:> R0 ;
MOVC 44 R3 ; FOR I:=1 UNTIL 44
END10: ; DO
JMPI S6 OUTCHAR ; WRITE_CHAR;
SOB R3 END10 ; END FOR_UNTIL;
JMP UT5010 ; RETURN UTILITIES_MAIN_LINE;
;-----------------------------------------------------------------------
;FF\f
; M A S T E R C L E A R E N T R Y P O I N T
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; ENTRY POINT UPON MASTER CLEAR
;
; R2 POINTER PROMMED PROGRAM
; R4 PROG_REL ADDRESS OF AUTOMATIC SERVICE PROGRAM
; R5 POINTER PROMMED PROCESS_DESCRIPTOR
; R7 DEVICE ADDRESS
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
MCENTRYPOINT: ;ENTRY_POINT UPON MASTER CLEAR:
SVP MCWAITCPU ;
MOVC 0 R6 ;
MOV R6 XR0 ; RESET MEMORY CLAIM SEMAPHORE;
MOVC 100 R6 ;
SOB R6 LOC ; WAIT 100-200 USEC;
RESS X6 BIT0 ; RESERVE MEMORY
JMP MCE10 ; (LOST: WAIT FOR CPU_INTERRUPT,
; WON: CONTINUE);
MOV MSEC R6 ;
SOB R6 LOC ; WAIT 1 MSEC;
JMP MCE20 ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; WAIT FOR WINNER'S CPU INTERRUPT ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
MCE10: ;LOOSER'S_FAITH:
MOV R1 XBASE ;
MOV R1 XMOD ;
LDN R3 ;***ACTIVATE CPU WITH DUMMY PROCESS;
MCWAITCPU:
LDM 2#101 ; OPEN FOR CPU_INTERRUPTS ONLY;
JMP LOC ; WAIT FOR INTERRUPT;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; INITIALIZE WINNING PROCESS ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
MCE20: ;INITIALIZE:
MOVC XABS R7 ; FOR I:=1 UNTIL COUNT
MCE30: ; DO
MOVL 0. X5 R01 ;
MOVL R01 0. X6 ; COPY
ADDC 2 R5 ; PROCESS
ADDC 2 R6 ; DESCRIPTOR;
SOB R7 MCE30 ; END FOR_UNTIL;
;
JMPI S4 OUTSTRING, <:<13>CSS/395/01 791015:>, EOT
JMPI S4 OUTSTRING, <:<13>CPU :>, EOT
SVS R0 ; GET CURRENT PSW
SWP R0 ; POSITION CPU-NO AS RIGHTMOST;
XTR R0 3 ; ISOLATE CPU NO;
ADDC <:0:> R0 ; CONVERT TO ASCII;
JMPI S6 OUTCHAR ; WRITE_CHAR;
MCE50: JMPI S6 UTILITIES ;
JMP MCE50 ;
;///////////////////////////////////; END BASIC_INTITIALIZATION;
MCE90: ;RETURN_CALLER:
MOV XOLDPRC R7 ; GET BASE CALLING PROCESS
LDN R7 ; RE-ACTIVATE CALLING PROCESS;
ENDOFPGM:
;FF\f
PROGRAMSTART:= CPUPROM+PROGSTART
PROGRAMGO:= PROGRAMSTART+MCENTRYPOINT
ABSMCE50:= PROGRAMSTART+MCE50
IF LOC LT #0FE0
THEN #0000, REPEAT (#FE0-LOC) AN #7FF
ELSE MESSAGE LOC FI
RELPROMBASE= PROGRAMSTART+LOC-CPUBASE
USE BASE
IF LOC LT #1E
#0000
IF LOC LT #1E
REPEAT (#1E-LOC)
FI
FI
PROGRAMSTART+EMERGENCY ; EMERGENCY ACTION SERVICE PROGRAM
#0000 ; PROM CHECK-SUM
BEGIN
EXTERNAL EOT
EXTERNAL BIT0, BIT1, BIT2, BIT3, BIT4, BIT5, BIT6, BIT7,
EXTERNAL BIT8, BIT9, BIT10, BIT11, BIT12, BIT13, BIT14, BIT15
USE BASE
EXTERNAL CPUMON
EXTERNAL XBASE, XPROG
EXTERNAL TCBASE, TCREFWORK
EXTERNAL B5555, BAAAA, CP06, CP20INS, CPWORK
EXTERNAL CP46P, CP46
USE PROG
EXTERNAL MAINLINE, P5555, PAAAA
NAMES
END
END
«eof»