diff --git a/Makefile b/Makefile index 7b623bf5..bca86889 100644 --- a/Makefile +++ b/Makefile @@ -11,7 +11,7 @@ SRC = system syseng sysen1 sysen2 sysen3 sysnet kshack dragon channa \ jim jm jpg macrak maxdoc maxsrc mrg munfas paulw reh rlb rlb% share \ tensor transl wgd zz graphs lmlib pratt quux scheme gsb ejs mudsys \ draw wl taa tj6 budd sharem ucode rvb kldcp math as imsrc gls demo \ - macsym + macsym lmcons DOC = info _info_ sysdoc sysnet syshst kshack _teco_ emacs emacs1 c kcc \ chprog sail draw wl pc tj6 share _glpr_ _xgpr_ inquir mudman system \ xfont maxout ucode moon acount alan channa fonts games graphs humor \ diff --git a/build/misc.tcl b/build/misc.tcl index de736a43..a1c44f44 100644 --- a/build/misc.tcl +++ b/build/misc.tcl @@ -1082,6 +1082,12 @@ expect ":KILL" respond "*" ":palx sysbin;vxgp bin_sysen2;xgp\r" expect ":KILL" +# CCONS. STUFF prefers it to be in the CONS directory. +respond "*" ":print cons;..new. (udir)\r" +type ":vk\r" +respond "*" ":palx cons;_lmcons;ccons\r" +expect ":KILL" + # 11BOOT respond "*" ":midas /t sys3;ts 11boot_syseng;11boot\r" respond "with ^C" "APR==0\r\003" diff --git a/doc/programs.md b/doc/programs.md index aa1041ce..138ac30a 100644 --- a/doc/programs.md +++ b/doc/programs.md @@ -29,6 +29,7 @@ - BYE, say goodbye to user. Used in LOGOUT scripts. - CALPRT, decode a .CALL instruction's CALL block. - CC, C compiler (binary only). +- CCONS, CONS console. - CHADEV, Chaosnet jobdev (binary only). - CHARFC/CHARFS, Chaos RFC. - CHASE, a 2-player maze game. diff --git a/src/lmcons/ccons.478 b/src/lmcons/ccons.478 new file mode 100644 index 00000000..90b7a966 --- /dev/null +++ b/src/lmcons/ccons.478 @@ -0,0 +1,9420 @@ +.TITLE CONS-CONSOLE -- ALSO DATAPOINT EMULATOR +;ALSO GENERAL PURPOSE GRAPHICS DISPLAY + +;PITTS JARVIS/JOE COHEN -- AUGUST 1973 + +%ABSADR==1 + +.IIF NDF GT40P, GT40P==0 ;1 TO ASSEMBLE GT40 ROUTINES +.IIF NDF TVP, TVP==1 ;1 TO ASSEMBLE TV ROUTINES +.IIF NDF KBDP, KBDP==0 ;0 TO USE FANCY KEYBOARD +.IIF NDF DEBUG, DEBUG==0 ;1 TO RUN UNDER PDP11 SIMULATOR? + +;VARIOUS DEBUGGING AIDS +.MACRO BPT ;MISFEATURE IN PALX + RMS LOSES +.ENDM +.MACRO NOP + RMS LOSES +.ENDM +.IFNZ DEBUG + .STITL DEBUGGING VERSION FOR 11/20 + BPT==3 ;BREAKPOINT INSTUCTION + NOP==BPT + PATL==100 +.ENDC +.IFZ DEBUG + .STITL GT40 VERSION + DEBUG==0 + BPT==3 + NOP==BPT + PATL==40 +.ENDC + +;DLIMSW==0 ;IF NZ, ASSEMBLE DISPLAY LIMITING + ;(THIS HACK USED EMT FOR SOME WEIRD REASON) +PCHIST==0 ;KEEPS HISTORY OF PCS IN PCBUF + +.SBTTL DEFINITIONS + .IF2 +;.IFNZ DLIMSW +;.PRINT /DISPLAY LIMITING +;/ +;.ENDC +.IFNZ PCHIST +.PRINT /PC HISTORY +/ +.ENDC +.ENDC + +;MACROS + +.MACRO PUSH A + .NLIST + MOV A,-(SP) + .LIST +.ENDM + +.MACRO POP A + .NLIST + MOV (SP)+,A + .LIST +.ENDM + +.MACRO REPORT TEXT,NUM +.IF2 + .PRINT /TEXT NUM +/ +.ENDC +.ENDM + +.MACRO ZAPFLG FOO +.NLIST +%COMPAT==0 + MOV PC,FOO +%COMPAT==1 +.LIST +.ENDM + +;REGISTER ASSIGNMENTS + +A=%0 ;USED FOR ARGUMENT PASSING +B=%1 +C=%2 +T=%3 +TT=%4 +U=%5 ;RESERVED FOR PIECE OF PAPER NUMBER +SP=%6 +PC=%7 +.XCREF A,B,C,T,TT,SP,PC + +;MEMORY MAP + +NXMPC= 4 ;BUS ERROR VECTOR +NXMPSW= 6 +RESPC== 10 ;RESERVED INTRUCTION VECTOR +RESPSW==12 +BPTPC== 14 ;BREAK POINT VECTOR +BPTPSW==16 +IOTPC== 20 ;IOT VECTOR +IOTPSW==22 +PWRPC= 24 ;POWER FAIL TRAP VECTOR +PWRPS= 26 +EMTPC= 30 ;EMULATE TRAP VECTOR +EMTPSW= 32 +TRPPC== 34 ;TRAP INSTRUCTION VECTOR +TRPPSW==36 +TIMEH==40 ;32 BIT 60 CYCLE COUNTER FOR LISPM, HIGH PART +TIMEL==42 ;" " LOW PART +TYIPC= 60 ;TTY INPUT INTERUPT VECTOR +TYIPSW= 62 +LKPC= 100 ;LINE CLOCK INTERUPT VECTOR +LKPSW= 102 +KLIPC= 300 ;KL11 INPUT INTERUPT VECTOR +KLIPSW=302 +DSPC= 320 ;DISPLAY STOPPED INTERRUPT VECTOR +DSPSW= 322 +DLPPC= 324 ;LIGHT PEN INTERRUPT VECTOR +DLPPSW=326 +DTOPC= 330 ;DISPLAY TIME/SHIFT OUT VECTOR +DTOPSW=332 + +HMEML==35714 ;HI LIMIT OF MEM USED BY DYNAMIC HACK +DSKRQB=35716 ;DISK REQUEST BUFFER (SEE CCDISK) +DSKRBL==30. ;NUMBER OF REQUESTS IN BUFFER +DSKRBE==DSKRQB+4+<10.*DSKRBL> ;END ADDRESS +.IIF P2 .IIF GT DSKRBE-LDBFF2, .ERR DISK REQUEST BUFFER OVERLAPS AUX LOAD BUFFER +LDBUFF=37002 ;LOW 1/2 OF FLAG DOUBLE WD USED TO SIGNAL STATE OF + ;LOADER BUFFER + ; 0 -> BUFFER EMPTY, + ;-1 -> DO READING OP + ; (BUFFER FULL OF REGISTER EXAMINE COMMANDS) + ;+ -> DO WRITING OP + ; (BUFFER FULL OF REGISTER DEPOSIT COMMANDS) +LDBUF=37004 ;ADDRESS OF FIRST BUFFER BLOCK +LDBUFB==40 ;LOAD BUFFER LENGTH IN BLOCKS (4 WD EA) +LDBUFL==LDBUFB*10 ;LOAD BUFFER LENGTH IN BYTES +LDBFF2=36376 ;FLAG WORD FOR AUXILIARY BUFFER +LDBUF2=36400 ;ADDR OF FIRST BUFFER BLOCK IN AUX BUFFER +.IIF GT LDBUF2+LDBUFL-LDBUFF-2, .ERR BUFFERS OVERLAP + +;RUGSA==37000 ;RUG STARTING ADDRESS +;RUGBRK==RUGSA+162 ;RUG BREAK POINTER HANDLER + +KLIS=175610 ;KL11 INPUT STATUS +KLIB=175612 ;KL11 INPUT BUFFER +KLOS=175614 ;KL11 OUTPUT STATUS +KLOB=175616 ;KL11 OUTPUT BUFFER +TKS= 177560 ;TTY KEYBOARD STATUS +TKB= 177562 ;TTY KEYBOARD BUFFER +LKS= 177546 ;LINE CLOCK STATUS +CSR= 177570 ;CONSOLE SWITCH REGISTER +PS= 177776 ;PROCESSOR STATUS REGISTER + .SBTTL GT40 DEFINITIONS +.IFNZ GT40P + +;GEOMETRY + +BITPL==2000 ;BITS PER LINE +NLINS==1400 ;LINES ON SCREEN +BYTPL==BITPL/10 ;BYTES PER LINE +WRDPL==BYTPL/2 ;WORDS PER LINE + +CHRWD==16 ;CHARACTER WIDTH +CHRHT=30 ;CHARACTER HEIGHT +CHRPL==BITPL/CHRWD ;CHARACTERS PER LINE +CHRLN==NLINS/CHRHT ;CHARACTER LINES ON SCREEN + +DPC= 172000 ;DISPLAY PROGRAM COUNTER +DSR= 172002 ;DISPLAY STATUS REGISTER +XSR= 172004 ;X STATUS REGISTER, GRAPH PLOT INCREMENT +YSR= 172006 ;Y STATUS REGISTER, CHARACTER REGISTER + +;GT40 OPCODES + +DPYJMP==160000 +DPYNOP==164000 +DPYSTP==173400 ;STOP DISPLAY AND CAUSE INTERRUPT +DPYJSR==DPYSTP+1 ;CALL DPY SUBROUTINE +DPYRTS==DPYSTP+2 ;RETURN FROM DPY SUBROUTINE +DPYJSI==DPYSTP+3 ;INDIRECT CALL DPY SUBROUTINE +SETPNT==114000 +RPOINT==130000 +SVW==104000 +LVW==110000 +CHARS==100000 +DPYNRM==3724 ;NORMAL SET GRAPHIC MODE BITS + ; INTENSITY 7 + ; NO LIGHT PEN + ; NO BLINK + ; NO ITALICS + ; SOLID LINE +BLENAB==20 ; LISTEN TO DBLINK BIT +DBLINK==10 ; YES BLINK (IF ENABLED) + +STSNRM=171640 ;NORMAL A REGISTER SETTINGS + ; ENABLE STOP INTERRUPTS + ; DISABLE LIGHT PEN INTERRUPTS +SYNC==4 ; SYNCS DPU WITH CLOCK +ITALICS==20 ; CAUSE ITALICS +LITEPN==200 ; ENABLE LIGHT PEN INTERRUPTS + +ESCHR==20 ;ESCAPE TO DISPLAY SLAVE (^P) +XLOD==6 ;EXTRA BYTES IN LOADER BLOCK (TYPE, SIZE, ITEM) +.ENDC ;GT40P + .SBTTL TV DEFINITIONS +.IFNZ TVP + ;FROM TS TV STUFF + +FONTSW==1 ;COMPILE FONTS +FONTMS==0 ;USE MACROS TO COMPILE FONTS + +.MACRO CHECK TAG,LENGTH +.NLIST +.IF NE .-- +.ERROR TAG WRONG LENGTH +.ENDC +.EVEN +.LIST +.ENDM + +.MACRO CONC A,B,C,D,E,F,G,H,I +A'B'C'D'E'F'G'H'I +.ENDM + +TVCTL=176660 ;CONTROL REG + BOWBIT==1 ;1.1 WHITE ON BLACK OF SELECTED CHANNEL + ;1.2-1.4 VIDEO SWITCH + ;1.9-2.2 CHANNEL SELECT + VERINC==100000 ;2.7 VERTICAL INCREMENT MODE +TVPTR=176662 ;RELATIVE ADDRESS IN TV BUFFER +TVDAT=176664 ;DATA READ/WRITE +TVDATI=176666 ;SAME EXCEPT AUTO INCREMENTS TVPTR ON WRITE ONLY +TVCTL2=176670 ;SECOND CONTROL REG + ;AT THIS ADDRESS YOU CAN WRITE WHITE ON BLACK AND VIDEO SWITCH + ;AT THE TVCTL ADDRESS YOU CAN WRITE PLANE SELECT AND VERTICAL INCR + ;THE OTHER THREE REGISTERS ARE REPEATED HERE + +;TVMEM=200000 ;TV 16K STARTS ABOVE FIRST 32K OF ADDRESS +;TVMEM=0 ; LOW 16 BITS OF TV ADDRESS +;TVMEMX=1*10000 ;EXTENSION BITS FOR ADDR + +;GEOMETRY + +BITPL==576. ;BITS PER LINE +NLINS==454. ;LINES ON SCREEN +BYTPL==BITPL/10 ;BYTES PER LINE +WRDPL==BYTPL/2 ;WORDS PER LINE + +CHRWD==6 ;CHARACTER WIDTH ON TEXT LINE +GRIDWD==5 ;WIDTH OF CHARACTER GRID +CHRHT==12 ;CHARACTER HEIGHT +CHRVSP==2 ;BLANK RASTER LINES BETWEEN CHARACTER LINES +LINHT==CHRHT+CHRVSP ;CHRACTER LINE HEIGHT +CHRPL==BITPL/CHRWD ;CHARACTERS PER LINE +CHRLN==NLINS/LINHT ;CHARACTER LINES ON SCREEN + +TVLO==0 ;RELATIVE ORIGIN OF DISPLAY MEMORY +TVFENCE=TVHI- ;DON'T START ORDINARY TEXT LINE PAST THIS POINT +TVCFENC=TVHI-> ;DON'T TRY TO DISPLAY A CHARACTER AFTER THIS POINT +TVHI=TVLO+-2 ;HIGHEST LEGAL DISPLAY ADDRESS +...==0 +....==0 + +;VARIOUS BUFFER SIZES AND ETC. + +BUFSIZ==200 ;DL11 INPUT BUFFER SIZE +PDL==400 ;PDL SIZE +.IFNZ GT40P +MCHRPL==3*CHRPL+1 ;MAXIMUM CHARS PER LINE (ALLOW UNDERLINING OF WHOLE LINE) +LBL==MCHRPL+6 ;WORST CASE LINE LINE LENGTH +XTLBYT==6 ;EXTRA TEXT LINE BYTES +NEBISH==20 ;BYTES WE'RE WILLING TO WASTE IN FREE STORAGE ALLOCATOR +INUSE==1 ;BLOCK IN USE +DPYPDL==40 ;DPY PUSH DOWN LENGTH +OPENSW=LINBUF+2 ;0 IMPLIES LINE CLOSED, NON-0 IMPLIES LINE OPEN +MIBFRS==10 ;# MAIN/INTERUPT LEVEL COMMUNICATION BUFFERS +.ENDC ;GT40P +.IFNZ PCHIST +PCS==90. ;# PC'S TO SAVE +PCL==4 ;LENGTH OF EACH PC RECORD +PCBFL==PCS*PCL ;SIZE OF PC BUFFER +.ENDC + + +;BEGIN CONSOLE RELATED STUFF + +.SBTTL EMT DEFINITIONS + +CONS=164000 ;CONS INTERFACE BASE ADDRESS + +;EMTS +EFATL=EMT!0 ;FATAL ERROR +ETEXT=EMT!1 ;OUTPUT ASCIZ TEXT STRING POINTED TO BY FOLLOWING WD +EERRO=EMT!2 ;OUTPUT TEXT CORRESPONDING TO ERROR CODE IN A +EROBUS=EMT!3 ;READ OBUS INTO DOUBLE WORD POINTED TO BY A +ERIR=EMT!4 ;READ IR INTO TRIPLE WD POINTED TO BY A +ERPC=EMT!5 ;READ MICRO PC INTO WD POINTED TO BY A +ERERWS=EMT!6 ;READ ERROR WORDS INTO DOUBLE WD POINTED TO BY A +EWDIB=EMT!7 ;WRITE DIAG INST BUFFER FROM TRIPLE WD POINTED TO BY A +EDDEST=EMT!10 ;DEPOSIT CONTENTS OF B INTO THREE WD + ;BLOCK POINTED TO BY A. POSITION B + ;INTO DEST FIELD OF ALU OR BYTE INST. + ;THIS IS THE ALSO THE SAME FIELD USED FOR THE + ;DISPATCH OFFSET OF A DISPATCH INSTRUCTION. +EDALUF=EMT!11 ;DEPOSIT B INTO ALU OP FIELD OF BLOCK POINTED TO BY A +EDOBSL=EMT!12 ;DEPOSIT B INTO OUTPUT BUS SELECT FIELD + ; OF U INST POINTED TO BY A +EDMSRC=EMT!13 ;DEPOSIT B INTO M SOURCE FIELD OF U INST + ; POINTED TO BY A +EDASRC=EMT!14 ;DEPOSIT B INTO A SOURCE FIELD OF U INST + ; POINTED TO BY A +EUICLR=EMT!15 ;CLEAR UI 3 REG TEMP BLOCK AND SET UP A + ; TO POINT THERE +EDCLK=EMT!16 ;TICK CLOCK ONCE IN DEBUG MODE +EDMM0=EMT!17 ;DEPOSIT CONTENTS OF TWO WD BLOCK + ; POINTED TO BY A IN DEST GIVEN BY B. + ; B IS INTERPRETED AS A DESTINATION FIELD + ; (AS IN ALU INSTRUCTION). IF B IS + ; A M MEMORY LOCN, DESIRED VALUE IS + ; "BUILT UP" DIRECTLY IN B. OTHERWISE, + ; IT IS BUILT UP IN M MEM LOCN 0 AND + ; THEN STORED IN B. +ENPCLK=EMT!20 ;TICK CLOCK ONCE WITH NO-OP BIT ON +EEXAMD=EMT!21 ;EXAMINE DATA PATH MEMORIES. LOCN OF TWO + ; WD BLOCK IN A, MEM LOCN + ; (AS FOR DESTINATION) IN B +EDJPC=EMT!22 ;DEPOSIT B IN PC FIELD (OF JUMP INST) + ; IN BLOCK POINTED TO BY A +EDCMEM=EMT!23 ;DEPOSIT 3 WD BLOCK IN A IN CONTROL MEM + ; AT ADR IN B +EICLR=EMT!24 ;ZERO 3 WD BLOCK POINTED TO BY A +ECLK=EMT!25 ;CYCLE CLOCK ONCE IN REGULAR RUN MODE +EEXAMC=EMT!26 ;EXAMINE CONTROL MEM AT LOCN IN B. + ; RETURN RESULT IN BLOCK POINTED TO BY A +ENCLK=EMT!27 ;CYCLE CLOCK ONCE IN REGULAR RUN MODE + ; BUT WITH NO-OP BIT SET +EOCTP4=EMT!30 ;DO 4 DIGIT PRINT OF # IN A +EOCTPD=EMT!31 ;PRINT OUT TWO WD BLOCK POINTED TO BY A AS 11 OCTAL DIGITS +EPI=EMT!32 ;PRINT 3 WD BLOCK POINTED TO BY A AS U INST +EPASRC=EMT!33 ;EXTRACT A SOURCE FIELD AND PRINT IT +EPMSRC=EMT!34 ;EXTRACT M SOURCE FIELD AND PRINT IT +EPDEST=EMT!35 ;EXTRACT DEST FIELD (OF ALU OR BYTE) AND PRINT IT +EPOBSL=EMT!36 ;EXTRACT OUTPUT BUS SELECT (OF ALU) AND PRINT IT +EPALUF=EMT!37 ;EXTRACT ALU FUNCTION (OF ALU INST) AND PRINT IT +EPCRYC=EMT!40 ;EXTRACT CARRY CONTROL FIELD OF ALU INST AND PRINT IT +EPQC=EMT!41 ;EXTRACT Q CONTROL FIELD OF ALU INST AND PRINT IT +EPDDC=EMT!42 ;EXTRACT DISPATCH CONSTANT OF DISPATCH INST AND PRINT +EPDDO=EMT!43 ;EXTRACT DISPATCH OFFSET AND PRINT IT +EPDNB=EMT!44 ;EXTRACT DISPATCH # OF BITS FIELD AND PRINT IT +EPMROT=EMT!45 ;EXTRACT M ROTATE FIELD AND PRINT IT +EPJPC=EMT!46 ;EXTRACT JUMP ADDRESS FIELD OF JUMP INST AND PRINT IT +EPJRB=EMT!47 ;PRINT JUMP INST R BIT +EPJPB=EMT!50 ;PRINT JUMP INST P BIT +EPJNB=EMT!51 ;PRINT JUMP INST N BIT +EPJINV=EMT!52 ;PRINT JUMP INVERT SENSE BIT +EPJCND=EMT!53 ;PRINT JUMP CONDITION FIELD +EPBMD=EMT!54 ;PRINT BYTE INST MODE (LDB DPB ETC) +EPBLEN=EMT!55 ;PRINT BYTE INST BYTE LENGTH + +EXFLD=EMT!56 ;EXTRACT BYTE FROM UINST IN 3 WD BLOCK +ELDB=EMT!56 ; POINTED TO BY A. + ;B HAS FIELD DESCRIPTION (SEE IPNFLD) + ;RETURN RESULT IN A. + +EWPC=EMT!57 ;WRITE CONTENTS OF WD POINTED TO BY A + ;INTO PC OF CONS +EPERRS=EMT!60 ;PRINT TWO WORD BLOCK POINTED TO BY A + ; INTERPRETED AS ERROR BITS +ESTOP=EMT!61 ;STOP CONS AND CLEAR CONS RUNNING FLAG +EDPB==EMT!62 ;DEPOSIT B IN WORD BLOCK POINTED TO BY A + ;AT POSITION SPECIFIED BY "BYTE POINTER" + ;IN C. WORKS FOR UP TO 3 PRECISION +EDMDST==EMT!63 ;DEPOSIT B IN M MEM PART OF DEST OF BLOCK (A) +EDRDST==EMT!64 ;DEPOSIT B IN REG PART OF DEST OF BLOCK (A) +EDDSPO==EMT!65 ;DEPOSIT B IN DISPATCH OFFSET FIELD OF BLOCK (A) +ERPDLB==EMT!66 ;READ PDL BUFFER ADR IN B INTO 2 WD + ; BLOCK POINTED TO BY A +EWPDLB==EMT!67 ;DEPOSIT BLOCK POINTED TO BY A IN + ;PDL BUFFER ADR IN B +ESUSTK==EMT!70 ;SAVE ENTIRE U STACK IN USSVD BLOCK + ; SAVES POINTER IN USTPNR + ;NOTE: TESTS USSVDF TO SEE IF USTACK + ; ALREADY SAVED. IF SO, DOES NOTHING +EUUSTK==EMT!71 ;UNSAVE ENTIRE U STACK AND POINTER + ; IF THEY HAVE BEEN SAVED BY ESUSTK +ETEXTP==EMT!72 ;OUTPUT ASCIZ TEXT STRING POINTED TO BY A +ECCLK==EMT!73 ;DO ECLK UNLESS NOOPF SET, IN WHICH CASE + ;DO ENCLK. CLEAR NOOPF. +EDCCLK==EMT!74 ;DO EDCLK UNLESS NOOPF SET, IN WHICH CASE + ;DO ENPCLK +ERESET==EMT!75 ;RESET CONS +ERDSP==EMT!76 ;READ DISPATCH MEM INTO WD POINTED TO BY A, + ;ADDR IN B. TRANSPARENT TO DISPATCH CONSTANT REGISTER. +EWDSP==EMT!77 ;WRITE DISPATCH MEM FROM WD POINTED TO BY A, + ;ADDR IN B. TRANSPARENT TO DISPATCH CONSTANT REGISTER. +ERDSPC==EMT!100 ;READ DISPATCH CONSTANT REGISTER INTO WD POINTED TO BY A +EWDSPC==EMT!101 ;WRITE DISPATCH CONSTANT REGISTER FROM WD POINTED TO BY A +EWIR==EMT!102 ;DO EWDIB, THEN ENPCLK TO LOAD INTO IR +EDPBLK==EMT!103 ;TAKES POINTER TO 4 WD BLOCK IN A. + ;FIRST WD IS REGISTER ADR, + ;NEXT THREE ARE VALUE, WHICH IS + ;DEPOSITED IN INDICATED ADR +ERL1MP==EMT!104 ;READ LVL 1 MAP INTO WD POINTED TO BY A. ADR IN B. +EWL1MP==EMT!105 ;WRITE LVL 1 MAP FROM WD POINTED TO BY A. ADR IN B. +ERL2MP==EMT!106 ;READ LVL 2 MAP INTO 2 WD BLOCK POINTED TO BY A. + ;ADR IN B. +EWL2MP==EMT!107 ;WRITE LVL 2 MAP INTO 2 WD BLOCK POINTED TO BY A. + ;ADR IN B. +ERMEMS==EMT!110 ;SAVE MEM SUBROUTINE (VMA+MWD) +EWMEMS==EMT!111 ;WRITE MEM SUBROUTINE (VMA+MWD) +ERDBLK==EMT!112 ;TAKES POINTER TO 4 WD BLOCK IN A. + ;FIRST WD IS REGISTER ADR. EXAMINE THIS ADR, AND STORE + ;RESULT IN NEXT THREE WORDS. +EWPVMA==EMT!113 ;WRITE "PHYSICAL" VMA. TAKES POINTER TO TWO WD BLOCK + ; AND LOADS VMA, LVL 1 AND 2 MAPS SO THAT LOCN WILL BE REF'ED + ; (CLOBBERS MWD) +EMMWC==EMT!114 ;CAUSE MAIN MEMORY WRITE CYCLE. (ASSUME EVERYTHING SET UP, + ; IE, DATA IN MWD, ADR IN VMA AND MAPS, ETC) +EMMRC==EMT!115 ;CAUSE MAIN MEMORY READ CYCLE. (ASSUME ADR IN VMA AND MAPS) +EVMEMS==EMT!116 ;VALIDIFY MEMORY SUBROUTINE (JUST THE MAPS, NOT MWD,MRD,VMA) + +;TRP S ARE SIMILAR TO EMTS BUT SAVE ALL AC S BEFORE DISPATCH +;AND RESTORE AFTERWARDS. NO PROVISION FOR ERROR RETURN VIA +;CARRY FLAG. + +TRP=104400 + +IFATL=TRP!0 ;FATAL ERROR +IPNFLD=TRP!1 ;EXTRACT AND PRINT NUMERIC FIELD. + ; POINTER TO U INST IN A. + ; B HAS FIELD DESCRIPTOR. + ; BYTE 1 LENGTH IN BITS, + ; BYTE 0 NUMBER OF BITS OVER (TRIPLE + ; PRECISION WISE) + ;AFTER EXTRACTION, FIELD IS PRINTED AS + ;A FIXED WIDTH OCTAL FIELD, WHERE WIDTH + ;IS JUST GREAT ENUF TO ACCOMODATE FIELD + ;SIZE +IPSFLD=TRP!2 ;EXTRACT AND PRINT "SYMBOLIC" FIELD. + ; POINTER TO UINST IN A + ; FIELD DESCRIPTION IN B (SAME AS FOR + ; IPNFLD). + ; TABLE BASE IN C. + ;FIELD IS EXTRACTED, THEN VALUE USED TO + ;INDEX WORD ORIENTED TABLE STARTING AT + ;ADR IN C. WORD FROM TABLE POINTS AT + ;.ASCIZ STRING WHICH IS PRINTED. + + +;EETST=EMT 1 ;EXAMINE CONS TO SEE IF ANY ERRORS ARE ON. (PARITY, ETC) +; ; IF SO, DISPLAY ERRORS AND RETURN WITH CARRY SET. +; ; IF NOT, RETURN WITH CARRY CLEAR +;ENORM=EMT 2 ;"NORMALIZE" CONS. IE CYCLE CLOCK ONCE WITH NO-OP ON TO ASSURE +; ; THAT EVERYTHING THATS GOING TO GET WRITTEN, GETS WRITTEN, ETC. +;ERDOB=EMT 3 ;READ OBUS INTO DOUBLE WORD POINTED TO BY AC A. +;ERDIR=EMT 4 ;READ IR INTO TRIPLE WORD POINTED TO BY AC A. +;EWDIB=EMT 5 ;WRITE TRIPLE WORD POINTED TO BY A +; ; INTO DIAGNOSTIC INSTRUCTION BUFFER +;EWCM=EMT 6 ;WRITE CONTROL MEMORY. A POINTS TO THREE WORD BLOCK, +; ; B GIVES CONTROL MEMORY ADDRESS. CHECKS DATA WRITTEN +; ; AND RETURNS WITH CARRY SET IF BAD. +;ERCM=EMT 7 ;READ CONTROL MEMORY. A POINTS TO THREE WORD BLOCK, +; ; B GIVES CONTROL MEMORY ADDRESS. +;ERPC=EMT 10 ;READ MICRO PC INTO ADDRESS POINTED TO BY A +;EWPC=EMT 11 ;WRITE MICRO PC FROM LOCN POINTED TO BY A +;EROPC=EMT 12 ;READ OPC VECTOR INTO 8 REGISTER VECTOR POINTED TO BY A +;ERDSM=EMT 13 ;READ DISPATCH MEMORY. LOCN IN B. +;EWDSM=EMT 14 ;WRITE DISPATCH MEMORRY. LOCN IN B. +;ERAM=EMT 15 ;READ A MEM. POINTER TO TWO WD BLOCK IN A. LOCN IN B +;ERMM=EMT 16 ;READ M MEM. (OR MMUX). +;EWDATM=EMT 17 ;WRITE "DATA PATH" MEMORIES. B HAS WHAT TO PUT IN DEST OF INST. + +.SBTTL DEFINE VARIOUS CONS MACHINE WORD FORMATS + +;"PSEUDO" DESTINATION DEFS +; EDMM0 KNOWS ABOUT THESE. THEY ARE DISTINGISHED FROM REAL +; DESTINATIONS BY PRESENCE OF 2000 BIT +; THESE REGISTERS ARE UNUSAL IN THAT THEY CANNOT BE SPECIFIED +; AS A NORMAL "FUNCTIONAL DESTINATION". +CSDQ== 2000 ;Q REGISTER +CSDUSP==2001 ;U CODE STACK POINTER +CSDDC== 2002 ;DISPATCH CONSTANT REGISTER + + +;CONS MICRO WORD FIELD DEFS + +CDAMEM==1000 ;IF SET, SELECT DEST TO A MEMORY + CAMEMB==200 ; SAME BIT IN DIRECT FORM (IE IN WD1) +CDMD== 40 ;MEMORY DATA REG +CDMDWN==100 ;MEMORY DATA REG, WRITE NOW +CDVMA== 200 ;VMA +CDVMAR==240 ;VMA START READ +CDVMAW==300 ;VMA START WRITE +CDVMAM==340 ;VMA WRITE MAP +CDCPPH==440 ;PDL(POINTER), PUSH +CDCPI== 500 ;PDL(INDEX) +CDPI== 540 ;PDL INDEX +CDPP== 600 ;PDL POINTER +CDSPCH==640 ;MICRO-PC-STACK(SPCPTR), PUSH SPCPTR +CDIMH== 700 ;INSTRUCTION MODIFIER HI (44-24) +CDIML== 740 ;INSTRUCTION MODIFIER LO (23-0) + +;O BUS CONTROL (ALU INST) +COBMSK==0 ;SELECT MASKING LOGIC (RANDOM) +COBA== 1 ;SELECT ALU OUTPUT +COBAR==2 ;SELECT ALU OUTPUT SHIFTED RIGHT 1 +COBAL==3 ;SELECT ALU OUTPUT SHIFTED LEFT 1 + +;ALU FUNCTION DEFS (NOTE: THE M MUX IS HOOKED TO THE "A" SIDE OF THE ALU) +; BOOLEAN ONES ( AND THE A MEMORY IS HOOKED TO THE "B" SIDE) +USETCM==20 ;OUTPUT COMPLEMENT OF M SIDE +UANDCB==21 ;AND, COMPLEMENT BOTH +UANDCM==22 ;AND, COMPLEMENT M +USETZ== 23 ;OUTPUT ZEROS +UORCB== 24 ;IOR, COMPLEMENT BOTH +USETCA==25 ;OUTPUT COMPLEMENT OF A SIDE +UXOR== 26 ;XOR +UANDCA==27 ;AND, COMPLEMENT A SIDE +UORCM== 30 ;IOR, COMPLEMENT M SIDE +UEQV== 31 ;EQV +USETA== 32 ;OUTPUT A SIDE +UAND== 33 ;AND +USETO== 34 ;OUTPUT ONES +UORCA== 35 ;IOR, COMPLEMENT A SIDE +UIOR== 36 ;IOR +USETM== 37 ;OUTPUT M SIDE +; ARITHMETIC ONES +UAOSM== 0 ;OUTPUT M+1 +USUB== 6 ;OUTPUT M-A +UADD== 11 ;OUTPUT M+A +UASHM== 14 ;OUTPUT M+M (IE ASH M 1) +USOSM== 17 ;OUTPUT M-1 + + +;CONS OP CODES (IN PROPER PLACE FOR BIS ING INTO 3 WD) +CIALU==0 ;ALU +CIDSP==200 ;DISPATCH +CIJMP==400 ;JUMP +CIBYTE==600 ;BYTE + +CIPJB==100 ;POPJ-AFTER-NEXT BIT + +;CONS JUMP INSTRUCTION BITS +CIJRB==1000 ;RETURN BIT +CIJPB==400 ;PUSHJ BIT +CIJNB==200 ;N BIT (NO-OP FOLLOWING INST) +CIJINV==100 ;INVERT JUMP SENSE +CIJTC==40 ;TEST CONDITION (AS OPPOSED TO TEST BIT) + +;CONS JUMP INSTRUCTION CONDITIONS +CIJALN==CIJTC+1 ;ALU NEGATIVE CONDITION +CIJA31==CIJTC+2 ;ALU BIT 31 +CIJAEM==CIJTC+3 ;A = M CONDITION +CIJINT==CIJTC+4 ;INTERRUPT PENDING CONDITION +CIJPF==CIJTC+5 ;VMA NOT OK CONDITION (PAGE FAULT) +CIJPFI==CIJTC+6 ;VMA NOT OK OR INTERRUPT PENDING +CIJUC==CIJTC+7 ;UNCONDITIONAL 1 + +;CONS M SOURCE DEFS +CMSMMD==42 ;MAIN MEMORY DATA +CMSMWD==52 ;MAIN MEMORY WRITE DATA +CMSVMA==62 ;VMA +CMSPMD==72 ;PAGE MAP DATA +CMSQ== 43 ;Q REGISTER +CMSPPI==44 ;PDL INDEX (9-0), PDL POINTER (19-10) +CMSUS== 45 ;U STACK DATA (17-0) U STACK POINTER (31-27) +CMSUSP==55 ;SAME AS ABOVE, ALSO POP SPC POINTER +CMSDC== 46 ;DISPATCH CONSTANT +CMSCI== 47 ;PDL (INDEX) +CMSPPP==57 ;PDL (POINTER), POP +;67 UNUSED +CMSCP== 77 ;PDL (POINTER) + + +;CONS FUNCTIONAL DESTINATION DEFS +CFDMWD==1 ;MAIN MEMORY WRITE DATA REGISTER +CFDMMW==2 ; AS ABOVE, AND INITIATE WRITE +;3 +CFDVMA==4 ;VMA +CFDVMR==5 ;VMA, START READ +CFDVMW==6 ;VMA, START WRITE +CFDVWM==7 ;VMA, WRITE MAP +CFDCP==10 ;PDL(POINTER) +CFDCPP==11 ;PDL(POINTER), PUSH +CFDCI== 12 ;PDL(INDEX) +CFDPI== 13 ;PDL INDEX +CFDPP== 14 ;PDL POINTER +CFDUSP==15 ;U STACK (CAUSES PUSH) +CFDIMH==16 ;INST MOD HI (44-24) +CFDIML==17 ;INST MOD LO (23-0) + +;BITS IN DISPATCH MEM +CDMPAR==100000 ;PARITY BIT +CDMR==40000 ;R +CDMP==20000 ;P +CDMN==10000 ;N + +;MISC FUNCTION BITS (IN POSITION FOR BIS ING INTO FIRST WD OF U INST) +CMF1==1_10. +CMF2==2_10. +CMF3==3_10. + +;ERROR BITS +;ERROR WD 1 +; HIGH BYTE FROM 164000 HIGH BYTE +CESPCP==100000 ;SPC PARITY +CEDSPP==40000 ;DISPATCH PARITY +CEHIER==20000 ;HIGH RUN LOSSAGE +CECP== 10000 ;MAIN CONTROL MEM PARITY (IN IR NOW) +CEMMP== 4000 ;M MEM PARITY +CEAMP== 2000 ;A MEM PARITY +CEPDL== 1000 ;PARITY ERROR IN PDL BUFFER +CEMNMP==400 ;MAIN MEMORY PARITY +; LOW BYTE FROM 164002 HIGH BYTE +; ;200 ;100000 ;- ERRHALT +CEHNOK==100 ;40000 ;- HIGH OK (DC SIGNAL) +CESRUN==40 ;20000 ;S RUN (1 IF RUN=1 AND ALL ERRORS ARE 0) +CESSDN==20 ;10000 ;SINGLE STEP DONE +; 4000,2000,1000, AND 400 BITS ARE OPC BITS AND ARE NOT CONSIDERED +; PART OF ERROR WORD + +;WD1 +; HIGH BYTE FROM HIGH BYTE OF 164010 +CEWIM== 100000 ;WRITE INSTRUCTION MEMORY ON NEXT CLOCK +CEIMOD==40000 ;INSTRUCTON IN IR WAS MODIFIED VIA OA PATHS +CEINOP==20000 ;IF SET, MACHINE WILL NO-OP INSTRUCTION + ; TRYING TO BE EXECUTED ON NEXT CLOCK +; REST OF BITS IN HIGH BYTE OF 164010 ARE IR BITS AND NOT +; CONSIDERED PART OF ERROR WORD. +; LOW BYTE FROM HIGH BYTE OF 164012 + ;200 ;100000 ;UNUSED +CENMMW==100 ;40000 ;NOT WAITING FOR MAIN MEMORY +CEWPDL==40 ;20000 ;WRITE INTO PDL BUFFER WILL OCCUR ON NEXT CLOCK +CEWSPC==20 ;10000 ;WRITE INTO SPC WILL OCCUR ON NEXT CLOCK +CEPF== 10 ;4000 ;MAPPED ADR NOT OK +CEJC== 4 ;2000 ;JUMP CONDITION BIT +CEPCS1==2 ;1000 ;PC SOURCE BIT 1 +CEPCS0==1 ;400 ;PC SOURCE BIT 0 + ; 0 -> PC+1 + ; 1 -> DISPATCH MEM + ; 2 -> SPC (AS IN POPJ) + ; 3 -> IR 23-12 (JUMP OPERATION) + + +.SBTTL START OF PROGRAM + +.=400+PDL + +GO: RESET ;IN THE PRIVACY OF YOUR OWN HOME + MOV #2,CMREQ ;GO INTO CONSOLE MODE AS DEFAULT +GO0: CLR PS + CLR LDBUFF ;CLEAR 10 BUFFER FLAG + CLR DSKRQB+2 ;CLEAR DISK REQUEST + CLR DSKRQB ;MUST BE IN THIS ORDER! + CLR LDBFF2 ;.. + CLR TNRQFG + MOV VERSE,0 + MOV #GO,SP ;SET UP PUSH DOWN POINTER + MOV #KLIBRK,KLIPC ;SET UP INTERRUPT VECTORS + MOV #5_5,KLIPSW + MOV #CLKBRK,LKPC + MOV #6_5,LKPSW + MOV #4_5,A ;LEVEL 4 IN AC A + MOV #6_5,C ;ALL PROCESSOR TRAPS GO ON 6 + CLR TT ;LEVEL 0 IN TT + MOV #NXMPC,B + MOV #NXMFND,(B)+ ;BUS TIME OUT + MOV C,(B)+ + MOV #RESBRK,(B)+ ;RESERVED INSTRUCTION + MOV C,(B)+ + MOV #RUGBRK,(B)+ ;BREAK POINT + MOV C,(B)+ + MOV #IOTBRK,(B)+ ;IOT TRAP + MOV C,(B)+ + MOV #POWERF,(B)+ ;POWER FAILURE + MOV C,(B)+ + MOV #EMTBRK,(B)+ ;EMT + MOV TT,(B)+ ;PUT EMT ON PROGRAM LEVEL (0) + MOV #TRPBRK,(B)+ ;"TRAP" TRAP (LEV 0) + MOV TT,(B)+ + MOV #TYIBRK,TYIPC ;KEYBOARD ON 4 + MOV A,TYIPSW +.IF NZ TVP + CLR TVCTL ;SELECT PLANE 0 + CLR TVCTL2 ;BLACK ON WHITE, CLEAR VIDEO SWITCH +.ENDC ;TVP +.IFNZ GT40P + MOV #DSPC,B ;DISPLAY BREAKS (LEV 4) + MOV #DSBRK,(B)+ + MOV A,(B)+ + MOV #LPBRK,(B)+ + MOV A,(B)+ + MOV #DTOBRK,(B)+ + MOV A,(B)+ + MOV #HMEML,TT + MOV TT,MEMTOP + MOV #FS,T + JSR PC,CLRL3 ;CLEAR ALL OF MEMORY, FIRST NXM STOPS IT +.ENDC ;GT40P + CLR ACTCHR + MOV #BUF,GETCC ;DL11 INPUT VECTOR + MOV #BUF,PUTCC +.IFNZ DEBUG + JSR PC,DEBST ;DO ASSORTED HACKING (RE INTERRUPT VECTORS, ETC.) +.ENDC + MOV #NXMBRK,NXMPC ;ALL FUTHER BUS ERRORS WILL HALT +;DROPS THRU + +;DROPS IN +.IFNZ GT40P ;FREE STORAGE ONLY EXISTS IN GT40 VERSION + MOV MEMTOP,T + MOV #-1,-(T) ;EVERYTHING ABOVE FREE STORAGE RESERVED + MOV T,MEMTOP ;SET UP FREE STORAGE + MOV #FAKEBL+2,T + MOV T,AVAIL + MOV T,ROVER + MOV #FS+2,TT ;SET UP FAKE BLOCK + CLR -2(T) ;SIZE 0 + MOV TT,(T) ;FAKEBL FD PNTR + MOV TT,2(T) ;BACK PNTR + MOV #-1,4(T) ;LOOKS TAKEN FROM ABOVE + MOV T,(TT) ;FD PNTR IN FS + MOV T,2(TT) ;BACK PNTR IN FS + MOV MEMTOP,A + SUB #FS,A ;SIZE OF FREE STORAGE (LEAVE 1 WD FOR -1) + MOV A,-(TT) + CLR RETLAD + CLR TXSTRT + CLR GRSTRT + MOV #DPYRTS,GRJMP + MOV #LOWLIN+TXTIDX,T ;INITIALIZE TEXT RING +GO2: CLR (T)+ + MOV #DPYJMP,(T) + ADD #LHDRS-2,T + CMP T,#HILIN+TXTIDX + BLO GO2 + CLR (T)+ + MOV #DPYRTS,(T) + MOV #-DPYPDL/2,DPYPDC ;SET UP DPY PUSH DOWN LIST + MOV #DPYPDB+DPYPDL,DPYPDP + CLR CPOS ;SET SCREEN VARIABLES + CLR CLINE + MOV #NLINS-CHRHT+1,CURSY ;CURSOR Y + CLR BYTCNT + JSR PC,HU + JSR PC,CLRLIN + MOV #LOWLIN,TXSTRT + MOV #,TEXTP + CLR CASE + DEC OCSR ;FORCE DSBRK TO LOOK AT CSR + MOV #MIBFRS-1,B + MOV #MIBUF,A ;SET THE MAIN/INTERUPT BUFFERS + MOV #6,C ;6 BYTES PER BUFFER + MOV #MIBUF+2,PUTDPY + MOV #MIBUF+2,GETDPY +GO3: MOV A,(A) + ADD C,(A)+ + CLR (A)+ ;FOR ADDRESS + CLR (A)+ ;FOR CONTENTS + DEC B + BGT GO3 + MOV #MIBUF,(A)+ + CLR (A)+ + CLR (A)+ +.ENDC ;GT40P + MOV #100,A + MOV A,TKS ;ENABLE INTERUPTS + MOV A,@AKLIS +.IIF NZ TVP, MOV A,LKS ;CLK BRKS ENABLED IF TV +.IFNZ PCHIST + MOV #PCBUF,PCPNT +.ENDC +.IFNZ GT40P +;.IFNZ DLIMSW ;CLOCK NEEDED ONLY FOR DISPLAY LIMITING +; MOV A,LKS +; CLR DSTOPD +; CLR DTIME +; CLR TICKS +;.ENDC + MOV #DPYSA,@ADPC ;START THE DISPLAY +.ENDC ;GT40P +MAINLR:;CLR LMHTTY + CLR CNHTTY + CLR BLKTIM ;JUST TO GET OUT OF WEDGED STATE IF 60 CY COUNTER OVFL 16 BITS + BR MAINL + + +.SBTTL MAIN LOOP & COMMAND PROCESSOR + +MAINL1: JSR PC,ADDCHR ;PROCESS CHAR FROM INPUT BUFFER +MAINL: CLR RAIDM ;USE WHOLE SCREEN + MOV CURSX,RCURSX + MOV CURSY,RCURSY + TST CMREQ + BGE CMAIN ;GO TO CONSOLE MONITOR MAIN LOOP + JSR PC,GETCHW ;WAIT FOR CHARACTER +; CMP #ESCHR,A +; BNE MAINL1 +; JSR PC,CMND ;PROCESS DISPLAY SLAVE COMMAND + BR MAINL1 + + +CMAIN: ZAPFLG CNHTTY ;INDICATE IN CONSOLE MONITOR MODE + JSR PC,ENTER + JSR PC,CDSPLY ;DISPLAY CONSOLE + JSR PC,RDHU ;HOME UP (BUT STAY BELOW RAID AREA) +CMN1R: CLR REGOPF ;NO REGISTER OPEN +CMN1: CLR DEPFLG ;DEPOSIT DONE FLAG + MOV #-1,RAIDM ;CONFINE PRINTOUT TO BETWEEN RAID AREA AND CONSOLE AREA + MOV #-1,CMREQ ;INDICATE GOT HERE + JSR PC,GECOM ;RETURN WITH ASCIZ STRING IN CBUF + ;IF CNUMF HAS -1, CONVERTED INTEGER IN CNUM, +2, +4 + ;TERMINATING CHR IN A + CMP A,#' ;ALT MODE + BEQ CMNX + TST CVALF + BEQ CMN1A ;NO VALUE, SO WHAT EVER CNUMF HAS IS IT + MOV #CNUM,T ;CNUM MUST BE 0 IF CNUMF IS 0 + MOV #CVAL,TT + ADD (TT)+,(T)+ + ADC (T) + ADD (TT)+,(T)+ + ADC (T) + ADD (TT)+,(T)+ + DEC CNUMF ;INDICATE "NUMBER" +CMN1A: CLR CVALF ;USE UP VALUE + ASL A + MOV A,B + MOV CNUM,A ;(LOW ORDER) ARG ALSO IN A (0 IF NO ARG) + JSR PC,@COMTAB(B) ;ARGP IN CNUMF, ARG IN CNUM + MOV A,CVAL ;BUT THIS IS A NO-OP UNLESS COMMAND HAS DEC'ED CVALF + TST DEPFLG + BEQ CMN1B + JSR PC,CDSPLY ;POSSIBLY UPDATE RAID VARS +CMN1B: BR CMN1 + + +CMNX: JMP MAINLR ;GO BACK TO DATAPOINT MODE + +CMCR: JSR PC,REGCLS ;CLOSE OPEN REG, IF ANY + MOV #15,A + JSR PC,TYOCHR + RTS PC + +COMERR: ETEXT + ASCQQ + TST TNRQFG + BEQ 1$ + CLR LDBUFF ;REQUEST FROM 10 LOST, FLUSH IT + CLR LDBFF2 ;.. + CLR TNRQFG +1$:; CLR LMHTTY ;TAKE TTY AWAY FROM LISP MACHINE + TST CNHTTY + BNE CMAINR + JMP GO0 + +CMAINR: MOV #GO,SP + BR CMN1R + +RDFLD1: ETEXT + ASCXXX +RDFLD: JSR PC,GECOM ;GET FIELD + CMP A,#RUBCOD + BEQ RDFLD1 + CMP A,#7 + BEQ COMERR + TST CNUMF + BLT RDFLDX + CMP A,#40 + BEQ RDFLD ;SPACE DOES NOT TERM NULL FIELD +RDFLDX: RTS PC + +QFF: JSR PC,TVPREP + JSR PC,HU ;CLEAR SCREEN + JSR PC,CLEOF + JSR PC,CDSPLY ;PUT BACK CONSOLE DISPLAY + JSR PC,RDHU ;GO TO TOP OF CONSOLE AREA + CLR BLKDFR + RTS PC + +RDNM: JSR U,ACSAV ;READ NUMBER + JSR PC,GECOM + JSR U,ACRES + TST CNUMF + BNE RDNM1 + SEC ;SET CARRY -> NO NUMBER +RDNM1: RTS PC + +GECOM: CLR SYMFND + JSR PC,GCOM ;GET COMMAND, EVAL SYMS + TST CNUMF + BLT GECOMX + TST CSYL + BEQ GECOMX + MOV #GSYMT,B ;SEARCH SYMTAB +GECSML: CMP B,#GSYMTE + BHIS GECNF ;NOT FOUND + MOV #CBUF,T + MOV (B)+,U +GECSM2: CMPB (T)+,(U) + BNE GECSM3 + TSTB (U)+ + BNE GECSM2 + MOV (B),CNUM ;RETURN VALUE + DEC CNUMF ;INDICATE VALUE PRESENT + DEC SYMFND +GECOMX: RTS PC + +GECSM3: TST (B)+ ;MOVE TO NEXT SYM + BR GECSML + +GECNF: ETEXT + ASCQST + JMP BELL + +SYMFND: 0 + + +GSYMT: ASCRST ;RESET + RARSET + ASCVMA ;VMA + RAVMA + ASCMWD ;MWD + RAMWD + ASCRDR ;RAIDR + RARDRO + ASCNPF ;NOOPF + RACSWO+</2> + ASCLLM ;LLMODE + RACSWO+</2> + ASCFSV ;FSV + RACSWO+</2> + ASCPSV ;PSV + RACSWO+</2> + ASCFD ;FDEST + RAFDO + ASCFS + RAFSO + ASCIR ;.IR + RAIR + ASCSIR ;IR + RASIR + ASCPC ;PC + RAPC + ASCUSP ;USP + RAUSP + ASCQ ;Q + RAQ + ASCDC1 ;DC + RADC + ASCPP ;PP + RAPP + ASCPI ;PI + RAPI + ASCCIB ;CIB + RACIBO + ACVMAR ;CVMAR + RACVMR + ACMRD ;CMRD + RACRDR + ACPMAR ;CPMAR + RACPMR + ACMWD ;CMWD + RACMWD + ACVMAW ;CVMAW + RACVMW + ACPMAW ;CPMAW + RACPMW + ASCMOD ;MODE + RAMOD +GSYMTE: + + +GCOM: MOV #CBUF,GCMPTR + MOV #*2,CBUFC + JSR PC,GCZNM ;ZERO CNUM + CLR CDNUM + MOV #-1,CNUMF + CLR CSYL + CLR COMFRC ;COMMAND FORCE +GCOM1: JSR PC,CTYI +; TST LMHTTY +; BGT LMTYI ;GO FEED CHAR TO LISP MACHINE + CMP A,#3 + BEQ GCOM1 ;IGNORE ^C S (IN CASE THEY COME FROM 10 IN COMMAND FILE) + CMP A,#173 + BLT GCOM1B + SUB #32,A ;COLLAPSE HOLE LEFT BY LOWER CASE LETTERS + BR GCOMT ;LEAVING OPEN BRACE JUST ABOVE ` + +GCOM1B: CMP A,#140 + BLE GCOM1A + SUB #40,A ;UPPER CASEIFY +GCOM1A: TST COMFRC + BNE GCOMT ;FORCE TO BE COMMAND CHAR + CMP A,#'0 + BLT GCOM2 + CMP A,#'9 + BLE GCOMN ;DIGIT +GCOM2: CMP A,#'A + BLT GCOM3 + CMP A,#'Z + BLE GCALP +GCOM3: CMP A,#'. + BEQ GCOMPD + CMP A,#'@ + BEQ GCOMAT ;ATSIGN FORCES NEXT CHR TO DISPATCH +GCOMT: CLRB @GCMPTR ;STORE 0 ON ASCIZ STRING + CMP CBUF,(PC)+ + .ASCIZ /./ + BEQ GCMPT ;GEE THATS OUR SYMBOL!! + TST CSYL + BNE GCOMT1 +GCNONM: CLR CNUMF ;NULLNESS, REALLY NO NUMBER +GCZNM: MOV #CNUM,TT ;ASSURE CNUM IS 0 IF NO NUMBER + CLR (TT)+ + CLR (TT)+ + CLR (TT)+ +GCOMT1: RTS PC + +;LMTYI: CMP A,#23 ;^S TAKEN AS COMMAND EVEN IF LISP MACHINE HAS TTY +; BEQ GCOMT +; CMP A,#24 ;^T .. +; BEQ GCOMT +; CMP A,#30 ;^X .. +; BEQ GCOMT +; CLR -(SP) +; MOV A,-(SP) +; CMP A,#15 +; BNE 1$ +; JSR PC,TYOCHR ;ECHO CR AS CR,LF,CLEOL +;1$: MOV SP,A +; JSR PC,QDPRC0 +; CMP (SP)+,(SP)+ ;FLUSH TEMP REGISTERS +; BR GCOM + +GCMPT: MOV CONSPT,CNUM ;SUPPLY VALUE OF PT + DEC CNUMF ;MAKE NUMBER AGAIN + BR GCOMT1 + +GCOMAT: DEC COMFRC ;FORCE TO BE COMMAND + BR GCOM1 + +GCOMN: MOV #CNUM,C ;ASSEMBLE OCTAL NUMBER + JSR PC,GCOMN1 + ASL CDNUM + ADD CDNUM,T ;WHICH HAS LAST DIGIT + ASL CDNUM + ASL CDNUM + ADD T,CDNUM ;ASSEMBLE DECIMAL NUMBER + ; 8+2=10.! + BR GCCHRS + +GCOMPD: MOV CDNUM,CNUM ;USE DECIMAL NUMBER + CLR CNUM+2 ;LOSER S WHO TYPE THREE PRECISION DECIMAL NUMBERS DESERVE TO LOSE + TST CSYL + BEQ GCALP ;NO FLOATING POINT! INITIAL . IS ALPHABETIC + BR GCCHRS + +GCOMN3: JSR PC,GCOMN2 ;THREE PRECISION DOUBLE ASL (C) +GCOMN2: ASL (C) ;THREE PRECISION ASL (C) + ROL 2(C) + ROL 4(C) + RTS PC + +GCOMN1: JSR PC,GCOMN3 + JSR PC,GCOMN2 +GCOMN5: MOV A,T + SUB #'0,T +GCOMN4: ADD T,(C) + ADC 2(C) + ADC 4(C) + RTS PC + + +GCALP: JSR PC,GCNONM ;NO NUMBER +GCCHRS: MOV #-1,CSYL + DEC CBUFC + BLE GCCHR1 + MOVB A,@GCMPTR ;STORE CHAR IN STRING + INC GCMPTR +GCCHR1: JMP GCOM1 + +CTYI: MOV CURSX,RCURSX ;MAKE SURE CURSOR DISPLAYING IN RIGHT PLACE + MOV CURSY,RCURSY +CTYI1B: TST TENMOD + BNE CTYI1 ;PDP-10 MODE, DONT TOUCH + JSR PC,WATST ;STARTING A WAIT, SO MAYBE RELOAD IR +CTYI1: TST LDBFF2 + BNE 1$ + TST LDBUFF + BEQ CTYI1A ;NO COMMAND FROM 10 +1$: JSR PC,C10CM ;PROCESS 10 COMMAND + BR CTYI1B ;THAT MAY HAVE CLOBBERED IR, SO PUT IT BACK + +CTYI1A: TST DSKRQB ;REQUEST FROM 10? + BEQ 2$ ;NO + JSR PC,DSKRUN ;YES, RUN THE DISK +2$: TST TENMOD + BNE 1$ ;PDP-10 MODE, DONT TOUCH + TST CTRUN + BEQ 1$ + TST 164002 ;IF CONS TRYING TO RUN, BUT HALTED, + BMI 1$ + CLR CTRUN ;LOSE, ERROR; NOT ONLY STOP, BUT STOP TRYING + JSR PC,ENTER ;SAVE STATE OF MACHINE + JSR PC,CDSPLY ;AND UPDATE THE DISPLAY +1$: +CTYI1C: JSR PC,FOO105 ;CHECK FOR 105 FOOBAR REQUEST + MOV TYICH,A ;COMMAND TYPEIN. + BEQ CTYI1 ;NO CHR + CLR TYICH + PUSH A + CMP A,#40 + BLT CTYI2 ;DONT ECHO CONTROL CHRS + CMP A,#177 + BEQ CTYI2 ;NOR RUBOUT + JSR PC,ADDCHR ;ECHO CHR +CTYI2: POP A + RTS PC + +WATST: TST CPSVAL ;POSSIBLY STARTING A WAIT, SO RELOAD IR + BEQ WATSTX ; SAVED IR NOT VALID + MOV #CIR,A + EWIR ;RELOAD IR SO ITS THERE FOR DEBUGGING +WATSTX: RTS PC + +CDSPLY: PUSH RAIDM ;GOING TO DISPLAY TEXT OUTSIDE MAIN WINDOW + CLR RAIDM + PUSH CPOS ;SAVE CURRENT CURSOR POS + PUSH CLINE + TST CLLMOD + BNE CDSPL1 ;DONT DISPLAY RAID STUFF IN LL MODE + JSR PC,TVPREP + JSR PC,HU ;START AT TOP OF SCREEN + CLR B +CDSRL: TST RAIDA(B) + BEQ CDSRL1 ;THAT ONE NULL + PUSH B + ASR B ;FLUSH BYTE BIT + MOV #1,C + JSR PC,OCTPNB ;PRINT RAID REG # + ETEXT + ASCSP ;PRINT SPACE + MOV (SP),B + MOV RAIDA(B),A + JSR PC,REGPNT ;PRINT IT OUT + TST CPOS ;CR IF NOT AT BEG OF LINE + BEQ CDSRL2 + ETEXT + ASCCR +CDSRL2: POP B +CDSRL1: TST (B)+ + CMP B,#<10*2> + BLT CDSRL ;LOOP IF NOT THRU +CDSPL1: CLR A ;UPDATE CONSOLE DISPLAY SECTION + MOV CDLNN,B ;LINE NUMBER TO START CURSOR DISPLAY ON + JSR PC,CSRPOS + ETEXT + CSTARS + MOV CPC,A ;PRINT PC + EOCTP4 ;4 DIGIT OCTAL PRINT + ETEXT + ASC3SP + MOV #CIR,A + EPI + ETEXT + COBTX + MOV #COBUS,A ;PRINT OUTPUT BUS + MOV #<<32.*400>+0>,B + IPNFLD + MOV #/2>>,A + JSR PC,REGPNT ;PRINT LLMODE=X + MOV #/2>>,A + JSR PC,REGPNT ;PRINT FSV=X + MOV #/2>>,A + JSR PC,REGPNT ;PRINT PSV=X + MOV #/2>>,A + JSR PC,REGPNT ;PRINT NOOPF=X + ETEXT + CERRST + MOV #CCERR1,A + EPERRS + POP B + POP A + JSR PC,CSRPOS ;RESTORE CURSOR POS + CLR BLKDFR + POP RAIDM + RTS PC + +;CONSOLE COMMAND PROCESSOR COMMAND FORMAT +; COMMANDS TO THE CONSOLE PROCESSOR ARE A SINGLE CHARACTER +; THEY MAY TAKE A (16 BIT MAX) NUMERIC ARG PRECEEDING. +; MANY COMMANDS ARE "INTERACTIVE" IN THAT THEY PROMPT THE +; USER FOR FURTHER ARGS ETC AFTER THE COMMAND IS INVOKED. +; WHEN THE USER IS PROMPTED, THE STANDARD DEFAULT FOR +; "I DONT WANT TO BOTHER ABOUT THIS FIELD, GO ON TO THE NEXT ON/E" +; IS SPACE. A CR USUALLY SAYS "FINISH OFF THE COMMAND AND +; EXECUTE IT. A RUBOUT INDICATES AN ERROR WAS MADE IN TYPING +; THE LAST FIELD. THE LAST FIELD IS ERASED AND MAY BE TYPED +; IN AGAIN. A CONTROL G QUITS OUT OF THE COMMAND IMMEDIATELY +; WITHOUT EXECUTING IT. + +; ARGUMENTS AND VALUES. +; MANY COMMANDS CAN TAKE A NUMERIC ARGUMENT PRECEEDING +; THE COMMAND. IF NO ARGUMENT IS TYPED, THE ARGUMENT MAY +; BE SUPPLIED BY THE VALUE OF THE LAST COMMAND. +; ANY ARGUMENT TYPED OVERRIDES THE VALUE OF THE LAST COMMAND, +; HOWEVER. A CR INTERPRETED AT TOP LEVEL CAUSES THE VALUE +; OF THE LAST COMMAND TO BE DISCARDED. + +; VARIOUS MEMORIES. +; THE CONSOLE PROGRAM KNOWS ABOUT THE FOLLOWING MEMORIES: +; INTERNALLY, THESE MEMORIES ARE "ADDRESSED" BY A SINGLE +; SIXTEEN BIT QUANTITY, CALLED THE "REGISTER ADDRESS". +; IN PARENS BELOW IS THE "KEY" USED TO DENOTE +; "SYMBOLICALLY" ADDRESSES IN THE GIVEN MEMORY. +; THE ADDRESS SPACE BELOW COMMENCES AT 40000. ADDRESSES BELOW THIS ARE +; "NUMBERS". (QUANTITIES WITH THE 100000 BIT SET ARE ALSO NUMBERS, +; CALLED "NEGATIVE NUMBERS"). IF "NUMBERS" ARE USED TO REFERENCE MEMORIES, +; THEY ARE RELOCATED BY THE BASE OF THE LAST MEMORY REFERENCED. + +; REFERENCES TO "MAIN MEMORY". +; GENERALLY SPEAKING, REGISTER ADDRESSES ARE ASSIGNED ONLY TO REGISTERS +; WITHIN THE PROCESSOR ITSELF. THUS, TO REFERENCE MAIN MEMORY ONE MUST +; "SIMULATE" WHAT THE MICROCODE ITSELF MUST DO (IE LOAD THE VMA-START-READ +; AND READ THE READ-DATA-REGISTER, ETC.) ADDITIONALLY, THE MAP (BOTH 1ST +; AND 2ND LEVELS MUST BE SET UP PROPERLY. THIS IS A GREAT PAIN, AND ALSO +; IS VERY INEFFICIENT. BELOW IS DESCRIBED A MECHANISM FOR SOMEWHAT +; ALEVIATING THIS PROBLEM. +; PART OF THE PROBLEM IS THE NECESSITY OF SAVING AND RESTORING THE +; VARIOUS REGISTERS (VMA, MWD, LEVEL 1 AND 2 MAP). TO ASSIST HERE, +; SEVERAL "VIRTUAL" REGISTERS ARE DEFINED. THESE HAVE FUNCTIONS SIMILAR +; TO THE HARDWARE ONES, BUT HAVE INDEPENDANT EXISTANCE. THE CONSOLE PROGRAM +; TAKES CARE OF SAVING AWAY THE "REAL" VALUES AND RESTORING THEM AT THE +; APPROPRIATE TIMES. +; FOR ADDITIONAL "EFFIECIENCY" ON REFERENCES FROM THE 10, A HACK IS +; PROVIDED WHICH MAKES IT POSSIBLE TO DO A "COMPLETE" OPERATION IN ONE +; 4 WORD COMMAND BLOCK. THIS HACK IS TRIGGERRED WHEN THE 10 SPECIFIES A +; NEGATIVE REGISTER ADDRESS. THE PARTICULAR OPERATION IS SPECIFIED +; BY THE MAGNITUDE OF THE REGISTER ADDRESS. THE MOST NOTABLE ONES ARE +; MAIN MEMORY READS (PHYSICAL AND VIRTUAL PROVIDED). THE OPERATION IS TO +; WRITE THE VMA-START-READ FROM THE DATA, THEN CLOBBER THE DATA WITH THE +; READ DATA REGISTER. (IF IT WERE NOT FOR THIS HACK, ONE WOULD HAVE TO +; "TURN THE BUFFER AROUND" FOR EVERY INDIVIDUAL EXAMINE SINCE IT WOULD +; CONSIST OF "WRITING" THE VMA-START-READ AND "READING" THE READ-DATA-REGISTER.) +; SINCE DATA IS ACTUALLY FLOWING IN BOTH DIRECTIONS, NEGATIVE REGISTER +; ADDRESSES ARE DECODED IDENTICALLY REGARDLESS OF WHICH WAY THE BUFFER +; IS SET UP. + + +;BASIC COMMANDS: +; REGISTER EXAMINATION +; / TAKES AS ARG ADDRESS. IF ITS A "NUMBER" IT IS RELOCATED BY +; CURRENT DEFAULT MEMORY. GOES TO APPROPRIATE EXAMINE ROUTINE +; WHICH PRINTS CONTENTS OF INDICATED MEMORY. THEN GOES TO +; TO DEPOSIT ROUTINE WHICH GIVES USER AN OPPORTUNITY TO ALTER +; REGISTER CONTENTS +; EXAMINE NEXT REGISTER +; EXAMINE PREVIOUS +; \ PROMPTS WITH MEM? USER TYPES SYMBOLIC MEMORY DESIGNATOR. +; RETURNS VALUE OF REGISTER ADDRESS OF BEGINNING OF SAID MEMORY. +; ^S STOP CONS. +; ^N STEP CONS (ARG # OF TIMES, NO ARG -> 1) +; ^G START CONS (AT LOCATION). IF NO LOCATION, LAST SPECIFIED +; IS USED. IF LOCN IN CI MEM, CONSOLE COMPUTER ENTERS A LOOP +; FEEDING THE CONTENTS OF CI MEMORY AT CONS. + +;STATE SAVING +; THERE ARE TWO "MODES" IN WHICH THE STATE OF CONS CAN BE "SAVED". +; "PASSIVE" MODE CONSISTS OF SAVING JUST WHAT CAN BE WITHOUT AFFECTING +; CONS IN ANY WAY. (IE THAT INFO THAT CAN BE DIRECTLY READ IN: +; THE PC, IR, OUTPUT BUS, AND ERROR INDICATIONS). +; A PASSIVE SAVE CAN BE DONE WITH CONS RUNNING, ALTHO THE RESULTS ARE +; SOMEWHAT RANDOM OF COURSE. +; "FULL" MODE SAVES THE A MEM 0 AND M MEM 0. IT ALSO DOES HAIR NECESSARY +; TO GET STARTED AGAIN RE THE IR. (SIMULATES OA HACKERY, REMEMBERS THE +; NO-OP BIT, ETC.) AFTER A FULL SAVE HAS BEEN DONE, INTERNAL CONS +; REGISTERS CAN BE EXAMINED, MODIFIED, ETC. +; THE PROCESS OF TAKING A FULL SAVE INVOLVES STOPPING CONS. +; NORMALLY WHEN THE CONSOLE LOOP IS ENTERED, FIRST A PASSIVE SAVE IS DONE. +; IF THAT SHOWS CONS STILL TO BE RUNNING, A FULL SAVE IS NOT DONE. +; IF CONS IS NOT RUNNING, A FULL SAVE IS DONE IMMEDIATELY. +; THE ^S COMMAND (STOP) WILL CAUSE A FULL SAVE TO BE DONE. + + +; LOW LEVEL "CLOCK TICKING" +; MOST CONSOLE MONITOR COMMANDS ARE "HIGH LEVEL" IN THE SENSE THAT +; IN ORDER TO EXECUTE THEM THE CONSOLE COMPUTER MUST GO THRU +; A (FREQUENTLY FAIRLY ELABORATE) SERIES OF MACHINATIONS, INVOLVING +; MANY CLOCK CYCLES ON CONS. HOWEVER, A "LOW LEVEL" MODE +; IS PROVIDED, WHICH ALLOWS THE USER TO DIRECTLY MANIPULATE THE MACHINE +; WITHOUT ANYTHING "EXTRA" HAPPENING THE USER DOESNT EXPLICTLY +; COMMAND. IN LOW LEVEL MODE, ONLY INFORMATION THE CONSOLE COMPUTER +; CAN DETERMINE WITHOUT DISTURBING THE STATE OF CONS IS DISPLAYED. +; (THIS CONSISTS OF THE PC, IR, OUTPUT BUS, AND ERROR INDICATIONS, +; IE PASSIVE STATE SAVES.) + +COMTAB: CRTSPC ;0 + COMERR ;^A + COMERR ;^B + CRTSPC ;^C + COMERR ;^D + COMERR ;^E + COMERR ;^F + COMERR ;^G (BELL) + QBS ;^H (BS) + COMERR ;^I (TAB) + QLF ;^J (LF) + COMERR ;^K + QFF ;^L (FF) + CMCR ;^M (CR) + QCN ;^N + COMERR ;^O + QCP ;^P + COMERR ;^Q (MUST BE QUOTED) + QCR ;^R + QCS ;^S + QCT ;^T + COMERR ;^U + COMERR ;^V + COMERR ;^W + COMERR ;^X + COMERR ;^Y + QCZ ;^Z (ZONK) + COMERR ;ALT + COMERR ;^\ + COMERR ;^] + COMERR ;^^ + COMERR ;^_ + QPLS ;SPACE + COMERR ;! + COMERR ;" + COMERR ;# + COMERR ;$ + COMERR ;% + QAMP ;& + COMERR ;' + COMERR ;( + COMERR ;) + COMERR ;* + QPLS ;+ + COMERR ;, + COMERR ;- + COMERR ;. + QSLSH ;/ + + COMERR ;0 (MUST FOLLOW @ TO DISPATCH) + QM1 ;1 + QM2 ;2 + COMERR ;3 + COMERR ;4 + COMERR ;5 + COMERR ;6 + COMERR ;7 + COMERR ;8 + COMERR ;9 + COMERR ;: + COMERR ;; + COMERR ;< + QEQ ;= + COMERR ;> + COMERR ;? + COMERR ;@ + QA ;A (MUST FOLLOW @ TO DISPATCH) + COMERR ;B + QC ;C + QD ;D + COMERR ;E + COMERR ;F + QG ;G + COMERR ;H + COMERR ;I + COMERR ;J + COMERR ;K + COMERR ;L + QM ;M + COMERR ;N + COMERR ;O + QP ;P + COMERR ;Q + COMERR ;R + COMERR ;S + COMERR ;T + QU ;U + COMERR ;V + COMERR ;W + COMERR ;X + COMERR ;Y + COMERR ;Z + COMERR ;[ + COMERR ;\ + COMERR ;] + QUPAR ;^ + COMERR ;_ + COMERR ;` + COMERR ;{ + COMERR ;| + COMERR ;} + COMERR ;~ +RUBCOD=<.-COMTAB>/2 ;MAPPED CODE FOR RUBOUT + COMERR ;RUBOUT +.IFNZ <<.-COMTAB>/2>-200+32 + .PRINT \COMTAB LOSES\ +.ENDC + +QCS: +QDPSTP: CLR CTRUN ;NO LONGER TRYING TO RUN + JSR PC,QDPHLT +QCT1:; CLR LMHTTY ;TAKE TTY AWAY FROM LISP MACHINE + RTS PC + +QDPHLT: ESTOP ;STOP CONS ^S + JSR PC,ENTER ;DO FULL SAVE + RTS PC + +QCT:; TST LMHTTY ;COMPLEMENT STATE OF LISP MACHINE HAVING TTY +; BNE QCT1 +; ZAPFLG LMHTTY + RTS PC + +QA: ADD #RAAMO,A ;ADDRESS A MEM +VALRET: DEC CVALF ;INDICATE VALUE PRESENT + RTS PC + +QU: ADD #RAUSO,A ;ADDRESS U STACK + BR VALRET + +QM: ADD #RAMMO,A ;ADDRESS M MEM + BR VALRET + +QC: ADD #RACMO,A ;ADDRESS MAIN CONTROL MEM + BR VALRET + +QP: ADD #RAPBO,A ;ADDRESS PDL BUFFER + BR VALRET + +QD: ADD #RADMO,A ;ADDRESS DISPATCH MEMORY + BR VALRET + +QM1: ADD #RAM1O,A ;ADDRESS LVL 1 MAP + BR VALRET + +QM2: ADD #RAM2O,A ;ADDRESS LVL 2 MAP + BR VALRET + +PCNSPT: MOV CONSPT,A + JSR PC,QPAD + ETEXT + ASCSLT ;SLASH TAB + MOV CONSPT,A + RTS PC + +REGPNT: PUSH A ;PRINT XXX/ WHERE XXX IS REG ADR + JSR PC,QPAD + ETEXT + ASCSLH + POP A + PUSH REGOPF ;DONT AFFECT REGOPF + MOV #QEXAMV,B + MOV #-1,QEXPF ;WANT TO PRINT IT OUT + JSR PC,REGDC + TST CPOS + BEQ REGPN2 ;DONT PRINT SPACE AT BEG OF LINE + ETEXT + ASCSP ;PRINT SPACE +REGPN2: POP REGOPF + RTS PC + +QUPAR: JSR PC,REGCLS ;CLOSE REG BEFORE MODIFING PT + DEC CONSPT ;UP ARROW (OR CARRET) + BR QLF2 + +QLF: JSR PC,REGCLS ;CLOSE REG BEFORE MODIFING PT + INC CONSPT ;LF EXAMINE NEXT REGISTER +QLF2: TST CPOS + BEQ QLF1 ;CR UNLESS AT BEG OF LINE + ETEXT + ASCCR +QLF1: JSR PC,PCNSPT + DEC CNUMF ;SIGNAL VALID ARG IN A +QSLSH: JSR PC,QPTSET ;SET UP POINT (CONSPT) + MOV #QEXAMV,B ;/ EXAMINE + MOV #-1,QEXPF ;WANT TO PRINT IT OUT + JSR PC,REGDC ;DECODE REGISTER ADDR IN A, DISPATCHING + ;VIA VECTOR IN B + MOV REGDEF,QBLMEX ;BASE OF LAST MEM EXAMINED + RTS PC + +QPTSET: TST CNUMF + BEQ QSLSH3 ;NO ARG + CMP A,#RAORG + BGE QSLSH1 ;REGISTER ADDR, OK + ADD QBLMEX,A ;TRY EXAMINING WITHIN LAST MEM + CMP A,#RAORG + BLT QSLSH2 ;STILL DIDNT WIN, WILL GO TO COMERR +QSLSH1: MOV A,CONSPT ;LAST LOCN EXAMINED +QSLSH2: RTS PC + +QSLSH3: MOV CONSPT,A + RTS PC + +.SBTTL REGISTER ADDRESS DEFS + +RAORG==40000 ; ORIGIN OF REGISTER ADDRESS SPACE +RACMO==40000 ; ORIGIN OF CONTROL MEM + RACME==50000 ; CONTROL MEMORY (C) 4K +RADMO==50000 + RADME==52000 ; DISPATCH MEMORY (D) 1K +RAPBO==52000 + RAPBE==54000 ; PDL BUFFER (P) 1024 REG +RAM1O==54000 + RAM1E==60000 ; MAP (1ST LEVEL)(1) 2048 REG (5 BITS EA) +RAM2O==60000 + RAM2E==62000 ; MAP (2ND LEVEL)(2) 1024 REG (20 BITS EA) +RAAMO==62000 + RAAME==62400 ; A MEMORY (A) 256 REG +RAUSO==62400 + RAUSE==62440 ; U STACK (U) 32 REG +RAMMO==62440 + RAMME==62500 ; M MEMORY (M) 32 REG +RAFSO==62500 ; NOTE: M MEM MUST BE CONTIG WITH FUNCT SRC + RAFSE==62540 ; FUNCTIONAL SOURCES 32 REGS +RAFDO==62540 ; FUNCTIONAL DESTINATIONS 16 REG + RAFDE==62560 + RAMWD==RAFDO+CFDMWD ;MAIN MEM WRITE DATA REGISTER + RAVMA==RAFDO+CFDVMA ;VMA (VIRTUAL MEMORY ADDRESS) + RAPP==RAFDO+CFDPP ;PDL POINTER (TO PDL BUFFER) + RAPI==RAFDO+CFDPI ;PDL INDEX (TO PDL BUFFER) + ; MICROPROCESSOR REGISTERS +RARGO==62560 ; INTERNAL (COPY OF) REGISTER SECTION + RARGE==62600 ; (OR IN SOME CASES, THESE REQUIRE SPECIAL ACCESS FOR + ; "HARWARE" REASONS) +RAPC==62560 ; PC (PC) +RAUSP==62561 ; U STACK POINTER (USP) +RAIR==62562 ; .IR (PUT IN DIAG INST REG, THEN LOAD INTO IR, THEN + ; UPDATE OBUS DISPLAY. DIAGNOSTIC ONLY) +RASIR==62563 ; SAVED IR (THE ONE SAVE ON FULL STATE SAVE + ; AND RESTORED ON FULL RESTORE) + ; THIS IS NORMALLY THE UINST ABOUT TO GET EXECUTED. +RAQ==62564 ; Q REGISTER (Q) +RADC==62565 ; DISPATCH CONSTANT REGISTER (DC) +RARSET==62566 ; RESET REGISTER! DEPOSITING HERE + ; CLEARS ENTIRE C, D, P, M1, M2, A, U AND + ; M MEMORIES! +RASTS==62567 ; STATUS REGISTER (32 BIT, AS READ BY ERERWS) +RAOBS==62570 ; OUTPUT BUS STATUS (32 BITS) +;THE FOLLOWING REGISTERS MAKE VARIOUS FUNCTIONS AVAILABLE TO THE PDP-10 +; WHICH ARE OTHERWISE ACCESSIBLE ONLY BY TYPIN. +RARS== 62571 ; RESET (CNTRL-R) +RASTEP==62572 ; STEP (CNTRL-N) +RASTOP==62573 ; STOP (CNTRL-S) +RASA== 62574 ; SET STARTING ADR (@G) +RAGO== 62575 ; GO (CNTRL-P, BUT KEEP LISTENING) + ; WHEN EXAMINED, RETURN STATE OF CTRUN. +RAMOD== 62576 ;MODE REGISTER, BIT 1.1 => RUN SLOW, BIT 1.2 => DON'T HALT IF ERROR + ; ZERO IS THE NORMAL DEFAULT VALUE FOR THIS REG +RARCON==62577 ;REMOTE CONSOLE, DEPOSIT = TYI, EXAMINE = TYO + + ; BUFFERS WITHIN THE CONSOLE COMPUTER +RACSWO==62600 ; MODE SWITCHES (CLLMOD, ETC) + RACSWE==62620 +RARDRO==62620 ; "RAID" REGISTERS (RAIDR) + RARDRE==62630 +RACIBO==62630 + RACIBE==62640 ; CONSOLE INST BUFFER (CI) 8 REG + ; (EA HOLDS A U INST. CAN BE SENT TO CONS VIA DIB IN A LOOP) + +RACMFO==62640 ; MAIN MEMORY FUNCTION REGISTERS + RACVMR==62640 ; VIRTUAL MEMORY (ADDRESS), INITIATE READ + RACRDR==62641 ; CONSOLE MEMORY READ DATA (LAST READ BY RACVMR OR RACPMR) + RACPMR==62642 ; PHYSICAL MEMORY, INITIATE READ + ; 62643 IS ANOTHER ADDRESS FOR 62642 (FOR LINE-FEEDING CONVENIENCE) + RACMWD==62644 ; CONSOLE MEMORY WRITE DATA REGISTER + RACVMW==62645 ; VIRTUAL MEMORY, INITIATE WRITE + ; 62646 IS ANOTHER ADDRESS FOR 62645 + RACPMW==62647 ; PHYSICAL MEMORY, INITIATE WRITE +RACMFE==62650 + +RAOPCO==62650 ;8 OLD PC REGISTERS +RAOPCE==62660 + + + +; IN ADDITION, THE CONSOLE PROGRAM KNOWS SOME ABOUT THE FOLLOWING, BUT +; THEY OBVIOUSLY DONT FIT INTO THE 16 BIT ADDRESS SCHEME: + +; MAIN MEMORY VIRTUAL ADDRESS - 23 BITS +; MAIN MEMORY PHYSICAL ADDRESS - 20 BITS + +; TELETYPE KLUDGE + +;RATYI==RAAMO+40 ;SET BY 11, CLEARED BY LM +;RATYO==RAAMO+3 ;SET BY LM, CLEARED BY 11 + +.SBTTL REGISTER ADDRESS DECODER + +REGDC: ;DECODE REGISTER ADDR IN A, VECTOR IN B + MOV #REGATL,C ;ADDRESS TABLE +REGDCL: CMP A,(C) + BHIS REGDC1 ;HIGHER THAN THAT + MOV -(C),REGDEF ;BASE OF LAST MEM ADDRESSED + SUB (C),A ;LEAVE RELATIVE ADDR WITHIN MEM IN B + MOV B,C + MOV A,B + MOV #QEXB,A + JMP @(C) ;FOUND IT, GO TO CORRESPONDING PLACE IN GIVEN VECTOR + +REGDC1: TST (B)+ + TST (C)+ + CMP C,#REGATE + BLO REGDCL + JMP COMERR ;OFF END, TOO HIGH + +REGDEF: 0 ;BASE OF LAST MEM SUCCESSFULLY ADDRESSED +QBLMEX: 0 ;BASE OF LAST MEM EXAMINED (WITH /, ETC) +QEXPF: 0 ;EXAMINE PRINT FLAG. IF -1 EXAMINE ROUTINE + ; PRINTS DATA. OTHERWISE, IT RETURNS WITH + ; POINTER TO DATA IN A, AND FIELD SPEC IN B + + 0 ;MUST BE HERE +REGATL: RACMO ;TOO LOW .. +REGATH: RACME ;CONTROL MEM + RADME ;DISPATCH MEM + RAPBE ;PDL BUFFER + RAM1E ;1ST LVL MAP + RAM2E ;2ND LVL MAP + RAAME ;A MEM + RAUSE ;U STACK + RAMME ;M MEM + RAFSE ;FUNCTIONAL SOURCES + RAFDE ;FUNCTIONAL DESTINATIONS + RARGE ;CONSOLE COMPUTER REGS + RACSWE ;CONSOLE COMPUTER MODES AND SWITCHES + RARDRE ;RAID REGISTERS + RACIBE ;CONSOLE COMPUTER INST BUFFER + RACMFE ;MAIN MEMORY FUNCTION REGISTERS + RAOPCE ;OLD PCS +REGATE==. ;TOP + +.SBTTL EXAMINATION ROUTINES + +;IF QEXPF = -1, EXAMINE AND PRINT FROB +;OTHERWISE, RETURN WITH A POINTING TO DATA AND B A FIELD SPEC +QEXAMV: COMERR ;TOO LOW + QEXC ;CONTROL MEM + QEXD ;DISPATCH MEM + QEXPB ;PDL BUFFER + QEX1MP ;1ST LVL MAP + QEX2MP ;2ND LVL MAP + QEXA ;A MEM + QEXUS ;U STACK + QEXM ;M MEM + QEXFS ;FUNCTIONAL SOURCES + QEXFD ;FUNCTIONAL DESTINATIONS + QEXCON ;CONSOLE COMPUTER REGS + QEXSW ;CONSOLE COMPUTER MODES AND SWITCHES + QEXRDR ;RAID REGISTERS + QEXCIB ;CONSOLE COMPUTER INST BUFFER + QEXMMF ;MAIN MEMORY FUNCTION REGISTERS + QEXOPC ;OLD PCS + COMERR ;TOO HI + +QEXCIB: JSR PC,QEXCI1 ;GET BUFFER ADR IN C +QEXSI1: MOV A,B ;PLACE WE WANT TO STORE IT + MOV (C)+,(B)+ ;STORE THREE WDS WORTH + MOV (C)+,(B)+ + MOV (C),(B) + BR QEXIR1 + +QEXCI1: MOV B,C ;EXAMINE CONSOLE INST BUFFER (COMPUTE ADR IN C) + ASL C ;3 WDS PER ENTRY + ADD B,C + ASL C ;CONVERT TO WORDS + ADD #CIBUF,C + RTS PC + +QEXC: EEXAMC ;EXAMINE CONTROL MEM +QEXIR1: MOV #<<44.*400>+0>,B + TST QEXPF + BEQ QEXCX + EPI +CRLF: ETEXT + ASCCR +QEXCX: RTS PC + +QEXFD: EWMEMS ;ASSURE VMA AND MWD VALID + MOV B,C ;FUNCTIONAL DESTINATIONS + MOV #CMSMWD,B ; TRY TO TURN INTO RIGHT THING + CMP C,#CFDMMW + BLE QEXM ;MAIN WRITE MEMORY DATA + MOV #CMSVMA,B ;VMA SOURCE + CMP C,#CFDVWM + BLE QEXM ;EXAMINE VMA IN VARIOUS FORMS + MOV #CMSCP,B ;PDL (POINTER) + CMP C,#CFDCPP + BLE QEXM + MOV #CMSCI,B ;PDL (INDEX) + CMP C,#CFDCI + BLE QEXM + CMP C,#CFDPP + BLE QEXPPI ;EXAMINE PDL INDEX OR PDL POINTER + JMP COMERR ;THATS AS MUCH AS WE FEEL LIKE.. + +QEXOPC: ASL B + MOV OLDPCS(B),(A) + JMP QEXPC0 + +QEXPPI: PUSH C ;EX PDL INDEX OR PDL POINTER + MOV #CMSPPI,B + EEXAMD ;EXAMINE BOTH + POP C + CMP C,#CFDPI + BEQ QEXPP1 ;EX PDL INDEX, ITS IN LOW PART + PUSH A ;EX PDL POINTER, ITS IN HIGH + MOV #<<10.*400>+10.>,B ; PART + EXFLD + MOV A,@(SP) + POP A +QEXPP1: BIC #176000,(A) + CLR 2(A) + MOV #<<10.*400>+0>,B + BR QEXPC1 + +QEXD: ERDSP ;EXAMINE DISPATCH MEM + MOV #<<16.*400>+0>,B + BR QEXPC1 + +QEXFS: EWMEMS ;ASSURE VMA AND MWD VALID + ADD #40,B ;EXAMINE FUNCT SOURCES + BR QEXM ; (TURN INTO M SOURCE) + +QEXA1: MOV CAMEM1,(A) + MOV CAMEM1+2,2(A) + BR QEXPB1 + +QEXM0: MOV CMMEM0,(A) + MOV CMMEM0+2,2(A) + BR QEXPB1 + +QEXA: CMP B,#1 + BEQ QEXA1 ;USE SAVED A MEM 1 + BIS #CDAMEM,B ;EXAMINE A MEM +QEXM: TST B ;EXAMINE M MEM + BEQ QEXM0 ;USE SAVED M MEM 0 + EEXAMD +QEXPB1: MOV #<<32.*400>+0>,B ;FIELD DESCRIPTION +QEXPC1: TST QEXPF + BEQ QEXMX ;JUST WANT TO FETCH DATA + DEC REGOPF + IPNFLD +QEXMX: RTS PC + +QEXQ: MOV #CMSQ,B ;EXAMINE Q + BR QEXM + +QEXPB: ERPDLB ;EXAMINE PDL BUFFER + BR QEXPB1 + +QEXRDR: ASL B ;EXAMINE RAID REGISTER + MOV B,C + MOV RAIDA(C),(A) + MOV #<<16.*400>+0>,B + TST QEXPF + BEQ QEXRDX + MOV (A),A + BEQ QEXRD1 ;0 IS NULL + JSR PC,QPAD ;PRINT IT AS ADDRESS +QEXRST: ;GET HERE TO "OPEN" RESET REGISTER +QEXRD1: ETEXT + ASCSP + DEC REGOPF +QEXRDX: RTS PC + +QEXSW: MOV B,C + ASL C + MOV CSSWO(C),(A) + MOV #<<3.*400>+0>,B ;EXAMINE SWITCH (PRINT ONE DIGIT) + BR QEXPC1 + +QEX1MP: TST B + BEQ QEX1M1 + ERL1MP ;EXAMINE 1ST LVL MAP +QEX1M2: MOV #<<5*400>+0>,B + BR QEXPC1 + +QEX1M1: MOV CL1M0,(A) ;LOCN 0 SAVED AWAY SPECIALLY + BR QEX1M2 + +QEX2MP: TST B + BEQ QEX2M1 + ERL2MP ;EXAMINE 2ND LVL MAP +QEX2M2: MOV #<<20.*400>+0>,B + BR QEXPC1 + +QEX2M1: MOV CL2M0,(A) ;LOCN 0 SAVED AWAY SPECIALLY + MOV CL2M0+2,2(A) + BR QEX2M2 + +QEXSTS: MOV CCERR1,(A) ;EXAMINE SAVED ERROR STATUS + MOV CCERR2,2(A) + BR QEXPB1 + +QEXOBS: MOV COBUS,(A) ;EXAMINE SAVED OBUS STATUS + MOV COBUS+2,2(A) + BR QEXPB1 + +QEXNL: CLR B ;"NULL" EXAMINE + RTS PC + +QEXGO: MOV CTRUN,(A) ;RETURN STATE OF WHETHER TRYING TO RUN OR NOT +QEX1WD: CLR 2(A) + MOV #<<16.*400>+0>,B + JMP QEXPC1 + +QEXMOD: MOV MODREG,(A) ;EXAMINE MODE REGISTER AS LAST SET + BR QEX1WD + +QEXRCN: CLR (A) ;REMOTE CONSOLE EXAMINE, 0 OR CHAR BEING TYO'ED + TST CTRUN + BEQ QEX1WD +;; tyo wait loop in CONS +;; ((M-GARBAGE) A-TYO IR-FLAG-TO-11) +;; (JUMP A-ZERO M-ZERO .-1 IR-FLAG-TO-11) +;; ((M-GARBAGE) M-ZERO IR-FLAG-TO-11) +;;--ALSO SEE TYO HACKER AT QCN2 + BIT 164010,#4000 ;IR43 + BEQ QEX1WD + MOV #0,164006 ;STOP CONS + MOV #100,B +2$: MOV 164004,(A) ;LOW 16 BITS OF OBUS + BNE 3$ + JSR PC,XCLK + DEC B + BGT 2$ + CLR (A) ;SOMETHING SCREWED, EITHER ITS TYPING OUT RANDOMNESS OR NOT REALLY + BR QEX1WD ;IN RIGHT LOOP. AT LEAST DONT HANG UP. + +3$: JSR PC,XNCLK ;CLOCK PAST FIRST ALU INST + JSR PC,XNCLK ;CLOCK PAST JUMP, NO-OP ING IT + MOV #1,164006 ; START 'ER UP + BR QEX1WD + +QEXCON: ASL B ;EXAMINE CONSOLE COMPUTER REGS + CMP B,#QEXCVL + BHIS QEXCER + JMP @QEXCT(B) + +QEXCER: JMP COMERR + +QEXCT: QEXPC ;EXAMINE PC + QEXUSP ;U STACK POINTER + QEXIR ;HARDWARE IR + QEXSIR ;SAVED IR + QEXQ ;EXAMINE Q + QEXDC ;EXAMINE DISPATCH CONSTANT + QEXRST ;RESET REGISTER (JUST "OPEN" IT) + QEXSTS ;EXAMINE STATUS REGISTER + QEXOBS ;EXAMINE O-BUS STATUS + QEXNL ;RESET FUNCTION + QEXNL ;STEP FUNCTION + QEXNL ;STOP FUNCTION + QEXPC ;EXAMINE STARTING ADR + QEXGO ;GO FUNCTION (RETURN CTRUN) + QEXMOD ;MODE REGISTER + QEXRCN ;REMOTE CONSOLE +QEXCVL==.-QEXCT + + +QEXUS: PUSH A + PUSH B ;EXAMINE U STACK + ESUSTK + POP B + POP A + ASL B + MOV USSVD(B),(A) + MOV #<<16.*400>+0>,B + BR QEXPC2 + +QEXUSP: PUSH A + ESUSTK ;EXAMINE U STACK POINTER + POP A + MOV USTPNR,(A) + MOV #<<5.*400>+0>,B + BR QEXPC2 + +QEXPC: MOV CPC,(A) +QEXPC0: MOV #<<12.*400>+0>,B + BR QEXPC2 + +QEXDC: ERDSPC ;EXAMINE DISPATCH CONSTANT + MOV #<<8*400>+0>,B +QEXPC2: JMP QEXPC1 + +QEXIR: ERIR + JMP QEXIR1 + +QEXSIR: MOV #CIR,C + JMP QEXSI1 + +QEXMMF: ASL B ;MAIN MEMORY FUNCTIONS + JMP @QEMMFT(B) + +QEMMFT: QECVMR ;EXAMINE CONSOLE VIRTUAL ADDRESS REGISTER + QECVRD ;EXAMINE CONSOLE READ DATA + QECVMR ;EXAMINE CONSOLE PHYSICAL ADR REGISTER + QECVRD ;EXAMINE CONSOLE READ DATA + QECVWD ;EXAMINE CONSOLE VIRTUAL WRITE DATA REGISTER + QECVMR ;EXAMINE CONSOLE VIRTUAL ADR REGISTER + QECVWD ;EXAMINE CONSOLE VIRTUAL WRITE DATA REGISTER + QECVMR ;EXAMINE CONSOLE VIRTUAL ADR REGISTER + +QECVMR: MOV CVMVMA,(A) ;EXAMINE CONSOLE VIRTUAL ADR REGISTER + MOV CVMVMA+2,2(A) +QEXPB2: JMP QEXPB1 ;OUT OF RANGE, LOSE LOSE + +QECVRD: MOV CVMMRD,(A) ;EXAMINE CONSOLE READ DATA REGISTER + MOV CVMMRD+2,2(A) + MOV CVMMPF,4(A) ;HIGH WORD FAULT STATUS + BR QEXPB2 + +QECVWD: MOV CVMMWD,(A) ;EXAMINE CONSOLE WRITE DATA REGISTER + MOV CVMMWD+2,2(A) + BR QEXPB2 + +QEXB: 0 ;TEMP BLOCK FOR EXAMINING FCTNS + 0 + 0 + + +.SBTTL DEPOSITATION ROUTINES + +QDEPV: COMERR ;TOO LOW .. + QDPC ;CONTROL MEM (NUMERIC STYLE) + QDPD ;DISPATCH MEM + QDPPB ;PDL BUFFER + QDP1MP ;1ST LVL MAP + QDP2MP ;2ND LVL MAP + QDPA ;A MEM + QDPUS ;U STACK + QDPM ;M MEM + COMERR ;FUNCTIONAL SOURCES + QDPFD ;FUNCTIONAL DESTINATIONS + QDPCON ;CONSOLE COMPUTER REGS + QDPSW ;CONSOLE COMPUTER MODES AND SWITCHES + QDPRDR ;RAID REGISTERS + COMERR ;CONSOLE COMPUTER INST BUFFER + QDPMMF ;MAIN MEMORY FUNCTION REGISTERS + COMERR ;OLD PCS + COMERR ;TOO HI + +QDPD: MOV #CNUM,A ;DEPOSIT IN DISPATCH MEM + EWDSP + BR QDPXIT + +QDPFD: SWAB B ;DEPOSIT IN FUNCT DEST + ASR B ; (ALSO CLOBBERS M MEM 0 BUT THAT DOESNT HURT) + ASR B + ASR B + EWMEMS ;ASSURE VMA AND MWD VALID + JSR PC,QDPM ;DO STUFF + ERMEMS ;READ THEM AGAIN AS THEY MAY HAVE CHANGED + RTS PC + +QDPA1: MOV #CAMEM1,A ;DEPOSIT IN A MEM 1 +QDPM1: MOV CNUM,(A)+ + MOV CNUM+2,(A) + BR QDPXIT + +QDPM0: MOV #CMMEM0,A ;DEPOSIT IN M MEM 0 + BR QDPM1 + +QDPA: CMP B,#1 + BEQ QDPA1 ;DEPOSIT IN A MEM 1 + BIS #CDAMEM,B ;DEPOSIT IN A MEM +QDPM: TST B + BEQ QDPM0 + CMP B,#1 ;WRITING 1@M CLOBBERS 1@A + BNE 1$ + MOV CNUM,CAMEM1 + MOV CNUM+2,CAMEM1+2 +1$: MOV #CNUM,A ;DEPOSIT IN M MEM + EDMM0 +QDPXIT: DEC DEPFLG ;SIGNAL DEPOSIT DONE + RTS PC + +QDPPB: MOV #CNUM,A ;DEPOSIT IN PDL BUFFER + EWPDLB + BR QDPXIT + +QDPRDR: ASL B ;DEPOSIT IN RAID REGISTER + ADD #RAIDA,B + BR QDPRD1 + +QDPSW: ASL B + ADD #CSSWO,B ;DEPOSIT IN CONSOLE COMPUTER SWITCH +QDPRD1: MOV CNUM,(B) + BR QDPXIT + +REGCLS: TST REGOPF ;CLOSE OPEN REGISTER + BEQ REGCLX ;NO REG OPEN + TST CNUMF + BEQ REGCLX ;NO NUMBER TYPED + MOV CONSPT,A + MOV #QDEPV,B + JSR PC,REGDC +REGCLX: RTS PC + +QDP1MP: MOV #CNUM,A + TST B + BEQ QDP1M1 + EWL1MP ;DEPOSIT IN LVL 1 MAP + BR QDPXIT + +QDP1M1: MOV (A),CL1M0 ;HACK LOCN 0 SPECIALLY + MOV #1,CL1M0F + BR QDPXIT + +QDP2MP: MOV #CNUM,A + TST B + BEQ QDP2M1 + EWL2MP ;DEPOSIT IN LVL 2 MAP + BR QDPXIT + +QDP2M1: MOV (A),CL2M0 + MOV 2(A),CL2M0+2 + MOV #1,CL2M0F + BR QDPXIT + +QDPCON: ASL B ;DEPOSIT IN CONSOLE COMPUTER REGS + CMP B,#QDPVL + BHIS QDPCER + JMP @QDPCV(B) + +QDPCER: JMP COMERR + +QDPCV: QDPPC ;DEPOSIT IN PC + QDPUSP ;DEPOSIT IN U STACK POINTER + COMERR ;DEPOSIT IN HARDWARE IR + COMERR ;DEPOSIT IN SAVED IR + QDPQ ;DEPOSIT IN Q + QDPDC ;DEPOSIT IN DISPATCH CONSTANT REGISTER + QDPRST ;DEPOSIT IN RESET REGISTER (ZAP) + COMERR ;STATUS REGISTER + COMERR ;O-BUS STATUS + QDPRS ;RESET FUNCTION + QDPSTE ;STEP FUNCTION + QDPSTP ;STOP FUNCTION + QDPSA ;SET STARTING ADR + QDPGO ;GO FUNCTION + QDPMOD ;MODE REGISTER + QDPRCN ;REMOTE CONSOLE +QDPVL==.-QDPCV + +QDPUS: PUSH B ;DEPOSIT IN U STACK + ESUSTK + POP B + ASL B + ADD #USSVD,B + MOV CNUM,(B) + BR QDPXIT + +QDPUSP: ESUSTK ;DEPOSIT IN U STACK POINTER + MOV CNUM,USTPNR + BIC #177740,USTPNR + BR QDPXIT + +QG: +QDPSA: MOV #1,NOOPF ;NO OP PRESENT CONTENTS OF IR +QDPPC: MOV CNUM,CPC + BIC #170000,CPC + BR QDPXIT + +QDPQ: MOV #CSDQ,B ;DEPOSIT IN Q REGISTER + BR QDPM ; ("PSEUDO" DEST Q) + +QDPDC: MOV #CNUM,A ;DEPOSIT IN DISPATCH CONSTANT REGISTER + EWDSPC + BR QDPXIT + +QDPRST: ERESET ;RESET MISC STATE + MOV #RACMO,QDPRC ;CLEAR ALL MEMORIES!! +QDPR1: MOV #QDEPV,B ;START OFF WITH CONTROL MEM + MOV QDPRC,A + CMP A,#RAMME + BHIS QDPXIT + JSR PC,REGDC + INC QDPRC + BR QDPR1 + +QDPRC: 0 + +QDPMMF: MOV #CNUM,A + ASL B ;MAIN MEMORY FUNCTION REGISTERS + JMP @QDMMFT(B) + +QDMMFT: QDCVMR ;CONSOLE VIRTUAL ADDRESS REGISTER, INITIATE READ + QDCVRD ;CONSOLE VIRTUAL READ DATA REGISTER + QDCPMR ;CONSOLE PHYSICAL ADDRESS REGISTER, INITIATE READ + QDCVRD ;CONSOLE VIRTUAL READ DATA REGISTER + QDCMWD ;CONSOLE VIRTUAL WRITE DATA REGISTER + QDCVWD ;CONSOLE VIRTUAL ADDRESS REGISTER, INITIATE WRITE + QDCMWD ;CONSOLE VIRTUAL WRITE DATA REGISTER + QDCPWD ;CONSOLE PHYSICAL ADDRESS REGISTER, INITIATE WRITE. + +QDCVMR: MOV (A)+,CVMVMA ;DEPOSIT IN CONSOLE VMA, INITIATE READ + MOV (A),CVMVMA+2 + EVMEMS ;"VALIDIFY" MEM SUBROUTINE + MOV #CVMVMA,A + MOV #,B + EDMM0 ;START READ +QDCVM1: INC CSMRDF ;HACKING WITH "REAL" READ DATA REG + JSR PC,QCVFLT ;CHECK FOR PAGE FAULT + MOV #CVMMRD,A ;UPDATE CONSOLE READ DATA REG + MOV #CMSMMD,B + EEXAMD +QDPXI1: JMP QDPXIT ;OUT OF RANGE, LOSE LOSE + +QCVFLT: CLR CVMMPF ;ASSUME NO FAULT + MOV #QEXB,A ;CHECK FOR FAULT + MOV #CMSPMD,B + EEXAMD + BIT #3,(A) + BEQ 1$ + INC CVMMPF ;FAULT PRESENT +1$: RTS PC + +QDCVRD: MOV (A)+,CVMMRD ;DEPOSIT IN CONSOLE VIRTUAL MEM DATA REGISTER + MOV (A),CVMMRD+2 ; (TOTALLY RANDOM OPERATION) + BR QDPXI1 + +QDCPMR: MOV (A)+,CVMVMA ;LOAD CONSOLE "PHYSICAL" VMA + MOV (A),CVMVMA+2 + MOV #CVMVMA,A + EWPVMA ;LOAD "PHYSICAL" VMA + EMMRC ;START READ CYCLE + BR QDCVM1 ;UPDATE CONSOLE READ DATA REG + +QDCMWD: MOV (A)+,CVMMWD ;WRITE CONSOLE MEMORY WRITE DATA REG + MOV (A),CVMMWD+2 + BR QDPXI1 + +QDCVWD: MOV (A)+,CVMVMA ;DEPOSIT IN CONSOLE VMA, START WRITE + MOV (A),CVMVMA+2 + EVMEMS ;GET BACK EVERYTHING (SAVED MAP, ETC) + MOV #CVMMWD,A + MOV #,B + EDMM0 ;LOAD MWD WITH CONSOLE MWD + MOV #CVMVMA,A + MOV #,B + EDMM0 ;DO VMA START WRITE + JSR PC,QCVFLT ;CHECK FOR FAULT + BR QDPXI1 + +QDCPWD: MOV (A)+,CVMVMA ;LOAD CONSOLE "PHYSICAL" VMA, START WRITE + MOV (A),CVMVMA+2 + MOV #CVMVMA,A + EWPVMA ;LOAD "PHYSICAL" VMA + MOV #CVMMWD,A + MOV #,B + EDMM0 ;LOAD MWD WITH CONSOLE MWD + EMMWC ;START WRITE CYCLE + BR QDPXI1 + + +.SBTTL FUNNY-FORMAT TYPE-IN + +QBS: JSR PC,QPTSET + TST CNUMF + BLT QBS1 + JSR PC,PCNSPT +QBS1: MOV #QTIVEC,B ;TYPE IN FUNNY FORMATS + JSR PC,REGDC + JMP CRLF + + +;TYPE IN VECTOR FOR FUNNY FORMAT TYPE INS +QTIVEC: COMERR ;TOO LOW, TRY LAST MEM + QUICM ;CONTROL MEMORY + COMERR ;DISPATCH MEM + COMERR ;PDL BUFFER + COMERR ;1ST LVL MAP + COMERR ;2ND LVL MAP + COMERR ;A MEM + COMERR ;U STACK + COMERR ;M MEM + COMERR ;FUNCTIONAL SOURCES + COMERR ;FUNCTIONAL DESTINATIONS + QUICR ;CONSOLE COMPUTER REGS + COMERR ;CONSOLE COMPUTER MODES AND SWITCHES + COMERR ;RAID REGISTERS + QUICIB ;CONSOLE COMPUTER INST BUFFER + COMERR ;MAIN MEMORY FUNCTION REGISTERS + COMERR ;OLD PCS + COMERR ;TOO HI + +QUICIB: JSR PC,QEXCI1 ;DEPOSIT IN CONSOLE INST BUFFER + MOV C,A + JSR PC,QUTYI + BR QUIXIT + +QDPC: MOV #CNUM,A ;DO NUMERIC STYLE DEPOSIT + BR QDPC1 + +QUICM: EEXAMC ;GET CURRENT CONTENTS FOR DEFAULTING + PUSH B ;DEPOSIT IN CONTROL MEM + JSR PC,QUTYI + POP B +QDPC1: EDCMEM +QUIXIT: DEC DEPFLG + RTS PC + +QUICR: ASL B ;SPECIAL DEPOSIT IN CONSOLE REG + CMP B,#QUIVL + BHIS QUIVER + JMP @QUIVC(B) + +QUIVER: JMP COMERR + +QUIVC: COMERR ;DEPOSIT IN PC + COMERR ;DEPOSIT IN U STACK POINTER + QUIIR ;DEPOSIT IN HARDWARE IR + QUISIR ;DEPOSIT IN SAVED IR + COMERR ;DEPOSIT IN Q + COMERR ;DEPOSIT IN DISPATCH CONSTANT + COMERR ;DEPOSIT IN RESET REGISTER + COMERR ;STATUS REGISTER + COMERR ;O-BUS STATUS + COMERR ;RESET FUNCTION + COMERR ;STEP FUNCTION + COMERR ;STOP FUNCTION + COMERR ;SET STARTING ADR + COMERR ;GO FUNCTION +QUIVL==.-QUIVC + +QUIIR: ERIR ;READ IN CURRENT IR FOR DEFAULT + JSR PC,QUTYI ;READ IN U INST + EWIR ;PUT IN IR + MOV #COBUS,A ;READ IN NEW O BUS + EROBUS + BR QUIXIT + +QUISIR: MOV #CIR,A + JSR PC,QUTYI + BR QUIXIT + + +;U INST TYPEIN -- +; THERE ARE TWO ROUTINES ASSOCIATED WITH EA FIELD, A PROMPT +; GENERATING FIELD AND A DEPOSITING FIELD. +; AT EACH STAGE OF THE GAME THE USER IS PROMPT ED BY SOME +; PROMPT ROUTINE. IF HE TYPES A NUMBER, THAT NUMBER IS FED +; TO THE APPROPRIATE DEPOSIT ROUTINE. IF HE TYPES A SYMBOL, +; IT IS LOOKED UP IN A TABLE. IF NOT FOUND, ERROR. +; IF IT IS FOUND, IT SPECIFIES A TRANSFER ADDRESS AND A +; VALUE. THE TRANSFER ADDRESS MAY BE EITHER A PROMPT OR +; A DEPOSIT ROUTINE. IF A PROMPT, THE ARG (FROM THE SYMBOL +; TABLE) IS IGNORED. IF A DEPOSIT, IT GETS DEPOSITED!! +; EACH DEPOSIT ROUTINE FALLS THRU INTO AN "APPROPRIATE" +; PROMPT ROUTINE. CR AS A TERMINATOR, STOPS PROMPTING AND +; DEPOSITS! RUBOUT FLUSHES CURRENT COMMAND (U CAN TRY AGAIN IF +; YOU WANT). ^G QUITS OUT OF ENTIRE THING. SPACE ADVANCES +; TO THE NEXT PROMPT ROUTINE. + +QUTYI: CLR QIFCRT ;POINTER TO QEXB IN A +QPUOP: ETEXT ;TYPE IN U INST + ASCTOP ;TYPE TAB OP + JSR PC,QIFLD ;GOBBLE FIELD. IF SYMBOLIC, ZAP + BR QDUOP1 ;SPACE LEAVE OP AND REST + ;THE SAME TO START WITH +QDUOP: EICLR ;INTIALIZE STUFF + MOV #<<2*400>+47>,C + EDPB + TST B + BNE QDUOP1 + BIS #1_14,(A) ;ALU OP, DEFAULT ALU OUTPUT BUS +QDUOP1: +QPAS: ETEXT ;A SOURCE (D C FOR DSP) + ASCA + JSR PC,QIFLD + BR QPMS +QDAS: EDASRC +QPMS: ETEXT ;M SOURCE (ALL INSTS) + ASCM + JSR PC,QIFLD + BR QPDD + EDMSRC +QPDD: MOV 4(A),B + ASL B + ASL B + SWAB B + BIC #177771,B + JMP @QPDDT(B) + +QPDDT: QPDSTA ;ALU TAKES DEST + QPDIS ;DISPATCH PROMPT SEQ + QPJMP ;JMP PROMPT SEQ + QPDSTA ;BYT TAKES DEST + + +QPDSTM: ETEXT ;DESTINATION M + ASCDM + JSR PC,QIFLD + BR QPDSTR + EDMDST ;DEPOSIT IN M PART OF DESTINATION +QPDSTR: ETEXT ;DESTINATION REGISTER/FUNCTION + ASCDR + JSR PC,QIFLD + BR QPAOB + EDRDST ;DEPOSIT IN R PART OF DEST + BR QPAOB + +QPDSTA: ETEXT ;DESTINATION A + ASCDA + JSR PC,QIFLD + BR QPDSTM + BIS #CDAMEM,B + EDDEST +QPAOB: MOV 4(A),B + BIC #177177,B + BNE QPBYT ;BYTE PROMPT SEQ +QPALU: ETEXT ;ALU PROMPT SEQ + ASCALU + JSR PC,QIFLD + BR QPCRYC + EDALUF +QPCRYC: ETEXT + ASCCRY + JSR PC,QIFLD + BR QPQC + MOV #<<2*400>+2>,C + EDPB +QPQC: ETEXT + ASCQC + JSR PC,QIFLD + BR QPMF + MOV #<<2*400>+0>,C + EDPB +QPMF: ETEXT + ASCMF + JSR PC,QIFLD + BR QPILG + MOV #<<2*400>+12>,C + EDPB +QPILG: ETEXT + ASCILG + JSR PC,QIFLD + BR QTIDEP + MOV #<<1*400>+41.>,C + EDPB +QTIDEP: RTS PC ;RETURN FROM U INST TYPE IN + ;U INST IN QEXB + +QPBYT: ETEXT ;BYTE PROMPT SEQ + ASCMD + JSR PC,QIFLD + BR QPBLEN + MOV #<<2*400>+14>,C + EDPB +QPBLEN: ETEXT ;BYTE LENGTH + ASCNB + JSR PC,QIFLD + BR QPBROT + MOV #<<5*400>+5>,C +QPDNB1: EDPB +QPBROT: +QPDMR: ETEXT ;BYTE ROTATE + ASCMR + JSR PC,QIFLD + BR QPBMF + MOV #<<5*400>+0>,C + EDPB +QPBMF: BR QPMF ;MISC FUNCTION SAME POSITION IN ALL INST + +QIFBS2: BIS B,4(A) ;BIS VAL OF SYM INTO WD2 +QPUOPJ: JMP QPUOP + +QIFBC2: BIC B,4(A) ;BIC VAL OF SYM INTO WD2 + BR QPUOPJ + +QIFOB: BIC #3_12.,(A) ;DEPOSIT INTO ALU OBUS SELECTION FIELD + BIS B,(A) + BR QPALU + +QPDIS: ETEXT ;DISPATCH INST SEQUENCE + ASCDO ;DISPATCH OFFSET + JSR PC,QIFLD + BR QPDNB + EDDSPO ;DEPOSIT INTO DISPATCH OFFSET FIELD +QPDNB: ETEXT + ASCNB + JSR PC,QIFLD + BR QPDMR + MOV #<<3*400>+5>,C + BR QPDNB1 + +QPJMP: ETEXT ;JMP SEQUENCE + ASCJPC + JSR PC,QIFLD + BR QPJR + EDJPC +QPJR: ETEXT + ASCR + JSR PC,QIFLD + BR QPJP + MOV #<<1*400>+11>,C + EDPB +QPJP: ETEXT + ASCP + JSR PC,QIFLD + BR QPJN + MOV #<<1*400>+10>,C + EDPB +QPJN: ETEXT + ASCN + JSR PC,QIFLD + BR QPJI + MOV #<<1*400>+7>,C + EDPB +QPJI: ETEXT + ASCI + JSR PC,QIFLD + BR QPJC + MOV #<<1*400>+6>,C + EDPB +QPJC: ETEXT + ASCJC + JSR PC,QIFLD + BR QPJTB ;NULL HERE TO TEST BIT + ADD #40,B ;SET TEST CONDITION BIT +QPJTB1: MOV #<<6*400>+0>,C + EDPB +QPJMF: JMP QPMF + + +QPJTB: ETEXT + ASCTB + JSR PC,QIFLD + BR QPJMF + BR QPJTB1 + +QIFSU: ETEXT ;SYM UNDEFINED + ASCU ;RUB IT OUT! +QIFRUB: ETEXT + ASCXXX + BR QIFRB1 + +QIFLD: PUSH A ;READ IN FIELD +QIFRB1: TST QIFCRT ;SKIP UNLESS FIELD NULL + BNE QIFCL ;TYPED CR BEFORE, CLOSE REG +QIFLD1: JSR PC,GECOM ;G COM, EVAL SYMS + CMP A,#RUBCOD + BEQ QIFRUB + CMP A,#7 + BEQ QIFQT + TST CNUMF + BLT QIFNM ;HE TYPED A NUMBER! + TST CSYL + BNE QIFSYL ;HE TYPED SYM, LOOK IT UP + CMP A,#40 + BEQ QIFSP ;SKIP OVER THIS FLD + ; IE RETURN W/O SKIPPING + CMP A,#15 + BEQ QIFCL ;CR CLOSE REG + BR QIFLD1 ;SOMETHING ELSE RANDOM, IGNORE + +QIFCL: MOV #QTIDEP,2(SP) ;FORCE RETURN TO QTIDEP + BR QIFSP + +QIFNM: CMP A,#15 ;TERM BY CR? + BNE QIFLDX + DEC QIFCRT ;REMEMBER CR TYPED +QIFLDX: ADD #2,2(SP) ;SKIP ON RETURN +QIFSP: MOV CNUM,B ;DONT SKIP ON RETURN (MEANS SKIP + ;FIELD +QIFSP1: POP A + RTS PC + +QIFQT: JMP COMERR + +QIFSYL: MOV #QIFST,C ;SEARCH SYMTAB +QIFSY1: CMP C,#QIFSTE + BHIS QIFSU ;SYMBOL UNDEFINED + MOV #CBUF,T + MOV (C)+,U +QIFSY2: CMPB (T)+,(U) + BNE QIFSY3 ;THAT ONE LOSES + TSTB (U)+ + BNE QIFSY2 ;KEEP LOOKING + MOV (C)+,B ;VALUE TO RETURN + MOV (C)+,2(SP) ;PLACE TO FORCE RETURN + BR QIFSP1 + +QIFSY3: CMP (C)+,(C)+ ;TRY NEXT SYMBOL + BR QIFSY1 + +QIFCRT: 0 ;-1 CR TYPED + +;SYMBOL TABLE FORMAT: +; WD0 POINTER TO ASCIZ STRING +; WD1 VALUE +; WD2 FORCE RETURN ADR + +QIFST: ASCPJ1 ;PJ + CIPJB + QIFBS2 ;BIS INTO WD 2 + ASCNPJ ;NPJ + CIPJB + QIFBC2 ;BIC INTO WD 2 + ASCOL1 ;OBL1 (OUTPUT BUS LEFT 1) + COBAL_12. + QIFOB + ASCOR1 ;OBR1 (OUTPUT BUS RIGHT 1) + COBAR_12. + QIFOB +QIFSTE: + + +.SBTTL MISC COMMAND CHARS' ROUTINES + +QCZ: EDCLK ;ZONK. CYCLE CLOCK ONCE + RTS PC + +QCR: +QDPRS: JSR PC,RESSV ;RESET + ERESET + RTS PC + +QCN: +QDPSTE: JSR PC,RESSV ;RESTORE STATE, SAVE AND COME BACK + CMP CNUM,#RAORG + BHIS QCN2 ;BRANCH IF ARG IS REGISTER ADDRESS + TST CNUMF + BLT QCN1 + INC CNUM ;DEFAULT ARG OF 1 +QCN1: SUB #1,CNUM + SBC CNUM+2 + SBC CNUM+4 + BLT QCNX + ECCLK + TST CMREQ + BLT QCN1 ;GUY WANTS TO QUIT OUT +QCNX: RTS PC + +QCN2: SUB #RACMO,CNUM ;C MEM ADDRESS OF INSTR TO STOP AT +QCN3: JSR PC,XCCLK ;PROCEED UNTIL ABOUT TO EXECUTE THAT + CLR CPSVAL ;BUT ALWAYS PROCEED AT LEAST ONCE +QCN4: TST CMREQ + BGE QCNX ;STOP IF GUY ASKS TO QUIT OUT + MOV TYICH,A + BNE QCNTYI ;HACK TYPEIN + TST 164002 + BPL QCNX ;MACHINE LOSSAGE, CEASE PROCEEDING + BIT 164010,#4000 ;IR43 + BNE QCN5 ;HANDLE TYO WHILE STEPPING + MOV 164006,A ;READ PC INTO A + BIC #170000,A ; PC 12 BITS + CMP A,CNUM ;DON'T STOP IF HAVEN'T REACHED DESIRED PC + BNE QCN3 + ECCLK ;CLOCK ONCE MORE TO FETCH DESIRED INSTR + CLR CPSVAL + JSR PC,PSCONS + TST NOOPF ;BUT IF ITS NOOPED, DON'T STOP + BNE QCN4 ;BECAUSE NOT REALLY EXECUTING IT + RTS PC + +QCN5: MOV 164004,A ;LOW 16 BITS OF OBUS + BNE 3$ + ECCLK + BR QCN5 + +3$: JSR PC,TYOCHR ;GOT THE STUFF, TYPE IT + MOV CURSX,RCURSX ;MAKE SURE CURSOR DISPLAYING IN RIGHT PLACE + MOV CURSY,RCURSY + ENCLK ;CLOCK PAST FIRST ALU INST + ENCLK ;CLOCK PAST JUMP, NO-OP ING IT + BR QCN3 + +QCNTYI: CLR TYICH ;HERE WHEN KEY HIT WHILE ONE-PROCEEDING + CMP A,#23 ;^S STOP + BEQ QCNX + BR QCN4 ;EVERYTHING ELSE IGNORED +; MOV CNUM,-(SP) ;I'M A LITTLE PARANOID ABOUT THIS +; CLR -(SP) ;OTHER CHAR, GIVE TO CONS +; MOV A,-(SP) +; CMP A,#40 +; BLT 2$ +; CMP A,#177 +; BEQ 2$ +; JSR PC,ADDCHR ;ECHO NON-CONTROLS EXCEPT RUBOUT +; MOV (SP),A +;2$: CMP A,#15 +; BNE 1$ +; JSR PC,TYOCHR ;ECHO CR AS CR,LF,CLEOL +;1$: MOV CURSX,RCURSX ;MAKE SURE CURSOR DISPLAYING IN RIGHT PLACE +; MOV CURSY,RCURSY +; JSR PC,ENTER ;SAVE STATE OF CONS +; CMP -(SP),-(SP) ;CHECK THE TYI REGISTER +; MOV SP,A +; MOV #RATYI-RAAMO+CDAMEM,B +; EEXAMD +; BIS (SP)+,(SP)+ ;IS IT ZERO? +; BEQ 3$ ;YES, OK +; JSR PC,BELL ;NO, BEEP, PREV CHAR NOT PICKED UP YET +; BR 4$ + +;3$: MOV SP,A ;GIVE IT THE CHARACTER +; MOV #RATYI-RAAMO+CDAMEM,B +; EDMM0 +;4$: CMP (SP)+,(SP)+ ;FLUSH TEMP REGISTERS +; JSR PC,LEAVE ;RESTORE STATE OF CONS +; MOV (SP)+,CNUM +; BR QCN4 ;RETURN TO ONE-PROCEED LOOP + +QCP:; JSR PC,RESSV ;RESTORE STATE, SAVE AND COME BACK +; ECCLK ;MAYBE XCT IR (MIGHT CAUSE IR PARITY ERR) +; ECLK ;MAKE SURE ERRORS CLEARED +; MOV #1,164006 ;SET RUN! +;QCP1: WAIT +; TST CMREQ +; BLT QCP1 +; RTS PC + +QDPGO: MOV #-1,CTRUN ;INDICATE "TRYING TO RUN" + JSR PC,QDPRUN +; TST CNUM ;IF VALUE STORING IS NON-ZERO, DON'T GIVE UP TTY +; BNE 1$ +; ZAPFLG LMHTTY ;GIVE THE TTY TO THE LISP MACHINE +; TST CNUM ;IF VALUE STORING NON-ZERO +; BEQ 1$ +; COM LMHTTY ;SET IT NEGATIVE FOR REMOTE CONSOLE MODE +1$: RTS PC + +QDPRUN: TST CTRUN ;SET REAL RUN. FIRST SEE IF REALLY WANT TO + BEQ QDPRUX ; MUST HAVE BEEN CLEARED BY DETECTING AN ERROR + JSR PC,LEAVE ;START MACHINE, KEEP LISTENING (PRESUMABLY TO 10) + ECCLK + ECLK + MOV #1,164006 + MOV #-1,CRUN ;CONS SHOULD REALLY BE RUNNING NOW! +QDPRUX: RTS PC + +RESSV: JSR PC,LEAVE ;LEAVE - CALL BACK -ENTER -RETURN + JSR PC,@(SP) ;CALL GUY BACK + JSR PC,ENTER + JSR PC,CDSPLY ;UPDATE DISPLAY + TST (SP)+ + RTS PC + +QPLS: MOV #CNUM,TT ;PLUS, SPACE + MOV #CVAL,T ;JUST RETURN ARG AS VALUE + MOV (TT)+,(T)+ + MOV (TT)+,(T)+ + MOV (TT),(T) + DEC CVALF +QAMP3: RTS PC + +QAMP: INC NOOPF ;NO OP FIRST CYCLE + MOV A,B ;SEND CONSOLE INST BUFFER + JSR PC,QEXCI1 ;TO MACHINE, ARG IS HOW MANY TO + MOV C,QAMPL ;POINTER TO BUFFER AT LAST PLACE + JSR PC,RESSV +QAMP2: MOV #CIBUF,A +QAMP1: TST CMREQ + BGE QAMP3 ;LEAVE LOOP + CMP A,QAMPL + BHIS QAMP2 + EWDIB + EDCCLK ;DO DEBUG CLOCK OR NOOP DEBUG + ADD #<3*2>,A ; CLOCK FIRST TIME + BR QAMP1 + +QAMPL: 0 ;HIGH CONSOLE BUFFER ADR TO SEND + +QEQ: TST CNUMF + BEQ QEQ1 ;TYPE OUT LAST REG INSTEAD + MOV A,B ;= + MOV #6,C + JSR PC,OCTPNB +QEQ2: JMP CRLF + +QEQ1: CLR QEXPF ;FETCH PT AND PRINT NUMERIC + MOV CONSPT,A + MOV #QEXAMV,B + JSR PC,REGDC + IPNFLD + BR QEQ2 + +QDPRCN: MOV #CNUM,A +;QDPRC0: TST CTRUN +; BNE 1$ + JMP COMERR + +;1$: PUSH A +; JSR PC,QDPHLT ;STOP MOMENTARILY +; POP A +; MOV #RATYI-RAAMO+CDAMEM,B +; EDMM0 +; JMP QDPRUN ;RESUME (IF NO ERROR) + +QDPMOD: TST CTRUN + BEQ 10$ + JMP COMERR ;DOESN'T WIN IF MACHINE RUNNING + +10$: MOV CNUM,MODREG ;STORE INTO MODE REGISTER +MODSET: MOV #100000,A ;CONVERT TO MACHINE FORMAT + BIT #1,MODREG ;SLOW MODE + BEQ 1$ + BIS #400,A +1$: BIT #2,MODREG ;DISABLE ERROR HALT MODE + BNE 2$ + BIS #1000,A +2$: MOV A,164006 ;STORE INTO HARDWARE MODE + RTS PC + +.SBTTL PRINT ADDRESS + +QPAD: MOV #GSYMT,TT ;PRINT SYMBOL IF ONE FOUND EXACTLY EQUAL +QPASY1: CMP TT,#GSYMTE + BHIS QPASYX ;NO MATCH + CMP A,2(TT) + BEQ QPASYF ;FOUND IT + ADD #4,TT + BR QPASY1 + +QPASYF: MOV (TT),A ;SYMBOL FOUND, PRINT IT + ETEXTP + RTS PC + +QPASYX: MOV #QPADV,B ;PRINT ADDRESS (IN A) + JSR PC,REGDC + RTS PC + +QPADV: QPATL ;TOO LOW, JUST PRINT NUMBER + QPAC ;CONTROL MEM PRINT ADDRESS VECTOR + QPADM ;DISPATCH MEM + QPAPB ;PDL BUFFER + QPA1MP ;1ST LVL MAP + QPA2MP ;2ND LVL MAP + QPAA ;A MEM + QPAUS ;U STACK + QPAM ;M MEM + QPAFS ;FUNCTIONAL SOURCES + QPAFD ;FUNCTIONAL DESTINATIONS + QPANUL ;CONSOLE COMPUTER REGS + QPANUL ;CONSOLE COMPUTER MODES AND SWITCHES + QPARDR ;RAID REGISTERS + QPACIB ;CONSOLE COMPUTER INST BUFFER + QPANUL ;MAIN MEMORY FUNCTION REGISTERS + QPANUL ;OLD PCS + QPANUL ;TOO HI + +QPA1MP: MOV #4,C + JSR PC,OCTPNB + ETEXT ;1ST LVL MAP + ASC1MP + RTS PC + +QPA2MP: MOV #4,C + JSR PC,OCTPNB + ETEXT ;2ND LVL MAP + ASC2MP + RTS PC + +QPARDR: ETEXT ;RAID REGISTERS + ASCRDP + MOV #1,C + JSR PC,OCTPNB + RTS PC + +QPACIB: ETEXT ;CONSOLE INST BUFFER + ASCCBP ;CIB+ + MOV #2,C + JSR PC,OCTPNB + RTS PC + +QPAUS: MOV #2,C ;PRINT U STACK ADR + JSR PC,OCTPNB + ETEXT + ASCIUS + RTS PC + +QPADM: MOV #4,C ;PRINT DISPATCH MEM ADR + JSR PC,OCTPNB + ETEXT + ASCIDM + RTS PC + +QPAC: MOV #4,C ;PRINT CONTROL MEM ADR + JSR PC,OCTPNB + ETEXT + ASCICM + RTS PC + +QPAPB: MOV #4,C ;PRINT PDL BUFFER ADR + JSR PC,OCTPNB + ETEXT + ASCIPB + RTS PC + +QPAA: MOV #3,C + JSR PC,OCTPNB + ETEXT + ASCIAM + RTS PC + +QPAFD: MOV #2,C ;FUNCTIONAL DEST + JSR PC,OCTPNB + ETEXT + ASCFDP + RTS PC + +QPAFS: ADD #40,B ;TURN F SRC INTO M ADR S +QPAM: MOV #2,C + JSR PC,OCTPNB + ETEXT + ASCIMM + RTS PC + +QPANUL: ADD REGDEF,B ;GET BACK FULL ADR +QPANL1: ETEXT ;DONT KNOW HOW TO PRINT THAT, SO + ASCREG ;PRINT INTERNAL ADDR +QPATL: MOV #6,C + JSR PC,OCTPNB + RTS PC + +.SBTTL EMT HANDLER + +EMTBRK: CMP SP,#PDL+30 + BLO STAKO ;STACK OVERFLOW + PUSH #EMTRET + PUSH A + BIC #17,6(SP) ;CLEAR PROCESSOR FLAGS + ; SO THEY CAN BE USED TO RETURN INFO + MOV 4(SP),A ;GET RETURN PC + MOV -(A),A ;GET EMT INST + ASL A ;SHIFT TO CONVERT TO WORD INDEX + CMP A,#TWHEMT + BHI BADEMT ;OUT OF RANGE + MOV EMTTAB-TWLEMT(A),A + RTS A ;XFER TO EMT ROUTINE. WHEN IT RETURNS, IT WILL GO + ;TO EMTRET AND RETURN AGAIN +XFATL: BPT +EMTERX: BIS #1,4(SP) ;SET CARRY ON RETURN INDICATING ERROR + RTS PC + +EMTRET: RTI + +STAKO: BPT +BADEMT: BPT + +;THIS ROUTINE MUST BE CALLED IMMEDIATELY AFTER EMT DISPATCH BY EMT WANTING +;TO ACCESS ARG AFTER THE EMT. IT SAVES ALL AC S, LOADS THE WD AFTER THE EMT +;INTO A, AND BUGGERS THE RETURN SO IT WILL RESTORE THE STATE OF THE MACHINE +;AND SKIP OVER THE ARG WORD. U IS CLOBBERED IN THIS PROCESS ALTHO IT WILL +;BE RESTORED AT EXIT FROM EMT + +EMTARG: JSR U,ACSAV ;SAVE AC S (PUSHING 5 WDS) + MOV <5+1+1+1>*2(SP),U ;ACCESS EMT ADR (+2) + ; ON STACK ARE 5 WDS PUSHED AT ACSAV, ONE FOR JSR U, + ; ONE BY JSR PC,EMTARG AND ONE FOR EMTRET. + MOV (U)+,A ;GET ARG WD + MOV U,<5+1+1+1>*2(SP) ;SMASH BACK SO ARG WD WILL BE SKIPPED OVER +EMTSA1: JSR PC,@<5+1>*2(SP) ;CALL BACK EMT HANDLER TO FINISH THAT STUFF + JSR U,ACRES + TST (SP)+ ;FLUSH WD WHERE EMT GUY CALLED US + RTS PC + +EMTSAV: JSR U,ACSAV ;CALLED BY EMT S WISHING TO SAVE AND RESTORE ALL ACS + BR EMTSA1 + +LEMT=EMT!0 +TWLEMT=LEMT+LEMT +EMTTAB: XFATL ;EMT 0 + XTEXT ; 1 + XERRO ; 2 + XROBUS ; 3 + XRIR ; 4 + XRPC ;EMT 5 + XRERWS ; 6 + XWDIB ; 7 + XDDEST ; 10 + XDALUF ; 11 + XDOBSL ;EMT 12 + XDMSRC ; 13 + XDASRC ; 14 + XUICLR ; 15 + XDCLK ; 16 + XDMM0 ;EMT 17 + XNPCLK ; 20 + XEXAMD ; 21 + XDJPC ; 22 + XDCMEM ; 23 + XICLR ; 24 + XCLK ; 25 + XEXAMC ; 26 + XNCLK ; 27 + XOCTP4 ; 30 + XOCTPD ; 31 + XPI ; 32 + XPASRC ; 33 + XPMSRC ; 34 + XPDEST ; 35 + XPOBSL ; 36 + XPALUF ; 37 + XPCRYC ; 40 + XPQC ; 41 + XPDDC ; 42 + XPDDO ; 43 + XPDNB ; 44 + XPMROT ; 45 + XPJPC ; 46 + XPJRB ; 47 + XPJPB ; 50 + XPJNB ; 51 + XPJINV ; 52 + XPJCND ; 53 + XPBMD ; 54 + XPBLEN ; 55 + XXFLD ; 56 + XWPC ; 57 + XPERRS ; 60 + XSTOP ; 61 + XDPB ; 62 + XDMDST ; 63 + XDRDST ; 64 + XDDSPO ; 65 + XRPDLB ; 66 + XWPDLB ; 67 + XSUSTK ; 70 + XUUSTK ; 71 + XTEXTP ; 72 + XCCLK ; 73 + XDCCLK ; 74 + XRESET ; 75 + XRDSP ; 76 + XWDSP ; 77 + XRDSPC ;100 + XWDSPC ;101 + XWIR ;102 + XDPBLK ;103 + XRL1MP ;104 + XWL1MP ;105 + XRL2MP ;106 + XWL2MP ;107 + XRMEMS ;110 + XWMEMS ;111 + XRDBLK ;112 + XWPVMA ;113 + XMMWC ;114 + XMMRC ;115 + XVMEMS ;116 +HEMT=EMT!<<.-EMTTAB>/2> +TWHEMT==HEMT+HEMT + + +.SBTTL RANDOM EMT ROUTINES + +XTEXTP: JSR PC,EMTSAV ;PRINT ASCIZ TEXT STRING IN A + BR PTEXT + +XTEXT: JSR PC,EMTARG ;SAVE ALL AC S, CHANGE EMT RETURN, RTN WD AFTER EMT IN A +PTEXT: MOV A,B ;TYPE OUT ASCIZ STRING POINTED TO BY A -CLOBBERS ACS- +PTEXTL: MOVB (B)+,A + BEQ PTEXTX + PUSH B + JSR PC,TYOCHR + POP B + BR PTEXTL + +PTEXTX: RTS PC + +XERRO: CMP A,#NERMS ;OUTPUT SYSTEM ERR MSG WHOSE NUMBER IS IN A + BHIS XERROF + ASL A + MOV ERRTXT(A),A + BR PTEXT + +XERROF: EFATL + +ERRTXT: ;POINTER TO ASCIZ STRING FOR ERR MSG +NERMS==<.-ERRTXT>/2 + + +XROBUS: PUSH A ;READ OBUS INTO DOUBLE WD POINTED TO BY A + MOV 164004,(A)+ + MOVB 164000,(A)+ + MOVB 164012,(A)+ + POP A + RTS PC + +XRIR: PUSH A ;READ IR INTO TRIPLE WD POINTED TO BY A + MOV 164014,(A)+ + MOV 164016,(A)+ + MOV 164010,(A) + BIC #160000,(A) ;THOSE BITS ARENT REALLY PART OF IR + POP A + RTS PC + +XRPC: MOV 164006,(A) ;READ PC INTO WD POINTED TO BY A + BIC #170000,(A) ; PC 12 BITS + RTS PC + + +XRERWS: PUSH A ;READ ERROR DOUBLE WORD INTO BLOCK POINTED TO BY A + MOVB 164003,(A)+ ;LOW BYTE FROM HIGH BYTE OF 002 + MOVB 164001,(A)+ ;HIGH BYTE FROM HIGH BYTE OF 000 + BIC #17,-2(A) ;THOSE BITS SOMETHING ELSE .. + MOVB 164013,(A)+ ;LOW BYTE FROM HIGH BYTE OF 012 + MOVB 164011,(A)+ ;HIGH BYTE FROM HIGH BYTE OF 010 + BIC #17600,-(A) ;THOSE BITS ALSO SOMETHING ELSE .. + POP A + RTS PC + +XWDIB: MOV (A)+,164000 ;WRITE DIAG INST BUFFER FROM TRIPLE WD POINTED TO BY A + MOV (A)+,164002 + MOV (A),164004 + SUB #<2*2>,A ;RESTORE A + RTS PC + +XDDEST: ;DEPOSIT B INTO DEST FIELD OF + ROR B ;DONT CARE ABT CARRY SINCE WILL MASK + ROR B ;LOW 2 BITS OF B GO IN HIGH 2 BITS OF FIRST WD + PUSH B ;PUSH IT WHEN LOW BYTE HAS HIGH 8 BITS + ROR B ;GET BIT OUT OF CARRY BACK INTO WD + BIC #37777,B + BIC #140000,(A) + BIS B,(A)+ + POP B + BIC #377,(A) ;OTHER 8 BITS GO IN LOW BYTE OF SECOND WD + BISB B,(A) + TST -(A) ;RESTORE A + RTS PC + + +XDALUF: ;DEPOSIT B INTO ALU OP FIELD OFU-INST POINTED TO BY A + ROL B + ROL B + ROL B + ROL B + BIC #1760,(A) + BIC #176017,B + BIS B,(A) + RTS PC + + +XDOBSL: ;DEPOSIT B INTO OUTPUT BUS CNTRL + SWAB B ;OF U INST POINTED TO BY A + ROL B + ROL B + ROL B + ROL B + BIC #030000,(A) + BIC #147777,B + BIS B,(A) + RTS PC + + +XDMSRC: ;DEPOSIT B INTO M SRC FIELD + TST (A)+ + SWAB B + BIC #037400,(A) + BIC #140377,B + BIS B,(A) + TST -(A) + RTS PC + +XDASRC: ;DEPOSIT B INTO A SRC FIELD + TST (A)+ + ROR B ;DONT CARE ABT CARRY SINCE WILL MASK + ROR B ;LOW 2 BITS OF B GO IN HIGH 2 BITS OF SECOND WD + PUSH B ;PUSH IT WHEN LOW BYTE HAS + ;HIGH 6 BITS RIGHT ADJUSTED + ROR B ;GET BIT OUT OF CARRY BACK INTO WD + BIC #37777,B + BIC #140000,(A) + BIS B,(A)+ + POP B + BIC #77,(A) ;OTHER 6 BITS GO IN LOW BYTE OF THIRD WD + BIC #177700,B + BIS B,(A) + SUB #4,A + RTS PC + + +XUICLR: MOV #UI+6,A ;CLEAR OUT TEM 3 REG BLOCK AND LEAVE A POINTING THERE + CLR -(A) + CLR -(A) + CLR -(A) + RTS PC + +XDMM0: PUSH A + PUSH B ;SAVE FINAL DEST + BIT B,#3740 + BEQ XDMMM ;DEST IS MM LOCN, BUILD THERE + CLR B ;BUILD IN M MEM 0 +XDMMM: MOV #XDMTM1,A ;CLEAR MM LOCN + JSR PC,XICLR + PUSH B ;SAVE BUILD DEST + JSR PC,XDDEST ;AND PUT IT INTO U INST + MOV (SP),B + JSR PC,XDMSRC ;ALSO M SRC + MOV #COBA,B + JSR PC,XDOBSL + MOV #USETZ,B + JSR PC,XDALUF + JSR PC,XWIR + JSR PC,XDCLK + MOV 4(SP),T ;GET BACK ORIG CONTENTS OF A + TST (T)+ + BNE XDMMB + TST (T) + BEQ XDMMC ;DEPOSITING ZERO +XDMMB: MOV #UASHM,B ;LOAD ASH IN ALU FCTN + EDALUF + MOV 4(SP),T ;GET BACK ORIG CONTENTS OF A + MOV 2(T),C ;DEPOSIT 2 WD BLOCK POINTED + BEQ XDMMA ;TO BY A IN M MEMORY LOCN 0 + JSR PC,XDM0A +XDMMA: MOV @4(SP),C + JSR PC,XDM0A +XDMMC: JSR PC,XNPCLK ;MAKE SURE DATA NOT IN PASS AROUND PATH + MOV #USETM,B + EDALUF +; EWIR +; MOV #XDM0BB,A +; EROBUS +; MOV 4(SP),C ;GET BACK ORIG CONTENTS OF A +; CMP (C),XDM0BB +; BNE XDM0ER +; CMP 2(C),XDM0BB+2 +; BNE XDM0ER + POP C ;BUILD DEST + POP B ;FINAL DEST + MOV #XDMTM1,A ;RESTORE A + CMP B,C + BEQ XDM0EX ;HAVE STORED IT WHERE DESIRED + PUSH B + BIT #2000,B + BNE XDMSD ;GEE, REALLY WANT THIS IN PSEUDO DEST + JSR PC,XDDEST ;DEPOSIT IN FINAL DEST +; MOV #USETM,B +; JSR PC,XDALUF + JSR PC,XWIR + JSR PC,XDCLK + JSR PC,XNPCLK ;GENERATE AN EXTRA JUST TO MAKE SURE + POP B ;IT REALLY GETS WRITTEN IF TO PDL BUFFER +XDM0EX:;BIT #CDAMEM,B +; BEQ XDM0X1 +; PUSH B +; EDASRC ;CHECK DEPOSIT INTO A MEM +; MOV #USETA,B +; EDALUF +; EWIR +; MOV #XDM0BB,A +; EROBUS +; MOV 2(SP),C +; CMP (C),XDM0BB +; BNE XDM0E1 +; CMP 2(C),XDM0BB+2 +; BNE XDM0E1 +;XDM0X2: POP B +XDM0X1: POP A + RTS PC + +;XDM0ER: POP B +XDM0E1: POP B + POP A + RTS PC +; JMP EMTERX ;LOSES ON DIRECT CALL + +XDMSD: CMP B,#CSDQ ;DEPOSIT IN PSEUDO DEST + BNE XDM0E1 + BIS #3,(A) ;LOAD Q INTO Q CONTROL + EWIR + EDCLK + POP B + BR XDM0X1 + +XDM0BB: 0 + 0 + +XDMTM1: 0 + 0 + 0 + + +XDM0A: MOV #16.,T ;LOOP COUNT + MOV #4,TT ;CARRY IN BIT OF ALU +XDM0B: BIC TT,(A) + TST C + BGE XDM0C + BIS TT,(A) ;SET CARRY IN +XDM0C: JSR PC,XWIR ;GO DIRECTLY TO SAVE TIME! + JSR PC,XDCLK + ROL C + DEC T + BNE XDM0B + RTS PC + +XEXAMD: PUSH A ;EXAMINE DATA PATH MEMORIES + PUSH B + MOV #XEXM1,A + EICLR + EDDEST + MOV #COBA,B + EDOBSL + MOV (SP),B + BIT B,#CDAMEM + BNE XEXAM ;A MEM + EDMSRC + MOV #USETM,B +XEXAM1: EDALUF + EWIR + MOV 2(SP),A + EROBUS + POP B + POP A + RTS PC + +XEXAM: EDASRC + MOV #USETA,B + BR XEXAM1 + +XEXM1: 0 + 0 + 0 + + +XDJPC: ROR B ;DEPOSIT B INTO JUMP FIELD OF A + ROR B + ROR B + ROR B + PUSH B + ROR B + BIC #7777,B + BIC #170000,(A) + BIS B,(A) + POP B + BIC #377,2(A) + BISB B,2(A) + RTS PC + +XDCMEM: PUSH A ;LOAD U INST POINTED TO BY A INTO CONTROL + PUSH B ;MEM LOCN IN B + MOV 2(SP),A + ADD #4,A + MOV #CDAMEM+1,B + JSR PC,XDMM0 ;DEPOSIT HI PART IN A-MEM LOCN 1 + MOV 2(SP),A + CLR B + JSR PC,XDMM0 ;DEPOSIT LOW PART IN M-MEM LOCN 0 +; MOV #XDCIPC,A +; JSR PC,XRPC ;SAVE PC BEFORE HACKING HAIRY PART + MOV #XDCIB,A + JSR PC,XICLR + BIS #CIJMP,4(A) + MOV (SP),B + JSR PC,XDJPC + BIS #CIJNB+CIJRB+CIJPB+CIJUC,(A) + BIS #40000,2(A) ;A SOURCE 1 + JSR PC,XWIR +; MOV #XDCTPC,A +; JSR PC,XRPC +; DEC XDCTPC +; BIC #170000,XDCTPC +; CMP XDCTPC,XDCIPC +; BEQ XDCEC1 +; INC XDCME1 ;THEY SHOULD HAVE BEEN EQUAL +XDCEC1: JSR PC,XCLK +; ERPC +; CMP XDCTPC,(SP) +; BEQ XDCEC2 +; INC XDCME2 +XDCEC2: JSR PC,XNPCLK +; ERPC +; DEC XDCTPC +; BIC #170000,XDCTPC +; CMP XDCTPC,XDCIPC +; BEQ XDCEC3 +; INC XDCME3 +XDCEC3: POP B + POP A + RTS PC + +;XDCME1: 0 +;XDCME2: 0 +;XDCME3: 0 + +XDCIB: 0 + 0 + 0 + +;XDCIPC: 0 ;INITIAL PC (BEFORE HACKING) +;XDCTPC: 0 ;TEMP FOR READING IN PC + + +XICLR: PUSH A ;CLEAR THREE INST BLOCK POINTED + CLR (A)+ ;TO BY A + CLR (A)+ + CLR (A) + POP A + RTS PC + +XEXAMC: PUSH A ;EXAMINE CONTROL MEM AT LOCN IN B + PUSH B + MOV #XEXC1,A + EICLR + BIS #CIJNB+CIJUC,(A) + EDJPC + BIS #CIJMP,4(A) + EWIR + EDCLK + ENCLK + POP B + POP A + ERIR + RTS PC + +XEXC1: 0 + 0 + 0 + +XRESET: MOV #4,164006 ;DO CONS RESET + MOV #0,164006 + JMP MODSET ;SET SPEED AND ENABLE HALT ON ERROR + +; MOV #101000,164006 ;NORMAL SPEED, ENABLE HALT ON ERROR +; CLR MODREG +; RTS PC + +XDCLK: MOV #110,164006 ;TICK CLOCK IN DEBUG MODE + MOV #112,164006 ;NOT CHANGING OPCS + RTS PC + +XWIR: JSR PC,XWDIB ;WRITE INTO IR (FIRST INTO DIB) + BR XNPCLK ;THEN NO-OP CLOCK + +XDCCLK: TST NOOPF ;EDCLK UNLESS NOOPF SET + BEQ XDCLK ;IN WHICH CASE ENPCLK + CLR NOOPF +XNPCLK: MOV #130,164006 ;TICK CLOCK WITH BOTH DEBUG AND NO OP ON + MOV #132,164006 ;NOT AFFECTING OPCS + MOV #112,164006 ;CLEAR NO OP + RTS PC + +XCLK: MOV #0,164006 ;TICK CLOCK ONCE IN REGULAR RUN + MOV #2,164006 ;MODE + RTS PC + +XCCLK: TST NOOPF ;CLOCK UNLESS NOOPF SET + BEQ XCLK ;NO NOOP + CLR NOOPF +XNCLK: MOV #120,164006 ;CYCLE CLOCK ONCE IN REGULAR + MOV #122,164006 ;MODE WITH NO-OP BIT SET, NOT AFFECTING OPCS + MOV #12,164006 ;CLEAR NO OP + RTS PC + + +XOCTPD: JSR PC,EMTSAV ;PRINT 11 OCTAL DIGITS OF BLOCK POINTED TO BY A + PUSH A + MOV 2(A),A ;GET HIGH WORD + CLC + ROR A + ASR A + ASR A + ASR A + MOV #5,C + JSR PC,OCTPN ;PRINT HIGH FIVE DIGITS (14 BITS WORTH) + MOV (SP),C + MOV (C),A + ROL A ;GET HIGH BIT OF LOW WORD IN CARRY + MOV 2(C),A + ROL A + MOV #1,C + JSR PC,OCTPN ;PRINT THE SPLIT DIGIT + POP C + MOV (C),A + MOV #5,C + BR OCTPN ;FINISH OFF WITH LAST 5 DIGITS. + +XPI: MOV 4(A),C ;PRINT BLOCK POINTED TO BY A AS U INST. + BIT #100,C + BEQ XPI1 ;TEST POPJ BIT + ETEXT ;POPJ BIT ON + ASCPJ +XPI1: ROL C + SWAB C + BIC #177774,C + ASL C + JMP @XPIDT(C) ;DISPATCH ON OP CODE + +XOCTP4: JSR PC,EMTSAV ;SAVE AC S + MOV #4,C ;PRINT 4 DIGITS OF A +OCTPN: MOV A,B ;PRINT # DIGITS IN C OF A +OCTPNB: MOV #6,T + CLR A ;DROP IN HERE SINCE FIRST "DIGIT" HAS ONE BIT +OCTPL: ROL B + ROL A + CMP C,T + BLT OCTPL1 ;DONT WANT THAT DIGIT + ADD #'0,A + PUSH B + PUSH C + PUSH T + JSR PC,ADDCHR + POP T + POP C + POP B +OCTPL1: DEC T + BEQ OCTPX + CLR A + ROL B + ROL A + ROL B + ROL A + BR OCTPL + +OCTPX: RTS PC + +.SBTTL ASCII CONSTANTS + +ASC3SP: .ASCIZ / / +ASC2SP=ASC3SP+1 +ASCSP=ASC3SP+2 +ASCPJ: .ASCIZ / PJ / +ASCALU: .ASCIZ /ALU / +ASCDSP: .ASCIZ /DSP / +ASCJMP: .ASCIZ /JMP / +ASCBYT: .ASCIZ /BYT / +ASCA: .ASCIZ /A / +ASCM: .ASCIZ /M / +ASCD: .ASCIZ /D / +ASCDM: .ASCIZ /DM / +ASCDR: .ASCIZ /DR / +ASCDA: .ASCIZ /DA / +ASCMSK: .ASCIZ /MSK?? / +ASCAR1: .ASCIZ /ALUR1 / +ASCAL1: .ASCIZ /ALUL1 / +ASCMB: .ASCIZ /MULT / +ASCINM: .ASCIZ /INCM / +ASC1: .ASCIZ /1 / +ASC2: .ASCIZ /2 / +ASC3: .ASCIZ /3 / +ASC4: .ASCIZ /4 / +ASC5: .ASCIZ /5 / +ASCSUB: .ASCIZ /SUB / +ASC7: .ASCIZ /7 / +ASC10: .ASCIZ /10 / +ASCADD: .ASCIZ /ADD / +ASC12: .ASCIZ /12 / +ASC13: .ASCIZ /13 / +ASLSHM: .ASCIZ /LSHM / +ASC15: .ASCIZ /15 / +ASC16: .ASCIZ /16 / +ASCDCM: .ASCIZ /DECM / +ASETCM: .ASCIZ /SETCM / +AANDCB: .ASCIZ /ANDCB / +AANDCM: .ASCIZ /ANDCM / +ASETZ: .ASCIZ /SETZ / +AORCB: .ASCIZ /ORCB / +ASETCA: .ASCIZ /SETCA / +AXOR: .ASCIZ /XOR / +AANDCA: .ASCIZ /ANDCA / +AORCM: .ASCIZ /ORCM / +AEQV: .ASCIZ /EQV / +ASETA: .ASCIZ /SETA / +AAND: .ASCIZ /AND / +ASETO: .ASCIZ /SETO / +AORCA: .ASCIZ /ORCA / +AOR: .ASCIZ /OR / +ASETM: .ASCIZ /SETM / +ASCC0: .ASCIZ /C0 / +ASCC1: .ASCIZ /C1 / +ASCCL: .ASCIZ /CRYLAST / +ASCCQ: .ASCIZ /CRYQ / +ASCNUL: .ASCIZ // +ASCQL: .ASCIZ /QLEFT / +ASCQR: .ASCIZ /QRIGHT / +ASCLQ: .ASCIZ /LOADQ / +ASCDC: .ASCIZ /DISP-C / +ASCDO: .ASCIZ /DISP-O / +ASCNB: .ASCIZ /BYT-LEN / +ASCMR: .ASCIZ /M-ROT / +ASCR: .ASCIZ /R / +ASCP: .ASCIZ /P / +ASCN: .ASCIZ /N / +ASCI: .ASCIZ /I / +ASCTB: .ASCIZ /TEST-BIT / +ASCSR: .ASCIZ / R / +ASCLDB: .ASCIZ /LDB / +ASCDPB: .ASCIZ /DPB / +ASCSBB: .ASCIZ /SUBS / +ASCAUM: .ASCIZ /ALU- / +ASCAUH: .ASCIZ /ALU-31 / + +ASCAEM: .ASCIZ /A=M / +ASCINT: .ASCIZ /INT / +ASCPF: .ASCIZ /PF / +ASCIPF: .ASCIZ /IPF / +ASCUNC: .ASCIZ /UNC / +ASCQQ: .ASCIZ /?? +/ +ASCSPC: .ASCIZ /PC-FROM-SP / +ASCPC1: .ASCIZ /PC+1 / +ASCJT: .ASCIZ /JC-TRUE / +ASCJF: .ASCIZ /JC-FALSE / +ASCSPP: .ASCIZ /SPC-PAR / +ASCDPP: .ASCIZ /DSP-PAR / +ASCHER: .ASCIZ /HI-ERR / +ASCCPP: .ASCIZ /C-MEM-PAR / +ASCMPP: .ASCIZ /M-MEM-PAR / +ASCAPP: .ASCIZ /A-MEM-PAR / +ASCPPP: .ASCIZ /PDL-BUF-PAR / +ASCMNP: .ASCIZ /MN-MEM-PAR / +ASCHOK: .ASCIZ /HI-NOT-OK / +ASCRUN: .ASCIZ /SRUN / +ASCWIM: .ASCIZ /W-C-MEM / +ASCIMD: .ASCIZ /IMOD / +ASCNOP: .ASCIZ /NOP / +ASCMMW: .ASCIZ /MN-MEM-WT / +ASCWPD: .ASCIZ /W-P-BUF / +ASCWSP: .ASCIZ /W-USTK / +ASCICM: .ASCIZ /@C/ +ASCIAM: .ASCIZ /@A/ +ASCIMM: .ASCIZ /@M/ +ASCIPB: .ASCIZ /@P/ +ASCIUS: .ASCIZ /@U/ +ASC1MP: .ASCIZ /@1/ +ASC2MP: .ASCIZ /@2/ +ASCIDM: .ASCIZ /@D/ +ASCREG: .ASCIZ /REGADR / +ASCCR: .ASCIZ / +/ +ASCSLT: .ASCIZ ?/ ? +ASCQQJ: .ASCIZ /JC?? / +ASCQST=ASCQQJ+3 +ASCTOP: .ASCIZ / OP / +ASCQC: .ASCIZ /QC / +ASCMF: .ASCIZ /MF / +ASCXXX: .ASCIZ /XXX / +ASCU: .ASCIZ /U / +ASCCRY: .ASCIZ /CRYC / +ASCJC: .ASCIZ /JC / +ASCJPC: .ASCIZ /J-ADR / +ASCMD: .ASCIZ /MD / +ASCHLT: .ASCIZ /HALT / +ASCMF2: .ASCIZ /MF2 / +ASCLLB: .ASCIZ /LD-LOW-PC-BIT / +ASCLLR: .ASCIZ /LOW-PC-BIT-SEL-HW / +ASCIR: .ASCIZ /.IR/ +ASCSIR: .ASCIZ /IR/ +ASCPC: .ASCIZ /PC/ +ASCUSP: .ASCIZ /USP/ +ASCFSP: .ASCIZ /+FSRC/ +ASCFS=ASCFSP+1 +ASCFDP: .ASCIZ /+FDST/ +ASCFD=ASCFDP+1 ;HACK HACK +ASCQ: .ASCIZ /Q/ +ASCPP: .ASCIZ /PP/ +ASCPI: .ASCIZ /PI/ +ASCCIB: .ASCIZ /CIB/ +ASCCBP: .ASCIZ /CIB+/ +ACVMAR: .ASCIZ /CVMAR/ +ACMRD: .ASCIZ /CMRD/ +ACPMAR: .ASCIZ /CPMAR/ +ACMWD: .ASCIZ /CMWD/ +ACVMAW: .ASCIZ /CVMAW/ +ACPMAW: .ASCIZ /CPMAW/ + +CSTARS: .ASCIZ /****************************************************** +PC= / +COBTX: .ASCIZ / +OBUS= / +CERRST: .ASCIZ / +STATUS: / +ASCLLM: .ASCIZ /LLMODE/ +ASCFSV: .ASCIZ /FSV/ +ASCPSV: .ASCIZ /PSV/ +ASCSLH: .ASCIZ ?/? +ASCNPF: .ASCIZ /NOOPF/ +ASCRDR: .ASCIZ /RAIDR/ +ASCRDP: .ASCIZ /RAIDR+/ +ASCDC1: .ASCIZ /DC/ +ASCVMA: .ASCIZ /VMA/ +ASCMWD: .ASCIZ /MWD/ +ASCRST: .ASCIZ /RESET/ +ASCPJ1: .ASCIZ /PJ/ +ASCNPJ: .ASCIZ /NPJ/ +ASCOL1: .ASCIZ /OBL1/ +ASCOR1: .ASCIZ /OBR1/ +ASCMOD: .ASCIZ /MODE/ +ASCILG: .ASCIZ /ILONG / +ASCB42: .ASCIZ /BIT42 / +ASCPFG: .ASCIZ /PDP11-FLAG / +.EVEN + + +.SBTTL PRINT VARIOUS FIELDS + +XPIDT: XPIALU + XPIDSP + XPIJMP + XPIBYT + +XPIALU: ETEXT + ASCALU + EPASRC ;PRINT A SOURCE + EPMSRC ;PRINT M SOURCE + EPOBSL ;PRINT OUTPUT BUS SELECT + EPDEST ;PRINT DEST + EPALUF ;PRINT ALU FCTN + EPCRYC ;PRINT CARRY CODE + EPQC ;PRINT Q CONTROL + MOV #XPALMF,C ;MISC FCTN + BR XPMF1 + +XPALMF: ASCNUL ;MF S FOR ALU + ASCHLT + ASCMF2 + ASCLLB + +XPIDSP: ETEXT + ASCDSP + EPDDC ;PRINT DISPATCH CONSTANT + EPMSRC + EPDDO ;PRINT DISPATCH OFFSET + EPDNB ;DISPATCH # BITS + EPMROT ;M ROTATE +XPMF: MOV #XPMFT,C ;MISC FTCN +XPMF1: MOV #<<2*400>+12>,B + IPSFLD + BIT #1000,4(A) ;THE 4 EXTRA BITS (BUT DON'T PRINT PARITY BIT) + BEQ 1$ + ETEXT + ASCILG +1$: BIT #2000,4(A) + BEQ 2$ + ETEXT + ASCB42 +2$: BIT #4000,4(A) + BEQ 3$ + ETEXT + ASCPFG +3$: RTS PC + +XPMFT: ASCNUL ;MISC FCTN TBL FOR JMP BYT DSP + ASCHLT + ASCMF2 + ASCLLR + +XPIJMP: ETEXT + ASCJMP + EPASRC + EPMSRC + EPJPC ;NEW PC + EPJRB ;R BIT + EPJPB ;P BIT + EPJNB ;N BIT + EPJINV ;INVERT + EPJCND ;CONDITION + BR XPMF ;ONLY THING LEFT IS MISC FCTN + +XPIBYT: ETEXT + ASCBYT + EPASRC + EPMSRC + EPDEST + EPBMD ;BYTE MODE + EPBLEN ;BYTE LENGTH + EPMROT ;BYTE ROTATE + BR XPMF ;ONLY THING LEFT IS MISC FCTN + + +XPASRC: ETEXT ;PRINT A SOURCE + ASCA +XPASR1: MOV #<<8*400>+36>,B ;8 BIT FLD 36 OVER + ; ENTER HERE FOR DISPATCH CONSTANT +XPMSR1: IPNFLD ;EXTRACT AND PRINT FIELD + RTS PC + +XPMSRC: ETEXT ;PRINT M SOURCE + ASCM + MOV #<<6*400>+30>,B ;6 BIT FIELD 30 OVER + BR XPMSR1 + +XPDEST: ;PRINT DEST (OF BYTE AND ALU INSTS) + BIT #CAMEMB,2(A) + BNE XPDES1 ;A MEM DESTINATION + ETEXT ;M MEM AND/OR REGISTER DESTINATION + ASCDM + MOV #<<5*400>+16>,B ;PRINT M MEM DEST + IPNFLD + ETEXT + ASCDR ;PRINT REGISTER DEST + MOV #<<4*400>+23>,B + IPNFLD + RTS PC + +XPDES1: ETEXT ;PRINT A MEM DESTINATION + ASCDA + MOV #<<8*400>+16>,B + IPNFLD + RTS PC + + +XPOBSL: MOV #<<2*400>+14>,B ;PRINT O BUS SELECTOR FIELD OF ALU INST + MOV #XOPBTX,C + IPSFLD + RTS PC + +XOPBTX: ASCMSK + ASCALU + ASCAR1 + ASCAL1 + +XPALUF: BIT #1000,(A) ;PRINT ALU FCTN + BEQ XPALU1 + ETEXT + ASCMB ;"MULTIPLY" BIT ON +XPALU1: MOV #<<5*400>+4>,B + MOV #XPALTX,C + IPSFLD + RTS PC + +XPALTX: ASCINM + ASC1 + ASC2 + ASC3 + ASC4 + ASC5 + ASCSUB + ASC7 + ASC10 + ASCADD + ASC12 + ASC13 + ASLSHM + ASC15 + ASC16 + ASCDCM + ASETCM + AANDCB + AANDCM + ASETZ + AORCB + ASETCA + AXOR + AANDCA + AORCM + AEQV + ASETA + AAND + ASETO + AORCA + AOR + ASETM + + +XPCRYC: MOV #<<2*400>+2>,B ;PRINT CARRY CONTROL FIELD + MOV #XPCRYT,C + IPSFLD + RTS PC + +XPCRYT: ASCC0 + ASCC1 + ASCCL + ASCCQ + +XPQC: MOV #<<2*400>+0>,B ;PRINT Q CONTROL FIELD + MOV #XPQCT,C + IPSFLD + RTS PC + +XPQCT: ASCNUL + ASCQL + ASCQR + ASCLQ + +XPDDC: ETEXT ;PRINT DISPATCH CONSTANT + ASCDC ;DISPATCH CONSTANT SAME AS A SOURCE + JMP XPASR1 + +XPDDO: ETEXT ;PRINT DISPATCH OFFSET + ASCDO + MOV #<<12*400>+16>,B ;10. BIT FIELD 16 OVER + IPNFLD + RTS PC + +XPDNB: ETEXT ;PRINT # BITS FIELD OF DISPATCH INST + ASCNB ;GET BYTE LENGTH + MOV #<<3*400>+5>,B + IPNFLD + RTS PC + +XPMROT: ETEXT ;PRINT M ROTATE FIELD + ASCMR +XPMRT1: MOV #<<5*400>+0>,B ;ENTER HERE FOR JUMP COND ON BIT + IPNFLD + RTS PC + +XPJPC: ETEXT ;PRINT JUMP NEW PC FIELD + ASCJPC + MOV #<<14*400>+14>,B + IPNFLD + RTS PC + + +XPJRB: MOV #<<1*400>+11>,B ;PRINT JUMP R BIT FIELD + MOV #XPJRBT,C +XPJPB1: IPSFLD + RTS PC + +XPJRBT: ASCNUL + ASCR + +XPJPB: MOV #<<1*400>+10>,B ;PRINT JUMP P BIT FIELD + MOV #XPJPBT,C + BR XPJPB1 + +XPJPBT: ASCNUL + ASCP + +XPJNB: MOV #<<1*400>+7>,B ;PRINT JUMP N BIT FIELD + MOV #XPJNBT,C + BR XPJPB1 + +XPJNBT: ASCNUL + ASCN + +XPJINV: MOV #<<1*400>+6>,B ;PRINT JUMP INVERT SENSE FIELD + MOV #XPJIBT,C + BR XPJPB1 + +XPJIBT: ASCNUL + ASCI + +XPJCND: MOV #<<5*400>+0>,B ;PRINT JUMP CONDITION FIELD + BIT #40,(A) + BEQ XPJCN1 ;XFER ON TEST BIT + MOV #XPJCNT,C + IPSFLD + RTS PC + +XPJCN1: ETEXT ;TEST BIT + ASCTB + JMP XPMRT1 ;SAME AS M ROTATE + +XPJCNT: ASCNUL ;0 ;TABLE OF JUMP CONDITIONS + ASCAUM ;1 + ASCAUH ;2 + ASCAEM ;3 + ASCINT ;4 + ASCPF ;5 + ASCIPF ;6 + ASCUNC ;7 + ASCQQJ ;10 + ASCQQJ ;11 + ASCQQJ ;12 + ASCQQJ ;13 + ASCQQJ ;14 + ASCQQJ ;15 + ASCQQJ ;16 + ASCQQJ ;17 + ASCQQJ ;20 + ASCQQJ ;21 + ASCQQJ ;22 + ASCQQJ ;23 + ASCQQJ ;24 + ASCQQJ ;25 + ASCQQJ ;26 + ASCQQJ ;27 + ASCQQJ ;30 + ASCQQJ ;31 + ASCQQJ ;32 + ASCQQJ ;33 + ASCQQJ ;34 + ASCQQJ ;35 + ASCQQJ ;36 + ASCQQJ ;37 + +XPBMD: MOV #<<2*400>+14>,B ;PRINT MODE FIELD OF BYTE INST + MOV #XPBMTX,C + IPSFLD + RTS PC + +XPBMTX: ASCNUL + ASCLDB + ASCSBB + ASCDPB + +XPBLEN: ETEXT ;PRINT BYTE LENGTH FIELD OF BYTE INST + ASCNB + MOV #<<5*400>+5>,B + IPNFLD + RTS PC + +XXFLD: PUSH B + MOV 4(A),C ;EXTRACT FIELD FROM U INST + MOV 2(A),T ;B HAS FIELD DESC + MOV (A),TT + MOVB B,U + BEQ XXFLD1 +XXFLD2: ROR C + ROR T + ROR TT + DEC U + BNE XXFLD2 +XXFLD1: MOVB 1(SP),U ;FIELD LENGTH + CMP U,#16. + BLE XXFLD3 + MOV #16.,U ;GIVE LOW 16. BITS OF FIELD > 16. BITS +XXFLD3: ASL U + MOV TT,A + BIC XXMSK(U),A + POP B + RTS PC + +XXMSK: 177777 + 177776 + 177774 + 177770 + 177760 + 177740 + 177700 + 177600 + 177400 + 177000 + 176000 + 174000 + 170000 + 160000 + 140000 + 100000 + 0 + + + +XWPC: MOV (A),B ;WRITE LOCN POINTED TO BY A INTO CONS PC + PUSH B + MOV #XWPCI,A + EICLR + BIS #CIJMP,4(A) + EDJPC + BIS #CIJUC,(A) + EWIR + EDCLK + MOV #XWPCT,A + ERPC + CMP XWPCT,(SP)+ + BEQ XWPCR + INC XWPCL + JMP EMTERX + +XWPCR: RTS PC + +XWPCI: 0 + 0 + 0 +XWPCT: 0 +XWPCL: 0 + + +XPERRS: PUSH A ;PRINT ERRORS + BIT #CESPCP,(A) + BEQ XPER1 + ETEXT + ASCSPP +XPER1: BIT #CEDSPP,(A) + BEQ XPER2 + ETEXT + ASCDPP +XPER2: BIT #CEHIER,(A) + BEQ XPER3 + ETEXT + ASCHER +XPER3: BIT #CECP,(A) + BEQ XPER4 + ETEXT + ASCCPP +XPER4: BIT #CEMMP,(A) + BEQ XPER5 + ETEXT + ASCMPP +XPER5: BIT #CEAMP,(A) + BEQ XPER6 + ETEXT + ASCAPP +XPER6: BIT #CEPDL,(A) + BEQ XPER7 + ETEXT + ASCPPP +XPER7: BIT #CEMNMP,(A) + BEQ XPER8 + ETEXT + ASCMNP +XPER8: BIT #CEHNOK,(A) + BEQ XPER9 + ETEXT + ASCHOK +XPER9: BIT #CESRUN,(A)+ + BEQ XPER10 + ETEXT + ASCRUN +XPER10: BIT #CEWIM,(A) ;2ND WORD BITS + BEQ XPER11 + ETEXT + ASCWIM +XPER11: BIT #CEIMOD,(A) + BEQ XPER12 + ETEXT + ASCIMD +XPER12: BIT #CEINOP,(A) + BEQ XPER13 + ETEXT + ASCNOP +XPER13: BIT #CENMMW,(A) + BNE XPER14 + ETEXT + ASCMMW +XPER14: BIT #CEWPDL,(A) + BEQ XPER15 + ETEXT + ASCWPD +XPER15: BIT #CEWSPC,(A) + BEQ XPER16 + ETEXT + ASCWSP +XPER16: BIT #CEPF,(A) + BEQ XPER17 + ETEXT + ASCPF +XPER17: MOV #<<1*400>+2>,B ;JUMP CONDITION BIT + MOV #XPERJT,C + IPSFLD + MOV #<<2*400>+0>,B ;PC SOURCE FIELD + MOV #XPERPT,C + IPSFLD + POP A + RTS PC + +XPERJT: ASCJF + ASCJT + +XPERPT: ASCPC1 + ASCDSP + ASCSPC + ASCJMP + +.SBTTL READ & WRITE VARIOUS PARTS OF CONS + +XSTOP: TST CTRUN + BEQ XSTOP1 + TST 164002 + BMI XSTOP1 + CLR CTRUN ;LOSE, ERROR; NOT ONLY STOP, BUT STOP TRYING +; CLR LMHTTY ;ALSO FLUSH TTY +XSTOP1: MOV #0,164006 ;STOP CONS + CLR CRUN + RTS PC + +XDPB: PUSH B ;DPB B IN BLOCK (A) AT POS IN C + PUSH C + MOVB 1(SP),U ;# BITS IN FIELD + ASL U + MOV XXMSK(U),C ;MASK FOR FIELD + BIC C,B ;CLEAR ANY EXTRA BITS IN B + COM C + MOVB (SP),U ;# PLACES TO SHIFT + JSR PC,XDPBS ;SHIFT IFY + BIC C,(A) + BIC T,2(A) + BIC TT,4(A) + MOV B,C + MOVB (SP),U + JSR PC,XDPBS + BIS C,(A) + BIS T,2(A) + BIS TT,4(A) + POP C + POP B +XDPBX: RTS PC + +XDPBS: CLR T + CLR TT +XDPBS1: TST U ;THREE PRECISION SHIFT OF C T TT AMT IN U + BEQ XDPBX + ASL C + ROL T + ROL TT + DEC U + BR XDPBS1 + +XDMDST: MOV #<<5*400>+16>,C ;DEPOSIT IN M MEM PART OF DESTINATION +XDRDS1: BIC #CAMEMB,2(A) ;TURN OFF A DEST BIT +XDDSP1: EDPB + RTS PC + +XDRDST: MOV #<<4*400>+16+5>,C ;DEPOSIT IN REG PART OF DESTINATION + BR XDRDS1 + +XDDSPO: MOV #<<10.*400>+16>,C ;DEPOSIT IN DISPATCH OFFSET FIELD + BR XDDSP1 + + +XRPDLB: JSR PC,SVPDLI ;READ PDL BUFFER ADR IN B + MOV #CMSCI,B ; STORE RESULT IN 2 WD BLOCK(A) + EEXAMD ;READ DATA +RSPDLI: PUSH A ;RESTORE PDL INDEX + MOV #SVPITM,A + BR RSPI1 + +XWPDLB: JSR PC,SVPDLI ;WRITE PDL BUFFER ADR IN B FROM + MOV #,B ; DATA IN BLOCK(A) + EDMM0 + BR RSPDLI + +SVPDLI: PUSH A + MOV B,SVPDTM ;SAVE DESIRED NEW CONTENTS OR + MOV #SVPITM,A ;PDL INDEX + MOV #CMSPPI,B + EEXAMD ;SAVE PDL INDEX + BIC #176000,(A)+ ;LEAVE JUST PI + CLR (A) + MOV #SVPDTM,A +RSPI1: MOV #,B + EDMM0 ;WRITE IN NEW CONTENTS + MOV SVPDTM,B + POP A + RTS PC + +SVPDTM: 0 ;TEMP BLOCK HOLDING NEW DATA + 0 +SVPITM: 0 ;TEMP BLOCK HOLDING OLD PI + 0 + +XSURUP: MOV #XSUTP,A ;SAVE ENTIRE USTACK + MOV #CMSUS,B ;GET USTACK POINTER + EEXAMD + MOV #<<5*400>+27.>,B ;POINTER READS INTO THOSE BITS + EXFLD + RTS PC + +XSUSTK: TST USSVDF + BNE XSUSTY ;ALREADY SAVED + JSR PC,XSURUP ;READ U STACK PNTR + MOV A,USTPNR + MOV #32.,XSUSTC ;SAVE 32 REG + ASL A ;CONVERT TO WDS + ADD #USSVD,A ;GET ADR IN USTK IMAGE +XSUSTL: MOV A,XSUSTP + MOV #XSUTP,A + MOV #CMSUSP,B ;USTACK DATA, POP + EEXAMD + EDCLK ;CLOCK WITH THAT IN IR TO POP + MOV XSUSTP,A + MOV XSUTP,(A) ;SALT DATA AWAY + TST -(A) ;HARDWARE DECREMENTS ON POP + DEC XSUSTC + BEQ XSUSTX ;THRU + CMP A,#USSVD + BHIS XSUSTL + MOV #USSVDE-2,A ;WRAP AROUND TO TOP + BR XSUSTL +XSUSTX: DEC USSVDF ;INDICATE SAVED +XSUSTY: RTS PC + +XSUSTP: 0 ;POINTER TO PLACE IN PDL BUFFER +XSUSTC: 0 ;COUNT OF LOCNS +XSUTP: 0 ;TEMP BLOCK + 0 + +XUUSTK: TST USSVDF + BEQ XUUSTX +XUUST1: JSR PC,XSURUP ;READ USTACK PDL + CMP A,USTPNR + BEQ XUUST2 ;GOT THAT RESTORED .. + MOV #XSUTP,A + MOV #CMSUSP,B + EEXAMD ;BUMP IT BY ONE + EDCLK ;CLOCK IT WITH THAT IN IR + BR XUUST1 ;TRY AGAIN! +XUUST2: MOV #32.,XSUSTC + INC A ;HARDWARE WILL INC BEFORE PUSH + BIC #177740,A ;SET UP A TO POINT TO USSVD + ASL A ; LOCN THAT WILL GET WRITTEN +XUUST4: ADD #USSVD,A +XUUST3: MOV (A)+,XSUTP ;HARDWARE INCRS ON PUSH + MOV A,XSUSTP + MOV #XSUTP,A + CLR 2(A) ;MAYBE RUN A LITTLE FASTER (HA) + MOV #,B ;RESTORE THAT ONE + EDMM0 + DEC XSUSTC + BEQ XUUSTX ;THRU + MOV XSUSTP,A + CMP A,#USSVDE + BLO XUUST3 + CLR A + BR XUUST4 +XUUSTX: CLR USSVDF ;NOW RESTORED + RTS PC + +XRDSP: PUSH A ;READ DISPATCH MEMORY + PUSH B ;FIRST SAVE DISPATCH CONSTANT REGISTER + JSR PC,XDSPSU ;"SET UP" DISPATCH INST + EWIR ;PUT THAT CONCONCTION IN IR .. + MOV #XRDT,A ;READ IN PC SELECT BITS AND FIGURE OUT P AND R + ERERWS ;READ IN ERROR WDS + MOV XRDT+2,C + BIC #177774,C ;GET PC SELECT BITS + ASL C + MOV XRDSTB(C),XRDSPW ;TRANSLATE TO WHAT THOSE TWO BITS REALLY MEAN + MOV #XRDSB,A ;GET POINTER TO UINST AGAIN + BIS #CMF1,(A) ;TURN ON MISC FCTN 1 (FORCE STRAIGHT DISPATCH) + EWIR + EDCLK ;EXECUTE INST + MOV #XRDT,A + ERPC ;READ IN PC + MOV XRDT,C ;GOBBLE PC BITS + BIS XRDSPW,C ;IOR IN P AND R BITS + BIT #1_13.,164010 ;TEST NO-OP CONDITION + BEQ XRDS1 + BIS #CDMN,C ;N BIT MUST HAVE BEEN ON +XRDS1: POP B + POP A + MOV C,(A) + RTS PC + +XRDSTB: CDMR+CDMP ; (PC+1) IT WAS GOING TO FALL THRU, SO BOTH P AND R SET + 0 ; (DSP) + CDMR ; (SPC) IT WAS GOING TO POPJ + 0 ; (JMP) ?? + +XRDSPW: 0 ;TEMP FOR BUILDING UP WD +XRDT: 0 ;TEMP BLOCK + 0 +XRDSB: 0 ;TEMP BLOCK FOR DISPATCH U INST + 0 + 0 + +XDSPSU: MOV #XRDT,A ;READ DISP CONST + ERDSPC ; CAUTION!! TAKES DISP OFFSET ARG IN 2(SP) +XDSPS1: ESUSTK ;SAVE USTACK SINCE HACKING WITH + ;DISP MEMORY CAN CLOBBER IT + ; (REMOVE THIS WHEN HARDWARE MOD + ; MADE) + MOV #XRDSB,A ;DUMMY UP DISP INST + EICLR + BIS #CIDSP,4(A) + MOV 2(SP),B ;GET DESIRED DISPATCH OFFSET + EDDEST ;STORE IN DISPATCH OFFSET (SAME FLD AS DEST) + MOV XRDT,B + EDASRC ;PUT IN DISPATCH CONSTANT AS IT IS + RTS PC + +XWDSP: PUSH A ;WRITE DISPATCH MEM + PUSH B + MOV (A),C + BIC #100000,C ;THAT BIT TO BE PARITY + JSR PC,PARCMP ;RETURN 0 OR -1 IN T + BIC #77777,T ;LEAVE PARITY IN DESIRED PLACE + BIS C,T ;OR IN REST OF BITS + MOV T,XRDT ;SAVE THAT + CLR XRDT+2 + MOV #XRDT,A + CLR B + EDMM0 ;PUT DATA TO WRITE IN MM LOCN 0 + JSR PC,XDSPSU ;SET UP DISP INSTRUCTION + BIS #CMF2,(A) ;MF2 IS WRITE DISPATCH MEM + EWIR ;PUT IN IR + EDCLK ;EXECUTE + ENPCLK ;LET IT ACTUALLY GET WRITTEN + POP B + POP A + RTS PC + +PARCMP: MOV #-1,T ;COMPUTE PARITY OF C + TST C + BEQ PARCMX ;SPECIAL CASE CHECK FOR 0 TO RUN FAST + MOV #16.,TT ;RETURN T -1 OR 0 SUCH AS TO MAKE ODD PARITY +PARCM1: ROL C + BCC PARCM2 + COM T +PARCM2: DEC TT + BNE PARCM1 + ROL C ;RESTORE TO FORMER GLORY +PARCMX: RTS PC + +XRDSPC: PUSH A ;READ DISP CONSTANT + MOV #XRDCTB,A + MOV #CMSDC,B + EEXAMD + MOV (A),@(SP) + POP A + RTS PC + +XRDCTB: 0 + 0 + +XWDSPC: PUSH A ;WRITE DISP CONSTANT + MOV (A),XRDT ;DESIRED CONTENTS OF DISP CONST REGISTER. + CLR -(SP) ;PUT 0 IN DISP OFFSET (FOR RANDOMNESS, + JSR PC,XDSPS1 ; SHOULDNT MATTER) + BIS #CMF1,(A) ;SET FORCE XFER BIT TO STOP ANY CLOBBERAGE OF + EWIR ;U STACK OR U STACK POINTER + EDCLK + TST (SP)+ + POP A + RTS PC + +XDPBLK: PUSH A ;DEPOSITIFY 4 WD BLOCK POINTED TO BY A + MOV (A),A + BLT XDPBL2 ;MINUS -> COMBINATION BLOCK + BEQ XDPBL1 ;ADDRESS OF 0 IS NULL BLOCK +XCVMR2: MOV (SP),C + MOV #CNUM,T + TST (C)+ ;SPACE PAST REG ADR + MOV (C)+,(T)+ + MOV (C)+,(T)+ + MOV (C),(T) + MOV #-1,CNUMF ;INDICATE NUMBER TYPED + MOV #QDEPV,B + JSR PC,REGDC +XDPBL1: POP A + RTS PC + +XDPBL2: NEG A + ASL A + CMP A,#XCBLTL + BHIS XDPBL1 ;IGNORE IF TOO HIGH + JMP @XCBLT-2(A) + +XCBLT: XCVMR ;VIRTUAL MEMORY READ + XCPMR ;PHYSICAL MEMORY READ +XCBLTL==.-XCBLT+2 + +XCPMR: MOV #RACPMR,A ;CONSOLE PHYSICAL VMA, START READ + BR XCPMR1 + +XCVMR: MOV #RACVMR,A ;CONSOLE VIRTUAL VMA, START READ +XCPMR1: MOV #XCVMR1,-(SP) + MOV 2(SP),-(SP) ;PUSH POINTER TO BLOCK TO FAKE OUT LOSING ROUTINE + BR XCVMR2 ; THIS WILL ALSO BE IN A ON RETURN + +XCVMR1: TST (A)+ ;POINTER TO BLOCK IN A ON RETURN + MOV CVMMRD,(A)+ ;CLOBBER BACK CONSOLE READ DATA REG + MOV CVMMRD+2,(A)+ + MOV CVMMPF,(A) ;HIGH WORD PAGE FAULT STATUS + BR XDPBL1 + +XRDBLK: PUSH A ;EXAMINIFY 4 WD BLOCK POINTED TO BY A + MOV (A),A + BLT XDPBL2 ;COMBINATION OP, SAME AS ON WRITE + BEQ XDPBL1 + MOV #QEXB,B ;CLEAR IT OUT TO MINIMIZE RANDOMNESS, ESPECIALLY IN + CLR (B)+ ;HIGH ORDER WORDS + CLR (B)+ + CLR (B) + MOV #QEXAMV,B + CLR QEXPF ;DONT PRINT IT OUT + JSR PC,REGDC ;EXAMINE STUFF AND LEAVE RESULT IN QEXB + MOV (SP),A + TST (A)+ + MOV #QEXB,B + MOV (B)+,(A)+ ;STORE DATA + MOV (B)+,(A)+ + MOV (B),(A) + BR XDPBL1 + +XRL1MP: PUSH A ;READ LVL 1 MAP + MOV #XRL1T1,A + MOV #<<11.*400>+12.>,C ;SHIFT 12 TO MOVE INTO LVL1 PART OF VMA + EDPB + MOV #,B + EDMM0 ;PUT THAT IN VMA + MOV #XRL1T2,A ;NOW READ MAP DATA + MOV #CMSPMD,B + EEXAMD + MOV #<<5*400>+27.>,B ;GET LVL1 MAP PART + ELDB + MOV A,B + POP A + MOV B,(A) ;STORE AWAY DATA + RTS PC + +XRL1T1: 0 ;TEMP TO CONSTRUCT VMA + 0 + +XRL1T2: 0 ;TEMP TO READ BACK MAP DATA + 0 + +XWL1MP: PUSH A ;WRITE LVL 1 MAP + PUSH B + MOV (A),B ;DATA TO WRITE + MOV #XWL1T1,A + MOV #<<5*400>+27.>,C ;PUT IN RIGHT PLACE + EDPB + MOV #,B + EDMM0 ;AND PUT THAT IN WRITE DATA REG + POP B + MOV #XRL1T2,A ;GENERATE RIGHT THING TO PUT IN VMA + MOV #<<11.*400>+12.>,C ;SHIFT 12 TO MOVE INTO LVL1 PART OF VMA + EDPB + MOV #,B ;VMA WRITE MAP + EDMM0 ;WILL WRITE FIRST LVL MAP + POP A + RTS PC + +XWL1T1: 0 ;DATA TO WRITE (GOES TO MWD) + 0 + +XWL1T2: 0 ;ADDRESS WD (GOES TO VMA WRITE MAP) + 0 + +XRL2A: PUSH B ;SET UP ADDRESS FOR LVL 2 MAP + MOV #XRL2T1,A ;WRITE HIGH 5 BITS OF ADDRESS IN LVL1 MAP LOCN 0 + ASL B + ASL B + ASL B + SWAB B + BIC #177740,B + MOV B,(A) + CLR B + EWL1MP + MOV #XRL2T2,A ;PUT LOW 5 BITS IN VMA WD + POP B + MOV #<<5*400>+7>,C + EDPB + RTS PC + +XRL2MP: PUSH A ;READ LVL 2 MAP + JSR PC,XRL2A ;PUT RIGHT THING IN LVL 1 MAP AND GEN RIGHT THING + ;FOR VMA + MOV #,B ;NOW PUT THAT IN VMA + EDMM0 + MOV #XRL2T3,A ;READ VMA DATA + MOV #CMSPMD,B + EEXAMD + MOV #<<4*400>+16.+7>,B ;LDB HIGH DATA WD + ELDB + MOV (SP),B + MOV A,2(B) ;STORE HIGH DATA WD + MOV #XRL2T3,A + MOV #<<16.*400>+7>,B + ELDB ;LDB LOW DATA WD + MOV A,@(SP) ;STORE LOW DATA WD +XWL2M1: MOV #1,CL1M0F ;INDICATE LVL 1 MAP LOCN 0 HAS BEEN HACKED + POP A ; (NOT NECESSARILY TO 0) + RTS PC + +XRL2T1: 0 ;LVL 1 MAP DATA + +XRL2T2: 0 ;VMA ADR WD + 0 + +XRL2T3: 0 ;MAP DATA READ BACK + 0 + +XWL2MP: PUSH A ;WRITE 2ND LVL MAP + JSR PC,XRL2A ;GENERATE RIGHT THING TO PUT IN VMA + ;MUST DO THIS FIRST SINCE IN WRITES IN 1ST LVL MAP + ;AND CLOBBERS MWD. LEAVE STUFF TO PUT IN VMA IN + ;XRL2T2 + MOV (SP),A + MOV 2(A),B ;SET UP DATA FOR MWD (HIGH WD) + MOV #XWL2T1,A + MOV #<<4*400>+16.+7>,C + EDPB + MOV @(SP),B ;SET UP DATA FOR MWD (LOW WD) + MOV #<<16.*400>+7>,C + EDPB + MOV #,B + EDMM0 ;PUT THAT IN MWD + MOV #XRL2T2,A ;GET BACK POINTER TO STUFF TO PUT IN VMA + MOV #,B + EDMM0 ;PUT IT IN VMA WRITE MAP + BR XWL2M1 ;CLR OUT LVL 1 MAP LOCN 0 AGAIN + +XWL2T1: 1 ;SET UP DATA FOR MWD (1 SELECTS 2ND LVL MAP) + 0 + +XRMEMS: PUSH A + PUSH B + MOV #CSVMA,A ;SAVE MEM SUBROUTINE + MOV #CMSVMA,B + EEXAMD ;SAVE VMA + MOV #CSPMD,A + MOV #CMSPMD,B + EEXAMD ;SAVE PAGE FAULT STATUS + MOV #CSMWD,A + MOV #CMSMWD,B + EEXAMD ;SAVE MWD + MOV #CSMRD,A + MOV #CMSMMD,B + EEXAMD ;SAVE MAIN MEMORY READ DATA + CLR CSMRDF ;AND INDICATE IT HASNT CHANGED + MOV #CL1M0,A + CLR B + ERL1MP ;SAVE 1ST LEVEL MAP, LOCN 0 + CLR CL1M0F ; VALID IN HARDWARE STATE + MOV #CL2M0,A + CLR B + ERL2MP + CLR CL2M0F ;CLR HACKED WITH 2ND LVL MAP, LOCN 0 FLAG + POP B ; (SINCE ITS SUCH A PAIN TO RELOAD) + POP A + RTS PC + +XWMEMS: PUSH A ;RESTORE MEMORY SUBROUTINE + PUSH B ;NOTE: THIS ROUTINE CAN ALSO BE CALLED WITH THE + TST CSMRDF ; INTENTION OF "VALIDIFING" THE MEM SUBROUTINE + BEQ XWMEM1 ;XFER ON READ DATA MEMORY REG HASNT BEEN CHANGED + MOV #CSMGBR,A ;TRY TO RESTORE IT + EWPVMA ; BY WRITING IN A GARBAGE REGISTER AND + MOV #CSMRD,A ; READING IT BACK + MOV #,B + EDMM0 ;PUT DATA IN MWD + EMMWC ;DO MAIN MEM WRITE CYCLE + EMMRC ;DO MAIN MEM READ CYCLE, GETTING IT BACK!! +XWMEM1: TST CL2M0F + BEQ XWMEM2 + MOV #CL2M0,A + CLR B + EWL2MP ;RESTORE LVL 2 MAP, LOCN 0 +XWMEM2: TST CL1M0F + BEQ XWMEM3 + MOV #CL1M0,A + CLR B + EWL1MP ;RESTORE LVL 1 MAP, LOCN 0 + CLR CL1M0F ;SINCE IF VALIDIFING, ITS NO LONGER NECESSARILY 0 +XWMEM3: MOV #CSMWD,A + MOV #,B + EDMM0 ;RESTORE MWD + MOV #CSVMA,A + MOV #,B + EDMM0 ;RESTORE VMA + BIT #1,CSPMD ;RESTORE PAGE FAULT STATUS + BEQ 1$ + MOV #SETRPF,A + JSR PC,XWIR + JSR PC,XDCLK + JSR PC,XNPCLK + BR 2$ + +1$: BIT #2,CSPMD + BEQ 2$ + MOV #SETWPF,A + JSR PC,XWIR + JSR PC,XDCLK + JSR PC,XNPCLK +2$: POP B + POP A + RTS PC + +XVMEMS: PUSH A ;VALIDIFY MAPS FOR CONSOLE VIRTUAL + PUSH B ; READ OR WRITE CYCLE + TST CL2M0F + BEQ XVMEM2 + MOV #CL2M0,A + CLR B + EWL2MP ;RESTORE LVL 2 MAP, LOCN 0 + CLR CL2M0F ;REMEMBER THAT IT IS RESTORED +XVMEM2: TST CL1M0F + BEQ XVMEM3 + MOV #CL1M0,A + CLR B + EWL1MP ;RESTORE LVL 1 MAP, LOCN 0 + CLR CL1M0F ;REMEMBER THAT IT IS RESTORED +XVMEM3: POP B + POP A + RTS PC + +XMMRC: MOV #XMMRI,A ;DO MAIN MEM READ CYCLE + BR XMMWC1 + +XMMWC: MOV #XMMWI,A ;DO MAIN MEM WRITE CYCLE +XMMWC1: EWIR + EDCLK + RTS PC + +XMMWI: + ;O-BUS FROM ALU, ALU-OP SETM + + ;M-SRC VMA, FDST VMA-START-WRITE + CIALU + +XMMRI: + + + ;M-SRC VMA, FDST VMA-START-READ + CIALU + +XWPVMA: PUSH A ;WRITE "PHYSICAL" VMA + PUSH B + MOV (A)+,XWPVT1 + MOV (A),XWPVT1+2 + TST CL1M0F + BLT XWPVM1 ;0 ALREADY THERE + MOV #CZERO,A + CLR B + EWL1MP ;MAKE SURE LEVEL 1 MAP LOCN 0 POINTS TO LEVEL 2 LOCN 0 + MOV #-1,CL1M0F +XWPVM1: MOV #XWPVT1,A + PUSH (A) ;SAVE LOW VMA BEFORE CLOBBERING IT + BIS #1,(A) ;SELECT 2ND LVL MAP + BIS #3000,2(A) ;SET VALID AND WRITE OK + MOV #,B + EDMM0 ;PUT THAT IN MWD + MOV #CZERO,A + MOV #,B + EDMM0 ;PUT ZERO ON VMA, WRITE MAP (WRITES LVL2 MAP LOCN 0) + MOV #1,CL2M0F ;FLAG HACKED WITH LVL 2 MAP LOCN 0 + MOV #XWPVT1,A ;RESTORE A + POP (A) ;GET BACK LOW VMA + BIC #177600,(A) ;BITS WITHIN PAGE REALLY COME FROM VMA + CLR 2(A) ;REST DONT (SELECT LOCN 0, LVL 1 AND 2 MAPS) + MOV #,B + EDMM0 ;PUT THAT IN VMA + POP B + POP A + RTS PC + +XWPVT1: 0 + 0 + +CZERO: 0 + 0 + +SETRPF: 010760 ;((VMA-START-READ) VMA) + .BYTE 50,62 + 0 + +SETWPF: 010760 ;((VMA-START-WRITE) VMA) + .BYTE 60,62 + 0 + +.SBTTL TRAP HANDLER + +TRPBRK: CMP SP,#PDL+30 ;TRP BRK + BLO ISTKO + BIC #17,2(SP) ;CLEAR PROCESSOR FLAGS ON RETURN + JSR U,ACSAV ;PUSHES 5 FROBS (+1 FOR JSR) + MOV <5+1>*2(SP),U ;GET RETURN PC + MOV -(U),U + ASL U + CMP U,#TWHTRP + BHI BADTRP + JSR PC,@TRPTAB-TWLTRP(U) +TRPRET: JSR U,ACRES + RTI + +TRPERX: BIS #1,<6+1+1>*2(SP) ;SET CARRY ON RETURN + RTS PC + +JFATL: BPT +ISTKO: BPT +BADTRP: BPT + +LTRP=TRP!0 +TWLTRP=LTRP+LTRP +TRPTAB: JFATL ;TRP 0 + JPNFLD ; 1 + JPSFLD ; 2 + +HTRP=TRP!<<.-TRPTAB>/2> +TWHTRP==HTRP+HTRP + +JPNFLD: CMP B,#<17.*400> + BGE JPNF1 ;FIELD > 16. BITS +JPNF2: EXFLD ;PRINT NUMERIC FIELD + MOV B,C + SWAB C + BIC #177400,C ;GET # OF BITS IN C + MOVB JPNTAB(C),C ;CONVERT TO # OF DIGITS + JSR PC,OCTPN + MOV #' ,A + JMP ADDCHR + +JPNF1: PUSH A + PUSH B + ADD #170020,B ;.BYTE -20,20 + JSR PC,JPNFLD ;PRINT OUT HIGH PART (S) + POP B + POP A + BIC #177400,B + BIS #<16.*400>,B ;PRINT 16 BITS AT ORIGINAL POSITION + BR JPNF2 + +JPNTAB: <1*400>+1 + <1*400>+1 + <2*400>+2 + <3*400>+2 + <3*400>+3 + <4*400>+4 + <5*400>+4 + <5*400>+5 + <6*400>+6 + <6*400>+6 + +JPSFLD: PUSH C + EXFLD + ASL A + ADD (SP)+,A + MOV (A),A + JMP PTEXT + + +.SBTTL SAVE & RESTORE STATE OF MACHINE + +ENTER: JSR PC,PSCONS ;ENTER, SAVING STATE AS APPRO TO CLLMOD + TST CLLMOD + BNE ENTERX + JSR PC,FSCONS ;HIGH LVL MODE, DO FULL +ENTERX: RTS PC + +LEAVE: JSR PC,FRCONS ;LEAVE, RESTORING WHAT SAVED + JSR PC,PRCONS + RTS PC + +PSCONS: TST CPSVAL ;DO PASSIVE STATE CHANGE.. + BNE PSCONX ;STATE ALREADY SAVED + MOV #CCERR1,A ;"PASSIVE" STATE SAVE + ERERWS ;READ ERROR WDS + MOV #CPC,A ;SAVE STATE OF CONS PROCESSOR + ERPC ; (AS BEST AS CAN) + MOV #CIR,A + ERIR + MOV #COBUS,A + EROBUS +; BIT #CESRUN,CCERR1 ;THIS BIT STAYS ON IF MACHINE STOPS FOR ERROR SO.. +; BNE PSCONX ;MACHINE STILL RUNNING, THIS FAIRLY RANDOM + INC CPSVAL ;INDICATE STATE SAVED + CLR NOOPF ;IS NEXT INST TO BE NO-OP ED? + BIT #CEINOP,CCERR2 + BEQ PSCONX + INC NOOPF ;YEP, THAT INST A LOSER +PSCONX: RTS PC + + +FSCONS: TST CFSVAL ;DO FULL STATE SAVE + BNE FSCONX ;FULL STATE ALREADY SAVED + ESTOP ;STOP MACHINE, CLEAR CRUN, LEAVE CTRUN ALONE. + JSR PC,PSCONS ;DO PASSIVE SAVE + MOV #OLDPCS,A ;SAVE OLD PCS +1$: MOV @#164002,(A) + BIC #170000,(A)+ + MOV #40,164006 + MOV #0,164006 + CMP A,#OLDPCS+20 + BLO 1$ + MOV #CMMEM0,A + CLR B + EEXAMD ;SAVE M MEM LOCN 0 + MOV #CAMEM1,A + MOV #CDAMEM+1,B + EEXAMD ;SAVE A MEM LOCN 1 + ERMEMS ;SAVE MEM SUBROUTINE (VMA+MWD) + INC CFSVAL ;INDICATE FULL SAVE VALID +FSCONX: RTS PC + +PRCONS: CLR CPSVAL ;DO "RESTORE" AFTER PASSIVE SAVE + RTS PC + +FRCONS: TST CFSVAL + BEQ FRCONX + EUUSTK ;RESTORE U STACK IF SAVED + EWMEMS ;RESTORE MEM SUBROUTINE (VMA+MWD) + MOV #CAMEM1,A ;DO RESTORE AFTER FULL SAVE + MOV #CDAMEM+1,B + EDMM0 ;RESTORE A MEM LOCN 1 + MOV #CMMEM0,A + CLR B + EDMM0 ;RESTORE M MEM LOCN 0 + MOV #OLDPCS,A ;RESTORE OPC HISTORY REGISTERS +1$: PUSH A + EWPC ;LOAD PC WITH WHAT IS TO GO IN OPCS + POP A + MOV #40,164006 ;THEN CLOCK OPCS + MOV #0,164006 + TST (A)+ + CMP A,#OLDPCS+20 + BLO 1$ + MOV CPC,CPCT ;COPY PC + DEC CPCT ;COMPENSATE FOR THE FACT IT WILL GET INCREMENTED + MOV #CPCT,A ;WHEN IR IS RELOADED + EWPC + MOV #CIR,A + EWIR ;PUT IR BACK (THIS INCRS THE PC) + CLR CFSVAL ;CLEAR FULL SAVE VALID +FRCONX: RTS PC + + +.SBTTL TEST LOOPS + +TL2: MOV #TL2DTA,A ;DEST DEPOSIT IN DATA PATH MEM + CLR TL2DTA ; M LOCN 10 INITIALLY + MOV CSR,TL2DTA+2 + MOV #10,B ;DEST M MEM LOCN 10 + EDMM0 + BCS TL2B + JMP TL2 + +TL2B: INC TL2DTC + JMP TL2 + +TL2DTA: 0 + 0 +TL2DTC: 0 + +TL3: MOV #377,TL3T1 ;A MEM LOCN +TL3A: MOV TL3T1,TL3T2 ;ADDRESS TEST ON A MEM + MOV TL3T1,TL3T2+2 + MOV #TL3T2,A + MOV TL3T1,B + BIS #CDAMEM,B + EDMM0 + DEC TL3T1 + BGE TL3A +TL3B: MOV #377,TL3T1 +TL3C: MOV #TL3T2,A + MOV TL3T1,B + BIS #CDAMEM,B + EEXAMD + CMP TL3T1,TL3T2 + BNE TL3L + CMP TL3T1,TL3T2+2 + BNE TL3L +TL3D: DEC TL3T1 + BGE TL3C + JMP TL3 + +TL3L: INC TL3LC + JMP TL3D + +TL3T1: 0 +TL3T2: 0 + 0 +TL3LC: 0 + +TL4: CLR TL4T1 ;TEST ABILITY TO WRITE PC +TL4A: MOV #TL4T2,A + EICLR ;CLEAR 3 WD BLOCK + BIS #CIJMP,4(A) + MOV TL4T1,B + EDJPC + BIS #47,(A) ;SET TEST CONDITION AND UNCONDITONAL CONDITION + EWIR ;LOAD INTO IR + EDCLK ;EXECUTE IT + MOV #TL4T3,A + ERPC + CMP TL4T3,TL4T1 + BNE TL4L +TL4L1: INC TL4T1 + BIC #170000,TL4T1 + BR TL4A + +TL4L: INC TL4LC + BR TL4L1 + +TL4LC: 0 +TL4T1: 0 +TL4T2: 0 + 0 + 0 +TL4T3: 0 + +TL5: CLR TL5T1 ;DATA TEST ON CONTROL MEM +TL5A: EUICLR + MOV CSR,(A) + MOV CSR,2(A) + MOV CSR,4(A) + BIC #177000,4(A) ;THATS HOW MANY THERE ARE + MOV TL5T1,B + EDCMEM + MOV #TL5T2,A + MOV TL5T1,B + EEXAMC + BIC #177000,TL5T2+4 ;DONT TRY TO CHECK PARITY FOR NOW + CMP UI,TL5T2 + BNE TL5L + CMP UI+2,TL5T2+2 + BNE TL5L + CMP UI+4,TL5T2+4 + BNE TL5L +TL5L1: INC TL5T1 + BIC #170000,TL5T1 ;MASK TO CNTRL MEM SIZE + JMP TL5A + +TL5L: INC TL5LC + JMP TL5L1 + +TL5LC: 0 +TL5T1: 0 +TL5T2: 0 + 0 + 0 + +TL6: CLR TL6T1 ;ADDRESS TEST ON CONTROL MEM + MOV CSR,CSRSV +TL6C: EUICLR + MOV TL6T1,(A) + MOV TL6T1,2(A) + MOV TL6T1,4(A) + TST CSRSV + BGE TL6A + COM (A) + COM 2(A) + COM 4(A) +TL6A: BIC #177000,4(A) + MOV TL6T1,B + EDCMEM + INC TL6T1 + BIC #170000,TL6T1 ;MASK TO CNTRL MEM SIZE + BNE TL6C +TL6D: MOV #TL6T2,A + MOV TL6T1,B + EEXAMC + BIC #177000,TL6T2+4 + MOV TL6T1,A + TST CSRSV + BGE TL6E + COM A +TL6E: CMP A,TL6T2 + BNE TL6L + CMP A,TL6T2+2 + BNE TL6L + BIC #177000,A + CMP A,TL6T2+4 + BNE TL6L +TL6B: INC TL6T1 + BIC #170000,TL6T1 ;MASK TO CNTRL MEM SIZE + BNE TL6D + JMP TL6 + +TL6L: INC TL6T3 + JMP TL6B + +TL6T1: 0 +TL6T2: 0 + 0 + 0 +TL6T3: 0 +CSRSV: 0 + +TL7: CLR TL7T1 ;ADDRESS TEST ON PDL BUFFER + MOV CSR,CSRSV +TL7A: MOV TL7T1,A + TST CSRSV + BGE TL7B + COM A +TL7B: MOV A,TL7T2 + MOV A,TL7T2+2 + MOV #TL7T2,A + MOV TL7T1,B + EWPDLB + INC TL7T1 + CMP TL7T1,#2000 + BNE TL7A + CLR TL7T1 +TL7C: MOV TL7T1,B + MOV #TL7T3,A + ERPDLB + MOV TL7T1,C + TST CSRSV + BGE TL7D + COM C +TL7D: CMP TL7T3,C + BNE TL7L + CMP TL7T3+2,C + BNE TL7L +TL7L1: INC TL7T1 + CMP TL7T1,#2000 + BNE TL7C + JMP TL7 + +TL7L: INC TL7LC + JMP TL7L1 + +TL7LC: 0 +TL7T1: 0 +TL7T2: 0 + 0 +TL7T3: 0 + 0 + +.SBTTL DISPLAY INTERRUPT ROUTINES + +.IFNZ GT40P + +RETST: PUSH T + PUSH TT + JSR PC,RETBLK + POP TT + POP T + RTS PC + +;DISPLAY INTERRUPT ROUTINES + +LPBRK: JSR PC,DPYSAV + BPT ;LIGHT PEN + RTI +DTOBRK: JSR PC,DPYSAV + BPT ;TIMEOUT/SHIFTOUT + RTI + +DPYSAV: MOV DPC,SAVDPC ;SAVE STATE OF DISPLAY + MOV DSR,SAVDSR + MOV XSR,SAVXSR + MOV YSR,SAVYSR + RTS PC + +DSBRK: PUSH A + PUSH B +;;;;;;; JSR PC,DPYSAV + CMP OCSR,CSR ;CHECK SWITCH REGISTER OPTIONS + BEQ DSBRK1 + PUSH C + MOV CSR,OCSR + MOV #1,A ;DON'T BLINK + MOV #DBLINK,B + MOV #DPYSPT,C + COM OCSR ;FAKE OUT SETDPY + JSR PC,SETDPY + COM OCSR + ASL A ;ITALICS + MOV #ITALICS,B + MOV #DPYSA,C + JSR PC,SETDPY + POP C +DSBRK1: MOV RETLAD,A + BEQ .+6 + JSR PC,RETST ;FREE BLOCKS + +DSBRK3: +;.IFNZ DLIMSW +; TST DSTOPD +; BNE DUNLIM ;BR IF WE WERE JUST RESTARTED BY CLOCK +;.ENDC + MOV @ADPC,A + MOV -2(A),B ;HALT INSTRUCTION + BIC #3,B + CMP #DPYSTP,B + BNE DSBERR ;ITS NOT A HALT!!! + MOV -2(A),B + BIC #177774,B + ASL B ;MAKE IT A WORD INDEX + JMP @.+4(B) ;DISPATCH + + DSBERR ;0 ERROR + AJSR ;1 DPYJSR + ARTS ;2 DPYRTS + AJSI ;3 DPYJSI + ;DISPLAY INTERRUPT CONTINUED + +DSBERR: TST FORGIV ;TO ERR IS HUMAN (PROBABLY A TIMING SCREW) + BNE DSRET ;TO FORGIVE, DIVINE + JSR PC,DPYSAV + BPT ;ILLEGAL INSTRUCTION + BR DSRET + +AJSR: TST (A)+ + BEQ DSRET ;DPYJSR 0 IS A NOOP + JSR PC,AJPUSH + MOV -(A),A ;JSR DESTINATION + BR DSRET + +AJSI: TST (A) + BEQ DSRET ;DPYJSI 0 IS NOOP + TST @(A)+ ;DPYJSI @0 IS ALSO NOOP + BEQ DSRET + JSR PC,AJPUSH + MOV @-(A),A + BR DSRET + +AJPUSH: INC DPYPDC + BLE .+4 + BPT ;DISPLAY OVERPUSH + SUB #2,DPYPDP + MOV A,@DPYPDP + RTS PC + +ARTS: DEC DPYPDC + MOV @DPYPDP,A + ADD #2,DPYPDP +DSRET: MOV @GETDPY,B + BEQ DSTART + PUSH A + MOV GETDPY,A + MOV 2(A),(B) ;PUT CONTENTS IN ADDRESS + CLR (A) ;FREE THIS BUFFER + MOV -(A),B ;NEXT ON RING + TST (B)+ ;POINT AT ADDRESS + MOV B,GETDPY + POP A + BR DSRET + +;.IFNZ DLIMSW +; CMP A,#TXSTRT+2 +; BNE DSTART +; TST DTIME ;READY TO DISPLAY TEXT +; BEQ DLIMIT ;BR IF IT TOOK +; BLO .+10 +; MOV #PCBUF,PCPNT +; MOV (SP),@PCPNT +; ADD #2,PCPNT +; MOV 2(SP),@PCPNT +; ADD #2,PCPNT +;.ENDC +;.IFNZ DLIMSW +; INC TICKS +; TST DSTOPD +; BNE CLKDS ;BR IF DISPLAY STOPPPED +; INC DTIME +; RTI +; +;CLKDS: MOV #DLINT,@ADPC ;CAUSE DISPLAY INTERRUPT +; RTI +; +;DLINT: DPYSTP ;DISPLAY LIST TO CAUSE INTERRUPT +;.ENDC + +.SBTTL 105 FOOBAR ROUTINE + +;IF THE MACHINE IS STOPPED, AND SOMEONE HITS RIGHT-CTRL RIGHT-META CALL +;ON THE KNIGHT KEYBOARD, RESTART THE MACHINE. SAVES WALKING TO THE OTHER ROOM. +FOO105: TST CTRUN + BMI FOO109 ;JUMP IF RUNNING + BIT #20000,164002 ;ALSO TEST IF MACHINE REALLY RUNNING + BNE FOO109 ; (THIS EXPECIALLY FOR PDP-10 MODE) + TST 164102 + BPL FOO109 ;JUMP IF KEYBOARD NOT READY + MOV 164100,-(SP) ;GET INPUT, CLEAR KEYBOARD (OK SINCE MACH STOPPED) + COM (SP) ;COMPENSATE FOR BRAIN BUBBLES + BIC #165700,(SP) ;CLEAR ALL BUT RIGHT CTL, RIGHT META, KEYCODE + CMP (SP)+,#12020 ;CHECK FOR CONTROL META CALL + BNE FOO109 + MOV #1,CNUM ;1@G + JSR PC,QG + JSR PC,QDPGO ;^P +FOO109: RTS PC + +.SBTTL KEYBOARD INTERRUPT ROUTINE + +TYIBRK: TSTB @AKLOS + BEQ TYIBRK + PUSH A + PUSH B + MOVB TKB,A + BIC #177600,A ;LOSEY LOSEY + TST TYIQF + BMI TYIB1 ;CHAR QUOTED + CMP A,#' ;CNTRL X + BEQ TYICX + CMP A,#' ;CNTRL Q + BEQ TYICQ + TST TYIQM ;(LOOK FOR OTHER CONTROLS?) CHECK QUOTE MODE + BEQ TYIB2 ;NO + CMP A,#' ;CNTRL S + BEQ TYICS ; STOP LISP MACHINE + CMP A,#' ;CNTRL D + BEQ TYICD ; COMPLEMENT STATE OF DISPLAY CONSOLE SWITCH +TYIB2: MOV #-1,CMREQ ;NOT TRYING TO ENTER MONITOR MODE NOW.. + TST CNHTTY + BNE TYIMCM ;CONSOLE HAS THE TTY, FEED IT CHAR +; TST LMHTTY +; BNE TYIMCM ;LISP MACHINE HAS THE TTY, FEED CHAR TO CONSOLE + BR TYIMGT ;NEITHER, FEED CHARACTER TO TTY LINE TO 10 + +TYIB1: CLR TYIQF ;PROCESS CHAR WHICH HAS BEEN QUOTED + BR TYIB2 + +TYICS: CLR 164006 ;STOP LISP MACHINE, ENTER CONSOLE MONITOR LOOP + CLR CTRUN + CLR CRUN +TYICX: INC CMREQ ;CNTRL X TYPED + BEQ TYIEX ;ON FIRST CNTRL X, TRY FOR GRACEFUL ENTRY + ZAPFLG CNHTTY ;GRONK AND RESET WORLD +; CLR LMHTTY + JMP GO0 ;(TRY TO ENTER CONSOLE LOOP) + +TYICQ: MOV #-1,TYIQF ;QUOTE FOLLOWING CHAR + BR TYIEX + +TYICD: COM CONSF ;COMPLEMENT "DISPLAY CONSOLE" FLAG + BR TYIEX + +TYIMCM: MOV A,TYICH ;LEAVE CHAR FOR CONSOLE MONITOR + BR TYIEX + +TYIMGT: MOVB A,@AKLOB ;GT40 MODE SEND CHAR TO 10 +TYIEX: POP B + POP A + RTI + +.SBTTL TTY LINE INPUT INTERRUPT ROUTINE + +KLIBRK: PUSH A + MOV @AKLIB,A ;GET THAT CHARACTER + BGE .+4 + BPT ;DL11 HARDWARE ERROR + BIC #177600,A + CMP #177,A + BEQ KLIRET ;IGNORE PADDING ON INTERRUPT LEVEL +.IFNZ DEBUG + MOVB A,177566 ;ECHO ON CONSOLE +.ENDC + CMP ACTCHR,#BUFSIZ + BGE KLIER + INC ACTCHR + MOVB A,@PUTCC + CMP ACTCHR,MAXACT + BLE .+10 + MOV ACTCHR,MAXACT ;TO FIND A GOOD SIZE FOR BUFFER + INC PUTCC + CMP PUTCC,#BUFEND + BLO KLIRET + MOV #BUF,PUTCC +KLIRET: POP A + RTI + +KLIER: BPT ;BUFFER OVERFLOWED + BR KLIRET + +.SBTTL PROCESSOR TRAP ROUTINES + +NXMFND: PUSH MEMTOP + SUB #2,T ;REGISTER HAS ALREADY BEEN INCREMENTED + MOV T,MEMTOP + POP T + RTI + +POWERF: HALT +; JSR U,ACSAV +; MOV #POWERU,PWRPC +; MOV SP,SAVSP +; HALT +POWERU: HALT +; RESET +; MOV #<7_5>,PS +; MOV #POWERF,PWRPC +; MOV SAVSP,SP +; MOV #100,A ;RENABLE ALL INTERRUPTS +; MOV A,TKS +; MOV A,@AKLIS +;.IFNZ DLIMSW +; MOV A,LKS +; CLR DSTOPD +; CLR DTIME +;.ENDC +; MOV #DPYSA,@ADPC +; JSR U,ACRES +; RTI + +;VARIAOUS PROCESSOR ERRORS COME HERE + +NXMBRK: BPT + RTI + +IOTBRK: BPT + RTI + +RESBRK: BPT + RTI + +RUGBRK: TST CSR ;THERE'S NO RUG IN THIS LOSING MACHINE + BMI BPTBRK ;SIGN OF SWITCHES => STOP FOR CARPET + JMP GO0 ;OTHERWISE REINITIALIZE PROGRAM + +;BPT BREAKS COME HERE IF THERE IS NO RUG. +;DON'T WANT TO HALT THE 11 SINCE 11TEN INTERFACE WOULDN'T BE ABLE TO GET TO BUS. +;WANT TO PUT CONTENTS OF REGISTERS IN CORE WHERE CARPET CAN GET AT THEM. + +BPTBRK: .REPT 7 ;SAVE THE ACS + MOV %0+.RPCNT,BPTACS+<2*.RPCNT> + .ENDR + + WAIT ;PUT 000001 IN LIGHTS (11/05) + BR . ;WAIT FOR RELOAD OR MANUAL INTERVENTION + ;BRANCH TO POINT SO STUFF WILL AUTOMATICALLY START IT. + .REPT 7 ;PROCEED + MOV BPTACS+<2*.RPCNT>,%0+.RPCNT + .ENDR + RTI + +BPTACS: .BLKW 7 + +.SBTTL WAIT FOR COMMAND FROM 10 OR KEYBOARD TYPEIN + +GETCH1: TST TENMOD + BNE GETCH0 + JSR PC,WATST ;STARTING A WAIT, LOAD IR +GETCH0: WAIT +GETCHW: CLR A + TST CMREQ ;WANT TO GO TO CONSOLE MONITOR + BGE GETC1 ;RETURN NULL CHAR + TST LDBFF2 + BNE 1$ + TST LDBUFF ;COMMANDS FROM 10 APPEARED? + BEQ GETCH2 +1$: JSR PC,C10CM ;YEP, HACK THEM +GETCH2: TST DSKRQB ;REQUEST FROM 10? + BEQ 2$ ;NO + JSR PC,DSKRUN ;YES, RUN THE DISK +2$: JSR PC,FOO105 ;CHECK FOR 105 FOOBAR REQUEST + TST ACTCHR + BLE GETCH1 ;WAIT TILL CHARS IN BUFFER +GETCHR: DEC ACTCHR + MOVB @GETCC,A + INC GETCC + CMP GETCC,#BUFEND + BLO GETC1 + MOV #BUF,GETCC +GETC1: RTS PC + +C10CM: ZAPFLG TNRQFG + MOV #LDBUF,A + MOV #LDBUFF,-(SP) + MOV #,-(SP) + TST LDBUFF + BEQ C10CM2 + BGT CLDR1 ;DEPOSIT IN REGISTER ADRS +CEXR1: TST (A) ;EXAMINE REGISTER ADRS + BEQ CEXRX ;EXIT ON ZERO (SAVES A BIT OF TIME) + ERDBLK + ADD #<4*2>,A + CMP A,(SP) + BLO CEXR1 + BR CEXRX + +CLDR1: TST (A) + BEQ CEXRX ;SAVE A BIT OF TIME + EDPBLK + ADD #<4*2>,A + CMP A,(SP) + BLO CLDR1 +CEXRX: TST (SP)+ + CLR @(SP)+ ;CLEAR FLAG FOR BUFFER THAT GOT SERVICED + CLR TNRQFG + RTS PC + +C10CM2: MOV #LDBFF2,2(SP) + MOV #,(SP) + MOV #LDBUF2,A + TST LDBFF2 + BGT CLDR1 + BEQ CEXRX + BR CEXR1 + +.SBTTL RUN DISK FOR 10 + +;A REQUEST IS 5 WORDS: +; COMMAND REG, TRACK REG, DUSH REG, LM CORE ADD, LM PAGE COUNT + +;BASHES ALL REGISTERS +DSKRUN: CLR DSKRQB+2 ;CLEAR SUCCESSFULL TRANSFER COUNT + MOV DSKRQB,A ;GET REQUEST COUNT + BLE DSKRNE + MOV #DSKRQB+4,B ;POINTER TO FIRST REQUEST +DSKRN0: MOV #164320,C ;SET UP THE UNIBUS MAP (USE MAP REGS 10 AND UP) + MOV 6(B),T ;CORE ADD + BIS #100000,T ;WRITE PERMIT + MOV 8(B),TT ;PAGE COUNT +1$: MOV T,(C)+ ;STORE MAP + INC T ;NEXT PAGE + DEC TT + BGT 1$ +20$: TSTB 176700 ;MAKE SURE DISK CONTROL IS IDLE + BPL DSKRNE ;IF NOT, TREAT AS ERROR + MOV 4(B),176702 ;DUSH + MOV #150000,176704 ;CA<15:0>. CA<17:16> IS CMD<13:12>, BUT FORTUNATELY IT'S ZERO. + MOV 8(B),T ;PAGE COUNT + SWAB T ;400 PDP11 WORDS PER PAGE + NEG T + MOV T,176706 ;-WC + MOV 2(B),176710 ;TRACK + MOV (B),176700 ;COMMAND +DSKRN2: TSTB 176700 ;AWAIT COMPLETION + BPL DSKRN2 + TST 176700 ;CHECK ERROR SUMMARY + BMI DSKRNE ;LOSE + INC DSKRQB+2 ;WIN + ADD #10.,B ;NEXT REQUEST + DEC A ;COUNT + BGT DSKRN0 + MOV #-1,DSKRQB+2 ;WON ON ALL TRANSFERS +DSKRNE: CLR DSKRQB ;AWAKEN, MONSTER + RTS PC + +.SBTTL PUT CHARACTER ON SCREEN + +TYOCHR: JSR PC,TVPREP + CMP A,#12 + BEQ TYOCH1 ;JUST CLEAR LINE ON LF + CMP A,#15 + BNE ADDCHR ;NORMAL CHR + JSR PC,CLEOL ;CLEAR REST OF THIS LINE + JSR PC,CR ; (INCLUDING CLEAR LINE ON CR, LF) + TST RAIDM + BEQ TYOCH2 ;NOT IN RAID MODE, USE WHOLE SCREEN + MOV CLINE,A + INC A + CMP A,CDLNN + BLT TYOCH2 ;STILL GOING TO BE ABOVE CONSOLE AREA +RDHU: CLR B ;HOME UP TO BOTTOM OF ACTIVE RAID AREA + MOV #RAIDA,A ;COUNT LINES IN USE +RDHU1: TST (A)+ + BEQ RDHU2 ;THAT ONE ISNT + INC B +RDHU2: CMP A,#RAIDA+<10*2> + BLO RDHU1 ;LOOP + CLR A + JSR PC,CSRPOS ;POSITION CURSOR THERE + BR TYOCH1 + +TYOCH2: JSR PC,LF +TYOCH1: JSR PC,CLEOL +TYOCHX: CLR BLKDFR + RTS PC + +TVPREP: +.IFNZ TVP + MOV #PPVAR,U + JSR PC,BLKOFF +.ENDC ;TVP + RTS PC + +ADDCHR: BIC #177600,A +.IF NZ TVP + PUSH U + JSR PC,TVPREP + CMP #40,A + BGT FORMAT ;CONTROL CHARACTER + JSR PC,TVO +ADDCRT: CLR BLKDFR + POP U +.ENDC ;TVP +.IFNZ GT40P + CMP #40,A + BGT FORMAT ;CONTROL CHARACTER + CMP CPOS,#MCHRPL + BGE RTSPC1 ;IGNORE OVERFLOW +PUTCHR: TST OPENSW + BNE PUTCH1 + JSR PC,OPNLIN ;OPEN UP THIS LINE +PUTCH1: CMP CPOS,BYTCNT + BLT PUTCH2 + MOV CPOS,BYTCNT ;IN CASE WE LINE FED OR MOVED UP FROM FULL LINE TO NEARLY EMPTY ONE +PUTCH6: INC BYTCNT +PUTCH2: MOVB A,@LINPNT +PUTCH3: INC LINPNT + INC CPOS + ADD #CHRWD,CURSX +.ENDC ;GT40P +RTSPC1: RTS PC + +;HERE FOR CONTROL CHARACTER + +FORMAT: ASL A +.IFNZ GT40P + JMP @DPTAB(A) +.ENDC ;GT40P +.IFNZ TVP + JSR PC,@DPTAB(A) + BR ADDCRT +.ENDC ;TVP + +DPTAB: FORMA1 ;^@ 00 + FORMA1 ;^A 01 + FORMA1 ;^B 02 + FORMA1 ;^C 03 + FORMA1 ;^D 04 + FORMA1 ;^E 05 + FORMA1 ;^F 06 + BELL ;^G 07 + BS ;^H 10 + TAB ;^I 11 + LF ;^J 12 + ALT ;^K 13 + FORMA1 ;^L 14 + CR ;^M 15 + FORMA1 ;^N 16 + FORMA1 ;^O 17 + FORMA1 ;^P 20 + FORMA1 ;^Q 21 + FORMA1 ;^R 22 + FORMA1 ;^S 23 + FORMA1 ;^T 24 + FORMA1 ;^U 25 + FORMA1 ;^V 26 + FORMA1 ;^W 27 + CFS ;^X 30 MOVE FORWARD + CLRCHR ;^Y 31 CLEAR CHARACTER + MU ;^Z 32 MOVE UP + ALT ;^[ 33 ALT-MODE + HD ;^\ 34 HOME DOWN + HU ;^] 35 HOME UP + CLEOL ;^^ 36 CLEAR TO END OF LINE + CLEOF ;^_ 37 CLEAR TO END OF FILE + +.IFNZ GT40P + +BELL: CLR DSR ;TRYING TO WRITE DSR CAUSES BEEP +ALT: +FORMA1: RTS PC + +BS: BIT #1_2,CSR + BEQ MB ;IF OPTION NOT CHOSEN, JUST MOVE BACK + CMP CPOS,#MCHRPL + BGE RTSPC1 + SUB #CHRWD*2,CURSX ;TO COMPENSATE FOR MOVING IT FWD ONE + MOV #10,A + BR PUTCHR ;NOW INSERT BS + +MB: TST CPOS ;MOVE BACK + BEQ CRTSPC + CMP LINPNT,#OPENSW + BLOS MB1 ;AT BEGINNING OR LINE NOT OPEN + DEC LINPNT +MB1: DEC CPOS + SUB #CHRWD,CURSX + RTS PC + +TAB: CMP CPOS,#MCHRPL + BGE CRTSPC + MOV #40,A ;AT LEAST ONE SPACE + JSR PC,ADDCHR + BIT #7,CPOS + BNE TAB + RTS PC + +CR: CLR CPOS + CLR CURSX + MOV #OPENSW,LINPNT + RTS PC + +CFS: CMP CPOS,#MCHRPL ;FORWARD SPACE + BGE CRTSPC + BIT #1_2,CSR + BEQ PUTCH3 + TST OPENSW ;IF INSERTING BS, BE A BIT CLEVER ABOUT FS + BNE .+6 + JSR PC,OPNLIN + JSR PC,PUTCH3 ;GO PAST A CHAR + CMPB @LINPNT,#10 ;IS NEXT CHAR A BS? + BNE FORMA1 ;NO + SUB #CHRWD*2,CURSX + JSR PC,CFS ;RECURSIVELY GO PAST BACKSPACE + BR PUTCH3 ;NOW GO PAST A REAL CHAR TO GET TO RIGHT COLUMN + +LF: TST @TEXTP + BEQ LF1 ;LINE DIDN'T EXIST (YET) + TST OPENSW + BEQ LF2 ;LINE NEVER OPENED +LF1: JSR PC,CLSLIN ;CLOSE THE LINE +LF2: MOV TEXTP,A + MOV NXTIDX-TXTIDX(A),A + ADD #TXTIDX,A + MOV A,TEXTP + INC CLINE + SUB #CHRHT,CURSY + CMP CLINE,#CHRLN-1 + BLE CRTSPC + JMP HU ;AT BOTTOM, GO TO TOP +CRTSPC: RTS PC + +HD: JSR PC,CR +HD1: CMP CLINE,#CHRLN-1 + BGE HD2 + JSR PC,LF + BR HD1 +HD2: RTS PC + +MU: TST CLINE ;MOVE UP + BEQ CRTSPC ;ALREADY AT TOP LINE + TST @TEXTP + BEQ MU0 ;IF LINE DIDN'T EXIST, INVENT CRLF + TST OPENSW + BEQ MU1 ;BR IF NO LINE OPEN +MU0: JSR PC,CLSLIN +MU1: DEC CLINE + ADD #CHRHT,CURSY + MOV TEXTP,A + SUB #TXTIDX,A + MOV BACIDX(A),A + ADD #TXTIDX,A + MOV A,TEXTP + RTS PC + +HU: JSR PC,CR ;HOME UP +HU1: TST CLINE + BEQ CRTSPC + JSR PC,MU + BR HU1 + +CLEOL: TST @TEXTP + BEQ CLEOL2 ;LET MU OR LF WORRY ABOUT LINE WHICH NEVER EXISTED + TST OPENSW + BNE .+6 + JSR PC,OPNLIN ;OPEN IT SO WE CAN FREE WHERE IT POINTED + BIT #1,CPOS + BEQ CLEOL1 + MOVB #' ,@LINPNT +CLEOL1: MOV CPOS,BYTCNT + JSR PC,CLSLIN +CLEOL2: RTS PC + +CLEOF: JSR PC,CLEOL ;CLEAR THE LINE THAT'S THERE + MOV #CHRLN-1,B + SUB CLINE,B ;# OF ADDITIONAL LINES TO FLUSH + BEQ CLEOF3 + MOV TXSTRT,C ;TOP LINE + BNE .+4 + BPT ;HOW CAN THERE BE NO TEXT? + ;FLUSH TEXT +CLEOF1: MOV BACIDX(C),C + MOV TXTIDX(C),A + BEQ CLEOF2 ;NO TEXT ON THAT LINE + CLR TXTIDX(C) + JSR PC,RETLIN ;RETURN LINE TO FREE STORAGE +CLEOF2: DEC B + BGT CLEOF1 +CLEOF3: MOV #GRJSR-HJSIDX,TT ;FLUSH THE GRAPHICS AS WELL + MOV GRSTRT,T + BEQ CLEOF4 + BPT ;GRAPHICS FLUSHED +; JSR PC,DITEM2 +; BR CLEOF3 +CLEOF4: RTS PC + +CSRPOS: PUSH A ;POSITION CURSOR TO H,V IN A,B + PUSH B +CSPV1: CMP (SP),CLINE + BEQ CSPH1 ;VERTICAL POSITION RIGHT + BLE CSPV2 + JSR PC,LF ;MOVE DOWN + BR CSPV1 + +CSPV2: JSR PC,MU ;MOVE UP ONE + BR CSPV1 + +CSPH1: CMP 2(SP),CPOS + BEQ CSPHX ;HORIZONAL POSITION RIGHT TOO + BLE CSPH2 + JSR PC,CFS ;FORWARD SPACE + BR CSPH1 + +CSPH2: JSR PC,MB ;MOVE BACK + BR CSPH1 + +CSPHX: POP B + POP A + RTS PC + + ;HERE TO CLOSE A LINE + +CLSLIN: MOV BYTCNT,A + ASR A ;MAKE A EVEN + ADC A + ASL A + ADD #XTLBYT,A ;SIZE OF BUFFER DESIRED (INCLUDE CHARS,CRLF,DPYRTS) + MOV A,B + JSR PC,GETBLK + MOV #CHARS,(A) + ADD A,B + MOV #DPYRTS,-(B) + MOV #<<15_10>+12>,-(B) + MOV BYTCNT,B + BEQ CLSL2 ;EMPTY LINE + MOV A,TT + MOV #LINBUF,T + MOV (T)+,(TT)+ + ASR B + ADC B ;WORD COUNT +CLSL1: MOV (T)+,(TT)+ + DEC B + BGT CLSL1 +CLSL2: MOV A,@TEXTP +CLRLIN: CLR BYTCNT + MOV #LINBUF+LBL-4,T ;DON'T CLEAR CRLF OR DPYRTS + MOV #LINBUF,TT ;OR THE CHARS EITHER +CLRL1: CLR -(T) + CMP T,TT + BHI CLRL1 + RTS PC + +CLRL3: CLR (T)+ + CMP T,TT + BLO CLRL3 + RTS PC + +;OPENS CURRENT LINE, COPIES CURRENT LINE INTO LINBUF +; AND RETURNS LINE BUFFER TO FREE STORAGE +OPNLIN: PUSH A + MOV @TEXTP,T + BEQ OPNL4 ;NO TEXT ON LINE + MOV #LINBUF,TT + MOV (T)+,(TT)+ ;SHOULD BE CHARS + MOV (T)+,(TT)+ + BGE .-2 ;UGH! THIS WORKS ONLY BECAUSE DPYRTS + ;HAS 100000 BIT ON, AND CHARS DON'T. + CMP -(TT),-(TT) ;DPYRTS AND CRLF + MOV TT,T + SUB #LINBUF+2,TT ;NUMBER OF BYTES IN LINE + MOV TT,BYTCNT +OPNL1: MOV #LINBUF+LBL-2,TT + MOV #DPYRTS,(TT) + MOV #<15_10>+12,-(TT) + MOV #" ,A ;2 SPACES + BIT #1,A + BEQ OPNL2 + MOVB A,(T)+ ;FILL ODD BYTE + BR OPNL2 + MOV A,(T)+ ;FILL LINE WITH SPACES +OPNL2: CMP T,TT + BLO .-4 + MOV @TEXTP,A + BEQ OPNL3 ;NO LINE TO RETURN + MOV #FAKEL,@TEXTP + JSR PC,RETLIN ;RETURN LINE AT INTERUPT LEVEL +OPNL3: MOV #LINBUF,@TEXTP + POP A + RTS PC + +;HERE FOR NO TEXT ON OPEN LINE + +OPNL4: MOV #LINBUF,T + MOV #CHARS,(T)+ + CLR BYTCNT + BR OPNL1 + +.IFNZ 0 ;FLUSHED TO SAVE CORE + +.SBTTL DISPLAY SLAVE COMMAND PROCESSOR + +CMND: JSR PC,GETCHW ;GET COMMAND + CMP A,#CMTBLL/2 + BHIS RTSPC3 ;NOT A COMMAND IGNORE + MOV A,COMAND ;FOR DEBUGGING + CLR CKS + CLR C ;ONE LESS THAN # OF WORDS WE EXPECT + ASL A + JMP @CMTBL(A) ;DISPACH + +;COMMAND DISPATCH TABLE +CMTBL: LODERS ;LOAD A LIST AND SHOW IT + LODER ;JUST LOAD IT + DITEM ;DELETE AN ITEM + GO0 ;RESTART WORLD + SITEM ;SHOW AND ITEM + EITEM ;ERASE AN ITEM + CITEM ;COPY AN ITEM + MITEM ;MOVE ITEM + CMITEM ;CHANGE THE SET GRAPHICS MODE OF ITEM + ADITEM ;ADD TO AN ITEM + SBRITM ;SUBROUTINIZE AN ITEM + USBITM ;UNSUBROUTINIZE AN ITEM + +CMTBLL==.-CMTBL + +;DRAWING PROGRAM STYLE COMMANDS + +;HERE TO LOAD DISPLAY ITEM AND SHOW IT +LODERS: MOV #,C ;COUNT + JSR PC,GETWRD + CMP A,#2 + BEQ LODER2 + CMP A,#1 + BNE RTSPC3 + JSR PC,LODER ;LOAD ITEM +RTSPC3: RTS PC + + +;HERE TO DELETE AN ITEM FROM OVER COMMUNICATION LINK + +LODER2: JSR PC,GETWRD + MOV A,C + SUB #,C +LOD2A: JSR PC,DITEM + TST C + BGT LOD2A + JSR PC,LODEND + RTS PC + +GETCNT: JSR PC,GETWRD ;SIZE OF BLOCK + MOV A,C + MOV A,COUNT ;FOR DEBUGGING + ADD #,A ;BYTES OF CORE WE WANT + SUB #,C ;WE'VE ONLY 2 LEFT TO READ + RTS PC + +GTAIB2: JSR PC,GTAIB ;DO GTAIB TWICE +;GET WORD AND INSERT AT (B)+ +GTAIB: JSR PC,GETWRD + MOV A,(B)+ + RTS PC + +;HERE TO READ A WORD IN LODER FORMAT +GETWRD: JSR PC,GETCHW ;6 BITS + PUSH A + JSR PC,GETCHW ;4 BITS + SWAB A + ASR A + ASR A + ADD A,(SP) + MOVB (SP),A + BIC #<377_10>,A + ADD A,CKS + DEC C + JSR PC,GETCHW ;LAST 6 BITS + SWAB A + ASL A + ASL A + ADD A,(SP) + DEC C + BLT POPAJ ;ONLY 8 BITS OF CHECK SUM + MOVB 1(SP),A + BIC #<377_10>,A + ADD A,CKS +POPAJ: POP A + RTS PC + +;SOME SBRS USED BY ALL STYLE COMMANDS +;GET ITEM AND FIND IT +;CALL WITH ITEM # IN A +;RETURN WITH ITEM # IN A, & IF FOUND, Z BIT CLEARED, & ITEM ADDR IN T +GFITEM: JSR PC,GETWRD +FHEDR: MOV #GRSTRT-HNXIDX,TT + BR FHEDR2 +FHEDR1: MOV T,TT +FHEDR2: MOV HNXIDX(TT),T + BEQ RTSPC4 ;BR IF ITEM DOESN'T EXIST + CMP A,HITIDX(T) + BNE FHEDR1 + CLZ ;FOUND IT, CLR Z BIT +RTSPC4: RTS PC + +;CREATE A HEADR, CALL WITH ITEM # IN A +;INSERT INTO DISPLAY RING &RETURN WITH HEADR ADDR IN T +CHEDR: JSR PC,FHEDR + BNE DELIS1 ;ALREADY EXISTS + PUSH A + MOV #HSIZE,A + JSR PC,GETBLK ;GET A NEW HEADER BLOCK + MOV A,T + POP A + PUSH T + MOV #DPYNOP,(T)+ ;SETPNT + MOV #DPYNOP,(T)+ ;X + MOV #DPYNOP,(T)+ ;Y + MOV #DPYJSR,(T)+ + CLR (T)+ ;THIS ITEM'S LIST ADDR + CMP (T)+,(T)+ ;JMP OR JSR TO NEXT LIST & NEXT LIST + MOV A,(T)+ ;ITEM # + CLR (T)+ ;LIST ADDR + CLR (T)+ ;# OF SUBR CALLS TO THIS LIST + POP T +IINSRT: MOV GRJMP,HJMIDX(T) + MOV GRSTRT,HNXIDX(T) + MOV T,GRSTRT ;FLASH + MOV #DPYJMP,GRJMP + RTS PC + +;DELETE ITEM WITH # IN A +;RETURN HEADR ADDR, IF ANY, IN T & CLR Z BIT +GDELIS: JSR PC,GETWRD +DELIS: JSR PC,FHEDR + BEQ RTSPC4 ;HEADER DOESN'T EXIST +DELIS1: TST HIAIDX(T) + BEQ RTSPC4 ;NO ASSOCIATED LIST + CLR HDSIDX(T) ;DON'T SHOW IT + PUSH A + MOV HIAIDX(T),A ;LIST ADDR + CLR HIAIDX(T) + JSR PC,RETLIN ;FREE IT UP + POP A + CLZ + RTS PC + +;LISP STYLE COMMANDS + +;HERE TO LOAD AN ITEM +LODER: JSR PC,GETCNT + SUB #LINHDR,A ;LIST BYTES IN HEADER + PUSH A ;LIST SIZE IN A + JSR PC,GETWRD + JSR PC,CHEDR ;CREATE A HEADR + MOV T,B ;HEADR ADDR + PUSH B + JSR PC,GTAIB ;SET POINT + JSR PC,GTAIB2 ;X&Y + POP B + POP A ;LIST SIZE + JSR PC,GETBLK ;GET ITEM + MOV A,T + MOV A,HIAIDX(B) ;LIST ADDR + MOV #DPYRTS,(A) + MOV T,HDSIDX(B) ;DEST OF DPYJSR + MOV A,B + JSR PC,GTALL ;GET WRDS UNTILL C=0, PUT THEM AT (B)+, CHECKSUM + RTS PC + +;HERE TO DELETE AN ITEM! +DITEM: JSR PC,GDELIS + TST T + BEQ RTSPC4 ;NO HEADER EXISTS +DHEDR: TST HSCIDX(T) + BNE EDHEDR +DITEM2: MOV HJMIDX(T),HJMIDX(TT) ;TAKE IT OUT OF DISPLAY LIST RING + MOV HNXIDX(T),HNXIDX(TT) + PUSH A + MOV T,A ;HEADER ADDR + JSR PC,RETLIN + BR POPAJ + +EDHEDR: BPT ;CAN'T DELETE THIS, IT'S A SUBR + RTS PC + +;GET ALL WORDS AND INSERT AT (B)+, THEN CHECKSUM +;MAIN LODER LOOP + +GTALL1: MOV #DPYRTS,2(B) + PUSH B ;SAVE THE ADDRESS + JSR PC,GETWRD + TST @PUTDPY ;PUT THE WORD IN LIST AT INTERRUPT LEVEL + BEQ .+4 + BPT ;NOT FAST ENOUGH FOR OUR TASTE + MOV PUTDPY,B + MOV A,2(B) ;THAT'S THE CONTENTS + POP A ;GET THE ADDRESS BACK + MOV A,(B) ;ADDRESS MARKS BUFFER AS GOOD + MOV -(B),B ;NEXT BUFFER ON RING + TST (B)+ ;MAKE IT POINT TO ADDRESS + MOV B,PUTDPY ;SET FOR NEXT TIME + MOV A,B ;GET ADRRESS BACK IN RIGHT PLACE + TST (B)+ ;AND INCREMENT IT +GTALL: TST C + BGT GTALL1 +LODEND: TST C + BEQ .+4 + BPT ;ODD # OF BYTES +LGCKS: JSR PC,GETWRD + TSTB CKS + BEQ .+4 + BPT ;CHECKSUM + RTS PC + +;HERE TO SHOW DISPLAY ITEM +SITEM: JSR PC,GFITEM ;GET ITEM NUMBER AND FIND IT + BEQ RTSPC5 ;NO SUCH ITEM +RSITEM: MOV HIAIDX(T),HDSIDX(T) + RTS PC + +;HERE TO ERASE ITEM +EITEM: JSR PC,GFITEM + BEQ RTSPC5 ;NO SUCH ITEM + CLR HDSIDX(T) + RTS PC + +;HERE TO CALL ITEM2 AS A SUBROUTINE OF ITEM1 +SBRITM: INC C ;2 MORE WORDS LEFT + JSR PC,GFITEM + BEQ IG1WD2 + MOV T,B ;SOURCE ADDR + JSR PC,GFITEM + BEQ RTSPC5 + INC HSCIDX(T) ;# OF TIMES THIS IS CALLED AS SUBR + ADD #HDSIDX,T ;WHERE TO DPYJSR TO + PUSH T + MOV HIAIDX(B),A ;OLD DEST LIST + MOV #4,T ;ADDED SIZE OF CALLING ITEM + JSR PC,TCOPY ;COPY CALLING ROUTINE, RETURN WITH NEW ADDRESS IN A + ;PNTR TO LAST WORD IN T + MOV #DPYJSI,(T)+ ;PUT A CALL TO SUBR AT END OF NEW COPY + POP (T)+ + MOV #DPYRTS,(T) + PUSH HIAIDX(B) ;OLD DEST LIST + MOV A,HIAIDX(B) + TST HDSIDX(B) + BEQ .+6 ;WASN'T BEING SHOWN + MOV A,HDSIDX(B) ;SHOW IT + POP A + BEQ RTSPC5 ;SHOULDN'T HAPPEN + JSR PC,RETLIN ;FLUSH OLD LIST +RTSPC5: RTS PC + +;HERE TO UNSUBROUTINIZE AN ITEM +USBITM: INC C ;2 MORE WORDS LEFT + JSR PC,GFITEM + BEQ IG1WD2 + MOV T,B ;OLD SOURCE + JSR PC,GFITEM + BEQ RTSPC5 + MOV HIAIDX(B),B + MOV T,A + ADD #HDSIDX,A ;DEST OF DPYJSRS +USBIT1: CMP (B),#DPYRTS + BEQ RTSPC5 ;END OF THAT LIST + CMP (B)+,#DPYJSI + BNE USBIT1 ;THAT WORD WASN'T A SBR CALL + CMP (B),A + BNE USBIT1 ;DEST WASN'T WHAT WE WANTED + CLR (B) ;FLUSH IT + DEC HSCIDX(T) ;ONE LESS CALL TO ME + RTS PC + BR USBIT1 ;NOOP PREV INSTR TO REMOVE ALL CALLS TO THIS ITEM + +IG1WD2: JMP IG1WD + +;HERE TO COPY ITEM +CITEM: INC C ;2 MORE WORDS LEFT + JSR PC,GFITEM + BEQ IG1WD1 ;NO SUCH ITEM + PUSH T ;HEADER ADDRESS + JSR PC,GETWRD + JSR PC,CHEDR ;CREATE A HEADER + POP A ;SOURCE HEADER ADDR + MOV HSPIDX(A),HSPIDX(T) ;SETPOINT + MOV HXCIDX(A),HXCIDX(T) ;X + MOV HYCIDX(A),HYCIDX(T) ;Y + TST HIAIDX(A) + BEQ RTSPC5 ;NO LIST + PUSH A ;OLD HEADER ADDR + PUSH T ;NEW HEADER ADDR + MOV HIAIDX(A),A ;LIST TO BE COPIED + CLR T + JSR PC,TCOPY ;COPY LIST + POP T ;NEW HEADER ADDR + MOV A,HIAIDX(T) ;LIST ADDRESS + POP A + TST HDSIDX(A) + BEQ RTSPC5 ;OLD ITEM WASN'T BEING SHOWN + MOV HIAIDX(T),HDSIDX(T) + RTS PC + + +;MAKE A COPY OF ITEM WITH ADDRESS IN A, +; LEAVE T EXTRA BYTES +;RETURN PNTR TO NEW ITEM IN A, TO END OF NEW ITEM IN T +TCOPY: PUSH TT + PUSH A + MOV -BLIDX(A),TT + BIC #INUSE,TT + SUB #BXTRA,TT ;MAX LIST SIZE + ADD A,TT ;PNTR PAST END OF LIST +TCOPY2: CMP A,TT + BHIS TCOPY3 ;PAST END OF LIST + CMP (A)+,#DPYRTS ;FIND THE END OF DISPLAY INSTRUCTIONS + BNE TCOPY2 +TCOPY3: SUB (SP),A + MOV A,TT + ASR TT ;# OF WORDS TO BLT + PUSH TT + ADD T,A ;GRAND TOTAL SIZE + JSR PC,GETBLK + MOV A,T ;COPY ADDR + POP TT ;WD COUNT + POP A ;SOURCE ADDR + PUSH T +TCOPY1: MOV (A)+,(T)+ ;BLT OLD ITEM TO NEW + DEC TT + BGT TCOPY1 + TST -(T) ;LAST WORD IN COPY + POP A ;COPY ADDRESS + POP TT + RTS PC + +;CHANGE MODE (INTENSITY, BLINK, ETC) +CMITEM: INC C ;2 MORE WORDS LEFT + JSR PC,GFITEM +IG1WD1: BEQ IG1WD + JSR PC,GETWRD + MOV (T),TT ;OLD SET GRAPH MODE WORD + BIC #003777,TT ;COMBINE OLD MODE + BIC #174000,A ;WITH NEW ENABLE, ETC. BITS + BIS A,TT + MOV TT,(T) ;NEW WORD + RTS PC + +;ADD TO ITEM1 N WORDS +ADITEM: JSR PC,GETCNT ;RETURNS AMOUNT OF CORE WE NEED IN A + MOV A,B ;# OF XTRA BYTES + JSR PC,GFITEM + BNE ADITE1 ;BR IF FOUND ITEM + INC C ;IGNORE CKS ALSO + BR IGWDS +ADITE1: MOV HIAIDX(T),A ;OLD LIST ADDR + PUSH A + PUSH T ;HEADR ADDR + MOV B,T + JSR PC,TCOPY + MOV T,B ;END OF NEW LIST + POP T ;HEADR ADR + MOV A,HIAIDX(T) ;LIST ADDR + TST HDSIDX(T) + BEQ ADITE2 + MOV A,HDSIDX(T) +ADITE2: JSR PC,GTALL + POP A + JSR PC,RETLIN ;FREE OLD LIST SPACE + RTS PC + + +;MOVE AN ITEM TO X, Y +MITEM: MOV #2,C ;3 MORE WORDS + JSR PC,GFITEM + BEQ IG2WD ;NO SUCH ITEM + MOV T,B ;ITEM ADDRESS + ADD #HXCIDX,B + JSR PC,GTAIB2 ;GET X&Y + RTS PC + +;IGNORE 2 WORDS +IG2WD: MOV #2,C + BR IGWDS1 +;IGNORE 1 WORD +IG1WD: MOV #1,C +;IGNORE C WORDS +IGWDS1: JSR PC,GETWRD +IGWDS: TST C + BGE IGWDS1 + RTS PC + +.ENDC ;IFNZ 0 + +.SBTTL DYNAMIC STORAGE ALLOCATOR ROUTINES + +GETBLK: ASR A ;INSURE AN EVEN # OF BYTES + ADC A + ASL A + ADD #BXTRA,A ;SIZE OF BLOCK HE REALLY WANTS + BGT .+4 + BPT ;HE WANTS NEGATIVE OR ZERO BLOCK + PUSH PS ;DON'T ALLOW RETBLK AT INTERRUPT LEVEL + MOV DSPSW,PS + MOV ROVER,T + BNE GETBL1 + MOV @AVAIL,T + MOV T,ROVER +GETBL1: MOV (T),TT ;NEXT BLOCK + CMP A,-(T) + BLOS GETBL2 ;FOUND A WINNER + CMP TT,AVAIL + BEQ GETBL3 ;END OF CHAIN + MOV TT,T + BR GETBL1 + +;HERE IF WINNER FOUND + +GETBL2: MOV TT,ROVER + SUB A,(T) ;SIZE OF THIS BLOCK NOW + CMP (T)+,#NEBISH + BLO GETB21 + MOV T,TT ;BREAK INTO TWO BLOCKS + ADD -(T),TT ;ORIGIN OF NEW BLOCK + MOV (T),-4(TT) ;SIZE INTO TOP OF OLD BLOCK +GETBL4: MOV A,T ;LENGTH OF NEW BLOCK + BIS #INUSE,A ;MARKS BLOCK IN USE + CLR (TT)+ ;CLEAR FREE NEXT BLK PNTR + MOV A,-BLIDX(TT) ;MARKER INTO BLOCK + MOV TT,A ;RETURN POINTER TO CALLER + ADD T,TT ;ORIGIN OF NEXT BLOCK + MOV #INUSE,-BLIDX-2(TT) ;MARK LAST WORD OF NEW BLOCK + POP PS + RTS PC + +;HERE TO GIVE CALLER ENTIRE BLOCK + +GETB21: JSR PC,UNLINK ;TAKE BLOCK OUT OF FREE LIST + ADD -2(T),A ;SIZE OF BLOCK + MOV T,TT ;NEW BLOCK + BR GETBL4 + +;BLOCK FORMAT + ;FREE BLOCK + ;SIZE +BNXIDX==2 ;PNTR TO NEXT FREE BLOCK + ;PNTR TO PREVIOUS FREE BLOCK + ;BLOCK + ;SIZE + + ;ALLOCATED BLOCK + ;SIZE!INUSE + ;IF NON-ZERO, PNTR TO NEXT BLOCK TO BE FREED +BLIDX==BNXIDX+2 ;BLOCK + ;SIZE!INUSE + +BXTRA==6 ;NUMBER OF EXTRA BYTES IN A BLOCK + +;HERE ON END OF FREE LIST + +GETBL3: TST ROVER + BEQ ENOFRE ;BLOCK CANNOT BE FOUND + CLR ROVER + MOV @AVAIL,T + BR GETBL1 + +;TAKES BLOCK IN T AND PATCHES IT OUT OF FREE STORAGE LIST +UNLINK: MOV (T),TT + MOV TT,@2(T) ;PATCH FORWARD POINTER INTO PRECEEDING BLOCK + MOV 2(T),2(TT) ;PATCH BACK POINTER INTO NEXT BLOCK + CMP ROVER,T + BNE .+6 + MOV TT,ROVER ;DON'T LET ROVER POINT TO NON-EXISTENT BLOCK + RTS PC + + +;ERROR ROUTINES +ENOFRE: CLR A ;NO FREE STORAGE LEFT +; JSR PC,ESND + MOV #GO,SP + JMP MAINL + +;EINT: MOV #34,A ;INTERNAL ERROR +;ESND: MOV A,@AKLOB +; BR .+6 +;ESND1: JSR PC,GETWRD +; TST C ;IGNORE C+1 WORDS +; BGE ESND1 +; RTS PC + ;HERE TO RETURN A BLOCK TO FREE STORAGE (RUNS DURING DISPLAY INTERRUPTS) + +RETBLK: MOV A,OLDBLK ;SAVE FOR DEBUGGING + TST -(A) + CMP A,#FS+2 + BHIS .+4 + BPT ;CAN'T TAKE THAT ONE BACK + MOV -2(A),T ;SIZE + BIT #INUSE,T + BNE .+4 + BPT ;CAN'T FREE A BLOCK WHICH ISN'T IN USE + MOV (A),RETLAD ;IF NZ, NEXT BLOCK TO BE FREED + BIC #INUSE,T + BIT #INUSE,-4(A) ;IS BLOCK BELOW RESERVED + BNE RETBL1 ;YES, CHECK LOWER BOUND + SUB -4(A),A ;POINTS TO ENLARGED BLOCK + ADD T,-2(A) ;NEW SIZE + MOV A,T + ADD -2(A),T ;POINTS TO BLOCK ABOVE + MOV -2(A),-4(T) ;PUT MARKER AT TOP OF BLOCK + BIT #INUSE,-2(T) + BNE RTSPC2 ;BLOCK ABOVE RESERVED, GOOD BYE + ADD -2(T),-2(A) ;NEW SIZE OF MOBY BIG BLOCK + JSR PC,UNLINK ;TAKE THIS BLOCK OUT OF FREE LIST + MOV A,T ;MARK TOP OF ENLARGED BLOCK + ADD -2(A),T ;POINTS TO NEXT BLOCK + MOV -2(A),-4(T) ;MARK TOP OF BLOCK WITH SIZE + RTS PC + +;BLOCK BELOW RESERVED, CHECK ABOVE + +RETBL1: MOV T,-2(A) ;MARK THIS BLOCK AS FREE + ADD A,T ;POINTS TO NEXT BLOCK + MOV -2(A),-4(T) ;MARKER INTO TOP OF BLOCK + BIT #INUSE,-2(T) + BNE LINK ;BR IF BLOCK ABOVE RESERVED, PATCH THIS ONE BACK IN + JSR PC,UNLINK ;TAKE BLOCK ABOVE OUT OF FREE STORAGE + ADD -2(T),-2(A) ;NEW SIZE + MOV A,T + ADD -2(A),T ;POINTS TO NEXT BLOCK + MOV -2(A),-4(T) ;MARK TOP OF BLOCK +LINK: ;PATCH THIS IN AT AVAIL + CMP ROVER,A + BNE .+6 + CLR ROVER + MOV AVAIL,T ;PREVIOUS BLOCK + MOV (T),TT ;NEXT BLOCK + MOV A,(T) ;FWD PNTR IN PREV BLK + MOV TT,(A) ;FWD PNTR IN THI BLK + MOV T,2(A) ;BACK PNTR IN THIS BLK + MOV A,2(TT) ;BACK PNTR IN NEXT BLK +RTSPC2: RTS PC + +;MAIN PROGRAM LEVEL ROUTINE TO RETURN BLOCK AT INTERRUPT LEVEL + +RETLIN: CMP #FAKEL,A + BEQ RETERR + TST A + BEQ RETERR + PUSH PS + MOV DSPSW,PS ;GO TO DISPLAY INTERRUPT LEVEL + MOV RETLAD,-BNXIDX(A) ;ADD LIST TO FRONT OF CHIAN + MOV A,RETLAD +;.IFNZ DLIMSW +; EMT ;IF DISP ISN'T RUNNING, FREE BLOCK ON DISBRK LEVEL +;.ENDC +.IFNZ DEBUG + IOT ;FAKE A DISPLAY INTERRUPT +.ENDC + POP PS + RTS PC + +RETERR: BPT +.ENDC ;GT40P + +.SBTTL TV CHARACTER DISPLAY ROUTINES +.IFNZ TVP + +TVOMSK: BIC #177600,A ;HERE IF YOU DON'T TRUST THE HIGH BITS +TVO: JSR PC,GENCHR ;GENERATES CHARACTER AND ADVANCES CURSOR + ;BY FALLING INTO LEDADC +;LEDADC ADVANCES LINE EDITOR CURSOR +;TAKES AND PRESERVES CHAR IN A +CFS:: +LEDADC: TST PPPHS(U) + BGT LEDAD1 + ADD #20,PPPHS(U) ;# BITS/WORD + ADD #2,PPCC(U) ;ADVANCE TO NEXT WORD IN DISPLAY + CMP PPCC(U),#TVCFENCE + BLOS LEDAD1 + MOV #TVLO,PPCC(U) +LEDAD1: SUB #CHRWD,PPPHS(U) + INC PPCPOS(U) + RTS PC + +;RETREATS LINE EDITOR CURSOR + +BS:: +LEDREC: TST PPCPOS(U) + BEQ LEDRE1 + DEC PPCPOS(U) + ADD #CHRWD,PPPHS(U) + CMP #<20-CHRWD>,PPPHS(U) + BGE LEDRE1 + SUB #20,PPPHS(U) ;BACKUP A WORD IN DISPLAY + SUB #2,PPCC(U) + CMP PPCC(U),#TVLO + BHIS LEDRE1 + MOV #TVFENCE,PPCC(U) +LEDRE1: RTS PC + +;TURN BLINKER OFF +BLKOFF: ZAPFLG BLKDFR + TST BLKPHS + BEQ 1$ + JSR PC,XORCHR + CLR BLKPHS +1$: RTS PC + + +;CLOCK BREAK COMES HERE TO HACK BLINKER +CRSCLK: DEC BLKTIM + BGT 1$ + TST BLKDFR + BNE 1$ + TST BLKPHS + BNE 2$ ;ALWAYS TURN BLINKER OFF ON TIME +; TST LMHTTY ;THESE DAYS, TURN CURSOR ON ONLY IF IN DATAPOINT TO 10 MODE +; BNE 1$ + TST CNHTTY + BNE 1$ +2$: PUSH U + MOV #PPVAR,U + JSR PC,XORCHR + POP U + COM BLKPHS + MOV #15.,BLKTIM +1$: TST BELTIM + BEQ 4$ + DEC BELTIM + BGT 4$ + CLR BELTIM + JSR PC,BOWXOR +4$: RTS PC + +BOWXOR: BIT #BOWBIT,TVCTL + BEQ 1$ + BIC #BOWBIT,TVCTL + RTS PC + +1$: BIS #BOWBIT,TVCTL + RTS PC + +;COME HERE TO "DISPLAY" "FORMAT" CHARACTER ANYWAY +ALT: ASR A ;COMPENSATE FOR ASL DONE BEFORE DISPATCH + JMP TVO + +;BELL, FLASH SCREEN + +BELL: PUSH PS + MOV #300,PS ;PREVENT CLOCK BREAKS + TST BELTIM + BNE 1$ ;ONLY ONE BELL AT A TIME + MOV #20.,BELTIM + JSR PC,BOWXOR +1$: POP PS + RTS PC + +FORMA1:: ;HERE TO IGNORE RANDOM CONTROL CHARS +TAB:: ;TAB NOT IMPLEM + RTS PC + +MU: MOV CPOS,A + MOV CLINE,B + DEC B + BGT SXYJ + CLR B +SXYJ: JMP SETXY + +HD: CLR A + MOV #CHRLN-1,B + BR SXYJ + +;HERE FOR LINE FEED, NO FRILLS + +LF: INC PPLINE(U) + ADD #,PPLCC(U) + ADD #,PPCC(U) + CMP #TVFENCE,PPLCC(U) + BHI LF1 + CLR PPLINE(U) + SUB PPLCC(U),PPCC(U) + ADD #TVLO,PPCC(U) + MOV #TVLO,PPLCC(U) +LF1: RTS PC + +;HERE FOR CARRIAGE RETURN + +CR: MOV PPLCC(U),PPCC(U) ;ORIGIN OF THIS LINE +CR1: MOV #20-CHRWD,PPPHS(U) ;PHASE + CLR PPCPOS(U) ;CHAR POSN + RTS PC + ;DATA POINT ROUTINES + +;CLEARS TO END OF LINE + +CLEOL: PUSH PPCC(U) + PUSH PPPHS(U) + PUSH PPCPOS(U) + JSR PC,CLEOL1 ;DO THE DIRTY WORK +CLEOX: POP PPCPOS(U) + POP PPPHS(U) + POP PPCC(U) + RTS PC + +CLEOL1: CMP PPCPOS(U),#CHRPL-1 + BGE CLEOLX ;ALREADY AT END OF LINE + CMP PPPHS(U),#20-CHRWD + BEQ CLEOL2 ;IF AT START OF WORD, START CLEARING WORD-WISE + JSR PC,CLRCHR ;ELSE CLEAR 1 CHAR AT A TIME TILL REACH WORD BOUNDARY. + JSR PC,LEDADC + BR CLEOL1 + +CLEOL2: MOV PPLCC(U),-(SP) + SUB PPCC(U),(SP) + ADD #BYTPL,(SP) ;# OF BYTES TO CLEAR + ASR (SP) + PUSH PPCC(U) ;ADDR OF 1ST WORD TO CLEAR, + PUSH #LINHT ;# LINES TO PROCESS +CLEOL3: MOV 2(SP),TVPTR ;START CLEARING HERE + BIC #VERINC,TVCTL ;HORIZONTAL INCREMENT MODE + MOV 4(SP),TT ;# WDS TO CLEAR +CLEOL4: CLR TVDATI + DEC TT + BNE CLEOL4 + ADD #BYTPL,2(SP) + DEC (SP) + BGT CLEOL3 + ADD #6,SP ;CLEANSE STACK + MOV TVPTR,PPCC(U) + BR CR1 ;RESET X AND PHASE + +CLEOLX: MOV PPLCC(U),T + ADD #,T ;HERE IF ALREADY AT END OF LINE + MOV T,PPCC(U) + BR CR1 + ;DATA POINT ROUTINES CONTINUED + +;CLEARS TO END OF SCREEN + +CLEOF: PUSH PPCC(U) + PUSH PPPHS(U) + PUSH PPCPOS(U) + PUSH PPLCC(U) + TST PPCPOS(U) ;IF WE'RE AT THE LEFT MARGIN + BEQ CLEOF0 ;START DOING FAST LINE-BY-LINE CLEARING RIGHT AWAY. + JSR PC,CLEOL1 ;CLEAR TO END OF LINE FIRST +CLEOF0: MOV #TVHI+2,TT + SUB PPCC(U),TT + ASR TT ;# OF WDS REMAINING IN TV MEMORY + BEQ CLEOFX + MOV #TVDATI,T + BIC #VERINC,TVCTL ;HORIZONTAL INCREMENT MODE +CLEOF1: CLR (T) + DEC TT + BNE CLEOF1 +CLEOFX: POP PPLCC(U) + BR CLEOX ;RESTORE ALL THAT OTHER STUFF + +;HERE TO HOME UP + +HU: MOV PPORG(U),PPCC(U) ;RESET MA + MOV PPORG(U),PPLCC(U) + CLR PPCPOS(U) + CLR PPLINE(U) + BR CR1 ;SET CHARACTER PHASE AND X + ;MULTIPLY, DIVIDE SUBROUTINES, BORROWED FROM TRANTOR + +R0==%0 ;for some reason they like funny names for ACs +R1==%1 +R2==%2 +R3==%3 +R4==%4 +R5==%5 + +.MACRO SOB R,D + DEC R + BNE D +.ENDM SOB + +;.sbttl Register save/restore routines + +; SAVE6 routine saves R0 through R5 on stack, R0 at top: +; SP -> R0 +; R1 +; R2 +; R3 +; R4 +; R5 +; Call by JSR R5,SAVE6. Restore regs by REST6 routine. + +save6: push r4 ; R5 already on stack by JSR. + push r3 + push r2 + push r1 + push r0 + jmp (r5) ; return. + + +; SAVE5 is similar to SAVE6, but only saves r0-r4, thus leaving r5 +; as a return ptr for JSR R5,FOO calls. Call with "JSR R4,SAVE5". + +save5: push r3 ; R4 on stack from JSR. + push r2 + push r1 + push r0 + jmp (r4) + + +; REST6 routine restores R0 through R5 from stack, where +; R0 is considered to be the top word of the stack (which is +; how SAVE6 pushes the registers). Call by JSR R5,REST6. +; REST6 returns with the 6 words popped off the stack. + +rest6: tst (sp)+ ; forget old R5 contents. + pop r0 ; restore other regs. + pop r1 + pop r2 + pop r3 + pop r4 + rts r5 ; return and restore R5. + +; Same as above, except used for restoring SAVE5 calls. +; Call with "JSR R4,REST5". + +rest5: tst (sp)+ ; forget old R4 contents. + pop r0 ; restore regs + pop r1 + pop r2 + pop r3 + rts r4 ; and return + +; .sbttl Flow of control macros + +;IF macro: Generates code that executes the if clause +;if the specified conditon is true, the else clause if +;it is false. The else clause is not required. Example: +; if eq,< mov r0,r1 +; mov (r1)+,r2 > +; else < jsr pc,foo > + +.macro if cond,code + .nlist + gncnt===gncnt+1 + .irp foo,\gncnt + .iif p1, .word 0 + .else + %.itmp===>/2 + .iif gt %.itmp-377, .err Branch out of range + .iif lt %.itmp+377, .err Branch out of range + .iif eq &400, +%.itmp+400 + .ielse +%.itmp-400 + .endc + code +g'foo===. +ifcnt===foo + .endm .irp + .list + .endm if + +.macro else code + gncnt===gncnt+1 + .irp foo,\ifcnt + .irp bar,\gncnt + br g'bar +g'foo===. + code +g'bar===. + .endm + .endm + .endm else + +gncnt===777 ;gensym count. + + +;LOOP macro allows loops without labels. Use RPTL and EXITL +;to repeat loop and exit loop. Both take branch condition arguments. +;If condition arg is null, then BR is used, i.e. unconditional. +;End of CODE falls out of loop unless specific RPTL is used. + +;Example of LOOP macro: +;loop < cmpb r0,(r1)+ ;found char yet? +; exitl eq ;exit loop on equal. +; inc r2 ;not found. +; cmp r2,r5 ;too many? +; rptl lt ;no, keep going. +; jmp error ;too many. +; > +; ;EXITL comes here. + +;Loop defines two lables around the code argument, +;the first for looping back via the RPTL macro, the +;second for exiting the loop via the EXITL macro. +;Labels are of the form %Lnv or %Xnv where n signifies +;that this is the nth use of the LOOP macro, and v is +;the level of nesting of this loop macro. Up to 7 +;levels of nesting are allowed. + %level===0 + %loopn===0 +.macro loop code + .iif eq %level, %loopn===%loopn+1 + %level===%level+1 + .if gt <10*%loopn>+%level-7777 + .error Too many loops and/or nestings. + .mexit + .endc + .if gt %level-7 + .error Too many loop nestings (7 allowed). + .mexit + .endc + .irp n,\<<10*%loopn>+%level> + %l'n===. ;loop back to here. + code + %x'n===. ;exit to here. + .endm .irp + %level===%level-1 + .endm loop + +.macro rptl cond + .if eq %level + .error RPTL not inside LOOP + .mexit + .endc + .irp n,\<<10*%loopn>+%level> + .iif b cond, br %l'n ;loop back. + .ielse b'cond %l'n + .endm .irp + .endm rptl + +; SORL expands into a SOB instruction back to the last LOOP +; point. SORL takes one arg, a register to use with the SOB +; instruction. +.macro sorl r + .if eq %level + .error SORL not inside LOOP + .mexit + .endc + .irp n,\<<10*%loopn>+%level> + sob r,%l'n + .endm .irp + .endm sorl + + +.macro exitl cond + .if eq %level + .error EXITL not inside LOOP + .mexit + .endc + .irp n,\<<10*%loopn>+%level> + .iif b cond, br %x'n ;exit. + .ielse b'cond %x'n + .endm .irp + .endm exitl + +;.sbttl Multiply, Divide, Base-conversion + +;.if eq pdp11-10 + +; DIV2 divides a double word quantity by a single word +; quantity yielding a quotient and remainder. It is meant +; to simulate the DIV instruction found on reasonable 11s. + +; ARGS: VALS: +; SP -> divisor SP -> quotient +; dividend lo remainder +; dividend hi + +div2: jsr r4,save5 ; save regs + mov 20(sp),r0 ; dividend hi + mov 16(sp),r1 ; divident lo + mov 14(sp),r2 ; divisor + if mi,< neg r2 ; negate divisor and dividend + com r0 ; double word negate + neg r1 ; ... + adc r0 > ; ... + clr r3 + mov #16.,r4 +loop < asl r3 + rol r1 + rol r0 + cmp r2,r0 + if le,< sub r2,r0 + inc r3 > + sorl r4 + > + mov r0,20(sp) + mov r3,16(sp) + jsr r4,rest5 + pop (sp) + rts r5 + + + +; Multiply routine, args and vals each 1 word. + +; ARGS: VALS: +; SP -> A SP -> P (product) +; B + +mul1: jsr r5,save6 ; save registers r0-r5. + mov 16(sp),r1 ; first arg. + mov 20(sp),r2 ; second arg. + clr 20(sp) ; where result will go. +loop < tst r2 ; done? + exitl eq ; yes, exit the loop. + ror r2 ; no, get next bit in arg2. + if cs,< add r1,20(sp) > ; if bit is 1 then add arg1 into result + asl r1 ; then mult arg1 by 2. + rptl ; and repeat. + > + jsr r5,rest6 ; restore regs. + mov (sp)+,(sp) ; pop R5 down one word. + rts r5 ; return with result on stack. +;.endc + ;DATA POINT ROUTINES CONTINUED + +CSRPOS: JSR PC,TVPREP + +;HERE TO SET CURSOR GIVEN A DATAPOINT COORDINATE PAIR (X,Y) +;X AND Y ARE IN A AND B RESPECTIVELY, (0,0) IS UPPER LEFTHAND CORNER +;(1,3) IS THE SECOND CHARACTER OF FOURTH LINE + +SETXY: CMP #CHRPL,A ;CHECK FOR LEGAL POSITION + BLOS SETXY1 + CMP #CHRLN,B + BLOS SETXY1 +SETXY0: MOV B,PPLINE(U) + MOV A,PPCPOS(U) + MOV B,-(SP) ;Y POSITION + MOV #BYTPL*LINHT,-(SP) ;FIND ORIGIN OF LINE IN MEMORY + JSR 5,MUL1 + MOV (SP),PPLCC(U) + MOV (SP)+,PPCC(U) + CLR -(SP) ;FOR DIVIDE LATER + MOV A,-(SP) ;X POSITION + MOV #CHRWD,-(SP) + JSR 5,MUL1 ;PUSH #BITS FROM LEFT OF SCREEN + MOV #20,-(SP) + JSR 5,DIV2 + MOV (SP)+,T ;QUOTIENT + ASL T ;BYTES FROM BEGIN OF LINE + ADD T,PPCC(U) + MOV #20-CHRWD,T ;PHASE OF LEFT EDGE OF WORD + BIT #1,(SP) + BEQ 1$ + BPT ;DIVIDE BIT THE BAG? +1$: SUB (SP)+,T ;REMAINDER + MOV T,PPPHS(U) ;SET PHASE + CMP PPORG(U),#TVLO + BEQ .+4 + BPT ;NOT PREPARED TO HANDLE THAT PROBLEM + ADD PPORG(U),PPCC(U) + ADD PPORG(U),PPLCC(U) + BIT #1,PPCC(U) ;MAKE SURE IT LINES UP ON WORD BOUNDARY + BEQ .+4 + BPT +SETXY1: RTS PC + +;SAVE ALL ACS ON STACK + +ACSAVE: PUSH TT + PUSH T + PUSH C + PUSH B + PUSH A + PUSH U ;RETURN ADDRESS + MOV 14(SP),U ;RESTORE U + RTS PC + .SBTTL CHARACTER GENERATOR ROUTINES + +;ROUTINES TO GENERATE A CHARACTER +;CALL WITH CHARACTER IN A AND PAGE PRINTER IN U +;PRESERVES ALL ACS + +;IOR CHARACTER AT CURSOR + +GENCHR: JSR U,ACSAVE + MOV PPPHS(U),C + MOV PPCC(U),TVPTR + ASL A ;MAKE IT A BYTE OFFSET + MOV CTAB(A),T ;POINTS AT FONT DESCRIPTION + JSR PC,GENCH1 +ACREST: POP A + POP B + POP C + POP T + POP TT + POP U +CRTSPC: RTS PC + +;CLEARS CHARACTER AT LINE EDITOR CURSOR + +CLRCHR: JSR U,ACSAVE + MOV CTAB+<177*2>,T ;RUBOUT MASKS ENTIRE CHARACTER + MOV PPPHS(U),C + MOV PPCC(U),TVPTR + JSR PC,CLRCH1 + BR ACREST + +;BLINK CHARACTER AT CURSOR + +XORCHR: JSR U,ACSAVE + MOV CTAB+<177*2>,T ;RUBOUT MASKS ENTIRE CHARACTER + MOV PPPHS(U),C + MOV PPCC(U),TVPTR + JSR PC,XORCH1 + BR ACREST + +;ARRAY OF ROUTINES TO SHIFT B LEFT SPECIFIED AMOUNT +;ONLY EVEN INDICES WILL BE USED SINCE CHAR WIDTH AND WORD WIDTH BOTH EVEN +;INCOMING MASK IN B IS KNOWN TO BE 0 EXCEPT IN BOTTOM 5 BITS, WHICH HELPS +SHLTAB: SHL0 + SHL2 + SHL4 + SHL6 + SHL8 + SHL10 + SHL12 + SHL14 + +SHL14: ROR B + ROR B + ROR B + BIC #37777,B + RTS PC + +SHL10: ASL B + ASL B +SHL8: SWAB B + RTS PC + +SHL12: SWAB B +SHL4: ASL B + ASL B +SHL2: ASL B + ASL B +SHL0: RTS PC + +;ARRAY OF ROUTINES TO SHIFT B RIGHT SPECIFIED AMOUNT +;ONLY NEED EVEN AMOUNTS LESS THAN GRID WIDTH (I.E. -2, -4) + + SHR4 + SHR2 +SHRTAB:: ;INDEXED NEGATIVELY + +SHL6: SWAB B +SHR2: ASR B + ASR B + RTS PC + +SHR4: ASR B + ASR B + ASR B + ASR B + RTS PC + +.MACRO CGEN OP ;OP IS GEN, CLR, OR XOR +;The lowest level character generator +;AC use (CLOBBERS ALL) + +;A temp +;B bit raster +;C number of desired shifts +;T points into font description +;TT counts lines +;U - +;Called with TVPTR already set up from PPCC + +;THIS ROUTINE CLOBBERS -ALL- ACS + +OP'CH1: BIS #VERINC,TVCTL ;USE VERTICAL INCREMENT MODE + TST C ;CHECK SHIFT COUNT + BLT OP'OVRL ;OVERLAP CASE + MOV SHLTAB(C),C ;EASY CASE, GET PTR TO SHIFT ROUTINE +OP'EZCS:MOV #CHRHT,TT ;LINE COUNTER +OP'CGLP:MOVB (T)+,B ;CHARACTER RASTER LINE INTO B + JSR PC,(C) ;SHIFT IT +.LIF IDN OP,GEN + BIS B,TVDATI ;IOR INTO TV MEMORY AND BUMP TVPTR +.LIF IDN OP,CLR + BIC B,TVDATI ;ANDCA .. +.IF IDN OP,XOR + MOV B,A ;NO XOR INSN ON MACHINE + BIC TVDAT,A + BIC B,TVDAT + BIS A,TVDATI +.ENDC + DEC TT ;LOOP. NOT WORTH OPEN-CODING SINCE + BNE OP'CGLP ;SHIFT ROUTINES ARE SO SLOW ANYWAY AND + RTS PC ;WE'RE TIGHT ON CORE. + +;Character overlaps word boundaries. Do first column +;then transfer back to EZCS to do second column. + +OP'OVRL:PUSH C + MOV SHRTAB(C),C ;routine to shift right + JSR PC,OP'EZCS ;generate first column + SUB #CHRHT,T ;restore T + SUB #-2,TVPTR ;point to top of second column + POP C + MOV SHLTAB+20(C),C ;SHIFT LEFT ROUTINE + BR OP'EZCS ;DO SECOND COLUMN +.ENDM CGEN + +;ASSEMBLE 3 FLAVORS OF CHARACTER GENERATOR + +CGEN GEN +CGEN XOR +CGEN CLR + +RTSPC: RTS PC + .SBTTL KEYBOARD TABLES +.IFNZ KBDP + +.MACRO KBDKEY N,PLAIN,SH,SL,SLSH,TOP +.XLIST +.=XTAB+N +.BYTE PLAIN +.=XTAB+N+100 +.BYTE SH +.=XTAB+N+200 +.BYTE SL +.=XTAB+N+300 +.BYTE SLSH +.=XTAB+N+400 +.BYTE TOP +.LIST +.ENDM + +;WHAT FOLLOWS IS THE GRAND CHARACTER CONVERSION TABLE + +;AN 8 BIT QUANTITY IS USED TO INDEX INTO THE XTAB +; 0-5 KEYBOARD KEY NUMBER +; 6 SHIFT +; 7 SHIFT LOCK +; 8 TOP (6 AND 7 GUARANTEED TO BE ZERO) + +;IF THE BYTE PICKED IS NEGATIVE, YOU HAVE STRUCK A KEY THAT DOES NOT +;HAVE AN ASCII CODE. THESE CODES ARE ASSIGNED AS FOLLOWS: + +NASCTB: NONAS1 ; 0 ILLEGAL + RTSPC ; -1 BREAK + ESCAPE ; -2 ESCAPE + CALL ; -3 CALL + RTSPC ; -4 CLEAR + RTSPC ; -5 CAP DELTA + RTSPC ; -6 CIRCLE MINUS + RTSPC ; -7 DEL + RTSPC ; -10 CIRCLE PLUS + RTSPC ; -11 BACK + RTSPC ; -12 NEXT + RTSPC ; -13 HELP + RTSPC ; -14 BACK SPACE +MAXNAS==<<.-NASCTB>/2>-1 ;MAXIMUM # NON-ASCII CHARACTERS + +;GOODIES TO PRINT TO REPRESENT META BITS + +METATB: .BYTE 0,2,3,6 ;NOTHING, ALPHA, BETA, EPSILON +.EVEN + + +; CHAR NORMAL SHIFT LOCK SHIFT&LOCK TOP + +XTAB: +KBDKEY 0, -1, -1, -1, -1, -1 ;BREAK +KBDKEY 1, -2, -2, -2, -2, -2 ;ESCAPE +KBDKEY 2, '1, '!, '1, '!, '! +KBDKEY 3, '2, '", '2, '", '" +KBDKEY 4, '3, '#, '3, '#, '# +KBDKEY 5, '4, '$, '4, '$, '$ +KBDKEY 6, '5, '%, '5, '%, '% +KBDKEY 7, '6, '&, '6, '&, '& +KBDKEY 10, '7, '', '7, '', '' +KBDKEY 11, '8, '(, '8, '(, '( +KBDKEY 12, '9, '), '9, '), ') +KBDKEY 13, '0, '_, '0, '_, '_ +KBDKEY 14, '-, '=, '-, '=, '= +KBDKEY 15, '@, '`, '@, '`, '` +KBDKEY 16, '^, '~, '^, '~, '~ +KBDKEY 17, 10, 10, 10, 10, 10 ;BACK SPACE +KBDKEY 20, -3, -3, -3, -3, -3 ;CALL +KBDKEY 21, -4, -4, -4, -4, -4 ;CLEAR +KBDKEY 22, 11, 11, 11, 11, 11 ;TAB +KBDKEY 23, 33, 33, 33, 33, 33 ;ALT-MODE +KBDKEY 24, 'q, 'Q, 'Q, 'Q, 4, ;and +KBDKEY 25, 'w, 'W, 'W, 'W, 37 ;or +KBDKEY 26, 'e, 'E, 'E, 'E, 22 ;intersection +KBDKEY 27, 'r, 'R, 'R, 'R, 23 ;union +KBDKEY 30, 't, 'T, 'T, 'T, 20 ;subset +KBDKEY 31, 'y, 'Y, 'Y, 'Y, 21 ;superset +KBDKEY 32, 'u, 'U, 'U, 'U, 5 ;not +KBDKEY 33, 'i, 'I, 'I, 'I, 26 ;xor +KBDKEY 34, 'o, 'O, 'O, 'O, 1 ;down arrow +KBDKEY 35, 'p, 'P, 'P, 'P, 13 ;up arrow +KBDKEY 36, '[, '{, '[, '{, '{ +KBDKEY 37, '], '}, '], '}, '} +KBDKEY 40, '\, '|, '\, '|, '| +KBDKEY 41, '/, 16, '/, 16, 16 ;infinity +KBDKEY 42, -6, -5, -6, -5, -5 ;circle minus, cap delta +KBDKEY 43, -10, -7, -10, -7, -7 ;circle plus, cap del +KBDKEY 44, 14, 14, 14, 14, 14 ;form +KBDKEY 45, 13, 13, 13, 13, 13 ;vertical tab +KBDKEY 46, 177, 177, 177, 177, 177 ;rubout +KBDKEY 47, 'a, 'A, 'A, 'A, 34 ;.leq. +KBDKEY 50, 's, 'S, 'S, 'S, 35 ;.geq +KBDKEY 51, 'd, 'D, 'D, 'D, 36 ;equivalence +KBDKEY 52, 'f, 'F, 'F, 'F, 17 ;delta (partial derivative) +KBDKEY 53, 'g, 'G, 'G, 'G, 32 ;not equals +KBDKEY 54, 'h, 'H, 'H, 'H, -13 ;HELP!!!!! +KBDKEY 55, 'j, 'J, 'J, 'J, 30 ;back arrow +KBDKEY 56, 'k, 'K, 'K, 'K, 31 ;forward arrow +KBDKEY 57, 'l, 'L, 'L, 'L, 27 ;both ways arrow +KBDKEY 60,<';>, '+,<';>, '+, '+ +KBDKEY 61, ':, '*, ':, '*, '* +KBDKEY 62, 15, 15, 15, 15, 15 ;carriage return +KBDKEY 63, 12, 12, 12, 12, 12 ;line feed +KBDKEY 64, 37, 37, 37, 37, 37 ;next, back gives ^_ +;KBDKEY 64, -12, -11, -12, -11, -11 ;next, back +KBDKEY 65, 'z, 'Z, 'Z, 'Z, 2 ;alpha +KBDKEY 66, 'x, 'X, 'X, 'X, 3 ;beta +KBDKEY 67, 'c, 'C, 'C, 'C, 6 ;epsilon +KBDKEY 70, 'v, 'V, 'V, 'V, 10 ;lambda +KBDKEY 71, 'b, 'B, 'B, 'B, 7 ;pi +KBDKEY 72, 'n, 'N, 'N, 'N, 24 ;for all +KBDKEY 73, 'm, 'M, 'M, 'M, 25 ;there exists +KBDKEY 74,<',>, '<,<',>, '<, '< +KBDKEY 75, '., '>, '., '>, '> +KBDKEY 76, '/, '?, '/, '?, '? +KBDKEY 77, 40, 40, 40, 40, 40 ;space +.ENDC ;KBDP + .SBTTL FONT MACROS AND DEFINITION + +.IIF E FONTSW,CTAB==0 +.IF NE FONTSW +FNTORG==. + .MACRO CTBENT A + .XCREF ...'A + ...'A + .ENDM + +CTAB: .REPT 200 + CTBENT \.RPCNT + .ENDR + +.MACRO FONT A +....==0 +...==1_GRIDWD + +.IRPC CHR,A +...==..._<-1> +.IF NB CHR +....==....!... +.ENDC +.ENDM + +.IF NE ...-1 +ERROR \CURCHR +.ENDC + +;...FOO==%XLIST +;.REPT ...FOO +;.LIST +;.ENDR +.BYTE .... +;.XLIST +;%XLIST=...FOO +.ENDM + +.MACRO CDEF A +CURCHR==''A +CDEF1 \CURCHR +.ENDM + +.MACRO CDEF1 A +;.XCREF ...'A +CURCHR==A +;...FOO==%XLIST +;.REPT ...FOO +;.LIST +;.ENDR +...'A==. +;.XLIST +;%XLIST=...FOO +.ENDM + +.MACRO ERROR NUM +.IF1 +.ERROR ;FONT LOSSAGE NUM +.ENDC +.ENDM +.ENDC +.XLIST +.IF NE FONTSW +.IF NE FONTMS +.XCREF CURCHR,FONT,CDEF1,CDEF + +CDEF1 0 +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > + +CDEF1 1 +FONT < > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT <* * *> +FONT < *** > +FONT < * > +FONT < > +FONT < > + +CDEF1 2 +FONT < > +FONT < > +FONT < > +FONT < ** *> +FONT <* * > +FONT <* * > +FONT <* * > +FONT < ** *> +FONT < > +FONT < > + +CDEF1 3 +FONT < > +FONT < > +FONT < > +FONT < *** > +FONT <* *> +FONT <**** > +FONT <* *> +FONT <**** > +FONT <* > +FONT <* > + +CDEF1 4 +FONT < > +FONT < > +FONT < > +FONT < * > +FONT < * * > +FONT <* *> +FONT < > +FONT < > +FONT < > +FONT < > + +CDEF1 5 +FONT < > +FONT < > +FONT < > +FONT < > +FONT <*****> +FONT < *> +FONT < > +FONT < > +FONT < > +FONT < > + +CDEF1 6 +FONT < > +FONT < > +FONT < > +FONT < ** > +FONT < * > +FONT < *** > +FONT < * > +FONT < ** > +FONT < > +FONT < > + +CDEF1 7 +FONT < > +FONT < > +FONT < > +FONT <*****> +FONT < * * > +FONT < * * > +FONT < * * > +FONT < * * > +FONT < > +FONT < > + +CDEF1 10 +FONT < > +FONT < > +FONT <* > +FONT <* > +FONT < * > +FONT < * > +FONT < * * > +FONT <* *> +FONT < > +FONT < > + +CDEF1 11 +FONT <*** > +FONT < * > +FONT < * > +FONT < * > +FONT < > +FONT < ** > +FONT < * *> +FONT < ** > +FONT < * *> +FONT < ** > + +CDEF1 12 +FONT <* > +FONT <* > +FONT <* > +FONT <*** > +FONT < > +FONT < ***> +FONT < * > +FONT < ** > +FONT < * > +FONT < > + +CDEF1 13 +FONT < > +FONT < * > +FONT < *** > +FONT <* * *> +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < > +FONT < > + +CDEF1 14 +FONT < > +FONT < * > +FONT < * > +FONT <*****> +FONT < * > +FONT < * > +FONT <*****> +FONT < > +FONT < > +FONT < > + +CDEF1 15 +FONT < *** > +FONT <* > +FONT <* > +FONT < *** > +FONT < > +FONT < *** > +FONT < * *> +FONT < *** > +FONT < * *> +FONT < * *> + +CDEF1 16 +FONT < > +FONT < > +FONT < > +FONT < * * > +FONT <* * *> +FONT <* * *> +FONT < * * > +FONT < > +FONT < > +FONT < > + +CDEF1 17 +FONT < > +FONT < ** > +FONT < * > +FONT < *> +FONT < ****> +FONT <* *> +FONT <* *> +FONT < *** > +FONT < > +FONT < > + +CDEF1 20 +FONT < > +FONT < > +FONT < ****> +FONT <* > +FONT <* > +FONT <* > +FONT < ****> +FONT < > +FONT < > +FONT < > + +CDEF1 21 +FONT < > +FONT < > +FONT <**** > +FONT < *> +FONT < *> +FONT < *> +FONT <**** > +FONT < > +FONT < > +FONT < > + +CDEF1 22 +FONT < > +FONT < > +FONT < *** > +FONT <* *> +FONT <* *> +FONT <* *> +FONT < > +FONT < > +FONT < > +FONT < > + +CDEF1 23 +FONT < > +FONT < > +FONT <* *> +FONT <* *> +FONT <* *> +FONT < *** > +FONT < > +FONT < > +FONT < > +FONT < > + +CDEF1 24 +FONT < > +FONT <* *> +FONT <* *> +FONT <*****> +FONT <* *> +FONT < * * > +FONT < * * > +FONT < * > +FONT < > +FONT < > + +CDEF1 25 +FONT < > +FONT <*****> +FONT < *> +FONT < *> +FONT < ****> +FONT < *> +FONT < *> +FONT <*****> +FONT < > +FONT < > + +CDEF1 26 +FONT < > +FONT < > +FONT < *** > +FONT <** **> +FONT <* * *> +FONT <** **> +FONT < *** > +FONT < > +FONT < > +FONT < > + +CDEF1 27 +FONT < > +FONT < * > +FONT < * > +FONT <*****> +FONT < * > +FONT < * > +FONT < * > +FONT <*****> +FONT < * > +FONT < * > + +CDEF1 30 +FONT < > +FONT < > +FONT < * > +FONT < * > +FONT <*****> +FONT < * > +FONT < * > +FONT < > +FONT < > +FONT < > + +CDEF1 31 +FONT < > +FONT < > +FONT < * > +FONT < * > +FONT <*****> +FONT < * > +FONT < * > +FONT < > +FONT < > +FONT < > + +CDEF1 32 +FONT < > +FONT < *> +FONT < * > +FONT <*****> +FONT < * > +FONT <*****> +FONT < * > +FONT <* > +FONT < > +FONT < > + +CDEF1 33 +FONT < > +FONT < * > +FONT < * > +FONT < * * > +FONT <* *> +FONT < * * > +FONT < * > +FONT < * > +FONT < > +FONT < > + +CDEF1 34 +FONT < > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < > +FONT < *** > +FONT < > +FONT < > + +CDEF1 35 +FONT < > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < > +FONT < *** > +FONT < > +FONT < > + +CDEF1 36 +FONT < > +FONT < > +FONT <*****> +FONT < > +FONT <*****> +FONT < > +FONT <*****> +FONT < > +FONT < > +FONT < > + +CDEF1 37 +FONT < > +FONT < > +FONT < > +FONT <* *> +FONT < * * > +FONT < * > +FONT < > +FONT < > +FONT < > +FONT < > + +CDEF < > +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > + +CDEF +FONT < > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < > +FONT < * > +FONT < > +FONT < > + +CDEF <"> +FONT < * * > +FONT < * * > +FONT < * * > +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > + +CDEF <#> +FONT < > +FONT < > +FONT < * * > +FONT <*****> +FONT < * * > +FONT < * * > +FONT <*****> +FONT < * * > +FONT < > +FONT < > + +CDEF <$> +FONT < * > +FONT < *** > +FONT <* * *> +FONT <* * > +FONT < *** > +FONT < * *> +FONT <* * *> +FONT < *** > +FONT < * > +FONT < > + +CDEF <%> +FONT < > +FONT <*****> +FONT <** *> +FONT < * > +FONT < * > +FONT < * > +FONT <* **> +FONT <* **> +FONT < > +FONT < > + +CDEF <&> +FONT < > +FONT < * > +FONT <* * > +FONT <* * > +FONT < * > +FONT <* * *> +FONT <* * > +FONT < ** *> +FONT < > +FONT < > + +CDEF <'> +FONT < ** > +FONT < ** > +FONT <** > +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > + +CDEF <(> +FONT < > +FONT < *> +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < *> +FONT < > +FONT < > + +CDEF <)> +FONT < > +FONT <* > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT <* > +FONT < > +FONT < > + +CDEF <*> +FONT < > +FONT < * > +FONT <* * *> +FONT < *** > +FONT < * > +FONT < *** > +FONT <* * *> +FONT < * > +FONT < > +FONT < > + +CDEF <+> +FONT < > +FONT < > +FONT < * > +FONT < * > +FONT <*****> +FONT < * > +FONT < * > +FONT < > +FONT < > +FONT < > + +CDEF <,> +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > +FONT < ** > +FONT < ** > +FONT <** > +FONT < > + +CDEF <-> +FONT < > +FONT < > +FONT < > +FONT < > +FONT <*****> +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > + +CDEF <.> +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > +FONT < ** > +FONT < ** > +FONT < > +FONT < > + +CDEF +FONT < > +FONT < > +FONT < *> +FONT < * > +FONT < * > +FONT < * > +FONT <* > +FONT < > +FONT < > +FONT < > + +CDEF 0 +FONT < > +FONT < *** > +FONT <* *> +FONT <* **> +FONT <* * *> +FONT <** *> +FONT <* *> +FONT < *** > +FONT < > +FONT < > + +CDEF 1 +FONT < > +FONT < * > +FONT < ** > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < *** > +FONT < > +FONT < > + +CDEF 2 +FONT < > +FONT < *** > +FONT <* *> +FONT < *> +FONT < * > +FONT < * > +FONT < * > +FONT <*****> +FONT < > +FONT < > + +CDEF 3 +FONT < > +FONT < *** > +FONT <* *> +FONT < *> +FONT < ** > +FONT < *> +FONT <* *> +FONT < *** > +FONT < > +FONT < > + +CDEF 4 +FONT < > +FONT < * > +FONT < ** > +FONT < * * > +FONT <* * > +FONT <*****> +FONT < * > +FONT < * > +FONT < > +FONT < > + +CDEF 5 +FONT < > +FONT <*****> +FONT <* > +FONT <**** > +FONT < *> +FONT < *> +FONT <* *> +FONT < *** > +FONT < > +FONT < > + +CDEF 6 +FONT < > +FONT < ** > +FONT < * > +FONT <* > +FONT <**** > +FONT <* *> +FONT <* *> +FONT < *** > +FONT < > +FONT < > + +CDEF 7 +FONT < > +FONT <*****> +FONT < *> +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < > +FONT < > + +CDEF 8 +FONT < > +FONT < *** > +FONT <* *> +FONT <* *> +FONT < *** > +FONT <* *> +FONT <* *> +FONT < *** > +FONT < > +FONT < > + +CDEF 9 +FONT < > +FONT < *** > +FONT <* *> +FONT <* *> +FONT < ****> +FONT < *> +FONT < * > +FONT < ** > +FONT < > +FONT < > + +CDEF <:> +FONT < > +FONT < > +FONT < > +FONT < ** > +FONT < ** > +FONT < > +FONT < ** > +FONT < ** > +FONT < > +FONT < > + +CDEF <;> +FONT < > +FONT < > +FONT < > +FONT < ** > +FONT < ** > +FONT < > +FONT < ** > +FONT < ** > +FONT <** > +FONT < > + +CDEF1 74 +FONT < > +FONT < > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < > +FONT < > +FONT < > + +CDEF <=> +FONT < > +FONT < > +FONT < > +FONT <*****> +FONT < > +FONT <*****> +FONT < > +FONT < > +FONT < > +FONT < > + +CDEF1 76 +FONT < > +FONT < > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < > +FONT < > +FONT < > + +CDEF +FONT < > +FONT < *** > +FONT <* *> +FONT < * > +FONT < * > +FONT < * > +FONT < > +FONT < * > +FONT < > +FONT < > + +CDEF <@> +FONT < > +FONT < *** > +FONT <* *> +FONT <* ***> +FONT <* * *> +FONT <* ***> +FONT <* > +FONT < *** > +FONT < > +FONT < > + +CDEF A +FONT < > +FONT < *** > +FONT <* *> +FONT <* *> +FONT <*****> +FONT <* *> +FONT <* *> +FONT <* *> +FONT < > +FONT < > + +CDEF B +FONT < > +FONT <**** > +FONT <* *> +FONT <* *> +FONT <**** > +FONT <* *> +FONT <* *> +FONT <**** > +FONT < > +FONT < > + +CDEF C +FONT < > +FONT < *** > +FONT <* *> +FONT <* > +FONT <* > +FONT <* > +FONT <* *> +FONT < *** > +FONT < > +FONT < > + +CDEF D +FONT < > +FONT <**** > +FONT < * *> +FONT < * *> +FONT < * *> +FONT < * *> +FONT < * *> +FONT <**** > +FONT < > +FONT < > + +CDEF E +FONT < > +FONT <*****> +FONT <* > +FONT <* > +FONT <**** > +FONT <* > +FONT <* > +FONT <*****> +FONT < > +FONT < > + +CDEF F +FONT < > +FONT <*****> +FONT <* > +FONT <* > +FONT <**** > +FONT <* > +FONT <* > +FONT <* > +FONT < > +FONT < > + +CDEF G +FONT < > +FONT < *** > +FONT <* *> +FONT <* > +FONT <* > +FONT <* **> +FONT <* *> +FONT < *** > +FONT < > +FONT < > + +CDEF H +FONT < > +FONT <* *> +FONT <* *> +FONT <* *> +FONT <*****> +FONT <* *> +FONT <* *> +FONT <* *> +FONT < > +FONT < > + +CDEF I +FONT < > +FONT < *** > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < *** > +FONT < > +FONT < > + +CDEF J +FONT < > +FONT < *> +FONT < *> +FONT < *> +FONT < *> +FONT < *> +FONT <* *> +FONT < *** > +FONT < > +FONT < > + +CDEF K +FONT < > +FONT <* *> +FONT <* * > +FONT <* * > +FONT <** > +FONT <* * > +FONT <* * > +FONT <* *> +FONT < > +FONT < > + +CDEF L +FONT < > +FONT <* > +FONT <* > +FONT <* > +FONT <* > +FONT <* > +FONT <* > +FONT <*****> +FONT < > +FONT < > + +CDEF M +FONT < > +FONT <* *> +FONT <** **> +FONT <* * *> +FONT <* *> +FONT <* *> +FONT <* *> +FONT <* *> +FONT < > +FONT < > + +CDEF N +FONT < > +FONT <* *> +FONT <* *> +FONT <** *> +FONT <* * *> +FONT <* **> +FONT <* *> +FONT <* *> +FONT < > +FONT < > + +CDEF O +FONT < > +FONT < *** > +FONT <* *> +FONT <* *> +FONT <* *> +FONT <* *> +FONT <* *> +FONT < *** > +FONT < > +FONT < > + +CDEF P +FONT < > +FONT <**** > +FONT <* *> +FONT <* *> +FONT <**** > +FONT <* > +FONT <* > +FONT <* > +FONT < > +FONT < > + +CDEF Q +FONT < > +FONT < *** > +FONT <* *> +FONT <* *> +FONT <* *> +FONT <* * *> +FONT <* * > +FONT < ** *> +FONT < > +FONT < > + +CDEF R +FONT < > +FONT <**** > +FONT <* *> +FONT <* *> +FONT <**** > +FONT <* * > +FONT <* * > +FONT <* *> +FONT < > +FONT < > + +CDEF S +FONT < > +FONT < *** > +FONT <* *> +FONT <* > +FONT < *** > +FONT < *> +FONT <* *> +FONT < *** > +FONT < > +FONT < > + +CDEF T +FONT < > +FONT <*****> +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < > +FONT < > + +CDEF U +FONT < > +FONT <* *> +FONT <* *> +FONT <* *> +FONT <* *> +FONT <* *> +FONT <* *> +FONT < *** > +FONT < > +FONT < > + +CDEF V +FONT < > +FONT <* *> +FONT <* *> +FONT <* *> +FONT <* *> +FONT < * * > +FONT < * * > +FONT < * > +FONT < > +FONT < > + +CDEF W +FONT < > +FONT <* *> +FONT <* *> +FONT <* *> +FONT <* *> +FONT <* * *> +FONT <** **> +FONT <* *> +FONT < > +FONT < > + +CDEF X +FONT < > +FONT <* *> +FONT <* *> +FONT < * * > +FONT < * > +FONT < * * > +FONT <* *> +FONT <* *> +FONT < > +FONT < > + +CDEF Y +FONT < > +FONT <* *> +FONT <* *> +FONT < * * > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < > +FONT < > + +CDEF Z +FONT < > +FONT <*****> +FONT < *> +FONT < * > +FONT <*****> +FONT < * > +FONT <* > +FONT <*****> +FONT < > +FONT < > + +CDEF <[> +FONT < ***> +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < ***> +FONT < > + +CDEF <\> +FONT < > +FONT < > +FONT <* > +FONT < * > +FONT < * > +FONT < * > +FONT < *> +FONT < > +FONT < > +FONT < > + +CDEF <]> +FONT <*** > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT <*** > +FONT < > + +CDEF <^> +FONT < * > +FONT < * * > +FONT <* *> +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > + +CDEF <_> +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > +FONT <*****> + +CDEF <`> +FONT < ** > +FONT < ** > +FONT < **> +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > + +CDEF a +FONT < > +FONT < > +FONT < > +FONT < *** > +FONT < *> +FONT < ****> +FONT <* *> +FONT < ****> +FONT < > +FONT < > + +CDEF b +FONT < > +FONT <* > +FONT <* > +FONT <**** > +FONT <* *> +FONT <* *> +FONT <* *> +FONT <**** > +FONT < > +FONT < > + +CDEF c +FONT < > +FONT < > +FONT < > +FONT < *** > +FONT <* *> +FONT <* > +FONT <* > +FONT < ****> +FONT < > +FONT < > + +CDEF d +FONT < > +FONT < *> +FONT < *> +FONT < ****> +FONT <* *> +FONT <* *> +FONT <* *> +FONT < ****> +FONT < > +FONT < > + +CDEF e +FONT < > +FONT < > +FONT < > +FONT < *** > +FONT <* *> +FONT <**** > +FONT <* > +FONT < *** > +FONT < > +FONT < > + +CDEF f +FONT < > +FONT < ** > +FONT < * *> +FONT < * > +FONT <*** > +FONT < * > +FONT < * > +FONT < * > +FONT < > +FONT < > + +CDEF g +FONT < > +FONT < > +FONT < > +FONT < *** > +FONT <* *> +FONT <* *> +FONT <* *> +FONT < ****> +FONT < *> +FONT < *** > + +CDEF h +FONT < > +FONT <* > +FONT <* > +FONT <**** > +FONT <* *> +FONT <* *> +FONT <* *> +FONT <* *> +FONT < > +FONT < > + +CDEF i +FONT < > +FONT < > +FONT < * > +FONT < > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < > +FONT < > + +CDEF j +FONT < > +FONT < > +FONT < *> +FONT < > +FONT < *> +FONT < *> +FONT < *> +FONT < *> +FONT <* *> +FONT < *** > + +CDEF k +FONT < > +FONT <* > +FONT <* > +FONT <* *> +FONT <* * > +FONT <*** > +FONT <* * > +FONT <* *> +FONT < > +FONT < > + +CDEF l +FONT < > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < > +FONT < > + +CDEF m +FONT < > +FONT < > +FONT < > +FONT <** * > +FONT <* * *> +FONT <* * *> +FONT <* * *> +FONT <* * *> +FONT < > +FONT < > + +CDEF n +FONT < > +FONT < > +FONT < > +FONT <* ** > +FONT <** *> +FONT <* *> +FONT <* *> +FONT <* *> +FONT < > +FONT < > + +CDEF o +FONT < > +FONT < > +FONT < > +FONT < *** > +FONT <* *> +FONT <* *> +FONT <* *> +FONT < *** > +FONT < > +FONT < > + +CDEF p +FONT < > +FONT < > +FONT < > +FONT <**** > +FONT <* *> +FONT <* *> +FONT <* *> +FONT <**** > +FONT <* > +FONT <* > + +CDEF q +FONT < > +FONT < > +FONT < > +FONT < *** > +FONT <* *> +FONT <* *> +FONT <* *> +FONT < ****> +FONT < *> +FONT < *> + +CDEF r +FONT < > +FONT < > +FONT < > +FONT <* ** > +FONT <** *> +FONT <* > +FONT <* > +FONT <* > +FONT < > +FONT < > + +CDEF s +FONT < > +FONT < > +FONT < > +FONT < ****> +FONT <* > +FONT < *** > +FONT < *> +FONT <**** > +FONT < > +FONT < > + +CDEF t +FONT < > +FONT < * > +FONT < * > +FONT <*****> +FONT < * > +FONT < * > +FONT < * > +FONT < **> +FONT < > +FONT < > + +CDEF u +FONT < > +FONT < > +FONT < > +FONT <* *> +FONT <* *> +FONT <* *> +FONT <* *> +FONT < *** > +FONT < > +FONT < > + +CDEF v +FONT < > +FONT < > +FONT < > +FONT <* *> +FONT <* *> +FONT <* *> +FONT < * * > +FONT < * > +FONT < > +FONT < > + +CDEF w +FONT < > +FONT < > +FONT < > +FONT <* *> +FONT <* *> +FONT <* * *> +FONT <* * *> +FONT < * * > +FONT < > +FONT < > + +CDEF x +FONT < > +FONT < > +FONT < > +FONT <* *> +FONT < * * > +FONT < * > +FONT < * * > +FONT <* *> +FONT < > +FONT < > + +CDEF y +FONT < > +FONT < > +FONT < > +FONT <* *> +FONT <* *> +FONT <* *> +FONT < * * > +FONT < * > +FONT < * > +FONT <* > + +CDEF z +FONT < > +FONT < > +FONT < > +FONT <*****> +FONT < * > +FONT < *** > +FONT < * > +FONT <*****> +FONT < > +FONT < > + +CDEF1 173 +FONT < *> +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < *> +FONT < > + +CDEF1 174 +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < * > + +CDEF1 175 +FONT <* > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT < * > +FONT <* > +FONT < > + +CDEF1 176 +FONT < ** *> +FONT <* ** > +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > +FONT < > + +CDEF1 177 +FONT <*****> +FONT <*****> +FONT <*****> +FONT <*****> +FONT <*****> +FONT <*****> +FONT <*****> +FONT <*****> +FONT <*****> +FONT <*****> +.ENDC ;.IF NE FONTMS + .IF E FONTMS +...0==. +.BYTE 140,140,140,140,140,140,140,140,140,140 +...1==. +.BYTE 000,004,004,004,004,025,016,004,000,000 +...2==. +.BYTE 000,000,000,015,022,022,022,015,000,000 +...3==. +.BYTE 000,000,000,016,021,036,021,036,020,020 +...4==. +.BYTE 000,000,000,004,012,021,000,000,000,000 +...5==. +.BYTE 000,000,000,000,037,001,000,000,000,000 +...6==. +.BYTE 000,000,000,006,010,016,010,006,000,000 +...7==. +.BYTE 000,000,000,037,012,012,012,012,000,000 +...10==. +.BYTE 000,000,020,020,010,004,012,021,000,000 +...11==. +.BYTE 034,010,010,010,000,006,005,006,005,006 +...12==. +.BYTE 020,020,020,034,000,007,004,006,004,000 +...13==. +.BYTE 000,004,016,025,004,004,004,004,000,000 +...14==. +.BYTE 000,004,004,037,004,004,037,000,000,000 +...15==. +.BYTE 016,020,020,016,000,016,011,016,011,011 +...16==. +.BYTE 000,000,000,012,025,025,012,000,000,000 +...17==. +.BYTE 000,014,002,001,017,021,021,016,000,000 +...20==. +.BYTE 000,000,017,020,020,020,017,000,000,000 +...21==. +.BYTE 000,000,036,001,001,001,036,000,000,000 +...22==. +.BYTE 000,000,016,021,021,021,000,000,000,000 +...23==. +.BYTE 000,000,021,021,021,016,000,000,000,000 +...24==. +.BYTE 000,021,021,037,021,012,012,004,000,000 +...25==. +.BYTE 000,037,001,001,017,001,001,037,000,000 +...26==. +.BYTE 000,000,016,033,025,033,016,000,000,000 +...27==. +.BYTE 000,004,002,037,002,004,010,037,010,004 +...30==. +.BYTE 000,000,004,010,037,010,004,000,000,000 +...31==. +.BYTE 000,000,004,002,037,002,004,000,000,000 +...32==. +.BYTE 000,001,002,037,004,037,010,020,000,000 +...33==. +.BYTE 000,004,004,012,021,012,004,004,000,000 +...34==. +.BYTE 000,002,004,010,004,002,000,016,000,000 +...35==. +.BYTE 000,010,004,002,004,010,000,016,000,000 +...36==. +.BYTE 000,000,037,000,037,000,037,000,000,000 +...37==. +.BYTE 000,000,000,021,012,004,000,000,000,000 +...40==. +.BYTE 000,000,000,000,000,000,000,000,000,000 +...41==. +.BYTE 000,004,004,004,004,004,000,004,000,000 +...42==. +.BYTE 012,012,012,000,000,000,000,000,000,000 +...43==. +.BYTE 000,000,012,037,012,012,037,012,000,000 +...44==. +.BYTE 004,016,025,024,016,005,025,016,004,000 +...45==. +.BYTE 000,037,031,002,004,010,023,023,000,000 +...46==. +.BYTE 000,010,024,024,010,025,022,015,000,000 +...47==. +.BYTE 014,014,030,000,000,000,000,000,000,000 +...50==. +.BYTE 000,001,002,004,004,004,002,001,000,000 +...51==. +.BYTE 000,020,010,004,004,004,010,020,000,000 +...52==. +.BYTE 000,004,025,016,004,016,025,004,000,000 +...53==. +.BYTE 000,000,004,004,037,004,004,000,000,000 +...54==. +.BYTE 000,000,000,000,000,000,014,014,030,000 +...55==. +.BYTE 000,000,000,000,037,000,000,000,000,000 +...56==. +.BYTE 000,000,000,000,000,000,014,014,000,000 +...57==. +.BYTE 000,000,001,002,004,010,020,000,000,000 +...60==. +.BYTE 000,016,021,023,025,031,021,016,000,000 +...61==. +.BYTE 000,004,014,004,004,004,004,016,000,000 +...62==. +.BYTE 000,016,021,001,002,004,010,037,000,000 +...63==. +.BYTE 000,016,021,001,006,001,021,016,000,000 +...64==. +.BYTE 000,002,006,012,022,037,002,002,000,000 +...65==. +.BYTE 000,037,020,036,001,001,021,016,000,000 +...66==. +.BYTE 000,006,010,020,036,021,021,016,000,000 +...67==. +.BYTE 000,037,001,002,002,004,004,004,000,000 +...70==. +.BYTE 000,016,021,021,016,021,021,016,000,000 +...71==. +.BYTE 000,016,021,021,017,001,002,014,000,000 +...72==. +.BYTE 000,000,000,014,014,000,014,014,000,000 +...73==. +.BYTE 000,000,000,014,014,000,014,014,030,000 +...74==. +.BYTE 000,000,002,004,010,004,002,000,000,000 +...75==. +.BYTE 000,000,000,037,000,037,000,000,000,000 +...76==. +.BYTE 000,000,010,004,002,004,010,000,000,000 +...77==. +.BYTE 000,016,021,002,004,004,000,004,000,000 +...100==. +.BYTE 000,016,021,027,025,027,020,016,000,000 +...101==. +.BYTE 000,016,021,021,037,021,021,021,000,000 +...102==. +.BYTE 000,036,021,021,036,021,021,036,000,000 +...103==. +.BYTE 000,016,021,020,020,020,021,016,000,000 +...104==. +.BYTE 000,036,011,011,011,011,011,036,000,000 +...105==. +.BYTE 000,037,020,020,036,020,020,037,000,000 +...106==. +.BYTE 000,037,020,020,036,020,020,020,000,000 +...107==. +.BYTE 000,016,021,020,020,023,021,016,000,000 +...110==. +.BYTE 000,021,021,021,037,021,021,021,000,000 +...111==. +.BYTE 000,016,004,004,004,004,004,016,000,000 +...112==. +.BYTE 000,001,001,001,001,001,021,016,000,000 +...113==. +.BYTE 000,021,022,024,030,024,022,021,000,000 +...114==. +.BYTE 000,020,020,020,020,020,020,037,000,000 +...115==. +.BYTE 000,021,033,025,021,021,021,021,000,000 +...116==. +.BYTE 000,021,021,031,025,023,021,021,000,000 +...117==. +.BYTE 000,016,021,021,021,021,021,016,000,000 +...120==. +.BYTE 000,036,021,021,036,020,020,020,000,000 +...121==. +.BYTE 000,016,021,021,021,025,022,015,000,000 +...122==. +.BYTE 000,036,021,021,036,024,022,021,000,000 +...123==. +.BYTE 000,016,021,020,016,001,021,016,000,000 +...124==. +.BYTE 000,037,004,004,004,004,004,004,000,000 +...125==. +.BYTE 000,021,021,021,021,021,021,016,000,000 +...126==. +.BYTE 000,021,021,021,021,012,012,004,000,000 +...127==. +.BYTE 000,021,021,021,021,025,033,021,000,000 +...130==. +.BYTE 000,021,021,012,004,012,021,021,000,000 +...131==. +.BYTE 000,021,021,012,004,004,004,004,000,000 +...132==. +.BYTE 000,037,001,002,037,010,020,037,000,000 +...133==. +.BYTE 007,004,004,004,004,004,004,004,007,000 +...134==. +.BYTE 000,000,020,010,004,002,001,000,000,000 +...135==. +.BYTE 034,004,004,004,004,004,004,004,034,000 +...136==. +.BYTE 004,012,021,000,000,000,000,000,000,000 +...137==. +.BYTE 000,000,000,000,000,000,000,000,000,037 +...140==. +.BYTE 006,006,003,000,000,000,000,000,000,000 +...141==. +.BYTE 000,000,000,016,001,017,021,017,000,000 +...142==. +.BYTE 000,020,020,036,021,021,021,036,000,000 +...143==. +.BYTE 000,000,000,016,021,020,020,017,000,000 +...144==. +.BYTE 000,001,001,017,021,021,021,017,000,000 +...145==. +.BYTE 000,000,000,016,021,036,020,016,000,000 +...146==. +.BYTE 000,006,011,010,034,010,010,010,000,000 +...147==. +.BYTE 000,000,000,016,021,021,021,017,001,016 +...150==. +.BYTE 000,020,020,036,021,021,021,021,000,000 +...151==. +.BYTE 000,000,004,000,004,004,004,004,000,000 +...152==. +.BYTE 000,000,001,000,001,001,001,001,021,016 +...153==. +.BYTE 000,020,020,021,022,034,022,021,000,000 +...154==. +.BYTE 000,004,004,004,004,004,004,004,000,000 +...155==. +.BYTE 000,000,000,032,025,025,025,025,000,000 +...156==. +.BYTE 000,000,000,026,031,021,021,021,000,000 +...157==. +.BYTE 000,000,000,016,021,021,021,016,000,000 +...160==. +.BYTE 000,000,000,036,021,021,021,036,020,020 +...161==. +.BYTE 000,000,000,016,021,021,021,017,001,001 +...162==. +.BYTE 000,000,000,026,031,020,020,020,000,000 +...163==. +.BYTE 000,000,000,017,020,016,001,036,000,000 +...164==. +.BYTE 000,004,004,037,004,004,004,003,000,000 +...165==. +.BYTE 000,000,000,021,021,021,021,016,000,000 +...166==. +.BYTE 000,000,000,021,021,021,012,004,000,000 +...167==. +.BYTE 000,000,000,021,021,025,025,012,000,000 +...170==. +.BYTE 000,000,000,021,012,004,012,021,000,000 +...171==. +.BYTE 000,000,000,021,021,021,012,004,010,020 +...172==. +.BYTE 000,000,000,037,002,016,010,037,000,000 +...173==. +.BYTE 001,002,002,002,004,002,002,002,001,000 +...174==. +.BYTE 004,004,004,004,004,004,004,004,004,004 +...175==. +.BYTE 020,010,010,010,004,010,010,010,020,000 +...176==. +.BYTE 015,026,000,000,000,000,000,000,000,000 +...177==. +.BYTE 037,037,037,037,037,037,037,037,037,037 +.ENDC ;.IF E FONTMS +.LIST + +.IIF E FONTSW,.=.+3000 ;APPROXIMATE SIZE OF FONT + +REPORT FONT SIZE=,\.-FNTORG +.NLIST +.ENDC ;.IF NE FONTSW +.LIST + +PPVAR: .OFFSET -. ;PAGE PRINTER VARIABLES. +PPCC:: TVLO ;ADDRESS WHERE NEXT CHARACTER GOES +PPPHS:: 20-CHRWD ;CHARACTER PHASE +;PPX:: -BITPL ;X POSITION OF CHARACTER +;PPLE:: 0 ;LINE EDITOR ASSOCIATED WITH PAGE +;PPCREG:: .BYTE -1 ;CONSOLE REGISTER # +; .BYTE 0 ;UNUSED + +;PPCHN:: -1 ;PAGE PRINTER CHANNEL, -1=>THESE VARIABLES UNUSED +;PPY:: -NLINS ;Y POSITION +PPLCC:: TVLO ;ORIGIN OF THIS LINE IN MEMORY +PPORG:: TVLO ;ORIGIN OF THIS PIECE OF PAPER IN MEMORY +PPCPOS:: 0 ;CHARACTER COLUMN POSITION (0=LEFT MARGIN) +PPLINE:: 0 ;LINE NUMBER (0=TOP LINE) +;PPXORG:: -BITPL ;X ORIGIN OF PAGE +;PPYORG:: -NLINS ;Y ORIGIN OF PAGE +;PPFONT:: CTAB ;FONT WE ARE PRINTING WITH +;PPLPG:: .BYTE 4 ;LINES/GLITCH COUNTER +;PPLPGK:: .BYTE 4 ;LINES/GLITCH CONSTANT (0=>WRAP AROUND) +;PPNGL:: .BYTE 11 ;# GLITCHES/PAGE COUNTER +;PPNGLK:: .BYTE 11 ;# GLITCHES/PAGE CONSTANT +PPLEN:: .OFFSET 0 + +CPOS=PPVAR+PPCPOS +CLINE=PPVAR+PPLINE + +BLKPHS: 0 ;0 NORMAL 1 CHAR UNDER BLINKER INVERTED +BLKTIM: 0 ;COUNT DOWN CLOCK BREAKS UNTIL BLINK +BELTIM: 0 ;IF NON-ZERO, COUNT DOWN CLOCK BREAKS UNTIL BELL +.ENDC ;TVP +BLKDFR: 0 ;NON-ZERO INHIBIT BLINKING [OUTSIDE CONDITIONAL FOR EASE] + +.SBTTL SOME LOWER LEVEL GOODIES + +ACSAV: PUSH A ;CALL WITH JSR U, + PUSH B + PUSH C + PUSH T + PUSH TT + JMP @U + +ACRES: TST (SP)+ ;CALL WITH JSR U, + POP TT + POP T + POP C + POP B + POP A + RTS U + +.IFNZ DEBUG + +;DEBST-- START UP 11/20 + +DEBST: MOV #174000,AKLIS + MOV #174002,AKLIB + MOV #174004,AKLOS + MOV #174006,AKLOB + MOV #KLIBRK,320 ;WAS CLOBBERED + MOV #DSBRK,20 ;USE IOT TO FAKE DISPLAY INTERRUPT + MOV DSPSW,22 + MOV #FDPC,ADPC + RTS PC + +FDPC: 0 ;FAKE DPC + +.ENDC ;DEBUG + +.SBTTL VARIABLES + +;SOME DEBUGGING AIDS + +VERSE: %FNAM2 ;VERSION NUMBER + +.IFNZ GT40P +ADPC: DPC ;CAN BE CHANGED TO NON-NXM FOR DEBUGGING ON PDP11 +.ENDC ;GT40P +AKLIS: KLIS +AKLIB: KLIB +AKLOS: KLOS +AKLOB: KLOB + +;VARIABLES + +ACTCHR: 0 ;# CHARACTERS BUFFERED +MAXACT: 0 ;THE BIGGEST ACTCHR WE'VE SEEN +GETCC: 0 ;WHERE TO GET NEXT CHARACTER +PUTCC: 0 ;WHERE TO PUT NEXT CHARACTER + +.IFNZ GT40P +CURSX: 0 ;X-Y CURSOR POSITION +CURSY: 0 ; (SCOPE COORDS) +BYTCNT: 0 ;# CHARACTERS ON THIS LINE +LINPNT: 0 ;BYTE POINTER INTO LINBUF +OCSR: 0 ;OLD CONSOLE SWITCH REGISTER +AVAIL: 0 ;POINTS TO FIRST FREE BLOCK +ROVER: 0 ;POINTS TO HEAD OF SEARCH LIST +OLDBLK: 0 +CASE: 0 ;-1 IMPLIES SHIFT OUT (SPECIAL CHARACTERS) +TEXTP: 0 ;INDIRECT POINTER TO TEXT LINE +TLINE: 0 ;INDEX OF TOP RING ON SCREEN +CKS: 0 ;LODER CHECKSUM +COMAND: 0 ;FOR DEBUGGING (DISPLAY SLAVE COMMAND) +COUNT: 0 ;FOR DEBUGGING (# BYTES IN LODER BLOCK) +CLINE: 0 ;CURRENT LINE (STARTS AT 0) +CPOS: 0 ;CURSOR POSITION ON LINE +.ENDC ;GT40P +MEMTOP: 0 ;FIRST NXM + +.IFZ GT40P +CURSX: CURSY: RCURSX: RCURSY: 0 ;THESE ARE HERE TO MAKE PALX HAPPY +.ENDC + +;INTERUPT LEVEL STORAGE + +;.IFNZ DLIMSW +;TICKS: 0 ;CLOCK TICK TIMER +;DTIME: 0 ;TIME TO DISPLAY EVERYTHING +;DSTOPD: 0 ;IF NON 0, WHERE DISPLAY STOPPED +;.ENDC +.IFNZ PCHIST +PCPNT: 0 +PCBUF: .=.+PCBFL +.ENDC +RETLAD: 0 ;ADDRESS OF BLOCK TO BE RETURNED +SAVSP: 0 ;SP SAVED AT POWER FAILURE +SAVDPC: 0 ;DPY STATUS AT LAST DISPLAY BREAK +SAVDSR: 0 +SAVXSR: 0 +SAVYSR: 0 +FORGIV: 0 ;IF NON-ZERO, IGNORE MYSTERIOUS DISPLAYS STOPS + +;CONSOLE RELATED STORAGE AND SWITCHES + +CNHTTY: 0 ;0 NORMAL DATAPOINT MODE TO 10, NON-ZERO LM CONSOLE HAS THE TTY +;LMHTTY: 0 ;NON-ZERO LISP MACHINE HAS THE TTY, NEGATIVE REMOTE CONSOLE MODE +;LMTOCK: 0 ;LISP-MACHINE TYPE-OUT CHECK DELAY COUNTER + +TNRQFG: 0 ;-1 PROCESSING REGISTER EXAM/DEPOS REQUEST FROM 10 +CONSF: 0 ;0 FULL CONSOLE SCREEN USED FOR TTY + ;-1 BOTTOM N LINES USED TO DISPLAY "LISP MACHINE CONSOLE" +TYIQM: 0 ;TYPE IN QUOTE MODE + ;CHARACTERS ARE ACTED UPON AT THE INTERRUPT LEVEL AS FOLLOWS: + ;ALWAYS ACTIVE: + ; ^Q QUOTES FOLLOWING CHR + ; ^X ENTERS CONSOLE MONITOR MODE + ;IN ADDITION, IF TYIQM=2 + ; ^S STOP LISP MACHINE + ; ^N SINGLE STEP LISP MACHINE + ; ^D COMPLEMENT DISPLAY CONSOLE SWITCH + ; (HOWEVER, THE CONSOLE IS ALWAYS DISPLAYED IN CONSOLE MONITOR MODE, + ; INDEPENDANT OF THE SETTING OF THE DISPLAY CONSOLE SWITCH). +TYIQF: 0 ;IF -1, QUOTE NEXT TYI CHAR +TYICH: 0 ;CHAR INPUT FROM KEYBOARD FOR CONSOLE MONITOR +CMREQ: -1 ;-1 NOT TRYING TO REACH CONSOLE MONITOR LEVEL + ;0 CNTRL X TYPED. RANDOM LOOPS SEEING THIS SHOULD XFER TO + ; CONSOLE MONITOR LOOP + ; IF A SECOND CNTRL X IS TYPED WHEN CMREQ=0, A GROSS QUIT OUT + ; AND REINITIALIZATION AT GO WILL OCCUR. +CDLNN: CHRLN-7 ;LINE NUMBER TO START CONSOLE DISPLAY ON + ; (THIS MAY MAKE REMAINING SCREEN DATAPOINT SIZED) + +;SAVED CONS MACHINE STATE +CSSWO: ;ORIGIN OF BLOCK OF SWITCHES ACCESSIBLE VIA RACSWO-RACSWE REGISTER + ;ADDRESSES +CPSVAL: 0 ;NON ZERO -> PASSIVE STATE SAVE VALID +CFSVAL: 0 ;NON ZERO -> FULL STATE SAVE VALID + ;THE "RUN" FLIP-FLOP IN CONS: + ; CTRUN REFLECTS THE "COMMAND" FROM THE 10 OR THE GT40 KEYBOARD. + ;WHEN THE 10 EXAMINES RAGO, THE CONTENTS OF CTRUN ARE RETURNNED. + ;QDPGO AND QDPSTP ARE THE ROUTINES TO SET AND CLEAR CTRUN RESPECTIVELY. + ; CRUN REFLECTS THE "ACTUAL" STATE OF CONS. QDPRUN AND QDPHLT + ;ARE ROUTINES TO SET AND CLEAR CRUN. NORMALLY, CRUN "FOLLOWS" CTRUN, + ;BUT VARIOUS CIRCUMSTANCES AND CAUSE IT TO DIFFER MOMENTARILY + ;(TYPE IN/OUT LOSSAGE NOTABLY). +CRUN: 0 ;NON ZERO -> CONS ACTUALLY RUNNING + ; IF THIS SET, CONS CLOCK SHOULD ACTUALLY BE TICKING AT HIGH SPEED. + ; SET BY QDPRUN, CLEARED BY ESTOP (AND QDPHLT WHICH CALLS IT). +CTRUN: 0 ;NON ZERO -> CONS "TRYING" TO RUN, ALTHO IT MAY BE TEMPORARILY STOPPED. + ; SET BY QDPGO (CNTRL-P OR RUN COMMAND FROM 10) + ; CLEARED BY QDPSTP (CNTRL-S OR STOP COMMAND FROM 10) + ; ALSO IF CRUN WAS -1 AND CONS HALTED DUE TO AN ERROR + +CLLMOD: 0 ;NON ZERO "LOW LEVEL MODE", 0 NORMAL +NOOPF: 0 ;NON ZERO -> NEXT INST WAS TO BE NO-OP ED WHEN + ; MACHINE STATE SAVED + +MODREG: 0 ;SAVES LAST SETTING OF MODE REGISTER (RAMOD) + +TENMOD: 0 ;NON ZERO -> PDP-10 FLAVOR CONSOLE PRGM ACTIVE, PDP-11 TO DO NOTHING + ; EXCEPT CNTRL-META-CALL HACK. +CSSWE: ;END OF RACSW BLOCK +.IFGE </2-> + .ERR RACSW OVERFLOW!! +.ENDC + +COBUS: 0 ;"OBSERVED" OBUS (LOW 16 BITS) + 0 ; HIGH 16 BITS +CIR: 0 ;"OBSERVED" IR 15-00 + 0 ; IR 31-16 + 0 ; IR 44-32 +CPC: 0 ;"OBSERVED" PC +CPCT: 0 ; TEMP (AT FRCONS) +CCERR1: 0 ;"OBSERVED" ERROR WD1 + ; (HIGH BYTE COMES FROM 164000 HIGH BYTE) + ; (LOW BYTE COMES FROM HIGH BYTE OF 164002) +CCERR2: 0 ;"OBSERVED" ERROR WD2 + ; (HIGH BYTE COMES FROM 164010 HIGH BYTE) + ; (LOW BYTE FROM 164012 HIGH BYTE) + +;M MEM LOCN 0 GET CLOBBERED BY VARIOUS OPERATIONS SO IT MUST +;BE SAVED AND RESTORED. IT AND A MEM LOCN 1 ARE USED WHEN +;WRITING CONTROL MEMORY + +CMMEM0: 0 ;SAVED M MEM LOCN 0 (LOW WD) + 0 ; HIGH WD +CAMEM1: 0 ;SAVED A MEM LOCN 1 (LOW WD) + 0 +CSVMA: 0 ;SAVED VMA (LOW WD) + 0 +CSPMD: 0 ;SAVED PAGE MAP DATA (LOW WD). 1-BIT=READ-FLT, 2-BIT=WRT-FLT + 0 +CSMWD: 0 ;SAVED WRITE DATA REGISTER (LOW WD) + 0 +CSMRD: 0 ;SAVED READ DATA REGISTER + 0 +CSMRDF: 0 ;.NE. 0, -> READ DATA REGISTER ALTERED, SO (TRY) TO RESTORE IT + +CSMGBR: 177 ;ADDRESS OF GARBAGE REGISTER TO WRITE IN ORDER TO RELOAD (LAST IN PG 0) + 0 ;READ DATA REGISTER (20 BIT PHYSICAL ADDRESS) +CL1M0: 0 ;LEVEL 1 MAP, LOCN 0 + +CL1M0F: 0 ;.NE. 0, LVL 1 MAP LOCN 0 HACKED + ; IF -1, 0 HAS BEEN WRITTEN IN HARDWARE +CL2M0: 0 ;LEVEL 2 MAP, LOCN 0 + 0 +CL2M0F: 0 ;.NE. 0, LVL 2 MAP LOCN 0 HACKED + +CVMMWD: 0 ;CONSOLE "VIRTUAL" MAIN MEM WRITE DATA REGISTER + 0 +CVMVMA: 0 ;CONSOLE "VIRTUAL" MAIN MEM ADDRESS REGISTER + 0 +CVMMRD: 0 ;CONSOSLE "VIRTUAL" MAIN MEM READ DATA REGISTER + 0 +CVMMPF: 0 ;PAGE FAULT FLAG ON CONSOLE VIRTUAL READ/WRITE (0 OR 1) +USSVDF: 0 ;U STACK SAVED IN USSVD +USTPNR: 0 ;SAVED USTACK POINTER +USSVD: .BLKW 32. ;SAVED STATE OF USTACK +USSVDE: ; (ALL 32 REGS SAVED SINCE THERE IS + ; NO RANDOM ACCESS TO HARDWARE RAM) + +UI: 0 ;TEM BLOCK FOR "ASSEMBLING" MICRO INSTRUCTIONS + 0 + 0 + +OLDPCS: .BLKW 8 ;OLD PCS + +;COMMAND VARIABLES AND SWITCHES + +CDNUM: 0 ;ASSEMBLED DECIMAL NUMBER + +CNUM: 0 ;RETURNED NUMERIC VALUE FROM COMMAND SCANNER. + 0 ; (POTENTIALLY 3 PRECISION) + 0 + 0 ;MUST BE HERE SO RESET WILL RUN FAST!! + ; DURING READIN, ASSEMBLE OCTAL NUMBER HERE +CNUMF: 0 ; (ON RETURN FROM GCOM) -1 NUMBER HAS BEEN TYPED VALUE IN CNUM + +CBUFL==10 ;COMMAND BUFFER LENGTH IN WDS + +CBUF: .BLKW CBUFL ;ASCIZ STRING TYPED IN + +CDELIM: 0 ;DELIMITER ENCOUNTERED +CBUFC: 0 ;AMT OF ROOM REMAINING IN CBUF +GCMPTR: 0 ;FILLING POINTER TO CBUF +CSYL: 0 ;-1 NON NULL SYLABLE SEEN +CVAL: 0 ;VALUE OF PREVIOUS COMMAND + 0 ; POTENTIALLY 3 PRECISION + 0 + +CVALF: 0 ;-1 -> CVAL NON-NULL +COMFRC: 0 ;-1 FORCE NEXT CHR TO BE COMMAND CHAR (@ SETS THIS) +CONSPT: 0 ;"." FOR CONS MACHINE +REGOPF: 0 ;-1 REG OPEN + + +CIBUF: .REPT 8 ;CONSOLE INSTRUCTION BUFFER + 0 + 0 + 0 + .ENDR + +;"RAID MODE" VARIABLES AND SWITCHES. +RAIDA: .REPT 8 ;REGISTER ADDRESSES TO BE DISPLAYED. 0 -> NULL + 0 + .ENDR +RAIDM: 0 ;-1 CURRENTLY PRINTING TEXT IN RAID MODE, + ; IE WRAP CURSOR BETWEEN LINES + ; C(RAIDN) AND CDLNN +DEPFLG: 0 ;NON ZERO -> DEPOSIT TYPE OPERATION + ; DONE BY LAST COMMAND, SO DO CDSPLY + +.SBTTL DISPLAY LISTS & BUFFERS +.IFNZ GT40P + +;TEXT RING HEADER + +DPYSA: + STSNRM ;SET STATUS REGISTER + SETPNT ;OFF SCREEN + 0 ;WATSE SOME TIME TO LET + 1400 ;THE MAIN PROGRAM RUN A LITTLE + CHARS + 17 ;SHIFT IN + .ASCII /**************************/ + .EVEN +DPYSPT: SETPNT+DPYNRM ;CURSOR +RCURSX: 0 +RCURSY: NLINS-CHRHT+1 + CHARS + <177_10>+17 ;CURSOR + 17 ;SHIFT IN + 0 + SETPNT+DPYNRM + 0 ;X + NLINS-CHRHT+1 ;Y + DPYJSR +TXSTRT: 0 ;PATCHED BY PROGRAM + DPYJSR + GRJSR + DPYJMP + DPYSA + +GRHDR==.-HJSIDX +GRJSR: DPYNOP + DPYNOP +GRJMP: DPYRTS +GRSTRT: 0 + +;FORMAT OF DISPLAY ITEM +HSPIDX==0 ;SETPOINT +HXCIDX==2 ;X CORDINATE +HYCIDX==4 ;Y COORDINATE +HJSIDX==6 ;DPYJSR +HDSIDX==10 ;DESTINATION (LIST) +HJMIDX==12 ;DPYJMP +HNXIDX==14 ;ADDRESS OF NEXT HEADER +HITIDX==16 ;ITEM NUMBER +HIAIDX==20 ;ADDRESS OF LIST +HSCIDX==22 ;# OF SUBROUTINE CALLS TO THIS LIST + +HSIZE==HSCIDX+2 ;SIZE OF HEADER +LINHDR==HYCIDX+2 ;NUMBER OF LIST BYTES IN HEADER + +;DISPLAY LIST +;DPYRTS +XITEM==2 ;NUMBER OF EXTRA BYTES IN LIST (DPYRTS) + +;RING OF LINE HEADERS + +LHDRS==12 ;SIZE OF LINE HEADER + + ;DPYJSR +TXTIDX==2 ;OFFSET OF TEXT POINTER +JMPIDX==4 ;OFFSET OF DPYJMP +NXTIDX==6 ;OFFSET OF NEXT LINE HEADER +BACIDX==10 ;OFFSET OF BACK POINTER + + +FAKEL: CHARS + <<15_10>+12> + DPYRTS + +LOWLIN: DPYJSR + 0 + DPYJMP + .+4 + HILIN + +.REPT CHRLN-2 +.XLIST + DPYJSR + 0 + DPYJMP + .+4 + .+2- +.LIST +.ENDR + +HILIN: DPYJSR + 0 + DPYRTS + LOWLIN + .+2- +.ENDC ;GT40P + ;DL11 INPUT BUFFER + +BUF=. +.=.+BUFSIZ +BUFEND==. + +.IFNZ GT40P +;DPY CHARACTER LINE BUFFER + +LINBUF=. +.=.+LBL +.EVEN + +;DPY PUSH DOWN LIST + +DPYPDP: 0 ;PUSH DOWN POINTER +DPYPDC: 0 ;PUSH DOWN COUNTER +DPYPDB=. +.=.+DPYPDL +.ENDC ;GT40P + +;PATCH AREA + +PAT:PATCH: +.=.+PATL + +.IFNZ GT40P +;***********INTERUPT/MAIN PROG LEVEL COMMUNICATION RING******** + +;ALL OF THIS HACKERY IS TO PUT GOODIES INTO DISPLAY LIST WHILE +;DISPLAY IS STOPPED AT INTERUPT LEVEL. BUFFERS ARE SET UP AT GO3. +;EACH BUFFER IS 6 BYTES AND IS OF THE FOLLOWING FORM + +; NEXT ON RING +; ADDRESS TO WRITE FOLLOWING WORD +; CONTENTS + +;GETDPY AND PUTDPY POINT AT ADDRESS WORD OF BUFFER AND ARE FOR +;INTERUPT AND MAIN PROGRAM LEVELS RESPECTIVELY + +PUTDPY: 0 +GETDPY: 0 +MIBUF: .=.+ + +;FAKE BLOCK +FAKEBL: 0 + FS+2 + FAKEBL+2 + -1 + +;FREE STORAGE +FS=. ;FREE STORAGE STARTS HERE +REPORT ,\BUFSIZ +REPORT ,\FS +REPORT ,\ +.IFF +REPORT ,\. +REPORT ,\HMEML-. +.ENDC ;GT40P + +.END GO