Brainfuck Interpreter

[BlackJack]

@fail: Nein, das würde nur funktionieren wenn *alle* Schleifen ineineinander geschachtelt sind, aber nicht wenn es Schleifen gibt, die nacheinander ausgeführt werden. Beispiel wo es nicht nach dem von Dir beschriebenen Muster funkioniert:

Code: Alles auswählen

...[...[...]...]...[...]... BF-Code
   1   2   3   4   5   6    Klammer-Nr.
012345678901234567890123456 Code Index
          1         2

Hier gehören zusammen: Klammern 1 und 4, 2 und 3, 5 und 6.

Du musst die Zeichen abgehen und dir Merken wie viele Klammern aktuell noch offen sind, für die Du noch keine schliessende Klammer gesehen hast.

Am besten macht man das am Anfang in einem Durchlauf und merkt sich in einem Wörterbuch welche Indizes in den Code zusammen gehören. Jeweils in beide Richtungen. Da kann man sich mit einem Stack die Positionen der noch offenen Klammern merken. Dann braucht man während des BF-Programmablaufs keinen Stack mehr und kann die jeweils andere Klammerposition ganz einfach ermitteln in dem man im Wörterbuch nachschaut. Für das Beispiel oben sähe das Wörterbuch so aus:

Code: Alles auswählen

d = {3: 15, 15: 3, 7: 11, 11: 7, 19: 23, 23: 19}

[fail]

Wie kann ich das mit dem Suchen machen?

[BlackJack]

@fail: Das habe ich im Grunde doch beschrieben. Ich nehme mal an *Du* kannst bei einem beliebigen Ausdruck mit korrekt verschachtelten Klammern heraus finden welche zusammen gehören. Dann musst Du ja auch beschreiben können wie Du auf das Ergebnis kommst. Das musst Du dann nur noch so genau/formal beschreiben, dass man es als Quelltext schreiben kann.

[fail]

Wo ist jetzt der fehler das Hello world Programm gibt irgendeine Komische ausgabe aus

Code: Alles auswählen

def Klammernpaare(code):
    codeindex=0
    listeoffen=[]
    zuposition={}
    offenposition={}
    while codeindex<len(code):
        if code[codeindex]=="[":
            listeoffen.append(codeindex)
        elif code[codeindex]=="]":
            letze=listeoffen.pop()
            zuposition[letze]=codeindex
        codeindex +=1
    for i in zuposition:
        offenposition[zuposition[i]]= i
	
    return offenposition, zuposition


def bf(code):
    #Kommentare entfernen
    code=[s for s in code if s in ("<",">","+","-",".",",")]
    #aktuelle Zelle
    cellindex=0
    #Zellen
    cells=[0]*30000
    #Position im Code
    codeindex=0
    #Klammernpaare finden für Schleifen
    offenposition, zuposition= Klammernpaare(code)
    
    while codeindex < len(code):
        index=code[codeindex]
        if index==">":
            cellindex +=1
           
        elif index=="<":
            cellindex -=1
            
        elif index=="+":
            cells[cellindex] +=1
           
        elif index=="-":
            cells[cellindex] -=1
            
        elif index==".":
            print(chr(cells[cellindex]), end="")
         

        elif index==",":
            cells[cellindex] = ord(input())
        

        elif index=="[":
            if cells[cellindex]== 0:
                codeindex=zuposition[codeindex]
                codeindex -=1
                
        

        elif index=="]":
            codeindex=offenposition[codeindex]
            codeindex -=1
            
               
        codeindex +=1    
                
                

[Sirius3]

@fail: Dafür ist das Testen der einzelnen Funktionen gut. Tut jedes BF-Commando das was es soll, werden die Klammern richtig ermittelt, springt [ und ] an die richtige Stelle, usw.

[fail]

Ihr müsst mir helfen ich hab keine Ahnung wo der Fehler liegt. Wahrscheinlich etwas mit den Schleifenindex

[Sirius3]

1. vor die while-Schleife ein print(offenposition,zuposition)
2. in die while Schleife ein print(codeindex,index)
und dann von Hand Dein brain**** Programm durcharbeiten und schauen, ob der Computer auf die selben Ergebnisse kommt.

[fail]

Scheint jetzt zu funktionieren. Noch eine Frage wie kann ich die Eingabe so machen das ich nicht enter drücken muss?

Code: Alles auswählen

def Klammernpaare(code):
        codeindex=0
        listeoffen=[]
        zuposition={}
        offenposition={}
        while codeindex<len(code):
            if code[codeindex]=="[":
                listeoffen.append(codeindex)
            elif code[codeindex]=="]":
                letze=listeoffen.pop()
                zuposition[letze]=codeindex
            codeindex +=1
        for i in zuposition:
            offenposition[zuposition[i]]= i
	
        return offenposition, zuposition


def bf(code):
    #Kommentare entfernen
    code=[s for s in code if s in ("<",">","+","-",".",",","[","]")]
    #aktuelle Zelle
    cellindex=0
    #Zellen
    cells=[0]*30000
    #Position im Code
    codeindex=0
    #Klammernpaare finden für Schleifen
    offenposition, zuposition= Klammernpaare(code)

    while codeindex < len(code):
        index=code[codeindex]
        if index==">":
            cellindex +=1
           
        elif index=="<":
            cellindex -=1
            
        elif index=="+":
            cells[cellindex] +=1
           
        elif index=="-":
            cells[cellindex] -=1
            
        elif index==".":
            print(chr(cells[cellindex]), end="")
         

        elif index==",":
            cells[cellindex] = ord(input())
        

        elif index=="[":
            if cells[cellindex]== 0:
                codeindex=zuposition[codeindex]
                
                

        elif index=="]":
            codeindex=offenposition[codeindex]
            codeindex -=1
                        
        codeindex +=1
        
                
                

[darktrym]

Windows oder Unix-like?

[BlackJack]

@darktrym: Weder noch würde ich sagen, sondern einfach ein Byte von der Standardeingabe lesen wie das Sirius3 weiter vorne im Thema schon mal in einem BF nach Python-Übersetzer gezeigt hat. So machen das jedenfalls alle anderen BF-Implementierungen die ich kenne. Man kann ja kein Terminal voraussetzen und die Eingaben müssen ja nicht zwingend aus Tastendrücken bestehen.

[darktrym]

@BlackJack: Ich steh' grad auf dem Schlauch. Das("sys.stdin.read(1)") verhält sich doch wie raw_input unter Windows, Abschluss der Eingabe mit einem Enter. Und gerade das war nicht gewollt?

[BlackJack]

@darktrym: Nein, so verhält sich das ``sys.stdin.read(1)`` nicht. Das liest genau ein Byte von der Standardeingabe des Prozesses. Das was Du beobachtest ist wahrscheinlich das Verhalten des Terminals was die Eingabe erst an den Prozess weiterleitet, wenn Du entweder das Zeichen für eine neue Zeile durch die Eingabetaste erzeugst oder den Datenstrom mit der entsprechenden Tastenkombination beendest. Unter Unix ist das Ctrl+D und unter Windows Ctrl+Z. Auf jeden Fall ist das das Verhalten was alle anderen (mit bekannten) BF-Interpreter an den Tag legen und was auch Sinn macht. Denn man möchte Ein- und Ausgabe in der Regel umleiten können.

[fail]

Ich habe versucht es mit einem Dictionary umzusetzen aber nach eine Schleife beendet es mein Programm.

Code: Alles auswählen

import sys

def bf(code):
    def Klammernpaare(code):
        listeoffen=[]
        zuposition={}
        for s in code:
            if s=="[":
                listeoffen.append(code.index(s))
            elif s=="]":
                zuposition[listeoffen.pop()]=code.index(s)

        offenposition=dict((zuposition[i],i) for i in zuposition)    
	
        return offenposition, zuposition
		
    def ink():
        cells[cellindex] +=1
    def dek():
        cells[cellindex] -=1
    def vorne():
        cellindex +=1
    def hinten():
        cellindex -=1
    def ausgabe():
        print(chr(cells[cellindex]), end="")
    def eingabe():
        cells[cellindex] = ord(sys.stdin.read(1))  #ord(input())
    def schleifenanfang():
        if cells[cellindex]== 0:
                codeindex=zuposition[codeindex]
    def schleifenende():
        codeindex=offenposition[codeindex]
        codeindex -=1
    befehle={"+":ink,"-":dek,">":vorne,"<":hinten,".":ausgabe,",":eingabe,"[":schleifenanfang,"]":schleifenende}
    #Kommentare entfernen
    code=[s for s in code if s in ("<",">","+","-",".",",","[","]")]
    #aktuelle Zelle
    cellindex=0
    #Zellen
    cells=[0]*30000
    #Position im Code
    codeindex=0
    #Klammernpaare finden für Schleifen
    offenposition, zuposition= Klammernpaare(code)

    while codeindex < len(code):
        index=code[codeindex]
        befehle[code[codeindex]]()
        codeindex +=1


bf(input("Geben sie hier ihren Code ein: "))
input()