-h

Usage-Information

-c

Ausgeben des SeL-Objektcodes auf die Standardausgabe (Compile-Only-Modus)

-r <Dateiname>

Ausführen einer SeL-Objektcode-Datei (Runtime-Only-Modus)

-e

Ausgabe interner Konfigurationsoptionen

-f=<Feldname> <Datei>

Der Inhalt des Feldes Feldname (der SeL-Quelltext) in der Datei Datei wird zurückgegeben. Jede andere Ausgabe des Interpreters wird unterdrückt. Die Ausgabe enthält immer auch das abschließende Semikolon der Felddefinition.

Interpreter, Compile- und Runtime-Modus

sel -c datei.sel

wird datei.sel nicht ausgeführt, wie das normalerweise der Fall wäre, sondern nur in ein Zwischenformat ("Objektcode") compiliert und dieser Objektcode wird auf die Standardausgabe geschrieben. Man kann ihn auch, etwa mit:

sel -c datei.sel > datei.sco

in eine zweite Datei speichern (.sco steht hier für "SeL compiled object", die Erweiterungen sind aber, wie immer in SeL, frei wählbar).

Compilierte SeL-Dateien haben einige interessante Eigenschaften:

• Sie sind etwas kleiner als die reinen Quelltexte
• Sie sind wesentlich schneller in der Ausführung, gerade wenn sie mehrere oder sehr umfangreiche Masterfiles verwenden
• Alle lib-Anweisungen darin sind bereits aufgelöst worden, d.h. diese Dateien sind ohne die Bibliotheken und Masterfiles lauffähig
• Der Nachteil von letzterem ist jedoch, daß compilierte Dateien nicht mehr auf die Masterfile-Override-Anweisungen reagieren; d.h. man muß, wenn man weiterhin verschiedene Masterfiles verwenden will, pro Masterfile eine Objekt-Datei erzeugen
• Sie lassen sich mit einem sehr einfachen Interpreter (einer SeL stack machine) ausführen. Im Moment gibt es nur den mit SeL mitgelieferten Interpreter; es wäre jedoch denkbar, eine solche stack machine in Java zu implementieren und compilierte Obketdateien dann im Browser des Benutzers ablaufen zu lassen, was sowohl die Serverlast verringern als auch dem Benutzer erlauben würde, SeL-Dateien offline zu lesen.

  (Die genaue Spezifikation der SeL stack machine ist beim Autor erhältlich).

sel -r datei.sco

ausgeführt werden.

Zum Vergleich hier der Geschwindigkeitsgewinn bei Verwendung von compilierten Objektdateien gegenüber normalen SeL-Dateien. Die Messungen wurden mehrfach mit derselben Datei durchgeführt (der GhK-Homepage); das Ausgabeformat ist das des Unix-Kommandos "time".

Timings für SeL-Quelltext: real 0m0.603s user 0m0.430s sys 0m0.100s real 0m0.570s user 0m0.440s sys 0m0.060s real 0m0.577s user 0m0.450s sys 0m0.060s real 0m0.557s user 0m0.420s sys 0m0.090s real 0m0.563s user 0m0.450s sys 0m0.070s real 0m0.572s user 0m0.450s sys 0m0.080s real 0m0.565s user 0m0.430s sys 0m0.080s real 0m0.567s user 0m0.440s sys 0m0.060s real 0m0.562s user 0m0.430s sys 0m0.080s real 0m0.555s user 0m0.430s sys 0m0.070s

Timings für compilierte Objektdatei: real 0m0.204s user 0m0.100s sys 0m0.030s real 0m0.188s user 0m0.090s sys 0m0.050s real 0m0.172s user 0m0.090s sys 0m0.040s real 0m0.168s user 0m0.090s sys 0m0.050s real 0m0.168s user 0m0.100s sys 0m0.040s real 0m0.186s user 0m0.090s sys 0m0.060s real 0m0.170s user 0m0.100s sys 0m0.040s real 0m0.168s user 0m0.100s sys 0m0.050s real 0m0.164s user 0m0.090s sys 0m0.050s real 0m0.183s user 0m0.090s sys 0m0.040s

Datentypen

Variablen müssen vor der Verwendung nicht deklariert werden, aber sie müssen einen Wert zugewiesen bekommen, bevor man sie abfragen kann. Das Referenzieren einer nicht initialisierten Variable ergibt eine Fehlermeldung des Interpreters!

Strings können in SeL grundsätzlich beliebig lang sein und mehrere Zeilen umfassen.

Zuweisungen

=GRUSS "Hallo";

Hier weisen wir der Variable GRUSS den Wert "Hallo" zu. Groß- und Kleinschreibung bei Variablennamen wird unterschieden, d.h. "gruss", "Gruss", und "GRUSS" sind verschiedene Variablen. Alle drei Variablennamen sind in SeL zulässig, aber wir empfehlen (im Sinne der Benutzer) alle Variablen in einem Masterfile konsistent auf die eine oder andere Weise zu schreiben. Im WWW-Angebot der GhK werden alle Variablennamen großgeschrieben.

Jede Zuweisung endet mit einem Semikolon (";"). Das Semikolon ist für die korrekte Interpretation der Zuweisung erforderlich, weil man in SeL Zuweisungen schachteln kann (s.u.). Ein vergessenes Semikolon wird in vielen Fällen keinen Syntaxfehler hervorrufen, weil die Zuweisung aus der Sicht von SeL legal sein wird. Man wird allerdings dadurch eine unerwartete Schachtelung der Zuweisungen erhalten, die später zu Folgefehlern oder einem abenteuerlichen Verhalten der SeL-Datei führen wird. Achten Sie also bitte immer auf den korrekten Abschluß Ihrer Zuweisungen.

Einer Variable können mehrfach Werte zugewiesen werden. Die alten Werte werden dadurch überschrieben:

=GRUSS "Hallo"; =GRUSS "Guten Tag";

Die Variable GRUSS hat nach dieser Sequenz den Wert "Guten Tag".

Anführungsstriche und SQD

=GRUSS "Er sagte "Hallo"";

Das funktioniert nicht, weil die Anführungsstriche vor dem Wort "Hallo" von SeL als das Ende der Zeichenkette "Er sagte " interpretiert werden. Möchte man Anführungsstriche innerhalb einer Zeichenkette verwenden, so muß man die Zeichenkette mit der Sequenz <SQD> statt mit Anführungsstrichen begrenzen:

=GRUSS <SQD>Er sagte "Hallo"</SQD>;

SQD steht für "Sel Quoted Data" und funktioniert wie ein HTML-Tag. Der Beginn der Zeichenkette wird durch <SQD>, das Ende durch </SQD> angegeben. Innerhalb einer SQD-Sequenz können Anführungsstriche verwendet werden, ebenso wie innerhalb einer durch Anführungsstriche begrenzten Zeichenkette die Zeichenfolge "<SQD>" vorkommen kann:

=GRUSS "Zum Begrenzen von Zeichenketten kann man <SQD> benutzen!";

Innerhalb einer Zeichenkette können Zeilenumbrüche vorkommen. Sie werden als Teil der Zeichenkette übernommen:

=GRUSS "Erste Zeile Zweite Zeile Dritte Zeile" ;

Diese Zeichenkette umfasst also drei Zeilen. Das abschließende Semikolon sollte man in solchen Fällen am besten in eine eigene Zeile schreiben, damit es für den Leser der Datei besser sichtbar ist. Dem Interpreter ist es gleichgültig, wo das Semikolon plaziert wird, aber die Datei bleibt so besser lesbar.

Anführungsstriche und SQD sind in SeL fast immer gleichbedeutend. Der einzige Unterschied tritt bei der Verwendung von HTML-Triggern (s.u.) auf.

Kommentare

Kommentare werden wie in der Sprache C geschrieben, und dürfen (wie dort) nicht geschachtelt werden. Sie werden eingeleitet durch die Zeichenfolge /* und durch */ abgeschlossen:

/* Hier machen wie eine dreizeilige Zuweisung. Das hier ist übrigens ein Kommentar. */ =GRUSS "Erste Zeile Zweite Zeile Dritte Zeile" ;

Kommentare können beliebig lang sein und mehrere Zeilen umfassen.

Eine weitere Form des Kommentars ist die "#if 0"-Anweisung. Da Kommentare nicht geschachtelt werden können, gibt es ein der Sprache C entlehntes Konstrukt, das in der Lage ist, ganze Blöcke von Anweisungen, einschließlich aller evtl. darin vorhandener Kommentare auszukommentieren. Das ist besonders praktisch, wenn während der Entwicklung eines SeL-Programms testweise ein Teil der Datei deaktiviert werden soll. So funktioniert es:

#if 0 /* Hier machen wie eine dreizeilige Zuweisung. Das hier ist übrigens ein Kommentar. */ =GRUSS "Erste Zeile Zweite Zeile Dritte Zeile" ; #endif =GRUSS "Hallo";

Alles zwischen "#if 0" und "#endif" wird einfach ignoriert. Der so auskommentierte Dateiabschnitt kann beliebig lang sein und seinerseits (wie im Beispiel) Kommentare enthalten (aber keine "#endif"-Sequenz!). Möchte man den auskommentierten Dateiabschnitt probeweise aktivieren, so muß man nur die "0" durch "1" ersetzen:

#if 1 /* Hier machen wie eine dreizeilige Zuweisung. Das hier ist übrigens ein Kommentar. */ =GRUSS "Erste Zeile Zweite Zeile Dritte Zeile" ; #endif =GRUSS "Hallo";

Jetzt ist die ganze Datei aktiv, gerade so als stünde das "#if"-Konstrukt übehaupt nicht da.

Im Gegensatz zur Sprache C werden keine weiteren Ausdrücke nach dem "#if" ausgewertet. Nur die Werte "0" und "1" sind zulässig.

Referenzieren von Variablen

$GRUSS

Dieser Ausdruck wird durch den gegenwärtigen Wert der Variable GRUSS ersetzt.

Implizite Verkettung von Werten

=NAME "Andreas"; =GRUSS "Hallo, mein Name ist "$NAME;

Der Wert der Variable GRUSS wäre hier: "Hallo, mein Name ist Andreas".

Durch die implizite Verkettung von Werten können Zuweisungen sehr lang und komplex werden. Innerhalb der rechten Seite einer Zuweisung können Variablenwerte eingesetzt, Funktionen aufgerufen, Schleifen durchlaufen werden (diese Dinge werden im einzelnen weiter unten besprochen), und alle diese Konstrukte geben Werte zurück, die in die Zuweisung aufgenommen werden. Hier folgt ein Beispiel für eine komplexe Zuweisung. Das Beispiel ist im Detail mit dem bisher gesagten nicht verständlich, aber es soll einen Eindruck davon vermitteln, wie eine komplexe Zuweisung in SeL aussehen kann:

=c if ($a!=$b) then "Ungleich" else "Gleich" fi " " $_env("PATH") " " <SQD>Und jetzt ein substring von "Hallo", beginnend mit Zeichen 1 und 3 Zeichen lang: </SQD> $_copy( "Hallo", 1, 3 ) <SQD> Dasselbe nur mit einer Laenge von 99 Zeichen: </SQD> $_copy( "Hallo", 1, 99 ) " Das Zeichen Nummer 4 (sollte o sein): " $_copy( "Hallo", 4, 1 ) " Mal sehen, wo de in uni-kassel.de matcht: " $_match( "uni-kassel.de", "de" ) " Mal sehen, wo com in uni-kassel.de matcht: " $_match( "uni-kassel.de", "com" ) " Mal sehen, wo kassel in uni-kassel.de matcht: " $_match( "uni-kassel.de", "kassel" ) " Und jetzt nochmal die vier letzten Zeichen von Hallo: " =startpos $_len("Hallo")-4; $_copy( "Hallo", $startpos, 999 ) ;

Und noch ein letzter wichtiger Punkt: der Wert einer Zuweisung ist eine leere Zeichenkette:

=a "A"; =b =b1 "B1"; =b2 "B2"; ; =c $a$b;

Der Wert von c in diesem Beispiel wäre "A" (und sonst nichts), weil die Variable b selber nur die zwei leeren Zeichenketten der beiden Zuweisungen zugewiesen bekommt. b1 und b2 haben zwar jeweils eine nicht-leere Zeichenkette als Wert, b jedoch ist zwar deklariert, enthält jedoch nur einen leeren String ("").

Startsymbole

Die genaue Ablaufsteuerung in einem SeL-Programm ist formal etwas unübersichtlich; sie ist so konzipiert worden, daß sie im konkreten Anwendungsbereich (der Erstellung hierarchisch designter WWW-Seiten) möglichst natürlich wirkt. Betrachten wir zum Anfang einen einfachen Fall. Später werden wir uns mit den Details der Ausführungsreihenfolge von Variablen und Funktionen mit und ohne Masterfiles befassen.

Ein Startsymbol ist syntaktisch dadurch gekennzeichnet, daß es eine mit einem Punkt abgeschlossene Variablenreferenz ist. Hier ein erstes Beispiel eines vollständigen SeL-Programms:

=a "Hallo "; =b "Welt"; =c $a$b; $c.

Das Startsymbol ist hier der Ausdruck "$c". Das SeL-Programm läuft zunächst durch bis zum Startsymbol, macht aber keinerlei Ausgabe. Die einzige Ausgabe eines jeden SeL-Programms ist der Wert seines Startsymbols.

Das Programm beginnt also seine sichtbare Ausführung beim Ausdruck "$c". Das "$c" wird evaluiert und expandiert zu "$a$b". $a wiederum ist "Hallo " und $b hat den Wert "Welt". Also ist $c gleich "Hallo Welt", und da $c der Startausdruck ist, wird dieser Wert auch als Ausgabe des SeL-Programms erscheinen.

Streng genommen muß ein SeL-Programm keinen Startausdruck haben. Folgendes Programm ist syntaktisch korrekt:

=a "Hallo "; =b "Welt"; =c $a$b;

Dieses Programm gibt soviel aus wie ein C-Programm ohne main()-Funktion, nämlich gar nichts. SeL-Programme ohne Startsymbol sind also alleine nicht besonders hilfreich :) aber sie können in manchen Fällen sinnvoll sein: nämlich wenn das Startsymbol in einer Bibliothek verborgen ist (s.u.). Das wird in realen WWW-Server-Umgebungen in der Regel der Fall sein.

Ablaufmodell mit Variablen und Funktionen

!a(void) "Hallo "; !b(void) "Welt"; =c $a()$b(); $c.

Dieses Programm produziert dieselbe Ausgabe wie das entsprechende Programm mit Variablen, nämlich "Hallo Welt". Im Unterschied zu einer Variablenzuweisung (die mit dem Operator "=" eingeleitet wird) werden Funktionen mit dem Operator "!" deklariert. Aufgerufen werden sie mit einer Klammer hinter dem Funktionsnamen. Details zur Schreibweise folgen im Abschnitt über selbstdefinierte Funktionen weiter unten.

Was uns hier interessiert, ist der Programmablauf. Auch hier wird zuerst das Startsymbol "$c" evaluiert, und das ruft widerum die Funktionen "a" und "b" auf, die die Werte "Hallo " und "Welt" erzeugen. Soweit klingt alles sehr ähnlich dem Programm mit den Variablen, und die Ausgaben der beiden Programme sind auch gleich. Wo nun liegt der Unterschied?

In einem Satz: Variablenzuweisungen werden in dem Moment vollzogen, wo der Interpreter der Zuweisung begegnet; Funktionen werden erst dann ausgeführt, wenn sie aufgerufen werden. Hier noch einmal die beiden Programmversionen, diesmal mit Zeilennummern. Wir werden im folgenden den Ablauf der beiden Versionen anhand dieser Zeilennummern besprechen. Die Zeilennummern dienen nur dieser Diskussion und sind natürlich nicht Teil des jeweiligen Programms.

Variante A: Variablen

A1: =a "Hallo "; A2: =b "Welt"; A3: =c $a$b; A4: $c.

Variante B: Funktionen

B1: !a(void) "Hallo "; B2: !b(void) "Welt"; B3: =c $a()$b(); B4: $c.

Das Programm A läuft so ab: A1,A2,A3,A4. In jedem Schritt stehen die jeweils zugewiesenen Variablenwerte für die folgenden Zeilen zur Verfügung. Variante B hingegen wird folgendermaßen ausgeführt: B3,B1,B2,B4. Die Funktionen werden also nicht sofort ausgeführt, sondern erst wenn sie aufgerufen werden. Die darin berechneten Werte stehen erst nach Aufruf der Funktion zur Verfügung. Dafür kann aber eine Funktion auch Werte verwenden, die erst "weiter unten" im Programm berechnet werden, solange sie nur zum Zeitpunkt ihres Aufrufs zur Verfügung stehen. Variablenzuweisungen können hingegen nur mit Werten arbeiten, die vorher im Programm ("weiter oben") festgelegt wurden, und die sich während des Ablaufs nicht mehr ändern.

Man kann das ganze so zusammenfassen: die sicherste Art ein SeL-Programm zu schreiben, ist mit Funktionen. Sie funktionieren unter allen Bedingungen eher so, wie man das erwartet. Allerdings sind sie etwas schwerfälliger zu formulieren und sie sind langsamer in der Ausführung als Variablenzuweisungen (weil sie bei mehrfachen Aufrufen auch mehrfach durchlaufen werden). Der Autor, der das oben gesagte verstanden hat, kann also gezielt seine Programme optimieren, indem er geeignete Funktionen durch Variablenzuweisungen ersetzt.

Bibliotheken werden in ein SeL-Programm mit der Anweisung lib eingebunden, z.B.:

lib "ghk.mas";

Betrachten wir wieder ein einfaches Beispiel, das bereits das Zusammenspiel von Masterfile (Bibliothek) und Inhaltsdatei (aufrufendes SeL-Programm) verdeutlicht:

Bibliothek test.mas

fwd NAME; !main(void) "Ihr Name ist: "$NAME ; $main().

Inhaltsdatei test.sel

lib "test.mas"; =NAME "Andreas";

Die Ausgabe dieses SeL-Programms test.sel ist "Ihr Name ist: Andreas". Wir sehen, daß das SeL-Programm zwar kein Startsymbol hat, dafür ist aber eines in der Bibliothek: "main()". Dieses Symbol wird aufgrufen, die gleichnamige Funktion ausgeführt, und die oben genannte Zeichenkette als Ergebnis ausgegeben. Es ist wichtig, daß Sie verstehen, daß das Startsymbol in diesem Fall eine Funktion sein muß! Es hätte nicht funktioniert, wenn das Symbol "main" eine Variable gewesen wäre, weil sie sonst evaluiert worden wäre, bevor ein Wert für das Symbol "NAME" zur Verfügung gestanden hätte! Nur durch die Eigenschaft von Funktionen, erst dann ausgeführt zu werden, wenn sie aufgerufen werden, wird die Verwendung einer Variable, die erst später definiert wird, innerhalb einer Funktion möglich.

Außerdem benötigen wir in diesem Fall eine sogenannte Forward-Deklaraion des Symbols NAME (erste Zeile des Masterfiles). Die genaue Bedeutung einer solchen Forward-Deklaration wird im nächsten Abschnitt besprochen.

Es gibt weiterhin die Möglichkeit, ähnlich wie in C, Bibliotheken zu inkludieren, um bestimmte, in SeL selbst nicht enthaltene Funktionen zu nutzen. Ein Beispiel ist die mitgelieferte Datei percentbars.lib. Nachdem sie mit "lib" inkludiert wurde, steht im weiteren Programmablauf die Funktion $percentbar (da es sich nicht um eine eingebaute Funktion handelt, beginnt der Funktionsname nicht mit "$_") zur Verfügung. Diese Funktion gibt auf der Basis übergebender Argumente HTML-Code zurück, der im Browser als Prozent-Balken gerendert wird.

lib "percentbars.lib"; =BAR $percentbar("42","0","CENTER");

Ergebnis:

42%

Anhand des mitgelieferten Beispiels können leicht weitere Bibliotheken geschrieben und weitergegeben werden. Bitte dokumentieren Sie Syntax und Funktionalität Ihrer Funktionen in einem Kommentar im Kopf der Bibliothek und beachten Sie die im Beispiel eingehaltene Namenskonvention für Variablennamen in Bibliotheken: Variablennamen beginnen hier immer mit "lib.", es folgt der Name der Bibliothek, dann einem weiteren "." und schließlich einer frei wählbaren Zeichenkette (z.B. lib.percentbars.type). Wenn Sie nützliche Funktionen entwickelt haben, die Sie mit anderen SeL-Nutzern teilen wollen, können Sie sie an uns senden und wir werden sie in der SeL-Distribution veröffentlichen (eMail-Adressen am Anfang dieser Dokumentation).

Forward-Deklarationen

File ./test.mas Line 3: Error: Reference to undefined symbol /main/NAME at `NAME'

In der Tat ist das die Meldung, die wir bekommen, wenn wir im zuletzt vorgstellten Masterfile die "fwd"-Zeile entfernen. Was ist passiert? Der Interpreter liest als erstes die SeL-Datei test.sel und findet darin die "lib"-Anweisung. Daraufhin sucht er nach der Bibliothek test.mas und fängt an, diese zu lesen. Dort stößt er irgendwann auf die Zeile:

"Ihr Name ist: "$NAME

und stellt fest, daß in dieser Zeile eine unbekannte Variable "NAME" auftritt. Das ist eigentlich kein Problem, weil die Variable jetzt ja noch nicht gebraucht wird. Das Startsymbol wird erst aufgerufen, wenn die ganze Datei gelesen wurde, und dann wird das Symbol "NAME" auch existieren. Unglücklicherweise braucht der Interpreter aber schon vorher, um das Programm übersetzen zu können, eine Speicheradresse für jede Variable. Diese Adresse wird angelegt, wenn die Variable einen ersten Wert zugewiesen bekommt. Da das nicht geschehen ist, kann hier die Abfrage nicht übersetzt werden, weil ja diese Variable zu diesem Zeitpunkt des Übersetzens dem Interpreter noch nie begegnet ist.

Jetzt sind wir bei der "fwd"-Anweisung angelangt. Mit

fwd NAME;

können wir SeL mitteilen, daß jetzt schon eine Adresse für eine Variable angelegt werden soll, die erst später zugewiesen wird. Es ist also sozusagen eine reine Deklaration ohne Wertzuweisung, oder, mit wieder anderen Worten, dieses Vorgehen ist immer erforderlich, wenn eine Variable abgefragt (referenziert) wird, bevor sie zum ersten Mal zugewiesen wird. Alternativ hätten wir auch schreiben können:

=NAME "";

in der ersten Zeile des Masterfiles. Auch das hätte eine gültige Variable erzeugt, und das Problem wäre nicht aufgetreten. Die "fwd"-Anweisung ist bloß praktischer, weil man damit eine beliebige Anzahl von Variablen vordeklarieren kann:

fwd LAYOUT INDEX URL KEYWORDS TITLE AUTHOR MAILTO DATE INSTITUTION INSTLOGO ADDRESS WIDTH UPLINK HELP HELPURL SEARCH SEARCHURL REMINDER SCRIPT CONTENT LANGUAGE LOCATION ADDTOBODY;

(das ist ein Ausschnitt aus dem Masterfile der GhK). Wir sehen, daß wir alle im Masterfile genutzten Variablen, die erst in der SeL-Datei des Benutzers zugewiesen werden, hier mit einem einzigen "fwd" deklariert haben. Auch das "fwd" wird, wie die meisten SeL-Anweisungen, mit einem Semikolon abgeschlossen.

Falls Sie Turbo-Pascal kennen, werden Sie die "fwd"-Anweisung, die in Pascal eine FORWARD-Deklaration ist, wiedererkennen. Auch C hat ein ähnliches Konstrukt: die extern-Deklaration von Variablen.

=GRUSS if ($NAME=="Andreas") then "Hallo" else "Guten Tag" fi ;

Was passiert hier? Der Schlüssel zum Verständnis dieser Zeilen liegt darin, daß wir uns erinnern, daß jede SeL-Anweisung einen Ergebniswert hat. So auch die "if"-Anweisung. Der ganze "if"-Block evaluiert zu einem "Hallo", wenn die Variable "NAME" den Wert "Andreas" hat, und sonst zu "Guten Tag". Dieser Ergebniswert von "if" wird dann der Variable "GRUSS" zugewiesen (natürlich mußß die Variable NAME in diesem Fall irgendwo anders im Programm einen Wert zugewiesen bekommen). "if"-Konstrukte machen also (wie fast alle anderen Anweisungen von SeL auch) nur innerhalb einer Zuweisung Sinn.

Der else-Zweig ist optional und kann entfallen:

=GRUSS if ($NAME=="Andreas") then "Hallo" fi ;

In diesem Fall würde, wenn NAME gleich "Andreas" ist, GRUSS den Wert "Hallo" bekommen, sonst eine leere Zeichenkette. Im folgenden Abschnitt werden wir einige Operatoren kennelernen, die man in "if"-Anweisungen verwenden kann.

=ZAHLEN
	for (i,1,9) do
	    $i" "
	done 
;

Manchmal möchte man eine "for"-Schleife in anderen Schritten als 1 zählen lassen. Dazu kann man das vierte (optionale) Argument der Schleife verwenden: die Schrittweite (step). Ein Beispiel:

=ZAHLEN for (i,9,1,"-2") do $i" " done ;

In diesem Fall würde der Variable ZAHLEN die Zeichenkette "9 7 5 3 1 " zugewiesen. Daß die "-2" in Anführungsstrichen eingeschlossen ist, hängt mit einem SeL-Fehler zusammen (vgl. Abschnitt über dokumentierte Fehler), der es erforderlich macht, negative numerische Literale in Anführungsstrichen anzugeben. Wird die Schrittweite überhaupt nicht angegeben, so wird (wie im ersten Beispiel) eine Schrittweite von +1 angenommen.

Simulation einer While-Schleife durch goto

=ERGEBNIS :nochmal "Schleifeninhalt..." if ($weiter()!="nein") then goto nochmal fi ;

Diese Schleife würde der Variable ERGEBNIS einen Wert der Art: "Schleifeninhalt...Schlefeninhalt...Schleifeninhalt..." so oft zuweisen, bis die Funktion weiter() den Wert "nein" zurückgibt.

Eine Positionsmarkierung (label) wird durch:

:Markierungsname

definiert. Mit:

goto Markierungsname

kann man später wieder dahin zurückspringen.

Um den Namensraum übersichtlich zu halten, beginnen die Namen aller vordefinierten Funktionen mit einem Unterstrich ("_"). Vermeiden Sie es also, Namen, die mit einem Unterstrich beginnen, an benutzerdefinierte Funktionen zu vergeben. Dadurch vermeiden Sie Namenskonflikte zwischen vor- und benutzerdefinierten Funktionen.

Arithmetische Funktionen

Stringfunktionen

System- und Dateifunktionen

HTTP-Funktionen

Verschiedene Funktionen

Zusätzliche Präprozessor-Anweisungen

Referenzieren von ungültigen Array-Elementen

Benutzerdefinierte Funktionen

Referenzieren von Funktionen als Variablen

HTML-Trigger

Trigger entsprechen in ihrer Funktionalität damit etwa den HTML-Style-Sheets, werden aber vollständig innerhalb von SeL (und damit serverseitig) behandelt, ohne daß der Browser des Benutzers damit in Berührung kommt.

Trigger werden durch die Anweisung html_trigger definiert:

html_trigger tag;

wobei tag zu ersetzen ist durch das HTML-Tag, das abgefangen werden soll. Das Tag muß dabei ohne die spitzen Klammern angegeben werden. Wollen wir das Tag <H1> abfangen, würden wir also schreiben:

html_trigger H1;

Mehrere Trigger können mit mehreren html_trigger-Anweisungen gesetzt werden:

html_trigger H1; html_trigger H2; html_trigger BODY;

Für jedes Tag, das abgefangen werden soll, müssen nun eine oder zwei SeL-Funktionen definiert werden. Diese haben immer festgelegte Namen:

html_start_tag( attributes )

und

html_end_tag( attributes )

wobei tag zu ersetzen ist durch das Tag, wie es in der html_trigger-Anweisung angegeben wurde; also z.B.:

!html_start_H1( attributes ) ... ... ;

Die Start-Funktion wird vom Interpreter aufgerufen, wenn der Beginn des Trigger-Tags gefunden wird; die End-Funktion, wenn das Ende angetroffen wird. Bei Tags, die kein Ende haben (z.B. <LI>), würde es im Prinzip also genügen, eine Start-Funktion zu definieren. Da man aber nicht ausschließen kann, daß eine Benutzerdatei auch ein </LI> enthält (und da das auch normalerweise von den Browsern toleriert wird) sollte man zur Sicherheit immer auch eine leere End-Funktion mitdefinieren.

Die Trigger-Funktionen bekommen immer einen Parameter von SeL übergeben: die Attribute des Tags (z.B. BGCOLOR im BODY-Tag). Hat das Tag keine Attribute, so wird ein leerer String übergeben.

Der Rückgabewert der Trigger-Funktion wird statt des ursprünglichen Trigger-Tags in den Quelltext des SeL-Programms eingefügt und dann wird die Compilierung fortgesetzt. Trigger-Tags können also durch beliebig komplexe SeL-Anweisungsfolgen ersetzt werden.

Wichtig:

Beachten Sie bitte auch, daß SeL keine Kenntnis bestimmter HTML-Tags hat, d.h. die Trigger sprechen auch auf nicht standardgemäße Pseudotags an. Man kann also bei Bedarf eigene Tags erfinden und diese mittels Trigger in SeL behandeln.

Ein Beispiel für die Verwendung von Triggern liegt als test19.sel der Distribution bei.