GEOS-InfoBase-Forum

Hallo Rainer und Alle

Auf JMGs Homepage lesen ich, dass R-Basic ähnlich KC85-Basic ist. Wie ähnlich? Kann man mit R-Basic z.b. auch Programme direkt für den KC85 schreiben? Ich besitze selbst seit den 90ern einen KC85/x. (Oder ist es Basicode kompatibel?)

Wer keinen KC85/x besitzt findet hier den Emulator KC85EMU V0.84. Dieser ist als DOS Software auch perfekt von PC/GEOS aus startbar (läuft auch unter WIN). Zudem gibts eine Menge KC85 KULT-Programme(!), viele Infos und eine Linkseite:
http://www.kc85emu.de/

Wer Software sucht, kann im KC-Club viel finden:
http://www.iee.et.tu-dresden.de/~kc-club/09/0900.HTML#FILES

Vielleicht lassen sich solche KC85-Basic Quelltexte als Ideen-Vorlage für R-Basic nutzen???
- BASIC-Spielprogramme
http://www.iee.et.tu-dresden.de/~kc-club/09/RUBRIK03.HTM
- Basic-Anwendungen
http://www.iee.et.tu-dresden.de/~kc-club/09/RUBRIK04.HTM
- Basicode-Programme
http://www.iee.et.tu-dresden.de/~kc-club/09/RUBRIK05.HTM

====================
Kurze Einführung in
KC85-Basic, Teil 1
====================

1. Einleitung

Basic ist eine sehr simple, dafür aber auch leicht erlernbare Programmiersprache. Im Gegensatz zu fast allen moderneren Sprachen ist Basic eine Interpretersprache. Das heißt, daß ein Programm, ein Programmteil oder auch nur ein einzelner Befehl jederzeit ausprobiert werden kann. Das Ergebnis kann sofort begutachtet werden.
So kann man Basic schon nach wenigen Minuten als Taschenrechner einsetzen, während andere Sprachen zuerst eine aufwendige Einarbeitung in Editor, Compiler und Entwicklungsumgebung voraussetzen.
Dadurch ist die Abarbeitungsgeschwindigkeit fertiger Basicprogramme aber auch nicht mit der von C- oder gar Assemblerprogrammen vergleichbar.

1.1 Befehlsmodus

Der einfachste Einstieg in den Umgang mit Basic ist der Befehlsmodus. Er ist bei fast jedem Homecomputer direkt nach dem Einschalten verfügbar. Sie tippen einen Befehl ein, drücken am Ende die Eingabetaste und schon wird der Befehl ausgeführt.
In der Praxis wird der Befehlsmodus hauptsächlich für zwei Aufgaben genutzt: Erstens können Programme vom Befehlsmodus aus von einem Speichergerät geladen bzw. auf einem Speichergerät abgelegt werden, zweitens ist der Befehlsmodus ein sehr schöner Taschenrechner.

1.1.1 Laden und speichern von Programmen

Der KC85 ist standardmäßig nur mit einer Schnittstelle für einen handelsüblichen Kassettenrekorder ausgestattet. Daher beziehen sich auch alle Lade- und Speicherbefehle auf dieses Gerät:

CLOAD
CLOAD "<programmname>"

CLOAD prüft bei den vom Datenrekorder abgespielten Programmen, ob eines mit dem richtigen Namen dabei ist und lädt dieses dann in den Arbeitsspeicher. Es kann dann bearbeitet oder einfach nur mit dem RUN-Befehl gestartet werden.

CSAVE
CSAVE "<programmname>"

CSAVE speichert das im Arbeitsspeicher befindliche Programm auf Kassette ab. Am Datenrekorder muß die Aufnahme bereits gestartet sein, wenn Sie den CSAVE-Befehl ausführen. Am Ende der Aufzeichnung fragt der Rechner "VERIFY?". Nun können Sie die Aufnahme anhalten. Falls die Aufnahme geprüft werden soll, geben Sie "Y" ein, spulen das Band zurück und drücken die EIngabetaste, sobald sie am Datenrekorder das Abspielen gestartet haben.

CSAVE*, CLOAD*
CSAVE* "<dateiname>";<feldname>
CLOAD* "<dateiname>";<feldname>

CSAVE* zeichnet Variablenfelder auf Band auf, die dann später mit CLOAD* wieder eingeladen werden können. Beide Befehle werden vorzugsweise in Programmen eingesetzt. Vor dem Aufruf von CLOAD* muß das zu ladende Feld mit dem DIM-Befehl in ausreichender Größe dimensioniert werden.

1.1.2 Basic als Taschenrechner

Wenn der Computer etwas ausrechnen soll, brauchen Sie nur ein Fragezeichen, gefolgt von einem Leerzeichen und der Rechenaufgabe einzutippen und danach die Eingabetaste zu drücken. Das Ergebnis erscheint sofort auf dem Bildschirm.
Sie tippen ein: ? (23-7)*3
Der Computer antwortet mit: 48

Sie sehen, daß in Basic die normale mathematische Notation funktioniert. Ein paar Besonderheiten sollten Sie aber wissen:
- Als Multiplikationszeichen wird der Stern (*) verwendet. - Für Divisionen geben Sie den Schrägstrich (/) an. - Falls Sie keine Klammern angeben gilt "Punkt vor Strich".
Basic beherrscht die meisten mathematischen Funktionen, die auch auf einem besseren Taschenrechner zu finden sind. Dazu aber mehr im Kapitel "Arithmetik".

1.1.3 Befehlsübersicht des Direktmodus

Der einfachste Einstieg in den Umgang mit Basic ist der Befehlsmodus. Er ist bei fast jedem Homecomputer direkt nach dem Einschalten verfügbar. Sie tippen einen Befehl ein, drücken am Ende die Eingabetaste und schon wird der Befehl ausgeführt.
In der Praxis wird der Befehlsmodus hauptsächlich für zwei Aufgaben genutzt: Erstens können Programme vom Befehlsmodus aus von einem Speichergerät geladen bzw. auf einem Speichergerät abgelegt werden, zweitens ist der Befehlsmodus ein sehr schöner Taschenrechner.

CLEAR

CLEAR löscht alle Variablen.

LINES
LINES <Zeilenzahl>

Mit dem LINES-Befehl wird die Anzahl der beim LIST-Befehl auf einmal ausgegebenen Zeilen begrenzt.

WIDTH
WIDTH <zeichenprozeile>

Mit WIDTH legen Sie fest, wieviele Zeichen beim LIST-Befehl in eine Zeile geschrieben werden. Dies ist insbesondere für die Formatierung der Ausgabe auf einem Drucker wichtig.


================
Weiter Teil 2
================

====================
Kurze Einführung in
KC85-Basic, Teil 2
====================

1.2 Programmieren

Der Befehlsmodus ist recht nützlich für einfache Rechenaufgaben - mit Basic-Programmierung hat seine Verwendung aber noch nichts zu tun.
Ein Programm ist eine Abfolge von Befehlen, die durch den Basicinterpreter abgearbeitet werden. Die Befehle stehen dabei in sogenannten Befehlszeilen, wobei jede Zeile normalerweise nur einen Befehl enthält. Die Reihenfolge, in der die Befehlszeilen abgearbeitet werden, wird durch Zeilennummern am Zeilenanfang bestimmt. Das Programm startet bei der kleinsten Zeilennummer und endet bei der größten. Die Nummern müssen nicht fortlaufend sein, es empfiehlt sich sogar, ein Programm zunächst z.B. in Zehnerschritten zu numerieren, um später Zeilen einfügen zu können.
Wenn Sie im Befehlsmodus eine Zeile mit einer Zeilennummer am Anfang eingeben, wird diese nicht sofort ausgeführt sondern gemäß ihrer Zeilennummer an der richtigen Stelle in das im Speicher befindliche Programm eingefügt. Ist der Speicher leer, wird das Programm mit der Eingabe der ersten Programmzeile angelegt.
Existiert bereits eine Zeile mit der Nummer der neu eingegebenen Zeile, so wird die alte kommentarlos durch die neue Zeile ersetzt. Die Eingabe einer Zeilennummer solo löscht eine bereits vorhandene Zeile mit dieser Nummer.
Für die Beispiele in diesem und den folgenden Kapiteln sollen drei einfache Basicbefehle schon an dieser Stelle vorgestellt werden. Sie werden in einem späteren Kapitel noch detailliert besprochen. Den ersten haben Sie schon kennengelernt: Das Fragezeichen im Direktmodus ist eigentlich die Abkürzung eines Basicbefehls, der ausgeschrieben "PRINT" heißt und für Bildschirmausgaben zuständig ist.
Eingaben des Benutzers kann ein Basicprogramm mit dem Befehl "INPUT" anfordern und der Befehl "LET" wird verwendet, um einer Variablen einen Wert zuzuweisen.
Am besten verstehen Sie diese drei Befehle anhand Ihres ersten Basicprogramms:
100 INPUT "GEBEN SIE EINE ZAHL EIN", A
110 LET B=A*A
120 PRINT "DAS QUADRAT VON "; A; " IST "; B

Die erste Zeile (Nummer 100) veranlasst den Computer, den Text "GEBEN SIE EINE ZAHL EIN" gefolgt von einem Fragezeichen und einem Eingabecursor auszugeben. Nun wartet der Computer auf die Eingabe einer Zahl. Diese wird dann in der Variablen "A" gespeichert.
In der zweiten Zeile (Nummer 110) wird einer neuen Variable "B" der Wert "A*A" zugewiesen. "B" enthält nun also den Wert von "A" im quadrat.
Die dritte Zeile schließlich gibt den Text "DAS QUADRAT VON ", den Wert der Variable "A", den Text " IST " und den Wert der Variable "B" nacheinander aus. Das Semikolon als Trennzeichen bewirkt, daß die Texte und Variableninhalte nahtlos aneinandergehängt werden.
Wenn Sie das Programm mit "RUN" ausführen, passiert auf dem Bildschirm zunächst folgendes:
GEBEN SIE EINE ZAHL EIN? _

Nun wartet der Computer auf Ihre Eingabe. Geben Sie nun z.B. eine 5 ein und drücken Sie dann die Eingabetaste. Folgendes steht nun auf dem Bildschirm:
GEBEN SIE EINE ZAHL EIN? 5
DAS QUADRAT VON 5 IST 25


1.3 Editieren eines Programms

Die Kleincomputer der KC-Serie haben einen Zeileneditor, bei dem Zeilen nur so lange bearbeitet werden können, wie der Cursor sie nicht verlassen hat. Sie können mit den Cursortasten auf/ab zwar jede auf dem Bildschirm sichtbare Zeile anfahren, an dieser Stelle aber nicht verändern.
Die soeben eingegebene Zeile hingegen können Sie problemlos mit den Cursortasten, der Löschtaste "DEL" oder der Einfügetaste "INS" bearbeiten.
Nachträglich kann eine Zeile auch noch bearbeitet werden. Dazu geben Sie im Direktmodus EDIT <Zeilennummer>
ein. Die angegebene Zeile wird angezeigt und kann wie oben beschrieben editiert werden.
Auf der Tastatur gibt es zwei Tasten, die sowohl beim Editieren als auch beim Programmablauf sehr wichtig sind: STOP hält jede Bildschirmausgabe an - so können Sie den LIST-Befehl daran hindern, das Programm schneller über den Bildschirm rollen zu lassen, als Sie mitlesen können aber auch ein laufendes Basicprogramm wird im Ablauf angehalten. Die Taste "Pfeil nach unten" setzt das Programm bzw. die Ausgabe des LIST-Befehls wieder fort. Die Taste "BRK" bricht den laufenden Vorgang ab. Sie kommen wieder in den Direktmodus zurück.
Eine weitere Besonderheit ist die Fähigkeit der KCs, mehrere Befehle in einer Zeile zu verarbeiten. Die Befehle müssen dazu durch Doppelpunkt getrennt werden. Eine Befehlszeile darf maximal 72 Zeichen lang werden, es ist aber übersichtlicher, Zeilen nur im Ausnahmefall länger als die in einer Bildschirmzeile verfügbaren 40 Zeichen werden zu lassen.
Folgende Befehle im Direktmodus unterstützen Sie bei der Programmierung

EDIT
EDIT <Zeilennummer>

Wie bereits oben angeführt, können Sie mit dem EDIT-Kommando die bereits vorhandene Basiczeile mit der angegebenen Zeilennummer erneut bearbeiten.
Haben Sie die Bearbeitung abgeschlossen, drücken Sie die Eingabetaste und die geänderte Zeile wird abgelegt. Gleichzeitig erscheint die Zeile mit der nächsthöheren Zeilennummer zur Bearbeitung auf dem Bildschirm. Um eine Zeile unverändert zu lassen - auch wenn Sie sie am Bildschirm bereits bearbeitet haben - verlassen Sie entweder die angezeigte Zeile mit der Pfeiltaste nach unten (womit die folgende Zeile angezeigt wird) oder Sie verlassen den EDIT-Modus mit der STOP-Taste. Letzteres bringt Sie zurück in den Direktmodus.

DELETE
DELETE <startzeile>[,<endzeile>]

Der DELETE-Befehl löscht einzelne Zeilen oder einen ganzen Zeilenbereich. Ersteres macht nicht viel Sinn, da Sie diese Aufgabe schneller und einfacher durch die schlichte Eingabe der zu löschenden Zeilennummer gefolgt von der Eingabetaste lösen können.
Interessanter ist die Möglichkeit, ganze Programmteile zu löschen. Dazu geben Sie hinter DELETE die Zeilennummer der ersten zu löschenden Zeile gefolgt von einem Komma und der Zeilennummer der letzten zu löschenden Zeile an. Diese beiden Zeilen und alle dazwischenliegenden werden daraufhin gelöscht.
Um das gesamte Programm zu löschen ist der Befehl "NEW" bequemer anzuwenden.

KEY

KEYLIST

AUTO
AUTO [<startzeile>[,<schrittweite>]]

AUTO unterstützt Sie beim Schreiben von Programmen, indem Zeilennummern vorgegeben werden. Nachdem Sie den AUTO-Befehl abgesetzt haben, erscheint die unter <startzeile> angegebene Zeilennummer auf dem Bildschirm und Sie können die gewünschte Basiczeile dahinter schreiben. Sobald Sie die Eingabetaste drücken, erscheint in der folgenden Zeile sofort die nächste, um die angegebene <schrittweite> erhöhte Zeilennummer. Ist keine Schrittweite angegeben, erhöht AUTO die Zeilennummern immer um 10. Fehlt zudem die Startzeilennummer, beginnt die automatische Numerierung bei 10.
Eine Besonderheit ergibt sich, wenn AUTO eine Zeilennummer vorgibt, die bereits mit einer Programmzeile belegt ist. Dann erscheint hinter der Zeilennummer ein Stern als Hinweis. Sie können nun den AUTO-Modus mit der STOP-Taste beenden, mit der Eingabetaste die Zeile komplett löschen oder durch Eingabe einesr Befehlszeile der Zeilennumer einen neuen Inhalt geben. Einen direkten Sprung in den EDIT-Modus für diese Zeile gibt es leider nicht.
Wenn Sie den AUTO-Modus verlassen möchten, können Sie das mit der STOP-Taste jederzeit tun. Es empfiehlt sich jedoch, die aktuell bearbeitete Zeile mit der Eingabetaste abzuschließen und erst dann die STOP-Taste zu drücken, da sonst die Eingaben der aktuellen Zeile verloren gehen.

RENUMBER
RENUMBER [<alt_von>[,<alt_bis>[,<neu_von>[,<neu_schritt>]]]]

RENUMBER numeriert ein Programm oder einen Teil davon neu durch. Dabei werden alle Verweise auf Zeilennummern im Programm (bei GOTO- oder THEN-Befehlen) automatisch an die neuen Nummern angepaßt.
Per Default beläßt RENUMBER nur die erste Zeile und numeriert das Programm ab dieser in Zehnerschritten komplett neu durch. Sie können aber auch festlegen, welcher Programmzeil (Zeilennummern <alt_von> bis <alt_bis>) neu numeriert werden soll und zwar mit welcher Startzeilennummer (<neu_von>) und mit welcher Schrittweite.
Beachten müssen Sie dabei, daß der neu numerierte Bereich mit seinen Nummern noch zu den vor- und nachstehenden Zeilennummern paßt. RENUMBER verschiebt keine Zeilen! Wenn die Nummern nicht mehr zusammenpassen, werden Sie das Programm vermutlich löschen oder gar den ganzen Rechner neu starten müssen.

================
Weiter Teil 3
================

====================
Kurze Einführung in
KC85-Basic, Teil 3
====================

2. Programmstruktur

Im letzten Kapitel wurde ausgeführt, daß ein Programm immer in der Reihenfolge aufsteigender Zeilennummern ausgeführt wird. Das trifft aber nur für sehr einfache Programme zu, die z.B. beim Start ein paar Informationen abfragen und daraus irgendetwas berechnen.
Die meisten Programme erfordern jedoch ein deutlich komplexeres Verhalten. Oft muß ein Programm aufgrund vorgegebener Bedingungen unterschiedlich reagieren, d.h. verschiedene Programmteile abarbeiten. Dies wird als "bedingte Verzweigung" bezeichnet.
Eine andere Form der Strukturierung sind Schleifen, also die mehrfache Abarbeitung eines Programmteils bis zur Erfüllung einer Bedingung.
Eine letzte Variante bei den Strukturbefehlen ermöglicht die Nutzung von Unterprogrammen. Diese können dann jederzeit und von mehreren Stellen des Hauptprogramms aus aufgerufen werden.
Doch eins nach dem anderen:

2.1 Verzweigungen

Im folgenden wird immer wieder von Bedingungen die Rede sein. Sie sollten daher wissen, wie eine Bedingung aussieht. Basic verfügt für Bedingungen über ein großes Repertoir an Vergleichsoperatoren:
> größer < kleiner = gleich >= größer oder gleich <= kleiner oder gleich <> ungleich
Diese funktionieren nicht nur mit Zahlen sondern auch mit Zeichenketten, wobei hier "größer" gleichbedeutend ist mit "steht weiter hinten im Lexikon".
Mehrere Vergleiche können mit den logischen Operatoren "AND", "OR" und "NOT" verknüpft werden. Die Hierarchie der Vergleiche wird im Bedarfsfall mit Klammern festgelegt.
Am besten verstehen Sie die Möglichkeiten auch hier mit Hilfe einiger Beispiele:
A>=5
...ist wahr, wenn der Wert der Variable A größer oder gleich 5 ist.
"Klaus"<"Peter"
...ist wahr, weil "Klaus" lexikalisch vor "Peter" kommt
( A>=5 AND A<=10 ) OR B=1
...ist wahr, wenn A zwischen 5 und 10 liegt oder B gleich 1 ist.
GOTO / GO TO
GOTO <Zeilennummer>

Die einfachste Verzweigungsanweisung ist der GOTO-Befehl. Wenn die Programmabarbeitung auf einen GOTO-Befehl stößt, wird das Programm in der angegebenen Zeile fortgesetzt, ohne wenn und aber.
Bei gutem Programmierstil sollte der Einsatz des GOTO-Befehls auf den Ausgleich der Defizite bei anderen Strukturbefehlen in einfachen Basicdialekten beschränkt bleiben (siehe die Beispiele bei IF / THEN und ON GOTO). Wildes Herumspringen im Programm macht es sehr unübersichtlich - dem Basicinterpreter macht das nichts aus, aber der Autor des Programms wird sich nach ein paar Wochen in seinem eigenen Werk nicht mehr zurechtfinden.

IF / THEN / ELSE
IF <Bedingung> THEN <Befehl> [: ELSE <Befehl>]
IF <Bedingung> THEN|GOTO <Zeilennummer>

Die bedingte Verzweigung IF / THEN führt einen Programmteil abhängig von einer Bedingung aus. Trifft die Bedingung zu, wird das Programm ab der hinter THEN oder GOTO angegebenen Zeilennummer fortgesetzt bzw der hinter THEN stehende Befehl ausgeführt, andernfalls läuft das Programm entweder in der nächsten Zeile also ganz normal) weiter oder - falls ELSE angegeben wurde - wird der hinter ELSE stehende Befehl ausgeführt.
Das folgende Programm berechnet die Quadratwurzel der eingegeben Zahl. Ist die Zahl kleiner als Null, erscheint eine Warnung und das Programm ermöglicht einen neuen Versuch, eine Zahl einzugeben:
100 INPUT "GEBEN SIE EINE POSITIVE ZAHL EIN", A
110 IF A>=0 THEN 140
120 PRINT "DIE ZAHL "; A; "IST NEGATIV!"
130 GOTO 100
140 PRINT "DIE WURZEL VON "; A; " IST "; SQR( A )


ON / GOTO
ON <Ausdruck> GOTO <Zeilennummer>[, <Zeilennummer][...]

Mit ON / GOTO können Sie eine Mehrfachverzweigung realisieren. Der Ausdruck wird ausgewertet. Ist das Ergebnis gleich eins, wird zur ersten Zeilennummer der Liste hinter dem GOTO-Befehl gesprungen. Ist das Ergebnis zwei, erfolgt der Sprung zur zweiten der in der Liste aufgeführten Zeilennummern und so weiter.
Das folgende Beispiel zeigt ein einfaches Menü. Sie treffen Ihre Auswahl durch Eingabe einer Nummer:
100 PRINT "WAS MÖCHTEN SIE BESTELLEN?"
110 PRINT "1. ETWAS ZU TRINKEN"
120 PRINT "2. EIN HAUPTGERICHT"
130 PRINT "3. EINEN NACHTISCH"
140 INPUT "GEBEN SIE EINE NUMMER EIN", A
150 ON A GOTO 200, 300, 400
200 PRINT "SIE BEKOMMEN EINE HALBE BIER"
210 GOTO 500
300 PRINT "SIE BEKOMMEN EINE SCHWEINSHAXE MIT SAUERKRAUT"
310 GOTO 500
400 PRINT "SIE BEKOMMEN NOCH EINE HALBE BIER"
500 PRINT "WOHL BEKOMM'S"


2.2 Schleifen


FOR / TO / NEXT
FOR <Variable>=<Ausdruck> TO <Ausdruck> [STEP <Ausdruck>]
...
NEXT <Variable>

Bei einer Schleife werden ein oder mehrere Befehle mehrfach ausgeführt. Diese Befehlsgruppe wird eingerahmt durch einen Schleifenbefehl am Anfang und einen am Ende. Bei der FOR/NEXT-Schleife handelt es sich um eine Zählschleife, d.h. bereits der Schleifenbefehl am Anfang legt die Zahl der Schleifendurchläufe fest. Dazu wird einer Variablen das Ergebnis eines Ausdrucks zugewiesen. Diese Variable wird dann mit jedem Durchlauf der Schleife um den hinter "STEP" angegeben Wert erhöht. Fehlt die Angabe von "STEP", wird um eins erhöht.
Die Schleife endet mit dem Erreichen des Wertes, der hinter "TO" angegeben ist.
Zwei Beispiele:
1. Der Computer soll die 7er-Reihe aufsagen:
100 FOR I=7 to 70 STEP 7
110 PRINT I
120 NEXT I

In der ersten Zeile wird der Variablen "I" zunächst der Wert 7 zugewiesen. Dieser wird in der zweiten Zeile dann auf dem Bildschirm ausgegeben. Die dritte Zeile veranlasst, daß "I" um die Schrittweite 7 erhöht wird und prüft, ob der Endwert 70 bereits erreicht ist. Da dem nicht so ist, wird die Schleife erneut durchlaufen und so der neue Wert von "I", also 14, ausgegeben. Das wird nun so fortgesetzt, bis "I" nach der Erhöhung um 7 den Wert 77 annimmt. Der Endwert 70 ist nun überschritten und die Schleife endet.
2. Der Computer soll das gesamte kleine Einmaleins anzeigen:
100 FOR A=1 TO 10
110 FOR B=1 TO 10
120 PRINT A*B;
130 NEXT B
140 PRINT
150 NEXT A

Jetzt wird klar, warum beim NEXT-Befehl nochmal der Variablenname steht: Er macht klar, welcher NEXT-Befehl zu welchem FOR-Befehl gehört.
Das Programm beginnt in Zeile 100 mit der Zuweisung des Werts 1 an die Variable "A". In Zeile 110 erhält "B" ebenfalls den Wert 1. Zeile 120 gibt nun den Wert von 1*1 auf dem Bildschirm aus. Das Semikolon am Zeilenende bewirkt, daß die nächste Ausgabe mit PRINT in der gleichen Zeile angehängt wird. In der folgenden Zeile (130) wird nun "B" um eins erhöht, mit dem Endwert 10 verglichen und das Programm in Zeile 120 fortgesetzt. Nun erscheint das Ergebnis von 1*2 auf dem Bildschirm. Dies wiederholt sich nun solange, bis die Schleife mit einem Wert von 10 in der Variable "B" durchlaufen wurde. Nun ist der Endwert erreicht und das Programm geht mit Zeile 140 weiter. Diese macht keine Ausgabe, sondern veranlaßt, daß der nächste PRINT-Befehl seine Ausgabe in einer neuen Bildschirmzeile beginnt. Nun wird in Zeile 150 der Wert von "A" um eins erhöht, mit dem Endwert für "A" verglichen und das Programm in Zeile 110 fortgesetzt. Dort erhält "B" wieder den Wert 1 und die innere Schleife (Zeilen 110 - 130) läuft wieder von 1 bis 10 und gibt dabei die Zeierreihe auf dem Bildschirm aus. Das Spiel wiederholt sich solange, bis auch "A" den Endwert erreicht hat und das geamte kleine Einmaleins auf dem Bildschirm steht.

================
Weiter Teil 4
================

====================
Kurze Einführung in
KC85-Basic, Teil 4
====================

2.3 Unterprogramme


GOSUB / RETURN
GOSUB <Zeilennummer>
RETURN

Der Befehl "GOSUB" springt zunächst genauso wie "GOTO" einfach zu der angegebenen Zeilennummer und setzt das Programm dort fort. Der Basicinterpreter merkt sich aber, welche Zeile auf die mit dem GOSUB-Befehl folgt. Falls das Programm nun auf einen "RETURN"-Befehl stößt, wird die Programmausführung in der gemerkten Zeile fortgesetzt.
Als Beispiel soll ein Unterprogramm dienen, das einen Text nacheinander zeichenweise auf den Bildschirm schreibt. Machen Sie sich nichts daraus, wenn Sie die folgenden Zeilen noch nicht ganz verstehen - es genügt für's erste zu wissen, daß sie den Inhalt der Stringvariablen "A$" zeichenweise auf den Bildschirm schreiben. Eine Stringvariable ist eine Variable, die Text enthalten kann.
1000 FOR I=1 TO LEN(A$)
1010 PRINT MID$(A$,I,1);
1020 NEXT I
1030 RETURN

Dieses Unterprogramm für sich auszuführen macht keinen Sinn: Erstens hat A$ noch keinen Inhalt, es wird also auch nichts auf den Bildschirm geschrieben. Zweitens würde der Basicinterpreter in Zeile 1030 auf den RETURN-Befehl stoßen, ohne daß er zuvor bei einem GOSUB vorbeigekommen wäre. Das Programm würde daher mit einer Fehlermeldung abbrechen.
Wir benötigen daher noch ein Hauptprogramm, das unser Unterprogramm nutzt. Es kann es nicht nur einmal, sondern beliebig oft und von verschiedenen Stellen aus aufrufen:
100 A$="ACHTUNG! ACHTUNG! HIER SPRICHT DEIN COMPUTER!"
110 GOSUB 1000
120 PRINT
130 A$="IN MEINEM SPEICHER HAT SICH EIN BIT VERKLEMMT."
140 GOSUB 1000
150 PRINT
160 A$="BITTE DREH MICH UM UND KLOPF MIR AUF DEN RUECKEN!"
170 GOSUB 1000
180 PRINT
190 END

Zeile 190 enthält einen weiteren neuen Befehl: END. Er führt dazu, daß das Programm an dieser Stelle beendet wird. Es gilt als ordentlicher Programmierstil, alle Unterprogramme am Ende des Programmes (d.h. bei den hohen Zeilennummern) unterzubringen. Das davorstehende Hauptprogramm endet dann mit dem END-Befehl, andernfalls wird zuletzt das erste Unterprogramm nach dem Hauptprogramm ausgeführt und der Basicinterpreter scheitert am RETURN-Befehl, der dieses Unterprogramm abschließt.
ON / GOSUB / RETURN
ON <Ausdruck> GOSUB <Zeilennummer>[, <Zeilennummer>][...]
...
RETURN

ON / GOSUB funktioniert genauso wie ON / GOTO, allerdings wird nicht einfach zu eine der in der Liste angegebenen Zeilennummern gesprungen, sondern an der angesprungenen Zeilennummer wird ein Unterprogramm erwartet, das dann irgendwann mit "RETURN" zu der auf den ON/GOTO-Befehl folgenden Zeile zurückkehrt.

2.4 Programmsteuerung


PAUSE
PAUSE [<dauer>]

PAUSE unterbricht die Programmabarbeitung für die angegebene Dauer. Die Angabe wird in Zehntelsekunden erwartet. Sie können bereits vor Ablauf der angegeben Zeitspanne das Programm mittels der CONT-Taste fortsetzen lassen.

STOP

STOP beendet die Programmausführung. Der Unterschied zum END-Befehl besteht darin, daß ein per STOP beendetes Programm durch Eingabe von CONT im Direktmodus in der Folgezeile fortgesetzt werden kann und daß beim Abbruch die Bildschirmmeldung "BREAK IN <zeilennummer>" erscheint.
Somit sollte die Anwendung des STOP-Befehls auf die Fehlersuche und den Test von Programmen beschränkt bleiben.
Die Vorgehensweise ist dabei ganz einfach: In jenem Programmteil, das den Fehler mutmaßlich verursacht streuen Sie an geeigneten Stellen STOP-Befehle ein. Immer wenn das Programm nun abbricht, können Sie im Direktmodus Variablenwerte abfragen und so prüfen, ob alle Variablen die erwarteten Inhalte haben. Wenn ja, setzen Sie das Programm bis zur nächsten STOP-Stelle fort (mit CONT). Wenn nein, wird sich der Fehler wahrscheinlich zwischen dem aktuellen und dem vorhergehenden STOP-Befehl eingeschlichen haben.

CLEAR
CLEAR [<größe>[,<endadresse>]]

CLEAR löscht den Variablenspeicher. Alle numerischen Variablen, Strings, Felder und Felddefinitionen verlieren dabei ihren Wert. Zudem wird der Lesezeiger für READ-Befehle wieder auf die erste DATA-Zeile gesetzt.
Darüber hinaus können Sie die Größe des Stringspeichers festlegen (der Standardwert ist 256 Zeichen) und den für Basic benutzten Speicherbereich einschränken. Letzteres kann sinnvoll sein, um Platz für Maschinenprogramme zu schaffen. Der Maximalwert für die Endadresse hängt vom Hauptspeicherausbau ab und errechnet sich nach Hauptspeichergröße in Bytes minus eins. Sollte dabei ein Wert größer 32768 herauskommen, müssen Sie aufgrund eines Fehlers im Basicinterpreter bei der Angabe 65536 abziehen, also eine negative Adresse angeben. Der Minimalwert der Endeadresse ist etwa 1200, falls der Basicinterpreter eingebaut ist bzw. in einem ROM-Modul steckt und etwa 11440, wenn er von Datenkassette geladen wurde.

================
Weiter Teil 5
================

====================
Kurze Einführung in
KC85-Basic, Teil 5
====================
3. Arithmetik und Variablen

3.1 Variablen

In den letzten Kapiteln war schon mehrfach von Variablen die Rede. Nun wollen wir sie etwas genauer betrachten.
Sie kennen Variablen aus der Mathematik als Platzhalter für Zahlen. Man kann mit Variablen ausdrücken, daß eine Formel gilt - unabhängig welche Zahlen man für die darin enthaltenen Variablen einsetzt.
In allen gängigen Programmiersprachen erfüllen Variablen die gleiche Funktion: Sie können stellvertretend für Zahlen angegeben werden. Man kann einer Variablen einen Wert zuweisen. Überall, wo diese Variable dann im Programm vorkommt, wird sie dann so behandelt als stünde da direkt der Wert dieser Variablen.
LET
[LET] <Variablenname>=<Ausdruck>

Mit dem LET-Befehl gibt man einer Variablen einen Wert. Hatte diese Variable zuvor bereits einen anderen Wert, so wird dieser überschrieben. Der LET-Befehl kann auch weggelassen werden.
A=5
weist also der Variablen A den Wert 5 zu.
Das folgende Beispiel berechnet mit Hilfe der Formel des Pythagoras die Länge der langen Seite (Hypotenuse) eines rechtwinkligen Dreiecks:
100 INPUT "LAENGE DER 1. KATHETE:", A
110 INPUT "LAENGE DER 2. KATHETE:", B
120 C = SQR( A*A + B*B )
130 PRINT "LAENGE DER HYPOTENUSE: "; C


3.2 Rechnen mit Zahlen

Ein Computer wäre kein Computer, könnte er nicht rechnen. Bisher haben Sie in den Programmbeispielen fast nur die Grundrechenarten sehen können. Basic kann aber noch mehr:
Operatoren

Als Operatoren bezeichnet man die normalen mathematischen Rechenzeichen. Neben den bereits vorgestellten "+" (Addition), "-" (Subtraktion), "*" (Multiplikation) und "/" (Division) kennt Basic noch Klammern zur Festlegung der Auswertungsreihenfolge eines Ausdrucks und das "^" als Exponentzeichen.
2*(4+1) ergibt 10
3^2 ergibt 9
5/2 ergibt 2.5

Am Ergebnis des letzten Beispiels sehen Sie, daß Basic auch mit nichtganzen Zahlen umgehen kann. Entgegen der in Deutschland gebräuchlichen Notation wird in Basic jedoch statt dem Komma ein Punkt verwendet.
INT()

INT() rundet auf die nächste ganze Zahl ab.
INT( 5.32 ) ergibt 5
INT( -2.3 ) ergibt -3


ABS()

ABS() bildet den Betrag.
ABS( 23 ) ergibt 23
ABS( -4 ) ergibt 4


SIN(), COS(), TAN()

SIN() errechnet den Sinus. Das Argument wird im Bogenmaß erwartet. Das gleiche gilt für den Cosinus COS() und den Tangens TAN().
SIN( 3.1415 / 2 ) ergibt 1


SGN()

SGN() liefert 1 bei positivem Argument, -1 bei negativem Argument und 0, falls das Argument gleich Null ist.
SGN( 0.3 ) ergibt 1
SGN( -1423 ) ergibt -1


SQR()

SQR() errechnet die Quadratwurzel.
SQR( 16 ) ergibt 4


LN(), EXP()

LN() bestimmt den natürlichen Logarithmus, EXP() die Exponentialfunktion (d.h. die Eulersche Zahl hoch dem Argument).
LN( 1 ) ergibt 0
EXP( 1 ) ergibt 2.7172...


DEF FN, FN
DEF FN<name>(<parameter>)=<ausdruck>
FN(<ausdruck>)

Sie können nicht nur mit den vorgefertigten Basicfunktionen arbeiten. Wenn eine Formel in einem Programm mehrfach benötigt wird, kann es nützlich sein, sie als Funktion zu definieren. Im Gegensatz zu anderen Programmiersprachen ist die Funktionsdefinition in Basic sehr eingeschrängt, sie darf nämlich nur eine einfache Formel enthalten. Programmierer höherer Programmiersprachen kennen Funktionen hingegen als Unterprogramme mit Rückgabewert.
Als Beispiel sei hier eine Sinusfunktion aufgeführt, deren Argument statt im Bogenmaß in Grad angegeben werden kann:
DEF FNSING(x)=SIN(x/PI*180)

Nun können Sie die neue Funktion mit vorangestelltem "FN" genauso nutzen, wie jede vorgefertigte Basicfunktion auch:
FNSING(90) ergibt 1
FNSING(270) ergibt -1


ATN()

Berechnet den Arkustankens. Das Ergebnis ist im Bogenmaß

RND()
RND(<Basiswert>)

RND() liefert Pseudozufallszahlen, die größer oder gleich Null und kleiner als eins sind. "Pseudo" deshalb, weil die Zahlen nicht ganz zufällig sind: Ist der Basiswert < 0, wird die Zufallszahl aus dem Basiswert berechnet - der gleiche Basiswert liefert also immer die gleiche Zufallszahl. Noch weniger einfallsreich zeigt sich RND(0): Hier ergibt sich immer die zuletzt ermittelte Zufallszahl als Ergebnis.
Am tauglichsten erscheint RND() bei positiven Basiswerten. Aber auch hier wird eine Zufallszahl immer aus der vorhergehenden berechnet und - was noch schwerer wiegt: Nach jedem Neustart des Basicinterpreters produziert RND wieder die exakt gleichen Zufallszahlen.
Glücklicherweise gibt es Abhilfe:

RANDOMIZE

RANDOMIZE initialisiert den Zufallszahlengenerator mit einem wirklich zufälligen Wert. Dadurch sind die Ergebnisse nachfolgender RND()-Aufrufe mit positivem Basiswert nicht mehr vorhersehbar. Ein Programm, das mit echten Zufallszahlen arbeiten möchte, sollte daher ganz am Anfang einmal einen Aufruf von RANDOMIZE enthalten.

FRE()

Die FRE-Funktion ermittelt den aktuell freien Arbeitsspeicher des Rechners. Das Argument wird dabei nicht ausgewertet, normalerweise gibt man daher FRE(0) an. Die Funktion wird wohl am häufigsten im Direktmodus verwendet:
? FRE(0)


PI

PI ist als Konstante fest definiert. Sie können daher PI wie eine Variable in Ausdrücken verwenden. Einen anderen Wert können Sie allerdings nicht dafür definieren.
100 INPUT "RADIUS : ", R
110 PRINT "UMFANG : U="; R*2*PI
120 PRINT "FLAECHE: A="; R^2*PI

================
Weiter Teil 6
================

====================
Kurze Einführung in
KC85-Basic, Teil 6
====================

3.3 Strings

Strings sind Zeichenketten, d.h. eine Abfolge von Buchstaben, Zahlen oder Sonderzeichen. Es gibt spezielle Variablen, die anstelle von Zahlen Strings als Wert annehmen können. Diese werden als Stringvariablen bezeichnet und durch ein Dollarzeichen am Ende des Variablennamens kenntlich gemacht.
Mit Strings kan man natürlich nicht im herkömmlichen Sinne rechnen. Zumindest die Addition ist jedoch definiert. Sie hängt die "Summanden" einfach aneinander.
A$="DIES IST "
B$="EIN BEISPIEL"
C$=A$+B$
PRINT C$

Der PRINT-Befehl schreibt den Wert der Stringvariablen C$ auf den Bildschirm. Es erscheint
DIES IST EIN BEISPIEL

Verschiedene Funktionen ermöglichen sehr interessante Anwendungen von Strings:

LEN()

LEN() ermittelt die Länge eines Strings
LEN( "HALLO" ) ergibt 5


LEFT$(), RIGHT$(), MID$()
LEFT$( <string>, <anzahl zeichen> )
RIGHT$( <string>, <anzahl zeichen> )
MID$( <string>, <ab zeichen nr>, <anzahl zeichen> )

Mit diesen Funktionen können Sie Teile von Strings ermitteln. LEFT$ liefert die angegebene Anzahl Zeichen vom Anfang des Strings, RIGHT$ ebenso aber vom Ende des Strings und mit MID$ können Sie die angegebene Anzahl von Zeichen ab einer bestimmten Position im String ausschneiden
LEFT$( "DONAUDAMPFSCHIFF", 5 ) ergibt DONAU
RIGHT$( "DONAUDAMPFSCHIFF", 6 ) ergibt SCHIFF
MID$( "DONAUDAMPFSCHIFF", 6, 5 ) ergibt DAMPF


ASC()

Jeder Buchstabe, jede Ziffer und jedes Sonderzeichen wird vom Computer intern als Zahl gespeichert. Welches Zeichen dabei welcher Zahl entspricht, ist in einem Code festgelegt. Etwa die Hälfte dieses Codes ist standardisiert und auf jedem Computer gleich. Dieser Code heißt "ASCII" (american standard code for information interchange).
Mit der ASC()-Funktion können Sie die Zahl ermitteln, die dem ersten Zeichen des angegebenen Strings zugeordnet ist.
ASC( "A" ) ergibt 65


CHR$()

Die umgekehrte Funktion zu ASC() stellt CHR$() dar. Die angegebene Zahl wird in das zugehörige Zeichen nach dem ASCII-Code umgewandelt.
CHR$( 65 ) ergibt 65

So können Sie sehr einfach ein Programm schreiben, das eine ASCII-Codetabelle auf den Bildschirm schreibt:
100 FOR I=0 TO 255 STEP 4
110 FOR J=0 TO 3
120 PRINT I+J; ":"; CHR$( I+J ); " ";
130 NEXT J
140 PRINT
150 NEXT I


VAL, STR$

VAL wandelt einen Zahlenstring in eine Zahl, STR$ tut genau das Gegenteil. Stößt VAL bei der Umwandlung des Strings auf ein Zeichen, das nicht zu einem Zahlenstring paßt, bricht die Wandlung ab.
Auch hier wird die Wirkungsweise wohl am ehesten durch einige Beispiele klar:
VAL( "12" ) ergibt die Zahl 12
VAL( "35.6" ) ergibt die Zahl 35,6
VAL( "23.07.1998" ) ergibt die Zahl 23,07 (eine Zahl kann nur ein Komma
enthalten) VAL( "7A12" ) ergibt die Zahl 7 (der Rest läßt sich nicht als Zahl lesen)

STR$( 14.5 ) ergibt den String "14.5"
STR$( 64 ) ergibt den String "64"



INSTR
INSTR( <string1>, <string2> )

Sucht <string1> in <string2>. Ist ersterer vollständig enthalten, gibt die Funktion INSTR die Position zurück, ab der <string1> in <string2> enthalten ist. Andernfalls liefert INSTR als Ergebnis die Null.
INSTR( "SCHIFF", "DONAUDAMPFSCHIFFFAHRT" ) ergibt 11
INSTR( "c", "abcdefg" ) ergibt 3
INSTR( "a", "bcdefgh" ) ergibt 0


STRING$
STRING$( <anzahl>, <string> )

STRING$ hängt den angegebenen String <anzahl> Mal hintereinander und gibt das Ergebnis zurück.
STRING$( 32, "-" ) ergibt eine Linie aus 32 Minuszeichen
STRING$( 3, "Bla " ) ergibt "Bla Bla Bla "


3.4 Felder

Oft ist es notwendig, viele gleichartige Informationen in Variablen abzulegen. Der einfachste Weg, dies zu tun ist die Verwendung von Feldvariablen. Einem Variablennamen kann dabei eine vorher festzulegende Anzahl verschiedener Werte zugewiesen werden. Dem Variablennamen wird dabei in eckigen Klammern ein Index mitgegeben, der die verschiedenen möglichen Werte mit Nummern versieht.
DIM
DIM <Variablenname>[<Anzahl Feldelemente>]

Wie gesagt, die Anzahl möglicher verschiedener Werte in einer Feldvariable muß zuvor festgelegt werden. Dazu dient der DIM-Befehl. Er muß im Programm ausgeführt werden, bevor die zugehörige Feldvariable erstmals benutzt wird.
100 DIM U[12]
110 FOR I=1 TO 12
120 PRINT "UMSATZ IM "; I; ". MONAT DES JAHRES:";
130 INPUT U
140 NEXT I
150 FOR I=1 TO 12
160 PRINT I,
170 FOR J=1 TO U[I]
180 PRINT "#";
190 NEXT J
200 PRINT
210 NEXT I

Das Beispielprogramm definiert in Zeile 100 eine Feldvariable mit 12 Elementen. In den Zeilen 110 bis 140 werden diese dann vom Anwender des Programms mit Werten gefüllt. Der Rest des Programms gibt die eingegebenen Werte dann als Balkendiagramm wieder aus.

3.5 Programminterne Daten

Oftmals werden in einem Programm Daten benötigt, die fest hinterlegt sein sollen, d.h. nicht jedes mal von Neuem abgefragt werden sollen. Basic bietet dafür einen einzigartigen Mechanismus: Beliebige Daten können, durch Komma getrennt, in sogenannten DATA-Zeilen abgelegt werden. Diese können an jeder beliebigen Stelle im Programm stehen. Stößt der Basicinterpreter bei der Programmabarbeitung auf eine DATA-Zeile, so wird diese ignoriert. Üblicherweise stellt man DATA-Zeilen jedoch ans Programmende.
Der Zugriff auf DATA-Zeilen erfolgt durch den READ-Befehl. Dieser ist in der Verwendung stark an den INPUT-Befehl angelehnt. Die Informationen werden jedoch nicht von der Tastatur eingelesen, sondern von vorn nach hinten aus den im Programm vorhandenen DATA-Zeilen. Dieser Vorgang bleibt im Gegensatz zum Einlesen von Daten per INPUT-Befehl auf dem Bildschirm unsichtbar.
Sollen Daten mehrfach gelesen oder selektiv auf bestimmte Datenbereiche zugegriffen werden, so können Sie per RESTORE-Befehl festlegen, ab welcher DATA-Zeilennummer folgende READ-Befehle ihre Daten lesen sollen.
Nochmals im Detail:

DATA
DATA <konstante>[,<konstante>][...]

Hinter dem Data-Befehl folgen eine oder mehrere Konstanten, wobei es sich dabei um Zahlen oder Zeichenketten handeln darf. Die Trennung erfolgt durch Kommas, Zeichenketten sollten in Anführungszeichen eingeschlossen werden.

READ
READ <variablenname>[,<variablenname>][...]

Die nächste Konstante oder (bei mehreren angegebenen Variablennamen) die nächsten Konstanten aus den DATA-Zeilen werden gelesen und als Wert(e) der/den angegebenen Variablen zugewiesen.
Ein Beispiel dürfte die Verwendung von Read und Data etwas anschaulicher machen. Es handelt sich dabei um eine abgewandelte Fassung des Balkendiagramm-Generators aus der Erklärung des DIM-Befehls:
100 DIM U[12]
110 FOR I=1 TO 12
130 READ U[I]
140 NEXT I
150 FOR I=1 TO 12
160 PRINT I,
170 FOR J=1 TO U[I]
180 PRINT "#";
190 NEXT J
200 PRINT
210 NEXT I
1000 DATA 5, 8, 9, 13, 12, 18, 20, 17, 11, 8, 1, 0


RESTORE
RESTORE [zeilennummer]

Als nächste per READ zu bearbeitende DATA-Zeile wird die mit der angegebenen Zeilennummer (oder die erste darauffolgende DATA-Zeile, falls die angegebene Zeilennummer keine DATA-Zeile enthält) festgelegt. Wird keine Zeilennummer angegeben, liest der nächste READ-Befehl wieder ab der ersten DATA-Zeile des Programms.
Zur Illustration soll hier nochmals eine Variante des Balkendiagramms dienen:
100 DIM U[12]
101 PRINT "DIE UMSATZZAHLEN DER FOLGENDEN JAHRE LIEGEN VOR:"
102 PRINT "[0] 1996, [1] 1997, [2] 1998"
103 INPUT "GEBEN SIE 0, 1 ODER 2 EIN:"; A
104 RESTORE 1000+A
105 READ J
106 PRINT "UMSATZZAHLEN DES JAHRES "; J; ":"
110 FOR I=1 TO 12
130 READ U[I]
140 NEXT I
150 FOR I=1 TO 12
160 PRINT I,
170 FOR J=1 TO U[I]
180 PRINT "#";
190 NEXT J
200 PRINT
210 NEXT I
1000 DATA 1996, 5, 8, 9, 13, 12, 18, 20, 17, 11, 8, 1, 0
1001 DATA 1997, 3, 7, 11, 17, 12, 16, 21, 22, 18, 11, 10, 9
1002 DATA 1998, 15, 18, 20, 22, 23, 21, 20, 17, 18, 16, 16, 15

================
Weiter Teil 7
================

================================
Kurze Einführung in KC85-Basic,
in Bezug auf den GDR Computer KC85/x,
Teil 7
================================

4. Ein- / Ausgabe

4.1 Textausgabe auf dem Bildschirm


PRINT
PRINT [<Ausdruck>[;|,[<Ausdruck>]][...]]

Der PRINT-Befehl ermöglicht die Ausgabe beliebiger Informationen auf den Bildschirm Als <Ausdruck> können Sie entweder Strings, Stringvariablen oder numerische Ausdrücke angeben, wobei letztere vor der Ausgabe ausgerechnet werden. Werden zwei Ausdrücke durch Semikolon getrennt, hängt sie der Printbefehl direkt aneinander. Ein Komma als Trennzeichen lässt eine Lücke. Komma oder Semikolon können auch am Ende des Printbefehls stehen, sie wirken sich darauf aus, wie die Ausgabe des nächsten Printbefehls angefügt wird.
Ein PRINT-Befehl alleine bewirkt einen Zeilenvorschub, d.h. der darauf folgende PRINT-Befehl beginnt mit der Ausgabe eine Zeile tiefer.
Es gibt noch einige weitere Möglichkeiten, die den PRINT-Befehl noch universeller machen:
Die Funktion TAB ermöglicht eine tabularische Ausgabe, indem sie die nächste horizontale Ausgabeposition auf die als Argument angegebene Spaltennummer setzt. Natürlich kann das nur funktionieren, wenn die nächste Ausgabeposition vor dem Aufruf von TAB noch links der angegebenen Spalte gewesen wäre.
100 PRINT "NAME";TAB(8);"PUNKTE"
110 PRINT "KLAUS";TAB(8);"15"
120 PRINT "SANDRA";TAB(8);"18"
130 PRINT "PAUL";TAB(8);"9"
140 PRINT "MARGARETHE";TAB(8);"10"

Das Beispielprogramm produziert folgende Ausgabe:
NAME PUNKTE
KLAUS 15
SANDRA 18
PAUL 9
MARGARETHE10

Die letzte Zeile zeigt, daß durch den langen Namen die Punktzahl bei Margarethe nicht mehr auf die Tabulatorposition 8 geschrieben werden kann.
Die SPC-Funktion fügt in der Printanweisung die angegebene Anzahl Leerzeichen ein:
100 PRINT " ";STRING$(28, "-")
110 FOR I=1 TO 18
120 PRINT "|";SPC(28);"|"
130 NEXT I
140 PRINT " ";STRING$(28, "-")

Dieses Beispiel zeichnet einen 30 Zeichen breiten und 20 Zeichen hohen Rahmen.

PRINT AT
PRINT AT(<zeile>,<spalte>);<ausdruck>[,[<ausdruck>]]...

Mit PRINT AT beginnt die Ausgabe an einer vorgegebenen Bildschirmposition. Ansonsten funktioniert PRINT AT genauso wie PRINT - allerdings sind mehrere Ausdrücke durch Komma zu trennen, das Semikolon ist hier nicht erlaubt.

POS
POS(0)

Die Funktion POS liefert die Spaltenposition, an der die nächste Ausgabe mit PRINT beginnen würde. Das Argument der POS-Funktion ist ohne Bedeutung und wird normalerweise auf 0 gesetzt.

CLS

Löscht den Bildschirm

WINDOW
WINDOW [<erstezeile>, <letztezeile>, <erstespalte>, <letztespalte>]

WINDOW schränkt den mit PRINT und INPUT nutzbaren Bildschirmbereich auf ein rechteckiges Fenster ein. WINDOW ohne Parameter hebt die Einschränkung wieder auf.
Der Bereich außerhalb des Fensters bleibt unverändert.

PAPER, INK, BORDER
PAPER <farbnummer>
INK <farbnummer>
BORDER <farbnummer>

Mit diesen Befehlen legen Sie die Hintergrund-, Text- bzw. Rahmenfarbe fest. Die Farbnummer muß in jedem Fall zwischen 1 und 8 liegen, wobei folgende Zuordnung gilt:
1 schwarz 3 grün 5 blau 7 blaugrün
2 rot 4 gelb 6 pink 8 weiß


PRINT mit Farbangabe
PRINT [INK <farbnummer>[,]][PAPER <farbnummer>][;AT(...)];...

Auch direkt bei einem PRINT-Befehl kann die Text- oder Hintergrundfarbe (oder beide) festgelegt werden. Diese gelten dann jedoch nur für diesen einen Befehl. Auch die Kombination mit PRINT AT ist machbar:
PRINT INK 2;AT(5,10);"*"

...schreibt in die 5. Zeile in der 10. Spalte ein rotes Sternchen.


================
Weiter Teil 8
================

================================
Kurze Einführung in KC85-Basic,
in Bezug auf den GDR Computer KC85/x,
Teil 7
================================

4.2 Eingaben über die Tastatur


INPUT
INPUT ["<Ausgabetext>",]<Variablenname>[,<Variablenname>][...]

Falls angegeben, schreibt der INPUT-Befehl zuerst den Ausgabetext auf den Bildschirm, gefolgt von einem Fragezeichen und dem Eingabecursor. Ohne Ausgabetext produziert INPUT nur ein Fragezeichen und den Cursor. Der Programmbenutzer muß nun die Werte für die angegebenen Variablen in der richtigen Reihenfolge eingeben.
Es ist eine gute Idee, mit jedem INPUT-Befehl nur eine Variable eingeben zu lassen. Das reduziert die Fehleranfälligkeit und gibt Ihnen die Möglichkeit, die Plausibilität jeder einzelnen Eingabe zu prüfen bevor die nächste erfolgt.

INKEY$

INKEY$ prüft, ob über die Tastatur ein Zeichen eingegeben wurde. Wenn ja, enthält INKEY$ dieses Zeichen, andernfalls einen Leerstring. Im Gegensatz zum INPUT-Befehl wartet INKEY$ nicht auf eine Tastatureingabe.
Mit INKEY$ können Sie auf auf Tastendrücke prüfen, denen kein Bildschirmzeichen zugeordnet ist - die Pfeiltasten z.B. oder ESC, DEL und die Eingabetaste. Die Abfrage erfolgt dann über den ASCII-Code:
100 IF ASC(INKEY$)<>13 THEN GOTO 100

Dieses Miniaturprogramm bewegt sich in einer Endlosschleife - Solange bis jemand die Eingabetaste (ASCII-Code 13) betätigt.
Das folgende Programm wartet auf Tastendrücke und zeigt die gedrückte Taste und ihren ASCII-Code:
100 A$=INKEY$
110 IF A$="" THEN GOTO 100
120 IF A$>=" " THEN PRINT A$; " = ";
130 PRINT ASC( A$ )
140 GOTO 100


4.3 Ansteuerung von Peripheriegeräten


4.3.1 Joystick


JOYST
JOYST( 1|2 )

Fragt die Richtung ab, in die der Joystick mit der angegebenen Nummer (1 oder 2) gerade gedrückt wird. Die Rückgabewerte sind folgendermaßen definiert:
9 8 10
\ | /
1--0--2
/ | \
5 4 6

Wird zudem die Feuertaste gedrückt, erhöht sich der Wert um 16.
Die einfachste Abfrageroutine für den Joystick funktioniert über eine bitweise Auswertung:
100 A=JOYST(1)
110 IF A=0 THEN GOTO 100
120 IF (A AND 1) = 1 THEN PRINT "LINKS ";
130 IF (A AND 2) = 2 THEN PRINT "RECHTS ";
140 IF (A AND 4) = 4 THEN PRINT "UNTEN ";
150 IF (A AND 8) = 8 THEN PRINT "OBEN ";
160 IF (A AND 16) = 16 THEN PRINT "FEUER";
170 PRINT
180 GOTO 100

Die Funktion des Joysticks kann auch die Tastatur wahrnehmen. Die Pfeiltasten und die ESC-Taste ermöglichen dies. Die Diagonalbewegungen des Joysticks können Sie durch den Druck von zwei Pfeiltasten gleichzeitig simulieren.
Während der Programmsteuerung mit dem Joystick sollte die Tastatur nicht benutzt werden. Sollte nach der Benutzung des Joysticks die Tastatur nicht mehr richtig funktionieren, drücken Sie entweder die "GRAPHIC"-Taste oder eine der Tasten 1 bis 8.

4.3.2 Drucker

Um einen Drucker am KC85 verwenden zu können, benötigen Sie ein Druckermodul.
Ausdrucke können Sie auf verschiedene Arten erzeugen: Im Direktmodus drücken Sie einfach CONTR und P gemeinsam und jede Bildschirmausgabe geht dann zusätzlich auch an den Drucker. Der gleiche Tastendruck beendet den Spuk wieder.
Eine Bildschirmhardcopy erzeugen Sie durch Druck auf CONTR zusammen mit N.
Beide Funktionen können Sie natürlich auch im Programmbetrieb aufrufen. Die Ausgabeumlenkung aktivieren und deaktivieren Sie mit PRINT CHR$(16) und die Hardcopy starten Sie mit PRINT CHR$(14).

4.4 Grafik

4.5 Tonerzeugung


BEEP

BEEP erzeugt einen kurzen Signalton.


================
Weiter Teil 9
================

================================
Kurze Einführung in KC85-Basic,
in Bezug auf den GDR Computer KC85/x,
Teil 7
================================

5. Fortgeschrittene Programmierung


5.1 Programme testen

Wenn ein Programm nicht so läuft, wie Sie es sich als sein Schöpfer eigentlich gedacht hatten, werden Sie sich sicher schnell etwas Unterstützung bei der Erziehung des mißratenen Sprößlings wünschen. Ein sehr wirksamer Weg ist die Verwendung von TRON und TROFF, die eine permanente Überwachung der Aktivitäten des laufenden Programms ermöglichen.

TRON, TROFF

TRON schaltet die Programmverfolgung ein, TROFF schaltet sie wieder aus. Bei aktiver Programmverfolgung wird die Zeilennummer jeder abgearbeiteter Programmzeile angezeigt. So sehen Sie, welche Wege der Interpreter in Ihrem Code einschlägt und finden so auch sicherlich heraus, an welcher Stelle das Programm aus dem Ruder läuft.
Nähere Analysen können Sie dann mit Hilfe des STOP-Befehls betreiben.

5.2 Manipulation von Speicherstellen

Die meisten Basicdialekte ermöglichen die Manipulation beliebiger Speicherstellen des Arbeitsspeichers. So auch das Basic des KC85. Während das Auslesen des Speicherinhalts noch recht ungefährlich ist, müssen Sie bei der Veränderung schon sehr genau wissen, was Sie tun.

POKE
POKE <adresse>,<wert>

POKE schreibt an der angegebenen Adresse den Wert (1 Byte) in den Arbeitsspeicher. Die Adresse muß im Bereich von -32768 bin 32767 liegen, wobei bei den negativen Werten im Geiste 65536 hinzugezählt werden muß.

DOKE
DOKE <adresse>,<wert>

Der "Doppel-POKE" schreibt einen 2-Byte-Wert an die angegebene Adresse und die darauf folgende.

PEEK
PEEK( <adresse> )

Die Funktion PEEK liefert den Inhalt der angegebenen Speicherstelle.

DEEK
DEEK( <adresse> )

DIe Funktion DEEK liefert den Inhalt der angegebenen und der darauf folgenden Speicherstelle als 2-Byte-Wert.

CALL, CALL*
CALL <adresse>
CALL* <hexadresse>

CALL ruft ein Maschinenspracheprogramm ab der angegebenen Adresse auf.

USR
USR( <parameter> )

Die USR-Funktion ist eine benutzerdefinierbare Maschinensprachefunktion. Um sie aufrufen zu können, müssen Sie jedoch zunächst festlegen, ab welcher Position im Arbeitsspeicher das aufzurufende Maschinenprogramm abgelegt ist. Dies machen Sie am besten mit einem DOKE-Befehl, und zwar beim RAM-Basic in Speicherstelle 11012 und beim ROM-Basic in Speicherstelle 772.
Der Parameter kann vom Maschinenprogramm ausgewertet werden.

OUT, INP, WAIT
OUT <adresse>,<wert>
INP( <adresse> )
WAIT <adresse>,<wert1>[,<wert2>]

OUT beschreibt die angegebene I/O-Adresse mit einem bestimmten Wert. Mit INP() können Sie den Wert einer I/O-Adresse auslesen und mit WAIT auf ein Ereignis an einem I/O-Port warten.
I/O-Adressen sprechen direkt bestimmte Funktionen auf den Ein-/Ausgabechips des Computers an. Eine wichtige I/O-Adresse ist z.B. 136. Dort ist bitweise codiert nicht nur die Farbe des Bildschirmrands hinterlegt, sondern auch die Einstellung der Zeilenzahl (20 oder 24 Zeilen), der Grafikmodus und die Aktivierung des Piepsers.

5.3 Programme als Quelltext speichern

Programme werden normalerweise in kodierter Form abgespeichert. Das ist keine Sicherheitsmaßnahme sondern ganz einfach die interne Darstellung des Programmtextes und mithin die schnellste und einfachste Methode, das Programm zu laden und zu speichern.
Falls Sie ein Basicprogramm auf ein anderes Rechnersystem übertragen wollen, sollte das Programm jedoch im Klartext vorliegen. Mit dem Befehl LIST# können Sie dies bewerkstelligen und mit LOAD# ein solches Programm auch wieder laden.

LIST#, LOAD#
LIST#<gerät>"<dateiname>"
LOAD#<gerät>"<dateiname>"

LIST# sendet das Programm im Arbeitsspeicher unter dem angegebenen Namen auf das angegebene Gerät. Als Gerät sind die Nummern 0 (Bildschirm) und 1 (Datenrekorder) zulässig.
LOAD# lädt ein mit LIST# gespeichertes Programm wieder ein.

NULL
NULL <anzahl>

Mit NULL legen Sie fest, wieviele Nullzeichen am Ende jeder Zeile bei der Ausgabe per LIST# angehängt werden sollen. Diese Nullzeichen sind beim Einlesen mit LOAD# wichtig, da hierbei jede Zeile einzeln in den Arbeitsspeicher geschrieben werden muß, was jedesmal einen winzigen Moment dauert. Falls in diesem Moment der Datenrekorder bereits mit dem Senden der nächsten Zeile beginnt, schlägt das Einladen des Programms fehl. Wenn genügend Nullzeichen vorhanden sind, reicht die Zeit bis zum Beginn der Übertragung der nächsten Zeile aus. Der optimale Wert für NULL muß experimentell ermittelt werden.


================
ENDE
================

Quellen:
http://www.homecomputermuseum.de/doku/man27_de.htm
http://www.homecomputermuseum.de/doku/man28_de.htm