[ << ] | [ >> ] | [Anfang] | [Inhalt] | [Index] | [ ? ] |
Dieses Kapitel (das größte dieser Dokumentation) beschreibt die Programmiersprache von MUIbase, 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.
15.1 Programmeditor Wo ein MUIbase-Programm eingegeben wird. 15.2 Externe Programmquellen Benutzung Ihres Lieblingseditors zum Programmieren. 15.3 Vorverarbeitung Include-Dateien, bedingte Kompilation und Konstanten. 15.4 Programmiersprache Der Aufbau der Ausdrücke.   Funktionen     15.5 Befehle definieren Funktionen- und Variablendefinitionen. 15.6 Programmsteuerungsfunktionen Schleifen, bedingte Ausdrücke und mehr. 15.7 Typaussagen Feststellen des Typs eines Ausdrucks. 15.8 Typumwandlungsfunktionen Typen umwandeln. 15.9 Boolesche Funktionen AND, OR, und NOT. 15.10 Vergleichsfunktionen Werte von Ausdrücken vergleichen. 15.11 Mathematik-Funktionen Addieren, Multiplizieren, etc. 15.12 Zeichenkettenfunktionen Nützliches Zeug für Zeichenketten. 15.13 Funktionen für mehrzeilige Texte Nützliches Zeug für mehrzeilige Texte. 15.14 Datum- und Zeitfunktionen Nützliches Zeug für Datum und Zeit. 15.15 Listenfunktionen Listenverarbeitungsbefehle. 15.16 Benutzereingabefunktionen Den Benutzer nach Eingaben fragen. 15.17 E/A-Funktionen Dateiein- und -ausgabebefehle. 15.18 Datensatzfunktionen Nützliches Zeug für Datensätze. 15.19 Feldfunktionen Verändern von Feldern. 15.20 Tabellenfunktionen Verändern von Tabellen. 15.21 Oberflächenfunktionen Verändern der Benutzeroberfläche. 15.22 Projektfunktionen Informationen über das aktuelle Projekt erhalten. 15.23 Systemfunktionen Betriebssystembezogene Funktionen. 15.24 Variablen Vordefinierte Variablen. 15.25 Konstanten Vordefinierte Werte von Konstanten.   Nützliche Informationen     15.26 Funktionale Parameter Funktionen als Argumente in Funktionsaufrufen verwenden. 15.27 Typdeklarierer Typen für Variablen. 15.28 Aufbau von Ausdrücken Die Bedeutung eines Ausdrucks. 15.29 Auslösefunktionen Wie Auslösefunktionen benutzt werden. 15.30 Liste veralteter Funktionen Funktionen, die entfernt wurden und Ersatz benötigen.   Funktionsverzeichnis Übersicht aller Funktionen.
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:
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.
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
MUIbase' ARexx-Port geschickt werden.
MUIbase 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.
MUIbase-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.
15.3.1 #define Konstanten definieren. 15.3.2 #undef Konstanten un-definieren. 15.3.3 #include Externe Dateien einfügen. 15.3.4 #if Bedingte Kompilation. 15.3.5 #ifdef Bedingte Kompilation. 15.3.6 #ifndef Bedingte Kompilation. 15.3.7 #elif Bedingte Kompilation. 15.3.8 #else Bedingte Kompilation. 15.3.9 #endif Bedingte Kompilation
|
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 |
#define
-Anweisung definiert wurde, um
verschachtelte Definitionen zu ermöglichen.
Es gibt jedoch eine Obergrenze von 16 verschachtelten Definitionen.
Siehe auch #undef, #ifdef, #ifndef.
|
Siehe auch #define, #ifdef, #ifndef.
|
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.
|
#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.
|
#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.
|
#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.
|
#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:
#if
-Anweisung lieferte
NIL, das Symbol name im vorherigen ifdef
war nicht definiert
oder das Symbol name in der vorherigen ifndef
-Anweisung war
definiert.
elif
-Anweisungen lieferten 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.
|
#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.
|
#if
,
#ifdef
oder #ifndef
beginnt. Jeder dieser Anweisungen muss
eine zugehörige #endif
-Anweisung besitzen.
Siehe auch #if, #ifdef, #ifndef, #elif, #else.
MUIbase verwendet eine Programmiersprache mit einen lisp-ähnlichen Aufbau.
Tatsächlich sind einige Konstrukte und Funktionen vom Standard-Lisp entnommen
worden. MUIbase 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
).
15.4.1 Warum Lisp? Die Vorteile von Lisp. 15.4.2 Lisp-Aufbau Aufbau der Programmiersprache. 15.4.3 Programmarten Verschiedene verwendete Arten von Programmen in MUIbase. 15.4.4 Namenskonventionen Namenskonventionen für Programmsymbole. 15.4.5 Datensatzinhalte ansprechen Felder und Tabellen in Programmen verwenden. 15.4.6 Datentypen zum Programmieren Verfügbare Datentypen zum Programmieren. 15.4.7 Konstanten Konstante Ausdrücke. 15.4.8 Befehlsaufbau Aufbau der Beschreibung aller Befehle.
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.
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) |
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.
MUIbase 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 MUIbase-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.
In einem MUIbase-Programm können Symbole, wie Funktionen, lokale und globale Variablen, definiert werden. Die Namen dieser Symbole müssen folgenden Punkten genügen:
Um auf Tabellen und Felder in einem MUIbase-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'.
Die Programmiersprache von MUIbase 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. |
Die Programmiersprache von MUIbase 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. |
Im Rest dieses Kapitels findet man die Beschreibung aller Befehle und Funktionen, die für die Programmierung von MUIbase zur Verfügung stehen. Der folgende Aufbau wird verwendet, um die Befehle zu beschreiben:
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.
Dieser Abschnitt listet Befehle zum Definieren von Funktionen und globalen Variablen auf. Die Befehle sind nur für Projektprogramme verfügbar.
15.5.1 DEFUN Funktionsdefinition. 15.5.2 DEFUN* Funktionsdefinition mit verstecktem Namen. 15.5.3 DEFVAR Variablendefinition. 15.5.4 DEFVAR* Variable, die ihren Wert behält.
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.
|
Der Parameter varlist legt die Parameter der Funktion fest:
varlist: var1 ... |
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))) ) ) |
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.
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.
|
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 MUIbase 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 MUIbase (siehe Vordefinierte Variablen).
Siehe auch DEFVAR*, DEFUN, DEFUN*, LET.
|
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.
Dieser Abschnitt listet Funktionen zur Programmflusskontrolle auf, z.B. Funktionen zum Definieren von lokalen Variablen, Schleifenfunktionen, bedingte Programmausführung, Schleifenkontrollfunktionen und mehr.
15.6.1 PROGN Verbundbefehl, liefert letzten Ausdruck. 15.6.2 PROG1 Verbundbefehl, liefert ersten Ausdruck. 15.6.3 LET Definition lokaler Variablen. 15.6.4 SETQ Setzen von Variablen, Feldern und Tabellen. 15.6.5 SETQ* Setzen von Variablen, Feldern und Tabellen. 15.6.6 FUNCALL Funktionsaufruf mit Argumenten. 15.6.7 APPLY Funktionsanwendung auf Argumentenliste. 15.6.8 IF If-then-else bedingte Programmausführung. 15.6.9 CASE Switch-case bedingte Programmausführung. 15.6.10 COND Leistungsfähige bedingte Programmausführung. 15.6.11 DOTIMES Schleife über einen Bereich von Ganzzahlen. 15.6.12 DOLIST Schleife über eine Liste. 15.6.13 DO Gewöhnliche Schleife. 15.6.14 FOR ALL Schleife über eine Menge von Datensätzen. 15.6.15 NEXT Zur nächsten Schleifenausführung springen. 15.6.16 EXIT Schleife verlassen. 15.6.17 RETURN Rückkehr von einer Funktion. 15.6.18 HALT Programmausführung anhalten. 15.6.19 ERROR Programmausführung mit Fehlermeldung abbrechen.
Um mehrere Ausdrücke der Reihe nach auszuführen,
wird der PROGN
-Aufruf verwendet.
|
(PROGN
[expr ...])
bekannt.
Beispiel: `(1 2 3 4)' liefert 4.
Siehe auch PROG1.
Neben PROGN
gibt es mit PROG1
eine andere Möglichkeit, mehrere
Ausdrücke zu errechnen.
|
Beispiel: `(PROG1 1 2 3 4)' liefert 1.
Siehe auch PROGN.
LET
definiert einen neuen Block von lokalen Variablen.
Dies ist nützlich, um z.B. lokale Variablen einer Funktion zu definieren.
Der Aufbau ist:
|
varlist: varspec ... |
varspec: |
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) ) |
Siehe auch DOTIMES, DOLIST, DO, DEFVAR.
Die Funktion SETQ
setzt Werte in Variablen, Feldern und Tabellen.
|
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.
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.Attr 0)' ruft die Auslösefunktion von `Table.Attr' 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.
FUNCALL
ruft eine Funktion mit Argumenten auf.
|
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.
APPLY
wendet eine Funktion auf eine Argumentenliste an.
|
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.
IF
ist ein Bedingungsoperator.
|
Diese Funktion ist nicht strikt, das bedeutet, dass entweder der eine oder der andere Ausdruck ausgewertet wird.
CASE
ähnelt der switch
-Anweisung in der Sprache C.
|
case: |
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.
COND
ist wie IF
ein Bedingungsoperator.
|
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.
(COND ((> 1 2) "1 > 2") ((= 1 2) "1 = 2") ((< 1 2) "1 < 2") ) |
Für einfache Schleifen kann der Befehl DOTIMES
verwendet werden.
|
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.
(DOTIMES (i 50 i) (PRINT i)) |
Siehe auch DOLIST, DO, FOR ALL, LET.
Für Schleifen über Listen kann der Ausdruck DOLIST
verwendet werden.
|
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.
(DOLIST (i (SELECT * FROM Accounts)) (PRINT i)) |
Siehe auch DOTIMES, DO, FOR ALL, LET.
Mit dem Ausdruck DO
können beliebige Schleifen programmiert werden.
|
(
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.
(DO ((i 0 (+ i 1))) ((>= i 5) i) (PRINT i)) |
DOTIMES
eine einfachere
Version.
Siehe auch DOTIMES, DOLIST, FOR ALL, LET.
Der Ausdruck FOR ALL wird verwendet, um eine Liste von Datensätzen abzuarbeiten.
|
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)) ) |
FOR ALL
liefert NIL.
Siehe auch SELECT, DOTIMES, DOLIST, DO.
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)) ... ) |
EXIT
kann verwendet werden, um eine Schleife zu beenden.
|
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 ...) ...) |
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)) ... ) |
Innerhalb einer Funktionsdefinition kann mit dem Befehl RETURN
zur
aufrufenden Funktion zurückgesprungen werden.
|
(DEFUN find-record (name) (FOR ALL Table DO (IF (= Name name) (RETURN Table)) ) ) |
HALT
kann verwendet werden, um die Programmausführung abzubrechen.
|
Siehe auch ERROR, EXIT, RETURN.
Zum Abbrechen der Programmausführung mit einer Fehlermeldung kann die
Funktion ERROR
verwendet werden.
|
SPRINTF
(siehe SPRINTF)
aus fmt und den optionalen Parametern arg ... erzeugt.
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 |
Dieser Abschnitt listet Funktionen auf, die zum Umwandeln von einem Datentyp in einen anderen verwendet werden.
15.8.1 STR Umwandlung in eine Zeichenkette. 15.8.2 MEMO Umwandlung in einen mehrzeiligen Text. 15.8.3 INT Umwandlung in eine Ganzzahl. 15.8.4 REAL Umwandlung in eine Fließkommazahl. 15.8.5 DATE Umwandlung in ein Datum. 15.8.6 TIME Umwandlung in eine Zeit.
STR
kann verwendet werden, um einen Ausdruck in eine
Zeichenkettendarstellung umzuwandeln.
|
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. |
MEMO
kann verwendet werden, um einen Ausdruck in einen mehrzeiligen
Text umzuwandeln.
|
STR
(siehe STR) auf,
liefert aber einen mehrzeiligen Text statt einer Zeichenkette.
Siehe auch STR.
INT
wird verwendet, um einen Ausdruck in eine Ganzzahl umzuwandeln.
|
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. |
REAL
wird verwendet, um einen Ausdruck in einen Wert vom Typ
Fließkommazahl umzuwandeln.
|
INT
(siehe INT) auf,
liefert aber einen Wert vom Typ Fließkommazahl anstatt einer Ganzzahl.
Siehe auch INT.
DATE
wird verwendet, um einen Ausdruck in ein Datum umzuwandeln.
|
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. |
TIME
wird verwendet, um einen Ausdruck in einen Zeitwert umzuwandeln.
|
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. |
Dieser Abschnitt listet die booleschen Operatoren auf.
15.9.1 AND Vereinigung von Booleschen Werten. 15.9.2 OR Verknüpfung von Booleschen Werten. 15.9.3 NOT Invertierung eines Booleschen Wertes.
AND
prüft, ob alle seine Parameter TRUE sind.
|
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.
OR
prüft, ob alle seiner Parameter NIL sind.
|
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.
NOT
wird verwendet, um den Wert eines Booleschen Ausdrucks zu
invertieren.
|
In diesem Abschnitt findet man Funktionen zum Vergleich von Werten vor.
15.10.1 Relationsoperatoren =, <>, <, >, <=, >= und ihre Versionen mit Stern. 15.10.2 CMP Liefert eine Ganzzahl, die eine Sortierung repräsentiert. 15.10.3 CMP* Erweiterter Vergleich, z.B. zeichengrößenunabhängig
Zum Vergleichen zweier Werte in einem MUIbase-Programm verwendet man
|
=
, <>
, <
, >
, >=
,
<=
, =*
, <>*
, <*
, >*
, >=*
, <=*
}
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 MUIbase-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) |
CMP
liefert eine Ganzzahl, die eine Sortierung ihrer Argumente repräsentiert.
|
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.
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.
Einige mathematische Funktionen werden hier aufgelistet.
15.11.1 + Addieren von Werten. 15.11.2 - Subtrahieren von Werten. 15.11.3 1+ Erhöhen von Werten. 15.11.4 1- Verringern von Werten. 15.11.5 * Fließkomma-Multiplikation. 15.11.6 / Fließkomma-Division. 15.11.7 DIV Ganzzahl-Division. 15.11.8 MOD Ganzzahl-Modulo. 15.11.9 MAX Maximum-Ausdruck. 15.11.10 MIN Minimum-Ausdruck. 15.11.11 ABS Absoluter Wert eines Ausdrucks. 15.11.12 TRUNC Nachkommastellen einer Fließkommazahl abschneiden. 15.11.13 ROUND Eine Fließkommazahl runden. 15.11.14 RANDOM Zufallszahlengenerator. 15.11.15 POW Potenzfunktion. 15.11.16 SQRT Wurzelfunktion. 15.11.17 EXP Exponentialfunktion. 15.11.18 LOG Logarithmus einer Zahl.
Zum Zusammenzählen von Zahlen verwendet man
|
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.
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 |
Zum Subtrahieren von Werten verwendet man
|
(-
expr)
hat eine spezielle Bedeutung: Es liefert den
negativen Wert von expr (Ganz- oder Fließkommazahl), z.B.
`(- (+ 1 2))' liefert -3.
1+
erhöht den Wert einer Ganz- bzw Fließkommazahl (-ausdrucks) um
Eins.
|
1-
verringert den Wert einer Ganz- bzw Fließkommazahl (-ausdrucks) um
Eins.
|
Zum Multiplizieren von Ganz-/Fließkommazahlen verwendet man
|
Zum Dividieren von Ganz-/Fließkommazahlen verwendet man
|
DIV
verwendet man zur Ganzzahldivision.
|
MOD
wird zur Modulo-Berechnung verwendet.
|
Siehe auch DIV.
MAX
liefert den Parameter mit dem größten Wert.
|
Siehe auch MIN.
MIN
liefert den Parameter mit dem kleinsten Wert.
|
Siehe auch MAX.
ABS
berechnet den absoluten Wert eines Ausdrucks.
|
TRUNC
schneidet die Nachkommastellen einer Zahl ab.
|
Beispiele: `(TRUNC 26.1)' liefert 26, `(TRUNC -1.2)' liefert -2.
Siehe auch ROUND.
ROUND
rundet einen Fließkommawert.
|
Beispiele: `(ROUND 70.70859 2)' liefert 70.71, `(ROUND 392.36 -1)' liefert 390.0.
Siehe auch TRUNC.
RANDOM
kann zum Generieren von Zufallszahlen verwendet werden.
|
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.
Beispiel Bedeutung (RANDOM 10) liefert einen Wert von 0 bis 9, (RANDOM 10.0) liefert einen Wert von 0.0 bis 9.99999... |
POW
berechnet die Potenz von Zahlen.
|
Beispiel: `(POW 2 3)' ergibt 8.
SQRT
berechnet die Wurzel einer Zahl.
|
Siehe auch POW.
EXP
berechnet die Exponentialfunktion.
|
LOG
berechnet den natürlichen Logarithmus einer Zahl.
|
Siehe auch EXP.
Dieser Abschnitt behandelt Funktionen für Zeichenketten.
15.12.1 LEN Zeichenkettenlänge. 15.12.2 LEFTSTR Linke Teilzeichenkette. 15.12.3 RIGHTSTR Rechte Teilzeichenkette. 15.12.4 MIDSTR Individuelle Teilzeichenkette. 15.12.5 SETMIDSTR Teilzeichenkette setzen. 15.12.6 INSMIDSTR Zeichenkette einfügen. 15.12.7 INDEXSTR erstes Auftreten einer Teilzeichenkette, zeichengrößenabhängig. 15.12.8 INDEXSTR* erstes Auftreten einer Teilzeichenkette, zeichengrößenunabhängig. 15.12.9 INDEXBRK erstes Auftreten eines Zeichens, zeichengrößenabhängig. 15.12.10 INDEXBRK* erstes Auftreten eines Zeichens, zeichengrößenunabhängig. 15.12.11 RINDEXSTR letztes Auftreten einer Teilzeichenkette, zeichengrößenabhängig. 15.12.12 RINDEXSTR* letztes Auftreten einer Teilzeichenkette, zeichengrößenunabhängig. 15.12.13 RINDEXBRK letztes Auftreten eines Zeichens, zeichengrößenabhängig. 15.12.14 RINDEXBRK* letztes Auftreten eines Zeichens, zeichengrößenunabhängig. 15.12.15 REPLACESTR Teilzeichenketten ersetzen, zeichengrößenabhängig. 15.12.16 REPLACESTR* Teilzeichenketten ersetzen, zeichengrößenunabhängig. 15.12.17 REMCHARS Zeichen aus Zeichenkette entfernen. 15.12.18 TRIMSTR Führende und abschließende Zeichen entfernen. 15.12.19 WORD Wort aus Zeichenkette holen. 15.12.20 WORDS Anzahl Wörter in einer Zeichenkette. 15.12.21 STRTOLIST Zeichenkette in Liste von Zeichenketten umwandeln. 15.12.22 LISTTOSTR Liste von Elementen in Zeichenkette umwandeln. 15.12.23 CONCAT Zeichenketten verbinden. 15.12.24 CONCAT2 Zeichenketten verbinden. 15.12.25 COPYSTR Erzeugt Kopien einer Zeichenkette. 15.12.26 SHA1SUM SHA1-Hash einer Zeichenkette. 15.12.27 UPPER Zeichenkette in Großbuchstaben. 15.12.28 LOWER Zeichenkette in Kleinbuchstaben. 15.12.29 ASC Unicode/8-bit-Wert eines Zeichens. 15.12.30 CHR Zeichen eines Unicode/8-bit-Werts. 15.12.31 LIKE Zeichenkettenvergleich. 15.12.32 SPRINTF Zeichenkettenformatierung.
LEN
berechnet die Länge der Zeichenkette.
|
Siehe auch WORDS, LINES, MAXLEN.
LEFTSTR
extrahiert eine Teilzeichenkette aus einer Zeichenkette.
|
Beispiel: `(LEFTSTR "Hallo Welt!" 5)' liefert "Hallo".
Siehe auch RIGHTSTR, MIDSTR, WORD, LINE.
RIGHTSTR
extrahiert eine Teilzeichenkette aus einer Zeichenkette.
|
Beispiel: `(RIGHTSTR "Hallo Welt!" 5)' liefert "Welt!".
Siehe auch LEFTSTR, MIDSTR, WORD, LINE.
MIDSTR
extrahiert eine Teilzeichenkette aus einer Zeichenkette.
|
Beispiel: `(MIDSTR "Hallo Welt!" 3 5)' liefert "lo We".
Siehe auch LEFTSTR, RIGHTSTR, WORD, LINE, SETMIDSTR, INSMIDSTR.
SETMIDSTR
setzt eine Teilzeichenkette in einer Zeichenkette.
|
Beispiel: `(SETMIDSTR "Hallo Welt!" 6 "Melanie!")' liefert "Hallo Melanie!".
Siehe auch INSMIDSTR, REPLACESTR.
INSMIDSTR
wird verwendet, um eine Teilzeichenkette in eine
Zeichenkette einzufügen.
|
Beispiel: `(INSMIDSTR "Hallo Welt!" 6 "MUIbase-")' liefert "Hallo MUIbase-Welt!".
Siehe auch SETMIDSTR, REPLACESTR.
INDEXSTR
sucht in einer Zeichenkette nach dem ersten Vorkommen der
Teilzeichenkette.
|
Beispiel: `(INDEXSTR "Hallo Welt!" "Welt")' liefert 6.
Siehe auch INDEXSTR*, RINDEXSTR, RINDEXSTR*, INDEXBRK, INDEXBRK*.
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*.
INDEXBRK
sucht nach dem ersten Vorkommen eines Zeichens in einer
Zeichenkette.
|
Beispiel: `(INDEXBRK "Hallo Welt!" "aeiou")' liefert 1.
Siehe auch INDEXBRK*, RINDEXBRK, RINDEXBRK*, INDEXSTR, INDEXSTR*.
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*.
RINDEXSTR
sucht in einer Zeichenkette nach dem letzten Vorkommen der
Teilzeichenkette.
|
Beispiel: `(RINDEXSTR "Do itashimashite." "shi")' liefert 11.
Siehe auch RINDEXSTR*, INDEXSTR, INDEXSTR*, RINDEXBRK, RINDEXBRK*.
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*.
RINDEXBRK
sucht nach dem letzten Vorkommen eines Zeichens in einer
Zeichenkette.
|
Beispiel: `(RINDEXBRK "Konnichiwa" "chk")' liefert 6.
Siehe auch RINDEXBRK*, INDEXBRK, INDEXBRK*, RINDEXSTR, RINDEXSTR*.
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*.
REPLACESTR
ersetzt Teilzeichenketten durch andere Zeichenketten.
|
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.
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.
REMCHARS
entfernt Zeichen aus einer Zeichenkette.
|
Beispiel: `(REMCHARS deine-zeichenkette " \t\n")' entfernt alle Leerzeichen, Tabulatoren und Neue-Zeile-Zeichen aus deine-zeichenkette.
Siehe auch REPLACESTR, TRIMSTR.
TRIMSTR
entfernt führende und abschließende Zeichen von einer
Zeichenkette.
|
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.
WORD
liefert ein Wort einer Zeichenkette.
|
Ist str oder num gleich NIL oder ist num außerhalb des gültigen Bereichs (negativ oder größer als 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, LINE, LEFTSTR, RIGHTSTR, MIDSTR.
WORDS
zählt die Anzahl der Wörter in einer Zeichenkette.
|
Beispiel: `(WORDS "In Wirklichkeit ist es aber nicht mein Fahrrad.")' liefert 8.
STRTOLIST
wandelt eine Zeichenkette in eine Liste von Zeichenketten um.
|
"\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.
`(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.
LISTTOSTR
wandelt eine Liste von Elementen in eine Zeichenkette um.
|
"\t"
verwendet.
Ist list oder sep NIL, so wird NIL zurückgegeben.
`(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.
CONCAT
verbindet Zeichenketten.
|
Beispiele: `(CONCAT "Ich" "dachte," "es" "war" "ein "verlassenes" "Fahrrad.")' liefert "Ich dachte, es war ein verlassenes Fahrrad.".
Siehe auch CONCAT2, +, LISTTOSTR, COPYSTR, SPRINTF.
CONCAT2
verbindet Zeichenketten.
|
Beispiel: `(CONCAT2 "! " "Aber" "es" "war es nicht!")' liefert "Aber! es! war es nicht!".
Siehe auch CONCAT, +, LISTTOSTR, COPYSTR, SPRINTF.
COPYSTR
erzeugt Kopien einer Zeichenkette.
|
Beispiel: `(COPYSTR "+-" 5)' liefert "+-+-+-+-+-".
Siehe auch CONCAT CONCAT2, +, SPRINTF.
SHA1SUM
berechnet den SHA1-Hash einer Zeichenkette.
|
Beispiel: `(SHA1SUM "flower, sun and beach")' ergibt "47b6c496493c512b40e042337c128d85ecf15ba4".
Siehe auch ADMINPASSWORD, Beispielprojekt `Users.mb'.
UPPER
wandelt eine Zeichenkette in Großbuchstaben.
|
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.
LOWER
wandelt eine Zeichenkette in Kleinbuchstaben.
|
Beispiel: `(LOWER "Der Brief war von Silke.")' liefert "der brief war von silke.".
Siehe auch UPPER.
ASC
wandelt ein Zeichen in die interne Zahlendarstellung um.
|
Beispiel: (ASC "A")
liefert 65.
CHR
wandelt einen Zahlenwert in ein Zeichen um.
|
Beispiel: `(CHR 99)' liefert "c".
LIKE
vergleicht Zeichenketten.
|
Beispiel: `(LIKE "Silke war für ein Jahr in Frankreich." "*Jahr*")' liefert TRUE.
Siehe auch Vergleichsfunktionen.
SPRINTF
formatiert eine Zeichenkette mit verschiedenen Daten.
|
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:
|
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.
SPRINTF
liefert die formatierte Zeichenkette oder NIL, wenn fmt
NIL ist.
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!" |
Dieser Abschnitt behandelt Funktionen für mehrzeilige Texte.
15.13.1 LINE Eine Zeile aus einem mehrzeiligen Text holen. 15.13.2 LINES Die Anzahl der Zeilen im mehrzeiligen Text. 15.13.3 MEMOTOLIST Einen mehrzeiligen Text in eine Liste umwandeln. 15.13.4 LISTTOMEMO Eine Liste in einen mehrzeiligen Text umwandeln. 15.13.5 FILLMEMO Einen mehrzeiligen Text füllen. 15.13.6 FORMATMEMO Einen mehrzeiligen Text formatieren. 15.13.7 INDENTMEMO Einen mehrzeiligen Text einrücken.
LINE
holt eine Zeile aus einem mehrzeiligen Text.
|
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.
LINES
liefert die Anzahl der Zeilen in einem mehrzeiligen Text.
|
MEMOTOLIST
wandelt einen mehrzeiligen Text in eine Liste von
Zeichenketten um.
|
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.
`(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.
LISTTOMEMO
wandelt eine Liste in einen mehrzeiligen Text um.
|
LISTTOSTR
(siehe LISTTOSTR) auf die Unterliste angewandt
bevor die resultierende Zeichenkette in den mehrzeiligen Text aufgenommen wird.
`(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.
FILLMEMO
füllt einen mehrzeiligen Text mit den Ergebnissen von
Ausdrücken.
|
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.
FORMATMEMO
formatiert einen mehrzeiligen Text.
|
Siehe auch FILLMEMO, INDENTMEMO.
INDENTMEMO
rückt einen mehrzeiligen Text ein, in dem links Leerzeichen
eingefügt werden.
|
Siehe auch FILLMEMO, FORMATMEMO.
Dieser Abschnitt behandelt Funktionen für Datum und Zeit.
15.14.1 DAY Extraktion des Tags eines Datums. 15.14.2 MONTH Extraktion des Monats eines Datums. 15.14.3 YEAR Extraktion des Jahres eines Datums. 15.14.4 DATEDMY Erstellen eines Datums aus Tag, Monat und Jahr. 15.14.5 MONTHDAYS Anzahl Tage eines Monats. 15.14.6 YEARDAYS Anzahl Tage eines Jahres. 15.14.7 ADDMONTH Addition einer Anzahl Monate zu einem Datum. 15.14.8 ADDYEAR Addition einer Anzahl Jahre zu einem Datum. 15.14.9 TODAY Heutiges Datum. 15.14.10 NOW Aktuelle Uhrzeit.
DAY
extrahiert den Tag eines Datums.
|
Siehe auch MONTH, YEAR, DATEDMY.
MONTH
extrahiert den Monat eines Datums.
|
Siehe auch DAY, YEAR, DATEDMY, MONTHDAYS.
YEAR
extrahiert das Jahr eines Datums.
|
Siehe auch DAY, MONTH, DATEDMY, YEARDAYS.
DATEDMY
erstellt ein Datum aus Tag, Monat und Jahr.
|
Beispiel: `(DATEDMY 28 11 1968)' ergibt den 28. November, 1968.
Siehe auch DATE, TODAY, DAY, MONTH, YEAR.
MONTHDAYS
bestimmt die Anzahl Tage eines Monats.
|
Beispiele: `(MONTHDAYS 2 2004)' liefert 29, `(MONTHDAYS 2 NIL)' ergibt 28.
YEARDAYS
bestimmt die Anzahl Tage eines Jahres.
|
Beispiele: `(YEARDAYS 2004)' liefert 366, `(YEARDAYS 2005)' ergibt 365.
ADDMONTH
addiert eine Anzahl Monate zu einem Datum.
|
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.
ADDYEAR
addiert eine Anzahl Jahre zu einem Datum.
|
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.
TODAY
liefert das heutige Datum.
|
Siehe auch NOW.
NOW
liefert die aktuelle Uhrzeit.
|
Siehe auch TODAY.
Dieser Abschnitt listet Funktionen zum Verarbeiten von Listen auf.
15.15.1 CONS Elementarer Listenkonstruktor. 15.15.2 LIST Erzeugt Liste aus Elementen. 15.15.3 LENGTH Liefert Anzahl Elemente einer Liste. 15.15.4 FIRST Holt das erste Element aus einer Liste. 15.15.5 REST Liefert den Rest einer Liste. 15.15.6 LAST Holt das letzte Element aus einer Liste. 15.15.7 NTH Holt das n-te Element aus einer Liste. 15.15.8 APPEND Verbindet Listen. 15.15.9 REVERSE Kehrt die Elementreihenfolge einer Liste um. 15.15.10 MAPFIRST Anwenden einer Funktion auf alle Listenelemente. 15.15.11 SORTLIST Sortiert die Elemente einer Liste. 15.15.12 SORTLISTGT Sortiert die Elemente einer Liste.
CONS
erzeugt ein Paar von Ausdrücken.
|
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.
LIST
erzeugt eine Liste anhand ihrer Parameter.
|
(CONS
elem (CONS
... NIL))
.
Man beachte, dass NIL alleine für eine leere Liste steht.
LENGTH
ermittelt die Länge einer Liste.
|
Beispiel: `(LENGTH (LIST "a" 2 42 3))' liefert 4.
Siehe auch LIST.
FIRST
holt das erste Element aus einer Liste.
|
Siehe auch REST, LAST, NTH, CONS.
REST
liefert die Teilliste nach dem ersten Element einer Liste.
|
Beispiel: `(REST (LIST 1 2 3))' liefert ( 2 3 ).
LAST
holt das letzte Element aus einer Liste.
|
NTH
holt das n-te Element aus einer Liste.
|
APPEND
verbindet Listen.
|
Beispiel: `(APPEND (list 1 2) (list 3 4) (list 5))' liefert ( 1 2 3 4 5 ).
Siehe auch LIST.
REVERSE
kehrt eine Liste um.
|
Beispiel: `(REVERSE (list 1 2 3))' liefert ( 3 2 1 ).
MAPFIRST
wendet eine Funktion auf alle Listenelemente an.
|
Ausdruck Wert (MAPFIRST 1+ (LIST 1 2 3)) ( 2 3 4 ) (MAPFIRST + (LIST 1 2 3) (LIST 2 3)) ( 3 5 NIL ) |
SORTLIST
sortiert die Elemente einer Liste.
|
Beispiel für eine Zeichenkettenvergleichsfunktion für die Sortierung:
(DEFUN cmp_str (x y) (COND ((< x y) -1) ((> x y) 1) (TRUE 0) ) ) |
(SORTLIST cmp_str (LIST "hi" "gut" "großartig" "ok")) |
Siehe auch SORTLISTGT, MAPFIRST.
SORTLIST
sortiert die Elemente einer Liste.
|
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.
Zum Abfragen von Benutzereingaben können folgende Funktionen verwendet werden:
15.16.1 ASKFILE Abfragen eines Dateinamens. 15.16.2 ASKDIR Abfragen eines Verzeichnisnamens. 15.16.3 ASKSTR Abfragen einer Zeichenkette. 15.16.4 ASKINT Abfragen einer Ganzzahl. 15.16.5 ASKCHOICE Abfragen eines Elements aus vielen. 15.16.6 ASKCHOICESTR Abfragen einer Zeichenkette und bietet vorgegebene an. 15.16.7 ASKOPTIONS Abfragen mehrere Elemente aus vielen. 15.16.8 ASKBUTTON Auswahl eines Knopfdrucks. 15.16.9 ASKMULTI Abfragen mehrere Informationen.
ASKFILE
fragt den Benutzer nach einem Dateinamen.
|
ASKFILE
liefert den eingegebenen Dateinamen als Zeichenkette oder NIL,
wenn der Benutzer das Fenster mit Abbrechen verlassen hat.
ASKDIR
fragt den Benutzer nach einem Verzeichnisnamen.
|
ASKFILE
(siehe ASKFILE).
ASKDIR
liefert den eingegebenen Verzeichnisnamen als Zeichenkette oder
NIL, wenn der Benutzer das Fenster mit Abbrechen verlassen hat.
ASKSTR
fragt den Benutzer nach einer Zeichenkette.
|
ASKSTR
liefert die eingegebene Zeichenkette oder NIL, wenn der
Benutzer das Fenster mit Abbrechen verlassen hat.
Siehe auch ASKFILE, ASKDIR, ASKCHOICESTR, ASKINT.
ASKINT
fragt den Benutzer nach einer Ganzzahl.
|
ASKINT
liefert die eingegebene Ganzzahl oder NIL, wenn der Benutzer
das Fenster mit Abbrechen verlassen hat.
Siehe auch ASKSTR.
ASKCHOICE
fragt den Benutzer nach einer Auswahl aus mehreren Elementen.
|
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.
(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)) ) ) ) |
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) ) |
ASKCHOICESTR
fragt den Benutzer nach einer Zeichenkette und bietet
vorgegebene an.
|
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.
(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)) ) |
ASKOPTIONS
erlaubt dem Benutzer mehreren Optionen
aus einer Liste auszuwählen.
|
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.
(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)) ) ) ) ) ) |
ASKBUTTON
fragt den Benutzer nach einen Knopfdruck.
|
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.
(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 MUIbase spitze!" NIL NIL) |
ASKMULTI
fragt den Benutzer nach verschiedenartigen Informationen.
|
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:
|
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.
(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") )) ) |
Dieser Abschnitt listet die Funktionen und Variablen zur Dateiein- und ausgabe (z.B. drucken) auf.
15.17.1 FOPEN Öffnet eine Datei zum Lesen/Schreiben. 15.17.2 FCLOSE Schließt eine Datei. 15.17.3 stdout Standard-Ausgabedateihandler. 15.17.4 PRINT Gibt einen Ausdruck nach stdout aus. 15.17.5 PRINTF Formatierte Ausgabe nach stdout. 15.17.6 FPRINTF Formatierte Ausgabe in eine Datei. 15.17.7 FERROR Fehlerprüfung einer Datei. 15.17.8 FEOF Ende-Erkennung einer Datei. 15.17.9 FSEEK Setzt Position in einer Datei. 15.17.10 FTELL Ermittelt Position in einer Datei. 15.17.11 FGETCHAR Liest das nächste Eingabezeichen aus einer Datei. 15.17.12 FGETCHARS Liest mehrere Eingabezeichen aus einer Datei. 15.17.13 FGETSTR Liest eine Zeichenkette aus einer Datei. 15.17.14 FGETMEMO Liest einen mehrzeiligen Text aus einer Datei. 15.17.15 FPUTCHAR Schreibt ein Zeichen in eine Datei. 15.17.16 FPUTSTR Schreibt eine Zeichenkette in eine Datei. 15.17.17 FPUTMEMO Schreibt einen mehrzeiligen Text in eine Datei. 15.17.18 FFLUSH Leert den Schreibpuffer einer Datei.
FOPEN
öffnet eine Datei zum Lesen/Schreiben.
|
Der optionale Parameter encoding gibt die Textkodierung der Datei an und kann eine der folgenden Zeichenketten sein:
LANG
- und
LC_*
-Umgebungsvariablen (siehe man locale
).
Beim Amiga ist es die voreingestellte 8-Bit-Kodierung.
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.
`(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, MUIbase 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.
FCLOSE
schließt eine Datei.
|
Die globale Variable stdout
trägt den Dateihandler zur Standardausgabe
von MUIbase. 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 MUIbase die Programmausgabedatei nicht öffnen kann, dann wird die Ausführung unterbruchen und eine Fehlermeldung ausgegeben.
PRINT
wandelt einen Ausdruck in eine Zeichenkette und gibt ihn aus.
|
stdout
aus. Diese Funktion ist hauptsächlich zu Prüfzwecken
vorhanden.
PRINTF
gibt eine formatierte Zeichenkette aus.
|
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.
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.
FPRINTF
gibt eine formatierte Zeichenkette in eine Datei aus.
|
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.
FERROR
prüft, on ein Ein-/Ausgabefehler einer Datei aufgetreten ist.
|
Siehe auch FEOF, FOPEN, FCLOSE.
FEOF
prüft auf den Endestatus einer Datei.
|
Siehe auch FERROR, FTELL, FOPEN, FCLOSE.
FSEEK
setzt die Schreib-/Leseposition in einer 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.
FTELL
liefert die Schreib-/Leseposition der Datei.
|
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.
FGETCHAR
liest ein Zeichen aus einer Datei.
|
Siehe auch FGETCHARS, FGETSTR, FPUTCHAR.
FGETCHARS
liest Zeichen aus einer Datei.
|
FGETSTR
liest eine Zeichenkette aus einer Datei.
|
Siehe auch FGETCHAR, FGETCHARS, FGETMEMO, FPUTSTR.
FGETMEMO
liest einen mehrzeiligen Text aus einer Datei.
|
FPUTCHAR
schreibt ein Zeichen in eine Datei.
|
FPUTSTR
schreibt eine Zeichenkette in eine Datei.
|
Siehe auch FPUTCHAR, FPUTMEMO, FGETSTR.
FPUTMEMO
schreibt einen mehrzeiligen Text in eine Datei.
|
FFLUSH
leert den Schreibpuffer in eine Datei.
|
Dieser Abschnitt behandelt Funktionen für Datensätze.
15.18.1 NEW Neuen Datensatz anlegen. 15.18.2 NEW* Neuen Datensatz durch Aufruf der Auslösefunktion anlegen. 15.18.3 DELETE Datensatz löschen. 15.18.4 DELETE* Datensatz durch Aufruf der Auslösefunktion löschen. 15.18.5 DELETEALL Löschen aller Datensätze einer Tabelle. 15.18.6 GETMATCHFILTER Holt den Zustand der Filterübereinstimmung eines Datensatzes. 15.18.7 SETMATCHFILTER Setzt den Zustand der Filterübereinstimmung eines Datensatzes. 15.18.8 GETISSORTED Prüft, ob ein Datensatz einsortiert ist. 15.18.9 SETISSORTED Übergibt einem Datensatz den Sortierstatus. 15.18.10 RECNUM Holt die Nummer eines Datensatzes. 15.18.11 COPYREC Kopiert den Inhalt eines Datensatzes.
NEW
legt einen neuen Datensatz für eine Tabelle an.
|
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.
NEW*
ist die Version von NEW
(siehe NEW) mit dem Stern.
|
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.
DELETE
löscht einen Datensatz einer Tabelle.
|
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.
DELETE*
ist die Version von DELETE
(siehe DELETE) mit dem
Stern.
|
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 requester 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*.
DELETEALL
löscht alle Datensätze einer Tabelle.
|
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.
GETMATCHFILTER
liefert den Status der Filterübereinstimmung eines
Datensatzes.
|
Siehe auch SETMATCHFILTER, GETISSORTED, GETFILTERSTR, SETFILTERSTR.
SETMATCHFILTER
setzt den Status der Filterübereinstimmung eines
Datensatzes.
|
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.
GETISSORTED
liefert den Sortierstatus eines Datensatzes.
|
Siehe auch SETISSORTED, GETMATCHFILTER, REORDER, GETORDERSTR, SETORDERSTR, Vergleichsfunktion.
SETISSORTED
setzt den Sortierstatus eines Datensatzes.
|
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.
RECNUM
liefert die Datensatznummer des Datensatzes.
|
COPYREC
kopiert Datensätze.
|
COPYREC
liefert rec.
Siehe auch NEW.
Dieser Abschnitt behandelt Funktionen für Felder einer Tabelle.
15.19.1 ATTRNAME Holen des Namens eines Feldes. 15.19.2 MAXLEN Maximale Anzahl von Zeichen eines Zeichenkettenfeldes. 15.19.3 GETLABELS Holen der Auswahltexte eines Auswahl- oder Zeichenkettenfeldes. 15.19.4 SETLABELS Setzen der Auswahltexte eines Auswahl- oder Zeichenkettenfeldes.
ATTRNAME
liefert den Namen des Feldes.
|
Siehe auch TABLENAME
MAXLEN
liefert die maximale Anzahl von Zeichen eines
Zeichenkettenfeldes.
|
Siehe auch LEN.
GETLABELS
liefert alle Auswahltexte eines Auswahl- oder
Zeichenkettenfeldes.
|
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.
SETLABELS
wird verwendet, um die Auswahltexte eines
Zeichenkettenfeldes zu setzen.
|
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.
15.20.1 TABLENAME Holen des Tabellennamens. 15.20.2 GETORDERSTR Holen der Datensatzreihenfolge. 15.20.3 SETORDERSTR Setzen der Datensatzreihenfolge. 15.20.4 REORDER Unsortierte Datensätze neu sortieren. 15.20.5 REORDERALL Alle Datensätze einer Tabelle neu sortieren. 15.20.6 GETFILTERACTIVE Holen des Datensatzfilterstatus. 15.20.7 SETFILTERACTIVE Setzen des Datensatzfilterstatus. 15.20.8 GETFILTERSTR Holen des Datensatzfilterausdrucks. 15.20.9 SETFILTERSTR Setzen des Datensatzfilterausdrucks. 15.20.10 RECORDS Anzahl der Datensätze. 15.20.11 RECORD Holen eines Zeigers auf einen Datensatz. 15.20.12 SELECT SELECT-FROM-WHERE-Abfragen.
TABLENAME
liefert den Namen einer Tabelle.
|
Siehe auch ATTRNAME
GETORDERSTR
liefert die Datensatzreihenfolge einer Tabelle.
|
Wird die Tabelle anhand einer Vergleichsfunktion sortiert, dann wird der Name dieser Funktion geliefert.
Eine leere Zeichenkette zeigt an, dass keine Sortierung vorliegt.
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.
SETORDERSTR
setzt die Sortierreihenfolge einer Tabelle.
|
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 ATTRNAME
(siehe ATTRNAME) zu verwenden und dessen
Ergebnis in die Sortierzeichenkette zu kopieren.
Man betrachte eine Tabelle `Person' mit den Feldern `Name', `Stadt' und `Geburtstag'. `(SETORDERSTR Person (SPRINTF "+%s" (ATTRNAME Person.Name)))' setzt dann die Sortierreihenfolge der Tabelle `Person' auf `Name' als (aufsteigendes) Sortierfeld.
Siehe auch GETORDERSTR, REORDER, REORDERALL, GETISSORTED, SETISSORTED, Order, Vergleichsfunktion.
REORDER
bringt alle unsortierten Datensätze zurück in die richtige
Reihenfolge.
|
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.
REORDERALL
sortiert alle Datensätze einer Tabelle neu.
|
REORDER
zum kompletten
Neusortieren aufgerufen wird.
REORDERALL
liefert NIL.
Siehe auch REORDER, GETORDERSTR, SETORDERSTR, GETISSORTED, SETISSORTED, Sortieren, Vergleichsfunktion.
GETFILTERACTIVE
liefert den Filterstatus einer Tabelle.
|
Siehe auch SETFILTERACTIVE, GETFILTERSTR, GETMATCHFILTER.
SETFILTERACTIVE
setzt den Filterstatus einer Tabelle.
|
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.
GETFILTERSTR
liefert den Datensatzfilterausdruck einer Tabelle.
|
Siehe auch SETFILTERSTR, GETFILTERACTIVE, GETMATCHFILTER.
SETFILTERSTR
setzt den Datensatzfilterausdruck einer Tabelle.
|
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)) ) |
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.
RECORDS
liefert die Anzahl der Datensätze in einer Tabelle.
|
RECORD
liefert einen Datensatzzeiger für eine gegebene Datensatznummer.
|
Es ist darauf zu achten, dass Datensatznummern bei 1 beginnen und die Datensatznummer 0 für den Vorgabedatensatz verwendet wird.
SELECT
ermittelt und liefert diverse Daten von Datensätzen.
|
exprlist: |
tablelist: table[ |
Die Sortierliste hat den folgenden Aufbau:
orderlist: expr [ |
ASC
oder DESC
für eine auf- bzw. absteigende
Sortierung angeben.
Ist keiner der beiden vorhanden, dann wird aufsteigende Sortierung
angenommen.
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.
Siehe Abfragebeispiele
für einige Beispiele mit der Funktion SELECT
.
Siehe auch FOR ALL.
Dieser Abschnitt beschreibt die Funktionen zum Verändern von Benutzeroberflächenelementen.
15.21.1 SETCURSOR Setzt den Cursor auf ein GUI-Element. 15.21.2 GETWINDOWOPEN Holt den Geöffnet/Geschlossen-Status eines Fensters. 15.21.3 SETWINDOWOPEN Öffnen/Schließen eines Fensters. 15.21.4 GETVIRTUALLISTACTIVE Bestimmt die aktuelle Zeile eines virtuellen Feldes. 15.21.5 SETVIRTUALLISTACTIVE Setzt die aktuelle Zeile eines virtuellen Feldes.
SETCURSOR
setzt den Cursor auf ein Benutzeroberflächenelement.
|
SETCURSOR
liefert TRUE, wenn kein Fehler auftrat (Fenster konnte
geöffnet werden) oder NIL bei einem Fehler.
Siehe auch SETVIRTUALLISTACTIVE.
GETWINDOWOPEN
liefert den Geöffnet-Status eines Fensters.
|
Siehe auch SETWINDOWOPEN.
SETWINDOWOPEN
öffnet und schließt ein Fenster.
|
SETWINDOWOPEN
liefert den neuen Geöffnet-Status des Fensters.
Siehe auch GETWINDOWOPEN.
GETVIRTUALLISTACTIVE
liefert den Index der aktiven Zeile
eines virtuellen Feldes, welches für die Anzeige die `Listen'-Art
verwendet.
|
Siehe auch SETVIRTUALLISTACTIVE.
SETVIRTUALLISTACTIVE
setzt die aktive Zeile eines virtuellen Feldes,
welche die `Listen'-Art für die Anzeige verwendet.
|
Liefert num oder NIL, falls das Bedienelement von virtual-attr nicht sichtbar ist oder nicht die `Listen'-Art für die Anzeige verwendet oder falls num außerhalb des gültigen Bereiches ist (kleiner als 1 oder größer der Anzahl Zeilen).
SETVIRTUALLISTACTIVE
setzt nicht den Cursor auf das Benutzerelement des
Feldes. Dies kann mit SETCURSOR
(siehe SETCURSOR) erreicht werden.
Siehe auch GETVIRTUALLISTACTIVE, SETCURSOR.
Dieser Abschnitt listet Funktionen auf, die mit Projekten zu tun haben.
15.22.1 PROJECTNAME Holt den Projektnamen. 15.22.2 CHANGES Holt die Anzahl bisher gemachter Änderungen. 15.22.3 GETADMINMODE Prüfen ob in Admin- oder Benutzermodus. 15.22.4 SETADMINMODE Setzen des Admin- oder Benutzermodus. 15.22.5 ADMINPASSWORD SHA1-Hash des Admin-Passworts.
PROJECTNAME
liefert den Projektnamen.
|
PROJECTNAME
liefert den Namen des aktuellen Projekts als
Zeichenkette oder NIL, wenn noch kein Name definiert wurde.
Der Projektname ist der Pfadname des Projektverzeichnisses im Dateisystem.
Siehe auch CHANGES.
CHANGES
liefert die Anzahl der bisher gemachten Änderungen am
aktuellen Projekt.
|
Siehe auch PROJECTNAME.
GETADMINMODE
gibt an,
ob sich das aktuelle Projekt im Admin- oder Benutzermodus befindet.
|
Siehe auch SETADMINMODE, ADMINPASSWORD, onAdminMode.
SETADMINMODE
versetzt das aktuelle Projekt
in den Admin- oder Benutzermodus.
|
Liefert TRUE, falls das Projekt in den Admin-Modus versetzt wurde, oder NIL falls es in den Benutzermodus versetzt wurde.
Siehe auch GETADMINMODE, ADMINPASSWORD, onAdminMode, Beispielprojekt `Users.mb'.
ADMINPASSWORD
liefert das Admin-Passwort als SHA1-Hash.
|
Siehe auch GETADMINMODE, SETADMINMODE, SHA1SUM, Beispielprojekt `Users.mb'.
Dieser Abschnitt listet Funktionen auf, die auf das Betriebssystem zugreifen.
15.23.1 EDIT Startet externen Editor und wartet. 15.23.2 EDIT* Startet externen Editor asynchron. 15.23.3 VIEW Startet externen Anzeiger und wartet. 15.23.4 VIEW* Startet externen Anzeiger asynchron. 15.23.5 SYSTEM Führt externe Befehle aus und wartet. 15.23.6 SYSTEM* Führt externe Befehle asynchron aus. 15.23.7 STAT Untersucht eine Datei. 15.23.8 TACKON Erzeugt einen Pfadnamen aus Komponenten. 15.23.10 DIRNAME Ermittelt das Verzeichnis von einem Pfad. 15.23.9 FILENAME Ermittelt die letzte Komponente eines Pfades. 15.23.11 MESSAGE Gibt Meldungen aus. 15.23.12 COMPLETEMAX Setzen der max. Anzahl der Fortschrittsanzeige. 15.23.13 COMPLETEADD Erhöhen der Fortschrittsanzeige. 15.23.14 COMPLETE Direktes Setzten der Fortschrittsanzeige. 15.23.15 GC Erzwingt das Aufräumen des Speichers. 15.23.16 PUBSCREEN Name des Public-Screens (Amiga).
EDIT
startet den externen Editor.
|
EDIT
startet den externen Editor synchron, das bedeutet,
die Funktion wartet bis der Benutzer den Editor beendet hat.
EDIT
gibt den Rückgabewert des externen Editors als Ganzzahl zurück.
Siehe auch EDIT*, VIEW, SYSTEM.
EDIT*
ist die Stern-Version von EDIT
und hat den selben
Effekt wie EDIT
(siehe EDIT).
Der einzige Unterschied ist, dass EDIT*
den externen Editor asynchron
startet und sofort wieder zurückkehrt.
EDIT*
liefert 0, wenn der Editor erfolgreich gestartet werden konnte,
anderenfalls wird eine Ganzzahl ungleich 0 zurückgegeben, welche einen
system-abhängigen Fehler beschreibt.
Siehe auch EDIT, VIEW*, SYSTEM*.
VIEW
startet den externen Anzeiger.
|
VIEW
startet den externen Anzeiger synchron, das bedeutet,
die Funktion wartet bis der Benutzer den Anzeiger beendet hat.
Zu beachten ist aber, dass auf manchen Systemen sofort
zurückgekehrt wird, falls bereits eine Instanz des Anzeigers gestartet wurde.
VIEW
gibt den Rückgabewert des externen Anzeigers als Ganzzahl zurück.
Siehe auch VIEW*, EDIT, SYSTEM.
VIEW*
ist die Stern-Version von VIEW
und hat den selben
Effekt wie VIEW
(siehe VIEW).
Der einzige Unterschied ist, dass VIEW*
den externen Anzeiger asynchron
startet und sofort wieder zurückkehrt.
VIEW*
liefert 0, wenn der Anzeiger erfolgreich gestartet werden konnte,
anderenfalls wird eine Ganzzahl ungleich 0 zurückgegeben, welche einen
system-abhängigen Fehler beschreibt.
Siehe auch VIEW, EDIT*, SYSTEM*.
SYSTEM
ruft ein externes Programm auf.
|
SPRINTF
(siehe SPRINTF) erzeugt.
Die Befehlszeile wird mit einem Kommandozeilen-Interpreter ausgeführt
(ShellExecute auf Windows, /bin/sh auf Mac OS und Linux, User-Shell auf Amiga).
SYSTEM
wartet, bis das aufgerufene Programm beendet wurde.
SYSTEM
gibt den Rückgabewert des ausgeführten Befehls
als Ganzzahl zurück.
Siehe auch EDIT, VIEW, SYSTEM*.
SYSTEM*
ist die Stern-Version von SYSTEM
und hat den selben
Effekt wie SYSTEM
(siehe SYSTEM).
Der einzige Unterschied ist, dass SYSTEM*
die Befehlszeile asynchron
ausführt und sofort wieder zurückkehrt.
SYSTEM*
liefert 0, wenn das Ausführen der Befehlszeile erfolgreich
gestartet werden konnte,
anderenfalls wird eine Ganzzahl ungleich 0 zurückgegeben, welche einen
system-abhängigen Fehler beschreibt.
Siehe auch SYSTEM, EDIT*, VIEW*.
STAT
untersucht eine Datei.
|
STAT
liefert NIL, wenn der Dateiname nicht gefunden werden konnte;
0, wenn der Dateiname existiert und ein Verzeichnis ist,
und eine Ganzzahl größer 0, wenn der Dateiname existiert
und eine gültige Datei ist.
TACKON
erzeugt einen Pfadnamen.
|
TACKON
weiß, wie es mit speziellen Zeichen,
die als Pfadseparator dienen, am Ende jedes Arguments umzugehen hat.
Es liefert den Pfadnamen als Zeichekette oder NIL, falls eines der
Argumente NIL ist.
Zu beachten ist, dass TACKON
nicht untersucht,
ob der resultierende Pfad auch tatsächlich zu einer Datei oder
einem Verzeichnis im Dateisystem gehört.
Beispiel: `(TACKON "Sys:System" "CLI")' liefert "Sys:System/CLI".
FILENAME
extrahiert den Dateinamen aus einem Pfadnamen.
|
FILENAME
zu verwenden, um den Namen eines Unterverzeichnisses zu erhalten.
FILENAME
liefert sein Ergebnis als Zeichenkette oder NIL,
wenn path NIL ist.
Beispiel: `(FILENAME "Sys:System/CLI")' liefert "CLI".
DIRNAME
extrahiert den Verzeichnis-Teil eines Pfadnamens.
|
DIRNAME
zu verwenden,
um den Namen eines übergeordneten Verzeichnisses zu erhalten.
DIRNAME
liefert sein Ergebnis als Zeichenkette oder NIL,
wenn path NIL ist.
Beispiel: `(DIRNAME "Sys:System/CLI")' liefert "Sys:System".
MESSAGE
gibt eine Meldung für den Benutzer aus.
|
SPRINTF
(siehe SPRINTF) erzeugt.
MESSAGE
liefert die formatierte Titelzeichenkette.
Beispiel: `(MESSAGE "6 * 7 = %i" (* 6 7))'.
COMPLETEMAX
setzt die maximale Anzahl Schritte der Fortschrittsanzeige.
|
COMPLETEMAX
gibt das Argument steps zurück.
Siehe auch COMPLETEADD, COMPLETE.
COMPLETEADD
erhöht die Fortschrittsanzeige.
|
COMPLETEADD
gibt das Argument add zurück.
(SETQ num ...) (COMPLETEMAX num) (DOTIMES (i num) (COMPLETEADD 1) ) |
COMPLETE
setzt die Fortschrittsanzeige.
|
COMPLETE
gibt das Argument cur zurück.
(COMPLETE 10) ... (COMPLETE 50) ... (COMPLETE 100) |
GC
erzwingt das Aufräumen des Speichers.
|
PUBSCREEN
liefert den Namen des Public-Screens.
|
PUBSCREEN
den Namen des Public-Screens,
auf dem MUIbase läuft, zurück oder NIL, falls der Screen nicht öffentlich ist.
Auf anderen Systemen liefert PUBSCREEN
NIL zurück.
MUIbase kennt einige vordefinierte globale Variablen.
Momentan existiert nur eine einzige globale Variable: stdout
(siehe stdout).
Die folgenden vordefinierten Konstanten können in jedem Ausdruck bei der Programmierung verwendet werden:
Name Typ Wert Bemerkung ------------------------------------------------------------------------- |
#define
(siehe #define).
Es ist möglich, eine Funktion als einen Parameter an eine andere Funktion zu übergeben. Dies ist nützlich für die Definition von übergeordneten Funktionen, wie z.B. zum Sortieren oder Abbilden einer Liste.
Um eine Funktion auzurufen, die als Parameter übergeben wurde, muss die
Funktion FUNCALL
(siehe FUNCALL) verwendet werden.
(DEFUN map (l fun) # Parameter: Liste und Funktion (LET (res) # lokale Variable res, vorbelegt mit NIL (DOLIST (i l) # jedes Element der Reihe nach (SETQ res (CONS (FUNCALL fun i) res) # Funktion aufrufen und ) # neue Liste erzeugen ) (REVERSE res) # die Liste muss nun umgekehrt werden ) ) |
`(map (LIST 1 2 3 4) 1+)' liefert ( 2 3 4 5 ).
Siehe auch FUNCALL, APPLY, MAPFIRST.
Es ist möglich, den Typ einer Variable durch Anfügen eines Typdeklarierers hinter dem Namen festzulegen. Die folgenden Typdeklarierer existieren:
Deklarierer Beschreibung :INT für Ganzzahlen :REAL für Fließkommazahlen :STR für Zeichenketten :MEMO für mehrzeilige Zeichenketten :DATE für Datumswerte :TIME für Zeitwerte :LIST für Listen :FILE für Dateihandler :FUNC für Funktionen jedes Typs :table für Datensatzzeiger auf table |
(LET (x:INT (y:REAL 0.0) z) ...) |
Der Vorteil von Typspezifizierern ist, dass der Compiler mehr Typfehler entdecken kann, z.B. wenn eine Funktion
(DEFUN foo (x:INT) ...) |
Aus Geschwindigkeitsgründen wird beim Programmlauf keine Typüberprüfung durchgeführt. Es könnte eingebaut werden, aber dies würde eine kleine Verlangsamung bewirken, die nicht wirklich notwendig ist, da ein falscher Typ früher oder später in einem Typfehler endet.
Typdeklarierer für Datensatzzeiger haben eine andere nützliche Eigenschaft. Wird eine Variable als Datensatzzeiger auf eine Tabelle belegt, dann kann auf alle Felder dieser Tabelle mit dem Variablennamen statt des Tabellennamens im Feldpfad zugegriffen werden. Hat man z.B. eine Tabelle `Foo' mit einem Feld `Bar' und man definiert eine Variable `foo' als
(LET (foo:Foo) |
(SETQ foo (RECORD Foo 3)) (PRINT foo.Bar) |
Zu beachten ist in Select-from-where Ausdrücken, dass die Variablen in der FROM-Liste automatisch vom Typ des Datensatzzeigers des zugeordneten Tabelle sind.
Der Aufbau von Ausdrücken ist von sehr großer Bedeutung, um zu verstehen, was ein Programm tut.
Dieser Abschnitt bescheibt die Semantik, abhängig vom Aufbau der Ausdrücke:
(
func [expr ...])
Errechnet expr ... und ruft dann die Funktion func
(Aufruf mit Wert) auf.
Liefert den Rückgabewert der aufgerufenen Funktion.
In MUIbase gibt es einige nicht-strikte Funktionen, z.B.
AND
, OR
und IF
.
Diese Funktionen müssen nicht zwingend alle Ausdrücke errechnen.
Mehr zu nicht-strikten Funktionen, siehe Lisp-Aufbau,
AND, OR, and IF.
(
[expr ...])
Errechnet expr ... und liefert den Wert des letzten Ausdrucks
(siehe PROGN).
Ein leerer Ausdruck ()
wird zu NIL.
Liefert den Programmdatensatzzeiter der gegebenen Tabelle.
Liefert den Datensatzzeiger der Benutzeroberfläche von der gegebenen Tabelle.
Liefert den Inhalt des gegebenen Feldes. Der Feldpfad legt fest, welcher Datensatz verwendet wird, aus dem der Feldinhalt geholt wird. Zum Beispiel benutzt `Table.Attribute' den Programmdatensatzzeiger von `Table', um den Wert des Feldes zu ermitteln; `Table.ReferenceAttribute.Attribute' verwendet den Programmdatensatzzeiger von `Table', um den Wert des Beziehungsfeldes zu ermitteln (der ein Datensatzzeiger ist) und verwendet diesen Datensatz, um den Wert von `Attribute' zu erhalten.
Liefert den Inhalt der globalen oder lokalen Variable var.
Globale Variablen können durch DEFVAR
(siehe DEFVAR),
lokale Variablen z.B. durch LET
(siehe LET) definiert werden.
Verwendet den Datensatzzeiger von var, um den Wert des gegebenen Feldes zu ermitteln.
Zum automatischen Ausführen von MUIbase-Programmen können Auslösefunktionen für Projekte, Tabellen und Felder festgelegt werden, wie in bestimmten Fällen aufgerufen werden. Dieser Abschnitt bescheibt alle vorhandenen Auslösemöglichkeiten.
15.29.1 onOpen Auslösefunktion nach dem Öffnen eines Projekts. 15.29.2 onClose Auslösefunktion beim Schließen eines Projekts. 15.29.3 onAdminMode Auslösefunktion beim Eintreten/Verlassen des Admin-Modus. 15.29.4 onChange Auslösefunktion beim Verändern des Projekts. 15.29.5 Auslösefunktion Neu Auslösefunktion beim Anlegen eines neuen Datensatzes. 15.29.6 Auslösefunktion Löschen Auslösefunktion beim Löschen eines Datensatzes. 15.29.7 Vergleichsfunktion Zum Vergleichen von Datensätzen einer Tabelle. 15.29.8 Auslösefunktion Feld Auslösefunktion beim Verändern eines Feldes. 15.29.9 Virtuelle Felder Wie Funktionen für virtuelle Felder geschrieben werden. 15.29.10 Berechne-Aktiv-Funktion Berechnung des Aktiv-Zustands von Objekten. 15.29.11 Auslösefunktion Doppelklick Auslösefunktion bei Doppelklick in einer virtuellen Liste. 15.29.12 Berechne Listenansicht-Auswahltexte Auslösefuncktion bei Drücken eines Listenansicht-Popups. 15.29.13 Berechne Referenz-Datensätze Auslösefuncktion bei Drücken eines Referenzen-Popups.
Nach dem Öffnen eines Projekts durchsucht MUIbase das Programm des Projekts
nach einer Funktion mit dem Namen onOpen
.
Existiert eine solche Funktion, dann wird diese ohne Parameter aufgerufen.
(DEFUN onOpen () (ASKBUTTON NIL "Danke für das Öffnen!" NIL NIL) ) |
Bevor ein Projekt geschlossen wird, durchsucht MUIbase das Programm des
Projekts nach einer Funktion mit dem Namen onClose
.
Existiert eine solche Funktion, dann wird diese ohne Parameter aufgerufen.
In der jetzigen Version wird der Rückgabewert der Funktion ignoriert und das
Projekt unabhängig vom Rückgabewert geschlossen.
Wurden in der Funktion onClose
Änderungen am Projekt durchgeführt,
dann fragt MUIbase nach, ob das Projekt zuerst gespeichert werden soll, bevor
das Projekt geschlossen wird. Wird der Menüpunkt `Projekt - Speichern &
Schließen' zum Schließen des Projekts aufgerufen, dann wird die
Auslösefunktion aufgerufen, bevor das Projekt gespeichert wird, so dass die
Änderungen automatisch gespeichert werden.
(DEFUN onClose () (ASKBUTTON NIL "Auf Wiedersehen!" NIL NIL) ) |
Wird ein Projekt in den Admin- uder Benutzermodus versetzt
und eine Funktion mit dem Namen onAdminMode
existiert im Projektprogramm,
so wird diese Funktion aufgerufen.
Die Funktion erhält ein Argument admin, welches angibt,
ob sich das aktuelle Projekt im Admin- (admin ist nicht NIL)
oder Benutzermods (admin ist NIL) befindet.
(DEFUN onAdminMode (admin) (IF admin (ASKBUTTON NIL "Im Admin-Modus" NIL NIL) (ASKBUTTON NIL "Im Benutzermodus" NIL NIL) ) ) |
Wann immer der Benutzer eine Änderung am Projekt durchführt oder nach dem
Speichern eines Projekts, durchsucht MUIbase das Programm des Projekts nach
einer Funktion mit dem Namen onChange
.
Existiert eine solche Funktion, dann wird diese ohne Parameter aufgerufen.
Dies kann verwendet werden, um die Anzahl der Änderungen zu erfassen, die ein
Benutzer an diesem Projekt durchgeführt hat.
(DEFUN onChange () (SETQ Control.NumChanges (CHANGES)) ) |
Siehe auch onOpen, onClose, onAdminMode, Beispielprojekt `Trigger.mb'.
Sobald der Benutzer einen neuen Datensatz durch Auswählen der Menüpunkte `Neuer Datensatz' oder `Datensatz kopieren' anlegen möchte und die Auslösefunktion `Neu' für diese Tabelle auf eine MUIbase-Funktion gesetzt wurde, dann wird diese Auslösefunktion ausgeführt. Die Auslösefunktion für `Neu' kann im Tabellenfenster (siehe Tabellen erstellen) gesetzt werden.
Die Auslösefunktion erhält NIL oder einen Datensatzzeiger als ersten und
einzigen Parameter. NIL bedeutet, dass der Benutzer einen neuen Datensatz
anlegen möchte und ein Datensatzzeiger zeigt an, dass der Benutzer einen
Datensatz eine Kopie dieses Datensatzes anlegen will. Hat die Auslösefunktion
mehr als einen Parameter, dann werden diese mit NIL vorbelegt. Die
Auslösefunktion sollte nun einen neuen Datensatz mit NEW
(siehe NEW)
anlegen. Der Rückgabewert der Auslösefunktion wird ausgewertet. Ist er ein
Datensatzzeiger, dann wird dieser Datensatz angezeigt.
Die Auslösefunktion `Neu' wird auch aufgerufen, wenn ein
MUIbase-Programm die Funktion NEW*
(siehe NEW*) aufruft.
(DEFUN newRecord (init) (PROG1 ; zum Rückgeben des Ergebnisses von NEW (NEW Table init) ... ) ) |
Sobald der Benutzer einen Datensatz durch Auswählen des Menüpunkts `Datensatz löschen' löschen möchte und die Auslösefunktion `Löschen' für diese Tabelle auf eine MUIbase-Funktion gesetzt wurde, dann wird diese Auslösefunktion ausgeführt. Die Auslösefunktion für `Löschen' kann im Tabellenfenster (siehe Tabellen erstellen) gesetzt werden.
Die Auslösefunktion erhält einen Booleschen Parameter als einzigen Parameter.
Ist er nicht NIL, dann sollte die Funktion nachfragen, ob der Benutzer
wirklich diesen Datensatz löschen möchte. Wenn er es möchte, dann sollte die
Funktion DELETE
(siehe DELETE) zum Löschen des Datensatzes aufrufen.
Die Auslösefunktion `Delete' wird auch aufgerufen, wenn ein
MUIbase-Programm die Funktion DELETE*
(siehe DELETE*) aufruft..
(DEFUN deleteRecord (requester) (DELETE Table requester) ) |
Um eine Sortierung von Datensätzen einer Tabelle zu definieren, kann eine Vergleichsfunktion verwendet werden. Siehe Sortierung ändern, für Informationen wie eine solche Funktion für eine Tabelle spezifiziert werden kann. Die Vergleichsfunktion erhält zwei Datensatzzeiger als Argumente und liefert eine Ganzzahl zurück, die das Sortierverhältnis der beiden Datensätze anzeigt. Die Vergleichsfunktion sollte einen Wert kleiner 0 liefern, wenn ihr erstes Argument kleiner ist als das zweite; 0, wenn sie gleich sind und einen Wert größer 0, wenn das erste Argument größer ist als das zweite.
Angenommen, man hat eine Tabelle `Persons' mit dem Zeichenkettenfeld `Name', dann könnte man folgende Funktion zum Vergleich zweier Datensätze verwenden:
(DEFUN cmpPersons (rec1:Persons rec2:Persons) (CMP rec1.Name rec2.Name) ) |
Mit einer Vergleichsfunktion lassen sich sehr komplexe Sortierungen definieren. Man achte jedoch darauf, keine rekursiven Funktionsaufrufe zu erzeugen, die sich selbst aufrufen. MUIbase wird seine Programmausführung anhalten und dies mit einer Fehlermeldung quittieren, sollte so etwas versucht werden. Auch sollten keine Befehle verwendet werden, die Seiteneffekte erzeugen könnten, wie z.B. einen Wert einem Feld zuweisen.
Wird eine Vergleichsfunktion verwendet, dann weiß MUIbase nicht immer, wann es die Datensätze neu zu sortieren hat. Nehmen wir im obigen Beispiel zusätzlich an, dass es die Tabelle `Toys' mit dem Zeichenkettenfeld `Name' und das Beziehungsfeld `Owner' gibt, das auf `Persons' verweist. Zudem nehmen wir folgende Vergleichsfunktion an:
(DEFUN cmpToys (rec1:Toys rec2:Toys) (CMP* rec1.Owner rec2.Owner) ) |
Ändert nun der Benutzer einen Datensatz in der Tabelle `Persons' und dieser Datensatz erhält eine neue Position, dann müssten auch Datensätze in `Toys' neu sortiert werden, die auf diesen Datensatz verweisen. MUIbase kennt jedoch diese Abhängigkeit nicht.
Neben der Verwendung des Menüpunktes `Tabelle - Alle Datensätze neu sortieren' auf die Tabelle `Toys' zum Neusortieren kann auch ein automatisches Neusortieren implementiert werden, indem folgende Auslösefunktion für das Feld `Name' der Tabelle `Persons' festgelegt wird:
(DEFUN setName (newValue) (SETQ Persons.Name newValue) (FOR ALL Toys WHERE (= Toys.Owner Persons) DO (SETISSORTED Toys NIL) ) (REORDER Toys) ) |
Siehe auch Sortieren, GETISSORTED, SETISSORTED, REORDER, REORDERALL, GETORDERSTR, SETORDERSTR, Demo `Order.mb'.
Im Feldfenster (siehe Felder erstellen) kann eine Auslösefunktion definiert werden, die immer dann aufgerufen wird, denn der Benutzer den Inhalt des Feldes ändern möchte.
Wurde eine solche Auslösefunktion definiert und der Benutzer ändert den Wert
dieses Feldes, dann wird der Datensatzinhalt nicht automatisch auf den neuen
Wert gesetzt. Stattdessen wird der Wert als erster Parameter an die
Auslösefunktion übergeben. Die Auslösefunktion kann nun den Wert überprüfen
und ihn ablehnen. Um den Wert im Datensatz zu speichern, muss die Funktion
SETQ
verwendet werden.
Die Auslösefunktion sollte das Ergebnis des SETQ
-Aufrufs
(siehe SETQ) oder den alten Wert des Feldes, wenn sie den neuen Wert
abzulehnt, zurückgeben.
Die Auslösefunktion wird auch ausgeführt, wenn ein MUIbase-Programm die
Funktion SETQ*
(siehe SETQ*) zum Setzen eines Feldwertes
aufruft.
(DEFUN setAmount (amount) (IF some-expression (SETQ Table.Amount amount) (ASKBUTTON NIL "Ungültiger Wert!" NIL NIL) ) Table.Amount ; liefert momentanen Wert zurück ) |
In MUIbase sind virtuelle Felder besondere Felder, deren Inhalt immer dann berechnet wird , wenn er benötigt wird. Wird z.B. zu einem anderen Datensatz gewechselt, indem man auf einen der Pfeile in der Panelleiste einer Tabelle klickt, so wird ein virtuelles Feld in dieser Tabelle automatisch neu berechnet und angezeigt (die entsprechenden Einstellungen für das virtuelle Feld vorausgesetzt, siehe Feldobjekteditor). Zum Berechnen des Wertes wird die Auslösefunktion `Berechne' des Feldes aufgerufen. Diese Auslösefunktion kann im Feldfenster (siehe Typabhängige Einstellungen). festgelegt werden. Der Rückgabewert dieser Funktion definiert den Wert des virtuellen Feldes. Wurde keine `Berechne'-Auslösefunktion für ein virtuelles Feld festgelegt, dann ist der Wert des Feldes NIL.
Man kann auch die Berechnung eines virtuellen Feldes auslösen, indem man einfach in einem MUIbase-Programm darauf zugreift, so dass man z.B. auf Knopfdruck zum Berechnen des Wertes eines virtuellen Feldes wie im folgenden nur eine Funktion für den Knopf festlegen muss:
(DEFUN buttonHook () virtual-attr ) |
SETQ
verwendet:
(SETQ virtual-attr expr) |
SETQ
-Aufruf auf das virtuelle Feld zugegriffen,
dann wird der Wert des virtuellen Feldes neu berechnet.
Der Wert eines virtuellen Feldes wird nicht zwischengespeichert, da nicht einfach festzustellen ist, wann der Wert neu berechnet werden muss und wann nicht. Daher sollte man auf virtuelle Felder möglichst sparsam zugreifen und den Wert in lokalen Variablen für die weitere Verwendung selbst zwischenspeichern.
Für ein Beispiel, wie virtuelle Felder benutzt werden, sehe man sich das Beispielprojekt `Movie.mb' an.
Siehe auch Virtuelles Feld, Beispielprojekt `Movie.db'.
Für Feldobjekte und Fensterknöpfe kann eine Auslösefunktion angegeben werden, welche den Aktivzustand des Objekts berechnet. Siehe Feldobjekteditor und Fenstereditor für Informationen wie diese Auslösefunktion angegeben wird.
Die Auslösefunktion wird ohne Argumente aufgerufen. Gibt die Funktion NIL zurück, so wird das Objekt deaktiv, sonst wird es aktiv.
Zum Beispiel kann die Berechne-Aktiv-Funktion für ein Objekt, das aktiv sein soll, wenn ein bestimmtes virtuelles `Listen'-Feld eine aktive Zeile hat, wie folgt aussehen:
(DEFUN enableObject () (GETVIRTUALLISTACTIVE virtual-list-attr) ) |
Für virtuelle Attribute, welche die Listenanzeige verwenden, kann eine Auslösefunktion angegeben werden, welche immer dann aufgerufen wird, wenn der Benutzer auf ein Listenfeld doppelt klickt. Für Informationen wie eine solche Auslösefunktion für ein virtuelles Attribut angegeben werden kann, siehe Feldobjekteditor.
Die Auslösefunktion wird mit drei Argumenten aufgerufen. Das erste Argument gibt die Zeilenummer beginnend mit 1 für die erste Zeile an (Zeile 0 enthält den Listenkopf). Das zweite Argument enthält die Spaltennummer beginnend mit 0. Das dritte Argument ist ein Zeiger auf den Datensatz, aus dem das Listenfeld erzeugt wurde, oder NIL, falls der Eintrag nicht direkt aus einem Datensatz stammt. Der Rückgabewert der Funktion wird ignoriert.
Ein typisches Beispiel für eine Doppelklick-Auslösefunktion ist das folgende.
(DEFUN doubleClickTrigger (row col rec:Table) ... ) |
Falls es mehr als eine Tabelle gibt, auf die sich das Datensatzargument beziehen könnte, so ist folgende Konstruktion, welche Typprädikate zu verschiedenen Tabellen einsetzt, nützlich.
(DEFUN doubleClickTrigger (row col rec) (COND ((RECP Table1 rec) (SETQ Table1 rec) ...) ((RECP Table2 rec) (SETQ Table2 rec) ...) ... ) ) |
(DEFUN doubleClickTrigger (row col) (PRINT (NTH col (NTH row virtual-attr))) ) |
Für Zeichenkettenfelder kann neben dem GUI-Element ein Listenansicht-Popup-Knopf plaziert werden, welcher bei Drücken eine Liste von Auswahltexten anzeigt, aus welcher der Benutzer wählen kann. Die Auswahltexte in dieser Liste können statisch sein, oder aber durch eine Auslösefunktion berechnet werden. Siehe Feldobjekteditor für mehr Informationen, wie zwischen statischen und berechneten Auswahltexten ausgewählt werden kann und wie die Auslösefunktion angegeben wird.
Die Auslösefunktion zur Berechnung der Auswahltexte hat keine Argumente. Sie gibt einen Memo-Text, bei der jede Zeile eine Beschriftung enthält, oder NIL für keine Beschriftungen zurück.
Zum Beispiel kann die Berechnungsfunktion wie folgt aussehen:
(DEFUN computeLabels () "Tokio\nMünchen\nLos Angeles\nRom" ) |
Für Referenz-Felder wird neben dem GUI-Element für gewöhnlich ein Popup-Knopf angebracht, welcher bei Drücken eine Liste von Datensätzen anzeigt, aus welcher der Benutzer wählen kann. Die Liste dieser Datensätze kann durch eine Auslösefunktion berechnet werden. Siehe Feldobjekteditor für mehr Informationen, wie die Auslösefunktion für Referenz-Felder angegeben wird.
Die Auslösefunktion zur Berechnung der Datensatzliste hat keine Argumente. Sie gibt einen Liste zurück, welche nach Datensätzen der referenzierten Tabelle durchsucht wird. Jeder solche gefundene Datensatz wird in die anzuzeigende Liste mit aufgenommen. Einträge, die keine Datensätze sind, werden stillschweigend ignoriert.
Eine typische Funktion zur Berechnung der Referenz-Datensatzliste ist das folgende Beispiel. Gegeben sei ein Projekt mit einer Tabelle `Person', welches ein Boolesches Feld `Female' enthält. Dann zeigt die folgende Berechnungsfunktion nur die weiblichen Personen im Referenz-Popup an:
(DEFUN computeFemaleRecords () (SELECT Person FROM Person WHERE Female) ) |
Die folgenden Funktionen sind seit MUIbase Version 2.7 veraltet.
GETDISABLED
SETDISABLED
GETWINDOWDISABLED
SETWINDOWDISABLED
Veraltete Funktionen arbeiten nicht mehr wie erwartet und ein Aufruf wird entweder ignoriert (was einer Null-Operation entspricht), ein Warn-Dialog wird geöffnet, oder ein Fehler wird generiert. Menüpunkt `Programm - Veraltete Funktionen' legt das genaue Vorgehen fest (siehe Veraltete Funktionen).
Es wird empfohlen, alle veralteten Funktionen im Projekt-Programm zu entfernen, und die Funktionalität über die Aktiv/Inaktiv-Einstellung der Feldobjekte und Fensterknöpfe zu realisieren (siehe Berechne-Aktiv-Funktion).
[ << ] | [ >> ] | [Anfang] | [Inhalt] | [Index] | [ ? ] |