Semaine 6 – Interprète d’un mini-langage (1)

(* évaluation d'expressions à valeur entières *)
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
;;
 
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)
;;
 
"(23 < ((10 / 3) + (8 * 2)))";;
let e = Inf (
            Ent 23,
            Plus (
                 Div (Ent 10, Ent 3), (* x en 0 *)
                 Mult (Ent 8, Ent 2)
              )
          );;
eval e;;
 
(* ajoutons des variables impératives *)
let etats = [|0; 0; 0; 0;|];; (* la mémoire *)
 
exception Segfault;;
 
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 *)
;;
 
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 < 4 &amp;&amp; n >= 0 -> etats.(n)
  | Var n -> raise Segfault
;;
 
"(23 > ((x / 3) + (8 * 2)))";;
let e = Sup (
            Ent 23,
            Plus (
                 Div (Var 0, Ent 3), (* x en 0 *)
                 Mult (Ent 8, Ent 2)
              )
          );;
eval e;;
 
(* maintenant on veut ajouter les instructions affectation, et *)
(* séquence (bloc) d'instructions. Comment faire ? (à suivre au TP 7) *)