Station - Ein Code-Interpreter für strukturierte MyKaGoto-Programme
Aufgabe des Code-Interpreters
Der Code-Erzeuger hat die Aufgabe, strukturierte MyKaGoto-Programme auszuführen. Wir verdeutlichen die Ausführung an einem entsprechenden Goto-Programm.
Bei der Ausführung müssen der aktuelle Variablenzustand und die aktuelle Ausführungsstelle im Programm
verwaltet werden.
Zur Verwaltung der Ausführungsstelle wird hier ein sog. Programmzähler benutzt. Dieser Programmzähler
wird im Folgenden durch das Symbol >
gekennzeichnet.
Programm: >links label .L0 if nichtVorWand: goto .L1 else: goto .L2 label .L1 ziegelHinlegen schritt goto .L0 label .L2 Roboter: (0, 0, 'S') Welt - Ziegel: [[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]] ===================================================================================== Programm: links >label .L0 if nichtVorWand: goto .L1 else: goto .L2 label .L1 ziegelHinlegen schritt goto .L0 label .L2 Roboter: (0, 0, 'O') Welt - Ziegel: [[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]] ===================================================================================== Programm: links label .L0 >if nichtVorWand: goto .L1 else: goto .L2 label .L1 ziegelHinlegen schritt goto .L0 label .L2 Roboter: (0, 0, 'O') Welt - Ziegel: [[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]] ===================================================================================== Programm: links label .L0 if nichtVorWand: goto .L1 else: goto .L2 >label .L1 ziegelHinlegen schritt goto .L0 label .L2 Roboter: (0, 0, 'O') Welt - Ziegel: [[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]] ===================================================================================== Programm: links label .L0 if nichtVorWand: goto .L1 else: goto .L2 label .L1 >ziegelHinlegen schritt goto .L0 label .L2 Roboter: (0, 0, 'O') Welt - Ziegel: [[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]] ===================================================================================== Programm: links label .L0 if nichtVorWand: goto .L1 else: goto .L2 label .L1 ziegelHinlegen >schritt goto .L0 label .L2 Roboter: (0, 0, 'O') Welt - Ziegel: [[0, 1, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]] ===================================================================================== Programm: links label .L0 if nichtVorWand: goto .L1 else: goto .L2 label .L1 ziegelHinlegen schritt >goto .L0 label .L2 Roboter: (1, 0, 'O') Welt - Ziegel: [[0, 1, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]] ===================================================================================== Programm: links >label .L0 if nichtVorWand: goto .L1 else: goto .L2 label .L1 ziegelHinlegen schritt goto .L0 label .L2 Roboter: (1, 0, 'O') Welt - Ziegel: [[0, 1, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]] ===================================================================================== ... ===================================================================================== Programm: links label .L0 if nichtVorWand: goto .L1 else: goto .L2 label .L1 ziegelHinlegen schritt goto .L0 label .L2 Roboter: (4, 0, 'O') Welt - Ziegel: [[0, 1, 1, 1, 1], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
Alles klar?
Implementierung des Code-Interpreters
Wir benutzen Objekte der Klasse Roboter und Welt (vgl. ...) zur
Simulation der Roboterwelt.
Der Code-Interpreter wird durch ein Objekt der Klasse InterpreterMyKaGoto realisiert.
Dieses Objekt verfügt insbesondere über eine Methode anweisungAusfuehren, die
letztlich für das Auswerten von Anweisungen zuständig ist.
class InterpreterMyKaGoto(object):
def __init__(self, rob):
self.programm = None
self.pc = 0
self.roboter = rob
def initProgramm(self, p):
self.programm = p
self.pc = 0
def getProgramm(self):
return self.programm
def getPC(self):
return self.pc
def anweisungAusfuehren(self):
if self.pc < len(self.programm):
zeile = self.programm[self.pc]
label = zeile[0]
if label != None:
self.pc = self.pc + 1
else:
anweisung = zeile[1]
if anweisung[0] in ["schritt",
"links",
"rechts",
"ziegelHinlegen",
"ziegelAufheben",
"markeSetzen",
"markeLoeschen",
"pass"]:
self.verarbeiteAnweisung(anweisung[0])
self.pc = self.pc + 1
elif anweisung[0] == "if":
if self.verarbeiteBedingung(anweisung[1][0]):
self.verarbeiteGoto(anweisung[2])
else:
self.verarbeiteGoto(anweisung[3])
elif anweisung[0] == "goto":
self.verarbeiteGoto(anweisung)
elif anweisung[0] == "noop":
self.pc = self.pc + 1
def verarbeiteAnweisung(self, bezeichner):
if bezeichner == "schritt":
self.roboter.schritt()
elif bezeichner == "links":
self.roboter.links()
elif bezeichner == "rechts":
self.roboter.rechts()
elif bezeichner == "markeSetzen":
self.roboter.markeSetzen()
elif bezeichner == "markeLoeschen":
self.roboter.markeLoeschen()
elif bezeichner == "ziegelHinlegen":
self.roboter.ziegelHinlegen()
elif bezeichner == "ziegelAufheben":
self.roboter.ziegelAufheben()
elif bezeichner == "pass":
self.roboter.pause()
def verarbeiteBedingung(self, bezeichner):
if bezeichner == "vorZiegel":
return self.roboter.vorZiegel()
elif bezeichner == "nichtVorZiegel":
return self.roboter.nichtVorZiegel()
elif bezeichner == "vorWand":
return self.roboter.vorWand()
elif bezeichner == "nichtVorWand":
return self.roboter.nichtVorWand()
elif bezeichner == "aufMarke":
return self.roboter.aufMarke()
elif bezeichner == "nichtAufMarke":
return self.roboter.nichtAufMarke()
def verarbeiteGoto(self, anweisung):
label = anweisung[1]
self.pc = 0
while self.programm[self.pc][0] != label:
self.pc = self.pc + 1
Objekte der vorgestellten Klassen können jetzt direkt genutzt werden, um strukturierte Goto-Programme auszuführen.
from roboterwelt import *
from interpreterMyKaGoto import *
# Testprogramm
programm = [
(None, ['links']),
('.L0', ['noop']),
(None, ['if', ['nichtVorWand'], ['goto', '.L1'], ['goto', '.L2']]),
('.L1', ['noop']),
(None, ['ziegelHinlegen']),
(None, ['schritt']),
(None, ['goto', '.L0']),
('.L2', ['noop'])
]
# Erzeugung des Interpreters
roboter = Roboter()
welt = Welt(5, 5)
roboter.setWelt(welt)
interpreterMyKaGoto = InterpreterMyKaGoto(roboter)
# Initialisierung des Programms
interpreterMyKaGoto.initProgramm(programm)
# Ausführung des Programms und Ausgabe der Zustände
print('Roboter:')
print(roboter.getZustand())
#print('Welt - Marken:')
#print(welt.marken)
print('Welt - Ziegel:')
print(welt.ziegel)
print('---------------------------')
weiter = input("weiter mit return")
print('---------------------------')
while interpreterMyKaGoto.getPC() < len(interpreterMyKaGoto.getProgramm()):
print('aktuelle Programmzeile:')
print(interpreterMyKaGoto.programm[interpreterMyKaGoto.pc])
interpreterMyKaGoto.anweisungAusfuehren()
print()
print('Roboter:')
print(roboter.getZustand())
#print('Welt - Marken:')
#print(welt.marken)
print('Welt - Ziegel:')
print(welt.ziegel)
print('---------------------------')
weiter = input("weiter mit return")
print('---------------------------')
Aufgabe 1
Probiere das selbst einmal aus. Teste verschiedene strukturierte MyKaGoto-Programme.
