This page is also available in

Handbuch

Die folgende Dokumentation ist Bestandteil der BeeBase-Distribution und gibt es auch als PDF.

16. BeeBase programmieren

Dieses Kapitel (das größte dieser Dokumentation) beschreibt die Programmiersprache von BeeBase, einschließlich aller verfügbaren Funktionen. Das Kapitel dient jedoch nicht als allgemeine Anleitung für Programmieren. Man sollte mit den Grundzügen der Programmierung vertraut sein und schon kleinere (richtig funktionierende :-)) Programme geschrieben haben.

16.1 Programmeditor

Um ein Programm für ein Projekt einzugeben, öffnet man den Programmeditor über den Menüpunkt `Programm - Ändern'. Sofern Sie die Einstellung Programmquellen intern (siehe Programmquellen) verwenden, öffnet dies das Fenster `Ändere Programm' mit:

• einem Texteditorfeld, in dem das Programm editiert wird
• einem Knopf `Kompilieren & Schließen', mit dem das Programm kompiliert und nach einer erfolgreichen Kompilation der Programmeditor verlassen wird.
• einem Knopf `Kompilieren', um das Programm zu kompilieren. Enthält das Programm irgendwo einen Fehler, dann wird eine Fehlerbeschreibung in den Fenstertitel und der Cursor an die fehlerhafte Stelle gesetzt.
• einem Knopf `Rückgängig machen', der alle Änderungen seit der letzten erfolgreichen Kompilation verwirft.

Der Programmeditor ist ein nicht-modales Fenster. Das Fenster kann offen gelassen und weiterhin mit dem Rest der Anwendung gearbeitet werden. Man kann den Editor zu jeder Zeit schließen, indem dessen Fensterschließ-Knopf gedrückt wird. Wurden Änderungen seit der letzten erfolgreichen Kompiliation vorgenommen, dann erscheint eine Sicherheitsabfrage, die um Bestätigung fragt, ob das Fenster geschlossen werden darf.

Falls Sie Menüpunkt `Programm - Quellen' auf `Extern' gesetzt haben, so wird bei Wahl von `Programm - Ändern' der externe Editor (siehe Externer Editor) mit dem Dateinamen der externen Quelldatei gestartet. Dies ermöglicht das Editieren der Programmquellen mit Ihrem Lieblingseditor (siehe Externe Programmquellen).

Man kann das Projektprogramm auch ohne das Öffnen des Programmeditors kompilieren, indem der Menüpunkt `Programm - Kompilieren' ausgewählt wird. Dies ist nützlich, wenn Änderungen an einer Include-Datei gemacht wurden und diese Änderungen in das Projektprogramm einfließen sollen.

16.2 Externe Programmquellen

Durch Wählen des Menüpunktes `Programm - Quellen - Extern' und Eingabe eines Dateinamens können die Programmquellen eines Projekts extern verfügbar gemacht werden. Dies erlaubt es, die Quelldatei für die Programmierung in Ihren Lieblingseditor zu laden.

Bei erfolgreicher Übersetzung wird das übersetzte Programm als neues Projektprogramm übernommen und beim Aufruf von Auslösefunkionen verwendet. Wenn Sie ein Projekt speichern, so wird das letzte erfolgreich übersetzte Program in der Projektdatei gespeichert. Von daher wird nach dem Speichern und Schließen eines Projekts die externe Programquelldatei nicht mehr benötigt. Sie können in Menüpunkt `Einstellungen - Externe Programmquellen aufräumen' einstellen, ob unbenötigte externe Quelledateien automatisch gelöscht werden sollen.

Der Zustand von Menüpunkt `Programm - Quellen' wird mit einem Projekt gespeichert. Wenn Sie ein Projekt, welches die externe Quelldateien-Einstellung verwendet, erneut öffnen, so wird die externe Quelldatei nach dem Öffnen erzeugt. Falls die externe Datei bereits existiert und verschieden von der im Projekt gespeicherten Version ist, so erscheint eine Sicherheitsabfrage bevor die Datei überschrieben wird.

Auf dem Amiga kann aus dem Editor heraus der compile-Befehl an BeeBase' ARexx-Port geschickt werden. BeeBase lädt daraufhin die externe Quelldatei, übersetzt sie, und liefert den Übersetzungsstatus mit einer optionalen Fehlermeldung zurück. Die Fehlermeldung enthält Dateiname, Zeile und Spalte, und eine Fehlerbeschreibung. Dies erlaubt es, auf die genau Fehlerstelle im Editor zu springen. Siehe ARexx compile, für weitere Details über Rückgabewerte und Fehlerformat.

16.3 Vorverarbeitung

BeeBase-Programme werden vorverarbeitet, wie ein C-Compiler einen C-Quellcode vorverarbeitet. Dieser Abschnitt beschreibt, wie die Vorverarbeitungs-Anweisungen verwendet werden.

Alle Anweisungen beginnen mit dem Rauten-Symbol #, welcher das erste Zeichen in einer Zeile sein muss. Leerzeichen und Tabulatoren können nach dem begonnenen # folgen.

16.3.1 #define

#define name string

Definiert ein neues Symbol mit dem gegebenen Namen und Inhalt. Das Symbol string kann jeder Text einschließlich Leerzeichen sein und endet am Zeilenende. Passt string nicht in eine Zeile, dann können weitere Zeilen durch ein Backslash-Zeichen \ am Ende jeder Zeile (außer der letzten) verwendet werden. Taucht das Symbol name im verbleibenden Quellcode auf, dann wird es durch den Inhalt von string ersetzt.

Beispiel: `(PRINTF "X ist %i" X)' gibt `X ist 1' aus (name's in Zeichenketten werden nicht verändert.)

Das Ersetzen von definierten Symbolen geschieht syntaktisch, das bedeutet, dass Symbole durch jeden Text ersetzt werden können, z.B. man kann sich seine eigene Syntax wie im folgenden Beispiel definieren:

#define BEGIN (
#define END )

BEGIN defun test ()
        ...
END

Die zu ersetzende Zeichenkette einer Definition kann ein anderes Symbol enthalten, das mit der #define-Anweisung definiert wurde, um verschachtelte Definitionen zu ermöglichen. Es gibt jedoch eine Obergrenze von 16 verschachtelten Definitionen.

Siehe auch #undef, #ifdef, #ifndef.

16.3.2 #undef

#undef name

Entfernt die Definition des Symbols name. Wurde name nicht definiert, dann passiert nichts.

Siehe auch #define, #ifdef, #ifndef.

16.3.3 #include

#include filename

Liest den Inhalt von filename (eine Zeichenkette in Anführungszeichen) an diese Stelle. BeeBase sucht im aktuellen Verzeichnis und im in den Einstellungen festgelegten Verzeichnis (siehe Programm-Include-Verzeichnis) nach der zu ladenden Datei.

Der Dateiinhalt wird durch den Compiler verarbeitet, als ob er Teil des momentanen Quellcodes wäre.

Eine externe Datei kann eine oder mehrere externe Dateien enthalten. Es gibt jedoch eine Obergrenze von 16 verschachtelten #include-Anweisungen. Um zu vermeiden, dass Dateien mehr als einmal eingefügt werden, kann die bedingte Kompilation verwendet werden.

Man sollte vorsichtig sein, wenn man Quellcode in externe Dateien auslagert! Die Fehlersuche und das Auffinden von Fehlern in externen Dateien wesentlich schwerer. Man verschiebe daher nur getesteten und Projekt-unabhängigen Code in externe Dateien.

16.3.4 #if

#if const-expr

Ist der gegebene konstante Ausdruck const-expr nicht NIL, dann wird der Text bis zum zugehörigen #else, #elif oder #endif zur Kompilation verwendet, anderenfalls (der Ausdruck lieferte NIL) wird der Text bis zum zugehörigen #else, #elif oder #endif nicht zur Kompilation herangezogen.

Momentan können nur TRUE und NIL als konstante Ausdrücke verwendet werden.

Siehe auch #ifdef, #ifndef, #elif, #else, #endif.

16.3.5 #ifdef

#ifdef name

Ist das gegebene Symbol name mit einer #define-Anweisung definiert worden, dann wird der Text bis zum zugehörigen #else, #elif oder #endif zur Kompilation verwendet, anderenfalls nicht betrachtet.

Siehe auch #if, #ifndef, #elif, #else, #endif.

16.3.6 #ifndef

#ifndef name

Ist das gegebene Symbol name nicht mit einer #define-Anweisung definiert worden, dann wird der Text bis zum zugehörigen #else, #elif oder #endif zur Kompilation verwendet, anderenfalls nicht betrachtet.

Siehe auch #if, #ifdef, #elif, #else, #endif.

16.3.7 #elif

#elif const-expr

Beliebig viele #elif-Anweisungen können zwischen einem #if, #ifdef oder #ifndef und dem zugehörigen #else oder #endif auftreten. Die Zeilen, die der elif-Anweisung folgen, werden für eine Kompilation verwendet, aber nur dann, wenn jede der folgenden Bedingungen erfüllt ist:

• Der konstante Ausdruck in der vorherigen #if-Anweisung lieferte NIL, das Symbol name im vorherigen ifdef war nicht definiert oder das Symbol name in der vorherigen ifndef-Anweisung war definiert.
• Die konstanten Ausdrücke in allen dazwischenliegenden elif-Anweisungen lieferten NIL.
• Der momentane konstante Ausdruck liefert nicht NIL.

Wenn die oben genannten Bedingungen stimmen, dann werden die nachfolgenden Anweisungen #elif und #else bis zum zugehörigen #endif ignoriert.

Siehe auch #if, #ifdef, #ifndef, #else, #endif.

16.3.8 #else

#else

Dies kehrt den Sinn einer bedingten Anweisung um, der sonst gestimmt hätte. Wenn die vorhergehende Bedingung anzeigen würde, dass Zeilen eingefügt werden, dann werden die Zeilen zwischen #else und dem zugehörigen #endif ignoriert. Zeigt die vorhergehende Bedingung an, dass Zeilen ignoriert werden, dann werden nachfolgende Zeilen für die Kompilation eingefügt.

Bedingte Anweisungen und dazugehörige #else-Anweisungen können verschachtelt werden. Es gibt jedoch eine maximale Verschachteltiefe von 16 verschachtelten bedingten Anweisungen.

Siehe auch #if, #ifdef, #ifndef, #elif, #endif.

16.3.9 #endif

#endif

Beendet einen Bereich von Zeilen, der mit einer der bedingten Anweisungen #if, #ifdef oder #ifndef beginnt. Jeder dieser Anweisungen muss eine zugehörige #endif-Anweisung besitzen.

Siehe auch #if, #ifdef, #ifndef, #elif, #else.

16.4 Programmiersprache

BeeBase verwendet eine Programmiersprache mit einen lisp-ähnlichen Aufbau. Tatsächlich sind einige Konstrukte und Funktionen vom Standard-Lisp entnommen worden. BeeBase ist jedoch nicht vollständig kompatibel zu Standard-Lisp. Viele Funktionen fehlen (z.B. destruktive Befehle) und die Bedeutung einiger Befehle unterscheiden sich (z.B. der Befehl return).

16.4.1 Warum Lisp?

Der Vorteil einer lisp-ähnlichen Sprache ist, dass man sowohl funktional als auch imperativ programmieren kann. Funktionale Sprachen sind in mathematischen Anwendungen weit verbreitet. Das Grundelement von funktionalen Sprachen ist die Verwendung von Ausdrücken. Funktionen werden in mathematischer Schreibweise definiert und häufig wird Rekursion benutzt.

Imperative Programmiersprachen (wie C, Pascal, Modula) benutzen eine Befehlsvorschrift (oder Zustandsänderungsvorschrift), wie etwas berechnet werden soll. Hier ist das Grundelement der Zustand (z.B. Variablen) und ein Programm berechnet dessen Ausgabe durch den Wechsel von einem Zustand in einen anderen (z.B. durch Zuweisen von Werten an Variablen).

Lisp kombiniert beide Techniken und deshalb kann man auswählen, auf welche Art etwas implementiert werden soll. Man verwendet diejenige, die besser zum vorgegebenen Problem passt oder die man lieber mag.

16.4.2 Lisp-Aufbau

Ein lisp-Ausdruck ist entweder eine Konstante, eine Variable oder ein Funktionsausdruck. Beim Funktionsaufruf verwendet Lisp eine Prefix-Notation. Die Funktion und seine Parameter werden von runden Klammern eingeschlossen. Um zum Beispiel zwei Werte a und b zu addieren, schreibt man

(+ a b)

Alle Ausdrücke liefern einen Wert, z.B. im obigen Beispiel die Summe von a und b. Ausdrücke können verschachtelt werden, d.h. man kann Ausdrücke als Unterausdruck in eine andere einsetzen.

Funktionen werden nach dem call-by-value-Schema aufgerufen, was bedeutet, dass zuerst die Parameter berechnet werden, bevor die Funktion aufgerufen wird.

Wenn nicht anders angegeben, sind alle Funktionen strikt, d.h. alle Parameter einer Funktion müssen zuerst ermittelt werden, bevor sie an die Funktion übergeben und diese ausgeführt wird. Einige Funktionen sind jedoch nicht strikt, z.B. IF, AND und OR. Diese Funktionen brauchen nicht alle Parameter ermitteln.

16.4.3 Programmarten

BeeBase kennt drei Programmarten. Die erste ist das Projektprogramm. Im Programm dieser Art können Funktionen und globale Variablen definiert werden. Die Funktionen können als Auslösefunktionen für Felder verwendet werden. Ein Projektprogramm wird im Programmeditor (siehe Programmeditor) festgelegt.

Die zweite Art ist das Abfrageprogramm. FÜr dieses können nur Ausdrücke eingegeben werden. Ein solcher Ausdruck darf globale Variablen enthalten und Funktionen aufrufen, die im Projektprogramm definiert wurden. Man kann jedoch in einem Abfrageprogramm keine neuen globalen Variablen und Funktionen festlegen. Abfrageprogramme werden im Abfrageeditor (siehe Abfrageeditor) eingegeben.

Die dritte Programmart sind Filterausdrücke. Hier lassen sich nur Ausdrücke eingeben, die vordefinierte BeeBase-Funktionen aufrufen. Es sind nicht alle vordefinierten Funktionen verfügbar und zwar nur solche die keine Seiteneffekte aufweisen, z.B. kann man keine Funktion verwenden, die Daten in eine Datei schreibt. Filterausdrücke werden im Filterfenster (siehe Filter ändern) verändert.

16.4.4 Namenskonventionen

In einem BeeBase-Programm können Symbole, wie Funktionen, lokale und globale Variablen, definiert werden. Die Namen dieser Symbole müssen folgenden Punkten genügen:

• das erste Zeichen eines Namens muss ein Kleinbuchstabe sein. Dies unterscheidet Programmsymbole von Tabellen- und Feldnamen.
• die folgenden Zeichen können Buchstaben (groß oder klein), Ziffern und Unterstriche sein. Andere Zeichen wie z.B. deutsche Umlaute sind nicht zulässig.

16.4.5 Datensatzinhalte ansprechen

Um auf Tabellen und Felder in einem BeeBase-Programm zugreifen zu können, muss ein Pfad zu diesen angegeben werden. Ein Pfad ist eine durch Punkte getrennte Liste von Komponenten, wobei jede Komponente der Name einer Tabelle oder eines Feldes ist.

Pfade können entweder relativ oder absolut sein. Absolute Pfade beginnen mit dem Tabellennamen als erste Komponente, gefolgt von einer Liste von Feldern, die zum gewünschten Feld hinführen, auf das man zugreifen möchte. Zum Beispiel greift der absolute Pfad `Person.Name' auf das Feld `Name' im aktuellen Datensatz der Tabelle `Person' zu oder der absolute Pfad `Person.Vater.Name' auf das Feld `Name' in dem Datensatz, der durch das Feld `Vater' referenziert wird (der ein Beziehungsfeld zur Tabelle `Person' ist).

Relative Pfade haben schon eine aktuelle Tabelle, auf die sie sich beziehen. Zum Beispiel ist in einem Filterausdruck die aktuelle Tabelle diejenige, für die der Filterausdruck geschrieben wird. Der relative Pfad für ein Feld in der aktuellen Tabelle ist dann nur der Feldname selbst. Auf Felder, auf die nicht direkt von der aktuellen Tabelle aus zugegriffen werden kann, sondern indirekt über eine Beziehung, dann gelten die gleichen Regeln wie für absolute Pfade.

Es ist nicht immer eindeutig, ob ein angegebener Pfad ein relativer oder ein absoluter ist, z.B. bei einem Filterausdruck für eine Tabelle, das ein Feld `Bar' besitzt, wenn es auch eine Tabelle `Bar' gibt. Wird nun `Bar' eingegeben, dann ist unklar, was gemeint ist: die Tabelle oder das Feld? Daher werden alle Pfade zuerst als relative Pfade betrachtet. Wird kein Feld für den angegebenen Pfad gefunden, dann wird der Pfad global betrachtet. In unserem Beispiel würde das Feld bevorzugt.

Was aber, wenn im Beispiel oben auf die Tabelle zugegriffen werden soll? In dem Fall muss der Pfad absolut angegeben werden. Um einen Pfad als global zu kennzeichnen, müssen vor dem Pfad zwei Doppelpunkte angefügt werden. In unserem Beispiel müsste man `::Bar' eingeben, um auf die Tabelle zuzugreifen.

Um Pfade und ihre Anordnungen besser zu verstehen, betrachten wir hier als Beispiel, dass das Feld `Bar' in der Tabelle `Foo' eine Beziehung zur Tabelle `Bar' ist und die Tabelle `Bar' enthält ein Feld `Name'. Nun kann man auf das Feld `Name' zugreifen, indem man `Bar.Name' oder `::Bar.Name' eingibt. Beide Ausdrücke haben unterschiedliche Bedeutungen. `::Bar.Name' bedeutet, dass der aktuelle Datensatz der Tabelle `Bar' hergenommen wird und der Wert des Feldes `Name' in diesem Datensatz zurückgeliefert wird, wohingegen `Bar.Name' den aktuellen Datensatz von `Foo' hernimmt, die Beziehung des Feldes `Bar' ermittelt und diesen Datensatz zum Ermitteln des Wertes vom Feld `Name' verwendet.

Um ein komplexeres Beispiel anzubringen, stellen wir uns vor, dass die Tabelle `Bar' zwei Datensätze hat. Der eine enthält im Feld `Name' den Eintrag `Ralph' und der andere `Steffen'. Der erste Datensatz ist der momentan aktive. Des weiteren hat die Tabelle `Foo' einen Datensatz (den aktuellen), dessen Feld `Bar' auf den zweiten Datensatz der Tabelle `Bar' verweist. `::Bar.Name' liefert jetzt `Ralph' und `Bar.Name' liefert `Steffen'.

16.4.6 Datentypen zum Programmieren

Die Programmiersprache von BeeBase kennt die folgenden Datentypen:

Typ         Beschreibung

Boolesch    alle Ausdrücke. Nicht-NIL-Ausdrücke werden als TRUE betrachtet.

Integer     lange Ganzzahl, 32 bit, Auswahlwerte werden automatisch in
            Integer umgewandelt

Real        double, 64 bit

String      Zeichenketten von unterschiedlicher Länge

Memo        wie Zeichenketten, aber zeilenorientiertes Format

Date        Datumswerte

Time        Zeitwerte

Record      Zeiger auf einen Datensatz

File        Dateideskriptor zum Lesen/Schreiben

List        Liste von Elementen, NIL ist eine leere Liste.

Alle Programmiertypen unterstützen den Wert NIL.

16.4.7 Konstanten

Die Programmiersprache von BeeBase kann konstante Ausdrücke handhaben, die abhängig von ihrem Typ eingegeben werden kann:

Typ         Beschreibung

Integer     Ganzzahlkonstanten im Bereich von -2147483648 bis
            2147483647 können wie üblich angegeben werden.
	    Werte, die mit 0 beginnen, werden als Octalzahlen
            interpretiert, Werte, die mit 0x beginnen, als
 	    Hexadezimalzahlen.

Real        Fließkommazahlen im Bereich von -3.59e308 bis
            3.59e308 können wie üblich angegeben werden, sowohl
            im wissenschaftlichen als auch nicht-wissenschaft-
            lichen Format. Wird der Dezimalpunkt vergelassen,
            so wird die Zahl nicht als Real betrachtet, sondern
            als Integer.

String      Zeichenkettenkonstanten sind jedes Zeichen in einer
            Kette, umschlossen mit doppelten Anführungsstrichen,
            z.B."Beispielzeichenkette". Innerhalb der doppelten
            Anführungszeichen kann jedes Zeichen angegeben werden,
            mit Ausnahme von Steuerzeichen und neuen Zeilen. Es
            gibt jedoch besondere Escapezeichen zum Eingeben
            solcher Zeichen:

                \n              neue Zeile (nl)
                \t              horizontaler Tabulator (ht)
                \v              vertikaler Tabulator (vt)
                \b              Rückschritt (bs)
                \r              Wagenrücklauf (cr)
                \f              Seitenumbruch (ff)
                \\              der Backslash selbst
                \"              doppeltes Anführungszeichen
                \e              Escapezeichen 033
                \nnn            Zeichen mit dem Oktalcode nnn
                \xnn            Zeichen mit dem Hexcode nn

Memo        Wie Zeichenkettenkonstanten.

Date        Konstante Datumswerte können in einem der Formate
            `TT.MM.JJJJ', `MM/TT/JJJJ' oder `JJJJ-MM-TT'
            angegeben werden, wobei `TT', `MM' und `JJJJ'
            die zwei- und vierstelligen Werte für Tag, Monat
            bzw. Jahr darstellen.

Time        Konstante Zeitwerte werden im Format `HH:MM:SS' angegeben,
            wobei `HH' die Stunden, `MM' die Minuten und `SS' 
            die Sekunden repräsentieren.

Für andere vordefinierte Konstanten, siehe Vordefinierte Konstanten.

16.4.8 Befehlsaufbau

Im Rest dieses Kapitels findet man die Beschreibung aller Befehle und Funktionen, die für die Programmierung von BeeBase zur Verfügung stehen. Der folgende Aufbau wird verwendet, um die Befehle zu beschreiben:

• Text innerhalb von [] ist optional. Wird der Text innerhalb der Klammern weggelassen, dann wird ein Vorgabewert angenommen.
• Texte, die durch senkrechte Striche | getrennt werden, geben verschiedene Optionen an. Z.B. bedeutet `a | b', dass entweder `a' oder `b' angegeben werden kann.
• Text, der im Schriftstil var geschrieben wird, ist ein Platzhalter, der mit anderen Ausdrücken gefüllt werden kann.
• Punkte ... zeigen an, dass weitere Ausdrücke folgen können.
• jeder andere Text ist obligatorisch.

Anm.d.Übersetzers: Bei der Beschreibung der Befehle wird die englische Namensgebung der Parameter etc. beibehalten. Dies vermeidet Fehler bei der Übersetzung und bleibt dennoch verständlich.

16.5 Befehle definieren

Dieser Abschnitt listet Befehle zum Definieren von Funktionen und globalen Variablen auf. Die Befehle sind nur für Projektprogramme verfügbar.

16.5.1 DEFUN

DEFUN definiert eine Funktion mit einem festgelegten Namen, einer Liste von Parametern, die an die Funktion weitergereicht und eine Liste von Ausdrücken, die abgearbeitet werden.

(DEFUN name (varlist) expr ...)

Der Name der Funktion muss mit einem Kleinbuchstaben beginnen, gefolgt von weiteren Zeichen, Ziffern und Unterstrich-Zeichen. (siehe Namenskonventionen).

Der Parameter varlist legt die Parameter der Funktion fest:

varlist: var1 ...

wobei var1 ... die Namen der Parameter sind. Die Namen müssen den gleichen Regeln wie die des Funktionsnamens genügen.

Es ist auch möglich, Typdeklarierer an die Parameter zu hängen (siehe Typdeklarierer).

Die Funktion führt die Ausdrücke expr, ... der Reihe nach aus und liefert den Wert des letzten Ausdrucks. Die Funktion kann auch weitere Funktionen einschließlich sich selbst aufrufen. Eine selbstdefinierte Funktion wird wie eine vordefinierte Funktion aufgerufen.

Um zum Beispiel die Anzahl der Elemente einer Liste zu zählen, kann folgende Funktion definiert werden:

(DEFUN len (l)
    (IF (= l NIL)
        0
        (+ 1 (len (REST l)))
    )
)

Mit DEFUN definierte Funktionen werden in Popuplisten von Tabellen- und Feldfenstern aufgelistet (siehe Tabellen erstellen und Felder erstellen).

Dieser Befehl ist nur für Projektprogramme verfügbar.

Siehe auch DEFUN*, DEFVAR.

16.5.2 DEFUN*

DEFUN* ist die Stern-Variante von DEFUN und hat den selben Effekt wie DEFUN (siehe DEFUN). Der einzige Unterschied ist, dass Funktionen, die mit DEFUN* definiert wurden, beim Erzeugen oder Ändern von Tabellen und Feldern nicht in den Popuplisten aufgelistet werden. Es ist jedoch möglich, den Funktionsnamen in den entsprechenden Zeichenkettenfeldern einzugeben.

Dieser Befehl ist nur für Projektprogramme verfügbar.

Siehe auch DEFUN, DEFVAR.

16.5.3 DEFVAR

(DEFVAR var [expr])

Definiert eine globale Variable mit dem Vorgabewert aus expr oder NIL, wenn expr fehlt. Der Name der Variablen muss mit einem Kleinbuchstaben beginnen, gefolgt von weiteren Zeichen, Ziffern und Unterstrich-Zeichen. (siehe Nameskonventionen).

Man kann Typdeklarierer an den Variablennamen anhängen (siehe Typdeklarierer).

DEFVAR ist nur verfügbar für Projektprogramme. Alle DEFVAR-Befehle sollten am Anfang vor allen Funktionsdefinitionen plaziert werden.

Nach Beenden einer Trigger-Funktion (wenn BeeBase zum Benutzer-Interface zurückschaltet) geht der Inhalt aller globaler Variablen verloren. Diese werden beim nächsten Aufruf einer Auslösefunktion neu mit ihrem Vorgabewert expr initialisiert. Ist dies nicht erwünscht, so kann der Befehl DEFVAR* (siehe DEFVAR*) verwendet werden, welcher es erlaubt, den Inhalt globaler Variablen zwischen den Aufrufen zu speichern.

Bitte verwenden Sie globale Variablen sparsam (oder gar nicht). Alle globalen Variablen müssen bei jedem externen Aufruf einer Auslösefunktion neu initialisiert (und expr ausgewertet, wenn gegeben) werden.

Beispiel: `(DEFVAR x 42)' definiert eine globale Variable `x' mit dem Wert 42.

Es gibt einige vordefinierte Variablen in BeeBase (siehe Vordefinierte Variablen).

Siehe auch DEFVAR*, DEFUN, DEFUN*, LET.

16.5.4 DEFVAR*

(DEFVAR* var [expr])

DEFVAR* hat den gleichen Effekt wie der DEFVAR-Befehl (siehe DEFVAR) nur dass eine mit DEFVAR* definierte Variable nicht ihren Inhalt bei Programmende verliert.

Bei dem ersten Programmaufruf wird var mit dem Ausdruck expr oder NIL (falls expr fehlt) initialisiert. In allen weiteren Aufrufen wird expr nicht nocheinmal ausgewertet sondern der Wert von var aus dem letzten Aufruf verwendet. Dadurch ist es möglich, Informationen von einem Programmaufruf zum nächsten zu übermitteln, ohne Daten in externen Dateien oder in einer Datenbank-Tabelle zu speichern. Zu beachten ist aber, dass alle mit DEFVAR* definierten Variablen bei jeder Programmübersetzung ihren Wert verlieren. Falls Daten permanent gespeichert werden sollen, verwenden Sie hierfür ein (vorzugsweise verstecktes) Feld in einer Tabelle.

Siehe auch DEFVAR, DEFUN, DEFUN*, LET.

16.6 Programmsteuerungsfunktionen

Dieser Abschnitt listet Funktionen zur Programmflusskontrolle auf, z.B. Funktionen zum Definieren von lokalen Variablen, Schleifenfunktionen, bedingte Programmausführung, Schleifenkontrollfunktionen und mehr.

16.6.1 PROGN

Um mehrere Ausdrücke der Reihe nach auszuführen, wird der PROGN-Aufruf verwendet.

([expr ...])

führt expr ... der Reihe nach aus. Liefert das Ergebnis des letzten Ausdrucks (oder NIL, wenn kein Ausdruck angegeben wurde). In Lisp ist dieser Aufruf als (PROGN [expr ...]) bekannt.

Beispiel: `(1 2 3 4)' liefert 4.

Siehe auch PROG1.

16.6.2 PROG1

Neben PROGN gibt es mit PROG1 eine andere Möglichkeit, mehrere Ausdrücke zu errechnen.

(PROG1 [expr ...])

führt expr ... aus und liefert den Wert des ersten Ausdrucks (oder NIL, wenn kein Ausdruck angegeben wurde).

Beispiel: `(PROG1 1 2 3 4)' liefert 1.

Siehe auch PROGN.

16.6.3 LET

LET definiert einen neuen Block von lokalen Variablen. Dies ist nützlich, um z.B. lokale Variablen einer Funktion zu definieren. Der Aufbau ist:

(LET (varlist) expr ...)

wobei varlist eine Liste von lokalen Variablen ist.

varlist: varspec ...

varspec: (var expr) | var

Hier ist var der Name der Variable, der mit einem Kleinbuchstaben beginnt, gefolgt von weiteren Zeichen, Ziffern und Unterstrich-Zeichen. (siehe Namenskonventionen).

Im Falle von (var expr) wird die neue Variable mit dem gegebenen Ausdruck initalisiert. Im anderen Fall ist die neue Variable auf NIL gesetzt.

Es ist auch möglich, Typdeklarierer an die Variablen zu hängen (siehe Typdeklarierer).

Nach dem Initialisieren aller Variablen wird die Liste der Ausdrücke expr ... ausgewertet und der Wert der letzten zurückgegeben.

Der folgende LET-Ausdruck

(LET ((x 0) y (z (+ x 1)))
    (+ x z)
)

liefert zum Beispiel 1.

Siehe auch DOTIMES, DOLIST, DO, DEFVAR.

16.6.4 SETQ

Die Funktion SETQ setzt Werte in Variablen, Feldern und Tabellen.

(SETQ lvalue1 expr ...)

Setzt lvalue1 auf den Wert von expr. Die Punkte zeigen weitere Zuweisungen für lvalues an. Ein lvalue ist eine Variable, ein Feld einer Tabelle oder eine Tabelle. Im Falle einer Variable muss diese voher definiert worden sein (z.B. mit dem LET-Ausdruck).

Setzen des Wertes einer Tabelle bedeutet das Setzen seines Programm- oder Oberflächen-Datensatzzeigers: `(SETQ Table expr)' setzt den Programm-Datensatzzeiger von Table auf den Wert von expr und `(SETQ Table* expr)' setzt dessen Oberflächen-Datensatzzeiger und aktualisiert die Anzeige. Mehr Informationen über Programm- und Oberflächen-Datensatzzeigern, siehe Tabellen.

SETQ liefert den Wert des letzten Ausdrucks.

Beispiel: `(SETQ a 1 b 2)' weist 1 der Variable `a' zu, 2 der Variable `b' und liefert 2.

Siehe auch SETQ*, LET, DEFVAR, Tabellen, Aufbau von Ausdrücken.

16.6.5 SETQ*

SETQ* ist die Stern-Variante von SETQ (siehe SETQ) und hat ähnliche Auswirkungen. Der Unterschied ist, dass SETQ* beim Zuweisen eines Wertes zu einer Variable die Auslösefunktion dieses Feldes aufruft (siehe Auslösefunktion Feld), statt den Wert direkt zuzuweisen. Ist zum Feld keine Auslösefunktion zugewiesen, dann verhält sich SETQ* genauso wie SETQ und weist einfach den Wert der Variable zu.

Beispiel: `(SETQ* Table.Field 0)' ruft die Auslösefunktion von `Table.Field' mit dem Parameter 0 auf.

Achtung: Mit dieser Funktion ist es möglich, Endlosschleifen zu schreiben, z.B. wenn eine Auslösefunktion für ein Feld definiert wurde und diese Funktion SETQ* aufruft, das sich selbst einen Wert setzt.

Siehe auch SETQ, LET, DEFVAR.

16.6.6 SETQLIST

SETQLIST ist ähnlich wie SETQ (siehe SETQ) benutzt aber eine Liste, um mehrere `lvalue's anhand der Elemente der Liste zuzuweisen.

(SETQLIST lvalue1 ... list-expr)

Weißt lvalue1 den Wert des ersten Elements von list-expr zu. Die Punkte deuten weitere Zuweisungen an `lvalue's von den zughörigen Listenelementen an. Die Anzahl der `lvalue's mmuss mit der Länge der Liste identisch sein, andernfalls wird die Programmausführung mit einer Fehlermeldung beendet.

Es gelten die gleiche Reglen wie in SETQ (siehe SETQ). Zum Beispiel sind die folgenden beiden Versionen zum Setzten von Variablen gleichwertig:

(SETQLIST a b c (LIST 1 2 3))

(SETQ a 1 b 2 c 3)

SETQLIST gibt den Wert von list-expr zurück.

Siehe auch SETQLIST*, SETQ.

16.6.7 SETQLIST*

SETQLIST* ist die Stern-Variante von SETQLIST (siehe SETQLIST) und hat ähnliche Auswirkungen. Der Unterschied ist, dass SETQLIST* beim Zuweisen eines Wertes zu einer Variable die Auslösefunktion dieses Feldes aufruft (siehe Auslösefunktion Feld), statt den Wert direkt zuzuweisen. Ist zum Feld keine Auslösefunktion zugewiesen, dann verhält sich SETQLIST* genauso wie SETQLIST und weist einfach den Wert der Variable zu.

Siehe auch SETQLIST, SETQ*.

16.6.8 FUNCALL

FUNCALL ruft eine Funktion mit Argumenten auf.

(FUNCALL fun-expr [expr ...])

Ruft die Funktion fun-expr mit den gegebenen Parametern auf. Der Ausdruck fun-expr kann jeder Ausdruck sein, dessen Wert eine vor- oder benutzerdefinierte Funktion ist, z.B. eine Variable, die die Funktion enthält, die aufgerufen werden soll. Stimmt die Anzahl der Parameter nicht, dann wird eine Fehlermeldung erzeugt.

FUNCALL liefert den Rückgabewert des Funktionsaufrufes oder NIL, wenn fun-expr NIL ist.

Mehr Informationen über funktionale Ausdrücke, siehe Funktionale Parameter.

Siehe auch APPLY.

16.6.9 APPLY

APPLY wendet eine Funktion auf eine Argumentenliste an.

(APPLY fun-expr [expr ...] list-expr)

Wendet die Funktion fun-expr auf eine Liste an, die dadurch erzeugt wird, indem die Argumente expr ... mittels cons vorne an list-expr angehängt werden. Anders gesagt wird die Funktion fun-expr mit den Argumenten expr ... und list-expr, ersetzt durch seine Listenelemente, aufgerufen.

Der Ausdruck fun-expr kann jeder Ausdruck sein, dessen Wert eine vor- oder benutzerdefinierte Funktion ist, z.B. eine Variable, die die Funktion enthält, die aufgerufen werden soll. Das letzte Argument list-expr muss eine gültige Liste oder NIL sein, sonst wird eine Fehlermeldung erzeugt. Stimmt die Anzahl der Parameter nicht, so wird ein Fehler gemeldet.

APPLY liefert den Rückgabewert des Funktionsaufrufes oder NIL, wenn fun-expr NIL ist.

Mehr Informationen über funktionale Ausdrücke, siehe Funktionale Parameter.

Beispiel: `(APPLY + 4 (LIST 1 2 3))' liefert 10.

Siehe auch FUNCALL.

16.6.10 IF

IF ist ein Bedingungsoperator.

(IF expr1 expr2 [expr3])

Der Ausdruck expr1 wird getestet. Wenn er nicht NIL liefert, dann wird der Wert von expr2 geliefert, anderenfalls der von expr3 (oder NIL, wenn nicht vorhanden).

Diese Funktion ist nicht strikt, das bedeutet, dass entweder der eine oder der andere Ausdruck ausgewertet wird.

Siehe auch CASE, COND.

16.6.11 CASE

CASE ähnelt der switch-Anweisung in der Sprache C.

(CASE expr [case ...])

Hier ist expr der Auswahlausdruck und case ... sind Paare bestehend aus:

case: (value [expr ...])

wobei value ein einzelner Ausdruck oder eine Liste von Ausdrücken ist und expr ... die Ausdrücke sind, die ausgeführt werden, wenn der Fallausdruck passt.

Der Ausdruck CASE wertet erst expr aus. Dann wird jedes Fallpaar geprüft, ob es (oder einer der Ausdrücke in der Liste) zum ausgewerten Ausdruck passt. Wird ein passender Fallausdruck gefunden, dann werden die dazugehörigen Ausdrücke ausgeführt und der Wert des letzten Ausdrucks zurückgeliefert. Passt kein Fall, dann wird NIL zurückgeliefert.

Beispiel: `(CASE 1 ((2 3 4) 1) (1 2))' liefert 2.

Siehe auch IF, COND.

16.6.12 COND

COND ist wie IF ein Bedingungsoperator.

(COND [(test-expr [expr ...]) ...])

COND prüft der Reihe nach den ersten Ausdruck jeder Liste. Für den ersten, der nicht NIL liefert, wird der dazugehörige Ausdruck expr ... ausgeführt und der Wert des letzten Ausdrucks zurückgeliefert.

Liefern alle geprüften Ausdrücke NIL, dann wird NIL zurückgegeben.

Beispiel

(COND ((> 1 2) "1 > 2")
      ((= 1 2) "1 = 2")
      ((< 1 2) "1 < 2")
)

liefert "1 < 2".

Siehe auch IF, CASE.

16.6.13 DOTIMES

Für einfache Schleifen kann der Befehl DOTIMES verwendet werden.

(DOTIMES (name int-expr [result-expr ...]) [loop-expr ...])

Hier ist name der Name einer neuen Variable, die innerhalb der Schleife verwendet wird. Der Name muss mit einem Kleinbuchstaben beginnen, gefolgt von weiteren Zeichen, Ziffern und Unterstrich-Zeichen. (siehe Namenskonventionen).

Die Anzahl der Schleifendurchläufe wird über int-expr angegeben. In result-expr ... können Ausdrücke angegeben werden, die nach dem Beenden der Schleife ausgeführt werden sollen. loop-expr enthält den Körper der Schleife, darin sind die Ausdrücke, die bei jedem Schleifendurchlauf ausgewertet werden.

Bevor die Schleife ausgeführt wird, errechnet DOTIMES den Wert von int-expr, um die Anzahl festzustellen, wie oft die Schleife ausgeführt werden soll. Hier wird int-expr nur einmal zu Beginn der Schleife ausgewertet und muss einen Ganzzahlwert liefern. Danach setzt DOTIMES die Schleifenvariable schrittweise in jedem Durchlauf auf 0 bis int-expr-1. Zuerst wird die Variable auf Null gesetzt und geprüft, ob diese schon größer oder gleich dem Wert von expr ist. Ist int-expr ist negativ oder NIL, oder ist die Variable größer oder gleich dem Wert von expr, dann wird die Schleife abgebrochen und die Rückgabewerte ermittelt. Anderenfalls werden die Ausdrücke in der Schleife abgearbeitet und die Variable um eins erhöht. Danach kehrt die Schleife wieder zum Abbruchtest zurück und führt -wenn möglich- weitere Schleifendurchläufe aus.

Der Ausdruck DOTIMES liefert den Wert des letzten Rückgabewert-Ausdrucks oder NIL, wenn kein solcher angegeben wurde.

Beispiel

(DOTIMES (i 50 i) (PRINT i))

Gibt die Nummern von 0 bis 49 aus und liefert den Wert 50.

Siehe auch DOLIST, DO, FOR ALL, LET.

16.6.14 DOLIST

Für Schleifen über Listen kann der Ausdruck DOLIST verwendet werden.

(DOLIST (name list-expr [result-expr ...]) [loop-expr ...])

Hier ist name der Name einer neuen Variable, der in der Schleife verwendet wird. Der Name muss mit einem Kleinbuchstaben beginnen, gefolgt von weiteren Zeichen, Ziffern und Unterstrich-Zeichen. (siehe Namenskonventionen).

In list-expr wird die Liste festgelegt, über diese die Schleife ausgeführt werden soll, result-expr ... sind Ausdrücke, die nach dem Beenden der Schleife ausgeführt werden und loop-expr ... bilden den Körper der Schleife.

Bevor die Schleife ausgeführt wird, berechnet DOLIST den Wert von list-expr. Dieser Ausdruck wird nur einmal beim Start der Schleife ausgewertet und muss einen Listenwert liefern. Dann setzt DOTIMES bei jedem Schleifendurchlauf die Schleifenvariable der Reihe nach auf jedes Element der Liste. Zuerst wird die Schleifenvariable mit dem ersten Element der Liste initialisiert. Ist die Liste schon leer (NIL), dann wird die Schleife beendet und die Rückgabewerte berechnet. Anderenfalls werden die Schleifenausdrücke ausgeführt und die Variable auf das nächste Element in der Liste gesetzt. Danach kehrt die Schleife wieder zum Abbruchtest zurück und führt -wenn möglich- weitere Schleifendurchläufe aus.

Der Ausdruck DOLIST liefert den Wert des letzten Rückgabewert-Ausdrucks oder NIL, wenn kein solcher angegeben wurde.

Beispiel

(DOLIST (i (SELECT * FROM Accounts)) (PRINT i))

Gibt alle Datensätze der Tabelle `Accounts' aus und liefert NIL.

Siehe auch DOTIMES, DO, FOR ALL, LET.

16.6.15 DO

Mit dem Ausdruck DO können beliebige Schleifen programmiert werden.

(DO ([binding ...]) (term-expr [result-expr ...]) [loop-expr ...])

wobei binding ... die Variablenzuweisungen sind, die jeweils wie folgt aussehen können:

• ein neuer Name für eine Variable (der mit NIL vorbelegt wird)
• eine Liste der Form (name init [step]) mit name als Namen für eine neue Variable, init ist der Startwert der Variable und step der Ausdruck für Zählschrittweite.

Des weiteren ist term-expr der Abbruchbedingungsausdruck, result-expr ... sind die Rückgabewertausdrücke (voreingestellt ist NIL) und loop-expr ... bilden den Körper der Schleife.

Die DO-Schleife initialisiert zuerst alle lokalen Variablen mit den Startwerten und testet dann die Abbruchbedingung. Liefert sie TRUE, dann wird die Schleife unterbrochen und die Rückgabewertausdrücke ausgeführt. Der Wert des letzten Rückgabewerts wird zurückgeliefert. Anderenfalls werden die Schleifenausdrücke (loopexpr ...) ausgeführt und jede Variable wird mit dem Wert der Schrittweite aktualisiert. Danach kehrt die Ausführung zum Test der Abbruchbedingung zurück und so weiter.

Beispiel

(DO ((i 0 (+ i 1))) ((>= i 5) i) (PRINT i))

Gibt die Werte 0, 1, 2, 4 und 4 aus und liefert den Wert 5. Natürlich ist das ein ziemlich komplizierter Weg, eine einfache FOR-Schleife zu bauen. Dafür gibt es mit dem Ausdruck DOTIMES eine einfachere Version.

Siehe auch DOTIMES, DOLIST, FOR ALL, LET.

16.6.16 FOR ALL

Der Ausdruck FOR ALL wird verwendet, um eine Liste von Datensätzen abzuarbeiten.

(FOR ALL table-list [WHERE where-expr] [ORDER BY order-list] DO expr ...)

Hier ist table-list eine durch Kommas getrennte Liste von Tabellen, where-expr ein Ausdruck zum Testen einer jeden Menge von Datensätzen, order-list eine durch Kommas getrennte Liste von Ausdrücken, nach denen sortiert werden soll und expr ... sind die Ausdrücke, die für jeden Datensatz ausgeführt werden sollen.

FOR ALL erzeugt zuerst eine Liste aller Datensätze, für die der Schleifenkörper ausgeführt werden soll. Dies wird wie bei einem SELECT-Ausdruck durchgeführt. Siehe SELECT für mehr Informationen, wie diese Liste erzeugt wird. Für jedes Element dieser Liste wird der Schleifenkörper expr ... ausgeführt.

Zum Beispiel kann ein Aufsummieren eines Tabellenfeldes folgendermaßen durchgeführt werden:

(SETQ sum 0)
(FOR ALL Accounts DO
    (SETQ sum (+ sum Accounts.Amount))
)

Der Ausdruck FOR ALL liefert NIL.

Siehe auch SELECT, DOTIMES, DOLIST, DO.

16.6.17 NEXT

NEXT kann verwendet werden, um DOTIMES-, DOLIST-, DO- und FOR ALL-Schleifen zu steuern.

Ein Aufruf von NEXT im Schleifenkörper springt zum nächsten Schleifendurchlauf. Dies kann benutzt werden, wenn uninteressante Schleifendurchläufe übersprungen werden sollen, wie z.B. in folgendem Beispiel:

(FOR ALL Table DO
    (IF nicht-interessant-im-aktuellen-Datensatz (NEXT))
    ...
)

Siehe auch EXIT, DOTIMES, DOLIST, DO, FOR ALL.

16.6.18 EXIT

EXIT kann verwendet werden, um eine Schleife zu beenden.

(EXIT [expr ...])

EXIT innerhalb eines Schleifenkörpers beendet die Schleife und führen die optionalen Ausdrücke expr ... aus und liefern den Wert des letzten Ausdrucks (oder NIL, wenn kein Ausdruck angegeben wurde) als Rückgabewert der Schleife. Mögliche Rückgabewerte der Schleife im Beispiel

(DOTIMES (x 10 ret-expr ...) ...)

werden nicht ausgeführt.

Man kann die Funktion EXIT z.B. verwenden, um eine FOR ALL-Schleife zu beenden, wenn ein Datensatz gefunden wurde, der uns interessiert:

(FOR ALL Table DO
    (IF interessanter-aktueller-Datensatz (EXIT Table))
    ...
)

Siehe auch NEXT, RETURN, HALT, DOTIMES, DOLIST, DO, FOR ALL.

16.6.19 RETURN

Innerhalb einer Funktionsdefinition kann mit dem Befehl RETURN zur aufrufenden Funktion zurückgesprungen werden.

(RETURN [expr ...])

beendet die Funktion, führt die optionalen Ausdrücke expr ... aus und liefert den Wert des letzten Ausdrucks (oder NIL, wenn kein Ausdruck angegeben wurde).

Beispiel

(DEFUN find-record (name)
    (FOR ALL Table DO
        (IF (= Name name) (RETURN Table))
    )
)

Das Beispiel sucht nach einem Datensatz, dessen Feld Name zum gegebenen Namen passt. Die Funktion liefert den ersten Datensatz, der gefunden wurde oder NIL, wenn kein Datensatz gefunden wurde.

Siehe auch HALT, EXIT.

16.6.20 HALT

HALT kann verwendet werden, um die Programmausführung abzubrechen.

(HALT)

stoppt stillschweigend die Programmausführung.

Siehe auch ERROR, EXIT, RETURN.

16.6.21 ERROR

Zum Abbrechen der Programmausführung mit einer Fehlermeldung kann die Funktion ERROR verwendet werden.

(ERROR fmt [arg ...])

stoppt die Programmausführung und öffnet ein Fenster mit einer Fehlermeldung. Die Fehlermeldung wird wie in der Funktion SPRINTF (siehe SPRINTF) aus fmt und den optionalen Parametern arg ... erzeugt.

Siehe auch HALT, SPRINTF.

16.7 Typaussagen

Für jeden Datentyp ist eine Aussage definiert, die TRUE liefert, wenn der übergebene Ausdruck vom gegebenen Typ ist, anderenfalls NIL. Die Aussagen sind:

Aussage            Beschreibung

(STRP expr)        TRUE wenn expr vom Typ Zeichenkette ist, sonst NIL.

(MEMOP expr)       TRUE wenn expr vom Typ mehrzeiliger Text ist, sonst NIL.

(INTP expr)        TRUE wenn expr vom Typ Ganzzahl ist, sonst NIL.

(REALP expr)       TRUE wenn expr vom Typ Fließkommazahl ist, sonst NIL.

(DATEP expr)       TRUE wenn expr vom Typ Datum ist, sonst NIL.

(TIMEP expr)       TRUE wenn expr vom Typ Zeit ist, sonst NIL.

(NULL expr)        TRUE wenn expr vom Typ NIL (leere Liste) ist, sonst NIL.

(CONSP expr)       TRUE wenn expr keine leere Liste ist, sonst NIL.

(LISTP expr)       TRUE wenn expr eine Liste (die NIL sein kann) ist, sonst NIL.

(RECP table expr)  TRUE wenn expr ein Datensatzzeiger der gegebenen Tabelle ist.
                   Wenn expr NIL ist, dann wird TRUE geliefert (Anfangsdatensatz).
                   Wenn table NIL ist, dann wird geprüft, ob expr
                   ein Datensatzzeiger irgendeiner Tabelle ist.

16.8 Typumwandlungsfunktionen

Dieser Abschnitt listet Funktionen auf, die zum Umwandeln von einem Datentyp in einen anderen verwendet werden.

16.8.1 STR

STR kann verwendet werden, um einen Ausdruck in eine Zeichenkettendarstellung umzuwandeln.

(STR expr)

wandelt expr in eine Zeichenkettendarstellung um. Der Typ von expr bestimmt die Umwandlung:

Typ                 Ergebniszeichenkette

Zeichenkette        Die Zeichenkette selbst.

mehrzeiliger Text   Der gesamte mehrzeilige Text in einer Zeichenkette.

Ganzzahl            Zeichenkettendarstellung einer Ganzzahl.

Fließkommazahl      Zeichenkettendarstellung einer Fließkommazahl.
                    Wenn expr ein Feld ist, dann wird die Anzahl
                    der Nachkommastellen dieses Feldes, anderenfalls
                    zwei Ziffern verwendet.

Auswahl             Auswahltext des Auswahlfeldes.

Datum               Zeichenkettendarstellung des Datumswertes.

Zeit                Zeichenkettendarstellung des Zeitwertes.

Boolesch            Die Zeichenkette "TRUE"

NIL                 Benutzerdefinierte Zeichenkette für NIL, wenn
                    expr ein Feld ist, anderenfalls die
                    Zeichenkette "NIL"

Datensatz           Zeichenkettendarstellung der Datensatznummer.

Andere              Zeichenkettendarstellung des internen Adresszeigers.

Siehe auch MEMO, SPRINTF.

16.8.2 MEMO

MEMO kann verwendet werden, um einen Ausdruck in einen mehrzeiligen Text umzuwandeln.

(MEMO expr)

wandelt expr in eine mehrzeilige Textdarstellung. Es fasst den Ausdruck wie bei der Funktion STR (siehe STR) auf, liefert aber einen mehrzeiligen Text statt einer Zeichenkette.

Siehe auch STR.

16.8.3 INT

INT wird verwendet, um einen Ausdruck in eine Ganzzahl umzuwandeln.

(INT expr)

wandelt expr in eine Ganzzahl. Mögliche Umwandlungen sind:

Typ                 Ergebniswert

Zeichenkette        Wenn die gesamte Zeichenkette eine Ganzzahl darstellt, 
                    dann wird die Zeichenkette in eine Ganzzahl umgewandelt.  
                    Beginnt die Zeichenkette mit 0, so wird sie als Oktalzahl 
                    interpretiert, beginnt sie mit 0x, als Hexadezimalzahl.  
                    Führende und folgende Leerzeichen werden ignoriert.
                    Stellt die Zeichenkette keine Ganzzahl dar, so wird NIL 
                    geliefert.

mehrzeiliger Text   Analog zu Zeichenkette.

Ganzzahl            Der Wert selbst.

Fließkommazahl      Wenn der Wert im Ganzzahlbereich liegt, wird der
                    gerundetet Fließkommawert geliefert, anderenfalls NIL.

Auswahltext         Die interne Nummer (beginnend bei 0) des Auswahltextes.

Datum               Anzahl Tage seit dem 01.01.0000.

Zeit                Anzahl Sekunden seit 00:00:00.

Datensatz           Datensatznummer.

NIL                 NIL

Andere              Eine Fehlermeldung wird erzeugt und die Programmaus-
                    führung wird abgebrochen.

Siehe auch REAL, ASC.

16.8.4 REAL

REAL wird verwendet, um einen Ausdruck in einen Wert vom Typ Fließkommazahl umzuwandeln.

(REAL expr)

wandelt expr in eine Fließkommazahl. Es fasst den Ausdruck wie bei der Funktion INT (siehe INT) auf, liefert aber einen Wert vom Typ Fließkommazahl anstatt einer Ganzzahl.

Siehe auch INT.

16.8.5 DATE

DATE wird verwendet, um einen Ausdruck in ein Datum umzuwandeln.

(DATE expr)

wandelt den gegebenen Ausdruck in ein Datum. Mögliche Umwandlungen sind:

Typ                 Ergebniswert

Zeichenkette        Wenn die gesamte Zeichenkette einen Datum darstellt, 
                    dann wird die Zeichenkette in ein Datum umgewandelt.
                    Führende und folgende Leerzeichen werden ignoriert.  
                    Stellt es kein Datum dar, wird NIL geliefert.

mehrzeiliger Text   Analog zu Zeichenkette.

Ganzzahl            Ein Datumswert wird erzeugt, der die gegebene Ganzzahl
                    als die Anzahl der Tage seit dem 01.01.0000 darstellt. 
                    Ist die Ganzzahl zu groß (Datum würde größer als der 
                    31.12.9999) oder negativ, dann wird NIL zurückgegeben.

Fließkommazahl      Analog zu Ganzzahl.

Datum               Der Wert selbst.

NIL                 NIL

Andere              Eine Fehlermeldung wird erzeugt und die Programmaus-
                    führung wird abgebrochen.

Siehe auch DATEDMY.

16.8.6 TIME

TIME wird verwendet, um einen Ausdruck in einen Zeitwert umzuwandeln.

(TIME expr)

wandelt den gegebenen Ausdruck in einen Zeitwert. Mögliche Umwandlungen sind:

Typ                 Ergebniswert

Zeichenkette        Wenn die gesamte Zeichenkette einen Zeitwert darstellt,
                    dann wird die Zeichenkette in eine Zeit umgewandelt. 
                    Führende und folgende Leerzeichen werden ignoriert.
                    Stellt es keine Zeit dar, wird NIL geliefert.

mehrzeiliger Text   Analog zu Zeichenkette.

Ganzzahl            Ein Zeitwert wird erzeugt, der die gegebene Ganzzahl 
                    als Anzahl der Sekunden seit 00:00:00 darstellt. 

Fließkommazahl      Analog zu Ganzzahl.

Zeit                Der Wert selbst.

NIL                 NIL

Andere              Eine Fehlermeldung wird erzeugt und die Programmaus-
                    führung wird abgebrochen.

16.9 Boolesche Funktionen

Dieser Abschnitt listet die booleschen Operatoren auf.

16.9.1 AND

AND prüft, ob alle seine Parameter TRUE sind.

(AND [expr ...])

prüft der Reihe nach expr ..., bis ein Ausdruck zu NIL wird. Sind alle Ausdrücke zu Nicht-NIL aufgelöst worden, dann wird der Wert des letzten Ausdrucks zurückgeliefert, anderenfalls NIL.

Diese Funktion ist nicht strikt, dies bedeutet, dass nicht alle Parameter von AND ausgewertet werden müssen, z.B. wird in `(AND NIL (+ 1 2))' der Ausdruck `(+ 1 2)' nicht ausgewertet, da ein NIL-Wert schon ermittelt wurde. In `(AND (+ 1 2) NIL)' jedoch wird der Ausdruck `(+ 1 2)' ausgewertet.

Siehe auch OR, NOT.

16.9.2 OR

OR prüft, ob alle seiner Parameter NIL sind.

(OR [expr ...])

prüft der Reihe nach expr ..., bis ein Ausdruck zu Nicht-NIL wird. Liefert den Wert des ersten Ausdrucks, der zu Nicht-NIL wurde, oder NIL, wenn alle Ausdrücke zu NIL wurden.

Diese Funktion ist nicht strikt, dies bedeutet, dass nicht alle Parameter von AND ausgewertet werden müssen, z.B. wird in `(OR TRUE (+ 1 2))' der Ausdruck `(+ 1 2)' nicht ausgewertet, da ein Nicht-NIL-Wert (hier TRUE) schon ermittelt wurde. In `(OR (+ 1 2) TRUE)' jedoch wird der Ausdruck `(+ 1 2)' ausgewertet.

Siehe auch AND, NOT.

16.9.3 NOT

NOT wird verwendet, um den Wert eines Booleschen Ausdrucks zu invertieren.

(NOT expr)

liefert TRUE, wenn expr NIL ist, sonst NIL.

Siehe auch AND, OR.

16.10 Vergleichsfunktionen

In diesem Abschnitt findet man Funktionen zum Vergleich von Werten vor.

16.10.1 Relationsoperatoren

Zum Vergleichen zweier Werte in einem BeeBase-Programm verwendet man

(op expr1 expr2)

wobei op einer aus {=, <>, <, >, >=, <=, =*, <>*, <*, >*, >=*, <=*} ist. Der Stern wird für besondere Vergleiche (Zeichenkettenvergleiche ohne Groß-/Kleinschreibung, Datensatzvergleich mit der benutzerdefinierten Reihenfolge) verwendet.

Die folgende Tabelle zeigt alle Regeln beim Vergleich von zwei Werten in einem BeeBase-Programm.

Typ                 Vergleichsreihenfolge

Ganzzahl            NIL < MIN_INT < ... < -1 < 0 < 1 < ... < MAX_INT

Fließkommazahl      NIL < -HUGE_VAL < ... < -1.0 < 0.0 < 1.0 < ... < HUGE_VAL

Zeichenkette        NIL <  "" <  "Z" <  "a"  <  "aa" <  "b" < ... (mit groß/klein)
                    NIL <* "" <* "a" <* "AA" <* "b" < ...        (groß/klein egal)

mehrzeiliger Text   wie bei Zeichenketten

Datum               NIL < 1.1.0000 < ... < 31.12.9999

Zeit                NIL < 00:00:00 < ... < 596523:14:07 

Boolesch            NIL < TRUE

Datensatz           NIL < jeder_Datensatz    (Datensätze selbst können nicht
                                              mit < verglichen werden)
                    NIL <* rec1 <* rec2    (Reihenfolge festgelegt durch Benutzer)

HUGE_VAL steht für den größtmöglichen Fließkommazahlenwert, den ein Prozessor handhaben kann. MIN_INT ist die kleinste Ganzzahl und MAX_INT ist die größte Ganzzahl.

Siehe auch CMP, CMP*, LIKE.

16.10.2 CMP

CMP liefert eine Ganzzahl, die eine Sortierung ihrer Argumente repräsentiert.

(CMP expr1 expr2)

liefert einen Wert kleiner als 0, wenn expr1 kleiner ist als expr2; 0, wenn expr1 gleich expr2 ist und einen Wert größer 0, wenn expr1 größer ist als expr2. Zum Erkennen der Sortierung wird die einfache (ohne Stern) Sortierrelation wie bei den Relationaloperatoren (siehe Relationsoperatoren) verwendet.

Es darf nicht angenommen werden, dass der Rückgabewert immer -1, 0 oder 1 ist!

Beispiel: `(CMP "Bike" "bIKE")' liefert -1.

Siehe auch CMP*, Relationsoperatoren.

16.10.3 CMP*

CMP* ist die Stern-Version von CMP. Der Unterschied ist, dass CMP* eine erweiterte Sortierung wie bei den Relationsoperatoren (siehe Relationsoperatoren) verwendet, bei denen Zeichenketten zeichengrößenunabhängig und Datensätze gemäß ihrer benutzerdefinierten Datensatzreihenfolge verglichen werden.

Beispiel: `(CMP* "Bike" "bIKE")' liefert 0.

Siehe auch CMP, Relationsoperatoren.

16.10.4 MAX

MAX liefert den Ausdruck mit dem größten Wert.

(MAX [expr ...])

Liefert den größten Wert der Argumente expr .... Werden keine Argumente angegeben, so wird NIL zurückgegeben. Zum Bestimmen des größten Ausdrucks wird die einfache (ohne Stern) Sortierrelation wie bei den Relationaloperatoren (siehe Relationsoperatoren) verwendet.

Siehe auch MAX*, MIN, Relationsoperatoren.

16.10.5 MAX*

MAX* ist die Stern-Version von MAX. Der Unterschied ist, dass MAX* eine erweiterte Sortierung wie bei den Relationsoperatoren (siehe Relationsoperatoren) verwendet, bei denen Zeichenketten zeichengrößenunabhängig und Datensätze gemäß ihrer benutzerdefinierten Datensatzreihenfolge verglichen werden.

Beispiel: `(MAX* "x" "Y")' ergibt "Y".

Siehe auch MAX, MIN*, Relationsoperatoren.

16.10.6 MIN

MIN liefert den Ausdruck mit dem kleinsten Wert.

(MIN [expr ...])

Liefert den kleinsten Wert der Argumente expr .... Werden keine Argumente angegeben, so wird NIL zurückgegeben. Zum Bestimmen des kleinsten Ausdrucks wird die einfache (ohne Stern) Sortierrelation wie bei den Relationaloperatoren (siehe Relationsoperatoren) verwendet.

Siehe auch MIN*, MAX, Relationsoperatoren.

16.10.7 MIN*

MIN* ist die Stern-Version von MIN. Der Unterschied ist, dass MIN* eine erweiterte Sortierung wie bei den Relationsoperatoren (siehe Relationsoperatoren) verwendet, bei denen Zeichenketten zeichengrößenunabhängig und Datensätze gemäß ihrer benutzerdefinierten Datensatzreihenfolge verglichen werden.

Beispiel: `(MIN* "x" "Y")' ergibt "x".

Siehe auch MIN, MAX*, Relationsoperatoren.

16.11 Mathematik-Funktionen

Einige mathematische Funktionen werden hier aufgelistet.

16.11.1 Werte addieren

Zum Zusammenzählen von Zahlen verwendet man

(+ expr ...)

Liefert die Summe der Parameter expr .... Wenn irgendein Parameter NIL ist, dann ist das Ergebnis NIL. Wenn die Werte vom Typ Fließkomma- oder Ganzzahl sind, dann ist das Ergebnis auch eine Fließkommazahl (oder Ganzzahl).

Es lassen sich auch Zeichenketten und mehrzeilige Texte 'addieren'. In diesem Fall ist das Ergebnis die zusammengehängten Zeichenketten bzw mehrzeiligen Texte.

Ist expr vom Typ Datum und der Rest der Parameter sind Ganz-/Fließkommazahlen, dann wird die Summe der Ganz-/Fließkommazahlen als Anzahl Tage aufgefasst und zu expr addiert. Ist das zurückgelieferte Ergebnis außerhalb des gültigen Bereichs (vor dem 1.1.0000 oder nach dem 31.12.9999), dann ist das Ergebnis NIL.

Ist expr vom Typ Zeit und der Rest der Parameter sind Ganz-/Fließkommazahlen oder andere Zeitwerte, dann wird die Summe der Ganz-/Fließkommazahlen (als Anzahl Sekunden aufgefasst) und Zeitwerte zu expr addiert. Ist das zurückgelieferte Ergebnis außerhalb des gültigen Bereichs (kleiner als 00:00:00 oder größer als 596523:14:07),dann ist das Ergebnis NIL.

Beispiele

Ausdruck                         Wert

(+ 1 2 3)                        6
(+ 5 1.0)                        6.0
(+ "Hallo" " " "Welt!")          "Hallo Welt!"
(+ 28.11.1968 +365 -28 -9)       22.10.1969
(+ 07:30:00 3600)                08:30:00
(+ 03:00:00 23:59:59)            26:59:59

Siehe auch -, 1+, *, CONCAT, CONCAT2, ADDMONTH, ADDYEAR.

16.11.2 Werte subtrahieren

Zum Subtrahieren von Werten verwendet man

(- expr1 expr2 ...)

Zieht die Summe expr2 ... von expr1 ab. Hier gelten die gleichen Regeln wie beim Addieren von Werten (siehe Werte addieren außer dass Zeichenketten und mehrzeilige Texte nicht subtrahiert werden können.

(- expr) hat eine spezielle Bedeutung: Es liefert den negativen Wert von expr (Ganz- oder Fließkommazahl), z.B. `(- (+ 1 2))' liefert -3.

Siehe auch +, 1-.

16.11.3 1+

1+ erhöht den Wert einer Ganzzahl, Fließkommazahl, Datum or Zeit um Eins.

(1+ expr)

Liefert den Wert von expr (Ganzzahl, Fließkommazahl, Datum oder Zeit) plus Eins. Wenn expr NIL ist, dann wird NIL geliefert.

Siehe auch +, 1-.

16.11.4 1-

1- verringert den Wert einer Ganzzahl, Fließkommazahl, Datum or Zeit um Eins.

(1- expr)

Liefert den Wert von expr (Ganzzahl, Fließkommazahl, Datum oder Zeit) minus Eins. Wenn expr NIL ist, dann wird NIL geliefert.

Siehe auch -, 1+.

16.11.5 Werte multiplizieren (*)

Zum Multiplizieren von Ganz-/Fließkommazahlen verwendet man

(* expr ...)

Liefert die Multiplikation der Ganz-/Fließkommazahlen expr .... Wenn alle Parameter Ganzzahlen sind, dann wird eine Ganzzahl geliefert, anderenfalls ist der Wert vom Typ Fließkommazahl.

Siehe auch +, /.

16.11.6 Werte dividieren

Zum Dividieren von Ganz-/Fließkommazahlen verwendet man

(/ expr1 [expr2 ...])

Teilt expr1 durch die Multiplikation der restlichen Parameter. Liefert eine Fließkommazahl. Bei einer Division durch 0 wird NIL geliefert.

Siehe auch *, DIV, MOD.

16.11.7 DIV

DIV verwendet man zur Ganzzahldivision.

(DIV int1 int2)

Liefert die Ganzzahldivision von int1 mit int2. Zum Beispiel liefert `(DIV 5 3)' den Wert 1.

Siehe auch /, MOD.

16.11.8 MOD

MOD wird zur Modulo-Berechnung verwendet.

(MOD int1 int2)

Liefert int1 modulo int2. Zum Beispiel liefert `(MOD 5 3)' den Wert 2.

Siehe auch DIV.

16.11.9 ABS

ABS berechnet den absoluten Wert eines Ausdrucks.

(ABS expr)

Liefert den absoluten Wert von expr (Ganz- oder Fließkommazahl). Ist expr NIL, dann wird NIL geliefert.

16.11.10 TRUNC

TRUNC schneidet die Nachkommastellen einer Zahl ab.

(TRUNC real)

Liefert die größte Ganzzahl (als Fließkommazahl), die nicht größer ist als die angegebene Fließkommazahl. Ist real NIL, dann wird NIL geliefert.

Beispiele: `(TRUNC 26.1)' liefert 26, `(TRUNC -1.2)' liefert -2.

Siehe auch ROUND.

16.11.11 ROUND

ROUND rundet einen Fließkommawert.

(ROUND real digits)

Liefert den angegebenen Fließkommawert aufgerundet auf digits Stellen. Ist real oder digits gleich NIL, dann wird NIL geliefert.

Beispiele: `(ROUND 70.70859 2)' liefert 70.71, `(ROUND 392.36 -1)' liefert 390.0.

Siehe auch TRUNC.

16.11.12 RANDOM

RANDOM kann zum Generieren von Zufallszahlen verwendet werden.

(RANDOM expr)

Liefert eine Zufallszahl. Beim ersten Aufruf wird der Zufallszahlengenerator mit dem Wert aus der aktuellen Uhrzeit initialisiert. RANDOM erzeugt eine Zufallszahl im Bereich von 0 ... expr, ausgenommen expr selbst. Der Typ von expr (Ganz- oder Fließkommazahl) ist auch der Rückgabewert-Typ. Ist expr NIL, dann wird NIL geliefert.

Beispiele:

Beispiel                Bedeutung

(RANDOM 10)             liefert einen Wert von 0 bis 9,
(RANDOM 10.0)           liefert einen Wert von 0.0 bis 9.99999...

16.11.13 POW

POW berechnet die Potenz von Zahlen.

(POW x y)

Liefert den Wert der Fließkommazahl x potenziert mit Fließkommazahl y. Ist x or y NIL, oder ist x negativ und y keine Ganzzahl, so wird NIL zurückgegeben.

Beispiel: `(POW 2 3)' ergibt 8.

Siehe auch SQRT, EXP.

16.11.14 SQRT

SQRT berechnet die Wurzel einer Zahl.

(SQRT x)

Gibt die Quadratwurzel der Fließkommazahl x zurück. Ist x NIL oder ein negativer Wert, so wird NIL zurückgegeben.

Siehe auch POW.

16.11.15 EXP

EXP berechnet die Exponentialfunktion.

(EXP x)

Liefert den Wert der Basis des natürlichen Logarithmus potenziert mit Fließkommazahl x. Ist x NIL, so wird NIL zurückgegeben.

Siehe auch POW, LOG.

16.11.16 LOG

LOG berechnet den natürlichen Logarithmus einer Zahl.

(LOG x)

Liefert den natürlichen Logarithmus der Fließkommazahl x. Ist x NIL oder keine positive Zahl, so wird NIL zurückgegeben.

Siehe auch EXP.

16.12 Zeichenkettenfunktionen

Dieser Abschnitt behandelt Funktionen für Zeichenketten.

16.12.1 LEN

LEN berechnet die Länge der Zeichenkette.

(LEN str)

Liefert die Länge der gegebenen Zeichenkette oder NIL wenn str NIL ist.

Siehe auch WORDS, LINES, MAXLEN.

16.12.2 LEFTSTR

LEFTSTR extrahiert eine Teilzeichenkette aus einer Zeichenkette.

(LEFTSTR str len)

Liefert den linken Teil einer gegebenen Zeichenkette mit höchstens len Zeichen. Ist str oder len gleich NIL oder ist len negativ, dann wird NIL geliefert.

Beispiel: `(LEFTSTR "Hallo Welt!" 5)' liefert "Hallo".

Siehe auch RIGHTSTR, MIDSTR, WORD, LINE.

16.12.3 RIGHTSTR

RIGHTSTR extrahiert eine Teilzeichenkette aus einer Zeichenkette.

(RIGHTSTR str len)

Liefert den rechten Teil einer gegebenen Zeichenkette mit höchstens len Zeichen. Ist str oder len gleich NIL oder ist len negativ, dann wird NIL geliefert.

Beispiel: `(RIGHTSTR "Hallo Welt!" 5)' liefert "Welt!".

Siehe auch LEFTSTR, MIDSTR, WORD, LINE.

16.12.4 MIDSTR

MIDSTR extrahiert eine Teilzeichenkette aus einer Zeichenkette.

(MIDSTR str pos len)

Liefert einen Teil einer gegebenen Zeichenkette mit höchstens len Zeichen. Die Teilzeichenkette beginnt an der Stelle pos (beginnend bei Null). Ist len NIL, dann wird die komplette Teilzeichenkette, welche bei pos beginnt, zurückgegeben. Falls str NIL oder len negativ ist, dann wird NIL zurückgeliefert. Ist pos außerhalb des gültigen Bereichs (negativ oder größer als die Zeichenkettenlänge), dann wird NIL geliefert.

Beispiel: `(MIDSTR "Hallo Welt!" 3 5)' liefert "lo We".

Siehe auch LEFTSTR, RIGHTSTR, WORD, LINE, SETMIDSTR, INSMIDSTR.

16.12.5 SETMIDSTR

SETMIDSTR setzt eine Teilzeichenkette in einer Zeichenkette.

(SETMIDSTR str index set)

Liefert eine Kopie der Zeichenkette str, in dem die Zeichenkette beginnend bei index mit der Zeichenkette set überschrieben wird. Die Länge der zurückgelieferten Zeichenkette ist größer oder gleich der von str. Ist einer der Parameter NIL oder ist index außerhalb des gültigen Bereichs, dann wird NIL geliefert.

Beispiel: `(SETMIDSTR "Hallo Welt!" 6 "Melanie!")' liefert "Hallo Melanie!".

Siehe auch INSMIDSTR, REPLACESTR.

16.12.6 INSMIDSTR

INSMIDSTR wird verwendet, um eine Teilzeichenkette in eine Zeichenkette einzufügen.

(INSMIDSTR str index insert)

Liefert eine Kopie der Zeichenkette str, in der die Zeichenkette insert an der gegebenen Stelle eingefügt wurde. Ist eines der Parameter NIL oder ist index außerhalb des gültigen Bereichs, dann wird NIL zurückgeliefert.

Beispiel: `(INSMIDSTR "Hallo Welt!" 6 "BeeBase-")' liefert "Hallo BeeBase-Welt!".

Siehe auch SETMIDSTR, REPLACESTR.

16.12.7 INDEXSTR

INDEXSTR sucht in einer Zeichenkette nach dem ersten Vorkommen der Teilzeichenkette.

(INDEXSTR str substr)

Sucht nach dem ersten Vorkommen von substr in str. Der Zeichenkettenvergleich wird mit Beachtung der Groß-/Kleinschreibung durchgeführt. Liefert die Stelle (beginnend bei 0) von der Teilzeichenkette in str oder NIL, wenn die Teilzeichenkette nicht vorhanden ist. Ist eines der Argumente NIL, dann wird NIL zurückgegeben.

Beispiel: `(INDEXSTR "Hallo Welt!" "Welt")' liefert 6.

Siehe auch INDEXSTR*, RINDEXSTR, RINDEXSTR*, INDEXBRK, INDEXBRK*.

16.12.8 INDEXSTR*

INDEXSTR* hat den selben Effekt als INDEXSTR (siehe INDEXSTR), außer dass der Zeichenkettenvergleich nicht auf Groß-/Kleinschreibung achtet.

Siehe auch INDEXSTR, RINDEXSTR, RINDEXSTR*, INDEXBRK, INDEXBRK*.

16.12.9 INDEXBRK

INDEXBRK sucht nach dem ersten Vorkommen eines Zeichens in einer Zeichenkette.

(INDEXBRK str brkstr)

Sucht nach dem ersten Vorkommen eines Zeichens von brkstr in str. Der Zeichenkettenvergleich wird mit Beachtung der Groß-/Kleinschreibung durchgeführt. Liefert die Stelle (beginnend bei 0) des ersten Zeichens, das in str gefunden wurde, anderenfalls NIL. Ist eines der Parameter NIL, dann wird NIL geliefert.

Beispiel: `(INDEXBRK "Hallo Welt!" "aeiou")' liefert 1.

Siehe auch INDEXBRK*, RINDEXBRK, RINDEXBRK*, INDEXSTR, INDEXSTR*.

16.12.10 INDEXBRK*

INDEXBRK* hat den selben Effekt wie INDEXBRK (siehe INDEXBRK), außer dass der Zeichenvergleich nicht auf Groß-/Kleinschreibung achtet.

Siehe auch INDEXBRK, RINDEXBRK, RINDEXBRK*, INDEXSTR, INDEXSTR*.

16.12.11 RINDEXSTR

RINDEXSTR sucht in einer Zeichenkette nach dem letzten Vorkommen der Teilzeichenkette.

(RINDEXSTR str substr)

Sucht nach dem letzten Vorkommen von substr in str. Der Zeichenkettenvergleich wird mit Beachtung der Groß-/Kleinschreibung durchgeführt. Liefert die Stelle (beginnend bei 0) von der Teilzeichenkette in str oder NIL, wenn die Teilzeichenkette nicht vorhanden ist. Ist eines der Argumente NIL, dann wird NIL zurückgegeben.

Beispiel: `(RINDEXSTR "Do itashimashite." "shi")' liefert 11.

Siehe auch RINDEXSTR*, INDEXSTR, INDEXSTR*, RINDEXBRK, RINDEXBRK*.

16.12.12 RINDEXSTR*

RINDEXSTR* hat den selben Effekt als RINDEXSTR (siehe RINDEXSTR), außer dass der Zeichenkettenvergleich nicht auf Groß-/Kleinschreibung achtet.

Siehe auch RINDEXSTR, INDEXSTR, INDEXSTR*, RINDEXBRK, RINDEXBRK*.

16.12.13 RINDEXBRK

RINDEXBRK sucht nach dem letzten Vorkommen eines Zeichens in einer Zeichenkette.

(RINDEXBRK str brkstr)

Sucht nach dem letzten Vorkommen eines Zeichens von brkstr in str. Der Zeichenkettenvergleich wird mit Beachtung der Groß-/Kleinschreibung durchgeführt. Liefert die Stelle (beginnend bei 0) des letzten Zeichens, das in str gefunden wurde, anderenfalls NIL. Ist eines der Parameter NIL, dann wird NIL geliefert.

Beispiel: `(RINDEXBRK "Konnichiwa" "chk")' liefert 6.

Siehe auch RINDEXBRK*, INDEXBRK, INDEXBRK*, RINDEXSTR, RINDEXSTR*.

16.12.14 RINDEXBRK*

RINDEXBRK* hat den selben Effekt wie RINDEXBRK (siehe RINDEXBRK), außer dass der Zeichenvergleich nicht auf Groß-/Kleinschreibung achtet.

Siehe auch RINDEXBRK, INDEXBRK, INDEXBRK*, RINDEXSTR, RINDEXSTR*.

16.12.15 REPLACESTR

REPLACESTR ersetzt Teilzeichenketten durch andere Zeichenketten.

(REPLACESTR str [substr1 replacestr1 ...])

Ersetzt alle Vorkommen von substr1 in str durch replacestr1. Fortführend werden mit der nächsten Such- und Ersetzungszeichenkette weitere Teilzeichenketten in der neu erhaltenen Zeichenkette ersetzt bis alle Argumente abgearbeitet sind. Zu beachten ist, dass die Anzahl der Argumente ungerade sein muss. Arumente an geraden Positionen geben die Such-Teilzeichenketten an, jeweils gefolgt von der Ersetzungszeichenkette. Aufgrund der Tatsache, dass das Ergebnis einer Ersetzung für die darauf folgende Ersetzung verwendet wird, können Mehrfachersetzungen auftreten. Dies sollte bei Verwendung dieser Funktion beachtet werden. Das Ändern der Reihenfolge der Argumente kann helfen, Konflikte aufzulösen, da Ersetzungen immer von links nach rechts durchgeführt werden.

Wenn eine der Zeichenketten NIL ist oder einer der Such-Teilzeichenketten leer ist, dann wird NIL zurückgeliefert.

Beispiel: `(REPLACESTR "black is white" "black" "white" "white "black")' results to "black is black".

Siehe auch REPLACESTR*, SETMIDSTR, INSMIDSTR, REMCHARS.

16.12.16 REPLACESTR*

REPLACESTR* hat den selben Effekt wie REPLACESTR (siehe REPLACESTR), außer dass der Zeichenvergleich für die Suche nach Teilzeichenketten nicht auf Groß-/Kleinschreibung achtet.

Siehe auch REPLACESTR, SETMIDSTR, INSMIDSTR, REMCHARS.

16.12.17 REMCHARS

REMCHARS entfernt Zeichen aus einer Zeichenkette.

(REMCHARS str chars-to-remove)

Liefert eine Kopie von str, in der alle Zeichen von chars-to-remove entfernt wurden. Ist str oder chars-to-remove NIL, dann wird NIL geliefert.

Beispiel: `(REMCHARS deine-zeichenkette " \t\n")' entfernt alle Leerzeichen, Tabulatoren und Neue-Zeile-Zeichen aus deine-zeichenkette.

Siehe auch REPLACESTR, TRIMSTR.

16.12.18 TRIMSTR

TRIMSTR entfernt führende und abschließende Zeichen von einer Zeichenkette.

(TRIMSTR str [front back])

Liefert eine Kopie von str, in der führenden und abschließenden Zeichen entfernt wurden. Bei Aufruf mit nur einem Argument werden Leerzeichen, Seiten- und Zeilenumbrüche, Carriage Return, sowie horizontable unf vertikale Tabulatoren entfernt. Werden drei Argumente verwendet, so gibt front die führenden und back die abschließenden Zeichen an, die enfernt werden sollen. TRIMSTR kann nicht mit zwei Argumenten aufgerufen werden.

Ist eines der Argumente str, front oder back NIL, so wird NIL zurückgegeben.

Beispiel: (TRIMSTR " Ich fuhr Selma's Fahrrad zu Schrott. ") liefert "Ich fuhr Selma's Fahrrad zu Schrott.", (TRIMSTR "007 " "0" " \f\n\r\t\v") ergibt "7".

Siehe auch REMCHARS.

16.12.19 WORD

WORD liefert ein Wort einer Zeichenkette.

(WORD str num)

Liefert das num-te Wort (beginnend bei Null) aus der gegebenen Zeichenkette. Wörter sind nicht-leere Teilzeichenketten, die durch ein oder mehrere nicht-brechbare Leerzeichen (z.B. Leerzeichen, Tabulatoren und Neue-Zeile-Zeichen) getrennt sind.

Ist str oder num gleich NIL oder ist num außerhalb des gültigen Bereichs (negativ oder größer gleich der Anzahl Wörter in der Zeichenkette), dann wird NIL zurückgeliefert.

Beispiel: `(WORD "Deshalb lieh ich Selma mein Fahrrad." 3)' liefert "Selma".

Siehe auch WORDS, FIELD, LINE, LEFTSTR, RIGHTSTR, MIDSTR, STRTOLIST.

16.12.20 WORDS

WORDS zählt die Anzahl der Wörter in einer Zeichenkette.

(WORDS str)

Liefert die Anzahl der Wörter in der gegebenen Zeichenkette oder NIL, wenn str NIL ist. Wörter sind nicht-leere Teilzeichenketten, die durch ein oder mehrere nicht-brechbare Leerzeichen (z.B. Leerzeichen, Tabulatoren und Neue-Zeile-Zeichen) getrennt sind.

Beispiel: `(WORDS "In Wirklichkeit ist es aber nicht mein Fahrrad.")' liefert 8.

Siehe auch WORD, FIELDS, LINES, LEN.

16.12.21 FIELD

FIELD liefert ein Feld in einer Zeichenkette.

(FIELD str num [sep [quotes]])

Liefert das num-te Feld (beginnend bei Null) in der gegebenen Zeichenkette. Felder sind Teilzeichenketten, die durch genau ein Trennzeichen getrennt sind. Ein Feld kann eine leere Zeichenkette sein. Argument sep enthält die Trennzeichen, durch die Felder getrennt sind. Ist sep NIL oder wird es nicht angegeben, so werden nicht-brechbare Leerzeichen (z.B. Leerzeichen, Tabulatoren und Neue-Zeile-Zeichen) verwendet. Wird quotes angegeben und ist nicht NIL, so können Felder mit doppelten Anführungszeichen umgeben sein und Trennzeichen enthalten. Die doppelten Anführungszeichen werden entfernt bevor das Feld zurückgegeben wird.

Ist str oder num gleich NIL oder ist num außerhalb des gültigen Bereichs (negativ oder größer gleich der Anzahl Wörter in der Zeichenkette), dann wird NIL zurückgeliefert.

Beispiel: `(FIELD "Mein Name ist \"Darth Vader\"" 3 " " TRUE)' liefert "Darth Vader".

Siehe auch FIELDS, WORD, LEFTSTR, RIGHTSTR, MIDSTR, STRTOLIST.

16.12.22 FIELDS

FIELDS zählt die Anzahl der Felder in einer Zeichenkette.

(FIELDS str [sep [quotes]])

Liefert die Anzahl Felder in der gegebenen Zeichenkette oder NIL, wenn str NIL ist. Felder sind Teilzeichenketten, die durch genau ein Trennzeichen getrennt sind. Ein Feld kann eine leere Zeichenkette sein. Argument sep enthält die Trennzeichen, durch die Felder getrennt sind. Ist sep NIL oder wird es nicht angegeben, so werden nicht-brechbare Leerzeichen (z.B. Leerzeichen, Tabulatoren und Neue-Zeile-Zeichen) verwendet. Wird quotes angegeben und ist nicht NIL, so können Felder mit doppelten Anführungszeichen umgeben sein und Trennzeichen enthalten.

Siehe auch FIELD, WORDS, LEN.

16.12.23 STRTOLIST

STRTOLIST wandelt eine Zeichenkette in eine Liste von Zeichenketten um.

(STRTOLIST str [sep])

Erzeugt eine Liste von Zeichenketten, welche durch das Aufteilen der Zeichenkette str an den Stellen der Trennungs-Sequenz sep entsteht. Wird sep nicht angegeben, so wird das Tab-Zeichen "\t" verwendet. Ist sep die leere Zeichenkette "", so wird eine Liste aller Zeichen der Zeichenkette generiert.

Ist str oder sep NIL, so wird NIL zurückgegeben.

Beispiele

`(STRTOLIST "Ich\tmag\tJapan.")' ergibt ( "Ich" "mag" "Japan." ).

`(STRTOLIST "Name|Straße|Stadt" "|")' ergibt ( "Name" "Straße" "Stadt" ).

`(STRTOLIST "abc" "")' ergibt ( "a" "b" "c" ).

Siehe auch MEMOTOLIST, LISTTOSTR.

16.12.24 LISTTOSTR

LISTTOSTR wandelt eine Liste von Elementen in eine Zeichenkette um.

(LISTTOSTR list [sep])

Wandelt die gegebene Liste von Elementen in eine Zeichenkette um, indem die Zeichenketten-Repräsentationen jedes Elements getrennt durch die Sequenz sep aneinandergehängt werden. Wird sep nicht angegeben, so wird das Tab-Zeichen "\t" verwendet. Ist list oder sep NIL, so wird NIL zurückgegeben.

Beispiele

`(LISTTOSTR (LIST "Peter ist" 18 "Jahre alt"))' ergibt "Peter ist\t18\tJahre alt".

`(LISTTOSTR (LIST "Name" "Straße" "Stadt") "|")' ergibt "Name|Straße|Stadt".

Siehe auch LISTTOMEMO, CONCAT, CONCAT2, STRTOLIST.

16.12.25 CONCAT

CONCAT verbindet Zeichenketten.

(CONCAT [str ...])

Liefert die Verknüpfung der gegebenen Liste von Zeichenketten, wobei einzelne Leerzeichenzwischen den Zeichenketten eingefügt werden. Ist eine der Zeichenketten NIL oder die Liste leer, dann wird NIL zurückgeliefert.

Beispiele: `(CONCAT "Ich" "dachte," "es" "war" "ein "verlassenes" "Fahrrad.")' liefert "Ich dachte, es war ein verlassenes Fahrrad.".

Siehe auch CONCAT2, +, LISTTOSTR, COPYSTR, SPRINTF.

16.12.26 CONCAT2

CONCAT2 verbindet Zeichenketten.

(CONCAT2 insert [str ...])

Liefert die Verknüpfung der gegebenen Liste von Zeichenketten. Zwischen den Zeichenketten wird jeweils die gegebene Zeichenkette insert eingefügt. Ist eine der Zeichenketten NIL oder die Liste leer, dann wird NIL zurückgeliefert.

Beispiel: `(CONCAT2 "! " "Aber" "es" "war es nicht!")' liefert "Aber! es! war es nicht!".

Siehe auch CONCAT, +, LISTTOSTR, COPYSTR, SPRINTF.

16.12.27 COPYSTR

COPYSTR erzeugt Kopien einer Zeichenkette.

(COPYSTR str num)

Liefert eine Zeichenkette, die num mal die Zeichenkette str enthält. Ist str NIL, num gleich NIL oder kleiner als NUll, dann wird NIL zurückgegeben.

Beispiel: `(COPYSTR "+-" 5)' liefert "+-+-+-+-+-".

Siehe auch CONCAT CONCAT2, +, SPRINTF.

16.12.28 SHA1SUM

SHA1SUM berechnet den SHA1-Hash einer Zeichenkette.

(SHA1SUM str)

Gibt eine Zeichenkette zurück, welche den SHA1-Hash der gegebenen Zeichenkette enthält. Ist str NIL, so wird NIL zurückgegeben.

Beispiel: `(SHA1SUM "flower, sun and beach")' ergibt "47b6c496493c512b40e042337c128d85ecf15ba4".

Siehe auch ADMINPASSWORD, Beispielprojekt `Users.bbs'.

16.12.29 UPPER

UPPER wandelt eine Zeichenkette in Großbuchstaben.

(UPPER str)

Liefert eine Kopie der gegebenen Zeichenkette, in der alle Zeichen in Großbuchstaben umgewandelt wurden. Ist str NIL, dann wird NIL geliefert.

Beispiel: `(UPPER "Selma fand einen Brief, der an mein Fahrrad geheftet war.")' liefert "SELMA FAND EINEN BRIEF, DER AN MEIN FAHRRAD GEHEFTET WAR.".

Siehe auch LOWER.

16.12.30 LOWER

LOWER wandelt eine Zeichenkette in Kleinbuchstaben.

(LOWER str)

Liefert eine Kopie der gegebenen Zeichenkette, in der alle Zeichen zu Kleinbuchstaben umgewandelt wurden. Ist str NIL, dann wird NIL geliefert.

Beispiel: `(LOWER "Der Brief war von Silke.")' liefert "der brief war von silke.".

Siehe auch UPPER.

16.12.31 ASC

ASC wandelt ein Zeichen in die interne Zahlendarstellung um.

(ASC str)

Liefert den internen Zahlenwert des ersten Zeichens von str. Auf Windows, Mac OS und Linux ist dies die Unicode-Darstellung. Auf Amiga ist es der 8-bit-Zahlenwert in der vom System vorgegebenen Zeichen-Kodierung. Ist str leer, wird 0 geliefert. Ist str NIL, dann wird NIL geliefert.

Beispiel: (ASC "A") liefert 65.

Siehe auch CHR, INT.

16.12.32 CHR

CHR wandelt einen Zahlenwert in ein Zeichen um.

(CHR int)

Liefert eine Zeichenkette, die das Zeichen mit dem Zahlen-Code int enthält. Auf Linux und Windows wird int als Unicode-Zeichen interpretiert. Auf Amiga ist int der 8-bit Zahlenwert in der vom System vorgegebenen Zeichenkodierung. Ist int gleich 0, dann wird eine leere Zeichenkette geliefert. Ist int NIL oder nicht im Bereich der zulässigen Zeichenwerte, so wird NIL geliefert.

Beispiel: `(CHR 99)' liefert "c".

Siehe auch ASC, STR.

16.12.33 LIKE

LIKE vergleicht Zeichenketten.

(LIKE str1 str2)

Liefert TRUE, wenn str1 mit str2 übereinstimmt, anderenfalls NIL. Die Zeichenkette str2 kann die Jokerzeichen '?' und '*' enthalten, wobei '?' genau irgendein einzelnes Zeichen und '*' eine Zeichenkette jeder Länge irgendeines Inhalts (inklusive der leeren Zeichenkette) darstellt. Der Zeichenkettenvergleich wird ohne Beachtung der Groß-/Kleinschreibung durchgeführt.

Beispiel: `(LIKE "Silke war für ein Jahr in Frankreich." "*Jahr*")' liefert TRUE.

Siehe auch Vergleichsfunktionen.

16.12.34 SPRINTF

SPRINTF formatiert eine Zeichenkette mit verschiedenen Daten.

(SPRINTF fmt [expr ...])

SPRINTF erhält eine Reihe von Parametern, die in Zeichenketten umgewandelt werden und in aufbereiteter Form als einzelne Zeichenkette zurückgegeben wird. Die Zeichenkette fmt entscheidet genau, was in die zurückgegebene Zeichenkette geschrieben werden soll und kann zwei Arten von Elemente enthalten: ordinäre Zeichen, die unverändert kopiert werden und Umwandlungsbefehle, die SPRINTF anweisen, die Parameter aus seiner Parameterliste zu nehmen und zu formatieren. Umwandlungsbefehle beginnen immer mit dem Zeichen `%'.

Umwandlungsbefehle benötigen immer diese Form:

%[flags][width][.precision]type

wobei

• Das optionale Feld flags steuert die Ausrichtung der Ausgabe, das Vorzeichen von numerischen Werten, Dezimalpunkte und führende Leerzeichen.

• Das optionale Feld width legt die minimale Anzahl von Zeichen fest, die ausgegeben werden sollen (die Feldbreite), gegebenenfalls wird mit Leerzeichen oder führenden Nullen aufgefüllt.

• Das optionale Feld precision legt entweder die maximale Anzahl von auszugebenden Zeichen für die Typen Zeichenkette, Boolesch, Datum und Zeit oder die Anzahl der Ziffern nach dem Dezimalpunkt zur Ausgabe eines Fließkommawertes fest.

• Das Feld type legt den gewünschten Type des Parameters fest, den SPRINTF umwandeln soll, wie etwa Zeichenkette, Ganzzahl, Fliekommazahl etc.

Zu beachten ist, dass alle Felder außer type optional sind. Die folgenden Tabellen listen die gültigen Optionen für diese Felder auf.

Flaggenfeld flags

-:

Das Ergebnis ist linksbündig, das rechts mit Leerzeichen aufgefüllt wird. Normalerweise wird das Feld rechtsbündig ausgerichtet und links mit Leerzeichen oder `0'en aufgefüllt, wenn kein `-' angegeben wird.

+:

Das Ergebnis erhält immer ein Zeichen `-' oder `+' vorangestellt, wenn es eine numerische Umwandlung ist.

0:

Für Zahlen wird linksbündig mit führenden Nullen anstatt mit Leerzeichen aufgefüllt.

Leerzeichen:

Positive Zahlen erhalten ein Leerzeichen anstatt dem Zeichen `+', aber negative Zahlen bekommen nach wie vor das Zeichen `-' vorangestellt.

Breitenfeld width

n:

Mindestens n Zeichen werden ausgegeben. Hat die Umwandlung weniger als n Zeichen ergeben, dann wird mit Leerzeichen oder führenden Nullen aufgefüllt.

*:

Der Breite-Parameter wird in der Parameterliste als Ganz- oder Fließkommazahl vor dem eigentlichen Umwandlungsparameter mitgeliefert. Der Wert ist beschränkt auf 0 bis 999.

Genaugkeitsfeld precision

.n:

Für Zeichenketten-, Boolesche, Datums- und Zeit-Werte ist n die maximale Anzahl der auszugebenden Zeichen vom umgewandelten Element. Für Umwandlungen von Fließkommazahlen legt n die Anzahl der Nachkommastellen fest (Umwandlungen `e' und `f') oder die Anzahl signifikanter Stellen (Umwandlung `g'). Für Ganzzahlkonvertierungen wird dieser Wert ignoriert.

.*:

Die Genauigkeit wird in der Parameterliste als Ganz- oder Fließkommazahl vor dem eigentlichen Umwandlungsparameter mitgeliefert. Der Wert ist beschränkt auf 0 bis 999.

Typenfeld type

b:

Wandelt einen Booleschen Parameter nach "TRUE" (wahr) oder "NIL" (falsch).

i:

Wandelt eine Ganzzahl in Dezimalzahlnotation um.

o:

Wandelt eine Ganzzahl in Octalzahlnotation um.

x:

Wandelt eine Ganzzahl in Hexadezimalzahlnotation um. Es werden Kleinbuchstaben `abcdef' verwendet.

X:

Wandelt eine Ganzzahl in Hexadezimalzahlnotation um. Es werden Großbuchstaben `ABCDEF' verwendet.

e:

Wandelt eine Fließkommazahl in das Format `[-]d.ddde+dd' um. Genau eine Ziffer erscheint vor dem Dezimalpunkt, gefolgt von Nachkommastellen, einem `e' und dem Exponenten. Die Anzahl der Nachkommastellen wird im Genauigkeitsfeld festgelegt oder wenn nicht, dann ist sie 2. Der Dezimalpunkt erscheint nicht, wenn sie 0 ist.

f:

Wandelt eine Fließkommazahl in das Format `[-]ddd.ddd' um. Die Anzahl der Nachkommastellen wird im Genauigkeitsfeld festgelegt oder wenn nicht, dann ist sie 2. Der Dezimalpunkt erscheint nicht, wenn sie 0 ist.

g:

Wandelt eine Fließkommazahl entweder mittels Stil `e' oder `f' um, je nach Anzahl der benötigten Stellen, um die Zahl darzustellen. Ist die Genauigkeit nicht festgelegt, so werden 15 signifikante Stellen verwendet. Nachfolgende Nullen mit der Ausnahme einer einzelnen Null nach dem Dezmialpunkt werden unterdrückt.

s:

Schreibt eine Zeichenkette bis zum Ende der Zeichenkette oder soviele Zeichen, wie im Präzisionsfeld angegeben.

d:

Wandelt einen Datumswert um.

t:

Wandelt einen Zeitwert um.

%:

Nur das Zeichen `%' wird geschrieben und kein Parameter umgewandelt.

SPRINTF liefert die formatierte Zeichenkette oder NIL, wenn fmt NIL ist.

Beispiele

Aufruf                          Ergebnis

(SPRINTF "Hallo")                "Hallo"
(SPRINTF "%s" "Hallo")           "Hallo"
(SPRINTF "%10s" "Hallo")         "     Hallo"
(SPRINTF "%-10.10s" "Hallo")     "Hallo     "
(SPRINTF "%010.3s" "Hallo")      "       Hal"
(SPRINTF "%-5.3b" TRUE)          "TRU  "
(SPRINTF "%i" 3)                 "3"
(SPRINTF "%03i" 3)               "003"
(SPRINTF "%0- 5.3i" 3)           " 3   "
(SPRINTF "%f" 12)                "12.00"
(SPRINTF "%10e" 12.0)            "  1.20e+01"
(SPRINTF "%+-10.4f" 12.0)        "+12.0000  "
(SPRINTF "%10.5t" 12:30:00)      "     12:30"
(SPRINTF "%d" 28.11.1968)        "28.11.1968"
(SPRINTF "Ha%s %4.4s!"
   "llo"
   "Weltmeisterschaft")          "Hallo Welt!"

Siehe auch PRINTF, FPRINTF, STR, +, CONCAT, CONCAT2, COPYSTR.

16.13 Funktionen für mehrzeilige Texte

Dieser Abschnitt behandelt Funktionen für mehrzeilige Texte.

16.13.1 LINE

LINE holt eine Zeile aus einem mehrzeiligen Text.

(LINE memo num)

Liefert die num-te Zeile (beginnend bei Null) aus dem gegebenen mehrzeiligen Text. Die Zeile hat dann kein abschließendes Neue-Zeile-Zeichen.

Ist str oder num gleich NIL oder ist num außerhalb des gültigen Bereichs (negativ oder größer als Anzahl Zeilen), dann wird NIL zurückgeliefert.

Siehe auch LINES, WORD.

16.13.2 LINES

LINES liefert die Anzahl der Zeilen in einem mehrzeiligen Text.

(LINES memo)

Liefert die Anzahl der Zeilen des gegebenen mehrzeiligen Textes oder NIL, wenn memo NIL ist.

Siehe auch LINE, WORDS, LEN.

16.13.3 MEMOTOLIST

MEMOTOLIST wandelt einen mehrzeiligen Text in eine Liste von Zeichenketten um.

(MEMOTOLIST memo [expandstr])

Wandelt den gegebenen mehrzeiligen Text in eine Liste um. Ist memo gleich NIL, dann wird NIL geliefert, anderenfalls wird eine Liste erzeugt, in der jedes Element eine Zeile des mehrzeiligen Textes enthält.

Wird expandstr angegeben und ist nicht NIL, so wird die resultierende Liste von Zeichenketten weiter unterteilt, indem die Funktion STRTOLIST auf jedes Listenelement angewendet wird. Dies ergibt eine Liste von Listen von Zeichenketten.

Beispiele

`(MEMOTOLIST "Meine Versicherung\nzahlt für\ndas kaputte Fahrrad.")' liefert ( "Meine Versicherung" "zahlt für" "das kaputte Fahrrad." ).

`(MEMOTOLIST "Hier ist\tein mehr-spaltiges\nBeispiel." TRUE)' liefert ( ( "Hier ist" "ein mehr-spaltiges" ) ( "Beispiel" ) ).

Siehe auch STRTOLIST, LISTTOMEMO.

16.13.4 LISTTOMEMO

LISTTOMEMO wandelt eine Liste in einen mehrzeiligen Text um.

(LISTTOMEMO list)

Wandelt eine gegebene Liste in einen mehrzeiligen Text um. Ist list gleich NIL, dann wird NIL zurückgegeben, anderenfalls wird ein mehrzeiliget Text erzeugt, dessen einzelne Zeilen die Zeichenkettendarstellung des entsprechenden Listenelements enthalten. Falls ein Listenelement eine Unterliste enthält, so wird LISTTOSTR (siehe LISTTOSTR) auf die Unterliste angewandt bevor die resultierende Zeichenkette in den mehrzeiligen Text aufgenommen wird.

Beispiele

`(LISTTOMEMO (LIST "Silke" "leiht mir" "'mein' Fahrrad" "bis zum" 01.09.1998)' liefert: "Silke\nleiht mir\n'mein' Fahrrad\nbis zum\n01.09.1998".

`(LISTTOMEMO (LIST (LIST "Name" "Geburtstag") (LIST "Steffen" 28.11.1968)' liefert: "Name\tGeburtstag\nSteffen\t28.11.1968".

Siehe auch LISTTOSTR, MEMOTOLIST.

16.13.5 FILLMEMO

FILLMEMO füllt einen mehrzeiligen Text mit den Ergebnissen von Ausdrücken.

(FILLMEMO memo)

Erzeugt eine Kopie des gegebenen mehrzeiligen Textes, in dem alle Teilzeichenketten der Form `$(expr)' durch ihre Ergebnisse nach der Auswertung ersetzt werden.

Beispiel: `(FILLMEMO "(+ 1 1) ist $(+ 1 1).")' liefert "(+ 1 1) ist 2."

Man sollte nur kleine Ausdrücke in einem mehrzeiligen Text verwenden, da die Fehlersuche nicht einfach ist(3).

Siehe auch FORMATMEMO, INDENTMEMO.

16.13.6 FORMATMEMO

FORMATMEMO formatiert einen mehrzeiligen Text.

(FORMATMEMO memo width [fill [singlelinesec]])

Formatiert memo in einen mehrzeiligen Text mit Zeilen, die nicht länger als width Zeichen sind. Wird fill angegeben und ist nicht NIL, dann werden Leerzeichen zum Auffüllen der Zeilen verwendet, damit die Zeilen genau die Länge width erhalten. Der mehrzeilige Test wird abschnittsweise abgearbeitet. Ein Abschnitt beginnt beim ersten Zeichen, das kein Leerzeichen ist. Wird singlelinesec angegeben und ist nicht NIL, dann gehören alle Zeichen in dieser Zeile zu dem Abschnitt. Andernfalls zählen alle Zeichen in dieser und den folgenen Zeilen zu dem Abschnitt, bis eine Zeile gefunden wird, die mit einem Leerzeichen beginnt. Der gesamte Abschnitt wird wortweise formatiert, dies bedeutet, dass soviele Wörter in eine Zeile gesetzt werden, wie dafür vorhanden Platz ist. Die restlichen Wörter kommen dann in eine neue Zeile, usw.

Siehe auch FILLMEMO, INDENTMEMO.

16.13.7 INDENTMEMO

INDENTMEMO rückt einen mehrzeiligen Text ein, in dem links Leerzeichen eingefügt werden.

(INDENTMEMO memo indent)

Liefert eine Kopie des gegebenen mehrzeiligen Textes, in dem jede Zeile mit indent Leerzeichen eingerückt wird. Ist memo oder indent NIL, dann wird NIL zurückgeliefert. Ist indent negativ, dann wird 0 angenommen.

Siehe auch FILLMEMO, FORMATMEMO.

16.14 Datum- und Zeitfunktionen

Dieser Abschnitt behandelt Funktionen für Datum und Zeit.

16.14.1 DAY

DAY extrahiert den Tag eines Datums.

(DAY date)

Liefert eine Ganzahl, welche den Tag des gegebenen Datums repräsentiert. Ist date NIL, so wird NIL zurückgegeben.

Siehe auch MONTH, YEAR, DATEDMY.

16.14.2 MONTH

MONTH extrahiert den Monat eines Datums.

(MONTH date)

Liefert eine Ganzahl, welche den Monat des gegebenen Datums repräsentiert. Ist date NIL, so wird NIL zurückgegeben.

Siehe auch DAY, YEAR, DATEDMY, MONTHDAYS.

16.14.3 YEAR

YEAR extrahiert das Jahr eines Datums.

(YEAR date)

Liefert eine Ganzahl, welche das Jahr des gegebenen Datums repräsentiert. Ist date NIL, so wird NIL zurückgegeben.

Siehe auch DAY, MONTH, DATEDMY, YEARDAYS.

16.14.4 DATEDMY

DATEDMY erstellt ein Datum aus Tag, Monat und Jahr.

(DATEDMY day month year)

Erstellt ein Datum aus dem gegebenen Tag, Monat und Jahr. Ist eines von day, month, oder year NIL oder außerhalb des gültigen Bereichs, oder ist das resultierende Datum ungültig, so wird NIL geliefert.

Beispiel: `(DATEDMY 28 11 1968)' ergibt den 28. November, 1968.

Siehe auch DATE, TODAY, DAY, MONTH, YEAR.

16.14.5 MONTHDAYS

MONTHDAYS bestimmt die Anzahl Tage eines Monats.

(MONTHDAYS month year)

Liefert die Anzahl Tage des gegebenen Monats und Jahrs als Ganzzahlwert. Ist month NIL oder außerhalb des gültigen Bereichs (kleiner als 1 oder größer als 12), so wird NIL zurückgegeben. Ist year NIL, so wird ein Nicht-Schaltjahr für die Berechnung der Anzahl Tage betrachtet. Falls year ungültig ist (kleiner als 0 oder größer als 9999), so wird NIL geliefert.

Beispiele: `(MONTHDAYS 2 2004)' liefert 29, `(MONTHDAYS 2 NIL)' ergibt 28.

Siehe auch YEARDAYS, MONTH.

16.14.6 YEARDAYS

YEARDAYS bestimmt die Anzahl Tage eines Jahres.

(YEARDAYS year)

Liefert die Anzahl Tage des gegebenen Jahrs als Ganzzahlwert. Ist year NIL oder außerhalb des gültigen Bereichs (kleiner als 0 oder größer als 9999), so wird NIL zurückgegeben.

Beispiele: `(YEARDAYS 2004)' liefert 366, `(YEARDAYS 2005)' ergibt 365.

Siehe auch MONTHDAYS, YEAR.

16.14.7 ADDMONTH

ADDMONTH addiert eine Anzahl Monate zu einem Datum.

(ADDMONTH date months)

Liefert ein Datum, bei welchem die gegebene Anzahl Monate zu dem gegebenen Datum addiert wurde. Negative Werte für months subtrahieren Monate. Falls date oder months NIL sind, oder das resultierende Datum ungültig ist, so wird NIL geliefert.

ADDMONTH behandelt einen Über- oder Unterlauf des Monatfelds, indem das Jahresfeld entsprechend angepasst wird. Falls das Tagfeld die maximale Anzahl Tage des resultierenden Monats überschreitet, so wird es auf den maximal erlaubten Tag reduziert.

Beispiele: `(ADDMONTH 30.01.2004 1)' ergibt 29.02.2004, `(ADDMONTH 30.01.2004 -1)' ergibt 30.12.2003.

Siehe auch ADDYEAR, +.

16.14.8 ADDYEAR

ADDYEAR addiert eine Anzahl Jahre zu einem Datum.

(ADDYEAR date years)

Liefert ein Datum, bei welchem die gegebene Anzahl Jahre zu dem gegebenen Datum addiert wurde. Negative Werte für years subtrahieren Jahre. Falls date oder years NIL sind, oder das resultierende Datum ungültig ist, so wird NIL geliefert.

ADDYEAR dekrementiert das Tagfeld um 1, falls date den 29. Februar repräsentiert und das resultierende Jahr kein Schaltjahr ist.

Beispiele: `(ADDYEAR 29.02.2004 1)' ergibt 28.02.2005, `(ADDMONTH 04.02.2004 -1962)' ergibt 04.02.0042.

Siehe auch ADDMONTH, +.

16.14.9 TODAY

TODAY liefert das heutige Datum.

(TODAY)

Liefert das heutige Datum als Datumswert.

Siehe auch NOW.

16.14.10 NOW

NOW liefert die aktuelle Uhrzeit.

(NOW)

Liefert die aktuelle Uhrzeit als Zeitwert.

Siehe auch TODAY.

16.15 Listenfunktionen

Dieser Abschnitt listet Funktionen zum Verarbeiten von Listen auf.

16.15.1 CONS

CONS erzeugt ein Paar von Ausdrücken.

(CONS elem list)

Erzeugt eine neue Liste. Das erste Element der neuen Liste ist elem, der Rest sind die Elemente von list (die eine Liste sein muss oder NIL). Die Liste list wird nicht kopiert, sondern nur ein Zeiger auf diese wird verwendet.

Beispiel: `(CONS 1 (CONS 2 NIL))' liefert ( 1 2 ).

Die Elemente der Liste können von jedem Typ sein, z.B. ist es auch möglich, eine Liste von Listen zu haben (z.B. siehe SELECT). Der Konstruktor CONS kann auch verwendet werden, um Element-Paare zu erzeugen, z.B. `(CONS 1 2)' ist ein Paar mit den Ganzzahlen 1 und 2.

Siehe auch LIST, FIRST, REST.

16.15.2 LIST

LIST erzeugt eine Liste anhand ihrer Parameter.

(LIST [elem ...])

nimmt die Parameter elem ... und generiert daraus eine Liste. Dies ist gleichbedeutend dem Aufruf von (CONS elem (CONS ... NIL)). Man beachte, dass NIL alleine für eine leere Liste steht.

Siehe auch CONS, LENGTH.

16.15.3 LENGTH

LENGTH ermittelt die Länge einer Liste.

(LENGTH list)

liefert die Länge der gegebenen Liste.

Beispiel: `(LENGTH (LIST "a" 2 42 3))' liefert 4.

Siehe auch LIST.

16.15.4 FIRST

FIRST holt das erste Element aus einer Liste.

(FIRST list)

liefert das erste Element der gegebenen Liste. Ist list leer (NIL), dann wird NIL geliefert.

Siehe auch REST, LAST, NTH, CONS.

16.15.5 REST

REST liefert die Teilliste nach dem ersten Element einer Liste.

(REST list)

liefert den Rest der gegebenen Liste (die Liste ohne dem ersten Element). Ist list leer (NIL), dann wird NIL zurückgeliefert.

Beispiel: `(REST (LIST 1 2 3))' liefert ( 2 3 ).

Siehe auch FIRST, CONS.

16.15.6 LAST

LAST holt das letzte Element aus einer Liste.

(LAST list)

Liefert das letzte Element der gegebenen Liste oder NIL, wenn list NIL ist.

Siehe auch FIRST, NTH.

16.15.7 NTH

NTH holt das n-te Element aus einer Liste.

(NTH n list)

Liefert das n-te Element der gegebenen Liste (beginnend bei 0) oder NIL, wenn das Element nicht existiert.

Siehe auch FIRST, LAST, REPLACENTH

16.15.8 REPLACENTH

REPLACENTH ersetzt das n-te Element in einer Liste.

(REPLACENTH n elem list)

Liefert eine neue Liste, in der das n-te Element der gegebenen Liste (beginnend bei 0) durch elem ersetzt wurde.

Ist n NIL oder exisistiert das n-te Element nicht, dann wird NIL zurückgegeben.

Siehe auch NTH, REPLACENTH*, MOVENTH, REMOVENTH.

16.15.9 REPLACENTH*

REPLACENTH* ist die Stern-Variante von REPLACENTH. Der einzige Unterschied zu REPLACENTH ist, dass REPLACENTH* die Originalliste zurückgibt, falls das n-te Element nicht existiert.

REPLACENTH* kann wie folgt implementiert werden:

(DEFUN REPLACENTH* (n e l)
    (LET ((r (REPLACENTH n e l)))
        (IF r r l)
    )
)

Siehe auch NTH, REPLACENTH, Beispielprojekt `FileList.bbs'.

16.15.10 MOVENTH

MOVENTH schiebt das n-te Element in einer Liste an eine neue Position.

(MOVENTH n m list)

Liefert eine neue Liste, in der das n-te Element der gegebenen Liste (beginnend bei 0) an die m-te Position verschoben wurde.

Ist n oder m NIL oder exisistiert das n-te oder m-te Element nicht, dann wird NIL zurückgegeben.

Beispiel: `(MOVENTH 0 1 (list 1 2 3))' liefert ( 2 1 3 ).

Siehe auch NTH, MOVENTH*, REPLACENTH, REMOVENTH.

16.15.11 MOVENTH*

MOVENTH* ist die Stern-Variante von MOVENTH. Der einzige Unterschied zu MOVENTH ist, dass MOVENTH* die Originalliste zurückgibt, falls das n-te oder m-te Element nicht existiert.

MOVENTH* kann wie folgt implementiert werden:

(DEFUN MOVENTH* (n m l)
    (LET ((r (MOVENTH n m l)))
        (IF r r l)
    )
)

Siehe auch NTH, MOVENTH, Beispielprojekt `FileList.bbs'.

16.15.12 REMOVENTH

REMOVENTH entfernt das n-te Element in einer Liste.

(REMOVENTH n list)

Liefert eine neue Liste, in der das n-te Element der gegebenen Liste (beginnend bei 0) entfernt wurde.

Ist n NIL oder exisistiert das n-te Element nicht, dann wird NIL zurückgegeben.

Beispiel: `(REMOVENTH 1 (list 1 2 3))' liefert ( 1 3 ).

Siehe auch NTH, REMOVENTH*, REPLACENTH, MOVENTH.

16.15.13 REMOVENTH*

MOVENTH* ist die Stern-Variante von REMOVENTH. Der einzige Unterschied zu REMOVENTH ist, dass REMOVENTH* die Originalliste zurückgibt, falls das n-te Element nicht existiert.

REMOVENTH* kann wie folgt implementiert werden:

(DEFUN REMOVENTH* (n l)
    (LET ((r (REMOVENTH n l)))
        (IF r r l)
    )
)

Siehe auch NTH, REMOVENTH, Beispielprojekt `FileList.bbs'.

16.15.14 APPEND

APPEND verbindet Listen.

(APPEND [list ...])

liefert die Verknüpfung von list ....

Beispiel: `(APPEND (list 1 2) (list 3 4) (list 5))' liefert ( 1 2 3 4 5 ).

Siehe auch LIST.

16.15.15 REVERSE

REVERSE kehrt eine Liste um.

(REVERSE list)

liefert die umgekehrte Liste.

Beispiel: `(REVERSE (list 1 2 3))' liefert ( 3 2 1 ).

16.15.16 MAPFIRST

MAPFIRST wendet eine Funktion auf alle Listenelemente an.

(MAPFIRST func list [...])

Erzeugt eine Liste, deren Elemente das Ergebnis einer angegebenen Funktion sind, die als Parameter die einzelnen Listenelemente der Reihe nach bekommen hat. Die Länge der zurückgelieferten Liste ist genau so lang, wie die längste angegebene Liste. Ist eine der gegebenen Listen zu kurz, dann wird die Liste mit NIL aufgefüllt.

Beispiele

Ausdruck                               Wert

(MAPFIRST 1+ (LIST 1 2 3))             ( 2 3 4 )
(MAPFIRST + (LIST 1 2 3) (LIST 2 3))   ( 3 5 NIL )

16.15.17 SORTLIST

SORTLIST sortiert die Elemente einer Liste.

(SORTLIST func list)

Liefert eine Kopie der gegebenen Liste, die mit der Funktion func sortiert wurde. Die Sortierfunktion muss zwei Parameter für jedes Element verarbeiten und einen Ganzzahlwert liefern, der kleiner als Null ist, wenn das erste Element 'kleiner' ist als das zweite, einen Wert größer Null, wenn das zweite 'größer' ist als das erste und einen Wert gleich Null, wenn beide Elemente 'gleich' sind.

Beispiel für eine Zeichenkettenvergleichsfunktion für die Sortierung:

(DEFUN cmp_str (x y)
    (COND
        ((< x y) -1)
        ((> x y) 1)
        (TRUE 0)
    )
)

Nun lässt sich eine Liste durch den Aufruf

(SORTLIST cmp_str (LIST "hi" "gut" "großartig" "ok"))

sortieren, die ( "großartig" "gut" "hi" "ok" ) liefert.

Siehe auch SORTLISTGT, MAPFIRST.

16.15.18 SORTLISTGT

SORTLIST sortiert die Elemente einer Liste.

(SORTLISTGT gtfunc list)

Arbeitet wie SORTLIST, aber hier wird eine Sortierfunktion angegeben, die einen Wert ungleich NIL liefert, wenn das erste Element 'größer' ist als das zweite, anderenfalls NIL.

Beispiel: `(SORTLISTGT > (LIST "hi" "gut" "großartig" "ok"))' liefert ( "großartig" "gut" "hi" "ok" ).

Siehe auch SORTLIST, MAPFIRST.

16.16 Benutzereingabefunktionen

Zum Abfragen von Benutzereingaben können folgende Funktionen verwendet werden:

16.16.1 ASKFILE

ASKFILE fragt den Benutzer nach einem Dateinamen.

(ASKFILE title oktext default savemode)

Öffnet ein Dateiauswahlfenster zur Eingabe eines Dateinamens. Der Fenstertitel kann in title, der Text des `Ok'-Knopfes in oktext und der vorgegebene Dateiname in default gesetzt werden. Für jeden dieser Argumente kann NIL gesetzt werden, um Vorgabewerte zu verwenden. Der letzte Parameter savemode (Boolesch) setzt das Dateiauswahlfenster in den Speichermodus. Dieser Modus sollte verwendet werden, wenn nach einem Dateinamen gefragt wird, im etwas in eine Datei zu schreiben.

ASKFILE liefert den eingegebenen Dateinamen als Zeichenkette oder NIL, wenn der Benutzer das Fenster mit Abbrechen verlassen hat.

Siehe auch ASKDIR, ASKSTR.

16.16.2 ASKDIR

ASKDIR fragt den Benutzer nach einem Verzeichnisnamen.

(ASKDIR title oktext default savemode)

Öffnet ein Dateiauswahlfenster zur Eingabe eines Verzeichnisnamens. Die Parameter werden auf die gleiche Weise verwendet wie in ASKFILE (siehe ASKFILE).

ASKDIR liefert den eingegebenen Verzeichnisnamen als Zeichenkette oder NIL, wenn der Benutzer das Fenster mit Abbrechen verlassen hat.

Siehe auch ASKFILE, ASKSTR.

16.16.3 ASKSTR

ASKSTR fragt den Benutzer nach einer Zeichenkette.

(ASKSTR title oktext default maxlen [secret])

Öffnet ein Fenster, das nach einer Zeichenketteneingabe fragt. Der Fenstertitel, der Text des `Ok'-Knopfes und der Vorgabewert können mit title, oktext beziehungsweise default (mit Zeichenketten oder NIL für die Vorgabewerte) gesetzt werden. maxlen bestimmt die maximale Anzahl Zeichen, die der Benutzer eingeben kann. Wird secret angegeben und ist nicht NIL, so wird die eingegebene Zeichnkette unsichtbar gemacht, indem ein Aufzählungszeichen für jedes Zeichen der Zeichenkette angezeigt wird.

ASKSTR liefert die eingegebene Zeichenkette oder NIL, wenn der Benutzer das Fenster mit Abbrechen verlassen hat.

Siehe auch ASKFILE, ASKDIR, ASKCHOICESTR, ASKINT.

16.16.4 ASKINT

ASKINT fragt den Benutzer nach einer Ganzzahl.

(ASKINT title oktext default min max)

Öffnet ein Eingabefenster, das nach einer Ganzzahleingabe fragt. Der Fenstertitel und der Text des `Ok'-Knopfes können mit title und oktext (mit Zeichenketten oder NIL für Vorgabewerte) gesetzt werden. In default wird der Vorgabewert übergeben oder NIL, wenn mit einem leeren Feld begonnen werden soll. In min und max wird der erlaubte Zahlenbereich festgelegt. Eingegebene Werte außerhalb dieses Bereichs werden vom Eingabefenster nicht akzeptiert. Man verwende NIL für einen unbeschränkten Vorgabebereich.

ASKINT liefert die eingegebene Ganzzahl oder NIL, wenn der Benutzer das Fenster mit Abbrechen verlassen hat.

Siehe auch ASKSTR.

16.16.5 ASKCHOICE

ASKCHOICE fragt den Benutzer nach einer Auswahl aus mehreren Elementen.

(ASKCHOICE title oktext choices default [titles])

Öffnet ein Eingabefenster, das den Benutzer nach einem Element aus einer Liste von Elementen fragt. Der Fenstertitel und der Text des `Ok'-Knopfes können mit title und oktext (Zeichenketten oder NIL für Vorgabewerte) gesetzt werden. In choices wird eine Liste der Auswahlelemente angegeben. Es kann ein mehr-spaltiges Format verwendet werden, indem jedes Auswahlelement als eine Liste von Unterelementen angegeben wird. Eine Vorauswahl kann in default als Index in die Liste der Auswahlelemente (beginnend mit 0 für das erste Element) getroffen werden. Für keine Vorauswahl wird hier NIL angegeben. Wird das optionale Argument titles angegeben und ist nicht NIL, so wird ein Listenkopf mit dem Inhalt von titles angezeigt. Für ein mehr-spaltiges Format kann titles als eine Liste von Spaltenüberschriften angegeben werden.

Sowohl choices als auch titles können durch einen mehrzeiligen Text und eine Zeichenkette (anstatt von Listen) angegeben werden. In diesem Fall werden diese automatisch durch Aufrufen von (MEMOTOLIST choices TRUE) (siehe MEMOTOLIST), bzw. (STRTOLIST titles) (siehe STRTOLIST) in Listen umgewandelt.

ASKCHOICE liefert den Index des gewählten Elements oder NIL, wenn der Benutzer das Fenster mit Abbrechen verlassen hat.

Beispiele

(LET ((items (LIST "Erster Eintrag" 2 3.14 "Letzter Eintrag")) index)
    (SETQ index (ASKCHOICE "Wähle ein Element" "Ok" items NIL))
    (IF index
        (PRINTF "Benutzer wählte Element Nummer %i mit dem Inhalt <%s>\n"
            index (STR (NTH index items))
        )
    )
)

Nehmen wir an, Sie wollen den Benutzer einen bestimmten Datensatz einer Tabelle auswählen lassen. Die Tabelle soll `Artikel' heißen und die Felder `Name', `Nummer', and `Preis' enthalten. Das folgende Programm-Fragment zeigt, wie ASKCHOICE dazu verwendet werden kann, um einen Datensatz mit Preis größer 10 und nach Name geordnet auszuwählen:

(LET ((query (SELECT Artikel, Name, Nummer, Preis from Artikel 
	      WHERE (> Preis 10) ORDER BY Name))
     (recs (MAPFIRST FIRST (REST query)))	; Datensatz-Zeiger
     (items (MAPFIRST REST (REST query)))	; Auswahl
     (titles (REST (FIRST query)))		; Überschriften
     (index (ASKCHOICE "Auswahl" "Ok" items NIL titles))
     (rec (NTH index recs)))
     ; jetzt enthält rec den ausgewählten Datensatz (oder NIL bei Abbruch)
)

Siehe auch ASKCHOICESTR, ASKOPTIONS.

16.16.6 ASKCHOICESTR

ASKCHOICESTR fragt den Benutzer nach einer Zeichenkette und bietet vorgegebene an.

(ASKCHOICESTR title oktext strings default [titles])

Öffnet ein Eingabefenster, das dem Benutzer erlaubt, eine Zeichenkette aus mehreren auszuwählen oder eine beliebige Zeichenkette im separaten Zeichenkettenfeld einzugeben. Der Fenstertitel und der Text des `Ok'-Knopfes können mit title und oktext (Zeichenketten oder NIL für Vorgabewerte) gesetzt werden. In strings wird eine Liste der Auswahlelemente angegeben. Es kann ein mehr-spaltiges Format verwendet werden, indem jedes Auswahlelement als eine Liste von Unterelementen angegeben wird. Der Vorgabewert des Zeichenkettenfeldes kann mit default (Zeichenkette oder NIL für ein leeres Feld) gesetzt werden. Wird das optionale Argument titles angegeben und ist nicht NIL, so wird ein Listenkopf mit dem Inhalt von titles angezeigt. Für ein mehr-spaltiges Format kann titles als eine Liste von Spaltenüberschriften angegeben werden.

Sowohl strings als auch titles können durch einen mehrzeiligen Text und eine Zeichenkette (anstatt von Listen) angegeben werden. In diesem Fall werden diese automatisch durch Aufrufen von (MEMOTOLIST strings TRUE) (siehe MEMOTOLIST), bzw. (STRTOLIST titles) (siehe STRTOLIST) in Listen umgewandelt.

ASKCHOICESTR liefert die ausgewählte Zeichenkette oder NIL, wenn der Benutzer das Fenster mit Abbrechen verlassen hat.

Beispiel

(LET ((strings (LIST "Claudia" "Mats" "Ralphie")) likebest)
    (SETQ likebest
        (ASKCHOICESTR "Wen mögen Sie am liebsten?" "Ok" strings 
            "Meine Collie-Hunde!"
        )
    )
    (IF likebest (PRINTF "Benutzer wählte <%s>\n" likebest))
)

Siehe auch ASKCHOICE, ASKOPTIONS.

16.16.7 ASKOPTIONS

ASKOPTIONS erlaubt dem Benutzer mehreren Optionen aus einer Liste auszuwählen.

(ASKOPTIONS title oktext options selected 
[titles])

Öffnet ein Eingabefenster, das dem Benutzer erlaubt, mehrere Optionen aus einer Liste auszuwählen. Der Fenstertitel und der Text des `Ok'-Knopfes können mit title und oktext (Zeichenketten oder NIL für Vorgabewerte) gesetzt werden. In options wird eine Liste der Optionen angegeben. Es kann ein mehr-spaltiges Format verwendet werden, indem jede Option als eine Liste von Unterelementen angegeben wird. Die Vorgabeauswahl der Optionen lässt sich in selected festlegen, welche eine Liste von Index-Zahlen enthält, die jeweils den entsprechenden Eintrag in options angibt, die vorab ausgewählt werden soll. Für keine Vorauswahl wird NIL anstatt einer Liste von Index-Zahlen angegeben. Wird das optionale Argument titles angegeben und ist nicht NIL, so wird ein Listenkopf mit dem Inhalt von titles angezeigt. Für ein mehr-spaltiges Format kann titles als eine Liste von Spaltenüberschriften angegeben werden.

Sowohl options als auch titles können durch einen mehrzeiligen Text und eine Zeichenkette (anstatt von Listen) angegeben werden. In diesem Fall werden diese automatisch durch Aufrufen von (MEMOTOLIST options TRUE) (siehe MEMOTOLIST), bzw. (STRTOLIST titles) (siehe STRTOLIST) in Listen umgewandelt.

ASKOPTIONS liefert eine Liste von Ganzzahlen, die den Index der ausgewählten Elemente enthält oder NIL, wenn der Benutzer das Fenster mit Abbrechen verlassen oder kein Element ausgewählt hat.

Beispiel

(LET ((options (LIST "Salva Mea" "Insomnia" "Don't leave" "7 days & 1 week"))
        (selected (LIST 0 1 3))
    )
    (SETQ selected (ASKOPTIONS "Wähle Musiktitel" "Ok" options selected))
    (IF selected
        (
            (PRINTF "Benutzer wählte folgende Einträge:\n")
            (DOLIST (i selected)
                (PRINTF "\tNummer %i enthält: <%s>\n" i 
                    (STR (NTH i options))
                )
            )
        )
    )
)

(Anm.d.Übersetzers: Hier hören Entwickler und Übersetzer die gleiche Musik von Faithless :-)

16.16.8 ASKBUTTON

ASKBUTTON fragt den Benutzer nach einen Knopfdruck.

(ASKBUTTON title text buttons canceltext)

Öffnet ein Eingabefenster mit dem gegebenen Fenstertitel title (als Zeichenkette oder NIL für einen Vorgabetitel) und dem gegebenen Beschreibungstext text (als Zeichenkette oder NIL für keinen Text). Die Funktion wartet auf einen Druck der in buttons (als Liste von Zeichenketten) festgelegten Knöpfe oder des `Abbrechen'-Knopfes. Der Text des Abbruchknopfes lässt sich mit canceltext ändern. Wird hier NIL angegeben, dann wird ein Vorgabetext verwendet, der sich nach der Anzahl der festgelegten Knöpfe richtet.

ASKBUTTON liefert die Nummer des gedrückten Knopfes (beginnend bei 0 mit dem am weitesten links angeordneten Knopf) oder NIL, wenn der Benutzer den `Abbruch'-Knopf gedrückt hat.

Beispiele

(LET ((buttons (LIST "Zuhause" "Im Bett" "Vor meinem Computer")) index)
    (SETQ index (ASKBUTTON "Bitte beantworten:"
        "Wo werden Sie morgen sein?" buttons "Weiß nicht")
    )
    (IF index
        (PRINTF "Benutzer entschied sich für: <%s>\n" (NTH index buttons))
    )
)

(ASKBUTTON "Info" "Ich finde BeeBase spitze!" NIL NIL)

Siehe auch ASKCHOICE.

16.16.9 ASKMULTI

ASKMULTI fragt den Benutzer nach verschiedenartigen Informationen.

(ASKMULTI title oktext itemlist)

ASKMULTI ist ein Mehrzweck-Eingabefenster. Es öffnet ein Fenster mit dem angegebenen Titel title, einem Satz von grafischen Objekten für die Dateneingabe und zwei Knöpfen (`Ok' und `Abbrechen') zum Beenden des Eingabefensters. Der Text für den `Ok'-Knopf kann mit oktext verändert werden (als Zeichenkette oder NIL für einen Vorgabetext). Der Satz der grafischen Objekte werden in itemlist festgelegt, das eine Liste ein Elementen ist, in der jedes eine der folgenden Formate hat:

    (LIST title "String" initial [help [secret]])  zum Bearbeiten einer Textzeile,
    (LIST title "Memo" initial [help])        zum Bearbeiten von mehrzeiligen Texten,
    (LIST title "Integer" initial [help])     zum Bearbeiten einer Ganzzahl,
    (LIST title "Real" initial [help])        zum Bearbeiten einer Fließkommazahl,
    (LIST title "Date" initial [help])        zum Bearbeiten eines Datums,
    (LIST title "Time" initial [help])        zum Bearbeiten einer Zeit,
    (LIST title "Bool" initial [help])        zum Bearbeiten eines Booleschen Wertes,
    (LIST title "Choice" initial
        (LIST choice ...) [help]
    )                                     für ein Auswahlfeld.
    (LIST title "ChoiceList" initial
        (LIST choice ...) [help]
    )                                     zum Auswählen eines Elements
                                          aus einer Liste.
    (LIST title "Options" initial
        (LIST choice ...) [help]
    )                                     zum Auswählen mehrerer Elemente
                                          aus einer Liste.
    non-list-expr                           für statischen Text

Der Titel title (als Zeichenkette oder NIL für keinen Titel) wird links neben dem grafischen Objekt angeordnet. Ist der Vorgabewert initial NIL, dann wird ein Vorgabewert verwendet (z.B. ein leeres Textfeld). Für Auswahlfelder muss der Vorgabewert der Index (beginnend bei 0) sein, für Auswahllistenfelder darf der Vorgabewert NIL (kein Eintrag ausgewählt) sein und für Optionsfelder muss der Vorgabewert eine Liste von Ganzzahlen sein, die die Indexe (beginnend bei 0) der Elemente sein, die vorbelegt sein sollen. Das optionale Hilfsfeld (eine Zeichenkette) kann verwendet werden, um dem Benutzer mehr Informationen über die Verwendung des Feldes mitzugeben. Für Zeichenkettenfelder kann ein weitere Parameter `secret' angegeben werden. Ist dieser nicht NIL, so wird die eingegebene Zeichnkette unsichtbar gemacht, indem ein Aufzählungszeichen für jedes Zeichen der Zeichenkette angezeigt wird.

ASKMULTI liefert eine Liste von Werten, die der Benutzer bearbeitet und über den `Ok'-Knopf bestätigt hat. Jeder Ergebniswert eines Feldes hat das gleiche Format wie der für den Vorgabewert, z.B. für ein Auswahllistenfeld ist der Rückgabewert der Index des ausgewählten Elements (oder NIL, wenn keines ausgewählt wurde) oder für Optionsfelder ist er die Liste von Ganzzahlen, die die Indexe der ausgewählten Elemente darstellen. Für statischen Text wird NIL zurückgegeben.

Wurde z.B. ein Datumsfeld, ein statischer Text, ein Auswahlfeld, ein Optionsfeld und ein Zeichenkettenfeld mit dem Vorgabewert "Welt" festgelegt und der Benutzer gab 11.11.1999 ein, wählte den Auswahleintrag mit dem Index 2, wählte das dritte und vierte Element des Optionsfeldes und ließ das Zeichenkettenfeld unberührt, dann liefert die Funktion die Liste ( 11.11.1999 NIL 2 ( 3 4 ) "world" ).

Brach der Benutzer das Eingabefenster ab, wird NIL geliefert.

Beispiel

(ASKMULTI "Bitte bearbeiten:" NIL (LIST
    (LIST "_Name" "String" "")
    (LIST "_Geburtstag" "Date" NIL)
    (LIST "Ge_schlecht" "Choice" 0 (LIST "männlich" "weiblich"))
    (LIST "_Hat ein Auto?" "Bool" NIL)
    (LIST "_Mag" "Options" (LIST 0 2)
        (LIST "Bier" "Wein" "Whisky" "Wodka" "Schnaps")
    ))
)

Man sehe sich auch das Projekt `AskDemo.bbs' für weitere Beispiele an.

16.17 E/A-Funktionen

Dieser Abschnitt listet die Funktionen und Variablen zur Dateiein- und ausgabe (z.B. drucken) auf.

16.17.1 FOPEN

FOPEN öffnet eine Datei zum Lesen/Schreiben.

(FOPEN filename mode [encoding])

Öffnet eine Datei mit dem Dateinamen filename (Zeichenkette). Das Argument mode (Zeichenkette) steuert den Zugriff auf die Datei. Mit `"w"' wird die Datei zum Schreiben geöffnet, mit `"a"' zum Anfügen an die bestehende Datei und mit `"r"' zum Lesen aus einer Datei. Es sind auch andere Zeichen (oder Kombinationen von ihnen) möglich, wie z.B. `"r+"' zum Lesen und Schreiben. Es gibt keine Überprüfung, ob die angegebenen Modi gültig sind. Es wird jedoch NIL zurückgeliefert, wenn die Datei nicht geöffnet werden konnte.

Der optionale Parameter encoding gibt die Textkodierung der Datei an und kann eine der folgenden Zeichenketten sein:

`"none"':

Keine Interpretation von Zeichen wird vorgenommen. Dies ist für Binärdateien.

`"UTF-8"':

Text ist in UTF-8 kodiert. Lesen und Schreiben wandelt von/in UTF-8 um.

`"locale"':

Text ist in der Systemlokalisierung kodiert. Auf Windows is dies die System-Codepage. Unter Mac OS und Linux ist dies die Einstellung in den LANG- und LC_*-Umgebungsvariablen (siehe man locale). Beim Amiga ist es die voreingestellte 8-Bit-Kodierung.

`"8-bit"':

Text ist in der voreingestellten 8-Bit-Kodierung abgelegt. Auf Windows, Mac OS und Linux ist dies die ISO-8859-1-Kodierung (Latin 1). Auf dem Amiga ist es die im System voreingestellte 8-Bit-Kodierung (gleich wie `locale').

`"auto"':

Die Kodierung wird automatisch ermittelt. Ist die Datei lesbar, so wird die Kodierung wie folgt ermittelt: Ist der gesamte Inhalt UTF-8 konform, so wird `"UTF-8"' verwendet. Sonst, wenn die Systemlokalisierung nicht UTF-8 ist, so wird `"locale"' angenommen. Ansonsten wird `"8-bit"' verwendet. Beim Schreiben wird, sofern die Kodierung noch nicht festgelegt wurde, zuerst versucht in der Systemlokalisierung zu schreiben. Sofern es keine Umwandlungsfehler gab, wird `"locale"' verwendet, ansonsten wird `"UTF-8"' verwendet.

Wird kein encoding-Parameter angegeben, so wird `"auto"' verwendet.

FOPEN liefert bei Erfolg einen Dateihandler. Schlug er fehl, wird NIL geliefert. Sind filename, mode oder encoding NIL, dann wird NIL zurückgeliefert.

Beispiele

`(FOPEN "index.html" "w" "utf-8")' öffnet und liefert einen Dateihandler zum Schreiben der Datei `index.html', welche in UTF-8 kodiert wird.

`(FOPEN "output.txt" "a+")' öffnet die Datei `output.txt' zum Anhängen und verwendet die in der Datei bereits vorhandene Textkodierung. Zu beachten ist, dass wenn nur `"a"' als Mode verwendet wird, BeeBase die Datei möglicherweise nicht lesen kann und von daher die vorhandene Textkodierung nicht bestimmen kann. In diesem Fall wird die Kodierung beim Schreiben festgelegt (und ist möglicherweise eine andere als die bereits bestehende).

Siehe auch FCLOSE, stdout, FFLUSH.

16.17.2 FCLOSE

FCLOSE schließt eine Datei.

(FCLOSE file)

Schließt die gegebene Datei und liefert 0 bei Erfolg oder NIL, wenn ein Fehler auftrat. Ist file NIL, dann wird 0 geliefert (kein Fehler). Der Zugriff auf eine Datei nach dem Schließen einer Datei ist eine illegale Operation und führt zum Abbruch der Programmausführung mit einer Fehlermeldung.

Siehe auch FOPEN, FFLUSH.

16.17.3 stdout

Die globale Variable stdout trägt den Dateihandler zur Standardausgabe von BeeBase. Der Ausgabedateinamen kann im Menüpunkt `Programm - Ausgabedatei' gesetzt werden (siehe Programm-Ausgabedatei).

Die Datei wird beim ersten Zugriff auf diese Variable (z.B. durch den Aufruf von `(FPRINTF stdout ...)' oder durch den Aufruf von `(PRINTF ...)') geöffnet. Die Datei wird nicht vor der Programmausführung geöffnet. Dies verhindert das Öffnen der Datei, wenn keine Ausgabe erzeugt wird, z.b. wenn nur Berechnungen und Änderungen an einigen Datensätzen durchgeführt werden sollen.

Beim Öffnen der Datei wird als Mode-Parameter entweder `"w"' oder `"a+"' in Abhängigkeit der `Anhängen'-Einstellung in Menüpunkt `Programm - Ausgabedatei' verwendet. Als Kodierung wird `"auto"' eingesetzt.

Wenn BeeBase die Programmausgabedatei nicht öffnen kann, dann wird die Ausführung unterbruchen und eine Fehlermeldung ausgegeben.

Siehe auch FOPEN, PRINTF.

16.17.4 PRINT

PRINT wandelt einen Ausdruck in eine Zeichenkette und gibt ihn aus.

(PRINT elem)

Wandelt den Wert von elem in eine lesbare Zeichenkette und gibt ihn über stdout aus. Diese Funktion ist hauptsächlich zu Prüfzwecken vorhanden und wird nicht als eine Funktion mit Seiteneffekt betrachtet, so dass sie z.B. in einer Vergleichsfunktion eingesetzt werden kann.

Siehe auch PRINTF, stdout, Vergleichsfunktion.

16.17.5 PRINTF

PRINTF gibt eine formatierte Zeichenkette aus.

(PRINTF format [expr ...])

Formatiert eine Zeichenkette aus der gegebenen Formatzeichenkette und seinen Parameter und gibt sie an stdout aus. Die Formatierung entspricht der von SPRINTF (siehe SPRINTF).

PRINTF liefert die Anzahl der ausgegebenen Zeichen oder NIL bei einem Fehler. Ist format NIL, dann wird NIL geliefert.

Diese Funktion wird nicht als eine Funktion mit Seiteneffekt betrachtet, so dass sie z.B. zu Prüfzwecken in einer Vergleichsfunktion eingesetzt werden kann.

Beispiel: `(PRINTF "%i Tage und %i Woche" 7 1)' gibt die Zeichenkette "7 Tage und 1 Woche" nach stdout aus und liefert 18.

Siehe auch PRINT, FPRINTF, stdout, Vergleichsfunktion.

16.17.6 FPRINTF

FPRINTF gibt eine formatierte Zeichenkette in eine Datei aus.

(FPRINTF file format [expr ...])

Formatiert eine Zeichenkette aus der gegebenen Formatzeichenkette und seinen Parameter und gibt sie in die angegebene Datei aus. Die Formatierung entspricht der von SPRINTF (siehe SPRINTF).

PRINTF liefert die Anzahl der ausgegebenen Zeichen oder NIL bei einem Fehler. Ist file NIL, dann liefert FPRINTF dennoch die Anzahl der potentiell geschriebenen Zeichen zurück, macht aber keine Ausgabe. Ist format NIL, dann wird NIL geliefert.

Siehe auch PRINTF, FOPEN.

16.17.7 FERROR

FERROR prüft, on ein Ein-/Ausgabefehler einer Datei aufgetreten ist.

(FERROR file)

liefert TRUE, wenn ein Fehler bei der gegebenen Datei auftrat, anderenfalls NIL. Ist `file' NIL, wird NIL geliefert.

Siehe auch FEOF, FOPEN, FCLOSE.

16.17.8 FEOF

FEOF prüft auf den Endestatus einer Datei.

(FEOF file)

Überprüft den Dateende-Indikator der gegebenen Datei und liefert TRUE, wenn er gesetzt ist, anderenfalls NIL. Ist `file' NIL, wird NIL geliefert.

Siehe auch FERROR, FTELL, FOPEN, FCLOSE.

16.17.9 FSEEK

FSEEK setzt die Schreib-/Leseposition in einer Datei.

(FSEEK file offset whence)

Setzt die Schreib-/Leseposition für die gegebene Datei. Die neue Position -gemessen in Bytes- wird erreicht durch das Hinzufügen von offset bytes bezogen auf die Position, die durch whence festgelegt wird. Ist whence auf SEEK_SET, SEEK_CUR oder SEEK_END gesetzt, dann ist offset relativ zum Beginn der Datei, der aktuellen Position beziehungsweise zum Ende der Datei.

Bei Erfolg liefert FSEEK 0, anderenfalls NIL und die Dateiposition bleibt unverändert. Ist file, offset oder whence NIL, oder ist whence nicht eine der Konstanten SEEK_SET, SEEK_CUR oder SEEK_END, dann wird NIL geliefert.

Zu beachten ist, dass nach einer Lese-Operation, der Aufruf von FSEEK mit whence als SEEK_CUR nur für die Zeichenkodierung `"none"' unterstützt wird.

Siehe auch FTELL, FOPEN, Vordefinierte Konstanten.

16.17.10 FTELL

FTELL liefert die Schreib-/Leseposition der Datei.

(FTELL file)

Ermittelt die aktuelle Schreib-/Leseposition relativ zum Anfang der gegebenen Datei und liefert sie als Ganzzahl. Tritt ein Fehler auf oder ist `file' NIL, dann wird NIL geliefert.

Zu beachten ist, dass nach einer Lese-Operation, der Aufruf von FTELL nur für die Zeichenkodierung `"none"' unterstützt wird.

Siehe auch FSEEK, FOPEN, FEOF.

16.17.11 FGETCHAR

FGETCHAR liest ein Zeichen aus einer Datei.

(FGETCHAR file)

Liefert das nächste Zeichen von der gegebenen Datei als Zeichenkette oder NIL, wenn file NIL ist, das Ende der Datei erreicht wurde oder ein Fehler auftrat. Ist das nächste Zeichen ein Nullbyte, dann wird eine leere Zeichenkette geliefert.

Siehe auch FGETCHARS, FGETSTR, FPUTCHAR.

16.17.12 FGETCHARS

FGETCHARS liest Zeichen aus einer Datei.

(FGETCHARS num file)

liefert eine Zeichenkette, die die nächsten num Zeichen aus der gegebenen Datei enthält. Ist das Ende der Datei erreicht worden, bevor num Zeichen gelesen werden konnten, oder wenn ein Nullbyte gelesen wurde, dann werden nur die bisher gelesenen Zeichen zurückgegeben. Ist num oder file NIL, num negativ, das Ende der Datei erreicht worden, bevor das erste Zeichen gelesen wurde, oder ein Lesefehler aufgetreten, dann wird NIL zurückgeliefert.

Siehe auch FGETCHAR, FGETSTR.

16.17.13 FGETSTR

FGETSTR liest eine Zeichenkette aus einer Datei.

(FGETSTR file)

liefert die nächste Zeile aus der gegebenen Datei oder NIL, falls file NIL ist, das Ende der Datei erreicht wurde oder ein Fehler auftrat. Das Ende einer Zeile wird entweder durch ein Neue-Zeile-Zeichen oder durch ein Nullbyte gekennzeichnet oder falls das Ende der Datei erkannt wurde. In jedem Fall enthält die Zeichenkette keine Neue-Zeile-Zeichen.

Siehe auch FGETCHAR, FGETCHARS, FGETMEMO, FPUTSTR.

16.17.14 FGETMEMO

FGETMEMO liest einen mehrzeiligen Text aus einer Datei.

(FGETMEMO file)

liefert einen mehrzeiligen Text, der den Inhalt der gegebenen Datei bis zum nächsten Nullbyte oder zum Ende der Datei enthält. Ist file NIL, das Ende der Datei erreicht worden, bevor ein Zeichen gelesen wurde oder trat ein Fehler auf, dann wird NIL zurückgeliefert.

Siehe auch FGETSTR, FPUTMEMO.

16.17.15 FPUTCHAR

FPUTCHAR schreibt ein Zeichen in eine Datei.

(FPUTCHAR str file)

Schreibt das erste Zeichen von str in die gegebene Datei. Ist str leer, dann wird ein Nullbyte geschrieben. Sind str

file NIL, dann passiert nichts. Liefert str oder NIL, wenn ein Ausgabefehler auftrat.

Siehe auch FPUTSTR, FGETCHAR.

16.17.16 FPUTSTR

FPUTSTR schreibt eine Zeichenkette in eine Datei.

(FPUTSTR str file)

Gibt str zusammen mit einem Neue-Zeile-Zeichen in die gegebene Datei aus. Sind str oder file NIL, dann passiert nichts. Liefert str oder NIL, wenn ein Ausgabefehler auftrat.

Siehe auch FPUTCHAR, FPUTMEMO, FGETSTR.

16.17.17 FPUTMEMO

FPUTMEMO schreibt einen mehrzeiligen Text in eine Datei.

(FPUTMEMO memo file)

Gibt memo in die gegebene Datei aus. Sind memo oder file NIL, dann passiert nichts. Liefert memo oder NIL, wenn ein Ausgabefehler auftrat.

Siehe auch FPUTSTR, FGETMEMO.

16.17.18 FFLUSH

FFLUSH leert den Schreibpuffer in eine Datei.

(FFLUSH file)

Schreibt den Schreibpuffer der gegebenen Datei. Liefert 0 bei Erfolg, NIL bei einem Fehler. Ist file NIL, dann wird 0 zurückgegeben (kein Fehler).

Siehe auch FOPEN, FCLOSE.

16.18 Datensatzfunktionen

Dieser Abschnitt behandelt Funktionen für Datensätze.

16.18.1 NEW

NEW legt einen neuen Datensatz für eine Tabelle an.

(NEW table init)

Legt einen neuen Datensatz für die gegebene Tabelle an. Das Argument init legt den Datensatz fest, der zum Einrichten des neuen Datensatzes verwendet werden soll. Ein Wert von NIL steht für den Vorgabedatensatz.

NEW liefert den Datensatzzeiger für den neuen Datensatz.

Die Funktion NEW hat zudem den Nebeneffekt, dass der Programm-Datensatzzeiger der gegebenen Tabelle (siehe Tabellen) auf den neuen Datensatz gesetzt wird.

Beispiel: `(NEW table NIL)' legt einen neuen Datensatz in der gegebenen Tabelle an und richtet ihn mit dem Vorgabedatensatz ein.

Siehe auch NEW*, DELETE, Tabellen.

16.18.2 NEW*

NEW* ist die Version von NEW (siehe NEW) mit dem Stern.

(NEW* table init)

NEW* prüft, ob eine Auslösefunktion für die gegebene Tabelle (siehe Auslösefunktion Neu) definiert wurde. Ist eine vorhanden, dann wird diese zum Anlegen des Datensatzes ausgeführt und dessen Ergebnis zurückgeliefert. Das Argument init gibt den Datensatz an, anhand dessen der neue Datensatz initialisiert werden soll (NIL für den Vorgabedatensatz).

Wurde keine Auslösefunktion eingerichtet, dann verhält sich die Funktion wie NEW.

Achtung: Mit dieser Funktion ist es möglich, Endlosschleifen zu schreiben, wenn z.B. für eine Tabelle eine Auslösefunktion für `New' definiert wurde und diese Funktion NEW* aufruft, um den Datensatz anzulegen.

Siehe auch NEW, DELETE*.

16.18.3 DELETE

DELETE löscht einen Datensatz einer Tabelle.

(DELETE table confirm)

Löscht den aktuellen Programm-Datensatz der gegebenen Tabelle, nachdem ein optionales Löschfenster bestätigt wurde. Das erste Argument definiert die Tabelle, für die der aktuelle Programm-Datensatz gelöscht werden soll und das zweite ist ein Boolescher Ausdruck. Ist dieser NIL, dann wird der Datensatz stillschweigend gelöscht, anderenfalls wird der Status des Menüpunkts `Datensätze löschen bestätigen?' geprüft. Ist dieser nicht gesetzt, dann wird der Datensatz auch stillschweigend gelöscht, anderenfalls erscheint das Löschbestätigungsfenster, das bestätigt werden muss. Bricht der Benutzer die Löschfunktion ab, dann wird der Datensatz nicht gelöscht.

Der Rückgabewert der Funkion DELETE wiederspiegelt die ausgewählte Aktion. Liefert sie TRUE, dann ist der Datensatz gelöscht worden, anderenfalls NIL (wenn der Benutzer die Funktion unterbrochen hat).

Beim Löschen setzt DELETE den Programm-Datensatzzeiger (siehe Tabellen) der gegebenen Tabelle auf NIL.

Beispiel: `(DELETE table NIL)' löscht stillschweigend den aktuellen Datensatz der gegebenen Tabelle.

Siehe auch DELETE*, DELETEALL, NEW, Tabellen.

16.18.4 DELETE*

DELETE* ist die Version von DELETE (siehe DELETE) mit dem Stern.

(DELETE* table confirm)

DELETE* prüft, ob eine Auslösefunktion für die gegebene Tabelle (siehe Auslösefunktion Löschen) definiert wurde. Ist eine vorhanden, dann wird diese zum Löschen des Datensatzes ausgeführt und dessen Ergebnis zurückgeliefert. Das Argument confirm gibt an, ob die Auslösefunktion ein Bestätigungsfenster öffnen soll, bevor der Datensatz gelöscht wird.

Wurde keine Auslösefunktion eingerichtet, dann verhält sich die Funktion wie DELETE.

Achtung: Mit dieser Funktion ist es möglich, Endlosschleifen zu schreiben, wenn z.B. für eine Tabelle eine Auslösefunktion für `Delete' definiert wurde und diese Funktion DELETE* aufruft, um den Datensatz zu löschen.

Siehe auch DELETE, DELETEALL, NEW*.

16.18.5 DELETEALL

DELETEALL löscht alle Datensätze einer Tabelle.

(DELETEALL table[*])

Löscht alle Datensätze der gegebenen Tabelle. Wird ein Stern hinter dem Tabellennamen angehängt, dann werden nur die Datensätze gelöscht, die dem aktuellen Filter der Tabelle genügen. Es erscheint kein Sicherheitsfenster, bevor dir Datensätze gelöscht werden!

DELETEALL liefert TRUE, wenn alle Datensätze erfolgreich gelöscht werden konnten, anderenfalls NIL. Ist table NIL, dann wird NIL geliefert.

Beispiel: `(DELETEALL table*)' löscht alle Datensätze in der gegebenen Tabelle, die dem Filter der Tabelle genügen.

Siehe auch DELETE, Tabellen.

16.18.6 GETMATCHFILTER

GETMATCHFILTER liefert den Status der Filterübereinstimmung eines Datensatzes.

(GETMATCHFILTER rec)

Liefert TRUE, wenn der gegebene Datensatz dem Filter seiner Tabelle entspricht, anderenfalls NIL. Ist der Filter der Tabelle momentan nicht aktiviert, dann wird TRUE geliefert. Ist rec NIL (der Vorgabedatensatz), dann wird NIL geliefert.

Siehe auch SETMATCHFILTER, GETISSORTED, GETFILTERSTR, SETFILTERSTR.

16.18.7 SETMATCHFILTER

SETMATCHFILTER setzt den Status der Filterübereinstimmung eines Datensatzes.

(SETMATCHFILTER rec on)

Ändert den Status der Filterübereinstimmung beim gegebenen Datensatz auf den Wert von on. SETMATCHFILTER liefert den neuen Status der Filterübereinstimmung des gegebenen Datensatzes. Der neue Status kann vom erwarteten abweichen, weil das Setzen auf NIL nur dann wirksam ist, wenn der Filter der dazugehörigen Tabelle aktiviert ist, anderenfalls wird TRUE geliefert. Der Aufruf von SETMATCHFILTER mit dem Wert NIL für rec (der Vorgabedatensatz) liefert immer NIL.

Siehe auch GETMATCHFILTER, SETISSORTED, GETFILTERSTR, SETFILTERSTR.

16.18.8 GETISSORTED

GETISSORTED liefert den Sortierstatus eines Datensatzes.

(GETISSORTED rec)

Liefert TRUE, wenn der gegebene Datensatz nach der für die Tabelle definierten Reihenfolge sortiert ist, ansonsten NIL. Ist rec NIL, dann wird NIL geliefert.

Siehe auch SETISSORTED, GETMATCHFILTER, REORDER, GETORDERSTR, SETORDERSTR, Vergleichsfunktion.

16.18.9 SETISSORTED

SETISSORTED setzt den Sortierstatus eines Datensatzes.

(SETISSORTED rec on)

Ändert den Sortierstatus des angegebenen Datensaztes auf on. Die Funktion wird verwendet, wenn man der Meinung ist, dass der Datensatz in der richtigen Reihenfolge steht (on = TRUE) oder er neu sortiert werden sollte (on = NIL). Neusortieren aller unsortierten Datensätze kann mit der Funktion REORDER (siehe REORDER) durchgeführt werden.

SETISSORTED liefert den neuen Sortierstatus des gegebenen Datensatzes. Der Aufruf von SETISSORTED mit dem Wert NIL für rec (der Anfangsdatensatz) wird NIL liefern.

Für ein Beispiel, wie diese Funktion angewendet wird, siehe Vergleichsfunktion.

Siehe auch GETISSORTED, SETMATCHFILTER, REORDER, GETORDERSTR, SETORDERSTR, Vergleichsfunktion.

16.18.10 GETREC

GETREC liefert die Datensatzreferenz eines Ausdrucks.

(GETREC expr)

Liefert den Datensatz, welcher für die Erstellung von expr verwendet wurde. Ausdrücke, welche von einem Feld einer Tabelle stammen, haben den Datensatz aus dem sie generiert wurden als Datensatzreferenz.

Falls expr eine Liste ist und nicht selbst eine Datensatzreferenz hat, dann liefert GETREC den Datensatz des ersten Listenelements, welches eine Datensatzreferenz hat. GETREC untersucht aber keine Unterlisten.

Falls keine Datensatzreferenz gefunden wurde, dann liefert GETREC NIL zurück.

Die Eigenschaft Element einer Liste zu untersuchen ist nützlich, um die Datensatzreferenz einer Zeile in einer Select-from-where-Abfrage zu bestimmen. Z.B. liefert das folgende Programmfragment den Datensatz, welcher zur Erstellung der 7. Zeile in einer Select-from-where-Abfrage benutzt wurde.

(GETREC (NTH 7 (SELECT field FROM table)))

Diese Funktion ist nützlich in einer Auslösefunktion für das Sortieren-Drop in einer virtuellen Liste, siehe Auslösefunktion Sortieren-Drop.

Siehe auch SETREC, RECORD, Auslösefunktion Sortieren-Drop.

16.18.11 SETREC

SETREC setzt die Datensatzreferenz eines Ausdrucks.

(SETREC expr record)

Liefert expr mit einer Datensatzreferenz zu record zurück.

SETREC ist nützlich, wenn ein Ausdruck mit einem bestimmten Datensatz assoziiert werde soll, z.B. beim Berechnen von Informationen, die von einem Feld in einer Tabelle abstammen. Zum Beispiel kann in einer Tabelle `Person' mit einem Booleschen Feld `Female' eine Select-from-where-Abfrage das Feld `Female' auf die Zeichenketten "F" und "M" umlegen:

SELECT (SETREC (IF Female "F" "M") Person) FROM Person

Mit dem SETREC-Befehl werden "F" und "M" jetzt mit dem Datensatz, aus dem diese generiert wurden assoziiert, was z.B. in einem virtuellen Listenfeld, welches dies Abfrage verwendet, ermöglicht, das Öffnen des zugehörigen Datensatz per Doppelklick zu unterstützen (siehe Feldobjekteditor) .

Siehe auch GETREC.

16.18.12 RECNUM

RECNUM liefert die Datensatznummer des Datensatzes.

(RECNUM record)

Liefert die Datensatznummer des gegebenen Datensatzes. Man beachte, dass die Nummerierung der Datensätze von z.B. der der Listen abweicht. Bei Listen, Zeicheketten und anderem beginnt die Zählung bei Null, bei den Datensätzen beginnt sie jedoch bei 1. Die Nummer 0 ist für den Vorgabedatensatz reserviert. Dies scheint mit den restlichen BeeBase-Funktionen unvereinbar zu sein, aber hier macht es wirklich Sinn, da die Datensatznummern auch in der Fensteranzeige verwendet werden.

Siehe auch RECORDS, MOVEREC, INT.

16.18.13 MOVEREC

MOVEREC schiebt einen Datensatz an eine neue Position.

(MOVEREC record pos)

Verschiebt den gegebenen Datensatz an die gegebene Position in the Tabelle, so dass die Datensatznummer zu pos wird. Man beachte, dass Datensatznummern mit 1 für die erste Position beginnen. Liefert die neue Datensatznummer zurück oder NIL, falls das Verschieben des Datensatzes fehlschlägt, z.B. wenn pos nicht zwischen 1 und der Anzahl Datensätze in the Tabelle liegt.

Falls der Datensatz verschoben wurde, dann wird auch der Sortierstatus des Datensatzes gelöscht. Zu beachten ist, dass wenn eine Tabelle eine definierte Ordnung hat, das Neuordnen aller Datensätze den Datensatz wieder an seinen Platz verschiebt. Von daher ist diese Funktion hauptsächlich nützlich in Tabellen, die keine definierte Ordnung haben.

Diese Funktion ist nützlich in einer Auslösefunktion für das Sortieren-Drop in einer virtuellen Liste, siehe Auslösefunktion Sortieren-Drop.

Siehe auch RECNUM, GETISSORTED, Auslösefunktion Sortieren-Drop.

16.18.14 COPYREC

COPYREC kopiert Datensätze.

(COPYREC rec source)

Kopiert den Inhalt des Datensatzes source in den Datensatz rec. Ist source NIL, dann wird rec auf die Werte des Vorgabedatensatzes gesetzt. Ist rec NIL, dann wird eine Fehlermeldung erzeugt.

COPYREC liefert rec.

Siehe auch NEW.

16.19 Feldfunktionen

Dieser Abschnitt behandelt Funktionen für Felder einer Tabelle.

16.19.1 FIELDNAME

FIELDNAME liefert den Namen des Feldes.

(FIELDNAME field)

Liefert eine Zeichenkette mit dem Namen des angegebenen Feldes.

Siehe auch TABLENAME

16.19.2 MAXLEN

MAXLEN liefert die maximale Anzahl von Zeichen eines Zeichenkettenfeldes.

(MAXLEN string-field)

Liefert die maximale Anzahl von Zeichen, die das gegebene Zeichenkettenfeld aufnehmen kann.

Siehe auch LEN.

16.19.3 GETLABELS

GETLABELS liefert alle Auswahltexte eines Auswahl- oder Zeichenkettenfeldes.

(GETLABELS field)

Liefert die Auswahltexte des gegebenenen Auswahl- oder Zeichenkettenfeldes. Im Falle eines Auswahlfeldes werden die im Auswahltexteditor (siehe Typabhängige Einstellungen) eingegebenen Texte zurückgegeben, Bei Zeichenkettenfeldern werden die statischen Auswahltexte zurückgegebene, die für das Listenansicht-Popup (siehe Feldobjekteditor) eingegeben wurden (zu beachten ist, dass diese Funktion nur für statische Auswahltexte sinnvoll ist).

Die Auswahltexte werden in einer einzelnen Zeichenkette zurückgegeben und werden jeweils durch ein Neue-Zeile-Zeichen getrennt.

Beispiel: Man nehme an, man hat ein Auswahlfeld mit den Auswahltexten `Auto', `Haus' und `Öl'. Der Aufruf von GETLABELS mit diesem Feld liefert dann die Zeichenkette "Auto\nHaus\nÖl".

Hinweis: Diese Rückgabezeichenkette lässt sich einfach mit MEMOTOLIST (siehe MEMOTOLIST) in eine Liste umwandeln.

Siehe auch SETLABELS.

16.19.4 SETLABELS

SETLABELS wird verwendet, um die Auswahltexte eines Zeichenkettenfeldes zu setzen.

(SETLABELS field str)

Setzt die statischen Auswahltexte des Zeichenkettenfeldes field auf die Auswahlfelder, die im Parameter str aufgelistet sind. Der Parameter str enthält für jeden Auswahltext eine Zeile. Die Auswahltexte ersetzen diejenigen, die in dem Listenansicht-Popup des Feldobjekteditors (siehe Feldobjekteditor) eingegeben wurden. Zu beachten ist, dass diese Funktion nur für statische Auswahltexte sinnvoll ist.

SETLABELS liefert den Wert des Parameters str.

Beispiel: `(SETLABELS Table.String "Mein Haus\nist\ndein Haus")' setzt die statischen Listenansicht-Auswahltexte des gegebenen Zeichenkettenfeldes auf `Mein Haus', `ist' und `dein Haus'.

Hinweis: Man kann eine Liste von Auswahltexte durch den Aufruf von LISTTOMEMO in das benötigte Zeichenkettenformat umwandeln.

Siehe auch GETLABELS.

16.20 Tabellenfunktionen

16.20.1 TABLENAME

TABLENAME liefert den Namen einer Tabelle.

(TABLENAME table)

Liefert eine Zeichenkette, die den Namen der angegebenen Tabelle enthält.

Siehe auch FIELDNAME

16.20.2 GETORDERSTR

GETORDERSTR liefert die Datensatzreihenfolge einer Tabelle.

(GETORDERSTR table)

Verwendet die Tabelle eine Felderliste zum Sortieren, dann enthält die gelieferte Zeichenkette die Feldnamen, getrennt durch Leerzeichen. Jedes Feld hat ein `+' oder ein `-' vorangestellt, um eine auf- bzw. absteigende Sortierung anzuzeigen.

Wird die Tabelle anhand einer Vergleichsfunktion sortiert, dann wird der Name dieser Funktion geliefert.

Eine leere Zeichenkette zeigt an, dass keine Sortierung vorliegt.

Beispiel

Angenommen, es gibt eine Tabelle `Person', die nach ihren Feldern `Name' (aufsteigend), `Stadt' (aufsteigend) und `Geburtstag' (absteigend) sortiert ist. Dann liefert `(ORDERSTR Person)' die Zeichenkette "+Name +Stadt -Geburtstag".

Siehe auch SETORDERSTR, REORDER, REORDERALL, GETISSORTED, SETISSORTED, Order, Vergleichsfunktion.

16.20.3 SETORDERSTR

SETORDERSTR setzt die Sortierreihenfolge einer Tabelle.

(SETORDERSTR table order)

Setzt die Sortierreihenfolge der gegebenen Tabelle auf die Felder in der Zeichenkette order. Die Zeichenkette order kann entweder eine Liste von Feldnamen enthalten oder den Namen der Vergleichsfunktion.

Zum Sortieren einer Feldliste muss die Zeichenkette order die Feldnamen für die Sortierung enthalten, die durch eine beliebige Anzahl von Leerzeichen, Tabulatoren oder Neue-Zeile-Zeichen getrennt sind. Jedem Feldnamen kann ein `+' oder ein `-' für auf- bzw. absteigende Sortierung vorangestellt werden. Wird dieses Zeichen weggelassen, dann wird aufsteigende Sortierung angenommen.

Zum Sortieren anhand einer Vergleichsfunktion muss die Zeichenkette order den Namen der Funktion tragen.

SETORDERSTR liefert TRUE, wenn es möglich war, die neue Sortierung zu setzen, anderenfalls NIL, wenn z.B. ein unbekanntes Feld angegeben wurde oder das Typ des Feldes für die Sortierung nicht erlaubt ist. Wird NIL für order angegeben, dann passiert nichts und es wird NIL zurückgeliefert.

Hinweis: Zum Erzeugen der Sortierzeichenkette sollten man nicht direkt den Feldnamen in die Zeichenkette einfügen, weil bei einer Änderung des Feldnamens der Name in der Zeichenkette nicht mit verändert wird. Besser ist es, die Funktion FIELDNAME (siehe FIELDNAME) zu verwenden und dessen Ergebnis in die Sortierzeichenkette zu kopieren.

Beispiel

Man betrachte eine Tabelle `Person' mit den Feldern `Name', `Stadt' und `Geburtstag'. `(SETORDERSTR Person (SPRINTF "+%s" (FIELDNAME Person.Name)))' setzt dann die Sortierreihenfolge der Tabelle `Person' auf `Name' als (aufsteigendes) Sortierfeld.

Siehe auch GETORDERSTR, REORDER, REORDERALL, GETISSORTED, SETISSORTED, Order, Vergleichsfunktion.

16.20.4 REORDER

REORDER bringt alle unsortierten Datensätze zurück in die richtige Reihenfolge.

(REORDER table)

Untersucht alle Datensätze der gegebenen Tabelle nach unsortierten Datensätzen und fügt diese in ihrer korrekten Position ein. Nach dem Einfügen eines unsortierten Datensatzes wird der Sortierstatus des Datensatzes auf TRUE gesetzt, so dass bei nach Beendigung der Funktion REORDER der Sortierstatus aller Datensätze auf TRUE steht.

REORDER liefert NIL.

Normalerweise wird diese Funktion nur dann aufgerufen, wenn eine Vergleichsfunktion für die Sortierung der Tabelle definiert wurde. Sortierungen anhand einer Felderliste sind automatisch, das bedeutet, dass ein Datensatz automatisch sortiert wird, wenn er benötigt wird.

Für einen Anwendungsfall zur Anwendung dieser Funktion siehe Vergleichsfunktion.

Siehe auch REORDERALL, GETORDERSTR, SETORDERSTR, GETISSORTED, SETISSORTED, Order, Vergleichsfunktion.

16.20.5 REORDERALL

REORDERALL sortiert alle Datensätze einer Tabelle neu.

(REORDERALL table)

Sortiert alle Datensätze der gegebenen Tabelle neu, indem der Sortierstatus aller Datensätze auf NIL gesetzt und dann REORDER zum kompletten Neusortieren aufgerufen wird.

REORDERALL liefert NIL.

Siehe auch REORDER, GETORDERSTR, SETORDERSTR, GETISSORTED, SETISSORTED, Sortieren, Vergleichsfunktion.

16.20.6 GETFILTERACTIVE

GETFILTERACTIVE liefert den Filterstatus einer Tabelle.

(GETFILTERACTIVE table)

Liefert TRUE, wenn der Filter gegebenen Tabelle momentan aktiviert ist, anderenfalls NIL.

Siehe auch SETFILTERACTIVE, GETFILTERSTR, GETMATCHFILTER.

16.20.7 SETFILTERACTIVE

SETFILTERACTIVE setzt den Filterstatus einer Tabelle.

(SETFILTERACTIVE table bool)

Setzt den Filterstatus der gegebenen Tabelle. Ist bool nicht NIL, dann wird er Filter aktiviert, anderenfalls deaktiviert.

SETFILTERACTIVE liefert den neuen Status des Filters. Der neue Status muss nicht dem erwarteten entsprechen, falls beim Aktivieren des Filters ein Fehler auftrat und der Filter deshalb nicht aktiviert werden konnte. Deaktivieren des Filters gelingt jedoch immer.

Siehe auch GETFILTERACTIVE, SETFILTERSTR, SETMATCHFILTER.

16.20.8 GETFILTERSTR

GETFILTERSTR liefert den Datensatzfilterausdruck einer Tabelle.

(GETFILTERSTR table)

Liefert den Datensatzfilterausdruck der gegebenen Tabelle als Zeichenkette. Eine leere Zeichenkette bedeutet, dass kein Filterausdruck für diese Tabelle gesetzt wurde.

Siehe auch SETFILTERSTR, GETFILTERACTIVE, GETMATCHFILTER.

16.20.9 SETFILTERSTR

SETFILTERSTR setzt den Datensatzfilterausdruck einer Tabelle.

(SETFILTERSTR table filter-str)

Setzt den Datensatzfilterausdruck der gegebenen Tabelle auf den Ausdruck im Parameter filter-str (hierbei wird der Ausdruck als Zeichenkette angegeben, also nicht der Ausdruck selbst!). Ist der Filter der gegebenen Tabelle momentan aktiviert, dann wird der neue Filterausdruck sofort auf alle Datensätze angewendet und der Status der Filterübereinstimmung aller Datensätze neu berechnet.

SETFILTERSTR liefert TRUE, wenn es möglich war, den gegebenen Filterzeichenkettenausdruck zu kompilieren, anderenfalls wird NIL geliefert. Man beachte, dass man nur das Ergebnis der Kompilierung erhält. Ist der Filter der gegebenen Tabelle momentan aktiviert und das Neuberechnen aller Stati der Filterübereinstimmungen fehlschlägt, dann wird man nicht über das Ergebnis dieser Funktion informiert. Daher ist der empfohlene Weg, einen neuen Filterausdruck zu setzen, folgender:

(SETFILTERACTIVE Table NIL)               ; gelingt immer.
(IF (NOT (SETFILTERSTR Table filter-string))
    (ERROR "Kann den Filter für %s nicht setzen!" (TABLENAME Table))
)
(IF (NOT (SETFILTERACTIVE Table TRUE))
    (ERROR "Kann den Filter für %s nicht aktivieren!" (TABLENAME Table))
)

Wird SETFILTERSTR mit dem Wert NIL für den Parameter filter-str aufgerufen, dann passiert nichts und NIL wird zurückgeliefert.

Beispiel: `(SETFILTERSTR Table "(> Wert 0.0)")'.

Siehe auch GETFILTERSTR, SETFILTERACTIVE, SETMATCHFILTER.

16.20.10 RECORDS

RECORDS liefert die Anzahl der Datensätze in einer Tabelle.

(RECORDS table)

Liefert die Anzahl der Datensätze in der gegebenen Tabelle. Man kann einen Stern zum Tabellennamen hinzufügen, um die Anzahl der Datensätze zu ermitteln, die dem Filter der Tabelle genügen.

Siehe auch RECORD, RECNUM.

16.20.11 RECORD

RECORD liefert einen Datensatzzeiger für eine gegebene Datensatznummer.

(RECORD table num)

Liefert den Datensatzzeiger des num-ten Datensatzes in der gegebenen Tabelle oder NIL, wenn ein Datensatz mit dieser Nummer nicht existiert. Man kann einen Stern zum Tabellennamen hinzufügen, um den num-ten Datensatz zu erhalten, der dem Datensatzfilter genügt.

Es ist darauf zu achten, dass Datensatznummern bei 1 beginnen und die Datensatznummer 0 für den Vorgabedatensatz verwendet wird.

Siehe auch RECORDS, RECNUM.

16.20.12 SELECT

SELECT ermittelt und liefert diverse Daten von Datensätzen.

(SELECT [DISTINCT] exprlist FROM tablelist
        [WHERE where-expr] [ORDER BY orderlist])

wobei exprlist entweder ein einfacher Stern `*' oder eine Liste von durch Komma getrennten Ausdrücken mit optionalen Titeln ist:

exprlist:     * | expr "Titel", ...

und tablelist eine Liste von Tabellennamen:

tablelist:      table[*] [ident], ...

Für jede Tabelle in der Tabellenliste kann ein Bezeichner (Identifier) angegeben werden. Dies kann nützlich sein, wenn eine Tabelle mehr als einmal in der Tabellenliste vorkommt (siehe unten das Beispiel zum Vergleichen von Altersangaben). Wird ein Stern zum Tabellennamen hinzugefügt, dann werden nur die Datensätze der Tabelle betrachtet, die dem momentanen Filter der Tabelle genügen.

Die Sortierliste hat den folgenden Aufbau:

orderlist:    expr [ASC | DESC], ...

wobei expr, ... beliebige Ausdrücke oder Feldnummern sein können. Zum Beispiel sortiert `(SELECT Name FROM ... ORDER BY 1)' das Ergebnis nach dem Feld `Name'. Man kann zudem ASC oder DESC für eine auf- bzw. absteigende Sortierung angeben. Ist keiner der beiden vorhanden, dann wird aufsteigende Sortierung angenommen.

Funktionsweise

Die SELECT-FROM-WHERE-Abfrage bildet das (mathematische) Kreuzprodukt aller Tabellen in der Tabellenliste (es wertet alle Datensatzmengen in table, ... aus) und prüft den WHERE-Ausdruck (wenn vorhanden). Liefert der WHERE-Ausdruck TRUE (oder es gibt keinen WHERE-Ausdruck), dann wird eine Liste erzeugt, dessen Elemente anhand der Ausdrucksliste im SELECT-Teil berechnet wurden. Wurde ein einzelner Stern in der Ausdrucksliste angegeben, dann enthält die Liste die Werte aller Felder, die zu den Tabellen in der Tabellenliste gehören (hiervon ausgenommen sind die virtuellen Felder und Knöpfe).

Das Ergebnis der Abfrage ist eine Liste von Listen. Der erste Listeneintrag enthält die Titelzeichenketten, die restlichen die Werte der FROM-Liste für die passenden Datensätze.

Beispiele

Siehe Abfragebeispiele für einige Beispiele mit der Funktion SELECT.

Siehe auch FOR ALL.

16.21 Oberflächenfunktionen

Dieser Abschnitt beschreibt die Funktionen zum Verändern von Benutzeroberflächenelementen.

16.21.1 SETCURSOR

SETCURSOR setzt den Cursor auf ein Benutzeroberflächenelement.

(SETCURSOR field-or-table)

Setzt den Cursor auf das gegebene Feld oder Benutzeroberflächenelement der Tabelle. Die Funktion öffnet auch das Fenster, in dem das Feld/die Tabelle eingebettet ist, wenn das Fenster noch geschlossen ist.

SETCURSOR liefert TRUE, wenn kein Fehler auftrat (Fenster konnte geöffnet werden) oder NIL bei einem Fehler.

Siehe auch SETVIRTUALLISTACTIVE.

16.21.2 SETBGPEN

SETBGPEN setzt den Hintergrundstift eines GUI-Elements.