| [ << ] | [ >> ] | [Anfang] | [Inhalt] | [Index] | [ ? ] |
Dieses Kapitel(22) 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(23) Programme geschrieben haben(24).
15.1 Programmeditor Wo ein MUIbase-Programm eingegeben wird. 15.2 Vorverarbeitung Einfügedateien, bedingte Kompilation und Konstanten. 15.3 Programmiersprache Der Aufbau der Ausdrücke. Funktionen 15.4 Befehle definieren Funktionen- und Variablendefinitionen. 15.5 Programmsteuerungsfunktionen Schleifen, bedingte Ausdrücke und mehr. 15.6 Typaussagen Feststellen des Typs eines Ausdrucks. 15.7 Typumwandlungsfunktionen Typen umwandeln. 15.8 Boolesche Funktionen AND, OR, und NOT. 15.9 Vergleichsfunktionen Werte von Ausdrücken vergleichen. 15.10 Mathematik-Funktionen Addieren, Multiplizieren, etc. 15.11 Zeichenkettenfunktionen Nützliches Zeug für Zeichenketten. 15.12 Funktionen für mehrzeilige Texte Nützliches Zeug für mehrzeilige Texte. 15.13 Listenfunktionen Listenverarbeitungsbefehle. 15.14 Benutzereingabefunktionen Den Benutzer nach Eingaben fragen. 15.15 E/A-Funktionen Dateiein- und -ausgabebefehle. 15.16 Datensatzfunktionen Nützliches Zeug für Datensätze. 15.17 Feldfunktionen Verändern von Feldern. 15.18 Tabellenfunktionen Verändern von Tabellen. 15.19 Oberflächenfunktionen Verändern der Benutzeroberfläche. 15.20 Projektfunktionen Informationen über das aktuelle Projekt erhalten. 15.21 Systemfunktionen Betriebssystembezogene Funktionen. 15.22 Variablen Vordefinierte Variablen. 15.23 Konstanten Vordefinierte Werte von Konstanten. Nützliche Informationen 15.24 Funktionale Parameter Funktionen als Argumente in Funktionsaufrufen verwenden. 15.25 Typdeklarierer Typen für lokale Variablen. 15.26 Aufbau von Ausdrücken Die Bedeutung eines Ausdrucks. 15.27 Auslösefunktionen Wie Auslösefunktionen benutzt werden. Funktionsverzeichnis Übersicht aller Funktionen.
Um ein Programm für ein Projekt einzugeben, öffnet man den Programmeditor über den Menüpunkt `Programm - Ändern...'. Dies öffnet das Fenster `Ändere Programm' mit:
Der Programmeditor ist ein asynchrones 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 ein Sicherheitsfenster, das um Bestätigung fragt, ob das Fenster geschlossen werden darf.
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 Einfügedatei gemacht wurden und diese Änderungen in das Projektprogramm einfließen sollen.
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 muß. Leerzeichen und Tabulatoren können nach dem begonnenen # folgen.
15.2.1 #define Konstanten definieren. 15.2.2 #undef Konstanten un-definieren. 15.2.3 #include Externe Dateien einfügen. 15.2.4 #if Bedingte Kompilation. 15.2.5 #ifdef Bedingte Kompilation. 15.2.6 #ifndef Bedingte Kompilation. 15.2.7 #elif Bedingte Kompilation. 15.2.8 #else Bedingte Kompilation. 15.2.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, daß 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, daß 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, daß 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 muß
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.3.1 Warum Lisp? Die Vorteile von Lisp. 15.3.2 Lisp-Aufbau Aufbau der Programmiersprache. 15.3.3 Programmarten Verschiedene verwendete Arten von Programmen in MUIbase. 15.3.4 Namenskonventionen Namenskonventionen für Programmsymbole. 15.3.5 Datensatzinhalte ansprechen Felder und Tabellen in Programmen verwenden. 15.3.6 Datentypen zum Programmieren Verfügbare Datentypen zum Programmieren. 15.3.7 Konstanten Konstante Ausdrücke. 15.3.8 Befehlsaufbau Aufbau der Beschreibung aller Befehle.
Der Vorteil einer lisp-ähnlichen Sprache ist, daß 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, wie etwas berechnet werden soll(25). 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 paßt oder die man lieber mag.
Ein lisp-Ausdruck ist entweder eine Konstante, eine Variable oder ein
Funktionsausdruck.
Beim Funktionsaufruf verwendet lisp eine
Prefix-Notation(26).
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 (27) aufgerufen, das bedeutet, daß 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, muß 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(29) 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 `Foo'(30), 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 muß 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üßte man `::Bar' eingeben, um auf die Tabelle zuzugreifen.
Um Pfade und ihre Anordnungen besser zu verstehen, betrachten wir hier als Beispiel, daß 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, daß 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, daß die Tabelle `Bar' zwei Datensätze hat. Der eine enthält im Feld `Name' den Eintrag `Mats'(31) 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 `Mats' und `Bar.Name' liefert `Steffen'.
Die Programmiersprache von MUIbase kennt die folgenden Datentypen:
Typ Beschreibung
Bool 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.
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 Es gibt keine konstanten Werte, sondern stattdessen
nur eine konstante Zeichenkette.
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' ein zweistelliger Wert im Bereich 0 bis 23
ist, der Stunden darstellt, `MM' ein zweistelliger
Wert im Bereich 0 bis 59 ist, der Minuten repräsentiert
und `SS' ein zweistelliger Wert im Bereich 0 bis 59 ist,
der Sekunden anzeigt.
|
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.4.1 DEFUN Funktionsdefinition. 15.4.2 DEFUN* Funktionsdefinition. 15.4.3 DEFVAR Variablendefinition.
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, daß 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.
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 DEFUN, DEFUN*, LET.
Dieser Abschnitt listet Funktionen zur Programmflußkontrolle auf, z.B. Funktionen zum Definieren von lokalen Variablen, Schleifenfunktionen, bedingte Programmausführung, Schleifenkontrollfunktionen und mehr.
15.5.1 PROGN Verbundbefehl, liefert letzten Ausdruck. 15.5.2 PROG1 Verbundbefehl, liefert ersten Ausdruck. 15.5.3 LET Definition lokaler Variablen. 15.5.4 SETQ Setzen von Variablen, Feldern und Tabellen. 15.5.5 SETQ* Setzen von Variablen, Feldern und Tabellen. 15.5.6 FUNCALL Funktionsaufruf. 15.5.7 IF If-then-else bedingte Programmausführung. 15.5.8 CASE Switch-case bedingte Programmausführung. 15.5.9 COND Leistungsfähige bedingte Programmausführung. 15.5.10 DOTIMES Schleife über einen Bereich von Ganzzahlen. 15.5.11 DOLIST Schleife über eine Liste. 15.5.12 DO Gewöhnliche Schleife. 15.5.13 FOR ALL Schleife über eine Menge von Datensätzen. 15.5.14 NEXT Zur nächsten Schleifenausführung springen. 15.5.15 EXIT Schleife verlassen. 15.5.16 RETURN Rückkehr von einer Funktion. 15.5.17 HALT Programmausführung anhalten. 15.5.18 ERROR Programmausführung mit Fehlermeldung abbrechen.
Um mehrere Ausdrücke der Reihe nach auszuführen, wird der
PROGN-Aufruf(32) 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(33).
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ächenzeigers: `(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, daß 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 wird verwendet, um eine Funktion aufzurufen.
|
FUNCALL liefert den Rückgabewert des Funktionsaufrufes oder NIL, wenn
fun-expr NIL ist.
Mehr Informationen über funktionale Ausdrücke, siehe Funktionale Parameter.
IF ist ein Bedingungsoperator.
|
Diese Funktion ist nicht strikt, das bedeutet, daß 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 paßt.
Wird ein passender Fallausdruck gefunden, dann werden die dazugehörigen
Ausdrücke ausgeführt und der Wert des letzten Ausdrucks zurückgeliefert.
Paßt 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
muß 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 muß 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.7.1 STR Umwandlung in eine Zeichenkette. 15.7.2 MEMO Umwandlung in einen mehrzeiligen Text. 15.7.3 INT Umwandlung in eine Ganzzahl. 15.7.4 REAL Umwandlung in eine Fließkommazahl. 15.7.5 DATE Umwandlung in ein Datum. 15.7.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.
Bool 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 Adreßzeigers(36)
|
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. Führende
und folgende Leerzeichen werden ignoriert.
Stellt es keine Ganzzahl dar, wird NIL geliefert.
mehrzeiliger Text Analog Zeichenkette.
Ganzzahl Der Wert selbst.
Fließkommazahl Wenn der Wert im Ganzzahlbereich liegt, wird der
Fließkommazahlenwert gerundet und geliefert, anderenfalls NIL.
Auswahltext Die interne Nummer (beginnend bei 0) des aktuellen 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 Programmausführung
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
(37).
|
Typ Rückgabewert
Zeichenkette Wenn die gesamte Zeichenkette einen Datumswert 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 Zeichenkette.
Ganzzahl Ein Datumswert wird erzeugt, wenn die gegebene Ganzzahl 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 Ganzzahl.
Datum Der Wert selbst.
NIL NIL
Andere Eine Fehlermeldung wird erzeugt und die Programmausführung
abgebrochen.
|
TIME wird verwendet, um einen Ausdruck in einen Zeitwert umzuwandeln.
|
Type Return value
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 Zeichenkette.
Ganzzahl Ein Zeitwert wird erzeugt, wenn die gegebene Ganzzahl die
Anzahl der Sekunden seit 00:00:00 darstellt. Die Ganzzahl
modulo der Anzahl der Sekunden pro Tag wird hergenommen,
d.h. z.B. `(TIME 86400)' liefert 00:00:00.
Fließkommazahl Analog Ganzzahl.
Zeit Der Wert selbst.
NIL NIL
Andere Eine Fehlermeldung wird erzeugt und die Programmausführung
abgebrochen.
|
Dieser Abschnitt listet die booleschen Operatoren auf.
15.8.1 AND Vereinigung von booleschen Werten. 15.8.2 OR Verknüpfung von booleschen Werten. 15.8.3 NOT Invertierung eines booleschen Wertes.
AND prüft, ob alle seine Parameter TRUE sind.
|
Diese Funktion ist nicht strikt, dies bedeutet, daß 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, daß 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 (39).
15.9.1 Relationsoperatoren =, <>, <, >, <=, >= und ihre Versionen mit Stern. 15.9.2 CMP Liefert eine Ganzzahl, die eine Sortierung repräsentiert. 15.9.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 < ... < 23:59:59
Bool 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, daß der Rückgabewert immer -1, 0 oder 1 ist!
Beispiel: `(CMP "Bike" "bIKE")' liefert -32.
Siehe auch CMP*, Relationsoperatoren.
CMP* ist die Stern-Version von CMP.
Der Unterschied ist, daß 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.10.1 + Addieren von Werten. 15.10.2 - Subtrahieren von Werten. 15.10.3 1+ Erhöhen von Werten. 15.10.4 1- Verringern von Werten. 15.10.5 * Fließkomma-Multiplikation. 15.10.6 / Fließkomma-Division. 15.10.7 DIV Ganzzahl-Division. 15.10.8 MOD Ganzzahl-Modulo. 15.10.9 MAX Maximum-Ausdruck. 15.10.10 MIN Minimum-Ausdruck. 15.10.11 ABS Absoluter Wert eines Ausdrucks. 15.10.12 TRUNC Nachkommastellen einer Fließkommazahl abschneiden. 15.10.13 ROUND Eine Fließkommazahl runden. 15.10.14 RANDOM Zufallszahlengenerator.
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 aufgefaßt 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 Ergenis NIL.
Ist expr vom Typ Zeit und der Rest der Parameter sind Ganz-/Fließkommazahlen, dann wird die Summe der Ganz-/Fließkommazahlen als Anzahl Sekunden aufgefaßt und zu expr addiert. Es können jedoch in den restlichen Parametern Ausdrücke vom Typ Zeit vorhanden sein. Das zurückgelieferte Ergebnis wird modulo 24:00:00 genommen.
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) 02: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 392.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... |
Dieser Abschnitt behandelt Funktionen für Zeichenketten.
15.11.1 LEN Zeichenkettenlänge. 15.11.2 LEFTSTR Linke Teilzeichenkette. 15.11.3 RIGHTSTR Rechte Teilzeichenkette. 15.11.4 MIDSTR Individuelle Teilzeichenkette. 15.11.5 SETMIDSTR Teilzeichenkette setzen. 15.11.6 INSMIDSTR Zeichenkette einfügen. 15.11.7 INDEXSTR erstes Auftreten einer Teilzeichenkette, zeichengrößenabhängig. 15.11.8 INDEXSTR* erstes Auftreten einer Teilzeichenkette, zeichengrößenunabhängig. 15.11.9 INDEXBRK erstes Auftreten eines Zeichens, zeichengrößenabhängig. 15.11.10 INDEXBRK* erstes Auftreten eines Zeichens, zeichengrößenunabhängig. 15.11.11 RINDEXSTR letztes Auftreten einer Teilzeichenkette, zeichengrößenabhängig. 15.11.12 RINDEXSTR* letztes Auftreten einer Teilzeichenkette, zeichengrößenunabhängig. 15.11.13 RINDEXBRK letztes Auftreten eines Zeichens, zeichengrößenabhängig. 15.11.14 RINDEXBRK* letztes Auftreten eines Zeichens, zeichengrößenunabhängig. 15.11.15 REPLACESTR Teilzeichenketten ersetzen. 15.11.16 REMCHARS Zeichen aus Zeichenkette entfernen. 15.11.17 TRIMSTR Umgebende Leerzeichen entfernen. 15.11.18 WORD Wort aus Zeichenkette holen. 15.11.19 WORDS Anzahl Wörter in einer Zeichenkette. 15.11.20 CONCAT Zeichenketten verbinden. 15.11.21 CONCAT2 Zeichenketten verbinden. 15.11.22 COPYSTR Erzeugt Kopien einer Zeichenkette. 15.11.23 UPPER Zeichenkette in Großbuchstaben. 15.11.24 LOWER Zeichenkette in Kleinbuchstaben. 15.11.25 ASC ASCII-Wert eines Zeichens. 15.11.26 CHR Zeichen eines ASCII-Werts. 15.11.27 LIKE Zeichenkettenvergleich. 15.11.28 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 daß 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 daß 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 (43).
Siehe auch RINDEXSTR*, INDEXSTR, INDEXSTR*, RINDEXBRK, RINDEXBRK*.
RINDEXSTR* hat den selben Effekt als RINDEXSTR
(siehe RINDEXSTR), außer daß 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 daß der Zeichenvergleich nicht auf
Groß-/Kleinschreibung achtet.
Siehe auch RINDEXBRK, INDEXBRK, INDEXBRK*, RINDEXSTR, RINDEXSTR*.
REPLACESTR ersetzt Teilzeichenketten durch andere.
|
Beispiel: `(REPLACESTR "From Freiburg to San Francisco" "Fr" "X")' liefert "Xom Xeiburg to San Xancisco".
Siehe auch 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 Leerzeichen von einer
Zeichenkette.
|
Beispiel: (TRIMSTR " Ich fuhr Selmas Fahrrad zu Schrott. ") liefert
"Ich fuhr Selmas Fahrrad zu Schrott.".
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.
CONCAT verbindet Zeichenketten.
|
Beispiele: `(CONCAT "Ich" "dachte," "es" "war" "ein "verlassenes" "Fahrrad.")' liefert "Ich dachte, es war ein verlassenes Fahrrad.".
Siehe auch CONCAT2, +, COPYSTR, SPRINTF.
CONCAT2 verbindet Zeichenketten.
|
Beispiel: `(CONCAT2 "! " "Aber" "es" "war es nicht!")' liefert "Aber! es! war es nicht!".
Siehe auch CONCAT, +, COPYSTR, SPRINTF.
COPYSTR erzeugt Kopien einer Zeichenkette.
|
Beispiel: `(COPYSTR "+-" 5)' liefert "+-+-+-+-+-"
Siehe auch CONCAT CONCAT2, +, SPRINTF.
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 ihren ASCII-Code.
|
Beispiel: (ASC "A") liefert 65.
CHR wandelt einen ASCII-Code in ein Zeichen um.
|
Beispiel: `(CHR 99)' liefert to "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, daß 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) " 003 " (SPRINTF "%f" 12) "12.00" (SPRINTF "%10e 12.0) " 1.20e+1" (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.12.1 LINE Eine Zeile aus einem mehrzeiligen Text holen. 15.12.2 LINES Die Anzahl der Zeilen im mehrzeiligen Text. 15.12.3 MEMOTOLIST Einen mehrzeiligen Text in eine Liste wandeln. 15.12.4 LISTTOMEMO Eine Liste in einen mehrzeiligen Text wandeln. 15.12.5 FILLMEMO Einen mehrzeiligen Text füllen. 15.12.6 FORMATMEMO Einen mehrzeiligen Text formatieren. 15.12.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.
|
Beispiel: `(MEMOTOLIST "Meine Versicherung\nzahlt für\ndas kaputte Fahrrad.")' liefert ( "Meine Versicherung" "zahlt für" "das kaputte Fahrrad." ).
Siehe auch LISTTOMEMO.
LISTTOMEMO wandelt eine Liste in einen mehrzeiligen Text um.
|
Beispiel: `(LISTTOMEMO (LIST "Silke" "leiht mir" "'mein' Fahrrad" "bis zum" 01.09.1998)' liefert: "Silke\nleiht mir\n'mein' Fahrrad\nbis zum\n01.09.1998".
Siehe auch 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(48).
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 listet Funktionen zum Verarbeiten von Listen auf.
15.13.1 CONS Elementarer Listenkonstruktor. 15.13.2 LIST Erzeugt Liste aus Elementen. 15.13.3 LENGTH Liefert Anzahl Elemente einer Liste. 15.13.4 FIRST Holt das erste Element aus einer Liste. 15.13.5 REST Liefert den Rest einer Liste. 15.13.6 LAST Holt das letzte Element aus einer Liste. 15.13.7 NTH Holt das n-te Element aus einer Liste. 15.13.8 APPEND Verbindet Listen. 15.13.9 REVERSE Kehrt die Elementreihenfolge einer Liste um. 15.13.10 MAPFIRST Anwenden einer Funktion auf alle Listenelemente. 15.13.11 SORTLIST Sortiert die Elemente einer Liste. 15.13.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, daß 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.14.1 ASKFILE Abfragen eines Dateinamens. 15.14.2 ASKDIR Abfragen eines Verzeichnisnamens. 15.14.3 ASKSTR Abfragen einer Zeichenkette. 15.14.4 ASKINT Abfragen einer Ganzzahl. 15.14.5 ASKCHOICE Abfragen eines Elements aus vielen. 15.14.6 ASKCHOICESTR Abfragen einer Zeichenkette und bietet vorgegebene an. 15.14.7 ASKOPTIONS Abfragen mehrere Elemente aus vielen. 15.14.8 ASKBUTTON Auswahl eines Knopfdrucks. 15.14.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.
|
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))
)
)
)
|
ASKCHOICESTR fragt den Benutzer nach einer Zeichenkette und bietet
vorgegebene an.
|
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 fragt den Benutzer nach mehreren aus einer Liste von
Elementen.
|
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 Amiga")) 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"
"Du hast nun schon für fünf\nStunden mit deinem Amiga gespielt.\nGeh ins Bett!"
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.15.1 FOPEN Öffnet eine Datei zum Lesen/Schreiben. 15.15.2 FCLOSE Schließt eine Datei. 15.15.3 stdout Standard-Ausgabedateihandler. 15.15.4 PRINT Gibt einen Ausdruck nach stdout aus. 15.15.5 PRINTF Formatierte Ausgabe nach stdout. 15.15.6 FPRINTF Formatierte Ausgabe in eine Datei. 15.15.7 FERROR Fehlerprüfung einer Datei. 15.15.8 FEOF Ende-Erkennung einer Datei. 15.15.9 FSEEK Setzt Position in einer Datei. 15.15.10 FTELL Ermittelt Position in einer Datei. 15.15.11 FGETCHAR Liest das nächste Eingabezeichen aus einer Datei. 15.15.12 FGETCHARS Liest mehrere Eingabezeichen aus einer Datei. 15.15.13 FGETSTR Liest eine Zeichenkette aus einer Datei. 15.15.14 FGETMEMO Liest einen mehrzeiligen Text aus einer Datei. 15.15.15 FPUTCHAR Schreibt ein Zeichen in eine Datei. 15.15.16 FPUTSTR Schreibt eine Zeichenkette in eine Datei. 15.15.17 FPUTMEMO Schreibt einen mehrzeiligen Text in eine Datei. 15.15.18 FFLUSH Leert den Schreibpuffer einer Datei.
FOPEN öffnet eine Datei zum Lesen/Schreiben.
|
FOPEN liefert bei Erfolg einen Dateihandler. Schlug er fehl, wird NIL
geliefert. Sind filename oder mode NIL, dann wird NIL
zurückgeliefert.
Beispiel: `(FOPEN "PRT:" "w")' öffnet und liefert einen Dateihandle zum Drucker.
Siehe auch FCLOSE, stdout, FFLUSH.
FCLOSE schließt eine Datei.
|
Die globale Variable stdout trägt den Dateihandle zur Standardausgabe
von MUIbase. Der Ausgabedateinamen kann im Menüpunkt `Programm -
Ausgabedatei...' gesetzt werden. Man kann `PRT:' verwenden, um die
Ausgabe zum Drucken zu schicken oder `CON:////Output/CLOSE/WAIT' für die
Ausgabe in ein (neues) Shellfenster.
Beim ersten Zugriff auf diese Variable (entweder direkt, z.B. durch den Aufruf von `(FPRINTF stdout ...)' oder indirekt, z.B. durch den Aufruf von `(PRINTF ...)') wird die Datei 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 einfach nur Berechnungen und Änderungen an einigen Datensätzen durchgeführt werden.
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.
Siehe auch FTELL, Vordefinierte Konstanten.
FTELL liefert die Schreib-/Leseposition der Datei.
|
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.16.1 NEW Neuen Datensatz anlegen. 15.16.2 NEW* Neuen Datensatz durch Aufruf der Auslösefunktion anlegen. 15.16.3 DELETE Datensatz löschen. 15.16.4 DELETE* Datensatz durch Aufruf der Auslösefunktion löschen. 15.16.5 DELETEALL Löschen aller Datensätze einer Tabelle. 15.16.6 GETMATCHFILTER Holt den Zustand der Filterübereinstimmung eines Datensatzes. 15.16.7 SETMATCHFILTER Setzt den Zustand der Filterübereinstimmung eines Datensatzes. 15.16.8 GETISSORTED Prüft, ob ein Datensatz einsortiert ist. 15.16.9 SETISSORTED Übergibt einem Datensatz den Sortierstatus. 15.16.10 RECNUM Holt die Nummer eines Datensatzes. 15.16.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, daß 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.17.1 ATTRNAME Holen des Namens eines Feldes. 15.17.2 MAXLEN Maximale Anzahl von Zeichen eines Zeichenkettenfeldes. 15.17.3 GETLABELS Holen der Auswahltexte eines Auswahl- oder Zeichenkettenfeldes. 15.17.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äßt 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 Listenansicht-Auswahltexte des gegebenen Zeichenkettenfeldes auf sets the list-view labels of the specifies string attribute to `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.18.1 TABLENAME Holen des Tabellennamens. 15.18.2 GETORDERSTR Holen der Datensatzreihenfolge. 15.18.3 SETORDERSTR Setzen der Datensatzreihenfolge. 15.18.4 REORDER Unsortierte Datensätze neu sortieren. 15.18.5 REORDERALL Alle Datensätze einer Tabelle neu sortieren. 15.18.6 GETFILTERACTIVE Holen des Datensatzfilterstatus. 15.18.7 SETFILTERACTIVE Setzen des Datensatzfilterstatus. 15.18.8 GETFILTERSTR Holen des Datensatzfilterausdrucks. 15.18.9 SETFILTERSTR Setzen des Datensatzfilterausdrucks. 15.18.10 RECORDS Anzahl der Datensätze. 15.18.11 RECORD Holen eines Zeigers auf einen Datensatz. 15.18.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, daß 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 muß 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 muß 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, daß 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 muß 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, daß 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, daß 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.19.1 SETCURSOR Setzt den Cursor auf ein GUI-Element. 15.19.2 GETDISABLED Holt den Inaktiv-Status eines GUI-Elements. 15.19.3 SETDISABLED Setzt den Inaktiv-Status eines GUI-Elements. 15.19.4 GETWINDOWDISABLED Holt den Inaktiv-Status eines Fensters. 15.19.5 SETWINDOWDISABLED Setzt den Inaktiv-Status eines Fensters. 15.19.6 GETWINDOWOPEN Holt den Geöffnet/Geschlossen-Status eines Fensters. 15.19.7 SETWINDOWOPEN Öffnen/Schließen eines Fensters.
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.
GETDISABLED liefert den Inaktiv-Status eines Feldes.
|
Siehe auch SETDISABLED, GETWINDOWDISABLED.
SETDISABLED setzt den Inaktiv-Status eines Feldes.
|
Siehe auch GETDISABLED, SETWINDOWDISABLED.
GETWINDOWDISABLED liefert den Inaktiv-Status eines Fensters.
|
Siehe auch SETWINDOWDISABLED, GETWINDOWOPEN, GETDISABLED.
SETWINDOWDISABLED setzt den Inaktiv-Status eines Fensters.
|
SETWINDOWDISABLED liefert den neuen Inaktiv-Status des Fensters.
Siehe auch GETWINDOWDISABLED, SETWINDOWOPEN, SETDISABLED.
GETWINDOWOPEN liefert den Geöffnet-Status eines Fensters.
|
Siehe auch SETWINDOWOPEN, GETWINDOWDISABLED.
SETWINDOWOPEN öffnet und schließt ein Fenster.
|
SETWINDOWOPEN liefert den neuen Geöffnet-Status des Fensters.
Siehe auch GETWINDOWOPEN, SETWINDOWDISABLED.
Dieser Abschnitt listet Funktionen auf, die mit Projekten zu tun haben.
15.20.1 PROJECTNAME Holt den Projektnamen. 15.20.2 CHANGES Holt die Anzahl bisher gemachter Änderungen.
PROJECTNAME liefert den Projektnamen.
|
PROJECTNAME liefert den Namen des aktuellen Projekts als
Zeichenkette oder NIL, wenn noch kein Name definiert wurde.
Siehe auch CHANGES.
CHANGES liefert die Anzahl der bisher gemachten Änderungen am
aktuellen Projekt.
|
Siehe auch PROJECTNAME.
Dieser Abschnitt listet Funktionen auf, die auf das Betriebssystem zugreifen.
15.21.1 EDIT Startet asynchron den externen Editor. 15.21.2 EDIT* Startet synchron den externen Editor. 15.21.3 VIEW Startet asynchron den externen Anzeiger. 15.21.4 VIEW* Startet synchron den externen Anzeiger. 15.21.5 SYSTEM Startet externe Befehle. 15.21.6 STAT Untersucht eine Datei. 15.21.7 TACKON Erzeugt einen Pfadnamen aus Verzeichnis- und Dateinamen. 15.21.9 DIRNAME Ermittelt das Verzeichnis von einem Pfad. 15.21.8 FILENAME Ermittelt die letzte Komponente eines Pfades. 15.21.10 TODAY Holt das aktuelle Datum. 15.21.11 NOW Holt die aktuelle Uhrzeit. 15.21.12 MESSAGE Gibt Meldungen aus. 15.21.13 GC Erzwingt das Aufräumen des Speichers.
EDIT startet den externen Editor.
|
EDIT
starten den externen Editor asynchron, das bedeutet, die Funktion kehrt
sofort wieder zurück (und wartet nicht auf das Ende des Editors).
EDIT liefert TRUE, wenn der Editor erfolgreich gestartet werden
konnte, anderenfalls NIL.
Siehe auch EDIT*, VIEW, SYSTEM.
EDIT* ist die Version von EDIT mit dem Stern und hat den selben
Effekt wie EDIT (siehe EDIT).
Der einzige Unterschied ist, daß EDIT* den externen Editor synchron
startet und wartet, bis der Benutzer den Editor verlassen hat.
Siehe auch EDIT, VIEW*, SYSTEM.
VIEW startet den externen Anzeiger.
|
VIEW
starten den externen Anzeiger asynchron, das bedeutet, die Funktion kehrt
sofort wieder zurück (und wartet nicht auf das Ende des Anzeigers).
VIEW liefert TRUE, wenn der Anzeiger erfolgreich gestartet werden
konnte, anderenfalls NIL.
Siehe auch VIEW*, EDIT, SYSTEM.
VIEW* ist die Version von VIEW mit dem Stern und hat den selben
Effekt wie VIEW (siehe VIEW).
Der einzige Unterschied ist, daß VIEW* den externen Anzeiger synchron
startet und wartet, bis der Benutzer den Anzeiger verlassen hat.
Siehe auch VIEW, EDIT*, SYSTEM.
SYSTEM ruft ein externes Programm auf.
|
SPRINTF
(siehe SPRINTF) erzeugt.
SYSTEM wartet, bis das aufgerufene Programm beendet wurde.
Wenn nicht gewünscht ist, daß SYSTEM warten soll, dann benutzt man
eine Befehlszeile, die das Programm im Hintergrund startet.
SYSTEM liefert bei Erfolg TRUE, anderenfalls NIL, wenn z.B. die
Befehlszeile nicht ausgeführt werden konnte oder der aufgerufene Befehl einen
Fehlercode lieferte.
Beispiel: `(SYSTEM "run %s %s" "clock" "digital")' startet die Systemuhr mit Digitalmodus als Hintergrundprozeß.
Siehe auch EDIT, EDIT*, VIEW, 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(61)
TACKON erzeugt einen Pfadnamen.
|
TACKON weiß, wie es mit Doppelpunkten und Schrägstrichen
(Slashes) in dirname umzugehen hat. Es liefert den Pfadnamen
als Zeichekette oder NIL, wenn dirname oder filename NIL
ist.
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".
TODAY liefert das heutige Datum.
|
Siehe auch NOW.
NOW liefert die aktuelle Uhrzeit.
|
Siehe auch TODAY.
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))'.
GC erzwingt das Aufräumen des Speichers(62).
|
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, muß 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 anwenden und
) # neue Liste erzeugen
)
(REVERSE res) # die Liste muß nun umgekehrt werden
)
)
|
`(map (LIST 1 2 3 4) 1+)' liefert ( 2 3 4 5 ).
Es ist möglich, den Typ einer lokalen 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, daß 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, daß 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 lokalen Variable. Lokale Variablen können mit z.B.
LET (siehe LET) definiert werden.
Verwendet den Datensatzzeiger von localvar, 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.27.1 onOpen Auslösefunktion nach dem Öffnen eines Projekts. 15.27.2 onClose Auslösefunktion beim Schließen eines Projekts. 15.27.3 onChange Auslösefunktion beim Verändern des Projekts. 15.27.4 Auslösefunktion Neu Auslösefunktion beim Anlegen eines neuen Datensatzes. 15.27.5 Auslösefunktion Löschen Auslösefunktion beim Löschen eines Datensatzes. 15.27.6 Vergleichsfunktion Zum Vergleichen von Datensätzen einer Tabelle. 15.27.7 Auslösefunktion Feld Auslösefunktion beim Verändern eines Feldes. 15.27.8 Virtuelle Felder Wie Funktionen für virtuelle Felder geschrieben werden.
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 daß die
Änderungen automatisch gespeichert werden.
(DEFUN onClose ()
(ASKBUTTON NIL "Auf Wiedersehen!" 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, 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, daß der Benutzer einen neuen Datensatz
anlegen möchte und ein Datensatzzeiger zeigt an, daß 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, die zwei Datensatzzeiger als Argumente erhält und eine Ganzzahl zurückliefert, 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, daß 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üßten 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, muß 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, die ihren Inhalt nebenbei berechnen, 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 und ein virtuelles Feld in dieser Tabelle das Flag `Sofort' (siehe Feldobjekteditor) gesetzt hat, dann wird der Wert dieses Feldes berechnet und dargestellt. 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 daß man z.B. auf Knopfdruck zum Berechnen des Wertes eines virtuellen Feldes wie im folgenden nur eine Funktion für den Knopf festlegen muß:
(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 muß 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'.
| [ << ] | [ >> ] | [Anfang] | [Inhalt] | [Index] | [ ? ] |