diff --git a/src/passePlacementRat.ml b/src/passePlacementRat.ml new file mode 100644 index 0000000..175c433 --- /dev/null +++ b/src/passePlacementRat.ml @@ -0,0 +1,51 @@ +(* Module de la passe de typage *) +module PassePlacementRat : Passe.Passe with type t1 = Ast.AstType.programme and type t2 = Ast.AstType.programme = +struct + + open Tds + open Exceptions + open Ast + open AstType + open Type + + type t1 = Ast.AstType.programme + type t2 = Ast.AstType.programme + +let rec analyse_placement_instruction i base reg = + match i with + | AstType.Declaration(info, e) -> + begin + match info_ast_to_info info with + | InfoVar(_, t, _, _) -> + let taille = getTaille t in + modifier_adresse_info base reg info; + taille + | _ -> failwith "wtf frère" + end + + | AstType.Conditionnelle(e, b1, b2) -> + let _ = analyse_placement_bloc base reg b1 in + let _ = analyse_placement_bloc base reg b2 in + 0 + + | AstType.TantQue(e, b) -> + let _ = analyse_placement_bloc base reg b in + 0 + + | _ -> 0 + +and analyse_placement_bloc base reg bloc = + match bloc with + | [] -> base + | t::q -> + 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" + +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) *) + +end diff --git a/src/passeTypeRat.ml b/src/passeTypeRat.ml index 5ed04a1..832198b 100644 --- a/src/passeTypeRat.ml +++ b/src/passeTypeRat.ml @@ -6,6 +6,7 @@ struct open Exceptions open Ast open AstType + open Type type t1 = Ast.AstTds.programme type t2 = Ast.AstType.programme @@ -26,29 +27,31 @@ let rec analyse_type_expression e = 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) + raise (TypesParametresInattendus(l_type_fun, l_type)) end | AstTds.Unaire(u, expr) -> begin match (analyse_type_expression expr) with | n_expr, Rat -> - match u with - | AstSyntax.Numerateur -> (AstType.Unaire(Numerateur, n_expr), Int) - | AstSyntax.Denominateur -> (AstType.Unaire(Denominateur, n_expr), Int) - | _, t -> raise (TypeInattendu(Rat, t)) + begin + match u with + | AstSyntax.Numerateur -> (AstType.Unaire(Numerateur, n_expr), Int) + | AstSyntax.Denominateur -> (AstType.Unaire(Denominateur, n_expr), Int) + end + | _, t -> raise (TypeInattendu(t, Rat)) end | AstTds.Binaire(b, expr_1, expr_2) -> begin - let (n_expr_1, t1) = analyse_type_expresseion expr_1 in - let (n_expr_2, t2) = analyse_type_expresseion expr_2 in + let (n_expr_1, t1) = analyse_type_expression expr_1 in + let (n_expr_2, t2) = analyse_type_expression expr_2 in match (b, t1, t2) with | Fraction, Int, Int -> (AstType.Binaire(Fraction, n_expr_1, n_expr_2), Rat) | Plus, Int, Int -> (AstType.Binaire(PlusInt, n_expr_1, n_expr_2), Int) | Mult, Int, Int -> (AstType.Binaire(MultInt, n_expr_1, n_expr_2), Int) - | Equ, Int ,Int -> (AstType.Binaire(EquInt, n_expr_1, n_expr_2), Int) - | Inf, Int, Int -> (AstType.Binaire(Inf, n_expr_1, n_expr_2), Int) + | Equ, Int ,Int -> (AstType.Binaire(EquInt, n_expr_1, n_expr_2), Bool) + | Inf, Int, Int -> (AstType.Binaire(Inf, n_expr_1, n_expr_2), Bool) | Plus, Rat, Rat -> (AstType.Binaire(PlusRat, n_expr_1, n_expr_2), Rat) | Mult, Rat, Rat -> (AstType.Binaire(MultRat, n_expr_1, n_expr_2), Rat) | Equ, Bool ,Bool -> (AstType.Binaire(EquBool, n_expr_1, n_expr_2), Bool) @@ -75,62 +78,70 @@ en une instruction de type AstType.instruction *) let rec analyse_type_instruction opt i = match i with | AstTds.Declaration (t, info, e) -> - begin - let (ne, nt) = analyse_type_expr e in - if (est_compatible t nt) then - modifier_type_info t info; - AstType.Declaration(info, ne) - else - raise TypeInattendu(t, nt) - end - - | AstTds.Affectation (info, e) -> - begin - let (ne, nt) = analyse_type_expr e in - match (info_ast_to_info info) with - | InfoVar(_, t, _, _) -> - if est_compatible t nt then - AstType.Affectation(info, ne) - else - raise TypeInattendu(t, nt) - | _ -> failwith "wut" - end - + let (ne, nt) = analyse_type_expression e in + if (est_compatible t nt) then + let _ = modifier_type_info t info in + AstType.Declaration(info, ne) + else + raise (TypeInattendu(nt, t)) + + + | AstTds.Affectation (info, e) -> + begin + let (ne, nt) = analyse_type_expression e in + match (info_ast_to_info info) with + | InfoVar(_, t, _, _) -> + if est_compatible t nt then + AstType.Affectation(info, ne) + else + raise (TypeInattendu(nt, t)) + | _ -> failwith "wut" + end + | AstTds.Affichage e -> begin - let (ne, nt) = analyse_type_expr e in + let (ne, nt) = analyse_type_expression e in match nt with - | Int -> AstType.AffciaheInt(ne) - | Rat -> AstType.AffciaheRat(ne) - | Bool -> AstType.AffichagBool(ne) + | Int -> AstType.AffichageInt(ne) + | Rat -> AstType.AffichageRat(ne) + | Bool -> AstType.AffichageBool(ne) end - + | AstTds.Conditionnelle (e, b1, b2) -> begin - let (ne, nt) = analyse_type_expr e in + let (ne, nt) = analyse_type_expression e in let nb1 = analyse_type_bloc opt b1 in let nb2 = analyse_type_bloc opt b2 in - AstType.Conditionnelle(ne, nb1, nb2) + if (est_compatible Bool nt) then + AstType.Conditionnelle(ne, nb1, nb2) + else + raise (TypeInattendu(nt, Bool)) end - | AstTds.TantQue (e, b) -> + | AstTds.TantQue (e, b) -> begin - let (ne, nt) = analyse_type_expr e in - let nb = analyse_type_bloc b in - AstType.Conditionnelle(ne, nb) + let (ne, nt) = analyse_type_expression e in + if (est_compatible nt Bool) then + let nb = analyse_type_bloc opt b in + AstType.TantQue(ne, nb) + else + raise (TypeInattendu(nt, Bool)) end - - | AstTds.Retour (e) -> + + | AstTds.Retour (e) -> begin match opt with | Some(t) -> - let (ne, nt) = analyse_type_expr e in - if est_compatible t nt then + let (ne, nt) = analyse_type_expression e in + if est_compatible t nt then AstType.Retour(ne) - else - raise TypeInattendu(t, nt) + else + raise (TypeInattendu(t, nt)) | None -> failwith "Pas de return dans le main" end + + | AstTds.Empty -> AstType.Empty + (* analyse_type_bloc : AstTds.bloc -> AstType.bloc *) (* Paramètre tds : la table des symboles courante *) @@ -154,49 +165,18 @@ en une fonction de type AstType.fonction *) AstTds.fonction[typ * string * (typ * string) list * bloc] -> AstType.fonction[typ * Tds.info_ast * (typ * Tds.info_ast ) list * bloc] *) -let analyse_type_fonction opt (AstTds.Fonction(t, str, l_typstr, bloc)) = failwith "TODO" - (* begin - match chercherLocalement maintds str with - | Some _ -> raise (DoubleDeclaration str) - | None -> - begin - (* Info de l'identifiant de la fonction *) - let info = Tds.InfoVar(str, Undefined, 0, "") in +let analyse_type_fonction opt (AstTds.Fonction(t, info, l_typinfo, bloc)) = + match opt with + | Some t_ret -> + if est_compatible t_ret t then + let _ = modifier_type_info t info in + let n_l_info = List.map (fun (ti, i) -> modifier_type_info ti i; i) l_typinfo in + let nb = analyse_type_bloc opt bloc in + AstType.Fonction(info, n_l_info, nb) + else + raise (TypeInattendu(t, t_ret)) + | None -> failwith "Il faut un return dans une fonction" - (* Copie de la tds globale dans la tds locale au bloc *) - let tds_bloc = creerTDSFille maintds in - - (* Ajouter les arguments de la fonction dans la tds locale *) - let _ = (List.map ( - fun (_, nom) -> - match chercherLocalement tds_bloc nom with - | None -> ajouter tds_bloc nom (info_to_info_ast (Tds.InfoVar(nom, Undefined, 0, ""))) - (* Si un argument est en double, on lève une exception *) - | Some _ -> raise (DoubleDeclaration nom) - ) l_typstr) in - - (* On ajoute a la tds locale la fonction pour qu'il puisse y avoir des appels récursifs *) - let _ = ajouter tds_bloc str (info_to_info_ast (Tds.InfoFun(str, t, (List.map (fun (t, _) -> t) l_typstr)))) in - - (* On génère le nouveau bloc avec la tds locale *) - let new_bloc = analyse_type_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 - - (* On ajoute la fonction a la tds globale *) - ajouter maintds str (info_to_info_ast info_fun); - - (* On retourne la AstType fonction *) - AstType.Fonction(t, (info_to_info_ast info), nl_typinfo, new_bloc) - end - end *) (* analyser : AstTds.ast -> AstType.ast *) (* Paramètre : le programme à analyser *) @@ -204,7 +184,8 @@ let analyse_type_fonction opt (AstTds.Fonction(t, str, l_typstr, bloc)) = failw en un programme de type AstType.ast *) (* Erreur si mauvaise utilisation des identifiants *) let analyser (AstTds.Programme(fonctions, prog)) = - (* let nf = List.map (analyse_type_fonction Some(...)) 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) diff --git a/src/testType.ml b/src/testType.ml index a24e543..a689049 100644 --- a/src/testType.ml +++ b/src/testType.ml @@ -7,12 +7,12 @@ exception ErreurNonDetectee (* Sans fonction *) (* ------------------------------ *) + let%test_unit "testDeclaration1"= let _ = compiler "../../fichiersRat/src-rat-type-test/testDeclaration1.rat" in () -(* let%test_unit "testDeclaration2"= - let _ = compiler "../../fichiersRat/src-rat-type-test/testDeclaration2.rat" in () +let _ = compiler "../../fichiersRat/src-rat-type-test/testDeclaration2.rat" in () let%test_unit "testDeclaration3"= let _ = compiler "../../fichiersRat/src-rat-type-test/testDeclaration3.rat" in () @@ -419,13 +419,12 @@ let _ = compiler "../../fichiersRat/src-rat-tam-test/factiter.rat" in () let%test_unit "code_complique" = 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 () @@ -559,4 +558,4 @@ let%test_unit "code_testfun6" = let%test_unit "code_testfuns" = let _ = compiler "../../fichiersRat/src-rat-tam-test/testfuns.rat" in () -*) +*) \ No newline at end of file