Brainfuck

Aus C64-Wiki
Zur Navigation springenZur Suche springen

Dieser Artikel behandelt die esoterische Programmiersprache Brainfuck aus der Sicht der Commodore Computersysteme.

Allgemeines[Bearbeiten | Quelltext bearbeiten]

Brainfuck-Quellcode und -Compiler mit Programm-Ausgabe (unten) mit BF-Compiler von "Marco64".

Die esoterische Programmiersprache Brainfuck (kurz: BF; zu deutsch etwa.: Hirnfick; alternativ auch als Brainf*ck, Brainf*** oder Brainf... bezeichnet) ist im Jahr 1993 durch den Schweizer Aminet-Gründer Urban Müller zu Schulungszwecken von Softwareentwicklern entwickelt worden.

Die Idee war eine einfache Turing-vollständige Programmiersprache zu entwerfen, welche mit einem möglichst kleinen Compiler übersetzt werden kann. Die Inspiration kam durch die im selben Jahr erschienenen verschleiernde und nicht nachvollziehbar esoterische Programmiersprache False[1] vom Niederländer Wouter van Oortmerssem, deren Compiler nur 1024 Byte groß war und der dies wohl nur als Scherzprogramm entwickelt hatte, um das möglich Machbare aus Sicht der Informationswissenschaft zu demonstrieren. Urban Müller entwickelte auf einen Commodore Amiga einen Compiler mit einer maximalen Größe von 240 Bytes (2. entwickelte Version). Erst spätere und neuere Compiler-Entwicklungen von Brainfuck für Linux und MS-DOS konnten die maximale Dateigröße von 240 Bytes deutlich unterbieten.


C64-Versionen (Auszug)[Bearbeiten | Quelltext bearbeiten]

Der Aufruf der BF-Programme "HELLOWORLD.BF" und "PRIME.BF" mit dem BF-Compiler von der Gruppe "Ninja/The Dreams" aus der GO64! (2001).
Der Aufruf des BF-Programms "99BOTTLES.BF" mit Amiga-Textdatei aus der GO64! (2001).

Für den C64 wurden ebenfalls einige Brainfuck-Compiler geschrieben:

  • Im Jahr 2001 wurde von der Gruppe "Ninja/The Dreams" ein BF-Compiler in Maschinensprache für das Computermagazin GO64! (Ausgabe 05/2001) geschrieben.[2] Es existieren hier zwei Versionen jeweils 1 Block groß, davon einmal die Standard-Version und einmal die etwas kleinere Tiny-Version (nur ca. 135 Bytes groß)! Aufruf des Quellcodes aus SEQ-Datei mit speziellen SYS-Befehl mit vier Beispielprogrammen und den beiden dokumentierte Assembler-Quellcodes dieser Versionen (ebenfalls als SEQ-Datei):
    • HELLOWORLD.BF (Mittlerweile erstes globales Standard-Programmierbeispiel für Einsteiger)
    • PRIME.BF (Primzahlermittelung)
    • QUINE.BF (Bildschirmausgabe unter BF)
    • 99BOTTLES.BF (EOL-Type: 0A; Lyrix-Programm: 99 Bottles of Beer (Programm)[3])
    • BRAINF.../SRC (Quellcode Standard-BF-Compiler)
    • BRAINF.../SM/SRC (Quellcode Tiny-BF-Compiler)
Hinweis: Parameter "EOL-Type" (in Hexadezimal; kurz für End of Line): 0D für C64-Textdatei; 0A für Amiga-Textdatei; für andere Textdateien von anderen Computern wie bspw. PC oder Mac muss man den richtigen Wert ausprobieren, um eine fehlerfreie Ausführung des BF-Codes zu erhalten.
  • TINY-Version: Eingabe von folgender BASIC-Befehlsreihenfolge:
OPEN1,gerätenr.,0,"quellcodename,S"
SYS53000
CLOSE1
Hinweis: Auftauchende Fehlermeldungen sollten ignoriert werden. Da dies eine abgespeckte Version der Standard-Version ist, muss man einige Ungereimtheiten in Kauf nehmen, u.a. auch die fehlerhafte Ausführung des BF-Codes von Nicht-C64-Textdateien!
In beiden Versionen muss der exakte "Quellcodename" ohne Jokerzeichen (wie * oder ?) angegeben werden!
  • Im Jahr 2009 von "Marco64" in BASIC V2: Der BF-Code wird in den angehängten DATA-Zeilen ab BASIC-Zeile 670 eingegeben (inklusive Beispielprogramm ca. 4 KByte groß).
  • Im Jahr 2011 von Heiko Prüssing in 6502-Assembler (ca. 170 Bytes groß).
  • Im Jahr 2013 durch Gergő Érdi als Transpiler in cc65-Quellcode mit einigen Einschränkungen!

Es gibt mittlerweile auch Implementierungen für den C128 (siehe Weblinks)


Befehle[Bearbeiten | Quelltext bearbeiten]

Brainfuck als BASIC-Programm von "Marco64" (2009).

Diese sehr universelle Programmiersprache, die stark der formalen Definition einer Turingmaschine ähnelt, beinhaltet zwar nur 8 Befehle bzw. Zeichen, ist aber für die produktive Programmierung zu umständlich und zu ineffizient.

Befehl (Zeichen): BASIC-Synonym: Bedeutung:
> P=P+1 Zeiger / Variablenwert um 1 erhöhen.
< P=P-1 Zeiger / Variablenwert um 1 erniedrigen.
+ A(P)=A(P)+1 Aktuellen Zellenwert um 1 erhöhen.
− A(P)=A(P)-1 Aktuellen Zellenwert um 1 erniedrigen.
. PRINT CHR$(A(P)) Aktuellen Zellenwert als ASCII-Zeichen auf Bildschirm ausgeben.
, INPUT A$: A(P)=ASC(A$) Zeichen von Tastatur einlesen und in der aktuellen Zelle als

ASCII-Wert abspeichern.

[ IF A(P)=0 GOTO Schleifenende Anfang einer WHILE-Schleife, d. h. springt nach vorne, hinter den passenden ]-Befehl, wenn der aktuelle Zellenwert 0 ist.
] Schleifenende Ende einer WHILE-Schleife, d. h. springt zurück, hinter den passenden [-Befehl, wenn der aktuelle Zellenwert nicht 0 ist.

Alle anderen Zeichen werden ignoriert und können daher als Anmerkungen im Quelltext zur Dokumentation genutzt werden.


Seit dem Jahr 1993 wurden zahlreiche Programme mit Brainfuck entwickelt. Durch die minimalistischen Ansprüche dieser Programmiersprache ist der BF-Programmcode plattformunabhängig, wenn die entsprechenden BF-Compiler nicht von den 8 oben genannten Befehlen abweichen!

Beispiele[Bearbeiten | Quelltext bearbeiten]

Ein einfaches BF-Programm kann schon diese Dekrementier-Schleife mit Bildschirmausgabe sein: 

[-.]
Brainfuck-Programm "Hello world!" im Brainfuck-Transpiler von Gergő Érdi (2013).

Der BF-Quellcode für die Ausgabe von "Hello world!". 

>++++++++[<+++++++++++++>-]<.
>+++++++[<----->-]<.
+++++++..
+++.
>>>++++++++[<++++>-] <.<<
>++++[<++>-]<.
--------.
+++.
------.
--------.
[-]>++++++++[<++++>- ]<+.
[-]++++++++++.

Das Programm berechnet in jeder Zeile den PETSCII-Code eines Buchstabens und gibt diesen dann aus. Beispielsweise wird in der ersten Zeile der Wert 104=8*13 berechnet, der PETSCII-Code von 'H'. Dazu wird die Schleife 8 mal durchlaufen und in der Schleife wird der Wert (der zu Beginn 0 ist) jeweils um 13 erhöht. Am Ende steht dann der Ausgabebefehl. In der zweiten Zeile wird dieser Wert dann 7mal um 5 reduziert, was zu 69 führt, dem PETSCII-Code von 'e'. Und so weiter...

Übersetzung als BASIC-Code: 

   0 rem brainfuck
   1 dim m%(255) : rem memory
   2 p%=0 : rem pointer
   3 p%=p%+1and255
   4 m%(p%)=m%(p%)+8and255
   5 if m%(p%) = 0 then    11
   6 p%=p%-1and255
   7 m%(p%)=m%(p%)+13and255
   8 p%=p%+1and255
   9 m%(p%)=m%(p%)-1and255
  10 goto 5
  11 p%=p%-1and255
  12 print chr$(m%(p%));
  13 p%=p%+1and255
  14 m%(p%)=m%(p%)+7and255
  15 if m%(p%) = 0 then    21
  16 p%=p%-1and255
  17 m%(p%)=m%(p%)-5and255
  18 p%=p%+1and255
  19 m%(p%)=m%(p%)-1and255
  20 goto 15
  21 p%=p%-1and255
  22 print chr$(m%(p%));
  23 m%(p%)=m%(p%)+7and255
  24 print chr$(m%(p%));
  25 print chr$(m%(p%));
  26 m%(p%)=m%(p%)+3and255
  27 print chr$(m%(p%));
  28 p%=p%+3and255
  29 m%(p%)=m%(p%)+8and255
  30 if m%(p%) = 0 then    36
  31 p%=p%-1and255
  32 m%(p%)=m%(p%)+4and255
  33 p%=p%+1and255
  34 m%(p%)=m%(p%)-1and255
  35 goto 30
  36 p%=p%-1and255
  37 print chr$(m%(p%));
  38 p%=p%-2and255
  39 p%=p%+1and255
  40 m%(p%)=m%(p%)+4and255
  41 if m%(p%) = 0 then    47
  42 p%=p%-1and255
  43 m%(p%)=m%(p%)+2and255
  44 p%=p%+1and255
  45 m%(p%)=m%(p%)-1and255
  46 goto 41
  47 p%=p%-1and255
  48 print chr$(m%(p%));
  49 m%(p%)=m%(p%)-8and255
  50 print chr$(m%(p%));
  51 m%(p%)=m%(p%)+3and255
  52 print chr$(m%(p%));
  53 m%(p%)=m%(p%)-6and255
  54 print chr$(m%(p%));
  55 m%(p%)=m%(p%)-8and255
  56 print chr$(m%(p%));
  57 if m%(p%) = 0 then    60
  58 m%(p%)=m%(p%)-1and255
  59 goto 57
  60 p%=p%+1and255
  61 m%(p%)=m%(p%)+8and255
  62 if m%(p%) = 0 then    68
  63 p%=p%-1and255
  64 m%(p%)=m%(p%)+4and255
  65 p%=p%+1and255
  66 m%(p%)=m%(p%)-1and255
  67 goto 62
  68 p%=p%-1and255
  69 m%(p%)=m%(p%)+1and255
  70 print chr$(m%(p%));
  71 if m%(p%) = 0 then    74
  72 m%(p%)=m%(p%)-1and255
  73 goto 71
  74 m%(p%)=m%(p%)+10and255
  75 print chr$(m%(p%));
  76 end

Weblinks[Bearbeiten | Quelltext bearbeiten]

WP-W11.png Wikipedia: Brainfuck


Quellen

  1. ↑ Wouter van Oortmerssem: "The FALSE Programming Language" Sprache:englisch
  2. ↑ Auszug aus dem GO64!-Artikel in Ausgabe 05/2001
  3. ↑ www.99-bottles-of-beer.net - Viele Hintergründe zu diesem Programmierbeispiel, deren Anfang als 6-zeiliges BASIC-Beispiel begann. Sprache:englisch
Abgerufen von „https://www.c64-wiki.de/index.php?title=Brainfuck&oldid=258424“