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;
    */
}

leggere e memorizzare le costanti

void Elabora_Costanti(MEMORIA * m)
/*legge e memorizza le costanti*/
{    A_Capo_Lettura();  /*salta @const NL */
     while(Look_Char() != '@')
         Elabora_Costante(m);
}

void Elabora_Costante(MEMORIA *m)
{
     IDENT id;
     REALE_ENORME re;
     
     Salta_Blanks(); 
     id = Leggi_Ident();
     Salta('=');
     Salta_Blanks(); 
     re = Leggi_Reale_Enorme();
     A_Capo_Lettura();
     * m = Modifica(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(Look_Char() != '@')
         Elabora_Funzione();
}

void Elabora_Funzione(void)
{
     IDENT funz, par_for;
     ESPRESSIONE corpo;
     
     Salta_Blanks(); 
     funz = Leggi_Ident();
     Salta('(');
     Salta_Blanks(); 
     par_for = Leggi_Ident();
     Salta(')');
     Salta('=');
     Salta_Blanks(); 
     corpo = Leggi_Espressione();
     A_Capo_Lettura();
     Aggiungi_Funzione(funz,par_for,corpo);
}

leggere e valutare le espressioni

void Elabora_Espressioni(void)
/*legge e valuta le espressioni*/
{
     A_Capo_Lettura(); /*salta @valuta NL */
     while(Look_Char() != '@')
         Elabora_Espressione();
}

void Elabora_Espressione(void)
{
     REALE_ENORME re;
     ESPRESSIONE esp;
     
     esp = Leggi_Espressione();
     A_Capo_Lettura();
     re = Valuta(esp, Valori_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(Corpo(Funzione(esp)),
                      Modifica(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);
    }