HACKER IDNT 1,0 NOPAGE INCLUDE MACROS.INC NOFORMAT * INCLUDE MACROS2.INC * UPDATED VERSION -- OS 1.

1 COMPATIBLE * * * ENTRY SYSADR Returns POINTER TO local copies * * ENTRY PADSTK(int*4) Pads the stack to provide buffer * against certain FORTRAN stack problems * ENTRY UNPSTK(int*4) UNPads the stack * * ENTRY ALOADB -- soon -Loads a binary file * FORTRAN calling sequence: CALL ALOADB(ADDR,ERR,VOL,NAME,EXT) * ADDR, ERR should be INTEGER*4, get transfer address and error code * * ENTRY ACHAIN -- soon -Loads a binary file AND transfers * control, can overlay * FORTRAN calling sequence: CALL ACHAIN(VOL,NAME,EXT) * for both of the above: VOL is 6 bytes, NAME is 8 bytes, EXT is 3 byte * blank ($20, 32) padded as necessary * * * ENTRY ABSCAL This is a proper version of ABSCAL, * ENTRY MCALL ie. one that WORKS. It can even be * used to 'call' DEBUG & will correctly handle conditions on return. * FORTRAN CALLING SEQUENCE: CALL ABSCAL(INT*4 address) OR * alternate CALL: CALL ABSCAL(...ARG LIST (ANY # OF vars)...,INT*4 address) * NOTE: Registers D0 - A7 & SR are saved upon return, and can be gotten by * calling GETRGS described below { CALL GETRGS(array(0:16) of INTEGER*4 ) * [ see also QCALLP & ZCALLP; GETBAK, REENTR, TRYAGN ] * * ENTRY GETRGS Get the values * FORTRAN CALLING SEQUENCE: CALL GETRGS(array (0:16) of INTEGER*4) * RETURNS register values present upon return from JSR in ABSCAL * array(0) <- D0, array(1) <- D1, ... array(7) <- D7 * array(8) <- A0, array(9) <- A1, ... array(15) <- A7; array(16) <- SR * [ see also QETREGS & ZETREGS ] * * ENTRY HBOOT If CSOS2.01 does HBOOT, else WBOOT * ENTRY REBOOT [aka WBOOT] Strangely enough, this reboots! * ENTRY CBOOT COLD BOOT - DOES POWER ON TESTS * * XDEF GETBAK,GETBK2 * GETBAK PREPARES A MEANS TO RE-ENTER AN EXECUTING PROGRAM AFTER EXITTING * (VOLUNTARILY OR FORCED) TO THE DEBUGGER, AND RETURNS THE ADDRESS VALUE * TO RETURN TO, GETBK2 RETURNS THE RETURN POINT VALUE W/O CHANGING THE POINT * OF RE-ENTRY * XDEF REENTR,REENT2 [also TRYAGN, TRYAG2] * SAME FUNCTION AS GETBAK, GETBK2; BUT USES DIFFERENT SAVE AREAS ALLOWS * SECOND RETURN POINT &/OR USE OF MCALL W/O DISTURBING RE-ENTRY ARRANGEMENTS * [ TRYAGN, TRYAG2 are same kind of beasts, but used w/ZCALLP which is used * by DEBUG calls in PASUTIL {DEBUG, DEBUGF, DEBUGX, DEBUGQ} ] * * ENTRY GETSR * GETSR RETURNS THE CURRENT VALUE OF THE STATUS REGISTER (SR) * I = GETSR() * --> SETSR(NEWSR INT*2) also PSETSR (Pascal type arg), ASETSR (D0->SR)

* --> SETILV(LEVEL INT*4) * * ENTRY SETSTK,PSETSTK (aka SETSP,PSETSP) * CALL SETSTK(NEWSTACK VALUE) * * ENTRY GETSSP * GETSSP RETURNS THE CURRENT VALUE OF THE SYSTEM STACK POINTER (SSP) * I = GETSSP() -- contrast to ISTACK (above), ALSO SETSSP * * ENTRY RSTSSP, FIXSSP (csos2.01 upgrade of rstssp) * RSTSSP RESETS THE SYSTEM STACK POINTER * CALL RSTSSP * * ENTRY SUPERM * SUPERM PUTS THE PROGRAM INTO SUPERVISOR MODE (PRIVELEGED STATE) * CALL SUPERM * * ENTRY USERM * USERM PUTS THE PROGRAM INTO USER MODE (NORMAL STATUS) * CALL USERM * * ENTRY SETIVC SET interrupt vector value * FORTRAN CALLING SEQUENCE: CALL SETIVC(INT*4 vector#,address) * * ENTRY GETIVC GET value of interrupt vector * FORTRAN CALLING SEQUENCE: INT*4 = GETIVC(INT*4 vector#) * * ENTRY PJUMPTO - Pascal version - jumps to address passed as arg * ENTRY JUMPTO - FORTRAN vers. - jumps to address passes as arg * CALL JUMPTO(ADDRESS integer*4) * * ENTRY DBTRAP fakes a DEBUG breakpoint, will kill program * if DEBUG is not active: CALL DBTRAP aka TRAP15 * * ALSO CAN INVOKE OTHER TRAPS: * TROPCO, TRDIV0, TRCHCK (aka TRCHKC), TRTRPV (aka TRAPOV) * TRPRIV, TRPROT, TR1010, TR1111, TRDTAK, TRADDR * TRAP14, TRAP13, TRAP12, TRAP11, TRAP10, TRAP09, TRAP08 * note TRAP12, TRAP11 not currently used by system; TRPSON (below) * enables TRAP12 as goto SUP MODE, and TRAP11 as goto USER MODE * * ENTRY TRPSON, TRPSOF -- enable/disable use of TR11/TR12 * when ON TR12 is goto SupMode, TR11 is return to UserMode * * added subs for task manipulation, calling resident commands, dtchdev, * atchdev, dtchdrv, atch IEEE 488 bus * * * BEGHAK EQU * * * * SYSADR EQU * XDEF SYSADR CMPI #0,LRAMEND BNE.S SYSADRR SAVREG GBASPTR SYSTEM CALL -returns ptr to data in A5 LEA LOSEND,A0 GET address of local vars into A0

MOVE.L MOVE.L MOVE.L MOVE.L MOVE.L MOVE.L RSTREG SYSADRR RTS LOSEND DC.L LAPPBEGIN DC.L LAPPEND DC.L LRAMEND DC.L LUSRPAG DC.L * PADSTK EQU XDEF MOVEA.L MOVE.L ANDI.L BLE.S NEG.L PADSTK1 MOVE.L LEA FNRET1 * UNPSTK EQU XDEF MOVEA.L MOVE.L ANDI.L BGE.S NEG.L UNPSTK1 MOVE.L LEA FNRET1 * * ALOADB EQU XDEF MOVEA.L REGSAV PUSH.L JSR MOVEQ.L MOVE.B LOADB POP.L MOVEQ.L MOVE.W MOVEA.L MOVE.L MOVEA.L MOVE.L REGRST FNRET * ACHAIN EQU XDEF MOVEA.L JSR

A0,D0 (A5)+,(A0)+ (A5)+,(A0)+ (A5)+,(A0)+ (A5)+,(A0)+ (A5)+,(A0)+ 0 0 0 0 0 * PADSTK 4(A7),A0 (A0),D0 #$FFFFFFFC,D0 PADSTK1 D0 (A7),(A7,D0) (A7,D0),A7 * UNPSTK 4(A7),A0 (A0),D0 #$FFFFFFFC,D0 UNPSTK1 D0 (A7),(A7,D0) (A7,D0),A7

COPY move move move move move

into D0 for function return OSEND APPBEGIN APPEND RAMEND USRPAG

A0 loaded with address of operand D0 loaded with operand MASK out low bits & set cond. code make sure it is negative by negating if it is not copy the return address change the stack pointer HOME, JAMES!

A0 loaded with address of operand D0 loaded with operand MASK out low bits & set cond. code make sure it is positive by negating if it is not copy the return address change the stack pointer HOME, JAMES!

* ALOADB A7,A0 A0 FILDIB(PC) #0,D5 #72,D5 A0 #0,D0 D7,D0 16(A0),A1 D0,(A1) 20(A0),A1 A2,(A1) 5 * ACHAIN A7,A0 FILDIB(PC)

LOADS binary file ...

CHAINS to binary file ...(overlays) PUTS DIB ADDRES IN A6

MOVEQ.L MOVE.B TRAP DC.W MOVE.L ANDI.B SUBQ.L MOVEA.L PUSH.W PUSH.W MOVEA.L PUSH.L PUSH.L CHAIN * FILDIB EQU XDEF MOVEA.L LEA.L MOVE.B MOVE.B MOVE.B MOVEA.L LEA.L MOVE.B MOVE.B MOVE.B MOVE.B MOVE.B MOVE.B MOVE.B MOVE.B MOVEA.L LEA.L MOVEA.L MOVE.B MOVE.B MOVE.B MOVE.B MOVE.B MOVE.B RTSLOC RTS * * MCALLP EQU XDEF MOVE.L MOVE.L MOVE.L LEA MOVEM.L MOVE.L MOVE.L BRA.S * ENTRY * ENTRY MCALL EQU ABSCLL EQU MCALLF EQU XDEF

#0,D5 #72,D5 #0 52 8(A5),D0 #$0FE,D0 #8,D0 D0,A7 #43 #$4E40 A7,A0 A0 A0 * FILDIB 4(A0),A2 DIBEXT,A1 (A2)+,(A1)+ (A2)+,(A1)+ (A2)+,(A1)+ 8(A0),A2 DIBNAM,A1 (A2)+,(A1)+ (A2)+,(A1)+ (A2)+,(A1)+ (A2)+,(A1)+ (A2)+,(A1)+ (A2)+,(A1)+ (A2)+,(A1)+ (A2)+,(A1)+ 12(A0),A2 DIBVOL,A1 A1,A6 (A2)+,(A1)+ (A2)+,(A1)+ (A2)+,(A1)+ (A2)+,(A1)+ (A2)+,(A1)+ (A2)+,(A1)+

FIND END OF AVAILABLE RAM FORCE TO WORD BOUNDARY DECREASE APPEND POINTER 2 LWORDS SET STACK = (APPEND-8)

* MCALLP A7,BASE A7,SVA7 A6,SVA6 SAV5ND,A6 BASELIST,-(A6) 4(A7),D1 D1,ARG1ADR MCALLPFOO ABSCLL MCALL * * * MCALLF,ABSCLL,MCALL

SAVE SAVE SAVE LOAD SAVE

A7 A7 A6 A6 D0

for stack based addressing for restoration for restoration with save area address through A5

This is a proper version of ABSCAL, ie. one that WORKS. It can even be used to 'call' DEBUG & will correctly handle conditions on return.

* * * *

FORTRAN CALLING SEQUENCE: CALL ABSCAL(INT*4 address) OR alternate CALL: CALL ABSCAL(...ARG LIST (ANY # OF vars)...,INT*4 address) NOTE: Registers D0 - A7 & SR are saved upon return, and can be gotten by calling GETRGS described below { CALL GETRGS(array(0:16) of INTEGER*4 ) MOVE.L A7,BASE SAVE A7 for stack based addressing MOVE.L A7,SVA7 SAVE A7 for restoration MOVE.L A6,SVA6 SAVE A6 for restoration LEA SAV5ND,A6 LOAD A6 with save area address MOVEM.L BASELIST,-(A6) SAVE D0 through A5 MOVEA.L 4(A7),A4 A4 loaded with address of last op MOVE.L A4,ARG1ADR SAVE address of ARG 1 MOVE.L (A4),D1 LAST OP is ADDRESS, get it into D0 MCALLPFOO EQU * AND.L ADRMASK,D1 FORCE address to word boundary MOVEA.L D1,A0 GET the adjusted addr. into A0 MOVE.L A0,JSRADR SAVE in core for possible post-mortem MOVE.L (A7),RETADR SAVE return address ADDQ.L #8,A7 FAKE stack to look like direct call JSR (A0) GO to it NOP GETBAKRESTORE EQU * NOP MOVE.W SR,SRRET Save status register as returned MOVE.L A7,A7RET Save A7 as returned MOVE.L A6,A6RET Save A6 as returned LEA RETEND,A6 LOAD A6 with RETURNED save area address MOVEM.L BASELIST,-(A6) SAVE D0 through A5 AS RETURNED LEA SAVEA,A6 LOAD address of save area into A6 MOVEM.L (A6)+,BASELIST RESTORE the registers MOVEA.L SVA6,A6 RESTORE A6 MOVEA.L SVA7,A7 RESTORE A7 MOVE.L RETADR,(A7) RESTORE return address, may be smashed MOVE.L ARG1ADR,4(A7) RESTORE arg 1 address, may be smashed FNRET 1 ABSCAL return GETREGS EQU * GETRGS EQU * XDEF GETREGS,GETRGS * FORTRAN CALLING SEQUENCE: CALL GETRGS(array (0:16) of INTEGER*4) * RETURNS register values present upon return from JSR in ABSCAL * array(0) <- D0, array(1) <- D1, ... array(7) <- D7 * array(8) <- A0, array(9) <- A1, ... array(15) <- A7; array(16) <- SR SAVREG MOVEA.L 4(A5),A0 Get address of operand (storage area) LEA RETRGS,A1 Get address of saved registers MOVEQ.L #7,D0 ] GRDLOOP MOVE.L (A1)+,(A0)+ ]MOVE the saved Data reg values DBF D0,GRDLOOP ] MOVEQ.L #8,D0 [ GRALOOP MOVE.L (A1)+,(A0)+ [MOVE the saved Addr (& SR) reg values DBF D0,GRALOOP [ RSTREG FNRET 1 GETRGS return * LOCAL STORAGE for ABSCAL and GETRGS routines RETRGS EQU * D0RET DS.L 1 D1RET DS.L 1 D2RET DS.L 1 D3RET DS.L 1 D4RET DS.L 1 D5RET DS.L 1

D6RET D7RET A0RET A1RET A2RET A3RET A4RET A5RET RETEND A6RET A7RET SRRET SRPAD JSRADR SVA7 SVA6 PJSRADR QCALLP

DS.L 1 DS.L 1 DS.L 1 DS.L 1 DS.L 1 DS.L 1 DS.L 1 DS.L 1 EQU * DS.L 1 DS.L 1 DS.W 1 DS.W 1 DS.L 1 DS.L 1 DS.L 1 DS.L 1 EQU * XDEF QCALLP MOVE.L A7,BASEQ MOVE.L A7,SQA7 MOVE.L A6,SQA6 LEA SAQ5ND,A6 MOVEM.L BASELIST,-(A6) MOVE.L 4(A7),D1 MOVE.L D1,ARQ1ADR AND.L ADRMASK,D1 MOVEA.L D1,A0 MOVE.L A0,QSRADR MOVE.L (A7),REQADR ADDQ.L #8,A7 JSR (A0) NOP REENTRESTORE EQU * NOP MOVE.W SR,SRREQ MOVE.L A7,A7REQ MOVE.L A6,A6REQ LEA REQEND,A6 MOVEM.L BASELIST,-(A6) LEA SAQEA,A6 MOVEM.L (A6)+,BASELIST MOVEA.L SQA6,A6 MOVEA.L SQA7,A7 MOVE.L REQADR,(A7) MOVE.L ARQ1ADR,4(A7) FNRET 1 QETREGS EQU * QETRGS EQU * XDEF QETREGS,QETRGS SAVREG MOVEA.L 4(A5),A0 LEA REQRGS,A1 MOVEQ.L #7,D0 QRDLOOP MOVE.L (A1)+,(A0)+ DBF D0,QRDLOOP MOVEQ.L #8,D0 QRALOOP MOVE.L (A1)+,(A0)+ DBF D0,QRALOOP RSTREG

FNRET 1 * LOCAL STORAGE *Register SAVE area PAD1Q DS.L 1 SAQEA EQU * SD0Q DS.L 1 SD1Q DS.L 1 SD2Q DS.L 1 SD3Q DS.L 1 SD4Q DS.L 1 SD5Q DS.L 1 SD6Q DS.L 1 SD7Q DS.L 1 SA0Q DS.L 1 SA1Q DS.L 1 SA2Q DS.L 1 SA3Q DS.L 1 SA4Q DS.L 1 SA5Q DS.L 1 SAQ5ND EQU * SA6Q DS.L 1 SA7Q DS.L 1 SAQEND EQU * PAD2Q DS.L 1 BASEQ DS.L 1 PAD3Q DS.L 1 REQADR DS.L 1 ARQ1ADR DS.L 1 PAD4Q DS.L 1 USPSAQE DS.L 1 USPTEMQ DS.L 1 SSPSAQE DS.L 1 REQRGS EQU * D0REQ DS.L 1 D1REQ DS.L 1 D2REQ DS.L 1 D3REQ DS.L 1 D4REQ DS.L 1 D5REQ DS.L 1 D6REQ DS.L 1 D7REQ DS.L 1 A0REQ DS.L 1 A1REQ DS.L 1 A2REQ DS.L 1 A3REQ DS.L 1 A4REQ DS.L 1 A5REQ DS.L 1 REQEND EQU * A6REQ DS.L 1 A7REQ DS.L 1 SRREQ DS.W 1 SRPADQ DS.W 1 QSRADR DS.L 1 SQA7 DS.L 1 SQA6 DS.L 1 PQSRADR DS.L 1 * * SEXIT EQU * XDEF SEXIT

EXIT * HBOOT EQU MOVEQ TRAP DC.W WBOOT EQU TRAP JMP REBOOT EQU XDEF WRMST CBOOT EQU XDEF EXALT MOVEQ MOVEA.L MOVEA.L JMP * * ICALL EQU MOVEA.L MOVE.L BRA.S DCALL EQU ENTRY MOVE.L INCALL EQU MOVE.L JMP * IJSR EQU MOVEA.L MOVE.L BRA.S DJSR EQU ENTRY MOVE.L INJSR EQU JSR FNRET1 * * GETBAK EQU XDEF LEA PUSH.L JSR.L GETBK2 EQU NOP LEA MOVE.L NOP GETBAKQQ NOP RTS * REENTR EQU XDEF LEA * #5,D0 #0 1 * #1 $FC00A4 * REBOOT,WBOOT,HBOOT * CBOOT #4,D0 D0,A0 (A0),A0 (A0) * 4(A7),A0 (A0),A0 INCALL * ICALL,DCALL 4(A7),A0 * (A7)+,(A7) (A0) * 4(A7),A0 (A0),A0 INJSR * IJSR,DJSR 4(A7),A0 * (A0)

* GETBAK,GETBK2 GETBAKQQ(PC),A0 A0 MCALLP(PC) * GETBAKRESTORE,A0 A0,D0

* REENTR,REENT2 REENTRQQ(PC),A0

PUSH.L A0 JSR.L QCALLP(PC) REENT2 EQU * NOP LEA REENTRESTORE,A0 MOVE.L A0,D0 NOP REENTRQQ NOP RTS * GETSR EQU * XDEF GETSR EOR.L D0,D0 MOVE SR,D0 RTS * SET4SR EQU * SETSR4 EQU * MOVEA.L 4(A7),A0 MOVE.L (A0),D0 MOVE.L (A7)+,A0 MOVE.L A0,(A7) BRA.S ASETSR PSETSR EQU * MOVE.W 4(A7),SCRLWRD MOVE.W 4(A7),SCRLWRD+2 MOVE.L (A7),D1 ADDQ.L #2,A7 MOVE.L D1,(A7) BRA.S INSETSRA ASETSR EQU * MOVE.W D0,SCRLWRD MOVE.W D0,SCRLWRD+2 BRA.S INSETSRA SETSR EQU * XDEF SETSR,PSETSR,ASETSR,SETSR4,SET4SR * FORTRAN CALLING SEQUENCE: CALL SETSR(INT*2 NEWSR) MOVEA.L 4(A7),A0 MOVE.W (A0),SCRLWRD+2 MOVE.W (A0),SCRLWRD INSETSR EQU * MOVE.L (A7)+,D1 MOVE.L D1,(A7) MOVE.L D1,RETPT INSETSRA EQU * MOVE.L A7,USPSAVE MOVE.L A7,USPTEMP MOVE.L A7,BARFOO ANDI.L #$A71FA71F,SCRLWRD BTST #5,SCRLWRD+2(PC) BEQ.S SETSROVER JSR SUPERM(PC) MOVE.L SCRLWRD(PC),D0 ORI.W #$2000,D0 MOVE.W D0,SR SETSRRET EQU * MOVE.L BARFOO,A7 MOVE.L RETPT,(A7) MOVEA.L (A7)+,A0 SWAP D0

ANDI.W MOVE JMP SETSROVER EQU MOVEA.L EXALT MOVEA.L MOVE.L ORI.W MOVE.W ANDI.W MOVEA.L MOVE.L MOVE.L MOVEA.L JMP * INTON EQU MOVEQ.L BRA.S INTOFF EQU MOVEQ.L ASETILV EQU MOVE.L BRA.S SETILV EQU XDEF MOVEA.L MOVE.L INSETILV EQU ANDI.L LSL.W MOVE ANDI.W OR.W MOVE.W MOVE.W BRA * * PSETSTK EQU PSETSP EQU LEA.L BRA.S SETSTK EQU SETSP EQU XDEF MOVEA.L ISETSTK EQU MOVE.L MOVEA.L MOVEA.L JMP * * GETSSP EQU XDEF MOVE.L RTS SETSSP EQU

#$A71F,D0 D0,CCR (A0) * A7,A0 ,, #$D58C,A7 SCRLWRD(PC),D0 #$2000,D0 D0,SR #$871F,SR A0,A7 BARFOO,A7 RETPT,(A7) (A7)+,A0 (A0)

TEMPORARY goto SUPERVISOR state

* #0,D0 ASETILV * #7,D0 * (A7),-(A7) INSETILV * SETILV,ASETILV,INTON,INTOFF 4(A7),A0 (A0),D0 * #7,D0 #8,D0 SR,D1 #$A01F,D1 D1,D0 D0,SCRLWRD D0,SCRLWRD+2 INSETSR * * 4(A7),A0 ISETSTK * * SETSTK,PSETSTK,SETSP,PSETSP 4(A7),A0 * (A0),D0 (A7),A0 D0,A7 (A0) * GETSSP SSPSAVE,D0 *

XDEF MOVEA.L MOVE.L MOVE.L FNRET1

SETSSP 4(A7),A0 SSPSAVE,D0 (A0),SSPSAVE

* RSTSSP EQU * XDEF RSTSSP SAVREG MOVE.L A7,LOCALUSP JSR SUPERM(PC) JSR USERM(PC) RSTREG RTS LOCALUSP DS.L 1 * FIXSSP EQU * XDEF FIXSSP MOVE SR,D0 BTST #13,D0 BEQ FIXSSP_OK RTS FIXSSP_OK TRAP #0 DC.W 32 SWAP D0 MOVEA.L A7,A1 CMPI.W #$01FF,D0 BCC.S CSOS_2 MOVE.L #$D58C,D0 FIXSSP_R MOVEA.L #$0ABCDEF,A0 TRAP #5 MOVEA.L D0,A7 MOVE.L (A1)+,-(A7) MOVE.L D0,SSPSAVE ANDI #$0FF,SR RTS CSOS_2 MOVEQ #4,D0 TRAP #0 DC.W 1 BRA.S FIXSSP_R * * SUPERM EQU * XDEF SUPERM MOVE.L A7,USPSAVE MOVE SR,D0 BTST #13,D0 BNE.S SUPERALREADY SAVREG MOVE.L A7,USPTEMP ADDA.L #-512,A7 MOVEA.L #$00ABCDEF,A0 TRAP #5 NOP MOVE.L A7,SSPSAVE MOVEA.L USPTEMP,A7 RSTREG MOVEA.L USPSAVE,A7 SUPERALREADY EQU * RTS

GET INTO SUPERVISOR MODE SAVE 'REAL' SSP RESTORE USP AS SP Restore USP as SP

* USERM

EQU * XDEF USERM MOVE.L A7,USPSAVE MOVE SR,D0 BTST #13,D0 MOVEA.L A7,A1 BEQ.S USERALREADY MOVEA.L A7,A0 SAVE 'USP' in A0 MOVE.L A7,USPSAVE * MOVEA.L SSPSAVE,A7 RESTORE 'REAL' SSP MOVEA.L #$0D58C,A7 MOVE.L A7,SSPSAVE ANDI #$D0FF,SR * MOVEA.L A0,A7 RESTORE USP AS SP USERALREADY EQU * MOVEA.L USPSAVE(PC),A7 Restore USP as SP BRA FIXSSP * * SETIVC EQU * XDEF SETIVC SET interrupt vector * FORTRAN CALLING SEQUENCE: CALL SETIVC(INT*4 vector#,address) SAVREG MOVE.L 4(A5),SPOKESRC SPOKESRC Loaded w/ address of second op MOVEA.L 8(A5),A0 A0 loaded with address of first op MOVE.L (A0),D1 First OP is ADDRESS, get it into D1 LSL.L #2,D1 change vector # to address MOVE.L D1,SPOKEADDR GET the VECTOR address SAVED EXALT ,, TEMPORARY goto SUPERVISOR state MOVEA.L SPOKEADDR,A3 Restore A3 MOVEA.L SPOKESRC,A1 Restore A1 MOVE.L (A1),(A3) MOVE the LONG word HUMBLE ,, Return to USER state RSTREG FNRET 2 SETIVC return * SPOKESRC DS.L 1 SPOKEADDR DS.L 1 NOP NOP GETIVC EQU * XDEF GETIVC GET interrupt vector * FORTRAN CALLING SEQUENCE: INT*4 = GETIVC(INT*4 vector#) SAVREG MOVEA.L 4(A5),A0 A0 loaded with address of operand MOVE.L (A0),D1 OP is vector #, get it into D1 LSL.L #2,D1 change vector # to address MOVEA.L D1,A1 GET the VECTOR address into A1 MOVE.L (A1),D0 MOVE the LONG word RSTREG FNRET 1 GETIVC return * PJUMPTO EQU * XDEF PJUMPTO MOVE.L 4(A7),D0 GET the operand BRA.S PJUMPTOQQ JUMPTO EQU * XDEF JUMPTO MOVEA.L 4(A7),A0 GET the address of the operand

MOVE.L PJUMPTOQQ EQU ANDI.B MOVEA.L JMP * DBTRAP EQU TRAP15 EQU XDEF TRAP RTS TROPCO EQU XDEF DC.W RTS TRDIV0 EQU XDEF EOR.L DIVU RTS TRCHCK EQU TRCHKC EQU XDEF MOVEQ CHK RTS TRTRPV EQU TRAPOV EQU XDEF * ORI.W DC.W DC.W TRAPV RTS TRPRIV EQU XDEF JSR.L EOR.W DC.W RTS TRPROT EQU XDEF JSR.L EOR.W MOVEA.L MOVE.W RTS TR1010 EQU XDEF DC.W NOP NOP RTS TR1111 EQU XDEF DC.W NOP NOP RTS TRAP14 EQU

(A0),D0 * #$E,D0 D0,A0 (A0) * * DBTRAP,TRAP15 #$F * TROPCO $4AF6 ILLEGAL * TRDIV0 D0,D0 #0,D0 * * TRCHCK,TRCHKC #-1,D0 (A7),D0 * * TRTRPV,TRAPOV #02,CCR $003C $0002 * TRPRIV USERM(PC) D0,D0 $46C0 MOVE D0,SR * TRPROT USERM(PC) D0,D0 D0,A0 D0,(A0) * TR1010 $AAAA

Get the OPerand (an address) Make sure on word boundary GET READY GO!

* TR1111 $FFFF

TRAP13

TRAP12

TRAP11

TRAP10

TRAP09

TRAP08

TRADDR

TRDTAK

XDEF TRAP RTS EQU XDEF TRAP RTS EQU XDEF TRAP RTS EQU XDEF TRAP RTS EQU XDEF TRAP RTS EQU XDEF TRAP RTS EQU XDEF TRAP RTS EQU XDEF MOVEQ MOVEA.L MOVE.L RTS EQU XDEF MOVE.L MOVEA.L MOVE.L RTS

TRAP14 #$E * TRAP13 #$D * TRAP12 #$C * TRAP11 #$B * TRAP10 #$A * TRAP09 #$9 * TRAP08 #$8 * TRADDR #1,D0 D0,A0 (A0),D0 * TRDTAK #$0F000000,D0 D0,A0 (A0),D0

* * * TRPS0N EQU LEA.L BRA.S TRPSON EQU LEA.L IMTRAPSON EQU * LEA.L * TRAP * DC.W MOVEQ.L CMP.L BNE.S MOVEM.L JSR MOVEM.L INTRAPSON EQU MOVEM.L * LEA.L

* RTSLOC(PC),A1 IMTRAPSON * USERM(PC),A1 * TR2_MESS(PC),A6 #0 18 PRTMES #0,D0 MEM_START(PC),D0 B0_OK D0-D7/A0-A6,-(A7) TRAPSN(PC) (A7)+,D0-D7/A0-A6 * D0-D7/A0/A2-A6,-(A7) TR3_MESS(PC),A6

* *

TRAP #0 DC.W 18 PRTMES JSR.L SUPERM(PC) MOVE.L $040,D0 CMP.L $0AC,D0 BNE.S AC_OK LEA.L TRAPB(PC),A0 MOVE.L A0,$0AC AC_OK: CMP.L $0B0,D0 BNE.S B0_OK LEA.L TRAPC(PC),A0 MOVE.L A0,$0B0 B0_OK: LEA.L RSTSSP(PC),A0 MOVE.L A0,$0C8 LEA.L ASETSR(PC),A0 MOVE.L A0,$0CC LEA.L SUPERM(PC),A0 MOVE.L A0,$0C0 LEA.L USERM(PC),A0 MOVE.L A0,$0C4 MOVEM.L (A7)+,D0-D7/A0/A2-A6 JMP.L (A1) TRPS0F EQU * LEA.L RTSLOC(PC),A1 BRA.S INTRPSOF TRPSOF EQU * LEA.L USERM(PC),A1 INTRPSOF EQU * JSR.L SUPERM(PC) MOVE.L $040,D0 LEA.L TRAPB(PC),A0 CMPA.L $0AC,A0 BNE.S OK_AC MOVE.L D0,$000000AC OK_AC: LEA.L TRAPC(PC),A0 CMPA.L $0B0,A0 BNE.S OK_B0 MOVE.L D0,$000000B0 OK_B0: MOVE.L D0,$000000C0 MOVE.L D0,$000000C4 MOVE.L D0,$000000C8 MOVE.L D0,$000000CC JMP.L (A1) XDEF TRPSON,TRPSOF,TRAPC,TRAPB,TRPS0N,TRPS0F,TRAPSN,TRAPSP TRAPSN EQU * TRAPSP EQU * MOVEM.L D0-D7/A0-A6,-(A7) * LEA.L TR1_MESS(PC),A6 * TRAP #0 * DC.W 18 PRTMES MOVEQ.L #0,D0 CMP.L MEM_START(PC),D0 BEQ.S NOT_YET BRA.S TR_FAIL NOT_YET: MOVEA.L $040,A0 CMPA.L $0AC,A0 BNE.S AC_ALREDY IS_B0: MOVEA.L $040,A0 CMPA.L $0B0,A0 BEQ.S DOTRAPS

LEA.L TRAPC(PC),A0 CMPA.L $0B0,A0 BEQ.S DOTRAPS TR_FAIL: MOVEM.L (A7)+,D0-D7/A0-A6 RTS AC_ALREDY EQU * LEA.L TRAPB(PC),A0 CMPA.L $0AC,A0 BNE.S TR_FAIL BRA.S IS_B0 DOTRAPS EQU * * LEA.L TR_MESS(PC),A6 * TRAP #0 * DC.W 18 PRTMES MOVEQ.L #0,D7 MOVE.L #5,D4 GETMEM MOVE.L #'SYSM',D5 FROM SYSTEM MEMORY POOL LEA.L TRAPS_MRB(PC),A6 TRAP #0 DC.W 57 MEM_MGR NOP NOP TST.W D7 BEQ.S MEM_COOL MOVE.L #0,MEM_START-TRAPS_MRB(A6) MOVEM.L (A7)+,D0-D7/A0-A6 MOVEA.L (A7)+,A1 JMP INTRAPSON(PC) MEM_COOL EQU * * GOT THE MEMORY MOVEA.L #$0ABCDEF,A0 TRAP #5 MOVEA.L MEM_START(PC),A6 LEA.L TRAPC(PC),A0 MOVE.L #BLOCK_SIZE,D0 TR_LOOP MOVE.B 0(A0,D0.W),0(A6,D0.W) DBRA D0,TR_LOOP MOVE.L A6,$0B0 MOVE.L A0,D0 LEA.L TRAPB(PC),A0 SUBA.L D0,A0 ADDA.L A0,A6 MOVE.L A6,$0AC MOVEA.L #$0FEDCBA,A0 TRAP #5 MOVEM.L (A7)+,D0-D7/A0-A6 RTS * *TRAP 12 HANDLER TRAPC EQU * NOP * CODE BELOW AS POSITION INDEPENDENT CODE SO CAN BE MOVED TO CSOS * SYSM MEMORY POOL * * If already in Supervisor state, just return BTST.B #5,(A7) BNE.S RTELOC * Prep for switch to supervisor state, by updating stacked SR ORI.W #$2000,(A7) * SWITCH STACKS AND RETURN

SWSTACK EQU * * Turn off interrupts for stack switch ORI.W #$0700,SR * save contants of A0 register & ESTABLISH ADDRESSING MOVE.L A0,-(A7) LEA.L A0SAVESX(PC),A0 MOVE.L (A7)+,(A0) * save A1 MOVE.L A1,4(A0) * get User's SP, and move SR, PC from SSP to USP data areas MOVE.L USP,A1 MOVE.W (A7)+,12(A0) MOVE.L (A7)+,8(A0) MOVE.L 8(A0),-(A1) MOVE.W 12(A0),-(A1) * store SSP as USP MOVE.L A7,USP * restore User's SP as SP (now SSP) MOVEA.L A1,A7 * restore A0 & A1 MOVEA.L 4(A0),A1 MOVEA.L (A0),A0 RTELOC EQU * RTE DS.W 1 A0SAVESX DS.L 1 A1SAVESX DS.L 1 DS.L 1 SPTEMPSX DS.W 1 DS.W 1 *TRAP 11 HANDLER NOP TRAPB EQU * NOP * If already in USER state, just return BTST.B #5,(A7) BEQ.S RTELOC * Prep for switch to USER state, by updating stacked SR ANDI.W #$DFFF,(A7) BRA.S SWSTACK NOP BC_H_END EQU * * BLOCK_SIZE EQU BC_H_END-TRAPC+4 * TRAPS_MRB EQU * DC.L 0 MEM_LEN DC.L BLOCK_SIZE DC.L 0 MEM_START DC.L 0 DC.L 0 *TR_MESS DC.B 'TRAPSP or TRAPSN - about to GETMEM.',$0D *TR1_MESS DC.B 'TRAPSP or TRAPSN entered.',$0D *TR2_MESS DC.B 'TRPSON or alternate entered.',$0D *TR3_MESS DC.B '@ INTRAPSON.',$0D * BTS0FF EQU * JSR TRPS0N(PC) MOVE.L $0B0,$020 JMP.L (A1)

BTSOFF EQU JSR MOVE.L JMP.L SAFN0W EQU TRAP MOVE.L RTS SAFNOW EQU TRAP MOVE.L JMP.L XDEF * PRITSK EQU MOVEA.L MOVE.L MOVEA.L MOVE.L MOVE.L BRA.S PRI EQU XDEF MOVEA.L MOVE.L MOVEQ.L INPRI EQU MOVE.L EXG TRAP DC.W NOP NOP EXG EXG RTS * DLYTSK EQU MOVEA.L MOVE.L MOVEA.L MOVE.L MOVE.L BRA.S DLY EQU XDEF MOVEA.L MOVE.L MOVEQ.L INDLY EQU MOVE.L TRAP DC.W NOP NOP RTS * WAKTSK EQU MOVEA.L MOVE.L

* TRPS0N(PC) $0B0,$020 USERM * #12 #$0FC08C8,$020 * #12 #$0FC08C8,$020 USERM BTS0FF,BTSOFF,SAFNOW,SAFN0W * 4(A7),A0 (A0),D1 8(A7),A0 (A0),D0 (A7)+,(A7) INPRI * PRI,PRITSK 4(A7),A0 (A0),D1 #0,D0 * (A7)+,(A7) D2,D7 #0 28 D2,D7 D2,D0 * 4(A7),A0 (A0),D1 8(A7),A0 (A0),D0 (A7)+,(A7) INDLY * DLY,DLYTSK 4(A7),A0 (A0),D1 #0,D0 * (A7)+,(A7) #0 29

* 4(A7),A0 (A0),D0

WAK INWAK

MOVE.L BRA.S EQU XDEF MOVEQ.L EQU TRAP DC.W NOP NOP RTS

(A7)+,(A7) INWAK * WAK,WAKTSK #0,D0 * #0 30

* KILTSK EQU * MOVEA.L 4(A7),A0 MOVE.L (A0),D0 MOVE.L (A7)+,(A7) BRA.S INKIL KIL EQU * XDEF KIL,KILTSK MOVEQ.L #0,D0 INKIL EQU * TRAP #0 DC.W 26 NOP NOP RTS * GSTATALL EQU * SAVREG LEA.L PCBINFO,A2 CLR.L D6 FOR.B D6 = #1 TO #15 BY #1 DO.S PUSH.L D6 MOVE.L D6,D0 CLR.L D5 TRAP #0 DC.W 27 SWAP D0 MOVE.W D5,D0 POP.L D6 MOVE.L D6,D5 SUBQ.L #1,D5 MULU #12,D5 CMPI.B #0,D0 BNE.S VALID MOVE.L #0,0(A2,D5.W) MOVE.L #'*no ',4(A2,D5.W) MOVE.L #'task',8(A2,D5.W) BRA.S NEXT VALID EQU * SWAP D0 MOVE.L D0,0(A2,D5.W) MOVE.L D1,4(A2,D5.W) MOVE.L D2,8(A2,D5.W) NEXT EQU * NOP ENDFOR RSTREG RTS

* FINDNAME EQU * MOVEA.L 10(A7),A1 MOVE.W 8(A7),D0 ANDI.L #$0F,D0 CMPI.B #8,D0 BLT.S D0OK MOVE.B #8,D0 D0OK EQU * ENTRY D0OK,FINDNAME SUBQ.L #1,D0 LEA.L COMPNAME(PC),A0 CLR.L D1 FOR.B D1 = #0 TO D0 BY #1 DO.S MOVE.B 0(A1,D1.W),0(A0,D1.W) ENDFOR ADDQ.L #1,D0 FOR.B D1 = D0 TO #7 BY #1 DO.S MOVE.B #' ',0(A0,D1.W) ENDFOR CLR.L FLAGNAME LOOPNAME EQU * JSR GSTATALL(PC) CLR.L D0 FOR.B D0 = #1 TO #15 BY #1 DO.S LEA.L COMPNAME(PC),A0 LEA.L PCBINFO(PC),A1 MOVE.L D0,D1 SUBQ.L #1,D1 MULU #12,D1 ADDA.L D1,A1 PUSH.L A1 ADDQ.L #4,A1 DC.W $023C,$0000 ANDI #0,CCR CMPM.L (A0)+,(A1)+ BNE.S NOTFND CMPM.L (A0)+,(A1)+ BNE.S NOTFND MOVE.L D0,D1 POP.L D0 RTS NOTFND EQU * POP.L A1 ENDFOR TAS FLAGNAME BEQ.S LOOPNAME CLR.L D0 RTS * PRIOF EQU * ENTRY PRIOF JSR FINDNAME(PC) CMPI.L #0,D0 BNE.S PRICOOL BRA.S PRIRET PRICOOL MOVEA.L D0,A0 CLR.L D0

MOVE.W BRA.S * STAOF EQU ENTRY JSR CMPI.L BNE.S BRA.S STACOOL MOVEA.L CLR.L MOVE.W PRIRET MOVEA.L ADDA.L JMP * PCBOF EQU ENTRY JSR CMPI.L BNE.S BRA.S PCBCOOL EQU MOVE.L BRA.S * MURDER EQU ENTRY JSR CMPI.L BNE.S BRA.S MRDRCOOL EQU CMPI.L BEQ.S MOVE.L TRAP DC.W BRA.S * DELAYT EQU ENTRY MOVEA.L MOVE.L MOVE.L JSR CMPI.L BNE.S BRA.S DLYTCOOL EQU CMPI.L BEQ.S MOVE.L MOVE.L TRAP DC.W BRA.S * WAKEIT EQU ENTRY

2(A0),D0 PRIRET * STAOF FINDNAME(PC) #0,D0 STACOOL PRIRET D0,A0 D0 (A0),D0 (A7),A0 #10,A7 (A0) * PCBOF FINDNAME(PC) #0,D0 PCBCOOL PRIRET * D1,D0 PRIRET * MURDER FINDNAME(PC) #0,D0 MRDRCOOL PRIRET * #0,D1 PRIRET D1,D0 #0 26 GIVPCB PRIRET * DELAYT 4(A7),A0 (A0),TEMP (A7)+,(A7) FINDNAME(PC) #0,D0 DLYTCOOL PRIRET * #0,D1 PRIRET D1,D0 TEMP(PC),D1 #0 29 DELAY PRIRET * WAKEIT

JSR FINDNAME(PC) CMPI.L #0,D0 BNE.S WKITCOOL BRA.S PRIRET WKITCOOL EQU * CMPI.L #0,D1 BEQ.S PRIRET MOVE.L D1,D0 TRAP #0 DC.W 30 WAKEUP BRA.L PRIRET * PRISET EQU * ENTRY PRISET MOVEA.L 4(A7),A0 MOVE.L (A0),TEMP MOVE.L (A7)+,(A7) JSR FINDNAME(PC) CMPI.L #0,D0 BNE.S PRISCOOL BRA.L PRIRET PRISCOOL EQU * CMPI.L #0,D1 BEQ.L PRIRET MOVE.L D1,D0 MOVE.L TEMP(PC),D1 EXG D2,D7 TRAP #0 DC.W 28 SETPRI EXG D2,D7 EXG D2,D0 BRA.L PRIRET * TEMP DC.L 0 * * SFUNHA EQU * ENTRY SFUNHA SAVREG MOVEA.L 12(A5),A0 MOVE.L (A0),D5 MOVEA.L 8(A5),A6 MOVEA.L 4(A5),A0 PUSH.L A0 TRAP #6 BRA.L SFUNERR MOVEQ.L #0,D7 SFUNERR EQU * POP.L A0 MOVE.L D7,(A0) RSTREG FNRET 3 * * ATCHBU EQU * IEE488 EQU * ENTRY ATCHBU,IEE488 *VERY MODIFIED VERSION FROM Disassembly of: 4:BUS.DRV THEREGS REG D3-D7/A2-A6 MOVEM.L THEREGS,-(A7)

MOVE.L A7,STACK MOVEA.L #$00ABCDEF,A0 GET INTO SUPERVISOR MODE TRAP #05 MOVE.L A7,SSTACK * GETSENS RETURNS IEEE488 RAM REQUIREMENTS IN D4.L * AND ADDRESS OF IEEE488 DRIVER INITIALIZATION IN A4 TRAP #00 DC.W +00067 GETSEN * DID GETSENS RETURN ERROR MESSAGE? TST.B D7 BNE.S DOERR *BUS ADDRESS IN D1.W & 0 IN D2.W FOR CONTROLLER MOVE.L #'#BUS',D0 MOVE.W #'@?',D1 CLR.L D2 DC.L $007C2100 ORI.W #$2100,SR *CALL IEEE 488 DRIVER INIT CODE JSR (A4) TST.B D7 BNE.S DOERR MOVE.L #0,ERRORCODE RETURNPT: MOVEA.L #$00FEDCBA,A0 GET OUT OF SUPERVISOR MODE TRAP #05 MOVEA.L STACK(PC),A7 MOVEM.L (A7)+,THEREGS MOVE.L ERRORCODE(PC),D0 RTS DOERR EQU * MOVE.L D7,ERRORCODE BRA.S RETURNPT STACK DS.L 1 SSTACK DS.L 1 ERRORCODE DC.L 0 *END OF ATCHBU STORAGE AND CODE * * ATCDEV, ATTACH are FORTRAN callable attach device routines, ERROR CODE IN D0 * IERROR = ATTACH('#device-name') * ATCHDEV is Pascal callable: IERROR := ATCHDEV('#device-name'); ATCDEV EQU * ATTACH EQU * ENTRY ATCDEV,ATCHDEV,ATTACH MOVEA.L (A7),A0 ;ADJUST FOR FORTRAN PUSHING STRING LENGTH MOVE.L A0,2(A7) ADDQ.L #2,A7 MOVEA.L 4(A7),A0 ;GET STRING ADDRESS BRA.S INADEV ATCHDEV EQU * MOVEA.L 4(A7),A0 ;GET STRING ADDRESS ADDQ.L #1,A0 ;ADJUST FOR PASCAL STRING LENGTH INADEV EQU * MOVE.B (A0),D0 LSL.W #8,D0 MOVE.B 1(A0),D0 SWAP D0 MOVE.B 2(A0),D0 LSL.W #8,D0 MOVE.B 3(A0),D0 MOVE.B 4(A0),D1 LSL.W #8,D1 MOVE.B 5(A0),D1

* * * * * * * * * * *

PUSH.L A6 LEA.L CRUD,A6 MOVE.L D0,(A6) MOVE.W D1,4(A6) PUSH.L D0 PUSH.W D1 TRAP #0 DEBUGGING CODE DC.W 18 POP.W D1 POP.L D0 POP.L A6 MOVEM.L THEREGS,-(A7) TRAP #8 DC.W 7 BRA.L NEXTADEV MOVEQ.L #0,D7 NEXTADEV: MOVE.L D7,D0 MOVEM.L (A7)+,THEREGS FNRET1 * * DTCDEV, DETACH are FORTRAN callable detach device routines, ERROR CODE IN D0 * IERROR = DETACH('#device-name') * DTCHDEV is Pascal callable: IERROR := DTCHDEV('#device-name'); DTCDEV EQU * DETACH EQU * ENTRY DTCDEV,DTCHDEV,DETACH MOVEA.L (A7),A0 ;ADJUST FOR FORTRAN PUSHING STRING LENGTH MOVE.L A0,2(A7) ADDQ.L #2,A7 MOVEA.L 4(A7),A0 ;GET STRING ADDRESS BRA.S INDDEV DTCHDEV EQU * MOVEA.L 4(A7),A0 ;GET STRING ADDRESS ADDQ.L #1,A0 ;ADJUST FOR PASCAL STRING LENGTH INDDEV EQU * MOVE.B (A0),D0 LSL.W #8,D0 MOVE.B 1(A0),D0 SWAP D0 MOVE.B 2(A0),D0 LSL.W #8,D0 MOVE.B 3(A0),D0 MOVE.B 4(A0),D1 LSL.W #8,D1 MOVE.B 5(A0),D1 * PUSH.L A6 * LEA.L CRUD,A6 * MOVE.L D0,(A6) * MOVE.W D1,4(A6) * PUSH.L D0 * PUSH.W D1 * TRAP #0 * DC.W 18 * POP.W D1 * POP.L D0 * POP.L A6 MOVEM.L THEREGS,-(A7) TRAP #8 DC.W 8 BRA.L NEXTDDEV

MOVEQ.L #0,D7 NEXTDDEV: MOVE.L D7,D0 MOVEM.L (A7)+,THEREGS FNRET1 *CRUD DC.B 13,13,13,13,13,13,13,13 * * DTCDRV is FORTRAN callable detach driver routine, ERROR CODE IN D0 * IERROR = ATTACH('#driver-name') * DTCHDRV is Pascal callable: IERROR := DTCHDRV('#driver-name'); DTCDRV EQU * ENTRY DTCDRV,DTCHDRV MOVEA.L (A7),A0 ;ADJUST FOR FORTRAN PUSHING STRING LENGTH MOVE.L A0,2(A7) ADDQ.L #2,A7 MOVEA.L 4(A7),A0 ;GET STRING ADDRESS BRA.S INDDRV DTCHDRV EQU * MOVEA.L 4(A7),A0 ;GET STRING ADDRESS ADDQ.L #1,A0 ;ADJUST FOR PASCAL STRING LENGTH INDDRV EQU * MOVE.B (A0),D0 LSL.W #8,D0 MOVE.B 1(A0),D0 SWAP D0 MOVE.B 2(A0),D0 LSL.W #8,D0 MOVE.B 3(A0),D0 MOVE.B 4(A0),D1 LSL.W #8,D1 MOVE.B 5(A0),D1 MOVEM.L THEREGS,-(A7) TRAP #8 DC.W 6 BRA.L NEXTDDRV MOVEQ.L #0,D7 NEXTDDRV: MOVE.L D7,D0 MOVEM.L (A7)+,THEREGS FNRET1 * * look up (or execute) RESident COMmand ... * I = RESCMD(name CHAR*8) RETURNS E.P. ADDR. * CALL DOCMD(name) COMMAND DS.L 2 RESCMD EQU * XDEF RESCMD MOVE.L (A7)+,A0 MOVE.W (A7)+,D0 CMPI.W #7,D0 BCS.S RC_LEN_OK MOVEQ #8,D0 RC_LEN_OK MOVE.L (A7)+,A1 MOVE.L A0,-(A7) LEA.L COMMAND(PC),A0 MOVE.L A0,D1 MOVE.L #' ',(A0) MOVE.L #' ',4(A0) ADDI.W #-1,D0 RESCMD_L MOVE.B (A1)+,(A0)+ DBRA D0,RESCMD_L MOVEA.L D1,A0

MOVE.L (A0)+,D1 MOVE.L (A0),D2 MOVE.L D7,-(A7) MOVEQ #1,D0 TRAP #0 DC.W 50 CMP.W #0,D7 BEQ.S RESCMD_OVER MOVEQ #0,D0 RESCMD_OVER MOVE.L (A7)+,D7 RTS SAVE_RET DC.L 0 DOCMD EQU * XDEF DOCMD LEA.L SAVE_RET(PC),A0 MOVE.L (A7)+,(A0) BSR.S RESCMD CMP.L #0,D0 BNE.S DO_CMD DO_CMD_RET MOVEA.L SAVE_RET(PC),A0 JMP (A0) DO_CMD MOVEM.L D0-D7/A0-A6,-(A7) MOVEA.L D0,A0 JSR (A0) MOVEM.L (A7)+,D0-D7/A0-A6 BRA DO_CMD_RET * * USERSC EQU * XDEF USERSC --> CALL USERSC(INT*4 ARRAY(2)) * ARRAY(1) -> D0 ARRAY(2) -> D1 RESULT IS FN VALUE * |----------------------------------| MOVEA.L 4(A7),A0 |LOAD SR FROM D1.W D0=0 | MOVE.L (A0),D0 |SW. STACKS IF SUP MODE D0=1 | MOVE.L 4(A0),D1 |SW. STACKS IF USR MODE D0=2 | SAVREG |RET. USP_TOP IN D0 D0=3 | TRAP #0 |RET. SSP_TOP IN D0 D0=4 | DC.W 1 |SET PRTSC KOLOR FROM D1 D0=5 | RSTREG |----------------------------------| FNRET1 * SYSCAL EQU * XDEF SYSCAL ;CALL SYSCAL(INT*4 ARRAY(16) * ARRAY(1)-> WHICH SYSCALL ARRAY(2..) -> D0 to D7, A0 .. A6 [A7 is SP] SAVREG MOVEA.L 4(A5),A6 LEA.L GRONK(PC),A0 MOVE.L (A6),D0 MOVE.W D0,(A0) BRA.L SYSCAL2 ;having modified Self, force? cache flush NOP SYSCAL2 EQU * MOVEM.L (A6)+,BASELIST ; load all registers except stack pointer & A6 MOVE.L A6,-(A7) ;SAVE A6 VALUE MOVE.L (A6),A6 ;LOAD A6 TRAP #0 ; do SysCall GRONK DC.W 0 MOVE.L A6,-(A7) ;SAVE A6 VALUE MOVE.L 8(A7),A6 RESTORE array address MOVE.L 4(A7),(A6)

MOVEM.L BASELIST,-(A6) ADDA.L #8,A7 RSTREG FNRET1 * * *Register SAVE area PAD1 DS.L 1 SAVEA EQU * SD0 DS.L 1 SD1 DS.L 1 SD2 DS.L 1 SD3 DS.L 1 SD4 DS.L 1 SD5 DS.L 1 SD6 DS.L 1 SD7 DS.L 1 SA0 DS.L 1 SA1 DS.L 1 SA2 DS.L 1 SA3 DS.L 1 SA4 DS.L 1 SA5 DS.L 1 SAV5ND EQU * SA6 DS.L 1 SA7 DS.L 1 SAVEND EQU * PAD2 DS.L 1 BASE DS.L 1 CMDLNADDR DS.L 1 PAD3 DS.L 1 ADRMASK DC.L $FFFFFFFE RETADR DS.L 1 ARG1ADR DS.L 1 PAD4 DS.L 1 USPSAVE DS.L 1 USPTEMP DS.L 1 SSPSAVE DS.L 1 PAD5 DS.L 1 SCRLWRD DS.L 1 Q1STORAGE DS.L 1 BARFOO DS.L 1 DS.L 1 RETPT DS.L 1 DS.L 1 FOOBAR DS.B 1 DS.B 1 DIBVOL DC.B ' ' DC.B 1 DC.B 0 DC.L 0,0 DC.W 0 DC.L 0 DC.L 0 DC.W 0,0 DC.L 0,0 DIBNAM DC.B ' ' DIBEXT DC.B ' ' DC.B 0,0,0

DC.W DC.L DC.W DC.L DC.W DC.L PADDIB DC.L * FLAGNAME DC.L DC.L COMPNAME EQU DC.L PCBINFO EQU PCB1 DC.W DC.W DC.L PCB2 DC.W DC.W DC.L PCB3 DC.W DC.W DC.L PCB4 DC.W DC.W DC.L PCB5 DC.W DC.W DC.L PCB6 DC.W DC.W DC.L PCB7 DC.W DC.W DC.L PCB8 DC.W DC.W DC.L PCB9 DC.W DC.W DC.L PCBA DC.W DC.W DC.L PCBB DC.W DC.W DC.L PCBC DC.W DC.W DC.L PCBD DC.W DC.W DC.L PCBE DC.W DC.W DC.L PCBF DC.W DC.W DC.L ENDHAK EQU ZZZZZ EQU

0 0 0 0 0 0,0 0 0 ' COMPNAME * '!!!!','!!!!' * 0 0 ' ',' ' 0 0 ' ',' ' 0 0 ' ',' ' 0 0 ' ',' ' 0 0 ' ',' ' 0 0 ' ',' ' 0 0 ' ',' ' 0 0 ' ',' ' 0 0 ' ',' ' 0 0 ' ',' ' 0 0 ' ',' ' 0 0 ' ',' ' 0 0 ' ',' ' 0 0 ' ',' ' 0 0 ' ',' ' * * '

END