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

feat: ca avance

Browse source
This commit is contained in:
Guillotin Damien 2021-12-11 16:49:23 +01:00
parent 3b73128050
commit 33ccff335a
12 changed files with 183 additions and 88 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

34
src/ast.ml
View file

@ -33,8 +33,6 @@ type affectable =
type expression =
(* Appel de fonction représenté par le nom de la fonction et la liste des paramètres réels *)
| AppelFonction of string * expression list
(* Accès à un identifiant représenté par son nom *)
| Ident of string
(* Booléen *)
| Booleen of bool
(* Entier *)
@ -87,16 +85,25 @@ end
module AstTds =
struct
type affectable =
(* Dé-référencement d'un affectable *)
| Dref of affectable
(* Identifiant *)
| Ident of Tds.info_ast
(* Expressions existantes dans notre langage *)
(* ~ expression de l'AST syntaxique où les noms des identifiants ont été
remplacés par les informations associées aux identificateurs *)
type expression =
| AppelFonction of Tds.info_ast * expression list
| Ident of Tds.info_ast (* le nom de l'identifiant est remplacé par ses informations *)
| Booleen of bool
| Entier of int
| Unaire of AstSyntax.unaire * expression
| Binaire of AstSyntax.binaire * expression * expression
| Affectable of affectable
| Null
| NewType of typ
| Adresse of Tds.info_ast
(* instructions existantes dans notre langage *)
(* ~ instruction de l'AST syntaxique où les noms des identifiants ont été
@ -105,7 +112,7 @@ struct
type bloc = instruction list
and instruction =
| Declaration of typ * Tds.info_ast * expression (* le nom de l'identifiant est remplacé par ses informations *)
| Affectation of Tds.info_ast * expression (* le nom de l'identifiant est remplacé par ses informations *)
| Affectation of affectable * expression (* le nom de l'identifiant est remplacé par ses informations *)
| Affichage of expression
| Conditionnelle of expression * bloc * bloc
| TantQue of expression * bloc
@ -135,15 +142,24 @@ type unaire = Numerateur | Denominateur
(* Opérateurs binaires existants dans Rat - résolution de la surcharge *)
type binaire = Fraction | PlusInt | PlusRat | MultInt | MultRat | EquInt | EquBool | Inf
type affectable =
(* Dé-référencement d'un affectable *)
| Dref of affectable
(* Identifiant *)
| Ident of Tds.info_ast
(* Expressions existantes dans Rat *)
(* = expression de AstTds *)
type expression =
| AppelFonction of Tds.info_ast * expression list
| Ident of Tds.info_ast
| Booleen of bool
| Entier of int
| Unaire of unaire * expression
| Binaire of binaire * expression * expression
| Affectable of affectable
| Null
| NewType of typ
| Adresse of Tds.info_ast
(* instructions existantes Rat *)
(* = instruction de AstTds + informations associées aux identificateurs, mises à jour *)
@ -151,7 +167,7 @@ type expression =
type bloc = instruction list
and instruction =
| Declaration of Tds.info_ast * expression
| Affectation of Tds.info_ast * expression
| Affectation of affectable * expression
| AffichageInt of expression
| AffichageRat of expression
| AffichageBool of expression
@ -202,9 +218,3 @@ type programme = Programme of fonction list * bloc
end
(* Conversion des affectables *)
let rec string_of_affectable a =
match a with
| AstSyntax.Dref(n) -> (string_of_affectable n)
| AstSyntax.Ident(n) -> n ^ " "

6
src/compilateur.ml
View file

@ -33,7 +33,7 @@ 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 *)
@ -54,11 +54,11 @@ module CompilateurRat = Compilateur (PasseTdsRat) (PasseTypeRat) (PassePlacement
(* + passe de génération de code -> compilateur complet *)
open PasseTdsRat
(* open PasseTdsRat
open PasseTypeRat
open PassePlacementRat
open PasseCodeRatToTam
module CompilateurRat = Compilateur (PasseTdsRat) (PasseTypeRat) (PassePlacementRat) (PasseCodeRatToTam)
module CompilateurRat = Compilateur (PasseTdsRat) (PasseTypeRat) (PassePlacementRat) (PasseCodeRatToTam) *)

28
src/parser.mly
View file

@ -70,14 +70,14 @@ is :
| i1=i li=is {i1::li}
i :
| t=typ n=ID EQUAL e1=e PV {Declaration (t,n,e1)}
| n=ID EQUAL e1=e PV {Affectation (n,e1)}
| CONST n=ID EQUAL e=ENTIER PV {Constante (n,e)}
| PRINT e1=e PV {Affichage (e1)}
| IF exp=e li1=bloc ELSE li2=bloc {Conditionnelle (exp,li1,li2)}
| WHILE exp=e li=bloc {TantQue (exp,li)}
| RETURN exp=e PV {Retour (exp)}
| a1=a EQUAL exp=e1 {Affectation(Deref(a1), e1)}
| t=typ n=ID EQUAL exp=e PV {Declaration (t,n,exp)}
| n=ID EQUAL exp=e PV {Affectation (Ident(n),exp)}
| CONST n=ID EQUAL e=ENTIER PV {Constante (n,e)}
| PRINT exp=e PV {Affichage (exp)}
| IF exp=e li1=bloc ELSE li2=bloc {Conditionnelle (exp,li1,li2)}
| WHILE exp=e li=bloc {TantQue (exp,li)}
| RETURN exp=e PV {Retour (exp)}
| aff=a EQUAL exp=e {Affectation (aff, exp)}
dp :
| {[]}
@ -87,7 +87,7 @@ typ :
| BOOL {Bool}
| INT {Int}
| RAT {Rat}
| t1=typ MULT {Deref t1}
| t1=typ MULT {Pointeur (t1)}
e :
| CALL n=ID PO lp=cp PF {AppelFonction (n,lp)}
@ -103,14 +103,14 @@ e :
| PO e1=e INF e2=e PF {Binaire (Inf,e1,e2)}
| PO exp=e PF {exp}
| a1=a {Affectable a1}
| NULL { ??? }
| PO NEW t1=typ PF { ??? }
| AMP n=ID { Deref n }
| NULL {Null}
| PO NEW t1=typ PF {NewType (t1)}
| AMP n=ID {Adresse (n)}
cp :
| {[]}
| e1=e le=cp {e1::le}
a :
| n=ID {Ident n}
| PO MULT a1=a PF {Deref a1}
| n=ID {Ident (n)}
| PO MULT a1=a PF {Dref (a1)}

4
src/passeCodeRatToTam.ml
View file

@ -21,9 +21,9 @@ let rec analyse_code_expression e =
"CALL (ST) " ^ nom ^ "\n"
end
| Ident(i) ->
(* | Ident(i) ->
let InfoVar(_,t,base,reg) = info_ast_to_info i in
"LOAD (" ^ (string_of_int (getTaille t)) ^ ") " ^ (string_of_int base) ^ "[" ^ reg ^ "]\n"
"LOAD (" ^ (string_of_int (getTaille t)) ^ ") " ^ (string_of_int base) ^ "[" ^ reg ^ "]\n" *)
| Booleen(b) ->
if b then

102
src/passeTdsRat.ml
View file

@ -6,11 +6,38 @@ struct
open Exceptions
open Ast
open AstTds
open PrinterAst
type t1 = Ast.AstSyntax.programme
type t2 = Ast.AstTds.programme
let rec analyse_tds_affectable tds a modif =
match a with
| AstSyntax.Dref new_aff ->
let x = analyse_tds_affectable tds new_aff true in
AstTds.Dref(x)
| AstSyntax.Ident n ->
begin
match (chercherGlobalement tds n) with
| None -> raise (IdentifiantNonDeclare n)
| Some info ->
begin
match (info_ast_to_info info) with
| InfoVar _ -> AstTds.Ident(info)
| InfoConst _ ->
begin
if modif then
failwith "bah non en fait"
else
AstTds.Ident(info)
end
| InfoFun _ -> failwith "t chelou bro"
end
end
(* analyse_tds_expression : AstSyntax.expression -> AstTds.expression *)
(* Paramètre tds : la table des symboles courante *)
(* Paramètre e : l'expression à analyser *)
@ -34,21 +61,7 @@ let rec analyse_tds_expression tds e =
(* L'identifiant ne fait pas référence à une fonction, on lève ue exception *)
| _ -> raise (MauvaiseUtilisationIdentifiant str)
end
| AstSyntax.Ident(str) ->
begin
match chercherGlobalement tds str with
(* L'identifiant n'est pas déclaré *)
| None -> raise (IdentifiantNonDeclare str)
| Some info ->
match (info_ast_to_info info) with
| InfoVar(_, _, _, _) ->
AstTds.Ident(info)
| InfoConst(_, v) ->
AstTds.Entier(v)
(** L'identifiant fait référence a une fonction lors de l'association a une varibale, on lève une exception *)
| _ -> raise (MauvaiseUtilisationIdentifiant str)
end
| AstSyntax.Booleen(b) ->
begin
AstTds.Booleen(b)
@ -68,7 +81,20 @@ let rec analyse_tds_expression tds e =
let new_expr_2 = analyse_tds_expression tds expr_2 in
AstTds.Binaire(b, new_expr_1, new_expr_2)
end
| AstSyntax.Affectable(a) -> AstTds.Affectable(analyse_tds_affectable tds a false)
| AstSyntax.Null -> AstTds.Null
| AstSyntax.NewType(t) -> AstTds.NewType(t)
| AstSyntax.Adresse(n) ->
let info = chercherGlobalement tds n in
match info with
| None ->
raise (IdentifiantNonDeclare n)
| Some i ->
begin
match (info_ast_to_info i) with
| InfoVar _ -> AstTds.Adresse(i)
| _ -> raise (MauvaiseUtilisationIdentifiant(n))
end
(* analyse_tds_instruction : AstSyntax.instruction -> tds -> AstTds.instruction *)
(* Paramètre tds : la table des symboles courante *)
@ -101,27 +127,33 @@ let rec analyse_tds_instruction tds i =
il a donc déjà été déclaré dans le bloc courant *)
raise (DoubleDeclaration n)
end
| AstSyntax.Affectation (n,e) ->
| AstSyntax.Affectation (aff, e) ->
begin
match chercherGlobalement tds (string_of_affectable n) with
| None ->
(* L'identifiant n'est pas trouvé dans la tds globale. *)
raise (IdentifiantNonDeclare (string_of_affectable n))
| Some info ->
(* L'identifiant est trouvé dans la tds globale,
il a donc déjà été déclaré. L'information associée est récupérée. *)
let ne = analyse_tds_expression tds e in
let n_a = analyse_tds_affectable tds a true in
match aff with
| Dref a ->
Affectation (n_a, ne)
| Ident(n) ->
begin
match info_ast_to_info info with
| InfoVar _ ->
(* Vérification de la bonne utilisation des identifiants dans l'expression *)
(* et obtention de l'expression transformée *)
let ne = analyse_tds_expression tds e in
(* Renvoie de la nouvelle affectation où le nom a été remplacé par l'information
et l'expression remplacée par l'expression issue de l'analyse *)
Affectation (info, ne)
| _ ->
(* Modification d'une constante ou d'une fonction *)
raise (MauvaiseUtilisationIdentifiant (string_of_affectable n))
match chercherGlobalement tds n with
| None ->
(* L'identifiant n'est pas trouvé dans la tds globale. *)
raise (IdentifiantNonDeclare n)
| Some info ->
(* L'identifiant est trouvé dans la tds globale,
il a donc déjà été déclaré. L'information associée est récupérée. *)
begin
match info_ast_to_info info with
| InfoVar _ ->
(* Renvoie de la nouvelle affectation où le nom a été remplacé par l'information
et l'expression remplacée par l'expression issue de l'analyse *)
Affectation (n_a, ne)
| _ ->
(* Modification d'une constante ou d'une fonction *)
raise (MauvaiseUtilisationIdentifiant n)
end
end
end
| AstSyntax.Constante (n,v) ->

87
src/passeTypeRat.ml
View file

@ -12,6 +12,41 @@ struct
type t2 = Ast.AstType.programme
let rec analyse_type_affectable a =
match a with
| AstTds.Dref(a) ->
begin
match (analyse_type_affectable a) with
| (na, Pointeur t) -> (AstType.Dref(na), t)
| _ -> failwith "jsp koi mettre ici"
end
| AstTds.Ident(info) ->
begin
match info_ast_to_info info with
| InfoVar(_, t, _, _) -> (AstType.Ident(info), t)
| InfoConst _ -> (AstType.Ident(info), Int)
| InfoFun _ -> failwith "c chelou frr"
end
(*
let rec analyse_type_affectable (aff:AstTds.affectable) : (affectable*typ) =
match aff with
| AstTds.Ident info ->
begin
match info_ast_to_info info with
| InfoVar (_,t,_,_) -> (Ident info, t)
| InfoConst _ -> (Ident info, Int)
| _ -> failwith ("Erreur interne : symbole non reconnnu")
end
| AstTds.Valeur aff ->
begin
match analyse_type_affectable aff with
| (naff, Pointeur t) -> (Valeur(naff, t),t)
| _ -> raise PasUnPointeur
end
*)
(* analyse_tds_expression : AstTds.expression -> (AstType.expression, type) *)
(* Paramètre tds : la table des symboles courante *)
(* Paramètre e : l'expression à analyser *)
@ -60,18 +95,22 @@ let rec analyse_type_expression e =
| _, _, _ -> raise (TypeBinaireInattendu(b, t1, t2))
end
| AstTds.Ident(info) ->
begin
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)
| AstTds.Entier(i) -> (AstType.Entier(i), Int)
| AstTds.Affectable(a) ->
let (n_a, n_t) = analyse_type_affectable a in
(AstType.Affectable(n_a), n_t)
| AstTds.Null -> (AstType.Null, Pointeur(Undefined))
| AstTds.NewType(t) -> (AstType.NewType(t), Pointeur(t))
| AstTds.Adresse(info) ->
let _ = modifier_type_info Int info in
(AstType.Adresse(info), Int)
(* analyse_tds_instruction : AstTds.instruction -> tds -> AstType.instruction *)
(* Paramètre tds : la table des symboles courante *)
(* Paramètre i : l'instruction à analyser *)
@ -89,17 +128,27 @@ let rec analyse_type_instruction opt i =
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.Affectation (aff, e) ->
let (ne, nt) = analyse_type_expression e in
begin
match aff with
| Dref a ->
begin
match (analyse_type_affectable a) with
| (na, Pointeur t) -> AstType.Affectation(na, ne)
| _ -> failwith "jsp koi mettre ici"
end
| AstTds.Ident info ->
begin
match (info_ast_to_info info) with
| InfoVar(_, t, _, _) ->
if est_compatible t nt then
AstType.Affectation(AstType.Ident(info), ne)
else
raise (TypeInattendu(nt, t))
| _ -> failwith "wut"
end
end
| AstTds.Affichage e ->
begin

7
src/printerAst.ml
View file

@ -50,11 +50,16 @@ struct
| Equ -> "= "
| Inf -> "< "
(* Conversion des affectables *)
let rec string_of_affectable a =
match a with
| AstSyntax.Dref(n) -> (string_of_affectable n)
| AstSyntax.Ident(n) -> n ^ " "
(* Conversion des expressions *)
let rec string_of_expression e =
match e with
| AppelFonction (n,le) -> "call "^n^"("^((List.fold_right (fun i tq -> (string_of_expression i)^tq) le ""))^") "
| Ident n -> n^" "
| Booleen b -> if b then "true " else "false "
| Entier i -> (string_of_int i)^" "
| Unaire (op,e1) -> (string_of_unaire op) ^ (string_of_expression e1)^" "

3
src/tds.ml
View file

@ -346,5 +346,4 @@ let%test _ =
match info_ast_to_info ia with
| InfoVar ("x", Rat, 10 , "LB") -> true
| _ -> false

0
src/testPlacement.ml → src/testPlacement.ml.bak
View file

0
src/testTDS.ml → src/testTDS.ml.bak
View file

0
src/testTam.ml → src/testTam.ml.bak
View file

0
src/testType.ml → src/testType.ml.bak
View file