2dbf - Offizielle Spezifikation

2dbf lässt sich vergleichen mit einer Schnur, die man in einem bestimmten
Muster ausbreitet. Die Richtung der Schnur bestimmt dabei, welches Kommando
ausgeführt wird. Die 8 möglichen Richtungen der Schnur werden hierbei jeweils
einem Befehl der Programmiersprache Brainfuck gleichgesetzt. Sollen mehrere
gleiche Befehle hintereinander ausgeführt werden, lässt sich dies durch
Ziffern (vergleichbar mit Knoten in der Schnur) realisieren. Die Länge eines
Richtungsabschnittes auf der Schnur hat keine Auswirkung drauf, wie oft der
Befehl ausgeführt wird, nur die Quersumme der im Richtungsabschnitt ingesamt
vorhanden Ziffern bestimmt dies. Findet(/n) sich keine Ziffer(n) am Anfang
des Richtungswechsels, wird ein Richtungswechsel als genau ein Befehl
interpretiert (Spätere Ziffern werden dann aber immer noch hinzuaddiert).
Leitet man einen Richtungswechsel mit 0 ein wird dieser nicht beachtet. Auf
diese Weise kann man sich Platz schaffen.

Die Sprache kennt außerdem nur 3 Gruppen von Zeichen. Leerzeichen, Ziffern,
und den Rest. Leerzeichen haben nur eine isolierende Bedeutung. Sie schirmen
die Gruppe "Rest" von sich selber ab.

2dbf arbeitet nicht linear, es wird also nicht Zeile für Zeile abgearbeitet.
Die Anweisungsfolge ergibt sich aus den Verknüpfungen. Um wieder zurück auf
die Schnur zu kommen: Der Interpreter folgt einfach dem Muster der Schnur
(angefangen oben links, Zeile 1, Zeichen 1). Treten Überschneidungen auf,
geht der Faden den Weg weiter, den er bereits gegangen war (kommt er von
rechts unten, geht er weiter nach links oben), sofern dies möglich ist. Er
versucht also möglichst seine Richtung beizubehalten. Ist dies nicht
möglich, bricht das Programm ab.
Verzweigungen wie
         *
        *
********
        *
         *
sind also nicht möglich, da nicht eindeutig definiert wird, wo das Programm
fortfahren soll. Dies führt zum Abbruch.
Bei Abschnitten wie
*
 *
  *
*******
    *
     *
ist jedoch eindeutig definiert, wo die Schnur ihre Laufbahn fortsetzt.

Das Ende eines Programmes ist ein absolut isloliertes Ende der Schnur, wie
z.B.
*  <- Anfang
 *
  *
   *           *  <- Ende
    *         *
     *5555552*


Beginnt der Anfang des Programmes mit einem Befehl der nach links oder oben
gerichtet ist, muss man diese mit Hilfe des 0-Abschnittes weiter nach innen
schieben. Wollen Sie z.B. ein Echo Programm schreiben (links-oben,
rechts-oben; ( ,. ), könnte dies so aussehen:
*0*********
          0
  . ->  * *
       *  *
        * *
  , ->   **
          *

Die Schnur selbst kann aus allen Zeichen bestehen, nur nicht aus Leerzeichen.
Sie muss in zeile 1 bei zeichen 1 beginnen. Ziffern gelten als
Wiederholungs-Operator und Wiederholen den Befehl ihrer aktuellen Richtung in
Abhängigkeit ihres Wertes. Eine Zahl auf Position(1,1) wird nicht beachtet.

Kommentare lassen sich überall einfügen, solange diese keine Verbindung zur
Schnur haben. Tritt dieser Fall ein, werden Kommentare selbst als Teil der
Schnur interpretiert, was oft zu Fehlern (in Form von Programmabbrüchen)
führen wird. 

Die Maximalgröße des Quelltextes richtet sich nach dem Interpreter, jedoch
sind mindestens 10.000 Zeilen á 200 Zeichen möglich.

2dbf ist "Turing-complete", mit dieser Sprache lässt sich alles berechnen,
was man mit "normalen" Programmiersprachen auch berechnen kann.

Die Befehle definieren sich nach den Richtungen. Folgende Richtungen
entsprechen folgenden Befehen in Brainfuck:
(Ein Punkt (.) entspricht hier der Ausgangssituation, um bei *****
feststellen zu können, ob es rechts oder links anfängt.)

|--------------------------------|
|Richtung      | Brainfuck-Befehl|
|--------------------------------|
|--------------------------------|
|.*****        |       +         |
|              |                 |
|nach rechts   |    Erhöhung     |
|--------------------------------|
|*****.        |       -         |
|              |                 |
|nach links    |  Verminderung   |
|--------------------------------|
|.             |       >         |
| *            |                 |
|rechtsunten   |   ArrInd-Vor    |
|--------------------------------|
|  .           |       <         |
| *            |                 |
|linksunten    |  ArrInd-Zurück  |
|--------------------------------|
|.             |       [         |
|*             |                 |
|nach unten    | Schleifenbegin  |
|--------------------------------|
|*             |       ]         |
|.             |                 |
|nach oben     | Schleifen-Ende  |
|--------------------------------|
| *            |       .         |
|.             |                 |
|rechtsoben    |    Ausgabe      |
|--------------------------------|
|*             |       ,         |
| .            |                 |
|linksoben     |    Eingabe      |
|________________________________|


In der Sprache Brainfuck, auf der 2dbf aufbaut, lässt sich mit < und >
innerhalb eines char-Arrays der Größe 30.000 navigieren. Zu Beginn wird jedes
Array Element mit 0 initialisiert, und der Pointer steht auf Element 0 des
Arrays. Mit > lässt sich der Pointer auf das nächste Element schieben, mit <
zurück, aber nie in den negativen Bereich herein.
+ Erhöht das aktuelle Array Element um 1, - vermindert es um 1 (Bereich:
0-255). Mit , lässt sich ein Ascii Wert der von der Tastatur abgefangen wird
zum aktuellen Array-Element hinzuaddieren, mit . lässt sich der Wert eines
Elements in Ascii Form ausgeben (65 ergibt z.B. A). [ und ] sind
Schleifenoperatoren. Was in ihnen steht wird solange wiederholt bis das bei ]
aktuelle Array-Element 0 beinhaltet.


2dbf ist eine Entwicklung von oCaS und Du-Ne und wird unterstützt von
www.legacy-project.de und www.gcf.de


Viel Spass und gute Nerven mit 2dbf,

Du-Ne