BASIC-Compiler

Funktionen und Systemvariablen


Der Compiler kennt folgende BASIC-Funktionen:
 ABS  ASC  ASM  BIN$  CDEC  CHR$  CINT  CLNG  CRSLIN  CRSPOS  DATETIME$  DECVAL  DEEK  EOF  ERR  ERR$  FRAC  HEX$  HIBYTE  HIWORD  H_CHAR  H_PIXEL  IN  INKEY$  INP  INPUT$  INSTR  INTVAL  IS_TARGET  JOYST  LCASE$  LEFT$  LEN  LNGVAL  LOBYTE  LOWER$  LOWORD  LTRIM$  MAX  MEMSTR$  MID$  MIN  MIRROR$  OCT$  PEEK  POINT  POS  PTEST  RIGHT$  RND  ROUND  RTRIM$  SCALE  SGN  SPACE$  SQR  STR$  STRING$  STRPTR  TRIM$  TRUNC  UCASE$  UPPER$  USR  VAL  VARPTR  W_CHAR  W_PIXEL  XPOS  YPOS

1. Datentyp des Rückgabewertes

Funktionen, die mit einem $-Zeichen enden, liefern eine Zeichenkette zurück. Alle anderen haben einen numerischen Rückgabewert, dessen Datentyp in der jeweiligen Tabelle in der Zeile Rückgabe angegeben ist. Systemvariablen, die mit einem $-Zeichen enden, enthalten eine Zeichenkette, alle anderen einen Integer-Wert.

2. Argumente

Die Argumente bzw. Parameter werden in Klammern hinter dem Funktionsnamen geschrieben. Bei String-Funktionen ohne Argumente (z.B. INKEY$) entfallen diese Klammern.

3. Systemvariablen

Systemvariablen sind wie Funktionen ohne Argumente. Sie können gelesen, nicht aber direkt beschrieben werden. Systemvariablen werden vom System gesetzt. Manche können auch mit Hilfe spezieller Anweisungen gesetzt werden (z.B. XPOS und YPOS durch die MOVE-Anweisung).

Da sich Systemvariablen für den Softwareentwickler wie Funktionen verhalten, werden sie hier in der Funktionsübersicht aufgeführt und beschrieben.

4. Liste der Funktionen und Systemvariablen

FunktionBedeutung
ABS Absoluter Betrag
ASC Zeichencode des ersten Zeichens einer Zeichenkette ermiteln
ASM Assemblerquelltext einfügen
BIN$ numerischen Wert in eine Binärzahl umwandeln
CDEC numerischen Wert in Decimal umwandeln
CHR$ Zeichencode in Zeichenkette umwandeln
CINT numerischen Wert in Integer umwandeln
CLNG numerischen Wert in Long umwandeln
CRSLIN aktuelle Zeile ermitteln, in der sich der Cursor befindet
CRSPOS aktuelle Spalte ermitteln, in der sich der Cursor befindet
DATETIME$ Zeichenkette mit aktuellem Datum und/oder Uhrzeit erzeugen
DECVAL Zeichenkette in einen Decimal-Wert umwandeln
DEEK 16-Bit-Wert (2 Bytes) aus dem Arbeitsspeicher lesen
EOF Ende eines Eingabekanals bzw. einer Datei erkennen
ERR Letzten Fehlercode ermitteln
ERR$ Letzten Fehlertext ermitteln
FRAC Nachkommaanteil eines Decimal-Wertes ermitteln
HEX$ numerischen Wert in eine Hexadezimalzahl umwandeln
HIBYTE Höherwertiges Byte ermitteln
HIWORD Höherwertiges Wort ermitteln
H_CHAR Bildschirmhöhe in Zeichenpositionen (Anzahl Textzeilen) ermitteln
H_PIXEL Bildschirmhöhe in Pixel ermitteln
IN Wert von einem Eingabetor lesen
INKEY$ Tastaturstatus abfragen
INP Wert von einem Eingabetor lesen
INPUT$ Tastatureingaben ohne Echo oder Bytes aus einem Eingabekanal bzw. einer Datei lesen
INSTR Zeichenkette in einer anderen Zeichenkette suchen
INTVAL Zeichenkette in einen Integer-Wert umwandeln
IS_TARGET Testen auf ein Zielsystem
JOYST Joystick abfragen
LCASE$ Zeichenkette in Kleinbuchstaben wandeln
LEFT$ Anfang einer Zeichenkette extrahieren
LEN Länge einer Zeichenkette ermitteln
LNGVAL Zeichenkette in einen Long-Wert umwandeln
LOBYTE Niederwertigen 16-Bit-Wert ermitteln
LONG numerischen Wert in Long umwandeln
LOWER$ Zeichenkette in Kleinbuchstaben wandeln
LOWORD Niederwertiges Wort ermitteln
LTRIM$ Führende weiße Leerzeichen abschneiden
MAX Größter Wert aus einer Liste von Werten ermitteln
MEMSTR$ auf eine im Arbeitsspeicher liegende Zeichenkette zugreifen
MID$ Teilzeichenkette aus einer Zeichenkette extrahieren
MIN Kleinster Wert aus einer Liste von Werten ermitteln
MIRROR$ Zeichenkette spiegeln
OCT$ numerischen Wert in eine Oktalzahl umwandeln
PEEK 8-Bit-Wert (1 Byte) aus dem Arbeitsspeicher lesen
POINT Farbe eines Pixels ermitteln
POS aktuelle Spalte ermitteln, in der sich der Cursor befindet
PTEST Testen eines Pixels
RIGHT$ Ende einer Zeichenkette extrahieren
RND Ermitteln einer Zufallszahl
ROUND Dezimalzahl runden
RTRIM$ angehängte weiße Leerzeichen abschneiden
SCALE Anzahl der Nachkommastellen eines Decimal-Wertes ermitteln
SGN Ermitteln des Vorzeichens
SPACE$ mit Leerzeichen gefüllte Zeichenkette erzeugen
SQR Ermitteln der Quadratwurzel
STR$ numerischen Wert in eine Dezimalzahl umwandeln
STRING$ Zeichen oder Zeichenkette vervielfältigen
STRPTR Anfangsadresse einer Zeichenkette ermitteln
TRIM$ weiße Leerzeichen abschneiden
TRUNC Nachkommastellen abschneiden
UCASE$ Zeichenkette in Großbuchstaben wandeln
UPPER$ Zeichenkette in Großbuchstaben wandeln
USR In Maschinencode implementierte Funktion aufrufen
VAL Zeichenkette in einen Integer-Wert umwandeln
VARPTR Adresse einer Variable ermitteln
W_CHAR Bildschirmbreite in Zeichenpositionen (Anzahl Textspalten) ermitteln
W_PIXEL Bildschirmbreite in Pixel ermitteln
XPOS aktuelle X-Koordinate des Grafikcursors ermitteln
YPOS aktuelle Y-Koordinate des Grafikcursors ermitteln


5. Beschreibung Funktionen und Systemvariablen

In spitzen Klammern eingeschlossene Elemente dienen als Platzhalter und sind entsprechend zu ersetzten.

ABS

Syntax: ABS ( <Wert> )
Wert: numerischer Ausdruck
Rückgabe: gleicher Typ wie der übergebene Wert

Die Funktion gibt den absoluten Betrag des übergebenen Wertes zurück.

ASC

Syntax: ASC ( <Zeichenkette> )
Zeichenkette:einfacher String-Ausdruck
Rückgabe:Integer

Die Funktion liefert den Code des ersten Zeichens in der übergebenen Zeichenkette. Ist die Zeichenkette leer, wird 0 zurückgegeben.

ASM

Syntax: ASM ( <Zeichenkette> [, <Zeichenkette> [, ...]] )
Zeichenkette:String-Literal
Rückgabe:Integer

Die ASM-Funktion fügt in den vom Compiler erzeugten Assemblertext eine oder mehrere Assemblerzeilen ein. Im Gegensatz zur ASM-Anweisung wird bei der ASM-Funktion der Wert im HL-Register an das BASIC-Programm zurückgegeben. In Verbindung mit der MEMSTR$-Funktion lassen sich auch in eigenen Assembler-Routinen erzeugte Zeichenketten an das BASIC-Programm zurückgeben.

Das Beispiel zeigt eine mögliche Anwendung der ASM-Funktion in Verbindung mit USR, um auf diese Art und Weise einen Parameter an die Assembler-Routine zu übergeben und einen numerischen Wert zurückgeben zu lassen:

DEF USR0 = ASM(" LD HL,meine_negation")
PRINT USR0(123)
END

ASM "meine_negation:"
ASM " LD HL,0000H"
ASM " OR A"
ASM " SBC HL,DE"
ASM " RET"

Im zweiten Beispiel liefert die Assembler-Routine die Zeichenkette ABC zurück:

PRINT MEMSTR$( ASM(" CALL meine_routine") )
END

ASM CODE "meine_routine:"
ASM CODE " LD HL,mein_string"
ASM CODE " RET"
ASM DATA "mein_string: DB 'ABC',0"

Achtung! Lesen Sie bitte die Hinweise zum Einbinden von eigenem Assembler-Quellcode!

BIN$

Syntax: BIN$ ( <Wert> )
BIN$ ( <Wert> , <Anzahl Stellen> )
Wert:Integer- oder Long-Ausdruck
Anzahl Stellen:Integer
Rückgabe:String

Die Funktion BIN$ erzeugt eine Zeichenkette, die den übergebenen Wert als Binärzahl darstellt. Bei negativen Werten erfolgt die Darstellung des Zweierkomplements. Lässt man das zweite Argument weg, ist die erzeugte Zeichenkette bei einem Integer-Wert 16 und bei einem Long-Wert 32 Zeichen lang.

Mit dem optionalen zweiten Argument kann die Länge der zu erzeugenden Binärzahl angegeben werden. Mögliche Werte sind bei einem Integer-Ausdruck 0 bis 16 und bei einem Long-Ausdruck 0 bis 32. Bei einer 0 wird die Binärzahl ohne Vornullen mit sovielen Stellen erzeugt, wie zur vollständigen Darstellung des Wertes notwendig ist. Bei einer Stellenzahl größer 0 hat die Binärzahl soviele Stellen wie angegeben, beginnend von rechts, d.h. mit den niederwertigsten Stellen.

CDEC

Syntax: CDEC ( <numerischer Ausdruck> )
Rückgabe: Decimal

Die Funktion wandelt den übergebenen Wert in einen Decimal-Wert um.

CHR$

Syntax: CHR$ ( <Zeichencode> )
Zeichencode:Integer-Ausdruck
Rückgabe:String

Die Funktion CHR$ erzeugt eine Zeichenkette, die nur aus dem einen Zeichen besteht, welches dem übergebenen Zeichencode (i.d.R. ASCII-Code) entspricht. Wird der Wert 0 übergeben, ist die zurückgelieferte Zeichenkette leer.

Achtung! Bei den Anweisungen PRINT und LPRINT wird mit CHR$(0) ein Nullbyte ausgegeben.

CINT

Syntax: CINT ( <numerischer Ausdruck> )
Rückgabe: Integer

Die Funktion wandelt den übergebenen Wert in einen Integer-Wert um. Ist die Umwandlung nicht möglich, weil der Betrag des übergebenen Wertes zu groß ist, bricht das Programm mit einem Überlauffehler ab.

CLNG

Syntax: CLNG ( <numerischer Ausdruck> )
Rückgabe: Long

Die Funktion wandelt den übergebenen Wert in einen Long-Wert um. Ist die Umwandlung nicht möglich, weil der Betrag des übergebenen Wertes zu groß ist, bricht das Programm mit einem Überlauffehler ab.

CRSLIN

Diese Systemvariable enthält die aktuelle Zeilennummer, in der sich der Cursor befindet, beginnend mit 0. Ist der Cursor außerhalb des sichtbaren Bereichs oder unterstützt das Zielsystem das Auslesen der Cursor-Position nicht, enthält die Variable den Wert -1.

CRSPOS

Diese Systemvariable enthält die aktuelle Spaltennummer, in der sich der Cursor befindet, beginnend mit 0. Ist der Cursor außerhalb des sichtbaren Bereichs oder unterstützt das Zielsystem das Auslesen der Cursor-Position nicht, enthält die Variable den Wert -1.

Die Systemvariable liefert die gleiche Information wie die Funktion POS und ist aus Gründen der Namensanalogie zu CRSLIN enthalten.

DATETIME$

Syntax: DATETIME$ ( <Formatstring> )
Formatstring:einfacher String-Ausdruck
Rückgabe: String

Die Funktion DATETIME$ liefert eine Zeichenkette mit dem aktuellen Datum und/oder der aktuellen Uhrzeit. Das Aussehen der Zeichenkette legen Sie mit einem Formatstring fest. Im Formatstring dienen bestimmte Buchstaben bzw. Buchstabengruppen als Platzhalter für die einzelnen Elemente des Datums bzw. der Uhrzeit. Die zurückgelieferte Zeichenkette entspricht dem Formatstring, in dem die Platzhalter entsprechend ersetzt wurden.

Die Platzhalter können sowohl groß als auch klein geschrieben werden. Alle Zeichen, die keine Platzhalter sind, werden unverändert in die zurückgelieferte Zeichenkette übernommen.

Folgende Platzhalter sind möglich:

PlatzhalterBedeutung
DTag, ein- oder zweistellig
DDTag, immer zweistellig
MMonat, ein- oder zweistellig
MMMonat, immer zweistellig
YJahr, einstellig (nur die Einer)
YYJahr, zweistellig (Zehner und Einer)
YYYYJahr, vierstellig
HStunde (0 bis 23), ein- oder zweistellig
HHStunde (0 bis 23), immer zweistellig
MIMinute, immer zweistellig
SSekunde, ein- oder zweistellig
SSSekunde, immer zweistellig


Beispiel:

PRINT "Heute ist der ";DATETIME$("D.MM.YYYY.")
PRINT "Datum heute: ";DATETIME$("DD.MM.YYYY")
PRINT "Akt. Zeit: ";DATETIME$("H:MI:SS")
PRINT "Datum / Zeit: ";DATETIME$("YYYY-MM-DD HH:MI:SS")

Achtung: Die Funktion kann nur dann eine sinnvolle Zeichenkette zurückliefern, wenn der Computer, auf dem das compilierte BASIC-Programm läuft, auch über eine Uhr verfügt. Standardmäßig wird versucht, das Datum und die Uhrzeit aus der Real Time Clock eines angeschlossenen GIDE zu lesen. Wenn kein GIDE angeschlossen ist oder das Zielsystem kein GIDE und auch keine andere Möglichkeit zum Auslesen der Systemzeit unterstützt, wird eine leere Zeichenkette zurückgeliefert.

DECVAL

Syntax: DECVAL ( <Zeichenkette> )
Zeichenkette:einfacher String-Ausdruck
Rückgabe: Decimal

Die Funktion DECVAL versucht den Inhalt einer Zeichenkette als Zahl zu lesen und liefert deren numerischen Wert als Decimal zurück. Die Funktion setzt die Fehlervariablen ERR und ERR$. Damit, insbesondere mit der ERR-Variable, kann geprüft werden, ob die Funktion erfolgreich war:

ERR-WertBedeutung
E_OK Zahl konnte gelesen werden
E_DIGITS_TRUNCATED Die Zahl konnte gelesen werden, enthält aber zu viele Nachkommastellen, die nicht in den Datentyp Decimal passen. Diese Nachkommastellen wurden abgeschnitten, d.h., der zurückgelieferte Wert entspricht nicht exakt der Zahl in der übergebenen Zeichenkette.
E_INVALID ungültige Zeichen gelesen, Rückgabewert ist 0
E_OVERFLOW numerischer Überlauf, d.h. die Zahl hat zu viele Vorkommastellen, Rückgabewert ist 0

Zur Umwandlung einer Zeichenkette in einen anderen numerischen Datentyp gibt es die Funktionen LNGVAL und VAL.

DEEK

Syntax: DEEK ( <Adresse> )
Adresse:Integer-Ausdruck
Rückgabe:Integer

Die Funktion liest zwei aufeinander folgende Bytes vom Arbeitsspeicher ab der angegebenen Adresse und liefert sie als 16-Bit-Wert zurück. Das erste Byte ist das niederwertige.

EOF

Syntax: EOF ( <Kanal> )
EOF ( # <Kanal> )
Kanal: Integer-Ausdruck
Rückgabe:Integer

Die Funktion testet, ob das Ende des Eingabekanals bzw. der Datei erreicht wurde. Dabei werden die Fehlervariablen ERR und ERR$ gesetzt.

Bei Dateien liefert die Funktion erst dann sicher TRUE zurück, wenn versucht wurde, über das Dateiende hinaus zu lesen.

ERR

Die Systemvariable ERR enthält den letzten Fehlercode. Der Wert 0 (Konstante E_OK) bedeutet, dass bei der letzten Anweisung oder Funktion, die Einfluss auf die Fehlervariable hat, kein Fehler aufgetreten ist. Ein Wert ungleich 0 steht für einen Fehler. Zum Auswerten der Fehlervariable ERR gibt es Fehlercodekonstanten.

Die ERR-Systemvariable wird am Anfang einer jeden BASIC-Anweisung zurückgesetzt, in der die Systemvariable durch die Anweisung selbst oder durch Funktionsaufrufe gesetzt bzw. beeinflusst wird. Dadurch ist sichergestellt, dass auch dann kein Fehlerzustand verloren geht, wenn in einer Anweisung mehrere Funktionsaufrufe die Fehlervariable beeinflussen. Folgendes Beispiel verdeutlicht das:

OPEN #1,"datei.dat"
...:REM Pruefen, ob Oeffnen der Datei erfolgreich war
PRINT "Hex=";HEX$(VAL(INPUT$(5,#1));" Text=";INPUT$(10,#1)
IF ERR THEN
  PRINT ERR$
ENDIF


Die Datei datei.dat beginnt mit zwei Datenfeldern mit jeweils fest vorgegebener Feldlänge. Das erste Feld ist 5 Bytes groß und enthält eine Zahl in Textform. Im 10 Byte großen zweiten Feld steht eine Zeichenkette. In der ersten PRINT-Anweisung passiert der Reihe nach folgendes:
  1. Das erste Datenfeld wird als Zeichenkette aus der Datei gelesen.
  2. Die gelesene Zeichenkette wird in einen numerischen Wert umgewandelt.
  3. Dieser Wert wird in eine Hexadezimalzahl umgewandelt und auf dem Bildschirm ausgegeben.
  4. Das zweiten Datenfeld wird aus der Datei gelesen und ausgegeben.

Sowohl die beiden Lesevorgänge als auch die Umwandlung in einen numerischen Wert können fehlschlagen und die ERR-Variable beeinflussen. Würde z.B. im ersten Datenfeld etwas stehen, was nicht als Zahl interpretiert werden kann, setzt die VAL-Funktion die ERR-Systemvariable. Wenn nun das danach ausgeführte Lesen des zweiten Datenfeldes erfolgreich ist, soll der Fehlerinformation der VAL-Funktion aber nicht verloren gehen. Und genau das wird sichergestellt, indem die ERR-Systemvariable nur am Anfang einer betreffenden Anweisung zurückgesetzt wird. Im obigen Beispiel wird die ERR-Variable (außer zum Programmanfang) nur am Anfang der ersten PRINT-Anweisung auf Null zurückgesetzt. Da die nachfolgende IF-Anweisung die ERR-Variable nur liest und nicht setzt, erfolgt dort kein Zurücksetzen und man liest wie gewünscht die Fehlerinformation der vorangegangenen Anweisung.

Ein weiterer Fall, für den dieses Verhalten wichtig ist, sind Berechnungen mit dem Datentyp DECIMAL. Man kann bedenkenlos in einer Anweisung mehrere einzelne DECIMAL-Berechnungen durchführen und danach testen, ob dabei Dezimalstellen abgeschnitten wurden (IF ERR=E_DIGITS_TRUNCATED THEN ...). Wenn in einer der Berechnungen das Ergebnis gekürzt werden musste, ist die ERR-Systemvariable garantiert entsprechend gesetzt, auch wenn nachfolgende DECIMAL-Berechnungen in der gleichen Anweisung korrekt abliefen.

Achtung! Das Zurücksetzen der ERR-Systemvariable am Anfang einer betreffenden Anweisung muss beim Auslesen dieser beachtet werden. Wenn in einer Anweisung die ERR-Variable gleichzeitig gelesen und gesetzt wird, geht die Fehlerinformation der vorangegangen Anweisung verloren. Die Anweisungen in einem THEN- oder ELSE-Zweig einer IF- oder ELSEIF-Anweisung gelten dabei als separate Anweisungen, d.h., man kann problemlos in der Bedingung einer IF- oder ELSEIF-Anweisung den Fehlerstatus der vorangegangen Anweisung auswerten und dann im THEN- oder ELSE-Zweig Anweisungen verwenden, die die ERR-Systemvariable wieder beeinflussen.

ERR$

Die Systemvariable ERR$ enthält den letzten Fehlertext. In Verbindung mit der Systemvariable ERR kann die Fehlerbehandlung recht einfach und für den Anwender trotzdem komfortabel gestaltet werden, z.B.:

...:'Funktion oder Anweisung, die die Fehlervariablen setzt
IF ERR THEN
  PRINT ERR$
ELSE
  ...:'kein Fehler aufgetreten
ENDIF

Achtung! Wenn Sie die Systemvariable ERR$ verwenden, wird das compilierte Programm entsprechend größer, da alle Fehlermeldungen, die auftreten können, auch in das Programm hineincompiliert werden müssen. Wenn Sie ein möglichst kleines Programm anstreben und auf die detaillierten Fehlertexte verzichten können, sollten Sie nur die Fehlercodevariable ERR auswerten und ERR$ nicht verwenden.

Achtung! Bzgl. des Zurücksetzens der Systemvariable ERR$ gilt das gleiche wie für die Systemvariable ERR.

FRAC

Syntax: FRAC ( <Wert> )
Wert:Decimal-Ausdruck
Rückgabe: Decimal

Die Funktion FRAC liefert vom übergebenen Wert den Nachkommaanteil zurück, d.h., die Dezimalstellen, die hinter dem Komma stehen. Das Ergebnis ist immer größer oder gleich Null, auch dann, wenn der übergebene Wert kleiner Null ist.

Beispiele:
BASIC-CodeAusgabe
PRINT FRAC( 1.000 ) 0
PRINT FRAC( 12345.67890 ) 0.6789
PRINT FRAC( -1.0123400 ) 0.01234


HEX$

Syntax: HEX$ ( <Wert> )
HEX$ ( <Wert> , <Anzahl Stellen> )
Wert:Integer- oder Long-Ausdruck
Anzahl Stellen:Integer
Rückgabe:String

Die Funktion HEX$ erzeugt eine Zeichenkette, die den übergebenen Wert als Hexadezimalzahl darstellt. Bei negativen Werten erfolgt die Darstellung des Zweierkomplements. Lässt man das zweite Argument weg, ist die erzeugte Zeichenkette bei einem Integer-Wert vier und bei einem Long-Wert acht Zeichen lang.

Mit dem optionalen zweiten Argument kann die Länge der zu erzeugenden Hexadezimalzahl angegeben werden. Mögliche Werte sind bei einem Integer-Ausdruck 0 bis 4 und bei einem Long-Ausdruck 0 bis 8. Bei einer 0 wird die Hexadezimalzahl ohne Vornullen mit sovielen Stellen erzeugt, wie zur vollständigen Darstellung des Wertes notwendig ist. Bei einer Stellenzahl größer 0 hat die Hexadezimalzahl soviele Stellen wie angegeben, beginnend von rechts, d.h. mit den niederwertigsten Stellen.

HIBYTE

Syntax: HIBYTE ( <Wert> )
Wert:Integer-Ausdruck
Rückgabe:Integer

Die Funktion liefert vom übergebenen Wert nur den Wert des höherwertigen Bytes zurück, d.h., der Rückgabewert liegt immer im Bereich 0 bis 255.

Die Funktion HIBYTE hat die gleiche Wirkung wie (<Wert> SHR 8) AND &H00FF, erzeugt aber kürzeren und schnelleren Programmcode.

HIWORD

Syntax: HIWORD ( <Wert> )
Wert:Long-Ausdruck
Rückgabe:Long

Die Funktion liefert vom übergebenen Long-Wert nur den Wert der höherwertigen 16 Bit zurück, d.h., der Rückgabewert liegt immer im Bereich 0 bis 32767.

Die Funktion HIWORD hat die gleiche Wirkung wie (<Wert> SHR 16) AND &H0000FFFF, erzeugt aber kürzeren und schnelleren Programmcode.

H_CHAR

Die Systemvariable enthält die Höhe des Bildschirms in Zeichenpositionen, d.h., es wird die Anzahl der sichtbaren Textzeilen zurückgeliefert. Wenn dieser Wert nicht eindeutig feststeht bzw. bei dem Zielsystem unterschiedliche Werte möglich sind (z.B. bei CP/M), enthält die Variable den Wert -1.

Eine 0 wird zurückgegeben, wenn mit der SCREEN-Anweisung ein Grafikbildschirm eingestellt wurde, der keine Textausgaben zulässt.

H_PIXEL

Diese Systemvariable enthält die Höhe des vollgrafikfähigen Bildschirms in Pixel. Steht keine Vollgrafik zur Verfügung, wird der Wert 0 zurückgegeben. In dem Fall können die Grafikbefehle nicht verwendet werden.

INKEY$

Die Funktion prüft, ob gerade eine Taste gedrückt ist. Wenn ja, liefert die Funktion eine Zeichenkette mit dem eingegebenen Zeichen zurück. Anderenfalls wird eine leere Zeichenkette zurückgegeben. INKEY$ hat keine Argumente.

IN
INP

Syntax: IN ( <Adresse> )
INP ( <Adresse> )
Adresse:Integer-Ausdruck
Rückgabe:Integer

Die Funktionen IN und INP lesen ein Byte von dem durch die Adresse angegebenen Eingabetor und liefern den Wert des Bytes zurück.

Beide Funktionen sind identisch. Aus Gründen der Kompatibilität zu diversen BASIC-Dialekten werden beide Funktionsnamen unterstützt.

Achtung! Obwohl der Mikroprozessor offiziell nur 8 Bit große Ein-/Ausgabeadressen unterstützt, ist die Nutzung von 16-Bit-Adressen möglich. Der Compiler übersetzt die Anweisung in solch einen Programmcode, der aufgrund des undokumentierten Verhaltens des Mikroprozessors auch eine 16 Bit große Ein-/Ausgabeadresse wirksam werden lässt.

INPUT$

Syntax: INPUT$ ( <Anzahl> )
INPUT$ ( <Anzahl> , <Kanal> )
INPUT$ ( <Anzahl> , # <Kanal> )
Anzahl: Integer-Ausdruck im Bereich 0 bis 255
Kanal: Integer-Ausdruck
Rückgabe:String

Die Funktion gibt es in zwei Varianten, mit und ohne Kanalnummer. In der Variante ohne Kanalnummer wird die angegebene Anzahl von Zeichen von der Tastatur gelesen und als Zeichenkette zurückgegeben. Steuertasten (z.B. Cursor-Tasten, Enter) werden nicht ausgewertet. Stattdessen finden sich die entsprechenden Steuercodes in der Zeichenkette wieder. Es erfolgt keine Ausgabe auf dem Bildschirm.

In der Variante mit Kanalnummer liest die Funktion die angegebene Anzahl von Zeichen aus dem Eingabekanal bzw. der Datei und gibt diese als Zeichenkette zurück. Dabei werden die Fehlervariablen ERR und ERR$ gesetzt.

Achtung! Nullbytes dienen bei Zeichenketten als Endezeichen, d.h., wenn ein Nullbyte gelesen wird, enthält die zurückgelieferte Zeichenkette nur die Bytes bis zum ersten gelesenen Nullbyte. Es werden aber trotzdem soviele Bytes aus dem Eingabekanal gelesen, wie im ersten Argument übergeben wurde. Wenn also die zurückgelieferte Zeichenkette kürzer ist als die Anzahl der gelesenen Bytes und in der Fehlervariable ERR steht der Wert 0 (Konstante E_OK, kein Fehler aufgetreten), dann wurde hinter der Zeichenkette ein Nullbyte gelesen. Damit ist auch generell das Lesen von Binärdateien möglich. Das Beispiel zeigt, wie eine Datei Byte für Byte eingelesen und als Hex-Dump auf dem Bildschirm ausgegeben wird:

INPUT "Datei:";F$
OPEN F$ FOR BINARY INPUT AS #1
IF ERR THEN
  PRINT ERR$
ELSE
  N=0
  WHILE NOT EOF(#1)
    B=ASC(INPUT$(1,#1))
    IF ERR THEN
      PRINT ERR$:EXIT
    ELSE
      PRINT CHR$(32);HEX$(B,2);
      N=N+1
      IF N=8 THEN N=0:PRINT
    ENDIF
  WEND
  PRINT
  IF ERR THEN PRINT ERR$
  CLOSE #1
ENDIF

INSTR

Syntax: INSTR ( <durchsuchte Zeichenkette> , <gesuchte Zeichenkette> )
INSTR ( <Position> , <durchsuchte Zeichenkette> , <gesuchte Zeichenkette> )
Position:Integer-Ausdruck
durchsuchte Zeichenkette: einfacher String-Ausdruck
gesuchte Zeichenkette: einfacher String-Ausdruck
Rückgabe:Integer

Die Funktionen sucht in der ersten übergebenen Zeichenkette die zweite übergebene Zeichenkette und gibt die Position der Fundstelle zurück. Ist die zweite Zeichenkette in der ersten nicht enthalten, wird 0 zurückgegeben. Wenn eine Position angegeben wurde, wird ab dieser Position gesucht.

Beispiele:

PRINT INSTR("ABCD","C")

liefert 3.

PRINT INSTR(3,"KASKADE","K")

liefert 4.

Achtung! Bei dieser Funktion gibt es zwischen den einzelnen BASIC-Dialekten Unterschiede in der Argumentreihenfolge. Bei den meisten der international üblichen BASIC-Dialekte ist die erste Zeichenkette die durchsuchte und die zweite die gesuchte Zeichenkette. Aus diesem Grund ist das auch im JKCEMU so realisiert. Beim KC-BASIC ist es dagegen genau anders herum. Wenn Sie also KC-BASIC-Programme compilieren bzw. portieren möchten, müssen Sie die beiden Zeichenketten vertauschen.

INTVAL

Syntax: INTVAL ( <Zeichenkette> )
INTVAL ( <Zeichenkette> , <Zahlenbasis> )
Zeichenkette:einfacher String-Ausdruck
Zahlenbasis: Integer-Ausdruck mit dem Wert 2, 10 oder 16
Rückgabe: Integer

Die Funktion INTVAL ist identisch zur Funktion VAL und wird dort beschrieben. Der Funktionsname INTVAL macht deutlich, dass ein Integer-Wert zurückgeliefert wird und ist aus Gründen der Namensanalogie zu DECVAL (liefert Decimal zurück) und LNGVAL (liefert Long zurück) vorhanden.

IS_TARGET

Die Funktion IS_TARGET ermittelt, ob das Programm für ein bestimmtes Zielsystem compiliert wurde. Damit kann man BASIC-Programme portabel schreiben und diese trotzdem auf ganz spezifische Eigenheiten des Zielsystems anpassen. Man ruft die Funktion üblicherweise mit einer Konstante für das Zielsystem auf. Folgendes Beispiel demonstriert die Anwendung:

IF IS_TARGET(TARGET_KC85) THEN PRINT "Ich bin ein KC85/2..5 oder HC900"
IF IS_TARGET(TARGET_Z9001) THEN PRINT "Ich bin ein KC85/1, KC87 oder Z9001"
IF IS_TARGET(TARGET_Z1013) THEN PRINT "Ich bin ein Z1013"

Achtung! Die Funktion IS_TARGET liefert auch dann TRUE, wenn für ein abgeleitetes Zielsystem compiliert wird und man auf das allgemeinere Zielsystem testet, d.h., wenn z.B. in den Compiler-Optionen das Zielsystem TARGET_KC85_4 (KC85/4..5 mit Unterstützung beider Bildspeicher) eingestellt ist, liefert die Funktion sowohl bei TARGET_KC85 als auch bei TARGET_KC85_4 TRUE.

Achtung! Die Funktion IS_TARGET ermittelt nicht, auf welchem Computertyp das Programm tatsächlich ausgeführt wird, sondern für welchen Computertyp das BASIC-Programm compiliert wurde. So kann z.B. ein Programm für den AC1 übersetzt werden, aber trotzdem auf einem LLC2 ausgeführt werden, wenn es keine AC1-spezifischen Dinge verwendet. Die Funktion IS_TARGET(TARGET_AC1) würde dann trotzdem TRUE und IS_TARGET(TARGET_LLC2) FALSE liefern.

JOYST

Syntax: JOYST ( <Joystick-Nummer> )
Joystick-Nummer: Integer-Ausdruck mit einem Wert >= 0
Rückgabe:Integer

Die Funktionen liest den aktuellen Status des angegebenen Joysticks. Der erste Joystick hat die Nummer 0. Die Bit-Belegung des Rückgabewertes unterscheidet sich zwischen den einzelnen Zielsystemen und sollte deshalb mit folgenden Konstanten ausgewertet werden:

KonstanteBedeutung
JOYST_LEFT Joystick nach links gedrückt
JOYST_RIGHT Joystick nach rechts gedrückt
JOYST_UP Joystick nach oben gedrückt
JOYST_DOWN Joystick nach unten gedrückt
JOYST_BUTTON1 Aktionsknopf 1 gedrückt
JOYST_BUTTON2 Aktionsknopf 2 gedrückt
JOYST_BUTTONS Aktionsknopf 1 oder 2 gedrückt

Die JOYST-Funktion liefert einen Integer-Wert zurück, bei der jedes gesetzte Bit für eine bestimmte Aktion steht. Dabei können mehrere Bits gleichzeitig gesetzt sein, z.B. die Bits für links und nach oben, wenn der Joystick nach links oben gedrückt wird. Die Joystick-Konstanten sind so definiert, dass das jeweilige Bit der betreffenden Aktion gesetzt ist. Mit Hilfe der AND-Verknüpfung können die einzelnen Aktionen getestet werden:

A=JOYST(0)
IF A AND JOYST_LEFT THEN PRINT "links"
IF A AND JOYST_RIGHT THEN PRINT "rechts"
IF A AND JOYST_DOWN THEN PRINT "runter"
IF A AND JOYST_UP THEN PRINT "hoch"
IF A AND JOYST_BUTTON1 THEN PRINT "Feuer 1"
IF A AND JOYST_BUTTON2 THEN PRINT "Feuer 2"
IF A AND JOYST_BUTTONS THEN PRINT "Feuer 1 oder 2"

Auf einem Zielsystem, bei dem nur ein Feuerknopf pro Joystick unterstützt wird, hat die Konstante JOYST_BUTTONS den gleichen Wert wie JOYST_BUTTON1 und JOYST_BUTTON2 ist 0. Auf Systemen, die keine Joystick-Unterstützung bieten, liefert die JOYST-Funktion immer 0 und die Joystick-Konstanten haben auch alle den Wert 0.

LCASE$

Syntax: LCASE$ ( <Zeichenkette> )
Zeichenkette:einfacher String-Ausdruck
Rückgabe:String

Die Funktion LCASE$ wandelt in der übergebenen Zeichenkette die großen Buchstaben entsprechend dem ASCII-Zeichensatz in kleine um und liefert die umgewandelte Zeichenkette zurück. Eventuell vorhandene deutsche Umlaute bleiben unverändert.

LCASE$ ist identisch zur Funktion LOWER$. Aus Gründen der Kompatibilität zu diversen BASIC-Dialekten werden beide Funktionsnamen unterstützt.

LEFT$

Syntax: LEFT$ ( <Zeichenkette> , <Anzahl Zeichen> )
Zeichenkette:einfacher String-Ausdruck
Anzahl Zeichen:Integer-Ausdruck
Rückgabe:Integer

Die Funktion LEFT$ extrahiert aus der übergebenen Zeichenkette eine Teilzeichenkette, die aus den linken Anzahl Zeichen besteht.

LEN

Syntax: LEN ( <Zeichenkette> )
Zeichenkette:einfacher String-Ausdruck
Rückgabe:Integer

Die Funktion liefert die Länge der übergebenen Zeichenkette zurück.

Achtung! Bei Zeichenketten, die mehr als 32767 Zeichen enthalten, ist der Rückgabewert kleiner 0! Die interne String-Verarbeitung kann zwar so lange Zeichenketten nicht erzeugen, aber mit der Funktion MEMSTR$ sind überlange Zeichenketten prinzipiell möglich.

LNGVAL

Syntax: LNGVAL ( <Zeichenkette> )
LNGVAL ( <Zeichenkette> , <Zahlenbasis> )
Zeichenkette:einfacher String-Ausdruck
Zahlenbasis: Integer-Ausdruck mit dem Wert 2, 10 oder 16
Rückgabe: Long

Die Funktion LNGVAL versucht den Inhalt einer Zeichenkette als Zahl zu lesen und liefert deren numerischen Wert als Long-Wert zurück. Bzgl. der Argumente, des Formats der Zeichenkette und dem Setzen der Fehlervariablen gilt das gleiche wie bei der Funktion VAL, die zur Umwandlung einer Zeichenkette in einen Integer-Wert dient. Daneben gibt es noch die Funktion DECVAL, die eine Zeichnkette in einen Decimal-Wert umwandelt.

LOBYTE

Syntax: LOBYTE ( <Wert> )
Wert:Integer- oder Long-Ausdruck
Rückgabe:Integer

Die Funktion liefert vom übergebenen Wert nur den Wert des niederwertigen Bytes zurück, d.h., der Rückgabewert liegt immer im Bereich 0 bis 255.

Die Funktion LOBYTE hat die gleiche Wirkung wie <Wert> AND &H00FF, erzeugt aber schnelleren Programmcode.

LOWER$

Syntax: LOWER$ ( <Zeichenkette> )
Zeichenkette:einfacher String-Ausdruck
Rückgabe:String

Die Funktion LOWER$ wandelt in der übergebenen Zeichenkette die großen Buchstaben entsprechend dem ASCII-Zeichensatz in kleine um und liefert die umgewandelte Zeichenkette zurück. Eventuell vorhandene deutsche Umlaute bleiben unverändert.

LOWER$ ist identisch zur Funktion LCASE$. Aus Gründen der Kompatibilität zu diversen BASIC-Dialekten werden beide Funktionsnamen unterstützt.

LOWORD

Syntax: LOWORD ( <Wert> )
Wert:Long-Ausdruck
Rückgabe:Long

Die Funktion liefert von dem übergebenen Long-Wert nur den Wert der niederwertigen 16 Bit zurück, d.h., der Rückgabewert liegt immer im Bereich 0 bis 32767.

Die Funktion LOWORD hat die gleiche Wirkung wie <Wert> AND &H0000FFFF, erzeugt aber schnelleren Programmcode.

LTRIM$

Syntax: LTRIM$ ( <Zeichenkette> )
Zeichenkette:einfacher String-Ausdruck
Rückgabe:String

Die Funktion LTRIM$ liefert eine Teilzeichenkette, die mit dem ersten Zeichen beginnt, welches kein Leer- oder Steuerzeichen ist. Es werden somit die führenden weißen Leerzeichen abgeschnitten.

MAX

Syntax: MAX ( <numerischer Ausdruck> , <numerischer Ausdruck> [ , <numerischer Ausdruck> [ , ... ] ] )
Rückgabe: Decimal, wenn einer der übergebenen Ausdrücke Decimal ist,
sonst Long, wenn einer der übergebenen Ausdrücke Long ist,
sonst Integer

Die Funktion liefert den größten der in der Argumentliste angegebenen Werte zurück.

MEMSTR$

Syntax: MEMSTR$ ( <Adresse> )
Adresse:Integer-Ausdruck
Rückgabe:String

Die Funktion MEMSTR$ ermöglicht es, eine an der angegebenen Adresse im Arbeitsspeicher befindliche Zeichenkette als BASIC-String zu verwenden. Ein Nullbyte markiert das Ende der Zeichenkette. Folgendes Beispiel erzeugt im Arbeitsspeicher eine Zeichenkette mit dem Alphabet, auf die dann mit MEMSTR$ zugegriffen wird:

A=TOP
FOR I=65 TO 90
  POKE A,I
  A=A ADD 1
NEXT I
POKE A,0
PRINT MEMSTR$(TOP)

Das Gegenstück zu MEMSTR$ ist die Funktion STRPTR.

MID$

Syntax: MID$ ( <Zeichenkette> , <Position> )
MID$ ( <Zeichenkette> , <Position> , <Anzahl Zeichen> )
Zeichenkette:einfacher String-Ausdruck
Position:Integer-Ausdruck
Anzahl Zeichen:Integer-Ausdruck
Rückgabe:String

Die Funktion MID$ extrahiert aus der übergebenen Zeichenkette ab der angegebenen Position eine Teilzeichenkette und liefert diese zurück. Wird das dritte Argument angegeben, ist die Teilzeichenkette maximal Anzahl Zeichen lang. Anderenfalls geht die Teilzeichenkette bis zum Ende der Zeichenkette.

MIN

Syntax: MIN ( <numerischer Ausdruck> , <numerischer Ausdruck> [ , <numerischer Ausdruck> [ , ... ] ] )
Rückgabe: Decimal, wenn einer der übergebenen Ausdrücke Decimal ist,
sonst Long, wenn einer der übergebenen Ausdrücke Long ist,
sonst Integer

Die Funktion liefert den kleinsten der in der Argumentliste angegebenen Werte zurück.

MIRROR$

Syntax: MIRROR$ ( <Zeichenkette> )
Zeichenkette:einfacher String-Ausdruck
Rückgabe:String

Die Funktion MIRROR$ liefert ein gespiegeltes Abbild der übergebenen Zeichenkette zurück, d.h., das letzte Zeichen in der übergebenen Zeichenkette ist das erste Zeichen in der zurückgelieferten.

OCT$

Syntax: OCT$ ( <Wert> )
OCT$ ( <Wert> , <Anzahl Stellen> )
Wert:Integer- oder Long-Ausdruck
Anzahl Stellen:Integer
Rückgabe:String

Die Funktion OCT$ erzeugt eine Zeichenkette, die den übergebenen Wert als Oktalzahl darstellt. Bei negativen Werten erfolgt die Darstellung des Zweierkomplements. Lässt man das zweite Argument weg, ist die erzeugte Zeichenkette bei einem Integer-Wert sechs und bei einem Long-Wert elf Zeichen lang.

Mit dem optionalen zweiten Argument kann die Länge der zu erzeugenden Oktalzahl angegeben werden. Mögliche Werte sind bei einem Integer-Ausdruck 0 bis 6 und bei einem Long-Ausdruck 0 bis 11. Bei einer 0 wird die Oktalzahl ohne Vornullen mit sovielen Stellen erzeugt, wie zur vollständigen Darstellung des Wertes notwendig ist. Bei einer Stellenzahl größer 0 hat die Oktalzahl soviele Stellen wie angegeben, beginnend von rechts, d.h. mit den niederwertigsten Stellen.

PEEK

Syntax: PEEK ( <Adresse> )
Adresse:Integer-Ausdruck
Rückgabe:Integer

Die Funktion liest das Byte vom Arbeitsspeicher, welches auf der angegebenen Adresse steht, und liefert den Wert des Bytes zurück.

POINT

Syntax: POINT ( <X> , <Y> )
X: Integer-Ausdruck mit einem Wert >= 0
Y: Integer-Ausdruck mit einem Wert >= 0
Rückgabe:Integer

Die Funktion ermittelt die aktuelle Farbe des Pixels. Im Fehlerfall, d.h. wenn der angegebene Punkt außerhalb des Bildschirms liegt oder keine Grafikumgebung vorhanden ist, wird -1 zurückgeliefert. Lesen Sie bitte auch die Hinweise zur Grafikunterstützung!

Achtung! Wenn das BASIC-Programm für ein Zielsystem mit Farbunterstützung compiliert aber auf einem Computer ohne Farbunterstützung gestartet wird, liefert die Funktion falsche Werte zurück, da sie die Farbe aus dem (in dem Fall) nicht vorhandenen Farbspeicher liest.

POS

Syntax: POS ( )
POS ( <Dummy> )
Dummy: Integer-Ausdruck, beliebiger Wert ohne Bedeutung
Rückgabe:Integer

Die Funktion liefert die aktuelle Spaltennummer zurück, in der sich der Cursor befindet, beginnend mit 0. Ist der Cursor außerhalb des sichtbaren Bereichs oder unterstützt das Zielsystem das Auslesen der Cursor-Position nicht, liefert die Funtion den Wert -1 zurück.

Das übergebene Argument hat keine Bedeutung und wird syntaktisch nur aus Gründen der Kompatibilität zu anderen BASIC-Dialekten verstanden.

Die Funktion POS liefert die gleiche Information wie die Systemvariable CRSPOS.

PTEST

Syntax: PTEST ( <X> , <Y> )
X: Integer-Ausdruck mit einem Wert >= 0
Y: Integer-Ausdruck mit einem Wert >= 0
Rückgabe:Integer

Die Funktion ermittelt den Zustand eines Pixels. Ist das Pixel an der angegebenen Position gesetzt, wird 1 zurückgeliefert, bei nicht gesetztem Pixel eine 0. Im Fehlerfall, d.h. wenn der angegebene Punkt außerhalb des Bildschirms liegt oder keine Grafikumgebung vorhanden ist, wird -1 zurückgeliefert. Lesen Sie bitte auch die Hinweise zur Grafikunterstützung!

RIGHT$

Syntax: RIGHT$ ( <Zeichenkette> , <Anzahl Zeichen> )
Zeichenkette:einfacher String-Ausdruck
Anzahl Zeichen:Integer-Ausdruck
Rückgabe:String

Die Funktion RIGHT$ extrahiert aus der übergebenen Zeichenkette eine Teilzeichenkette, die aus den rechten Anzahl Zeichen besteht.

RND

Syntax: RND ( <Maximalwert> )
Maximalwert: Integer-Ausdruck mit Wert > 0
Rückgabe:Integer

Die Funktion liefert einen zufälligen Wert zwischen 0 (inklusive) und dem angegebenen Maximalwert (exklusive).

Beispiel Würfel (Ergebnis 1 bis 6):

PRINT "Wuerfelergebnis:";RND(6)+1

ROUND

Syntax: ROUND ( <Wert> )
ROUND ( <Wert> , <Modus> )
ROUND ( <Wert> , <Modus> , <Nachkommastellen> )
Wert: Decimal-Wert, der gerundet werden soll
Modus: Eine der Konstanten:
  • ROUND_HALF_UP (Betrag aufrunden, d.h. von der Null weg)
  • ROUND_HALF_EVEN (auf gerade Zahl runden)
  • ROUND_HALF_DOWN (Betrag abrunden, d.h. zur Null hin)
Der Modus kann auch mit einem variablen Ausdruck (z.B. Variable oder Funktionsaufruf) angegeben werden. Der Wert muss aber einem der drei Konstanten entsprechen.
Nachkommastellen: Anzahl der verbleibenden Nachkommastellen (Integer)
Rückgabe:Decimal

Die Funktion rundet den übergebenen Wert entsprechend des angegebenen Modus auf die angegebene Anzahl von Nachkommastellen. Wird die Anzahl der Nachkommastellen weggelassen, rundet die Funktion auf eine ganze Zahl. Der Rückgabetyp ist in dem Fall aber trotzdem Decimal. Wird zusätzlich der Modus weggelassen, kommt die Gerade-Zahl-Regel zur Anwendung.

Ist die Anzahl der gewünschten Nachkommastellen größer oder gleich der tatsächlichen, passiert nichts. Die Anzahl der gewünschten Nachkommastellen kann auch negativ sein. In dem Fall wird auf Zehner, Hunderter usw. gerundet. Wenn alle Stellen "weggerundet" werden, liefert die Funktion 0.

Beispiele:
BASIC-CodeAusgabe
PRINT ROUND( 1.234 ) 1
PRINT ROUND( 1.5 ) 2
PRINT ROUND( 2.5 ) 2
PRINT ROUND( 1.234, ROUND_HALF_DOWN, 2 ) 1.23
PRINT ROUND( 1.234, ROUND_HALF_UP, 2 ) 1.24
PRINT ROUND( 1.23400, ROUND_HALF_UP, 3 ) 1.234
PRINT ROUND( 1.23401, ROUND_HALF_UP, 3 ) 1.235
PRINT ROUND( -1.2345, ROUND_HALF_EVEN, 3 ) -1.234
PRINT ROUND( 1.23451, ROUND_HALF_EVEN, 3 ) 1.235
PRINT ROUND( 12345, ROUND_HALF_EVEN, -1 ) 12340
PRINT ROUND( 123450, ROUND_HALF_EVEN, -2 ) 123400
PRINT ROUND( 123451, ROUND_HALF_EVEN, -2 ) 123500


RTRIM$

Syntax: RTRIM$ ( <Zeichenkette> )
Zeichenkette:einfacher String-Ausdruck
Rückgabe:String

Die Funktion RTRIM$ schneidet von der übergebenen Zeichenkette am Ende stehende Leer- oder Steuerzeichen ab und liefert die so eventuell gekürzte Zeichenkette zurück. Es werden somit die angehängten weißen Leerzeichen abgeschnitten.

SCALE

Syntax: SCALE ( <Wert> )
Wert:Decimal-Ausdruck
Rückgabe: Integer (0 bis 7)

Die Funktion SCALE liefert vom übergebenen Wert die Anzahl der dezimalen Nachkommastellen zurück. Hinter dem Dezimalpunkt ganz rechts stehende Nullen, d.h. angehängte bzw. nachlaufende Nullen, werden nicht mitgezählt.

Beispiele:
BASIC-CodeAusgabe
PRINT SCALE( 1.000 ) 0
PRINT SCALE( 1.123 ) 3
PRINT SCALE( -1.123400 ) 4
PRINT SCALE( 123.001 ) 3


SGN

Syntax: SGN ( <numerischer Ausdruck> )
Rückgabe:Integer

Die Funktion liefert -1 zurück, wenn der Wert des angegebenen Ausdrucks kleiner 0 ist, 1 wenn der Wert größer 0 ist und 0, wenn der Wert 0 ist.

SPACE$

Syntax: SPACE$ ( <Anzahl> )
Anzahl:Integer-Ausdruck
Rückgabe:String

Die Funktion SPACE$ erzeugt eine Zeichenkette, die aus Anzahl Leerzeichen besteht.

SQR

Syntax: SQR ( <numerischer Ausdruck> )
numerischer Ausdruck:Integer- oder Long-Ausdruck
Rückgabe: gleicher Datentyp wie der übergebene numerische Ausdruck

Die Funktion liefert den ganzzahligen Anteil der Quadratwurzel aus dem Wert des angegebenen Ausdrucks zurück.

STR$

Syntax: STR$ ( <Wert> )
Wert:numerischer Ausdruck
Rückgabe:String

Die Funktion STR$ erzeugt eine Zeichenkette, die den übergebenen Wert als Dezimalzahl darstellt. Das erste Zeichen der erzeugten Zeichenkette ist entweder ein Leer- oder ein Minuszeichen.

STRING$

Syntax: STRING$ ( <Anzahl> , <Zeichencode> )
STRING$ ( <Anzahl> , <Zeichenkette> )
Anzahl:Integer-Ausdruck
Zeichencode:Integer-Ausdruck
Zeichenkette:einfacher String-Ausdruck
Rückgabe:String

Die Funktion STRING$ liefert eine Zeichenkette zurück, die aus Anzahl Wiederholungen der übergebenen Zeichenkette bzw. des mit seinem Code übergebenen Zeichens besteht. Die Anzahl der Wiederholungen wird im ersten Argument übergeben und kann auch 0 sein. In dem Fall wird eine leere Zeichenkette zurückgeliefert.

STRPTR

Syntax: STRPTR ( <Zeichenkette> )
Zeichenkette:einfacher String-Ausdruck
Rückgabe:Integer

Die Funktion STRPTR ermittelt die Anfangsadresse einer Zeichenkette. Damit ist es z.B. möglich, mit PEEK auf die Zeichenkette zuzugreifen oder die Zeichenkette an eine Assembler-Routine zu übergeben:

A$="..."
B=USR0(STRPTR(A$))

Prinzipiell könnte die Zeichenkette mit POKE auch geändert werden. Das sollte aber nicht getan werden, wenn die Zeichenkette ein im BASIC-Programm stehendes Literal ist, denn dann würde man den erzeugten Programmcode überschrieben. Auf keinen Fall darf man über das Ende der Zeichenkette hinaus schreiben!

Das Gegenstück zur STRPTR ist die Funktion MEMSTR$.

TRIM$

Syntax: TRIM$ ( <Zeichenkette> )
Zeichenkette:einfacher String-Ausdruck
Rückgabe:String

Die Funktion TRIM$ schneidet von der übergebenen Zeichenkette sowohl am Anfang als auch am Ende stehende Leer- oder Steuerzeichen ab und liefert die so eventuell gekürzte Zeichenkette zurück. Es werden somit die führenden und angehängten weißen Leerzeichen abgeschnitten.

TRUNC

Syntax: TRUNC ( <Wert> )
TRUNC ( <Wert> , <Nachkommastellen> )
Wert: Decimal-Wert, von dem Nachkommastellen abgeschnitten werden sollen
Nachkommastellen: Anzahl der verbleibenden Nachkommastellen (Integer, >= 0)
Rückgabe:Decimal

Die Funktion schneidet vom übergebenen Wert Nachkommastellen ab. Man kann die Anzahl der verbleibenden Nachkommastellen angeben. Lässt man den Parameter weg, werden alle Nachkommastellen abgeschnitten. Ist die Anzahl der gewünschten Nachkommastellen größer oder gleich der tatsächlichen, passiert nichts.

UCASE$
UPPER$

Syntax: UCASE$ ( <Zeichenkette> )
UPPER$ ( <Zeichenkette> )
Zeichenkette:einfacher String-Ausdruck
Rückgabe:String

Die Funktionen UCASE$ und UPPER$ wandeln in der übergebenen Zeichenkette die kleinen Buchstaben entsprechend dem ASCII-Zeichensatz in große um und liefert die umgewandelte Zeichenkette zurück. Eventuell vorhandene deutsche Umlaute bleiben unverändert.

Beide Funktionen sind identisch. Aus Gründen der Kompatibilität zu diversen BASIC-Dialekten werden beide Funktionsnamen unterstützt.

USR

Syntax: USR <Funktionsnummer> ( <Argument> )
Funktionsnummer:0...9
Argument:Integer-Ausdruck
Rückgabe:Integer-Wert

Mit USR wird eine von 10 möglichen Funktionen aufgerufen, die der Anwender in Maschinencode frei implementieren kann. Die Adresse muss vorher mit der Anweisung DEF USR festgelegt worden sein. Das Argument wird im DE-Register der Benutzerfunktion übergeben. Die Benutzerfunktion selbst muss mit einem Return-Befehl abgeschlossen sein. Der Wert, der sich zum Funktionsende im HL-Register befindet, wird an das BASIC-Programm zurückgegeben.

Das Schlüsselwort USR und die Funktionsnummer können sowohl zusammen als auch getrennt geschrieben werden, z.B.:

PRINT USR 0 (123)
PRINT USR0 (123)
PRINT USR 0(123)
PRINT USR0(123)

Im Gegensatz zur CALL-Anweisung kann man bei USR dem Maschinencodeunterprogramm einen Wert übergeben und einen zurückgeben lassen.

VAL

Syntax: VAL ( <Zeichenkette> )
VAL ( <Zeichenkette> , <Zahlenbasis> )
Zeichenkette:einfacher String-Ausdruck
Zahlenbasis: Integer-Ausdruck mit dem Wert 2, 10 oder 16
Rückgabe: Integer

Die Funktion VAL versucht den Inhalt einer Zeichenkette als Zahl zu lesen und liefert deren numerischen Wert als Integer zurück. Wird eine Zahlenbasis angegeben, erwartet die Funktion entsprechend dieser Basis eine Binär-, Dezimal- oder Hexadezimalzahl. Ohne dem zweiten Argument wird immer eine Dezimalzahl erwartet. Zahlen mit einer anderen Basis werden nicht unterstützt.

Bei Hexadezimalzahlen können die Buchstaben A bis F sowohl groß als auch klein geschrieben sein.

Die VAL-Funktion setzt die Fehlervariablen ERR und ERR$. Damit, insbesondere mit der ERR-Variable, kann geprüft werden, ob die Funktion erfolgreich war:

ERR-WertBedeutung
E_OK Zahl konnte gelesen werden
E_INVALID ungültige Zeichen gelesen, Rückgabewert ist 0
E_OVERFLOW numerischer Überlauf, d.h. die Zahl ist zu groß oder zu klein, Rückgabewert ist 0

Das Beispiel zeigt die VAL-Funktion in Verbindung mit der Fehlervariable ERR:

DO
  INPUT "Eingabe:";E$
  V=VAL(E$,2)
  IF ERR=E_OK THEN PRINT "Binaerzahl, Dezimalwert=";V
  V=VAL(E$,10)
  IF ERR=E_OK THEN PRINT "Dezimalzahl, Dezimalwert=";V
  V=VAL(E$,16)
  IF ERR=E_OK THEN PRINT "Hexadezimalzahl, Dezimalwert=";V
LOOP

Hinweis: In klassischen BASIC-Dialekten, die nicht typstreng sind, kann die Funktion VAL je nach übergebener Zeichenkette unterschiedliche Datentypen zurückliefern. Da der JKCEMU-BASIC-Compiler jedoch typstreng ist, muss schon zur Compile-Zeit feststehen, welcher Datentyp zurückgeliefert wird. Und das ist Integer. Möchte man größere Zahlen umwandeln, die außerhalb des Integer-Wertebereichs liegen, kann man DECVAL und LNGVAL verwenden. Diese Funktionen liefern einen Decimal- bzw. einen Long-Wert zurück. In Analogie zu den Namen DECVAL und LNGVAL gibt es auch die Funktion INTVAL, die Integer zurückliefert und identisch zu VAL ist.

VARPTR

Syntax: VARPTR ( <Variable> )
Rückgabe: Integer

Die Funktion VARPTR liefert die Adresse der übergebenen Variable bzw. des übergebenen Variablenfeldes zurück. Damit kann man z.B. in eigenen Assembler-Routinen auf BASIC-Variablen zugreifen.

Ist die übergebene Variable eine Feldvariable, so muss man das konkrete Feld angeben, dessen Adresse zurückgeliefert werden soll.

Achtung! Mit den Anweisungen POKE und DOKE kann man der Variable einen Wert zuweisen. Aber weisen Sie bitte niemals auf diese Art und Weise einer String-Variable einen Wert zu! Das kann die interne Speicherverwaltung durcheinander bringen. Und wenn Sie einer Decimal-Variable mit POKE oder DOKE einen Wert zuweisen, dann muss die Variable danach unbedingt ein gültiges BCD-Format haben! Anderenfalls kann es passieren, dass eine Division mit dieser Variable in einer Endlosschleife hängen bleibt.

W_CHAR

Die Systemvariable enthält die Breite des Bildschirms in Zeichenpositionen, d.h., es wird die Anzahl der sichtbaren Textspalten zurückgeliefert. Wenn dieser Wert nicht eindeutig feststeht bzw. bei dem Zielsystem unterschiedliche Werte möglich sind (z.B. bei CP/M), enthält die Variable den Wert -1.

Eine 0 wird zurückgegeben, wenn mit der SCREEN-Anweisung ein Grafikbildschirm eingestellt wurde, der keine Textausgaben zulässt.

W_PIXEL

Die Systemvariable enthält die Breite des vollgrafikfähigen Bildschirms in Pixel. Steht keine Vollgrafik zur Verfügung, wird der Wert 0 zurückgegeben. In dem Fall können die Grafikbefehle nicht verwendet werden.

XPOS

Die Systemvariable enthält die aktuelle X-Koordinate des Grafikcursors. Lesen Sie bitte auch die Hinweise zur Grafikunterstützung!

YPOS

Die Systemvariable enthält die aktuelle Y-Koordinate des Grafikcursors. Lesen Sie bitte auch die Hinweise zur Grafikunterstützung!