Scope, Memoria e Tabella dei Simboli

Transcript

1 Scope, Memoria e Tabella dei Simboli La tabella dei simboli è uno strumento fondamentale attraverso il quale interpreti e compilatori implementano la traduzione da un programma scritto in un linguaggio evoluto all equivalente scritto in linguaggio macchina. Attraverso l uso della tabella dei simboli è possibile, infatti, risolvere correttamente tutti i riferimenti ai nomi introdotti dal programmatore, risalendo così all opportuno oggetto denotato. Nel nostro linguaggio di riferimento che supporta scope statico e dinamico, l uso di funzioni e procedure, nonché diverse tipologie di passaggio dei parametri, la tabella dei simboli dovrà contenere il seguente insieme di informazioni fondamentali: per ogni nome, la natura dell oggetto denotato, ovvero, variabile, parametro, funzione o procedura; per ogni variabile, il suo tipo e l offset 1 nell RdA del blocco in cui è definita; per ogni parametro, il suo tipo, la modalità di passaggio e l offset; per ogni funzione o procedura, l indirizzo della locazione di memoria nella zona codice alla quale inizia la sua traduzione. Per comodità d uso, implementeremo la tabella dei simboli dividendo l insieme dei nomi nei vari ambienti locali che li definiscono. In presenza di riferimenti a nomi non appartenenti all ambiente locale di un blocco, sarà necessario cercare in nome nell ambiente locale dei blocchi in cui il blocco attivo in un determinato momento risulta annidato. Al fine di implementare correttamente lo scope statico e dinamico è necessario, quindi, conoscere quanti livelli di annodamento ci sono tra il blocco attivo e quello che definisce il nome utilizzato. Mentre questa informazione può essere calcolata staticamente (e quindi opportunamente memorizzata nella tabella dei simboli) in regime di scope statico, essa andrà calcolata dinamicamente in regime di scope dinamico tenendo traccia del flusso di esecuzione del programma. Illustriamo la nostra idea di tabella di simboli e l uso che ne fa l interprete attraverso il seguente esempio di programma C con scope statico. int x = 0; void pippo(reference int a) { int b; a = x + 3; b = pluto(a); 1 L offset di una variabile definita all interno di un certo blocco è il numero di locazioni di memoria che bisogna aggiungere alla locazione di inizio dell RdA associato al blocco per trovare la locazione in cui è memorizzata la variabile in questione.

2 write(b); } int pluto(int a) { a = a + 3; write(a); return (a * a); } int main() { int x = 2; pippo(x); write(x); return 0; } La memoria codice associate al programma in esame sarà la seguente: Loc. 0: x = 0 Loc. 1: main() Loc. 2: fine_programma Loc. 3: x = 2 Loc. 4: pippo(x) Loc. 5: write(x) Loc. 6: return 0 Loc. 7: fine_main Loc. 8: a = x + 3 Loc. 9: b = pluto(a) Loc. 10: write(b) Loc. 11: fine_pippo Loc. 12: a = a + 3 Loc. 13: write(a) Loc. 14: return(a * a) Loc. 15: fine_pluto Possiamo adesso calcolare gli offset delle variabili all interno dei rispettivi RdA. Per i blocchi anonimi, le variabili locali vengono memorizzate a partire dall offset 1, dato che l offset 0 è utilizzato per il puntatore di catena dinamica. Per i blocchi con nome, i parametri vengono memorizzati a partire dall offset 3 o 4 a seconda che si tratti di blocco associato a procedura o funzione. Le variabili locali vengono memorizzate a seguire. Abbiamo così la seguente tabella dei simboli organizzata per ambienti locali.

3 Tabella dei simboli Ambiente Globale (Livello 0): x intero 1 main funzione 3 pippo procedura 8 pluto funzione 12 Ambiente Locale di Main (Livello 1): x intero 4 Ambiente Locale di Pippo (Livello 1): a intero 3 parametro per riferimento b intero 4 Ambiente Locale di Pluto (Livello 1): a intero 4 parametro per valore Consideriamo, ora, la gestione della memoria relativa all esecuzione del programma. All inizio la pila è vuota: sia il puntatore al top della pila che quello all RdA attivo valgono 0. Si attiva il blocco relativo al programma principale che richiede 3 locazioni di memoria (PCD + variabile x + valore ritornato da main). La situazione in memoria è dunque la seguente: Loc. 1:? (x) Il puntatore al top della pila passa da 0 a 3. Si esegue adesso l istruzione in locazione 0 che fa x = 0. Siamo nell ambiente globale, la tabella dei simboli ci dice che a x è associata la locazione a offset 1. Quindi devo porre a 0 il valore contenuto nella locazione ottenuta sommando il valore 1 al valore del puntatore all RdA attivo. Quest ultimo è 0, quindi pongo a 0 il valore della locazione 1, ottenendo Passiamo all esecuzione dell istruzione alla locazione 1 che chiama main(). Dobbiamo attivare quindi un nuovo RdA. Servono 5 locazioni (PCD + PCS + Indirizzo di ritorno + Indirizzo del risultato + variabile x). Il valore di PCD viene ottenuto copiando il valore del puntatore all RdA attivo che vale 0. Poiché il blocco che chiama main è anche il blocco che definisce main anche il valore di PCS viene determinato alla stessa maniera. Siccome stiamo processando l istruzione alla locazione 1, l indirizzo di ritorno sarà quello dell istruzione successiva, quindi 2. Infine, l indirizzo del risultato è quello predisposto a offset 2 nell RdA attualmente

4 attivo. Il puntatore all RdA attivo vale sempre 0 e sommando 2 otteniamo 2 che sarà l indirizzo del risultato. Otteniamo: Loc. 7:? (x) A questo punto si può passare il controllo alla funzione main. La tabella dei simboli ci dice che ciò equivale a saltare all istruzione contenuta nella locazione 3. Prima, però, attiviamo il blocco appena creato: il puntatore all RdA attivo viene posto uguale al valore del puntatore al top della pila, cioè 3, mentre quest ultimo viene incrementato di 5 assumendo il valore 8. L esecuzione dell istruzione alla locazione 3 prevede x = 2. Siamo in main, la tabella dei simboli ci dice che esiste una x definita localmente che troviamo a offset 4. Sommando 4 al valore del puntatore all Rda attivo otteniamo 7 e quindi memorizziamo 2 nella locazione 7, ottenendo Loc. 7: 2 (x) Passiamo a eseguire l istruzione alla locazione 4 che chiama pippo(x), il ché comporta la creazione di un nuovo blocco. Occorrono 5 locazioni (PCD + PCS + Indirizzo di ritorno + parametro a + variabile b). Il PCD è uguale al valore del puntatore all RdA attivo, ovvero 3. Per il PCS, siccome chi chiama pippo non è il blocco che lo definisce, dobbiamo calcolare quanti livelli ci sono tra chi chiama pippo, cioè main, e chi lo definisce, cioè il programma principale. Attraverso la tabella dei simboli otteniamo 1, quindi otteniamo PCS risalendo una volta la catena statica. Il PCS del blocco attualmente attivo vale 0, quindi poniamo a 0 il PCS del blocco che stiamo creando. L indirizzo di ritorno è chiaramente 5. Infine dobbiamo passare x per riferimento: x si trova a offset 4 dell RdA attivo, ovvero alla locazione 7. Poniamo quindi il valore del parametro a di pippo uguale alla locazione di memoria di x, cioè 7. La situazione in memoria diventa la seguente:

5 Loc. 7: 2 (x) Loc. 12:? (b) Il controllo passa all istruzione in locazione 8 e si attiva il blocco ponendo il puntatore all RdA attivo a 8 e incrementando quello al top della pila da 8 a 13. L istruzione in questione fa a = x +3. La variabile x non è presente nell ambiente locale di pippo, ma lo è nell ambiente globale in cui pippo è annidata di un livello. Dobbiamo quindi risalire di una volta la catena statica e prendere il valore a offset 1, ovvero prendere il valore alla locazione 1 che è 0. Dobbiamo quindi fare a = 3 e siccome a è passata per riferimento, questo significa porre a 3 il valore della locazione contenuta alla locazione 11 (puntatore RdA attivo = 8 + offset di a = 3). Otteniamo Loc. 12:? (b) Si esegue ora l istruzione alla locazione 9 che comporta la chiamata di pluto(a). L RdA di pluto necessita di 5 locazioni (PCD + PCS + Indirizzo di ritorno + Indirizzo del risultato + parametro a). Il PCD è uguale al valore del puntatore all RdA attivo, ovvero 8. Per il PCS, siccome chi chiama pluto non è il blocco che lo definisce, dobbiamo calcolare quanti livelli ci sono tra chi chiama pluto, cioè pippo, e chi lo definisce, cioè il programma principale. Attraverso la tabella dei simboli otteniamo 1, quindi otteniamo PCS risalendo una volta la catena statica. Il PCS del

6 blocco attualmente attivo vale 0, quindi poniamo a 0 il PCS del blocco che stiamo creando. L indirizzo di ritorno è chiaramente 10. L indirizzo del risultato è 12, ottenuto aggiungendo l offset di b al valore del puntatore all RdA attivo. Infine dobbiamo passare a per valore: a si trova a offset 3 dell RdA attivo, ma siccome è, a sua volta, un parametro a cui si accede per riferimento, dobbiamo passare il contenuto della locazione 7, cioè 3. La situazione in memoria diventa la seguente: Loc. 12:? (b) Loc. 13: 8 (PCD) Loc. 14: 0 (PCS) Loc. 15: 10 (Ind. di ritorno) Loc. 16: 12 (Ind. del risultato) Loc. 17: 3 (a) Il puntatore all RdA attivo diventa 13, mentre quello al top della pila passa a 18 e il controllo passa all istruzione alla locazione 12. L esecuzione delle istruzioni dalla locazione 12 alla 14 pone a 6 il valore della locazione 17, ne stampa il valore e poi restituisce 36 che viene memorizzato nella locazione 12. Si ha così Loc. 12: 36 (b)

7 Loc. 13: 8 (PCD) Loc. 14: 0 (PCS) Loc. 15: 10 (Ind. di ritorno) Loc. 16: 12 (Ind. del risultato) Loc. 17: 6 (a) Con l istruzione alla locazione 15 si termina pluto, ovvero si pone il puntatore al top della pila uguale al valore di quello dell RdA attivo, cioè 13, mentre quest ultimo viene aggiornato con il valore del PCD, ovvero 8 e si passa il controllo all indirizzo di ritorno 10. Loc. 12: 36 (b) Con le istruzioni alle locazioni 10 e 11 si stampa b che vale 36 e quindi termina anche pippo. Si pone il puntatore al top della pila uguale al valore di quello dell RdA attivo, cioè 8, mentre quest ultimo viene aggiornato con il valore del PCD, ovvero 3 e si passa il controllo all indirizzo di ritorno 5. Si stampa 3, si restituisce 0 che viene memorizzato in locazione 2 e termina anche main. Si pone il puntatore al top della pila uguale al valore di quello dell RdA attivo, cioè 3, mentre quest ultimo viene aggiornato con il valore del PCD, ovvero 0 e si passa il controllo all indirizzo di ritorno 2.

8 Loc. 2: 0 (main()) Con l istruzione di fine programma anche l ultimo RdA viene cancellato e la pila si svuota.