                include         parsys.i68

                page            60
                cpu             68000

;-----------------------------------------------------------------------------
; Die Exceptionvektoren:

                supmode         on

		org		$00000000	; Die Vektoren
		dc.l		0		; Adresse vom Stack (Dummy)
		dc.l		Start	        ; erster Start
		dc.l		ex_vec2		; Busfehler
		dc.l		ex_vec3		; Adressfehler
		dc.l		ex_vec4		; Illegaler Befehl
		dc.l		ex_vec5		; Division durch Null
		dc.l		ex_vec6		; Befehl CHK
		dc.l		ex_vec7		; Befehl TRAPV
		dc.l		ex_vec8         ; Privilegverletzung
		dc.l	        StepProc	; Ablaufverfolgung
		dc.l            ex_vec10        ; Line-A --> Gleitkomma
		dc.l		S_LineF		; Line-F --> 68881-Emulator
		dc.l		ex_vec12	; Reserviert
                dc.l            ex_vec13        ; Koprozessor-Protokollfehler
                dc.l            ex_vec14        ; illegaler FRESTORE-Frame
		dc.l		ex_vec15	; nicht initialisierter Unterbrechungsvektor
		dc.l		ex_vec16        ; Reserviert
		dc.l		ex_vec17        ; Reserviert
		dc.l		ex_vec18        ; Reserviert
		dc.l		ex_vec19        ; Reserviert
		dc.l		ex_vec20        ; Reserviert
		dc.l		ex_vec21        ; Reserviert
		dc.l		ex_vec22        ; Reserviert
		dc.l		ex_vec23        ; Reserviert
		dc.l		ex_vec24        ; Unechte Unterbrechung
		dc.l		ex_vec25        ; autovektoriell 1
		dc.l		ex_vec26        ; autovektoriell 2
		dc.l		ex_vec27        ; autovektoriell 3
		dc.l		ex_vec28        ; autovektoriell 4
		dc.l		ex_vec29        ; autovektoriell 5
		dc.l		ex_vec30        ; autovektoriell 6
		dc.l		ex_vec31        ; autovektoriell 7
		dc.l		PcSysCall	; Trap #0 --> PC-Kommunikation
		dc.l		ex_vec33        ; Trap #1
		dc.l		ex_vec34        ; Trap #2
		dc.l		ex_vec35        ; Trap #3
		dc.l		ex_vec36        ; Trap #4
		dc.l		ex_vec37        ; Trap #5
		dc.l		ex_vec38        ; Trap #6
		dc.l		ex_vec39        ; Trap #7
		dc.l		ex_vec40        ; Trap #8
		dc.l		ex_vec41        ; Trap #9
		dc.l		ex_vec42        ; Trap #10
		dc.l		ex_vec43        ; Trap #11
		dc.l		ex_vec44        ; Trap #12
                dc.l            S_LibFun        ; Trap #13 --> Libraryverwaltung
		dc.l		S_StepTgl	; Trap #14 --> Trace an/aus
		dc.l		S_ProgEnd	; Trap #15 --> Programmende
                dc.l            ex_vec48        ; BSUN in FPU gesetzt
                dc.l            ex_vec49        ; FPU inexaktes Ergebnis
                dc.l            ex_vec50        ; FPU Division durch 0
                dc.l            ex_vec51        ; FPU Unterlauf
                dc.l            ex_vec52        ; FPU Operandenfehler
                dc.l            ex_vec53        ; FPU Ueberlauf
                dc.l            ex_vec54        ; FPU signaling NAN
                dc.l            ex_vec55        ; reserviert
                dc.l            ex_vec56        ; MMU Konfigurationsfehler
                dc.l            ex_vec57        ; MMU Illegale Operation
                dc.l            ex_vec58        ; MMU Zugriffsfehler
                                                ; Vektoren 59..255 frei

;----------------------------------------------------------------------------
; Installationssequenz:

                org     $800
start:
                clr.w   S_Latch.w       ; Port nullen

                and.b   #$fc,S_MemEnd+3.w ; Speichergroesse auf Lang-
                                        ; wortadresse ausrichten
                move.l  S_MemEnd.w,a7   ; SSP setzen

                lea     -256(a7),a0     ; SSP-Anfang in A0
                move.l  a0,S_SSPEnd.w   ; sichern

                lea     S_End.w,a1      ; Codelaenge berechnen
                lea     S_Start.w,a2
                sub.l   a2,a1           ; A1=Laenge Systemcode
                moveq   #4,d0           ; auf mehrfaches von 4 aus-
                sub.w   a1,d0           ; richten
                and.l   #3,d0
                add.l   d0,a1

                sub.l   a1,a0           ; Start des Systemcodes rechnen
                move.l  a0,S_SysStart.w ; sichern
                move.l  a0,$4.w         ; =Programmstart

                move.l  a1,d0           ; Systemcode umkopieren
                lsr.l   #2,d0           ; =Zahl Langworttransfers
                subq.w  #1,d0           ; wg. DBRA
S_SysCopy:      move.l  (a2)+,(a0)+
                dbra    d0,S_SysCopy

                sub.l   a2,a0           ; Verschiebedifferenz rechnen
                move.l  a0,d1

                lea     8.w,a1          ; alle Vektoren relozieren
                moveq   #45,d0
S_RelVec:       add.l   d1,(a1)+
                dbra    d0,S_RelVec

                move.l  S_SysStart.w,a1 ; obere Speichergrenze in USP...
                move    a1,usp
                move.l  a1,S_FreeMemEnd.w ; und Variable

                move.l  #-1,S_LibStart.w; Librarykette leer

                lea     S_floatlib.w,a0 ; passende FloatLib installieren
                btst    #0,S_Latch+1.w  ; 68881 vorhanden ?
                bne.s   S_NoCo81
                lea     S_float81lib.w,a0 ; ja-->andere Library
S_NoCo81:       moveq   #LibCtrlInstall,d0 ; einschreiben
                trap    #TrapLibCtrl

                moveq   #LibCtrlGetAdr,d0 ; Adresse holen
                lea     S_LibName.w,a0
                trap    #TrapLibCtrl
                move.l  d0,S_LibAdr.w

                move.l  4*4.w,a4        ; Exceptionvektoren 4 und 11 retten
                move.l  11*4.w,a5
                move.l  sp,a6           ; SP retten
                move.l  #S_NoCPU,4*4.w  ; neue Exceptionhandler einschreiben
                move.l  #S_NoMMU,11*4.w
                moveq   #is68008,d1     ; Prozessorcode loeschen

                cpu     68030           ; fuer zus. Befehle

                ori     #1,ccr          ; 68008 ausfiltern
                moveq   #is68000,d1

                movec   vbr,d0          ; geht erst ab 68010
                moveq   #is68010,d1

                extb    d0              ; geht erst ab 68020
                moveq   #is68020,d1

                cpu     68000           ; nicht mehr gebraucht
                fpu     on              ; dafuer dies

S_NoCPU:        btst    #0,S_Latch+1.w  ; FPU vorhanden ?
                bne.s   S_NoFPU         ; nein-->
                or.w    #has68881,d1    ; ja : 68881 annehmen
                fnop                    ; FPU idle machen, damit im folgenden
                fsave   -(sp)           ; ein idle frame gespeichert wird
                cmp.b   #$18,1(sp)      ; Framelaenge=$18 fuer 68881, $38 fuer 882
                beq.s   S_NoFPU
                add.w   #(has68882-has68881),d1 ; 68882 eintragen

                fpu     off             ; FPU nicht mehr gebraucht
                pmmu    on              ; dafuer die MMU

S_NoFPU:        move.l  a4,4*4.w        ; Exception 4 zuruecksetzen
                pflusha                 ; dies versteht auch die 68030-MMU
                add.w   #hasMMU,d1      ; gefunden: Flag dazu
                move.l  #S_SmallMMU,11*4.w ; testen ob Schmalspur-MMU
                psave   -(sp)
                bra.s   S_NoMMU         ; Ergebnis 68020/68851

S_SmallMMU:     move.b  #is68030,d1     ; 68030 eintragen (nicht MOVEQ!!)
                add.w   #(intMMU-hasMMU),d1 ; Code interne MMU

S_NoMMU:        move.l  a5,11*4.w       ; Line-F-Vektor zuruecksetzen
                move.l  a6,sp           ; SP restaurieren
                move.w  d1,S_CPUNo.w    ; Ergebnis einschreiben

                trap    #TrapProgEnd

S_LibName:      dc.b    "FLOAT",0

;----------------------------------------------------------------------------
; Gleitkommalibrary, ohne 68881:

                supmode         off

                include         float.i68

;----------------------------------------------------------------------------
; Gleitkommalibrary, mit 68881:

                supmode         off

                include         float81.i68

;----------------------------------------------------------------------------
; Die Startsequenz:

                supmode         on

S_Start:        clr.w           S_Latch.w       ; Ports loeschen
                clr.l           _fadd_cnt.w     ; Zielvariablen loeschen
                clr.l           _fmul_cnt.w
                clr.l           _fdiv_cnt.w
                clr.l           _fsqrt_cnt.w

		move.l          S_MemEnd.w,d0	; SSP an Speicherende legen
		move.l		d0,$0.w		; Neben Resetvekor vermerken
		move.l		d0,a7		; SSP setzen
                move.l          S_FreeMemEnd.w,a0 ; USP liegt am Speicherende
		move		a0,usp

		andi		#$dfff,sr	; In Usermodus schalten
                jmp             Start.w         ; zum Programmstart

;----------------------------------------------------------------------------
; Die Ausnahmebehandlungsprozeduren:

ex_vec2:
		move.w  	#2,S_ExVec.w
		bra.l		ex_handle
ex_vec3:
		move.w  	#3,S_ExVec.w
		bra.l		ex_handle
ex_vec4:
		move.w  	#4,S_ExVec.w
		bra.l		ex_handle
ex_vec5:
		move.w  	#5,S_ExVec.w
		bra.l		ex_handle
ex_vec6:
		move.w  	#6,S_ExVec.w
		bra.l		ex_handle
ex_vec7:
		move.w  	#7,S_ExVec.w
		bra.l		ex_handle
ex_vec8:
		move.w  	#8,S_ExVec.w
		bra.l		ex_handle
ex_vec10:
		move.w  	#10,S_ExVec.w
		bra.l		ex_handle
ex_vec11:
		move.w		#0,S_Control+S_Response.w ; FPU resetten
		move.w  	#11,S_ExVec.w
		bra.l		ex_handle
ex_vec12:
		move.w  	#12,S_ExVec.w
		bra.l		ex_handle
ex_vec13:
		move.w  	#13,S_ExVec.w
		bra.l		ex_handle
ex_vec14:
		move.w  	#14,S_ExVec.w
		bra.l		ex_handle
ex_vec15:
		move.w  	#15,S_ExVec.w
		bra.l		ex_handle
ex_vec16:
		move.w  	#16,S_ExVec.w
		bra.l		ex_handle
ex_vec17:
		move.w  	#17,S_ExVec.w
		bra.l		ex_handle
ex_vec18:
		move.w  	#18,S_ExVec.w
		bra.l		ex_handle
ex_vec19:
		move.w  	#19,S_ExVec.w
		bra.l		ex_handle
ex_vec20:
		move.w  	#20,S_ExVec.w
		bra.l		ex_handle
ex_vec21:
		move.w  	#21,S_ExVec.w
		bra.l		ex_handle
ex_vec22:
		move.w  	#22,S_ExVec.w
		bra.l		ex_handle
ex_vec23:
		move.w  	#23,S_ExVec.w
		bra.l		ex_handle
ex_vec24:
		move.w  	#24,S_ExVec.w
		bra.l		ex_handle
ex_vec25:
		move.w  	#25,S_ExVec.w
		bra.l		ex_handle
ex_vec26:
		move.w  	#26,S_ExVec.w
		bra.l		ex_handle
ex_vec27:
		move.w  	#27,S_ExVec.w
                bra.l           ex_handle
ex_vec28:
		move.w  	#28,S_ExVec.w
                bra.l           ex_handle
ex_vec29:
		move.w  	#29,S_ExVec.w
                bra.l           ex_handle
ex_vec30:
		move.w  	#30,S_ExVec.w
                bra.l           ex_handle
ex_vec31:
		move.w  	#31,S_ExVec.w
                bra.l           ex_handle
ex_vec33:
		move.w  	#33,S_ExVec.w
                bra.l           ex_handle
ex_vec34:
		move.w  	#34,S_ExVec.w
                bra.l           ex_handle
ex_vec35:
		move.w  	#35,S_ExVec.w
                bra.l           ex_handle
ex_vec36:
		move.w  	#36,S_ExVec.w
                bra.l           ex_handle
ex_vec37:
		move.w  	#37,S_ExVec.w
                bra.l           ex_handle
ex_vec38:
		move.w  	#38,S_ExVec.w
                bra.l           ex_handle
ex_vec39:
		move.w  	#39,S_ExVec.w
                bra.l           ex_handle
ex_vec40:
		move.w  	#40,S_ExVec.w
                bra.l           ex_handle
ex_vec41:
		move.w  	#41,S_ExVec.w
                bra.l           ex_handle
ex_vec42:
		move.w  	#42,S_ExVec.w
                bra.l           ex_handle
ex_vec43:
		move.w  	#43,S_ExVec.w
                bra.l           ex_handle
ex_vec44:
                move.w          #44,S_ExVec.w
                bra.l           ex_handle
ex_vec48:
                move.w          #48,S_ExVec.w
                bra.l           ex_handle
ex_vec49:
                move.w          #49,S_ExVec.w
                bra.l           ex_handle
ex_vec50:
                move.w          #50,S_ExVec.w
                bra.l           ex_handle
ex_vec51:
                move.w          #51,S_ExVec.w
                bra.l           ex_handle
ex_vec52:
                move.w          #52,S_ExVec.w
                bra.l           ex_handle
ex_vec53:
                move.w          #53,S_ExVec.w
                bra.l           ex_handle
ex_vec54:
                move.w          #54,S_ExVec.w
                bra.l           ex_handle
ex_vec55:
                move.w          #55,S_ExVec.w
                bra.l           ex_handle
ex_vec56:
                move.w          #56,S_ExVec.w
                bra.l           ex_handle
ex_vec57:
                move.w          #57,S_ExVec.w
                bra.l           ex_handle
ex_vec58:
                move.w          #58,S_ExVec.w

ex_handle:
		movem.l		d0-d7/a0-a7,S_RegSave.w ; Wert der Register abspeichern
		move		usp,a0
		move.l		a0,S_RegSave+64.w
		lea		S_Latch.w,a0
		move.w		S_ExVec.w,d0	; Vektornr. holen
		move.b		d0,1(a0)	; Fehlernr. ausgeben
ex_infinite:
		move.b		d0,d1		; Die LED n-mal blinken lassen						; Die LED n-mal blinken lassen
ex_blink:
		bset		#0,(a0)		; LED an
                bsr.s           ex_wait
		bclr		#0,(a0) 	; LED aus
		bsr.s		ex_wait
		subq.b		#1,d1
		bne.s		ex_blink
		move.b          #$05,d1		; eine Pause einlegen
ex_pause:
		bsr.s		ex_wait
		subq.b		#1,d1
		bne.s		ex_pause
		bra.s		ex_handle	; und alles von vorne

ex_wait:
		move.l		d0,-(a7)   	; Register retten
		move.l		#$50000,d0	; ungefaehr 1/2 Sekunde
ex_wloop:                          		; Register herunterzaehlen
		subq.l		#1,d0
		bne.s		ex_wloop
		move.l		(a7)+,d0	; D0 wieder zurueck
		rts

;----------------------------------------------------------------------------
; Einzelschrittverfolgung:

StepProc:
		clr.b		S_Latch+1.w
		movem.l		d0-d7/a0-a7,S_RegSave.w ; Register retten
		move		usp,a0
		move.l		a0,S_RegSave+64.w
		move.l		$4.w,S_ResVecSave.w ; Resetvektor sichern
		lea		S_Restart(pc),a0    ; am Punkt S_StepBack wacht
		move.l		a0,$4.w		    ; der PcPar wieder auf
		move.b		#9,S_Latch+1.w      ; ParMon-Aufruf ausgeben
                stop            #$2000              ; hier geht es nur mit einem
                                                    ; Reset weiter

;----------------------------------------------------------------------------
; Routinen zur Kommunikation mit dem PC  (Trap 0)

PcSysCall:
		clr.b		S_Latch+1.w
		movem.l		d0-d7/a0-a7,S_RegSave.w ; Register retten
		move		usp,a0
		move.l		a0,S_RegSave+64.w
		move.l		$4.w,S_ResVecSave.w ; Resetvektor sichern
		lea		S_Restart(pc),a0    ; am Punkt S_Restart wacht
		move.l		a0,$4.w		    ; der PcPar wieder auf
		move.b		#$40,S_Latch+1.w    ; PC-Aufruf ausgeben
                stop            #$2000              ; hier geht es nur mit einem

S_Restart:
		clr.b		S_Latch+1.w	    ; Systemanfrage loeschen
		move.l		S_ResVecSave.w,$4.w ; Resetvektor zurueck
		move.l		S_RegSave+64.w,a0
		move		a0,usp
		movem.l		S_RegSave.w,d0-d7/a0-a7 ; Register zurueckholen
		rte				        ; das war's

;----------------------------------------------------------------------------
; Libraryverwaltung :   Trap #13
;
; Struktur einer Library :
;
; Adresse 0:    Laenge in Bytes  (1 <= Laenge <= 256k)
; Adresse 4:    Dummyzeiger =-1 (vom System verwendet)  \
; Adresse 8:    Libraryname als ASCIIZ-String           | kopierter Block
; Adresse n:    Sprungtabelle                           |
; Adresse m:    Librarycode, private Daten              /
;
; der gesamte Librarycode muss lageunabhaengig geschrieben sein !
;
; definierte Unterfunktionen:
;
;     D0.L=0 : Library installieren
;     D0.L=1 : Libraryzeiger holen
;
;----------------------------------------------------------------------------

; Subfunktion 0: Library von Adresse 0 installieren:
; Eingabe: A0=Startadresse der Library
; Ausgabe: keine

S_LibFun:       movem.l d1-d2/a1-a2,-(a7)  ; Register sichern
                tst.l   d0              ; ist es Funktion 0 ?
                bne.s   S_LibFun1       ; nein-->bei Funktion 1 weitertesten

                move.l  (a0),d0         ; Laenge Library holen
                addq.l  #3,d0           ; auf Doppelworte aufrunden
                and.b   #$fc,d0
                moveq   #1,d1
                cmp.l   #$40000,d0      ; Maximalgroesse ueberschritten ?
                bge.l   S_LibErr        ; ja-->Ende mit Fehler Nr.1

                move    usp,a1          ; Userstack holen
                move.l  S_FreeMemEnd.w,d2 ; mom. belegte Stackmenge berechnen
                sub.l   a1,d2
                move.l  a1,a2           ; neue Untergrenze in A2 rechnen
                sub.l   d0,a2
                moveq   #2,d1
                cmp.l   #$800,a2        ; unter abs. Untergrenze gesunken ?
                ble.l   S_LibErr        ; ja-->Ende mit Fehler Nr.2

                move    a2,usp          ; neuen Userstack einschreiben
                lsr.l   #1,d2           ; Stackgroesse in Worten
                bra.s   S_LibStckEnd    ; damit Ende, falls kein Stack belegt

S_LibStckCpy:   move.w  (a1)+,(a2)+     ; Userstack umkopieren
S_LibStckEnd:   dbra    d2,S_LibStckCpy

                move.l  S_FreeMemEnd.w,a1 ; Startadresse der Library rechnen
                sub.l   d0,a1           ; =altes Speicherende-Laenge
                addq.l  #4,a0           ; Quellzeiger weitersetzen
                move.l  S_LibStart.w,d1 ; bisheriges Ende der Kette holen
                move.l  d1,(a0)         ; in neue Library eintragen
                move.l  a1,S_FreeMemEnd.w ; Speichergrenze heruntersetzen
                move.l  a1,S_LibStart.w ; neuen Kettenanfang eintragen

                lsr.l   #2,d0           ; Laenge in Doppelworte umrechnen
                subq.w  #1,d0           ; wg. DBRA

S_LibInstLoop:  move.l  (a0)+,(a1)+     ; Library umkopieren
                dbra    d0,S_LibInstLoop

                bra.l   S_LibOK         ; Ende ohne Fehler

; Subfunktion 1: Library finden, deren Name ab (A0) als ASCIIZ steht:
; Eingabe: A0=Startadresse des ASCIIZ-Strings
; Ausgabe: D0=Startadresse der Sprungtabelle

S_LibFun1:      subq.l  #1,d0           ; ist es Funktion 1 ?
                bne.s   S_LibFun2       ; nein-->bei Funktion 2 weitertesten

                move.l  S_LibStart.w,a2 ; Wurzelzeiger der Kette holen

S_LibGetLoop:   moveq   #3,d1           ; Kettenende erreicht ?
                move.l  a2,d0
                addq.l  #1,d0           ; wird durch -1 angezeigt
                beq.l   S_LibErr        ; ja-->Ende mit Fehler

                move.l  a0,d0           ; Startadresse Vergleichsstring retten
                lea     4(a2),a1        ; A1 zeigt auf zu testenden Namen
S_LibGetComp:   cmpm.b  (a0)+,(a1)+     ; ein Zeichen vergleichen
                bne.s   S_LibGetNext    ; ungleich-->weiter in Kette
                tst.b   -1(a0)          ; War das das Ende ?
                beq.s   S_LibGetFnd     ; ja-->Heureka!
                bra.s   S_LibGetComp    ; ansonsten naechstes Zeichen vergleichen

S_LibGetNext:   move.l  (a2),a2         ; weiter auf Nachfolger in Kette
                move.l  d0,a0           ; A0 auf Referenzstringanfang
                bra.s   S_LibGetLoop

S_LibGetFnd:    move.l  a1,d0           ; Libraryadresse gerade machen
                addq.l  #1,d0
                bclr    #0,d0

                bra.l   S_LibOK         ; Ende ohne Fehler

S_LibFun2:      moveq   #127,d1         ; unbekannte Funktion:
                bra.l   S_LibErr

S_LibErr:       move.l  d1,d0           ; Fehlercode in D0 holen
                movem.l (a7)+,d1-d2/a1-a2  ; Register zurueck
                or.b    #1,1(a7)        ; Carry setzen
                rte

S_LibOK:        movem.l (a7)+,d1-d2/a1-a2  ; Register zurueck
                and.b   #$fe,1(a7)      ; Carry loeschen
                rte

;----------------------------------------------------------------------------
; Tracemode ein/aus:

S_StepTgl:
		andi		#$7fff,sr	; bitte hier kein Trace!
		bclr		#7,(a7)		; altes T-Flag loeschen
		btst		#0,1(a7)
		bne.s		S_StepOn        ; C=1-->Tracemodus an
		rte				; C=0-->fertig
S_StepOn:
		bset		#7,(a7)		; T-Flag setzen
		rte

;----------------------------------------------------------------------------
; Programmende (Trap 15)

S_ProgEnd:      lea		S_Start(pc),a0	; Startvektor zurueck
		move.l		a0,4.w
		move.b		#$ff,S_Latch+1.w ; "Ich bin fertig"
                stop            #$2000          ; und Ende

;----------------------------------------------------------------------------
; Line-F-Exception

S_Response	equ		$fffffe00	; In a6 (Coprozessor-Register)
S_Control	equ		$02		; Alle weiteren Register relativ
S_Save		equ		$04		; zu "Response"
S_Restore	equ		$06
S_Command	equ		$0a		; in a5
S_Condition	equ		$0e
S_Operand	equ		$10		; in a4
S_Reg_Selec	equ		$14
S_Ins_Add	equ		$18

                supmode         on

S_LineF:	btst		#0,S_Latch+1.w	; Ist ein Koprozessor vorhanden ?
		bne		ex_vec11	; nein-->normaler Line-F

		movem.l		d0-d7/a0-a6,S_RegSave.w	; Register retten
		move.l		usp,a0		; USP retten
		move.l		a0,S_RegSave+60.w ; (geht nur ueber Umweg)
		lea		S_Response.w,a6	; #response nach A6
		lea		S_Command(a6),a5 ; #command nach A5
		lea		S_Operand(a6),a6 ; #operand nach A4
		lea		S_RegSave.w,a3	; #dregs nach A3
		move.l		2(a7),a0	; PC nach A0
		move.w		(a0),d1		; Kommando nach D1
S_again:					; Einsprung fuer weitere FPU-Befehle
		and.w		#%0000000111000000,d1 ; Spezialteil ausmaskieren
		bne		S_spezial	; Ein Bit gesetzt-->Spezialbefehl
		move.w		2(a0),d1	; zweiten Befehlsteil in D1 merken
		move.w		d1,(a5)		; Befehl in FPU schr. (A5==#command)
S_do_ca:					; Einsprung fuer weitere Nachfragen an FPU
		move.w		(a6),d0		; Response lesen
		btst		#12,d0		; Erstes Modusbit testen
		bne		S_rw_1x		; ==1 --> springen
		btst		#11,d0		; Zweites Modusbit testen
                beq.s           S_rw_00         ; ==0 --> springen
; ----- %xxx01, Null-Primitive/Transfer Single CPU Register
		btst		#10,d0		; Register uebertragen ?
		bne.s		S_rw_sngl	; Ja--> Transfer Single CPU-Register
		btst		#15,d0		; CA (Come Again) gesetzt ?
		bne.s		S_do_ca		; Ja--> weiter fragen, sonst fertig
		addq.l		#4,a0		; A0 um reine Befehlslaenge weiter
						; ( alles andere wurde in calc_add erledigt )
		move.w		(a0),d1		; erstes Befehlswort holen
		move.w		d1,d0		; und nach D0
		and.w		#$f000,d0	; Wieder COP-Befehl ?
		eor.w		#$f000,d0
		beq.s		S_again		; Ja-->direkt weitermachen
		move.l		a0,2(a7)	; Neuen PC eintragen
		move.l		S_RegSave+60.w,a0 ; USP wiederherstellen
		move.l		a0,usp		; (geht nur ueber Umweg)
		movem.l		(a3),d0-a6	; Register wiederherstellen
		rte				; Trap beenden
S_rw_sngl:
		and.w		#%1110000,d1	; Registernummer ausmaskieren ( nur Dn )
		lsr.w		#2,d1		; D1=Nummer*4
		move.l		0(a3,d1.w),(a4)	; Register uebertragen (a4==#operand, a3==#dregs)
		bra.s		S_do_ca		; danach kommt immer noch etwas
;-----%xxx00, Transfer multiple coprocessor Reg.
S_rw_00:
		bsr		S_calc_add	; Operandenadresse nach A1 holen
		move.w		S_Reg_Selec(a6),d4 ; Registerliste nach D4 holen
		btst		#13,d0		; Dr-Bit testen
		beq.s		S_w_00		; ==0--> Daten in FPU schreiben
		btst		#12,d0		; Predekrementmodus ?
		beq.s		S_r_pred	; ==0--> Ja,springen
		moveq		#7,d0		; Schleifenzaehler fuer 8 Bits
S_11:
		lsl.w		#1,d4		; Ein Bit ins Carry
		bcc.s		S_21		; nur bei Bit==1 etwas machen
		move.l		(a4),(a1)+	; 1 (A4==#operand)
		move.l		(a4),(a1)+	; 2
		move.l		(a4),(a1)+	; 3 Langworte fuer jedes Register
S_21:
		dbra		d0,S_11		; Fuer alle 8 Bits
                bra.s           S_do_ca         ; Nochmal FPU befragen
S_r_Pred:
		moveq		#7,d0           ; Schleifenzaehler fuer 8 Bits
S_12:
		lsl.w		#1,d4		; Ein Bit ins Carry
		bcc.s		S_22		; nur bei Bit=1 etwas machen
		move.l		(a4),(a1)+	; 1 (A4==#operand)
		move.l		(a4),(a1)+	; 2
		move.l		(a4),(a1)+	; 3 Langworte fuer jedes Register
		suba.w		#24,a1		; Dekrement durchfuehren
S_22:
		dbra		d0,S_12		; Fuer alle 8 Bits
		adda.w		#12,a1		; A1 wieder auf letztes Register
		move.l		a1,(a2)		; A1 als Registerinhalt abspeichern
		bra		S_do_ca		; Nochmal FPU befragen
S_w_00:
		move.w		(a0),d0		; erstes Befehlswort holen
		and.b		#%111000,d0	; Adressierungsart maskieren
		cmp.b		#%011000,d0	; Gleich (An)+ ?
		beq.s		S_w_Post	; Ja-->Postinkrementiermodus
		moveq		#7,d0		; Schleifenzaehler fuer 8 Bits
S_13:
		lsl.w		#1,d4		; Ein Bit ins Carry
		bcc.s		S_23		; Nur bei Bit==1 etwas machen
		move.l		(a1)+,(a4)	; 1 (A4==#operand)
		move.l		(a1)+,(a4)	; 2
		move.l		(a1)+,(a4)	; 3 Langworte fuer jedes Register
S_23:
		dbra		d0,S_13		; Fuer alle 8 Bits
		bra		S_do_ca		; Nochmal FPU befragen
S_w_Post:
		suba.w		#12,a1		; Inkrement von calc_add aufheben
		moveq		#7,d0		; Schleifenzaehler fuer 8 Bits
S_14:
		lsl.w		#1,d4		; Ein Bit ins Carry
		bcc.s		S_24		; nur bei Bit==1 etwas machen
		move.l		(a1)+,(a4)	; 1 (A4==#operand)
		move.l		(a1)+,(a4)	; 2
		move.l		(a1)+,(a4)	; 3 Langworte fuer jedes Register
S_24:
		dbra		d0,S_14		; Fuer alle 8 Bits
		move.l		a1,(a2)		; A1 als Registerinhalt abspeichern
		bra		S_do_ca		; Nochmal FPU befragen

S_rw_1x:
		btst		#11,d0		; zweites Modusbit testen
		bne.s		S_rw_11		; ==1 --> springen (Trap,Error)
		btst		#13,d0		; DR-Bit testen
		beq.s		S_w_10		; ==0 --> Daten an FPU schreiben
;----- %xx110, evaluate effective adress and transfer data
		bsr		S_calc_add	; Operandenadresse berechnen
						; A1=Operandenadresse, d1.l=Operandenl„nge
		cmp.w		#2,d1		; Laenge-2
		ble.s		S_r_bw		; <=2 --> Wort-oder-Byteoperand
S_r_11:
		move.l		(a4),(a1)+	; ein Langwort lesen (A4==#operand)
		subq.l		#4,d1		; und runterzaehlen
		bgt.s		S_r_11		; >0 --> weiter uebertragen
		bra		S_do_ca		; Nochmal FPU befragen
S_r_bw:
		btst		#0,d1		; Byte ?
		bne.s		S_r_byte	; Ja!
		move.w		(a4),(a1)	; Wort-Operand lesen (A4==#operand)
		bra		S_do_ca		; Nochmal FPU befragen
S_r_byte:
		move.b		(a4),(a1)	; Byte-Operand lesen (A4==#operand)
                bra.l           S_do_ca         ; Nochmal FPU befragen

;----- %xx101, evaluate effective adress and transfer data
S_w_10:
		bsr		S_calc_add	; Operandenadresse berechnen
						; A1=Operandenadresse, d1.l=Operandenl„nge
		cmp.w		#2,d1		; Laenge-2
		ble.s		S_w_bw		; <=2 --> Wort-oder-Byteoperand
S_w_11:
		move.l		(a1)+,(a4)	; ein Langwort lesen (A4==#operand)
		subq.l		#4,d1		; und runterzaehlen
		bgt.s		S_w_11		; >0 --> weiter uebertragen
		bra		S_do_ca		; Nochmal FPU befragen
S_w_bw:
		btst		#0,d1		; Byte ?
		bne.s		S_w_byte	; Ja!
		move.w		(a1),(a4)	; Wort-Operand lesen (A4==#operand)
		bra		S_do_ca		; Nochmal FPU befragen
S_w_byte:
		move.b		(a1),(a4)	; Byte-Operand lesen (A4==#operand)
                bra.l           S_do_ca         ; Nochmal FPU befragen

;----- %xxx11, take pre-instruction exception
S_rw_11:
		bra		ex_vec11	; Error-Handler anspringen
;		( hier koennte man eine genauere Fehleranalyse machen )

S_spezial:                                      ; Sprungbefehle etc.
		cmp.w		#%001000000,d1	; FScc,FDBcc oder FTRAPcc
		beq.s		S_s_trap
		cmp.w		#%010000000,d1	; Branch mit 16-Bit-Offset
                beq.l           S_s_br16
		cmp.w		#%011000000,d1	; Branch mit 32-Bit-Offset
                beq.l           S_s_br32
		bra		ex_vec11	; FSAVE/FRESTORE nicht unterstuetzt
S_s_trap:
		move.w		(a0),d0		; Erstes Befehlswort nach D0
		move.w		d0,d1		; und nach D1 retten
		and.w		#%111000,d0	; Wichtige Bits ausmaskieren
		cmp.w		#%001000,d0	; FDBcc ?
		beq.s		S_s_fdbcc	; Ja-->springen
		cmp.w		#%111000,d0	; FTRAP ?
		beq		ex_vec11	; Ja-->Fehler (nicht unterstuetzt)
						; sonst FScc
		move.w		2(a0),S_condition(a6) ; Bedingung an FPU schicken
		moveq		#1,d0		; Operandenlaenge=1 (fuer calc_add)
		bsr		S_calc_add	; Operandenadresse berechnen
S_15:
		move.w		(a6),d0		; Response lesen
		btst		#8,d0		; IA-Bit testen
		beq.s		S_25		; ==0 --> fertig
		and.w		#%1100000000000,d0 ; Bits 11 und 12 ausmaskieren
		eor.w		#%1100000000000,d0 ; Beide gesetzt ?
		bne.s		S_15		; Nicht beide==1 --> warten
		bra		ex_vec11	; Sonst ist Exception aufgetreten
S_25:
		btst		#0,d0		; Antwortbit testen
		sne		(a1)		; Je nach Bit setzen/loeschen
		bra		S_do_ca		; Nochmal FPU befragen
S_s_fdbcc:
		move.w		2(a0),S_condition(a6) ; Bedingung an FPU schicken
		and.w		#%111,d1	; Registernummer maskieren (D1=(A0))
		lsl.w		#2,d1		; D1=Nummer*4
		lea		0(a3,d1.w),a1	; A1 enthaelt Adresse des Datenreg.
		move.l		(a1),d1		; Dn holen
		subq.w		#1,d1		; Dn=Dn-1
		move.l		d1,(a1)		; Dn zurueckschreiben
		move.l		a0,a2           ; alten PC nach A2 holen
		addq.l		#2,a0		; PC 2 weiter ( fuer "nicht springen")
S_16:
		move.w		(a6),d0		; Response lesen
		btst		#8,d0		; IA-Bit testen
		beq.s		S_26		; ==0 --> fertig
		and.w		#%1100000000000,d0 ; Bits 11 und 12 ausmaskieren
		eor.w		#%1100000000000,d0 ; Beide gesetzt ?
		bne.s		S_16		; Nicht beide==1 --> warten
		bra		ex_vec11	; Sonst ist Exception aufgetreten
S_26:
		btst		#0,d0		; Antwortbit testen
		bne		S_do_ca		; True-->das war's schon
		adda.w		2(a2),a2	; 16-Bit-Sprungdist. add. (A2=PC)
		addq.w		#1,d1		; Dn=-1 ?
		beq		S_do_ca		; Ja-->kein Sprung (Schleifenende)
		move.l		a2,a0		; Sonst "Sprung" (neuen PC laden)
		bra		S_do_ca		; nochmal FPU befragen
S_s_br16:
		move.w		(a0),S_Condition(a6) ; Bedingung an FPU schicken
S_17:
		move.w		(a6),d0		; Response lesen
		btst		#8,d0		; IA-Bit testen
		beq.s		S_27		; ==0 --> fertig
		and.w		#%1100000000000,d0 ; Bits 11 und 12 ausmaskieren
		eor.w		#%1100000000000,d0 ; Beide gesetzt ?
		bne.s		S_17		; Nicht beide==1 --> warten
		bra		ex_vec11	; Sonst ist Exception aufgetreten
S_27:
		btst		#0,d0		; Antwortbit testen
		beq		S_do_ca		; False--> das war's schon
		adda.w		2(a0),a0	; 16-Bit-Sprungdistanz addieren
		subq.l		#2,a0		; Ein Wort zurueck ( weil spaeter
		; noch 4 addiert wird und und nur 2 addiert werden muesste )
		bra		S_do_ca		; Nochmal FPU befragen
S_s_br32:
		move.w		(a0),S_Condition(a6) ; Bedingung an FPU schicken
S_18:
		move.w		(a6),d0		; Response lesen
		btst		#8,d0		; IA-Bit testen
		beq.s		S_28	; ==0 --> fertig
		and.w		#%1100000000000,d0 ; Bits 11 und 12 ausmaskieren
		eor.w		#%1100000000000,d0 ; Beide gesetzt ?
		bne.s		S_18	; Nicht beide==1 --> warten
		bra		ex_vec11	; Sonst ist Exception aufgetreten
S_28:
		addq.l          #2,a0		; Befehl ist 3 Worte lang
						; (jetzt : (A0)=Distanz)
		btst		#0,d0		; Antwortbit testen
		beq		S_do_ca		; False--> das war's schon
		adda.l		(a0),a0		; 32-Bit-Sprungdistanz addieren
		subq.l		#4,a0		; Zwei Worte zurueck ( weil spaeter
		; noch 4 addiert wird, 2 wurden schon addiert )
		bra		S_do_ca		; Nochmal FPU befragen
S_calc_add:
		; Operandenadresse berechnen. A0 muss die Adresse des Line-F-
		; Befehls enthalten, D0 im unteren Byte die Operandenlaenge.
		; die zu berechnende Adresse wird in A1 abgelegt. A0 wird
		; um die Laenge der zusaetzlichen Daten erhaelt.
		; Zusaetzlich wird in D1 die Laenge des Operanden zurueckge-
		; geben (in Bytes, als Langwort). D2,D3,A3 werden zerstoert.
		; Bei den Adressierungsarten -(An),(An)+ steht in A2 ein
		; Zeiger auf die Stelle, in der der Inhalt des Adressregisters
		; gisters An steht (wird fuer FMOVEM gebraucht).

		clr.l		d1		; Laenge als Langwort loeschen
		move.b		d0,d1		; und Byte umkopieren
		move.w		(a0),d2		; erstes Befehlswort nach D2
		move.w		d2,d3		; und D3 retten
		and.w		#%111000,d3	; Adressierungsart ausmaskieren
		lsr.w		#1,d3		; D3=Adressierungsart*4 (Langworte)
                lea             S_cs_tab(pc),a1 ; Sprungtabellenadresse nach A1
		move.l		0(a1,d3.w),a1	; Adresse der Routine nach A1
		jmp		(a1)		; und Routine anspringen
S_c_drd:	; %000  Data Register Direct:			    Dn
S_c_ard:	; %001  Address Register Direct:        	    An
		lea		(a3),a1		; A1 auf Registerfeld
		and.w		#%1111,d2	; Registernummer ausmaskieren
;		( und ein Bit vom Modus, 0 fuer Daten-,1 fuer Adressregister )
		lsl.w		#2,d2		; D2="Registernummer"*4 (+Modusbit)
		addq.w		#4,d2		; +4 (fuer Operandenlaenge)
		sub.w		d1,d2		; Wahre Laenge abziehen
		adda.w		d2,a1		; Offset auf Registerfeldanfang add.
		rts
S_c_ari:	; %010  Address Register indirect:		    (An)
		and.w		#%111,d2	; Registernummer ausmaskieren
		lsl.w		#2,d2		; D2=Registernummer*4
		move.l		32(a3,d2.w),a1	; Adresse nach A1
		rts
S_c_arpo:	; %011	Adressregister indirect with Postincrement: (An)+
		and.w		#%111,d2	; Registernummer ausmaskieren
		lsl.w		#2,d2		; D2=Registernummer*4
		lea		32(a3,d2.w),a2	; Adresse Adressregister nach A2
		move.l		(a2),a1		; Adresse (Inhalt A.-Reg.) nach A1
		btst		#0,d1		; D1 ungerade ? (Byteoperand)
		bne.s		S_29		; Ja-->Spezialbehandlung
S_19:
		add.l		d1,(a2)		; Inkrement durchfuehren
		rts
S_29:
		cmp.w		#4*7,d2		; Ist A7 gemeint ?
		bne.s		S_19		; nein-->normal vorgehen
		addq.l		#2,(a2)		; Sonst (bei Byte) 2 addieren,
		rts				; damit Stack gerade bleibt!
S_c_arpr:	; %100  Adressregister Indirect with Predekrement:  -(An)
		and.w		#%111,d2	; Registernummer ausmaskieren
		lsl.w		#2,d2		; D2=Registernummer*4
		lea		32(a3,d2.w),a2	; Adresse des Adressreg. nach A2
		btst		#0,d1		; D1 ungerade? (Byteoperand)
		bne.s		S_210		; Ja-->Spezialbehandlung
S_110:
		sub.l		d1,(a2)		; Dekrement durchfuehren
		move.l		(a2),a1		; Adresse (Inhalt des A.-Reg) nach A1
		rts
S_210:
		cmp.w		#4*7,d2		; Ist A7 gemeint?
		bne.s		S_110		; nein-->normal vorgehen
		subq.l		#2,(a2)		; Sonst (bei Byte) 2 addieren,
						; damit Stack gerade bleibt !
		move.l		(a2),a1		; Adresse (Inhalt des A.-Reg) nach A1
		rts
S_c_ar16:	; %101  Addressregister Indirect with Displacement: d16(An)
		and.w		#%111,d2	; Registernummer ausmaskieren
		lsl.w		#2,d2		; D2=Registernummer*4
		move.l		32(a3,d2.w),a1	; Adresse nach A1
		move.w		4(a0),d2	; 3.Befehlswort nach D2 (Offset)
		adda.w		d2,a1		; Offset auf Adresse addieren
		addq.l		#2,a0		; A0 ein Wort (d16) weiter
		rts
S_c_ar08:	; %110  Addressregister Indirect with Index : 	    d8(An,Xn)
		and.w		#%111,d2	; Registernummer ausmaskieren
		lsl.w		#2,d2		; D2=Registernummer*4
		move.l		32(a3,d2.w),a1	; Adresse nach A1
		move.w		4(a0),d2	; 3.Befehlswort nach D2 (Byte-Offset)
		move.w		d2,d3		; und nach D3
		and.w		#$ff,d3		; Byte ausmaskieren (Byte-Offset)
		adda.w		d3,a1		; Offset auf Adresse addieren
		btst		#11,d2		; 1=long; 0=word
		bne.s		S_c_ar81
		and.w		#%1111000000000000,d2 ; Nummer von Dn und Modusbit
		lsr.w		#5,d2		; maskieren
		lsr.w		#5,d2		; D2=Registernummer*4 (und modusbit)
		adda.w		2(a3,d2.w),a1	; 16-Bit-Index auf A1 addieren
		addq.l		#2,a0		; A0 ein Wort (Kram & d8) weiter
		rts
S_c_ar81:
		and.w		#%1111000000000000,d2 ; Nummer von Dn und Modusbit
		lsr.w		#5,d2		; maskieren
		lsr.w		#5,d2		; D2=Registernummer*4 (und modusbit)
		adda.w		0(a3,d2.w),a1	; 32-Bit-Index auf A1 addieren
		addq.l		#2,a0		; A0 ein Wort (Kram & d8) weiter
		rts
S_c_pc:		; %111  absolut short/long, PC-relativ (ohne/mit Index) \ oder direkt
		btst		#2,d2		; Immidiate ?
		bne.s		S_immi		; <>0 --> Ja!
		btst		#1,d2		; PC-relativ ?
		bne.s		S_pc_rel	; <>0 --> Ja!
		btst		#0,d2		; Long ?
		bne.s		S_c_long	; <>0 --> Ja!
						; sonst short
		move.w		4(a0),d2	; Wortadresse holen
		ext.l		d2		; Auf Langwort erweitern
		move.l		d2,a1		; und als Operandenadresse merken
		addq.l		#2,a0		; A0 ein Wort (Short-A.) weiter
		rts
S_c_long:
		move.l		4(a0),a1	; Langwortadresse holen
		addq.l		#4,a0		; A0 zwei Worte (Long-A.) weiter
		rts
S_immi:
		move.l		a0,a1		; Befehlsadresse nach A1
		add.l		d1,a0		; A0 ueber Operand hinwegsetzen
		rts
S_pc_rel:
		btst		#0,d2		; mit Index ?
		bne.s		S_pc_idx	; <>0 --> Ja!
		move.l		a0,a1		; PC nach A1
		adda.w		4(a0),a1	; Offset addieren
		addq.l		#4,a1		; +4 fuer Laenge des FPU-Befehls
		addq.l		#2,a0		; A0 zwei (16-Bit-Offset) weiter
		rts
S_pc_idx:
		move.l		a0,a1		; PC nach A1
		clr.w		d2		; Oberes Byte loeschen
		move.b		5(a0),d2	; Offset nach D2
		adda.w		d2,a1		; und addieren
		addq.l		#4,a1		; +4 fuer Laenge des FPU-Befehls
		move.b		4(a0),d2	; D2=Registernummer*16 und Modusbit
						; ( high-Byte ist noch 0 )
		btst		#3,d2		; Long-Bit testen
		bne.s		S_pc_i_l	; <>0 -->Long-Index
		and.b		#%11110000,d2	; Registerinformation ausblenden
		lsr.w		#2,d2		; D2=Registernummer*4 (und Modusbit)
		adda.w		2(a3,d2.w),a1	; Word-Index addieren
		addq.l		#2,a0		; A0 zwei (8-Bit-Offset & Kram) weiter
		rts
S_pc_i_l:
		and.b		#%11110000,d2	; Restinformation ausblenden
		lsr.w		#2,d2		; D2=Registernummer*4 (und Modusbit)
		adda.l		0(a3,d2.w),a1	; Long-Index addieren
		addq.l		#2,a0		; A0 zwei (8-Bit-Offset & Kram) weiter
		rts				; Ende von S_calc_add

S_cs_tab:
		dc.l		S_c_drd,S_c_ard,S_c_ari,S_c_arpo ; Sprungtabelle fuer
		dc.l		S_c_arpr,S_c_ar16,S_c_ar08,S_c_pc ; Adressierungsarten
S_End:

