Station - Ein Interpreter für strukturierte MyKa-Programme

Aufgabe des Interpreters

Aufgabe des Interpretes ist es, strukturierte MyKa-Programme (Schritt für Schritt) auszuführen.

Die Arbeitsweise des Interpreters soll am folgenden Beispiel-Programm verdeutlicht werden.

[
    ['links'], 
    ['while', 
        ['nichtVorWand'], 
        [
            ['ziegelHinlegen'], 
            ['schritt']
        ]
    ]
]

Der Interpreter transformiert jeweils das noch auszuführende Restprogramm. In jedem Schritt wird die erste, in der Liste vorkommende Anweisung ausgeführt. Handelt es sich um eine Elementaranweisung, so wird der Roboter aktiviert. Bei Kontrollanweisungen wird ebenfalls der Roboter zur Auswertung der Bedingung aktiviert. Zusätzlich werden - in Abhängigkeit von dieser Auswertung - die nächsten auszuführenden Anweisung an den Anfang der Anweisungsliste gesetzt.

Programm:
[
    ['links'], 
    ['while', 
        ['nichtVorWand'], 
        [
            ['ziegelHinlegen'], 
            ['schritt']
        ]
    ]
]
Roboter:
(0, 0, 'S')
Welt:
[[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:
[
    ['while', 
        ['nichtVorWand'], 
        [
            ['ziegelHinlegen'], 
            ['schritt']
        ]
    ]
]
Roboter:
(0, 0, 'O')
Welt:
[[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]]

================================== Bedingung wahr ===================================

Programm:
[
    ['ziegelHinlegen'], 
    ['schritt'],
    ['while', 
        ['nichtVorWand'], 
        [
            ['ziegelHinlegen'], 
            ['schritt']
        ]
    ]
]
Roboter:
(0, 0, 'O')
Welt:
[[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:
[
    ['schritt'],
    ['while', 
        ['nichtVorWand'], 
        [
            ['ziegelHinlegen'], 
            ['schritt']
        ]
    ]
]
Roboter:
(0, 0, 'O')
Welt:
[[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:
[
    ['while', 
        ['nichtVorWand'], 
        [
            ['ziegelHinlegen'], 
            ['schritt']
        ]
    ]
]
Roboter:
(1, 0, 'O')
Welt:
[[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:
[
    ['while', 
        ['nichtVorWand'], 
        [
            ['ziegelHinlegen'], 
            ['schritt']
        ]
    ]
]
Roboter:
(4, 0, 'O')
Welt:
[[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]]

================================= Bedingung falsch ==================================

Programm:
[
]
Roboter:
(4, 0, 'O')
Welt:
[[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 Interpreters

Wir benutzen Objekte der Klasse Roboter und Welt (siehe myka.zip) zur Simulation der Roboterwelt.

Der Interpreter wird durch ein Objekt der Klasse InterpreterWhileList realisiert. Dieses Objekt verfügt insbesondere über eine Methode anweisungAusfuehren, die letztlich für das Auswerten von Anweisungen zuständig ist.

class InterpreterMyKaList(object):
    def __init__(self, r):
        self.programm = None
        self.roboter = r

    def setProgramm(self, p):
        self.programm = p

    def getProgramm(self):
        return self.programm

    def anweisungAusfuehren(self):
        if self.programm != []:
            anweisung = self.programm[0]
            bezeichner = anweisung[0]
            if bezeichner in ["schritt",
                              "links",
                              "rechts",
                              "ziegelHinlegen",
                              "ziegelAufheben",
                              "markeSetzen",
                              "markeLoeschen",
                              "pass"]:
                self.verarbeiteAnweisung(bezeichner)
                self.programm = self.programm[1:]
            elif bezeichner == "while":
                bedingung = anweisung[1]
                bezeichner_bedingung = bedingung[0]
                if self.verarbeiteBedingung(bezeichner_bedingung):
                    self.programm = anweisung[2] + self.programm
                else:
                    self.programm = self.programm[1:]
            elif bezeichner == "if":
                pass

    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()

Objekte der vorgestellten Klassen können jetzt direkt genutzt werden, um strukturierte MyKa-Programme auszuführen.

from roboterwelt import *
from interpreterMyKaList import *

# Testprogramm
programm = [
    ['links'], 
    ['while', 
        ['nichtVorWand'], 
        [
            ['ziegelHinlegen'], 
            ['schritt']
        ]
    ]
]

# Erzeugung des Interpreters
roboter = Roboter()
welt = Welt(5, 5)
roboter.setWelt(welt)
interpreter = InterpreterMyKaList(roboter)
# Initialisierung des Programms
interpreter.setProgramm(programm)

# Ausführung des Programms und Ausgabe der Zustände
print('Programm:')
print(interpreter.programm)
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 interpreter.getProgramm() != []:
    interpreter.anweisungAusfuehren()
    print('Programm:')
    print(interpreter.programm)
    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 MyKa-Programme.

Aufgabe 2

Ergänze die Regel zur Ausführung einer if-Anweisung.