start:
                lea     stack,A0
                movea.l A0,SP           ; neuer Stack
                addq.l  #4,A0           ; kleiner Sicherheitsabstand
                move.l  A0,aa_memory    ; Anfangsadresse merken
                jsr     autoaccinstall
                clr.w   -(SP)           ; Pterm()
                trap    #1              ; und raus hier

crlf:
                lea     ret(PC),A0      ; CR+LF ausgeben

strout:
                move.l  A0,-(SP)        ; a0 auf Stack
                move.w  #9,-(SP)        ; Cconws
                trap    #1              ; GEMDOS
                addq.l  #6,SP           ; SP korrigieren
                rts

****************************************
* autoaccinstall:
* Ausgabe der Initialisierungsmedung und
* des Bootlaufwerken.
****************************************
autoaccinstall:                         ; (df) Die Erweiterung
                movem.l D0-A6,-(SP)     ; alle Register retten
auto2accinstall:
				move.w  #0,newDevice	
                lea     shshclr(PC),A0  ; -> CLR
                bsr     strout          ; Bildschirm l”schen
                bsr     crlf            ; CR+LF ausgeben
                lea     shshmsg(PC),A0  ; -> Initialisierungs-Message
                bsr     strout          ; ausgeben
                bsr     crlf            ; CR+LF ausgeben

;       move.b  protstr2+1(pc), drive   ; Bootlaufwerk des CBHD holen
                move.w  #$19,-(SP)      ; Dgetdrv
                trap    #1              ; Gemdos
                addq.l  #2,SP
                add.w   #'A',D0         ; erzeuge Laufwerkssymbol
                move.b  D0,drive        ; und baue es in die Ausgabe ein

                lea     booting,A0      ; Laufwerksbezeichnung
                bsr     strout          ; ausgeben
                bsr     auto_acc        ; zur Hauptroutine
                tst.w   newDevice       ; wenn ein neues Laufwerke aus-
                bne.b   auto2accinstall ; gew„hlt wurde -> NOCHMAL!
                lea     shshclr(PC),A0  ; -> CLR
                bsr     strout          ; Bildschirm l”schen
                movem.l (SP)+,D0-A6     ; alle Register restaurieren
                rts                     ; und ENDE

***************************************
* loaddir:
* L„dt die Namen der Accessorys,
* Auto-Ordner Programme und Setup-Dateien
* aus den entsprechenden Directories
* a0: Directoryname (\, \AUTO, \SETUP)
* a1: Filemaske (*.AC?, *.PR?, *.SET)
* a5: Adresse des Speicherbereichs fr
*     die Namen
****************************************
loaddir:
                moveq   #0,D1           ; Z„hler fr die Anzahl der Namen auf 0
                move.l  A0,-(SP)        ; Pfad auf den Stack
                move.w  #$3B,-(SP)      ; Dsetpath()
                trap    #1              ; Gemdos
                addq.l  #6,SP           ; Stack korrigieren
                tst.l   D0              ; hat's geklappt
                bne.b   endload         ; Directory existiert nicht
                move.w  #$07,-(SP)      ; setze modus fr Fsfirst() auf 0x07
                move.l  A1,-(SP)        ; Lege Maske auf den Stack
                move.w  #$4E,-(SP)      ; Fsfirst
                trap    #1              ; Gemdos
                addq.l  #8,SP           ; Stack korrigieren
                tst.l   D0              ; wenigstens eine Datei vorhanden
                bne.b   endload         ; Nun, das ging ja schnell
                move.w  #$2F,-(SP)      ; Fgetdta()
                trap    #1              ; Gemdos
                addq.l  #2,SP           ; Stack nicht vergessen
                movea.l D0,A1           ; Adresse der DTA-Struktur
                adda.w  #30,A1          ; Anfang des gefundenen Dateinamens merken
                movea.l A5,A0           ; Speicheradresse
                bsr     strcopy         ; und kopieren des Basenames (ohne EXT)
nextload:
                addq.l  #1,D1           ; Erh”he Dateiz„hler um 1
                move.w  #$4F,-(SP)      ; Fsnext()
                trap    #1              ; Gemdos
                addq.l  #2,SP           ; und der Stack
                tst.l   D0              ; gibt's noch 'nen File
                bne.b   endload         ; Dann eben nicht
                move.w  #$2F,-(SP)      ; Fgetdta()
                trap    #1              ; Gemdos
                addq.l  #2,SP           ; Stack nicht vergessen
                movea.l D0,A1           ; Hole Adresse der DTA
                adda.w  #30,A1          ; und den Anfang des Filenamens
                move.l  D1,D7           ; Filez„hler
                asl.l   #4,D7           ; mal 16
                lea     0(A5,D7.w),A0   ; filename_memory[16*Z„hler]
                bsr     strcopy         ; kopiere Basename
                bra.b   nextload        ; und noch ein Versuch
endload:
                rts                     ; das war's dann erst einmal

****************************************
* auto_acc:
* Hauptroutine: L„žt die Dateinamen
* einlesen und verwaltet den Bildschirm-
* aufbau und reagiert auf den jeweiligen
* Tastendruck. Wechselt zwischen SETUP
* und AUTO hin und her. Bewegt sich
* zwischen den Filenamen umher und
* scrollt n”tigenfalls.
****************************************
auto_acc:
                moveq   #0,D2           ; Initialisiert die Z„hler fr die Setups
                movea.w #0,A2           ; und die Speicheradresse die Setup-Namen
                moveq   #0,D3           ; dito. AutoPrg-Z„hler
                movea.w #0,A3           ; und AutoPrg-Namen
                moveq   #0,D4           ; Schon erraten?
                movea.w #0,A4           ; fr die Accessorys
                pea     dtabuffer(PC)
                move.w  #$1A,-(SP)      ; Fsetdta
                trap    #1              ; Gemdos
                addq.l  #6,SP           ; und natrlich der Stack
                move.l  aa_memory,aa_nextfree ; Freier Speicher hinter Claus Ordnererw.
test_set:
                lea     setupdir,A0     ; Setup-Dir '\SETUP\',
                lea     setx,A1         ; Maske '*.SET' und
                movea.l aa_nextfree,A5  ; Speicherplatz als Parameter
                bsr     loaddir         ; fr ???
                move.l  D1,D2           ; merken der Anzahl der Setup-Files
                beq.b   test_prg        ; Na, viele waren es aber nicht
                movea.l aa_nextfree,A2  ; merken der Adresse der Namen
                asl.l   #4,D1           ; 16 * Anzahl
                add.l   D1,aa_nextfree  ; dazu ergibt n„chsten freien Speicher
test_prg:
                lea     bootdir,A0      ; Boot-Dir. Immer '\AUTO\'
                lea     prgx,A1         ; Maske '*.PR?' und
                movea.l aa_nextfree,A5  ; freien Platz fr die Namen
                bsr     loaddir
                move.l  D1,D3           ; Anzahl der AutoPrg merken
                beq.b   test_acc        ; Ein paar k”nnten es schon sein
                movea.l aa_nextfree,A3  ; Adresse der Namen merken
                asl.l   #4,D1           ; 16 * Anzahl
                add.l   D1,aa_nextfree  ; dazu gibt neue Anfangsadresse
test_acc:
                lea     rootdir,A0      ; Root-Dir '\', was sonst
                lea     accx,A1         ; Maske '*.AC?'
                movea.l aa_nextfree,A5  ; und freier Speicher
                bsr     loaddir
                move.l  D1,D4           ; Anzahl merken
                beq.b   end_acc         ; keine Acc? (merkwrdig!!)
                movea.l aa_nextfree,A4  ; Adresse der Namen
                asl.l   #4,D1           ; 16 * Anzahl
                add.l   D1,aa_nextfree  ; dazu ergibt freien Restspeicher

end_acc:
                move.l  A2,sets         ; Ermittelte Werte speichern
                move.l  D2,set_count
                move.l  A3,prgs
                move.l  D3,prg_count
                move.l  A4,accs
                move.l  D4,acc_count

                moveq   #1,D3           ; Beginne bei den AutoPrg's
                move.l  D3,acc__prg     ; und merken
                moveq   #0,D4           ; noch keine Taste gedrckt
                move.l  D4,scancode     ; ebenfalls merken
                moveq   #0,D0           ; X-Position
                moveq   #4,D1           ; und Y-Position
                bsr     gotoxy
                lea     begmenu(PC),A0  ; Kopfzeile des Rahmens
                bsr     strout          ; ausgeben
                moveq   #15,D7          ; 16 mal
menuloop:
                lea     medmenu(PC),A0  ; den Seitenrahmen
                bsr     strout          ; ausgeben
                dbra    D7,menuloop
                lea     endmenu(PC),A0  ; Rahmenabschluž
                bsr     strout          ; ausgeben

                moveq   #0,D5           ; aktueller Position in der Namensliste
                move.l  D5,offset       ; und den Scrolloffset aud 0 setzen
hndl_menu:
                move.l  acc__prg(PC),D3 ; wo stehen wir denn (0=Setup, 1=Auto, 2=Acc)
                cmpi.l  #$4B0000,D4     ; CRSR-LEFT ?
                bne.b   testright       ; vielleicht rechts herum
                moveq   #0,D5           ; aktueller Position in der Namensliste
                move.l  D5,offset       ; und den Scrolloffset aud 0 setzen
                subq.l  #1,D3           ; um eins nach links gehen
                bcc.b   testright       ; vorne rausgefallen
                addq.l  #3,D3           ; dann wieder hinten anfangen
testright:
                cmpi.l  #$4D0000,D4     ; CRSR-RIGHT ?
                bne.b   headline        ; dann, weiter
                moveq   #0,D5           ; aktueller Position in der Namensliste
                move.l  D5,offset       ; und den Scrolloffset aud 0 setzen
                addq.l  #1,D3           ; um eins nach recht herum
                cmpi.l  #3,D3           ; rechts herausgefallen
                bcs.b   headline
                subq.l  #3,D3           ; dann wieder vorne anfangen
headline:
                move.l  D3,acc__prg     ; Position merken
                tst.l   D3              ; bearbeiten wir die Setups
                bne.b   test2           ; dann halt Auto oder Acc
                movea.l sets,A2         ; Die Setupnamen
                move.l  set_count,D2    ; und die Anzahl holen
                bsr     re_set          ; setze alle auf deselektiert
                lea     header1(PC),A3  ; Header und
                lea     trailer1(PC),A4 ; Trailer fšr die Setups
                bra.b   endcase
test2:
                cmpi.l  #1,D3           ; vielleicht sind's AutoPrg
                bne.b   test3           ; dann sind Acc
                movea.l prgs,A2         ; AutoPrg-Namen
                move.l  prg_count,D2    ; und die Anzahl holen
                lea     header2(PC),A3  ; Der Header und
                lea     trailer2(PC),A4 ; Trailer fr die AutoPrgs
                bra.b   endcase
test3:
                movea.l accs,A2         ; Die Accessory-Namen
                move.l  acc_count,D2    ; und die Anzahl holen
                lea     header3(PC),A3  ; Den etsprechenden Header
                lea     trailer3(PC),A4 ; und Trailer
endcase:
                moveq   #6,D0
                moveq   #3,D1
                bsr     gotoxy          ; GOTOXY(6,3)
                movea.l A3,A0
                bsr     strout          ; Header ausgeben
                moveq   #0,D0
                moveq   #22,D1
                bsr     gotoxy          ; GOTOXY(0,22)
                movea.l A4,A0
                bsr     strout          ; und nun den Trailer

                moveq   #0,D3           ; Anfang der Liste
                moveq   #15,D4          ; und Ende
                bsr     put_menu        ; Ausgabe der Namen
hndl_files:
                move.w  #7,-(SP)        ; Crawin()
                trap    #1              ; Gemdos
                addq.l  #2,SP           ; korrigiere den Stack
                move.l  D0,D4
                move.l  D4,scancode     ; Taste merken
                moveq   #-1,D1          ; Alte Position in der Namensliste init.

                cmpi.l  #$1C000D,D4     ; RETURN
                bne     testup          ; sonst weiter gucken
                tst.l   D2              ; wenn kein Eintrag da ist
                beq     test_while      ; ist nichts zu tun
testprg1:
                tst.l   acc__prg        ; Sind es Setups
                beq     setup           ; dann Spezialbehandlung

                cmpi.l  #1,acc__prg     ; AutoProgramme ?
                bne.b   testacc1        ; dann halt Accessorys
                lea     oldfile,A0
                lea     bootdir,A1
                bsr     strcpy          ; '\AUTO\' nach oldfile
                lea     newfile,A0
                lea     bootdir,A1
                bsr     strcpy          ; und nach newfile kopieren
                bra.b   cp_filename
testacc1:
                lea     oldfile,A0
                lea     rootdir,A1
                bsr     strcpy          ; '\' nach oldfile
                lea     newfile,A0
                lea     rootdir,A1
                bsr     strcpy          ; und nach newfile kopieren
cp_filename:
                move.l  D5,D0           ; aktueller Eintrag
                add.l   offset(PC),D0   ; + offset
                asl.l   #4,D0           ; * 16 (+1) ergibt
                lea     1(A2,D0.w),A1   ; die Anfangsadresse des Namens
                move.l  A1,-(SP)        ; merken auf dem Stack
                lea     oldfile,A0      ; an den Pfadnamen
                bsr     strcat          ; anh„ngen
                movea.l (SP)+,A1        ; Namen holen
                move.l  A1,-(SP)        ; und wieder merken
                lea     newfile,A0      ; auch an hier anh„ngen
                bsr     strcat
                movea.l (SP)+,A0        ; Name
                subq.l  #1,A0           ; -1: hier steht die Aktivierungsmarkierung
                tst.b   (A0)            ; fr den Namen: aktiviert?
                bne.b   acttounact      ; ja dann .??[CG] -> .??X
unacttoact:
testprg2:
                cmpi.l  #1,acc__prg     ; AutoPrg?
                bne.b   testacc2        ; dann Acc
                lea     prx,A1          ; '.PRX'
                lea     oldfile,A0      ; an oldfile
                bsr     strcat          ; anh„ngen
                lea     prg,A1          ; '.PRG'
                lea     newfile,A0      ; an newfile
                bsr     strcat          ; anh„ngen
                bra.b   rename          ; und umbenennen
testacc2:
                lea     acx,A1          ; dito fr Accessories
                lea     oldfile,A0
                bsr     strcat
                lea     acc,A1
                lea     newfile,A0
                bsr     strcat
                bra.b   rename          ; und umbenennen
acttounact:
testprg3:
                cmpi.l  #1,acc__prg     ; AutoPrg?
                bne.b   testacc3        ; dann Acc
                lea     prg,A1          ; '.PRG'
                lea     oldfile,A0      ; an oldfile
                bsr     strcat          ; anh„ngen
                lea     prx,A1          ; '.PRX'
                lea     newfile,A0      ; an newfile
                bsr     strcat          ; anh„ngen
                bra.b   rename          ; und umbenennen
testacc3:
                lea     acc,A1          ; dito fr Accessories
                lea     oldfile,A0
                bsr     strcat
                lea     acx,A1
                lea     newfile,A0
                bsr     strcat
rename:
                pea     newfile         ; Neuer Name und
                pea     oldfile         ; alter Name auf den Stack
                move.w  #0,-(SP)        ; dummy
                move.w  #$56,-(SP)      ; Frename()
                trap    #1              ; Gemdos
                lea     $0C(SP),SP      ; Stack korrigieren
                tst.w   D0              ; hat's geklappt
                bne     hndl_files      ; wenn nicht Markierung nicht „ndern

                move.l  D5,D0           ; bestimme die Anfangsadresse
                add.l   offset(PC),D0   ; des Namens
                asl.l   #4,D0
                eori.b  #$FF,0(A2,D0.w) ; und invertiere die Markierung
                bra     godown          ; und einen Eintrag weiter
testup:
                cmpi.l  #$480000,D4     ; CRSR-UP ?
                bne.b   testdown
                tst.l   D2              ; kein Eintrag da?
                beq.b   firstentry
                move.l  D5,D1           ; alte Pos. = akt. Pos.
                subq.l  #1,D5           ; vermindere Pos. um eins
                bcc.b   print_change    ; nicht ber den oberen Rand
                move.l  offset(PC),D0   ; hole den Scrolloffset
                bne.b   decoffset       ; nicht 0 ernidrige diesen
                move.l  D2,D0           ; absolut erster Eintrag und CRSR-UP
                sub.l   #9,D0           ; sind es weniger als 9 Eintr„ge
                bcs.b   less9           ; dann zu letzen und nicht mehr
                and.b   #$F8,D0         ; d0 = d0 DIV 8
                move.l  D0,offset       ; ergibt den offset (in Vielfachen von 8)
                move.l  D2,D5           ; Anzahl
                sub.l   D0,D5           ; - Offset -1 sei die aktuelle Position
                subq.l  #1,D5
                bra.b   print_change    ; Žnderung ausgeben
decoffset:
                subq.l  #8,offset       ; vermindere den Offset um "1" sprich: 8
                moveq   #7,D5           ; akt. Pos. ist die letzte in diese Gruppe
                bra.b   print_change    ; und ausgeben
less9:
                move.l  #0,offset       ; offset auf 0
                add.l   D2,D5           ; akt. Pos. += Anzahl (oder akt. Pos. = Anzahl - 1)
                bra.b   print_change    ; und ausgeben
testdown:
                cmpi.l  #$500000,D4     ; CRSR-DOWN ?
                bne.b   test_nracc      ; keine Taste von Bedeutung
godown:
                move.l  D5,D1           ; alte Pos. = akt. Pos.
                addq.l  #1,D5           ; erh”he akt. Pos. um eins
                move.l  D5,D0
                add.l   offset(PC),D0   ; addiere dazu den Offset
                cmp.l   D2,D0           ; ber das Ende hinaus geschossen
                bcs.b   scrolldown      ; Nein
firstentry:
                moveq   #0,D5           ; Beginne wieder am Anfang
                move.l  #0,offset
                bra.b   print_change    ; und ausgeben
scrolldown:
                cmpi.l  #16,D5          ; am Ende einer Seite angekommen
                bne.b   print_change    ; auch nicht dann ist aller klar
                addq.l  #8,offset       ; Erh”he Offset um "1"
                moveq   #8,D5           ; und setze akt. Pos. auf den Anfang
print_change:
                move.l  D1,D0           ; liegen die akt. Pos. und die alte
                sub.l   D5,D0           ; nebeneinander oder anders hat kein
                bcc.b   put             ; Sprung oder Scroll stattgefunden
                neg.l   D0
put:
                cmpi.l  #1,D0
                beq.b   print2change    ; akt. und alt liegen nebeneinander
put2:
                moveq   #0,D3           ; Sprung oder Scroll
                moveq   #15,D4          ; alles neu zeichnen
                bsr     put_menu
                bra     hndl_files      ; und alles von vorn
print2change:                           ; <RETURN> oder kein Scroll/Jump
                move.l  D1,D3           ; zeichne von alter Pos.
                move.l  D5,D4           ; bis zur neuen Pos. neu
                bsr     put_menu
                bra     hndl_files      ; und nochmal das ganze
test_nracc:
                cmpi.l  #2,acc__prg     ; Bearbeitung von Acc
                bne.b   test_while      ; Nee
                bsr     countacc
                cmpi.l  #7,D0           ; sind mehr als 6 Acc aktiv?
                bcs.b   test_while      ; nein, dann ist ja gut
toomanyacc:
                lea     header3,A3
                lea     toomuchacc,A4   ; so geht das aber nicht
                bra     endcase         ; Na, das probieren wir aber nochmal
test_while:
				cmp.b   drive,D4
				beq.b   test_esc        ; Selbes Laufwerk wie vorher
				move.l	D4,D0           ; Hole die gedrckte Taste
				andi.w  #$FFFF,D0       ; Nur ASCII-Code interessant
				cmp.b   #'A',D0
				blt.b   test_esc        ; Kleiner 'A'; Kein Laufwerk
				cmp.b   #'P',D0
				bgt.b   test_esc        ; Gr”žer 'P'; Kein Laufwerk
				clr.w   D0
				move.b  drive,D0
				sub.w   #'A',D0
				move.w  D0,-(SP)        ; Altes Laufwerk
                move.w  #$0E,-(SP)      ; Dsetdrv
                trap    #1              ; Gemdos
                addq.l  #4,SP           ; korrigiere Stack
                andi.w  #$FFFF,D4       ; Nur ASCII-Code interessant
                move.w  D4,D1           ; Neue Laufwerksbezeichnung
                sub.w   #'A',D1         ; Neue Laufwerksnummer
				move.l  #1,D7
				lsl     D1,D7           ; Laufwerksnummer-Bit
				and.w	D0,D7           ; aktives Laufwerk ?
				beq.b   test_esc        ; Nein -> ignoriere Taste
;       move.b  D4,protstr2+1(pc)       ; Bootlaufwerk des CBHD holen
				move.w  D1,-(SP)        ; Neues Laufwerk
                move.w  #$0E,-(SP)      ; Dsetdrv
                trap    #1              ; Gemdos
                addq.l  #4,SP           ; korrigiere Stack
				
				move.w	#1,newDevice    ; Neues Laufwerk gew„hlt
				bra     endhndl_menu    ; Und alles frs neue Laufwerk
test_esc:
                cmpi.l  #$01001B,D4     ; ESC
                bne     hndl_menu       ; nein, immer noch nicht fertig
endhndl_menu:
                move.l  #2,acc__prg     ; ACC vorw„hlen
                movea.l accs,A2         ; Mal nachsehen ob zu viele Acc
                move.l  acc_count,D2    ; durch ein Setup aktiviert worden sind
                bsr     countacc
                cmpi.l  #7,D0           ; sind mehr als 6 Acc aktiv?
                bcc     toomanyacc      ; Nun, so aber nicht
endautuacc:
                rts                     ; geschaffffft !!!

****************************************
* countacc:
* a2: Namensliste der Accessories
* d2: Anzahl der Accessories
****************************************
countacc:
                moveq   #0,D0           ; Anzahl aktivierter Acc (erstmal 0)
                move.l  D2,D1           ; Sind berhaupt welche da?
                beq.b   endcountacc     ; Auch nicht
                subq.l  #1,D1           ; Schleifenz„hler = Anzahl - 1
loopnracc:
                move.l  D1,D7
                asl.l   #4,D7
                tst.b   0(A2,D7.w)      ; ist das d0te Acc aktiviert
                beq.b   eloopnracc      ; nicht aktiviert
                addq.l  #1,D0           ; und da ist noch eines aktiviert
eloopnracc:
                dbra    D1,loopnracc    ; Ende bei d0 = -1
endcountacc:
                rts

****************************************
* re_set:
* Setzt alle Eintr„ge (Setups) auf
* deaktiviert
* a2: Namensliste
* d2: Anzahl
****************************************
re_set:
                tst.l   D2              ; aber nur wenn es welche gibt
                beq.b   endre_set       ; schon fertig
                move.l  D2,D7           ; Schleifenz„hler
                subq.l  #1,D7           ; = Anzahl - 1
loopre_set:
                move.l  D7,D0           ; Anfangsadresse des d7ten Setups
                asl.l   #4,D0           ; berechnen
                move.b  #0,0(A2,D0.l)   ; setze auf deaktiviert
                dbra    D7,loopre_set   ; Ende bei d7 = -1
endre_set:
                rts                     ; fertig

****************************************
* setup:
* Spezialbehandlung fr die Setups
* a2: Namensliste
* d2: Anzahl
* d5: ausgew„hlte Eintrag
****************************************
setup:
                move.l  D5,D0           ; (aktueller Eintrag
                add.l   offset(PC),D0   ; + offset) * 16
                asl.l   #4,D0           ; ergibt Markierung des d5ten Eintrags
                move.b  #$FF,0(A2,D0.l) ; setze Markierung
                move.l  D5,D3           ; zeichne von
                move.l  D5,D4           ; bis
                bsr     put_menu        ; das Menu neu
                movem.l D0-A6,-(SP)     ; besser mal alles sichern

                move.l  aa_nextfree,filebuffer ; Beginn des freien Restspeichers

                lea     setupdir,A1     ; Stelle den Namen des Setups
                lea     filename,A0     ; incl. Pfad zusammen
                bsr     strcpy
                move.l  D5,D0           ; Eintrag
                add.l   offset(PC),D0   ; + offset
                asl.l   #4,D0           ; * 16
                lea     1(A2,D0.l),A1   ; Name des Eintrags
                tst.b   -(A0)           ; zurck aufs '\0'-Byte
                bsr     strcpy
                lea     setpost,A1      ; '.SET'
                tst.b   -(A0)           ; dazu
                bsr     strcpy
                move.w  #0,-(SP)        ; Readonly
                pea     filename
                move.w  #$3D,-(SP)      ; Fopen()
                trap    #1              ; Gemdos
                addq.l  #8,SP           ; und der Stack
                move.w  D0,D1           ; filehandle merken
                bmi     anywrong        ; Schade nicht mehr gefunden
                move.w  #2,-(SP)        ; Vom Ende der Datei
                move.w  D1,-(SP)        ; handle
                move.l  #0,-(SP)        ; 0 Bytes Abstand -> Das Ende der Datei
                move.w  #$42,-(SP)      ; Fseek()
                trap    #1              ; Gemdos
                move.l  D0,D7           ; filel„nge merken
                move.w  #0,8(SP)        ; Diesmal vom Enfang der Datei
                trap    #1              ; Fseek (Begin)
                lea     $0A(SP),SP      ; korrigiere den Stack
                tst.l   D7              ; filelen == 0 ?
                beq.b   closefile       ; dann Schluss
                movea.l filebuffer,A0   ; Der Platz fr das Setup-File
                adda.l  D7,A0           ; ans Ende der Datei
                move.b  #$0A,(A0)+      ; CR
                move.b  #$0D,(A0)+      ; LF ans Ende anfgen
                move.b  #$00,(A0)+      ; und noch zwei '\0'-Bytes
                move.b  #$00,(A0)+      ; Achtung: M”gl. Ungerade Adressen
                move.l  A0,copybuffer   ; Dahinter der Kopier-Buffer
                move.l  filebuffer,-(SP)
                move.l  D7,-(SP)        ; Anzahl der Bytes
                move.w  D1,-(SP)        ; filehandle
                move.w  #$3F,-(SP)      ; Fread()
                trap    #1              ; Gemdos
                lea     $0C(SP),SP      ; Stack korrigieren
closefile:
                move.w  D1,-(SP)        ; filehandle
                move.w  #$3E,-(SP)      ; Fclose()
                trap    #1              ; Gemdos
                addq.l  #4,SP           ; Stack korrigieren
                tst.l   D7              ; filelen == 0
                beq     anywrong        ; dann Abbruch

de_acc:
                movea.l accs,A2         ; Deaktiviere alle Accessories
                move.l  acc_count,D2
                beq.b   de_prg          ; keine Accessories
                subq.l  #1,D2
                lea     acc,A3          ; '.ACC' als Parameter
de_acc2:
                lea     rootdir,A1      ; '\'
                bsr     deactall
                dbra    D2,de_acc2      ; Bis alle bearbeitet
de_prg:
                movea.l prgs,A2         ; Deaktiviere alle AutoPrg's
                move.l  prg_count,D2
                beq.b   testfile        ; keine da
                subq.l  #1,D2
                lea     prg,A3          ; '.PRG' als Parameter
de_prg2:
                lea     bootdir,A1      ; '\AUTO\'
                bsr     deactall
                dbra    D2,de_prg2      ; bis alle deaktiviert

testfile:
                movea.l filebuffer,A3   ; Interpretiere Setup-Datei vom Anfang an
test_A:
                cmpi.b  #$23,(A3)+      ; #
                bne     nextline
                cmpi.b  #$41,(A3)+      ; A
                bne.b   test_P
                moveq   #0,D1
                bra.b   test_nxt
test_P:
                cmpi.b  #$50,-1(A3)     ; P
                bne.b   test_C
                moveq   #1,D1
                bra.b   test_nxt
test_C:
                cmpi.b  #$43,-1(A3)
                bne     nextline
                moveq   #2,D1
test_nxt:
                cmpi.b  #$3A,(A3)+      ; :
                bne     nextline
                cmpi.b  #$20,(A3)+      ; <BLANK>
                bne     nextline
                asl.l   #2,D1
                lea     action_table,A1
                movea.l 0(A1,D1.w),A0
                jmp     (A0)
action_table:
                DC.L action_A,action_P,action_C

action_A:
                lea     oldfile,A0
                lea     rootdir,A1      ; kopiere '\'
                bsr     strcpy
                tst.b   -(A0)           ; zurck auf's '\0'-Byte
                bsr     strcpylf        ; kopiere bis Blank oder CR
                lea     acc,A1
                bsr     strcpy          ; h„nge '.ACC' an
                lea     newfile,A0
                lea     oldfile,A1
                bsr     strcpy          ; nochmal als Ziel kopieren
                tst.b   -(A1)
                move.b  #'X',-(A1)      ; letztes 'C' durch 'X' ersetzen
                bra     setrename       ; und umbenennen

action_P:
                lea     oldfile,A0
                lea     bootdir,A1
                bsr     strcpy          ; kopiere '\AUTO\'
                tst.b   -(A0)           ; zurck aufs '\0'-Byte
                bsr     strcpylf        ; bis Blank oder CR
                lea     prg,A1
                bsr     strcpy          ; h„nge '.PRG' an
                lea     newfile,A0
                lea     oldfile,A1
                bsr     strcpy          ; nochmal alles als Ziel kopieren
                tst.b   -(A1)
                move.b  #'X',-(A1)      ; ersetze 'G' durch 'X'
                bra.b   setrename       ; und umbenennen

action_C:
                lea     srcfile,A0
                bsr     strcpylf        ; kopiere den ersten Namen als Quelle
                tst.b   (A3)            ; schon Fileende
                beq.b   nextline
                lea     destfile,A0
                bsr     strcpylf        ; kopiere den zweiten Namen als Ziel
                bsr     fileread        ; Lese Datei ein
                tst.l   D2              ; hat es geklappt ?
                beq.b   nextline
                bsr     filewrite       ; dann schreibe zurck
                bra.b   nextline        ; und n„chste Zeile finden
setrename:
                pea     newfile
                pea     oldfile
                move.w  #0,-(SP)        ; dummy
                move.w  #$56,-(SP)      ; Frename (oldfile -> newfile)
                trap    #1              ; Gemdos
                lea     $0C(SP),SP      ; korrigiere Stack
nextline:
                tst.b   -1(A3)          ; zuletzt kopiertes Byte berprfen
                beq.b   endsetup
nextln2:
                tst.b   (A3)            ; n„chstes Byte berprfen
                beq.b   endsetup        ; wenn Ende dann Ende
                cmpi.b  #$0A,(A3)+      ; LineFeed gefunden
                bne.b   nextln2         ; dann weitersuchen
                tst.b   (A3)            ; danach vielleicht Schluž
                beq.b   endsetup        ; alles bearbeitet
                bra     test_A          ; sonst weiterinterpretieren

****************************************
* deactall:
* Deaktiviert alle Acc oder AutoPrgs
* a0: Pfad
* a2: Namensliste
* d2: Anzahl
* a3: Extention (.ACC oder .PRG)
****************************************
deactall:
                lea     oldfile,A0
                bsr     strcpy
                tst.b   -(A0)
                move.l  D2,D0
                asl.l   #4,D0
                lea     $01(A2,D0.w),A1
                bsr     strcpy
                tst.b   -(A0)
                movea.l A3,A1
                bsr     strcpy
                lea     oldfile,A1
                lea     newfile,A0
                bsr     strcpy
                tst.b   -(A0)
                move.b  #'X',-(A0)
                pea     newfile
                pea     oldfile
                move.w  #0,-(SP)
                move.w  #$56,-(SP)
                trap    #1              ; Frename
                lea     $0C(SP),SP
                rts

****************************************
* endsetup:
* Schliežt die Sonderbehandlung fr
* Setups ab.
****************************************
endsetup:
                movem.l (SP)+,D0-A6     ; wenn erfolgreich
                bra     auto_acc        ; alles neu vom Laufwerk lesen
; und start bei 'AUTO'
anywrong:
                movem.l (SP)+,D0-A6
                move.l  D5,D0           ; Eintrag
                add.l   offset(PC),D0   ; + offset
                asl.l   #4,D0           ; ....
                move.b  #0,0(A2,D0.l)   ; zurcksetzen
                move.l  D5,D3
                move.l  D5,D4
                bsr     put_menu
                bra     hndl_files      ; und weitermachen

filebuffer:
                DC.L 0
copybuffer:
                DC.L 0

****************************************
* gotoxy:
* Positioniert auf dem Bildschirm
* d0: X-Position
* d1: Y-Position
****************************************
gotoxy:
                add.b   #32,D0
                add.b   #32,D1
                move.b  D0,goto_x
                move.b  D1,goto_y
                lea     goto_xy(PC),A0
                bra     strout
reverse:
                lea     rev_on,A0
                bra     strout
revout:
                lea     rev_off,A0
                bra     strout

****************************************
* putmenu:
* Gibt die Namen der Files in dem Rahmen
* aus. Dabei wird der aktuelle Name
* invertiert ausgegeben und die
* aktivierten Dateien mit '>>' und '<<'
* geglammert.
* a2: Namensliste
* d2: Anzahl
* d3: von Position
* d4: bis Position
* d5: aktuelle Position
****************************************
put_menu:
                cmp.l   D3,D4           ; ist d3 < d4
                bcc.b   no_swap         ; dann ist gut
                eor.l   D3,D4           ; sont vertausche Reihenfolge
                eor.l   D4,D3
                eor.l   D3,D4
no_swap:
                move.l  D3,D7           ; Laufvariable
                subq.l  #1,D7
                move.l  D7,D6           ; Y-Position fr die Ausgabe
                addq.l  #5,D6
                bra     endfor_menu     ; erstmal ans Ende der Schleife
for_menu:
                moveq   #8,D0           ; X = 9
                move.l  D6,D1           ; Y abh„ngig vom Durchlauf
                bsr     gotoxy
                lea     blk12,A1        ; šberschreibe Eintrag durch <BLANK>s
                lea     newentry,A0
                bsr     strcpy
                move.l  D7,D0           ; Z„hler
                add.l   offset(PC),D0   ; + offset
                cmp.l   D0,D2           ; schon ber das Ende der Liste
                bls.b   string_menu     ; dann reicht '            '
                asl.l   #4,D0
                lea     0(A2,D0.w),A1
                tst.b   (A1)            ; Eintrag aktiviert
                beq.b   noquotes        ; nein, dann keine '>>' und '<<'
                move.b  #$AF,entryleft
                move.b  #$AE,entryright
noquotes:
                cmp.l   D7,D5           ; aktueller Eintrag ?
                bne.b   no_rev1
                move.b  #'p',rev_on+1   ; dann Reverse ausgeben
no_rev1:
                addq.l  #1,A1
                lea     entryname,A0
                bsr     strcpy
                move.b  #' ',-(A0)
                move.b  #$1B,rev_off
string_menu:
                lea     newentry,A0
                bsr     strout
endfor_menu:
                addq.l  #1,D6           ; Erh”he Y-Pos. um 1
                addq.l  #1,D7           ; Erh”he Schleifenz„hler um 1
                cmp.l   D7,D4           ; schon bis zum Ende
                bcc     for_menu        ; nein, dann alles noch einmal
                rts

****************************************
* strcat:
* H„nge einen String (a1) an eine
* anderen (a0) an.
****************************************
strcat:
                tst.b   (A0)+
                bne.b   strcat
                subq.l  #1,A0
****************************************
* strcpy:
* Kopiere String von (a1) nach (a0)
****************************************
strcpy:
                move.b  (A1)+,(A0)+
                bne.b   strcpy
                rts

****************************************
* strcpylf:
* Kopiere eine String von (a3) nach
* (a0) bis zu Ende einem BLANK oder
* einem Zeilenumbruch (CR)
****************************************
strcpylf:
                move.b  (A3)+,D0
                beq.b   endcpylf
                cmpi.b  #$20,D0
                beq.b   endcpylf
                cmpi.b  #$0D,D0
                beq.b   endcpylf
                move.b  D0,(A0)+
                bra.b   strcpylf
endcpylf:
                move.b  #0,(A0)
                rts

****************************************
* strcopy:
* Kopiere einen String von (a1) nach
* (a0) bis zum '.' oder bis zum Ende
****************************************
strcopy:
                move.l  A0,-(SP)
                addq.l  #1,A0
str1copy:
                cmpi.b  #'.',(A1)
                beq.b   str2copy
                tst.b   (A1)
                beq.b   str2copy
                move.b  (A1)+,(A0)+
                bra.b   str1copy
str2copy:
                move.b  #0,(A0)
                movea.l (SP)+,A0
                cmpi.b  #'X',$03(A1)
                sne     (A0)
                rts

****************************************
* fileread:
* Liežt ein File in den freien Speicher-
* breich ein
****************************************
fileread:
                move.w  #0,-(SP)        ; ReadOnly
                pea     srcfile         ; zu kopierende Datei
                move.w  #$3D,-(SP)      ; Fopen()
                trap    #1              ; Gemdos
                addq.l  #8,SP           ; Stack korrigieren
                move.w  D0,D1           ; filehandle merken
                bmi.b   err_read        ; Oh, nicht da ?
                move.w  #2,-(SP)        ; Ans Dateiende
                move.w  D1,-(SP)        ; filehandle
                move.l  #0,-(SP)        ; Direkt ans Ende
                move.w  #$42,-(SP)      ; Fseek()
                trap    #1              ; Gemdos
                move.l  D0,D2           ; filel„nge merken
                move.w  #0,8(SP)        ; Diesmal vom Anfang an
                trap    #1              ; Fseek(Begin)
                lea     $0A(SP),SP      ; korrigiere Stack
                tst.l   D2              ; filelen == 0 ?
                beq.b   closeread       ; dann lassen wir es besser sein
                move.l  copybuffer,-(SP) ; Freier Kopierbuffer als Adresse
                move.l  D2,-(SP)        ; Anzahl der Bytes (alles)
                move.w  D1,-(SP)        ; filehandle
                move.w  #$3F,-(SP)      ; Fread()
                trap    #1              ; Gemdos
                lea     $0C(SP),SP      ; Stack korrigieren
closeread:
                move.w  D1,-(SP)        ; filehandle
                move.w  #$3E,-(SP)      ; Fclose()
                trap    #1              ; Gemdos
                addq.l  #4,SP           ; und der Stack
                rts                     ; und schluss
err_read:
                moveq   #0,D2           ; beim Fehler, setze filel„nge auf 0
                rts

****************************************
* filewrite:
* Speichert den vorher gelesenen
* Speicherbereich wieder ab.
* d2: filel„nge
****************************************
filewrite:
                move.w  #0,-(SP)        ; Attribute auf 0
                pea     destfile
                move.w  #$3C,-(SP)      ; Fcreate()
                trap    #1              ; Gemdos
                addq.l  #8,SP           ; korrigiere Stack
                move.w  D0,D1           ; filehandle merken
                bmi.b   err_write       ; Pech gehabt
                move.l  copybuffer,-(SP) ; Kopierbuffer
                move.l  D2,-(SP)        ; Anzahl der Bytes
                move.w  D1,-(SP)        ; filehandle
                move.w  #$40,-(SP)      ; Fwrite()
                trap    #1              ; Gemdos
                lea     $0C(SP),SP      ; Stack korriegieren
                move.w  D1,-(SP)        ; filehandle
                move.w  #$3E,-(SP)      ; Fclose()
                trap    #1              ; Gemdos
                addq.l  #4,SP           ; und der Stack
err_write:
                rts


aa_memory:      DC.L 0
aa_nextfree:
                DC.L 0

goto_xy:        DC.B $1B,'Y'
goto_y:         DC.B 0
goto_x:         DC.B 0,0
shshmsg:        DC.B '     ',$1B,'p====== Boot-X ======',$1B,'q'
ret:            DC.B 13,10,0
shshclr:        DC.B $1B,'E',0
booting:        DC.B ' ',$AE
drive:          DC.B ' :',$AF,0
blk12:          DC.B $1B,'q              ',$1B,'q',0
newentry:
rev_on:         DC.B $1B,'q '
entryleft:      DC.B '  '
entryname:      DC.B '         '
entryright:     DC.B '  '
rev_off:        DC.B $1B,'q',0
begmenu:        DC.B '     ',$F4,$5F,$5F,$5F,$5F,$5F,$5F,$5F
                DC.B $5F,$5F,$5F,$5F,$5F,$5F,$5F,$5F,$5F,$5F
                DC.B $5F,$F4,13,10,0
medmenu:        DC.B '     |                  |',13,10,0
endmenu:        DC.B '     ',$F5,$FF,$FF,$FF,$FF,$FF,$FF,$FF
                DC.B $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
                DC.B $FF,$F5,0
setupdir:       DC.B '\SETUP\',0
bootdir:        DC.B '\AUTO'
rootdir:        DC.B '\',0
setx:           DC.B '*.SET',0
setpost:        DC.B '.SET',0
prgx:           DC.B '*.PR?',0
prg:            DC.B '.PRG',0
prx:            DC.B '.PRX',0
accx:           DC.B '*.AC?',0
acc:            DC.B '.ACC',0
acx:            DC.B '.ACX',0
header1:        DC.B $1B,'p SET ',$1B,'q  AUTO   ACC  ',0
trailer1:       DC.B '     ',$1B,'pSetupDatei ausw„hlen',$1B,'q'
                DC.B 13,10
                DC.B '     ',$1B,'p',$BD,'1991  D. Fiebelkorn'
                DC.B $1B,'q',0
header2:        DC.B ' SET  ',$1B,'p AUTO ',$1B,'q  ACC  ',0
trailer2:       DC.B '     ',$1B,'pAuto-Start Programme',$1B,'q'
                DC.B 13,10
                DC.B '     ',$1B,'pselektieren ',$AF,' .... ',$AE
                DC.B $1B,'q',0
header3:        DC.B ' SET   AUTO  ',$1B,'p ACC ',$1B,'q ',0
toomuchacc:     DC.B '     ',$1B,'pMax. >6< Accessories',$1B,'q',0
trailer3:       DC.B '     ',$1B,'p    Accessories     ',$1B,'q'
                DC.B 13,10
                DC.B '     ',$1B,'pselektieren ',$AF,' .... ',$AE
                DC.B $1B,'q',0

                EVEN

dtabuffer:      DS.B 30
dta_fname:      DS.B 14
set_count:      DC.L 0
sets:           DC.L 0
prg_count:      DC.L 0
prgs:           DC.L 0
acc_count:      DC.L 0
accs:           DC.L 0
acc__prg:       DC.L 0
scancode:       DC.L 0
offset:         DC.L 0
newDevice:      DC.W 0

filename:
oldfile:
srcfile:        DS.B 160
newfile:
destfile:       DS.B 160
                EVEN
                DS.L 64
stack:

                END

