Das gibt einmal "Java" und einmal "Hello World!" aus.
Known Bugs: keine Unterstützung für geschachtelte Schleifen.
Nuja vielleicht braucht es mal jemand! :D
bye Saxony
Multipliziert Zelle 1 mit 2. In diesem Beispiel kommt also 10 raus!
Das mit Cow und WhiteSpaces ist auch recht interessant. Ebenso Ook - was aber im Endeffekt nur eine Substitution des BF Syntaxes ist.
Shakespeare wird bestimmt zu aufwändig um es mal in der KaffeePause zu machen - da war der BF Interpreter ja der reinste Kindergeburtstag!
[edit]
Das Dumme ist nur, dass ich leider kein BrainFuck kann. Meine BF Codes sind alles Abwandlungen des Hello World Beispieles von Wikipedia. Wer den Interpreter also mal ordentlich testen will, sollte dies tun - und FeedBack geben!
[/edit]
An einem Cow-Interpreter sitze ich gerade(nachdem Hinweis von Marco13), hab gestern mal angefangen aber zu wenig Zeit gehabt da wirklich was zu erreichen. Parser hab ich schon, der executer fehlt noch. Werde mal schauen wann ich die Tage nochmal Zeit finde weiter zu machen.
Gut Schuß
VuuRWerK
Edit: Shakespeare hab ich mir auch mal angeschaut, dafür aber einen Interpreter zu schreiben wäre sehr aufwändig. Sollte ich das mit Cow auf die Reihe bekommen, werde ich mir auch mal Whitespace anschauen, das ist ebenfalls sehr spaßig. Allerdings hat der Erfinder von Whitespace seine VM und Interpreter in Haskell geschrieben … :o)
ich habe nun mal den Interpreter noch um ein paar Optimierungen erweitert.
Folgen von Befehlen bewirken nun einmalige Aktionen und nicht immer ±1.
++++ Addiert nun 4 zur aktuellen Zelle und nicht +1+1+1+1
Schiebt den Zeiger nun um 4 Werte nach vorn und nicht +1+1+1+1
analoges für - und <.
Zusätzlich wird die Schleife [-] nun direkt als Nullstzung der aktuellen Zelle optimiert. Steht in der aktuellen Zelle nämlich 1000 wird 1000 -1 geloopt - nuja nun nicht mehr. Zellen auf null setzen dauert nun immer gleich lange egal welcher Inhalt sich darin befindet.
private void parseCode(String aCode) {
char[] code = aCode.toCharArray();
int pos = -1;
while (++pos < code.length) {
switch (code[pos]) {
case '+' : { pos += optimizeCode(aCode, pos, '+'); break; }
case '-' : { pos += optimizeCode(aCode, pos, '-'); break; }
case '>' : { pos += optimizeCode(aCode, pos, '>'); break; }
case '<' : { pos += optimizeCode(aCode, pos, '<'); break; }
case '.' : { System.out.print((char)map[ptr]); break; }
case ',' : { readInput(); break; }
case '[' : { pos += runLoop(getLoopCode(aCode, pos)); break; }
default : { pos += runFunction(getFunctionCode(aCode, pos)); break; }
}
}
}
private int runLoop(String aCode) {
if ("-".equals(aCode)) { map[ptr] = 0; return 2; }
while (map[ptr] != 0) {
parseCode(aCode);
}
return aCode.length() + 1;
}
private int optimizeCode(String aCode, int aPos, char aCmd) {
char[] code = aCode.substring(aPos).toCharArray();
int i = 0;
while((++i < code.length) && (code** == aCmd)) {}
switch (aCmd) {
case '+' : { map[ptr] += i; break; }
case '-' : { map[ptr] -= i; break; }
case '>' : { ptr += i; break; }
case '<' : { ptr -= i; break; }
}
return --i;
}
ich habe den BF Interpreter nun soweit folgendes zu fressen
/ My First BrainFuck Programm /
/ prints Hello World to StdOut /
print_Hello_World (
/ Fill the cells /
++++++++++[>+++++++>++++++++++>+++>+<<<<-]
/ Print out the cells /
>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.
)
/ define Main /
main (
/ Run the Hello World Function /
print_Hello_World()
)
/ Run main /
main()
Ich nutz den Thread mal, um auf meinen BrainFucker aufmerksam zu machen
Den Source für den Interpreter kann ich auch zur Verfügung stellen. Müsst ich aber auch erst raussuchen und ist imho nicht ganz so schön, wie der von Saxony .