Oppgave: Implementasjon av LMC med klasser og objekter

I denne oppgaven skal du implementere en simulator for LMC ved hjelp av klasser i Python. M?let med oppgaven er lik oppgaven for noen uker siden, men denne gangen skal vi l?se problemet ved hjelp av objektorientert programmering.

Du er gitt en tekstfil som inneholder et program skrevet i LMC-assemblerkode. Din oppgave er ? lage klassene som trengs for ? simulere denne datamaskinen. Tekstfilen leses ved hjelp av les_program-prosedyren i les_lmc-filen. Det anbefales at du laster ned les_lmc.py og legger den i samme mappe som resten av programmet.

Hvis du ikke husker hva les_program gj?r, handler det om at den gj?r om assembler-kode fra en fil, til en liste-representasjon av minnet som inneholder programkode.

Hele implementeringen av LMC skal skrives fra grunnen av. Les gjennom hele oppgaveteksten f?r du begynner med implementeringen.

Trinn 1: Implementasjon av Minne-klassen

Minne-klassen skal representere minnet i LMC. Klassen m? kunne lese og skrive til et gitt adresse.

Metoder:

• __init__(self, minne_liste): Tar inn listen som representerer minnet (100 plasser) F.eks. [901, 399, 901, 199, 902, 0, ..., 0] for add.txt-filen. Denne listen skal lagres i en i en instansvariabel.
• les(self, adresse): Returnerer verdien p? en gitt adresse.
• skriv(self, adresse, verdi): Skriver en verdi til en gitt adresse.

Trinn 2: Implementasjon av Instruksjon-klassen

Instruksjon-klassen skal representere en instruksjon i LMC. Hver instruksjon skal ha en operasjonskode (op_kode) og en operand.

Metoder:

• __init__(self, op_kode, operand): Initialiserer en instruksjon med en operasjonskode og en operand.

Trinn 3: Implementasjon av CPU-klassen

CPU-klassen skal simulere CPU-delen av LMC. Den skal kunne hente, dekode og utf?re instruksjoner fra minnet.

Metoder:

• __init__(self, minne): Initialiserer CPU-en med minneobjektet, en programteller satt til 0, og en akkumulator satt til 0.

def __init__(self, minne):
    self._minne = minne
    self._program_teller = 0
    self._akkumulator = 0

hent(self): Henter neste instruksjon fra minnet. Denne metoden m? ogs? oppdatere programtelleren.

• utf?r(self, instruksjon): Utf?rer en gitt instruksjon.
• kj?r(self): Start utf?ring av instruksjoner til vi m?ter p? en HLT-instruksjon (halt).

Instansvariabler

• Husk at denne klassen ogs? m? ha kontroll p? programtelleren og akkumulatoren

Trinn 4: Implementasjon av LMC-klassen

LMC-klassen vil v?re din hovedkontroller som initialiserer minne, laster inn programmet og starter utf?ringen.

Metoder:

• __init__(self, programfil): Initialiserer minnet og laster programmet fra programfilen. Her kan vi bruke les_program-prosedyren fra les_lmc-filen.
• kj?r(self): Starter utf?ringen ved ? bruke CPU-klassen.

Ta gjerne utgangspunkt i dette kodeskjelettet:

from les_lmc import les_program

class Minne:
    def __init__(self, minne_liste):
        pass

    def les(self, adresse):
        pass

    def skriv(self, adresse, verdi):
        pass


class Instruksjon:
    def __init__(self, op_kode, operand):
        pass


class CPU:
    def __init__(self, minne):
        pass

    def hent(self):
        pass

    def utf?r(self, instruksjon):
        pass

    def kj?r(self):
        pass


class LMC:
    def __init__(self, programfil): 
        pass

    def kj?r(self):
        pass

Programmet skal kunne kj?res s?nn her:

programfil = "factorial.txt"
lmc = LMC(programfil)
lmc.kj?r()