***
break
BREAK

Der Befehl BREAK wird verwendet, um den Bereich einer DO-Anweisung oder
eine INTERPRETierte Zeichenfolge zu verlassen. Die innerste DO-Anweisung
wird verlassen.

vgl. LEAVE, EXIT

***
leave
LEAVE [Variable]

Der Befehl LEAVE führt zum sofortigen Verlassen des iterativen DO-Bereichs,
der diesen BEFEHL enthält. Die [Variable] gibt an, wieviele DO-Ebenen be-
troffen sin.

vgl. BREAK, EXIT

***
exit
EXIT [Ausdruck]

EXIT beendet das Programm, und gibt den Wert [Ausdruck] zurück. Wurde eine
Zeichenfolge angefordert, so ist [Ausdruck] dessen Addresse.

vgl. BREAK, LEAVE
***
address
*
shell
ADDRESS oder SHELL (Synonyme)

Gibt Host-Adresse für den Interpreter an. Folgende Varianten sind möglich:

ADDRESS {Zeichenfolge|Symbol} Ausdruck:
Der Ausdruck wird ausgewertet, das Ergebnis als Kommando an die durch die
Zeichenfolge oder das Symbol spezifizierte Host-Adresse geschickt.

ADDRESS {Zeichenfolge|Symbol}:
Die Zeichnfolge oder das Symbol wird als neue Host-Adresse betrachtet.

ADDRESS [VALUE] Ausdruck:
Das Ergebnis des Ausducks wird als neue Host-Adresse betrachtet. Die Angabe
von VALUE ist optional.

ADDRESS:
Vertauscht aktuelle und frühere Host-Adresse.

vgl. SHOW.

***
arg
*
argumente
*
parameter
ARG [Schablone][,Schablone...]

Kurzform für PARSE UPPER ARG. Es können eine oder mehrere dem Programm zur
Verfügung stehende Argumentzeichenfolgen abgerufen und den Variablen in den
Schablonen als Wert zugewiesen werden.

ARG([Nummer],['Exists'|'Omitted'])

Liefert die Anzahl der Übergebenen Parameter, wenn nur Nummer angegeben ist
die entsprechende Argumentzeichenfolge. Ist eine Nummer und eines der Wörter
Exists (existiert) oder Omitted (existiert nicht) angegeben, zeigt der
boolsche Rückgabewert den Status des entspr. Arguments an.

***
call
CALL {Symbol|Zeichenfolge} [Ausdruck][,Ausdruck,...]

Aufruf einer internen oder externen Funktion. Der Name wird mittels Symbol
oder Zeichenfolge angegeben. Die Ausdrücke werden ausgewertet, und als
Argumente übergeben.
Das Ergebnis der Funktion wird der Sondervariable RESULT zugewiesen, und
kann von dort mittels
  Variable = RESULT
übernommen werden.

***
drop
DROP Variable [Variable ...]

Die angegebenen Variablen werden gelöscht.

***
echo
*
say
ECHO [Ausdruck]
SAY [Ausdruck]

Gleichbedeutend. Es wird das Ergebnis des Ausdrucks auf der Konsole ausge-
geben.

***
do
DO [[Var=Ausdr]|[Ausdr] [TO Ausdr] [BY Ausdr]] [FOR Ausdr] [FOREVER]
[WHILE Ausdr | UNTIL Ausdr]

Einleitung einer Gruppe von Befehlen.
Als Schlüsselwort alleine definiert DO einen Block, der bis zu END reicht.
Falls auf DO irgendwelche Iterationsangaben folgen, wird der Anweisungs-
block solange ausgeführt, bis eine Endbedingung auftritt.

siehe ARexx-Handbuch S.10-51ff
vgl. END

***
else
ELSE [;][dedingte Anweisung]

Alternativer Anweisungsblock nach IF ... THEN. In Verschachtelungen ist es
manchmal nötig eine Pseudo-Anweisung (ELSE;) anzugeben.

***
end
END [Variable]

Beendet einen Anweisungsblock.
Siehe auch DO.

Beispiel:

  do i=1 to 5
  say i
  end i
  
***
if
IF Ausdruck [THEN][;][bedingte Anweisung]

In Verbindung mit THEN und ELSE zur bedingten Ausführung einer Anweisung.
Nach THEN und ELSE kann jede beliebige Anweisung stehen. Mehrere Anweisungen
müssen zu einem Block (siehe DO, END) zusammengefaßt werden.
Der Ausdruck muß einen Boolschen Wert liefern. Ist dieser TRUE wird der
Block nach THEN ausgeführt, sonst der nach ELSE.

Siehe auch DO, END, THEN.

***
interpret
INTERPRET Ausdruck

Der Ausdruck wird wie ein Programmblock zwischen DO und END interpretiert
und abgearbeitet. Er darf beliebigt Anweisungen enthalten.
Der Befehl eignet sich dazu, Programme dynamisch zu gestalten. Der Ausdruck
kann als Parameter an Funktionen übergeben werden.

Siehe auch Handbuch S.10-57, LEAVE, ITERATE, BREAK.

***
nop
NOP

(engl. No OPeration). Der Befehl NOP tut nichts. Er dient dazu, die An-
bindung von ELSE-Klauseln an verschachtelte IF-Anweisungen zu gewährleisten.

Siehe auch IF, THEN.

***
numeric
*
scientific
*
engeneering
NUMERIC DIGITS Ausdruck

Wenn Ausdruck eine ganze pos. Zahl ergibt, wird damit die Anzahl der gül-
tigen Stellen für arithmetische Operationen festgelegt.

NUMERIC FUZZ Ausdruck

Legt die Anzahl der Stellen fest, die bei numerischen Vergleichen ignoriert
werden. Ausdruck muß einen kleineren Wert liefern, als bei DIGITS festgel.

NUMERIC FORM SCIENTIFIC

Legt für die Zahlendarstellung die Exponentialschreibweise fest.

NUMERIC FORM ENGENEERING

Legt für die Zahlendarstellung die Exponentialschreibweise mit einem
Vielfachen von 3 als Exponenten fest.

***
options
*
failat
*
prompt
*
results
OPTIONS [FAILAT Ausdruck]
OPTIONS [PROMPT Ausdruck]
OPTIONS [RESULTS]

Dient zur Festlegung interner Vorgaben.
FAILAT legt einen Grenzwert für Rückgabewerte fest, bei dessen Überschrei-
tung (größer oder gleich) ein Fehler angezeigt wird.
PROMPT legt eine Zeichenfolge fest, die beim Befehl PULL (oder PARSE PULL)
als Eingabeaufforderung erscheint.
RESULTS legt fest, daß der Interpreter eine Ergebniszeichenfolge anfordern
soll, wenn er ein Kommando an eine externe Host-Adresse ausgibt.

Siehe auch Handbuch S.10-61.

***
otherwise
OTHERWISE [;][bedingte Anweisung]

Nur im Bereich einer SELECT-Anweisung gültig, und muß auf alle "WHEN...THEN"
Anweisungen folgen. Trifft keine WHEN-Klausel zu, so wird die Anweisung oder
der Block nach OTHERWISE ausgeführt.

Bsp.: select
        when i=1 then say 'eins'
        when i=2 then say 'zwei'
        otherwise say 'was anderes'
      end

Siehe auch SELECT, WHEN.

***
parse
*
external
*
source
*
value
*
var
*
version
PARSE [UPPER] Eingabequelle [Schablone][,Schablone...]

Zieht aus einer Zeichenfolge eine Teilzeichenfolge heraus. Die Schablone
legt fest welchen Variablen Werte zugewiesen werden, und welcher Art die
Festlegung der Wertzeichenfolgen ist. Die Eingabequelle kann durch folgende
Schlüsselworte festgelegt werden:
UPPER    -> Umwandlung zunächst in Großbuchstaben.
ARG      -> Benutzt die Argumentzeichenfolge die dem Prog. übergeben wurde
EXTERNAL -> Eingabezeichenfolge aus dem STDERR-Strom (Kap.10.7.4, 10.10)
NUMERIC  -> akt.Optionen in Zeichenfolge übergeben (Seite 10-63)
PULL     -> Liest Zeichenfolge von der Konsole
SOURCE   -> (siehe Handbuch S.10-63)
VALUE Ausdruck WITH -> Das Ergebnis von Ausdruck ist die Quelle.
VAR Var. -> Der Wert der Variable ist die Quelle
VERSION  -> (siehe Handbuch S.10-64)

Bsp.: parse arg i   /* Der Variable i wird das Argument zugewiesen */

Siehe Handbuch S.10-63ff, Kapitel 10.7.4 und 10.10.

***
procedure
*
expose
PROCEDURE [EXPOSE Variable [Variable...]]

Beginnt eine interne Funktion. Die Funktion hat Zugriff auf die hinter
EXPOSE angegebenen Variablen der Übergeordneten (aufrufenden) Ebene.

Bsp.: fakult: procedure             /* Eine rekursive Funktion */
              arg i
              if i=1
                then return 1
                else return i*fakult(i-1)

***
pull
PULL [Schablone][,Schablone...]

Kurzform von PARSE UPPER PULL. Liest eine Zeichenfolge von der Konsole,
übersetzt diese in Großbuchstaben, und nimmt unter verwendung der Schablone
eine Syntaxanlyse vor.

Bsp.: pull Vorname Nachname          /* Namen einlesen */

***
return
RETURN [Ausdruck]

Verläßt eine Funktion und gibt den ausgewerteten Ausdruck als Ergebnis-
zeichenfolge zurück. Wird kein Ausdruck bereitgestellt kann es zu einem
Fehler kommen. Funktionen die über die Anweisung CALL aufgerufen wurden
brauchen kein Ergebnis zurückzugeben.

Siehe auch PROCEDURE, CALL.

***
select
SELECT

Beginn eines Anweisungsblock, der eine oder mehrere WHEN-Klauseln und evtl.
eine OTHERWISE-Klausel enthält. Auf jede WHEN-Klausel folgt eine bedingt
Anweisung, es wird jedoch nur eine ausgeführt. Es werden alle WHEN-Klauseln
ausgewertet, bis eine zutrifft. Führt keine zum Erfolg, wird die OTHERWISE-
Anweisung ausgeführt. Der SELECT-Block muß mit END abgeschlossen werden.

Bsp.: select
        when i=1 say 'eins'
        when i=2 say 'zwei'
        otherwise say 'was anderes'
      end

Siehe auch WHEN, OTHERWISE.

***
signal
*
break_c
*
break_d
*
break_e
*
break_f
*
error
*
halt
*
ioerr
*
novalue
*
syntax
SIGNAL {ON | OFF} Bedingung

Dient zur Steuerung von Interrupts. Folgende Bedingungen sind möglich:
BREAK_C   -> Eine Unterbrechung mit Ctrl-C wurde erkannt.
BREAK_D   -> Eine Unterbrechung mit Ctrl-D wurde erkannt.
BREAK_E   -> Eine Unterbrechung mit Ctrl-E wurde erkannt.
BREAK_F   -> Eine Unterbrechung mit Ctrl-F wurde erkannt.
ERROR     -> Ein Host-Kommando gibt einen Wert ungleich Null zurück.
HALT      -> Ein externer HALT-Befehl wurde erkannt.
IOERR     -> Das Eingabe-/Ausgabe-Fehlersystem hat einen Fehler erkannt.
NOVALUE   -> Eine nicht initialisierte Variable wurde verwendet.
SYNTAX    -> Ein Syntax- oder Ausführungsfehler wurde entdeckt.

Bsp.: signal on error      /* Interrupt aktivieren */
      signal off syntax    /* Syntaxüberprüfung aus */
      siganl start         /* zu START springen */

Siehe Handbuch S.10-69ff.

***
when
WHEN Ausdruck [THEN [;][bedingte Anweisung]]

Auswahlmöglichkeit innerhalb eines SELECT-Blocks.

Beispiel und Beschreibung siehe bei SELECT.

***
schablone
*
schablonen
Eine Schablone ist vergleichbar mit einer Formatanweisung zum formatieren
Lesen in anderen Sprachen, wie etwa C. In ARexx ist die Schablone jedoch
allgemeiner gefaßt, und deshalb im Extremfall kompliziert. Deshalb kann hier
nur auf das Handbuch verwiesen werden. Dort, auf den Seiten 10-150ff, im
Kapitel 10.8 werden die Schablonen genauer beschrieben.
Im einfachsten Fall handelt es sich jedoch nur um eine Variable, wie z.B. in

PARSE ARG Wert.

Hier wird der Variable Wert die Argumentzeichenfolge zugewiesen, welche dem
Programm oder der Funktion übergeben wurde.

Weitere Beispiele:
  pull Wort1 Wort2  /* Wort1 wird das erste Wort, Wort2 das zweite Wort */
                    /* der Eingabezeile von PULL zugewiesen */
  parse var String Wort Rest  /* Der Var.Wort wird das erste Wort des String
                                 zugewiesen, der Rest der Var.Rest */

***
abbrev
ABBREV(Zeichenfolge1,Zeichenfolge2,[Länge])

Liefert TRUE, wenn Zeichenfolge2 eine Abkürzung von Zeichenfolge1 ist. Es
wird bis zur Länge kontrolliert.

Bsp.: say abbrev('fullname','ful') --> 1
      say abbrev('almost','alm',4) --> 0

***
abs
ABS(Zahl)

Liefert den Absolutbetrag der Zahl.

***
addlib
*
bibliothek
*
bibliotheken
*
libs
*
lib
ADDLIB(Name,Priorität,[Offset,Version])

Eine durch den Namen spezifizierte Funktionsbibliothek oder ein durch den
"public Message-Port" spezifiziertes Funktions-Hostprogramm wird in die
Bibliotheksliste aufgenommen. Alle Bibliotheken sollten sich im Verzeichnis
LIBS: befinden.
Priorität ist ein Wert zwischen -100 und 100, und gibt die Suchpriorität an.
Offset ist die ganzzahlige Distanz zur "Query"-Einsprungsadresse.
Version ist die minimal zulässige Versionsnummer der Bibliothek.
Die Funktion liefert 1, wenn die Operation gelungen ist, sonst 0.

Bsp.: say addlib("rexxsupport.library",0,-30,0)

***
b2c
B2C(Zeichenfolge)

Wandelt eine aus den Zeichen 0 und 1 bestehende Zeichenfolge in das ent-
sprechende Zeichen um (deshalb: Bit TO Character).

Bsp.: say b2c('00110011')  --> 3
      say b2c('01100001')  --> a

***
bitand
*
bitor
*
bitxor
BITAND(String1,String2,[Füllzeichen])
BITOR(String1,String2,[Füllzeichen])
BITXOR(String1,String2,[Füllzeichen])

String1 und String2 werden durch die angegebene logisches Operation
miteinander verknüpft.
Das Ergebnis ist so lang wie der längere String. Ist ein Füllzeichen ange-
geben, so wird die kürzere Zeichenfolge damit aufgefüllt, sonst wird der
Rest der längeren Zeichenfolge an das Ergebnis angehängt.

Bsp.: bitand('0313'x,'FFF0'x)  --> '0310'x

vgl. BITCOMP.

***
bitchg
BITCHG(Zeichenfolge,Bit)

Kehrt den Status des angegebenen Bits in der Zeichenfolge um. Das rechte Bit
ist Bit Nummer 0.

Bsp.: bitchg('0313'x,4)  --> '0303'x

vgl. BITCLR, BITSET.

***
bitclr
*
bitset
BITCLR(Zeichenfolge,Bit)
BITSET(Zeichenfolge,Bit)

Löscht bzw. setzt das angegebene Bit in der Zeichenfolge.
Das rechte Bit ist Nummer 0.

vgl. BITCHG.

***
bitcomp
BITCOMP(String1,String2,[Füllzeichen])

Vergleicht String1 und String2 Bit für Bit. Es wird rechts begonnen. Der
Rückgabewert ist das erste unterschiedliche Zeichen. Sind alle gleich, so
wird -1 zurückgegeben.

vgl. BITCHG, BITSET, BITCLR, BITAND, BITXOR, BITOR.

***
bittst
BITTST(Zeichenfolge,Bit)

Gibt den Status des angegebenen Bits in der Zeichenfolge zurück. Das rechte
Bit ist Nummer 0.

vgl. BITSET, BITCLR, BITCHG.

***
c2b
C2B(Zeichenfolge)

Wandelt die Zeichenfolge in den Binärcode der Zeichen um (ASCII).

vgl. C2X().

***
c2d
C2D(Zeichnfolge,[n])

Gibt den zu der Zeichenfolge passenden dezimalen Wert zurück, fals die
Zeichenfolge einen konvertierbaren Wert enthält, sonst -1. Das Argument n
gibt an, wieviele Zeichen benutzt werden.

Bsp.: say c2d('0020'x)      --> 32
      say c2d('FFFF ffff'x) --> -1
      say c2d('FF0100'x,2)  --> 256

vgl. C2X.

***
c2x
C2X(Zeichenfolge)

Wandelt die Zeichenfolge in hexadezimale Ziffern um.

Bsp.: say c2x('abc')  --> 616263

vgl. C2D.

***
center
*
centre
CENTER(String,Länge,[Füllzeichen]) oder
CENTRE(String,Länge,[Füllzeichen])

Zentriert den String in einer Zeichenfolge mit der angegebenen Länge. Ist
die angegebene Länge größer als die des Strings werden Leerzeichen oder das
Füllzeichen - wenn angegeben - nach bedarf hinzugefügt.

Bsp.: say center('abc',6)       --> ' abc  '
      say center('abc',6,'+')   --> '+abc++'
      say center('123456',3)    --> '234'

***
close
CLOSE(Datei)

Schließt die angegebene logische Datei. War die Dateu offen, so wird eine
boolsche 1 zurückgegeben.

siehe OPEN.

***
compress
COMPRESS(Zeichenfolge,[Liste])

Es werden die in der Liste angegebenen Zeichen aus der Zeichenfolge entfernt,
ist keine solche angegeben alle Leerzeichen.

Bsp.: say compress(' why not ')       --> whynot
      say compress('++12-34-+','+-')  --> 1234

***
compare
COMPARE(String1,String2,[Füllzeichen])

Vergleicht die Strings, und gibt 0 zurück, wenn diese gleich sind, sonst die
Position der ersten Abweichung. Ist ein String kürzer, so wird er mit Leer-
zeichen oder dem Füllzeichen aufgefüllt.

***
copies
COPIES(String,Anzahl)

Erstellt einen neuen String durch Aneinanderhängen von Anzahl Kopien des
Strings.

***
d2c
*
asc
*
ascii
D2C(Nummer)

Liefert das zur Nummer gehörige ASCII-Zeichen.

***
d2x
D2X(Nummer,[Ziffern])

Wandelt eine Dezimalzahl in die hexadezimale Schreibweise um.

Bsp.: d2x(65)  --> '41'

***
date
DATE([Option],[Datum],[Format])

Gibt das aktuelle Datum im spezifizierten Format zurück.
Als Option sind folgende Werte oder deren erster Buchstabe gültig:
Basedate   --> Die Anzahl der Tage seit dem 1.Januar 0001
Century    --> Die Anzahl der Tage seit dem 1.Januar 1900
Days       --> Die Anzahl der Tage seit dem 1.Januar dieses Jahres
European   --> Das Datum im Format TT/MM/JJ
Internal   --> Interne Systemtage
Julian     --> Das Datum im Format JJTTT
Month      --> Der aktuelle Monat
Normal     --> Das Datum im Format TT MMM JJJJ
Ordered    --> Das Datum im Format JJ/MM/TT
Sorted     --> Das Datum im Format JJJJMMTT
USA        --> Das Datum im Format MM/TT/JJ
Weekday    --> Der Wochentag

Bsp.: say date()                 --> 20 Apr 1988
      say date('m')              --> April
      say date('w',19890609,'s') --> Friday

***
datatype
DATATYPE(Zeichenfolge,[Option])

Überprüft den Datentyp der Zeichnfolge. Ist keine Option angegeben liefert
die Funktion entweder NUM oder CHAR, sonst 1 wenn für ja und 0 für nein.
Folgende Optionen sind möglich:
Alphanumeric --> alphabetisch incl. Umlaute oder numerisch
Binary       --> Nur 0 und 1
Lowercase    --> Kleinbuchstaben
Mixed        --> Groß- und Kleinschreibung gemischt
Numeric      --> Gültige Zahlen
Symbol       --> Gültige ARexx-Symbole
Upper        --> Großbuchstaben
Whole        --> Ganzzahlen
X            --> hexadezimale Ziffernfolge

Bsp.: say datatype('123')        --> NUM
      say datatype('1a f2','x')  --> 1
      say datatype(aBcde','L')   --> 0
      say datatype('aBcäß','a')  --> 1

***
delstr
DELSTR(Zeichenfolge,n,[Anzahl])

Löscht ab dem n-ten Zeichen die angegebene Anzahl an Zeichen aus der Zei-
chenfolge. Ist keine Anzahl angegeben, so wird bis zum Ende gelöscht.

vgl. DELWORD.

***
delword
DELWORD(Zeichenfolge,n,[Anzahl])

Löscht ab dem n-ten Zeichen die angegebene Anzahl an Wörtern aus der Zei-
chenfolge. Ist keine Anzahl angegeben, so wird bis zum Ende gelöscht.

vgl. DELSTR

***
digits
DIGITS()

Gibt die aktuelle Einstellung der Option "Numeric Digits" an.

vgl. NUMERIC.

***
eof
EOF(Datei)

Überprüft, ob das Ende der angegebenen logischen Datei erreicht ist, und
gibt in diesem Fall 1 zurück, sonst 0.

***
errortext
ERRORTEXT(n)

Gibt die zur Zahl n gehörige Fehlermeldung aus, wenn n eine gültige Nummer
ist, sonst eine leere Zeichenfolge.

***
exists
EXISTS(Dateiname)

Überprüft ob eine Datei mit dem Dateinamen existiert, und gibt in diesem
Fall 1 zurück, sonst 0.

***
export
EXPORT(Adresse,[Zeichenfolge],[Länge],[Füllzeichen])

Schreibt an die mit 4 Bytes angegebene Adresse des Speichers Länge Zeichen
aus der Zeichenkette, und füllt gegebenenfalls mit dem Füllzeichen auf.

vgl. IMPORT, STORAGE, GETSPACE, FREESPACE.

***
form
FORM()

Gibt die aktuelle Einstellung von "Numeric Form" an.

vgl. NUMERIC.

***
find
FIND(Zeichenkette,Phrase)

Sucht die Phrase in der Zeichenkette, und gibt die Nummer des Wortes zu-
rück, an dem die Übereinstimmung beginnt.

vgl. INDEX.

***
freespace
*
getspace
GETSPACE(Länge)

Reserviert Länge Bytes Speicher aus dem internen Pool, und gibt die Adresse
des ersten Bytes zurück. Konnte kein Speicher reserviert werden, so wird
0 zurückgegeben.

FREESPACE(Adresse,Länge)

Gibt Speicher des internen Pools, welcher mit GETSPACE reserviert wurde
wieder frei. Die Adresse muß 4 Byte lang sein. Wird die Fkt. ohne Parameter
aufgerufen, so wird der interne Pool freigegeben!

vgl. ALLOCMEM, FREEMEM, IMPORT, EXPORT, STORAGE.

***
fuzz
FUZZ()

Gibt die interne Einstellung von "Numeric Fuzz" zurück.

vgl. NUMERIC

***
getclip
*
setclip
*
clip
GETCLIP(Name)
SETCLIP(Name,[Wert])

SETCLIP nimmt einen neuen Clip mit dem angegebenen Namen in die interne
Liste auf, und weißt diesem den Wert zu. Clips mit gleichem Namen werden
überschrieben. Wird ein leerer Wert übergeben, so wird der Clip gelöscht.

GETCLIP sucht einen Clip mit dem angegebenen Namen, und gibt die entspr.
Wertzeichenfolge zurück, wenn keine existiert einen Leerstring.

Beide Funktionen unterscheiden zwischen Groß- und Kleinschreibung!

***
hash
HASH(Zeichenfolge)

Gibt das Hashattribut der Zeichenfolge zurück.

vgl. Handbuch S.10-107.

***
import
IMPORT(Adresse,[Anzahl])

Liest ab der Adresse die angegebene Anzahl Bytes, und gibt diese als String
zurück. Ist die Anzahl nicht angegeben, so wird bis zu einer 0 gelesen.

vgl.: EXPORT, STORAGE.

***
index
INDEX(Zeichenfolge,Muster,[Start])

Sucht nach dem ersten Auftreten des Musters in der Zeichenfolge, und gibt
diese Stelle zurück. Ist Start nicht angegeben so wird ab Stelle 1 gesucht.
Gibt es keine Übereinstimmung, wird 0 zurückgegeben.

Bsp.: say index('123456','23')  --> 2

vgl. FIND, LASTPOS.

***
insert
INSERT(neu,alt,[Start],[Länge],[Füllzeichen])

Fügt in die Zeichenkette 'alt' die Zeichenkette 'neu' ab der Start-Position
ein, falls angegeben. Die Standart-Startposition ist 0. Wenn eine Länge an-
gegeben ist, wird die Zeichenkette bei bedarf gekürzt, oder mit dem Füll-
zeichen bzw. mit Leerzeichen aufgefüllt.

***
lastpos
LASTPOS(Muster,Zeichenfolge,[Start])

Sucht ab der Startposition rückwärts in der Zeichenfolge nach dem Muster,
und gibt dessen Position zurück. Wird keine Übereinstimmung gefungen, so
wird 0 zurückgegben. Ist keine Startposition angegeben so wird am Ende der
Zeichenfolge begonnen.

vgl. FIND, INDEX.

***
left
LEFT(Zeichenfolge,Anzahl,[Füllzeichen])

Gibt die linken 'Anzahl' Zeichen der Zeichenfolge zurück, und füllt ggf. mit
dem Füllzeichen oder Space auf.

vgl. RIGHT, SUBSTR, SUBWORD.

***
length
LENGTH(Zeichenfolge)

Gibt die Länge der Zeichenfolge an.

***
lines
LINES(Datei)

Gibt an, wieviele Zeilen einer logischen Datei in der Warteschlange stehen
oder bereits eingegeben wurden.

***
max
*
min
MAX(Zahl,Zahl[,Zahl...])
MIN(Zahl,Zahl[,Zahl...])

Gibt das MINimum bzw. das MAXimum der angegebenen Zahlen zurück.

***
open
OPEN(Datei,Dateiname,['Append' | 'Read' | 'Write'])

Öffnet eine externe Datei mit dem Dateinamen zum Anhängen (Append), Lesen
(Read) oder Schreiben (Write). Das Argument Datei definiert einen logischen
Namen, mit dem auf die Datei verwiesen wird. Es wird ein boolscher Wert
zurückgegeben, mit dem angezeigt wird, ob die Operation erfolgreich war.

vgl. CLOSE, READ, WRITE.

***
overlay
OVERLAY(neu,alt,[Start],[Länge],[Füllzeichen])

Überlagert die Zeichenfolge 'alt' mit der Zeichenfolge 'neu'. Ist das Ergeb-
nis kürzer als angegeben, wird mit dem Füllzeichen oder Space aufgefüllt.
Es wird an der Start-position begonnen. Standart ist 1.

***
pos
POS(Muster,Zeichenfolge,[Start])

Sucht ab dem Start in der Zeichenfolge nach dem Muster, und gibt dessen
Position zurück. Wird keine Übereinstimmung gefunden wird 0 zurückgegeben.
Die standartmäßige Startposition ist 1.

***
pragma
PRAGMA(Option,[Wert])

Änderung verschiedener Programmattribute, die mit Option angegeben werden:
-Directory (D) -> Wechselt Verzeichnis, liefert alten Wert
-Priority (P)  -> Legt Priorität fest, liefert alten Wert
-Id (I)        -> Legt Task-ID fest
-Stack (S)     -> Legt Größe des Stack fest

PRAGMA('W',{'Null' | 'Workbench'})
Steuert das Task-Feld "WindowPtr". 'Null' unterdrückt alle Dialogfenster.
PRAGNA('*',[Name])
Definiert den angeg. logischen Namen als den akt. Konsolenhandler.

vgl. Handbuch S.10-113f

***
random
*
rnd
*
zufall
*
zufallszahl
RANDOM([Min],[Max],[Ausgangszahl])

Gibt eine Pseudo-Zufallszahl >= Min und < Max zurück. Die Ausgangszahl setzt
den Startwert des internen Zufallszahlgenerators.

vgl. RANDU.

***
randu
RANDU([Ausgangszahl])

Liefert eine Pseudo-Zufallszahl zwischen 0 und 1. Die Ausgangszahl setzt den
Startwert des internen Zufallszahlgenerators.

vgl. RANDOM.

***
readch
READCH(Datei,Länge)

Liest Länge Zeichen aus der Datei.

vgl. READLN.

***
readln
READLN(Datei)

Liest eine Zeile aus der Datei. Das Zeichen für Zeilenende wird nicht mit
zurückgegeben.

vgl. READCH.

***
remlib
REMLIB(Name)

Löscht einen Namen aus der internen Bibliotheksliste. Es wird nicht zwischen
Funktionsbibliotheken und Funktions-Hostprogrammen unterschieden.

vgl. ADDLIB.

***
reverse
REVERSE(Zeichenfolge)

Stellt die Zeichenfolge in umgekehrter Reihenfolge dar.

Bsp.: say reverse('nebel')  --> leben

***
right
RIGHT(Zeichenfolge,Länge,[Füllzeichen])

Liefert Länge Zeichen von der rechten Seite der Zeichenfolge. Ist die Zei-
chenfolge kürzer als Länge, wird links mit dem Füllzeichen oder dem Leer-
zeichen aufgefüllt.

vgl. LEFT, SUBWORD, SUBSTR.

***
seek
SEEK(Datei,Offset,['Begin' | 'Current' | 'End'])

Geht in der Datei um den Offset vorwärts. Startpunkt ist der Anfang 'C',
die aktuelle Position 'C' oder das Ende 'E'. Rückgabewert ist die neue Posi-
tion, gezählt ab dem Dateianfang.

Bsp.: say seek('eingabe',10,'B') --> 10
      say seek('eingabe',0,'E')  --> 356  /* Dateilänge */

***
show
SHOW(Option,[Name],[Füllzeichen])

Gibt die Namen in der von Option festgelegten Liste zurück oder überprüft,
ob ein Eintrag mit dem angeg. Namen existiert. Bei den Namen wird zwischen
Groß- und Kleinschreibung unterschieden. Wird kein Name angegeben, so wird
eine Zeichenfolge mit allen Einträgen, getrennt durch das Füllzeichen oder
einem Leerzeichen zurückgegeben. Folgende Optionen sind möglich:
-Clip      -> Clip-Liste
-Files     -> Namen der offenen logischen Dateien
-Libraries -> Bibliotheks-Liste (ARexx!)
-Ports     -> System-Port-Liste

vgl. ADDRESS.

***
sign
*
sgn
SIGN(Zahl)

Vorzeichen der Zahl. Liefert 1 wenn positiv, -1 wenn negativ.

***
sourceline
SOURCELINE([Zeile])

Gibt die angegebene Programmzeile zurück wenn angegeben, sonst die Zahl der
Programmzeilen. Ermöglicht eine integrierte Hilfe-Funktion.

***
space
SPACE(Zeichenfolge,n,[Füllzeichen])

Formatiert die Zeichenfolge so, daß sich zwischen jedem Wort n Füllzeichen
oder Leerzeichen befinden.

***
storage
STORAGE([Adresse],[Zeichenfolge],[Länge],[Füllzeichen])

Ohne Parameter wird die verfügbare Kapazität des Speichers zurückgegeben.
Sonst wird die Zeichenfolge an die 4 Byte lange Adresse kopiert. Ist
Länge kleiner als die Länge der Zeichenfolge wird diese gekürzt, sonst wird
mit dem Füllzeichen oder der Leerzeichen aufgefüllt.

vgl. EXPORT, IMPORT.

***
strip
STRIP(Zeichenfolge,[{'B' | 'L' | 'T'}],[Zeichen])

Löscht das angegebene Zeichen am Anfang und/oder Ende der Zeichenfolge. Ist
kein Zeichen angegeben werden Leerzeichen gelöscht. Der zweite Parameter
gibt an, wo gelöscht wird:
-T (Trailing = Nachgestellt)
-L (Leading  = Vorangestellt)
-B (Both     = Beides)

vgl. TRIM.

***
substr
SUBSTR(Zeichenfolge,Start,[Länge],[Füllzeichen])

Gibt die Teilzeichenfolge der angegebenen Länge ab der angeg. Startposition
zurück. Ist Länge größer als die Länge des Strings, wird mit dem Füllzeichen
oder dem Leerzeichen aufgefüllt.

vgl. LEFT, RIGHT, SUBWORD.

***
subword
SUBWORD(Zeichenfolge,n,[Anzahl])

Gibt Anzahl Worte ab dem n-ten Wort der Zeichenfolge zurück.

vgl. SUBSTR, LEFT, RIGHT.

***
symbol
SYMBOL(Name)

Überprüft, ob der Name ein gültiges ARexx-Symbol ist, und gibt folgende
Werte zurück:
BAD -> Kein Symbol
LIT -> uninitialisiertes Symbol
VAR -> Variable mit Wert

***
time
TIME(Option)

Gibt die aktuelle Systemzeit zurück. Als Option können folgende Worte einge-
setzt werden (es genügt der Anfangsbuchstabe):
-Civil   -> 12-Stunden-Format
-Reset   -> Uhr zurücksetzen
-Elapsed -> Zeit in Sekunden seit Aufruf mit 'Reset'
-Hours   -> Stunden seit Mitternacht
-Minutes -> Minuten seit Mitternacht
-Normal  -> 24-Stunden-Format
-Seconds -> Sekunden seit Mitternacht

vgl. DATE.

***
trace
TRACE(Option)

Schaltet den Ablaufverfolgungsmodus ein. Beschreibung der Optionen siehe
Handbuch, eigenes Kapitel.

***
translate
TRANSLATE(Zeichenfolge,[Ausgabe],[Eingabe],[Füllzeichen])

Ersetzt alle in der Eingabe-Zeichenfolge vorkommenden Zeichen der Zeichen-
folge in die entsprechenden Zeichen der Ausgabe-Zeichenfolge. Zeichen, die
über die Länge der Ausgabe-Zeichenfolge hinausgehen werden durch ein Leer-
zeichen oder das Füllzeichen ersetzt.

Bsp.: say translate("abcde","123","cbade","+") --> 321++
      say translate("0110","10","01")          --> 1001

***
trim
TRIM(Zeichenfolge)

Löscht nachgestellte Leerzeichen aus der Zeichenfolge.

vgl. STRIP.

***
trunc
TRUNC(Zahl,[Stellen])

Gibt den ganzzahligen Anteil der Zahl, und die spezifizierte Anzahl an Nach-
kommastellen zurück. Bei Bedarf wird mit Nullen aufgefüllt.

***
upper
UPPER(Zeichenfolge)

Übersetzt die Zeichenfolge in Großbuchstaben.

vgl. LOWER.

***
value
VALUE(Name)

Liefert den Wert des Symbols mit dem angeg. Namen.

***
verify
VERIFY(Zeichenfolge,Liste,['Match'])

Wird 'Match' angegeben, so wird der Index des ersten Zeichens der Zeichen-
folge zurückgegeben, das in der Liste vorhanden ist, sonst den Index des
ersten Zeichens das nicht in der Liste ist.

Bsp.: say verify('123456','0123456789') --> 0
      say verify('123a56','0123456789') --> 4

***
word
WORD(Zeichenfolge,n)

Gibt das n-te Wort der Zeichenfolge zurück, oder eine leere Zeichenfolge,
wenn weniger als n Worte vorhanden sind.

vgl. WORDINDEX, WORDLENGTH, WORDS.

***
wordindex
WORDINDEX(Zeichenfolge,n)

Gibt die Startposition des n-ten Wortes der Zeichenfolge zurück, oder Null,
wenn weniger als n Worte vorhanden sind.

vgl. WORD, WORDS, WORDLENGTH.

***
wordlength
WORDLENGTH(Zeichenfolge,n)

Gibt die Länge des n-ten Wortes der Zeichenfolge zurück, oder Null,
wenn weniger als n Worte vorhanden sind.

vgl. WORD, WORDS, WORDINDEX.

***
words
WORDS(Zeichenkette)

Gibt die Anzahl der Worte der Zeichenkette zurück.

vgl. WORD, WORDLENGTH, WORDINDEX.

***
writech
WRITECH(Datei,Zeichenfolge)

Schreibt die Zeichenfolge in die logische Datei. Rückgabewert ist die Anzahl
der geschriebenen Zeichen.

vgl. WRITELN, READCH, READLN.

***
writeln
WRITELN(Datei,Zeichenfolge)

Schreibt die Zeichenfolge in die logische Datei, und fügt ein Zeichen für
'neue Zeile' hinzu. Rückgabewert ist die Anzahl der geschriebenen Zeichen.

vgl. WRITECH, READLN, READCH.

***
x2c
X2C(Zeichenfolge)

Wandelt eine aus hexadezimalen Ziffern bestehende Zeichenfolge in die
Zeichedarstellung (ASCII) um.

vgl. X2D.

***
x2d
X2D(Hex,Ziffern)

Wandelt eine hexadezimale Zahl in eine dezimale um.

Bsp.: say x2d('1f') --> 31

vgl. X2C.

***
xrange
XRANGE([Start],[Ende])

Generiert eine Zeichenfolge, die alle Zeichen besteht, die numerisch
zwischen Start und Ende liegen. Vorgabe ist '00'x und 'FF'x.

Bsp.: say xrange('a','f') --> 'abcdef'

***
rexxsupport
*
rexxsupport.library
*
allocmem
*
closeport
*
freemem
*
getarg
*
getpkt
*
openport
*
reply
*
showdir
*
showlist
*
statef
*
waitpkt
Folgende Funktionen werden in der RexxSupport.library definiert. Diese muß
zur Nutzung zuerst geöffnet werden (siehe Handbuch S.10-133):

ALLOCMEM(Länge,[Attribut])
CLOSEPORT(Name)
FREEMEM(Adresse,Länge)
GETARG(Paket,[n])
GETPKT(Name)
OPENPORT(Name)
REPLY(Paket,rc)
SHOWDIR(Verzeichnis,['All'|'File'|'Dir'],[Füllzeichen])
SHOWLIST({'A'|'D'|'H'|'I'|'L'|'M'|'P'|'R'|'S'|'T'|'V'|'W'},[Name],[Zeichen])
STATEF(Dateiname)
WAITPKT(Name)

