Ausgewählte Kapitel der BASIC-Programmierung

BASIC erweist sich immer mehr als beliebteste Sprache in verschiedenen Bereichen der Computertechnik. Nicht nur der Heim-Programmierer benutzt sie am häufigsten, sondern auch in der Industrie und an Universitäten gewinnt BASIC an Ansehen. Die neuen Versionen dieser Interpretersprache sind so erweitert und leistungsfähig, daß es kaum Argumente für die Ablehnung gibt. Ein neues Indiz für die Bedeutung dieser Programmiersprache ist die neueste Version eines BASIC-Interpreters von dem renommierten Softwarehauses BORLAND, der mit seinem TURBO-BASIC für IBM-Rechner und kompatible seine erfolgreiche Serie weiterführt. Für die Atari-ST-Serie gibt es schon seit langer Zeit eine Reihe von BASIC-Versionen, die wegen ihrer Geschwindigkeit und ihrer Leistung mit anderen höheren Sprachen problemlos konkurrieren können. Wir haben unsere Serie dieser wichtigen Sprache gewidmet und versuchen, in diesem Raum für jeden ein wenig zu bringen. Wir wollen also Einsteiger und Aufsteiger gleichermaßen ansprechen und hoffen, daß es gelingt.

Im ersten Teil dieser Serie beschäftigten wir uns mit der Ausgabe auf den Bildschirm und betrachteten eine Reihe von Befehlen, die die Ausgabe auf der Mattscheibe steuern. Niemand wird bezweifeln, daß dies eine wichtige Rolle bei der Programmierung spielt.

Eine andere wichtige Funktion, die uns immer verfolgen wird, ist die Eingabe. Dieser zweite Teil der Serie wird der Eingabe über die Tastatur gewidmet.

Eine Maus reicht nie aus

Neben Maus und GEM-Oberfläche gibt es beim Atari ST auch andere Eingabemöglichkeiten. Eine davon (und sicher eine der wichtigsten) ist die Tastatur. Sie wird nicht nur in Programmen, die unter TOS arbeiten, sondern auch bei Anwendungen, die unter GEM laufen, benutzt.

In BASIC gibt es verschiedene Funktionen, die die Eingabe über die Tastatur erlauben. Einige Befehle sind sozusagen standardisiert, sie gehören mehr oder weniger zu jeder BASIC-Version; andere sind Sonderfunktionen einer bestimmten Interpreter-Version. Da wir in dieser Serie die am meisten verbreiteten BASIC-Interpreter benutzen, nämlich die von GFA und OMIKRON, werden wir auch die Sonderfälle jeder Version besprechen.

Aus PUT wird INPUT

Um irgendetwas von der Tastatur zu lesen (zum Beispiel wenn der User die Taste ’A’ drückt), muß der Atari ST jede Menge leisten. Ein in der Tastatur untergebrachter Prozessor (Coprozessor) verwaltet jede einzelne Taste und teilt dies dem Hauptprozessor jedes Mal mit, wenn sie gedrückt wurde. Der gibt dann dem Betriebssystem die Meldung weiter. Vom Betriebssystem her kann diese Information weiterverarbeitet werden; es sorgt dafür, daß sie gut bewahrt wird. Gleichzeitig steht sie zu irgendwelchen anderen Zwecken zur Verfügung. So kann man zum Beispiel die gewohnte Information auf dem Bildschirm darstellen, auf einem Drucker ausgeben oder als Parameter für eine andere Funktion benutzen, oder...

Wenn man sich gut im Betriebssystem des ST auskennt, kann man dieses kleine Beispiel (Taste A drücken und auf dem Bildschirm darstellen) ohne weiteres in Maschinensprache ausführen. Es soll Leute geben, die das mit Genuß tun. Für alle anderen, die sich noch nicht so vertraulich auf dieser Ebene bewegen, bietet ein BASIC-Interpreter sehr bequeme Befehle, die das Gleiche erreichen, ohne dabei Alpträume zu bekommen.

Der am häufigsten angewendete Befehl, um eines oder mehrere Zeichen über die Tastatur einzugeben, ist der Befehl INPUT. Seine Syntax ist bei GFA und OMIKRON gleich. Immer, wenn der Interpreter auf den Befehl INPUT trifft, wird der Ablauf des Programms gestoppt und auf eine (oder mehrere) Eingaben gewartet. Der Befehl INPUT ermöglicht die Eingabe von Zahlen oder Strings. Werden mehrere Eingaben hintereinander eingegeben, so müssen sie durch Kommata voneinander getrennt werden. Die Eingabe muß durch Drücken der Return-Taste abgeschlossen werden. Erfolgt eine erlaubte Eingabe, so wird das Programm fortgesetzt. Nun die genaue Syntax von INPUT:

INPUT A
Ermöglicht die Eingabe einer Zahl

INPUT A,B,C
Ermöglicht die Eingabe von drei Zahlen

INPUT A$
Ermöglicht die Eingabe eines Strings

INPUT A$,B$,C$,
Ermöglicht die Eingabe von drei Strings Man kann die Eingabe von Zahlen und Strings, falls es notwendig ist, bunt vermischen:

INPUT A,B$,C,D,E$
Die erste, dritte und vierte Eingabe ist numerisch, die zweite und fünfte vom Typ String.

Wie man sehen kann, ist der Befehl sehr praktisch, um einem Programm verschiedene Parameter mitzuteilen. Es ist auch möglich, eine Eingabe mit einer Meldung zu versehen:

INPUT "Bitte geben sie jetzt Ihren Namen ein” ; Na$

Schließt man die Meldung mit einem Komma statt mit einem Semikolon ab, erscheint das ansonsten auftretende Fragezeichen nicht.

OMIKRON hat alle INPUT-Befehle um eine interessante Variante erweitert. Man kann den Cursor so steuern, daß die Eingabe an einer gewünschten Stelle auf dem Bildschirm erfolgt. Dafür muß man nur die Zeile bzw. Spalte eingeben:

	INPUT @ (Zeile, Spalte);Var_Name

100 ' Beispiel INPUT in OMIKRON
110 INPUT "Bitte geben Sie die Menge der Werte 
		an ";Mg 
120 DIM We(Mg)
130 FOR I=0 TO Mg-1
140		PRINT"Eingabe ",I+1;
150		INPUT We(I)
160		Summe = Summe + We(I)
170 NEXT I
180 MiweS= STRS(Summe/Mg)
190 Abst= INT(100/Mg)
200 Teil= INT((400-(Abst*Mg))/Mg)
210 CLS
220 DRAW 10,230 TO 400,230 
230 DRAW 10,230 TO 10,20 
240 X1=10
250 FOR I=0 TO Mg-1
260		Ms=Ms+1
270		FILL STYLE =2,Ms
280		PBOX X1,230	TO X1+Abst,230-We(I)
290		X1=X1+Teil
300 NEXT I
310 TEXT 10,290,"Das aritmetische Mittel 
		ist :"+MiweS

Input "Bitte geben Sie die Menge der Werte an ";Mg 
Dim We(Mg)
For I = 0 To Mg-1
	Print "Eingabe ",I+1;
	Input We(I)
	Summe=Summe+We(I)
Next I
Miwe$=Str$(Summe/Mg)
Abst=Int(100/Mg)
Teil=Int((400-(Abst*Mg))/Mg)
Cls
Defline 1,2,2,1 
Line 10,230,400,230 
Line 10,230,10,20 
X1 = 10
For I=0 To Mg-1 
	Ms=Ms+l
	Deffill 1,2,Ms
	Pbox X1,230,X1+Abst,230-We(I)
	X1=X1+Teil 
Next I
Text 10,290,"Das aritmetische Mittel ist :"+Miwe$

Obwohl dieser Befehl sehr leistungsfähig ist, ist er nicht für jede Eingabe genügend geeignet. Wir hatten weiter oben erklärt, daß diese Anweisung auf eine 'erlaubte Eingabe’ wartet, um im Programm fortzufahren. Diesen Punkt werden wir jetzt genau betrachten. Ein großes Manko vom INPUT ist, daß das Komma als Trennzeichen erkannt und nur der Teil links vor dem Komma angenommen wird. Der Rest wird einfach nicht berücksichtigt. Möchte man eine Realzahl als String eingeben, so wird dieser sozusagen in einen Integer verwandelt.

	INPUT Zahl$ ? 123,456 < RETURN > 123

Das erste Beispiel wird den Einsatz dieses Befehls anschaulicher machen (siehe Listing 1 für OMIKRON und la für GFA). Es handelt sich um ein minimales Balkendiagramm-Programm, das keinen großen Anspruch erhebt. Jetzt zur Erläuterung: Erst wird die Menge aller Angaben verlangt und dadurch ein Feld dimensioniert. Die verschiedenen Eingaben erfolgen über den INPUT-Befehl, der sich innerhalb der FOR...NEXT-Schleife befindet. Die variable Summe enthält die Addition aller Eingaben und wird später zur Bildung des Mittelwertes benutzt. Der zweite Teil des Programms hat die Aufgabe, die verschiedenen Blöcke auf dem Bildschirm darzustellen. Zuletzt wird das arithmetische Mittel ausgedruckt.

Beide Interpreter benutzen für dieses Programm fast die gleichen Anweisungen. Unterschiede gibt es nur bei einigen Grafikbefehlen. Es gibt eine Erweiterung des INPUT-Befehls, die solche Einschränkungen behebt. LINE INPUT macht in der Regel nichts anderes als die INPUT-Anweisung. Werden Kommas mit eingegeben, so werden diese nicht als Trennzeichen interpretiert, sondern sie werden genauso wie ein anderes Zeichen aufgenommen. Die LINE-INPUT-Anweisung ermöglicht allerdings nur die Eingabe von Zeichenketten (Strings). Möchte man reine Zahlen als Ergebnis haben, so muß man diese erst als String eingeben und später entsprechend umwandeln.

	LINE INPUT Zahl$ ? 123.456 
	Zahl = VAL(Zahl$)

Es gibt noch einen Befehl zur Eingabe von Zeichenketten, der in beiden Interpretern (GFA und OMIKRON) vorhanden ist. Es handelt sich auch hier mehr oder weniger um eine Erweiterung des schon beschriebenen Befehls INPUT.

Es gibt Fälle, in denen man die Eingabe einer Zeichenkette auf eine bestimmte Anzahl von Zeichen begrenzen will. Das ist zum Beispiel der Fall bei der Eingabe von Daten, die zu einer Datei gehören, oder bei der Eingabe eines Passwortes, das die Benutzung eines Programms erst ermöglicht.

Dafür hat der BASIC-Interpreter den Befehl INPUT$, der eine Eingabe auf eine gewünschte Länge begrenzt. Hat man diese Grenze erreicht, dann setzt das Programm sofort die Abarbeitung fort. Die große Einschränkung dieser Anweisung ist, daß die Zeichen nicht unmittelbar nach der Eingabe dargestellt werden. Die Eingabe wird einer Variablen zugewiesen, die später durch den Befehl PRINT auf dem Bildschirm angezeigt wird oder an einen anderen Teil des Programmes weitergegeben werden kann. Die Syntax von INPUT$ weicht sehr von den anderen INPUT-Anweisungen ab:

	Eingabe$ = INPUT$ (Länge)

Obwohl dieser Befehl gegenüber dem normalen INPUT eine Erweiterung darstellt, ist er wegen der obengenannten Einschränkung nur in wenigen Fällen brauchbar. Wir werden später sehen, daß sich dieser INPUT$ in gewisser Weise wie der Befehl INKEY$ verhält.

Das abgebildete kleine Programm „PASSWORD“ hilft uns, den INPUTS-Befehl in der Praxis zu betrachten (siehe Listing 2 für OMIKRON und 2a für GFA).

Die Atari-Sonderzeichen und der INPUT-Befehl

Wie Sie vielleicht wissen, umfaßt der Zeichensatz von Atari 255 Zeichen. Darunter befinden sich alle Buchstaben und Zahlen, die man auch von anderen Computern kennt. Man kann sie problemlos über die Tastatur eingeben und auf dem Bildschirm oder Drucker darstellen. Der ST besitzt aber noch andere Zeichen, die nicht so leicht zu handhaben sind.

Im ersten Teil dieser Serie haben wir gezeigt, wie durch den Befehl TEXT alle Zeichen des Atari-Zeichensatzes darstellbar sind. Viele von diesen Zeichen kann man problemlos in eine Variable übergeben. Für die 'normalen’ Zeichen wie Buchstaben, Zahlen oder Operanden-Zeichen reicht die Betätigung einer Taste. Andere lassen sich nur durch gleichzeitiges Drücken von mehreren Tasten darstellen. Das ist z. B. der Fall bei allen Buchstaben, die mit einem Akzent (französische Zeichen) versehen sind, oder es tritt auch beim Wurzel-Zeichen auf. Andere Zeichen lassen sich über den INPUT-Befehl überhaupt nicht darstellen. Das betrifft die ersten 30 Symbole des Atari-Zeichensatzes.

100 'Beispiel INPUT$ in OMIKRON 
110 CLS
120 PRINT "Bitte Passwort eingeben"
130 Passwort$= INPUT$(5)
140 Geheim$="AMIGA"
150 '
160 IF Geheim$=Passwort$ THEN
170 	FORM_ALERT (1, "[1]["+Passwort$+"|Richtig 
		mein Freund][Gut]", Button) 
180 ELSE
190 	FORM_ALERT (1,"[1][Falsch Du Schurke]
		[Schluß]",Button) 
200 'wie wäre es hier mit SYSTEM 
210 ENDIF

' Beispiel INPUT$ in GFA
'
Print "Bitte geben sie ihr Passwort ein" 
Passwort$=Input$(5)
Geheim$="AMIGA" ! groß geschrieben !!
If GeheimS=Passwort$ Then
	Alert 1,PasswortS+"|Richtig mein Freund",1,
		Passworts,A 
Else
	Alert 1,"Falsch Du Schurke",1,"Schluß",Dum
Endif

Das Editieren bei INPUT

Es kann passieren, daß man bei der Eingabe einer Zeichenkette oder Zahl irgendwelche Eingaben falsch macht oder daß man sich vertippt hat. Es wäre sehr ärgerlich, wegen so einer Lappalie den gesamten Text wieder neu eingeben zu müssen. Die Entwickler beider BASIC-Interpreter (GFA und OMIKRON) haben mit dieser Möglichkeit gerechnet und vielfältige Möglichkeiten der Editierung zugelassen. Löschen, Bewegen des Cursors nach links und rechts sowie schnelleres Einrücken des Cursors am Anfang bzw. Ende der Eingabe sind möglich.

Sonderwünsche gefällig?

Wir haben die verschiedenen Varianten der INPUT-Befehle gesehen. Jede Form ist für einen bestimmten Fall besser geeignet. Nach der Beschreibung der obengenannten Befehle ist uns klar, daß jeder sogenannte Standard für beide Interpreter vorhanden ist. Man kennt aber von anderen Rechnern, daß das, was als Standard bezeichnet wird, sehr eingeschränkt und die Abweichung sehr groß ist. Andererseits möchte jeder Entwickler mehr oder weniger seine persönlichen Merkmale im Produkt unterbringen. Wir werden jetzt die Abweichung von INPUT-Varianten, die es bei den beiden erwähnten Interpretern gibt, betrachten.

Eine Eingabe mit definierter Länge bei GFA

Bei der Beschreibung des INPUTS-Befehls haben wir gesagt, daß die eingegebenen Zeichen nicht unmittelbar dargestellt werden. Das ist mit Sicherheit ein Manko, das diese Anweisung nicht sehr hilfreich macht. Der Entwickler von GFA-BASIC hat die Einschränkung dieser Befehle erkannt und etwas neues geschaffen, das wesentlich leistungsstärker ist.

Die FORM-INPUT-Anweisung ermöglicht die Eingabe einer Zeichenkette mit einer vordefinierten Länge, wobei die Zeichen direkt auf dem Bildschirm angezeigt werden. Ist die Länge erreicht, wird das Programm nicht fortgesetzt, sondern der Cursor bleibt stehen und das Programm wartet, bis ein RETURN eingegeben wird. Die Syntax entspricht ungefähr der des einfachen INPUT:

	FORM INPUT Laenge,VariablenameS

Betrachten wir jetzt anhand eines Beispiels, wie dieser Befehl funktioniert. Stellen Sie sich vor, Sie möchten eine Kartei mit den Namen, Adressen und Telefonnummern all Ihrer Freunde einrichten. Wegen des Speicherplatzes möchten Sie die verschiedenen Eingaben auf eine bestimmte Anzahl von Zeichen begrenzen. So werden zum Beispiel für das Feld „Nachname“ nur 20 Zeichen reserviert und für das Feld „Vorname“ nur zehn. Durch den Befehl INPUTS können Sie diese Angaben problemlos auf die gewünschte Länge begrenzen. Sie werden aber nicht sehen, ob Ihre Eingabe richtig ist oder nicht. Außerdem, wenn die Eingabe die definierte Länge erreicht hat, wird das Programm sofort fortfahren (siehe Listing 3a).

100 ' Beispiel INPUT USING in OMIKRON 
110 DIM Eingabe$(3)
120 CLS
130 BOX 20,20,600,300 
140 TEXT STYLE =1 
150 REPEAT 
160		READ Feld_N$
170		TEXT 40,50+Unter,Feld_N$
180		Unter=Unter+46.5
190		I=I+1
200 UNTIL I>=4
210 DATA "Name","Vorname","Adresse","Telefon"
220 Zeile=2 
230 FOR I=0 TO 3 
240		READ Steuer$,L_Ge
250 	INPUT @(Zeile,20);Eingabe$(I) USING 
		Steuer$,Tasten 
260		Zeile=Zeile+3
270 NEXT I
280 DATA "a+-+ ",10,"a+-+ ",10,"a0+ +-",20,
	"0-/+/+ ", 15

' Beispiel FORM INPUT in GFA

Dim Eingabe$(3)
Cls
Box 20,20,620,300 
Deftext 1,0,0,13 
Repeat
	Read Feld_n$
	Text 40,50+Unter,Feld_n$ 
	Unter=Unter+46.5 
	Inc I 
Until I=>4
Data Name,Vorname,Adresse,Telefon 
Zeile=3 
For I=0 To 3 
	Read Laenge 
	Print At(20,Zeile);
	Form Input Laenge,Eingabe$(I) 
	Zeile=Zeile+3 
Next I
Data 20,10,20,5

Mit der FORM INPUT von GFA sind all diese Einschränkungen behoben. Das kleine Programm FORM INPUT soll zeigen, wie man diesen Befehl benutzen kann. Erst wird ein Feld dimensioniert, das die Aufnahme von vier verschiedenen Zeichenketten ermöglicht (’DIM Eingabe$(3)’ nicht vergessen). Die Dimensionierung fängt mit Null an. Dann wird eine Box gezeichnet und der Titel jedes Feldes wird innerhalb dieser Umrandung dargestellt. Das Programm holt sich aus den DATA-Zeilen die verschiedenen Namen der Felder. Das geschieht alles in einer REPEAT...UNTIL-Schleife. Ist die Bedingung erfüllt (I= > 4), wird die Schleife verlassen und das Programm fährt fort.

Die zweite Struktur ermöglicht die Eingabe durch den Befehl FORM INPUT. Die Länge jeder Eingabe holt sich das Programm ebenfalls aus einer DATA-Anweisung. Mit PRINT AT (20,Zeile); wird der Cursor positioniert. Die Variable ZEILE wird bis zum Wert Drei inkrementiert, die den Abstand der verschiedenen Felder beinhaltet.

Eine Eingabe mit Format .on OMIKRON

Die OMIKRON-Entwickler haben sich einen anderen Leckerbissen ausgedacht. Sie erinnern sich wahrscheinlich an die Beschreibung des Befehls PRINT USING in der ersten Folge dieser Serie (Juni-Heft). Dieser Befehl dient dazu, eine formatierte Ausgabe darzustellen. Dazu benutzt BASIC verschiedene Steuerzeichen, die zu diesem Zweck vordefiniert sind. Der Befehl INPUT USING, der Bestandteil des Sprachumfanges von OMIKRON-BASIC ist, arbeitet sehr ähnlich - nur daß es sich hier nicht um eine Ausgabe, sondern um eine Eingabe handelt.

Der Befehl ist außerordentlich leistungsfähig, obwohl er von der Syntax her um einiges komplizierter ist als der einfache INPUT. Er wurde in erster Linie für kommerzielle Anwendungen gedacht.

Um die genauere Syntax zu erklären, werden wir jetzt das gleiche Beispiel verwenden wie eben bei dem FORM-INPUT-Befehl von GFA. Wenn Sie das Programm genau betrachten, werden Sie feststellen, daß die Unterschiede sehr gering sind. In Zeile 150 wird der Befehl INPUT USING so gesteuert, daß er ungefähr das gleiche tut wie das FORM INPUT von GFA. Die Steuerzeichenkette holt sich den Interpreter aus der DATA-Anweisung (siehe Listing 3).

Wo bleibt mein Schlüssel?

Sowohl GFA wie OMIKRON übermitteln eine Tastatureingabe in anderer Form. Der INKEY$-Befehl liefert immer die Information der zuletzt gedrückten Taste. Bei OMIKRON ist diese Information um einiges ausführlicher. Bei diesem BASIC-Interpreter wird immer in einem Vier-Byte-Paket der Zustand der SHIFT-Taste, der SCAN-Code und der ASCII-Code der gedrückten Taste geliefert.

Bei GFA wird prinzipiell nur der ASCII-Wert geliefert. Wird eine Sondertaste betätigt, so wird ein Zwei-Zeichen-String übergeben, wobei das zweite Zeichen den Code für die Sonder-Taste beinhaltet.

Die INKEY$-Anweisung unterbricht das Programm nicht. Wird keine Taste gedrückt, so wird ein leerer String zurückgeliefert. Genau deswegen wird dieser Befehl meist innerhalb einer Schleife verwendet. Der Befehl ist für die Eingabe von längeren Zeichenketten nicht sehr geeignet, aber für die Abfrage bestimmter Tasten fast ideal. Die Syntax ist sehr unkompliziert und für beide Interpreter-Versionen gleich:

Eingabe$ = INKEY$

oder

REPEAT
	EXIT IF EingabeS = ”X”
UNTIL...

Das nächste Beispiel soll die Funktion von INKEY$ in der Praxis zeigen (siehe Listing 4 für OMIKRON und 4a für GFA).

Der INKEY$-Befehl wird inerhalb einer DO...LOOP-Schleife (bei OMIKRON-BASIC in einem REPEAT UNTIL) benutzt und dadurch ständig abgefragt. Wurde keine Taste gedrückt, so bleibt das Programm in der Schleife. Beim Drücken einer Cursor-Taste wird das Programm in die Procedure ’Aus’ umgeleitet. Dort wird die Taste identifiziert. Das geschieht durch eine logische Verknüpfung und eine Vergleichsoperation. Bei so einer Vergleichsoperation in BASIC erhält man bei einer Wahr-Aussage eine -1 (TRUE) als Ergebnis zurück und bei einer falschen Aussage eine 0 (FALSE). Betrachten wir die folgenden Beispiele:

Das bedeutet, daß die erste Aussage nicht richtig ist (falsch), und daß es sich bei der zweiten um eine wahre Aussage handelt.

Das gleiche können wir mit Zeichenketten (Strings) wiederholen:

In unserem Beispiel wird der folgende Vergleich gemacht:

X= (A = 75)2 OR (A-77)-2

Wird zum Beispiel die Taste 'Pfeil nach links’ gedrückt, so ist die Aussage X = (A = 75) wahr und X wird eine -1 zugewiesen. Danach folgt die Multiplikation mit 2, so daß der Endwert von X eine -2 ist. Wurde nicht die Taste 'Pfeil nach links’ gedrückt, so wird zuerst überprüft, ob der 'Pfeil nach rechts’ betätigt wurde. Ist das auch nicht der Fall, dann werden die zwei anderen Richtungen kontrolliert. Wir benutzen diesen Vergleich, um einen Inkrementwert (XA = XA + X bzw. YA= YA + Y) zu gewinnen, der später für das Zeichnen eines Kreises (CIRCLE XA,YA) auf verschiedenen Stellen des Bildschirms verwendet wird.

Damit ist die zweite Folge beendet. Wir werden uns im nächsten Heft mit anderen Kapiteln der BASIC-Programmierung beschäftigen.

(HS/MM)

100 ' Beispiel INKEY in OMIKRON 
110 CLIP 0,0,639,399'
120 ' clip 0,0,319,199	' bei Farbe
130 CLS
140 REPEAT
150		A$= INKEY$
160		B$= RIGHTS(A$,1)
170 	IF B$<>"" THEN GOSUB Aus 
180 UNTIL B$="x"
190 END 
200 '
210 '
220-Aus
230 A$=MID$(A$,2,1)
240 A= ASC(A$)
250 X=(A=75)*2 OR(A=77)*-2 
260 Y=(A=72)*2 OR(A=80)*-2 
270 IF X<>0 OR Y<>0 THEN 
280 	Xa=Xa+X 
290 	Ya=Ya+Y 
300 	CIRCLE Xa,Ya,15 
310 ENDIF 
320 RETURN

' Beispiel INKEY in GFA 
'
Do
	A$=Inkey$
	If A$<>""
		Gosub Aus 
	Endif
	Exit If A$="x"
Loop
'
Procedure Aus
	A=Asc(Right$(A$))
	X=(A=75)*2 Or (A=77)*-2 
	Y=(A=72)*2 Or (A=80)*-2 
	If X<>0 Or Y<>0 
		Xa=Xa+X 
		Ya=Ya+Y
		Circle Xa,Ya,15 
	Endif 
Return