*                     ›33;40m0815Copy Version a›0m

* Bei diesem  Programm handelt es sich wohl um das kürzeste
* Diskettenkopierprogramm  das zur Zeit auf dem  PD-Mark zu
* erhalten ist !  <aufjedenfall han isch noch kin kürtzeres
* entdecken könne, un  wenn doch... ja dann lauf isch Amok>

* 0815Copy benötigt ein  externes Laufwerk <DF1:> ! Kopiert
* wird immer von  DF0: <intern> nach DF1: <extern> <Logen!>
* Durch  drücken  der linken  Maustaste kann zu jeder  Zeit
* der laufende Kopiervorgang abgebrochen werden!  <Hurz...>

* Ach ja... mein Name ist zwar nicht Hase, esse aber  einen
* falschen schon  mal so  zwischendurch.  Kurz und  bündig:
* Programmiert hat das Ganze:  Volker Stepprath am 17/04/93
* mit dem  AZ Editor V1.50!  Assembliert wurde letztendlich
* mit GenAm Macro Assembler V2.11D © 85/88 by HiSoft <Yeah>



            * Variablen definieren *


_SYSBase         equ        4               * Basis von EXEC
_LVOAllocMem     equ     -198               * EXEC Offsets
_LVOFreeMem      equ     -210
_LVOFindTask     equ     -294
_LVOAddPort      equ     -354
_LVORemPort      equ     -360
_LVOCloseLibrary equ     -414
_LVOOpenDevice   equ     -444
_LVOCloseDevice  equ     -450
_LVODoIO         equ     -456
_LVOOpenLibrary  equ     -552

_LVORead         equ      -42               * DOS Offsets
_LVOWrite        equ      -48
_LVOOutput       equ      -60



            * Hauptprogramm *


_0815Copy   bsr     _OPENLIB
            bsr     _OPENDEV1
            cmp.l   #0,d0                   * Ext. Laufwerk vorhanden ?
            bne     _DEVFEHLER              * Ne du... is nisch !
            bsr     _OPENDEV0
            bsr     _WELCOME                * Hi... wie geht`s
            bsr     _CHECKDISKS             * Jetzt geht`s abe
            bsr     _CLOSEDEV0
            bsr     _CLOSEDEV1
            bra     _CLOSELIB



            * Device für DF1: öffnen & Speicher bereitstellen *


_OPENDEV1   move.l  _SYSBase,a6             * System-Basis nach a6
            move.l  #5632,d0                * Speichergröße in Bytes
            move.l  #$10003,d1              * ChipMem <Logen>
            jsr     _LVOAllocMem(a6)        * Speicher reservieren
            move.l  d0,DiskBuff             * Speicheradresse sichern

            sub.l   a1,a1                   * 0 für eigene Taskadresse
            jsr     _LVOFindTask(a6)        * Eigenen Task ermitteln
            move.l  d0,DiskRep+$10          * Antwort-Task festlegen

            lea     DiskRep,a1              * ReplyPort
            jsr     _LVOAddPort(a6)         * anmelden

            lea DiskIO1,a1                  * IORequest für DF1: angeben
            clr.l   d1                      * Flags brauchn wa nisch
            moveq   #1,d0                   * DF1: <Destination>
            lea     Device,a0               * Devicename nach a0
            jsr     _LVOOpenDevice(a6)      * trackdisk.device öffnen
            move.l  #DiskRep,14(a1)         * ReplyPort installieren
            rts                             * Puh... dat hätten wir



            * Device für DF0: öffnen *


_OPENDEV0   lea     DiskIO0,a1              * IORequest für DF0: angeben
            clr.l   d1                      * Wie gehabt
            moveq   #0,d0                   * DF0: <Source>
            lea     Device,a0               * Devicename nach a0
            jsr     _LVOOpenDevice(a6)      * trackdisk.device öffnen
            move.l  #DiskRep,14(a1)         * ReplyPort installieren
            rts                             * Na... dat ging doch



            * Message & Warten *


_WELCOME    move.l  #Message,d2
            moveq   #115,d3                 * Textlänge in Bytes
            bsr     _PRINT

            move.l  Handle,d1
            move.l  #Message,d2             * Wird nicht mehr benötigt
            moveq   #1,d3                   * 1 x Bitte
            jsr     _LVORead(a6)            * Auf Return warten
            rts                             * Hat dat jedauert



            * Diskettentests *


_CHECKDISKS move.l  _SYSBase,a6

            lea     DiskIO0,a1              * IORequest 0 nach a1
            move    #14,28(a1)              * TD_CHANGESTATE
            jsr     _LVODoIO(a6)
            cmp.l   #0,32(a1)               * Ist Disk in DF0: ?
            bne     _NODISK0                * Nein

            move    #2,28(a1)               * CMD_READ
            move.l  #5632,36(a1)            * 11*512 Blöcke
            move.l  DiskBuff,40(a1)         * Speicheradresse angeben

            lea     DiskIO1,a1              * IORequest 1 nach a1
            move    #14,28(a1)              * TD_CHANGESTATE
            jsr     _LVODoIO(a6)
            cmp.l   #0,32(a1)               * Ist Disk in DF1: ?
            bne     _NODISK1                * Nein

            move    #15,28(a1)              * TD_PROSTATUS
            jsr     _LVODoIO(a6)
            cmp.l   #0,32(a1)               * Ist Disk schreibgeschützt ?
            bne     _YESPRO1                * Ja <und warum ?>

            move    #11,28(a1)              * TD_FORMAT
            move.l  #5632,36(a1)            * 1 Track
            move.l  DiskBuff,40(a1)         * Speicheradresse angeben

            bra     _DISKCOPY               * OK! Dann ma los...



            * Wo ist die Sourcedisk ? *


_NODISK0    move.l  #NoDisk0,d2
            moveq   #31,d3
            bsr     _PRINT
            rts



            * Und wo ist die Targetdisk ? *


_NODISK1    move.l  #NoDisk1,d2
            moveq   #31,d3
            bsr     _PRINT
            rts



            * Wie soll man kopieren mit aktiven Schreibschutz ? *


_YESPRO1    move.l  #YesPro1,d2
            moveq   #32,d3
            bsr     _PRINT
            rts



            * 0815Copy starten *


_DISKCOPY   clr.l   d7                      * d7 löschen
            moveq   #49,d4                  * head = `0` - 1

_LOOPstart  bsr     _HEAD                   * Cylinder & head zeigen
            move.l  _SYSBase,a6             * Hatten wir schon

_READ       lea     DiskIO0,a1              * Track einlesen 0
            jsr     _LVODoIO(a6)            * !
            bne     _READERR                * Rülps... Fehler auf Source

_WRITE      lea     DiskIO1,a1              * Track schreiben 1
            jsr     _LVODoIO(a6)            * !

            btst    #6,$BFE001              * Kopieren abbrechen ?
            beq     _LOOPende               * Ja

            addq    #1,d7                   * Cylinderanzahl erhöhen
            cmp.l   #160,d7                 * max. Cylinder-1 erreicht ?
            beq     _LOOPende               * Ja

            lea     DiskIO0,a1              * IORequest DF0:
            add.l   #5632,44(a1)            * Cylinder um 1 erhöhen

            lea     DiskIO1,a1              * IORequest DF1:
            add.l   #5632,44(a1)            * Cylinder um 1 erhöhen

            bra     _LOOPstart              * Und weiter geht`s

_LOOPende   rts                             * Kopieren beendet



            * Aktuellen Cylinder & head ermitteln *


_HEAD       lea     Work,a0                 * Adr. von Worktext nach a0
            addq.b  #1,d4                   * head erhöhen
            cmp.b   #50,d4                  * ist head > 1
            beq     _P01                    * Jawohl
            move.b  #49,d4                  * head = 1
            bra     _SHOW                   * Dann zeig`s mal
_P01        move.b  #48,d4                  * head = 0
            addq.b  #1,19(a0)               * Einer erhöhen
            cmp.b   #58,19(a0)              * Ist Einer > 9
            blt     _SHOW                   * Ne, is nisch
_P10        addq.b  #1,18(a0)               * Zehner erhöhen
            move.b  #48,19(a0)              * Einer equ `0`
_SHOW       move.b  d4,27(a0)               * `head` angeben
            move.l  a0,d2                   * Worktext nach d2
            moveq   #31,d3                  * Textlänge in Bytes
            bsr     _PRINT                  * Cylinderpos. ausgeben
            rts                             * Und das 160 mal...



            * Lesefehler aufgetreten *


_READERR    lea     ReadErr,a0
            lea     Work,a1
            move.b  18(a1),35(a0)           * Cylinderposition
            move.b  19(a1),36(a0)           * übergeben
            divu    #10,d0                  * Zehner ermitteln
            add.b   #48,d0                  * und in ASCII wandeln
            move.b  d0,9(a0)                * Wert übergeben <Würg...>
            swap    d0                      * Einer ermitteln
            add.b   #48,d0                  * ebenfalls in ASCII wandeln
            move.b  d0,10(a0)               * & eintragen
            move.b  d4,44(a0)               * `head` übergeben
            move.l  a0,d2                   * ReadErrtext nach d2
            move.l  #48,d3                  * Textlänge in Bytes
            bsr     _PRINT

            move.l  _SYSBase,a6             * Ui, Hui, sehr wichtig !
            bra     _WRITE



            * Device konnte nicht geöffnet werden *


_DEVFEHLER  move.l  #DevErr,d2              * DevErrtext
            moveq   #31,d3                  * Textlänge in Bytes
            bsr     _PRINT
            bra     _ABORT                  * Da is wat schief jelaufen



            * Vorbereitungen für 0815Copy Va *


_OPENLIB    move.l  _SYSBase,a6             * System-Basis nach a6
            lea     DosName,a1              * dos.library nach a1
            clr.l   d0                      * Version... wat is dat ?
            jsr     _LVOOpenLibrary(a6)     * Library öffnen
            move.l  d0,_DOSBase             * & Basis sichern

            move.l  _DOSBase,a6             * DosBasis nach a6
            jsr     _LVOOutput(a6)          * Ausgabekanal ermitteln <*>
            move.l  d0,Handle               * & sichern
            rts                             * Wie... dat war et schon



            * Motor aus 0 & Device 0 schließen *


_CLOSEDEV0  move.l  _SYSBase,a6             * System-Basis nach a6
            lea     DiskIO0,a1              * IORequest 0 angeben
            move    #9,28(a1)               * TD_MOTOR
            move.l  #0,36(a1)               * von DF0:
            jsr     _LVODoIO(a6)            * aus !

            jsr     _LVOCloseDevice(a6)     * Device <DF0:> schließen
            rts



            * Motor aus 1 & Device 1 schließen *


_CLOSEDEV1  lea     DiskIO1,a1              * IORequest 1 angeben
            move    #9,28(a1)               * TD_MOTOR
            move.l  #0,36(a1)               * von DF1:
            jsr     _LVODoIO(a6)            * aus !

            jsr     _LVOCloseDevice(a6)     * Device <DF1:> schließen
            rts



            * Allgemeine Textausgebe *


_PRINT      move.l  _DOSBase,a6
            move.l  Handle,d1
            jsr     _LVOWrite(a6)
            rts



            * Speicher freigeben, dos.library schließen & Zurück *


_CLOSELIB   move.l  #Bye,d2                 * Tschüsstext
            moveq   #24,d3                  * Textlänge in Bytes
            bsr     _PRINT

_ABORT      move.l  _SYSBase,a6
            move.l  #5632,d0
            move.l  DiskBuff,a1
            jsr     _LVOFreeMem(a6)         * Speicher freigeben

            lea     DiskRep,a1              * Und Port auch
            jsr     _LVORemPort(a6)         * wieder schön abmelden

            move.l  _DOSBase,a1             * DosBasis angeben
            jsr     _LVOCloseLibrary(a6)    * & dos.library schließen

            RTS                             * Und... Tschüss !



            * Speicherreservierung *


_DOSBase    dc.l 0
Handle      dc.l 0
DiskBuff    dc.l 0
DiskRep     ds.l 8
DiskIO0     ds.l 20
DiskIO1     ds.l 20
DosName     dc.b 'dos.library',0
Device      dc.b 'trackdisk.device',0

Message     dc.b 10,$9b,'33;40m0815Copy Va (w)1993 by Volker Stepprath',10
            dc.b $9b,'0mSourcedisk in DF0: & Targetdisk in DF1:',10
            dc.b 'Press RETURN when ready:'

Work        dc.b 'Copying cylinder: 0/, head 0',10,$9b,$b

Bye         dc.b 10,10,'Operation finished !',10,10

NoDisk0     dc.b 10,$9b,'3mNo disk in sourcedrive !',$9b,'0m'

NoDisk1     dc.b 10,$9b,'3mNo disk in targetdrive !',$9b,'0m'

YesPro1     dc.b 10,$9b,'3mDisk is write protected !',$9b,'0m'

ReadErr     dc.b 'TDError #00 while reading cylinder 00, head 0 !',10

DevErr      dc.b 'External drive not available !',10
