Whitespace (Programmiersprache)

Whitespace ist eine relativ junge esoterische Programmiersprache. Die Befehle und Steueranweisungen bestehen im Gegensatz zu üblichen Programmiersprachen aus definierten Folgen von Leerzeichen, Tabs und Zeilenumbrüchen (engl. Whitespaces). Neben dieser offensichtlichen Eigenart verwendet Whitespace das übliche Dualsystem nur für Daten; der Programmcode wird in einem dreiwertigen Stellensystem („l“, „t“, „u“ oder engl. “s”, “t”, “l”) abgebildet.

Syntax

Die Befehle und Steueranweisungen bestehen aus definierten Folgen von Leerzeichen (l), Horizontal-Tabulatorzeichen (t) und Zeilenumbrüchen (u).

Es gibt kein Syntaxelement zur Kennzeichnung von Kommentaren. Stattdessen können Kommentare, die selbst keine Whitespaces enthalten dürfen, an beliebigen Stellen im Quellcode eingegeben werden. Der Interpreter ignoriert alle Zeichen, die für ihn keine Bedeutung haben.

Befehle

Die Befehle lassen sich grob in fünf Bereiche einteilen:

Zeichen	Bedeutung
l	Stack-Zugriff
tl	Rechenfunktionen
tt	Heap-Speicher-Zugriff
u	Schleifen, Sprünge, Bedingungen
tu	Ein- /Ausgabe von Werten

Eine genaue Beschreibung der einzelnen Befehle inklusive erwarteter Parameter befindet sich auf der unten genannten Webseite.

Daten

Während die Befehle ein dreiwertiges Stellensystem verwenden, werden die Daten im dualen System abgebildet: An der ersten Stelle von links steht ein t für eine negative Zahl; ein l für eine positive. Im weiteren Verlauf steht t für 1 und l für 0. Die Spezifikation besagt, dass Zahlen eine beliebige Bitlänge haben können, allerdings können Compiler und Interpreter hier eine sinnvolle Obergrenze festlegen. Abgeschlossen wird ein Datum durch einen Zeilenumbruch.

Sprache

Whitespace ist eine imperative, stackbasierte Programmiersprache, die den Programmierern einen Stack und Heap zur Verfügung stellt.

Alle Operationen arbeiten intern auf Ganzzahlen beliebiger Bit-Länge. Es besteht allerdings die Möglichkeit, ein Zeichen auszugeben, das durch seinen ASCII-Code-Wert identifiziert wird (outchar).

Geschichte und Hintergrund

Whitespace wurde ursrpünglich dazu entwickelt, um dem Primaten "Orang-Utan-Syphullius-Nigerianicus" das programmieren zu erleichtern

Hello World

Das oben dargestellte „Hello, world!“-Programm:

 lllullltlltllluttlllltulllttlltltuttlllltlulllttlttlluttllllttulllttlttlluttllll
 tllulllttlttttuttlllltltullltlttlluttllllttlullltllllluttlllltttullltttltttuttll
 lltlllulllttlttttuttlllltlltullltttlltluttlllltltlulllttlttlluttlllltlttulllttll
 tlluttllllttllullltlllltuttllllttltulllttltuttlllltttlullltltluttllllttttullllut
 tllllluulllltulultttlulutlltlutullllltutlllululltuullltluuuu

Entwicklungsumgebungen

Der Editor Vim bietet von Haus aus ein Syntax-Highlighting für Whitespace an, wodurch die Programmierung deutlich vereinfacht wird. Dies läuft allerdings einem Designziel der Sprache, beim Ausdruck möglichst wenig Tinte zu verbrauchen, entgegen. Einen Mode für Emacs gibt es bei den Weblinks.

Das oben und unten dargestellte "Hello, world!" kann mit einem der folgenden Skripts in richtiges Whitespace konvertiert werden:

 #!/bin/sh
 sed "s/ //g;s|//.*||g;s/\\n//g" $1 | tr -d '\n' | sed "s/l/ /g;s/t/\t/g;s/u/\n/g"

 #!/bin/sh
 sed "s|//.*||g" < $1 | tr -d " \t\n" | tr ltu " \t\n"

sed ist ein Unix-Werkzeug zur Bearbeitung von Text.

Whitespace-Assembler

Da der Umgang mit trinär kodierten Maschinenbefehlen relativ mühsam ist, wird häufig ein äquivalenter Assembler-Dialekt verwendet:

 // "Hello, world!" in den Speicher schreiben
 lllu          // push 0   // Speicherstelle 0
 llltlltlllu   // push 'H' // Zeichen 'H'
 ttl           // store    // in den Speicher
 llltu         // push 1   // ...
 lllttlltltu   // push 'e'
 ttl           // store
 llltlu        // push 2
 lllttlttllu   // push 'l'
 ttl           // store
[…]
 lllttllu      // push 12
 llltlllltu    // push '!'
 ttl           // store
 lllttltu      // push 13
 lllttltu      // push \r
 ttl           // store
 llltttlu      // push 14
 llltltlu      // push \n
 ttl           // store
 lllttttu      // push 15
 llllu         // push 0
 ttl           // store

 // Ausgabe-Schleife:
 llllu         // push 0
 ulllltu       // 1:          // /Schleife
    lul           // dup      // | --.
    ttt           // pop      // |   --- Spitze des Stacks untersuchen
    lul           // dup      // | --'
    utlltlu       // jz 2     // | ----> bei 0 sind wir fertig
    tull          // outchar  // | ----> Ausgabe
    llltu         // push 1   // | --._. Speicherstelle hochzaehlen
    tlll          // add      // | --'
 ululltu       // jmp 1       //  \naechster Durchlauf
 ullltlu       // 2:          //
 uuu           // halt        // ende

Literatur

Oliver Lau: Hexenwerk – Ein Plädoyer für esoterische Programmiersprachen: In: c’t, 22/2007, S. 192–199.

Weblinks

The Whitespace Homepage (Memento vom 26. April 2015 im Internet Archive)
Tutorial auf compsoc.dur.ac.uk
Emacs-Mode auf compsoc.dur.ac.uk
Whitespace-Interpreter

Einzelnachweise