BUFLEN: EQU 80; !INPUTBUFFER PROMPTER: EQU '*'; TABLEN: EQU 20; !MAX. 20 BYTE IF MC68000,0; INBUFLEN: EQU 256; OUTBUFLEN: EQU 256; ENDIF; IF MC68000,1; INBUFCTR: EQU @$556; BASE A6; VARSTART: DS.B 0; !FUER SPEICHERBEDARF ENDIF; IF MC68000,0; BASE @$400; !HIER LIEGEN DIE POINTER IM RAM INBUFFER: DS.B INBUFLEN; INBUFWR: DS.W 1; !ZEIGER AUF SCHREIBZEICHEN INBUFRD: DS.W 1; !ZEIGER AUF LESEZEICHEN INBUFCTR: DS.B 1; !ANZAHL IM PUFFER OUTBUFCTR: DS.B 1; !ZEICHENANZAHL OUTBUF: DS.B OUTBUFLEN; OUTBUFWR: DS.W 1; !SCHREIBZEIGER OUTBUFRD: DS.W 1; !LESEZEIGER XOUTBUFWR: DS.W 1; !FUER WIEDERHOLUNG DER AUSGABE XOUTBUFRD: DS.W 1; !EBENSO XOUTBUFCTR: DS.B 1; !UND ANZAHL CHECKSUM: DS.B 1; !ALLE BYTES WERDEN AUFSUMMIERT, OHNE CARRY ENDIF; REGLIST: DS.L 15; !D0-A6 SSPTR: DS.L 1; !A7 USPTR: DS.L 1; !USER A7 DS.W 1; !OBERE HAELFTE VON STATUS STATUSREG: DS.W 1; !SR PCREG: DS.L 1; BPRG: DS.L 8; !ADRESSEN DER BREAKPOINTS DS.L 8; !GERETTETE OP-CODES ALTREGLIST: DS.B BPRG-REGLIST; !ALTERNATIVER REGISTERSATZ ALS DEFAULT REGFLAG: DS.L 1; !MASKE FUER ANZUZEIGENDE REG. ALTERREGFLAG: DS.L 1; !FUR ANZEIGE VON REGISTERN BEI STEP, TRACE IF MC68000,0; INBYTE: DS.B 1; !INPUT UEBER 6551 INMASK: DS.B 1; !WENN <>0: INBYTE IST DA ENDIF; WERTETAB: DS.B TABLEN; !GESUCHTE WERTE MAX 20 MASKETAB: DS.B TABLEN; !MASKE FUER JOKER INBUF: DS.B BUFLEN; !INPUTBUFFER INPUTMODE: DS.B 1; !NORMAL ODER SCREEN DUMMY: DS.B 1; !BRAUCHT MAN IMMER REGSAVE: DS.L 1; LASTADDRESS: DS.L 1; !LETZTE ADRESSE AN DER EINE SUCHBEDINGUNG ZUTRAF MODE: DS.B 1; JOKER: DS.B 1; !JOKERZEICHEN OPTION: DS.B 1; STEPFLAG: DS.B 1; !FUER TRACE UND STEP STOP1: DS.B 1; !FUER ABBRUCH STOP2: DS.B 1; !WENN <>0, DANN STOP IM DISASS VERBOTEN, FUER ST BEGIN: DS.B 40; !POINTER FUER DISASS SOURCEADR: DS.L 1; !EFFEKTIVE QUELL-ADRESSE DESTADR: DS.L 1; !EFF. ZIEL-ADRESSE SOURCEFLAG: DS.B 1; !GESETZT, WENN SOURCEADR=GUELTIG DESTFLAG: DS.B 1; !GESETZT, WENN DESTADR=GUELTIG SHOWFLAG: DS.B 1; !GESETZT, WENN ANZEIGE SETPCFLAG: DS.B 1; !GESETZT, WENN BEI S,T,G ODER J PC-WERT = FROMAD EVENFLAG: DS.B 1; !WENN GESETZT SIND NUR GERADE ADRESSEN ERLAUBT IF MC68000,1; CONVERTFLAG: DS.B 1; KALT_STACK: DS.L 1; INITSTACK: DS.L 1; ALT_STACK: DS.L 1; RETURN_STACK: DS.L 1; RETURN_STATUS: DS.W 1; ENDIF; IF MC68000,0; ADRESSE: DS.B 1; !ADRESSE a, b, c oder d NACH RESET ADDRESSED: DS.B 1; !$80, WENN AKTIV ZWERT6850: DS.B 1; !FUER CONTROLREGISTER LEDFLAG: DS.B 1; !AKTUELLE LEDS ENDIF; EVEN; VAREND: INDEX: EQU D7; A0REG: EQU A0; ZIELAD: EQU A1; FROMAD: EQU A2; TOAD: EQU A3; A4REG: EQU A4; PTR: EQU A5; SPEICHER: EQU (FROMAD,INDEX); TOSTACK: EQU -(A7); FROMSTACK: EQU (A7)+; REGISTER: EQU D0-A6; WERTE: EQU (A0,INDEX); MASKE: EQU TABLEN(A0,INDEX); IF MC68000,0; SIZE 1; !ALLES BYTE ADRESSEN BASE @$FFFFFF00; !6522 PORTB: DS 1; !PORTB PORTA: DS 1; !PORTA DDRB: DS 1; DDRA: DS 1; T1CL: DS 1; !TIMER 1 COUNT-LOW T1CH: DS 1; !TIMER 1 COUNT-HIGH T1LL: DS 1; !TIMER 1 LATCH-LOW T1LH: DS 1; !TIMER 1 LATCH-HIGH T2CL: DS 1; !TIMER 2 COUNT+LATCH-LOW T2CH: DS 1; !TIMER 2 COUNT-HIGH SHIFT: DS 1; !SCHIEBEREGISTER ACR: DS 1; !AUXILIARY-CONTROL-REG. PCR: DS 1; !PERIPHERAL-CONTROL-REG. IFR: DS 1; !INTERRUPT-FLAG-REG. IER: DS 1; !INTERRUPT-ENABLE-REG. ORA: DS 1; !PORTA-REG. OHNE HANDSHAKE BASE @$FFFFC000; !68901 SIZE 2; !ADRESSEN OHNE BEACHTUNG VON A0 GPIP: DS 1; !DATENREGISTER FUER INPUT-OUTPUT AER: DS 1; !AKTIVE EDGE REGISTER DDR: DS 1; !DATA DIRECTION REGISTER IERA: DS 1; !INT. ENABLE REGISTER A IERB: DS 1; !INT. ENABLE REGISTER B IPRA: DS 1; !INT. PENDING REGISTER A IPRB: DS 1; !INT. PENDING REGISTER B ISRA: DS 1; !INT. IN-SERVICE REGISTER A ISRB: DS 1; !INT. IN-SERVICE REGISTER B IMRA: DS 1; !INT. MASK REGISTER A IMRB: DS 1; !INT. MASK REGISTER B VR: DS 1; !VECTOR REGISTER TACR: DS 1; !TIMER A CONTROL REGISTER TBCR: DS 1; !TIMER B CONTROL REGISTER TCDCR: DS 1; !TIMER C UND D CONTROL REGISTER TADR: DS 1; !TIMER A DATA REGISTER TBDR: DS 1; !TIMER B DATA REGISTER TCDR: DS 1; !TIMER C DATA REGISTER TDDR: DS 1; !TIMER D DATA REGISTER SCR: DS 1; !SYNC. CHARACTER REGISTER UCR: DS 1; !USART CONTROL REGISTER RSR: DS 1; !RECIEVER STATUS REGISTER TSR: DS 1; !TRANSMITTER STATUS REGISTER UDR: DS 1; !USART DATA REGISTER BASE @$FFFFFC00; DAAUS: DS.W 1; !DAWANDLER LEDS: DS.B 1; !REGISTER FUER LEUCHTDIODEN BASE @$FFFFFC80; CTRL6850: DS.B 1; !CONTROL REGISTER DATA6850: DS.B 1; !DATEN REGISTER BASE @$FFFFFE00; ADWANDLER: DS.W 1; !AD-WANDLER ALS WORTADRESSE ENDIF; !(MC68000,0) SIZE 4; !LANGWORTE BASE @$0; !ANFANG DER VEC-TABELLE VECTOR0: DS 1; !STACKPOINTER NACH RESET VECTOR1: DS 1; !HIER FAENGT ES AN VECTOR2: DS 1; !TIMEOUT BEIM ZUGRIFF VECTOR3: DS 1; !UNGERADE ADRESSE VECTOR4: DS 1; !ILLEGAL INSTRUCTION VECTOR5: DS 1; !SO IST ES VECTOR6: DS 1; !CHECKINST VECTOR7: DS 1; !TRAPOVERFL VECTOR8: DS 1; !PRIVILEGE; VECTOR9: DS 1; !TRACEVEC FUER TRACE-INSTR. VECTOR10: DS 1; !LINE1010 EMULATOR VECTOR11: DS 1; !LINE1111 EMULATOR VECTOR12: DS 1; !TRAPERR; VECTOR13: DS 1; !TRAPERR; VECTOR14: DS 1; !TRAPERR; VECTOR15: DS 1; !UNINIT; !NICHT INITIALISIERTER INTERRUPT VECTOR16: DS 1; !TRAPERR; DS 1; !TRAPERR; DS 1; !TRAPERR; DS 1; !TRAPERR; DS 1; !TRAPERR; DS 1; !TRAPERR; DS 1; !TRAPERR; DS 1; !TRAPERR; VECTOR24: DS 1; !SPURIOUS; !INTERRUPT VECTOR25: DS 1; !AUTOINT1; VECTOR26: DS 1; !AUTOINT2; VECTOR27: DS 1; !AUTOINT3; VECTOR28: DS 1; !AUTOINT4; VECTOR29: DS 1; !AUTOINT5; VECTOR30: DS 1; !AUTOINT6; VECTOR31: DS 1; !AUTOINT7; VECTOR32: DS 1; !TRAP0; VECTOR33: DS 1; !TRAP1; VECTOR34: DS 1; !TRAP2; VECTOR35: DS 1; !TRAP3; VECTOR36: DS 1; !TRAP4; VECTOR37: DS 1; !TRAP5; VECTOR38: DS 1; !TRAP6; VECTOR39: DS 1; !TRAP7; VECTOR40: DS 1; !TRAP8; VECTOR41: DS 1; !TRAP9; VECTOR42: DS 1; !TRAP10; VECTOR43: DS 1; !TRAP11; VECTOR44: DS 1; !TRAP12; VECTOR45: DS 1; !TRAP13; VECTOR46: DS 1; !TRAP14; VECTOR47: DS 1; !TRAP15; VECTOR48: DS 1; !TRAPERR; !VECTOR 48 - 63 SIND NICHT BELEGT DS 1; !TRAPERR; DS 1; !TRAPERR; DS 1; !TRAPERR; DS 1; !TRAPERR; DS 1; !TRAPERR; DS 1; !TRAPERR; DS 1; !TRAPERR; DS 1; !TRAPERR; DS 1; !TRAPERR; DS 1; !TRAPERR; DS 1; !TRAPERR; DS 1; !TRAPERR; DS 1; !TRAPERR; DS 1; !TRAPERR; DS 1; !TRAPERR; IF MC68000,0; GPI0VEC: DS 1; !VECTOR FUER IO-LEITUNG 0 GPI1VEC: DS 1; !VECTOR FUER IO-LEITUNG 1 GPI2VEC: DS 1; !VECTOR FUER IO-LEITUNG 2 GPI3VEC: DS 1; !VECTOR FUER IO-LEITUNG 3 TDVEC: DS 1; !TIMER D VECTOR TCVEC: DS 1; !TIMER C VECTOR GPI4VEC: DS 1; !VECTOR FUER IO-LEITUNG 4 GPI5VEC: DS 1; !VECTOR FUER IO-LEITUNG 5 TBVEC: DS 1; !TIMER B VECTOR TXERRVEC: DS 1; !TRANSMITTER ERROR TXEMTYVEC: DS 1; !TX-BUFFER EMTY RXERRVEC: DS 1; !RX ERROR RXFULLVEC: DS 1; !RX-BUFFER FULL TAVEC: DS 1; !TIMER A VECTOR GPI6VEC: DS 1; !VECTOR FUER IO-LEITUNG 6 GPI7VEC: DS 1; !VECTOR FUER IO-LEITUNG 7 HOECHSTE PRIORITAET !!! ENDIF; DEFSTAT: EQU #$2000; !DEFAULTWERT FUER STATUS IF MC68000,1; DEFPC: EQU #$20000; ! INITSTACK: EQU #$3F0; ORG $20000; MONSTART: BRA.W GANZ_KALT; ENDIF; IF MC68000,0; USERSTACK: EQU #$FF0; !DEFAULT FUER SSPTR INITSTACK: EQU #$3F0; DEFPC: EQU #$1000; ORG $8000; !ANFANG DES ROM IM OBEREN STECKPLATZ MONSTART: DC #INITSTACK; !WERT FUER SSP DC #KALTSTART; !WERT FUER PC ENDIF; !SPRUENGE AUF IO-ROUTINEN XINCH: JMP INCH; XOUTCH: JMP OUTCH; XPDATA: JMP PDATA; XPCRLF: JMP PCRLF; XWARM: JMP WARM0; !WARMSTART XKALT: JMP KALTSTART; IF MC68000,1; VARIABLE: DS.B VAREND-VARSTART; ENDIF; IF MC68000,0; IF M6850,0; !VERSIONSABHAENGIG RECIEVE: MOVE.B UDR,INBYTE; !BYTE LESEN CMPI.B 3,INBYTE; !CONTROL C ? BEQ.W ABBRUCH; CMPI.B 2,INBYTE; !ODER CONTROL B? BEQ.W ABBRUCH; TAS INMASK; !GUELTIG SETZEN RTE; ENDIF; IF M6850,1; !FUER 6850 RECIEVE: TST.B CTRL6850; !INTERRUPT VOM 6850 ? BPL.W RECIEVEX; !NEIN BTST 0,CTRL6850; !BYTE EMPFANGEN ? BEQ.W TXINT; !NEIN MOVEM.L D0/A0,-(A7); REPEAT: MOVE.B DATA6850,D0; !BYTE LESEN CMPI.B $61,D0; !TESTEN, OB ADRESSE BCS.S RECIEVE1; !NEIN CMPI.B $65,D0; !ADRESSE NUR VON $61-$64 BCC.S RECIEVE1; CMP.B ADRESSE,D0; !MEINE ADRESSE ? BNE.S RECIEVE3; !NEIN TAS ADDRESSED; !ICH BIN ADRESSIERT BSR.W OUTCH; !ADRESSE ALS ECHO AUSGEBEN ! CLR INBUFWR; !PUFFER ERST MAL LOESCHEN ! CLR INBUFRD; ! CLR INBUFCTR; CLR OUTBUFWR; CLR OUTBUFRD; CLR OUTBUFCTR; BRA.S RECIEVEX1; !DAS WAR ALLES RECIEVE3: CLR ADDRESSED; !ADRESSIERUNG LOESCHEN MOVE ZWERT6850,D0; ANDI.B $9F,D0; MOVE.B D0,ZWERT6850; MOVE.B D0,CTRL6850; !EVENTUELLEN TX-INT SPERREN BRA.S RECIEVEX1; !UND FERTIG RECIEVE1: TST.B ADDRESSED; !INPUT ERLAUBT ? BEQ.S RECIEVEX1; !NEIN MOVE.B D0,INBYTE; !OHNE PUFFER CMPI.B 3,D0; BEQ.W ABBRUCH; CMPI.B 2,D0; BEQ.W ABBRUCH; TAS.B INMASK; !IST GUELTIG LEA.L INBUFFER,A0; !IN PUFFER ABLEGEN ADDA.W INBUFWR,A0; !SCHREIBZEIGER ADDIEREN MOVE.B D0,(A0); !ABLEGEN ADDQ.B 1,INBUFCTR; !ANZAHL +1 ADDQ.B 1,INBUFWR+1; !NUR UNTERES BYTE BTST 0,CTRL6850; !WEITERES BYTE IM INPUT-REG ? BNE.W REPEAT; !DANN LESEN RECIEVEX1: MOVEM.L (A7)+,D0/A0; RECIEVEX: RTE; TXINT: BTST 5,ZWERT6850; !INTERRUPT VON TX ERLAUBT ? BEQ.S TXEND; !NEIN BTST 1,CTRL6850; !TX LEER ? BEQ.S TXEND; !IST NICHT LEER MOVEM.L D0-D1/A0,-(A7); TST OUTBUFCTR; !BEI FEHLER BEQ.S TXINT1; !INTERRUPT SPERREN LEA.L OUTBUF,A0; !BASIS MOVE.W OUTBUFRD,D1; !INDEX MOVE.B (A0,D1.W),D0; !BYTE HOLEN MOVE.B D0,DATA6850; !BYTE AUSGEBEN ADD.B D0,CHECKSUM; !QUERSUMME BILDEN ADDQ.W 1,D1; ANDI.W OUTBUFLEN-1,D1; MOVE D1,OUTBUFRD; !LESEZEIGER +1 SUBQ 1,OUTBUFCTR; !ANZAHL -1 BNE.S TXEND0; !ES KOMMEN NOCH MEHR ZEICHEN TXINT1: BCLR 5,ZWERT6850; MOVE ZWERT6850,CTRL6850;!INT SPERREN TXEND0: MOVEM.L (A7)+,D0-D1/A0; TXEND: RTE; ENDIF; ABBRUCH: MOVEM.L (A7)+,D0/A0; !REGISTER ZURUECK CLR INBUFWR; CLR INBUFRD; CLR INBUFCTR; BSR.W CLROUTBUF; !ZUR SICHERHEIT MOVE.B $7F,IER; !ALLE 6522 INTERRUPTS SPERREN PEA.L RECIEVE; !VECTOR RESTAURIEREN MOVE.L (A7)+,VECTOR26; BRA.W ABORT; TRAP0: MOVE.W (A7)+,SR; !STATUS ZUREUCK TST INBUFCTR; !TESTEN, OB ZEICHEN IM PUFFER RTS; TRAP1: BSR.S INCH; !ZEICHEN AUS PUFFER LESEN RTE; TRAP2: MOVE.W (A7)+,SR; TST INMASK; !TESTEN, OB ZEICHEN EINGETROFFEN RTS; TRAP3: TST INMASK; !ZEICHEN DIREKT LESEN BEQ.S TRAP3; MOVE INBYTE,D0; TRAP4: CLR INBYTE; !FLAG NUR LOESCHEN RTE; INCH: MOVE.L A0,-(A7); LEA.L INBUFFER,A0; ADDA.W INBUFRD,A0; !LESEZEIGER ADDIEREN INCH1: TST INBUFCTR; !GESETZT ? BEQ.S INCH1; !NOCH NICHT MOVE.B (A0),D0; !LESEN SUBQ 1,INBUFCTR; ADDQ.B 1,INBUFRD+1; !NUR UNTERES BYTE GEHT SCHNELL !!! MOVE.L (A7)+,A0; RTS; TRAP15: MOVE.W (A7)+,SR; !STAUS ZURUECK !UND MIT OUTCH WEITERMACHEN IF M6850,0; OUTCH: BTST.B 7,TSR; !PUFFER LEER ? BEQ.S OUTCH; !NOCH NICHT MOVE.B D0,UDR; !BYTE AUSGEBEN RTS; ENDIF; IF M6850,1; OUTCH: TST.B ADDRESSED; !ADRESSIERT ? BEQ.S OUTCHX; !NEIN BTST.B 1,CTRL6850; !TX READY ? BEQ.S OUTCH; !NEIN, WARTEN MOVE.B D0,DATA6850; OUTCHX: RTS; ENDIF; TRAP5: MOVE.W (A7)+,SR; !STATUS ZURUECK CLR.W D1; MOVE OUTBUFCTR,D1; !ANZAHL NACH D1 MOVE.B CHECKSUM,D0; CMPI OUTBUFLEN-1,OUTBUFCTR; !EQ, WENN PUFFER = VOLL RTS; TRAP6: MOVE.W (A7)+,SR; !STATUS ZUREUCK POUTCH: CMPI OUTBUFLEN-1,OUTBUFCTR; !VOLL ? BEQ.S POUTCH; !DANN WARTEN: KANN HAENGEN BLEIBEN!!! MOVEM.L D1/A0,-(A7); LEA.L OUTBUF,A0; !BASIS MOVE.W OUTBUFWR,D1; !INDEX MOVE.B D0,(A0,D1.W); !ZEICHEN ABLEGEN ADDQ.W 1,D1; ANDI.W OUTBUFLEN-1,D1; !MASKIEREN MOVE.W D1,OUTBUFWR; !SCHREIBZEIGER ABLEGEN ADDQ 1,OUTBUFCTR; !ANZAHL+1 MOVEM.L (A7)+,D1/A0; RTS; TRAP7: MOVE.W (A7)+,SR; !STATUS ZUREUCK TRIGGERPOUT: TST OUTBUFCTR; !TESTEN, OB ZEICHEN IM PUFFER BEQ.S TRIGPOUTEND; !NEIN, DANN IGNORIEREN BTST 5,ZWERT6850; !AUSGABE SCHON AKTIV ? BNE.S TRIGPOUTEND; !DANN NICHT NACHTRIGGERN !!! CLR CHECKSUM; !QUERSUMME LOESCHEN MOVE OUTBUFCTR,XOUTBUFCTR; !FUER WIEDERHOLUNG RETTEN MOVE OUTBUFWR,XOUTBUFWR; MOVE OUTBUFRD,XOUTBUFRD; BSET.B 5,ZWERT6850; !INTERRUPT ZULASSEN MOVE ZWERT6850,CTRL6850;!NUN GEHTS LOS TRIGPOUTEND: RTS; !DAS WARS TRAP8: MOVE.W (A7)+,SR; !STATUS ZUREUCK CLROUTBUF: CLR OUTBUFCTR; CLR OUTBUFRD; CLR OUTBUFWR; ANDI.B $9F,ZWERT6850; MOVE ZWERT6850,CTRL6850; !INT SPERREN ! RTS; TRAP9: MOVE.W (A7)+,SR; RESTOREPOUT: TST XOUTBUFCTR; !TESTEN, OB BELEGT BEQ.S RESTOREEND; !IST LEER BTST 5,ZWERT6850; !AUSGABE NOCH AKTIV ? BNE.S RESTOREEND; !DANN NICHT RESTAURIEREN ! MOVE XOUTBUFCTR,OUTBUFCTR; !ALTE POINTER ZURUECK MOVE XOUTBUFWR,OUTBUFWR; MOVE XOUTBUFRD,OUTBUFRD; RESTOREEND: RTS; IF M6850,0; INIT68901: MOVE.B 1,TCDCR; !TIMER D VORTEILER / 4 MOVE.B #1,TDDR; !TIMER D ERZEUGT 2,4576/8 MHz MOVE.B #$88,UCR; !19200, 8 X DATEN, 1 X START, 1 X STOP BSET.B 0,TSR; !SENDEN ERLAUBEN BSET.B 0,RSR; !EMPFANG ERLAUBEN TST.B UDR; !DUMMY LESEN BSET.B 4,IERA; !INTERRUPT BEI EMPFANG BSET.B 4,IMRA; CLR.B INBYTE; CLR.B INMASK; RTS; ENDIF; IF M6850,1; INIT6850: MOVE.B 3,CTRL6850; !RESET MOVE.B #$94,ZWERT6850; MOVE.B ZWERT6850,CTRL6850; !TAKT/16, 8-BIT, 1XSTOP, RXINT CLR ADDRESSED; CLR INBYTE; CLR INMASK; CLR INBUFRD; CLR INBUFWR; CLR INBUFCTR; CLR OUTBUFWR; CLR OUTBUFRD; CLR OUTBUFCTR; CLR XOUTBUFWR; CLR XOUTBUFRD; CLR XOUTBUFCTR; CLR CHECKSUM; RTS; ENDIF; KALTSTART: MOVE.W #$2700,SR; !INTERRUPTS SPERREN BSR.W SETVECTORS; IF M6850,1; PEA.L RECIEVE; MOVE.L (A7)+,VECTOR26; !AUTOINTVECTOR 2 BSR.W INIT6850; ENDIF; MOVE.B #$FF,LEDFLAG; MOVE.B PORTA,D0; ROL.B 2,D0; ANDI.B 3,D0; !ADRESSE ERMITTELN BCLR.B D0,LEDFLAG; !LED EINSCHALTEN MOVE.B LEDFLAG,LEDS; ADDI.B $61,D0; !ADRESSE ALS BUCHSTABE MOVE.B D0,ADRESSE; IF M6850,0; LEA.L UNINITVEC,A0; !VECTOREN FUER 68901 SETZEN LEA.L GPI0VEC,A1; !ANFANG DER VECTOREN MOVE.L A1,D0; !ANFANG DER TABELLE NACH 68901 VR ROR.W 2,D0; !DIVISION / 4 MOVE.B D0,VR; !WENN VETOREN AB $100 -> $40 MOVQ 15,D0; !16 VECTOREN LOESCHEN SET68901VEC: MOVE.L A0,(A1)+; DBF D0,SET68901VEC; PEA.L RECIEVE; MOVE.L (A7)+,RXFULLVEC; !EMPFANG UEBER INTERRUPT BSR.W INIT68901; !RX UND TX INITIALISIEREN ENDIF; MOVE.W DEFSTAT,SR; !ALLES ERLAUBEN AUTOTEST: MOVE.L #$55AA55AA,D0; !TESTMUSTR LADEN MOVEA.L #$2000,A0; !1.TEST CMP.L (A0),D0; !TEST BEI $2000 BNE.S AUTOTEST1; !KEIN AUTOSTART BEI $2004 JMP 4(A0); !ROM ANSPRINGEN AUTOTEST1: ADDA.L A0,A0; !2.TEST CMP.L (A0),D0; !TEST BEI $4000 BNE.S AUTOTEST2; JMP 4(A0); !WENN MUSTER VORHANDEN AUTOTEST2: MOVEA.L #$6000,A0; !3.TEST CMP.L (A0),D0; !TEST BEI $6000 BNE.W KEINAUTO; JMP 4(A0); !WENN MUSTER VORHANDEN SETVECTORS: LEA.L TRAPERR,A0; !DEFAULT MOVE.W SR,-(A7); !STATUS RETTEN MOVE.W #$2700,SR; !INTERUPT VERBIETEN MOVEQ 63,D1; !DIE UNTEREN 64 VECTOREN SUB.L A1,A1; !LOESCHEN SETVEC1: MOVE.L A0,(A1)+; DBF D1,SETVEC1; PEA.L BUSERR; MOVE.L (A7)+,VECTOR2; PEA.L ADRERR; MOVE.L (A7)+,VECTOR3; PEA.L ILLINST; MOVE.L (A7)+,VECTOR4; PEA.L ZERODIVIDE; MOVE.L (A7)+,VECTOR5; PEA.L CHECKINST; MOVE.L (A7)+,VECTOR6; PEA.L TRAPOVERFL; MOVE.L (A7)+,VECTOR7; PEA.L PRIVILEGE; MOVE.L (A7)+,VECTOR8; PEA.L TRACEVEC; MOVE.L (A7)+,VECTOR9; PEA.L LINE1010; MOVE.L (A7)+,VECTOR10; PEA.L LINE1111; MOVE.L (A7)+,VECTOR11; PEA.L SPURIOUSINT; MOVE.L (A7)+,VECTOR24; PEA.L AUTOINT2; MOVE.L (A7)+,VECTOR26; PEA.L AUTOINT7; MOVE.L (A7)+,VECTOR31; PEA.L TRAP0; MOVE.L (A7)+,VECTOR32; PEA.L TRAP1; MOVE.L (A7)+,VECTOR33; PEA.L TRAP2; MOVE.L (A7)+,VECTOR34; PEA.L TRAP3; MOVE.L (A7)+,VECTOR35; PEA.L TRAP4; MOVE.L (A7)+,VECTOR36; PEA.L TRAP5; MOVE.L (A7)+,VECTOR37; PEA.L TRAP6; MOVE.L (A7)+,VECTOR38; PEA.L TRAP7; MOVE.L (A7)+,VECTOR39; PEA.L TRAP8; MOVE.L (A7)+,VECTOR40; PEA.L TRAP9; MOVE.L (A7)+,VECTOR41; PEA.L TRAP13; MOVE.L (A7)+,VECTOR45; PEA.L TRAP14; MOVE.L (A7)+,VECTOR46; PEA.L TRAP15; MOVE.L (A7)+,VECTOR47; RTE; !STATUS ZURUECK ENDIF; ! MC68000,0 IF MC68000,1; BASE A7; RRR: DS.L 15; S_R: DS.W 1; !FUER (A7) ADRESSIERUNG GANZ_KALT: MOVEM.L D0-A6,-(A7); !ALLES RETTEN LEA.L VARIABLE,A6; MOVE.W SR,RETURN_STATUS; MOVE.L A7,RETURN_STACK; LEA.L GK0,A0; MOVEA.L @$80,A1; MOVE.L A0,@$80; TRAP 0; GK0: MOVE.L A1,@$80; ADDQ.L 6,A7; MOVE.W #$2700,SR; !SS-MODE KEIN INTERRUPT TRAP 1; MOVE.L $3A(A0),-(A7); MOVE.L $3E(A0),-(A7); PEA.L BLOCKENDE; MOVE.L (A7)+,$3A(A0); !AB HIER FREIES RAM FUER DOSSUB !!! MOVE.L $3E(A0),D0; ANDI.L -2,D0; SUBA.L A1,A1; MOVEQ 63,D1; !ALLE POINTER RETTEN GK1: MOVE.L (A1)+,-(A7); DBF D1,GK1; ! LEA.L VARIABLE,A6; MOVE.L A7,ALT_STACK; !RETTEN FUER RTS MOVEA.L D0,A7; !NEUER STACK SUBA.L 100,A7; MOVE.L A7,INITSTACK; MOVE.L A7,D0; SUB.L $1000,D0; MOVE.L D0,KALT_STACK; SUB.L $4001,D0; MOVE.L D0,$3E(A0); !RAM-ENDE IST UNGERADE KALTSTART: MOVE.W #$2700,SR; !INTERRUPTS SPERREN LEA.L VARIABLE,A6; BSR.W SETVECTORS; MOVE.W DEFSTAT,SR; BRA.W KEINAUTO; QUIT: BSR.W PCRLF; LEA.L VARIABLE,A6; MOVEA.L ALT_STACK,A7; !POINTER RESTAURIEREN MOVEA.W #$100,A1; MOVEQ 63,D0; QUIT1: MOVE.L (A7)+,-(A1); DBF D0,QUIT1; TRAP 1; MOVE.L (A7)+,$3E(A0); MOVE.L (A7)+,$3A(A0); !ALTER RAM-BEREICH MOVE.W RETURN_STATUS,SR; MOVEA.L RETURN_STACK,A7; !ALTER STATUS MOVEM.L (A7)+,D0-A6; RTS; !STACK KORRIGIEREN FMSSUB: MOVEM.L A0-A2,-(A7); BSR PCRLF; TRAP 1; MOVEA.L $42(A0),A1; MOVE.L (A1),-(A7); !ALTEN POINTER RETTEN LEA.L 1(PTR),A2; MOVE.L A2,(A1); MOVEM.L D0-A6,-(A7); JSR $32(A0); !DOSSUB AUFRUFEN MOVEM.L (A7)+,D0-A6; MOVE.L (A1),PTR; !SOLLTE AUF DAS ENDE DER ZEILE ZEIGEN SUBQ.L 1,PTR; MOVE.L (A7)+,(A1); !ALTER WERT MOVEM.L (A7)+,A0-A2; BRA.W MONX0; SETVECTORS: LEA.L TRAPERR,A0; !DEFAULT MOVE.W SR,-(A7); !STATUS RETTEN MOVE.W #$2700,SR; !INTERUPT VERBIETEN MOVE.L @$6C,-(A7); MOVE.L @$70,-(A7); MOVE.L @$78,-(A7); MOVE.L @$80,-(A7); MOVE.L @$84,-(A7); MOVE.L @$88,-(A7); MOVEQ 63,D1; !DIE UNTEREN 64 VECTOREN SUB.L A1,A1; !LOESCHEN SETVEC1: MOVE.L A0,(A1)+; DBF D1,SETVEC1; PEA.L BUSERR; MOVE.L (A7)+,VECTOR2; PEA.L ADRERR; MOVE.L (A7)+,VECTOR3; PEA.L ILLINST; MOVE.L (A7)+,VECTOR4; PEA.L ZERODIVIDE; MOVE.L (A7)+,VECTOR5; PEA.L CHECKINST; MOVE.L (A7)+,VECTOR6; PEA.L TRAPOVERFL; MOVE.L (A7)+,VECTOR7; PEA.L PRIVILEGE; MOVE.L (A7)+,VECTOR8; PEA.L TRACEVEC; MOVE.L (A7)+,VECTOR9; PEA.L LINE1010; MOVE.L (A7)+,VECTOR10; PEA.L LINE1111; MOVE.L (A7)+,VECTOR11; PEA.L SPURIOUSINT; MOVE.L (A7)+,VECTOR24; PEA.L TRAP13; MOVE.L (A7)+,VECTOR45; PEA.L TRAP14; MOVE.L (A7)+,VECTOR46; MOVE.L (A7)+,@$88; MOVE.L (A7)+,@$84; MOVE.L (A7)+,@$80; MOVE.L (A7)+,@$78; MOVE.L (A7)+,@$70; MOVE.L (A7)+,@$6C; RTE; !STATUS ZURUECK INCH: MOVE.L A0,-(A7); TRAP 1; JSR 2(A0); MOVEA.L (A7)+,A0; RTS; OUTCH: MOVE.L A0,-(A7); TRAP 1; JSR 8(A0); MOVEA.L (A7)+,A0; RTS; ENDIF; OUTREGDIS: MOVEM.L D0-A6,-(A7); !ZUR ANZEIGE DER REGISTR BEI TRACE MOVE.L ALTERREGFLAG,D7; !ALTERNATIVE MASKE BTST 15,D7; !STACK ANZEIGEN ? BEQ.S OUTREGY; !NEIN BTST.B 5,STATUSREG; !SS ODER US ? BNE.S OUTREGY; !SS IST ES BCLR 15,D7; !US, DANN SS LOESCHEN BSET 16,D7; !UND US SETZEN BRA.S OUTREGY; !UND AUSGEBEN OUTREGX: BSR PCRLF; !FUER 'R' OUTREG: MOVEM.L D0-A6,-(A7); !ALLES RETTEN MOVE.L REGFLAG,D7; !AUSGABEMASKE OUTREGY: LEA.L REGLIST,A0; !DA STEHEN DIE WERTE LEA.L REGTAB,A1; !DA STEHT DER TEXT OUTREG0: MOVEQ 0,D5; !ANZAHL IN ZEILE MOVEQ 0,D6; !BITPOINTER AUF REGFLAG OUTREG1: MOVE.L (A0)+,D2; !WERT IN D2 MOVE.W (A1)+,D0; !REG.-NAME BTST.L D6,D7; !ANZEIGEN ? BEQ.S OUTREG2; !NEIN BSR.S OUTREG5; !NAMEN AUSGEBEN MOVE.L D2,D0; !WERTE NACH D0 BSR.W PRINTL; !AUSGEBEN ADDQ.B 1,D5; CMPI.B 4,D5; !ENDE DER ZEILE ? BEQ.S OUTREG3; !JA MOVEQ 4,D1; BSR.W PBLANK; !4 BLANKS BRA.S OUTREG2; !WEITER OUTREG3: MOVEQ 0,D5; !LOESCHEN BSR.W PCRLF; !NAECHSTE ZEILE OUTREG2: ADDQ.B 1,D6; !NAECHSTES REGISTER CMPI.B 19,D6; !FERTIG ? BNE.S OUTREG1; !NEIN MOVEM.L (A7)+,D0-A6; RTS; OUTREG5: BSR.W XOUTCH; !1.BUCHSTABE DES NAMENS LSR.W 8,D0; BSR.W XOUTCH; !2.BUCHSTABE MOVEQ 1,D1; BSR.W PBLANK; !1 BLANK MOVEQ '=',D0; BSR.W XOUTCH; MOVEQ 1,D1; BSR.W PBLANK; RTS; !FERTIG REGTAB: DC '0D1D2D3D4D5D6D7D'; !NAMEN DER REGISTER VERDREHT FUER AUSG. DC '0A1A2A3A4A5A6ASS'; DC 'SURSCP'; BPTAB: DC '0B1B2B3B4B5B6B7B'; !NAMEN DER BREAKPOINTS ERRORBUS: DC 'BUS ERROR';DC.B 4; ERRORAD: DC 'ADDRESS ERROR';DC.B 4; ERRORILL: DC 'ILLEGAL INSTRUCTION';DC.B 4; ERRORZERO: DC 'ZERO DIVISIO';DC.B 4; ERRORCHK: DC 'CHK OUT OF RANGE';DC.B 4; ERROROVER: DC 'TRAPV';DC.B 4; ERRORPRI: DC 'PRIVILEGE VIOLATION';DC.B 4; ERROR1010: DC 'EMULATOR 1010';DC.B 4; ERROR1111: DC 'EMULATOR 1111';DC.B 4; UNINITMSG: DC 'UNINITIALIZED INTERRUPT VECTOR';DC.B 4; SPURIOUS: DC 'SPURIOUS INTERRUPT';DC.B 4; INT2MSG: DC 'AUTOINT 2 REACHED';DC.B 4; INT7MSG: DC 'AUTOINT 7 REACHED';DC.B 4; ERRORTRAP: DC 'TRAP ERROR';DC.B 4; ERRORPC: DC ' AT ';DC.B 4; MESSACT: DC 'ANZAHL DER AKTIVEN BREAKPOINTS = ';DC.B 4; TEXTBP: DC 'BREAKPOINT ERREICHT: PC = ';DC.B 4; EVEN; ILLINST: MOVE.L A5,-(A7); LEA.L ERRORILL,A5; BRA.W TRAPALL; ZERODIVIDE: MOVE.L A5,-(A7); LEA.L ERRORZERO,A5; BRA.W TRAPALL; CHECKINST: MOVE.L A5,-(A7); LEA.L ERRORCHK,A5; BRA.W TRAPALL; TRAPOVERFL: MOVE.L A5,-(A7); LEA.L ERROROVER,A5; BRA.W TRAPALL; PRIVILEGE: MOVE.L A5,-(A7); LEA.L ERRORPRI,A5; BRA.W TRAPALL; LINE1010: MOVE.L A5,-(A7); LEA.L ERROR1010,A5; BRA.W TRAPALL; LINE1111: MOVE.L A5,-(A7); LEA.L ERROR1111,A5; BRA.W TRAPALL; SPURIOUSINT: MOVE.L A5,-(A7); LEA.L SPURIOUS,A5; BRA.W TRAPALL; IF MC68000,0; AUTOINT2: MOVE.L A5,-(A7); LEA.L INT2MSG,A5; BRA.W TRAPALL; AUTOINT7: MOVE.L A5,-(A7); LEA.L INT7MSG,A5; BRA.W TRAPALL; ENDIF; UNINITVEC: MOVE.L A5,-(A7); LEA.L UNINITMSG,A5; BRA.W TRAPALL; TRAPERR: UNINIT: AUTOINT1: AUTOINT3: AUTOINT4: AUTOINT6: ABORT: MOVE.L A5,-(A7); !REG. RETTEN LEA.L ERRORTRAP,A5; !ZEIGER AUF TEXT TRAPALL: BSR.W PCRLF; BSR.W PDATA; !FEHLERMELDUNG AUSGEBEN MOVE.W DEFSTAT,SR; !INIT MOVE.L (A7)+,A5; !ZURUECK IF MC68000,1; MOVE.L A6,-(A7); LEA.L VARIABLE,A6; MOVEM.L D0-A5,(A6); MOVE.L (A7)+,14*4(REGLIST); ENDIF; IF MC68000,0; MOVEM.L D0-A6,REGLIST; !UND ALLES RETTEN ENDIF; TRAPALL1: BSR.W PCRLF; MOVE.L USP,A0; MOVE.L A0,USPTR; MOVE.W (A7)+,STATUSREG; MOVE.L (A7)+,PCREG; MOVE.L A7,SSPTR; BSR.W OUTREG; !REGISTER ANZEIGEN BRA.W KALT1; BUSERR: IF MC68000,1; MOVE.L A6,-(A7); LEA.L VARIABLE,A6; MOVEM.L D0-A5,(A6); MOVE.L (A7)+,14*4(REGLIST); ENDIF; IF MC68000,0; MOVEM.L D0-A6,REGLIST; !UND ALLES RETTEN ENDIF; LEA.L ERRORBUS,A5; !FEHLERMELDUNG BUSERR1: MOVE.W DEFSTAT,SR; BSR.W PCRLF; BSR.W PDATA; !AUSGEBEN LEA.L ERRORPC,A5; !AT PC BSR.W PDATA; MOVE.L 2(A7),D0; !PC BSR.W PRINTL; !PC WERT ANZEIGEN MOVEQ 4,D1; BSR.W PBLANK; !BLANKS MOVE.W (A7),D0; !FUNKTIONS-WORT BSR.W PRINTW; !ANZEIGEN MOVEQ 2,D1; BSR.W PBLANK; MOVE.W 6(A7),D0; !UND INSTRUCTION BSR.W PRINTW; !ANZEIGEN ADDQ.L 8,A7; !KORRIGIEREN BRA.W TRAPALL1; !REGISTER RETTEN UND ANZEIGEN ADRERR: IF MC68000,1; MOVE.L A6,-(A7); LEA.L VARIABLE,A6; MOVEM.L D0-A5,(A6); MOVE.L (A7)+,14*4(REGLIST); ENDIF; IF MC68000,0; MOVEM.L D0-A6,REGLIST; !UND ALLES RETTEN ENDIF; LEA.L ERRORAD,A5; BRA.S BUSERR1; PDATA: MOVE.L D0,-(A7); PDATA2: MOVE.B (A5)+,D0; CMPI.B 4,D0; BEQ.S PDATA1; BSR XOUTCH; BRA.S PDATA2; PDATA1: MOVE.L (A7)+,D0; RTS; CLRREGLIST: MOVE.W REGFLAG-REGLIST-1,D0; !LOESCHT REGISTER + BP LEA.L REGLIST,A0; CLRREG1: CLR.B (A0)+; DBF D0,CLRREG1; RTS; BLANKWEG1: ADDQ 1,PTR; BLANKWEG: MOVE.B (PTR)+,D0; CMPI.B ' ',D0; BEQ.B BLANKWEG; SUBQ.L 1,PTR; RTS; ASTOHEX: CMPI.B '0',D0; BLT.B ASTERR; CMPI.B ':',D0; BLT.B ASTO1; CMPI.B 'A',D0; BLT.B ASTERR; CMPI.B 'F',D0; BLE.B ASTO0; SUBI.B ' ',D0; !FUER KLEINE SCHRIFT CMPI.B 'A',D0; BLT.S ASTERR; CMPI.B 'F',D0; BGT.S ASTERR; ASTO0: SUBQ.B #7,D0; ASTO1: ANDI.L $F,D0; ORI.B 4,CCR; ASTERR: RTS; !Z=1 WENN OK WERTHOLEN: MOVEM.L D1-D2,TOSTACK; MOVEQ 0,D0; MOVEQ 0,D1; MOVEQ 1,D2; BSR.B BLANKWEG; MOVE.B (PTR)+,D0; CMPI.B '#',D0; BEQ.S READBCD; BNE.S READHEX1; READHEX0: MOVE.B (PTR)+,D0; READHEX1: BSR.B ASTOHEX; BNE.B HEXEND; MOVEQ 0,D2; ASL.L 4,D1; OR.B D0,D1; BRA.B READHEX0; HEXEND: SUBQ 1,PTR; MOVE.L D1,D0; TST.B D2; !Z=1 WENN ZAHL GELESEN,Z=0 KEINE ZAHL MOVEM.L FROMSTACK,D1-D2; RTS; READBCD: MOVE.B (PTR)+,D0; SUBI.B '0',D0; BMI.S HEXEND; !ZEICHEN ZU KLEIN CMPI.B 9,D0; BGT.S HEXEND; !ODER ZU GROSS MOVE.L D1,D2; !RETTEN ASL.L 3,D1; !*8 ADD.L D2,D1; ADD.L D2,D1; !UND MAL 10 ADD.L D0,D1; !WERT IN D1 MOVEQ 0,D2; !ZAHL ERKANNT BRA.S READBCD; !WEITER LESEN !GRUNDRECHENARTEN VON OS-9 math.l !DIE DIVISION IST SCHOEN UND SCHNELL !!! MULSL: MOVEM.L D2-D5,-(A7); MOVEQ.L 0,D5; TST.L D0; BPL.B L20032; MOVEQ.L 8,D5; NEG.L D0; L20032: TST.L D1; BPL.B L2003C; BCHG.L 3,D5; NEG.L D1; L2003C: BSR.B US_MULTIPLY; TST.L D5; BNE.B L20048; TST.L D0; BMI.B L20056; BRA.B L20052; L20048: NEG.L D0; BRA.B L20052; MULUL: MOVEM.L D2-D5,-(A7); BSR.B US_MULTIPLY; L20052: TST.L D1; BEQ.B L20062; L20056: TST.L D0; ORI.B 2,CCR; MOVEM.L (A7)+,D2-D5; RTS; L20062: TST.L D0; MOVEM.L (A7)+,D2-D5; RTS; US_MULTIPLY: MOVE.L D0,D2; MOVE.L D0,D3; SWAP.W D3; MOVE.L D1,D4; SWAP.W D4; MULU.W D1,D0; MULU.W D3,D1; MULU.W D4,D2; !32 BIT ERGEBNIS WUERDE REICHEN MULU.W D4,D3; SWAP.W D0; ADD.W D1,D0; CLR.L D4; ADDX.L D4,D3; ADD.W D2,D0; ADDX.L D4,D3; SWAP.W D0; CLR.W D1; SWAP.W D1; CLR.W D2; SWAP.W D2; ADD.L D2,D1; ADD.L D3,D1; RTS; DIVUL: MOVEM.L D3-D5,-(A7); TST.L D1; BNE.B L200AE; MOVEQ.L 0,D0; NOT.L D0; MOVE.W #2,CCR; MOVEM.L (A7)+,D3-D5; RTS; L200AE: BSR.B US_DIVIDE; TST.L D0; MOVEM.L (A7)+,D3-D5; RTS; DIVSL: MOVEM.L D3-D5,-(A7); TST.L D1; BNE.B L200D8; MOVE.L #$7FFFFFFF,D1; TST.L D0; BPL.B L200CC; NOT.L D1; L200CC: MOVE.L D1,D0; MOVE.W #2,CCR; MOVEM.L (A7)+,D3-D5; RTS; L200D8: BPL.B L200E8; NEG.L D1; BSR.B L200F2; NEG.L D0; TST.L D0; MOVEM.L (A7)+,D3-D5; RTS; L200E8: BSR.B L200F2; TST.L D0; MOVEM.L (A7)+,D3-D5; RTS; L200F2: TST.L D0; BPL.B US_DIVIDE; NEG.L D0; BSR.B US_DIVIDE; NEG.L D0; NEG.L D1; RTS; US_DIVIDE: MOVE.L D1,D3; SUBQ.L 1,D3; BEQ.B L20126; MOVE.L D3,D4; AND.L D1,D4; BNE.B L20120; LSR.L 1,D1; MOVEQ.L -1,D4; L20110: LSR.L 1,D1; DBCS.W D4,L20110; NEG.L D4; MOVE.L D0,D1; LSR.L D4,D0; AND.L D3,D1; RTS; L20120: CMP.L D0,D1; BNE.B L2012A; MOVEQ.L 1,D0; L20126: MOVEQ.L 0,D1; RTS; L2012A: BCS.B L20132; MOVE.L D0,D1; MOVEQ.L 0,D0; RTS; L20132: CMPI.L #$10000,D1; BCS.B L20178; MOVE.L D1,D3; CLR.W D3; SWAP.W D3; ADDQ.L 1,D3; MOVE.L D0,D4; MOVE.L D1,D5; MOVE.L D3,D1; BSR.B L20178; MOVE.L D5,D1; DIVU.W D3,D1; DIVU.W D1,D0; ANDI.L #$FFFF,D0; L20156: MOVE.L D5,D1; MOVE.L D5,D3; SWAP.W D3; MULU.W D0,D1; TST.W D3; BEQ.S L2015X; !ERGIBT SOWIESO 0 MULU.W D0,D3; SWAP.W D3; ADD.L D3,D1; L2015X: SUB.L D4,D1; BHI.B L20172; NEG.L D1; CMP.L D1,D5; BHI.B L20176; ADDQ.L 1,D0; BRA.B L20156; L20172: SUBQ.L 1,D0; BRA.B L20156; L20176: RTS; L20178: DIVU D1,D0; !VERSUCHEN BVS.S L2017X; !WENN NICHT GEKLAPPT MOVEQ 0,D1; SWAP D0; MOVE.W D0,D1; CLR.W D0; SWAP D0; RTS; L2017X: MOVEM.W D0/D3,-(A7); CLR.W D0; SWAP.W D0; DIVU.W D1,D0; MOVE.W D0,D3; MOVE.W (A7)+,D0; DIVU.W D1,D0; SWAP.W D0; MOVEQ.L 0,D1; MOVE.W D0,D1; MOVE.W D3,D0; SWAP.W D0; MOVE.W (A7)+,D3; RTS; UNSIGNED_MOD: BSR.W DIVUL; L201A0: BVC.B L201AA; MOVEQ.L 0,D0; MOVE.W #2,CCR; RTS; L201AA: MOVE.L D1,D0; TST.L D0; RTS; !A0 = STACK PRINT_BCD: MOVEM.L D0-A0,-(A7); LEA.L -12(A7),A7; LEA.L 11(A7),A0; CLR.B -(A0); MOVE.L D0,D3; TST.L D0; BPL.S P_BCD1; MOVEQ '-',D0; BSR.W XOUTCH; NEG.L D3; P_BCD1: MOVE.L D3,D0; MOVEQ 10,D1; BSR.W DIVUL; ADD.B '0',D1; MOVE.B D1,-(A0); MOVE.L D3,D0; MOVEQ 10,D1; BSR.W DIVUL; MOVE.L D0,D3; BNE.S P_BCD1; P_BCD2: MOVE.B (A0)+,D0; BEQ.S P_BCD3; BSR.W XOUTCH; BRA.S P_BCD2; P_BCD3: LEA.L 12(A7),A7; MOVEM.L (A7)+,D0-A0; RTS; RECHNE: ADDQ 1,PTR; BSR.W EXPRESSION; BNE.W EXPR_ERR; BSR.W PCRLF; CMPI.B 13,(PTR); BNE.W MONFEHL; MOVE.L D0,-(A7); BSR.W PRINTL; MOVEQ 4,D1; BSR.W PBLANK; MOVEQ '#',D0; BSR.W XOUTCH; MOVE.L (A7)+,D0; BSR.W PRINT_BCD; BRA.W MONX; READHEX: EXPRESSION: MOVEM.L D7-A1,-(A7); MOVEA.L A7,A1; !ADRESSE RETTEN MOVEQ 0,D7; SUBA.L 10,A7; !FUER VARIABLENSTACK MOVEA.L A7,A0; !HIER FAENGT ER AN BSR.W AUSDRUCK; MOVE.L -(A0),D0; !OBERSTES ELEMENT AUF STACK EXPRX: MOVEA.L A1,A7; !ZURUECK TST.B D7; MOVEM.L (A7)+,D7-A1; RTS; !Z = 1 WENN FEHLERFREI EXPR_ERRX: MOVEQ 1,D7; !KEINE ZAHL ERKANNT BRA.S EXPRX; EXPR_ERR: BSR PCRLF; BRA.W MONFEHL; !FALSCHE BERECHNUNG KONSTANTE: BSR.W BLANKWEG; !ZEICHEN HOLEN CMPI.B '~',(PTR); BEQ.S NOT_KONSTANTE; CMPI.B '$',(PTR); BEQ.S REG_WERT; CMPI.B '-',(PTR); !NEGATIVE ZAHL ? BEQ.S MINUSKONSTANTE; !SO IST ES CMPI.B '+',(PTR); !PLUS ? BNE.S PLUSKONSTANTE; ADDQ 1,PTR; PLUSKONSTANTE: ! BSR BLANKWEG; BSR.W WERTHOLEN; BNE.W EXPR_ERRX; !FEHLER BEI KONSTANTE: KEIN WERT BRA.S KONSTANTEND; MINUSKONSTANTE: ADDQ 1,PTR; ! BSR.W BLANKWEG1; !'-' UND ' ' UEBERLESEN BSR.W WERTHOLEN; BNE.W EXPR_ERR; !FEHLER NEG.L D0; !NEGIEREN BRA.S KONSTANTEND; NOT_KONSTANTE: ADDQ 1,PTR; BSR.W WERTHOLEN; BNE.W EXPR_ERR; !FEHLER NOT.L D0; !NEGIEREN BRA.S KONSTANTEND; REG_WERT: ADDQ 1,PTR; BSR.W LESE_REGISTER; BCS.W EXPR_ERR; KONSTANTEND: MOVE.L D0,(A0)+; !RESULTAT AUF STACK RTS; FAKTOR: BSR.W BLANKWEG; !1.ZEICHEN HOLEN CMPI.B '(',(PTR); !KLAMMER ? BNE.S FAKTOR1; !NEIN ADDQ 1,PTR; BSR.W AUSDRUCK; !WERT BERECHNEN :RESULTAT AUF VARSTACK BSR.W BLANKWEG; CMPI.B ')',(PTR); !MUSS UNBEDINGT SEIN BNE.W EXPR_ERR; ADDQ 1, PTR ; BRA.S FAKTOREND; FAKTOR1: BSR.W KONSTANTE; !KONSTANTE HOLEN FAKTOREND: RTS; TERM: BSR.W BLANKWEG; BSR.W FAKTOR; !1.OPERAND HOLEN TERMNEXT: BSR.W BLANKWEG; CMPI.B '*',(PTR); !MULTIPLIKATION ? BEQ.S MULTIPLY; CMPI.B '/',(PTR); !DIVISION ? BNE.S TERM2; !NEIN ADDQ 1, PTR ; !'/' UEBERLESEN BSR.W FAKTOR; !DIVISOR HOLEN MOVE.L -(A0),D1; ! BEQ.W EXPR_ERR; !FEHLER : DIVISION/0 MOVE.L -(A0),D0; !DIVIDEND BSR.W DIVUL; !ERGEBNIS IN D0 TERMABLAGE: MOVE.L D0,(A0)+; !UND ABLEGEN BRA.S TERMNEXT; !FERTIG ? MULTIPLY: ADDQ 1, PTR ; !'*' UEBERLESEN BSR.W FAKTOR; !2.FAKTOR MOVE.L -(A0),D0; MOVE.L -(A0),D1; BSR.W MULUL; !MULTIPLIKATION BRA.S TERMABLAGE; TERM2: CMPI.B '%',(PTR); !MODULO ? BNE.S TERMEND; ADDQ 1,PTR; BSR.W FAKTOR; !MODULO FUNKTION MOVE.L -(A0),D1; !DIVISOR BEQ.W EXPR_ERR; TERMMOD1: MOVE.L -(A0),D0; BSR.W UNSIGNED_MOD; !DIVISION; BRA.W TERMABLAGE; !UND ERGEBNIS ABLEGEN TERMEND: RTS; EINFACHAUSDR: BSR.W TERM; !1.WERT HOLEN EINFACHAUS1: BSR.W BLANKWEG; CMPI.B '-',(PTR); !SUBTRAKTION ? BEQ.S SUBTRACT; CMPI.B '+',(PTR); !ADDITION ? BNE.S EINFACHAUSEND; !NEIN, KEINE AKTION BSR.W BLANKWEG1; !'+' UEBERLESEN BSR.W TERM; !2.SUMMAND MOVE.L -(A0),D1; MOVE.L -(A0),D0; ADD.L D1,D0; BRA.S EINFACHABLAGE; SUBTRACT: BSR.W BLANKWEG1; !'-' UEBERLESEN BSR.W TERM; !SUBTRAHEND MOVE.L -(A0),D1; MOVE.L -(A0),D0; SUB.L D1,D0; EINFACHABLAGE: MOVE.L D0,(A0)+; !AUF VARSTACK BRA.S EINFACHAUS1; !WEITER ? EINFACHAUSEND: RTS; AUSDRUCK: BSR.W AUSDRUCK_A; AUSDRUCK0: BSR.W BLANKWEG; !TESTEN, OB 'OR' ODER 'XOR' CMPI.B '^',(PTR); !'OR' ? BEQ.S ODERN; CMPI.B ':',(PTR); !'XOR' ? BNE.S AUSDRUCKX; ADDQ 1,PTR; BSR.W AUSDRUCK_A; !2. WERT MOVE.L -(A0),D1; !HOLEN MOVE.L -(A0),D0; EOR.L D1,D0; !EOR AUSDRUCK1: MOVE.L D0,(A0)+; !UND AUF STACK BRA.S AUSDRUCK0; ODERN: ADDQ 1,PTR; BSR.W AUSDRUCK_A; MOVE.L -(A0),D1; !2. WERT HOLEN MOVE.L -(A0),D0; OR.L D1,D0; BRA.S AUSDRUCK1; !UND ABLEGEN AUSDRUCKX: AUSDRUCKEND: RTS; AUSDRUCK_A: BSR.W AUSDRUCK_B; AUSDRUCK_A0: BSR.W BLANKWEG; !TESTEN, OB 'AND' CMPI.B '&',(PTR); !'AND' ? BNE.S AUSDRUCK_AX; ADDQ 1,PTR; BSR.W AUSDRUCK_B; !2. WERT MOVE.L -(A0),D1; !HOLEN MOVE.L -(A0),D0; AND.L D1,D0; !AND MOVE.L D0,(A0)+; !UND AUF STACK BRA.S AUSDRUCK_A0; AUSDRUCK_AX: AUSDRUCK_AEND: RTS; AUSDRUCK_B: BSR.W BLANKWEG; CMPI.B '~',(PTR); !'NOT' ? BNE.S AUSDRUCK_BX; !NEIN ADDQ 1,PTR; BSR.W EINFACHAUSDR; !WERT HOLEN NOT.L -4(A0); !ALLE BITS INVERTIEREN RTS; AUSDRUCK_BX: BSR.W EINFACHAUSDR; AUSDRUCK_BEND: RTS; LESE_REGISTER: MOVEQ 0,D0; !INDEX AUF REGISTERLISTE CMPI.B 'D',(PTR); BEQ.W NORMAL_REG; CMPI.B 'd',(PTR); BEQ.W NORMAL_REG; MOVEQ 8,D0; !INDEX AUF A-REGISTER CMPI.B 'A',(PTR); BEQ.W NORMAL_REG; CMPI.B 'a',(PTR); BEQ.W NORMAL_REG; CMPI.B 'S',(PTR); BEQ.S SUPER; CMPI.B 's',(PTR); BNE.S TESTE_US; SUPER: MOVEQ 15,D0; !DEFAULT FUER SS-PTR CMPI.B 'R',1(PTR); !SR TEST BEQ.S IST_SR; CMPI.B 'r',1(PTR); BNE.S TESTE_REST; IST_SR: MOVEQ 17,D0; BRA.W SELECT_REG1; !IST SR-REG TESTE_US: MOVEQ 16,D0; !DEFAULT FUER US-PTR CMPI.B 'U',(PTR); BEQ.S TESTE_REST; CMPI.B 'u',(PTR); BNE.S TESTE_PC; TESTE_REST: CMPI.B 'S',1(PTR); BEQ.S SELECT_REG1; !IST EIN STACK-PTR CMPI.B 's',1(PTR); BEQ.S SELECT_REG1; BRA.S ADRESS_ERR; !KEIN GUELTIGES REGISTER TESTE_PC: MOVEQ 18,D0; !DEFAULT FUR PC-REG CMPI.B 'P',(PTR); BEQ.S TESTE_PC1; CMPI.B 'p',(PTR); BNE.S ADRESS_ERR; !IST KEIN PC TESTE_PC1: CMPI.B 'C',1(PTR); BEQ.S SELECT_REG1; CMPI.B 'c',1(PTR); BEQ.S SELECT_REG1; BRA.W ADRESS_ERR; NORMAL_REG: MOVEQ 0,D1; MOVE.B 1(PTR),D1; SUBI.B '0',D1; BMI.S ADRESS_ERR; CMP.B 7,D1; BGT.S ADRESS_ERR; ADD.W D1,D0; SELECT_REG: CMPI.B 15,D0; !A7 ? BNE.S SELECT_REG1; BTST.B 5,STATUSREG; !USERMODE ? BNE.S SELECT_REG1; !NEIN ADDQ.W 1,D0; !DANN US ANWAEHLEN SELECT_REG1: LSL.W 2,D0; MOVE.L (REGLIST,D0.W),D0; ADDQ 2,PTR; !WEITER CLEAR_CARRY: ANDI.B $FE,CCR; RTS; SET_CARRY: ADRESS_ERR: ORI.B 1,CCR; !FEHLER BEI C = 1 RTS; HUNTSTR: MOVE.B 2(PTR),JOKER; !JOKER LADEN ADDQ.L 2,PTR; !PTR ZEIGT AUF JOKER MOVEQ 0,INDEX; !INDEX AUF NULL HUNTSTR1: ADDQ.L 1,PTR; MOVE.B (PTR),D0; CMPI.B 13,D0; !FERTIG WENN $0D BEQ.S HUNTSTREND; CMP.B JOKER,D0; BEQ.S HUNTSTR2; !WENN JOKER, $FF IN WERTE UND MASKE MOVE.B D0,WERTE; !ZEICHEN NACH WERTE CLR.B MASKE; !MASKE LOESCHEN TST.B OPTION; !'+' ? BEQ.S HUNTSTR2; !NEIN ORI.B $80,MASKE; !BEI + OPTION IST OBERSTES BIT EGAL ORI.B $80,WERTE; HUNTSTR2: ADDQ.L 1,INDEX; CMPI.B TABLEN,INDEX; BLT.S HUNTSTR1; HUNTSTREND: CLR.B OPTION; !BEI ASCII-SUCHE NUR ALS DUMP !!! BRA.W ABAX; PROZENT: MOVEQ 0,D1; !HILFSREGISTER PROZENTNEXT: ADDQ.L 1,PTR; !NAECHSTES ZEICHEN MOVE.B (PTR),D0; CMPI.B $31,D0; !EINE '1' ? BNE.S PROZENT1; LSL.L 1,D1; ADDQ.L 1,D1; !DANN EINE 1 NACH WERTE BRA.S PROZENTNEXT; PROZENT1: CMPI.B $30,D0; !EINE '0' ? BNE.S PROZENT2; LSL.L 1,D1; !DANN EINE 0 NACH WERTE BRA.S PROZENTNEXT; PROZENT2: CMP.B JOKER,D0; !JOKER-ZEICHEN ? BNE.S PROZENTEND; LSL.L 1,D1; ADDQ.L 1,D1; ADD.L #$10000,D1; !DANN JE EINE 1 NACH WERTE UND MASKE BRA.S PROZENTNEXT; PROZENTEND: MOVE.B D1,WERTE; SWAP D1; MOVE.B D1,MASKE; SUBQ.L 1,PTR; !!KORREKTUR BRA.W AB4D; HUNT: CLR.B OPTION; !BASISADRESSE IN A6 LEA.L WERTETAB,A0; !FUER (IND,INDEX) BSR.W PCRLF; MOVE.B 1(PTR),D0; !ZEICHEN NACH 'H' LESEN CMPI.B '+',D0; BNE.S HUNT1; MOVE.B D0,OPTION; ADDQ.L 1,PTR; !ZEICHEN MERKEN HUNT1: MOVEQ TABLEN-1,INDEX; LOOP: MOVE.B #$FF,MASKE; !LOESCHEN MOVE.B #$FF,WERTE; !EBENSO DBF.W INDEX,LOOP; !20 MAL MOVEQ 0,INDEX; !D7 MOVE.B #'?',JOKER; CMPI.B '"',1(PTR); !STRING SUCHEN ? BEQ.W HUNTSTR; AB52: ADDQ.L 1,PTR; !INK. POINTER MOVE.B (PTR),D0; !ZEICHEN HOLEN CMPI.B 13,D0; !RETURN ? BEQ.W ABA9; ! CMPI.B ' ',D0; !BLANK ? BEQ.B AB52; CMPI.B '%',D0; BEQ.W PROZENT; CMP.B JOKER,D0; !JOKER ? BNE.B AB6A; MOVE.B #$F,WERTE; MOVE.B #$F,MASKE; BRA.B AB71; AB6A: BSR.W ASTOHEX; !D0=RESULTAT MOVE.B D0,WERTE; !ABLEGEN CLR.B MASKE; !MASKE LOESCHEN AB71: ADDQ.L 1,PTR; !NAECHSTES BYTE MOVE.B (PTR),D0; !HOLEN CMPI.B 13,D0; !RETURN ? BNE.B AB7X; ADDQ.L 1,INDEX; BRA.S ABA9; AB7X: CMPI.B ' ',D0; !BLANK ? BEQ.B AB4D; !SYNCHRONISIERT WIEDER MOVEQ 0,D1; !LOESCHEN MOVE.B WERTE,D1; !UNTERE HAELFTE LADEN SWAP D1; !VERTAUSCHEN MOVE.B MASKE,D1; !MASKE LADEN ASL.L 4,D1; !4 MAL SCHIEBEN MOVE.B D1,MASKE; !UND ZURUECK SWAP D1; MOVE.B D1,WERTE; !UND AUCH ZURUECK CMP.B JOKER,D0; !JOKER ? BNE.B AB9A; ORI.B $F,WERTE; !LOWNIB=JOKER ORI.B $F,MASKE; !EBENSO BRA.W AB4D; !UND NAECHSTES BYTE AB9A: BSR.W ASTOHEX; !WERT WANDELN OR.B D0,WERTE; !WERT ABLEGEN ANDI.B $F0,MASKE; !MASKE ABSCHALTEN AB4D: ADDQ 1,INDEX; !SCHLEIFE +1 CMP.B TABLEN,INDEX;!MEHR ALS 20 BYTE ? BLT.W AB52; ABAX: ADDQ.L 1,PTR; !POINTER AUFS ENDE SETZEN MOVE.B #13,(PTR); !UND INPUT ZEILE BEGRENZEN ABA9: TST.L INDEX; !MUSS GESUCHT WERDEN ? BEQ.B SUCHEND; !NEIN, DA KEINE DATEN MOVE.L INDEX,REGSAVE; !INDEX RETTEN CLR.L LASTADDRESS; SUBQ 1,FROMAD; !KORREKTUR SUCHEN: MOVEQ 0,INDEX; !LOESCHEN ADDQ.L 1,FROMAD; !NAECHSTE ADDR. SUCHEN1: CMP.L FROMAD,TOAD; !ENDE ERREICHT ? BLT.B SUCHEND; MOVE.B SPEICHER,D0;!BYTE HOLEN OR.B MASKE,D0; !MASKIEREN CMP.B WERTE,D0; !VERGLEICHEN BNE.B SUCHEN; !STIMMEN NICHT UEBEREIN ADDQ 1,INDEX; !NAECHSTES BYTE CMP.L REGSAVE,INDEX; !ENDE ERREICHT ? BLT.B SUCHEN1; !NOCH NICHT FERTIG MOVEM.L REGISTER,TOSTACK; MOVEA.L A2,A3; !ANFANG=ENDE ADD.L REGSAVE,A3; !ENDE = ANFANG + LAENGE TST.B OPTION; !DISASS ? BEQ.B SUCHEN2; !NEIN MOVE.L A2,D0; !ZUM TESTEN BTST 0,D0; !GERADE ADRESSE ? BNE.S SUCHEN4; !NEIN, DANN NICHT DISASS. SUBQ.L 2,A3; !MINIMALE BEFEHLSLAENGE SUBTR. SONST DOPPEL-DIS. MOVE.L A2,LASTADDRESS; BSR.W X; !DISASS BRA.S SUCHEN3; SUCHEN2: MOVE.L A2,LASTADDRESS; BSR DUMPING; SUCHEN3: BSR.W PCRLF; SUCHEN4: MOVEM.L FROMSTACK,REGISTER; BNE.B SUCHEN; !WEITER SUCHEND: SUBQ.L 1,PTR; TST.L LASTADDRESS; !LETZTER ANGEZEIGTER DUMP BEQ.S SUCHENDX; MOVE.L LASTADDRESS,FROMAD; !FUER WIEDERHOLTES ANZEIGEN SUCHENDX: RTS; BELL: MOVE.L D0,TOSTACK; MOVEQ 7,D0; BSR XOUTCH; MOVE.L FROMSTACK,D0; RTS; TEXT: MOVEM.L D0/A0,TOSTACK; TEXT1: MOVE.L 8(A7),A0; !BYTE LESEN MOVE.B (A0)+,D0; ADDQ 1,8(A7); !INKREMENT CMPI.B 4,D0; BEQ.B TEXTEND; !FERTIG BSR XOUTCH; BRA.B TEXT1; !WEITER TEXTEND: MOVEM.L FROMSTACK,D0/A0; RTS; ZEIGE_ADR: BSR.W PCRLF; BSR.S TEXT; DC 'Adressbereich $';DC.B 4; LEA.L MONSTART,A0; MOVE.L A0,D0; BSR.W PRINTAD; BSR.S TEXT; DC ' - $';DC.W 4; LEA.L BLOCKENDE,A0; MOVE.L A0,D0; SUBQ.L 1,D0; BSR.W PRINTAD; BSR.W PCRLF; RTS; MONITOR: CLR.B MODE; CLR.B INPUTMODE; SUB.L FROMAD,FROMAD; SUB.L TOAD,TOAD; BSR.W PCRLF; BSR.S TEXT; !AUSGABE DER FOLGENDEN BYTES DC '************* minomon *************';DC.B 4; BSR ZEIGE_ADR; BSR.W TEXT; DC 'Befehlsuebersicht mit ?';DC.B 4; RTS; KEINAUTO: BSR.W CLRREGLIST; !ALLES LOESCHEN BSR.W CLEARBPX; !AUCH BREAKPOINTS BSR MONITOR; !MELDUNG AUSGEBEN KALT1: MOVE.W DEFSTAT,SR; IF MC68000,1; LEA.L VARIABLE,A6; MOVE.L KALT_STACK,SSPTR; ENDIF; IF MC68000,0; MOVE.L USERSTACK,SSPTR; !DEFAULT IN REGLIST ENDIF; MOVE.L -1,REGFLAG; !ALLE REGISTER ANZEIGEN MOVE.W DEFSTAT,STATUSREG;!USER-DEFAULT MOVE.L DEFPC ,PCREG; !DEFAULT PC SUB.L A0,A0; MOVE.L A0,USP; !LOESCHEN BRA.W WARM0; TRAP13: IF MC68000,1; MOVE.L A6,-(A7); LEA.L VARIABLE,A6; MOVEM.L D0-A5,(A6); MOVE.L (A7)+,14*4(REGLIST); ENDIF; IF MC68000,0; MOVEM.L D0-A6,REGLIST; !UND ALLES RETTEN ENDIF; MOVE.L USP,A0; MOVE.L A0,USPTR; MOVE.W (A7)+,STATUSREG; MOVE.L (A7)+,PCREG; MOVE.L A7,SSPTR; MOVE.L INITSTACK,A7; !DEFAULT MONSTACK BSR.W PCRLF; BSR.W OUTREG; WARM0: BSR REMOVEBP; !BREAKPOINTS ZURUECK MONX: BSR.W PCRLF; MONX0: MOVE.L INITSTACK,A7; !DEFAULT-STACK MONX1: MOVEA.L FROMAD,TOAD; CLR.B STOP1; CLR.B STOP2; MON0: MOVEQ PROMPTER,D0; BSR XOUTCH; !PROMTER AUSGEBEN IF MC68000,1; BSR GETLINE_X; ENDIF; IF MC68000,0; BSR GETLINE; ENDIF; LEA.L INBUF,PTR; !INPUTPUFFER AUF ANFANG SETZEN MOVEA.L PTR,A4REG; CLR.B MODE; CLR.B SETPCFLAG; !ERSTMAL LOESCHEN CMPI.B ':',(PTR); !INTEL-FORMAT ? BNE.S MONCONT; BSR.W DOPPEL; !GEHT SCHNELLER BRA.W SPRUNG1; !UND WEITERMACHEN MONCONT: BSR.W READHEX; BNE.B MON01; !KEINE ZAHL GEWESEN MOVE.L D0,TOAD; !ZAHL NACH A3 TST.B MODE; BNE.B MON01; MOVE.L D0,FROMAD; !WENN MODE =0 ZAHL NACH A2 TAS SETPCFLAG; !BEI S,T,G,J WIRD PC-WERT = FROMAD MON01: MOVE.B (PTR),D0; !ZEICHEN LESEN MOVEQ TAB2-TAB1-1,INDEX; !MAX. ZEICHENANZAHL MON1: CMP.B (TAB1,INDEX),D0; !VERGLEICHEN BEQ.B MON2; !GEFUNDEN DBF.W INDEX,MON1; !WEITER SUCHEN MONFEHLX: BSR.W PCRLF; !WENN FEHLER, DANN ^ AUSGEBEN MONFEHL: SUB.L A4REG,PTR; MOVE.L PTR,D1; ADDQ.L 1,D1; BSR.W PBLANK; MOVEQ '^',D0; BSR XOUTCH; BSR.W BELL; BRA.W MONX; !NICHT GEFUNDEN MON2: ASL.L 2,INDEX; !INDEX MAL 4 FUER SPRUNGZIEL MOVE.L (TAB2,INDEX),INDEX; !ABSOLUTE ADRESSE MOVE.B MODE,D0; !MODE UEBERGEBEN CLR.B MODE; !UND LOESCHEN SUB.L #SPRUNG,INDEX; !PC-RELATIVER OFFSET SPRUNG: JSR 0(*,INDEX.L); !ROUTINE AUFRUFEN SPRUNG1: TST.B STOP1; !ABBRUCH ? BNE.W MONX; !JA ADDQ.L 1,PTR; MOVE.B (PTR),D0; CMPI.B 13,D0; BEQ.W MONX; BRA.B MONCONT; !UND WEITER TAB1: DC.B ' '; !BLANK DC.B #13; !RETURN DC.B '.'; !PUNKT DC.B ':'; !DOPPELP. DC.B '<'; !SLASH DC.B 'H'; !HUNT DC.B 'h'; DC.B 'M'; !MOVE DC.B 'm'; DC.B 'V'; !VERIFY DC.B 'v'; IF MC68000,1; DC.B 'Q'; DC.B 'q'; DC.B '^'; !FMS AUFRUFEN ENDIF; !QUIT DC.B ';'; !SEMIKOLON DC.B '='; !GLEICH DC.B 'I'; !INSERT-FILL DC.B 'i'; DC.B 'G'; !GOTO BEFEHL DC.B 'g'; DC.B 'J'; !JUMPSUB DC.B 'j'; DC.B 'S'; !MOTOROLA S-RECORDS LESEN DC.B 's'; !STEP DC.B 'T'; !TRACE DC.B 't'; DC.B '\'; !DISASS 23 ZEILEN DC.B '|'; DC.B 'L'; !DISASS DC.B 'l'; DC.B '?'; !HELP DC.B 'R'; !REGISTER ANZEIGE DC.B 'r'; DC.B ','; !ZWEITER SCANNER DC.B 'P'; !PUSH EINES LANGWORTES DC.B 'p'; DC.B '!'; DC.B PROMPTER; ! EVEN; TAB2: DC.L #BLANK; DC.L #RETURN; DC.L #PUNKT; DC.L #DOPPEL; DC.L #BACKSLASH; DC.L #HUNT; DC.L #HUNT; DC.L #MOVE; DC.L #MOVE; DC.L #VERIFY; DC.L #VERIFY; IF MC68000,1; DC.L #QUIT; DC.L #QUIT; DC.L #FMSSUB; ENDIF; DC.L #SEMI; DC.L #GLEICH; DC.L #INSERT; DC.L #INSERT; DC.L #GOTO; DC.L #GOTO; DC.L #JUMPSUB; DC.L #JUMPSUB; DC.L #MOLOAD; !GROSSES 'S' DC.L #STEP; !KLEINES 's' DC.L #TRACE; DC.L #TRACE; DC.L #X23; DC.L #X23; DC.L #X; DC.L #X; DC.L #HELP; DC.L #OUTREGX; DC.L #OUTREGX; DC.L #DECODE; !BEFEHLE MIT ',' DC.L #PUSH; DC.L #PUSH; DC.L #RECHNE; DC.L #PROMPT; PUSH: ADDQ.L 1,PTR; BSR READHEX; BNE.S PUSHEND; BTST.B 5,STATUSREG; !TEST WELCHER A7-PTR BNE.S PUSH_S; MOVEA.L USPTR,A0; MOVE.L D0,-(A0); MOVE.L A0,USPTR; BRA.S PUSHEND; PUSH_S: MOVEA.L SSPTR,A0; MOVE.L D0,-(A0); MOVE.L A0,SSPTR; PUSHEND: BRA.W MONX; X23: MOVE.L D1,TOSTACK; !RETTEN MOVEQ 22,D1; !ANZAHL DER ZEILEN X23X: MOVE.L FROMAD,TOAD; BSR.W X; !DISASSEMBLE DBEQ.W D1,X23X; !NOCHMAL WENN KEIN ABBRUCH MOVE.L FROMSTACK,D1; RTS; NORMAL: CLR.B INPUTMODE; !NORMALER INPUT =0 RTS; TERMINAL: TAS INPUTMODE; !ANGEPASSTER INPUT =$FF RTS; DATEN_BYTES: EQU D1; !ALS ZAEHLER QUERSUM: EQU D2; !ZUM AUFADDIEREN KENNUNG: EQU D3; !BYTE NACH DER ADRESSE DATEN_PTR: EQU A0; !ZUR INDIZIERTEN ABLAGE Z_PTR: EQU A1; !FUER ZWISCHENABLAGE GET_IBYTE: MOVE.B (PTR)+,D0; !HIGH-NIBBLE CMPI.B '0',D0; BLT.B GET_IBERR; CMPI.B ':',D0; BLT.B GET_IB1; CMPI.B 'A',D0; BLT.B GET_IBERR; CMPI.B 'F',D0; BGT.B GET_IBERR; SUBQ.B #7,D0; GET_IB1: ASL.B 4,D0; !INS OBERE NIBBLE SCHIEBEN MOVE.B D0,-(A7); !UND AUF DEN STACK MOVE.B (PTR)+,D0; !LOW-NIBBLE CMPI.B '0',D0; BLT.B GET_IBERX; CMPI.B ':',D0; BLT.B GET_IB2; CMPI.B 'A',D0; BLT.B GET_IBERX; CMPI.B 'F',D0; BGT.B GET_IBERX; SUBQ.B #7,D0; GET_IB2: ANDI.B $F,D0; OR.B (A7)+,D0; !BYTE IST KOMPLETT ADD.B D0,QUERSUM; !AUFADDIEREN ORI.B 4,CCR; !Z=1, WENN OK GET_IBEND: RTS; GET_IBERX: ADDQ.L 2,A7; !KORREKTUR GET_IBERR: ANDI.B $FB,CCR; RTS; GET_IWORD: BSR.S GET_IBYTE; !HIGH-BYTE EINER ADRESSE BNE.S GET_IWEND; !FEHLER MOVE.B D0,-(A7); !AUF DEN STACK LEGEN: XX00 BSR.S GET_IBYTE; !UNTERE ADRESSE BEQ.S GET_IW1; !IST OK ADDQ.L 2,A7; !KORREKTUR BRA.S GET_IWEND; !BEI FEHLER GET_IW1: MOVE.B D0,1(A7); !ALS LOW-BYTE DAZU MOVE.W (A7)+,D0; !UND FERTIG ORI.B 4,CCR; !Z=1, WENN OK GET_IWEND: RTS; DOPPEL: ADDQ.L 1,PTR; !INTEL-HEX LESEN MOVEM.L D0-D3/A0-A1,-(A7); !LOKALE WERTE MOVEQ 0,QUERSUM; !LOESCHEN MOVEQ 0,D0; !AUCH LOESCHEN BSR.W GET_IBYTE; !HOLT EIN BYTE AUS INPUT BNE.W INTEL_FEHL; CMPI.B 17,D0; !MAXIMAL NUR 16 DATENBYTES !!! BCC.W INTEL_FEHL; !FEHLER, WENN ZU GROSS SUBQ.B 1,D0; !KORREKTUR FUER SCHLEIFE MOVE.W D0,DATEN_BYTES; !ANZAHL DER DATENBYTES BSR.W GET_IWORD; !ADRESSE LESEN BNE.W INTEL_FEHL; MOVE.L D0,DATEN_PTR;!GEWUENSCHTE ZIELADRESSE MOVEQ 0,D0; !LOESCHEN BSR.W GET_IBYTE; BNE.W INTEL_FEHL; MOVE.W D0,KENNUNG; !0 ODER 1 BEQ.S INTEL1; !IST EINE 0 MOVE.L DATEN_PTR,PCREG; !WENN=1, DANN STARTADRESSE ABLEGEN INTEL1: TST.B DATEN_BYTES; !WENN NEGATIV-> KEIN EINZIGES BMI.S INTEL3; !NICHTS LESEN MOVE.W DATEN_BYTES,-(A7); !ANZAHL RETTEN LEA.L WERTETAB,Z_PTR; !ALS ZWISCHENSPEICHER NUTZEN INTEL2: BSR.W GET_IBYTE; !DATENBYTES LESEN BEQ.S INTEL2X; !WERT IST OK ADDQ.L 2,A7; !BEI FEHLER STACK KORRIGIEREN BRA.S INTEL_FEHL; !ABBRUCH INTEL2X: MOVE.B D0,(Z_PTR)+; !ZWISCHENSPEICHERN DBF DATEN_BYTES,INTEL2; !ALLE DATEN LESEN MOVE.W (A7)+,DATEN_BYTES; !ALTER WERT INTEL3: BSR.W GET_IBYTE; !PRUEFSUMME LESEN BNE.S INTEL_FEHL; TST.B QUERSUM; !MUSS = 0 SEIN BNE.S INTEL_FEHL; !NICHT OK TST.B DATEN_BYTES; !DATEN GELESEN ? BMI.S INTEL5; !NEIN LEA.L WERTETAB,Z_PTR; !ENDGUELTIGE SPEICHERABLAGE INTEL4: MOVE.B (Z_PTR)+,(DATEN_PTR)+; DBF DATEN_BYTES,INTEL4; INTEL5: TST.B KENNUNG; !TESTEN, OB 1 ODER 0 BEQ.S INTEL_RET; !NORMALE DATEN EMPFANGEN MOVE.B 'J',1(PTR); !WENN STARTADRESSE, DANN AUTOSTART MOVE.B 13, 2(PTR); MOVE.B '+',D0; BSR.W XOUTCH; !QUITTUNG FUER AUTOSTART BRA.S INTEL_X; INTEL_FEHL: MOVE.B '?',D0; !BEI FEHLER BSR.W XOUTCH; !? AUSGEBEN INTEL_RET: MOVE.B 13,1(PTR); !ZEILENENDE SETZEN INTEL_X: MOVEM.L (A7)+,D0-D3/A0-A1; !ZEILE VERARBEITET RTS; MOLOAD: ADDQ.L 1,PTR; !MOTOROLA S-RECORDS LESEN MOVEM.L D0-D3/A0-A1,-(A7); !LOKALE WERTE MOVE.B (PTR)+,D0; SUB.B '0',D0; BEQ.W MO_RET; !S0-RECORD IGNORIEREN CMPI.B 9,D0; !MAXIMAL S9 BHI.W MO_FEHL; !IST NICHT OK MOVE.B D0,KENNUNG; !FORMAT MERKEN MOVEQ 0,QUERSUM; !LOESCHEN MOVEQ 0,D0; !AUCH LOESCHEN BSR.W GET_IBYTE; !HOLT EIN BYTE AUS INPUT BNE.W MO_FEHL; CMPI.B 35,D0; !MAXIMAL 35 BYTES = 32 DATENBYTES !!! BHI.W MO_FEHL; !FEHLER, WENN ZU GROSS MOVE.W D0,DATEN_BYTES; !ANZAHL DER DATENBYTES MOVE.B D0,DUMMY; !RETTEN LEA.L WERTETAB,Z_PTR; !ALS ZWISCHENSPEICHER NUTZEN SUBQ.W 1,DATEN_BYTES; !KORREKTUR MO_2: BSR.W GET_IBYTE; !ALLE BYTES LESEN BNE.W MO_FEHL; !WERT IST NICHT OK MOVE.B D0,(Z_PTR)+; !ZWISCHENSPEICHERN DBF DATEN_BYTES,MO_2; !ALLE DATEN LESEN NOT.B QUERSUM; !MUSS = 0 SEIN BNE.S MO_FEHL; !NICHT OK MOVEQ 0,DATEN_BYTES; MOVE.B DUMMY,DATEN_BYTES; SUBQ.W 4,DATEN_BYTES; !KORREKTUR FUER EFF. ANZAHL DATENBYTES LEA.L WERTETAB,Z_PTR; !ADRESSE LESEN MOVEQ 0,D0; MOVE.B (Z_PTR)+,D0; !HIGH-BYTE DER ADRESSE ROL.L 8,D0; MOVE.B (Z_PTR)+,D0; !LOW-BYTE ADRESSE BTST 0,KENNUNG; !S1 ODER S9-RECORD ? BNE.S MO_3; !DANN NUR 2 BYTE FUER ADRESSE SUBQ.W 1,DATEN_BYTES;!NOCH EIN BYTE WENIGER AN DATEN ROL.L 8,D0; MOVE.B (Z_PTR)+,D0; !NOCH EIN ADRESS-BYTE MO_3: MOVE.L D0,DATEN_PTR; !FUER ABLAGE TST.W DATEN_BYTES; !UEBERHAUPT NOCH DATEN IM RECORD ? BMI.S MO_5; !KEINE DATEN, AUF STARTRECORD TESTEN MO_4: MOVE.B (Z_PTR)+,(DATEN_PTR)+; !DATEN UMSCHAUFELN DBF DATEN_BYTES,MO_4; BRA.W MO_RET; !NUR ABLEGEN MO_5: TST.L D0; !EMPFANGENE ADRESSE OHNE DATENBYTES BEQ.S MO_RET; !WENN =0, IGNORIEREN CMPI.B 8,KENNUNG; !S8 ODER S9 ? BCS.S MO_RET; !KEINE STARTADRESSE MOVE.L D0,PCREG; !STARTADRESSE ABLEGEN MOVE.B 'J',1(PTR); !WENN STARTADRESSE, DANN AUTOSTART MOVE.B 13, 2(PTR); MOVE.B '+',D0; BSR.W XOUTCH; !QUITTUNG FUER AUTOSTART BRA.S MO_X; MO_FEHL: MOVE.B '?',D0; !BEI FEHLER BSR.W XOUTCH; !? AUSGEBEN MO_RET: MOVE.B 13,1(PTR); !ZEILENENDE SETZEN MO_X: MOVEM.L (A7)+,D0-D3/A0-A1; !ZEILE VERARBEITET RTS; PROMPT: ADDQ.L 1,A4REG; RTS; BLANK: RETURN: MOVE.B D0,MODE; !MODUS BEIBEHALTEN CMPA.L A4REG,PTR; BEQ.B RTN1; !NUR RETURN: DUMP EINE ZEILE RTN3: TST.B MODE; BNE.B RTN0; BSR.W PCRLF; MOVE.L FROMAD,D0; BSR.W PRINTADD; MOVE.B (FROMAD),D0; BSR.W PRINTB; BRA.B RTNEND; RTN0: CMPI.B '.',MODE; BNE.B RTN2; BSR.W PCRLF; !XXXX.YYYY : DUMP VON-BIS RTN1: MOVEM.L D0-D3,TOSTACK; MOVEQ 13,D0; BSR XOUTCH; BSR.W DUMPING; MOVEA.L FROMAD,TOAD; MOVEM.L FROMSTACK,D0-D3; BRA.B RTNEND; RTN2: CMPI.B '+',MODE; BNE.B RTNEND; NOP; RTNEND: SUBQ.L 1,PTR; RTS; SEMI: SUBA.L #32,FROMAD; MOVE.L FROMAD,TOAD; MOVEM.L D0-D3,TOSTACK; MOVEQ 13,D0; BSR XOUTCH; BSR.W DUMP; MOVEM.L FROMSTACK,D0-D3; RTS; GLEICH: MOVE.B (PTR),MODE; MOVE.L PTR,TOSTACK; MOVEA.L A4REG,PTR; BSR.W BLANKWEG; MOVE.L FROMSTACK,PTR; CMPI.B '=',D0; BEQ.B DOPPEL0; MOVEA.L FROMAD,ZIELAD; DOPPEL0: ADDQ.L 1,PTR; MOVEQ 0,INDEX; MOVE.B (PTR),D0; !1. ZEICHEN LESEN CMPI.B '"',D0; !ASCII-STRING FOLGT ? BNE.S DOPPEL1; !NEIN, HEX-WERTE DOPPEL2: ADDQ.L 1,PTR; !AB DEM NAECHSTEN ZEICHEN EINLESEN MOVE.B (PTR),D0; !LESEN CMPI.B 13,D0; !FERTIG ? BEQ.S DOPPEND; !JA MOVE.B D0,(ZIELAD,INDEX); !ABSPEICHERN ADDQ.L 1,INDEX; BRA.S DOPPEL2; !UND WEITER DOPPEL1: BSR.W READHEX; !HEXWERTE EINLESEN UND ABSPEICHERN BNE.B DOPPEND; !BIS UNGUELTIGES ZEICHEN AUFTRITT MOVE.B D0,(ZIELAD,INDEX); ADDQ.L 1,INDEX; BRA.B DOPPEL1; DOPPEND: SUBQ.L 1,PTR; !PTR KORRIGIEREN MOVEA.L ZIELAD,FROMAD; !ANFANGSADRESSE RETTEN ADD.L INDEX,ZIELAD; !ENDADRESSE BERECHNEN MOVEA.L ZIELAD,TOAD; !UND RETTEN SUBQ.L 1,TOAD; !DAMIT BEIM SCREEN-EDIT NUR 1 ZEILE GEDUMP WIRD RTS; !WENN 16 WERTE NEU EINGEGEBEN WERDEN PUNKT: MOVE.B (PTR),MODE; !MODUS ABSPEICHERN RTS; !DAS IST ALLES BACKSLASH: MOVEA.L FROMAD,ZIELAD; CLR.B MODE; RTS; DUMP: BSR.W PCRLF; DUMPING: MOVE.L A2,D0; !ADRESSE BSR.W PRINTADD; !PRINT ADRESSE MOVEQ 0,D0; MOVEQ 0,D3; DUMP1: MOVE.B 0(A2,D3),D0; ADDQ.L 1,D3; BSR.W PRINTB; MOVEQ 1,D1; BSR.W PBLANK; CMPI.B 16,D3; BLT.B DUMP1; MOVEQ 0,D3; MOVEQ 3,D1; BSR.W PBLANK; DUMP2: MOVE.B 0(A2,D3),D0; CMPI.B ' ',D0; BLT.B DUMP3; CMPI.B $7E,D0; BLE.B DUMP4; DUMP3: MOVEQ $5F,D0; DUMP4: BSR XOUTCH; ADDQ.L 1,D3; CMPI.B 16,D3; BLT.B DUMP2; ADDA.L #16,A2; TST.B INBUFCTR; !TASTE GEDRUECKT ? BEQ.B DUMP6; !NEIN BSR XINCH; !WARTEN BSR XINCH; CMP.B #13,D0; BEQ.B DUMP7; DUMP6: CMP.L A2,A3; BGE.B DUMP; ANDI.B $FB,CCR; DUMP7: RTS; !Z=1 WENN ABBRUCH PRINTB: ROR.L 8,D0; !BYTE ALS HEXWERT AUSGEBEN MOVEQ 2,D1; !ZWEI ZEICHEN BRA.S PNIBBLE; PRINTW: SWAP D0; !WORT ALS HEXWERT MOVEQ 4,D1; !MIT VERTAUSCHTEN HAELFTEN BRA.S PNIBBLE; PRINTL: MOVEQ 8,D1; !LANGWORT ALS HEXWERT !WEITER GEHT'S MIT PNIBBLE PNIBBLE: MOVEM.L D2-D3,TOSTACK; SUBQ.L 1,D1; PNIB1: MOVEQ 3,D2; PNIB2: LSL.L 1,D0; ROXL.B 1,D3; DBF.W D2,PNIB2; EXG.L D0,D3; BSR.B PACK; BSR XOUTCH; EXG.L D0,D3; DBF.W D1,PNIB1; MOVEM.L FROMSTACK,D2-D3; RTS; PACK: ANDI.B $F,D0; CMPI.B $A,D0; BCS.B PACK1; ADDQ.B 7,D0; PACK1: ADDI.B $30,D0; RTS; PBLANK: MOVE.L D0,TOSTACK; SUBQ.B 1,D1; MOVEQ ' ',D0; PBLANK1: BSR XOUTCH; DBF.W D1,PBLANK1; MOVE.L FROMSTACK,D0; RTS; PCRLF: MOVE.W SR,TOSTACK; MOVE.L D0,TOSTACK; MOVEQ 13,D0; BSR XOUTCH; MOVEQ 10,D0; BSR XOUTCH; MOVE.L FROMSTACK,D0; RTR; PRINTAD: MOVE.L D1,TOSTACK; BSR.B PRINTL; MOVE.L FROMSTACK,D1; RTS; MOVE: MOVEM.L D0/A1-A5,TOSTACK; MOVEQ 0,D0; SUBA.L FROMAD,TOAD; !TOAD MUSS >= SEIN EXG.L D0,TOAD; TST.L D0; BMI.B MOVE0; EXG.L D0,TOAD; ADDA.L ZIELAD,TOAD; !TOAD ENTHAELT LETZE ZIELADR. LEA.L MONSTART,A4; LEA.L BLOCKENDE,A5; CMPA.L TOAD,A4; !ZIELAD MONITORENDE ? BLT.B MOVE1; !JA MOVE0: MOVEQ 1,D0; !WENN FEHLER MOVE1: TST.L D0; MOVEM.L FROMSTACK,D0/A1-A5; BEQ.B MOVE2; !WENN OK Z=1 BSR.W PFEHLER; BRA.B MOVEND; MOVE2: CMPA.L ZIELAD,FROMAD; BGT.B MOVEDOWN; ADDA.L TOAD,ZIELAD; SUBA.L FROMAD,ZIELAD; !ZIELAD=ZIEL+ANZAHL BYTES ADDQ.L 1,ZIELAD; ADDQ.L 1,TOAD; MOVEUP: CMPA.L FROMAD,TOAD; BLE.B MOVEND; MOVE.B -(TOAD),-(ZIELAD); BRA.B MOVEUP; MOVEDOWN: CMPA.L FROMAD,TOAD; BLT.B MOVEND; MOVE.B (FROMAD)+,(ZIELAD)+; BRA.B MOVEDOWN; MOVEND: RTS; VERIFY: MOVEM.L D0-D7,TOSTACK; CMPA.L FROMAD,TOAD; BLT.B VEREND; !FALSCHE ADRESSEN VERI1: MOVE.B (ZIELAD)+,D3; MOVE.B (FROMAD)+,D4; CMPA.L FROMAD,TOAD; BLT.B VEREND; TST.B INBUFCTR; BEQ.B VERI2; BSR XINCH; BSR XINCH; CMPI.B 13,D0; BEQ.B VEREND; VERI2: CMP.B D3,D4; BEQ.B VERI1; BSR.W PCRLF; MOVE.L FROMAD,D0; SUBQ.L 1,D0; BSR.W PRINTADD; MOVE.L D4,D0; BSR.W PRINTB; MOVEQ 5,D1; BSR.W PBLANK; MOVEQ '(',D0; BSR XOUTCH; MOVE.L ZIELAD,D0; SUBQ.L 1,D0; BSR.W PRINTADD; MOVE.L D3,D0; BSR.W PRINTB; MOVEQ')',D0; BSR XOUTCH; BRA.B VERI1; VEREND: MOVEM.L FROMSTACK,D0-D7; MOVEA.L FROMAD,TOAD; RTS; PRINTADD: BSR.W PRINTAD; MOVEQ '=',D0; BSR XOUTCH; MOVEQ 3,D1; BSR.W PBLANK; RTS; INSERT: MOVEM.L D0/A1-A5,TOSTACK; MOVEQ 0,D0; CMPA.L FROMAD,TOAD; !TOAD MUSS >= SEIN BLT.B INS0; LEA.L MONSTART,A4; LEA.L BLOCKENDE,A5; CMPA.L TOAD,A4; !ZIELAD MONITORENDE ? BLT.B INS1; !JA INS0: MOVEQ 1,D0; !WENN FEHLER INS1: TST.L D0; MOVEM.L FROMSTACK,D0/A1-A5; BNE.B INS4; !WENN OK Z=1 ADDQ.L 1,PTR; BSR.W READHEX; BNE.B INS3; INS2: MOVE.B D0,(FROMAD)+; CMPA.L FROMAD,TOAD; BGE.B INS2; SUBQ.L 1,PTR; BRA.B INSEND; INS3: SUBQ.L 1,PTR; INS4: BSR.W PFEHLER; INSEND: RTS; PFEHLER: BSR.W PCRLF; BSR.W TEXT; DC 'ADRESSEN/DATUM FALSCH ODER NICHT ERLAUBT !!!';DC.W $0704; MOVE.B #13,1(PTR); !BEGRENZT INPUTPUFFER RTS; GETLINE: MOVEM.L D0-A0,TOSTACK; MOVEQ ' ',D4; MOVEQ 13,D5; MOVEQ $7F,D6; !SCHNELLE VERGLEICHE MOVEQ ':',D7; GETLINEY: LEA.L INBUF,PTR; !PUFFERANFANG LEA.L INBUF+BUFLEN-2,A4REG; !PUFFERENDE BRA.S INLINE; DELETE: LEA.L INBUF,A0; CMPA.L A0,PTR; BEQ.S INLINE; MOVEQ $8,D0; BSR XOUTCH; MOVEQ ' ',D0; BSR XOUTCH; MOVEQ $8,D0; BSR XOUTCH; SUBQ.L 1,PTR; INLINE: BSR XINCH; CMP.B D6,D0; !$7F BEQ.S DELETE; CMP.B D4,D0; !' ' GEHT SCHNELLER BCC.S INLINE2; CMPI.B $8,D0; BEQ.S DELETE; CMP.B D5,D0; !$0D BEQ.S INLINE1; CMPI.B ' ',D0; BLT.B INLINE; INLINE2: CMPA.L PTR,A4REG; BLT.S INLINE; INLINE1: MOVE.B D0,(PTR)+; CMP.B INBUF,D7; !':' BEI INTEL-FORMAT ECHO UNTERDRUECKEN BEQ.S INLINE3; CMPI.B 'S',INBUF; BEQ.S INLINE3; BSR XOUTCH; INLINE3: CMP.B D5,D0; !$0D BNE.S INLINE; GETLINEX: MOVEM.L FROMSTACK,D0-A0; RTS; HELP: BSR.W PCRLF; BSR.W ZEIGE_ADR; MOVE.L A5,-(A7); LEA.L TEXX1,A5; BSR.W PDATA; BSR.W XINCH; !WEITER ? CMPI.B 13,D0; BEQ.B HELP1; !ABBRUCH LEA.L TEXX2,A5; BSR.W PDATA; BSR.W XINCH; !WEITER ? CMPI.B 13,D0; BEQ.B HELP1; !ABBRUCH LEA.L TEXX3,A5; BSR.W PDATA; HELP1: MOVE.L (A7)+,A5; RTS; TEXX1: DC ' Bitte beachten: Eingaben zumeist als Bytes, teilweise Mehrfacheingabe'; DC.B 10;DC.B 13; DC ' *********************************************************************'; DC.B 10;DC.B 13; DC 'xxxx :Anzeige eines Byte bei Adresse xxxx'; DC.B 10;DC.B 13; DC ' :Anzeige der naechsten 16 Byte'; DC.B 10;DC.B 13; DC '; {;;;;;;;} :wie zuvor, jedoch rueckwaerts'; DC.B 10;DC.B 13; DC 'xxxx= aa bb cc ... :Eingabe von Bytes ab xxxx'; DC.B 10;DC.B 13; DC '= 42 4C 41 2D 42 4C 41 ... :Fortsetzen der Eingabe'; DC.B 10;DC.B 13; DC 'xxxx="ASCII-TEXT :natuerlich auch fuer Strings'; DC.B 10;DC.B 13; DC 'xxxxL {LLLLLL} :disass. Zeilen ab xxxx, eine pro L'; DC.B 10;DC.B 13; DC '\ {\\\\\\} :disass. 23 Zeilen ab letzter Adresse'; DC.B 10;DC.B 13; DC 'xxxx.yyyy :dump von - bis'; DC.B 10;DC.B 13; DC 'xxxx.yyyyL :disass. von - bis'; DC.B 10;DC.B 13; DC 'xxxx.yyyyH aa bb :hunt sucht Bytes aa bb im Bereich; mit dump'; DC.B 10;DC.B 13; DC 'xxxx.yyyyH+ aa bb :ebenso, jedoch disass., wenn gerade Adresse'; DC.B 10;DC.B 13; DC 'xxxx.yyyyH+ ?? c? ? :ein Joker pro Nibble, Blanks synchronisieren'; DC.B 10;DC.B 13; DC 'xxxx.yyyyH aa %10?? b? :% = binaeres Suchkriterium, rechtsbuendig'; DC.B 10;DC.B 13; DC 'xxxx.yyyyH"jABCDE :sucht ASCII-String, Zeichen j nach " =Joker'; DC.B 10;DC.B 13; DC 'xxxx.yyyyH+" ABC : =Joker, + bedeutet BIT7 wird nicht beachtet'; DC.B 10;DC.B 13; DC '1000.1500H+ ????????49FA :Suchen mit Vorgeschichte, max. 20 Byte'; DC.B 10;DC.B 13; DC 'xxxx.yyyyI ff :insert, fuellt Speicher von - bis mit ff'; DC.B 10;DC.B 13; DC 'zzzz :Berechnung des Ausdrucks '; DC.B 10;DC.B 13;DC.B 10; DC 'Operanden eines Ausdrucks:'; DC.B 10;DC.B 13; DC 'abcd: :Zahleneingabe normalerweise in hex'; DC.B 10;DC.B 13; DC '#12345: :Eingabe einer Dezimalzahl'; DC.B 10;DC.B 13; DC '$Rx, $SS, $US, $SR, $PC :Verwendung eines Registerinhalts'; DC.B 10;DC.B 13;DC.B 10; DC 'Operatoren eines Ausdrucks:'; DC.B 10;DC.B 13; DC '( ) + - * / :Grundrechenarten und Klammern (10-fach)'; DC.B 10;DC.B 13; DC '- = negieren des Wertes, ~ = invertieren aller Bits eines Wertes'; DC.B 10;DC.B 13; DC '^ = bitweise OR, : = bitweise EOR, & = bitweise AND'; DC.B 10;DC.B 13;DC.B 10; DC 'Ausdruecke koennen auch bei Adressangaben benutzt werden !'; DC.B 10;DC.B 13;DC.B 4;EVEN; COMTAB: DC.W 'D@'; !FUER DATENREGISTER DC.L #DATREG; DC.W 'A@'; !FUER ADRESS-REGISTER DC.L #ADREG; DC.W 'B@'; !FUER BP DC.L #BREAKP; DC.W 'SS'; !SUPERVISOR-STACK DC.L #SSTACKP; DC.W 'US'; !USER-STACK DC.L #USTACKP; DC.W 'SR'; !STATUS-REGISTER DC.L #STATREG; DC.W 'PC'; !PC DC.L #PROCOUN; DC.W 'DB'; !DISPLAY BREAKPOINTS DC.L #DISPLBP; DC.W 'CB'; !CLEAR BREAKPOINTS DC.L #CLEARBP; DC.W 'RS'; !SAVE REGISTER DC.L #RSAVE; DC.W 'RL'; !LOAD ALTERN. REGISTERSATZ DC.L #RLOAD; DC.W 'd@'; !FUER DATENREGISTER DC.L #DATREG; DC.W 'a@'; !FUER ADRESS-REGISTER DC.L #ADREG; DC.W 'b@'; !FUER BP DC.L #BREAKP; DC.W 'ss'; !SUPERVISOR-STACK DC.L #SSTACKP; DC.W 'us'; !USER-STACK DC.L #USTACKP; DC.W 'sr'; !STATUS-REGISTER DC.L #STATREG; DC.W 'pc'; !PC DC.L #PROCOUN; DC.W 'db'; !DISPLAY BREAKPOINTS DC.L #DISPLBP; DC.W 'cb'; !CLEAR BREAKPOINTS DC.L #CLEARBP; DC.W 'rs'; !SAVE REGISTER DC.L #RSAVE; DC.W 'rl'; !LOAD ALTERN. REGISTERSATZ DC.L #RLOAD; DC.W -1; !TABELLENENDE DECODE: BSR PCRLF; !BEFEHLE MIT ',' CLR.B EVENFLAG; !LOESCHEN ADDQ.L 1,PTR; !AUF NAECHSTES ZEICHEN LEA.L COMTAB,A0REG; MOVE.B (PTR)+,D1; !1.ZEICHEN LESEN ASL.W 8,D1; !UND NACH OBEN SCHIEBEN MOVE.B (PTR)+,D1; !2.ZEICHEN LESEN DECODE1: MOVE.W (A0REG)+,D0; !TABELLE LESEN BPL.S DECODE2; SUBQ.L 1,PTR; !WEGEN FEHLERANZEIGE BRA.W MONFEHL; !ENDE DER TABELLE DECODE2: MOVEA.L (A0REG)+,ZIELAD; !ADRESSE LADEN CMPI.B '@',D0; !2.ZEICHEN=@ ? BNE.S DECODE3; !NEIN MOVE.B D1,D0; !UEBERNEHMEN CMPI.B '0',D0; !KLEINER ALS 0 ? BMI.S DECODE1; !JA CMPI.B '8',D0; !GROESSER ALS 7 BPL.S DECODE1; !JA DECODE3: CMP.W D0,D1; !GEFUNDEN ? BNE.S DECODE1; !NEIN SUBA.L #DECODEX,ZIELAD; !OFFSET BERECHNEN DECODEX: JSR 0(*,ZIELAD.L); !ROUITNE PC-REL. ANSPRINGEN BEQ.W MONX1; !WEITER IM MONITOR SUBQ.L 1,PTR; !FUER FEHLERANZEIGE BRA.W MONFEHL; !FEHLER IN ROUTINE DISPLBP: BSR BLANKWEG; CMPI.B 13,D0; !ENDE DER ZEILE ? BNE.S DISPLBPX; !NEIN FEHLER MOVEM.L D0-A6,-(A7); !WEGEN OUTREG-ROUTINE !!! MOVE.L $FF,D7; !AUSGABE-MASKE LEA.L BPRG,A0; !BASIS-ADRESSE DER WERTE LEA.L BPTAB,A1; !BASIS DER NAMEN BRA.W OUTREG0; !AUSGEBEN DISPLBPX: RTS; !FEHLER BREAKP: ADD.B $B,D0; !BREAKPOINTS MIT OFFSET WIE ADREG ! TAS EVENFLAG; !NUR GERADE ADRESSE ADREG: SUBI.B $30,D0; ADD.B 8,D0; !OFFSET AUF WERTE BRA.S DATREG1; !UND WEITER SSTACKP: MOVEQ 15,D0; !OFFSET AUF SUPERVISOR-STACK TAS EVENFLAG; !NUR GERADE ADRESSEN BRA.S DATREG1; USTACKP: MOVEQ 16,D0; !USER-STACK TAS EVENFLAG; !NUR GERADE ADRESSEN BRA.S DATREG1; STATREG: MOVEQ 17,D0; !STATUS-REGISTER BRA.S DATREG1; PROCOUN: MOVEQ 18,D0; !PC TAS EVENFLAG; !NUR GERADE ADRESSEN BRA.S DATREG1; DATREG: SUBI.B $30,D0; !OFFEST BESTIMMEN DATREG1: MOVEQ 0,INDEX; !D7 LOESCHEN CMPI.B 15,D0; !STACK-PTR ? BNE.S DATREG5; TAS EVENFLAG; !NUR GERADE ADRESSEN ZULASSEN BTST.B 5,STATUSREG; !USERMODE ? BNE.S DATREG5; ADDQ 1,D0; !DANN US-PTR DATREG5: MOVE.B D0,INDEX; LSL.L 1,INDEX; !MAL 2 MOVE.L INDEX,D6;!D6 FUER REGISTER-TEXT LSL.L 1,INDEX; !INDEX FUER ADRESSE LEA.L REGLIST,A0REG; !BASISADRESSE DER REGISTER BSR BLANKWEG; MOVE.B (PTR)+,D0; !ZEICHEN LESEN CMPI.B '=',D0; !AENDERUNG ? BNE.S DATREG3; !NEIN, NUR ANZEIGEN BSR BLANKWEG; BSR READHEX; !NEUEN WERT HOLEN BNE.S DATREG2; !FEHLER TST.B EVENFLAG; !NUR GERADE ADRESSEN ERLAUBT ? BEQ.S DATREG4; !NEIN BTST 0,D0; !GERADE ? BEQ.S DATREG4; !JA SUBQ.L 1,PTR; BRA.W MONFEHL; !AUF UNGERADES BIT ZEIGEN DATREG4: MOVE.L D0,0(A0REG,INDEX.W); !WERT ABLEGEN DATREGX: ORI.B 4,CCR; !Z=1, KEIN FEHLER DATREG2: RTS; !FEHLER, WENN Z=0 !REGISTER AUSGEBEN DATREG3: CMPI.B 13,D0; !ENDE DER ZEILE ? BNE.S DATREG2; !NEIN, FEHLER LEA.L REGTAB,A1;!NAMEN DER REGISTER, BASIS MOVE.W 0(A1,D6.W),D0; !LESEN BSR OUTREG5; !UND ANZEIGEN MOVE.L 0(A0,INDEX.W),D0; !WERT BSR PRINTL; BSR PCRLF; BRA.S DATREGX; !FERTIG STEP: TAS STEPFLAG; BRA.S TRACE1; TRACE: CLR.B STEPFLAG; TRACE1: BSET.B 7,STATUSREG; !TRACE-BIT EIN BSR.W SETPCREG; !NEUER PC-WERT ? TAS SHOWFLAG; !BEIM AUFRUF IMMER ANZEIGEN CLR.B STOP1; TAS STOP2; !DISASS DARF NICHT STOPPEN CLR.L ALTERREGFLAG; MOVEQ 7,D1; !OP-CODE BEI BREAKPOINTS RETTEN LEA.L BPRG,A0; !HIER STEHEN DIE ADRESSEN TRACE2: MOVE.L (A0)+,D2; !ADRESSE LADEN BEQ.S TRACE3; !0=KEIN BP MOVE.L D2,A1; !FUER (A1) MOVE.L (A1),28(A0); !CODE RETTEN , OFFSET 28 WEGEN (A0)+ TRACE3: DBF D1,TRACE2; !MAX. 8 BRA.W TRACEIN1; !UND AUSFUEHREN TRACEVEC: IF MC68000,1; MOVE.L A6,-(A7); LEA.L VARIABLE,A6; MOVEM.L D0-A5,(A6); MOVE.L (A7)+,14*4(REGLIST); ENDIF; IF MC68000,0; MOVEM.L D0-A6,REGLIST; !UND ALLES RETTEN ENDIF; MOVE.L USP,A0; MOVE.L A0,USPTR; MOVE.W (A7)+,STATUSREG; MOVE.L (A7)+,PCREG; MOVE.L A7,SSPTR; MOVE.L INITSTACK,A7; !FUER MONITOR TST.B SHOWFLAG; !SOLL ANZEIGE ERFOLGEN ? BEQ.S TRACEIN01; !NEIN TST.L ALTERREGFLAG; !ANZEIGEN ? BEQ.S TRACEIN0; !NEIN BSR PCRLF; BSR OUTREGDIS; TRACEIN0: BSR PCRLF; !LEERZEILE TRACEIN01: CLR.L ALTERREGFLAG; !REGISTERANZEIGE LOESCHEN LEA.L BEGIN,A2; !POINTERANFANG MOVE.L PCREG,PROGRAMMZ; !NEUER WERT MOVE.L PCREG,A1; !FUER SCANNER BSR.W SCANNER; !NEUEN BEFEHL ZERLEGEN CLR.B SOURCEFLAG; !QUELLE UND ZIEL ERMITTELN BSR.W CALCSOURCE; BNE.S TESTDISPLAY; !KEINE EFF.-SOURCE-ADR. TAS SOURCEFLAG; !GUELTIG SETZEN MOVE.L D0,SOURCEADR; !UND ABLEGEN TESTDISPLAY: CLR.B DESTFLAG; BSR.W CALCDEST; BNE.S TESTDISPLAY1; !KEINE EFF.-DEST.-ADR. TAS DESTFLAG; !GULETIG SETZEN MOVE.L D0,DESTADR; !UND ABLEGEN TESTDISPLAY1: !BSR BEREICHTEST; BSR.W SOFTBREAK; !BEI BP AUF STEP UMSCHALTEN TST.B STEPFLAG; BEQ.S TRACEIN2; !NUR BEI TRACE TRACEIN1: BSR SHOWNEXT; MOVEQ '?',D0; BSR XOUTCH; BSR XINCH; CMPI.B $D,D0; !ABBRUCH ? BEQ.W WARM0; !JA CMPI.B 'T',D0; !SOLL AUF TRACE UMGESCHALTET WERDEN ? BEQ.S TRACEIN31;!JA CMPI.B 't',D0; BNE.S TRACEIN3; TRACEIN31: CLR.B STEPFLAG; !NUNMEHR TRACE BRA.S TRACEIN2; TRACEIN3: CMPI.B 'S',D0; !WENN BEIM AUFRUF VON TRACE S GEDRUECKT WIRD BEQ.S TRACEIN21;!AUF STEP UMSCHALTEN CMPI.B 's',D0; BNE.S TRACEIN2; TRACEIN21: TAS STEPFLAG; !DOCH UMSCHALTEN TRACEIN2: TST.B STEPFLAG; BNE.W GOCOM1; BSR SHOWNEXT; TST.B INBUFCTR; !ANHALTEN? BEQ.W GOCOM1; !NEIN BSR XINCH; BSR XINCH; CMPI.B 13,D0; !ABBRUCH ? BEQ.W WARM0; !JA CMPI.B 'S',D0; !WEITER MIT STEP ? BEQ.S TRACEIN4; !NEIN CMPI.B 's',D0; BNE.W GOCOM1; TRACEIN4: TAS STEPFLAG; !WEITER MIT STEP BRA.W GOCOM1; SETPCREG: TST.B SETPCFLAG; !IST PC-WERT IN DER KOMMANDOZEILE ? BEQ.S SETPCEND; !NEIN TST.B D0; !MODE=D0, IST MODE BEEINFLUSST WORDEN ? BNE.W MONFEHLX; !JA, DANN EINGABE NICHT OK MOVE.L FROMAD,D0; !HIER STEHT DIE ERSTE ZAHL DER EINGABE BCLR 0,D0; !NUR GERADE ADRESSEN MOVE.L D0,PCREG; !NEUER PC SETPCEND: RTS; !AUFRUF EINER ROUTINE ALS SUBROUTINE JUMPSUB: LEA.L JUMPSUB1,A1; !RETURN ADRESSE BTST.B 5,STATUSREG; !WOHIN DAMIT BNE.S JUMP0; MOVEA.L USPTR,A0; MOVE.L A1,-(A0); !AUF USER-STACK MOVE.L A0,USPTR; BRA.W GOTO; JUMP0: MOVEA.L SSPTR,A0; MOVE.L A1,-(A0); !UND RETURNADRESSE AUF S-STACK MOVE.L A0,SSPTR; !NEUEN WERT ABLEGEN BRA.S GOTO; !SONST WIE GO JUMPSUB1: IF MC68000,1; MOVE.W SR,-(A7); MOVE.L A6,-(A7); LEA.L VARIABLE,A6; MOVEM.L D0-A5,REGLIST; MOVE.L (A7)+,14*4(REGLIST); !A6 REGISTER MOVE.W (A7)+,STATUSREG; ENDIF; IF MC68000,0; MOVE.W SR,STATUSREG; !REGISTER RETTEN MOVEM.L D0-A7,REGLIST; ENDIF; LEA.L JUMPSUB2,A1; MOVEA.L @$80,A0; MOVE.L A1,@$80; TRAP 0; JUMPSUB2: ADDQ 6,A7; MOVE.L A0,@$80; !SS-MODE MOVE.L A7,SSPTR; MOVE.L USP,A0; MOVE.L A0,USPTR; BSR REMOVEBP; BRA.W WARM0; !UND ZURUECK GOCOMERR: RTS; !FUER FEHLER BEI GO GOTO: BCLR.B 7,STATUSREG; !TRACE IMMER AUS BSR.W SETPCREG; !TESTEN OB NEUER WERT EINGEGEBEN GOCOM2: MOVEQ 0,D4; !COUNT FUER BREAKPOINTS MOVE.W #$4E4E,D1; !BREAK= TRAP 14 LEA.L BPRG,A0; !ZEIT AUF 1. BREAKPOINT MOVEQ 7,D2; !MAX. 8 BP GOCOM3: MOVE.L (A0)+,D3; !WERT VON BP BEQ.S GOCOM4; !0, WENN NICHT AKTIV ADDQ.B 1,D4; !ZAEHLEN MOVEA.L D3,A2; !ZIELADRESSE NACH A2 MOVE.L (A2),28(A0); !OPCODE RETTEN MOVE.W D1,(A2); !UND MIT TRAP 14 UEBERSCHREIBEN GOCOM4: DBF D2,GOCOM3; !ACHTMAL TST D4; !BREAKPOINTS AKTIV ? BEQ.S GOCOM1; !NEIN BSR PCRLF; LEA.L MESSACT,A5; BSR PDATA; !MELDUNG AUSGEBEN MOVE.B D4,D0; !ANZAHL ADD.B '0',D0; !ALS ASCII BSR XOUTCH; !AUSGEBEN BSR PCRLF; GOCOM1: MOVEA.L USPTR,A0; MOVE.L A0,USP; !USER-STACKPTR. IF MC68000,1; MOVEM.L REGLIST,D0-A7; LEA.L VARIABLE,A6; MOVE.L PCREG,-(A7); MOVE.W STATUSREG,-(A7); MOVEM.L REGLIST,D0-A6; !A6 RESTAURIEREN ENDIF; IF MC68000,0; MOVEM.L REGLIST,D0-A7; !ALLE REGISTER LADEN MOVE.L PCREG,-(A7); !PC AUF STACK MOVE.W STATUSREG,-(A7); !STATUS HINTERHER ENDIF; RTE; !UND AB GEHT'S TRAP14: IF MC68000,1; MOVE.L A6,-(A7); LEA.L VARIABLE,A6; MOVEM.L D0-A5,(A6); MOVE.L (A7)+,14*4(REGLIST); ENDIF; IF MC68000,0; MOVEM.L D0-A6,REGLIST; !UND ALLES RETTEN ENDIF; MOVE.L USP,A0; MOVE.L A0,USPTR; MOVE.W (A7)+,STATUSREG; MOVE.L (A7)+,PCREG; MOVE.L A7,SSPTR; MOVE.L INITSTACK,A7; !DEFEULT FUER MONITOR SUBQ.L 2,PCREG; !ADJUST PC BSR PCRLF; LEA.L TEXTBP,A5; BSR PDATA; !TEXT AUSGEBEN, DASS BP ERREICHT MOVE.L PCREG,D0; BSR PRINTL; !PC AUSGEBEN BSR PCRLF; !UND NOCH BREAKPOINTS ENTFERNEN BRA.W WARM0; REMOVEBP: LEA.L BPRG,A0; !BASISADRESSE MOVEQ 7,D2; !MAX. 8 REMOVEBP1: MOVE.L (A0)+,D3; !ADRESSE HOLEN BEQ.S REMOVEBP2; !KEIN BP MOVEA.L D3,A2; MOVE.L 28(A0),(A2); !RESTORE REMOVEBP2: DBF D2,REMOVEBP1; RTS; CLEARBP: BSR BLANKWEG; CMPI.B 13,D0; !ZEILE MIT 0D ABGESCHLOSSEN ? BNE.S CLEARBP2; !NEIN, FEHLER CLEARBPX: LEA.L BPRG,A0; !ADRESSE MOVEQ 15,D0; !ANZAHL MAL 2 -1 FUER ADRESSEN+CODE CLEARBP1: CLR.L (A0)+; !LOESCHEN DBF D0,CLEARBP1; SETEQUAL: ORI.B 4,CCR; !Z=1 CLEARBP2: RTS; !FEHLER, WENN Z=0 REGMOVE: LEA.L REGLIST,A0; LEA.L ALTREGLIST,A1; !ZIEL MOVE.W #BPRG-REGLIST-1,D0; !COUNTER RTS; RSAVE: BSR.S REGMOVE; !REGISTER VORBESETZEN RSAVE1: MOVE.B (A0)+,(A1)+; DBF D0,RSAVE1; !UMSCHAUFELN BRA.S SETEQUAL; !ALLES OK RLOAD: BSR.S REGMOVE; RLOAD1: MOVE.B (A1)+,(A0)+; DBF D0,RLOAD1; BRA.S SETEQUAL; SHOWSTATUS: MOVEQ 70,D1; MOVEQ '=',D0; SHOWSTAT1: BSR XOUTCH; DBF D1,SHOWSTAT1; BSR PCRLF; MOVEQ 17*2,D0; !OFFSET FUER NAMEN LEA.L REGTAB,A0; !BASISADRESSE MOVE.W (A0,D0.W),D0; !NAMEN LESEN BSR OUTREG5; !UND ANZEIGEN MOVEQ '$',D0; BSR XOUTCH; MOVE.W STATUSREG,D0; !WERT HOLEN MOVE.W D0,D7; !RETTEN BSR PRINTW; !UND ANZEIGEN MOVEQ 1,D1; BSR PBLANK; !1 BLANK MOVEQ '(',D0; BSR XOUTCH; MOVEQ '-',D0; !DEFAULT BTST 15,D7; !TRACE-BIT ? BEQ.S SHOWS1; !NEIN MOVEQ 'T',D0; SHOWS1: BSR XOUTCH; MOVEQ '-',D0; BTST 14,D7; BEQ.S SHOWS2; MOVEQ '1',D0; SHOWS2: BSR XOUTCH; MOVEQ 'U',D0; BTST 13,D7; !SUPERVISOR - USER ? BEQ.S SHOWS3; !USER MOVEQ 'S',D0; SHOWS3: BSR XOUTCH; MOVEQ '-',D0; BTST 12,D7; BEQ.S SHOWS4; MOVEQ '1',D0; SHOWS4: BSR XOUTCH; MOVEQ '-',D0; BTST 11,D7; BEQ.S SHOWS5; MOVEQ '1',D0; SHOWS5: BSR XOUTCH; MOVEQ '0',D0; BTST 10,D7; !INTERRUPTS BEQ.S SHOWS6; MOVEQ '1',D0; SHOWS6: BSR XOUTCH; MOVEQ '0',D0; BTST 9,D7; BEQ.S SHOWS7; MOVEQ '1',D0; SHOWS7: BSR XOUTCH; MOVEQ '0',D0; BTST 8,D7; BEQ.S SHOWS8; MOVEQ '1',D0; SHOWS8: BSR XOUTCH; MOVEQ '-',D0; BTST 7,D7; BEQ.S SHOWS9; MOVEQ '1',D0; SHOWS9: BSR XOUTCH; MOVEQ '-',D0; BTST 6,D7; BEQ.S SHOWS10; MOVEQ '1',D0; SHOWS10: BSR XOUTCH; MOVEQ '-',D0; BTST 5,D7; BEQ.S SHOWS11; MOVEQ '1',D0; SHOWS11: BSR XOUTCH; MOVEQ '-',D0; BTST 4,D7; BEQ.S SHOWS12; MOVEQ 'X',D0; SHOWS12: BSR XOUTCH; MOVEQ '-',D0; BTST 3,D7; BEQ.S SHOWS13; MOVEQ 'N',D0; SHOWS13: BSR XOUTCH; MOVEQ '-',D0; BTST 2,D7; BEQ.S SHOWS14; MOVEQ 'Z',D0; SHOWS14: BSR XOUTCH; MOVEQ '-',D0; BTST 1,D7; BEQ.S SHOWS15; MOVEQ 'V',D0; SHOWS15: BSR XOUTCH; MOVEQ '-',D0; BTST 0,D7; BEQ.S SHOWS16; MOVEQ 'C',D0; SHOWS16: BSR XOUTCH; MOVEQ ')',D0; BSR XOUTCH; RTS; !ANZEIGE DES BEFEHLS UND DER REGISTER BEI STEP UND TRACE SHOWNEXT: MOVE.L PCREG,FROMAD; MOVEA.L FROMAD,TOAD; BSR X; !DISASS BEFEHL BSR PCRLF; BSR SHOWSTATUS; LEA.L BEGIN,A2; CLR.B SOURCEFLAG; !QUELLE UND ZIEL ERMITTELN BSR.W CALCSOURCE; BNE.S SHOWNEXT2; !KEINE EFF.-SOURCE-ADR. TAS SOURCEFLAG; !GUELTIG SETZEN MOVE.L D0,SOURCEADR; !UND ABLEGEN SHOWNEXT2: CLR.B DESTFLAG; BSR.W CALCDEST; BNE.S SHOWNEXT3; !KEINE EFF.-DEST.-ADR. TAS DESTFLAG; !GULETIG SETZEN MOVE.L D0,DESTADR; !UND ABLEGEN SHOWNEXT3: MOVEQ 5,D1; BSR.W PBLANK; LEA.L TSOURCE,A5; BSR.W PDATA; !TEXT AUSGEBEN MOVEQ 11,D1; !DEFAULT, WENN KEINE ADRESSE TST SOURCEFLAG; BPL.S SHOWNEXT4; !NUR BLANKS AUSGEBEN MOVE.L SOURCEADR,D0; BSR.W PRINTL; !ADRESSE AUSGEBEN MOVEQ 3,D1; !NACH DER AUSGABE EIN BLANK SHOWNEXT4: BSR.W PBLANK; LEA.L TDEST,A5; BSR.W PDATA; !TEXT AUSGEBEN TST DESTFLAG; BPL.S SHOWNEXT5; !KEINE ADRESSE AUSGEBEN MOVE.L DESTADR,D0; BSR.W PRINTL; !ADRESSE AUSGEBEN SHOWNEXT5: MOVEQ 2,D1; BSR.W PBLANK; !NOCH ZWEI BLANKS HINTERHER TST.L ALTERREGFLAG; BEQ.S SHOWNEXT1; BSR PCRLF; BSR OUTREGDIS; !AKTUELLE REGISTER ANZEIGEN SHOWNEXT1: RTS; TSOURCE: DC 'QUELLE = $';DC.B 4;EVEN; TDEST: DC 'ZIEL = $';DC.B 4;EVEN; !ACHTUNG: A4 ENTHAELT EINE UNGERADE ADRESSE SBEFMODE ODER DBEFMODE !!! BEFMODE: EQU (A4); !MODUS DES AKTUELLEN BEFEHLS BASREG: EQU 1(A4); !VERWENDETES REGISTER INDEXREG: EQU 2(A4); !INDEXREGISTER, WENN VORHANDEN DISPLACEM: EQU 3(A4); !OFFSET, ABS.-ADR. ODER REGLISTE BASE A2; !FUER POINTER IM RAM BEFBASIS: DS.L 1; !BASISADR. VOM BEFEHL IM SCANNER BEFEHL: DS.W 1; !BEFEHL AUS SPEICHER BEFINDEX: DS.W 1; !INDEX AUF KLARTEXT BEFEXT: DS.B 1; !EXTENSION .B, .W, .L SBEFMODE: DS.B 1; !SOURCE-BEFEHLS-MODE SBASREG: DS.B 1; !SOURCE BASIS REGISTER SINDEXREG: DS.B 1; !SOURCE-INDEX-REG. SDISPLACEM: DS.L 1; !SOURCE-DISPLACEMENT ODER ASB.-ADR. BEFLEN: DS.B 1; !LAENGE DES BEFEHLS DBEFMODE: DS.B 1; !DESTINATION-BEFEHLS-MODE DBASREG: DS.B 1; !DEST. BASIS REGISTER DINDEXREG: DS.B 1; !DEST.-INDEX-REG. DDISPLACEM: DS.L 1; !DEST.-DISPLACEMENT ODER ABS-ADR. PROGRAMMZ: DS.L 1; !ADRESSE DES MOMENT. BEFEHLS ENDADR: DS.L 1; !LETZTE ZU DISASS. ADR. POINTERENDE: DS.B 0; HOLEADWERT: ORI.B 8,D1; !DA IN BASREG NUR DIE NUMMER STEHT !!! HOLEREGWERT: ANDI.W $1F,D1; !IN D1 STEHT DER 1/4 INDEX AUF DIE LISTE CMPI.W 15,D1; !STACK-PTR ? BNE.S HOLEAD1; BTST.B 5,STATUSREG; BNE.S HOLEAD1; !SS-MODE ADDQ.W 1,D1; !US-PTR HOLEN HOLEAD1: ASL.W 2,D1; !MASKIEREN UND EFF. INDEX LEA.L REGLIST,A0; MOVE.L (A0,D1.W),D1; !WERT HOLEN RTS; CALCSOURCE: LEA.L SBEFMODE,A4; !EFF. QUELL-ADRESSE BERECHNEN, BASISREGISTER BRA.S CALCADR1; CALCDEST: LEA.L DBEFMODE,A4; !EFF. ZIEL-ADRESSE BERECHNEN CALCADR1: MOVEM.L D1-D2,-(A7); !HILFSREGISTER RETTEN MOVE.B BEFMODE,D0; !MODUS LADEN CMPI.B 3,D0; !WENN KLEINER 3, DANN NUR REGISTER DIREKT BLT.W CALCEND; !ZU KLEIN BEQ.S CALCMODE3; CMPI.B 13,D0; !ZU GROSS ? BGT.W CALCEND; !JA BRA.S CALCMODE4; CALCMODE3: MOVE.B BASREG,D1; !ADDRESS-REGISTER INDIREKT BSR.S HOLEADWERT; MOVE.L D1,D0; !IN D0 DAS ERGEBNIS BRA.S CALCENDX; !GEFUNDEN CALCMODE4: CMPI.B 4,D0; !MODE 4? INDIREKT MIT POSTINCREMENT BEQ.S CALCMODE3; !WIE MODE3 CMPI.B 5,D0; !MODE5? BNE.S CALCMODE9; MOVE.B BASREG,D1; !INDIREKT MIT PREDECR. BSR.S HOLEADWERT; MOVE.L D1,D0; MOVEQ 0,D1; !LOESCHEN MOVE.B BEFEXT,D1; !LAENGE DES BEFEHLS SUB.L D1,D0; !VOM MOMENTANEN WERT ABZIEHEN: PREDECREMENT BRA.S CALCENDX; CALCMODE9: CMPI.B 9,D0; !MODE9 ? ABS.W BNE.S CALCMODE10; CALCABSADR: MOVE.L DISPLACEM,D0; !ABS.-WERT BRA.S CALCENDX; CALCMODE10: CMPI.B 10,D0; BEQ.S CALCABSADR; !ABS.L !JETZT SIND NUR NOCH d(Xn), d(Xn,Ri.W) und d(Xn,Ri.L) MOEGLICH MOVE.L DISPLACEM,D2; !AUF JEDEN FALL CMPI.B 11,D0; !PC-REL.? BGE.S CALCPCREL;!JA MOVE.B BASREG,D1; !WENN An BSR.W HOLEADWERT;!ADDRESS-REGISTER BRA.S CALCXN; CALCPCREL: MOVE.L PCREG,D1;!PC-WERT HOLEN ADDQ.L 2,D1; !KOREKTUR FUER PC CALCXN: ADD.L D1,D2; !UND SUMMIEREN CMPI 6,D0; !MODE6 ? d(An) BEQ.S CALCENDY; !JA, FERTIG CMPI 11,D0; !MODE11 ? d(PC) BEQ.S CALCENDY; !DANN FERTIG MOVE.B INDEXREG,D1; BSR.W HOLEREGWERT; !INDEX HOLEN CMPI 8,D0; !MODE8? INDEX.L BEQ.S CALCXN2; !JA, DANN WERT OK CMPI 13,D0; !MODE13 INDEX.L BEQ.S CALCXN2; !DANN WERT OK EXT.L D1; !WENN .W, DANN NOCH ERWEITERN CALCXN2: ADD.L D1,D2; !INDEX-REG. DAZU, JETZT IST ALLES OK CALCENDY: MOVE.L D2,D0; !IN D0 STEHT DAS ERGEBNIS CALCENDX: ORI.B 4,CCR; !STAUS=EQUAL, WENN ERGEBNIS KORREKT CALCEND: MOVEM.L (A7)+,D1-D2; !HILFSREGISTER ZURUECK RTS; SOFTBREAK: LEA.L BPRG,A0; !BASISADRESSE DER BREAKPOINTS MOVE.L PCREG,D0;!FUER COMPARE MOVEQ 7,D1; !FUER 8 BREAKPOINTS SOFTBREAK1: CMP.L (A0)+,D0; !VERGLEICHEN DBEQ D1,SOFTBREAK1; !LOOP BIS GLEICH ODER ENDE BNE.S SOFTENDE; !NICHT GEFUNDEN TAS STEPFLAG; !AUF STEP UMSCHALTEN SOFTENDE: RTS; IF MC68000,1; GETLINE_X:: ZEILE_LEN: EQU BUFLEN-2; ! 78 MAX_LEN: EQU D5; LEN: EQU D6; INDEX: EQU D7; CR: EQU $D; CLR_EOL: EQU 5; TAB: EQU 9; PFEIL_RECHTS: EQU $E; BACK_SPACE: EQU $8; DELETE: EQU $7F; DEL_LINE: EQU $13; DEL_CHAR: EQU 4; INS_CHAR: EQU 5; Z_ANFANG: EQU $0B; !ANFANG DER ZEILE CTRL_W: EQU $17; Z_ENDE: EQU $02; REPEAT_BUF: EQU $6; ESCAPE: EQU $1B; MOVEM.L D0-A6,-(A7); !ALLES RETTEN TRAP 1; !A0 VORBESETZEN MOVEQ 0,LEN; MOVEQ 0,INDEX; MOVEQ ZEILE_LEN,MAX_LEN; LEA.L INBUF,A2; !POINTER AUF 1.ZEICHEN LEA.L CONVERTFLAG,A4; INLOOP: BSR XINCH; !ZEICHEN HOLEN CMP.B #$1C,D0; !ALT-MODE BNE.B INLOOP1; NOT.B (A4); BRA.B INLOOP; INLOOP1: CMP.B 'a',D0; !KLEINSCHRIFT ? BLT.B INLOOP2; CMP.B 'z',D0; !NUR KLEINE BUCHSTABEN BHI.S INLOOP2; TST.B (A4); !KONVERTIEREN WENN=1 BEQ.B INLOOP2; SUB.B $20,D0; INLOOP2: CMP.B $D,D0; !ENDE DER EINGABE ? BEQ.W INLOOP3; CMP.B ' ',D0; BLT.W HANDLE_CTRL; !STEUERZEICHEN SEPARAT VERARBEITEN CMPI.B DELETE,D0; BEQ.W HANDLE_CTRL; MOVE.B D0,(A2,INDEX); !ZEICHEN IN PUFFER SCHREIBEN CMPI.B ':',(A2); !INTEL-FORMAT ? BEQ.S INLOOP5; !DANN KEIN ECHO CMPI.B 'S',(A2); !MOTOROLA-FORMAT ? BEQ.S INLOOP5; BSR XOUTCH; !ECHO AUF SCHIRM INLOOP5: CMP.W INDEX,LEN; !TESTEN, OB HINTEN ANHEHAENGT WURDE BHI.S IM_STRING; !NEIN, LAENGE NICHT ERHOEHEN ADDQ.W 1,LEN; IM_STRING: ADDQ.W 1,INDEX; CMP.W MAX_LEN,LEN; !ENDE DES PUFFERS ERREICHT ? BLS.W INLOOP; !NOCH NICHT BSR.W LOESCHE_LINKS; BRA.W INLOOP; INLOOP3: MOVE.B #$0D,(A2,LEN.W); !PUFFER MIT $0D ABSCHLIESSEN ADDQ.W 1,LEN; INLOOP4: CMP.W MAX_LEN,LEN; BCC.S INLOOPEND; !PUFFER IST VOLL CLR.B (A2,LEN.W); !REST DES PUFFERS LOESCHEN ADDQ.W 1,LEN; BRA.S INLOOP4; INLOOPEND: MOVEM.L (A7)+,D0-A6; RTS; HANDLE_CTRL: CMPI.B BACK_SPACE,D0; !TAB NACH LINKS ? BNE.S HANDLE1; BSR.W BEWEGE_LINKS; BRA.W INLOOP; HANDLE1: CMPI.B DELETE,D0; BNE.S HANDLE2; BSR.W LOESCHE_LINKS; BRA.W INLOOP; HANDLE2: CMPI.B DEL_CHAR,D0; BNE.S HANDLE3; BSR.W LOESCHE_CURSOR; BRA.W INLOOP; HANDLE3: CMPI.B INS_CHAR,D0; !BLANK EINFUEGEN ? BNE.S HANDLE4; CMP.W INDEX,LEN; !STEHT DER CURSOR AM ENDE ? BEQ.W INLOOP; !DANN NICHTS MACHEN BSR.W INS_BLANK; BSR.W FUEGE_EIN; BRA.W INLOOP; HANDLE4: CMPI.B PFEIL_RECHTS,D0; BNE.S HANDLE5; BSR.W BEWEGE_RECHTS; BRA.W INLOOP; HANDLE5: CMPI.B REPEAT_BUF,D0; !ALTEN PUFFER AUSGEBEN ? BNE.S HANDLE6; HANDLE50: MOVE.B (A2,INDEX.W),D0; !ALTES ZEICHEN LESEN BEQ.W INLOOP; CMPI.B CR,D0; BEQ.W INLOOP; !JEWEILS DAS ENDE DER ZEICHEN BSR XOUTCH; !ECHO AUF SCHIRM CMP.W INDEX,LEN; !TESTEN, OB HINTEN ANHEHAENGT WURDE BHI.S HANDLE51; !NEIN, LAENGE NICHT ERHOEHEN ADDQ.W 1,LEN; HANDLE51: ADDQ.W 1,INDEX; CMP.W MAX_LEN,LEN; !ENDE DES PUFFERS ERREICHT ? BCS.W HANDLE50; !NOCH NICHT BRA.W INLOOP; HANDLE6: CMPI.B ESCAPE,D0; BNE.S HANDLE7; HANDLE60: BSR.W LOESCHE_ALL; BRA.W INLOOP; HANDLE7: CMPI.B CTRL_W,D0; BNE.W HANDLE8; BSR.W LOESCHE_WORT; BRA.W INLOOP; HANDLE8: CMPI.B TAB,D0; BNE.S HANDLE9; BSR.W SETZE_TAB; BRA.W INLOOP; HANDLE9: CMPI.B Z_ANFANG,D0; BNE.W HANDLE_A; HANDLE91: BSR.W BEWEGE_LINKS; TST.W INDEX; BNE.S HANDLE91; BRA.W INLOOP; HANDLE_A: CMPI.B DEL_LINE,D0; BNE.W HANDLE_B; MOVE.W INDEX,LEN; MOVEQ CLR_EOL,D0; BSR.W XOUTCH; BRA.W INLOOP; HANDLE_B: CMPI.B Z_ENDE,D0; !CURSOR GANZ NACH RECHTS ? BNE.S HANDLE_X; HANDLE_B1: CMP.W INDEX,LEN; !SCHON AM ENDE ? BEQ.W INLOOP; BSR.W BEWEGE_RECHTS; BRA.S HANDLE_B1; HANDLE_X: BRA.W INLOOP; SETZE_TAB: MOVE.W D4,-(A7); MOVE.W INDEX,D4; ADDQ.W 1,D4; NOT.W D4; ANDI.W 7,D4; SET_TAB1: BSR.W BEWEGE_RECHTS; DBF D4,SET_TAB1; MOVE.W (A7)+,D4; RTS; BEWEGE_RECHTS: CMP.W INDEX,LEN; !SCHON AM RECHTEN ENDE BEQ.S BEW_REND; MOVEQ PFEIL_RECHTS,D0; BSR.W XOUTCH; ADDQ.W 1,INDEX; BEW_REND: RTS; BEWEGE_LINKS: TST.B INDEX; BEQ.W BEW_END; !STEHT SCHON LINKS MOVEQ BACK_SPACE,D0; BSR.W XOUTCH; SUBQ.W 1,INDEX; BEW_END: RTS; LOESCHE_CURSOR: TST.W LEN; BEQ.S LC_END; !KEINE ZEICHEN DA CMP.W INDEX,LEN; !CURSOR AUF LETZTEM ZEICHEN ? BEQ.S LC_END; !DANN NICHTS LOESCHEN BSR.W DEL_BLANK; BSR.W LOESCHE_ZEICHEN; LC_END: RTS; LOESCHE_LINKS: TST.W INDEX; !CURSOR SCHON LINKS ? BEQ.S LL_END; !DANN NICHTS LOESCHEN TST.W LEN; !UEBERHAUPT ETWAS ZU LOESCHEN ? BEQ.S LL_END; !NEIN BSR.W BEWEGE_LINKS; BSR.W LOESCHE_CURSOR; LL_END: RTS; LOESCHE_ALL: BSR.W BEWEGE_LINKS; !AN DEN ANFANG DER ZEILE GEHEN TST.W INDEX; BNE.S LOESCHE_ALL; MOVEQ 0,LEN; MOVEQ CLR_EOL,D0; BSR.W XOUTCH; !REST DER ZEILE LOESCHEN RTS; LOESCHE_WORT: CMP.W INDEX,LEN; BNE.S LLL; LOESCHE_WORT1: TST.W INDEX; BEQ.S LLL; BSR.W LOESCHE_LINKS; CMPI.B ' ',(A2,INDEX.W); BNE.S LOESCHE_WORT1; LLL: RTS; LOESCHE_ZEICHEN: MOVEM.L D4/A0-A1,-(A7); LEA.L (A2,INDEX.W),A0; !ZIEL LEA.L 1(A0),A1; !QUELLE SUBQ.W 1,LEN; MOVE.W LEN,D4; SUB.W INDEX,D4; BEQ.S LZ2; LZ1: MOVE.B (A1)+,(A0)+; LZ2: DBF D4,LZ1; MOVEM.L (A7)+,D4/A0-A1; RTS; FUEGE_EIN: MOVEM.L D4/A0-A1,-(A7); LEA.L 1(A2,LEN.W),A0; !ZIEL LEA.L -1(A0),A1; !QUELLE MOVE.W LEN,D4; SUB.W INDEX,D4; BRA.S FE2; FE1: MOVE.B -(A1),-(A0); FE2: DBF D4,FE1; MOVE.B ' ',(A1); !BLANK EINFUEGEN CLR.B (A2,MAX_LEN.W); CMP.W MAX_LEN,LEN; BCC.S FEX; ADDQ.W 1,LEN; FEX: MOVEM.L (A7)+,D4/A0-A1; RTS; CURSOR_AUS: MOVEQ ESCAPE,D0; BSR.W XOUTCH; MOVEQ 'E',D0; BSR.W XOUTCH; RTS; CURSOR_EIN: MOVEQ ESCAPE,D0; BSR.W XOUTCH; MOVEQ 'B',D0; BSR.W XOUTCH; RTS; INS_BLANK: MOVEM.L D0-D7,-(A7); BSR CURSOR_AUS; SUBQ.W 1,MAX_LEN; !FUER VERGLEICH MOVEQ 0,D3; MOVEQ ' ',D0; BSR.W XOUTCH; MOVE.W INDEX,D4; INS_B1: MOVE.B (A2,D4.W),D0; BSR.W XOUTCH; ADDQ.W 1,D3; ADDQ.W 1,D4; CMP.W MAX_LEN,D4; !KLJSD\LJ\DS BCC.S INS_B11; CMP.W D4,LEN; BHI.S INS_B1; INS_B11: MOVEQ CLR_EOL,D0; BSR.W XOUTCH; MOVEQ BACK_SPACE,D0; INS_B2: BSR.W XOUTCH; DBF D3,INS_B2; BSR CURSOR_EIN; MOVEM.L (A7)+,D0-D7; RTS; DEL_BLANK: MOVEM.L D0/D4-D5,-(A7); BSR CURSOR_AUS; MOVEQ 0,D5; MOVE.W INDEX,D4; DEL_B0: ADDQ.W 1,D5; ADDQ.W 1,D4; CMP.W D4,LEN; BLS.S DEL_B1; MOVE.B (A2,D4.W),D0; BSR.W XOUTCH; BRA.S DEL_B0; DEL_B1: MOVEQ ' ',D0; BSR.W XOUTCH; MOVEQ BACK_SPACE,D0; BRA.S DEL_B3; DEL_B2: BSR.W XOUTCH; DEL_B3: DBF D5,DEL_B2; BSR CURSOR_EIN; MOVEM.L (A7)+,D0/D4-D5; RTS;; ENDIF;