BASIC-Compiler

Funktionen und Systemvariablen


Der Compiler kennt folgende BASIC-Funktionen:
 ABS  ASC  ASM  BIN$  CHR$  DEEK  EOF  ERR  ERR$  HEX$  HIBYTE  H_CHAR  H_PIXEL  IN  INKEY$  INP  INPUT$  INSTR  IS_TARGET  JOYST  LCASE$  LEFT$  LEN  LOBYTE  LOWER$  LTRIM$  MAX  MEMSTR$  MID$  MIN  MIRROR$  PEEK  POINT  PTEST  RIGHT$  RND  RTRIM$  SGN  SPACE$  SQR  STR$  STRING$  TRIM$  UCASE$  UPPER$  USR  VAL  W_CHAR  W_PIXEL  XPOS  YPOS

1. Datentyp des Rückgabewertes

Funktionen, die mit einem $-Zeichen enden, liefern eine Zeichenkette zurück. Alle anderen Funktionen haben einen numerischen Rückgabewert.

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

FunktionBedeutung
ABS Absoluter Betrag
ASC Zeichencode des ersten Zeichens einer Zeichenkette ermiteln
ASM Assemblerquelltext einfügen
BIN$ numerischen Wert in eine Binärzahl umwandeln
CHR$ Zeichencode in Zeichenkette 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
HEX$ numerischen Wert in eine Hexadezimalzahl umwandeln
HIBYTE Höherwertiges Byte 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
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
LOBYTE Niederwertiges Byte ermitteln
LOWER$ Zeichenkette in Kleinbuchstaben wandeln
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
PEEK 8-Bit-Wert (1 Byte) aus dem Arbeitsspeicher lesen
POINT Farbe eines Pixels ermitteln
PTEST Testen eines Pixels
RIGHT$ Ende einer Zeichenkette extrahieren
RND Ermitteln einer Zufallszahl
RTRIM$ angehängte weiße Leerzeichen abschneiden
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
TRIM$ weiße Leerzeichen abschneiden
UCASE$ Zeichenkette in Großbuchstaben wandeln
UPPER$ Zeichenkette in Großbuchstaben wandeln
USR In Maschinencode implementierte Funktion aufrufen
VAL Zeichenkette in einen numerischen Wert umwandeln
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

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

ABS

Syntax: ABS ( <numerischer Ausdruck> )

Die Funktion liefert den absoluten Betrag des Wertes des angegebenen Ausdrucks.

ASC

Syntax: ASC ( <Zeichenkette> )
Zeichenkette:einfacher String-Ausdruck

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

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! Der BASIC-Compiler enthält einen Global-Optimizer, der den erzeugten Assembler-Code durchgeht und unnötige Befehle entfernt. Dabei kann auch der mit ASM-Funktionen erzeugte Assembler-Code verändert werden. Der Global-Optimizer fasst aber nur solche Assembler-Zeilen an, bei denen die Befehls-Memonik durch einen Tabulator vom Zeilenanfang bzw. der Marke getrennt ist. Wenn sie also sichergehen wollen, dass der Optimizer Ihren Assembler-Code nicht verändert, dann verwenden Sie keine Tabulatoren in den ASM-Funktionen.

Achtung! Die ASM-Funktion greift direkt in die Programmcodeerzeugung ein und ist deshalb nur für Experten gedacht, die genau wissen, was sie tun!

BIN$

Syntax: BIN$ ( <Wert> )
BIN$ ( <Wert> , <Anzahl Stellen> )
Wert:numerischer Ausdruck
Anzahl Stellen:numerischer Ausdruck

Die Funktion BIN$ erzeugt eine Zeichenkette, die den übergebenen Wert als Binärzahl darstellt. Wird das zweite Argument weggelassen oder dieses ist 0, dann richtet sich die Anzahl der Stellen, d.h. die Länge der erzeugten Zeichenkette, nach der Größe des übergebenen Wertes.

CHR$

Syntax: CHR$ ( <Zeichencode> )
Zeichencode:numerischer Ausdruck

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.

DEEK

Syntax: DEEK ( <Adresse> )
Adresse:numerischer Ausdruck

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

EOF

Syntax: EOF ( <Kanal> )
EOF ( # <Kanal> )
Kanal: numerischer Ausdruck mit dem Wert 1 oder 2

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 die Fehlervariable gesetzt hat, kein Fehler aufgetreten ist. Ein Wert ungleich 0 steht für einen Fehler. Zum Auswerten der Fehlervariable ERR gibt es Fehlercodekonstanten.

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.

HEX$

Syntax: HEX$ ( <Wert> )
HEX$ ( <Wert> , <Anzahl Stellen> )
Wert:numerischer Ausdruck
Anzahl Stellen:numerischer Ausdruck

Die Funktion HEX$ erzeugt eine Zeichenkette, die den übergebenen Wert als Hexadezimalzahl darstellt. Wird das zweite Argument weggelassen oder dieses ist 0, dann richtet sich die Anzahl der Stellen, d.h. die Länge der erzeugten Zeichenkette, nach der Größe des übergebenen Wertes.

HIBYTE

Syntax: HIBYTE ( <Wert> )
Wert:numerischer Ausdruck

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.

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:numerischer Ausdruck

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: numerischer Ausdruck im Bereich 0 bis 255
Kanal: numerischer Ausdruck mit dem Wert 1 oder 2

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: numerischer Ausdruck
durchsuchte Zeichenkette: einfacher String-Ausdruck
gesuchte Zeichenkette: einfacher String-Ausdruck

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.

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: numerischer Ausdruck mit einem Wert >= 0

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 numerischen 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 "ab"
IF A AND JOYST_UP THEN PRINT "auf"
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

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:numerischer Ausdruck

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

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.

LOBYTE

Syntax: LOBYTE ( <Wert> )
Wert:numerischer Ausdruck

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 kürzeren und schnelleren Programmcode.

LOWER$

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

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.

LTRIM$

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

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> [ , ... ] ] )

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

MEMSTR$

Syntax: MEMSTR$ ( <Adresse> )
Adresse:numerischer Ausdruck

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+1
NEXT I
POKE A,0
PRINT MEMSTR$(TOP)

MID$

Syntax: MID$ ( <Zeichenkette> , <Position> )
MID$ ( <Zeichenkette> , <Position> , <Anzahl Zeichen> )
Zeichenkette:einfacher String-Ausdruck
Position:numerischer Ausdruck
Anzahl Zeichen:numerischer Ausdruck

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> [ , ... ] ] )

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

MIRROR$

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

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.

PEEK

Syntax: PEEK ( <Adresse> )
Adresse:numerischer Ausdruck

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: numerischer Ausdruck mit einem Wert >= 0
Y: numerischer Ausdruck mit einem Wert >= 0

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 nicht vorhandenen Farbspeicher liest.

PTEST

Syntax: PTEST ( <X> , <Y> )
X: numerischer Ausdruck mit einem Wert >= 0
Y: numerischer Ausdruck mit einem Wert >= 0

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:numerischer Ausdruck

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

RND

Syntax: RND ( <Maximalwert> )
Maximalwert: numerischer Ausdruck mit Wert > 0

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

RTRIM$

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

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.

SGN

Syntax: SGN ( <numerischer Ausdruck> )

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:numerischer Ausdruck

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

SQR

Syntax: SQR ( <numerischer Ausdruck> )

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

STR$

Syntax: STR$ ( <Wert> )
Wert:numerischer Ausdruck

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:numerischer Ausdruck
Zeichencode:numerischer Ausdruck
Zeichenkette:einfacher String-Ausdruck

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.

TRIM$

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

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.

UCASE$
UPPER$

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

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:numerischer Ausdruck

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: numerischer Ausdruck mit dem Wert 2, 10 oder 16

Die Funktion VAL versucht den Inhalt einer Zeichenkette als Zahl zu lesen und liefert deren numerischen Wert zurück. Wird eine Zahlenbasis angegeben, erwartet die Funktion entsprechend dieses 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ß, 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

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.