From 1b3af051b37285764731d2969369ffb95fcc53f4 Mon Sep 17 00:00:00 2001 From: Antoine Grimod Date: Fri, 16 Dec 2022 00:02:48 +0100 Subject: [PATCH 01/11] adding automaton translation pass to list of executed passes --- src/main.ml | 3 ++- src/passes.ml | 4 ++++ src/test.node | 1 - 3 files changed, 6 insertions(+), 2 deletions(-) diff --git a/src/main.ml b/src/main.ml index 450e81d..06434d7 100644 --- a/src/main.ml +++ b/src/main.ml @@ -25,7 +25,7 @@ let exec_passes ast main_fn verbose debug passes f = let _ = (** Usage and argument parsing. *) - let default_passes = ["pre2vars"; "linearization"; "equations_ordering"] in + let default_passes = ["pre2vars"; "automata_translation"; "linearization"; "equations_ordering"] in let sanity_passes = ["chkvar_init_unicity"; "check_typing"] in let usage_msg = "Usage: main [-passes p1,...,pn] [-ast] [-verbose] [-debug] \ @@ -67,6 +67,7 @@ let _ = [ ("pre2vars", Passes.pre2vars); ("chkvar_init_unicity", Passes.chkvar_init_unicity); + ("automata_translation", Passes.automata_translation_pass); ("linearization", Passes.pass_linearization); ("equations_ordering", Passes.pass_eq_reordering); ("check_typing", Passes.pass_typing); diff --git a/src/passes.ml b/src/passes.ml index ad8ff30..e711189 100644 --- a/src/passes.ml +++ b/src/passes.ml @@ -426,3 +426,7 @@ let automata_trans_pass debug (node:t_node) : t_node option= n_automata = node.n_automata; } +let automata_translation_pass verbose debug main_fn = + node_pass (automata_trans_pass debug) + + diff --git a/src/test.node b/src/test.node index ef459bb..5b65c18 100644 --- a/src/test.node +++ b/src/test.node @@ -1,5 +1,4 @@ node diagonal_int (i: int) returns (o1, o2 : int); -var i: int; let (o1, o2) = (i, i); tel From 6af9ddf394d1d74d0aac09fc102ca185f3e2f7e8 Mon Sep 17 00:00:00 2001 From: Antoine Grimod Date: Fri, 16 Dec 2022 01:04:09 +0100 Subject: [PATCH 02/11] added pass to check validity of automata and disable flattening of automaton branch because of incorrect code resulting from it --- src/main.ml | 3 ++- src/passes.ml | 61 +++++++++++++++++++++++++++++++-------------------- src/test.node | 5 +++-- 3 files changed, 42 insertions(+), 27 deletions(-) diff --git a/src/main.ml b/src/main.ml index 06434d7..e0c67f3 100644 --- a/src/main.ml +++ b/src/main.ml @@ -25,7 +25,7 @@ let exec_passes ast main_fn verbose debug passes f = let _ = (** Usage and argument parsing. *) - let default_passes = ["pre2vars"; "automata_translation"; "linearization"; "equations_ordering"] in + let default_passes = ["pre2vars"; "automata_validity" ;"automata_translation"; "linearization"; "equations_ordering"] in let sanity_passes = ["chkvar_init_unicity"; "check_typing"] in let usage_msg = "Usage: main [-passes p1,...,pn] [-ast] [-verbose] [-debug] \ @@ -68,6 +68,7 @@ let _ = ("pre2vars", Passes.pre2vars); ("chkvar_init_unicity", Passes.chkvar_init_unicity); ("automata_translation", Passes.automata_translation_pass); + ("automata_validity", Passes.check_automata_validity); ("linearization", Passes.pass_linearization); ("equations_ordering", Passes.pass_eq_reordering); ("check_typing", Passes.pass_typing); diff --git a/src/passes.ml b/src/passes.ml index e711189..6c721a3 100644 --- a/src/passes.ml +++ b/src/passes.ml @@ -295,28 +295,35 @@ let pass_typing verbose debug main_fn ast = else None in aux ast -let check_automaton_branch_vars automaton = - let (init, states) = automaton in - let left_side = Hashtbl.create 10 in +let check_automata_validity verbos debug main_fn = + let check_automaton_branch_vars automaton = + let (init, states) = automaton in + let left_side = Hashtbl.create 10 in - let rec init_left_side eqlist = match eqlist with - | [] -> () - | (varlist, exp)::q -> - begin - Hashtbl.add left_side varlist true; - init_left_side q; - end + let rec init_left_side eqlist = match eqlist with + | [] -> () + | (varlist, exp)::q -> + begin + Hashtbl.add left_side varlist true; + init_left_side q; + end + in + let check_state s = match s with + | State(name, eqs, cond, next) -> + List.for_all (fun (varlist, exp) -> (Hashtbl.mem left_side varlist)) eqs + in + begin + match init with | State(name, eqs, cond, next) -> init_left_side eqs; + let validity = List.for_all (fun s -> (check_state s)) states in + if not validity then + failwith "Automaton branch has different variables assignment in different branches" + end in - let check_state s = match s with - | State(name, eqs, cond, next) -> - List.for_all (fun (varlist, exp) -> (Hashtbl.mem left_side varlist)) eqs + let aux node = + List.iter check_automaton_branch_vars node.n_automata; + Some node in - begin - match init with | State(name, eqs, cond, next) -> init_left_side eqs; - let validity = List.for_all (fun s -> (check_state s)) states in - if not validity then - failwith "Automaton branch has different variables assignment in different branches" - end + node_pass aux let automaton_translation debug automaton = let gathered = Hashtbl.create 10 in @@ -331,7 +338,7 @@ let automaton_translation debug automaton = let rec init_state_translation states c = match states with | [] -> () | State(name, _, _, _)::q -> - Hashtbl.replace state_to_int name c; (init_state_translation q c) + Hashtbl.replace state_to_int name c; (init_state_translation q (c+1)) in let rec find_state name = @@ -350,14 +357,20 @@ let automaton_translation debug automaton = let flatten_state state = match state with | State(name, eq, cond, next) -> + (* Flattening is not possible + for example a branch where x,y = 1, 2 will be unpacked + when in another branch x, y = f(z) will not be unpacked + *) + (* let new_equations = List.flatten begin List.map (tpl debug) eq end in - equation_pass name new_equations; - State(name, new_equations, cond, next) + *) + equation_pass name eq; + State(name, eq, cond, next) in let rec transition_eq states s = @@ -399,7 +412,7 @@ let automaton_translation debug automaton = let (init, states) = flatten_automaton automaton in let s = create_automaton_name () in init_state_translation states 1; - let exp_transition = transition_eq states s in + let exp_transition = EBinOp([TInt], BOp_arrow, EConst([TInt], CInt(1)), EMonOp([TInt], MOp_pre, transition_eq states s)) in let new_equations = [(([TInt], [IVar(s)]), exp_transition)] in Hashtbl.fold (fun var explist acc -> (var, translate_var s var explist)::acc) gathered new_equations, IVar(s) @@ -423,7 +436,7 @@ let automata_trans_pass debug (node:t_node) : t_node option= n_outputs = node.n_outputs; n_local_vars = (new_ty@ty, vars@loc_vars); n_equations = eqs@node.n_equations; - n_automata = node.n_automata; + n_automata = []; (* not needed anymore *) } let automata_translation_pass verbose debug main_fn = diff --git a/src/test.node b/src/test.node index 5b65c18..03d9db8 100644 --- a/src/test.node +++ b/src/test.node @@ -12,9 +12,10 @@ let tel node auto (i: int) returns (o : int); +var x, y:int; let automaton - | Incr -> do o = (pre o) + 1; done - | Decr -> do o = (pre o) - 1; done + | Incr -> do (o,x) = (0 fby o + 1, 2); done + | Decr -> do (o,x) = diagonal_int(0 fby o); done tel From 9987922e0f080ce5bd74249360127a42fd1b8354 Mon Sep 17 00:00:00 2001 From: dsac Date: Fri, 16 Dec 2022 07:47:20 +0100 Subject: [PATCH 03/11] [passes] linearization of pre (wip) --- src/passes.ml | 59 +++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 53 insertions(+), 6 deletions(-) diff --git a/src/passes.ml b/src/passes.ml index 9fdffda..b60c590 100644 --- a/src/passes.ml +++ b/src/passes.ml @@ -137,9 +137,9 @@ let chkvar_init_unicity verbose debug main_fn : t_nodelist -> t_nodelist option in let add_var_in = add_var 1 in let add_var_loc = add_var 0 in - List.iter add_var_in (snd node.n_inputs); List.iter add_var_loc (snd node.n_outputs); List.iter add_var_loc (snd node.n_local_vars); + List.iter add_var_in (snd node.n_inputs); (** Usual Equations *) incr_eqlist h node.n_equations; if check_now h = false @@ -157,6 +157,47 @@ let chkvar_init_unicity verbose debug main_fn : t_nodelist -> t_nodelist option let pass_linearization verbose debug main_fn = let node_lin (node: t_node): t_node option = + let pre_aux_expression b vars expr: t_eqlist * t_varlist * t_expression = + match expr with + | EVar _ -> [], vars, expr + | EMonOp of full_ty * monop * t_expression -> (** TODO! *) + | EBinOp (t, op, e, e') -> + let eqs, vars, e = pre_aux_expression false vars e in + let eqs', vars, e' = pre_aux_expression false vars e' in + eqs @ eqs', vars, EBinOp (t, op, e, e') + | ETriOp (t, op, e, e', e'') -> + let eqs, vars, e = pre_aux_expression false vars e in + let eqs', vars, e' = pre_aux_expression false vars e' in + let eqs'', vars, e'' = pre_aux_expression false vars e'' in + eqs @ eqs' @ eqs'', vars, ETriOp (t, op, e, e', e'') + | EComp (t, op, e, e') -> + let eqs, vars, e = pre_aux_expression false vars e in + let eqs', vars, e' = pre_aux_expression false vars e' in + eqs @ eqs', vars, EComp (t, op, e, e') + | EWhen (t, e, e') -> + let eqs, vars, e = pre_aux_expression false vars e in + let eqs', vars, e' = pre_aux_expression false vars e' in + eqs @ eqs', vars, EWhen (t, e, e') + | EReset (t, e, e') -> + let eqs, vars, e = pre_aux_expression false vars e in + let eqs', vars, e' = pre_aux_expression false vars e' in + eqs @ eqs', vars, EReset (t, e, e') + | EConst _ -> [], vars, expr + (** TODO!*) + | ETuple (t, l) -> + let eqs, vars, l = List.fold_right + (fun e (eqs, vars, l) -> + let eqs', vars, e = pre_aux_expression false vars e in + eqs' @ eqs, vars, (e :: l)) + l ([], vars, []) in + eqs, vars, ETuple (t, l) + | EApp (t, n, e) -> + let eqs, vars, e = pre_aux_expression false vars e in + eqs, vars, EApp (t, n, e) + in + let rec pre_aux_equation (vars: t_varlist) (eq: t_equation) = + [], ([], []) + in let rec tpl ((pat, exp): t_equation) = match exp with | ETuple (_, hexps :: texps) -> @@ -173,13 +214,19 @@ let pass_linearization verbose debug main_fn = | ETuple (_, []) -> [] | _ -> [(pat, exp)] in - let new_locvars = node.n_local_vars in let new_equations = List.flatten - begin - List.map + (List.map tpl - node.n_equations - end in + node.n_equations) + in + let new_equations, new_locvars = + List.fold_left + (fun (eqs, vars) eq -> + let es, vs = pre_aux_equation vars eq in + es @ eqs, ((fst vs) @ (fst vars), (snd vs) @ (snd vars))) + (new_equations, node.n_local_vars) + new_equations + in Some { n_name = node.n_name; From d7f0f148e9f8a1554f373c235c7ce5e1b5c5f642 Mon Sep 17 00:00:00 2001 From: Arnaud DABY-SEESARAM Date: Fri, 16 Dec 2022 08:52:48 +0100 Subject: [PATCH 04/11] [pre linearization] done, not tested --- src/passes.ml | 53 ++++++++++++++++++++++++++++++++++----------------- 1 file changed, 36 insertions(+), 17 deletions(-) diff --git a/src/passes.ml b/src/passes.ml index b60c590..c206cce 100644 --- a/src/passes.ml +++ b/src/passes.ml @@ -157,46 +157,65 @@ let chkvar_init_unicity verbose debug main_fn : t_nodelist -> t_nodelist option let pass_linearization verbose debug main_fn = let node_lin (node: t_node): t_node option = - let pre_aux_expression b vars expr: t_eqlist * t_varlist * t_expression = + let rec pre_aux_expression vars expr: t_eqlist * t_varlist * t_expression = match expr with | EVar _ -> [], vars, expr - | EMonOp of full_ty * monop * t_expression -> (** TODO! *) + | EMonOp (t, op, e) -> + begin + match op with + | MOp_pre -> + let eqs, vars, e = pre_aux_expression vars e in + let nvar: string = fresh_var_name vars 6 in + let nvar = match t with + | [TInt] -> IVar nvar + | [TBool] -> BVar nvar + | [TReal] -> RVar nvar + | _ -> failwith "Should not happened." in + let neq_patt: t_varlist = (t, [nvar]) in + let neq_expr: t_expression = EMonOp (t, MOp_pre, e) in + let vars = varlist_concat (t, [nvar]) vars in + (neq_patt, neq_expr) :: eqs, vars, EVar (t, nvar) + | _ -> + let eqs, vars, e = pre_aux_expression vars e in + eqs, vars, EMonOp (t, op, e) + end | EBinOp (t, op, e, e') -> - let eqs, vars, e = pre_aux_expression false vars e in - let eqs', vars, e' = pre_aux_expression false vars e' in + let eqs, vars, e = pre_aux_expression vars e in + let eqs', vars, e' = pre_aux_expression vars e' in eqs @ eqs', vars, EBinOp (t, op, e, e') | ETriOp (t, op, e, e', e'') -> - let eqs, vars, e = pre_aux_expression false vars e in - let eqs', vars, e' = pre_aux_expression false vars e' in - let eqs'', vars, e'' = pre_aux_expression false vars e'' in + let eqs, vars, e = pre_aux_expression vars e in + let eqs', vars, e' = pre_aux_expression vars e' in + let eqs'', vars, e'' = pre_aux_expression vars e'' in eqs @ eqs' @ eqs'', vars, ETriOp (t, op, e, e', e'') | EComp (t, op, e, e') -> - let eqs, vars, e = pre_aux_expression false vars e in - let eqs', vars, e' = pre_aux_expression false vars e' in + let eqs, vars, e = pre_aux_expression vars e in + let eqs', vars, e' = pre_aux_expression vars e' in eqs @ eqs', vars, EComp (t, op, e, e') | EWhen (t, e, e') -> - let eqs, vars, e = pre_aux_expression false vars e in - let eqs', vars, e' = pre_aux_expression false vars e' in + let eqs, vars, e = pre_aux_expression vars e in + let eqs', vars, e' = pre_aux_expression vars e' in eqs @ eqs', vars, EWhen (t, e, e') | EReset (t, e, e') -> - let eqs, vars, e = pre_aux_expression false vars e in - let eqs', vars, e' = pre_aux_expression false vars e' in + let eqs, vars, e = pre_aux_expression vars e in + let eqs', vars, e' = pre_aux_expression vars e' in eqs @ eqs', vars, EReset (t, e, e') | EConst _ -> [], vars, expr - (** TODO!*) | ETuple (t, l) -> let eqs, vars, l = List.fold_right (fun e (eqs, vars, l) -> - let eqs', vars, e = pre_aux_expression false vars e in + let eqs', vars, e = pre_aux_expression vars e in eqs' @ eqs, vars, (e :: l)) l ([], vars, []) in eqs, vars, ETuple (t, l) | EApp (t, n, e) -> - let eqs, vars, e = pre_aux_expression false vars e in + let eqs, vars, e = pre_aux_expression vars e in eqs, vars, EApp (t, n, e) in let rec pre_aux_equation (vars: t_varlist) (eq: t_equation) = - [], ([], []) + let (patt, expr) = eq in + let eqs, vars, expr = pre_aux_expression vars expr in + (patt, expr)::eqs, vars in let rec tpl ((pat, exp): t_equation) = match exp with From c7a97f3305f8a673ede6e6eb867f335eadf698dc Mon Sep 17 00:00:00 2001 From: Arnaud DABY-SEESARAM Date: Fri, 16 Dec 2022 09:00:03 +0100 Subject: [PATCH 05/11] [passes] linearization: merge fix --- src/passes.ml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/passes.ml b/src/passes.ml index a043d18..e31b3b3 100644 --- a/src/passes.ml +++ b/src/passes.ml @@ -267,7 +267,7 @@ let pass_linearization verbose debug main_fn = n_name = node.n_name; n_inputs = node.n_inputs; n_outputs = node.n_outputs; - n_local_vars = node.n_local_vars; + n_local_vars = new_locvars; n_equations = new_equations; n_automata = node.n_automata; } From 7c2c43fe2422402d2ae36fe4404d922e620b6c5f Mon Sep 17 00:00:00 2001 From: Benjamin Loison Date: Fri, 16 Dec 2022 01:20:42 +0100 Subject: [PATCH 06/11] Precise to what extent considering integers work fine with working with floats instead --- src/ast_to_c.ml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ast_to_c.ml b/src/ast_to_c.ml index ff4e5f7..0390814 100644 --- a/src/ast_to_c.ml +++ b/src/ast_to_c.ml @@ -199,7 +199,7 @@ let rec pp_equations node_name fmt: t_eqlist -> unit = function (* By prepending to the `Format.formatter` `fmt` we could just declare these arrays once with a size of the maximum `reset_expressions_counter` *) let pp_resvars reset_expressions_counter = - (* use the fact that any boolean and any integer can be encoded as a float *) + (* use the fact that any boolean and any integer can be encoded as a float, concerning integers [-2^(23+1) + 1; 2^(23+1) + 1] are correctly encoded (cf https://stackoverflow.com/a/53254438) *) Format.sprintf "float tmp_reset[%i], init[%i];" reset_expressions_counter reset_expressions_counter (* TODO: manage general outputs *) From 3417d75620fd1b45788838154cfbc1be0c9d1493 Mon Sep 17 00:00:00 2001 From: Arnaud DABY-SEESARAM Date: Fri, 16 Dec 2022 09:44:22 +0100 Subject: [PATCH 07/11] [passes] linearisation: correction (10 -> pre (20 -> 30)) works --- src/main.ml | 2 +- src/passes.ml | 9 ++++----- src/test2.node | 7 ++----- 3 files changed, 7 insertions(+), 11 deletions(-) diff --git a/src/main.ml b/src/main.ml index e0c67f3..3652564 100644 --- a/src/main.ml +++ b/src/main.ml @@ -25,7 +25,7 @@ let exec_passes ast main_fn verbose debug passes f = let _ = (** Usage and argument parsing. *) - let default_passes = ["pre2vars"; "automata_validity" ;"automata_translation"; "linearization"; "equations_ordering"] in + let default_passes = ["automata_validity" ;"automata_translation"; "linearization"; "pre2vars"; "equations_ordering"] in let sanity_passes = ["chkvar_init_unicity"; "check_typing"] in let usage_msg = "Usage: main [-passes p1,...,pn] [-ast] [-verbose] [-debug] \ diff --git a/src/passes.ml b/src/passes.ml index e31b3b3..e1ae5a9 100644 --- a/src/passes.ml +++ b/src/passes.ml @@ -188,9 +188,9 @@ let pass_linearization verbose debug main_fn = | [TReal] -> RVar nvar | _ -> failwith "Should not happened." in let neq_patt: t_varlist = (t, [nvar]) in - let neq_expr: t_expression = EMonOp (t, MOp_pre, e) in + let neq_expr: t_expression = e in let vars = varlist_concat (t, [nvar]) vars in - (neq_patt, neq_expr) :: eqs, vars, EVar (t, nvar) + (neq_patt, neq_expr) :: eqs, vars, EMonOp (t, MOp_pre, EVar (t, nvar)) | _ -> let eqs, vars, e = pre_aux_expression vars e in eqs, vars, EMonOp (t, op, e) @@ -228,8 +228,7 @@ let pass_linearization verbose debug main_fn = let eqs, vars, e = pre_aux_expression vars e in eqs, vars, EApp (t, n, e) in - let rec pre_aux_equation (vars: t_varlist) (eq: t_equation) = - let (patt, expr) = eq in + let rec pre_aux_equation (vars: t_varlist) ((patt, expr): t_equation) = let eqs, vars, expr = pre_aux_expression vars expr in (patt, expr)::eqs, vars in @@ -259,7 +258,7 @@ let pass_linearization verbose debug main_fn = (fun (eqs, vars) eq -> let es, vs = pre_aux_equation vars eq in es @ eqs, ((fst vs) @ (fst vars), (snd vs) @ (snd vars))) - (new_equations, node.n_local_vars) + ([], node.n_local_vars) new_equations in Some diff --git a/src/test2.node b/src/test2.node index 36209a1..2116ba7 100644 --- a/src/test2.node +++ b/src/test2.node @@ -1,7 +1,4 @@ -node diagonal_int (i: int) returns (o1, o2 : int); -var y: int; +node main (i: int) returns (o1: int); let - o2 = y; - y = i; - o1 = i; + o1 = 10 -> pre (20 -> 30); tel From 3fa0f92233b9f68b3ef6f5f8e227af2f58b3c26d Mon Sep 17 00:00:00 2001 From: Arnaud DABY-SEESARAM Date: Fri, 16 Dec 2022 10:45:20 +0100 Subject: [PATCH 08/11] [beamer] A few straight forward slides added --- beamer/beamer.tex | 56 +++++++++++++++++++++++++++++------------------ 1 file changed, 35 insertions(+), 21 deletions(-) diff --git a/beamer/beamer.tex b/beamer/beamer.tex index 445a780..b460a99 100644 --- a/beamer/beamer.tex +++ b/beamer/beamer.tex @@ -97,35 +97,49 @@ \section{Passes} \begin{frame}{Passes} - \begin{block}{Classification} - The passes of our compiler are functions of taking a program and either: + \begin{block}{Sanity checks} \begin{itemize} - \item returning a program if the pass succeeded - \item returns nothing otherwise + \item Check the well-typedness of a program + \item Check that there are no assignment conflicts in a programs + \end{itemize} + \end{block} + \begin{block}{AST modification} + \begin{itemize} + \item Rewrite automata into \texttt{if-then-else} constructs + \item Linearization of the equations + \item (no longer required) Push the \texttt{pre} to variables \end{itemize} - - We only have one language in our compiler: no intermediary language. \end{block} \end{frame} -\subsection{Check} +\section{Translation to C} \begin{frame} - \begin{block}{Passes} - The passes can be split into: - \begin{itemize} - \item those checking the program validity - \item those modifying the AST of the program - \end{itemize} - \end{block} + \centerline{\Huge TODO $\boxed{\ddot\smile}$} \end{frame} -\begin{frame}{Implemented passes} - \begin{block}{\texttt{pre}-propagation to leaves} - \end{block} - \begin{block}{Check: unique initialization for variables} - \end{block} - \begin{block}{Linearization of the equations} - \end{block} +\section{Tests} +\begin{frame}{Tests} + \begin{block}{testing methods} + We thought of three testing methods: + \begin{itemize} + \item manual testing of our functionalities + \item run the sanity-checks-passes after any AST-altering pass + \item simulation of the nodes (aborted) + \end{itemize} + \end{block} +\end{frame} + +\section{Possible improvements} +\begin{frame}{Improvements} + \begin{itemize} + \item Increase the expressivity of the accepted programs + \item Improve the complexity of the different passes + \begin{itemize} + \item Group neighbour passes of the same type (node-, expression or + equation-pass). + \end{itemize} + \item \dots{} + \end{itemize} \end{frame} \end{document} From c37e819f1a301b0ed9deb8a12d227cb1b83f57a1 Mon Sep 17 00:00:00 2001 From: Benjamin Loison Date: Fri, 16 Dec 2022 05:06:27 +0100 Subject: [PATCH 09/11] Add a title frame to the beamer --- beamer/beamer.tex | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/beamer/beamer.tex b/beamer/beamer.tex index b460a99..7606b00 100644 --- a/beamer/beamer.tex +++ b/beamer/beamer.tex @@ -6,6 +6,13 @@ \begin{document} +\title{Presentation of our Lustre-to-C compiler} +%\subtitle{} +\date{16 December 2022} +\author{Benjamin Loison, Arnaud Daby-Seesaram, Antoine Grimod} + +\frame{\titlepage} + \section{Structure of the compiler} \begin{frame}{Main ideas} \begin{figure} From 21414e6461c85ea20a9cf0d19bb2c5b3e4a989e9 Mon Sep 17 00:00:00 2001 From: Benjamin Loison Date: Fri, 16 Dec 2022 05:54:41 +0100 Subject: [PATCH 10/11] Make last equation of a node potentially not ending with a semi column Otherwise the following code: ``` -- count the number of top between two tick node counting (tick:bool; top:bool) returns (o: bool); var v: int; let o = if tick then v else 0 -> pre o + v; v = if top then 1 else 0 tel; ``` was involving the following error: ``` Syntax error at ``` --- src/parser.mly | 1 + 1 file changed, 1 insertion(+) diff --git a/src/parser.mly b/src/parser.mly index 134a77d..f5b92d5 100644 --- a/src/parser.mly +++ b/src/parser.mly @@ -276,6 +276,7 @@ equations: | /* empty */ { [] } | equation SEMICOL equations { $1 :: $3 } + | equation OPTIONAL_SEMICOL { [$1] } ; equation: From 57dd9c1aa4244daca2dd95f145be1240cadd2774 Mon Sep 17 00:00:00 2001 From: Arnaud DABY-SEESARAM Date: Fri, 16 Dec 2022 14:16:00 +0100 Subject: [PATCH 11/11] [passes] linearozation: avoir duplication of variables --- src/passes.ml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/passes.ml b/src/passes.ml index e1ae5a9..2918d32 100644 --- a/src/passes.ml +++ b/src/passes.ml @@ -257,7 +257,7 @@ let pass_linearization verbose debug main_fn = List.fold_left (fun (eqs, vars) eq -> let es, vs = pre_aux_equation vars eq in - es @ eqs, ((fst vs) @ (fst vars), (snd vs) @ (snd vars))) + es @ eqs, vars) ([], node.n_local_vars) new_equations in