| |||||||||||||||||||||||||||||||||
|
| ||||||||||||||||||||||||||||||||
|
| |||||||||||||||||||||||||||||||||
|
|
| ||||||||||||||||||||||||||||||||
»ARexx-Kurs: Übersicht
1. Einführung in ARexx.
|
2. Programmstruktur und Ansteuerung von anderen Programmen
|
3. Ein- und Ausgabe; Funktionen
|
4. komplexere Programmstrukturen
|
5. Beispiele für die Vernetzung von Programmen
|
»
Der Kurs wird als reine Text-Datei angefertigt, da auch Amiga aktuell u.a. in ASCII-Form verschickt wird. Um den Text etwas zu gliedern, habe ich daher ein paar "Textmarker" eingefügt.
|
********** unterteilt einzelne Abschnitte
__________ bezeichnet Beginn und Ende eines ARexx-Programms. Die Striche
gehören nicht zum Programm! |
| Anmerkung: In der HTML-Version verwenden wir selbstverständlich entsprechende Formatierungen statt der Zeichenfolgen "***..." und "___...". |
Ich hoffe, daß diese Regelung den Kurs etwas leserlicher macht.
Wenn Ihr spezielle Fragen habt, etwas nicht verstanden habt oder Anregungen und Ideen für weitere Kursteile habt, könnt Ihr euch gerne an mich wenden. Ich selbst benutze folgende ARexx-fähige Programme und kann daher auf deren Programmierung kurz eingehen, wenn das gewünscht wird: Wordworth, GoldEd, Database Professional, YAM, Miami, Voyager, TurboCalc.
Hier meine Kontaktadresse:
Heiko Kuschel
Lehmgrubenweg 13
97280 Remlingen
E-Mail: hk0006@wuerzburg.baynet.de
Und jetzt... viel Spaß mit ARexx!
Für alle diese Fälle gibt es die Möglichkeit, Dateien zu öffnen und zu schließen. Sinnvollerweise mit der Funktion OPEN().
Erfolg=OPEN(Test,"Text:Golded/Amigaaktuell/ARexx-Kurs/03.txt","R")
öffnet diesen Text zum Lesen (R) und weist der Variable Erfolg den Wert 1
zu, wenn die Operation Erfolg hatte, und 0, wenn ein Fehler aufgetreten ist
(z.B., weil ich eine Verzeichnisebene ausgelassen habe... :-) ).
Die Datei kann jetzt unter dem Namen Test mit anderen Befehlen (keine
Angst, die kommen gleich!) angesprochen werden. Das ist der sogenannte
logische Dateiname.
Es gibt folgende Optionen:
R (Read) - Lesen
W (Write) - Schreiben (Achtung: Eine evtl. vorhandene Datei wird gelöscht!)
A (Append) - Anhängen
So, jetzt haben wir also eine Datei (hoffentlich) erfolgreich geöffnet. Statt einer Datei kann man mit OPEN() auch ein AmigaDos-Device öffnen, z.B. ein Konsolenfenster (CON:, oder für besondere Fälle, s.u., RAW:).
Was können wir mit der geöffneten Datei nun alles anfangen?
Wir können ein oder mehrere Zeichen aus der Datei lesen: Zeichen=READCH(Test,Anzahl) Vorsicht! Die Funktion wartet, bis so viele Zeichen wie angegeben eingetrudelt sind!
Wir können eine ganze Zeile (bis zum nächsten Absatzendezeichen) lesen:
Zeile=READLN(Test)
Das gleiche gibt's natürlich auch zum Schreiben in die Datei:
Ergebnis=WRITECH(Test,"Das hier soll in meine Datei geschrieben werden")
Ergebnis=WRITELN(Test,"Das hier soll in meine Datei geschrieben werden")
Im zweiten Fall wird am Schluß ein Absatzendezeichen angefügt.
Zum besseren Merken:
READ heißt Lesen
WRITE heißt Schreiben.
CH steht für Char, d.h. Zeichen.
LN steht für Line, d.h. Zeile.
Wenn ich nun eine Weile aus der Datei gelesen habe, kann es ja passieren,
daß mir irgendwann die Zeichen ausgehen, weil die Datei zu Ende ist. Das
kann ich überprüfen, indem ich folgenden Befehl anwende:
Erfolg=EOF(Test)
ergibt 1, wenn das Dateiende erreicht ist, ansonsten 0.
... man kann statt dessen auch die Zeilen zählen, und zwar mit der Funktion
Ergebnis=LINES(Test)
Das gibt allerdings die Zeilen zurück, die im Eingabepuffer stehen, ohne
Angabe eines Namens die Anzahl der Zeilen, die in STDIN stehen.
Unter Umständen kann es natürlich auch sinnvoll sein, den Zeiger auf ein
anderes Zeichen innerhalb der Datei zu verschieben. Das geht zeichenweise
vor sich, man sollte also genau wissen, wie die Datei aufgebaut ist.
NeuePosition=SEEK(Test,Offset,Modus)
Offset bedeutet die Anzahl der Zeichen, die weitergegangen werden soll.
Modus kann folgendes sein:
B - Begin
C - Current (momentane Position)
E - End
und besagt, worauf sich der Offset bezieht.
Vorsicht mit Offsets, die über das Dateiende hinausgehen!
Wie wäre es, das Ganze nun einmal mit einer Eingabekonsole zu versuchen? Unser gutes altes HelloWorld aus dem ersten Kursteil, aufgepeppt mit einer selber geöffneten Konsole:
/* Hello World Version 1.5.*/ |
Es reicht auch, einfach nur CON: einzugeben. Dann kannst Du allerdings Position und Titel des Fensters nicht beeinflussen. Im Unterschied zu CON: gibt RAW: jeden Tastendruck sofort weiter. Es muß nicht erst die Return-Taste gedrückt werden. Auf diese Weise kann man auch abfragen, ob eine bestimmte Taste gedrückt wurde.
Oft braucht man von einer Zeichenkette nur einen Teil, vielleicht den Vornamen, wo doch der ganze Name in einer Variablen gespeichert ist o.ä. Zur Behandlung von Zeichenketten gibt es in ARexx eine große Anzahl von Funktionen. Zwei davon haben wir schon im letzten Teil kurz angesprochen:
LASTPOS(Buchstabe,Zeichenkette)
gibt die Position des Buchstabens an, an der er zum letzten Mal in einer
Zeichenkette auftritt
Position=LASTPOS("e","Heiko Kuschel")
ECHO Position
|
ECHO LEFT("Heiko Kuschel",6)
|
Genauso sind alle anderen Stringfunktionen auch aufgebaut, die ich hier einfach mal aufliste:
ABBREV(Lang,Kurz,Länge)
Testet, ob Kurz eine Abkürzung (abbreviation) von Lang ist. Optional kann auch noch eine Anzahl von Zeichen angegeben werden, bis zu der verglichen werden soll. Liefert 0 (falsch) oder 1 (wahr)
CENTER(Text,Länge,Füllzeichen)
CENTRE(Text,Länge,Füllzeichen)
Liefert einen String, der die in Länge angegebene Zahl von Zeichen hat.
Optional kann ein Füllzeichen angegeben werden.
ECHO CENTRE("TesttextTesttext",4)
XTTE
ECHO CENTRE("TesttextTesttext",20)
TESTTEXTTESTTEXT
ECHO CENTRE("TesttextTesttext",20,".")
..TESTTEXTTESTTEXT..
ECHO CENTRE("TesttextTesttext",40,".")
............TESTTEXTTESTTEXT............
COMPRESS(String[,Liste])
Entfernt die in Liste angegebenen Zeichen aus einer Zeichenkette. Wird
Liste nicht angegeben, entfernt es alle Leerzeichen.
ECHO COMPRESS("Haeaikgog Kausgchael","ag")
COMPARE(Text1,Text2[,Füllzeichen])
Gibt die erste Stelle zurück, an der sich die beiden Texte unterscheiden. Optional kann angegeben werden, mit welchem Füllzeichen der kürzere der Texte aufgefüllt werden soll, wenn die zwei nicht gleich lang sind. Voreingestellt sind Leerzeichen.
COPIES(Zeichenkette,Anzahl)
Gibt Zeichenkette so oft aus, wie Du willst. Nur negativ darf die Zahl nicht sein.
DATATYPE(Zeichenkette[,Typ])
Gibt NUM als Ergebnis zurück, wenn Zeichenkette eine gültige Zahl ist,
ansonsten CHAR.
Wird ein Typ angegeben, dann kann auf diesen Typ geprüft werden. Ergebnis
ist in diesem Fall 0 oder 1.
Folgende Typen gibt's:
Alphanumeric A-Z, a-z, 0-9
Binary Binär-String
Lowercase a-z
Mixed A-Z, a-z
Upper A-Z
Numeric Zahl
Symbol ARexx-Symbol
Whole ganze Zahl
X Hexadezimalstring
DELSTR(Zeichenkette,Pos[,Länge])
Diese Funktion schneidet von Zeichenkette alles ab dem Buchstaben mit der Nummer ab, die in Pos angegeben ist. Wird Länge mit angegeben, so wird ab Pos ein Teilstring "herausgeschnitten".
DELWORD(Zeichenkette, Pos[,Anzahl])
Ähnlich wie DELSTR, nur geht's hier um ganze Wörter.
FIND(Zeichenkette,Worte)
Gibt die Anfangsposition der Worte in der Zeichenkette zurück. 0, wenn
nicht gefunden.
ECHO FIND("Heiko Kuschel", "Kuschel")
2
INDEX(Zeichenkette,Muster[,Start])
Sucht nach dem ersten Auftreten von Muster in Zeichenkette und gibt die
Position aus. 0, wenn nicht gefunden. Eine Startposition kann auch
angegeben werden.
Gleichbedeutend damit ist POS(). INDEX() existiert allerdings nur auf der
Amiga-Version von REXX.
INSERT(Quellstring,Zielstring[,Start,Länge,Füllzeichen])
Fügt den Quellstring ab der Startposition in den Zielstring ein. Wenn eine
Länge angegeben ist, kann sie auch mit Füllzeichen erreicht werden.
ECHO INSERT("ARexx-Kurs ","Ein ist eine klasse Sache",4)
EIN AREXX-KURS IST EINE KLASSE SACHE
Vorsicht: Die Füllzeichen werden an den Quellstring angehängt:
ECHO INSERT("ARexx-Kurs ","Ein ist eine klasse Sache",4,30,"!")
EIN AREXX-KURS !!!!!!!!!!!!!!!!!!!IST EINE KLASSE SACHE
LASTPOS(Muster, Zeichenkette[,Start])
Wie POS() bzw. INDEX(), nur von hinten.
LEFT(Zeichenkette,Länge[,Füllzeichen])
Gibt den linken Teil der Zeichenkette zurück, der Länge lang ist. Evtl. kann mit Füllzeichen aufgefüllt werden, falls die Zeichenkette kürzer ist als die Zahl, die in Länge steht.
LENGTH(Zeichenkette)
Gibt die Länge in Zeichen zurück
OVERLAY(Quelle, Ziel[,Start,Länge,Füllzeichen])
Damit wird eine Zeichenkette über eine andere gelegt. Im Gegensatz zu INSERT() geht dabei ein Teil des Zielstrings verloren. Das entspricht so ungefähr dem Überschreib-Modus in einem Editor oder einer Textverarbeitung.
POS()
ist gleichbedeutend mit INDEX()
REVERSE(Zeichenkette)
Dreht die Zeichenkette um. Aus ARexx wird xxeRA.
RIGHT(Zeichenkette,Länge[,Füllzeichen])
Wie LEFT(), nur daß der rechte Teil abgeschnitten wird.
SPACE(Zeichenkette, Zahl[,Füllzeichen])
Damit können zwischen einzelnen Wörtern im String beliebig viele Leerzeichen (oder andere Füllzeichen) eingefügt werden.
STRIP(Zeichenkette[,B|L|T,Zeichen])
... und damit kannst Du sie wieder entfernen.
Optional können auch nur die vorangestellten oder nachfolgenden (Leer-)
Zeichen entfernt werden.
L steht für Leading (vorangestellte)
T steht für Trailing (nachgestellte)
B steht für Both (beides) und ist voreingestellt.
SUBSTR(Zeichenkette,Start[,Länge,Füllzeichen])
Damit kann ein Teilstring aus einer Zeichenkette übernommen werden, und zwar ab Position Start, optional mit angegebener Länge und Füllzeichen.
SUBWORD(Zeichenkette,Start[,Anzahl])
Ähnlich wie SUBSTR(), nur mit ganzen Wörtern.
TRANSLATE(Zeichenkette[,rein,raus,Füllzeichen])
Leider kann dieser Befehl nichts in andere Sprachen übersetzen... aber
praktisch kann er trotzdem sein.
Er vergleicht die in raus angegebenen Zeichen mit der Zeichenkette. Findet
er eines, ersetzt er es durch das Zeichen, das in rein an gleicher Stelle
angegeben ist. Ist rein dafür zu kurz, nimmt er ein Leerzeichen oder das
optional angegebene Füllzeichen. Hmmmh. Kapiert? Vielleicht einmal ein
Beispiel:
ECHO TRANSLATE("Hioku Kaschil","aeiou","eioua")
HEIKO KUSCHEL
ECHO TRANSLATE("Amiga 1200","60","12")
AMIGA 6000
TRIM(Zeichenkette)
entfernt alle nachgestellten Leerzeichen in der Zeichenkette.
UPPER(Zeichenkette)
Wandelt alles in GROSSBUCHSTABEN um. Als ob ARexx das nicht sowieso schon dauernd tun würde...
VERIFY(Zeichenkette,Liste[,M|N,Startposition])
Überprüft, ob Zeichenkette nur Zeichen aus der Liste enthält. Wenn ja, ist
das Ergebnis 0, ansonsten die erste Position, an der ein fremdes Zeichen
gefunden wurde. Durch Angabe einer Startposition für die Suche kann man
dann auch weiter hinten stehende "falsche" Zeichen finden.
N steht für NOMATCH und ist voreingestellt, d.h., es wird nach Zeichen
gesucht, die *nicht* vorkommen.
Mit M (MATCH) wird dann nach Zeichen gesucht, die in der Zeichenkette
vorkommen.
WORD(Zeichenkette,x)
Gibt das x-te Wort aus der Zeichenkette aus, oder eine leere Zeichenkette, wenn so viele Wörter gar nicht vorhanden sind.
WORDINDEX(Zeichenkette,Zahl)
Gibt die Position in Zeichen aus, an der das x-te Wort steht.
ECHO WORDINDEX("Das ist ein kleines Beispiel",4)
13
Das heißt: Das vierte Wort beginnt mit dem 13. Buchstaben.
WORDLENGTH(Zeichenkette,Zahl)
Gibt die Länge des an Nummer Zahl stehenden Wortes zurück, oder 0, wenn es nicht so viele Wörter gibt.
WORDS(Zeichenkette)
Liefert natürlich die Anzahl der Wörter.
XRANGE([Start,Ende])
Liefert eine Zeichenkette, die alle ASCII-Codes von Start bis Ende enthält. Voreingestellt ist 0 bis 255.
Uff, das war's. Eine lange, ziemlich trockene Liste. Aber irgendwann muß ich Euch die ganzen Befehle ja mal sagen... Und deswegen geht's jetzt gleich noch weiter:
Keine Angst, das sind nicht ganz so viele!
ABS(Zahl)
Gibt den absoluten Wert einer Zahl zurück. Völlig unmathematisch
ausgedrückt: Entfernt das Minuszeichen vor der Zahl, wenn eins vorhanden
ist
DIGITS()
FORM()
FUZZ()
Diese Funktionen liefern die gerade eingestellten Werte für NUMERIC, der gleich noch besprochen werden soll.
MAX(Zahl1,Zahl2[,Zahl3,...])
liefert die größte dieser Zahlen
MIN(Zahl1,Zahl2[,Zahl3,...])
liefert die kleinste dieser Zahlen
RANDOM([MIN,MAX,STARTWERT])
Liefert eine Zufallszahl, optional kann eine kleinste und größte Zahl
angegeben werden. Als voreingestellter Startwert wird die Systemzeit
verwendet. Wenn Du immer die gleiche Abfolge von Zufallszahlen haben
willst, kannst Du einen Startwert angeben, der statt der Systemzeit
verwendet wird.
Anmerkung: Zufallszahlen zu erzeugen, ist mit einem Computer praktisch
unmöglich. Denn ein Computer arbeitet mit mathematischen Formeln, und deren
Ergebnis ist immer gleich. Deshalb nimmt man eine Formel, bei der die
nächste Zahl nicht so ohne weiteres vorhersehbar ist und bei der die
Ergebnisse halbwegs gleichmäßig über alle Zahlen verteilt sind, und füttert
sie mit einem Startwert, der weitgehend zufällig ist, nämlich der
Systemzeit zum Zeitpunkt des ersten Aufrufs dieser Funktion. Wird dagegen
immer der gleiche Startwert genommen, kommt auch immer die gleiche Folge
von Zahlen heraus. Auch das kann nützlich sein, wenn man einen immer
gleichen Ablauf haben will.
RANDU([Startwert])
Wie RANDOM(), nur daß der Rückgabewert immer zwischen 0 und 1 liegt. Die Zahl der Nachkommastellen wird mit NUMERIC DIGITS bestimmt (s.u.).
SIGN(Zahl)
liefert das Vorzeichen der Zahl oder 0 für 0.
TRUNC(Zahl[,Stellen])
Schneidet die Nachkommastellen ab (rundet nicht!). Optional kann eine Anzahl von Nachkommastellen angegeben werden.
Nun brauchen wir noch den NUMERIC-Befehl, der schon ein paar Mal angesprochen wurde. Er hat die folgenden Optionen:
NUMERIC DIGITS Zahl
Stellt ein, wie viele Stellen bei einer numerischen Operation
signifikant sind (1-14).
Ist die Zahl länger, wird die Exponentialschreibweise verwendet, z.B.
2.122E+3
NUMERIC FUZZ Zahl
Stellt ein, wie viele Stellen (von rechts) bei Vergleichsoperationen
*nicht* berücksichtigt werden sollen.
NUMERIC FORM (Scientific|Engineering)
Stellt die Form der Exponentialschreibweise ein. Da gibt es einen
Unterschied zwischen akademischer und Ingenieursschreibweise, der mir
allerdings nicht klar ist.
Jetzt brauchen wir natürlich noch die Möglichkeit, z.B. Zahlen in
Zeichenketten zu verwandeln usw.
Dafür gibt es in ARexx ein sehr einfaches System von Funktionen: Jede "Art"
von Zeichen hat einen Buchstaben:
B - Binär
C - Character (Buchstaben)
D - Dezimal
X - hexadezimal
... und "2" steht im Englischen manchmal für "to", weil's genauso ausgesprochen wird.
Also:
ECHO B2C("00100010 01101001")
"i
Gibt die Zeichen aus, die im ASCII-Code den hier angegebenen Binärzahlen
entsprechen.
Leider sind nicht alle Konvertierungsmöglichkeiten vorhanden, nur die
folgenden:
B2C()
C2B()
C2D()
C2X()
D2C()
D2X()
X2C()
X2D()
Bei C2D darf die Zeichenkette, die übergeben wird, maximal 4 Zeichen
enthalten. Sie darf auch ein Hex-String, z.B. "FFFF"x oder ein Binärstring,
z.B. "0011"b sein.
Optional kann bei C2D() ein Argument angegeben werden:
C2D("FFFF"x,2)
In diesem Fall wird der Binärwert der Zeichenkette als Zweierkomplement von
2 Bytes Länge behandelt. So kann man auch vorzeichenbehaftete Zahlen
erzeugen.
Bei D2C(Zahl[,Bytes]) kann ebenfalls ein zusätzlicher Wert angegeben werden. Er bewirkt, daß das Ergebnis die entsprechende Länge hat und entweder links abgeschnitten oder mit "00"x aufgefüllt wird.
Bei D2X() und X2D() kann die Zahl von Nibbles (4 Bits, also 2 Nibbles= 1
Byte) angegeben werden, damit auch negative Zahlen dargestellt werden
können.
ECHO X2D("FFE0",4)
-32
ECHO X2D("FFE0",6)
65504
ECHO X2D("FFE0")
65504
Noch ein paar Funktionen zur Bitmanipulation, mehr der Vollständigkeit
halber.
Binärzahlen werden in ARexx folgendermaßen geschrieben: "00010000"b
Leerzeichen dürfen nur an den Byte-Grenzen eingefügt werden!
Folgende Funktionen gibt es:
BITAND(BitStr1[,BitStr2,Füllzeichen])
ergibt eine UND-Verknüpfung der Bit-Strings. Die Funktion arbeitet nicht
korrekt, wenn die Strings unterschiedlich lang sind, da dann mit
Leerzeichen aufgefüllt wird! Dann muß das richtige Füllzeichen gewählt
werden, was auch nicht ganz problemlos ist.
ECHO C2B(BITAND("01010001"b,"11101110"b))
01000000
zu UND, ODER etc. vgl. unten!
BITCHG(BitString,Bit)
Invertiert das Bit an der angegebenen Stelle. Gezählt werden die Bits von rechts nach links!
BITCLR(BitString,Bit)
Löscht das angegebene Bit.
BITCOMP(BitStr1,Bitstr2[,Füllzeichen])
Vergleicht die beiden Bitstrings und liefert 0, wenn sie gleich sind, ansonsten die erste Position, an der sie sich unterscheiden. Sind die Strings nicht gleich lang, wird der kürzere am linken Ende mit Füllzeichen aufgefüllt.
BITOR(BitStr1[,BitStr2,Füllzeichen])
ergibt eine ODER-Verknüpfung der Bit-Strings. Ansonsten wie bei BITAND().
BITSET(BitString,Bit)
Setzt das angegebene Bit auf 1.
BITTST(BitString,Bit)
Testet, ob das angegebene Bit gesetzt ist. Liefert 1, wenn ja, sonst 0.
BITXOR(BitStr1[,BitStr2,Füllzeichen])
ergibt eine Exklusiv-ODER-Verknüpfung der Bit-Strings. Ansonsten wie bei BITAND().
Was bedeutet UND-, ODER- etc. Verknüpfung?
Ganz einfach: zwei Bits (also einzelne Speicherstellen) werden miteinander
verglichen, und abhängig von ihrem Zustand (0 oder 1) kommt es zu einem
Ergebnis.
Das geht nach folgender Tabelle:
Bit 1 | 0 1 0 1 | Vergleich
Bit 2 | 0 0 1 1 |
______|________________|____________
UND | 0 0 0 1 | Ergebnis
ODER | 0 1 1 1 |
XODER | 0 1 1 0 |
So, das war heute eine riesige Fülle von Befehlen. Leider ist dieser Kursteil dadurch etwas trockener geworden als die ersten zwei. Ich hoffe, Ihr verkraftet es und probiert nun selbst ein bißchen herum. Hier noch einmal die Zusammenfassung aller Befehle und Funktionen dieses Kursteils:
Ein-/Ausgabe:
EOF(LogName)
LINES(LogName)
OPEN(LogName,Pfad,"R"|"W"|"A")
READCH(LogName,Anzahl)
READLN(LogName)
SEEK(LogName,Offset,Modus)
WRITECH(LogName,Text)
WRITELN(LogName,Text)
Zeichenketten:
ABBREV(Lang,Kurz,Länge)
CENTER(Text,Länge,Füllzeichen)
CENTRE(Text,Länge,Füllzeichen)
COMPARE(Text1,Text2[,Füllzeichen])
COMPRESS(String[,Liste])
COPIES(Zeichenkette,Anzahl)
DATATYPE(Zeichenkette[,Typ])
DELSTR(Zeichenkette,Pos[,Länge])
DELWORD(Zeichenkette, Pos[,Anzahl])
FIND(Zeichenkette,Worte)
INDEX(Zeichenkette,Muster[,Start])
INSERT(Quellstring,Zielstring[,Start,Länge,Füllzeichen])
LASTPOS(Muster, Zeichenkette[,Start])
LEFT(Zeichenkette,Länge[,Füllzeichen])
LENGTH(Zeichenkette)
OVERLAY(Quelle, Ziel[,Start,Länge,Füllzeichen])
POS()
REVERSE(Zeichenkette)
RIGHT(Zeichenkette,Länge[,Füllzeichen])
SPACE(Zeichenkette, Zahl[,Füllzeichen])
STRIP(Zeichenkette{,B|L|T,Zeichen])
SUBSTR(Zeichenkette,Start[,Länge,Füllzeichen])
SUBWORD(Zeichenkette,Start[,Anzahl])
TRANSLATE(Zeichenkette[,rein,raus,Füllzeichen])
TRIM(Zeichenkette)
UPPER(Zeichenkette)
VERIFY(Zeichenkette,Liste[,M|N,Startposition])
WORD(Zeichenkette,x)
WORDINDEX(Zeichenkette,Zahl)
WORDLENGTH(Zeichenkette,Zahl)
WORDS(Zeichenkette)
XRANGE([Start,Ende])
mathematische Funktionen:
ABS(Zahl)
DIGITS()
FORM()
FUZZ()
MAX(Zahl1,Zahl2[,Zahl3,...])
MIN(Zahl1,Zahl2[,Zahl3,...])
NUMERIC DIGITS Zahl
NUMERIC FORM (Scientific|Engineering)
NUMERIC FUZZ Zahl
RANDOM([MIN,MAX,STARTWERT])
RANDU([Startwert])
SIGN(Zahl)
TRUNC(Zahl[,Stellen])
Konvertierungen:
B2C()
C2B()
C2D()
C2X()
D2C()
D2X()
X2C()
X2D()
Bitmanipulation:
BITAND(BitStr1[,BitStr2,Füllzeichen])
BITCHG(BitString,Bit)
BITCLR(BitString,Bit)
BITCOMP(BitStr1,Bitstr2[,Füllzeichen])
BITOR(BitStr1[,BitStr2,Füllzeichen])
BITSET(BitString,Bit)
BITTST(BitString,Bit)
BITXOR(BitStr1[,BitStr2,Füllzeichen])
So, das war's für heute. Sehr viele Informationen, sehr wenig Beispiele. Dafür haben wir schon fast alles von dem, was ich erst für den nächsten Kursteil geplant hatte, mit behandelt. Nächstes Mal gibt's wieder mehr "richtige" Beispiele, versprochen!«
