Newsgroup: it.comp.lang.pascal
Titolo: Aiuto per Programma...

Ciao a tutti...
qualcuno di voi sarebbe in grado di fare questo programma?
Un programma che legge un file input.dat cosě composto:
+_<var>_<val1>_<val2>
-_<var>_<val1>_<val2>
*_<var>_<val1>_<val2>
/_<var>_<val1>_<val2>
p_<var>
=_<var>_<val1>
dove _ indica uno spazio e +.-,*,/, indicano operazioni matematiche e p
indica l'opzione di stampa su output della variabile.
Var indica le variabili che possono assumere lettere singole dell'alfabeto
minuscolo e val1 e val2 sono variabili che possono assumere o numeri real o
lettere minuscole dell'alfabeto.
Con = si vuole l'assegnamento alla variabile del valore di val1.
Man Mano che si va avanti nel file input.dat, le variabili vengono
aggiornate in base ai dati.
Il programma deve leggere le linee di questo file ed eseguire le azioni
corrispondenti (tutte le variabili valgono all'inizio zero). Si suppone che
il file input.dat sia privo di errori.
Esempio file input.dat:
+ x 3 5
= y 7
p x
- z x y
p z
+ z z z
p z
/ w x y
p w
/ w x k
- w w 1
p w
L'output sara':
8.00000000
1.00000000
2.00000000
1.142857
Divisione per zero
0.142857.
Se qualcuno di voi č in grado di aiutarmi... veramente... per me sarebbe
molto...
č da giorni che ci provo e riprovo e alla fine mi si č fusa la testa...
Grazie mille...

qualcuno di voi sarebbe in grado di fare questo programma?
Output ottenuto :
   8.00000
   1.00000
   2.00000
   1.14286
Divisione per zero
   0.14286
Con il seguente programma :
(************************)
(* INTERPRETE.PAS       *)
(* 27/11/1999           *)
(* compilato con TP 6.0 *)
(* -------------------- *)
(*  by Andrea Laforgia  *)
(************************)
program interprete( input, output ) ;
type tipo_token = ( ADDIZIONE,
                    SOTTRAZIONE,
                    MOLTIPLICAZIONE,
                    DIVISIONE,
                    ASSEGNAMENTO,
                    SCRITTURA,
                    IDENTIFICATORE,
                    COSTANTE,
                    FINE_STRINGA ) ;
     tipo_operazione = tipo_token ;
var tav_simboli : record
                    indice  : integer ;
                    simbolo : array [0..99] of record
                                                  varname : string ;
                                                  varval  : real ;
                                                end ;
                  end ;
    stringa_token   : string ;
    token           : string ;
    classe_token    : tipo_token ;
    operazione      : tipo_operazione ;
    id              : string ;
    operando1       : real ;
    operando2       : real ;
    err1            : integer ;
    err2            : integer ;
    procedure inizializza_tavola_simboli ;
    begin
      tav_simboli.indice := -1 ;
    end ;
    function in_tav_simboli( id : string ) : integer ;
    var i : integer ;
    begin
      for i := 0 to tav_simboli.indice do
        if ( tav_simboli.simbolo[i].varname = id ) then
        begin
          in_tav_simboli := i ;
          exit ;
        end ;
      in_tav_simboli := -1 ;
    end ;
    procedure aggiorna_simbolo( id : string ; v : real ) ;
    var p : integer ;
    begin
      p := in_tav_simboli( id ) ;
      if p = -1 then
      begin
        inc(tav_simboli.indice) ;
        with tav_simboli.simbolo[tav_simboli.indice] do
        begin
          varname := id ;
          varval  := v ;
        end ;
      end
      else
        tav_simboli.simbolo[p].varval := v ;
    end ;
    function valore_simbolo( id : string ) : real ;
    var p : integer ;
    begin
      p := in_tav_simboli( id ) ;
      if p > -1 then
         valore_simbolo := tav_simboli.simbolo[p].varval
      else
         valore_simbolo := 0.0 ;
    end ;
    function ottieni_token( var token : string ) : tipo_token ;
        function carattere( c : char ) : boolean ;
        begin
          carattere := c in ['a'..'z','A'..'Z'] ;
        end ;
        function cifra( c : char ) : boolean ;
        begin
          cifra := c in ['0'..'9'] ;
        end ;
    begin
      token := '' ;
      while ( stringa_token <> '' ) and
            ( stringa_token[1] = ' ' ) do
        delete( stringa_token, 1, 1) ;
      if stringa_token <> '' then
      begin
        case stringa_token[1] of
              '=' : begin
                      delete( stringa_token, 1, 1 ) ;
                      ottieni_token := ASSEGNAMENTO ;
                      exit ;
                    end ;
              'p',
              'P' : begin
                      delete( stringa_token, 1, 1 ) ;
                      ottieni_token := SCRITTURA ;
                      exit ;
                    end ;
              '+' : begin
                      delete( stringa_token, 1, 1 ) ;
                      ottieni_token := ADDIZIONE ;
                      exit ;
                    end ;
              '-' : begin
                      delete( stringa_token, 1, 1 ) ;
                      ottieni_token := SOTTRAZIONE ;
                      exit ;
                    end ;
              '*' : begin
                      delete( stringa_token, 1, 1 ) ;
                      ottieni_token := MOLTIPLICAZIONE ;
                      exit ;
                    end ;
              '/' : begin
                      delete( stringa_token, 1, 1 ) ;
                      ottieni_token := DIVISIONE ;
                      exit ;
                    end ;
           else
           if carattere( stringa_token[1] ) then
           begin
              while ( stringa_token <> '' )  and
                    ( carattere( stringa_token[1] ) ) do
              begin
                token := token + stringa_token[1] ;
                delete( stringa_token, 1, 1 ) ;
              end ;
              ottieni_token := IDENTIFICATORE ;
              exit ;
           end
           else
           if cifra( stringa_token[1] ) then
           begin
              while ( stringa_token <> '' )  and
                    ( cifra( stringa_token[1] ) ) do
              begin
                token := token + stringa_token[1] ;
                delete( stringa_token, 1, 1 ) ;
              end ;
              ottieni_token := COSTANTE ;
              exit ;
           end
        end { case }
      end
      else ottieni_token := FINE_STRINGA ;
    end ;
begin
  inizializza_tavola_simboli ;
  while not eof( input ) do
  begin
    readln( stringa_token ) ;
    classe_token := ottieni_token( token ) ;
    if classe_token in [ADDIZIONE, SOTTRAZIONE,
                        MOLTIPLICAZIONE, DIVISIONE]
    then
    begin
      operazione := classe_token ;
      classe_token := ottieni_token( token ) ;
      if classe_token = IDENTIFICATORE then
      begin
        id := token ;
        classe_token := ottieni_token( token ) ;
        if classe_token in [COSTANTE, IDENTIFICATORE] then
        begin
          case classe_token of
             IDENTIFICATORE : operando1 := valore_simbolo( token ) ;
             COSTANTE       : val( token, operando1, err1 ) ;
          end ;
          classe_token := ottieni_token( token ) ;
          if classe_token in [COSTANTE, IDENTIFICATORE] then
          begin
            case classe_token of
               IDENTIFICATORE : operando2 := valore_simbolo( token ) ;
               COSTANTE       : val( token, operando2, err2 ) ;
            end ;
            case operazione of
                 ADDIZIONE       : aggiorna_simbolo( id,
operando1+operando2 ) ;
                 SOTTRAZIONE     : aggiorna_simbolo( id,
operando1-operando2 ) ;
                 MOLTIPLICAZIONE : aggiorna_simbolo( id,
operando1*operando2 ) ;
                 DIVISIONE       : if operando2 = 0 then
                                      writeln( 'Divisione per zero' )
                                   else
                                   aggiorna_simbolo( id,
operando1/operando2 ) ;
            end ;
          end ;
        end ;
      end ;
    end
    else
    if classe_token = SCRITTURA then
    begin
      classe_token := ottieni_token( token ) ;
      if classe_token = IDENTIFICATORE then
        writeln( valore_simbolo( token ) :10:5 ) ;
    end
    else
    if classe_token = ASSEGNAMENTO then
    begin
      classe_token := ottieni_token( token ) ;
      if classe_token = IDENTIFICATORE then
      begin
        id := token ;
        classe_token := ottieni_token( token ) ;
        if classe_token = COSTANTE then
        begin
          val( token, operando1, err1 ) ;
          aggiorna_simbolo( id, operando1 ) ;
        end ;
      end ;
    end ;
 end ;
end.
--
Andrea Laforgia        (
andrea_...@bigfoot.com
)