Und da beschwere sich mal wer, daß ich erst garnicht versuche Cross-Plattform zu arbeiten.
Ach ja, mein "BF to pacal.bf" ist nun lauffähig (in 8 Bit).
Es wandelt ein BF-Script in eine Pascal-
DPR um.
OK, meine IFs in BF sind noch sehr sehr unoptimal.
Ist auch garnicht so einfach sowas in BF hinzubekommen.
Aber die Laufzeit des Konverterscripts hat ja nicht mit der Laufzeit des Ergebnisses zu tun
und ihr glaubt garnicht, wie schnell urplötzlich das "kleine" Mandelbrot-Programmchen sein kann.
Und das, obwohl noch nichtmal optimiert wird.
( also z.B. Inc(P) + Inc(P) = Inc(P, 2) usw. )
Witzig ist dabei, daß dieser Konverter nur mit 32 Byte und einem Pointer auskommt
und wenn man unbedingt wöllte, dann würden auch 4 Byte plus den Zeiger ausreichen.
Also, obwohl es nicht grade sehr optimal arbeitet, bis ich doch recht zufrieden damit ... ist ja immerhin mein erstes richtiges BF-Programm.
In meinem BF-Interpreter kann aber jetzt eine derartige Optimierung aktiviert werden
und auch Strg+(Shift)+G, bzw. +B entfernen jetzt nicht nur Text/Kommentare und faßt alles zusammen,
sondern es entfernt jetzt auch offensichtlich unnötige BF-Befehle.
( z.B. >>< zu > )
dieses fibonacci.bf
Code:
++++++++++>>+>>+
[
[
+++++[<++++++++>-]<.
>++++++[<-------->-]
+<<<
]<.>>>>
[
-<[<+>>+<-]
<[>+<-[>+<-[>+<-[>+<-[>+<-
[>+<-[>+<-[>+<-[>+<-
[>[-]>>+>>[-]+<<<<<-
[>+<-]]]]]]]]]]]
>>[<<+>>-]
+>>>
]<<<
]
sieht in Delphi dann so aus
Delphi-Quellcode:
program mybf;
{$apptype console}
var
m:
array[0..1000000]
of char;
p: integer;
begin
p := 0;
inc(m[p]);
inc(m[p]);
inc(m[p]);
inc(m[p]);
inc(m[p]);
inc(m[p]);
inc(m[p]);
inc(m[p]);
inc(m[p]);
inc(m[p]);
inc(p);
inc(p);
inc(m[p]);
inc(p);
inc(p);
inc(m[p]);
while m[p] <> #0
do begin
while m[p] <> #0
do begin
inc(m[p]);
inc(m[p]);
inc(m[p]);
inc(m[p]);
inc(m[p]);
while m[p] <> #0
do begin
dec(p);
inc(m[p]);
inc(m[p]);
inc(m[p]);
inc(m[p]);
inc(m[p]);
inc(m[p]);
inc(m[p]);
inc(m[p]);
inc(p);
dec(m[p]);
end;
dec(p);
write(m[p]);
inc(p);
inc(m[p]);
inc(m[p]);
inc(m[p]);
inc(m[p]);
inc(m[p]);
inc(m[p]);
while m[p] <> #0
do begin
dec(p);
dec(m[p]);
dec(m[p]);
dec(m[p]);
dec(m[p]);
dec(m[p]);
dec(m[p]);
dec(m[p]);
dec(m[p]);
inc(p);
dec(m[p]);
end;
inc(m[p]);
dec(p);
dec(p);
dec(p);
end;
dec(p);
write(m[p]);
inc(p);
inc(p);
inc(p);
inc(p);
while m[p] <> #0
do begin
dec(m[p]);
dec(p);
while m[p] <> #0
do begin
dec(p);
inc(m[p]);
inc(p);
inc(p);
inc(m[p]);
dec(p);
dec(m[p]);
end;
dec(p);
while m[p] <> #0
do begin
inc(p);
inc(m[p]);
dec(p);
dec(m[p]);
while m[p] <> #0
do begin
inc(p);
inc(m[p]);
dec(p);
dec(m[p]);
while m[p] <> #0
do begin
inc(p);
inc(m[p]);
dec(p);
dec(m[p]);
while m[p] <> #0
do begin
inc(p);
inc(m[p]);
dec(p);
dec(m[p]);
while m[p] <> #0
do begin
inc(p);
inc(m[p]);
dec(p);
dec(m[p]);
while m[p] <> #0
do begin
inc(p);
inc(m[p]);
dec(p);
dec(m[p]);
while m[p] <> #0
do begin
inc(p);
inc(m[p]);
dec(p);
dec(m[p]);
while m[p] <> #0
do begin
inc(p);
inc(m[p]);
dec(p);
dec(m[p]);
while m[p] <> #0
do begin
inc(p);
inc(m[p]);
dec(p);
dec(m[p]);
while m[p] <> #0
do begin
inc(p);
while m[p] <> #0
do begin
dec(m[p]);
end;
inc(p);
inc(p);
inc(m[p]);
inc(p);
inc(p);
while m[p] <> #0
do begin
dec(m[p]);
end;
inc(m[p]);
dec(p);
dec(p);
dec(p);
dec(p);
dec(p);
dec(m[p]);
while m[p] <> #0
do begin
inc(p);
inc(m[p]);
dec(p);
dec(m[p]);
end;
end;
end;
end;
end;
end;
end;
end;
end;
end;
end;
inc(p);
inc(p);
while m[p] <> #0
do begin
dec(p);
dec(p);
inc(m[p]);
inc(p);
inc(p);
dec(m[p]);
end;
inc(m[p]);
inc(p);
inc(p);
inc(p);
end;
dec(p);
dec(p);
dec(p);
end;
end.
Und es ist garnicht so einfach NUR mit diesen Variablen
Delphi-Quellcode:
var
m: array[0..1000000] of char;
p: integer;
und diesen Befehlen
Delphi-Quellcode:
{ > } inc(p);
{ < } dec(p);
{ + } inc(m[p]);
{ - } dec(m[p]);
{ . } read(m[p]);
{ , } write(m[p]);
{ [ } while m[p] <> 0
do begin
{ ] } end;
ein Programm hinzubekommen,
aber da es sich hier um eine turingfähiges Programm handelt,
sollten sich damit in endlicher Zeit (kann allso etwas länger dauern) ALLE möglichen Programme/Berechnungen bewerkstelligen lassen.