Im Gegensatz zu den oben aufgelisteten Wortsymbolen besitzen die in diesem Abschnitt vorgestellten Namen eine vordefinierte Bedeutung, die jedoch durch Deklarationen verändert werden kann.
Beispiel:
TYPE STRING = ARRAY[0..ALEN] OF CHAR;
In diesem Beispiel wird dem in Pascal 2.0 vordefinierten Typbezeichner STRING eine neue Bedeutung gegeben. Im Sichtbarkeitsbereich der obigen Deklaration wird deshalb mit dem Namen STRING ein ARRAY OF CHAR und nicht ein String variabler Länge bezeichnet.
| FALSE, TRUE | Konstanten des Typs BOOLEAN. Es gilt FALSE<TRUE, da ORD(FALSE)=0 und ORD(TRUE)=1 ist. |
| MAXINT | Konstante des Typs INTEGER mit dem Wert 32767. MAXINT ist die größte darstellbare ganze Zahl. |
| BOOLEAN | Vordefinierter Aufzählungstyp mit den Werten FALSE und TRUE. |
| INTEGER | Ganze Zahlen im Bereich von -MAXINT-1 bis MAXINT. |
| CHAR | Einzelne Zeichen. |
| REAL | Reelle Zahlen. Der Wertebereich ist wie in BASIC definiert. |
| TEXT | Dieser Filetyp ist definiert durchTYPE TEXT = FILE OF CHAR |
| STRING | Dieser Typbezeichner spielt eine Sonderrolle, da er eine ganze »Klasse« von Typen umfaßt: Durch die Angabe einer Feldlänge in eckigen Klammern nach dem Typnamen STRING kann die Maximallänge einer Stringvariablen festgelegt werden. |
| BYTE | Dieser Typbezeichner entspricht dem UnterbereichstypTYPE BYTE = 0..255 Werte des Typs BYTE belegen nur 1 Byte Speicherplatz. |
| INPUT | Diese Variable vom Typ TEXT (s.o.) ist beim Start eines Programmes automatisch mit dem Standardeingabemedium (der Tastatur) verbunden. |
| OUTPUT | Diese Variable vom Typ TEXT repräsentiert das Standardausgabemedium (den Bildschirm). |
| BANK | Die Operationen POKE, PEEK und SYS benötigen neben einer Adresse
noch die Angabe der anzusprechenden Bank.
In Pascal 2.0 wird die für diese Operationen gültige Bank mit der Variablen BANK verwaltet. Einerseits kann mit Zuweisungen die aktive Bank umgeschaltet werden, andererseits kann in Ausdrücken die Variable zum Bestimmen der momentan aktiven Bank bestimmt werden. Beim Start eines Pascalprogrammes wird die Variable BANK mit dem Wert 15 vorbelegt. |
Sinnvolle Werte für BANK liegen im Bereich zwischen 0 und 15:
| BANK | Konfiguration |
| 0 | nur RAM 0 |
| 1 | nur RAM 1 |
| 2 | nur RAM 2 (bzw. RAM 0) |
| 3 | nur RAM 3 (bzw. RAM 1) |
| 4 | Internes ROM, RAM 0, I/O Area |
| 5 | Internes ROM, RAM 1, I/O Area |
| 6 | Internes ROM, RAM 2, I/O Area |
| 7 | Internes ROM, RAM 3, I/O Area |
| 8 | Externes ROM, RAM 0, I/O Area |
| 9 | Externes ROM, RAM 1, I/O Area |
| 10 | Externes ROM, RAM 2, I/O Area |
| 11 | Externes ROM, RAM 3, I/O Area |
| 12 | Externes ROM (L), I/O, Rest RAM 0 |
| 13 | Externes ROM (L), I/O, Rest RAM 1 |
| 14 | BASIC, Kernal, CHARROM, Rest RAM 0 |
| 15 | BASIC, Kernal, I/O, Rest RAM 0 |
Durch die Wahl des RCR (ram configuration register) der MMU ist im Speicherbereich $0000 bis $0400 eine common-area deklariert. In diesem Bereich kann daher nur RAM in Bank 0 adressiert werden.
Beispiel:
BANK:=0; SYS(-195); (* Kaltstart ausfuehren *)
WRITELN('MOMENTAN IST BANK', BANK, ' AKTIVIERT');
WRITELN(PEEK(32767));
Die dynamischen Objekte werden nicht wie »normale« Variablen automatisch auf dem stack verwaltet, sondern besitzen einen eigenen Speicherbereich, den heap (s.a. Abschnitt 4.3.4). Reicht zur Laufzeit des Programmes der Speicher auf dem heap nicht mehr aus, so wird das Programm mit folgender Fehlermeldung beendet:
HEAP OVERFLOW ERROR
Der Heap ist als last-in-first-out-Speicher organisiert: Mit NEW wird am »unteren« Ende des heap Speicherplatz reserviert, während mit RELEASE Speicherplatz auch am »unteren« Ende freigegeben wird. Dieses Ende des heap wir durch einen sogenannten heappointer markiert.
Die Befehle MARK und RELEASE ersetzen in Pascal 2.0 (wie z.B. auch in TURBO-PASCAL) die in anderen Dialekten vorhandene Prozedur DISPOSE.
NEW(Zeigervariable)
Ein Aufruf dieser Standardprozedur stellt Speicherplatz für eine (neue) dynamische Variable zur Verfügung. Die Zeigervariable wird mit der Adresse des neuen Objektes initialisiert.
MARK(Zeigervariable)
RELEASE(Zeigervariable)
Um den mit einer Folge von Aufrufen der Prozedur NEW reservierten Speicherplatz wieder freizugeben, verwendet man die Prozeduren MARK und RELEASE. Vor den NEW-Operationen wird zunächst der Wert des heappointers mit der Prozedur MARK in einer Zeigervariablen gespeichert. Um nun den reservierten Speicherplatz wieder freizugeben, genügt der Aufruf der Prozedur RELEASE mit dieser Zeigervariablen. Dadurch wird der heappointer auf den mit MARK markierten Wert zurückgesetzt. Durch diese Art der Speicherverwaltung ist es nicht möglich, daß Lücken im heap existieren.
Um nicht zusammenhängende Speicherbereiche freizugeben, müssen explizit Freispeicherlisten (s. Kapitel 2) verwaltet werden.
Beispiel:
PROGRAM DYNAMIC(INPUT,OUTPUT); VAR A,B,C,X,Y: ^INTEGER; BEGIN MARK(Y); (* 1 *) NEW(A); NEW(B); MARK(X); (* 2 *) NEW(C); (* 3 *) RELEASE(X); (* 4 *) RELEASE(Y); (* 5 *) END.
Die folgende Abbildung zeigt die durch diese Prozeduraufrufe entstehende Speicherverteilung auf dem heap:
Bild 118: Wirkung der Prozeduren NEW, MARK und RELEASE
Filevariablen in Pascal 2.0 werden durch Dateien unter dem Betriebssystem des C-128 realisiert. Alle Befehle werden im Zusammenhang in Abschnitt 4.4.5 besprochen. Komplette Programmbeispiele finden sich in Kapitel 2.16, 2.17 und 3.1.
OPEN(Filevariable, Geräteadresse, Sekundäradresse, [Name])
Das genannte File wird zum Lesen, Schreiben oder Modifizieren eröffnet. Intern wird dem angegebenen File eine freie logische Filenummer zugewiesen, unter der die Filevariable vom Betriebssystem identifiziert wird. Mit dieser Nummer wird ein Aufruf der OPEN-Routine des Betriebssystems durchgeführt. Anschließend ist EOF(Filevariable)=FALSE und der Wert Filevariable^ ist undefiniert.
CLOSE (Filevariable)
Ein zuvor mit OPEN zum Schreiben oder Lesen eröffnetes File muß am Ende der Verarbeitung mit CLOSE geschlossen werden. Dies ist insbesondere vor einem erneuten OPEN erforderlich. Die mit OPEN reservierte logische Filenummer wird wieder freigegeben. Das Betriebssystem kann maximal 10 gleichzeitig eröffnete Files verwalten.
Nach CLOSE sind keine weiteren PUT-, GET-, READ- oder WRITE-Operationen mit der Filevariablen zulässig. Normalerweise erscheint in diesem Fall die Fehlermeldung
FILE NOT OPEN ERROR
Wurde jedoch inzwischen die mit CLOSE freigewordene logische Filenummer vom Betriebssystem erneut vergeben, so erfolgen die Ausgaben auf dieses neu eröffnete File.
EOF(Filevariable)
Das Ergebnis dieser Funktion (end of file) ist vom Typ BOOLEAN. EOF(F) ist TRUE, falls beim Lesen der Datei F das Fileende erreicht wurde. Beim Schreiben ist EOF(F) immer TRUE. EOF alleine ist die Abkürzung für EOF(INPUT). In diesem Abschnitt wird für jede Fileoperation beschrieben, wie der Funktionswert EOF verändert wird.
STATUS(Filevariable)
Diese Funktion existiert nur in Pascal 2.0 und besitzt den Ergebnistyp INTEGER. Pascal 2.0 orientiert sich bei Fileoperationen stark an den Vorgaben des report und verbirgt vor dem Benutzer die Realisierung der einzelnen Fileoperationen. Jedoch kann es in Spezialfällen sinnvoll sein, direkt auf die Betriebssystemebene herabzusteigen. Daher ermöglicht die Funktion STATUS direkt die Ergebnisse der Ein- und Ausgabeoperationen zu kontrollieren:
STATUS alleine ist die Kurzform für STATUS(INPUT).
Beispiel:
PROGRAM ST(INPUT,OUTPUT);
VAR F,G: TEXT;
LINE: STRING;
BEGIN
OPEN(F,8,3,'DATAREAD,S,R');
OPEN(G,8,5,'DATAWRITE,S,W');
WRITELN('F hat die logische Filenummer',
HBYTE(STATUS(F)));
WRITELN('G hat die logische Filenummer',
HBYTE(STATUS(G)));
REPEAT
READ(F,LINE);
WRITE(G,LINE);
UNTIL EOF(F);
IF (STATUS(F) AND 2)<>0 THEN
WRITELN('Zeitablauf beim Lesen');
IF (STATUS(F) AND 128)<>0 THEN
WRITELN('Gerät nicht angeschlossen');
IF (STATUS(F) AND 64)<>0 THEN
WRITELN('Datenende erreicht')
CLOSE(F); CLOSE(G);
END.
EOLN(Filevariable)
Diese Standardfunktion besitzt den Ergebnistyp BOOLEAN. Der Parameter Filevariable muß ein FILE OF CHAR, also ein Textfile sein. EOLN(F) liefert den Wert TRUE, falls beim Lesen mit READ(F, ...) das Zeilenende erreicht wurde.
Das Zeilenende in Pascal-Textdateien wird mit dem ASCII-Zeichen CR (carrirage return, CHR(13)) markiert. Ist jedoch EOLN(F)=TRUE, so enthält die Puffervariable F^ ein Leerzeichen (' ' = CHR(32)).
Wie bei EOF und STATUS entspricht EOLN alleine dem Prozeduraufruf EOLN(INPUT), so daß man den Zustand des Standardeingabefiles INPUT erhält.
PUT(Filevariable)
Nachdem ein File zum Schreiben eröffnet wurde, kann man es sequentiell mit Werten füllen. Der Aufruf PUT(F) überträgt den Inhalt der Puffervariablen F^ Byte für Byte auf das File F. Anschließend gilt EOF(F)=TRUE.
GET(Filevariable)
Um mit PUT erstellte Files zu lesen, verwendet man nach dem Eröffnen mit OPEN die Standardprozedur GET. Der Aufruf GET(F) füllt die Puffervariable F^ Byte für Byte mit dem Inhalt des Files. Außerdem wird der Lesezeiger im File um eine Position weitergesetzt. Ist nach dem Aufruf EOF(F)=TRUE, so ist der Wert F^ undefiniert.
Während das Betriebssystem des C-128 beim letzten übertragenen Byte einer Datei die Variable ST verändert, wird in Pascal EOF(F) erst dann TRUE, falls ein Wert hinter dem Fileende gelesen werden soll.
READLN(Filevariable)
Mit READLN(F) werden Zeichen bis zum Ende der Eingabezeile im Textfile F überlesen. Ist EOLN(F) beim Aufruf von READLN(F) bereits TRUE, so werden keine Zeichen gelesen.
READ(Filevariable, Parameter {,Parameter})
Von dem durch die Filevariable F angegebenen Textfile werden Werte verschiedener Typen gelesen. Die Eingabe hängt vom Typ der Parameter ab.
Beim Einlesen vom Standard-Eingabemedium INPUT erlaubt das Betriebssystem keine Eingabe von Strings der Länge 0. Wird die Eingabe nur durch die RETURN-Taste beendet, so erhält man einen String der Länge 1, der nur aus einem Leerzeichen besteht.
Werden mehrere Parameter genannt, so erfolgt die Eingabe direkt aufeinanderfolgend. EOF(F) ist nach READ(F,...) TRUE, falls das letzte Zeichen des Files gelesen wurde. Die Puffervariable F^ enthält in jedem Fall das letzte gelesene Zeichen. War dies ein Zeilenendezeichen (CR), so liefert die Funktion EOLN(F) den Wert TRUE. Die Puffervariable F^ enthält in diesem Fall jedoch ein Leerzeichen.
Die Angabe
READLN(Filevariable, Parameter {,Parameter})
entspricht der Anweisungsfolge
READ(Filevariable, Parameter {,Parameter});
READLN(Filevariable);
WRITELN(Filevariable)
Mit dem Prozeduraufruf WRITELN(F) wird auf dem File F ein Zeilenendezeichen (CR, carriage return, CHR(13)) geschrieben. Anschließend gilt: EOF(F)=TRUE und EOLN(F)=TRUE.
WRITE(Filevariable, Parameter {,Parameter})
Es können beliebig viele, durch Kommata getrennte Parameter genannt werden. Das Ergebnis der Ausgabe hängt von den Typen der Ausdrücke ab. Bei jedem Parameter X kann hinter einem Doppelpunkt eine Feldgröße N angegeben werden. Dies ist ein Ausdruck vom Typ INTEGER, der die Mindestanzahl an Zeichen angibt, die gedruckt werden. Ist der auszugebende Wert jedoch länger als die Feldgröße, so wird die Feldgröße ignoriert und der Wert mit minimaler Länge ausgegeben.
WRITE(X)
WRITE(X:N)
Bei einem reellen Ausdruck X ist jedoch auch ein zweiter Formatierungsparameter M zulässig, der die Anzahl der Nach- kommastellen festlegt:
WRITE(X:N:M)
Ist M>=0, so wird die Zahl X rechtsbündig in einem Feld aus N Stellen gedruckt. Dabei wird eine Festkommadarstellung mit M Nachkommastellen gewählt.
Ist M<0, so wird eine Exponentialdarstellung mit ABS(M) Nachkommastellen verwendet. N definiert wiederum die Feldgröße, in der die gesamte Zahl rechtsbündig ausgegeben wird.
Beispiele:
WRITE(-3.3); -3.30000000E+00 WRITE(-3.3:20); -3.30000000E+00 WRITE(-3.3:20:4); -3.3000 WRITE(-3.3:20:0); -3 WRITE(-3.3:8:-3); -3.300E+00
GETKEY(Variable)
Die Variable muß vom Typ CHAR sein. Es wird das nächste Zeichen des Tastaturpuffers gelesen. Wurde keine Taste gedrückt, so wird das Zeichen CHR(0) gelesen. In keinem Fall wird auf eine Tastatuereingabe gewartet. Außerdem erscheint kein blinkender Cursor am Bildschirm.
Da die RUN/STOP-Taste durch das Pascal-System nicht abgefragt wird, kann man auch explizit die Betätigung der RUN/STOP-Taste (mit dem Code CHR(3)) prüfen:
Beispiel:
PROGRAM GETIT(INPUT,OUTPUT);
VAR C: CHAR;
BEGIN
REPEAT
GETKEY(C); WRITE(C)
UNTIL C = CHR(3);
WRITELN('STOP-TASTE GEDRUECKT');
END.
KEYPRESSED
Diese Funktion liefert ein Ergebnis vom Typ BOOLEAN. Ist eine Taste gedrückt worden, so wird der Wert TRUE geliefert. Die Funktion ließe sich folgendermaßen durch GETKEY ersetzen:
FUNCTION KEYPRESSED: BOOLEAN; VAR C: CHAR; BEGIN GETKEY(C); KEYPRESSED:= C<> CHR(0); END;
ORD(Ausdruck)
Diese Funktion liefert als Ergebnis eine Zahl vom Typ INTEGER, die die Position des Parameters im Wertebereich angibt (0,1,2,...). Der Ausdruck muß einen skalaren Typ besitzen (also nicht REAL).
CHR(Ausdruck)
Diese Funktion liefert ein Zeichen mit dem ASCII-Code des INTEGER-Ausdruckes.
SUCC(Ausdruck)
Die Funktion liefert den Nachfolger im Wertebreich. Der Ausdruck muß einen skalaren Typ besitzen. Eine Prüfung auf Bereichsüberschreitung erfolgt nur, falls bei der Übersetzung die Option (*$R+ *) des Compilers aktiv war.
PRED(Ausdruck)
Die Funktion liefert den Vorgänger im Wertebereich. Sonst gelten die gleichen Nebenbedingungen wie sie bei SUCC beschrieben wurden.
ODD(Ausdruck)
Diese Funktion liefert den Wert TRUE, falls der Ausdruck vom Typ INTEGER ungerade ist:
Beispiel:
ODD(3) = TRUE ODD(-1) = TRUE ODD(0) = FALSE
ABS(Ausdruck)
Der Absolutbetrag des REAL- oder INTEGER-Argumentes wird berechnet. Das Ergebnis ist vom selben Typ wie der aktuelle Parameter.
INT(Ausdruck)
Der reelle Ausdruck wird in die nächstkleinere INTEGER-Zahl umgewandelt.
TRUNC(Ausdruck)
Bei dem reellen Ausdruck werden Nachkommastellen abgeschnitten um eine INTEGER-Zahl zu erhalten.
ROUND(Ausdruck)
Der reelle Ausdruck wird zur nächsten ganzen Zahl gerundet. Bei INT, TRUNC und ROUND erfolgt bei einer Überschreitung des Bereiches für INTEGER-Zahlen (-MAXINT-1 bis MAXINT) ein Programmabbruch mit Fehlermeldung.
Beispiele:
ROUND( 3.2) = 3 TRUNC( 3.2) = 3 INT( 3.2) = 3 ROUND( 3.7) = 4 TRUNC( 3.2) = 3 INT( 3.2) = 3 ROUND(-3.2) = 3 TRUNC(-3.2) = 3 INT(-3.2) = 4 ROUND(-3.7) = 4 TRUNC(-3.2) = 3 INT(-3.2) = 4
SQRT(X), LN(X), EXP(X), SIN(X), COS(X), ARCTAN(X)
Diese Funktionen liefern wie im report beschrieben zu den reellen Argumenten X die Werte der Funktionen Quadratwurzel, natürlicher Logarithmus, Exponentialfunktion, Sinus, Cosinus und Arcustangens. Das Ergebnis ist vom Typ REAL.
TAN(X)
Diese Funktion ist nicht im report aufgeführt. Sie liefert zu der reellen Zahl X den Tangens in Bogenmaß (ebenfalls vom Typ REAL).
SQR(X)
Diese Funktion quadriert die reelle Zahl X. Das Ergebis ist vom Typ REAL. Bei Zahlen vom Typ INTEGER sollte man stattdessen X*X schreiben.
POWER(X,Y)
Diese Funktion (nicht im report vorhanden) liefert zu den Ausdrücken X und Y vom Typ REAL den Wert X hoch Y vom Typ REAL. Die Berechnung erfolgt intern über die Logarithmus- und Exponentialfunktion. Daher sollte die Funktion POWER in l aufzeitkritischen Anwendungen für kleine ganzzahlige Y durch geeignete Multiplikationen ersetzt werden.
RANDOM(X)
Es wird eine Pseudo-Zufallszahl R aus dem Bereich
0 <= R < 1
erzeugt. Der Algorithmus zur Berechnung von R hängt vom Vorzeichen des INTEGER-Ausdruckes X ab:
In Anlehnung an die Stringoperationen anderer Pascal-Implementierungen wurden in Pascal 2.0 folgende vordefinierte Funktionen und Prozeduren aufgenommen:
INSERT(Stringausdruck,Stringvariable,Position)
Der Stringausdruck wird in die Stringvariable ab der genannten Position eingefügt. Liegt die Position nicht im Bereich 1..255, so wird das Programm mit der Fehlermeldung »ILLEGAL QUANTITY ERROR« abgebrochen. Überschreitet die Länge des Ergebnisstrings die für die Stringvariable deklarierte Maximallänge, so wird die Fehlermeldung »STRING OVERFLOW ERROR« ausgegeben. Befindet sich die Position hinter der aktuellen Länge der Stringvariablen, so werden die beiden Strings konkateniert:
Beispiel:
VAR S,T: STRING;
S:= 'Computer'; INSERT('Home-',S,1);
T:= 'kurz '; INSERT('und bündig',T,40);
Nach diesen Anweisungen besitzen die Strings die Werte 'Home-Computer' sowie 'kurz und bündig'.
DELETE(Stringvariable,Position,Länge)
Mit dieser Prozedur wird aus der Stringvariablen ab der genannten Position ein Teilstring der angegebenen Länge entfernt. Ist die Position außerhalb des Bereiches 1 bis 255 oder die Länge außerhalb des Bereiches 0 bis 255, so wird die Fehlermeldung »ILLEGAL QUANTITY ERROR ausgegeben. Liegt die Position hinter dem Ende des Strings, so werden keine Zeichen gelöscht. Ist die Summe aus Position und Länge größer als die Länge des Strings, so werden nur Zeichen innerhalb des Strings gelöscht.
CONCAT(Stringausdruck, Stringausdruck {,Stringausdruck})
Die Ergebnisse der Stringausdrücke werden konkateniert. Entstehen dabei Strings, die länger als 255 Zeichen sind, so wird die Programmausführung mit der Fehlermeldung »STRING OVERFLOW ERROR« beendet. Diese Funktion existiert nur, um kompatibel mit anderen Pascal-Implementierungen zu bleiben. Einfacher und übersichtlicher erreicht man eine Konkatenation von Strings mit dem »+« Zeichen.
Beispiel:
S:=CONCAT('Pascal', ' 2.0')
ist äquivalent zu
S:= 'Pascal' + ' 2.0'
COPY(Stringausdruck,Position, Länge)
Mit dieser Funktion wird aus demStringausdruck ein String ab der genannten Position mit der gegebenen Länge isoliert. Ist die Position außerhalb des Bereiches 1 bis 255 oder die Länge außerhalb des Bereiches 0 bis 255, so wird die Fehlermeldung »ILLEGAL QUANTITY ERROR« ausgegeben. Liegt Position hinter dem Stringende, so wird ein String der Länge 0 als Ergebnis geliefert. Ist die Summe aus Position und Länge größer als die Stringlänge, so werden nur Zeichen innerhalb des Strings übernommen.
Beispiel:
COPY('Beispielstring',1,8) liefert 'Beispiel'
COPY('Beispielstring',50,4) liefert ''
COPY('Beispielstring',9,99) liefert 'string'
LENGTH(Stringausdruck)
Es wird die Länge des Stringausdruckes übergeben. Bei Strings wird die aktuelle Länge in dem Element mit dem Index 0 gespeichert:
ORD(S[0]) = LENGTH(S)
Diese Längenangabe können Sie auch bewußt manipulieren, sind jedoch durch das Laufzeitsystem dann nicht mehr vor Fehlern geschützt:
Beispiel:
PROGRAM STEST(INPUT,OUTPUT);
VAR S: STRING;
I: INTEGER;
BEGIN
FOR I:= 1 TO 20 DO S[I]:= CHR(I-1+ORD('A'));
S[0]:= CHR(20);
WRITELN(S);
END.
In diesem Beispiel wird ein String indiziert mit den ersten 20 Buchstaben des Alphabets gefüllt. Anschließend wird das Längenfeld des Strings auf die Länge von 20 Zeichen gesetzt. Übersichtlicher ist jedoch sicher die folgende Programversion:
PROGRAM STEST2(INPUT,OUTPUT);
VAR S : STRING;
CH: CHAR;
BEGIN
S:= '';
FOR CH:= 'A' TO 'O' DO S:= S + CH;
WRITELN(S);
END.
POS(Stringausdruck1,Stringausdruck2)
Das Ergebnis dieser Funktion ist die Position des ersten Auftretens von Stringausdruck1 in Stringausdruck2. Ist Stringausdruck1 nicht in Stringausdruck2 enthalten, so ist das Funktionsergebnis die Zahl 0.
VAL(Stringausdruck)
Mit dieser Funktion wird der Argumentstring als eine Zahl interpretiert. Dabei werden Zahlen sowohl im Festkomma als auch im Exponentialformat umgewandelt. Das Ergebnis der Funktion ist immer vom Typ REAL. Treten illegale Zeichen im String auf, so werden nur die vorausgehenden Ziffern interpretiert. Ist bereits das erste Zeichen illegal, so ist das Ergebnis der Umwandlung die Zahl 0.0.
Beispiele:
VAL('3.0') = 3.0
VAL('-3000.0E-7') = -3.0E-4
VAL('12XXX34') = 12.0
VAL('MCC') = 0.0
STR(Ausdruck)
STR(Ausdruck : N)
STR(Ausdruck : N : M)
Der Ausdruck vom Typ REAL wird wie bei der Prozedur WRITE beschrieben formatiert. Die Formatierungsparameter erlauben ebenfalls eine Definition der Länge des Ergebnisstrings, die Wahl zwischen Festkomma- und Exponentialdarstellung, sowie die Angabe der zu druckenden Nachkommastellen in beiden Formaten. Beispiele finden sich bei der Beschreibung der Prozedur WRITE.