From c7c9b0c35182d9af037980a025d9a0f3658ae63a Mon Sep 17 00:00:00 2001 From: Nicolas PENELOUX Date: Mon, 13 Nov 2023 17:47:48 +0100 Subject: [PATCH] formats, ajout commentaires et makefile --- flap/src/hopix/hopixInterpreter.ml | 209 ++++++++++++++++++----------- flap/tests/Makefile | 3 +- 2 files changed, 132 insertions(+), 80 deletions(-) diff --git a/flap/src/hopix/hopixInterpreter.ml b/flap/src/hopix/hopixInterpreter.ml index 7f25a5a..9a6f500 100644 --- a/flap/src/hopix/hopixInterpreter.ml +++ b/flap/src/hopix/hopixInterpreter.ml @@ -387,9 +387,7 @@ and expression' environment memory e = and E = [runtime.environment], M = [runtime.memory]. *) and expression pos environment memory = function | Literal l -> literal_expression l.value - | Variable (id, _) -> - (* On cherche l'id dans l'environnement *) - Environment.lookup id.position id.value environment + | Variable (id, _) -> variable_value id environment | Tagged (constructor, _, list_t) -> (* On ignore le type car on interprète *) VTagged (constructor.value, List.map (expression' environment memory) list_t) @@ -397,40 +395,21 @@ and expression pos environment memory = function VRecord (List.map (pair_labels_gvalue environment memory) labels) | Field (expr, label, _) -> field_value expr label environment memory (* On ignore la liste de type *) - | Tuple [] -> - (* Cas pour le Tuple vide - * Un tuple vide ne contient rien (logique), donc on utilise un VUnit*) + | Tuple [] -> (* Cas pour le Tuple vide. Un tuple vide ne contient rien (logique), donc on utilise un VUnit*) VUnit - | Tuple list_exp -> VTuple (List.map (expression' environment memory) list_exp) - (* Sequence : on evalue chaque expression, - * puis on récupère la dernière à avoir été évalué. - * Le dernier élément se trouve facilement en faisant un reverse de liste - * et en récupérant la tête. *) - | Sequence list_expr -> - let vs = List.map (expression' environment memory) list_expr in - List.hd (List.rev vs) - | Define (value_def, expr) -> - let runtime = value_definition { environment; memory } value_def in - expression' runtime.environment runtime.memory expr + | Tuple list_expr -> + tuple_value list_expr environment memory + | Sequence list_expr -> + sequence_value list_expr environment memory + | Define (value_def, expr) -> + define_value value_def expr environment memory | Fun (FunctionDefinition (pattern, expr)) -> VClosure (environment, pattern, expr) | Apply (f, x) -> apply_expression f x environment memory - | Ref ref -> - let dref = expression' environment memory ref in - VLocation (Memory.allocate memory Mint.one dref) + | Ref ref -> ref_value ref environment memory | Assign (expr1, expr2) -> - assign_value expr1 expr2 environment memory; - VUnit - | Read read -> - let loc = value_as_location (expression' environment memory read) in - (match loc with - | Some adr -> - Memory.read (Memory.dereference memory adr) Mint.zero - (* On lis la valeur de la mémoire *) - | None -> - (* TODO : faire une vrai erreur *) - failwith "erreur") + assign_value expr1 expr2 environment memory; VUnit + | Read read -> read_value read environment memory | Case (expr, branches) -> - (* TODO *) case_value expr branches environment memory | IfThenElse (expr1, expr2, expr3) -> if_then_else_value expr1 expr2 expr3 environment memory @@ -439,6 +418,43 @@ and expression pos environment memory = function | TypeAnnotation _ -> VUnit (* On ignore le type car on interprète *) +(* Variable : On cherche la variable dans l'environnement *) +and variable_value id environment = + Environment.lookup id.position id.value environment + + (* Tuple : On applique à chaque expression de la liste l'opération de calcul de sa valeur *) +and tuple_value list_expr environment memory = + VTuple (List.map (expression' environment memory) list_expr) + +(* Sequence : on evalue chaque expression, + * puis on récupère la dernière à avoir été évalué. + * Le dernier élément se trouve facilement en faisant un reverse de liste + * et en récupérant la tête. *) +and sequence_value list_expr environment memory = + let vs = List.map (expression' environment memory) list_expr in + List.hd (List.rev vs) + +(*Define : On évalue la définition local puis on en fait un nouveau runtime et on calcule la valeur de l'expression. *) +and define_value value_def expr environment memory = + let runtime = value_definition { environment; memory } value_def in + expression' runtime.environment runtime.memory expr + +(* Reference : On alloue de la mémoire pour le résultat du calcul de l'expression *) +and ref_value ref environment memory = + let dref = expression' environment memory ref in + VLocation (Memory.allocate memory Mint.one dref) + +(* Lecture : On va lire l'espace mémoire *) +and read_value read environment memory = + let loc = value_as_location (expression' environment memory read) in + (match loc with + | Some adr -> + Memory.read (Memory.dereference memory adr) Mint.zero + (* On lis la valeur de la mémoire *) + | None -> error [position read] "Erreur read") + +(* Case : On effectue le pattern matching des branches associés à notre case, + * et on renvoie l'environnement modifié après avoir calculer toute les branches. *) and case_value expr branches environment memory = (* On calcule d'abord l'expression *) let expr' = expression' environment memory expr in @@ -462,7 +478,7 @@ and case_value expr branches environment memory = | [] -> error [ expr.position ] "erreur" | _ as env -> List.hd env - + (* For : On va calculer les valeurs de l'expression (ici expr3) à chaque itération de la boucle *) and for_value id expr1 expr2 expr3 environment memory = let borne_inf = value_as_int (expression' environment memory expr1) in let borne_sup = value_as_int (expression' environment memory expr2) in @@ -501,9 +517,9 @@ and assign_calcul environment memory expr2 v = let mem = Memory.dereference memory v in Memory.write mem Mint.zero value -and pair_labels_gvalue environment memory (lab, expr) = - Position.value lab, expression' environment memory expr +(*While : Tant que la condition (valeur de l'expression 1) est true, alors on calcule l'expression de expression 2 + Sinon, on renvoie un VUnit, qui va stopper le processus d'interprétation pour While. *) and while_value expr1 expr2 environment memory pos = let cond = expression' environment memory expr1 in (* On récupère la valeur de la condition *) @@ -513,6 +529,8 @@ and while_value expr1 expr2 environment memory pos = expression pos environment memory (While (expr1, expr2)) | false -> VUnit +(* IfThenELse : Comme pour While, on regarde si la condition est vrai, si c'est le cas, + alors on calcule l'expression du "then", sinon celle du "else" *) and if_then_else_value expr1 expr2 expr3 environment memory = let cond = expression' environment memory expr1 in (* On récupère la valeur de la condition *) @@ -522,14 +540,18 @@ and if_then_else_value expr1 expr2 expr3 environment memory = (* Si c'est true, alors on évalue la première expression *) | false -> expression' environment memory expr3 (* sinon la deuxième *) + (* Record : on calcule l'expression, et on associe à chaque élément de la liste la valeur du label *) and field_value expr label environment memory = match expression' environment memory expr with | VRecord record -> List.assoc label.value record | _ -> assert false (* Cas où il n'y a pas de record, donc c'est une erreur *) -and label_gvalue_pair environment memory (label, expr) = - Position.value label, expression' environment memory expr + (* Fonction annexe qui renverra une paire label * valeur de expression *) +and pair_labels_gvalue environment memory (lab, expr) = + Position.value lab, expression' environment memory expr + +(* Apply : on applique la fonction f à x en fonction des différents cas possibles *) and apply_expression f x environment memory = let x_val = expression' environment memory x in match expression' environment memory f with @@ -545,12 +567,19 @@ and apply_expression f x environment memory = | None -> failwith "erreur") | _ -> assert false (* By typing *) +(* Littéraux *) and literal_expression = function | LInt n -> VInt n | LChar c -> VChar c | LString s -> VString s -(* On match le pattern et expression en même temps *) + + + + +(* --------------- PATTERN MATCHING ----------------- *) + + and pattern environment pat expression = match pat, expression with | PWildcard, _ -> wildcard_pattern environment @@ -566,47 +595,32 @@ and pattern environment pat expression = | PAnd pl, _ -> and_pattern environment pl expression | _ -> None -and wildcard_pattern environment = Some environment +(* PWildcard : on renvoie l'environnement sans modification *) +and wildcard_pattern environment = Some environment +(* PVariable : On bind la valeur de la variable ) l'expression dans l'environnement *) and variable_pattern var env expression = Some (Environment.bind env var.value expression) +(* PTypeAnnotation : On calcule le pattern à son tour *) and typeannot_pattern pattern' env expression = pattern env pattern' expression -and and_pattern env pl expression = - match pl with - | [] -> Some env - | p :: pl' -> - let valeur_pattern = p.value in - (match pattern env valeur_pattern expression with - | None -> None - | Some env' -> and_pattern env' pl' expression) - -and or_pattern env pl expression = - match pl with - | [] -> None - | p :: pl' -> - let valeur_pattern = p.value in - (match pattern env valeur_pattern expression with - | Some env' -> Some env' - | None -> or_pattern env pl' expression) - -and tuple_pattern environment tab tab2 = - if List.length tab = List.length tab2 - then ( - match tab, tab2 with - | [], [] -> Some environment - | pat :: tab', expr :: tab2' -> - let valeur_pattern = pat.value in - (match pattern environment valeur_pattern expr with - | Some env' -> tuple_pattern env' tab' tab2' - | None -> None) - | _ -> None) - else None +(* PLiteral : On regarde si la valeur du pattern correspond à celle de l'expression *) +and literal_pattern pl environment expression = + let valeur_literal = pl.value in + let verif_literal l1 l2 = if l1 = l2 then Some environment else None in + match valeur_literal, expression with + | LInt int1, VInt int2 -> verif_literal int1 int2 + | LChar char1, VChar char2 -> verif_literal char1 char2 + | LString str1, VString str2 -> verif_literal str1 str2 + | _ -> None + (* PTagged : On regarde si les deux constructeurs sont égaux, si c'est le cas on calcule + comme si c'était un PTuple, les deux listes de patterns que nous avons *) and tagged_pattern cons1 cons2 pattern1 pattern2 environment = if cons1.value = cons2 then tuple_pattern environment pattern1 pattern2 else None - + (*PRecord On compare les deux records, on essaye de trouver un match pour chaque field + (du premier record) dans le deuxième record, si c'est le cas on met à jour l'env, sinon + On regarde le prochain élément. *) and record_pattern environment r r' = - match r with | [] -> Some environment | field :: reste -> @@ -627,15 +641,52 @@ and record_pattern environment r r' = else record_labbel_pattern environment field reste +(* PTuple : On a deux tuples, qui pour chaque pair d'éléments effectue un pattern matching, et +renvoie le nouvel environnement *) +and tuple_pattern environment tab tab2 = + if List.length tab = List.length tab2 + then ( + match tab, tab2 with + | [], [] -> Some environment + | pat :: tab', expr :: tab2' -> + let valeur_pattern = pat.value in + (match pattern environment valeur_pattern expr with + | Some env' -> tuple_pattern env' tab' tab2' + | None -> None) + | _ -> None) + else None + +(* POr : Renvoie le nouvelle environnement si au moins un des patterns match avec l'expression*) +and or_pattern env pl expression = + match pl with + | [] -> None + | p :: pl' -> + let valeur_pattern = p.value in + (match pattern env valeur_pattern expression with + | Some env' -> Some env' + | None -> or_pattern env pl' expression) + + (* PAnd : de même, mais chaque élément de la liste des patterns doivent matchs avec l'expression*) +and and_pattern env pl expression = + match pl with + | [] -> Some env + | p :: pl' -> + let valeur_pattern = p.value in + (match pattern env valeur_pattern expression with + | None -> None + | Some env' -> and_pattern env' pl' expression) + + + + + + + + + + + -and literal_pattern pl environment expression = - let valeur_literal = pl.value in - let verif_literal l1 l2 = if l1 = l2 then Some environment else None in - match valeur_literal, expression with - | LInt int1, VInt int2 -> verif_literal int1 int2 - | LChar char1, VChar char2 -> verif_literal char1 char2 - | LString str1, VString str2 -> verif_literal str1 str2 - | _ -> None (** This function returns the difference between two runtimes. *) and extract_observable runtime runtime' = diff --git a/flap/tests/Makefile b/flap/tests/Makefile index 4a5fd80..88bab79 100644 --- a/flap/tests/Makefile +++ b/flap/tests/Makefile @@ -1,7 +1,8 @@ FLAP?=../_build/default/src/flap.exe JALONS=\ 01-Parsing.results \ - 01-Parsing-no-positions.results + 01-Parsing-no-positions.results \ + 02-Interpreter.results EXTS=parsing.hopix parsing-no-positions.hopix .PHONY: all clean test FAKE