Inhalt

Artikel
REXX 1
REXX: Einleitung 1
REXX: Variablen 4
REXX: Aus- und Eingabe 5
REXX: Mathematisches und logisches 7
REXX: String ist alles 8
REXX: Anweisungen, Funktionen und Operatoren 10
REXX: Schleifen 11
REXX: Bibliotheken 13
REXX: Beispiele: Primzahlen 15
REXX: Befehlsumfang 16
REXX: Aufgaben 19
REXX: Quellen 19

Referenzen
Quelle(n) und Bearbeiter des/der Artikel(s) 20

Artikellizenzen
Lizenz 21
REXX 1

REXX
• Einleitung
• Variablen
• Aus- und Eingabe
• Mathematisches und Logisches
• String ist alles
• Anweisungen, Funktionen und Operatoren
• Schleifen
• Bibliotheken
• Beispiele
• Befehlsumfang
• Aufgaben
• Quellen

REXX: Einleitung
REXX (Abk. f. Restructured Extended Executor) ist eine von Mike Cowlishaw bei IBM entwickelte Skriptsprache.
Sie sollte (durch Verwendung englischer Wörter) einfach zu lernen sein und es erlauben, möglichst einfach
Kommandos an eine oder sogar mehrere Umgebungen (z. B. bei Einsatz als Makrosprache in einem Editor, wobei
auch Kommandos an eine Systemshell abgesetzt werden) zu senden.

Grundlegende Konzepte

Alles ist ein String

In klassischem Rexx (im Unterschied zum hier nicht behandelten, jedoch kompatiblen Objektorientierten Rexx) ist
jeder Wert ein String – auch Zahlen! Es ist also ohne weiteres möglich, Zahlenwerte mit String-Manipulationen zu
ändern und das Ergebnis sofort wieder als Zahl zu verwenden:

a = 2
a = a || '00'
say a / 2

Durch Anhängen zweier Nullen wird a mit 100 „multipliziert“; das Ergebnis, die Zeichenkette 200, kann sofort
wieder als Zahl verwendet werden. Ausgegeben wird 100.
Folgerichtig ist die Arbeit mit Strings in Rexx sehr einfach. Die obige Verkettungsoperation hätte auch

a = a'00'

geschrieben werden können. Ein oder mehrere Leerzeichen zwischen a und '00' hingegen hätten dazu geführt, dass
bei der impliziten Verkettung ein Leerzeichen eingefügt worden wäre – was sicher unerwünscht ist, wenn das
Ergebnis eine Zahl ist.
Wenn eine Zahl benötigt wird, weil der verwendete Operator mit Zahlen arbeitet, versucht Rexx, die vorliegenden
Wert als Zahl zu interpretieren:

say ' 1' + 2

gibt tatsächlich 3 aus.

REXX: Einleitung 2

Im Normalfall rechnet Rexx auf neun Dezimalstellen genau; durch Angabe einer höheren Anzahl kann jedoch fast
beliebig genau gerechnet werden. Es liegt nahe, dass diese wenig hardwarenahe Methode Rexx nicht unbedingt als
Sprache für sehr rechenintensive Probleme prädestiniert.

Auswertungslogik
Rexx wurde u. a. entwickelt, um auf einfache Weise Kommandos an eine Umgebung absetzen zu können. Dies wird
unterstützt durch die folgende Strategie bei der Auswertung einer Anweisung, die Rexx-Programme unempfindlich
gegenüber neu eingeführten Schlüsselwörtern macht und ein Alleinstellungsmerkmal der Sprache sind:
1. Wenn das zweite Token mit einem Gleichheitszeichen beginnt, handelt es sich um eine Wertzuweisung
Hieraus folgt, dass z. B.

if = 1

ungeachtet des Schlüsselworts if eine gültige Anweisung ist, die der Variablen IF den Wert 1 zuweist!
Hingegen wäre

if == 1

zwar ein gültiger logischer Ausdruck, der prüft, ob die Variable if exakt den Wert 1 hat; als eigenständige
Anweisung ergibt sie jedoch einen Syntaxfehler, weil der zuzuweisende Wert = 1 eben kein gültiger Ausdruck ist.
2. Ist das zweite Token ein Doppelpunkt, handelt es sich um eine Marke
Marken werden benötigt, um Prozeduren und Funktionen zu realisieren; diese notiert man in Rexx nach dem
„ausführbaren Teil“ des Programms. Beispiel:

say: funk('dir x')

exit
funk: return Arg(1)

Man könnte erwarten, dass dir x zur Standardausgabe ausgegeben wird. Das Schlüsselwort say fungiert hier jedoch
nur als Marke; der Ausdruck funk('dir x') bildet schon die nächste Anweisung. Gemäß Regel 4 (siehe unten) wird
also funk aufgerufen und dir x zur Ausführung an die Umgebung übergeben. (Es ginge natürlich auch ohne die
Funktion funk; dies nur als sehr einfaches Beispiel für einen Funktionsaufruf)
Es ist auch möglich, mit signal value Ausdruck eine bestimmte Marke anzusteuern; dies ist eher unüblich und nur in
bestimmten Fällen sinnvoll, z. B. als Alternative zu sehr großen select-Anweisungen.
3. Wenn das erste Token ein Schlüsselwort ist, erfolgt die Auswertung entsprechend dieser
Schlüsselwortanweisung
Solche Schlüsselwörter sind z. B. if, do, say. Man beachte, dass die Auswertung der Schlüsselwörter erst an dritter
Stelle günstig im Hinblick auf zukünftige Erweiterungen ist. Zukünftige Versionen der Sprache können so neue
Schlüsselwörter einführen, ohne dass existierende Programme überarbeitet werden müssen, sowohl Variablen als
auch Marken können ihren Namen behalten.
4. In jedem anderen Fall wird die Anweisung als Ausdruck ausgewertet und das Ergebnis an die Umgebung
übergeben
Dies bedeutet, dass die folgende Rexx-Anweisung (unter DOS, Windows, OS/2, …) den Inhalt des aktuellen
Verzeichnisses ausgibt:

dir

oder auch:

'dir'
REXX: Einleitung 3

Im ersten Fall ist dir eine Variable; wurde ihr kein Wert zugewiesen, so ist ihr Wert DIR (ihr Name in
Großbuchstaben), und es wird DIR an die Umgebung übergeben und ausgeführt. Im zweiten Fall wird garantiert dir
übergeben und ausgeführt.
Es könnte natürlich sein, dass eine zukünftige Rexx-Version ein Schlüsselwort dir einführt. Um sicherzugehen, dass
das Programm auch dann noch funktioniert, kann z. B. durch

''dir

erzwungen werden, dass die Anweisung als Ausdruck (Verkettung der Variablen mit dem Leerstring) erkannt wird;
oder man verwendet einfach die Variante, das Kommando als Stringkonstante zu übergeben.

Symbolnamen
Rexx unterscheidet bei syntaktischen Elementen (Schlüsselwörter und Bezeichner) nicht zwischen Groß- und
Kleinschreibung; aus Gründen der Lesbarkeit wird hier meist Kleinschreibung bevorzugt. Solange Bezeichnern kein
Wert zugewiesen wurde, haben sie als impliziten Wert ihren Namen in Großschreibung.
Bezeichner dürfen die ASCII-Buchstaben A bis Z (groß und klein), die Dezimalziffern, den Unterstrich, den Punkt,
sowie das Frage- und das Ausrufezeichen enthalten; ist das erste Zeichen eine Ziffer oder ein Punkt, handelt es sich
um eine Konstante, und eine Zuweisung würde einen Syntaxfehler erzeugen.

Strings
Strings dürfen sowohl durch Gänsefüßchen (wie in C) als auch durch Hochkommate (wie in Pascal) begrenzt
werden; das Begrenzungszeichen kann enthalten sein, wenn es gedoppelt wird. Stringliterale müssen vor dem
Zeilenende abgeschlossen, können allerdings per Fortsetzungszeichen mit dem Inhalt der nächsten Zeile verkettet
werden. Es gibt keine Variablenersetzung innerhalb von Strings und auch keine mit Backslash codierten Zeichen ('\n'
usw.).
Folgt nach dem schließenden Begrenzungszeichen der Bezeichner x, so wird der Inhalt als hexadezimaler Code
interpretiert und darf deshalb nur Hexadezimalziffern und, zur Gruppierung zwecks besserer Lesbarkeit, Leerzeichen
enthalten; entsprechend gibt es Binärstrings mit dem Suffix b.

Kommentare
Rexx unterstützt die von C bekannten, durch /* und */ begrenzten Kommentare, die Zeilenumbrüche beinhalten,
aber nicht geschachteln werden können.
REXX: Variablen 4

REXX: Variablen
Einleitung
Die Programmiersprache REXX kennt keine Typendeklaration.
Wenn eine Variable noch keinen Wert zugewiesen bekommen hat, also uninitialisiert ist, verhält sie sich wie ein in
Großbuchstaben geschriebener String:

say hallo => HALLO

Erst mit der Initialisierung ändert sich das:

hallo = 25
say hallo => 25
hallo = "say 5 + 3"
say hallo => say 5 + 3

Durch die Anweisung drop wird eine Variable deinitialisiert und vergessen.

hallo = "Guten Morgen"

say hallo => Guten Morgen
drop hallo
say hallo => HALLO

Werden in REXX Variablen mit Zahlen initialisiert – oder mit Strings, die sich als Zahl interpretieren lassen –, läßt
sich mit ihnen rechnen:

a = 25
b = '17'
say a + b => 42
say a - b => 8
say a * b => 425

Um Stringverkettungen vorzunehmen, wird daher ein eigener Operator benötigt:

say a || b => 2517

Stems
Stems haben in vielerlei Hinsicht Ähnlichkeiten mit Arrays:

do i = 1 to 10
zahl.i = 10 - i
end
zahl.0 = i - 1 /* => 10; per Konvention */

do i = 1 to zahl.0
say i')' zahl.i
end i

Danach existieren folgende Variablen mit folgender Zuordnung: zahl.1 = 9, zahl.2 = 8, zahl.3 = 7 ... Per
Konvention wird unter dem Index 0 die Anzahl der gespeicherten Elemente abgelegt. Mit drop zahl. können
dann alle elf Variablen der Form zahl.i mit einem Schlag entfernt werden.
REXX: Variablen 5

Nicht jeder Index muß verwendet werden; nicht zugewiesene Variablen belegen keinen Speicherplatz. Der folgende
Code erzeugt ein spärlich besetztes Array:

a = 2
do 5
b = 2*a-1
p.a = b
a = b
end

Nach dem Ablauf existieren folgende Variablen mit folgender Zuordnung: p.2 = 3, p.3 = 5, p.5 = 9, p.9 =
17, p.17 = 33.
Diese Art der Variablen wird als Stem-Variablen bezeichnet; der erste Teil einschließlich des ersten Punkts wird als
Stem bezeichnet, der Rest als Tail. Der Tail kann auch aus mehreren Symbolen bestehen, die durch Punkte
voneinander getrennt werden; auf diese Weise können auch mehrdimensionale Arrays realisiert werden. Die Werte
der verwendeten Symbole können beliebig sein; sie sind durchaus nicht auf Zahlen beschränkt.

REXX: Aus- und Eingabe

Ausgabe

Ausgabe über den Bildschirm

Wenn man in REXX etwas über den Bildschirm ausgeben will, macht man das über die Anweisung say:

say ausdruck

Der Ausdruck wird zur Standardausgabe ausgegeben.

Ausgabe in eine Datei

call lineout dateiname,ausdruck

Dabei kann als Dateiname 'stderr' für die Standardfehlerausgabe und 'stdout' bzw. der Leerstring '' für
die Standardausgabe (dann entsprechend der SAY-Anweisung) angegeben werden.

Eingabe

Eingabe über die Tastatur

Die Eingabe über die Tastatur erfolgt über die Anweisung pull:

pull variable

Strenggenommen ist pull eine Abkürzung für parse upper pull, konvertiert also die Daten in Großschreibung;
außerdem kommen die Daten aus der aktuellen Standard-Queue, sofern diese Daten enthält (was allerdings
normalerweise nicht der Fall ist).
REXX: Aus- und Eingabe 6

Eingabe aus einer Datei

variable=linein(dateiname)

Wenn man sicher gehen will, dass im Eingabestrom noch Zeilen vorhanden sind, kann man die Funktion lines()
verwenden:

variable = lines(dateiname)

Der zurückgelieferte Wert gibt an, ob sich noch Zeilen im Eingabestrom befinden (0 oder 1); im Fall der aktuellen
Standardqueue ("QUEUE:"), oder wenn das Dateisystem Zeilenangaben unterstützt, kann es sich auch um die
Anzahl handeln.
Für den Fall, dass man einzelne Zeichen lesen will, gibt es die zu linein() und lines() analogen Funktionen charin()
und chars()

charin(dateiname)
variable = chars(dateiname)

Übergabe bei Start eines REXX-Programms

Wie bei den meisten Programmiersprachen lassen sich beim Start eines Programms Argumente übergeben. Diese
lassen sich mit der parse-arg-Anweisung oder der Funktion arg ermitteln:

/* Ein REXX-Program */
parse arg console /* übergebener Wert nun in der Variablen console */
say
anzahl = words(console)
do index = 1 to anzahl by 1
say word(console,index)
end

Der Aufruf von arg() liefert zurück, ob Argumente angegeben wurden (arg() == 1) oder nicht (arg() == 0); mit
arg(1) (anstelle von parse arg) läßt sich der Inhalt des ersten (und bei den meisten Rexx-Interpretern beim
Aufruf von der Kommandozeile einzigen möglichen) übergebenen Arguments auslesen.
REXX: Mathematisches und logisches 7

REXX: Mathematisches und logisches

Mathematische Grundoperationen
• Addieren:

a = 2+3 ==> a == 5

• Multiplizieren:

a = 2*3 ==> a == 6

• Subtrahieren:

a = 2-3 ==> a == -1

• Division:

a = 2 / 3 ==> a == 0.66667

• Potenzieren:
Um bn zu berechnen benutzt man b**n

a = 2**3 ==> a == 8

Modulo
Man kann nicht alles so teilen, daß gebrochene Zahlen herauskommen; wenn man zum Beispiel 33 Eier auf 4
Personen aufteilen will, ohne die Eier zu zerteilen, so bleibt ein Ei übrig. Die Aufteilung ist in diesem Fall 8 Eier pro
Person, und 1 Ei, das man nicht aufteilen kann. Die Operationen heißen Div (ganzzahlige Division) und Modulo und
werden in REXX durch die Symbole % und // repräsentiert:
• Div

a = 33 % 4 ==> a == 8

• Mod

a = 33 // 4 ==> a == 1

In der Praxis benötigt man die Modulo-Operation sehr oft für Datumsberechnungen, z.B. 26.01.2006 war ein
Mittwoch. Der 27.04.2006 ist genau 90 Tage später. 90 // 7 = 6 (90:7=84 Rest 6) Daraus folgt, Mittwoch + 6 Tage =
Dienstag

Bit-Funktionen
Die folgenden drei Funktionen vergleichen die Zeichen bitweise. Ein Bit kann dabei den Zustand 0 oder 1 haben.
Jeweils 8 Bit zusammengefasst ergeben ein Zeichen. Das Zeichen "A" hat zum Beispiel den entsprechenden binären
Code 01000001 (x2b(c2x('A'))).
• bitand(a,b)
Beispiel: 01011010 und 01101101 ergeben 01001000

a = bitand("Z","m") ==> a == "H"

• bitor(a,b)
REXX: Mathematisches und logisches 8

Beispiel: 01011010 und 01101101 ergeben 01111111

a = bitor("Z","m") ==>

• bitxor(a,b)
Beispiel: 01011010 und 01101101 ergeben 00110111

a = bitor("Z","m") ==> "7"

Um diese Operationen mit dezimalen Zahlen benutzen zu können, muß man sie vorher und nachher konvertieren:

a = D2C(5)
b = D2C(9)
x = C2D(bitand(a,b)) ==> x == 1
y = C2D(bitor(a,b)) ==> y == 13
z = C2D(bitxor(a,b)) ==> z == 12

Logische Operatoren
Die logischen Operatoren AND (&), OR (|) und XOR (ausschließliches oder, &&) verlangen und liefern die exakten
Werte 0 (falsch) oder 1 (wahr). Es findet keine „Kurzschlußauswertung“ statt: enthält ein logischer Ausdruck
mehrere Funktionsaufrufe, so werden alle Aufrufe tatsächlich ausgeführt, auch wenn sich der Wert des Ausdrucks
nicht mehr ändern kann.

REXX: String ist alles

Einleitung
Der eigentliche Typ einer Variable in REXX ist ja String. Demzufolge gibt es eine Menge Anweisungen und
Funktionen zur Bearbeitung von Strings.

Konkatenation
Es kommt vor, das man zwei Strings (oder mehr) zu einem String zusammenführen möchte. So eine Verkettung
ermöglicht der Operator ||:

gesamtstring = string1||string2

Whitespace verkettet implizit unter Hinzufügung genau eines Leerzeichens:

a = 'Ottos'
b = 'Mops'
say a b /* 'Ottos Mops' */

Die Verkettung einer Variablen mit einem Stringliteral, oder von Literalen, die mit verschiedenen
Anführungszeichen notiert wurden, kann auch durch direktes Aneinanderschreiben geschehen:

a = 'Otto'
say a's Mops'
say 'Otto'"s Mops"
REXX: String ist alles 9

Länge eines Strings

Mit der Funktion length() bekommt man heraus, aus wie vielen Zeichen ein String besteht:

variable = length(string)

Teilstrings
Manchmal will man nur einen Teil eines Strings verwenden. Dafür kann man die Funktion substr() verwenden:

teilstring = substr(string,startposition,länge)

Beispiel: a = substr("Grottenolm",2,5) => a == "rotte"

Die Funktion left(string, länge) liefert die ersten länge Zeichen, right(string, länge) entsprechend die letzten länge
Zeichen.

Wörterzerlegung
Angenommen, man will die Wörter eines als String eingegebenen Satzes analysieren. Dafür gibt es eine Anzahl von
Funktionen. Die Funktion words() gibt die Anzahl der Wörter zurück, aus denen der String zusammengesetzt ist:

variable = words(string)

Beispiel: a = words("Dieser Satz hat fünf Wörter") => a == 5

Mit der Funktion word() kann man dann auf die einzelnen Wörter dieses Strings zugreifen:

variable = word(string,wert)

Beispiel: a = word("Die Katze tritt die Treppe krumm",2) => a == "Katze"

Sonstiges
Beispiel: a = lower("HaLlO") => a == "hallo"
Beispiel: a = upper("HaLlO") => a == "HALLO"
REXX: Anweisungen, Funktionen und Operatoren 10

REXX: Anweisungen, Funktionen und

Operatoren
Einleitung
Alle Anweisungen und Funktionen, die nicht schon in den anderen Kapiteln besprochen wurden oder noch
besprochen werden, werden hier behandelt.

Anweisungen
• drop
Mit drop variable kann man einzelne Variablen löschen, oder auch einen ganzen Stem.
• exit
Die Anweisung exit veranlaßt ein Programm sich zu beenden.
• leave
leave bewirkt das Verlassen einer Schleife. Das ist besonders sinnvoll, wenn es sich bei der Schleife um eine
Endlosschleife handelt.
• nop
Die Anweisung nop steht für no operation. Es ist eine Leeranweisung, die nichts macht.
• random(u,o,s)
Um Zufallszahlen zu bekommen, kann man die Funktion random() verwenden. random kennt die drei Parameter u
(für Untergrenze), o (für Obergrenze) und s. Alle drei Parameter sind optional, können also auch entfallen.
• C2D()
C2D() wandelt Zeichen in ASCII-Code (dezimal) um.

a = C2D("A") ==> a == 65

• C2X
C2X() wandelt Zeichen in ASCII-Code (hexadezimal) um

a = C2X("A") ==> a == 41

• D2C
D2C() wandelt Dezimalzahlen in Zeichen um

a = D2C(33) ==> a == "!"

• D2X
D2X() wandelt Dezimalzahlen in Hexadezimalzahlen um a = D2X(255) ==> a == "FF"
REXX: Schleifen 11

REXX: Schleifen
Die universelle Schleife
Im Gegensatz zu anderen Programmiersprachen beginnen bei REXX alle Schleifen mit do. Die Gestaltung dieser
do-Schleife kann sehr vielfältig sein.

Ein Block von Anweisungen

Wenn man eine feste Folge von Anweisungen braucht (z. B. für den then- oder else-Teil einer bedingten
Anweisung), dann lassen sie sich diese zu einem do-end-Block zusammenfassen:

do
Anweisung1
Anweisung2
Anweisung3
.
.
.
AnweisungN
end

Begrenzte Anzahl von Wiederholungen

Soll eine Schleife eine fest vorgegebene Anzahl durchlaufen werden, dann kann man hinter dem do einen Ausdruck
angeben, der die Anzahl der Wiederholungen bestimmt (Beispiel):

do 5
say "Hallo"
end

Es wird fünfmal "Hallo" ausgegeben

Zählschleife
do index=start to ende by schrittweite
say index
end

Die Zählvariable darf nach dem abschließenden end wiederholt werden; stimmt die hier angegebene Variable nicht,
so wird ein Syntaxfehler ausgelöst:

do index=start to ende by schrittweite

say index
end index

Dies ist eine gute Hilfe, um in verschachtelten Schleifen den Überblick zu bewahren.
REXX: Schleifen 12

While-Schleife
Die While-Schleife ist eine abweisende Wiederholung: Wenn der logische Ausdruck zu Beginn 0 ist, werden die
enthaltenen Anweisungen überhaupt nicht ausgeführt. (Logische Ausdrücke müssen in Rexx immer den exakten
Wert 0 oder 1 ergeben, sonst tritt ein Syntaxfehler auf.)

i=0
do while Bedingung
i=i+1
say i
end

Until-Schleife
Hier wird eine Abbruchbedingung verwendet; wenn diese 1 ergibt, wird die Ausführung der Schleife abgebrochen.
Da die Bedingung erst am Schleifenende abgefragt wird, werden die enthaltenen Anweisungen mindestens einmal
ausgeführt:

i=11
do until Bedingung
i=i-1
say i
end

Endlosschleife (mit optionaler Abbruchbedingung)

do forever
Anweisung...
if Abbruchbedingung then leave
end

Insbesondere für Endlosschleifen bietet sich auch der Abbruch per Ausnahmebehandlung an:

signal on halt
do forever
Anweisung...
end
halt:
say 'abgebrochen.'

iterate und leave

Zur Verwendung in Schleifen gibt es die speziellen Sprunganweisungen iterate und leave. Beispiel:

do index=1
if index == 3 then
iterate index
if index > 5 then
leave
say index
end index
REXX: Schleifen 13

Dabei springt iterate zum Schleifenanfang (vergleichbar dem continue anderer Programmiersprachen), während
leave die Schleife verlässt (vergleichbar break). Die Angabe der Zählvariable ist wieder optional; sie ermöglicht
außerdem die Steuerung verschachtelter Schleifen. Im Beispiel wird ausgegeben:

1
2
4

REXX: Bibliotheken
Einleitung
Wie in den meisten Programmiersprachen kann man auch in REXX eigene Funktionen schreiben. Es lassen sich
auch externe Bibliotheken erstellen. Egal ob es sich um eine eigene Funktion innerhalb des Programms handelt, oder
um eine externe Bilbliothek, der Aufruf ist immer:

call funktionsname parameter

eigene Funktionen innerhalb des Programms

Als Beispiel ein Programm zur Ausgabe der Fakultät. Die eigentliche Berechnung der Fakultät findet in der
selbstgeschriebenen Funktion statt.

/* Ein Rexx-Programm */
signal on syntax
say "Bitte gib eine Zahl >= 0 ein"
pull n
do while n >= 0
say "die Fakultät zu" n "ist" fakultaet(n)
say "Bitte gib eine Zahl >= 0 ein"
pull n
end
exit 0

fakultaet: procedure
arg n
select
when n = 0 then
return 1
when n = 1 then
return 1
otherwise
return n * fakultaet(n-1)
end
syntax:
say 'Keine Zahl'
exit 1
REXX: Bibliotheken 14

Externe Bibliothek
Eine externe Bibliothek muß erst in das Programm hinzugeladen werden. Das bewirkt die Anweisung:

call load 'datei'

/* Ein REXX-Programm */
call load 'convert.r'
do forever
pull zahl
pull base
call d2n zahl,base
say zahl'='result
end

Die externe Bibliothek ist nicht ablauffähig. Um auf diesen Umstand hinzuweisen, kann man der Bibliothek zwei
Zeilen an den Anfang stellen:

say 'Only a Library!'

exit 1

Diese zwei Zeilen bewirken, das beim Starten der Bibliothek eine Meldung ausgegeben wird, daß es sich bei der
ausgeführten Datei um eine Bibliothek handelt. Das exit 1 beendet dann die Datei. Beim Aufruf mit call load aus
einem REXX-Programm haben diese beiden Zeilen keine Auswirkungen.

/* REXX-Programm */
say 'Only a Library!'
exit 1
/* */
/* */
D2N: procedure
arg n,b
/* initialisierung */
z='0123456789ABCDEFGHIJKLMNOPQRSTUVW'
conv =
nstart = n
DO WHILE n > 0
p = n // b
conv = substr(z,(p+1),1)||conv
n = n % b
END
/* Ausgabe der Konversion in der Form: 23 = (10111)2 */

return conv
REXX: Beispiele: Primzahlen 15

REXX: Beispiele: Primzahlen

Sieb des Erathostenes
/* Ein Rexx-Programm */
/* Initialisierung */
do index = 2 to 10000
zahl.index = 1 /* Alle Zahlen sind Primzahlen */
end
/* Primzahlen sieben */
do index = 2 to 100
if zahl.index = 1 then do index2 = (index*index) to 10000 by index
zahl.index2 = 0
end
end
/* Ausgabe der Primzahlen */
do index = 2 to 10000
if zahl.index = 1 then say index
end

Primzahltest naiver Ansatz

/* Ein REXX-Programm */
initial=1
obergrenze = 10000
anzahl_primzahlen = 1
primzahl_zeiger.1=2
say 2
do index = 3 to obergrenze
primzahl_wahr = 1
laeufer = initial
do anzahl_primzahlen
laeufer = primzahl_zeiger.laeufer
if index // laeufer = 0 then primzahl_wahr = 0
end
if primzahl_wahr = 1 then do
primzahl_zeiger.laeufer = index
anzahl_primzahlen = anzahl_primzahlen + 1
say index
end

end
REXX: Befehlsumfang 16

REXX: Befehlsumfang
Übersicht der REXX-Anweisungen (unvollständig)
REXX-Anweisungen

address umgebung ausdruck zum Ausführen von Anweisungen außerhalb der REXX-Umgebung address CMD 'DIR
*.*'

arg Argumentstring Auswertung per Kommandozeile übergebener Argumente; Abkürzung für arg n k
parse upper arg Argumentstring

arg Argument1 [, Argument2][…] Auswertung an eine Funktion oder Prozedur übergebener Argumente; arg n, k
Abkürzung für parse upper arg Argument1[, Argument2][…]

call prozedur Aufruf einer prozedur call binkoeff n, k

call on bzw. off Bedingung schaltet die Überwachung der Bedingung ein oder aus (mit Rückkehr) call on error

call load 'bibliothek' Eine externe Bibliothek laden call load 'mathe.r'

do Alle möglichen Arten von Schleifen

drop variable variable löschen drop a

exit veranlasst das Programm sich zu beenden

if log. Ausdruck then anweisung Selektionsbefehl if a > 0 then a = a +

1; else a = -a

interpret ausdruck ausdruck wird wie eine REXX-Anweisung behandelt interpret "a=5*(4+b)"

iterate Sprung zum nächsten Schleifendurchlauf, entsprechend dem continue anderer

Sprachen

leave Verlassen einer Schleife, entsprechend dem break anderer Sprachen

nop Leeranweisung, die nichts macht

numeric digits / form / fuzz [Wert] Festlegungen für arithmetische Operationen numeric digits 20

options ausdruck nimmt spezielle Einstellungen vor

parse Analyse von Eingaben und Variablen (Vorlaufinformation)

procedure nur direkt nach einer mit call angesteuerten Marke zulässig (Funktions- oder
Prozeduraufruf); erzeugt einen Namespace für lokale Variablen

pull variable liest eine Zeichenkette von der aktuellen Standardqueue oder (wenn diese pull eingabe
leer ist) der Tastatur ein (Abkürzung für parse upper pull)

push ausdruck ausdruck wird der aktuellen Standardqueue übergeben, die in diesem Fall als
Stack funktioniert (LIFO)

queue ausdruck ausdruck wird der aktuellen Standardqueue übergeben (FIFO)

return ausdruck kehrt zur aufrufenden Stelle zurück und übergibt ggf. den optional angegeben
Wert

say ausdruck ausdruck wird auf dem Bildschirm ausgegeben say "Hallo Welt!"

select; when Bedingung then Anweisung; Mehrfachverzweigung

[…] [otherwise Anweisungen;] end

signal label Äquivalent zu goto label

signal on bzw. off Bedingung Schaltet die Überwachung der Bedingung ein bzw. aus (ohne Rückkehr) signal on break

trace Abkürzung steuert die Debugging-Ausgaben trace ?i, trace off

REXX: Befehlsumfang 17

Übersicht der REXX-Funktionen (unvollständig)

REXX-Funktionen

address() gibt die Umgebung zurück z. B.: address() == 'DOS'

arg(n) gibt das n-te Argument zurück (im Falle der Kommandozeile ist n == console = arg(1)
1)

args() gibt die Anzahl der übergebenen Argumente zurück console = arg(1)

charin("dateiname") holt ein Zeichen aus dem Eingabestrom zeichen = charin("semmel.txt")

charout() schreibt ein Zeichen in den Ausgabestrom

chars() gibt die Anzahl der noch verfügbaren Zeichen im Eingabestrom aus

date() gibt je nach Option Tages- bzw. Datumsangaben zurück.

linein("dateiname") Liest eine ganze Zeile aus einer Datei ein zeile = linein("semmel.txt")

lineout("dateiname",ausdruck) ausdruck wird in Datei geschrieben lineout("semmel.txt",eumel)

lines() gibt die Anzahl der noch vollständigen Zeilen im Eingabestrom aus

queued() gibt die Anzahl ungelesenen Einträge in der aktuellen Standardqueue

aus

rxqueue("Kommando"[, "Name"]) Erzeugt oder setzt eine benannte Queue bzw. fragt ihren Namen ab

Stringfunktionen

length(string) liefert die Länge eines Strings zurück x = length("abc") => x = 3

substr(string,position,zeichenzahl) Ein Teilstring aus string x = substr("abcde",2,3) => x = bcd

word(string,wert) gibt das n.te Wort des String aus a = word("polyglotte Katze",2) =>
Katze

words(string) gibt die Anzahl der Wörter des Strings aus a = words("Hallo Leute") => 2

mathematische Funktionen

abs(zahl) liefert den vorzeichenlosen Teil einer Zahl zurück abs(-3) => 3

bitand() Bitweises UND

bitor() Bitweises ODER

bitxor() Bitweises XOR (exklusives Oder)

random(u,o,s) liefert eine zufällige Zahl in den Grenzen von u und o zurück. u,o und s
sind optional

C2D() Wandelt Zeichen in ASCII-Code (dezimal) um

C2X() Wandelt Zeichen in ASCII-Code (hexadezimal) um

D2C() Wandelt Dezimalzahlen in Zeichen um

D2X() Wandelt Dezimalzahlen in Hexadezimalzahlen um

REXX: Befehlsumfang 18

Übersicht der REXX-Operatoren (unvollständig)

Vergleichsoperatoren
Rexx verfügt über zwei Klassen von Vergleichsoperatoren, die exakt (z. B. ==) oder numerisch (=) vergleichen. Im
zweiten Fall werden zunächst etwaige Rand-Blanks entfernt, weil diese für die Interpretation als Zahl nicht von
Bedeutung sind.
Rexx unterstützt eine große Zahl von Varianten, wobei allerdings „nicht“ nicht, wie in manchen Sprachen üblich,
durch das Ausrufungszeichen, sondern durch das mathematische Zeichen für „nicht“ (¬), ersatzweise den Backslash
ausgedrückt wird (das Ausrufungszeichen gehört zum Zeichenvorrat für Bezeichner!)

Vergleichs-Operatoren Beispiel Ergebnis

exakt gleich == "1 " == 1 0

numerisch gleich = "1 " = 1 1

nicht exakt gleich ¬== \== "1 " \== 1 1

numerisch ungleich <>  ¬=  \= "1 " \= 1 0

exakt größer >> 30 >> "4 " 0

numerisch größer > 30 > "4 " 1

exakt größer oder gleich >== ¬<< \<< 30 >== "4 " 0

numerisch größer oder gleich >=  ¬<  \< 30 >= "4 " 1

exakt kleiner << 30 << "4 " 1

numerisch kleiner < 30 < "4 " 0

exakt kleiner oder gleich <== ¬>> \>> 30 <<= "4 " 1

numerisch kleiner oder gleich <=  ¬>  \> 30 <= "4 " 0

sonstige Operatoren
Die Operatoren +, -, * und / werden nicht extra aufgeführt.

REXX-Operatoren

** Potenz 4**3 == 64

% ganzzahlige Division 11%3 == 3

// Rest-Operator (Modulo) 11//3 == 2

& logisches UND a & b => wahr, wenn a und b wahr sind

| logisches ODER a | b => wahr wenn a oder b wahr ist

&& logisches XOR a && b => wahr, wenn entweder a oder b wahr ist, aber nicht beide gleichzeitig

|| Stringverkettung (Konkatenation) "bär"||"tiger" = "bärtiger"

REXX: Aufgaben 19

REXX: Aufgaben
• Rao-Zahlen
Es gibt Zahlen für die gilt, daß ist. Mit ist gemeint, daß und hintereinander als
eine Zahl aufgeschrieben wird. So wird aus und die Zahl . Diesen Vorgang nennt
man Konkatenation. Ein Beispiel für eine Rao-Zahl ist 1233, da ergibt.
Schreibe in REXX ein Programm, das die Rao-Zahlen bis 1.000.000 ausgibt.

REXX: Quellen
REXX-Versionen
• BREXX - Vasilis Vlachoudis (DOS, Linux, Amiga, ...)
• Regina (Linux, Windows, ...)
• ARexx - William S. Hawes (Amiga)

Literatur
• Michael Cowlishaw, The Rexx Language: A Practical Approach to Programming, ISBN 0137806515
• Michael Metz et al., ARexx. Eine Einführung und mehr, ISBN 3930733005
• Karlheinz Wittemann, REXX unter MVS-TSO/E, ISBN 3446179569
• Howard Fosdick, Rexx Programmer's Reference (Wiley/Wrox: 2005), ISBN 0764579967

Weblinks
• The REXX Language Association [1]
• Regina [2]
• BREXX [3]

Referenzen
[1] http:/ / www. rexxla. org/
[2] http:/ / regina-rexx. sourceforge. net/
[3] ftp:/ / ftp. gwdg. de/ pub/ languages/ rexx/ brexx/
Quelle(n) und Bearbeiter des/der Artikel(s) 20

Quelle(n) und Bearbeiter des/der Artikel(s)

REXX  Quelle: http://de.wikibooks.org/w/index.php?oldid=318950  Bearbeiter: Arbol01, E^(nix), Klaus Eifert, Moolsan, Stefan Majewsky, 1 anonyme Bearbeitungen

REXX: Einleitung  Quelle: http://de.wikibooks.org/w/index.php?oldid=399535  Bearbeiter: TobiasHerp, 1 anonyme Bearbeitungen

REXX: Variablen  Quelle: http://de.wikibooks.org/w/index.php?oldid=398320  Bearbeiter: Arbol01, Haden2, TobiasHerp

REXX: Aus- und Eingabe  Quelle: http://de.wikibooks.org/w/index.php?oldid=398330  Bearbeiter: Arbol01, TobiasHerp, 1 anonyme Bearbeitungen

REXX: Mathematisches und logisches  Quelle: http://de.wikibooks.org/w/index.php?oldid=458040  Bearbeiter: AlB, Arbol01, Mjchael, TobiasHerp, 4 anonyme Bearbeitungen

REXX: String ist alles  Quelle: http://de.wikibooks.org/w/index.php?oldid=398332  Bearbeiter: Arbol01, TobiasHerp

REXX: Anweisungen, Funktionen und Operatoren  Quelle: http://de.wikibooks.org/w/index.php?oldid=459380  Bearbeiter: AlB, Arbol01, TobiasHerp, 1 anonyme Bearbeitungen

REXX: Schleifen  Quelle: http://de.wikibooks.org/w/index.php?oldid=398328  Bearbeiter: Arbol01, TobiasHerp

REXX: Bibliotheken  Quelle: http://de.wikibooks.org/w/index.php?oldid=398335  Bearbeiter: Arbol01, TobiasHerp

REXX: Beispiele: Primzahlen  Quelle: http://de.wikibooks.org/w/index.php?oldid=419120  Bearbeiter: Arbol01, Polluks

REXX: Befehlsumfang  Quelle: http://de.wikibooks.org/w/index.php?oldid=398336  Bearbeiter: Arbol01, TobiasHerp

REXX: Aufgaben  Quelle: http://de.wikibooks.org/w/index.php?oldid=398337  Bearbeiter: Arbol01, TobiasHerp

REXX: Quellen  Quelle: http://de.wikibooks.org/w/index.php?oldid=317069  Bearbeiter: AlB, Arbol01, Polluks

Quelle(n), Lizenz(en) und Autor(en) des Bildes 21

Lizenz
Creative Commons Attribution-Share Alike 3.0 Unported
http:/ / creativecommons. org/ licenses/ by-sa/ 3. 0/