Next: Textdateien
Up: L3 Referenzhandbuch
Previous: Der ELAN Compiler
Der Datentyp INTEGER, der eine Untermenge der ganzen Zahlen repräsentiert, ist ein
elementarer Typ der Sprache ELAN. Der Wertebereich der 32 Bit Repräsentation liegt
zwischen -2 147 483 648 und 2 147 483 647.
Neben dem elementaren Typ Integer gibt es weitere Ganzzahltypen mit eingeschränktem oder erweitertem Wertebereich:
- TYPE BYTE:
- Vorzeichenloses Byte (8 Bit).
- TYPE WORD:
- Vorzeichenloses Wort (16 Bit).
- TYPE HINT:
- Vorzeichenbehaftetes Wort (16 Bit).
Wertebereich (-32768 bis 32767 ).
- TYPE INT:
- Vorzeichenbehaftetes Doppelwort (32 Bit).
Wertebereich
(-2147483648 bis 2147483647 ).
- TYPE DWORD:
- Vorzeichenloses Doppelwort (32 Bit).
- TYPE DINT:
- Vorzeichenbehaftetes Quadwort (64 Bit).
Wertebereich: (-9223372036854775808 bis
9223372036854775807 ).
Die interne Darstellung dieser Typen erfolgt durch die 80386 Datentypen BYTE,
WORD, DWORD und QUADWORD. Der Speicherplatzbedarf ist somit für jeden Datentyp der minimal erforderliche.
Für die »üblichen« Ganzzahltypen H(alf) Integer, Integer und D(ouble) Integer sind
alle üblichen arithmetischen Operationen bereitgestellt. Sollen Bytes, Worte oder
Doppelworte für Berechnungen herangezogen werden, sind die passenden Konvertierungsprozeduren zu benutzen, um sie in Integer umzuwandeln.
Die Notation von Integern kann zur Basis 2, zur Basis 10 oder hexadezimal erfolgen.
Binärnotation wird durch das Präfix 0b, hexadezimale Notation durch das Präfix 0x
angezeigt.
- Beispiel:
INT CONST i := 0x ff ,
j := 255 ,
k := 0b 1111 1111 ;
Hexadezimal- und Binärwerte werden nicht auf Integer Überlauf geprüft.
Nur INTEGER können in Zählschleifen (FOR Konstrukte), Selektionen (SELECT) oder
zur Subskription herangezogen werden.
INT
TYPE INT
:=
INT OP := (INT VAR a, INT CONST b)
- Wirkung: Zuweisung. Kopie des Wertes von 'b' in die Variable 'a'.
=
BOOL OP = (INT CONST a, b)
- Wirkung: Liefert 'TRUE' , falls 'a' gleich 'b' ist.
<>
BOOL OP <> (INT CONST a, b)
- Wirkung: Liefert 'TRUE', falls 'a' ungleich 'b' ist.
<
BOOL OP < (INT CONST a, b)
- Wirkung: Liefert 'TRUE', falls 'a' kleiner als 'b' ist.
<=
BOOL OP <= (INT CONST a, b)
- Wirkung: Liefert 'TRUE', falls 'a' kleiner oder gleich 'b' ist.
>
BOOL OP > (INT CONST a, b)
- Wirkung: Liefert 'TRUE', falls 'a' größer als 'b' ist.
>=
BOOL OP >= (INT CONST a, b)
- Wirkung: Liefert 'TRUE', falls 'a' größer oder gleich 'b' ist.
+
INT OP + (INT CONST a)
- Wirkung: Monadischer Operator (Vorzeichen, ohne Wirkung).
INT OP + (INT CONST a, b)
- Wirkung: Addition.
- Fehler: "INT-Überlauf". Das Ergebnis der Addition ist größer als max int
oder kleiner als min int.
-
INT OP - (INT CONST a)
- Wirkung: Vorzeichen-Umkehrung.
INT OP - (INT CONST a, b)
- Wirkung: Subtraktion.
- Fehler: "INT-Überlauf". Das Ergebnis der Subtraktion ist größer als max
int oder kleiner als min int.
*
INT OP * (INT CONST a, b)
- Wirkung: Multiplikation.
- Fehler: "INT-Überlauf". Das Ergebnis der Multiplikation ist größer als
max int oder kleiner als min int.
**
INT OP ** (INT CONST arg, exp)
- Wirkung: Exponentiation mit 'exp' >= 0
- Bemerkung: Ein negativer Exponent liefert das Ergebnis 0.
- Fehler: 0**0 ist undefiniert.
"INT-Überlauf".
abs
INT PROC abs (INT CONST argument)
- Wirkung: Absolutbetrag des INT-Wertes.
ABS
INT OP ABS (INT CONST argument)
- Wirkung: Absolutbetrag des INT-Wertes.
byte
BYTE PROC byte (INT CONST int)
- Wirkung: Liefert den Wert des niederwertigsten Bytes von 'int'.
DECR
OP DECR (INT VAR left, INT CONST right)
- Wirkung: Subtraktion. Entspricht left := left - right.
dint
DINT PROC dint (INT CONST int)
- Wirkung: Liefert den entsprechenden DINT Wert zu 'int'.
DIV
INT OP DIV (INT CONST a, b)
- Wirkung: Ganzzahldivision.
- Fehler: DIV durch 0
dword
DWORD PROC dword (INT CONST int)
- Wirkung: Liefert den entsprechenden DWORD Wert zu 'int'.
hint
HINT PROC hint (INT CONST int)
- Wirkung: Liefert den entsprechenden HINT Wert zu 'int'.
- Fehler: "INT Überlauf". Der Wert von 'int' liegt nicht zwischen -32768 und
32767.
INCR
OP INCR (INT VAR left, INT CONST right)
- Wirkung: Addition. Entspricht left := left + right.
initialize random
PROC initialize random (INT CONST n)
- Wirkung: Initialisierung des Generators für (Pseudo) Zufallszahlen. Die
Zufallszahlen werden durch sukzessiven Aufruf der Prozedur
random geliefert. Falls der Wert des Parameters 'n' erneut für
initialize random benutzt wird, wird die vorher gelieferte Reihe
von Zufallszahlen reproduziert.
max
INT PROC max (INT CONST left, right)
- Wirkung: Liefert das Maximum der beiden Werte.
max int
INT CONST max int
- Wirkung: Liefert den größten Wert, den der Typ INTEGER im L3
System annehmen kann ( 2 147 483 647 ).
min
INT PROC min ( INT CONST left, right)
- Wirkung: Liefert das Minimum der beiden Werte.
min int
INT CONST min int
- Wirkung: Liefert den kleinsten Wert, den der Typ INTEGER im L3
System annehmen kann (-2 147 483 648 ).
MOD
INT OP MOD (INT CONST left, right)
- Wirkung: Liefert die Divisionsrestklasse, vergl. REM.
- Beispiel: 3 MOD 2 ==> 1
-3 MOD 2 ==> 1
- Fehler: DIV durch 0
random
INT PROC random (INT CONST lower bound, upper bound)
- Wirkung: Liefert eine (Pseudo) Zufallszahl im Intervall zwischen 'lower
bound' und 'upper bound' und wird mittels 'initialize random'
initialisiert.
REM
INT OP REM (INT CONST left, right)
- Wirkung: Liefert den Divisionsrest, vergl.MOD.
- Beispiel: 3 REM 2 ==> 1
-3 REM 2 ==> -1
sign
INT PROC sign (INT CONST argument)
- Wirkung: Feststellen des Vorzeichens eines INT-Wertes.
argument > 0 ==> 1
argument = 0 ==> 0
argument < 0 ==> -1
SIGN
INT OP SIGN (INT CONST argument)
- Wirkung: Feststellen des Vorzeichens eines INT-Wertes.
argument > 0 ==> 1
argument = 0 ==> 0
argument < 0 ==> -1
text
TEXT PROC text (INT CONST number)
- Wirkung: Liefert die Darstellung von 'number' als ASCII Zeichenfolge. Falls
'number' einen negativen Wert hat, wird als Vorzeichen '-' vorangestellt.
TEXT PROC text (INT CONST number, length)
- Wirkung: Konvertierung von 'number' in einen Text der Länge 'length'. Falls
der Text kürzer als 'length' ist, wird er links (vorne) mit Leerzeichen aufgefüllt, falls er länger ist wird 'length' mal "*"
geliefert.
- Beispiel:
out ("X:"); out(text(12345,7)) ; line;
out ("Y:"); out(text(12345,3)) ;
(* ergibt *)
X: 12345
Y:***
word
WORD PROC word (INT CONST int)
- Wirkung: Liefert den Wert des niederwertigsten Wortes zu 'int'.
- Fehler: "INT Überlauf". Der Wert von 'int' liegt nicht zwischen 0 und
65535.
DINT
TYPE DINT
:=
DINT OP := (DINT VAR a, DINT CONST b)
- Wirkung: Zuweisung. Kopie des Wertes von 'b' in die Variable 'a'.
=
BOOL OP = (DINT CONST a, b)
- Wirkung: Liefert 'TRUE' , falls 'a' gleich 'b' ist.
<>
BOOL OP <> (DINT CONST a, b)
- Wirkung: Liefert 'TRUE', falls 'a' ungleich 'b' ist.
<
BOOL OP < (DINT CONST a, b)
- Wirkung: Liefert 'TRUE', falls 'a' kleiner als 'b' ist.
<=
BOOL OP <= (DINT CONST a, b)
- Wirkung: Liefert 'TRUE', falls 'a' kleiner oder gleich 'b' ist.
>
BOOL OP > (DINT CONST a, b)
- Wirkung: Liefert 'TRUE', falls 'a' größer als 'b' ist.
>=
BOOL OP >= (DINT CONST a, b)
- Wirkung: Liefert 'TRUE', falls 'a' größer oder gleich 'b' ist.
+
DINT OP + (DINT CONST a, b)
- Wirkung: Addition.
- Fehler: "INT-Überlauf". Das Ergebnis der Addition ist größer als max dint
oder kleiner als min dint.
-
DINT OP - (DINT CONST a, b)
- Wirkung: Subtraktion.
- Fehler: "INT-Überlauf". Das Ergebnis der Subtraktion ist größer als max
dint oder kleiner als min dint.
*
DINT OP * (DINT CONST a, b)
- Wirkung: Multiplikation.
- Fehler: "INT-Überlauf". Das Ergebnis der Multiplikation ist größer als
max dint oder kleiner als min dint.
abs
DINT PROC abs (DINT CONST argument)
- Wirkung: Absolutbetrag des DINT-Wertes.
DECR
OP DECR (DINT VAR left, DINT CONST right)
- Wirkung: Subtraktion. Entspricht left := left - right.
dint0
DINT PROC dint0
- Wirkung: Liefert DINT Wert '0'.
dint1
DINT PROC dint1
- Wirkung: Liefert DINT Wert '1'.
DIV
DINT OP DIV (DINT CONST a, b)
- Wirkung: Ganzzahldivision.
- Fehler: DIV durch 0
INCR
OP INCR (DINT VAR left, DINT CONST right)
- Wirkung: Addition. Entspricht left := left + right.
int
INT PROC int (DINT CONST dint)
- Wirkung: Liefert den Wert des niederwertigsten DWORDS von 'dint'.
max
DINT PROC max (DINT CONST left, right)
- Wirkung: Liefert das Maximum der beiden Werte.
max dint
DINT CONST maxdint
- Wirkung: Liefert den größten Wert, den der Typ DINT im L3 System
annehmen kann.
min
DINT PROC min (DINT CONST left, right)
- Wirkung: Liefert den kleineren der beiden Werte.
min dint
DINT CONST min dint
- Wirkung: Liefert den kleinsten Wert, den der Typ DINT im L3
System annehmen kann.
MOD
DINT OP MOD (DINT CONST left, right)
- Wirkung: Liefert die Divisionsrestklasse, vergl. REM.
- Beispiel:
dint( 3) MOD dint (2) ==> 1
dint(-3) MOD dint (2) ==> 1
- Fehler: DIV durch 0
sign
INT PROC sign (DINT CONST value)
- Wirkung: Vorzeichen eines DINT Wertes.
text
TEXT PROC text (DINT CONST number)
- Wirkung: Liefert die Darstellung von 'number' als ASCII Zeichenfolge. Falls
'number' einen negativen Wert hat, wird als Vorzeichen '-' vorangestellt.
HINT
TYPE HINT
:=
HINT OP := (HINT VAR a, HINT CONST b)
- Wirkung: Zuweisung. Kopie des Wertes von 'b' in die Variable 'a'.
=
BOOL OP = (HINT CONST a, b)
- Wirkung: Liefert 'TRUE' , falls 'a' gleich 'b' ist.
<>
BOOL OP <> (HINT CONST a, b)
- Wirkung: Liefert 'TRUE', falls 'a' ungleich 'b' ist.
<
BOOL OP < (HINT CONST a, b)
- Wirkung: Liefert 'TRUE', falls 'a' kleiner als 'b' ist.
<=
BOOL OP <= (HINT CONST a, b)
- Wirkung: Liefert 'TRUE', falls 'a' kleiner oder gleich 'b' ist.
>
BOOL OP > (HINT CONST a, b)
- Wirkung: Liefert 'TRUE', falls 'a' größer als 'b' ist.
>=
BOOL OP >= (HINT CONST a, b)
- Wirkung: Liefert 'TRUE', falls 'a' größer oder gleich 'b' ist.
+
HINT OP + (HINT CONST a, b)
- Wirkung: Addition.
- Fehler: "INT-Überlauf". Das Ergebnis der Addition ist größer als maxhint
oder kleiner als minhint.
-
HINT OP - (HINT CONST a, b)
- Wirkung: Subtraktion.
- Fehler: "INT-Überlauf". Das Ergebnis der Subtraktion ist größer als
maxhint oder kleiner als minhint.
*
HINT OP * (HINT CONST a, b)
- Wirkung: Multiplikation.
- Fehler: "INT-Überlauf". Das Ergebnis der Multiplikation ist größer als
maxhint oder kleiner als minhint.
DECR
OP DECR (HINT VAR left, HINT CONST right)
- Wirkung: Subtraktion. Entspricht left := left - right.
DIV
HINT OP DIV (HINT CONST a, b)
- Wirkung: Ganzzahldivision.
- Fehler: DIV durch 0
INCR
OP INCR (HINT VAR left, HINT CONST right)
- Wirkung: Addition. Entspricht left := left + right.
int
INT PROC int (HINT CONST hint)
- Wirkung: Liefert den entsprechenden INT Wert zu 'hint'.
max
HINT PROC max (HINT CONST left, right)
- Wirkung: Liefert das Maximum der beiden Werte.
maxhint
HINT CONST maxhint
- Wirkung: Liefert den größten Wert, den der Typ HINT im L3 System
annehmen kann.
min
HINT PROC min (HINT CONST left, right)
- Wirkung: Liefert das Minimum der beiden Werte.
minhint
HINT CONST minhint
- Wirkung: Liefert den kleinsten Wert, den der Typ HINT im L3
System annehmen kann.
MOD
HINT OP MOD (HINT CONST left, right)
- Wirkung: Liefert die Divisionsrestklasse, vergl MOD.
- Beispiel: hint( 3) MOD hint (2) ==> hint (1)
hint(-3) MOD hint (2) ==> hint (1)
- Fehler: DIV durch 0
DWORD
TYPE DWORD
:=
OP := (DWORD VAR a, DWORD CONST b)
- Wirkung: Zuweisung. Kopie des Wertes von 'b' in die Variable 'a'.
int
INT PROC int (DWORD CONST word)
- Wirkung: Liefert den entsprechenden INT Wert zu 'dword'.
WORD
TYPE WORD
:=
OP := (WORD VAR a, WORD CONST b)
- Wirkung: Zuweisung. Kopie des Wertes von 'b' in die Variable 'a'.
int
INT PROC int (WORD CONST word)
- Wirkung: Liefert den entsprechenden INT Wert zu 'word'.
BYTE
TYPE BYTE
:=
OP := (BYTE VAR a, BYTE CONST b)
- Wirkung: Zuweisung. Kopie des Wertes von 'b' in die Variable 'a'.
int
INT PROC int (BYTE CONST byte)
- Wirkung: Liefert den entsprechenden INT Wert zu 'byte'.
Der Wertebereich für Datenobjekte vom Type BOOL besteht aus TRUE und FALSE.
Werte des Typs BOOL können mit folgenden Operatoren verknüpft werden.
AND
BOOL OP AND (BOOL CONST a, b)
- Wirkung: Logisches UND. Die Reihenfolge der Auswertung ist unbestimmt.
Wenn der Operand, der zuerst ausgewertet wird, bereits FALSE
liefert, wird der zweite Operand nicht mehr ausgewertet.
CAND
BOOL OP CAND (BOOL CONST a, b)
- Wirkung: Bedingtes logisches UND. Der zweite Operand wird nicht ausgewertet, falls er für das Ergebnis nicht relevant ist.
Entspricht: IF a THEN b ELSE false FI.
- Bemerkung: Durch die festgelegte Reihenfolge der Auswertung kann z.B zuerst
überprüft werden, ob ein Index innerhalb gewisser Grenzen liegt,
bevor er zur Subscription herangezogen wird.
- Beispiel:
i > 0 CAND row [i] = 1
COR
BOOL OP COR (BOOL CONST a, b)
- Wirkung: Bedingtes logisches ODER. Der zweite Operand wird nicht ausgewertet, falls er für das Ergebnis nicht relevant ist.
Entspricht: IF a THEN true ELSE b FI.
false
BOOL CONST false
- Wirkung: Boolesche Konstante
NOT
BOOL OP NOT (BOOL CONST a)
- Wirkung: IF a THEN FALSE ELSE TRUE FI
OR
BOOL OP OR (BOOL CONST a, b)
- Wirkung: Logisches ODER. Die Reihenfolge der Auswertung ist unbestimmt.
Wenn der Operand, der zuerst ausgewertet wird, bereits TRUE
liefert, wird der zweite Operand nicht mehr ausgewertet.
true
BOOL CONST true
- Wirkung: Boolesche Konstante
XOR
BOOL OP XOR (BOOL CONST a, b)
- Wirkung: Exklusives ODER, liefert TRUE, wenn 'a' und 'b' ungleich, und
FALSE, wenn 'a' und 'b' gleich sind.
Bit-Operationen arbeiten in L3 auf Integer-Objekten. Sie können benutzt
werden, um Bitmasken zu erzeugen. Ein Integer hat 32 Bit. Das höchstwertige Bit hat
die Nummer 31, das niederwertigste die Nummer 0.
Ebenfalls vordefiniert sind einige dieser Operationen für DINTs, so daß auch Bitmasken der Länge 64 benutzt werden können.
AND
INT OP AND (INT CONST a, b)
- Wirkung: Bitweise UND-Verknüpfung von 'a' mit 'b'.
DINT OP AND (DINT CONST a, b)
- Wirkung: Bitweise UND-Verknüpfung von 'a' mit 'b'.
bit
BOOL PROC bit (INT CONST bits, bit no)
- Wirkung: Liefert TRUE, wenn das Bit mit der Nummer 'bit no' in dem INT
'bits' gesetzt ist.
- Beispiel:
IF bit (1024,10) THEN put("TRUE") FI ---> TRUE
lowest set
INT PROC lowest set (INT CONST bits)
- Wirkung: Liefert die Nummer des niederwertigsten auf 1 gesetzten Bits in
'bits'. Ist kein Bit auf 1 gesetzt, wird -1 geliefert.
lowest reset
lowest reset (INT CONST bits)
- Wirkung: Liefert die Nummer des niederwertigsten auf 0 gesetzten Bits in
'bits'. Ist kein Bit auf 0 gesetzt, wird -1 geliefert.
off
BOOL PROC off (INT CONST a, b)
- Wirkung: Liefert 'TRUE', falls (a AND b) = 0 ist.
on
BOOL PROC on (INT CONST a, b)
- Wirkung: Liefert 'TRUE', falls (a AND b) <> 0 ist.
OR
INT OP OR (INT CONST a, b)
- Wirkung: Bitweise ODER-Verknüpfung von 'a' mit 'b'.
DINT OP OR (DINT CONST a, b)
- Wirkung: Bitweise ODER-Verknüpfung von 'a' mit 'b'.
SHL
INT OP SHL (INT CONST a, b)
- Wirkung: Linksshift von 'a' um 'b' Bit.
- Beispiel: Schnelle Multiplikation mit 4:
17 SHR 4
SHR
INT OP SHR (INT CONST a, b)
- Wirkung: Rechtsshift von 'a' um 'b' Bit.
- Beispiel: Schnelle Division durch 4:
17 SHR 4
reset bit
PROC reset bit (INT VAR bits, INT CONST bit no)
- Wirkung: Das Bit mit der Nummer 'bit no' wird in 'bits' auf 0 gesetzt.
rotate
PROC rotate (INT VAR bits, INT CONST factor)
- Wirkung: Bits werden mit dieser Prozedur zyklisch geshiftet. Die Richtung
der Bitverschiebung wird durch das Vorzeichen von 'factor'
bestimmt. Ein positives Vorzeichen bewirkt Linksshift, ein negatives Rechtsshift.
- Bemerkung: Da zyklisch geshiftet wird, bewirkt ein Wert von 'factor' größer als
32 einen mehrfachen Zyklus.
- Beispiel:
rotate (1,1) ---> 2
rotate (1,2) ---> 4
rotate (1,-1) ---> minint
rotate (1,65) ---> 2
set bit
PROC set bit (INT VAR bits, INT CONST bit no)
- Wirkung: Das Bit mit der Nummer 'bit no' wird in 'bits' auf 1 gesetzt.
XOR
INT OP XOR (INT CONST a, b)
- Wirkung: Bitweise EXCLUSIV-ODER-Verknüpfung von 'a' mit 'b'.
DINT OP XOR (DINT CONST a, b)
- Wirkung: Bitweise EXCLUSIV-ODER-Verknüpfung von 'a' mit 'b'.
Realzahlen sind ein elementarer Datentyp der Sprache ELAN. Realzahlen werden in
ELAN Programmen in Punktnotation (z.B. 12.345), ggf. in Exponentialnotation (z.B.
1.2345e10) aufgeschrieben. Die Realzahlen stellen eine Untermenge der reellen
Zahlen dar. Die interne Darstellung ist die binäre 8 Byte-Fließkommadarstellung
gemäß der Norm IEEE 754. Sie entspricht im Hinblick auf interne Zahlendarstellung
damit dem für den INTEL 80387 geforderten Format. Dieses Format erlaubt die
Darstellung von Zahlen im ungefähren Bereich von 2.2e-308 bis 1.8e308. Die
Darstellung ist auf 15 bis 16 Dezimalstellen genau.
Wenn vorhanden, wird ein Coprozessor 80287/80387 benutzt. Falls dieser nicht
vorhanden ist, wird die standardmäßig in den L3 Systemkern eingebundene
Coprozessoremulation benutzt.
:=
REAL OP := (REAL VAR a, REAL CONST b)
- Wirkung: Zuweisung.
=
BOOL OP = (REAL CONST a, b)
- Wirkung: Liefert den Wahrheitwert der Aussage a = b
<>
BOOL OP <> (REAL CONST a, b)
- Wirkung: Liefert den Wahrheitwert der Aussage a <> b
<
BOOL OP < (REAL CONST a, b)
- Wirkung: Liefert den Wahrheitwert der Aussage a < b
<=
BOOL OP <= (REAL CONST a, b)
- Wirkung: Liefert den Wahrheitwert der Aussage a <= b
>
BOOL OP > (REAL CONST a, b)
- Wirkung: Liefert den Wahrheitwert der Aussage a > b
>=
BOOL OP >= (REAL CONST a, b)
- Wirkung: Liefert den Wahrheitwert der Aussage a >= b
+
REAL OP + (REAL CONST r)
- Wirkung: Monadischer Operator
REAL OP + (REAL CONST a, b)
- Wirkung: Liefert die Summe a + b (Addition).
-
REAL OP - (REAL CONST r)
- Wirkung: Vorzeichen-Umkehrung.
REAL OP - (REAL CONST a, b)
- Wirkung: Liefert die Differenz a - b (Subtraktion).
*
REAL OP * (REAL CONST a, b)
- Wirkung: Liefert das Produkt a * b (Multiplikation).
/
REAL OP / (REAL CONST a, b)
- Wirkung: Liefert den Quotienten a / b (Division).
- Fehler: Division durch 0
**
REAL OP ** (REAL CONST base, power)
- Wirkung: Exponentiation.
- Fehler: base < 0.0
0.0 ** 0.0
REAL OP ** (REAL CONST base, INT CONST power)
- Wirkung: Exponentiation.
- Fehler: 0.0 * 0
abs
REAL PROC abs (REAL CONST a)
- Wirkung: Absolutbetrag eines REAL-Wertes.
ABS
REAL OP ABS (REAL CONST a)
- Wirkung: Absolutbetrag eines REAL-Wertes.
arctan
REAL PROC arctan (REAL CONST r)
- Wirkung: Arcus Tangens Funktion. Liefert einen Wert im Bogenmaß.
arctand
REAL PROC arctand (REAL CONST r)
- Wirkung: Arcus Tangens Funktion. Liefert einen Wert in Grad.
cos
REAL PROC cos (REAL CONST r)
- Wirkung: Cosinus Funktion. 'r' muß im Bogenmaß angegeben werden.
cosd
REAL PROC cosd (REAL CONST r)
- Wirkung: Cosinus Funktion. 'r' muß in Grad angegeben werden.
decimal exponent
INT PROC decimal exponent (REAL CONST r)
- Wirkung: Liefert für den REAL-Wert 'r' den dezimalen Exponenten 'z', so
daß gilt: r = y * 10 ** z und 1.0 <= y < 10.0.
DECR
OP DECR (REAL VAR a, REAL CONST b)
- Wirkung: Wirkt wie a := a - b
e
REAL PROC e
- Wirkung: Liefert die Eulersche Zahl (ca. 2.718282).
exp
REAL PROC exp (REAL CONST x)
- Wirkung: Exponentialfunktion.
floor
REAL PROC floor (REAL CONST real)
- Wirkung: Schneidet die Stellen des REAL-Wertes 'real' nach dem Dezimalpunkt ab.
frac
REAL PROC frac (REAL CONST r)
- Wirkung: Liefert die Stellen eines REAL-Wertes hinter dem Dezimalpunkt.
INCR
OP INCR (REAL VAR a, REAL CONST b)
- Wirkung: Wirkt wie a := a + b
initialize random
PROC initialize random (REAL CONST z)
- Wirkung: Initialisierung des Generators für (Pseudo) Zufallszahlen im
Intervall zwischen 0.0 und 1.0. Die Zufallszahlen werden durch
sukzessiven Aufruf der Prozedur random geliefert. Falls derselbe
Wert des Parameters 'z' erneut für initialize random benutzt
wird, wird die vorher gelieferte Reihe von Zufallszahlen
reproduziert.
int
INT PROC int (REAL CONST x)
- Wirkung: Konvertierung in eine ganze Zahl. Die Nachkommastellen werden
abgeschnitten.
- Beispiel: int (3.9) ==> 3
ln
REAL PROC ln (REAL CONST x)
- Wirkung: Natürlicher Logarithmus.
- Fehler: x <= 0.0
log2
REAL PROC log2 (REAL CONST x)
- Wirkung: Logarithmus zur Basis 2.
- Fehler: x <= 0.0
log10
REAL PROC log10 (REAL CONST x)
- Wirkung: Logarithmus zur Basis 10.
- Fehler: x <= 0.0
max
REAL PROC max (REAL CONST a, b)
- Wirkung: Liefert das Maximum der beiden REAL-Werte.
maxreal
REAL CONST maxreal
- Wirkung: Liefert den größten REAL-Wert im L3-System.
min
REAL PROC min (REAL CONST a, b)
- Wirkung: Liefert das Minimum der beiden REAL-Werte.
MOD
REAL OP MOD (REAL CONST a, b)
- Wirkung: Liefert den Rest einer REAL Division (Restklasse).
- Beispiel: 5.0 MOD 2.0 ==> 1.0
4.5 MOD 4.0 ==> 0.5
4.5 MOD 4.4 ==> 0.1
pi
REAL CONST pi
- Wirkung: Liefert die Zahl pi (ca. 3.141593).
random
REAL PROC random
- Wirkung: Liefert eine (Pseudo) Zufallszahl im Intervall zwischen 0.0 und
1.0 und wird zuvor mit initialize random initialisiert.
round
REAL PROC round (REAL CONST real, INT CONST digits)
- Wirkung: Runden eines REAL-Wertes auf 'digits' Stellen. Für positive Werte
wird auf Stellen hinter dem Dezimalpunkt, für negative Werte von
'digits' auf Stellen vor dem Dezimalpunkt gerundet.
- Beispiel: round (3.14159, 3) ==> 3.142
round (123.456, -2) ==> 100.0
sign
INT PROC sign (REAL CONST argument)
- Wirkung: Feststellen des Vorzeichens eines REAL-Wertes.
INT OP SIGN (REAL CONST argument)
- Wirkung: Feststellen des Vorzeichens eines REAL-Wertes.
argument > 0 ==> 1
argument = 0 ==> 0
argument < 0 ==> -1
sin
REAL PROC sin (REAL CONST r)
- Wirkung: Sinus Funktion. 'r' muß im Bogenmaß angegeben werden.
sind
REAL PROC sind (REAL CONST r)
- Wirkung: Sinus Funktion. 'r' muß im Grad angegeben werden.
smallreal
REAL PROC smallreal
- Wirkung: Kleinster REAL-Wert im L3 System für den gilt:
1.0 - smallreal <> 1.0
1.0 + smallreal <> 1.0
sqrt
REAL PROC sqrt (REAL CONST x
- Wirkung: Wurzel Funktion.
- Fehler: x < = 0.0
tan
REAL PROC tan (REAL CONST r)
- Wirkung: Tangens Funktion. 'r' muß im Bogenmaß angegeben werden.
tand
REAL PROC tand (REAL CONST r)
- Wirkung: Tangens Funktion. 'd' muß in Grad angegeben werden.
text
TEXT PROC text (REAL CONST real)
- Wirkung: Konvertierung eines REAL-Wertes in einen TEXT der maximal 14
Zeichen umfaßt in Genauigkeit von maximal 7 Stellen hinter dem
Dezimalpunkt. Ggf. wird der TEXT in Exponentialnotation geliefert.
TEXT PROC text (REAL CONST real, INT CONST length)
- Wirkung: Konvertierung eines REAL-Wertes in einen TEXT der Länge 'length'
in Exponentialnotation. 'length' muß zwischen 8 und 25 liegen.
Bei Werten kleiner 8 wird 'length' mal "*" ausgegeben, bei zu
großen Werten wird 25 angenommen.
TEXT PROC text (REAL CONST real, INT CONST length, fracs)
- Wirkung: Konvertierung eines REAL-Wertes in einen TEXT in Punktnotation.
Dabei gibt 'length' die Länge des Resultats einschließlich des
Dezimalpunktes und des Vorzeichens, 'fracs' die Anzahl der
Stellen nach dem Dezimalpunkt an. Kann der REAL Wert nicht
wie gewünscht dargestellt werden, wird 'length' mal "*" geliefert.
underflow
BOOL PROC underflow
- Wirkung: Liefert TRUE, falls die letzte REAL Operation einen Wertunterlauf
erzeugte. Ein Unterlauf entsteht, wenn das Resultat einen so
kleinen Wert annimmt, daß eine korrekte interne Darstellung
nicht mehr möglich ist. Wenn dieser Fall eintritt, gilt underflow =
true. Das Resultat der Operation wird auf 0.0 gesetzt.
TEXT ist ein elementarer ELAN Datentyp, der Textobjekte variabler Länge aufnehmen
kann. ELAN kennt keine Unterscheidung der Typen "Character" (einzelnes Zeichen)
und "String" (Zeichenkette). Sowohl der leere Text (niltext) als auch einzelne
Zeichen ("A", "B" usw.) bis hin zur Zeichenkette der Länge 32000 (maxtextlength)
sind TEXTe.
Die Verwaltung von Textobjekten in Programmen zur Laufzeit ist dynamisch. Interna
über diese Verwaltung finden Sie am Ende dieses Abschnitts.
Texte werden nach den üblichen lexikalischen Regeln verglichen. Die Ordnung der
Zeichen ist durch die interne Darstellung, also die ASCII Codierung der Zeichen
bestimmt. Unter der Annahme 'a' < 'b' sind weiterhin folgende Ausdrücke wahr:
"" < "a"
"a" < "b"
"a" < "ab"
"aa" < "b"
"aa" < "ab"
Für den lexikalischen Vergleich (die Telefonbuchordnung) werden Regeln gemäß DIN
5007 benutzt. Die Operatoren LEXEQUAL, LEXGREATER und LEXGREATEREQUAL
prüfen nach folgenden Regeln:
-
Buchstaben haben die aufsteigende Reihenfolge 'A' bis 'Z'.
Dabei werden kleine und große Buchstaben gleich behandelt.
-
Umlaute werden behandelt als wären sie ausgeschrieben.
(Ä = Ae usw.) (ß = ss)
-
Alle Sonderzeichen (auch Ziffern) außer ' ' (Leerzeichen) und '-' werden ignoriert,
diese beiden Zeichen werden gleich behandelt.
Die ASCII Ordnung setzt also Ziffern vor Großbuchstaben, diese vor Kleinbuchstaben.
:=
TEXT OP := (TEXT VAR a, TEXT CONST b)
- Wirkung: Zuweisung.
=
BOOL OP = (TEXT CONST left, right)
- Wirkung: Vergleich von zwei Texten auf Gleichheit.
- Bemerkung: Texte mit ungleichen Längen sind immer ungleich.
<>
BOOL OP <> (TEXT CONST left, right)
- Wirkung: Vergleich zweier Texte auf Ungleichheit.
- Bemerkung: Texte mit ungleichen Längen sind immer ungleich.
<
BOOL OP < (TEXT CONST left, right)
- Wirkung: Liefert TRUE, falls der Text 'left' lexikographisch kleiner als 'right'
ist.
<=
BOOL OP <= (TEXT CONST left, right)
- Wirkung: Liefert TRUE, falls der Text 'left' lexikographisch kleiner oder
gleich 'right' ist.
>
BOOL OP > (TEXT CONST left, right)
- Wirkung: Liefert TRUE, falls der Text 'left' lexikographisch größer als
'right' ist.
>=
BOOL OP >= (TEXT CONST left, right)
- Wirkung: Liefert TRUE, falls der Text 'left' lexikographisch größer oder
gleich 'right' ist.
*
TEXT OP * (INT CONST xtimes, TEXT CONST text)
- Wirkung: 'text' wird 'xtimes' mal verkettet.
- Bemerkung: Falls 'xtimes' kleiner oder gleich Null ist, wird niltext geliefert.
- Beispiel: put (3 * "schwarzer Kater ")
+
TEXT OP + (TEXT CONST left, right)
- Wirkung: Verkettung der Texte 'left' und 'right' in dieser Reihenfolge.
- Bemerkung: Die Länge des Resultats ergibt sich aus der Addition der Länge der
Operanden.
CAT
TEXT OP CAT (TEXT VAR left, TEXT CONST right)
- Wirkung: Verknüpfung von 'left' und 'right'.
- Bemerkung: Entspricht left := left + right
CAT ist effizienter als die explizite Zuweisung.
change
PROC change (TEXT VAR text, TEXT CONST old, new)
- Wirkung: Ersetzung des (Teil-) TEXTes 'old' in 'text' durch 'new' beim
erstmaligen Auftreten.
- Bemerkung: Ist 'old' nicht in 'text' vorhanden, so wird keine Meldung abgesetzt.
Die Länge von 'text' kann sich bei dieser Operation verändern.
- Beispiel: TEXT VAR mein text :: "L3-Benutzerhandbuch";
change (mein text, "Ben", "N");
(* L3-Nutzerhandbuch *)
PROC change (TEXT VAR text, INT CONST from, to, TEXT CONST new)
- Wirkung: Der TEXT 'new' wird in den TEXT 'text' anstatt des TEXTes, der
zwischen 'from' und 'to' steht, eingesetzt. Die Länge von 'text'
kann sich dabei verändern.
changeall
PROC changeall (TEXT VAR text, TEXT CONST old, new)
- Wirkung: Ersetzt in 'text' jedes Auftreten von 'old' durch 'new'. Die Länge
von 'text' kann sich dabei ändern.
code
TEXT PROC code (INT CONST code)
- Wirkung: liefert das Zeichen, dessen ASCII Code angegeben ist.
- Bemerkung: Es muß gelten:0 <= code <= 255.
INT PROC code (TEXT CONST text)
- Wirkung: Wandelt ein Zeichen 'text' in einen INT-Wert um.
- Bemerkung: Falls length (text) <> 1 ist, wird der Wert -1 geliefert (also bei
mehr als einem Zeichen oder niltext).
compress
TEXT PROC compress (TEXT CONST text)
- Wirkung: Führende und abschließende Leerzeichen werden aus 'text'
entfernt.
is digit
BOOL PROC is digit (INT CONST code)
- Wirkung: Liefert TRUE, falls (code (code)) eine Ziffer ist.
is lowercase letter
BOOL PROC is lowercase letter (TEXT CONST code)
- Wirkung: Liefert TRUE, falls (code (code)) ein Kleinbuchstabe ist.
is uppercase letter
BOOL PROC is uppercase letter (INT CONST code)
- Wirkung: Liefert TRUE, falls (code (code)) ein Großbuchstabe ist.
length
INT PROC length (TEXT CONST text)
- Wirkung: Liefert die Länge (= Anzahl von Zeichen) von 'text' einschließlich
Leerzeichen.
LENGTH
INT OP LENGTH (TEXT CONST text)
- Wirkung: Liefert die Länge (= Anzahl von Zeichen) von 'text' einschließlich
Leerzeichen.
LEXEQUAL
BOOL OP LEXEQUAL (TEXT CONST left, right)
- Wirkung: Prüfung auf lexikalische Gleichheit.
- Beispiel: "Knödel" LEXEQUAL "Knoedel" (* => TRUE*)
siehe NORMEQUAL.
LEXGREATER
BOOL OP LEXGREATER (TEXT CONST left, right)
- Wirkung: Prüfung, ob der Text 'left' lexikalisch größer als 'right' ist.
LEXGREATEREQUAL
BOOL OP LEXGREATEREQUAL (TEXT CONST left, right)
- Wirkung: Prüfung, ob der Text 'left' lexikalisch größer oder gleich dem Text
'right' ist.
lowercase
PROC lowercase (TEXT VAR text)
- Wirkung: 'text' wird (ohne Kopie) in Kleinschreibung gewandelt. Jedes
Zeichen aus 'text', dessen Code zwischen 65 und 90 liegt, also
gerade die Großbuchstaben, wird in durch den entsprechenden
Kleinbuchstaben ersetzt.
TEXT OP LOWERCASE (TEXT CONST text)
- Wirkung: Liefert eine Textkopie von 'text', in der alle Großbuchstaben in
Kleinbuchstaben gewandelt sind.
NORMEQUAL
BOOL OP NORMEQUAL (TEXT CONST left, right)
- Wirkung: Liefert TRUE, falls UPPERCASE (left) = UPPERCASE (right).
- Beispiel: "Knödel" NORMEQUAL "KNÖDEL" (* => TRUE*)
"Knödel" NORMEQUAL "Knoedel" (* => FALSE*)
siehe LEXEQUAL.
max text length
INT PROC max text length
- Wirkung: Liefert die maximale Anzahl von Zeichen in einem TEXT (32 000).
pos
INT PROC pos (TEXT CONST text, pattern)
- Wirkung: Liefert die erste Position des ersten Zeichens von 'pattern' in 'text'.
- Bemerkung: Wird 'pattern' nicht gefunden oder ist 'pattern' niltext, so wird der
Wert '0' geliefert.
INT PROC pos (TEXT CONST text, pattern, INT CONST start)
- Wirkung: Es wird erst ab der Position 'start' gesucht. Dabei gilt folgende
Einschränkung: length (pattern) < 255
- Beispiel: TEXT VAR t1 :: "abcdefghijk...xyz",
t2 :: "cd";
... pos (t1, t2) ... (* liefert 3 *)
... pos (t2, t1) ... (* liefert 0 *)
INT PROC pos (TEXT CONST text, low char, high char, INT CONST start)
- Wirkung: Liefert die Position des ersten Zeichens 'x' in 'text' ab der Position
'start'. 'x' soll kein eindeutig bestimmtes Zeichen sein, sondern
ein Zeichen aus einer spezifizierten Menge von Zeichen. Diese
Spezifikation geschieht durch 'low char' und 'high char'. Dadurch
wird eine Zeichenmenge angegeben, deren (von der Codierung
gesehen) kleinstes Zeichen 'low char' und deren größtes Zeichen
'high char' ist.
- Bemerkung: 'low char' und 'high char' müssen TEXTe der Länge 1 sein. Wird
kein Zeichen in 'text' in dem Bereich zwischen 'low char' und
'high char' gefunden, wird der Wert '0' geliefert.
- Beispiel:
(* Suche nach Zeichen <> blank nach einer Leerspalte*)
TEXT VAR zeile :: "BlaBla Hier gehts weiter";
INT VAR pos erstes blank :: pos (zeile, " "),
ende leerspalte ::
pos (zeile,""33"",""254"", pos erstes blank);
replace
PROC replace (TEXT VAR text, INT CONST position, TEXT CONST new text)
- Wirkung: Ersetzung eines (Teil-) Textes in 'text' durch 'new text' an der
Position 'position' in 'text'.
- Bemerkung: Es muß gelten 1 <= position <= length (text) d.h. 'position'
muß innerhalb von 'text' liegen und 'new text' muß von der
Position 'position' ab in 'text' einsetzbar sein. Dabei bleibt die
Länge von 'text' unverändert.
SUB
TEXT OP SUB (TEXT CONST text, INT CONST pos)
- Wirkung: Liefert das Zeichen an der Stelle 'pos' aus 'text'.
Entspricht subtext (text, pos, pos) , ist jedoch effizienter .
- Bemerkung: Für pos <= 0 oder pos > length (text) wird niltext geliefert.
subtext
TEXT PROC subtext (TEXT CONST text, INT CONST from)
- Wirkung: Liefert den Teiltext von 'text', der bei der Position 'from' anfängt.
- Bemerkung: Die Länge des Resultats ergibt sich also aus length (text) - from + 1 d.h. von der Position 'from' bis zum Ende von 'text'.
'from' muß innerhalb von 'text' liegen. Ist 'from' < 1, dann wird
'text' geliefert. Falls from > length (text) ist, wird niltext
geliefert.
TEXT PROC subtext (TEXT CONST text, INT CONST from, to)
- Wirkung: Der Teiltext von 'text' von der Position 'from' bis einschließlich der
Position 'to' wird geliefert. Dabei muß gelten 1 <= from <= to <= length (text) d.h. die Positionen 'from' und 'to'
müssen in dieser Reihenfolge innerhalb von 'text' liegen.
Ist to >= length(text) wird subtext (text, from) ausgeführt.
Für die Bedingungen für 'from' siehe vorstehende Beschreibung
von 'subtext'.
text
TEXT PROC text (TEXT CONST text, INT CONST length)
- Wirkung: Liefert einen Teiltext aus 'text' mit der Länge 'length', beginnend
bei der Position 1 von 'text'. Das Resultat hat auf jeden Fall die
angegebene Länge.
TEXT PROC text (TEXT CONST text, INT CONST length, from)
- Wirkung: Liefert einen Teiltext aus 'text' ab der Position 'from' mit der
Länge 'length'.
- Bemerkung: Es muß gelten 1 <= 'from' <= length (text).
Für den Fall from > length (text) wird ein Text aus 'length'
Leerzeichen geliefert.
Für from < 0 wird text (text, length, 1) ausgeführt.
uppercase
PROC uppercase (TEXT VAR text)
- Wirkung: 'text' wird (ohne Kopie) in Großschreibung gewandelt. Jedes
Zeichen aus 'text', dessen Code zwischen 97 und 122 liegt, also
gerade die Kleinbuchstaben, wird in durch den entsprechenden
Großbuchstaben ersetzt.
TEXT OP UPPERCASE (TEXT CONST text)
- Wirkung: Liefert eine Textkopie von 'text', in der alle Kleinbuchstaben in
Großbuchstaben gewandelt sind.
Jedes Datenobjekt vom Typ TEXT besteht aus einem festen Teil und möglicherweise
aus einem flexiblen Teil auf dem Textheap. Im festen Teil werden Texte bis zur
Länge von 11 Zeichen untergebracht. Wenn eine TEXT-Variable einen Wert mit mehr
als 11 Zeichen Länge annimmt, werden alle Zeichen auf dem Heap untergebracht.
Der Textheap ist ein ausschließlich der Speicherung von Texten gewidmeter Abschnitt
eines Datenraums. Im Standarddatenraum ist der Textheap 14 MB groß. Er liegt im
Adreßbereich ab 0x1200000. Bei benutzerdefinierten Datenräumen sind Größe und
Lage des Textheaps einstellbar (siehe set min heapsize Kap.5).
Der Textheap des Standarddatenraums besteht aus Containern verschiedener Größe
zwischen 32 Bytes und 32 Kilobyte. Die 11 vorhandenen Containergrößen fassen
28 Bytes, 60 Bytes, 124 Bytes, 1*4 KBytes, 2*4 KBytes bis 8*4 KBytes. Der Textheap
von anderen Datenräumen (BOUND .... TEXT.... ) einfacher organisiert (siehe
unten).
Falls ein Textobjekt Platz auf dem Textheap benötigt, wird ihm dort der kleinstmögliche, passende Container zugewiesen. Der Platzbedarf von TEXTen richtet sich
also nicht nach der reinen Textgröße, sondern nach der erforderlichen Containergröße.
- Textdenoter
-
erhalten eine Sonderbehandlung. Ein Textdenoter 'd' wird im Standarddatenraum
mit den Länge len (d) + 1 im Datenbereich des ELAN Programms gespeichert.
len | 'len' text bytes..
0 1 ..254
Im ersten Byte ist die Länge des Denoters vermerkt, gefolgt vom Denoter selbst in
einer Länge zwischen 0 bis 254 Bytes.
- Kurze Textvariablen
-
bis zu einer Länge von 11 Byte werden Texte ohne Benutzung des Textheaps
gespeichert.
len | text bytes | heaplink
0 1 12 15
Nicht benutzte Textbytes und 'heaplink' sind undefiniert.
- Lange Textvariablen
-
Das 'heaplink' Feld enthält die 32 Bit Adresse des Containers in dem der Text
gespeichert ist.
0xff | xx | len | xxxx | heaplink
0 1 2 4 12 15
- Textcontainer im Standarddatenraum
-
Der Heap im Standarddatenraum ist in 11 Klassen von Textcontainern gegliedert.
Die ersten drei Klassen werden durch einen zusammenhängenden Abschnitt
gebildet. In diesem Abschnitt zur Verfügung:
Die Nutzlänge dieser Container ist um vier Byte geringer als ihre Bruttolänge, da
die ersten vier Byte den »Backlink« (die Adresse der Textvariable) enthalten.
Längere Texte werden in Textcontainern gespeichert, die eine Länge von n * 4KB
(1<=n<=8) haben. Sie tragen keine interne Verwaltungsinformation, bei ihnen ist
also Brutto = Nettolänge. Die Container werden nach Bedarf nach einem »first fit«
Algorithmus vergeben. Ein Text, der Platz in einer dieser Klassen benötigt, erhält
den kürzestmöglichen, »ersten« freien Container. Da durch Wachsen von Texten
Lücken entstehen und die Heapverwaltung stets bemüht ist, den Gesamtplatzbedarf des Textheap klein zu halten, finden unvorhersagbar Reorganisationen
(»Text-Müllabfuhr«, nicht zu verwechseln mit der System-Müllabfuhr) des Heap
statt.
Adressen auf dem Textheap (geliefert z.B. durch INT OP TADDR) sind also unsicher, weil nur unbestimmte Zeit gültig!
select container
PROC select container (TEXT VAR text, INT CONST length)
- Wirkung: Unabhängig von der aktuellen Länge von 'text' wird ein Container,
der 'length' Byte aufnehmen kann, auf dem Textheap reserviert.
shorten
PROC shorten (TEXT VAR text, INT CONST length)
- Wirkung: 'text' wird auf die Länge 'length' verkürzt, indem die Längenangabe auf den neuen Wert gesetzt wird. Die Textcontainerzuordnung
bleibt also unverändert.
In anderen Datenräumen als dem Standarddatenraum ist der Textheap ein
zusammenhängender Bereich, in dem Texte in Containern gespeichert werden, deren
Größe ein Vielfaches von 16 Byte ist.
Benutzerdef. Datenraum
0x0000 Zeiger auf ersten freien Container
0x0004 Zeiger auf ersten Container
...
Statischer
Teil des Datenraums
---------------
Erster Textcontainer
x.Textcontainer
...
y.Textcontainer
erster freier Container
Jeder Container hat in seinen ersten beiden Byte eine Kapazitätsangabe c (1 <= c
<= 2048). Die Kapazität des Containers errechnet sich durch (16 * c) - 2. Falls ein
Text über die Größe seines Containers hinaus wächst, wird ein neuer Container an
der Heapspitze zugewiesen. Eine »Müllabfuhr« auf dem Textheap findet nicht statt.
Es kann also nützlich sein, Daten in einen neuen Datenraum umzukopieren, wenn
sehr viel Speicherplatz durch »alte« Texte verbraucht wird.
Die Mindestgröße des Textheap in einem Datenraum kann mit der Prozedur set min
heapsize festgesetzt werden.
Next: Textdateien
Up: L3 Referenzhandbuch
Previous: Der ELAN Compiler
Michael Hohmuth
Sun Mar 31 04:49:53 MET DST 1996