Доехали норм. В поезде объяснял новоиспеченным девятиклассникам Brainf*ck Некоторых удалось серьёзно заинтересовать о_О… В остальном всё норм, комната на 3 человека… Скоро подъём… фацк =(

*зы – время этой публикации по москве, последующих до прибытия – местное.

Heute habe ich irgendwie keine Lust auf etwas ernsthaftes, also habe ich meinen kleinen Brainfuck-Interpreter ausgebuddelt. Brainfuck ist nichts schweinisches, sondern eine minimalistische turing-komplette Programmiersprache. Allerdings kostet es ganz schon Gehirnschmalz, darin etwas Vernünftiges zu progammieren – ich denke, ein Interpreter dafür ist leichter zu schreiben.

Meine Implementierung sollte möglichst flexibel sein, also z.B. sollte man einfach von einem “Band” mit Bytes auf eines mit Ints umsteigen können. Das Band sollte (im Gegensatz zur Original-Definition) in beide Richtungen unendlich lang sein. Und natürlich alles wieder ohne veränderliche Datenstrukturen. Klingt schwierig, ist es aber nicht. Zuerst die Operationen, die man auf dem Band ausführen können muss:

trait Func[T] {
    val zero:T
    def inc(t:T):T
    def dec(t:T):T
    def in: T
    def out(t: T):Unit
}

trait ByteFunc extends Func[Byte] {
    override val zero:Byte = 0
    override def inc(t:Byte) = ((t + 1) & 0xFF).toByte
    override def dec(t:Byte) = ((t - 1) & 0xFF).toByte
    override def in:Byte = readByte
    override def out(t: Byte) { print(t.toChar) }
}

Alles sehr elementar, wie man sieht. Nun das Band selber, das schwieriger aussieht, als es eigentlich ist. Die Grundidee ist, das Band mit dem aktuellen Wert und zwei Listen zu repräsentieren. Angenomme, das Band sieht so aus:
1 2 3 4 [5] 6 7 8
Dann ist meine aktuelle Zelle 5, alles davor wird “rückwärts” durch List(4,3,2,1) repräsentiert, alles danach durch List(6,7,8). Um einen Schritt zurückzugehen, füge ich meinen Wert 5 als Kopf der zweiten Liste an und mache den Kopf der ersten Liste zu meinem aktuellen Wert:
1 2 3 [4] 5 6 7 8. Komme ich ans Ende einer der Listen, liefere ich einfach Nullen.

class Tape[T](val cell:T, private val left:List[T], private val right:List[T], val func:Func[T]) {

    def inc = new Tape(func.inc(cell),left, right, func )
    def dec = new Tape(func.dec(cell),left, right, func)
    def goLeft = left match {
        case Nil => new Tape(func.zero,Nil, cell :: right, func)
        case head :: tail => new Tape(head, tail, cell :: right, func )
    }
    def goRight = right match {
        case Nil => new Tape(func.zero, cell:: left, Nil, func)
        case head :: tail => new Tape(head, cell :: left, tail, func)
    }
    def output = {
         func.out(cell)
         this
    }
    def input() = new Tape(func.in, left, right, func)
    def isZero = cell == func.zero
}

object Tape {
    def apply[T](func:Func[T]) = new Tape(func.zero, Nil, Nil, func)
}

Voila, ein unendliches Band! Natürlich wird bei jeder Operation ein neues Band zurückgeliefert, aber das ist nicht so schlimm, wie es klingt: Da alle Datenstrukturen unveränderlich sind, können auch alle ihre Bestandteile wiederverwendet werden.

object Brainfuck {
   def execute(prog: String) {
       println("---running---")
       execute(prog.replaceAll("[^\\+\\-\\[\\]\\.\\,\\>\\<]", ""), 0, Tape(new ByteFunc{}))
   }

    def execute(prog: String, pos:Int, tape:Tape[Byte]) {

        def closedBracePos(bPos:Int, count:Int):Int =
           if (count < 0 &#124;&#124; bPos == prog.length)
              error ("Unbalanced braces")
           else prog.charAt(bPos) match {
               case '[' => closedBracePos(bPos + 1, count + 1)
               case ']' =>  if (count == 0) bPos
                            else closedBracePos(bPos + 1, count - 1)
               case _ =>  closedBracePos(bPos + 1, count)
           }

        def openBracePos(bPos:Int, count:Int):Int =
           if (count < 0 &#124;&#124; bPos < 0)
              error ("Unbalanced braces")
           else prog.charAt(bPos) match {
               case ']' => openBracePos(bPos - 1, count + 1)
               case '[' =>  if (count == 0) bPos
                            else openBracePos(bPos - 1, count - 1)
               case _ =>  openBracePos(bPos - 1, count)
           }

        if(pos < prog.length) prog.charAt(pos) match {
          case '+' => execute(prog, pos + 1, tape.inc)
          case '-' => execute(prog, pos + 1, tape.dec)
          case '>' => execute(prog, pos + 1, tape.goRight)
          case '<' => execute(prog, pos + 1, tape.goLeft)
          case '.' => execute(prog, pos + 1, tape.output)
          case ',' => execute(prog, pos + 1, tape.input)
          case '[' => if (tape.isZero) execute(prog, closedBracePos(pos + 1, 0) + 1, tape)
                      else execute(prog, pos + 1, tape)
          case ']' => if (! tape.isZero) execute(prog, openBracePos(pos - 1, 0), tape)
                      else execute(prog, pos + 1, tape)
        } else {
          println("\n---done---")
        }
    }

   def main(args:Array[String]) {
       if (args.length == 1) execute(args(0))
       else println("First parameter must be a Brainfuck program")
   }
}

Der Interpreter ist ziemlich einfach: Das Brainfuck-Programm wird als String geladen. Zuerst werden alle Kommentare entfernt – Brainfuck betrachtet alle Zeichen, denen kein Befehl zugeordnet ist, als Kommentar. Danach wird mit einem neuen, leeren Band gestartet. Die schwierigste Aufgabe ist, die richtige öffnende Klammer zu einer schließenden Klammer zu finden (und umgekehrt), denn natürlich dürfen diese geschachtelt werden. Eckige Klammern dienen übrigens als Schleifenkonstrukt von Brainfuck.

Bleibt bloß noch, das Programm einmal auszuprobieren. Hier ein paar Anregungen:

//Hello World
>+++++++++[<++++++++>-]<.>+++++++[<++++>-]<+.+++++++..+++.[-]>++++++++
[<++++>-]<.#>+++++++++++[<+++++>-]<.>++++++++[<+++>-]<.+++.------.--------.
[-]>++++++++[<++++>-]<+.[-]++++++++++.""")

//Die Zahlen von 9 bis 0
++++++++++++++++++++++++++++++++[>+>+<<-]
>>+++++++++++++++++++++++++<<++++++++++[>>.-<.<-]

//ein Brainfuck-Quine
//siehe http://de.wikipedia.org/wiki/Quine_(Computerprogramm)
->+>+++>>+>++>+>+++>>+>++>>>+>+>+>++>+>>>>+++>+>>++>+>+++
>>++>++>>+>>+>++>++>+>>>>+++>+>>>>++>++>>>>+>>++>+>+++>>>
++>>++++++>>+>>++>+>>>>+++>>+++++>>+>+++>>>++>>++>>+>>++>
+>+++>>>++>>+++++++++++++>>+>>++>+>+++>+>+++>>>++>>++++>>
+>>++>+>>>>+++>>+++++>>>>++>>>>+>+>++>>+++>+>>>>+++>+>>>>
+++>+>>>>+++>>++>++>+>+++>+>++>++>>>>>>++>+>+++>>>>>+++>>
>++>+>+++>+>+>++>>>>>>++>>>+>>>++>+>>>>+++>+>>>+>>++>+>++
++++++++++++++++>>>>+>+>>>+>>++>+>+++>>>++>>++++++++>>+>>
++>+>>>>+++>>++++++>>>+>++>>+++>+>+>++>+>+++>>>>>+++>>>+>
+>>++>+>+++>>>++>>++++++++>>+>>++>+>>>>+++>>++++>>+>+++>>
>>>>++>+>+++>>+>++>>>>+>+>++>+>>>>+++>>+++>>>+[[->>+<<]<+]+
++++[->+++++++++<]>.[+]>>[<<+++++++[->+++++++++<]>-.-----------
-------->-[-<.<+>>]<[+]<+>>>]<<<[-[-[-[>>+<++++++[->+++++<]]>++++
++++++++++<]>+++<]++++++[->+++++++<]>+<<<-[->>>++<<<]>[->>.<<]<<]

Na dann, viel Spaß mit Brainfuck!

Már 26 H1N1 fertőzött van!

Azt képzeld el, mi lesz, ha meghal az első! Hetekig mást se hallunk!

Первому кто поймёт что ЭТО делает от меня какой-нибудь приз”)

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

Dies ist mein erster Artikel in diesem Blog. Ich freue mich in Zukunft über Themen der Wirtschaftsinformatik berichten zu können und hoffe, dass der eine oder andere interessierte Leser unter euch ist.

מפאת קוצר בזמן (אני ארמוז קלות שהבגרות בהיסטוריה אשמה בכך), אני אדחה את הביקורת הראשונה שלי למחר. הפוסט הזה יהווה מן.. פוסט פתיחה שכזה לבלוג, בתקווה שלי (ושלכם) שלא יהיו פוסטים מיותרים כל-כך בעתיד.

אז… מה לי ולוורדפרס? זהו, שכלום. בלוגלי כל הזמן קורס, אז בחיפוש אחר תחלופה הולמת שפחתכם הנאמנה הגיעה לוורדפרס (מה שמתברר כלא-כל-כך חכם בדיעבד, המערכת הזו מאמללת אותי).

אז… בקצרה עליי ועל הבלוג; 

שמי נועה (לא חמודים, לא קוראים לי נונה. ואף אחד לא התאכזר אליי בלידה עם השם הזה) ואני מוכרת יותר כנונה-צ’אן במספר קהילות (Nona Chan). אני אוטאקואית מרכזניקית בת 16, חובבת גנדמים, מכה והמון דרמה-טרגדיה-פסיכולוגי.  למרות חיבתי המאוד מוקצנת למכה, אני מבטיחה לא לתת לזה להשתלט על הבלוג (אם כי תצפו לביקורת מכה בימים הקרובים).

למרות חיבתי העזה לבדיחות “הומואים קסומים” (ע”ש האנימה Antique Bakery), איני פנגירלז (לצערכם או למזלכם), לכן אל תצפו לראות כאן ביקורות יאוי למינהן, וביקורות שונאן איי כמעט ולא יופיעו כאן. כן כן פנגירלז, הומואים לא עושים לי את זה, על כן סביר להניח שאם חיפשתן ביקורת לפרק האחרון של ג’ונג’ו רומנטיקה – לא תמצאו את זה כאן.

כל החפץ בהחלפת קישורים עימי מוזמן לעשות כך, אשמח להוסיף לינקים לבלוגים נוספים בתחום האנימה. כמו כן, ברצוני להודות לחן/צ’יב (המוכרת לרובכם מבלוג האנימה Tsukiakari) על הלוגו לבלוג, ועל חפירת הבוקר-טוב שלי. תודה חןחן 3>

בברכת קריאה מהנה לכל הקוראים,

נונה.

Максимум двух байт
>,>>,<<[->+>-[<<<]>]>[>>]<<[>>]<<[->+<]>.
А это уже минимум)))
>>,>,<[->->+<[<<<]>>]>>[>>>]<<<.
Вот такими вещами я порой маюсь в свободное время

Hab mal ein bisschen in der Vergangenheit gestöbert, und dabei dieses Video meiner damaligen Band “Brainfuck” wieder entdeckt. Der langhaarige Gitarrero bin ich vor etwa 4 1/2 Jahren…

Brainfuck is one of those turing complete languages that has no apparent use in the real world. But hey, being very very simple with a limited grammar, writing an interpreter should be easy. So here it is, under WTFPL. The code works (I hope so) with the examples from the Wikipedia article.

#include <stdio.h>
#include <error.h>

#include <config.h>

static char cellspace[30000];
static char *data_pointer;

int process_command(char command, FILE *file_ptr)
{
	char c;
	long pos;

	switch(command) {
	case '>':
		++data_pointer;
		break;
	case '<':
		--data_pointer;
		break;
	case '+':
		++*data_pointer;
		break;
	case '-':
		--*data_pointer;
		break;
	case '.':
		putchar(*data_pointer);
		break;
	case ',':
		*data_pointer = getchar();
		break;
	case '[':
		pos = ftell (file_ptr);
		while(*data_pointer != NULL) {
			fseek (file_ptr, pos, SEEK_SET);
			c = getc(file_ptr);
			while( c!= ']' && c != EOF) {
				process_command(c, file_ptr);
				c = getc(file_ptr);
			}

		}

	}

}

int interpret_source(const char *source) {

	/*
	 *  Allowed brainfuck commands are,
	 *  > 	increment the data pointer (to point to the next cell to the right).
	 *  < 	decrement the data pointer (to point to the next cell to the left).
	 *  + 	increment (increase by one) the byte at the data pointer.
	 *  - 	decrement (decrease by one) the byte at the data pointer.
	 *  . 	output the value of the byte at the data pointer.
	 *  , 	accept one byte of input, storing its value in the byte at the data pointer.
	 *  [ 	if the byte at the data pointer is zero,
	 *      then instead of moving the instruction pointer forward to the next command,
	 *      jump it forward to the command after the matching ] command.
	 *  ] 	if the byte at the data pointer is nonzero,
	 *      then instead of moving the instruction pointer forward to the next command,
         *      jump it back to the command after the matching [ command.
	 */

	char command;
	FILE *file_ptr = fopen(source, "r");

	if (!file_ptr) {
		fprintf(stderr, "Error: No such file %s\n", source);
		return FALSE;
	}

	while((command = getc(file_ptr)) != EOF)
		process_command(command, file_ptr);
	fclose(file_ptr);
	return TRUE;
}

int main(int argc, char **argv)
{
	/* Init data_pointer to the left most cell */
	data_pointer = &cellspace[0];

	/* Use getopts? */
	if (argc > 1)
		interpret_source(argv[1]);
	return 0;
}