Der Trap-Trapper
Auf grösseren Systemen der Datenverarbeitung finden sich Teile des Betriebssystems, die über bestimmte Ereignisse eine Art Logbuch führen. Für derartige Programme wird üblicherweise der Begriff Logger verwendet, eine Standardanwendung ist z.B. das Führen einer Fehlerliste. Als Testhilfe kann das hier von mir vorgestellte Programm dienen, das die Betriebssystemaufrufe des ATARI ST über die Trap-Befehle des 68000-Prozessors protokollieren kann. Der Quellcode bietet für den Interessierten darüber hinaus einen gewissen Einblick in die Handhabung der Ausnahmebehandlungen Trace und Line-F bei diesem Prozessor.
Vor der Implementierung eines Loggers waren einige grundsätzliche Betrachtungen anzustellen, die ich vorab kurz darlegen möchte. Zunächst muß die Programmierung wegen der möglichst hohen Ausführungsgeschwindigkeit in Assembler erfolgen. Weil der Start einer solchen Anwendung meiner Meinung nach auch aus dem AUTO-Ordner heraus möglich sein sollte, entfällt - leider -eine Realisierung als Accessory. Darüber hinaus erscheint mir eine Beschränkung des Protokolls auf die drei Bereiche GEMDOS, AES und VDI als sinnvoll, da diese die mächtigsten Funktionen des Betriebssystems zur Verfügung stellen. Um die zu erzeugende Liste auch nach einem Systemabsturz mit sich anschließendem Kaltstart verfügbar zu haben, kann diese nicht im RAM, z.B. in einem Ringspeicher, geführt werden. Sie muß vielmehr dauerhaft abgelegt werden, deshalb entschied ich mich für die Ausgabe über einen am Centronics-Port anzuschließenden Drucker. Als Kennzeichnung eines Betriebssystemaufrufs genügt dafür ein Buchstabe (‘A’: AES, ‘G’: GEMDOS, ‘V’: VDI), kombiniert mit einer zweistelligen Zahl, die die Funktionsnummer hexadezimal beinhaltet. Eine auf diese Weise geführte Liste zieht allerdings, trotz der kryptischen Ausgabe, einen enormen Papierverbrauch nach sich und ist wohl auch in den wenigsten Fällen gewünscht. Deshalb mußte ich die Möglichkeit schaffen, den Ausdruck ein- bzw. auszuschalten. Zur Vereinfachung der Handhabung war zudem die Implementierung einer ebenfalls schaltbaren Zeitlupe notwendig. Auf die Steuerung dieser Funktionen über die Tastatur konnte ich verzichten, da die Möglichkeit besteht, die RS232-Schnittstelle als 2-Bit-PIO zu benutzen. Die Funktion des residenten Programms sollte außerdem durch weitere Aufrufe ausgesetzt bzw. wieder aktiviert werden können.
Die elementare Funktion des Loggers besteht darin, nach der Auslösung eines der beiden Traps die Kennung des entsprechenden Betriebssystemaufrufes auszudrucken. Diese Aufgabe kann dadurch gelöst werden, daß man die jeweils zugehörige Ausnahmebehandlung über eine entsprechende Routine umleitet. Geholt werden die relevanten Daten dann vom Stack (Trap 1) bzw. über ein Register (Trap 2). Wenn es doch nur so einfach wäre! Leider ist eine derartige Installation nicht von Dauer, das Betriebssystem des ST boykottiert ein Verbiegen des Traps 2 gelegentlich durch Überschreiben des Vektors mit einem Zeiger auf sich selbst, z.B. wenn man sich eine Textdatei über das Desktop anzeigen läßt. Vor den Erfolg setzten die Götter die Reise - durch den Speicher des ATARI ST. Nach Lösen mehrerer Fahrkarten bei verschiedenen Reiseveranstaltern bzw. Debuggern konnte ich die gesuchten Übeltäter finden. Verantwortlich für die Reinitialisierung des Vektors für Trap 2 sind Teile des GEM, die durch Auslösung der Line-F-Ausnahme aufgerufen werden. Diese Ausnahmebehandlung wird beim ATARI ST im allgemeinen Line-F-Emulator genannt. Sie wird vom Prozessor eingeleitet, sobald er erkennt, daß im nächsten auszuführenden Befehlswort - in diesem Zusammenhang mit Opcode bezeichnet - die vier höchsten Bits gesetzt sind. Von den Schöpfern des GEM wurde diese Eigenschaft des 68000 benutzt, um häufig verwendete Befehlsfolgen zu ersetzen, dazu gehören auch die Aufrufe der eben angesprochenen Routinen. Auf die Nachteile dieser Art von Programmierung wurde schon in mehreren Artikeln hingewiesen, für den Logger war sie aber durchaus nützlich. Die Arbeitsweise des Line-F-Emulators, beschränkt auf seinen für dieses Programm relevanten Teil (Listing 1), möchte ich kurz erläutern.
Der Line-F-Emulator führt zwei grundsätzlich verschiedene Funktionen aus. Ist das niedrigste Bit des Opcodes gesetzt, erfolgt die Freigabe eines Stack-Bereiches über Unlink (UNLK). Andernfalls werden die unteren drei Bytes des Opcodes - er muß glatt durch vier teilbar sein - als Offset in einer Tabelle von Startadressen diverser GEMRoutinen interpretiert. An der auf diese Weise festgelegten Stelle wird das Programm dann mit dem Ende der Ausnahmebehandlung fortgesetzt. Diese stellt vorher noch den Status des Prozessors wieder richtig. Außerdem legt sie die Wortadresse auf dem Stack ab, die dem Befehl folgt, der die Ausnahme einleitete. Bei entsprechender Programmierung kann eine Anwendung die in Frage kommenden Routinen mittels Trace feststellen und ihre unerwünschten Resultate umgehen. Bei einer Installation des so erweiterten Loggers aus dem AUTO-Ordner heraus verweigert das System jedoch beim Aufbau des Desktops unwiderruflich seine Mitarbeit. Bei genauerer Untersuchung stellte ich fest, daß nicht alle über den Line-F Emulator angesprungenen Unterprogramme im Trace-Modus durchlaufen werden können. Das Problem kann aber doch durch eine Kombination von Änderungen in den Routinen für Line-F, Trace und illegale Adresse gelöst werden. Dabei habe ich den Umstand genutzt, daß die hier interessierenden Unterprogramme mit einem Return-Befehl (RTS) abschließen. Die Ausnahmebehandlung für Line-F muß dann so erfolgen, daß bei Nutzung des Emulators als Sprungverteiler die erzeugte Rücksprungadresse illegal ist. Bei Beendigung einer auf diesem Wege angesprungenen Routine erkennt der Prozessor dann die illegale Adresse und kann den Vektor für Trap 2 gegebenenfalls wieder aufsetzen.
Genug der langen Einleitung, ich komme zur Sache (Listing 2). Der ausführbare Code beginnt wie üblich mit der Berechnung des Stackpointers und der Programmngröße, dann wird Trap 1 nachdem XBRA-Standard abgeklopft. Befindet sich das Programm schon resident im Rechner, wird sein Status geändert, und eine entsprechende Meldung erscheint auf dem Monitor. Andernfalls wird der Logger für GEMDOS eingerichtet, und das Programm bleibt nach Beendigung im Speicher. Der beim Rücksprung in das Betriebssystem ausgelöste Trap 1 führt sofort wieder in die Anwendung zum GEMDOS-Logger. Dieser besteht aus einem ersten Teil, der die Installation für Trap 2 besorgen soll, und einem zweiten, der die Protokollierung für Trap 1 erledigt. Sobald das entsprechende Bit in der Steuervariablen ein fertig installiertes Desktop anzeigt, wird der erste Teil übersprungen. Solange das aber, wie auch beim ersten Durchlauf, noch nicht zutrifft, testet das Programm, ob das Desktop läuft. Dabei wird davon ausgegangen, daß nach Ende der Boot-Phase unterschiedliche Ausnahmebehandlungen für Line-F und Trace existieren. Verläuft der Test negativ, wird bei den folgenden Aufrufen des GEMDOS geprüft, ob sowohl Line-F-Emulator als auch AES/VDI zwischenzeitlich eingebunden wurden. Sobald das Desktop dann läuft, wird der Merker gesetzt, und die Vektoren für illegale Adresse, Line-F-Emulator, Trace und Trap 2 werden geändert. Die Installation ist damit beendet, und die Aufrufe von AES und VDI werden ebenfalls über den Drucker aufgelistet.
Für die Ausgabe des Protokolls wird bei Trap 1 und auch Trap 2 dasselbe Unterprogramm benutzt. Es beinhaltet außerdem noch die Zeitlupe und läuft über das BIOS. Zur Steuerung habe ich die Eingangssignale CTS (clear to send) und CD (carrier detect) bzw. die Ausgangssignale RTS (request to send) und DTR (data terminal ready) der seriellen Schnittstelle (Tabelle 1) vorgesehen. An Elektrikteilen braucht man einen 25poligen Stecker, ein Stück 4poliges Kabel und zwei Schalter. Die Teile sind jetzt so zu verlöten, daß mit dem einen Schalter CTS und RTS, mit dem anderen CD und DTR verbunden bzw. getrennt werden können. Am Parallel-Port des MFP 68901 kann dann die Schalterstellung gelesen werden.
014A74 MOVE.W (A7)+,D2 ; hole Kopie des alten Status'
014A76 MOVE.L (A7)+,A0 ; und Opcode (FXXX), Rücksprung-
014A78 MOVE.W (A0)+,D1 ; adresse jetzt in A0,
014A7A BTST #0,D1 ; Opcode testen, gegebenenfalls
014A7E BNE $014A9A ; UNLK-Funktion (...) ausführen,
014A80 MOVE.W D2,SR ; sonst Status restaurieren,
014A82 MOVE.L A0,-(A7) ; Rücksprungadresse auf Stack,
014A84 ANDI.W #$0FFF,D1 ; Adresse der
014A88 MOVE.L #$00FEE56A,A0 ; gewünschten Routine aus
014A8E MOVE.L $00(A0,D1.W),A0 ; der Tabelle holen und
014A92 JMP (A0) ; anspringen
014A94 ... ; ab hier Unlink-Funktion
Listing 1: Line-F-Emulator
| Pin | Bezeichnung |
|---|---|
| 1 | Gnd (ground) |
| 2 | TxD (transmit data) |
| 3 | RxD (receive data) |
| 4 | RTS (request to send) |
| 5 | CTS (clear to send) |
| 7 | Gnd (signal ground) |
| 8 | CD (carrier detect) |
| 20 | DTR (data terminal ready) |
| 22 | Rl (ring indicator) |
Tabelle 1: Belegung der RS232-Schnittstelle
Was passiert nun, wenn das Betriebssystem den Line-F-Emulator aufruft? Die modifizierte Ausnahmebehandlung prüft zunächst das niedrigste Bit des Opcodes, denn wenn der Line-F-Emulators im Unlink-Modus benutzt werden soll, kann ja ab hier wie bisher verfahren werden. Ansonsten wird der dem aktuellen Opcode-Wert entsprechende, beim Start des Loggers mit $FF vorbesetzte Merker getestet. Beinhaltet der Merker den Wert $00, so kann eine Reinitialisierung des Vektors für Trap 2 durch die zuzuordnende Routine ausgeschlossen werden; ohne Manipulationen läuft die Ausnahmebehandlung dann weiter über den Line-F-Emulator des GEM. Andernfalls wird die analog zur Vorgehens weise des Vorbildes erzeugte Rücksprungadresse auf dem Supervisor-Stack abgelegt. Anschließend wird in der Kopie des auf dem Stack abgelegten System-Bytes das Tracebit gesetzt. Schließlich kann über den gespeicherten alten Vektor der Sprung zum Original erfolgen. Hier weicht der Lauf der Dinge nur dann vom bisher bekannten ab, wenn die Kopie des Statuswortes, wie beschrieben, geändert wurde. Sobald dieses vom Stack geholt wird, um den Prozessorstatus zu restaurieren, wird der Trace-Modus eingeschaltet. Das Trace-Programm prüft ab jetzt nach jedem vom Line-F-Emulator ausgeführten Befehl, ob der auf dem entsprechenden Stack befindliche Eintrag identisch ist mit dem vorher abgelegten Rücksprungziel. Sobald dieser Zustand erreicht ist, wird das niedrigste Bit der weiterhin maßgeblichen Adresse gesetzt, die jetzt überzählige auf dem Supervisor-Stack gelöscht. Dann erfolgt die Beendigung des Trace-Modus’, und der Aufruf der gewünschten Routine schließt sich an. Nach deren Abarbeitung liest der Prozessor dann einen ungeraden Wert als Rücksprungadresse, also eine illegale Adresse. In der hierdurch ausgelösten Ausnahmebehandlung wird zuerst überprüft, ob sie durch eine Aktion des Loggers ausgelöst wurde, wenn nicht, hagelt es Bomben wie üblich. Ansonsten berichtigt die Routine entweder den Vektor für Trap 2, oder der dem soeben beendeten GEM-Teil zugeordnete Merker wird gelöscht. Dann wird das Programm an der richtigen Adresse fortgesetzt.
Zum Schluß gebe ich noch einige Anregungen zur eventuell nötigen Anpassung des Loggers an eine andere als die vorgesehene Konfiguration. Ein serieller Drucker kann relativ einfach angeschlossen werden, indem man die Stellung der Schalter über den Centronics-Port einliest. Diese Abfrage kann natürlich auch mit Hilfe einer I/O-Karte erfolgen, aber die hat ja nun mal nicht jeder. Obwohl von mir nur mit RAM-TOS bzw. Blitter-TOS auf einem Mega 1 entwickelt und getestet, habe ich die Hoffnung, daß das Programm auch mit den anderen Versionen des Betriebssystems läuft. Der kritische Punkt ist sicherlich der Test des Desktops. Das gilt vor allem für den neuen 1040 STE. Auf ihm, wie auch anderen Derivaten und zukünftigen Versionen des Betriebssystems (TOS030, PAK-68K, ...), die ohne Line-F-Emulator auskommen, kann der Logger in dieser Form nicht zum Laufen gebracht werden. Das ist der Preis, den man für eine solche Programmierung zahlen muß ... Aber ich weiß jetzt, was die Kiste beim Booten macht!
Literatur:
[1] Service Manual Mega 1, ATARI Corp.
[2] Brückmann, Englisch, Gerits, ATARI ST Intern. Data Becker GmbH Düsseldorf
;************************************************
;* TRAP_LOG.S - Stephan Simson *
;* (c) MAXON Computer GmbH 1991 *
;* Versionen *
;* 0.0 31.10.89: GEMDOS-Logger *
;* 1.0 10.12.89: AES/VDI-Logger *
;* 1.1 23.01.90: GEMDOS-Logger nur *
;* mit A0, D0 *
;* 2.0 27.03.90: AUTO-Start, XBRA *
;************************************************
;************************************************
;* Zuweisungen *
;************************************************
;
; Base-Page-Offset-Werte
TxtSgSiz EQU $00C ; Text-Segment-Größe
DatSgSiz EQU $014 ; Daten-Segment-Größe
BssSgSiz EQU $01C ; BSS-Segment-Größe
BasPgSiz EQU $100 ; Base-Page-Größe
;
; Ascii-Zeichen
;
NUL EQU $00
LF EQU $0A
CR EQU $0D
BLANK EQU $20
;
; Hardware-Adressen
;
MFP_PIO EQU $FFFA01 ; MFP 68901: par. I/O
;
; GEMDOS-Funktionen
;
CRAWCIN EQU $07 ; rohe Zeicheneingabe
CCONWS EQU $09 ; Stringausgabe
PTERM0 EQU $00 ; Programmende
PTERMRES EQU $31 ; Programmende / res.
;
; BIOS-Funktionen
;
SetExec EQU $05 ; Exc.-Vektor setzen
Bconout EQU $03 ; Ausgabe Zeichen
Bcostat EQU $08 ; Test Status Ausgabe
;
; Vektor-Nummern
;
IllAdVNr EQU $03 ; illegale Adresse
TraceVNr EQU $09 ; Trace
FLineVNr EQU $0B ; Line-F
T01VktNr EQU $21 ; Trap-01 (GEMDOS)
T02VktNr EQU $22 ; Trap-02 (AES / VDI)
;
; Trap-Nummern
;
GEMDOS EQU $01 ;
BIOS EQU $0D ;
;
; Geräte
;
PRN EQU 0 ; Centronics-Port
;
; Bits
;
Unlink EQU 0 ; FLine:Unlink-Modus
Gesperrt EQU 0 ; Funktion gesperrt
Drucken EQU 1 ; carrier detect
Zeitlupe EQU 2 ; clear to send
Desktop EQU 3 ; Desktop installiert
BootTest EQU 4 ; Boot-Test gelaufen
SuperMod EQU 5 ; Supervisor-Modus
TraceMod EQU 7 ; Trace-Modus
;
; Trap-2 Funktionen
;
AES_Code EQU $C8 ; AES-Funktion
VDI_Code EQU $73 ; VDI-Funktion
;
; Sonstige
;
StckSize EQU $100 ; Stack-Größe: 256
Bereit EQU $FFFF ; Geräte-Status
;************************************************
;* Programm *
;************************************************
TEXT
ProgrBgn:
;
; Berechnung: RAM-Bedarf und Stack-Pointer
;
LEA.L ProgrBgn-BasPgSiz(PC),SP
; SP -> BP
MOVE.L DatSgSiz(SP),D7 ; Data-Seg.
ADD.L BssSgSiz(SP),D7 ; BSS-Seg.
ADD.L #BasPgSiz,D7 ; Base-Page
ADD.L TxtSgSiz(SP),D7 ; Text-Seg.
ADD.L #StckSize,D7 ; Stack-Gr.
OR.B #$01,D7 ; D7: RAM-
ADDQ #$01,D7 ; Bedarf
ADD.L D7,SP ; SP okay
;
; Test der existierenden Trap-01-Routinen
;
MOVE.L #-1,-(SP) ; hole
MOVE.W #T01VktNr,-(SP) ; alten
MOVE.W #SetExec,-(SP) ; Vektor
TRAP #BIOS ; nach D0
ADDQ.L #8,SP ;
AND.L #$ 00FFFFFF,D0 ;
MOVE.L D0,A4 ;
SuchXBRA: CMP.L #'XBRA',-12(A4) ; nach
BNE InstaLOG ; XBRA
CMP.L #'TLOG',-8(A4) ; Standard
BEQ StatAend ; vorgehen
MOVE.L -4(A4),A4 ;
BRA SuchXBRA ;
;
; Status ändern
;
StatAend: BCHG #Gesperrt,-14(A4) ; ge-
BEQ NichtAkt ; sperrt ?
LEA Meldung2(PC),A0 ; Freigabe-
BRA ZeigStat ; oder
NichtAkt: LEA Meldung3(PC),A0 ; Sperr-
ZeigStat: BSR ZeigMeld ; Meldung
MOVE.W #PTERM0,-(SP) ; Programm
TRAP #GEMDOS ; beenden
;
; Installation des Loggers für Trap-01
;
InstaLOG: PEA Trp01LOG ; Routine
MOVE.W #T01VktNr,-(SP) ; für
MOVE.W #SetExec,-(SP) ; Trap-01
TRAP #BIOS ; einbauen
MOVE.L D0,_Trp01OV ;
ADDQ.L #8,SP ;
LEA Meldung1(PC),A0 ; Install.
BSR ZeigMeld ; melden
MOVE.W #0,(SP) ; Programm
MOVE.L D7,-(SP) ; beenden &
MOVE.W #PTERMRES,-(SP) ; resident
TRAP #GEMDOS ; halten
;
; Meldung zeigen und Taste warten
;
; Aufruf
; <A0>: Zeiger auf Meldungstext
;
ZeigMeld: MOVE.L A0,-(SP)
MOVE.W #CCONWS,-(SP) ; Meldung
TRAP #GEMDOS ; ausgeben
ADD.L #6,SP ;
MOVE.W #CRAWCIN,-(SP) ; warte auf
TRAP #GEMDOS ; Taste
ADD.L #2,SP ;
RTS ;
;
; Trap 01 TRAP_LOG.TOS
;
; benutzte Register: A0, D0
;
StrngFlg: DC.W NUL ; Steuerung
Magic_01: DC.B 'XBRA' ; Magic
Ident_01: DC.B 'TLOG' ; Ident-Nr.
_Trp010V: DC.L 0 ; Original
Trp01LOG: BTST #Desktop,StrngFlg ; ggf.
BNE Tr01LOG1 ; Trap-02-
BSR TestBoot ; Logger
BTST #Desktop, StrngFlg ; auch noch
BEQ Tr01LOG1 ; instal—
BSR InstTr02 ; lieren
Tr01LOG1: MOVE.L SP,A0 ; A0 = SP
BTST #SuperMod,(SP) ; alter
BNE Tr01LOG2 ; Status
MOVE.L USP,SP ; bestimmt,
MOVE.L SP,D0 ; ob USP zu
BRA Tr01LOG3 ; benutzen
Tr01LOG2: MOVE.L SP,D0 ; ist oder
ADDQ.L #6,D0 ; SSP
Tr01LOG3: EXG D0,A0 ; rette den
MOVE.L D0,-(SP) ; alten SP
BTST #Gesperrt,StrngFlg ; ge-
BNE Tr01LOG4 ; sperrt ?
MOVE.L A0,-(SP)
MOVE.W #'G',D0 ; 'G' für
BSR AusgZchn ; GEMDOS,
MOVE.L (SP)+,A0 ; dann über
MOVE.W (A0),D0 ; A0 adres-
MOVE.B D0,-(SP) ; sierte
ASR.B #4,D0 ; Nummer
BSR AusgHlbB ; ausgeben
MOVE.B (SP)+,D0 ;
BSR AusgHlbB ;
BSR AusgLeer ;
Tr01LOG4: MOVE.L (SP),SP ; SP okay
Tr01LOG5: MOVE.L _Trp01OV,A0 ; weiter
JMP (A0) ; wie sonst
;
; Installation Trap-02-Logger
;
InstTr02: BSR RettOrgV ; erst die
LEA IllAdLOG(PC),A0 ; Original-
MOVE.L A0,4*IllAdVNr ; Vektoren
LEA TraceLOG(PC),A0 ; sichern,
MOVE.L A0,4*TraceVNr ; dann die
LEA FLineLOG(PC),A0 ; Logger-
MOVE.L A0,4*FLineVNr ; Routinen
LEA Trp02LOG(PC),A0 ; ein-
MOVE.L A0,4*T02VktNr ; binden
RTS ;
;
; Rettung der Original-Vektoren
;
RettOrgV: MOVE.L 4*IllAdVNr,_IllAdOV ;
MOVE.L 4*TraceVNr,_TraceOV ;
MOVE.L 4*FLineVNr,_FLineOV ;
MOVE.L 4*T02VktNr,_Trp02OV ;
RTS ;
;
; Test, ob das Boot schon schwimmt
;
TestBoot: BSET #BootTest,StrngFlg ; Merker f.
BNE TstBoot2 ; TestBoot
MOVE.L 4*FLineVNr,-(SP) ; wenn
OR.L #$FF000000,(SP) ; FLine- &
MOVE.L 4*TraceVNr,D0 ; Trace-
OR.L #$FF000000,D0 ; Vektor
CMP.L (SP)+,D0 ; ungleich,
BEQ TstBoot1 ; dann
BSET #Desktop,StrngFlg ; läuft
RTS ; Desktop
TstBoot1: BSR RettOrgV ; Vektoren
RTS ; retten
TstBoot2: MOVE.L 4*FLineVNr,D0 ; Desktop
CMP.L _FLineOV,D0 ; läuft,
BEQ TstBoot9 ; wenn
MOVE.L 4*T02VktNr,D0 ; Vektoren
CMP.L _Trp02OV,D0 ; für FLine
BEQ TstBoot9 ; & Trap-02
BSET #Desktop,StrngFlg ; geändert
TstBoot9: RTS ;
;
; Trap 02 TRAP_LOG.TOS
;
; geänderte Register: keine
;
Magic_02: DC.B 'XBRA' ; Magic
Ident_02: DC.B 'TLOG' ; Ident-Nr.
_Trp02OV: DC.L 0 ; Original
Trp02LOG: BTST #Gesperrt,StrngFlg ; ge-
BNE Tr02LOG6 ; sperrt ?
MOVEM.L D0-D2/A0-A2,-(SP) ; rette
MOVE.L D1,-(SP) ; Register
CMP.W #AES_Code,D0 ; AES-
BEQ Trp02AES ; Aufruf ?
CMP.W #VDI_Code,D0 ; VDI-
BEQ Trp02VDI ; Aufruf ?
ADDQ.L #4,SP ; wer kommt
BRA Tr02LOG5 ; hierhin ?
Trp02VDI: MOVE.W #'V',D0 ; 'V' / 'A'
BRA Tr02LOG4 ; für
Trp02AES: MOVE.W #'A',D0 ; VDI / AES
Tr02LOG4: BSR AusgZchn ; ausgeben
MOVE.L (SP)+,A0 ; zeigt auf
MOVE.L (A0),A0 ; Zeiger,
MOVE.W (A0),D0 ; der zeigt
BSR AusgByte ; auf Nr.
BSR AusgLeer ;
Tr02LOG5: MOVEM.L (SP)+,D0-D2/A0-A2 ; Reg. okay
Tr02LOG6: MOVE.L _Trp02OV,-(SP) ; weiter,
RTS ; wie sonst
;
; illegale Adresse
;
_IllAdOV: DC.L NUL ; Original
IllAdLOG: MOVE.L A0,-(SP) ; A0 und D0
MOVE.L D0,-(SP) ; retten
MOVE.L 10(SP),A0 ; ill. Adr.
CMP.B #$F0,-3(A0) ; selbst
BLT IllAdAlt ; erzeugt ?
MOVE.L 4*T02VktNr,D0 ; Logger
CMP.L _Trp02OV,D0 ; wieder
BNE IlAdLOG1 ; einbin-
LEA Trp02LOG(PC),A0 ; den, wenn
MOVE.L A0,4*T02VktNr ; Vektor
BRA IlAdLOG2 ; verändert
IlAdLOG1: MOVE.W -3(A0),D0 ; sonst
AND.L #$00000FFF,D0 ; Merker
ASR.W #2,D0 ; für zuge
EXG.L D0,A0 ; hörige
ADD.L #FLineTab,A0 ; Routine
CLR.B (A0) ; löschen
IlAdLOG2: MOVE.L (SP)+,D0 ; A0, D0
MOVE.L (SP)+,A0 ; Stack und
MOVE.L 2(SP),10 (SP) ; Rück-
AND.L #$FFFFFFFE,10(SP) ; sprung
ADD.L #8,SP ; adresse
RTE ; okay
IllAdAlt: MOVE.L (SP)+,D0 ; D0 & A0
MOVE.L (SP)+,A0 ; okay,
MOVE.L _IllAdOV,A0 ; weiter
JMP (A0) ; wie sonst
;
; FLine
;
_FLineOV: DC.L NUL ; Original
FLineLOG: MOVE.L A0,-(SP) ; A0 retten
MOVE.L 6(SP),A0 ; Opcode
ADD.L #1,A0 ; testen
BTST #Unlink,(A0) ;
BNE FLinLOG1 ;
MOVE L D0,-(SP) ; D0 retten
ADD.L #1,A0 ; Nummer d.
MOVE.W -2(A0),D0 ; FLine-
AND.L #$00000FFF,D0 ; Routine
ASR.H #2,D0 ; bestimmen
EXG.L D0,A0 ; und zuge-
ADD.L #FLineTab,A0 ; hörigen
TST.B (A0) ; Merker
BEQ FLinLOGO ; testen,
MOVE.L (SP),-(SP) ; ggf.
MOVE.L 8(SP),4(SP) ; Adresse
MOVE.W 12(SP),8(SP) ; merken &
MOVE.L 14(SP),10(SP) ; und Trace
MOVE.L D0,14(SP) ; ver-
BSET #TraceMod,8(SP) ; anlassen
FLinLOG0: MOVE.L (SP)+,D0 ; D0 und A0
FLinLOG1: MOVE.L (SP),A0 ; okay
MOVE.L _FLineOV,(SP) ; weiter
RTS ; wie sonst
;
; Trace
;
_TraceOV: DC.L NUL ; Original
TraceLOG: MOVE.L A0,-(SP) ; A0 & D0
MOVE.L D0,-(SP) ; retten
BTST #SuperMod,8(SP) ; alter
BEQ TracLOG1 ; Status
MOVE.L SP,A0 ; bestimmt,
ADD.L #18,A0 ; ob SSP
BRA TracLOG2 ; oder USP
TracLOG1: MOVE.L USP,A0 ; zu nutzen
TracLOG2: MOVE.L (A0),D0 ; wenn Adr.
CMP.L 14(SP),D0 ; ungleich,
BEQ TraceEnd ; D0 & A0
MOVE.L (SP)+,D0 ; vom Stack
MOVE.L (SP)+,A0 ; holen,
RTE ; tracen
TraceEnd: BSET #0,3(A0) ; Adresse,
MOVE.L (SP)+,D0 ; D0, A0
MOVE.L (SP)+,A0 ; und Stack
MOVE.L 2(SP),6(SP) ; berichti-
MOVE.W (SP),4(SP) ; gen,
BCLR #TraceMod,4(SP) ; Trace
ADD.L #4,SP ; beenden
RTE ;
;
; Ausgabe Byte
;
AusgByte: MOVE.W D0,-(SP) ;
ASR.B #4,D0 ; oberes
BSR AusgHlbB ; Halbbyte
MOVE.W (SP)+,D0 ; unteres
BSR AusgHlbB ; Halbbyte
RTS
;
; Ausgabe Halb-Byte (nibble)
;
AusgHlbB: AND.W #$000F,D0 ; unterstes
LEA HexAscTb(PC),A0 ; Halbbyte
MOVE.B (A0,D0),D0 ; zeigt auf
BRA AusgZchn ; Zeichen
;
; Neue Zeile
;
NeueZeil: MOVE.W #CR,D0 ; Zeilen-
BSR AusgZchn ; anfang
MOVE.W #LF,D0 ; nächste
BRA AusgZchn ; Zeile
;
; Ausgabe Leerzeichen
;
AusgLeer: MOVE.W #BLANK,D0 ; ' ' !
;
; Ausgabe Zeichen
;
; enthalten sind Start/Stop und Zeitlupe
;
; Aufruf
;
; <D0>: Zeichen
;
AusgZchn: MOVEM.L D1-D2/A1-A2,-(SP) ; Register
MOVE.W D0,-(SP) ; retten
BTST #Zeitlupe,MFP_PIO ; Tee
BEQ AusgZch1 ; trinken,
MOVE.L #150,D0 ; wenn ge-
BSR Wartzeit ; schlossen
AusgZch1: BSR TstDruck ; zurück,
BNE AusgZch3 ; wenn
ADD.L #2,SP ; geöffnet
BRA AusgZch4 ;
AusgZch3: MOVE.W #PRN,-(SP) ; Status
MOVE.W #Bcostat,-(SP) ; des
TRAP #BIOS ; Druckers
ADDQ.L #4,SP ; ermitteln
CMP.W #Bereit,D0 ; wenn
BNE AusgZch1 ; bereit,
MOVE.W #PRN,—(SP) ; dann
MOVE.W #Bconout,-(SP) ; Zeichen
TRAP #BIOS ; ausgeben
ADDQ.L #6,SP ;
AusgZch4: MOVEM.L (SP)+,D1-D2/A1-A2 ; Register
RTS ; holen
;
; Wartezeit
;
; Aufruf
; <D0>: Anzahl der Wartezyklen,
; leider ein Software-Timer
;
Wartzeit: MOVE.L #10,D1
Wartzeil: DBRA D1,Wartzeil
DBRA D0,Wartzeit
RTS ; genug
;
; Test Schalter 'Drucken'
;
; Rücksprung
; <Z>: 1 - Druck
; 0 - kein Druck
;
TstDruck: MOVE.L D1,-(SP) ; D1 retten
MOVE.B MFP_PIO,D1 ; Wenn
MOVE.B StrngFlg,D0 ; Schalter
EOR.B D1,D0 ; betätigt,
BTST #Drucken,D0 ; dann Flag
BEQ TstDrck2 ; ändern &
BCHG #Drucken,StrngFlg ; ggf.
BNE TstDrck1 ; Zeilen-
BSR NeueZeil ; vorschub
TstDrck1: MOVE.L #1000,D0 ; Ent-
BSR Wartzeit ; prellen
TstDrck2: MOVE.L (SP)+,D1 ; D1 okay
BTST #Drucken,StrngFlg ; Test
RTS
;
; Konstanten
;
HexAscTb: DC.B '0123456789ABCDEF' ; Hex-Ascii
;
; Variablen
;
FLineTab: ; Merker
REPT $1000/4 ; für
DC.B $FF ; Trace
ENDM
;
; Texte
;
Meldung1: DC.B 'TRAP_LOG.PRG installiert'
DC.B CR,LF,LF
DC.B ' Stephan Simson 27.03.90'
DC.B CR,LF,NUL
Meldung2: DC.B 'TRAP_LOG.PRG wieder aktiv'
DC.B CR,LF,NUL
Meldung3: DC.B 'TRAP_LOG.PRG deaktiviert'
DC.B CR,LF,NUL
END
Stephan Simson