Exodus:
OldOpenLibrary       =-408
CloseLibrary         =-414
AllocMem             =-198
FreeMem              =-210
Read                 = -42
Write                = -48
Open                 = -30
Close                = -36
FindTask             =-294
OpenDevice           =-444
CloseDevice          =-450
DoIO                 =-456

        tst.l d0                ;parameterlänge
        beq.s run
        cmp.l #5,d0
        bne.s run
        cmp.b #"d",(a0)         ;test auf "dfx:"
        bne.s run
        cmp.b #"f",1(a0)
        bne.s run
        cmp.b #":",3(a0)
        bne.s run
        move.b 2(a0),d0
        sub.b #"0",d0
        move.b d0,device        ;laufwerk setzen
run:    move.l 4,a6             ;dos.library öffnen
        lea dosname,a1
        jsr OldOpenLibrary(a6)
        move.l d0,dosbase
        beq.l error

        move.l #$10002,d1       ;512 byte puffer in chipmem
        move.l #512,d0          ;reservieren
        jsr AllocMem(a6)
        move.l d0,buffer
        beq.l error

        sub.l a1,a1             ;task für trackdisk.device
        jsr FindTask(a6)
        lea diskport,a0
        move.l d0,16(a0)
        clr.l d0
        move.b device,d0        ;trackdisk.device für dfx: öffnen
        moveq #0,d1
        lea diskioreq,a1
        lea trkdisk,a0
        jsr OpenDevice(a6)
        tst.l d0
        bne.l nodrive           ;library scliessen,speicher freigeben

        move.b device,d0        ;laufwerk in titelzeile setzen
        add.b #"0",d0
        move.b d0,drive
        move.l dosbase,a6       ;raw-fenster öffnen
        move.l #title,d1
        move.l #1005,d2
        jsr Open(a6)
        move.l d0,wdhd          ;windowhandle
        beq.l error

        jsr crsroff             ;cursor aus
        move.l wdhd,d1          ;menü drucken
        move.l #top,d2
        move.l #toplen,d3
        jsr Write(a6)

        jsr dumpblock           ;block # und $ ausgeben,fehler lö.
        move.b #"r",key         ;read befehl simulieren
        bra.s start

main:   jsr dumptype            ;typ ausgabe
        jsr dumpcheck           ;prüfsumme ausgeben
        jsr getkey              ;taste nach key holen
start:  cmp.b #$1b,key          ;programmende
        beq.s quit
        cmp.b #"r",key          ;block lesen und zeigen
        beq.l readsec
        cmp.b #"w",key          ;block schreiben und zeigen
        beq.l writesec
        cmp.b #"c",key          ;data checksum bilden
        beq.l check
        cmp.b #"#",key          ;dezimal blockeingabe und lesen
        beq.l blockedit
        cmp.b #"$",key          ;hexadezimal blockeingabe und lesen
        beq.l blockedithex
        cmp.b #"+",key          ;block +1 lesen
        beq.l up
        cmp.b #"-",key          ;block -1 lesen
        beq.l down
        cmp.b #"a",key          ;ascii eingabe
        beq.l asciiedit
        cmp.b #"h",key          ;hex eingabe
        beq.l hexedit
        bne.l main

quit:   move.l dosbase,a6       ;fenster schliessen
        move.l wdhd,d1
        jsr Close(a6)

        move.l 4,a6             ;trackdisk.device schliessen
        lea diskioreq,a1
        jsr CloseDevice(a6)

nodrive:move.l buffer,a1        ;puffer freigeben
        move.l #512,d0
        jsr FreeMem(a6)

        move.l dosbase,a1       ;dos.library schliessen
        jsr CloseLibrary(a6)
        clr.l d0
        rts

error:  moveq #100,d0           ;returncode 100 bei systemfehler
        rts

dumphex:move.b #"0",row         ;cursor pos.
        move.b #"6",row+1
        move.b #"0",col
        move.b #"2",col+1
        move.l buffer,buffptr   ;pufferzeiger auf anfang
        clr.w adr
        moveq #15,d6            ;16 zeilen
poshex: jsr cursor              ;adresse ausgeben
        move.w adr,d0
        jsr convword
        jsr printword
        move.b #" ",key         ;space drucken
        jsr printkey
        add.w #$20,adr          ;adresse um $20 erhöhen
        moveq #15,d5            ;16 wörter pro zeile
        lea linebuf,a2          ;puffer für zeile
x:      move.l buffptr,a1
        add.l #2,buffptr        ;pufferzeiger+2
        move.w (a1),d0          ;wort holen
        jsr convword            ;in ascii wandeln
        move.l text,(a2)+       ;in zeilenpuffer kopieren
        dbra d5,x
        jsr printline
        move.b row+1,d0         ;cursor pos. zeile +1
        cmp.b #"9",d0
        bne.s l1
        add.b #1,row
        move.b #"0"-1,row+1
l1:     add.b #1,row+1
        dbra d6,poshex
        rts

convdez:lea text,a0             ;word in d0 in 4stellige
        divu #1000,d0           ;dezimalzahl wandeln
        add.b #"0",d0
        move.b d0,(a0)+
        clr.w d0
        swap d0
        divu #100,d0
        add.b #"0",d0
        move.b d0,(a0)+
        clr.w d0
        swap d0
        divu #10,d0
        add.b #"0",d0
        move.b d0,(a0)+
        clr.w d0
        swap d0
        add.b #"0",d0
        move.b d0,(a0)+
        rts

convword:                       ;word d0 in ascii text wandeln
        moveq #3,d2
        lea text+4,a0
l0:     move.b d0,d1
        and.b #$0f,d1
        lsr.w #4,d0
        cmp.b #$09,d1
        bgt.s hex
        add.b #"0",d1
        bra.s do
hex:    add.b #"a"-10,d1
do:     move.b d1,-(a0)
        dbra d2,l0
        rts

printword:                      ;text ausgeben
        move.l wdhd,d1
        move.l #text,d2
        moveq #4,d3
        jsr Write(a6)
        rts

dumpasc:move.b #"2",row         ;block ascii ausgeben
        move.b #"3",row+1
        move.b #"0",col
        move.b #"2",col+1
        move.l buffer,buffptr
        clr.w adr
        moveq #7,d6
posasc: jsr cursor              ;adresse ausgeben
        move.w adr,d0
        jsr convword
        jsr printword
        move.b #" ",key         ;space drucken
        jsr printkey
        add.w #$40,adr
        moveq #63,d5
        lea linebuf,a2          ;zeilenpuffer
        move.l buffptr,a1
y:      move.b (a1)+,d0         ;byte holen und ascii maskieren
        cmp.b #" ",d0
        blt.s dot
        cmp.b #"z",d0
        bgt.s dot
        move.b d0,(a2)+
        bra.s chr
dot:    move.b #".",(a2)+       ;steuerzeichen durch "." ersetzen
chr:    dbra d5,y
        move.l a1,buffptr
        jsr printline           ;zeilenpuffer ausgeben
        move.b row+1,d0         ;cursor pos. zeile +1
        cmp.b #"9",d0
        bne.s l2
        add.b #1,row
        move.b #"0"-1,row+1
l2:     add.b #1,row+1
        dbra d6,posasc
        rts

printline:                      ;zeilenpuffer ausgeben
        move.l wdhd,d1
        move.l #linebuf,d2
        moveq #64,d3
        jsr Write(a6)
        rts

dumpcheck:                      ;prüfsumme ausgeben
        move.b #"0",row
        move.b #"4",row+1
        move.b #"5",col
        move.b #"1",col+1
        jsr cursor
        move.l buffer,a0        ;oberes wort
        move.w 20(a0),d0
        jsr convword
        jsr printword
        move.l buffer,a0        ;unteres wort
        move.w 22(a0),d0
        jsr convword
        jsr printword
        rts

dumpblock:                      ;blocknummer dez. und hex. ausgeben
        move.b #"0",row
        move.b #"4",row+1
        move.b #"0",col
        move.b #"9",col+1
        jsr cursor
        move.w block,d0         ;offset für read/write setzen
        mulu #512,d0
        move.l d0,offset
        clr.l d0
        move.w block,d0
        jsr convdez             ;block dezimal umwandeln
        jsr printword
        move.b #"0",row         ;block hex. umwandeln
        move.b #"4",row+1
        move.b #"1",col
        move.b #"5",col+1
        jsr cursor
        move.w block,d0
        jsr convword
        jsr printword

        move.l #clear,d4        ;fehlermeldung löschen
        moveq #clrlen,d5
        jsr doerr
        rts

dumptype:
        move.b #"0",row         ;block typ ausgeben
        move.b #"2",row+1
        move.b #"0",col
        move.b #"2",col+1
        jsr cursor
        move.l wdhd,d1
        move.l #unkn,d2         ;typ unbekannt
        moveq #10,d3            ;typ-länge
        cmp.w #2,block          ;boot       block=0,1
        bge.s noboot
        move.l #boot,d2
        bra.s noknown
noboot: move.l buffer,a0
        cmp.l #8,(a0)           ;data       1.LW=$00000008
        bne.s nodata
        move.l #dat,d2
nodata: cmp.l #$10,(a0)         ;filelist   1.LW=$00000010
        bne.s nolist
        cmp.l #-3,508(a0)       ;filelist 127.LW=$fffffffd
        bne.s nolist
        move.l #flist,d2
nolist: cmp.l #2,(a0)           ;root,userdir,filehead
                                ;           1.LW=$00000002
        bne.s noknown
        cmp.l #1,508(a0)        ;root     127.LW=$00000001
        bne.s noroot
        move.l #root,d2
noroot: cmp.l #2,508(a0)        ;userdir  127.LW=$00000002
        bne.s noudir
        move.l #udir,d2
noudir: cmp.l #-3,508(a0)       ;filehead 127.LW=$fffffffd
        bne.s noknown
        move.l #fhead,d2
noknown:jsr Write(a6)
        rts

getkey: move.l wdhd,d1          ;auf taste warten,
        move.l #key,d2          ;taste nach key holen
        moveq #1,d3
        jsr Read(a6)
        rts

printkey:                       ;zeichen key drucken
        move.l wdhd,d1
        move.l #key,d2
        moveq #1,d3
        jsr Write(a6)
        rts

cursor: jsr cursoff             ;cursor aus ohne statusänderung
        move.l wdhd,d1          ;cursor auf #adresse positionieren
        move.l #adrpos,d2
        moveq #7,d3
        jsr Write(a6)
        lea text,a0
        move.l #"    ",(a0)
        btst #0,crsrstatus      ;wenn cursor aus,adresse löschen
        beq.s noadr
        move.l buffptr,d0       ;sonst adresse ausgeben
        sub.l buffer,d0         ;adresse=zeiger-start
        jsr convdez
noadr:  jsr printword
        move.l wdhd,d1          ;cursor auf $adresse positionieren
        move.l #adrpos2,d2
        moveq #7,d3
        jsr Write(a6)
        lea text,a0
        move.l #"    ",(a0)
        btst #0,crsrstatus      ;wenn cursor aus,adresse löschen
        beq.s noadr2
        move.l buffptr,d0       ;sonst adresse ausgeben
        sub.l buffer,d0
        jsr convword
noadr2: jsr printword
        move.l wdhd,d1          ;cursor positionieren
        move.l #pos,d2
        moveq #7,d3
        jsr Write(a6)
        btst #0,crsrstatus
        beq.s no
        jsr curson              ;cursor ein ohne statusänderung
no:     rts

crsron: bset #0,crsrstatus      ;cursor einschalten
curson: move.l wdhd,d1
        move.l #con,d2
        moveq #3,d3
        jsr Write(a6)
        rts

crsroff:bclr #0,crsrstatus      ;cursor ausschalten
cursoff:move.l wdhd,d1
        move.l #coff,d2
        moveq #4,d3
        jsr Write(a6)
        rts

doerr:  move.l dosbase,a6       ;fehlermeldung d4/d5 ausgeben
        move.b #"0",row
        move.b #"4",row+1
        move.b #"6",col
        move.b #"0",col+1
        jsr cursor
        move.l wdhd,d1
        move.l d4,d2
        move.l d5,d3
        jsr Write(a6)
        lea diskioreq,a0        ;fehlerstatus löschen
        clr.l 32(a0)
        rts

mtroff: move.l 4,a6             ;motor ausschalten
        lea diskioreq,a1
        move.w #9,28(a1)        ;motor aus
        clr.l 36(a1)
        jsr DoIO(a6)
        move.l dosbase,a6
        rts

readsec:move.l 4,a6             ;block nach puffer lesen
        lea diskioreq,a1
        move.w #14,28(a1)       ;test ob disk eingelegt
        jsr DoIO(a6)
        lea diskioreq,a1
        tst.l 32(a1)
        beq.s dsk

        move.l #nderr,d4        ;fehler ausgeben
        moveq #ndlen,d5
        jsr doerr
        bra.l here              ;read beendet

dsk:    lea diskioreq,a1        ;block lesen
        move.w #2,28(a1)
        move.l #512,36(a1)
        move.l buffer,40(a1)
        move.l offset,44(a1)
        jsr DoIO(a6)
        tst.l d0                ;test auf readerror
        beq.s noerr

        move.l #rderr,d4        ;fehler ausgeben
        moveq #rdlen,d5
        jsr doerr
        bra.s here

noerr:  jsr dumpblock           ;blocknummer ausgeben, fehler löschen
here:   jsr mtroff
        jsr dumpcheck           ;prüfsumme
        jsr dumptype            ;typ
        jsr dumphex             ;hex. ausgabe
        jsr dumpasc             ;ascii ausgabe
        bra.l main

writesec:                       ;block auf disk schreiben
        move.l 4,a6
        lea diskioreq,a1
        move.w #14,28(a1)       ;test ob disk eingelegt 
        jsr DoIO(a6)
        lea diskioreq,a1
        tst.l 32(a1)
        beq.s dsk2

        move.l #nderr,d4        ;fehler ausgeben
        moveq #ndlen,d5
        jsr doerr
        bra.l here2

dsk2:   lea diskioreq,a1
        move.w #15,28(a1)       ;test auf schreibschutz
        jsr DoIO(a6)
        lea diskioreq,a1
        tst.l 32(a1)
        beq.s dsk3

        move.l #pterr,d4        ;fehler ausgeben
        moveq #ptlen,d5
        jsr doerr
        bra.l here2

dsk3:   move.w #3,28(a1)        ;block schreiben
        move.l #512,36(a1)
        move.l buffer,40(a1)
        move.l offset,44(a1)
        jsr DoIO(a6)
        lea diskioreq,a1
        move.w #4,28(a1)        ;update disk
        move.l #512,36(a1)
        move.l buffer,40(a1)
        move.l offset,44(a1)
        jsr DoIO(a6)
        tst.l d0                ;test auf writeerror
        beq.s noerr2

        move.l #wrerr,d4        ;fehler ausgeben
        moveq #wrlen,d5
        jsr doerr
        bra.s here2

noerr2: jsr dumpblock           ;alles ausgeben
here2:  jsr mtroff
        jsr dumpcheck
        jsr dumphex
        jsr dumpasc
        bra.l main

check:  move.l buffer,a0        ;pufferprüfsumme berechnen
        moveq #126,d0
        clr.l d1
adck:   cmp.w #121,d0           ;prüfsumme überspringen
        bne.s ck
        add.l #4,a0
ck:     sub.l (a0)+,d1
        dbra d0,adck
        move.l buffer,a0        ;prüfsumme eintragen
        move.l d1,20(a0)
        jsr dumpcheck           ;ausgaben
        jsr dumphex
        jsr dumpasc
        bra.l main

blockedit:                      ;blocknummer dez. eingeben
        move.b #"0",row
        move.b #"4",row+1
        move.b #"0",col
        move.b #"9",col+1
        jsr cursor
        jsr crsron
        moveq #3,d4             ;4 zeichen
        lea text,a5
in:     jsr getkey
        cmp.b #"0",key
        blt.s in
        cmp.b #"9",key
        bgt.s in
        jsr printkey
        move.b key,(a5)+        ;in textpuffer
        dbra d4,in
        jsr crsroff
        clr.w block             ;textpuffer nach hex umrechnen
        lea text,a0
        clr.w d0
        move.b (a0)+,d0
        sub.w #"0",d0
        mulu #1000,d0
        add.w d0,block
        clr.w d0
        move.b (a0)+,d0
        sub.w #"0",d0
        mulu #100,d0
        add.w d0,block
        clr.w d0
        move.b (a0)+,d0
        sub.w #"0",d0
        mulu #10,d0
        add.w d0,block
        clr.w d0
        move.b (a0)+,d0
        sub.w #"0",d0
        add.w d0,block
        cmp.w #1759,block       ;vergleich auf letzten block
        bgt.l blockedit         ;neueingabe
        jsr dumpblock
        bra.l readsec           ;block lesen und zeigen

blockedithex:                   ;block hex eingeben
        move.b #"0",row
        move.b #"4",row+1
        move.b #"1",col
        move.b #"5",col+1
        jsr cursor
        jsr crsron
        lea text,a5
        moveq #3,d4             ;4 zeichen
retry:  jsr getkey
        cmp.b #"0",key
        blt.l retry
        cmp.b #"f",key
        bgt.l retry
        cmp.b #"9",key
        ble.s h0
        cmp.b #"a",key
        bge.s h0
        bra.s retry
h0:     jsr printkey
        move.b key,(a5)+        ;in textpuffer schreiben
        dbra d4,retry
        jsr crsroff
        move.b text,d0          ;nibbleweise text nach hex wandeln
        cmp.b #"9",d0
        bgt.s h1
        sub.b #"0"-"a"+10,d0
h1:     sub.b #"a"-10,d0
        lsl.b #4,d0
        move.b d0,block
        move.b text+1,d0
        cmp.b #"9",d0
        bgt.s h2
        sub.b #"0"-"a"+10,d0
h2:     sub.b #"a"-10,d0
        or.b d0,block
        move.b text+2,d0
        cmp.b #"9",d0
        bgt.s h3
        sub.b #"0"-"a"+10,d0
h3:     sub.b #"a"-10,d0
        lsl.b #4,d0
        move.b d0,block+1
        move.b text+3,d0
        cmp.b #"9",d0
        bgt.s h4
        sub.b #"0"-"a"+10,d0
h4:     sub.b #"a"-10,d0
        or.b d0,block+1
        cmp.w #1759,block       ;auf letzten block vergleichen
        bgt.l blockedithex
        jsr dumpblock           ;block ausgeben
        bra.l readsec           ;block lesen und zeigen

up:     cmp.w #1759,block       ;nächsten block lesen und zeigen
        beq.l main
        add.w #1,block
        jsr dumpblock
        jmp readsec

down:   tst.w block             ;vorhergehenden block l. und z.
        beq.l main
        sub.w #1,block
        jsr dumpblock
        jmp readsec

asciiedit:                      ;ascii eingabe im puffer
        move.b #"2",row
        move.b #"3",row+1
        move.b #"0",col
        move.b #"7",col+1
        move.l buffer,buffptr
        jsr crsron
        jsr cursor
getasc: jsr getkey

        cmp.b #$9b,key          ;auf cursor sequenz vergleichen
        bne.l nocurs
        jsr getkey
        cmp.b #$44,key          ;links
        beq.l ascleft
        cmp.b #$43,key          ;rechts
        beq.l ascright
        cmp.b #$41,key          ;oben
        beq.l ascup
        cmp.b #$42,key          ;unten
        beq.l ascdown
        bra.s getasc

ascright:                       ;cursor rechts oder zeilenanfang
        cmp.b #"7",col
        blt.s csright
        cmp.b #"0",col+1
        blt.s csright
        cmp.b #"3",row
        blt.l csdown
        cmp.b #"0",row+1
        blt.l csdown
        bra.l getasc            ;cursor ist links unten

csright:cmp.b #"9",col+1        ;cursor setzen
        bne.s m3
        move.b #"0"-1,col+1
        add.b #1,col
m3:     add.b #1,col+1
        add.l #1,buffptr        ;pufferzeiger setzen
        jsr cursor
        bra.l getasc

csdown: cmp.b #"9",row+1        ;s.o.
        bne.s m2
        move.b #"0"-1,row+1
        add.b #1,row
m2:     add.b #1,row+1
        move.b #"0",col
        move.b #"7",col+1
        add.l #1,buffptr
        jsr cursor
        bra.l getasc

ascdown:cmp.b #"3",row          ;cursor unten wenn möglich
        blt.l rowdown
        cmp.b #"0",row+1
        blt.l rowdown
        bra.l getasc

rowdown:cmp.b #"9",row+1
        bne.s m4
        move.b #"0"-1,row+1
        add.b #1,row
m4:     add.b #1,row+1
        add.l #$40,buffptr      ;pufferzeiger nächste zeile
        jsr cursor
        bra.l getasc

ascleft:cmp.b #"0",col          ;cursor links oder zeilenende
        bgt.s csleft
        cmp.b #"7",col+1
        bgt.s csleft
        cmp.b #"2",row
        bgt.l csup
        cmp.b #"3",row+1
        bgt.l csup
        bra.l getasc            ;cursor ist oben links

csleft: cmp.b #"0",col+1        ;cursor setzen
        bne.s m5
        move.b #"9"+1,col+1
        sub.b #1,col
m5:     sub.b #1,col+1
        sub.l #1,buffptr        ;pufferzeiger links
        jsr cursor
        bra.l getasc

csup:   cmp.b #"0",row+1        ;cursor zeilenende
        bne.s m6
        move.b #"9"+1,row+1
        sub.b #1,row
m6:     sub.b #1,row+1
        move.b #"7",col
        move.b #"0",col+1
        sub.l #1,buffptr
        jsr cursor
        bra.l getasc

ascup:  cmp.b #"2",row          ;cursor zeile oben wenn möglich
        bgt.l rowup
        cmp.b #"3",row+1
        bgt.l rowup
        bra.l getasc

rowup:  cmp.b #"0",row+1
        bne.s m8
        move.b #"9"+1,row+1
        sub.b #1,row
m8:     sub.b #1,row+1
        sub.l #$40,buffptr      ;pufferzeiger zeile oben
        jsr cursor
        bra.l getasc

nocurs: cmp.b #$1b,key          ;escape taste= eingabeende
        beq.l ascend    
        cmp.b #" ",key          ;tasten maskieren
        blt.l getasc
        cmp.b #"z",key
        bgt.l getasc

        cmp.b #"7",col          ;zeichen links oder zeilenanfang
        blt.s doright           ;drucken
        cmp.b #"0",col+1
        blt.s doright
        cmp.b #"3",row
        blt.l dodown
        cmp.b #"0",row+1
        blt.l dodown
        jsr printkey
        move.l buffptr,a0       ;in puffer eintragen
        move.b key,(a0)
        bra.l asciiedit         ;cursor home

doright:cmp.b #"9",col+1        ;zeichen links drucken
        bne.s m0
        move.b #"0"-1,col+1
        add.b #1,col
m0:     add.b #1,col+1
        jsr printkey
        move.l buffptr,a0
        move.b key,(a0)         ;in puffer eintragen
        add.l #1,buffptr
        jsr cursor
        bra.l getasc

dodown: cmp.b #"9",row+1        ;zeichen zeilenanfang drucken
        bne.s m1
        move.b #"0"-1,row+1
        add.b #1,row
m1:     add.b #1,row+1
        move.b #"0",col
        move.b #"7",col+1
        jsr printkey
        move.l buffptr,a0
        move.b key,(a0)         ;in puffer eintragen
        add.l #1,buffptr
        jsr cursor
        bra.l getasc

ascend: jsr crsroff             ;ende der asciieingabe
        jsr dumphex             ;hex ausgeben
        bra.l main

hexedit:move.b #"0",row         ;hexeingabe in puffer
        move.b #"6",row+1       ;analog asciieingabe
        move.b #"0",col         ;ausnahmen:cursor in 2erschritten
        move.b #"7",col+1       ;          umwandung in bytes
        move.l buffer,buffptr
        jsr crsron
        jsr cursor
gethex: jsr getkey
        cmp.b #$9b,key
        bne.l noxcurs
        jsr getkey
        cmp.b #$44,key
        beq.l hexleft
        cmp.b #$43,key
        beq.l hexright
        cmp.b #$41,key
        beq.l hexup
        cmp.b #$42,key
        beq.l hexdown
        bra.l gethex

hexright:
        cmp.b #"6",col
        blt.s xcsright
        cmp.b #"9",col+1
        blt.s xcsright
        cmp.b #"2",row
        blt.l xcsdown
        cmp.b #"1",row+1
        blt.l xcsdown
        bra.l gethex

xcsright:
        cmp.b #"9",col+1
        bne.s n3
        move.b #"1"-2,col+1
        add.b #1,col
n3:     add.b #2,col+1
        add.l #1,buffptr
        jsr cursor
        bra.l gethex

xcsdown:cmp.b #"9",row+1
        bne.s n2
        move.b #"0"-1,row+1
        add.b #1,row
n2:     add.b #1,row+1
        move.b #"0",col
        move.b #"7",col+1
        add.l #1,buffptr
        jsr cursor
        bra.l gethex

hexdown:cmp.b #"2",row
        blt.l rowxdown
        cmp.b #"1",row+1
        blt.l rowxdown
        bra.l gethex

rowxdown:
        cmp.b #"9",row+1
        bne.s n4
        move.b #"0"-1,row+1
        add.b #1,row
n4:     add.b #1,row+1
        add.l #$20,buffptr
        jsr cursor
        bra.l gethex

hexleft:cmp.b #"0",col
        bgt.s xcsleft
        cmp.b #"7",col+1
        bgt.s xcsleft
        cmp.b #"0",row
        bgt.l xcsup
        cmp.b #"6",row+1
        bgt.l xcsup
        bra.l gethex

xcsleft:cmp.b #"1",col+1
        bne.s n5
        move.b #"9"+2,col+1
        sub.b #1,col
n5:     sub.b #2,col+1
        sub.l #1,buffptr
        jsr cursor
        bra.l gethex

xcsup:  cmp.b #"0",row+1
        bne.s n6
        move.b #"9"+1,row+1
        sub.b #1,row
n6:     sub.b #1,row+1
        move.b #"6",col
        move.b #"9",col+1
        sub.l #1,buffptr
        jsr cursor
        bra.l gethex

hexup:  cmp.b #"0",row
        bgt.l xrowup
        cmp.b #"6",row+1
        bgt.l xrowup
        bra.l gethex

xrowup: cmp.b #"0",row+1
        bne.s n8
        move.b #"9"+1,row+1
        sub.b #1,row
n8:     sub.b #1,row+1
        sub.l #$20,buffptr
        jsr cursor
        bra.l gethex


noxcurs:cmp.b #$1b,key
        beq.l hexend    
        cmp.b #"0",key
        blt.l gethex
        cmp.b #"f",key
        bgt.l gethex
        cmp.b #"9",key
        ble.s ok0
        cmp.b #"a",key
        bge.s ok0
        bra.l gethex
ok0:    jsr printkey
ok2:    move.l wdhd,d1
        move.l #key2,d2
        moveq #1,d3
        jsr Read(a6)
        cmp.b #"0",key2
        blt.s ok2
        cmp.b #"f",key2
        bgt.s ok2
        cmp.b #"9",key2
        ble.s ok1
        cmp.b #"a",key2
        blt.s ok2
        
ok1:    move.b key,d0           ;key und key2 in byte wandeln
        cmp.b #"9",d0
        bgt.s ok3
        sub.b #"0"-"a"+10,d0
ok3:    sub.b #"a"-10,d0
        lsl.b #4,d0
        move.b d0,byte
        move.b key2,d0
        cmp.b #"9",d0
        bgt.s ok4
        sub.b #"0"-"a"+10,d0
ok4:    sub.b #"a"-10,d0
        or.b d0,byte

        cmp.b #"6",col
        blt.s doxright
        cmp.b #"9",col+1
        blt.s doxright
        cmp.b #"2",row
        blt.l doxdown
        cmp.b #"1",row+1
        blt.l doxdown
        move.l wdhd,d1
        move.l #key2,d2
        moveq #1,d3
        jsr Write(a6)
        move.l buffptr,a0
        move.b byte,(a0)
        bra.l hexedit

doxright:
        cmp.b #"9",col+1
        bne.s n0
        move.b #"1"-2,col+1
        add.b #1,col
n0:     add.b #2,col+1
        move.l wdhd,d1
        move.l #key2,d2
        moveq #1,d3
        jsr Write(a6)
        move.l buffptr,a0
        move.b byte,(a0)
        add.l #1,buffptr
        jsr cursor
        bra.l gethex

doxdown:cmp.b #"9",row+1
        bne.s n1
        move.b #"0"-1,row+1
        add.b #1,row
n1:     add.b #1,row+1
        move.b #"0",col
        move.b #"7",col+1
        move.l wdhd,d1
        move.l #key2,d2
        moveq #1,d3
        jsr Write(a6)
        move.l buffptr,a0
        move.b byte,(a0)
        add.l #1,buffptr
        jsr cursor
        bra.l gethex

hexend: jsr crsroff             ;ende hexeingabe
        jsr dumpasc             ;ascii ausgeben
        bra.l main

;       TEXTE, VARIABLE UND TABELLEN

title:  dc.b "raw:0/0/640/256/"
        dc.b "      DISK-MONITOR VERSION 1.0    "
        dc.b "      INSERT DISK TO EXAMINE IN DF"
drive:  dc.b 0,":   ",0
top:    dc.b $0a

        ;    invers               1.char        normal  rest

        dc.b "            "
        dc.b " ",$9b,"0;31;43",$6d,"Esc",$9b,"0;31;40",$6d,"ape"
        dc.b " ",$9b,"0;31;43",$6d,"#",$9b,"0;31;40",$6d," Block"
        dc.b " ",$9b,"0;31;43",$6d,"$",$9b,"0;31;40",$6d," Block"
        dc.b " ",$9b,"0;31;43",$6d,"+",$9b,"0;31;40",$6d," Up"
        dc.b " ",$9b,"0;31;43",$6d,"-",$9b,"0;31;40",$6d," Down"
        dc.b " ",$9b,"0;31;43",$6d,"R",$9b,"0;31;40",$6d,"ead"
        dc.b " ",$9b,"0;31;43",$6d,"W",$9b,"0;31;40",$6d,"rite"
        dc.b " ",$9b,"0;31;43",$6d,"C",$9b,"0;31;40",$6d,"hecksum"
        dc.b " ",$9b,"0;31;43",$6d,"A",$9b,"0;31;40",$6d,"scii"
        dc.b " ",$9b,"0;31;43",$6d,"H",$9b,"0;31;40",$6d,"ex"
        dc.b $0a,$0a
        dc.b " Block #     $      Buffer #     $      Checksum $"
        dc.b $0a,"---------------------------------------------------"
        dc.b "--------------------------"
toplen=*-top

        ; BLOCKTYP

boot:   dc.b "BOOTBLOCK "
root:   dc.b "ROOTBLOCK "
flist:  dc.b "FILELIST  "
fhead:  dc.b "FILEHEADER"
dat:    dc.b "DATABLOCK "
udir:   dc.b "USERDIR   "
unkn:   dc.b "----------"

        ; DISK FEHLERMELDUNGEN

nderr:  dc.b $9b,"43",$6d,"NO DISK IN DRIVE !",$9b,"40",$6d
ndlen=*-nderr
rderr:  dc.b $9b,"43",$6d,"   READ-ERROR !   ",$9b,"40",$6d
rdlen=*-rderr
wrerr:  dc.b $9b,"43",$6d,"   WRITE-ERROR !  ",$9b,"40",$6d
wrlen=*-wrerr
pterr:  dc.b $9b,"43",$6d,"WRITE-PROTECTION !",$9b,"40",$6d
ptlen=*-pterr
clear:  dc.b "    NO ERROR !    "
clrlen=*-clear


even
crsrstatus:
        dc.w 0
adr:    dc.w 0
text:   dc.b "0000"
key:    dc.b 0
key2:   dc.b 0
byte:   dc.b 0
even
linebuf:blk.b 64,0      ;puffer für umwandlungen

        ;sequenz für cursorpositionierung allgemein

pos:    dc.b $9b
row:    dc.b "00",$3b
col:    dc.b "00",$48

        ;s.o. für addresszähler dez und hex

adrpos: dc.b $9b,"04",$3b,"29",$48
adrpos2:dc.b $9b,"04",$3b,"35",$48

        ;sequenz für cursor ein/aus

con:    dc.b $9b,$20,$70
coff:   dc.b $9b,$30,$20,$70

dosname:dc.b "dos.library",0
trkdisk:dc.b "trackdisk.device",0
device: dc.b 0

even
dosbase:dc.l 0
wdhd:   dc.l 0          ;fensterhandle

block:  dc.w 880        ;startblock
offset: dc.l 0          ;offset für read/write =512*block
buffptr:dc.l 0          ;pufferzeiger
buffer: dc.l 0          ;pufferstart

diskport:
        dc.l 0          ;0
        dc.l 0          ;4
        dc.w $0400      ;8
        dc.l 0          ;10
        dc.b 0          ;14
        dc.b 31         ;15
        dc.l 0          ;16     task adr. hierhin
LH1:    dc.l LH2        ;20
LH2:    dc.l 0          ;24
        dc.l LH1        ;28
        dc.b 0          ;32
        dc.b 0          ;33

diskioreq:
        dc.l 0          ;0
        dc.l 0          ;4
        dc.b 5          ;8
        dc.b 0          ;9
        dc.l 0          ;10
        dc.l diskport   ;14
        dc.w 48         ;18
        dc.l 0          ;20
        dc.l 0          ;24
        dc.w 0          ;28 IO_CMD
        dc.w 0          ;30
        dc.l 0          ;32 IO_ERROR
        dc.l 0          ;36 IO_LENGTH
        dc.l 0          ;40 IO_DATA
        dc.l 0          ;44 IO_OFFSET
        dc.l 0
        dc.l 0