type token =
  | T_LET
  | T_EQ
  | T_IN
  | T_AND
  | T_LESS
  | T_ADD
  | T_SUB
  | T_MUL
  | T_DIV
  | T_NOT
  | T_IF
  | T_THEN
  | T_ELSE
  | T_FI
  | T_TRUE
  | T_FALSE
  | T_VALUE
  | T_LAZYDYN
  | T_LAZYSTAT
  | T_OUTPUT
  | T_INPUT
  | T_RANDOM
  | INT of (string)
  | IDENT of (string * int)
  | LPAR
  | RPAR
  | COMMA
  | SEMICOLON
  | DOUBLESEMICOLON
  | COLON

open Parsing;;
# 2 "parservhc.mly"
(* parservhc.mly, Objective Caml version 3.08.1 *)
(* syntaxe avec verification des conditions de contexte,
   methode de la table des symboles *)

open Print
open Aintv
open Parse_exceptions

type 'a chose = Rien | Chose of 'a
type typage_determine = Entier | Booleen
type typage = Determine of typage_determine | Indetermine of boite_typage and boite_typage = typage chose ref
let entier = ref (Chose (Determine Entier))
and booleen = ref (Chose (Determine Booleen))
and indetermine () = ref Rien

type appel = {a_f : string; a_type_vars : boite_typage list ; a_type_retour : boite_typage; a_pos : int}
type contexte = Variable of (string * boite_typage * int) | Appel of appel

type expr2 = {expr : expr; e_ctxt : contexte list; e_type : boite_typage}
type liste_args = {exprlist : expr2 list; l_ctxt : contexte list}
type elem_aff = {fundef : function_declaration; pos : int; f_type_vars : boite_typage list; f_type_retour : boite_typage; appels : appel list}
type affs = {elem_affs : elem_aff list; aretes : (string * string) list}

let rec reduire_typage t = match !t with
  | Rien -> t,Rien
  | Chose (Determine t1) -> t,Chose t1
  | Chose (Indetermine t1) -> reduire_typage t1

let verifier_typage t0 t = let (b0,u0),(b,u) = reduire_typage t0, reduire_typage t in 
 match u0,u with
   | Rien, Rien when b0 == b -> ()
   | Rien, Rien -> ( b := Chose (Indetermine b0)) (* tres important de mettre b a gauche et non pas b0 *)
   | Chose t1, Rien -> (b := Chose (Determine t1) )
   | Rien, Chose t1 -> (  b0 := Chose (Determine t1) )
   | Chose t1, Chose t2 when t2 <> t1 -> raise Type_mismatch
   | _ -> ()

let rec type_param p = function
  | [] -> Rien
  | ((FPVAL v), t) :: _ when v = p -> Chose t
  | ((FPNECDYN v), t) :: _ when v = p -> Chose t
  | ((FPNECSTAT v), t) :: _ when v = p -> Chose t
  | _ :: q -> type_param p q

let filtrer_contexte_local vars liste =
let rec aux accu = function
| [] -> accu
| (Appel a) :: q -> aux (a :: accu) q
| (Variable (v, t, pos)) :: q ->
( match type_param v vars with
   | Chose t2 -> (verifier_typage t t2; aux accu q)
   | Rien -> raise (Undefined_variable (v, pos))
)
in aux [] liste

let rec verifier_contexte_global foncts = function
| [] -> ()
| (Variable (s, _, i)) :: _ -> raise (Variable_in_body (s,i))
| (Appel {a_f = f; a_type_vars = l; a_type_retour = t; a_pos = pos}) :: q ->
begin
 let rec mem2 = function
 | [] -> raise (Undefined_function (f, pos))
 | g::_ when f = fst g.fundef ->
     begin
       let l0 = List.map reduire_typage g.f_type_vars and b0,t0 = reduire_typage g.f_type_retour in
       let rec aux = function
         | [],[] -> ()
         | (a,_)::q, b::r -> (verifier_typage a b; aux (q,r))
         | _ -> raise (Function_call_mismatch(f, pos))
       in aux (l0, l);
       verifier_typage b0 t;

       if t0 = Rien then b0 := Rien else ();
       let rec aux2 = function
         | [] -> ()
         | (b, Rien) :: q -> (b := Rien; aux2 q)
         | _ :: q -> aux2 q
       in aux2 l0
     end
 | _::r -> mem2 r
 in mem2 foncts; verifier_contexte_global foncts q
end

let afficher_contexte _ = () (* List.iter (function
| Variable v -> print_string ("Variable " ^ v ^ "\n")
| Appel (f, n) -> print_string ("Appel " ^ f ^ ", "  ^ string_of_int n ^ " arg\n")
) *)

let rec retirer_doublons = function
  |  [] -> []
  | a::q -> let rec aux = function
      | [] -> []
      | b::r when b == a || b = a -> aux r
      | b::r -> b::(aux r)
    in aux q

let ordre_typage foncts aretes = 
  let n = (List.length foncts) in
  let noms = if n = 0 then [| |] else Array.create n (List.hd foncts) in
  let l_numeros = ref [] in
  let rec remplir_numeros i = function
    | [] -> ()
    | nom :: q -> (l_numeros := (nom, i) :: !l_numeros; noms.(i) <- nom ; remplir_numeros (i + 1) q)
  in remplir_numeros 0 foncts;
  let numeros x =  List.assoc x !l_numeros in (* egalite logique *)
  let matrice = Array.create_matrix n n false in
  let cocher_arete (f,g) = matrice.(numeros f).(numeros g) <- true
  in List.iter cocher_arete aretes (* retirer_doublons aretes *);
  for x = 0 to n-1
  do
   for x1 = 0 to n-1
   do
    if matrice.(x1).(x)
    then for x2 = 0 to n-1
    do
     if matrice.(x).(x2)
     then matrice.(x1).(x2) <- true
    done
   done
  done;
  let visites = Array.create n false and composantes = ref [] in
  for x = 0 to n - 1
  do
   if not visites.(x) then
   let comp = ref [x] in begin
    for y = x + 1 to n - 1
    do
     if matrice.(x).(y) && matrice.(y).(x) then
       begin
        visites.(y) <- true;
        comp := y :: !comp
       end
    done;
    composantes := !comp :: !composantes;
   end
  done;
  let ordre comp1 comp2 = if comp1 = comp2 then 0 else if matrice.(List.hd comp1).(List.hd comp2) then 1 else -1 
  in let compo_triees = List.sort ordre !composantes in
  List.map (List.map (fun i -> noms.(i))) compo_triees (*
  let rec final accu = function
    | [] -> accu 
    | ([]::r) -> final accu r 
    | ((a::q)::r) -> final ((noms.(a))::accu) (q::r) 
  in  final [] compo_triees *)


(* with e -> (print_string "Exception dans ordre_typage" ; raise e) *)
(*
let completer_ordre foncts =
  let rechercher_fonction f = 
    let rec aux = function
      | [] -> failwith "completer_ordre cas impossible"
      | g::_ when fst g.fundef = f -> g
      | _::q -> aux q
    in aux foncts
  in List.map rechercher_fonction 
*)
let rec iter2 f g = function
  | [] -> ()
  | [a] -> ignore (f a)
  | a::q -> (ignore (f a) ; ignore (g ()) ; iter2 f g q)

let afficher_nom_type = 
  let types_indet = ref [] and compte_types_indet = ref 0 in
  let type_indet ty = try List.assq ty !types_indet with _ -> (incr compte_types_indet; types_indet := (ty, !compte_types_indet) :: !types_indet ; !compte_types_indet)
  in fun ty ->
    let b,u = reduire_typage ty in
    match u with
      | Rien -> print_string ("Indet" ^ string_of_int (type_indet b))
      | Chose Entier -> print_string "Entier"
      | Chose Booleen -> print_string "Booleen"

let afficher_typages = List.iter (fun f -> (print_string (fst f.fundef) ; print_string " ( " ; iter2 afficher_nom_type (fun () -> print_string ",") f.f_type_vars ; print_string " ) = "; afficher_nom_type f.f_type_retour ; print_newline ()))

let verifier_appels f2 f = 
  let verif a = if List.mem a.a_f f2 then () else raise (Undefined_function(a.a_f, a.a_pos)) in List.iter verif f.appels

let retyper_fonctions foncts aretes = (* print_string "Retypage."; *)
  let f2 = List.map (fun f -> fst f.fundef) foncts in

  List.iter (verifier_appels f2) foncts;

  let ordre2 = ordre_typage f2 aretes in
(*  let ordre = completer_ordre foncts ordre2 in *)
  let rec aux_compo compo =
  print_string "\nTypage de la composante connexe : ";
  let rec aux_foncts = function
    | [] -> ()
    | f2::q ->
        begin
          print_string f2; flush stdout;
          let rec fonction g = function
            | [] -> failwith "retyper_fonctions : cas impossible"
            | h::_ when fst h.fundef = g -> h
            | _::r -> fonction g r
          in let f = fonction f2 foncts  in
          let rec aux_appels = function
            | [] -> ()
            | ({a_f = gn; a_pos = pos} as a) :: r when not (List.mem gn compo) ->
                begin

                  let g = fonction gn foncts in
       let l0 = List.map reduire_typage g.f_type_vars and b0,t0 = reduire_typage g.f_type_retour and l = a.a_type_vars and t = a.a_type_retour in
       let duplique = List.map ( function b,Chose t -> b,ref (Chose(Determine t)) | b,Rien -> b, indetermine () ) l0 in
       let b1 = match t0 with
         | Rien -> (try (List.assq b0 duplique) with _ -> indetermine ())
         | Chose t -> ref (Chose (Determine t))
       in
       let l1 = List.map (function b,t -> List.assq b duplique, t) l0 in
       let rec aux = function
         | [],[] -> ()
         | (a,_)::q, b::r -> (verifier_typage a b; aux (q,r))
         | _ -> raise (Function_call_mismatch(f2, pos))
       in aux (l1, l);

       verifier_typage b1 t;

       if t0 = Rien then b0 := Rien else ();
       let rec aux2 = function
         | [] -> ()
         | (b, Rien) :: q -> (b := Rien; aux2 q)
         | _ :: q -> aux2 q
       in aux2 l0

                end

            | ({a_f = gn; a_pos = pos} as a) :: r -> let g = fonction gn foncts in
              begin 
                let rec aux_types = function
                  | [],[] -> ()
                  | t1::r1, t2::r2 -> (verifier_typage t1 t2 ; aux_types (r1,r2))
                  | _ -> raise (Function_call_mismatch (gn, pos))
                in
                (* print_string " Appel "; print_string a.a_f; print_string "("; iter2 afficher_nom_type (fun _ -> print_string " , ") a.a_type_vars ; print_string " ) = ";afficher_nom_type (a.a_type_retour); flush stdout; *) aux_types (g.f_type_vars, a.a_type_vars); verifier_typage g.f_type_retour a.a_type_retour; aux_appels r
              end 
          in (*print_int (List.length f.appels);*) aux_appels f.appels; aux_foncts q
        end
  in aux_foncts compo
  in List.iter aux_compo ordre2

# 276 "parservhc.ml"
let yytransl_const = [|
  257 (* T_LET *);
  258 (* T_EQ *);
  259 (* T_IN *);
  260 (* T_AND *);
  261 (* T_LESS *);
  262 (* T_ADD *);
  263 (* T_SUB *);
  264 (* T_MUL *);
  265 (* T_DIV *);
  266 (* T_NOT *);
  267 (* T_IF *);
  268 (* T_THEN *);
  269 (* T_ELSE *);
  270 (* T_FI *);
  271 (* T_TRUE *);
  272 (* T_FALSE *);
  273 (* T_VALUE *);
  274 (* T_LAZYDYN *);
  275 (* T_LAZYSTAT *);
  276 (* T_OUTPUT *);
  277 (* T_INPUT *);
  278 (* T_RANDOM *);
  281 (* LPAR *);
  282 (* RPAR *);
  283 (* COMMA *);
  284 (* SEMICOLON *);
  285 (* DOUBLESEMICOLON *);
  286 (* COLON *);
    0|]

let yytransl_block = [|
  279 (* INT *);
  280 (* IDENT *);
    0|]

let yylhs = "\255\255\
\001\000\002\000\002\000\003\000\015\000\015\000\016\000\016\000\
\004\000\004\000\005\000\005\000\005\000\006\000\006\000\006\000\
\007\000\007\000\007\000\008\000\009\000\009\000\009\000\009\000\
\009\000\009\000\009\000\009\000\009\000\009\000\009\000\009\000\
\009\000\009\000\010\000\010\000\011\000\011\000\011\000\012\000\
\012\000\013\000\013\000\014\000\014\000\014\000\014\000\000\000"

let yylen = "\002\000\
\002\000\001\000\004\000\001\000\001\000\003\000\002\000\001\000\
\003\000\001\000\003\000\003\000\001\000\003\000\003\000\001\000\
\003\000\003\000\001\000\001\000\003\000\001\000\002\000\001\000\
\001\000\001\000\003\000\004\000\004\000\007\000\001\000\003\000\
\004\000\004\000\001\000\003\000\001\000\002\000\003\000\005\000\
\006\000\001\000\003\000\001\000\002\000\002\000\002\000\002\000"

let yydefred = "\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000\024\000\025\000\
\000\000\000\000\000\000\022\000\000\000\000\000\048\000\000\000\
\002\000\000\000\000\000\000\000\000\000\019\000\020\000\004\000\
\000\000\000\000\000\000\000\000\023\000\000\000\000\000\000\000\
\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\000\000\000\000\000\000\032\000\000\000\027\000\000\000\000\000\
\021\000\000\000\000\000\000\000\000\000\000\000\017\000\018\000\
\006\000\000\000\000\000\000\000\044\000\000\000\000\000\000\000\
\003\000\039\000\029\000\000\000\033\000\034\000\000\000\028\000\
\045\000\047\000\046\000\000\000\000\000\000\000\000\000\036\000\
\040\000\000\000\043\000\000\000\041\000\030\000"

let yydgoto = "\002\000\
\015\000\016\000\055\000\018\000\019\000\020\000\021\000\022\000\
\023\000\056\000\027\000\028\000\071\000\072\000\024\000\025\000"

let yysindex = "\005\000\
\026\000\000\000\241\254\007\255\011\255\065\000\000\000\000\000\
\018\255\022\255\023\255\000\000\033\255\065\000\000\000\003\255\
\000\000\055\255\002\255\005\255\014\255\000\000\000\000\000\000\
\036\255\042\255\034\255\040\255\000\000\065\000\057\255\065\000\
\045\255\065\000\045\000\047\255\000\000\065\000\065\000\065\000\
\065\000\065\000\065\000\065\000\065\000\240\254\065\000\241\254\
\053\255\065\000\054\255\000\000\056\255\000\000\058\255\062\255\
\000\000\002\255\005\255\005\255\014\255\014\255\000\000\000\000\
\000\000\060\255\075\255\079\255\000\000\070\255\078\255\080\255\
\000\000\000\000\000\000\068\255\000\000\000\000\065\000\000\000\
\000\000\000\000\000\000\065\000\103\255\046\255\065\000\000\000\
\000\000\065\000\000\000\092\255\000\000\000\000"

let yyrindex = "\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\000\000\012\255\000\000\000\000\048\255\000\000\000\000\000\000\
\000\000\247\255\214\255\152\255\088\255\000\000\000\000\000\000\
\084\255\000\000\000\000\105\255\000\000\000\000\000\000\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\000\000\000\000\000\000\000\000\252\255\000\000\000\000\106\255\
\000\000\000\000\000\000\000\000\000\000\000\000\099\255\000\000\
\000\000\219\255\181\255\186\255\117\255\146\255\000\000\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000\000\000\100\255\
\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000"

let yygindex = "\000\000\
\000\000\000\000\255\255\000\000\089\000\244\255\249\255\001\000\
\000\000\049\000\084\000\000\000\047\000\000\000\090\000\000\000"

let yytablesize = 346
let yytable = "\017\000\
\066\000\067\000\068\000\039\000\031\000\001\000\040\000\069\000\
\026\000\070\000\041\000\042\000\036\000\031\000\031\000\031\000\
\031\000\031\000\031\000\031\000\031\000\043\000\044\000\031\000\
\031\000\031\000\059\000\060\000\049\000\029\000\051\000\037\000\
\053\000\061\000\062\000\030\000\047\000\031\000\031\000\031\000\
\031\000\031\000\032\000\063\000\064\000\073\000\033\000\034\000\
\076\000\026\000\026\000\026\000\026\000\026\000\026\000\026\000\
\026\000\035\000\038\000\026\000\026\000\026\000\066\000\067\000\
\068\000\045\000\046\000\048\000\050\000\069\000\052\000\084\000\
\057\000\026\000\026\000\026\000\026\000\026\000\075\000\077\000\
\087\000\078\000\089\000\081\000\079\000\092\000\005\000\080\000\
\093\000\016\000\016\000\016\000\016\000\016\000\016\000\005\000\
\005\000\005\000\082\000\016\000\016\000\016\000\083\000\085\000\
\090\000\094\000\086\000\037\000\038\000\005\000\005\000\005\000\
\005\000\016\000\016\000\016\000\016\000\016\000\014\000\014\000\
\014\000\014\000\014\000\014\000\035\000\042\000\058\000\088\000\
\014\000\014\000\014\000\074\000\091\000\000\000\065\000\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000\014\000\014\000\
\014\000\014\000\014\000\015\000\015\000\015\000\015\000\015\000\
\015\000\013\000\013\000\013\000\013\000\015\000\015\000\015\000\
\000\000\000\000\000\000\013\000\013\000\013\000\000\000\000\000\
\000\000\000\000\000\000\015\000\015\000\015\000\015\000\015\000\
\000\000\013\000\013\000\013\000\013\000\013\000\012\000\012\000\
\012\000\012\000\000\000\011\000\011\000\011\000\011\000\000\000\
\012\000\012\000\012\000\000\000\000\000\011\000\011\000\011\000\
\000\000\000\000\000\000\000\000\000\000\000\000\012\000\012\000\
\012\000\012\000\012\000\011\000\011\000\011\000\011\000\011\000\
\010\000\010\000\000\000\000\000\000\000\009\000\009\000\000\000\
\000\000\010\000\010\000\010\000\000\000\000\000\009\000\009\000\
\009\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\
\010\000\010\000\010\000\010\000\009\000\009\000\009\000\009\000\
\009\000\008\000\000\000\000\000\000\000\000\000\007\000\000\000\
\000\000\000\000\008\000\008\000\008\000\000\000\000\000\007\000\
\007\000\007\000\000\000\000\000\000\000\000\000\000\000\000\000\
\008\000\008\000\008\000\008\000\008\000\007\000\007\000\007\000\
\007\000\007\000\003\000\000\000\000\000\000\000\000\000\000\000\
\004\000\000\000\000\000\005\000\006\000\000\000\000\000\000\000\
\007\000\008\000\000\000\000\000\000\000\009\000\010\000\011\000\
\012\000\013\000\014\000\004\000\000\000\000\000\005\000\006\000\
\000\000\000\000\000\000\007\000\008\000\000\000\000\000\000\000\
\009\000\010\000\011\000\012\000\013\000\014\000\054\000\004\000\
\000\000\000\000\005\000\006\000\000\000\000\000\000\000\007\000\
\008\000\000\000\000\000\000\000\009\000\010\000\011\000\012\000\
\013\000\014\000"

let yycheck = "\001\000\
\017\001\018\001\019\001\002\001\006\000\001\000\005\001\024\001\
\024\001\026\001\006\001\007\001\014\000\002\001\003\001\004\001\
\005\001\006\001\007\001\008\001\009\001\008\001\009\001\012\001\
\013\001\014\001\039\000\040\000\030\000\023\001\032\000\029\001\
\034\000\041\000\042\000\025\001\003\001\026\001\027\001\028\001\
\029\001\030\001\025\001\043\000\044\000\047\000\025\001\025\001\
\050\000\002\001\003\001\004\001\005\001\006\001\007\001\008\001\
\009\001\025\001\004\001\012\001\013\001\014\001\017\001\018\001\
\019\001\030\001\025\001\028\001\012\001\024\001\026\001\002\001\
\026\001\026\001\027\001\028\001\029\001\030\001\026\001\026\001\
\013\001\026\001\084\000\024\001\027\001\087\000\003\001\026\001\
\090\000\002\001\003\001\004\001\005\001\006\001\007\001\012\001\
\013\001\014\001\024\001\012\001\013\001\014\001\024\001\026\001\
\002\001\014\001\027\001\003\001\003\001\026\001\027\001\028\001\
\029\001\026\001\027\001\028\001\029\001\030\001\002\001\003\001\
\004\001\005\001\006\001\007\001\026\001\026\001\038\000\079\000\
\012\001\013\001\014\001\048\000\086\000\255\255\045\000\255\255\
\255\255\255\255\255\255\255\255\255\255\255\255\026\001\027\001\
\028\001\029\001\030\001\002\001\003\001\004\001\005\001\006\001\
\007\001\002\001\003\001\004\001\005\001\012\001\013\001\014\001\
\255\255\255\255\255\255\012\001\013\001\014\001\255\255\255\255\
\255\255\255\255\255\255\026\001\027\001\028\001\029\001\030\001\
\255\255\026\001\027\001\028\001\029\001\030\001\002\001\003\001\
\004\001\005\001\255\255\002\001\003\001\004\001\005\001\255\255\
\012\001\013\001\014\001\255\255\255\255\012\001\013\001\014\001\
\255\255\255\255\255\255\255\255\255\255\255\255\026\001\027\001\
\028\001\029\001\030\001\026\001\027\001\028\001\029\001\030\001\
\003\001\004\001\255\255\255\255\255\255\003\001\004\001\255\255\
\255\255\012\001\013\001\014\001\255\255\255\255\012\001\013\001\
\014\001\255\255\255\255\255\255\255\255\255\255\255\255\026\001\
\027\001\028\001\029\001\030\001\026\001\027\001\028\001\029\001\
\030\001\003\001\255\255\255\255\255\255\255\255\003\001\255\255\
\255\255\255\255\012\001\013\001\014\001\255\255\255\255\012\001\
\013\001\014\001\255\255\255\255\255\255\255\255\255\255\255\255\
\026\001\027\001\028\001\029\001\030\001\026\001\027\001\028\001\
\029\001\030\001\001\001\255\255\255\255\255\255\255\255\255\255\
\007\001\255\255\255\255\010\001\011\001\255\255\255\255\255\255\
\015\001\016\001\255\255\255\255\255\255\020\001\021\001\022\001\
\023\001\024\001\025\001\007\001\255\255\255\255\010\001\011\001\
\255\255\255\255\255\255\015\001\016\001\255\255\255\255\255\255\
\020\001\021\001\022\001\023\001\024\001\025\001\026\001\007\001\
\255\255\255\255\010\001\011\001\255\255\255\255\255\255\015\001\
\016\001\255\255\255\255\255\255\020\001\021\001\022\001\023\001\
\024\001\025\001"

let yynames_const = "\
  T_LET\000\
  T_EQ\000\
  T_IN\000\
  T_AND\000\
  T_LESS\000\
  T_ADD\000\
  T_SUB\000\
  T_MUL\000\
  T_DIV\000\
  T_NOT\000\
  T_IF\000\
  T_THEN\000\
  T_ELSE\000\
  T_FI\000\
  T_TRUE\000\
  T_FALSE\000\
  T_VALUE\000\
  T_LAZYDYN\000\
  T_LAZYSTAT\000\
  T_OUTPUT\000\
  T_INPUT\000\
  T_RANDOM\000\
  LPAR\000\
  RPAR\000\
  COMMA\000\
  SEMICOLON\000\
  DOUBLESEMICOLON\000\
  COLON\000\
  "

let yynames_block = "\
  INT\000\
  IDENT\000\
  "

let yyact = [|
  (fun _ -> failwith "parser")
; (fun parser_env ->
    let _1 = (peek_val parser_env 1 : Aintv.prog) in
    Obj.repr(
# 268 "parservhc.mly"
                                    ( _1 )
# 515 "parservhc.ml"
               : Aintv.prog))
; (fun parser_env ->
    let _1 = (peek_val parser_env 0 : expr2) in
    Obj.repr(
# 272 "parservhc.mly"
        ( [] , (verifier_contexte_global [] _1.e_ctxt; _1.expr) )
# 522 "parservhc.ml"
               : Aintv.prog))
; (fun parser_env ->
    let _2 = (peek_val parser_env 2 : affs) in
    let _4 = (peek_val parser_env 0 : expr2) in
    Obj.repr(
# 273 "parservhc.mly"
                                ( 
            let (expr, vars1)= _4.expr, _4.e_ctxt  and foncts = _2.elem_affs and aretes = _2.aretes in let vars = vars1 in  
retyper_fonctions foncts aretes;verifier_contexte_global foncts vars; print_newline ();
  print_string "Types des fonctions : \n"; afficher_typages foncts; (List.map (fun e -> e.fundef) foncts, expr))
# 533 "parservhc.ml"
               : Aintv.prog))
; (fun parser_env ->
    let _1 = (peek_val parser_env 0 : 'expr_0) in
    Obj.repr(
# 280 "parservhc.mly"
                 ( _1 )
# 540 "parservhc.ml"
               : expr2))
; (fun parser_env ->
    let _1 = (peek_val parser_env 0 : 'expr_01) in
    Obj.repr(
# 284 "parservhc.mly"
                  ( _1 )
# 547 "parservhc.ml"
               : 'expr_0))
; (fun parser_env ->
    let _1 = (peek_val parser_env 2 : 'expr_01) in
    let _3 = (peek_val parser_env 0 : 'expr_0) in
    Obj.repr(
# 285 "parservhc.mly"
                                 ( { expr = EXPRSEQ (_1.expr, _3.expr); e_ctxt = _1.e_ctxt @ _3.e_ctxt ; e_type = _3.e_type } )
# 555 "parservhc.ml"
               : 'expr_0))
; (fun parser_env ->
    let _1 = (peek_val parser_env 1 : 'expr_01) in
    Obj.repr(
# 289 "parservhc.mly"
                          ( _1 )
# 562 "parservhc.ml"
               : 'expr_01))
; (fun parser_env ->
    let _1 = (peek_val parser_env 0 : expr2) in
    Obj.repr(
# 290 "parservhc.mly"
                   ( _1 )
# 569 "parservhc.ml"
               : 'expr_01))
; (fun parser_env ->
    let _1 = (peek_val parser_env 2 : expr2) in
    let _3 = (peek_val parser_env 0 : expr2) in
    Obj.repr(
# 294 "parservhc.mly"
                              ( verifier_typage booleen _1.e_type; verifier_typage booleen _3.e_type; {expr = AND (_1.expr, _3.expr); e_ctxt = _1.e_ctxt @ _3.e_ctxt; e_type = booleen} )
# 577 "parservhc.ml"
               : expr2))
; (fun parser_env ->
    let _1 = (peek_val parser_env 0 : expr2) in
    Obj.repr(
# 295 "parservhc.mly"
            ( _1 )
# 584 "parservhc.ml"
               : expr2))
; (fun parser_env ->
    let _1 = (peek_val parser_env 2 : expr2) in
    let _3 = (peek_val parser_env 0 : expr2) in
    Obj.repr(
# 299 "parservhc.mly"
                               ( verifier_typage entier _1.e_type; verifier_typage entier _3.e_type; {expr = LESS (_1.expr, _3.expr); e_ctxt = _1.e_ctxt @ _3.e_ctxt; e_type = booleen} )
# 592 "parservhc.ml"
               : expr2))
; (fun parser_env ->
    let _1 = (peek_val parser_env 2 : expr2) in
    let _3 = (peek_val parser_env 0 : expr2) in
    Obj.repr(
# 300 "parservhc.mly"
                        (verifier_typage _1.e_type _3.e_type ; {expr =EQUAL (_1.expr, _3.expr); e_ctxt = _1.e_ctxt @ _3.e_ctxt; e_type = booleen} )
# 600 "parservhc.ml"
               : expr2))
; (fun parser_env ->
    let _1 = (peek_val parser_env 0 : expr2) in
    Obj.repr(
# 301 "parservhc.mly"
            ( _1 )
# 607 "parservhc.ml"
               : expr2))
; (fun parser_env ->
    let _1 = (peek_val parser_env 2 : expr2) in
    let _3 = (peek_val parser_env 0 : expr2) in
    Obj.repr(
# 305 "parservhc.mly"
                              ( verifier_typage entier _1.e_type; verifier_typage entier _3.e_type; {e_type = entier;expr = ADD (_1.expr, _3.expr); e_ctxt = _1.e_ctxt @ _3.e_ctxt} )
# 615 "parservhc.ml"
               : expr2))
; (fun parser_env ->
    let _1 = (peek_val parser_env 2 : expr2) in
    let _3 = (peek_val parser_env 0 : expr2) in
    Obj.repr(
# 306 "parservhc.mly"
                         ( verifier_typage entier _1.e_type; verifier_typage entier _3.e_type; {e_type = entier;expr = SUB (_1.expr, _3.expr); e_ctxt = _1.e_ctxt @ _3.e_ctxt} )
# 623 "parservhc.ml"
               : expr2))
; (fun parser_env ->
    let _1 = (peek_val parser_env 0 : expr2) in
    Obj.repr(
# 307 "parservhc.mly"
            ( _1 )
# 630 "parservhc.ml"
               : expr2))
; (fun parser_env ->
    let _1 = (peek_val parser_env 2 : expr2) in
    let _3 = (peek_val parser_env 0 : expr2) in
    Obj.repr(
# 311 "parservhc.mly"
                       (  verifier_typage entier _1.e_type; verifier_typage entier _3.e_type; {e_type = entier;expr = MULT (_1.expr, _3.expr); e_ctxt = _1.e_ctxt @ _3.e_ctxt})
# 638 "parservhc.ml"
               : expr2))
; (fun parser_env ->
    let _1 = (peek_val parser_env 2 : expr2) in
    let _3 = (peek_val parser_env 0 : expr2) in
    Obj.repr(
# 312 "parservhc.mly"
                         (  verifier_typage entier _1.e_type; verifier_typage entier _3.e_type; {e_type = entier;expr = DIV (_1.expr, _3.expr); e_ctxt = _1.e_ctxt @ _3.e_ctxt} )
# 646 "parservhc.ml"
               : expr2))
; (fun parser_env ->
    let _1 = (peek_val parser_env 0 : expr2) in
    Obj.repr(
# 313 "parservhc.mly"
            ( _1 )
# 653 "parservhc.ml"
               : expr2))
; (fun parser_env ->
    let _1 = (peek_val parser_env 0 : expr2) in
    Obj.repr(
# 317 "parservhc.mly"
         ( _1 )
# 660 "parservhc.ml"
               : expr2))
; (fun parser_env ->
    let _2 = (peek_val parser_env 1 : expr2) in
    Obj.repr(
# 321 "parservhc.mly"
                  ( _2 )
# 667 "parservhc.ml"
               : expr2))
; (fun parser_env ->
    let _1 = (peek_val parser_env 0 : string) in
    Obj.repr(
# 322 "parservhc.mly"
         ( {expr = CST _1; e_ctxt = []; e_type = entier} )
# 674 "parservhc.ml"
               : expr2))
; (fun parser_env ->
    let _2 = (peek_val parser_env 0 : string) in
    Obj.repr(
# 323 "parservhc.mly"
               ( { expr =  CST ("-" ^ _2); e_ctxt = []; e_type = entier} )
# 681 "parservhc.ml"
               : expr2))
; (fun parser_env ->
    Obj.repr(
# 324 "parservhc.mly"
            ( {expr = CST "true"; e_ctxt = []; e_type = booleen} )
# 687 "parservhc.ml"
               : expr2))
; (fun parser_env ->
    Obj.repr(
# 325 "parservhc.mly"
             ( {expr = CST "false"; e_ctxt = []; e_type = booleen} )
# 693 "parservhc.ml"
               : expr2))
; (fun parser_env ->
    let _1 = (peek_val parser_env 0 : string * int) in
    Obj.repr(
# 326 "parservhc.mly"
           ( let p = indetermine ()  in {expr = VAR (fst _1); e_ctxt = [Variable (fst _1,p,snd _1)]; e_type = p } )
# 700 "parservhc.ml"
               : expr2))
; (fun parser_env ->
    let _1 = (peek_val parser_env 2 : string * int) in
    Obj.repr(
# 327 "parservhc.mly"
                     (let p = indetermine () in { e_type = p; expr = CALL ((fst _1), []); e_ctxt = [Appel {a_f = fst _1 ; a_type_vars = [] ; a_type_retour = p ; a_pos = snd _1}]} )
# 707 "parservhc.ml"
               : expr2))
; (fun parser_env ->
    let _1 = (peek_val parser_env 3 : string * int) in
    let _3 = (peek_val parser_env 1 : liste_args) in
    Obj.repr(
# 328 "parservhc.mly"
                                (let p = indetermine () in { e_type = p; expr = CALL ((fst _1), List.map (fun e -> e.expr) _3.exprlist); e_ctxt = Appel {a_f = fst _1; a_type_vars = List.map (fun e -> e.e_type) _3.exprlist ; a_type_retour = p ; a_pos = snd _1} :: _3.l_ctxt } )
# 715 "parservhc.ml"
               : expr2))
; (fun parser_env ->
    let _3 = (peek_val parser_env 1 : expr2) in
    Obj.repr(
# 329 "parservhc.mly"
                                 ( verifier_typage booleen _3.e_type; { expr = NOT (_3.expr); e_ctxt = _3.e_ctxt ; e_type = booleen} )
# 722 "parservhc.ml"
               : expr2))
; (fun parser_env ->
    let _2 = (peek_val parser_env 5 : expr2) in
    let _4 = (peek_val parser_env 3 : expr2) in
    let _6 = (peek_val parser_env 1 : expr2) in
    Obj.repr(
# 331 "parservhc.mly"
( verifier_typage booleen _2.e_type; verifier_typage _4.e_type _6.e_type; { expr = IF (_2.expr, (_4.expr, _6.expr)); e_ctxt = (_2.e_ctxt @ _4.e_ctxt) @ _6.e_ctxt ; e_type = _6.e_type } )
# 731 "parservhc.ml"
               : expr2))
; (fun parser_env ->
    Obj.repr(
# 333 "parservhc.mly"
                    ( { expr = INPUT; e_ctxt = []; e_type = entier} )
# 737 "parservhc.ml"
               : expr2))
; (fun parser_env ->
    Obj.repr(
# 334 "parservhc.mly"
                               ( { expr = INPUT; e_ctxt = []; e_type = entier} )
# 743 "parservhc.ml"
               : expr2))
; (fun parser_env ->
    let _3 = (peek_val parser_env 1 : expr2) in
    Obj.repr(
# 335 "parservhc.mly"
                                    (  { expr = OUTPUT( _3.expr );  e_ctxt = _3.e_ctxt; e_type = _3.e_type } )
# 750 "parservhc.ml"
               : expr2))
; (fun parser_env ->
    let _3 = (peek_val parser_env 1 : expr2) in
    Obj.repr(
# 336 "parservhc.mly"
                                     ( verifier_typage entier _3.e_type; { expr = RANDOM(_3.expr); e_ctxt = _3.e_ctxt; e_type = entier } )
# 757 "parservhc.ml"
               : expr2))
; (fun parser_env ->
    let _1 = (peek_val parser_env 0 : expr2) in
    Obj.repr(
# 340 "parservhc.mly"
         ( {exprlist = [ _1 ]; l_ctxt = _1.e_ctxt })
# 764 "parservhc.ml"
               : liste_args))
; (fun parser_env ->
    let _1 = (peek_val parser_env 2 : expr2) in
    let _3 = (peek_val parser_env 0 : liste_args) in
    Obj.repr(
# 341 "parservhc.mly"
                           ( { exprlist = _1 :: _3.exprlist; l_ctxt = _1.e_ctxt @ _3.l_ctxt } )
# 772 "parservhc.ml"
               : liste_args))
; (fun parser_env ->
    let _1 = (peek_val parser_env 0 : elem_aff) in
    Obj.repr(
# 345 "parservhc.mly"
             ( 
{
 elem_affs = [ _1 ];
 aretes =  List.map (function {a_f = g} -> (fst _1.fundef, g)) _1.appels ;
} 
           )
# 784 "parservhc.ml"
               : affs))
; (fun parser_env ->
    let _1 = (peek_val parser_env 1 : elem_aff) in
    Obj.repr(
# 352 "parservhc.mly"
                               ( 
{
 elem_affs = [ _1 ];
 aretes = List.map (function {a_f = g} -> (fst _1.fundef, g)) _1.appels ;
} 
           )
# 796 "parservhc.ml"
               : affs))
; (fun parser_env ->
    let _1 = (peek_val parser_env 2 : elem_aff) in
    let _3 = (peek_val parser_env 0 : affs) in
    Obj.repr(
# 359 "parservhc.mly"
                                     ( 

              let rec mem2 = function
                | [] -> {
 elem_affs = _1 :: _3.elem_affs ;
 aretes =  (List.map (function {a_f = g} -> (fst _1.fundef, g)) _1.appels) @ _3.aretes ;
                } 
                | a :: _ when fst a.fundef = fst _1.fundef -> raise (Double_fundef (fst a.fundef, _1.pos))
                | _ :: q -> mem2 q
              in mem2 _3.elem_affs
           )
# 814 "parservhc.ml"
               : affs))
; (fun parser_env ->
    let _1 = (peek_val parser_env 4 : string * int) in
    let _5 = (peek_val parser_env 0 : expr2) in
    Obj.repr(
# 374 "parservhc.mly"
                             (
{
  fundef = (fst _1, ([], _5.expr));
  appels = filtrer_contexte_local [] _5.e_ctxt;
  pos = snd _1;
  f_type_vars = [];
  f_type_retour = _5.e_type
}
          )
# 830 "parservhc.ml"
               : elem_aff))
; (fun parser_env ->
    let _1 = (peek_val parser_env 5 : string * int) in
    let _3 = (peek_val parser_env 3 : (fpar * boite_typage) list) in
    let _6 = (peek_val parser_env 0 : expr2) in
    Obj.repr(
# 384 "parservhc.mly"
                                          (

{
  fundef = (fst _1, (List.map fst _3, _6.expr));
  appels = filtrer_contexte_local _3 _6.e_ctxt;
  pos = snd _1;
  f_type_retour = _6.e_type;
  f_type_vars = List.map snd _3;
}
            )
# 848 "parservhc.ml"
               : elem_aff))
; (fun parser_env ->
    let _1 = (peek_val parser_env 0 : fpar * (string * int)) in
    Obj.repr(
# 397 "parservhc.mly"
              ( [ fst _1 , indetermine ()] )
# 855 "parservhc.ml"
               : (fpar * boite_typage) list))
; (fun parser_env ->
    let _1 = (peek_val parser_env 2 : fpar * (string * int)) in
    let _3 = (peek_val parser_env 0 : (fpar * boite_typage) list) in
    Obj.repr(
# 398 "parservhc.mly"
                                 ( let v,(n,pos) = _1 in match type_param n _3 with Chose _ -> raise (Double_argdef (n,pos)) | Rien -> (v, indetermine ()) :: _3 )
# 863 "parservhc.ml"
               : (fpar * boite_typage) list))
; (fun parser_env ->
    let _1 = (peek_val parser_env 0 : string * int) in
    Obj.repr(
# 402 "parservhc.mly"
                  (FPNECSTAT (* FPVAL *) (fst _1), _1 )
# 870 "parservhc.ml"
               : fpar * (string * int)))
; (fun parser_env ->
    let _2 = (peek_val parser_env 0 : string * int) in
    Obj.repr(
# 403 "parservhc.mly"
                          (FPVAL (fst _2), _2)
# 877 "parservhc.ml"
               : fpar * (string * int)))
; (fun parser_env ->
    let _2 = (peek_val parser_env 0 : string * int) in
    Obj.repr(
# 404 "parservhc.mly"
                             (FPNECSTAT (fst _2), _2)
# 884 "parservhc.ml"
               : fpar * (string * int)))
; (fun parser_env ->
    let _2 = (peek_val parser_env 0 : string * int) in
    Obj.repr(
# 405 "parservhc.mly"
                            (FPNECDYN (fst _2), _2)
# 891 "parservhc.ml"
               : fpar * (string * int)))
(* Entry program *)
; (fun parser_env -> raise (YYexit (peek_val parser_env 0)))
|]
let yytables =
  { actions=yyact;
    transl_const=yytransl_const;
    transl_block=yytransl_block;
    lhs=yylhs;
    len=yylen;
    defred=yydefred;
    dgoto=yydgoto;
    sindex=yysindex;
    rindex=yyrindex;
    gindex=yygindex;
    tablesize=yytablesize;
    table=yytable;
    check=yycheck;
    error_function=parse_error;
    names_const=yynames_const;
    names_block=yynames_block }
let program (lexfun : Lexing.lexbuf -> token) (lexbuf : Lexing.lexbuf) =
   (yyparse yytables 1 lexfun lexbuf : Aintv.prog)
;;
# 409 "parservhc.mly"
    
# 918 "parservhc.ml"