opt l-			;nicht linken

* MandelPrint - zum Erzeugen von Apfelmännchen, die aber nicht auf den
* Bildschirm, sondern den Drucker (24-Nadler, am besten NEC oder kompa-
* tibel) in der höchsten Auflösung (360*360 dpi) ausgegeben werden.
* An andere 24-Nadler anpaßbar.
* Die Benutzeroberfläche wurde deshalb so spartanisch ausgestattet, da
* dieses Programm nicht andere PD-Mandelbrot-Generatoren ersetzen soll,
* daher sollte man sich die Koordinaten z.B. von MandFXP besorgen und
* diese dann bei MandelPrint eingeben.
* Beim Ausdrucken bitte nicht verzweifeln, wenn eine Weile lang nichts
* kommt - er hat sich NICHT aufgehängt, nur muß er verdammt viel rechnen:
* eine Zeile besteht aus 12*1300 = 15600 Pixeln. Bei einer Tiefe von 100
* muß der Computer bis zu 400 Multiplikationen und Divisionen, 400 Additionen
* und Subtraktionen und tausende <move>s und anderen Kleinkram PRO PUNKT
* durchführen. Da kann man schon lange warten müssen.
* Das "Standart-Apfelmännchen"(xmin : -2 ; xmax : 0.7 ; ymin = -1 ; ymax : 1)
* braucht genau 625926 BYTES an Speicherplatz, wenn die Ausgabe auf Diskette
* erfolgen soll (dazu die Zeile <printname> ändern) !!!

* Version 1.1 - Maschinencode wurde noch optimiert, um jede unnötige Ver-
* zögerung zu vermeiden.

* © 25.7.1989 Tim Pietzcker Software, Schwarzwaldstr.52, D-7819 Denzlingen
* Dieses Programm ist Public Domain. Wer es verändert (verbessert), den bitte
* ich, mir das mitzuteilen, damit ich auch was davon habe. Danke!


	incdir ":include/"
	
	include "math/mathffp_lib.i"
	include "math/mathtrans_lib.i"
	include "exec/exec_lib.i"
	include "libraries/dos_lib.i"
	include "libraries/dos.i"
	include "exec/memory.i"
	

*DOS/Lib öffnen:

_main	lea	dosname,a1		;Name der DOS-Lib 
	clr.l	d0			;Version egal
	CALLEXEC OpenLibrary		;Lib öffnen
	tst.l	d0			;Fehler?
	beq	end4			;wenn Fehler, Ende
	move.l	d0,_DOSBase    		;Zeiger merken

	lea	ffpname,a1		;dasselbe mit mathffp-lib
	clr.l	d0
	CALLEXEC OpenLibrary
	tst.l	d0
	beq	end3
	move.l	d0,_MathBase
	
	lea	mathtransname,a1	;und mit mathtrans-lib
	clr.l	d0
	CALLEXEC OpenLibrary
	tst.l	d0
	bne	MTLok			;wenn okay, dann zu MTLok
	lea	matherror,a0		;sonst Fehlermeldung ausgeben
	bsr	writetext
	bra	end2
MTLok	move.l	d0,_MathTransBase
	

begin					;hier geht jetzt das Programm los !
	lea	starttext,a0		;Begrüßungstext ausgeben
	bsr	writetext

getmem	move.l	pbufsize,d0		;Speicher reservieren
	move.l	pbufflags,d1		;unter diesen Bedingungen
	CALLEXEC AllocMem
	move.l	d0,printbuf		;Zeiger merken
	tst.l	d0			;gab's überhaupt noch soviel ?
	bne	xmi1			;wenn ja
	lea	memerror,a0
	bsr	writetext		;Error-Meldung ausgeben
	bra	end1			;und Programm beenden
	
xmi1	lea	xmintext,a0		;Eingabe linker Rand
	bsr	writetext
	lea	buffer,a0
	bsr	readtext
	lea	buffer,a0
	subq	#1,d0			;RETURN-Zeichen nicht mitberechnen!
	bsr	stringfloat		;d0 : Länge , a0 : Adresse String
	move.l	d0,xmin
	move.l	#$800000C2,d1		;zum Vergleich : -2 als FFP in d1
	CALLFFP	SPCmp
	tst.l	d0			;ist xmin<-2 ?
	ble	xma1			;wenn nicht, dann OK
	lea	xminerror,a0		;sonst Fehler ausgeben
	bsr	writetext
	bra	xmi1
	
xma1	lea	xmaxtext,a0		;Eingabe rechter Rand
	bsr	writetext
	lea	buffer,a0
	bsr	readtext
	lea	buffer,a0
	subq	#1,d0
	bsr	stringfloat
	move.l	d0,xmax
	move.l	#$80000042,d1		;zum Vergleich : +2 als FFP in d1
	CALLFFP	SPCmp
	tst.l	d0			;ist xmax>2 ?
	bpl	xmimatest		;wenn nicht, dann OK
	lea	xmaxerror,a0
	bsr	writetext
	bra	xma1
	
xmimatest				;ist xmin < xmax ?
	move.l	xmin,d0
	move.l	xmax,d1
	CALLFFP	SPCmp
	tst.l	d0
	bgt	ymi1			;alles OK
	lea	xerrtext,a0
	bsr	writetext
	bra	xmi1
	
ymi1	lea	ymintext,a0		;Eingabe linker Rand
	bsr	writetext
	lea	buffer,a0
	bsr	readtext
	lea	buffer,a0
	subq	#1,d0			;RETURN-Zeichen nicht mitberechnen!
	bsr	stringfloat		;d0 : Länge , a0 : Adresse String
	move.l	d0,ymin
	move.l	#$800000C2,d1		;zum Vergleich : -2 als FFP in d1
	CALLFFP	SPCmp
	tst.l	d0			;ist xmin<-2 ?
	ble	yma1			;wenn nicht, dann OK
	lea	yminerror,a0		;sonst Fehler ausgeben
	bsr	writetext
	bra	ymi1
	
yma1	lea	ymaxtext,a0		;Eingabe rechter Rand
	bsr	writetext
	lea	buffer,a0
	bsr	readtext
	lea	buffer,a0
	subq	#1,d0
	bsr	stringfloat
	move.l	d0,ymax
	move.l	#$80000042,d1		;zum Vergleich : +2 als FFP in d1
	CALLFFP	SPCmp
	tst.l	d0			;ist xmax>2 ?
	bpl	ymimatest		;wenn nicht, dann OK
	lea	ymaxerror,a0
	bsr	writetext
	bra	yma1
	
ymimatest				;ist xmin < xmax ?
	move.l	ymin,d0
	move.l	ymax,d1
	CALLFFP	SPCmp
	tst.l	d0
	bgt	tmax1			;alles OK
	lea	yerrtext,a0
	bsr	writetext
	bra	ymi1
	
tmax1	lea	tmaxtext,a0		;Eingabe max. Iterationszahl
	bsr	writetext
	lea	buffer,a0
	bsr	readtext
	lea	buffer,a0
	subq	#1,d0
	bsr	stringfloat
	CALLFFP	SPFix			;in Ganzzahl wandeln
	move.l	d0,tmax
	cmp.l	#5,d0			;größer als 4 ?
	bge	ttest2			;wenn ja
	lea	tmaxerror,a0		;sonst...
	bsr	writetext
	bra	tmax1
ttest2	cmp.l	#2000,d0		;kleiner als 2001 ?
	blt	ende_eingabe		;wenn ja, dann ist alles OK
	lea	tmaxerror,a0
	bsr	writetext
	bra	tmax1

ende_eingabe
	move.l	xmax,d0			;berechne : stepx=(xmax-xmin)/pixh
	move.l	xmin,d1
	CALLFFP	SPSub
	move.l	d0,d2
	move.l	pixh,d0
	CALLFFP	SPFlt
	move.l	d0,d1
	move.l	d2,d0
	CALLFFP	SPDiv
	move.l	d0,stepx			
	move.l	#$80000042,d1		;2 in FFP
	CALLFFP	SPMul			;mit stepx multiplizieren	
	move.l	d0,stepy		;stepy = 2 * stepx (Wahrung des
					;Seitenverhältnisses; ich verwende
					;zwei Variablen, falls ich einmal das
					;Programm ändere, sodaß verschiedene
					;Seitenverhältnisse erlaubt sind)
					
berech_pixv
	lea	bereittext,a0		;Meldung "Bereit zum Ausdruck!"
	bsr	writetext
	move.l	ymax,d0			;berechne Anzahl der Zeilen 
	move.l	ymin,d1
	CALLFFP	SPSub
	move.l	stepy,d1
	CALLFFP	SPDiv
	CALLFFP	SPFix
	divu	#12,d0
	mulu	#12,d0
	move.l	d0,pixv			;pixv = (ymax-ymin)/stepy /12 *12 <=
					;um auf 12-Punkte-Grenze zu runden |	
	lea	wurzel2,a0
	move.l	#wurzel2len,d0
	bsr	stringfloat		;Wurzel aus 2 berechnen
	move.l	d0,d4	
	move.l	pixh,d0
	CALLFFP	SPFlt
	move.l	d4,d1
	CALLFFP	SPMul
	CALLFFP	SPFix
	cmp.l	pixv,d0			;ist pixv > pixh*Wurzel2 ?
	bgt	aspectOK		;(wenn ja, dann DIN A4 überschritten)
	lea	warntext,a0		;Warnung ausgeben
	bsr	writetext
aspectOK
	lea	ber2text,a0		;Meldung "Drucken oder abbrechen?"
	bsr	writetext
	lea	buffer,a0		
	bsr	readtext		;Antwort lesen
	lea	buffer,a0
	cmpi.b	#'q',(a0)		;Abbruch gewünscht ?
	beq	relmem			;Oh ja
	lea	ber3text,a0		;Meldung "Los geht's!"
	bsr	writetext
openpar
	move.l	#MODE_NEWFILE,d2	;zur Ausgabe öffnen
	move.l	#printname,d1		;"PAR:" als Druckername
	CALLDOS	Open
	move.l	d0,printhandle		;Handle merken
	tst.l	d0			;ist PAR: zu haben ?
	bne	nun_gehts_los		;wenn ja
	lea	parerror,a0
	bsr	writetext
	bra	relmem
	
nun_gehts_los
	move.l	#200,d1
	CALLDOS	Delay			;warten, parallel.device geladen ist
	CALLEXEC Forbid			;Multitasking aus (schneller rechnen)
	move.l	printhandle,d1		;LineFeed einstellen
	move.l	#setlfeed,d2
	move.l	#slflen,d3
	CALLDOS	Write
	tst.l	d0
	bmi	druckerror		;Fehler bei Übertragung ?
	clr.l	druckzeile
druckzeilenschleife			;zählt die Druckzeilen (je 12 Pixel)
	move.l	druckzeile,d0		;berechne offy (= Oberer Rand der
	mulu	#12,d0			;		jeweiligen Zeile )
	CALLFFP	SPFlt
	move.l	stepy,d1
	jsr	_LVOSPMul(a6)
	move.l	d0,d1
	move.l	ymax,d0
	jsr	_LVOSPSub(a6)
	move.l	d0,offy			;offy = ymax - 12*druckzeile*stepy
	move.l	ymin,d1			;Test, ob Bild fertig
	jsr	_LVOSPCmp(a6)
	tst.l	d0
	bpl	closepar		;Bild ist fertig
	
	move.l	xmin,cx			;cx (x-Anteil von C) zurücksetzen
	move.l	pbufsize,d2		;Anzahl der Bytes im Druckpuffer
	subq	#1,d2
	movea.l	printbuf,a0
clrloop	clr.b	(a0)+			;Druckerpuffer löschen
	dbra	d2,clrloop
	clr.l	offset			;Nummer des bearbeiteten Bytes
	clr.l	spalte
label1
zeilenschleife
	movea.l	_MathBase,a6
	clr.l	zeile
	move.l	offy,cy			;cy (y-Anteil von C) zurücksetzen
spaltenschleife
					;jetzt folgen die Rechenvariablen
	clr.l	d3			;Tiefe (Anzahl der berechneten Iter.)
	clr.l	d4			;xw (Hilfsvariable)
	clr.l	d5			;yw (ebenso)
	clr.l	d6			;x2 (x-Koordinate nach Tiefe Operat.)
	clr.l	d7			;y2 (y-Koordinate ... )
punktschleife
	move.l	d4,d1			;berechne yw (=d5)
	move.l	#$80000042,d0		;2 in FFP
	jsr	_LVOSPMul(a6)
	move.l	d5,d1
	jsr	_LVOSPMul(a6)
	move.l	cy,d1
	jsr	_LVOSPAdd(a6)
	move.l	d0,d5			;yw = 2*xw*yw + cy
	
	move.l	d6,d0			;berechne xw (=d4)
	move.l	d7,d1
	jsr	_LVOSPSub(a6)
	move.l	cx,d1
	jsr	_LVOSPAdd(a6)
	move.l	d0,d4			;xw = x2-y2+cx
	
	move.l	d0,d1			;berechne x2 (=d6)
	jsr	_LVOSPMul(a6)
	move.l	d0,d6			;x2 = xw²
	
	move.l	d5,d0			;berechne y2 (=d7)
	move.l	d0,d1
	jsr	_LVOSPMul(a6)
	move.l	d0,d7			;y2 = yw²
	
	move.l	d6,d1			;berechne x2+y2
	jsr	_LVOSPAdd(a6)
	move.l	#$80000044,d1		;8 in FFP
	jsr	_LVOSPCmp(a6)		;x2+y2 > 8 ?
	tst.l	d0
	bmi	punkt			;dann Punkt setzen
	addq.l	#1,d3			;Tiefe um 1 erhöhen
	cmp.l	tmax,d3			;maximale Tiefe überschritten ?
	blt	punktschleife		;noch nicht
punkt	
	cmp.l	tmax,d3			;max. Tiefe erreicht ?
	beq	increment		;dann keinen Punkt setzen
punktsetzen
	andi.l	#%0001,d3		;Tiefe mod 2 = Farbnummer
	asl.l	#2,d3			;mal 4, um auf Adresse zu kommen
	lea	coltab,a0
	adda.l	d3,a0			;Zeiger auf Tabelle Nr. Tiefe mod 4
	movea.l	(a0),a0			;in Register a0 laden
	move.l	zeile,d0		;Nummer der Zeile
	andi.l	#%0011,d0		;mod 4 (Rest einer Ganzzahldivision)
	asl.l	#1,d0			;mal 2
	movea.l	printbuf,a1
	adda.l	offset,a1
	adda.l	d0,a0
	move.b	(a0),d1
	or.b	d1,(a1)			;Punkt 1.Hälfte
	adda.l	#1,a0
	move.b	(a0),d1
	or.b	d1,3(a1)		;Punkt 2.Hälfte
increment
	move.l	cy,d0			
	move.l	stepy,d1
	jsr	_LVOSPSub(a6)
	move.l	d0,cy			;cy = cy - stepy
	addq.l	#1,zeile
	move.l	zeile,d0
	andi.l	#%0011,d0
	bne	inc2
	addq.l	#1,offset		;wenn zeile mod 4 = 0
inc2	cmpi.l	#12,zeile		;Druckspalte voll ?
	bne	spaltenschleife		;noch nicht
	addq.l	#3,offset		;sonst auf 6er-Grenze bringen
	move.l	cx,d0
	move.l	stepx,d1
	jsr	_LVOSPAdd(a6)		;cx = cx + stepx
	move.l	d0,cx
	cmp.b	#$41,$bfec01		;wurde HELP gedrückt ?
	bne	next_zeile		;nein
	CALLEXEC Permit			;Multitasking wieder an
	lea	abbrtext,a0		;doch
	bsr	writetext		;Meldung : "Abbrechen ?"
	lea	buffer,a0
	bsr	readtext
	CALLEXEC Forbid			;Multitasking aus
	lea	buffer,a0
	cmp.b	#'a',(a0)
	beq	closepar		;ja, abbrechen
next_zeile
	addq.l	#1,spalte
	move.l	spalte,d0
	cmp.l	pixh,d0			;Druckzeile fertig ?
	bne	zeilenschleife		;noch nicht
drucke_zeile
	move.l	printhandle,d1
	move.l	#setgraph,d2
	move.l	#sglen,d3
	CALLDOS	Write			;Graphikdruck einschalten
	tst.l	d0
	bmi	druckerror
	move.l	printhandle,d1
	move.l	printbuf,d2
	move.l	pbufsize,d3
	CALLDOS	Write
	tst.l	d0
	bmi	druckerror
	addq.l	#1,druckzeile
	bra	druckzeilenschleife
	
druckerror
	lea	parerror,a0
	bsr	writetext

* ------------------------------------ENDE------------------------------

closepar
	CALLEXEC Permit
	move.l	printhandle,d1
	CALLDOS	Close
relmem	movea.l	printbuf,a1
	move.l	pbufsize,d0
	CALLEXEC FreeMem

end1	movea.l	_MathTransBase,a1	;MathTrans-lib schließen
	CALLEXEC CloseLibrary
end2	movea.l	_MathBase,a1		;MathFFP-lib schließen
	CALLEXEC CloseLibrary
end3	movea.l	_DOSBase,a1		;DOS-lib schließen
	CALLEXEC CloseLibrary

end4	rts
	

* Unterprogramme ----------------------------------------------------

writetext
* Druckt einen mit Nullbyte abgeschlossenen String zum Standard-Output
* Argument : Zeiger auf Text in a0
	movem.l	d2-d5/a5,-(sp)		;Register retten
	movea.l	a0,a5			;Zeiger auf Text kopieren
	CALLDOS	Output			;Output-Handle holen
	move.l	d0,d5			;und merken
	movea.l	a5,a0			;Zeiger auf Text zurückholen
	movea.l	a0,a1			;Zeiger kopieren
w1	addq.l	#1,a1			;eine Stelle weiter
	cmp.b	#0,(a1)			;Null-Byte gefunden ?
	bne	w1			;wenn nicht
	suba.l	a0,a1			; = Textlänge
	
	move.l	a1,d3			;Länge
	move.l	d5,d1			;Handle
	move.l	a0,d2			;Zeiger auf Text
	CALLDOS	Write
	movem.l	(sp)+,d2-d5/a5		;Register zurückspeichern
	
	rts
	
* -------------------------------------------------------------------
	
readtext
* Liest einen Text vom Standard-Input
* Argument : Zeiger auf Puffer in a0 (80 Byte Platz reservieren !)
* Rückgabe : Länge in d0
	movem.l	d2-d3/a5,-(sp)		;Register retten
	movea.l	a0,a5			:Zeiger auf Text kopieren
	CALLDOS	Input			;Input-Handle holen
	move.l	d0,d1			;und für Read in d1 kopieren
	move.l	a5,d2			;Adresse Puffer
	moveq	#80,d3			;Maximale Anzahl Zeichen
	CALLDOS	Read			;lesen
	movem.l	(sp)+,d2-d3/a5		;Register zurück
	
	rts

* -------------------------------------------------------------------

stringfloat
* Routine, die einen String in eine FFP-Zahl umformt (aus : AMIGA -
* Programmieren in Maschinensprache von Frank Riemenschneider; mit ein paar
* Änderungen.
* Argumente : a0 : Zeiger auf String
*	      d0 : Länge des Strings
* Rückgabe  : d0 : FFP-Zahl
	movem.l	d2-d7/a3-a6,-(sp)	;Register retten
	movea.l	a0,a2
	move.l	d0,d5	
        clr.l float
	clr.w EXP
	clr.l d0
	clr.l d3
	
	move.b (a2),d0          ;erstes Zeichen
	cmpi.b #"-",d0		;Minuszeichen ?
	bne plus
* Negative Zahl

	move.b #128,EXP		;Negativ-Flag setzen
	move.w d5,d0
	move.l a2,a0		;und Rest-String
strloop1
	move.b 1(a0),(a0)+
	subq #1,d0		;um eine Position nach
	bne strloop1
	subq #1,d5		;links schieben

plus	clr.l d0		;Position
	move.l a2,a0
strloop2
	move.b (a0)+,d3 	;Zeichen holen
	cmpi.b #".",d3
	beq found		;Punkt gefunden
	addq.l #1,d0
	cmp.w d0,d5		;alles durchsucht
	beq nopoint
	bra  strloop2

found	subq #1,d0
	move.l d0,d4 		;höchster Exponent
	addq.l #1,d0
	move.l a2,a0		;Punkt aus String
strloop3
	move.l a0,a6
	adda.l d0,a6		;eleminieren
	move.b 1(a6),(a6)
	addq.l #1,d0
	cmp.w d0,d5
	bne strloop3
	subq #1,d5
	bra  weiter1

nopoint	move.l d5,d4
	subq #1,d4  		;höchster Exponent
	
weiter1 clr.l d6		;Position
	move.l a2,a5

strloop4
	move.l d4,d0		;Exponenten holen
	CALLFFP SPFlt		;in Fliesskomma
	move.l d0,d1
	move.l #$A0000044,d0	;10 in Fliesskomma
	CALLMATHTRANS SPPow	;10 hoch x rechnen
	move.l a5,a6            ;Faktor holen (ASCII)
	adda.l d6,a6
	clr.l d1
	move.b (a6),d1
	subi.b #"0",d1		;minus 48 ("0") =
	move.l d0,d7		;Zahl in Fliesskomma
	move.l d1,d0		;mit 10 hoch x
	CALLFFP SPFlt
	move.l d7,d1
	CALLFFP SPMul		;Multiplizieren
	move.l float,d1
	CALLFFP SPAdd		;zu bisheriger Summe
	move.l d0,float		;addieren
	subq.l #1,d4		;Exponenten verringern
	addq.l #1,d6 		;Position erhöhen
	cmp.l d6,d5		;fertig ?
	bne strloop4
	move.l float,d0		;Negativ-Flag einblenden
	or.b EXP,d0
	movem.l	(sp)+,d2-d7/a3-a6	;Register zurück	
	rts

* Daten -------------------------------------------------------------

dosname	DOSNAME
_DOSBase	ds.l	1	
ffpname FFPNAME
_MathBase	ds.l	1
mathtransname	MATHTRANSNAME
_MathTransBase	ds.l	1

matherror	dc.b	"FEHLER : mathtrans.library nicht in LIBS: gefunden!",10,0
		even

starttext
	dc.b	12,10,10,27,"[1m                             ***** MandelPrint ******",10
	dc.b	27,"[0m",27,"[3m                              Tim Pietzcker Software",10,10
	dc.b	27,"[0m",27,"[33mDieses Programm druckt die bekannten Apfelmännchen in der höchsten Auf-",10
	dc.b	"lösung, die der NEC P6 zu bieten hat (360*360 Punkte pro Quadratzoll), aus.",10
	dc.b	"Dieses Programm ist nicht zum Einsteigen in diese Materie gedacht, bitte",10
	dc.b	"probieren Sie erst mit einem anderen Mandelbrot-Programm, welchen Ausschnitt",10
	dc.b	"Sie gerne gedruckt hätten.",27,"[0m",10,10,0
	cnop	0,4

float		dc.l 0
EXP		dc.w 0
buffer	ds.b	80
	even
xmax	ds.l	1
ymax	ds.l	1
xmin	ds.l	1
ymin	ds.l	1
tmax	ds.l	1
zeile	ds.l	1
spalte	ds.l	1
druckzeile	ds.l	1
printbuf ds.l	1
printhandle	ds.l	1
cx	ds.l	1
cy	ds.l	1
stepx	ds.l	1
stepy	ds.l	1
offy	ds.l	1
pixh	dc.l	1300		;maximale Anzahl von horizontalen Pixeln
pixv	ds.l	1
offset	ds.l	1
setlfeed	dc.b	28,51,48	;Zeilenabstand auf 24/360" setzen
slflen	equ	*-setlfeed
	even
setgraph	dc.b	10,27,"*",40,40,10
sglen	equ	*-setgraph
	
* Die vorletzte Zeile schaltet den Drucker (wenn zu PAR: gesendet) in den
* Graphikmodus ( "27,'*',40" => 360*360 dpi²). Es werden pro Zeile
* 40+10*256 = 2600 Druckspalten = 7800 Bytes erwartet .
* Vorher wird ein Zeilenvorschub ausgeführt.

printname	dc.b	"PAR:",0
		even
pbufsize	dc.l	7800	
pbufflags	dc.l	MEMF_PUBLIC!MEMF_CLEAR

wurzel2		dc.b	"1.4151"
wurzel2len	equ	*-wurzel2

memerror	dc.b	27,"[33mFehler : Nicht mehr genug Speicherplatz übrig !!!",27,"[0m",10,0
	even
xmintext	dc.b	"Bitte geben Sie die Koordinaten des linken Rands ein : ",0
	even
xminerror	dc.b	27,"[33mFehler : linker Rand muß größer als -2 sein !",27,"[0m",10,0
	even
xmaxtext	dc.b	"Bitte geben Sie die Koordinaten des rechten Rands ein : ",0
	even
xmaxerror	dc.b	27,"[33mFehler : rechter Rand muß kleiner als 2 sein !",27,"[0m",10,0
	even
xerrtext	dc.b	27,"[33mFehler : linker Rand größer als oder gleich rechter Rand !",10,"Bitte wiederholen !",27,"[0m",10,0
	even

ymintext	dc.b	"Bitte geben Sie die Koordinaten des unteren Rands ein : ",0
	even
yminerror	dc.b	27,"[33mFehler : unterer Rand muß größer als -2 sein !",27,"[0m",10,0
	even
ymaxtext	dc.b	"Bitte geben Sie die Koordinaten des oberen Rands ein : ",0
	even
ymaxerror	dc.b	27,"[33mFehler : oberer Rand muß kleiner als 2 sein !",27,"[0m",10,0
	even
yerrtext	dc.b	27,"[33mFehler : unterer Rand größer als oder gleich oberer Rand !",10,"Bitte wiederholen !",27,"[0m",10,0
	even
tmaxtext	dc.b	"Bitte geben Sie die maximale Iterationszahl ein : ",0
	even
tmaxerror	dc.b	27,"[33mFehler : Iterationszahl muß zwischen 5 und 2000 liegen !",27,"[0m",10,0
	even
bereittext	dc.b	"Ich bin bereit zum Ausdruck! Legen Sie bitte ein Blatt Papier ein.",10,0
	even
warntext	dc.b	27,"[33mACHTUNG : Format übersteigt DIN A4-Blatt !!",27,"[0m",10,0
	even
ber2text	dc.b	"Drücken Sie [RETURN] zum Ausdrucken oder [q] zum Abbrechen : ",0
	even
ber3text	dc.b	"Rechenvorgang angelaufen ... Multitasking ausgeschaltet ...",10,"Zum Unterbrechen [HELP] drücken !",10,0
	even
parerror	dc.b	27,"[33mFehler : Printer belegt, ausgeschaltet oder offline !",27,"[0m",10,0
	even
abbrtext	dc.b	"Druckvorgang unterbrochen : [w]eiter oder [a]bbrechen ? ",0
	even

coltab	dc.l	color0				;Farbtabelle 
	dc.l	color1

color0	dc.b	%10000000			;1 Punkt = 1 Druckpixel
	dc.b	%00000000
	dc.b	%00100000
	dc.b	%00000000
	dc.b	%00001000
	dc.b	%00000000
	dc.b	%00000010
	dc.b	%00000000
	
color1	dc.b	%10000000			;1 Punkt = 2 Druckpixel
	dc.b	%01000000
	dc.b	%00100000
	dc.b	%00010000
	dc.b	%00001000
	dc.b	%00000100
	dc.b	%00000010
	dc.b	%00000001