Aufgabe des Interpreters

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

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

[
  ['=', ('VAR', 'x'), [('ZAHL', '9')]],
  ['=', ('VAR', 'y'), [('ZAHL', '6')]],
  ['while', ['!=', ('VAR', 'x'), ('VAR', 'y')], 
    [
      ['if', ['<=', ('VAR', 'x'), ('VAR', 'y')], 
        [
          ['=', ('VAR', 'y'), ['-', ('VAR', 'y'), ('VAR', 'x')]]
        ], 
        [
          ['=', ('VAR', 'x'), ['-', ('VAR', 'x'), ('VAR', 'y')]]
        ]
      ]
    ]
  ]
]

Der Interpreter transformiert jeweils das noch auszuführende Restprogramm und den aktuellen Variablenzustand:

Restprogramm:
[
  ['=', ('VAR', 'x'), [('ZAHL', '9')]],
  ['=', ('VAR', 'y'), [('ZAHL', '6')]],
  ['while', ['!=', ('VAR', 'x'), ('VAR', 'y')], 
    [
      ['if', ['<=', ('VAR', 'x'), ('VAR', 'y')], 
        [
          ['=', ('VAR', 'y'), ['-', ('VAR', 'y'), ('VAR', 'x')]]
        ], 
        [
          ['=', ('VAR', 'x'), ['-', ('VAR', 'x'), ('VAR', 'y')]]
        ]
      ]
    ]
  ]
]
Variablenzustand:
{}
<p>==================================================================</p>
<p>Restprogramm:<br />
[<br />
['=', ('VAR', 'y'), [('ZAHL', '6')]],<br />
['while', ['!=', ('VAR', 'x'), ('VAR', 'y')],<br />
[<br />
['if', ['<=', ('VAR', 'x'), ('VAR', 'y')],<br />
[<br />
['=', ('VAR', 'y'), ['-', ('VAR', 'y'), ('VAR', 'x')]]<br />
],<br />
[<br />
['=', ('VAR', 'x'), ['-', ('VAR', 'x'), ('VAR', 'y')]]<br />
]<br />
]<br />
]<br />
]<br />
]</p>
<p>Variablenzustand:<br />
{'x' -> 9}</p>
<p>==================================================================</p>
<p>Restprogramm:<br />
[<br />
['while', ['!=', ('VAR', 'x'), ('VAR', 'y')],<br />
[<br />
['if', ['<=', ('VAR', 'x'), ('VAR', 'y')],<br />
[<br />
['=', ('VAR', 'y'), ['-', ('VAR', 'y'), ('VAR', 'x')]]<br />
],<br />
[<br />
['=', ('VAR', 'x'), ['-', ('VAR', 'x'), ('VAR', 'y')]]<br />
]<br />
]<br />
]<br />
]<br />
]<br />
Variablenzustand:<br />
{'x' -> 9, 'y' -> 6}</p>
<p>======================= Bedingung wahr ===========================</p>
<p>Restprogramm:<br />
[<br />
['if', ['<=', ('VAR', 'x'), ('VAR', 'y')],<br />
[<br />
['=', ('VAR', 'y'), ['-', ('VAR', 'y'), ('VAR', 'x')]]<br />
],<br />
[<br />
['=', ('VAR', 'x'), ['-', ('VAR', 'x'), ('VAR', 'y')]]<br />
]<br />
],<br />
['while', ['!=', ('VAR', 'x'), ('VAR', 'y')],<br />
[<br />
['if', ['<=', ('VAR', 'x'), ('VAR', 'y')],<br />
[<br />
['=', ('VAR', 'y'), ['-', ('VAR', 'y'), ('VAR', 'x')]]<br />
],<br />
[<br />
['=', ('VAR', 'x'), ['-', ('VAR', 'x'), ('VAR', 'y')]]<br />
]<br />
]<br />
]<br />
]<br />
]<br />
Variablenzustand:<br />
{'x' -> 9, 'y' -> 6}</p>
<p>======================= Bedingung falsch ===========================</p>
<p>Restprogramm:<br />
[<br />
['=', ('VAR', 'x'), ['-', ('VAR', 'x'), ('VAR', 'y')]],<br />
['while', ['!=', ('VAR', 'x'), ('VAR', 'y')],<br />
[<br />
['if', ['<=', ('VAR', 'x'), ('VAR', 'y')],<br />
[<br />
['=', ('VAR', 'y'), ['-', ('VAR', 'y'), ('VAR', 'x')]]<br />
],<br />
[<br />
['=', ('VAR', 'x'), ['-', ('VAR', 'x'), ('VAR', 'y')]]<br />
]<br />
]<br />
]<br />
]<br />
]<br />
Variablenzustand:<br />
{'x' -> 9, 'y' -> 6}</p>
<p>==================================================================</p>
<p>Restprogramm:<br />
[<br />
['while', ['!=', ('VAR', 'x'), ('VAR', 'y')],<br />
[<br />
['if', ['<=', ('VAR', 'x'), ('VAR', 'y')],<br />
[<br />
['=', ('VAR', 'y'), ['-', ('VAR', 'y'), ('VAR', 'x')]]<br />
],<br />
[<br />
['=', ('VAR', 'x'), ['-', ('VAR', 'x'), ('VAR', 'y')]]<br />
]<br />
]<br />
]<br />
]<br />
]<br />
Variablenzustand:<br />
{'x' -> 3, 'y' -> 6}</p>
<p>==================================================================</p>
<p>...</p>
<p>==================================================================</p>
<p>Restprogramm:<br />
[<br />
['while', ['!=', ('VAR', 'x'), ('VAR', 'y')],<br />
[<br />
['if', ['<=', ('VAR', 'x'), ('VAR', 'y')],<br />
[<br />
['=', ('VAR', 'y'), ['-', ('VAR', 'y'), ('VAR', 'x')]]<br />
],<br />
[<br />
['=', ('VAR', 'x'), ['-', ('VAR', 'x'), ('VAR', 'y')]]<br />
]<br />
]<br />
]<br />
]<br />
]<br />
Variablenzustand:<br />
{'x' -> 3, 'y' -> 3}</p>
<p>======================= Bedingung falsch ===========================</p>
<p>Restprogramm:<br />
[<br />
]<br />
Variablenzustand:<br />
{'x' -> 3, 'y' -> 3}<br />

Alles klar?

Implementierung des Interpreters

Zur Verwaltung des Variablenzustans wird ein Objekt der Klasse Variablenzustand benutzt. Dieses Objekt stellt Operationen bereit, mit denen ein Variablenwert ermittelt und auch ein Variablenwert neu gesetzt werden kann.

class Variablenzustand(object):
    def __init__(self):
        self.variablen = {}
<pre><code>def initVariablen(self, v):
    self.variablen = {}
    for bezeichner in v:
        self.variablen[bezeichner] =0

def getVariable(self, bezeichner):
    return self.variablen[bezeichner]

def setVariable(self, bezeichner, wert):
    self.variablen[bezeichner] = wert

def setVariablenzustand(self, zustand):
    self.variablen = zustand

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 InterpreterWhileList(object):
    def __init__(self, v):
        self.programm = None
        self.variablenzustand = v
<pre><code>def setProgramm(self, p):
    self.programm = p

def getProgramm(self):
    return self.programm

def getVariablenzustand(self):
    return self.variablenzustand

def anweisungAusfuehren(self):
    if self.programm != []:
        anweisung = self.programm[0]
        bezeichner = anweisung[0]
        if bezeichner == "=":
            self.verarbeiteZuweisung(anweisung)
            self.programm = self.programm[1:]
        if bezeichner == "pass":
            self.programm = self.programm[1:]
        elif bezeichner == "while":
            bedingung = anweisung[1]
            if self.verarbeiteBedingung(bedingung):
                self.programm = anweisung[2] + self.programm
            else:
                self.programm = self.programm[1:]
        elif bezeichner == "if":
            bedingung = anweisung[1]
            if self.verarbeiteBedingung(bedingung):
                self.programm = anweisung[2] + self.programm[1:]
            else:
                self.programm = anweisung[3] + self.programm[1:]

def verarbeiteZuweisung(self, anweisung):
    variable = anweisung[1][1]
    term = anweisung[2]
    self.variablenzustand.setVariable(variable, self.wertTerm(term))

def wertOperand(self, operand):
    if operand[0] == "ZAHL":
        return int(operand[1])
    elif operand[0] == "VAR":
        return self.variablenzustand.getVariable(operand[1])

def wertTerm(self, term):
    if len(term) == 1:
        return self.wertOperand(term[0])
    else:
        wertOperand1 = self.wertOperand(term[1])
        wertOperand2 = self.wertOperand(term[2])
        op = term[0]
        if op == "+":
            return wertOperand1 + wertOperand2
        elif op == "-":
            return wertOperand1 - wertOperand2

def verarbeiteBedingung(self, bedingung):
    wertOperand1 = self.wertOperand(bedingung[1])
    wertOperand2 = self.wertOperand(bedingung[2])
    rel = bedingung[0]
    if rel == "==":
        return (wertOperand1 == wertOperand2)
    elif rel == "!=":
        return (wertOperand1 != wertOperand2)
    elif rel == "&lt;":
        return (wertOperand1 &lt; wertOperand2)
    elif rel == "&lt;=":
        return (wertOperand1 &lt;= wertOperand2)

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

from interpreterWhileList import *
from variablenzustand import *
<h1>Testprogramm</h1>
<p>programm = [<br />
['=', ('VAR', 'x'), [('ZAHL', '9')]],<br />
['=', ('VAR', 'y'), [('ZAHL', '6')]],<br />
['while', ['!=', ('VAR', 'x'), ('VAR', 'y')],<br />
[<br />
['if', ['<=', ('VAR', 'x'), ('VAR', 'y')],<br />
[<br />
['=', ('VAR', 'y'), ['-', ('VAR', 'y'), ('VAR', 'x')]]<br />
],<br />
[<br />
['=', ('VAR', 'x'), ['-', ('VAR', 'x'), ('VAR', 'y')]]<br />
]<br />
]<br />
]<br />
]<br />
]</p>
<h1>Erzeugung des Interpreters</h1>
<p>variablenzustand = Variablenzustand()<br />
interpreter = InterpreterWhileList(variablenzustand)</p>
<h1>Initialisierung des Programms</h1>
<p>interpreter.setProgramm(programm)</p>
<h1>Ausführung des Programms und Ausgabe der Zustände</h1>
<p>print('Restprogramm:')<br />
print(interpreter.programm)<br />
print('Variablenzustand')<br />
print(variablenzustand.variablen)<br />
print('---------------------------')<br />
while interpreter.getProgramm() != []:<br />
interpreter.anweisungAusfuehren()<br />
print('Restprogramm:')<br />
print(interpreter.programm)<br />
print('Variablenzustand')<br />
print(variablenzustand.variablen)<br />
print('---------------------------')<br />

Aufgabe 1

Probiere das selbst einmal aus. Teste verschiedene strukturierte MiniPython-Programme.