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ö.
	jsr dumpcheck		;checksum ausgeben
	move.b #"r",key		;read befehl simulieren
	bra.s start

main:	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.s 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

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 #"4",col
	move.b #"4",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
	lea text,a0		;block dezimal umwandeln
	clr.l d0
	move.w block,d0
	divu #1000,d0
	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)+
	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

getkey:	move.l wdhd,d1		;taste nach key holen
	move.l #key,d2
	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
	jsr convword
noadr:	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 ausgeben
	move.b #"5",col
	move.b #"3",col+1
	move.b #"0",row
	move.b #"4",row+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 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 " ",$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,"A",$9b,"0;31;40",$6d,"scii"
	dc.b " ",$9b,"0;31;43",$6d,"H",$9b,"0;31;40",$6d,"ex"
	dc.b " ",$9b,"0;31;43",$6d,"C",$9b,"0;31;40",$6d,"hecksum"
	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 $0a,$0a
	dc.b " Block #     $      Buffer $     Checksum $"
	dc.b $0a,"---------------------------------------------------"
	dc.b "--------------------------"
toplen=*-top

	; FEHLERMELDUNGEN

nderr:	dc.b $9b,"0;31;43",$6d,"NO DISK IN DRIVE !",$9b,"0;31;40",$6d
ndlen=*-nderr
rderr:	dc.b $9b,"0;31;43",$6d,"   READ-ERROR !   ",$9b,"0;31;40",$6d
rdlen=*-rderr
wrerr:	dc.b $9b,"0;31;43",$6d,"   WRITE-ERROR !  ",$9b,"0;31;40",$6d
wrlen=*-wrerr
pterr:	dc.b $9b,"0;31;43",$6d,"WRITE-PROTECTION !",$9b,"0;31;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

	;sequenz für cursorpositionierung

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

	;s.o. für addresszähler

adrpos:	dc.b $9b,"04",$3b,"29",$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

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