Nettoyage, suite

src/mlang/backend_compilers/bir_to_dgfip_c.ml

@@ -308,7 +308,7 @@ let rec generate_c_expr (e : Mir.expression Pos.marked)
   | FuncCallLoop _ | Loop _ -> assert false
 
 let generate_m_assign (dgfip_flags : Dgfip_options.flags)
-    (var_indexes : Dgfip_varid.var_id_map) (var : Mir.Var.t) (offset : D.offset)
+    (var_indexes : Dgfip_varid.var_id_map) (var : Com.Var.t) (offset : D.offset)
     (oc : Format.formatter) (se : D.expression_composition) : unit =
   let def_var = D.generate_variable ~def_flag:true var_indexes offset var in
   let val_var = D.generate_variable var_indexes offset var in
@@ -329,17 +329,17 @@ let generate_m_assign (dgfip_flags : Dgfip_options.flags)
       value val_var;
   if dgfip_flags.flg_trace then
     Format.fprintf oc "@;aff2(\"%s\", irdata, %s);"
-      (Pos.unmark var.Mir.Var.name)
+      (Pos.unmark var.Com.Var.name)
       (Dgfip_varid.gen_access_pos_from_start var_indexes var)
 
 let generate_var_def (dgfip_flags : Dgfip_options.flags)
-    (var_indexes : Dgfip_varid.var_id_map) (var : Mir.Var.t)
+    (var_indexes : Dgfip_varid.var_id_map) (var : Com.Var.t)
     (vidx_opt : Mir.expression Pos.marked option)
     (vexpr : Mir.expression Pos.marked) (fmt : Format.formatter) : unit =
   match vidx_opt with
   | None ->
       let se = generate_c_expr vexpr var_indexes in
-      if Mir.Var.is_it var then (
+      if Com.Var.is_it var then (
         let pr form = Format.fprintf fmt form in
         pr "@[<v 2>{";
         let idx = fresh_c_local "idxPROUT" in
@@ -377,9 +377,10 @@ let rec generate_stmt (dgfip_flags : Dgfip_options.flags)
     (program : Mir.program) (var_indexes : Dgfip_varid.var_id_map)
     (oc : Format.formatter) (stmt : Mir.m_instruction) =
   match Pos.unmark stmt with
-  | Affectation (SingleFormula (var, vidx_opt, vexpr), _) ->
+  | Affectation (SingleFormula (m_var, vidx_opt, vexpr), _) ->
       Format.fprintf oc "@[<v 2>{@,";
-      generate_var_def dgfip_flags var_indexes var vidx_opt vexpr oc;
+      generate_var_def dgfip_flags var_indexes (Pos.unmark m_var) vidx_opt vexpr
+        oc;
       Format.fprintf oc "@]@,}"
   | Affectation _ -> assert false
   | IfThenElse (cond, iftrue, iffalse) ->
@@ -429,7 +430,7 @@ let rec generate_stmt (dgfip_flags : Dgfip_options.flags)
       let print_def = print_val ^ "_d" in
       Format.fprintf oc "@[<v 2>{@,char %s;@;double %s;@;" print_def print_val;
       List.iter
-        (fun (arg : Mir.Var.t Com.print_arg Pos.marked) ->
+        (fun (arg : Com.Var.t Com.print_arg Pos.marked) ->
           match Pos.unmark arg with
           | PrintString s ->
               Format.fprintf oc "print_string(%s, %s, \"%s\");@;" print_std
@@ -480,7 +481,8 @@ let rec generate_stmt (dgfip_flags : Dgfip_options.flags)
                 print_std pr_ctx)
         args;
       Format.fprintf oc "@]@;}@;"
-  | Iterate (var, vcs, expr, stmts) ->
+  | Iterate (m_var, vcs, expr, stmts) ->
+      let var = Pos.unmark m_var in
       let it_name = fresh_c_local "iterate" in
       Com.CatVar.Map.iter
         (fun vc _ ->
@@ -520,14 +522,16 @@ let rec generate_stmt (dgfip_flags : Dgfip_options.flags)
       let rest_name = fresh_c_local "restore" in
       Format.fprintf oc "T_env_sauvegarde *%s = NULL;@;" rest_name;
       List.iter
-        (fun v ->
+        (fun m_v ->
+          let v = Pos.unmark m_v in
           Format.fprintf oc "env_sauvegarder(&%s, %s, %s, %s);@;" rest_name
             (Dgfip_varid.gen_access_def_pointer var_indexes v)
             (Dgfip_varid.gen_access_pointer var_indexes v)
             (Dgfip_varid.gen_size var_indexes v))
         vars;
       List.iter
-        (fun (var, vcs, expr) ->
+        (fun (m_var, vcs, expr) ->
+          let var = Pos.unmark m_var in
           let it_name = fresh_c_local "iterate" in
           Com.CatVar.Map.iter
             (fun vc _ ->
@@ -571,7 +575,8 @@ let rec generate_stmt (dgfip_flags : Dgfip_options.flags)
         stmts;
       Format.fprintf oc "env_restaurer(&%s);@;" rest_name;
       Format.fprintf oc "@]}@;"
-  | RaiseError (err, var_opt) ->
+  | RaiseError (m_err, var_opt) ->
+      let err = Pos.unmark m_err in
       let err_name = Pos.unmark err.Com.Error.name in
       let code =
         match var_opt with
@@ -597,7 +602,7 @@ let generate_target_prototype (add_semicolon : bool) (oc : Format.formatter)
     (if add_semicolon then ";" else "")
 
 let generate_var_tmp_decls (oc : Format.formatter)
-    (tmp_vars : (Mir.Var.t * Pos.t * int option) StrMap.t) =
+    (tmp_vars : (Com.Var.t * Pos.t * int option) StrMap.t) =
   StrMap.iter
     (fun vn (_, _, size) ->
       let sz = match size with Some i -> i | None -> 1 in

src/mlang/backend_compilers/bir_to_java.ml

@@ -51,27 +51,27 @@ let generate_binop (op : Com.binop) : string =
 let generate_unop (op : Com.unop) : string =
   match op with Com.Not -> "mNot" | Com.Minus -> "mNeg"
 
-let generate_var_name (var : Mir.Var.t) : string =
+let generate_var_name (var : Com.Var.t) : string =
   let v = Pos.unmark var.name in
   String.uppercase_ascii v
 
-let format_var_name (fmt : Format.formatter) (var : Mir.Var.t) : unit =
+let format_var_name (fmt : Format.formatter) (var : Com.Var.t) : unit =
   Format.fprintf fmt "%s" (generate_var_name var)
 
-let generate_name (v : Mir.Var.t) : string =
-  match Mir.Var.alias v with
+let generate_name (v : Com.Var.t) : string =
+  match Com.Var.alias v with
   | Some v -> Pos.unmark v
   | None -> Pos.unmark v.name
 
 let print_double_cut oc () = Format.fprintf oc "@,@,"
 
-let get_var_pos (_var : Mir.Var.t) : int = 0 (* var.Bir.offset *)
+let get_var_pos (_var : Com.Var.t) : int = 0 (* var.Bir.offset *)
 
-let get_tgv_position (var : Mir.Var.t) : string =
+let get_tgv_position (var : Com.Var.t) : string =
   Format.asprintf "tgv[%d /* %s */]" (get_var_pos var) (generate_var_name var)
 
 let rec generate_java_expr (e : Mir.expression Pos.marked) :
-    string * (Mir.Var.t * Mir.expression Pos.marked) list =
+    string * (Com.Var.t * Mir.expression Pos.marked) list =
   match Pos.unmark e with
   | TestInSet _ -> assert false
   | Comparison (op, e1, e2) ->

src/mlang/backend_compilers/decoupledExpr.ml

@@ -1,12 +1,12 @@
 type offset =
   | GetValueConst of int
   | GetValueExpr of string
-  | GetValueVar of Mir.Var.t
+  | GetValueVar of Com.Var.t
   | PassPointer
   | None
 
 let rec generate_variable (vm : Dgfip_varid.var_id_map) (offset : offset)
-    ?(def_flag = false) ?(debug_flag = false) (var : Mir.Var.t) : string =
+    ?(def_flag = false) ?(debug_flag = false) (var : Com.Var.t) : string =
   try
     match offset with
     | PassPointer ->
@@ -25,15 +25,15 @@ let rec generate_variable (vm : Dgfip_varid.var_id_map) (offset : offset)
         else
           let access_val = Dgfip_varid.gen_access_val vm var offset in
           if debug_flag then
-            let vn = Pos.unmark var.Mir.Var.name in
+            let vn = Pos.unmark var.Com.Var.name in
             let pos_tgv = Dgfip_varid.gen_access_pos_from_start vm var in
             Format.asprintf "(aff3(\"%s\",irdata, %s), %s)" vn pos_tgv
               access_val
           else access_val
   with Not_found ->
     Errors.raise_error
       (Format.asprintf "Variable %s not found in TGV"
-         (Pos.unmark var.Mir.Var.name))
+         (Pos.unmark var.Com.Var.name))
 
 type local_var =
   | Anon (* inlined sub-expression, not intended for reuse *)
@@ -65,11 +65,11 @@ and expr =
   | Dunop of string * expr
   | Dbinop of string * expr * expr
   | Dfun of string * expr list
-  | Daccess of Mir.Var.t * dflag * expr
+  | Daccess of Com.Var.t * dflag * expr
   | Dite of expr * expr * expr
   | Dinstr of string
 
-and expr_var = Local of stack_slot | M of Mir.Var.t * offset * dflag
+and expr_var = Local of stack_slot | M of Com.Var.t * offset * dflag
 
 and t = expr * dflag * local_vars
 
@@ -196,7 +196,7 @@ let dfalse _stacks _lv : t = (Dfalse, Def, [])
 
 let lit (f : float) _stacks _lv : t = (Dlit f, Val, [])
 
-let m_var (v : Mir.Var.t) (offset : offset) (df : dflag) _stacks _lv : t =
+let m_var (v : Com.Var.t) (offset : offset) (df : dflag) _stacks _lv : t =
   (Dvar (M (v, offset, df)), df, [])
 
 let local_var (lvar : local_var) (stacks : local_stacks) (ctx : local_vars) : t
@@ -343,7 +343,7 @@ let dfun (f : string) (args : constr list) (stacks : local_stacks)
 let dinstr (i : string) (_stacks : local_stacks) (_ctx : local_vars) : t =
   (Dinstr i, Val, [])
 
-let access (var : Mir.Var.t) (df : dflag) (e : constr) (stacks : local_stacks)
+let access (var : Com.Var.t) (df : dflag) (e : constr) (stacks : local_stacks)
     (ctx : local_vars) : t =
   let _, lv, e = push_with_kind stacks ctx Val e in
   (Daccess (var, df, e), df, lv)

src/mlang/backend_compilers/decoupledExpr.mli

@@ -1,7 +1,7 @@
 type offset =
   | GetValueConst of int
   | GetValueExpr of string
-  | GetValueVar of Mir.Var.t
+  | GetValueVar of Com.Var.t
   | PassPointer
   | None
 
@@ -10,7 +10,7 @@ val generate_variable :
   offset ->
   ?def_flag:bool ->
   ?debug_flag:bool ->
-  Mir.Var.t ->
+  Com.Var.t ->
   string
 
 type dflag = Def | Val
@@ -67,7 +67,7 @@ val dfalse : constr
 val lit : float -> constr
 (** Float literal *)
 
-val m_var : Mir.Var.t -> offset -> dflag -> constr
+val m_var : Com.Var.t -> offset -> dflag -> constr
 (** Value from TGV. [m_var v off df] represents an access to the TGV variable
     [v] with [df] to read defineness or valuation. [off] is the access type for
     M array, and should be [None] most of the time. For array access, see
@@ -114,7 +114,7 @@ val dfun : string -> constr list -> constr
 val dinstr : string -> constr
 (** Direct instruction *)
 
-val access : Mir.Var.t -> dflag -> constr -> constr
+val access : Com.Var.t -> dflag -> constr -> constr
 (** Arbitrary access to M TGV variable. Either defineness of valuation *)
 
 val ite : constr -> constr -> constr -> constr

src/mlang/backend_compilers/dgfip_gen_files.ml

@@ -447,7 +447,6 @@ let split_list lst cnt =
 (* Print a variable's description *)
 let gen_var fmt req_type opt ~idx ~name ~tvar ~is_output ~typ_opt ~attributes
     ~desc ~alias_opt =
-  let open Mast in
   let var_name = if opt.with_alias then get_name name alias_opt else name in
 
   (* TODO if flg_compact is used, then handle flat representation of TGV *)
@@ -458,11 +457,11 @@ let gen_var fmt req_type opt ~idx ~name ~tvar ~is_output ~typ_opt ~attributes
     | _ -> ("EST_SAISIE", true)
   in
 
-  let typ = match typ_opt with None -> Real | Some ct -> Pos.unmark ct in
+  let typ = match typ_opt with None -> Com.Real | Some ct -> Pos.unmark ct in
 
   Format.fprintf fmt "    { \"%s\", %s | %d" var_name kind idx;
   if opt.with_type_donnee then
-    Format.fprintf fmt ", %a" Format_mast.format_value_typ typ;
+    Format.fprintf fmt ", %a" Com.format_value_typ typ;
   if opt.with_verif then
     if is_input && false then Format.fprintf fmt ", err_%s" name
       (* Note: no alias *)
@@ -843,13 +842,13 @@ let gen_table_varinfo fmt var_dict cat
   let nb =
     StrMap.fold
       (fun _ (var, idx, size) nb ->
-        if Com.CatVar.compare (Mir.Var.cat var) cat = 0 then (
+        if Com.CatVar.compare (Com.Var.cat var) cat = 0 then (
           Format.fprintf fmt "  { \"%s\", \"%s\", %d, %d, %d"
-            (Pos.unmark var.Mir.Var.name)
-            (Mir.Var.alias_str var) idx size id_int;
+            (Pos.unmark var.Com.Var.name)
+            (Com.Var.alias_str var) idx size id_int;
           StrMap.iter
             (fun _ av -> Format.fprintf fmt ", %d" (Pos.unmark av))
-            (Mir.Var.attrs var);
+            (Com.Var.attrs var);
           Format.fprintf fmt " },\n";
           nb + 1)
         else nb)
@@ -890,7 +889,7 @@ let gen_table_varinfos fmt (cprog : Mir.program) vars =
   let var_dict =
     StrMap.fold
       (fun _ var dict ->
-        StrMap.add (Pos.unmark var.Mir.Var.name) (var, -1, -1) dict)
+        StrMap.add (Pos.unmark var.Com.Var.name) (var, -1, -1) dict)
       cprog.program_vars StrMap.empty
   in
   let var_dict =
@@ -2163,7 +2162,7 @@ let extract_var_ids (cprog : Mir.program) vars =
   let open Mir in
   (* let open Dgfip_varid in *)
   let pvars = cprog.program_vars in
-  let add vn (v : Var.t) vm =
+  let add vn (v : Com.Var.t) vm =
     let vs =
       match StrMap.find_opt vn vm with
       | None -> VariableSet.empty
@@ -2175,9 +2174,9 @@ let extract_var_ids (cprog : Mir.program) vars =
      ids) *)
   let vars_map =
     StrMap.fold
-      (fun _ (v : Var.t) vm ->
+      (fun _ (v : Com.Var.t) vm ->
         let vm = add (Pos.unmark v.name) v vm in
-        match Mir.Var.alias v with
+        match Com.Var.alias v with
         | Some a -> add (Pos.unmark a) v vm
         | None -> vm)
       pvars StrMap.empty

src/mlang/backend_compilers/dgfip_varid.ml

@@ -34,9 +34,9 @@ let gen_loc_type = function
   | Com.CatVar.LocBase -> "EST_BASE"
   | Com.CatVar.LocInput -> "EST_SAISIE"
 
-let gen_access_def vm (v : Mir.Var.t) offset =
+let gen_access_def vm (v : Com.Var.t) offset =
   let vn = Pos.unmark v.name in
-  if Mir.Var.is_temp v then Printf.sprintf "%s_def[0%s]" vn offset
+  if Com.Var.is_temp v then Printf.sprintf "%s_def[0%s]" vn offset
   else
     match Mir.VariableMap.find v vm with
     | VarInput i -> Printf.sprintf "DS_[%d/*%s*/%s]" i vn offset
@@ -45,9 +45,9 @@ let gen_access_def vm (v : Mir.Var.t) offset =
     | VarIterate (t, l, _) ->
         Printf.sprintf "D%s[%s->idx/*%s*/%s]" (gen_tab l) t vn offset
 
-let gen_access_val vm (v : Mir.Var.t) offset =
+let gen_access_val vm (v : Com.Var.t) offset =
   let vn = Pos.unmark v.name in
-  if Mir.Var.is_temp v then Printf.sprintf "%s_val[0%s]" vn offset
+  if Com.Var.is_temp v then Printf.sprintf "%s_val[0%s]" vn offset
   else
     match Mir.VariableMap.find v vm with
     | VarInput i -> Printf.sprintf "S_[%d/*%s*/%s]" i vn offset
@@ -56,9 +56,9 @@ let gen_access_val vm (v : Mir.Var.t) offset =
     | VarIterate (t, l, _) ->
         Printf.sprintf "%s[%s->idx/*%s*/%s]" (gen_tab l) t vn offset
 
-let gen_access_pointer vm (v : Mir.Var.t) =
+let gen_access_pointer vm (v : Com.Var.t) =
   let vn = Pos.unmark v.name in
-  if Mir.Var.is_temp v then Printf.sprintf "(%s_val)" vn
+  if Com.Var.is_temp v then Printf.sprintf "(%s_val)" vn
   else
     match Mir.VariableMap.find v vm with
     | VarInput i -> Printf.sprintf "(S_ + %d/*%s*/)" i vn
@@ -67,9 +67,9 @@ let gen_access_pointer vm (v : Mir.Var.t) =
     | VarIterate (t, l, _) ->
         Printf.sprintf "(%s + %s->idx/*%s*/)" (gen_tab l) t vn
 
-let gen_access_def_pointer vm (v : Mir.Var.t) =
+let gen_access_def_pointer vm (v : Com.Var.t) =
   let vn = Pos.unmark v.name in
-  if Mir.Var.is_temp v then Printf.sprintf "(%s_def)" vn
+  if Com.Var.is_temp v then Printf.sprintf "(%s_def)" vn
   else
     match Mir.VariableMap.find v vm with
     | VarInput i -> Printf.sprintf "(DS_ + %d/*%s*/)" i vn
@@ -78,20 +78,20 @@ let gen_access_def_pointer vm (v : Mir.Var.t) =
     | VarIterate (t, l, _) ->
         Printf.sprintf "(D%s + %s->idx/*%s*/)" (gen_tab l) t vn
 
-let gen_access_pos_from_start vm (v : Mir.Var.t) =
-  if Mir.Var.is_temp v then assert false
+let gen_access_pos_from_start vm (v : Com.Var.t) =
+  if Com.Var.is_temp v then assert false
   else
     match Mir.VariableMap.find v vm with
     | VarInput i -> Printf.sprintf "EST_SAISIE | %d" i
     | VarBase i -> Printf.sprintf "EST_BASE | %d" i
     | VarComputed i -> Printf.sprintf "EST_CALCULEE | %d" i
     | VarIterate (t, l, _) -> Printf.sprintf "%s | %s->idx" (gen_loc_type l) t
 
-let gen_size vm (v : Mir.Var.t) =
-  let get_size (v : Mir.Var.t) =
+let gen_size vm (v : Com.Var.t) =
+  let get_size (v : Com.Var.t) =
     match v.is_table with Some i -> Format.sprintf "%d" i | None -> "1"
   in
-  if Mir.Var.is_temp v then get_size v
+  if Com.Var.is_temp v then get_size v
   else
     match Mir.VariableMap.find v vm with
     | VarInput _ | VarBase _ | VarComputed _ -> get_size v