di  -  mercoledì 6 aprile 2011

Introduzione

In questa parte analizzeremo l’istruzione più delicata presente nel pdp8, ovvero quella che carica il contenuto del codice assembly, trasformandolo in codice macchina, nel nostro calcolatore didattico. Vedremo anche alcune funzioni utili per controllare lo stato della macchina durante l’esecuzione.

Ho già apportato le modifiche suggerite nel precedente articolo, di conseguenza il codice dovrebbe essere ancora più comprensibile. Non ho convertito il core per funzionare con gli interi, ma questa scelta è prettamente personale, poiché abbiamo già visto che porterebbe un incremento di prestazioni, che comunque non è rilevante ai fini del programma, del quale mi interessava sopratutto il funzionamento.

Codice

def carica(self,codice,master):
        """
        Carica il codice assembly in memoria.
        Non si conta l'ultimo END, che corrisponde al fine programma.
        La funzione ritorna 1 se il caricamento va a buon fine, None altrimenti.
        """
        self.halt = False # warning se l'istruzione HLT non viene trovata

        temp = codice.rstrip()
        temp = temp.split('\n')
        for x in range(0,len(temp)):
            temp[x] = self.purgestr(temp[x])
        self.purge(temp)
        cod = []

        ### elimino commenti
        for x in temp:
            var = x.split('/')
            cod.append(var[0].rstrip())

        self.purge(cod)
        ### START
        temp = cod[0].split()
        tempRAM = {}

        if temp[0] == 'ORG':
            if int(str(temp[1]),16)>-1 and int(str(temp[1]),16)<4096:
                self.START = int(str(temp[1]),16)
                self.PC = self.binario(self.START).zfill(12)
                cod.pop(0)
            else :
                showwarning("Errore di caricamento", "ORG di inizio file non corretto", parent = master.codice.master)
                return None
        else :
            self.START = 0
            self.PC = self.binario(self.START).zfill(12)

        ### Elimino END
        try:
            end = cod.index('END')
            if end == len(cod)-1:
                cod.pop(end)
                self.purge(cod)
            else:
                raise Exception
        except Exception:
            showwarning("Errore di caricamento", "Fine codice (END) non trovato!", parent = master.codice.master)
            return None

        origin = self.START
        count = 0
        ### RAM temporanea
        for x in range(0,len(cod)):
            temp = cod[x]
            if temp[:3] == 'ORG':
                tt = temp.split()
                if int(str(tt[1]),16)<4096 and int(str(tt[1]),16)>-1:
                    self.START = int(str(tt[1]),16)
                    count = 0
                    continue
                else:
                    showwarning("Errore di caricamento", "ORG non corretto", parent = master.codice.master)
                    return None
            tempRAM[self.START+count] = temp
            count += 1

        self.START = origin
        ### LABEL
        for x,y in sorted(tempRAM.iteritems()):
            if y.find(',')>=0:
                temp = y.split(',')
                self.purge(temp)
                self.LABEL[self.purgestr(temp[0].lstrip())]= self.binario(x).zfill(12)
                tempRAM[x] = temp[1]

        ### RAM
        for x,y in sorted(tempRAM.iteritems()):
            self.RAM[self.binario(x).zfill(12)] = y

        ### DEC e HEX e decodifica codici
        try:
            for x,y in sorted(self.RAM.iteritems()):
                temp = y.split(' ')
                self.purge(temp)
                for z in range(0,len(temp)):
                    temp[z] = self.purgestr(temp[z])
                if len(temp) == 0:
                    continue
                elif temp[0].lstrip() == 'DEC':
                    self.RAM[x] = self.binario(
                        self.range(int(temp[1]))).zfill(16)
                elif temp[0] == 'HEX':
                    self.RAM[x] = self.binario(self.range
                              (int(temp[1],16))).zfill(16)
                elif len(temp)==2:
                    if len(temp[0])!=3 :
                        raise Exception
                    else:
                        self.RAM[x]= '0'+self.decode(temp[0])+self.decode(temp[1])
                elif len(temp)==3:
                    if len(temp[0])!=3 :
                        raise Exception
                    else:
                        self.RAM[x]= '1'+self.decode(temp[0])+self.decode(temp[1])
                else:
                    self.RAM[x]= self.decode(temp[0].lstrip())
        except Exception:
            showwarning("Errore di caricamento", "Correggere : "+str(y), parent = master.codice.master)
            return None

        for x,y in sorted(self.RAM.iteritems()):
            self.BREAKP[x] = False
            if len(x)>12 or len(y)>16:
                return None
            if len(y) != 16:
                self.RAM[x] = y.zfill(16)

        self.nstep = 1

        if not self.halt:
            showwarning("Attenzione !!!",
                        """Istruzione assembly HLT non presente!!!
                        \nQuesto può portare ad un errore il programma, per esempio a causa di un ciclo infinito;
                        \nQuindi si potrebbe uscire inaspettatamente dall'applicazione.""", parent = master.master)
        return 1

    def decode(self,x):
        """
        Ritorna una stringa binaria corrispondente al comando passato
        """
        if self.LABEL.has_key(x):
            return str(self.LABEL[x])
        elif self.Opcodes.has_key(x):
            if x == 'HLT' and self.halt is False:
                self.halt = True
            return str(self.Opcodes[x])
        else:
            if len(x) != 0:
                return self.binario(
                        self.range(
                            int(str(x),16))).zfill(12)

    def setnstep(self,n):
        """
        Setta il numero di cicli da eseguire
        """
        self.nstep = n

    def startCD(self):
        """
        Avvia il Calcolatore Didattico
        """
        self.S = True

    def stopCD(self):
        """
        Arresta il calcolatore di dattico
        """
        self.S = False

    def __str__(self):
        """
        Stampa a video lo stato del Calcolatore Didattico
        """
        stringa = ''
        stringa += self.statusRAM()
        stringa += self.statusREG()
        stringa += self.label()
        stringa += self.uc()
        return stringa

    def statusRAM(self):
        """
        Ritorna una stringa con lo stato della RAM
        """
        stringa = ''
        strlabel = ''
        stropcode = ''
        stringa += 'Ind BIN'+'\t\t'+'B'+'\t'+'Ind HEX'+'\t\t'+'Cod Istr.'+'\t\t '+'LABEL'+'\t'+'Opcode'+'\t'+'Val DEC'+'\n'
        stringa += "--------------------------------------------------------------------------------"+"\n"
        temp = """%s\t\t%s\t%s\t\t%s\t%s\t\t%s\t%s\n"""
        for x,y in sorted(self.RAM.iteritems()):
            if self.BREAKP.has_key(x) and self.BREAKP[x]:
                breakpoint = 'X'
            else :
                breakpoint = '-'
            for z,t in sorted(self.LABEL.iteritems()):
                if t == x:
                    strlabel = z
                    break
                else:
                    strlabel = ''
            for h,j in sorted(self.Opcodes.iteritems()):
                if j == y[1:4]:
                    stropcode = h
                    break
                elif j == y and (j[:4] == '0111' or j[:4] == '1111'):
                    stropcode = h
                    break
                else:
                    stropcode = ''
            stringa += temp % (x, breakpoint,self.esadecimale(int(str(x),2)), y, strlabel,stropcode,
                               str(self.range(int(y,2))))
        stringa += "--------------------------------------------------------------------------------"+"\n"
        return stringa

    def statusREG(self):
        """
        Ritorna una stringa con lo stato dei registri
        """
        stringa = ''
        stringa += ("\n"+"--- REGISTRI ----------------------------"+"\n")
        stringa += ("PC\t= "+str(self.PC)+"\n")
        stringa += ("I\t= "+str(self.I)+"\tOPR\t= "+str(self.OPR)+"\n")
        stringa += ("E\t= "+str(self.E)+"\tAC\t= "+str(self.AC)+"\n")
        stringa += ("MAR\t= "+str(self.MAR)+"\n")
        stringa += ("MBR\t= "+str(self.MBR)+"\n")
        stringa += ("------------------------------------------""\n")
        return stringa

    def label(self):
        """
        Ritorna una stringa con i label memorizzati
        """
        stringa = ''
        stringa += ("\n"+"--- LABELS ------------"+"\n")
        for x,y in sorted(self.LABEL.iteritems()):
            stringa += str(x)+' = '+str(y)+'\n'
        stringa += ("-----------------------""\n")
        return stringa

    def uc(self):
        """
        Ritorna una stringa con lo stato dell'unita' di controllo
        """
        stringa = ''
        stringa += ("\n"+"--- UC ------"+"\n")
        stringa += 'S =\t'+str(self.S)+'\n'
        stringa += 'F =\t'+str(self.F)+'\n'
        stringa += 'R =\t'+str(self.R)+'\n'
        stringa += 'Int =\t'+str(self.Interrupt)+'\n'
        stringa += ("-------------""\n")
        return stringa

Analisi

– La funzione carica riceve in input il codice da caricare (codice) e la finestra dell’editor (master). Quest’ultima è stata aggiunta in un secondo momento, poiché ora la funzione visualizza un finestra di warning a seconda dell’errore commesso (sempre tramite tkinter).

Il file di testo viene passato alla funzione eliminando gli spazi all’inizio, quindi utilizziamo rstrip per togliere quelli alla fine e memorizziamo il codice in una variabile temporanea.

Una volta diviso il codice per righe tramite split(‘\n’), ripuliamo ogni stringa ed infine anche la lista di stringhe da caratteri indesiderati.

Fatto questo, creiamo una lista cod che conterrà i codici da tradurre. Per inserirli correttamente, eliminiamo i commenti e aggiungiamo solo quello che ci serve alla lista. Finito questo, eliminiamo elementi indesiderati dalla lista.

Ora che abbiamo i nostri codici, controlliamo se all’inizio è presente la stringa ORG e settiamo di conseguenza la variabile START, per indicare da quale indirizzo si inizierà a memorizzare il programma. Se l’ORG non è corretto, si interrompe e si mostra una finestra di warning. Abbiamo anche creato una variabile temporanea per la ram (un dizionario per la precisione).

Il controllo successivo, consiste nel trovare l’END del file, se non presente si ritorna errore come prima. Da notare che END si deve trovare necessariamente nell’ultima posizione, ovvero quella di index n-1 dove n è il numero degli elementi della lista cod. Visto che dovrebbe essere utilizzato solo per indicare la fine del file, non controllo se l’utente lo utilizza nel codice, ma in tal caso ristituirebbe comunque errore perché non si trova solo alla fine del file e l’idex quindi non sarà quello dell’ultimo elemento, ma di un elemento all’interno di cod.

Successivamente memorizziamo i codici nella ram temporanea in base al loro indirizzo. Essendo prevista la presenza di più ORG, utilizzo un contatore (count) per determinare la cella del codice da scrivere partendo da start. Origin terrà traccia del valore iniziale di START, poiché sarà soggetto a mutamenti e quindi dovrà essere ripristinato alla fine.

Una volta creata la ram temporanea possiamo riempire la tabella dei Labels, associando ogni etichetta al suo indirizzo fisico (si parla sempre della memoria del nostro calcolatore). Eliminiamo dunque le etichette dalla ram temporanea, lasciando solo i codici veri e propri (tempRAM[x]=temp[1]).

Una volta copiata la ram temporanea nella ram vera e propria (si intende sempre quella del calcolatore didattico), si procede all’ultima conversione dei codici assembly in stringhe binarie. Di norma le stringhe avranno due o tre istruzioni e quindi verranno tradotte in base a quello che è presente nella stringa. Per prima però si controlla se indicano un numero espresso in valore decimale (DEC) oppure in esadecimale (HEX).

Si conclude estendendo le stringhe nella ram a 16 bit (se rappresentate con meno) ed aggiornando la ‘tabella’ dei breakpoints. Infine si controlla se l’istruzione HLT è stata trovata.

Decode trasforma in binario i codici passati, controllando prima se sono indirizzi presenti nei labels, poi se sono istruzioni, altrimenti tratta quello che trova come se fosse un numero esadecimale e lo converte in binario. In questa funzione viene anche gestito il ritrovamento di HLT, che tecnicamente è solo un avvertimento, visto che il warning per HLT non blocca lesecuzione ma ritorna successivamente 1 (nella funzione carica carica).

– Le altre funzioni dovrebbero essere semplici da capire, visto che hanno solo il compito di stampare a video quello che è presente nel pdp8. Se avete provato il programma, noterete che l’unica funzione necessaria è statusRAM (per quel che riguarda l’interfaccia grafica), le altre sono solo necessarie se si utilizza la riga di comando. Infatti, durante la stesura del programma, controllavo la sua esecuzione tramite queste funzioni, visto che ancora non avevo implementato un’interfaccia grafica.

Conclusioni

Questa parte è stata la più delicata e fondamentale per tutto il progetto. Risente delle scelte prese inizialmente e condiziona pesantemente i passi successivi. Spero di essere stato comprensibile e di avervi dato un’idea di quello che fa l’emulatore per caricare un file assembly. Badate bene che questo è molto lontano dal lavoro che svolge un vero e proprio assembler, ma comunque ci si avvicina, se non altro come logica. Nel prossimo articolo vedremo come è gestita l’esecuzione del pdp8 per poi passare all’interfaccia grafica.

5 Commenti »

I commenti inseriti dai lettori di AppuntiDigitali non sono oggetto di moderazione preventiva, ma solo di eventuale filtro antispam. Qualora si ravvisi un contenuto non consono (offensivo o diffamatorio) si prega di contattare l'amministrazione di Appunti Digitali all'indirizzo info@appuntidigitali.it, specificando quale sia il commento in oggetto.

  • # 1
    Antonio Barba (TheKaneB)
     scrive: 

    Bravo! Io pensavo che fosse un semplice emulatore, invece gli hai infilato pure l’assembler :-) Molto comodo per fare esperimenti!

  • # 2
    Antonio Barba (TheKaneB)
     scrive: 

    Stai già scrivendo la prossima puntata? dai su su… :D

  • # 3
    Mirco Tracolli
     scrive: 

    Certamente, ma non volevo perdere troppo di vista la parte di isometria in pygame, quindi sto preparando entrambi. Vi prego di pazientare :D !!!

  • # 4
    Antonio Barba (TheKaneB)
     scrive: 

    fai fai… io preparo il secondo articolo sul DS :-p

  • # 5
    selene
     scrive: 

    Ti stai impegnando veramente tanto! Bravissimo! ^^

Scrivi un commento!

Aggiungi il commento, oppure trackback dal tuo sito.

I commenti inseriti dai lettori di AppuntiDigitali non sono oggetto di moderazione preventiva, ma solo di eventuale filtro antispam. Qualora si ravvisi un contenuto non consono (offensivo o diffamatorio) si prega di contattare l'amministrazione di Appunti Digitali all'indirizzo info@appuntidigitali.it, specificando quale sia il commento in oggetto.