?FED UP WITH BASIC ERROR IN 31720 |
[
Home |
Index |
Werbung |
|
Commodore Basic 2.0
(siehe auch Basic 3.5, Basic 4.0, Basic 7.0 und Simons' Basic)Das Commodore Basic V2.0, das u.a. im VC20 und Commodore 64 seinen Dienst tut, stammt ursprünglich von Microsoft, wie so viele Basic-Dialekte anderer Heimcomputer auch. Diese Basic-Variante ist sehr spartanisch, es gibt nur einen kleinen Grundstock an Befehlen, Unterstützung für Grafik- und Soundprogrammierung oder bequeme Diskettenoperationen fehlt komplett.
Gerade wegen dieses kleinen Befehlsumfangs bietet sich dieses Basic aber als Referenz für die Programmiersprache an, denn damit geschriebene Programme laufen, sofern nicht mit hardwareabhängigen Befehlen wie POKE gearbeitet wird, so ziemlich auf jedem Computer, der Basic versteht. Wer also Basic lernen möchte, kann durchaus mit dem Studium der Befehle auf dieser Seite anfangen, auch wenn er keinen Commodore-Computer hat.
Befehlsübersicht
|
ABS AND ASC ATN CHR$ CLOSE CLR CMD CONT COS DATA DEF FN DIM END EXP FN FOR ... TO ... STEP |
FRE GET GET# GOSUB GOTO IF ... THEN INPUT INPUT# INT LEFT$ LEN LET LIST LOAD LOG MID$ NEW |
NEXT NOT ON OPEN OR PEEK POKE POS PRINT# REM RESTORE RETURN RIGHT$ RND RUN SAVE |
SGN SIN SPC SQR ST STOP STR$ SYS TAB TAN TI TI$ USR VAL VERIFY WAIT |
ABS
| Typ: | numerische Funktion |
| Schablone: | ABS(<numerischer Ausdruck>) |
| Funktion: | Mit ABS wird der Absolutwert, also der Wert ohne Vorzeichen, einer Zahl ermittelt. Der Absolutwert einer negativen Zahl ist also die Zahl multipliziert mit -1. ABS kann sowohl auf Zahlen als auch auf komplexe numerische Ausdrücke angewendet werden. |
| Beispiele: |
10 PRINT ABS(-1) 20 IF ABS(N)=N THEN PRINT "POSITIVE ZAHL ODER NULL" |
AND
| Typ: | logischer Operator |
| Schablone: | <Ausdruck> AND <Ausdruck> |
| Funktion: |
AND wird in Booleschen Operationen zur Prüfung einzelner Bits und
zur Wahrheitsprüfung beider Operanden benutzt. In der Booleschen
Algebra ist das Ergebnis einer Verknüpfung mit AND nur dann 1
(=wahr), wenn beide beteiligten Zahlen 1 (=wahr) sind. Es gibt
bei einer AND-Operation mit jeweils 1 Bit insgesamt vier mögliche
Fälle:
0 AND 0 ergibt 0 0 AND 1 ergibt 0 1 AND 0 ergibt 0 1 AND 1 ergibt 1 Im Commodore-Basic dürfen AND-Operationen nur auf Ganzzahlen im Bereich von -32768 bis +32767 angewendet werden. Brüche dürfen nicht benutzt werden und Zahlen außerhalb des gültigen Bereichs erzeugen einen ?ILLEGAL QUANTITY ERROR. Wird AND im Vergleich (z.B. mit IF) benutzt, so ist das Ergebnis nur dann wahr, wenn beide Teilbedingungen auch wahr sind. Der Computer bewertet eine falsche Aussage mit 0 (alle Bits gelöscht), eine wahre mit -1 (was im Binärformat acht gesetzten Bits entspricht). |
| Beispiele: |
10 PRINT A AND B 20 N = (B AND 31) 30 IF A>0 AND B>0 THEN PRINT "A UND B SIND POSITIVE ZAHLEN" |
ASC
| Typ: | numerische Funktion |
| Schablone: | ASC(<Zeichenkette>) |
| Funktion: | Durch die Funktion ASC wird der ASCII-Wert eines Zeichens ermittelt. Das Ergebnis liegt immer im Zahlenbereich von 0 bis 255. Wird als Argument eine Zeichenkette angegeben, so ermittelt ASC den ASCII-Code des ersten Zeichens. Siehe auch die Umkehrfunktion CHR$. |
| Beispiele: |
10 PRINT ASC("A")
20 A=ASC(A$)
|
ATN
| Typ: | numerische Funktion |
| Schablone: | ATN(<numerischer Ausdruck>) |
| Funktion: | Diese Funktion gibt den Arcustangens der übergebenen Zahl zurück. Das Ergebnis ist der Winkel im Bogenmaß, dessen Tangens die gegebene Zahl ist. Das Ergebnis liegt immer im Bereich von -pi/2 bis +pi/2. |
| Beispiele: |
10 PRINT ATN(0) 20 PI=3.14:X=ATN(N)*180/PI |
CHR$
| Typ: | Zeichenkettenfunktion |
| Schablone: | CHR$(<numerischer Ausdruck>) |
| Funktion: | CHR$ ist die Umkehrfunktion zu ASC, es wird aus einem übergebenen ASCII-Code das entsprechende Zeichen erzeugt. Die übergebene Zahl muß im Bereich von 0 bis 255 liegen, andernfalls kommt es zu einem ?ILLEGAL QUANTITY ERROR. |
| Beispiele: |
10 PRINT CHR$(65) 20 A$=CHR$(13) 30 A=ASC(A$):A$=CHR$(A) |
CLOSE
| Typ: | Ein-/Ausgabeanweisung |
| Schablone: | CLOSE <logische Dateinummer> |
| Funktion: | Über diese Anweisung wird eine zuvor mit OPEN geöffnete Datei oder ein Gerätekanal geschlossen. Die Dateinummer muß dabei derjenigen beim Öffnen der Datei entsprechen. CLOSE muß auf jede zum Schreiben geöffnete Datei angewendet werden, andernfalls werden die Pufferinhalte nicht übertragen und die Datei ist unvollständig (im Falle von Disketten sogar unlesbar). |
| Beispiele: |
10 OPEN 1,8,1,"TEST,S,W" 20 PRINT#1,"SINNLOSER TEXT" 30 CLOSE 1 |
CLR
| Typ: | Anweisung |
| Schablone: | CLR |
| Funktion: | Mit der CLR-Anweisung werden sämtliche Variablen, Felder und Funktionen aus dem Speicher gelöscht, wodurch wieder Platz für neue Variablen etc. freigemacht wird. Basicprogramme bleiben unberührt, nach einem CLR ist aber kein CONT mehr möglich, weil auch die Stacks für Schleifen und Unterroutinen gelöscht werden. CLR schließt keine Dateien, vor dem Aufruf müssen offene Dateien also erst per CLOSE geschlossen werden. |
| Beispiel: |
10 X=666 20 CLR 30 PRINT X |
CMD
| Typ: | Ein-/Ausgabeanweisung |
| Schablone: | CMD <logische Dateinummer>[, Zeichenkette]) |
| Funktion: |
Mit CMD läßt sich die Datenausgabe vom Bildschirm auf eine beliebige
Datei umleiten. Diese Datei kann Diskette, Datasette, Drucker, Modem
oder anderen Geräten zugeordnet sein. Die logische Dateinummer wird
zuvor beim Öffnen der Datei mit OPEN festgelegt.
Wird bei CMD eine Zeichenkette übergeben, so wird diese in die
Datei geschickt. Nach Ausführung der CMD-Anweisung landen alle Ausgaben
wie z.B. PRINT oder LIST,
die sonst auf dem Bildschirm abgezeigt würden, als Text in der Datei.
Um die Umleitung zu deaktivieren, muß eine Leerzeile mit
PRINT# geschickt werden, bevor die Datei mit
CLOSE endgültig geschlossen wird. Tritt ein Fehler auf, wird die Ausgabe automatisch wieder auf den Bildschirm zurückgeleitet. Dadurch ist die Datei aber noch nicht geschlossen, weshalb auch in diesem Fall PRINT# und CLOSE ausgeführt werden müssen. |
| Beispiele: |
10 OPEN 1,8,1,"TEST,S,W" 20 CMD 1 30 FOR I=1 TO 1000 40 PRINT I 50 NEXT I 60 PRINT#1 70 CLOSE 1 10 OPEN 4,4 20 CMD 4,"TITELZEILE" 30 PRINT#4 40 CLOSE 4 |
CONT
| Typ: | Befehl |
| Schablone: | CONT |
| Funktion: |
Mit dem Befehl CONT läßt sich ein Programm, das durch die Anweisung
STOP oder END oder durch
Drücken der RUN/STOP-Taste abgebrochen wurde, weiterführen. Das
Programm wird genau an der Stelle fortgesetzt, an der die Unterbrechung
stattgefunden hat. Vor den Weiterführung des Programms durch CONT können Variableninhalte überprüft oder verändert werden. Änderungen des Programms sind nicht möglich, dies wird durch die Fehlermeldung ?CAN'T CONTINUE ERROR quittiert. Ein Programm läßt sich ebenfalls nicht fortführen, falls es durch einen Fehler abgebrochen wurde oder falls nach der Unterbrechung ein Fehler verursacht wurde. |
| Beispiele: |
10 PRINT "*"; 20 GOTO 10Wird diese Endlosschleife durch Druck auf RUN/STOP unterbrochen, läßt sie sich jederzeit durch Eingabe von CONT wieder weiterführen. 10 A=65:A$="DUMDIDUM" 20 STOP 30 PRINT A,A$Das Programm bricht in Zeile 20 ab, nach Eingabe von CONT werden die Inhalte der Variablen in Zeile 30 ausgegeben. |
COS
| Typ: | numerische Funktion |
| Schablone: | COS(<numerischer Ausdruck>) |
| Funktion: | Über diese mathematische Funktion wird der Kosinus einer Zahl berechnet, wobei diese Zahl als das Bogenmaß eines Winkels interpretiert wird. |
| Beispiele: |
10 PRINT COS(0) 20 PI=3.14:X=COS(Y*PI/180) |
DATA
| Typ: | Anweisung |
| Schablone: | DATA <Konstante>[,Konstante ...] |
| Funktion: |
Mit Hilfe der DATA-Anweisung werden Konstanten innerhalb eines Programms
gespeichert, die sich dann mit der READ-Anweisung
einer Variablen zuweisen lassen. Alle DATA-Anweisungen innerhalb eines
Programms werden als kontinuierliche Liste behandelt, die Daten werden
dabei von links nach rechts, von der Zeile mit der niedrigsten Zeilennummer
bis zu der mit der höchsten Zeilennummer gelesen. Da das Auslesen über
Variablen erfolgt, muß der Variablentyp mit dem aus der DATA-Zeile
gelesenen Datentyp übereinstimmen; der Versuch, einen String in eine
numerische Variable einzulesen, würde einen ?TYPE MISMATCH ERROR
erzeugen. DATA-Zeilen können beliebige Zeichen beinhalten, allerdings müssen viele Zeichen in Anführungszeichen eingeschlossen werden. Nur normale Buchstaben (ohne Shift) und Zahlen können direkt ohne Anführungszeichen eingegeben werden. |
| Beispiele: |
10 DATA 6,4,7,3,8 20 DATA UTE,SCHNUTE,KASIMIR 30 DATA "LEER- ODER SATZZEICHEN WIE :, MUESSEN IN ANFUEHRUNGZEICHEN STEHEN" |
DEF FN
| Typ: | Anweisung |
| Schablone: | DEF FN <Name>(<Variable>)=<Ausdruck> |
| Funktion: | Mit DEF FN wird eine Funktion definiert, die später im Programm aufgerufen werden kann. Diese Funktion kann aus einem beliebigen mathematischen Term bestehen. Auf diese Weise lassen sich längere Berechnungen, die an verschiedenen Stellen im Programm stehen würden, durch einen einfachen Funktionsaufruf ersetzen. Der Funktionsname setzt sich aus den Buchstaben FN gefolgt von einem beliebigen Variablennamen (ein oder zwei Zeichen) zusammen. In den Klammern wird der im Term zu verarbeitende Wert übergeben. |
| Beispiele: |
10 DEF FNWU(X)=SQR(X) 20 Y=FNWU(9) 30 DEF FNR(N)=INT(RND(1)*N+1) 40 PRINT "DIE LOTTOZAHL LAUTET: ";FNR(49) |
DIM
| Typ: | Anweisung |
| Schablone: | DIM <Variable>(<Index>)[,<Variable>(<Index>) ...] |
| Funktion: |
Mit DIM läßt sich ein Variablenarray definieren. Ein Array ist eine indizierte
Variable, über deren Index man auf die einzelnen Felder zugreifen kann. Der
einfachste Fall für ein Array ist eine eindimensionale Liste mit n Feldern,
es lassen sich aber auch zwei-, drei- und mehrdimensionale Arrays erzeugen.
Die Anzahl der Dimensionen und deren Feldanzahl wird durch die Indexangabe in
den Klammern bestimmt. Eine eindimensionale Liste würde z.B. mit DIM A(20)
definiert, eine zweidimensionales Array mit DIM B(10,10), dreidimensional
wäre der Aufruf DIM C(5,5,5) usw. usf. Ein Array kann theoretisch
255 verschiedene Indizes enthalten, durch die Beschränkung der Zeilenlänge
und den hohen Speicherbedarf ist dies aber unrealistisch. Jede Variable kann indiziert
werden, egal ob Ganzzahl- (%), Fließkomma- oder Stringvariable ($). Der niedrigste mögliche Index eines Feldes ist Null, der höchste Index entspricht der in der DIM-Anweisung angegebenen Zahl (maximal 32767). Die DIM-Anweisung muß vor dem ersten Zugriff auf die indizierte Variable einmal ausgeführt werden (andernfalls erscheint ein ?BAD SUBSCRIPT ERROR). Ausnahmen bilden hierbei nur eindimensionale Felder mit einem maximalen Index von 11, auf diese kann auch ohne vorheriges DIM zugegriffen werden - dann wird allerdings auch der maximale Index von 11 reserviert, ob dies nun benötigt wird oder nicht. Die DIM-Anweisung darf für ein Array nur jeweils einmal ausgeführt werden, ansonsten meldet der Computer einen ?REDIM'D ARRAY ERROR. Falls ein Array also neu definiert werden soll, muß vorher ein CLR ausgeführt werden (was allerdings alle Variablen löscht). |
| Beispiele: |
10 DIM X(99) 20 DIM A(7,4),A$(23),ZZ(99,2,3),I%(47) |
END
| Typ: | Anweisung |
| Schablone: | END |
| Funktion: | Mit END wird die Programmausführung beendet und in den Direktmodus zurückgekehrt. Ein Programm kann beliebig viele dieser Anweisungen enthalten. Das Einfügen von END-Anweisungen in Programme ist nicht unbedingt nötig, kann aber zur Programmkontrolle und Fehlersuche hilfreich sein (nach einem END behalten alle Variablen ihre Werte). Mit der CONT-Anweisung läßt sich ein durch END gestopptes Programm weiterführen. Die Funktion von END entspricht der der STOP-Anweisung, mit dem Unterschied, daß bei einem Abbruch durch END nicht die aktuelle Zeile angegeben wird. |
| Beispiele: |
10 INPUT "PROGRAMM ABBRECHEN";A$ 20 IF A$="J" THEN END 30 PRINT "REST DES PROGRAMMS" 40 END |
EXP
| Typ: | numerische Funktion |
| Schablone: | EXP(<numerischer Ausdruck>) |
| Funktion: | Über diese mathematische Funktion wird die Konstante e (2.71828183) in die Potenz des angegebenen Wertes erhoben. Der maximal zulässige Wert beträgt 88.0296919, höhere Werte erzeugen einen ?OVERFLOW ERROR. |
| Beispiele: |
10 PRINT EXP(1) 20 X=A*EXP(B)+C |
FN
| Typ: | numerische Funktion |
| Schablone: | FN <Name>(<Zahl>) |
| Funktion: | Diese Funktion verweist auf die zuvor mit der DEF-Anweisung definierte Funktion. Die übergebene Zahl wird in den definierten Term eingesetzt und das Ergebnis zurückgeliefert (stets numerisch!). Ein Aufruf von FN ohne vorige Definition der Funktion führt zu einem ?UNDEF'D FUNCTION ERROR. |
| Beispiele: | siehe DEF FN |
FOR ... TO ... [STEP]
| Typ: | Anweisung |
| Schablone: | FOR <Variable>=<Startwert> TO <Endwert> [STEP <Schrittweite>] |
| Funktion: |
Mit der FOR-Anweisung lassen sich Schleifen programmieren, die eine
Variable als Zähler benutzen. Die angegebene Variable wird dabei vom
Startwert bis zum Endwert mit der definierten Schrittweite erhöht
(bei negativer Schrittweite entsprechend vermindert),
die zwischen FOR und NEXT liegenden Anweisungen werden
so oft ausgeführt, bis der Variablenwert gleich dem Endwert ist (oder
ihn überschritten hat).
Alle Werte können beliebige Fließkommazahlen sein. Wird keine
Schrittweite angegeben, wird die Variable pro Durchlauf um 1 erhöht.
Die FOR-Schleife wird immer mindestens einmal durchlaufen. Innerhalb einer FOR-Schleife dürfen beliebige Anweisungen untergebracht werden, auch andere FOR-Schleifen. In diesem Fall ist aber darauf zu achten, daß sich die Schleifen nicht überlappen, sondern ineinander verschachtelt sind. Sprünge mit GOTO (z.B. zum Verlassen der Schleife) sollte man innerhalb von FOR-NEXT vermeiden. |
| Beispiele: |
10 FOR I=1 TO 1000 20 PRINT I 30 NEXT I 10 FOR X=-5 TO 5 STEP .1:PRINT X:NEXT 20 FOR T=10 TO -10 STEP -1:PRINT T:NEXT T 10 FOR S=0 TO 65535 20 PRINT "SPEICHERSTELLE ";S;": "; 30 PRINT PEEK(S) 40 NEXT S |
FRE
| Typ: | Funktion |
| Schablone: | FRE(<numerischer Ausdruck>) |
| Funktion: | Mit FRE wird der noch zur Verfügung stehende Speicherplatz für Programm und Variablen ermittelt. Der in Klammern übergebene Wert ist völlig beliebig und hat auf das Ergebnis keinen Einfluß. Falls die FRE-Funktion einen negativen Wert liefert, so muß zu diesem 65536 addiert werden (siehe Beispielzeile 20). |
| Beispiele: |
10 PRINT FRE(1) 20 X=FRE(0)-(FRE(0)<0)*65536 |
GET
| Typ: | Eingabeanweisung |
| Schablone: | GET <Variable>[,Variable ...] |
| Funktion: |
Über die GET-Anweisung wird ein einzelnes Zeichen vom Tastaturpuffer eingelesen.
Im Tastaturpuffer werden die letzten 10 vom Benutzer gedrückten Tasten gespeichert,
ist der Puffer voll, werden keine weiteren Zeichen berücksichtigt. GET liest das
erste vorliegende Zeichen aus dem Tastaturpuffer aus und schafft so wieder Platz
für ein neues. Ist der Tastaturpuffer leer, liefert GET einen Leerstring. Mit GET lassen sich sowohl String- als auch numerische Variablen zuweisen. Falls eine numerische Variable benutzt und ein anderes Zeichen als eine Zahl eingelesen wird, kommt es zu einem ?TYPE MISMATCH ERROR. Daher sollte man immer in eine Stringvariable einlesen und ggfs. später mit VAL die Umwandlung in eine Zahl vornehmen. |
| Beispiele: |
10 GET A$:IF A$="" THEN 10 20 GET A$,B$,C$,D$,E$ 30 GET N,Z$Anmerkung: In Zeile 10 stehen die "klassischen" Befehle zum Anhalten des Programms, bis eine Taste gedrückt wurde. Etwas eleganter geht dies beim C64 z.B. so: 10 POKE 198,0:WAIT 198,1 |
GET#
| Typ: | Eingabeanweisung |
| Schablone: | GET#<logische Dateinummer>,<Variable>[,Variable ...] |
| Funktion: |
GET# übergibt ein einzelnes Zeichen aus einer Datei oder von einem Gerät
in eine Variable. Werden mehrere Variablen angegeben, so wird jeder dieser
Variablen genau ein Zeichen zugewiesen. Wird kein Zeichen empfangen, enthält
die Variable einen Leerstring. Um mit GET# überhaupt etwas einlesen zu können,
muß natürlich vorher eine entsprechende Datei oder ein Gerät mit
OPEN und der angegebenen logischen Dateinummer zum Lesen
geöffnet werden. Wie bei GET gilt auch bei GET#, daß tunlichst immer in eine Stringvariable eingelesen werden sollte, bei einer Zuweisung in eine numerische Variable kommt es zum ?TYPE MISMATCH ERROR, falls das empfangene Zeichen keine Zahl ist. |
| Beispiele: |
10 OPEN 1,8,2,"DATEI,S,R":GET#1,A$:CLOSE 1 20 OPEN 3,3:GET#1,A$,B$,C$,D$:CLOSE 1 |
GOSUB
| Typ: | Anweisung |
| Schablone: | GOSUB <Zeilennummer> |
| Funktion: |
Mit GOSUB wird ein Unterprogramm, das bei der angegebenen Zeilennummer
anfängt, aufgerufen. Der Computer speichert die Position, von wo aus
zum Unterprogramm gesprungen wurde im Stack und setzt nach einer
RETURN-Anweisung das Hauptprogramm dort mit der
nächsten auf GOSUB folgenden Anweisung fort. Da der Speicherplatz des
Stacks auf 256 Bytes begrenzt ist, sollte unbedingt jeder Sprung mit
GOSUB durch ein RETURN abgeschlossen werden, andernfalls kann es zu
einem ?OUT OF MEMORY ERROR kommen (auch wenn noch viele KBytes
Speicher frei sind!). |
| Beispiel: |
10 PRINT "DIESES PROGRAMM MACHT NACH JEDER ZEILE" 20 GOSUB 100 30 PRINT "EINE KLEINE PAUSE." 40 GOSUB 100 50 PRINT "DIES IST SO, WEIL IM UNTERPROGRAMM EINE" 60 GOSUB 100 70 PRINT "KLEINE WARTESCHLEIFE ABGEARBEITET WIRD." 80 GOSUB 100 90 END 100 FOR P=1 TO 1000:NEXT P 110 RETURN |
GOTO
| Typ: | Anweisung |
| Schablone: | GOTO <Zeilennummer> GO TO <Zeilennummer> |
| Funktion: | Mit GOTO wird der Computer angewiesen, das Programm mit der genannten Zeile fortzuführen. Normalerweise werden alle Zeilen in ihrer numerischen Folge ausgeführt, mit GOTO kann man diese Reihenfolge unterbrechen und direkt zu einer gewünschten Zeile springen. Wird bei GOTO keine Zeilennummer angegeben, interpretiert der Computer diese Anweisung als GOTO 0. GOTO kann sowohl im Programm als auch im Direktmodus benutzt werden. |
| Beispiele: |
10 GOTO 10:REM ENDLOSSCHLEIFE! 20 GOTO 63999 |
IF ... THEN ...
| Typ: | Anweisung |
| Schablone: | IF <Ausdruck> THEN <Zeilennummer> IF <Ausdruck> GOTO <Zeilennummer> IF <Ausdruck> THEN <Anweisungen> |
| Funktion: |
Durch IF-THEN ist Basic in der Lage, Entscheidungen zu treffen. Dem Schlüsselwort
IF folgt ein beliebiger Ausdruck, der Variablen, Zeichenketten, Zahlen, Vergleiche
und logische Operatoren (siehe AND, OR und
NOT) enthalten kann. Ist das Ergebnis des verwendeten Ausdrucks
wahr, dann werden die nach THEN in der Zeile folgenden Befehle ausgeführt
(bzw. es wird zu der angegebenen Zeile gesprungen). Ist das Ergebnis falsch,
dann wird der Rest der Zeile hinter THEN ignoriert und das Programm mit der
nächsten Zeile fortgesetzt. |
| Beispiele: |
10 INPUT "GIB EINE POSITIVE ZAHL EIN";N
20 IF N<=0 THEN 50
30 PRINT "DIE WURZEL AUS";N;"ist:";SQR(N)
40 GOTO 10
50 PRINT N;"IST KEINE POSITIVE ZAHL!"
60 GOTO 10
10 INPUT "LOGIN";PW$
20 IF PW$="JOSHUA" GOTO 50
30 PRINT "ACCESS DENIED"
40 GOTO 10
50 PRINT "GREETINGS PROFESSOR FALKEN"
60 PRINT "SHALL WE PLAY A GAME?"
10 INPUT "ZWEI ZAHLEN (A,B)";A,B
20 IF A<B THEN PRINT "A IST KLEINER ALS B":END
30 IF A=B THEN PRINT "A UND B SIND GLEICH":END
40 IF A>B THEN PRINT "A IST GROESSER ALS B":END
50 PRINT "GRATULIERE, DU HAST EINE UNMOEGLICHE VARIANTE GEFUNDEN! :-)"
|
INPUT
| Typ: | Eingabeanweisung |
| Schablone: | INPUT ["<Kommentar>";] <Variablenliste> |
| Funktion: |
Über die INPUT-Anweisung können dem Programm durch den Benutzer Daten
übergeben werden. Wenn der Befehl ausgeführt wird, erscheint erst der
Kommentar (falls einer angegeben wurde), dann ein Fragezeichen und schließlich
rechts davon der blinkende Cursor, der dem Benutzer die Eingabebereitschaft
signalisiert. Es können nun beliebige Zeichen * eingegeben werden,
die nach dem Druck auf RETURN in die angegebene(n) Variable(n) übernommen
wird/werden. Falls mehrere Variablen benutzt werden, müssen auch entsprechend
viele Werte, jeweils durch Kommata getrennt oder durch RETURN einzeln bestätigt
**, eingegeben werden. * Natürlich müssen die Zeichen auch zum Variablentyp passen. Gibt man z.B. Buchstaben ein, wenn ein Zahlenwert erwartet wird, quittiert der Computer dies durch ?REDO FROM START und erwartet eine Neueingabe. Auch bei Zeichenketten gibt es Einschränkungen, Kommata z.B. werden als Trennzeichen interpretiert (und durch die Meldung ?EXTRA IGNORED quittiert). ** Wenn weniger Werte als erwartet eingegeben werden, fordert der Rechner durch zwei Fragezeichen (??) zur weiteren Eingabe auf. Dies geschieht so lange, bis jeder Variablen ein Wert zugewiesen wurde. |
| Beispiele: |
10 INPUT A 20 INPUT B,C 30 INPUT "WIE ALT BIST DU";X 40 INPUT "WIE HEISST DU";X$ 50 INPUT "DEIN ALTER UND DEIN NAME";N,N$ |
INPUT#
| Typ: | Eingabeanweisung |
| Schablone: | INPUT# <logische Filenummer>,<Variablenliste> |
| Funktion: | Über INPUT# lassen sich schnell Zeichenketten aus einer Datei von Diskette oder Band einlesen (oder auch von der Tastatur, je nach Gerätenummer). Im Gegensatz zu GET#, womit nur jeweils ein Zeichen empfangen werden kann, erlaubt INPUT# das Einlesen von bis zu 80 Zeichen auf einmal. Die Zeichen CR (CHR$(13)), Komma (,), Semikolon (;) und Doppelpunkt (:) werden dabei als Trennzeichen interpretiert. Wird eine numerische Variable erwartet, aber eine Zeichenkette ausgelesen, quittiert der Rechner dies durch die Fehlermeldung ?BAD DATA. Wird die maximale Zeichenzahl von 80 überschritten, beschwert sich der Rechner mit ?STRING TOO LONG. |
| Beispiele: |
10 OPEN 3,8,3,"0:DATEI,S,R" 20 INPUT#3,A$ 30 CLOSE 3 10 OPEN 15,8,15 20 INPUT#15,EN,ER$,TR,SE 30 PRINT "FLOPPYSTATUS: ";EN;ER$;TR;SE 40 CLOSE 15 |
INT
| Typ: | numerische Funktion |
| Schablone: | INT(<numerischer Ausdruck>) |
| Funktion: | Mit dieser Funktion wird der ganzzahlige Wert eines Ausdrucks ermittelt, der Nachkommateil wird also abgeschnitten. INT rundet dabei nicht, sondern "vergißt" die Nachkommastellen einfach. Trotzdem läßt sich mit INT auch prima runden, siehe das erste Beispiel. |
| Beispiele: |
10 INPUT "KOMMAZAHL";A 20 PRINT "GERUNDET: ";INT(A+0.5) 10 PRINT INT(3.1415) 20 PRINT INT(10/3) 30 Z=INT(RND(1)*6)+1 |
LEFT$
| Typ: | Stringfunktion |
| Schablone: | LEFT$(<Zeichenkette>,<Zeichenzahl>) |
| Funktion: | Mit LEFT$ läßt sich der linke Teil einer Zeichenkette extrahieren (siehe auch MID$ und RIGHT$). Das Ergebnis der Funktion ist eine Teilzeichenkette, die beginnend vom ersten Zeichen der übergebenen Zeichenkette so viele Zeichen wie angegeben enthält. Ist die Ursprungszeichenkette leer, wird als Ergebnis ein Leerstring übergeben, enthält die Zeichenkette die angegebene Zeichenzahl oder weniger, ist das Ergebnis identisch mit der Vorgabe (es wird also der komplette String übergeben). |
| Beispiele: |
10 PRINT LEFT$("8-BIT-NIRVANA",5)
10 A$="COMMODORE BASIC"
20 B$=LEFT$(A$,9)
30 PRINT B$
|
LEN
| Typ: | Ganzzahlfunktion |
| Schablone: | LEN(<Zeichenkette>) |
| Funktion: | Gibt die Anzahl der in der angegebenen Zeichenkette enthaltenen Zeichen an. Dabei werden alle Zeichen gezählt, auch Leer- und Steuerzeichen. |
| Beispiele: |
10 PRINT LEN("COMMODORE 64")
20 A$="8-BIT-NIRVANA":L=LEN(A$)
30 B$=" RULEZ!":PRINT LEN(A$+B$)
10 INPUT "HMPF";A$
20 PRINT "Die eingegebene Zeichenkette ";CHR$(34);A$;CHR$(34)
30 PRINT "ENTHAELT";LEN(A$);" ZEICHEN"
|
LET
| Typ: | Anweisung |
| Schablone: | [LET] <Variable>=<Ausdruck> |
| Funktion: | Die LET-Anweisung wird benutzt, um einer Variablen einen Wert zuzuordnen. Wenn sie überhaupt benutzt wird, das Schlüsselwort LET ist nämlich absolut überflüssig. Um einer Variablen einen Wert zuzuweisen, reicht es völlig, zwischen Variablennamen und Wert ein Gleichheitszeichen (=) zu setzen. LET wird eigentlich schon ewig nicht mehr benutzt - höchstens um zu uuuralten Basic-Dialekten kompatibel zu bleiben. Das ist aber i.A. unnötig und verschwendet nur Speicher. |
| Beispiele: |
10 LET PI=3.1415 20 LET A$="UNNUETZE ANWEISUNG" 10 PI=3.1415 20 A$="NIX UNNUETZES" |
LIST
| Typ: | Befehl |
| Schablone: | LIST [[<Startzeile>]-[<Endzeile>]] |
| Funktion: |
Mit dem LIST-Befehl läßt sich ein im Speicher befindliches
Basic-Programm anzeigen. Wenn die Ausgabe auf dem Bildschirm erfolgt
(der Normalfall), läßt sich das Programm auch direkt mit dem
Bildschirmeditor verändern. Alternativ kann das Listing aber auch
zu anderen Geräten geschickt werden, siehe dazu das Beispiel und
die CMD-Anweisung. LIST ohne Parameter zeigt das komplette Programm von der ersten bis zur letzten Zeile an, wenn es nicht durch Druck auf die RUN/STOP-Taste unterbrochen wird (durch Drücken der CTRL-Taste läßt sich die Geschwindigkeit verlangsamen). Wenn nur bestimmte Teile des Programms gelistet werden sollen, lassen sich auch Start- und/oder Endzeile angeben. LIST läßt sich auch innerhalb von Programmen aufrufen, allerdings wird das Programm nach dessen Ausführung beendet und der Rechner kehrt in den Direktmodus zurück. |
| Beispiele: |
10 PRINT "ZEILE 10" 20 PRINT "ZEILE 20" 30 LIST 40 PRINT "ZEILE 40" 50 PRINT "ZEILE 50" LIST LIST 20- LIST -40 LIST 20-40 |
LOAD
| Typ: | Befehl |
| Schablone: | LOAD ["<Programmname>"][,<Gerätenummer>][,<Sekundäradresse>] |
| Funktion: |
Über den LOAD-Befehl wird der Inhalt einer Programmdatei in den Speicher geladen,
normalerweise von Kassette oder Diskette. Da es beim Laden von Kassette und Diskette
teilweise große Unterschiede gibt, werden beide kurz getrennt erklärt:
Laden von Kassette: Wenn keine Geräteadresse angegeben wird, verwendet der Computer standardmäßig die Adresse 1, was der Datasette entspricht (beim PET/CBM die erste angeschlossene Datasette). LOAD ohne Parameter lädt also das erste gefundene Programm vom Band *. Wird ein Programmname angegeben, muß dieser exakt mit dem abgespeicherten Programmnamen übereinstimmen, Jokerzeichen sind nicht möglich. Es wird so lange auf dem Band nach dem Namen gesucht, bis die Datei gefunden wurde (was bei einem falschen Namen natürlich sehr lange dauert ;-)). Wenn der Computer eine Datei auf dem Band findet, meldet er sich mit der Meldung FOUND <PROGRAMMNAME>. Wenn diese Datei geladen werden soll, kann dies durch Drücken der Commodore-Taste bestätigt werden. Ein Druck auf die Leertaste überspringt das aktuell gefundene Programm und sucht nach dem nächsten. Falls keine Taste gedrückt wird, wartet der Rechner ca. 15 Sekunden und lädt das Programm dann selbständig. * Alternativ können auch die beiden Tasten SHIFT und RUN/STOP zusammen gedrückt werden, das entspricht der Eingabe von LOAD und anschließendem RUN, das geladene Programm wird also automatisch gestartet. Laden von Diskette: Bei der Diskettenstation gelten andere Regeln als bei der Datasette, hierbei müssen Programmname und Geräteadresse immer angegeben werden. Die Geräteadresse ist normalerweise 8 für das erste Laufwerk (9 bis 11 für evtl. weitere vorhandene Laufwerke). Bei der Floppy kann der Asterisk (*) als Jokerzeichen ** für Programmnamen benutzt werden. Eine Sonderfunktion hat das Dollarzeichen ($), es steht für das Inhaltsverzeichnis (Directory) der Diskette. Mit LOAD "$",8 wird das Directory geladen, dann kann es anschließend mit LIST betrachtet werden (Achtung, ein Basic-Programm wird beim Laden des Directory überschrieben!). ** Der Asterisk ersetzt beliebig viele Zeichen. Er kann also dazu benutzt werden, Namen für den LOAD-Befehl zu verkürzen oder ganz wegzulassen. LOAD "AB*",8 z.B. findet die erste Datei, die mit AB anfängt, egal welche Zeichen darauf folgen (möglicherweise auch keine). Der Asterisk kann auch allein benutzt werden, LOAD "*",8 findet die nächste Datei, egal wie sie heißt (normalerweise die erste auf der Diskette). Die Sekundäradresse kann beim Laden von Band und Diskette weggelassen werden. Wird keine angegeben, dann wird der Standardwert 0 benutzt, wodurch das Programm grundsätzlich an den Basic-Start bei Adresse $0801 (dezimal 2049) geladen wird (beim C64, andere Commodore-Rechner weichen davon ab). Bei einer anderen Sekundäradresse wird das Programm absolut geladen, d.h. es wird an die in der Datei gespeicherte Adresse transferiert. Im Direktmodus ausgeführt löscht LOAD alle Variablen (siehe CLR). LOAD kann auch innerhalb von Programmen benutzt werden, dabei bleiben die Variablen unangetastet. Dies kann benutzt werden, um einzelne Maschinenspracheprogramme von Basic aus nachzuladen (siehe Beispiel). |
| Beispiele: |
LOAD LOAD "SUPERSPIEL" LOAD "SUPERSPIEL",8,1 LOAD "SUP*",8,1 LOAD "$",8 10 IF FL=0 THEN FL=1:LOAD "DATEN1",8,1 20 IF FL=1 THEN FL=2:LOAD "DATEN2",8,1 30 IF FL=2 THEN FL=3:LOAD "DATEN3",8,1 40 PRINT "ALLES GELADEN." |
LOG
| Typ: | numerische Funktion |
| Schablone: | LOG(<numerischer Ausdruck>) |
| Funktion: | Die Funktion LOG liefert den natürlichen Logarithmus (Logarithmus der Basis e) des Arguments zurück. Ist das Argument Null oder negativ, bricht der Rechner mit der Fehlermeldung ?ILLEGAL QUANTITY ERROR ab. |
| Beispiele: |
10 PRINT LOG(13) 20 PRINT LOG(15*16) 30 N=LOG(A)/LOG(10) |
MID$
| Typ: | Stringfunktion |
| Schablone: | MID$(<Zeichenkette>,<Position>[,<Länge>]) |
| Funktion: | Die MID$-Funktion liefert einen Teilstring der übergebenen Zeichenkette. Als Ergebnis wird eine Zeichenkette geliefert, die alle Zeichen ab der angegebeben Position enthält. Wenn die Länge des Ergebnisses definiert wurde, erhält man entsprechend viele Zeichen ab der angegebenen Position zurück (oder auch weniger, falls die Ursprungszeichenkette kleiner ist). Mit MID$ lassen sich Strings also beliebig in ihre Bestandteile zerlegen (im Gegensatz zu LEFT$ und RIGHT$, die jeweils nur den linken oder rechten Teil eines Strings liefern können). |
| Beispiele: |
10 PRINT MID$("ATARI COMMODORE SCHNEIDER",6,9)
20 A$="8-BIT-NIRVANA":B$=MID$(A$,6)
|
NEW
| Typ: | Befehl |
| Schablone: | NEW |
| Funktion: |
Der Befehl NEW löscht im Speicher befindliche Programme * und
Variablen.NEW kann im Direkt- und im Programmodus benutzt, sollte aber in
beiden Fällen mit äußerster Vorsicht behandelt werden. *Das Programm ist eigentlich nicht direkt gelöscht, aber die Pointer werden alle zurückgesetzt. Mit entsprechender Erfahrung oder einem Toolkit läßt sich ein versehentlich durch NEW gelöschtes Programm durchaus wiederherstellen. |
NEXT
| Typ: | Anweisung |
| Schablone: | NEXT [<Variable>][,<Variable>] ... |
| Funktion: | Die NEXT-Anweisung wird mit FOR benutzt, um das Ende der Schleife zu bestimmen. Trifft der Basic-Interpreter auf NEXT, so wird die zuvor mit FOR definierte Zählvariable erhöht/erniedrigt (je nach STEP-Definition). Da FOR-NEXT-Schleifen immer ohne Überlappungen verschachtelt werden müssen, ist die Angabe der Zählvariablen eigentlich nicht nötig, der Interpreter weiß, welche aktuell ist. Eine einzige NEXT-Anweisung kann auch mehrere FOR-Schleifen abschließen, dazu müssen dann aber alle Zählvariablen in der richtigen Reihenfolge angegeben werden (siehe Beispiele). Hat die Zählvariable den mit FOR definierten Endwert erreicht, wird das Programm mit der nächsten Zeile nach NEXT fortgesetzt, andernfalls geht es wieder mit dem nächsten Befehl nach FOR weiter. |
| Beispiele: |
10 FOR I=1 TO 1000:PRINT I:NEXT 20 FOR J=1 TO 9999:PRINT J:NEXT J 10 FOR I=1 TO 10 20 FOR J=1 TO 10 30 PRINT I,J 40 NEXT 50 NEXT 10 FOR A=1 TO 10 20 FOR B=10 TO 1 STEP -1 30 FOR C=-5 TO 5 40 PRINT A;B;C 50 NEXT C,B,A |
NOT
| Typ: | logischer Operator |
| Schablone: | NOT <Ausdruck> |
| Funktion: |
Der logische Operator NOT "komplementiert"* den
Wert jedes Bits seines Operanden. Auf Bitebene wird also aus einer 1
eine 0 und umgekehrt: NOT 0 ergibt 1 NOT 1 ergibt 0 NOT kann nur auf Ganzzahlen angewendet werden, Fließkommazahlen werden vom Interpreter automatisch vorher zu Ganzzahlen gewandelt. * Y=NOT X entspricht Y=(-(X+1)), das Zweierkomplement einer Ganzzahl ist gleich dem Bit-Komplement + 1. Mit NOT lassen sich auch bei Vergleichen (z.B. mit IF) Wahr- und Falschwerte umkehren. Der Ausdruck wird also dann wahr (-1), wenn der NOT übergebene Ausdruck falsch (0) ist - oder umgekehrt. |
| Beispiele: |
10 PRINT NOT -1;NOT 0 20 A=666:B=NOT A:PRINT A,B 30 GET A$:IF NOT(A$="") THEN 30 |
ON
| Typ: | Anweisung |
| Schablone: | ON <Ausdruck> GOTO|GOSUB <Zeilennummer>[,<Zeilennummer>] ... |
| Funktion: | Die ON-Anweisung wird benutzt, um abhängig vom Wert des angegebenen Ausdrucks zu einer von mehreren angegebenen Zeilennummern zu springen. Der Wert des Ausdrucks muß dabei im Bereich von 1 bis zur Anzahl der angegebenen Zeilennummern liegen. Es können nur Ganzzahlen verwendet werden, Fließkommazahlen werden vom Interpreter automatisch vor der Ausführung in Ganzzahlen gewandelt. Sollte der Wert des Ausdrucks negativ sein, wird das Programm mit der Fehlermeldung ?ILLEGAL QUANTITY ERROR abgebrochen. Falls der Wert gleich Null oder größer als die Anzahl der angegebenen Zeilennummern ist, wird die komplette ON-Anweisung ignoriert. ON kann in Verbindung mit GOTO und GOSUB benutzt werden, es lassen sich also auch Subroutinen anspringen. Richtig eingesetzt stellt ON eine sehr gute Alternative zu aufwendigeren IF-Abfragen dar. |
| Beispiele: |
10 INPUT "ZAHL";Z 20 A=ABS(Z) 30 ON A+2 GOTO 40,50,60 40 PRINT "DIE ZAHL IST NEGATIV":END 50 PRINT "DIE ZAHL IST NULL":END 60 PRINT "DIE ZAHL IST POSITIV" 10 INPUT "SPRUNG ZU A, B ODER C";A$ 20 ON -(A$="A")-2*(A$="B")-3*(A$="C") GOTO 40,50,60 30 PRINT "UNGUELTIGE EINGABE":GOTO 10 40 PRINT "A":END 50 PRINT "B":END 60 PRINT "C" 10 FOR I=1 TO 3 20 ON I GOSUB 40,50,60 30 END 40 PRINT "SUBROUTINE 1":RETURN 50 PRINT "SUBROUTINE 2":RETURN 60 PRINT "SUBROUTINE 3":RETURN |
OPEN
| Typ: | Ein-/Ausgabe-Anweisung | ||||||||||||||||||||||
| Schablone: | OPEN <logische Filenummer> [,<Gerätenummer>] [,<Sekundäradresse>] [,"<Dateiname>[,<Typ>][,<Modus>]"] | ||||||||||||||||||||||
| Funktion: |
Über die OPEN-Anweisung wird ein Kanal für die Ein- und/oder Ausgabe zu
einem Peripheriegerät geöffnet. Es werden nicht immer alle Argumente
benötigt, häufig reicht die Angabe der logischen Filenummer und der
Gerätenummer, z.B. bei der Druckausgabe. Die logische Filenummer stellt für die Anweisungen OPEN, CLOSE, CMD, GET#, INPUT# und PRINT# den Ausgabekanal dar, mit dem das Gerät (und der Dateiname sowie alle übrigen Parameter) in Beziehung gesetzt werden. Gültige logische Filenummern liegen im Bereich 1 bis 255, Filenummern ab 128 haben allerdings spezielle Auswirkungen, so daß nur Zahlen bis 127 benutzt werden sollten. Jedes angeschlossene Peripheriegerät (Drucker, Floppy, Datasette, aber auch Tastatur oder Bildschirm) hat seine eigene Gerätenummer, auf die es antwortet. Die Gerätenummer sollte daher bei OPEN immer angegeben werden, da ansonsten nicht klar wäre, welches Gerät überhaupt angesprochen werden soll. Standardmäßig sind die Gerätenummern wie folgt verteilt:
Wird die Gerätenummer nicht angegeben, geht der Computer von der Gerätenummer 1 (Datasette) aus. Die Sekundäradresse dient bei den meisten Geräten als Schalter für Zusatzfunktionen, vor allem beim Drucker. Da dies aber stark vom jeweiligen Drucker bzw. Interface abhängt, wird hier nicht näher darauf eingegangen. Bei Floppy- oder Datasettenoperationen gibt es zumindest zwei definierte Sekundäradressen, nämlich 0 und 1. Sekundäradresse 0 wird als Leseoperation interpretiert, Sekundäradresse 1 zum Schreiben. Wird die Sekundäradresse bei einer Datasettenoperation nicht angegeben, geht der Computer von 0 aus und versucht zu lesen. Bei der Datasette ist zusätzlich noch die Sekundäradresse 2 definiert, sie schreibt beim Schließen der Datei eine Kennung für EOT (End of Tape, Kassettenende) auf das Band. Anders als bei der Datasette ist bei der Floppy die Angabe einer Sekundäradresse zwingend erforderlich. Es sollten für normale Diskettenoperationen nur die Sekundäradressen 2 bis 14 verwendet werden (bzw. 0 für Lese- oder 1 für Schreiboperationen), da Sekundäradressen ab 15 für DOS-Befehle reserviert sind (15 ist der übliche Befehlskanal). Der Dateiname sollte bei jeder Datasettenoperation angegeben werden, bei Diskettenoperationen muß er das sogar zwingend. Er besteht aus einem String mit insgesamt 16 Zeichen (überzählige Zeichen werden abgeschnitten). Am Ende des Dateinamens, durch Kommata getrennt, können zusätzlich noch Typ und Modus für die Datei definiert werden. Als Typen kommen für die Datasette nur SEQ (oder S, sequentielle Datei) oder PRG (oder P, Programmdatei) in Frage, für die Floppy sind zusätzlich noch REL (oder R, relative Datei) und USR (oder U, ganz was wildes ;-)) möglich. "Normale" Dateien sollten entweder als SEQ oder PRG gespeichert werden, da für die anderen Dateitypen Kenntnisse deren Struktur erforderlich sind. Als Modus kann entweder R(ead) für Lesen, W(rite) für Schreiben oder A(ppend) für das Anhängen an eine bestehende Datei angegeben werden. |
||||||||||||||||||||||
| Beispiele: |
10 OPEN 2,8,2,"FLOPPY-OUTPUT,S,W" : REM Sequentielle Datei schreiben 10 OPEN 1,1,2,"TAPE-OUTPUT" : REM Schreiben auf Tape mit EOT 10 OPEN 50,0 : REM Eingabe über die Tastatur 10 OPEN 1,2,0,CHR$(10) : REM RS232-Kanal öffnen 10 OPEN 12,3 : REM Ausgabe über den Bildschirm 10 OPEN 4,4 : REM Ausgabe über den Drucker 10 OPEN 1,4,0,"TEXT" : REM Druckerausgabe in Großschrift 10 OPEN 1,4,7,"TEXT" : REM Druckerausgabe in Kleinschrift 10 OPEN 1,5 : REM Ausgabe über Drucker Geräteadresse 5 10 OPEN 15,8,15,"Befehl" : REM Befehl zur Floppy schicken OPEN 15,8,15,"N:DISKNAME,ID" : CLOSE 15 : REM Formatieren einer Diskette OPEN 15,8,15,"N:DISKNAME" : CLOSE 15 : REM Quick-Format OPEN 15,8,15,"S:DATEINAME" : CLOSE 15 : REM Löschen einer Datei OPEN 15,8,15,"R:NEUERNAME=ALTERNAME" : CLOSE 15 : REM Umbenennen einer Datei |
OR
| Typ: | logischer Operator |
| Schablone: | <Operand> OR <Operand> |
| Funktion: |
So wie Vergleichsoperatoren für Entscheidungen hinsichtlich des
Programmablaufs benutzt werden können, können logische Operatoren
zwei oder mehrere Ausdrücke miteinander verknüpfen und als Ergebnis
"richtig" oder "falsch" liefern, die danach
in einer Entscheidung benutzt werden können (siehe IF).
Ist einer der Ausdrücke richtig, so ist der Wert des verknüpften
Ausdrucks richtig (-1); ist keiner der Ausdrücke richtig, so ist der Wert
des verknüpften Ausdrucks falsch (0). In Bitberechnungen gibt das logische OR das Bitergebnis 1, wenn in einem oder beiden Operanden das entsprechende Bit gesetzt ist. Ist das entsprechende Bit in beiden Operanden nicht gesetzt, so ist das Bitergebnis 0: 0 OR 0 ergibt 0 0 OR 1 ergibt 1 1 OR 0 ergibt 1 1 OR 1 ergibt 1 Logische Operatoren wandeln ihre Operanden in 16-Bit ganzzahlige Zweierkomplemente mit Vorzeichen aus dem Bereich -32768 bis 32767 um. Liegen die Operanden nicht in diesem Bereich, so wird die Fehlermeldung ?ILLEGAL QUANTITY ERROR ausgegeben. Jedes Bit des Ergebnisses wird durch die entsprechenden Bits in beiden Operanden bestimmt. |
| Beispiele: |
10 INPUT "ZAHL";Z 20 Z=Z OR 15 30 PRINT Z 10 A=128 OR 64 OR 32 20 B=127 OR 64 OR 32 30 PRINT A,B 100 IF (A=B) OR (C=D) THEN .... 110 IF (E=1) OR (F=2) THEN .... 120 IF G OR H THEN .... |
PEEK
| Typ: | Ganzzahl-Funktion |
| Schablone: | PEEK(<numerischer Ausdruck>) |
| Funktion: | PEEK liest einen Wert aus dem über einen numerischen Ausdruck angegebenen Speicherplatz. Daraus ergibt sich, daß das Ergebnis von PEEK immer im Bereich von 0 bis 255 liegt und die Adresse im Bereich von 0 bis 65535 liegen muß. Die Angabe einer anderen Adresse führt zur Fehlermeldung ?ILLEGAL QUANTITY ERROR. |
| Beispiele: |
10 PRINT PEEK(53280) AND 15 : REM Farbe des Bildschirmrahmens 20 V%=PEEK(45)+256*PEEK(46) : REM Adresse der Variablentabelle auslesen 30 A=45:L=PEEK(A):H=PEEK(A+1) |
POKE
| Typ: | Anweisung |
| Schablone: | POKE <Adresse>,<Wert> |
| Funktion: |
Mit POKE wird ein Byte-Wert in den gegebenen Speicherplatz oder ein
Ein-/Ausgaberegister geschrieben. Als Adresse kann jede Zahl und jeder
arithmetische Ausdruck, die im Bereich von 0 bis 65535 liegen, verwendet
werden, der zu schreibende Wert muß im Bereich von 0 bis 255 liegen.
Liegt einer der beiden Werte nicht im gültigen Bereich, quittiert der
Computer dies durch einen ?ILLEGAL QUANTITY ERROR. |
| Beispiele: |
10 POKE 1024,1 : REM "A" an Position 1 des Bildschirmspeichers setzen 20 A=1025:B=2:POKE A,B:POKE A+1,B+1 10 FOR I=0 TO 15 20 POKE 53280,I : POKE 53281,I : REM Rahmen- und Hintergrundfarbe setzen 30 POKE 198,0 : WAIT 198,1 : REM Tastaturpuffer leeren und auf Taste warten 40 NEXT I |
Die Befehlsbeschreibungen werden fortgesetzt, bis zur Fertigstellung dauert es allerdings noch ein Weilchen (ist ja auch ein ziemlich großes Projekt)...
