/*********************************************************
  Calcolatrice in notazione postfissa
  (versione 1, 2005)

  Accetta l'input su una o piu' righe terminato dal 
  carattere di EOF
      
  L'espressione, sotto forma di token viene fornita 
  da un analizzatore lessicale.
      
  La calcolatrice e' basata sull'esempio fornito nel 
  capitolo 11 del testo:
  G. Pighizzini, M. Ferrari, "Dai fondamenti agli oggetti:
  corso di Programmazione JAVA" (seconda edizione), 
  Addison Wesley, 2005.
       
**********************************************************/ 

import java.util.Stack;
import java.util.EmptyStackException;

class Postfissa {
   
  public static void main(String[] args) {

    //crea la pila
    Stack<Integer> pila = new Stack<Integer>();
      
    System.out.println("Inserire l'espressione da esaminare (eof per terminare)");

    //crea l'analizzatore lessicale
    AnalizzatoreLessicale lex = new AnalizzatoreLessicale(System.in);
    
    try {

      //preleva il primo token
      Token t = lex.getProssimo();

      while (t != null) {

        //elaborazione della token letto
        Integer sx, dx, risultato;
        switch (t.getTipo()) {
          case PIU:
          case MENO:
          case PER:
          case DIVISO:
            dx = pila.pop();
            sx = pila.pop();
            risultato = calcola(sx, dx, t.getTipo());
            pila.push(risultato);
            break;
          case NUMERO:
            Integer numero = (Integer) t.getValore();
            pila.push(numero);
            break;
          default:
            throw new EspressioneException("Carattere inaspettato: " +
					    t.getValore());
        }

        //lettura di un altro token
        t = lex.getProssimo();
      }

      //preleva il risultato dalla pila e lo comunica        
      Integer risultato = pila.pop();
      if (pila.empty())
        System.out.println("Il risultato e' " + risultato);
      else
        System.err.println("L'espressione contiene troppi operandi");
      //fine blocco try
    } catch (ArithmeticException e) {
      System.err.println("Errore: divisione per zero");
    } catch (EspressioneException e) {
      System.err.println(e.toString());
    } catch (EmptyStackException e) {
      System.err.println("L'espressione contiene un numero insufficiente di operandi");
    } catch (java.io.IOException e) {
      System.err.println("Errore di lettura dati");
    }
  }

  private static int calcola(int opSx, int opDx, TipoToken segno) {
    int ris = 0;
    switch (segno) {
      case PIU:
        ris = opSx + opDx;
        break;
      case MENO:
        ris = opSx - opDx;
        break;
      case PER:
        ris = opSx * opDx;
        break;
      case DIVISO:
        ris = opSx / opDx;
        break;
    }
    return ris;
  }

}



class EspressioneException extends RuntimeException {
  public EspressioneException() {
  }
  
  public EspressioneException(String s) {
     super(s);
  }
}