SVILUPPO PASSO A PASSO DEL MAIN

MAIN

main()
{
    /*leggere e memorizzare le costanti;
      leggere e memorizzare le definizioni di funzioni;
      leggere e valutare le espressioni;
    */
}

Programmiamo le letture delle varie parti dell'input e le loro elaborazioni seguendo la struttura sintattica del file di input.

leggere e memorizzare le costanti

MEMORIA Elabora_Costanti(void)
/*legge le definizioni costanti e ritorna la memoria che le contiene*/
{    MEMORIA m = Vuota;
     A_Capo_Lettura();  /*salta @const NL */
     while(Guarda_Car() != '@')  /*mentre c'e' una dichiarazione di costante*/
         m = Elabora_Costante(m);
     return m;
}

MEMORIA Elabora_Costante(MEMORIA m)
/*legge una definizione di costante e ritorna la memoria m estesa con tale costante*/
{
     IDENT id;
     REALE_ENORME re;
     
     Salta_Spazi(); 
     id = Leggi_Ident();
     Salta('=');
     Salta_Spazi(); 
     re = Leggi_Reale_Enorme();
     A_Capo_Lettura();
     return Registra(id,re,m);
}

leggere e memorizzare le definizioni di funzioni

void Elabora_Funzioni(void)
/*legge e memorizza le definizioni di funzioni*/
{
     A_Capo_Lettura(); /*salta @funz NL */
     while(Guarda_Car() != '@')   /*mentre c'e' una dichiarazione di funzione*/
         Elabora_Funzione();
}

void Elabora_Funzione(void)
/*legge e memorizza una definizione di funzione*/
{
     IDENT funz, par_for;
     ESPRESSIONE corpo;
     
     Salta_Spazi(); 
     funz = Leggi_Ident();
     Salta('(');
     Salta_Spazi(); 
     par_for = Leggi_Ident();
     Salta(')');
     Salta('=');
     Salta_Spazi(); 
     corpo = Leggi_Espressione();
     A_Capo_Lettura();
     Memorizza_Funzione(funz,par_for,corpo);
}

leggere e valutare le espressioni

void Elabora_Espressioni(MEMORIA Costanti)
/*legge e valuta le espressioni utilizzando i valori delle costanti contenute in Costanti*/
{
     A_Capo_Lettura(); /*salta @valuta NL */
     while(Guarda_Car() != '@')   /*mentre c'e' un'espressione*/
         Elabora_Espressione(MEMORIA Costanti);
}

void Elabora_Espressione(MEMORIA Costanti)
/*legge e valuta una espressione utilizzando i valori delle costanti contenute in Costanti*/
{
     REALE_ENORME re;
     ESPRESSIONE esp;
     
     esp = Leggi_Espressione();
     A_Capo_Lettura();
     re = Valuta(esp, Costanti);
     Stampa_Reale_Enorme(re);
     A_Capo_Stampa();
}

valutare un'espressione in una data memoria

questa funzione viene sviluppata per induzione sulla struttura delle espressioni
(tecnicamente è una funzione ricorsiva).

REALE_ENORME Valuta(ESPRESSIONE esp, MEMORIA m)
/*valuta l'espressione esp utilizzando la memoria m*/
{   
    if(E_Valore(esp))
        return Valore(esp);
    else if(E_Identificatore(esp))/*una costante o il parametro di una funzione*/
        return Valore_Di(Ident(esp),m);
    else if(E_Applicazione(esp)){
        REALE_ENORME re1 = Valuta(Primo_Arg(esp),m);
        REALE_ENORME re2 = Valuta(Secondo_Arg(esp),m);
        return Applica(Operatore(esp),re1,re2); }
    else if(E_Chiamata_Funzione(esp)){
        REALE_ENORME re = Valuta(Parametro_Attuale(esp),m);
        return Valuta(Recupera_Corpo(Funzione(esp)),
                      Registra(Parametro_Formale(Funzione(esp)),re,m)); }
}

REALE_ENORME Applica(char oper, REALE_ENORME re1, REALE_ENORME re2)
/*applica l'operatore oper ad re1 e re2*/
{
    if(oper == '+') 
        return Somma(re1,re2);
    else if(oper == '-')
        return Differenza(re1,re2);
    else if(oper == '*')
            return Prodotto(re1,re2);
    else printf("Errore: %c non puo\' essere un operatore\n",oper);
    }