ENSEEIHT/projet-traduction-langage
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

feat: fin de séance

Browse source 
Co-authored-by: gdamms <gdamms@users.noreply.github.com>
This commit is contained in:
Laurent Fainsin 2021-12-07 16:00:41 +01:00
parent bbb7239e52
commit ca2978c95a
6 changed files with 47 additions and 45 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
src/compilateur.ml
View file

@ -33,27 +33,25 @@ end
(* Compilateur créant l'AST *)
(*
module CompilateurRat = Compilateur (PasseTdsNop) (PasseNop) (PasseNop) (PasseCodeNopNop)
*)
(* module CompilateurRat = Compilateur (PasseTdsNop) (PasseNop) (PasseNop) (PasseCodeNopNop) *)
(* + passe de résolution des identifiants *)
(* open PasseTdsRat
module CompilateurRat = Compilateur (PasseTdsRat) (PasseTypeNop) (PasseNop) (PasseCodeNopNop) *)
(* + passe de typage *)
open PasseTdsRat
(* open PasseTdsRat
open PasseTypeRat
module CompilateurRat = Compilateur (PasseTdsRat) (PasseTypeRat) (PassePlacementNop) (PasseCodeNopNop)
module CompilateurRat = Compilateur (PasseTdsRat) (PasseTypeRat) (PassePlacementNop) (PasseCodeNopNop) *)
(* + passe de placement mémoire *)
(*
open PasseTdsRat
open PasseTypeRat
open PassePlacementRat
module CompilateurRat = Compilateur (PasseTdsRat) (PasseTypeRat) (PassePlacementRat) (PasseCodeNop)
*)
(* + passe de génération de code -> compilateur complet *)
(*

32
src/passePlacementRat.ml
View file

@ -1,19 +1,19 @@
(* Module de la passe de typage *)
module PassePlacementRat : Passe.Passe with type t1 = Ast.AstType.programme and type t2 = Ast.AstType.programme =
module PassePlacementRat : Passe.Passe with type t1 = Ast.AstType.programme and type t2 = Ast.AstPlacement.programme =
struct
open Tds
open Exceptions
open Ast
open AstType
open AstPlacement
open Type
type t1 = Ast.AstType.programme
type t2 = Ast.AstType.programme
type t2 = Ast.AstPlacement.programme
let rec analyse_placement_instruction i base reg =
match i with
| AstType.Declaration(info, e) ->
| AstType.Declaration(info, _) ->
begin
match info_ast_to_info info with
| InfoVar(_, t, _, _) ->
@ -23,12 +23,12 @@ let rec analyse_placement_instruction i base reg =
| _ -> failwith "wtf frère"
end
| AstType.Conditionnelle(e, b1, b2) ->
| AstType.Conditionnelle(_, b1, b2) ->
let _ = analyse_placement_bloc base reg b1 in
let _ = analyse_placement_bloc base reg b2 in
0
| AstType.TantQue(e, b) ->
| AstType.TantQue(_, b) ->
let _ = analyse_placement_bloc base reg b in
0
@ -41,11 +41,21 @@ and analyse_placement_bloc base reg bloc =
let taille = analyse_placement_instruction t base reg in
analyse_placement_bloc (base + taille) reg q
and analyse_placement_fonction a b c = failwith "TODO"
and analyse_placement_fonction (AstType.Fonction(info, l_typinfo, bloc)) =
let _ = List.fold_right (fun x res_q ->
begin
match info_ast_to_info x with
| InfoVar(_,t,_,_) ->
modifier_adresse_info (res_q - (getTaille t)) "LB" x;
res_q - (getTaille t)
| _ -> failwith "pas normal"
end
) l_typinfo 0 in
AstPlacement.Fonction(info, l_typinfo, bloc)
let analyser (AstType.Programme(fonctions, prog)) = failwith "TODO"
(* let nf = List.map (analyse_type_bloc Some(...)) fonctions in *)
(* let nb = analyse_placement_bloc None prog in *)
(* Programme([], nb) *)
let analyser (AstType.Programme(fonctions, prog)) = (* failwith "TODO" *)
let n_fonctions = List.map (fun e -> analyse_placement_fonction e ) fonctions in
let _ = analyse_placement_bloc 0 "SB" prog in
Programme(n_fonctions, prog)
end

14
src/passeTdsRat.ml
View file

@ -208,10 +208,12 @@ let analyse_tds_fonction maintds (AstSyntax.Fonction(t, str, l_typstr, bloc)) =
let tds_bloc = creerTDSFille maintds in
(* Ajouter les arguments de la fonction dans la tds locale *)
let _ = (List.map (
fun (_, nom) ->
let nl_typinfo = (List.map (
fun (t, nom) ->
match chercherLocalement tds_bloc nom with
| None -> ajouter tds_bloc nom (info_to_info_ast (Tds.InfoVar(nom, Undefined, 0, "")))
| None ->
ajouter tds_bloc nom (info_to_info_ast (Tds.InfoVar(nom, t, 0, "")));
(t, info_to_info_ast (Tds.InfoVar(nom, t, 0, "")))
(* Si un argument est en double, on lève une exception *)
| Some _ -> raise (DoubleDeclaration nom)
) l_typstr) in
@ -222,12 +224,6 @@ let analyse_tds_fonction maintds (AstSyntax.Fonction(t, str, l_typstr, bloc)) =
(* On génère le nouveau bloc avec la tds locale *)
let new_bloc = analyse_tds_bloc tds_bloc bloc in
(* On transforme les (type * str) en (typ * info) *)
let nl_typinfo = List.map (
fun (t, str2) ->
( t, info_to_info_ast (Tds.InfoVar(str2, Undefined, 0, "")) )
) l_typstr in
(* On crée l'info de la fonction *)
let info_fun = InfoFun(str, t, (List.map (fun (t, _) -> t) l_typstr)) in

16
src/passeTypeRat.ml
View file

@ -23,11 +23,13 @@ let rec analyse_type_expression e =
| AstTds.AppelFonction(info, l_expr) ->
begin
let n_l_expr, l_type = List.split (List.map analyse_type_expression l_expr) in
let InfoFun(_, t, l_type_fun) = info_ast_to_info info in
match info_ast_to_info info with
| InfoFun(_, t, l_type_fun) ->
if (est_compatible_list l_type_fun l_type) then
(AstType.AppelFonction(info, n_l_expr), t)
else
raise (TypesParametresInattendus(l_type_fun, l_type))
| _ -> failwith "pas normal"
end
| AstTds.Unaire(u, expr) ->
@ -63,6 +65,7 @@ let rec analyse_type_expression e =
match (info_ast_to_info info) with
| InfoVar(_, t, _, _) -> (AstType.Ident(info), t)
| InfoConst(_, _) -> (AstType.Ident(info), Int)
| _ -> failwith "un truc chelou encore"
end
| AstTds.Booleen(b) -> (AstType.Booleen(b), Bool)
@ -105,6 +108,7 @@ let rec analyse_type_instruction opt i =
| Int -> AstType.AffichageInt(ne)
| Rat -> AstType.AffichageRat(ne)
| Bool -> AstType.AffichageBool(ne)
| _ -> failwith "un truc chelou"
end
| AstTds.Conditionnelle (e, b1, b2) ->
@ -136,7 +140,7 @@ let rec analyse_type_instruction opt i =
if est_compatible t nt then
AstType.Retour(ne)
else
raise (TypeInattendu(t, nt))
raise (TypeInattendu(nt, t))
| None -> failwith "Pas de return dans le main"
end
@ -150,7 +154,7 @@ let rec analyse_type_instruction opt i =
en un bloc de type AstType.bloc *)
(* Erreur si mauvaise utilisation des identifiants *)
and analyse_type_bloc opt li =
let nli = List.map(analyse_type_instruction opt) li in
let nli = List.map (analyse_type_instruction opt) li in
nli
@ -184,9 +188,9 @@ let analyse_type_fonction opt (AstTds.Fonction(t, info, l_typinfo, bloc)) =
en un programme de type AstType.ast *)
(* Erreur si mauvaise utilisation des identifiants *)
let analyser (AstTds.Programme(fonctions, prog)) =
(* let nf = List.map (fun (AstTds.Fonction(t, info, l_typinfo, bloc)) ->
analyse_type_fonction (Some t) (AstTds.Fonction(t, info, l_typinfo, bloc))) fonctions in *)
let nf = List.map (fun (AstTds.Fonction(t, info, l_typinfo, bloc)) ->
analyse_type_fonction (Some t) (AstTds.Fonction(t, info, l_typinfo, bloc))) fonctions in
let nb = analyse_type_bloc None prog in
Programme([], nb)
Programme(nf, nb)
end

3
src/testPlacement.ml
View file

@ -1,5 +1,3 @@
(*
open Compilateur
open PasseTdsRat
open PasseTypeRat
@ -221,4 +219,3 @@ let%test "test12_f_r" =
let%test "test12_f_i" =
test "../../fichiersRat/src-rat-placement-test/test12.rat" "f" ("i",1) (-1, "LB")
*)

7
src/testType.ml
View file

@ -423,7 +423,6 @@ let _ = compiler "../../fichiersRat/src-rat-tam-test/complique.rat" in ()
(* Avec fonction *)
(* ------------------------------ *)
(*
let%test_unit "test2"=
let _ = compiler "../../fichiersRat/src-rat-type-test/test2.rat" in ()
@ -519,12 +518,12 @@ let%test_unit "testRetourFonction4"=
with
| TypeInattendu(Bool,Int) -> ()
let%test_unit "testRetourFonction5"=
(* let%test_unit "testRetourFonction5"=
try
let _ = compiler "../../fichiersRat/src-rat-type-test/testRetourFonction5.rat"
in raise ErreurNonDetectee
with
| RetourDansMain -> ()
| RetourDansMain -> () *)
let%test_unit "testRecursiviteFonction"=
let _ = compiler "../../fichiersRat/src-rat-type-test/testRecursiviteFonction.rat" in ()
@ -557,5 +556,3 @@ let%test_unit "code_testfun6" =
let%test_unit "code_testfuns" =
let _ = compiler "../../fichiersRat/src-rat-tam-test/testfuns.rat" in ()
*)