(* synthèse du mini-interprète cours 6 et tp 7 *)
type expression = Ent of int
                | Plus of expression * expression
                | Mult of expression * expression
                | Div of expression * expression
                | Moins of expression * expression
                | Opp of expression
                | Egal of expression * expression
                | Sup of expression * expression
                | Inf of expression * expression
                | Var of int (* une variable impérative est une *)
                             (* adresse mémoire *)
;;
 
type instruction = Printstr of string
                 | Print of expression
                 | Block of instruction list
                 | Affectation of int * expression
                 | While of expression * instruction
;;
 
(* erreur mémoire *)
exception Segfault;;
 
(* tout est dans la fonction run *) 
let run p k =
  let etats = Array.make k 0
  in
  let rec eval = function
    | Ent n -> n
    | Plus (e1, e2) -> (eval e1) + (eval e2)
    | Mult (e1, e2) -> (eval e1) * (eval e2)
    | Div (e1, e2) -> (eval e1) / (eval e2)
    | Moins (e1, e2) -> (eval e1) - (eval e2)
    | Opp e1 -> (-1) * (eval e1)
    | Egal (e1, e2) -> (match (eval e1) = (eval e2) with true -> 1
                                                       | false -> 0)
    | Sup (e1, e2)  -> (match (eval e1) > (eval e2) with true -> 1
                                                       | false -> 0)
    | Inf (e1, e2)  -> (match (eval e1) < (eval e2) with true -> 1
                                                       | false -> 0)
    | Var n when n < k && n >= 0 -> etats.(n)
    | Var n -> raise Segfault in
  let rec exec = function
    | Printstr s -> print_string s
    | Print e -> print_int (eval e)
    | Block [] -> ()
    | Block (x::xs) -> exec x;
                       exec (Block xs)
    | Affectation (n, e) when n < k && n >= 0 -> etats.(n) <- (eval e)
    | Affectation (n, e) -> raise Segfault
    | While (e, i) as w -> (match (eval e) with
                            | 0 -> ()
                            | _ -> exec i; exec w)
  in
  exec p;
  etats (* <-- on veut savoir dans quel état le programme termine *)
;;
  
(* essai sur un petit programme *)
"x = 10;
 y = 0;
 println;
 while (x < 40) {
   print x;
   println;
   y = y + x;
   x = x + 10;
 }";;
let p = Block [
            Affectation (0, Ent 10);
            Affectation (1, Ent 0);
            Printstr "\n";
            While ( Inf (Var 0, Ent 40),
                    Block [
                        Print (Var 0);
                        Printstr "\n";
                        Affectation (1, Plus (Var 1, Var 0));
                        Affectation (0, Plus (Var 0, Ent 10))
                  ])
          ]
  and
    taille_memoire = 2
    in
    run p taille_memoire;;
  
(* question bonus : écrire une fonction qui prend en entrée un *)
(* programme (de type instruction) et détermine la taille mémoire *)
(* nécessaire pour l'exécuter sans SegFault *)