ajout de la recuperation de taches et ecriture dans le yml (fonctionnel mais pas fini)

lib/soc2yaml.ml

@@ -8,13 +8,23 @@ open SocNameC
 
 let (f : Soc.key -> Soc.tbl -> string -> unit) = fun sk stbl basename ->
 
-  let main_soc = SocUtils.find (Lxm.dummy "dfsdf") sk stbl in
+  let main_soc = SocUtils.find (Lxm.dummy "dfsdf") sk stbl in (*recup tous les autres soc : cf socnamec*)
 
-  let nodes = SocNameC.get_nodes main_soc in
-  let filename = SocNameC.get_filename main_soc in
+  (*let nodes = SocNameC.get_nodes main_soc in*)
+  (*let socs = SocNameC.get_all_soc main_soc stbl in*)
   let variables = (SocNameC.get_inputs main_soc) @ (SocNameC.get_variables main_soc) @ (SocNameC.get_outputs main_soc) in
-  let instances = SocNameC.get_instances main_soc in
-  let yaml_file = open_out (filename ^ ".yml") in
+  (*let instances = SocNameC.get_instances main_soc in*)
+  let tasks = SocNameC.get_tasks main_soc in
+  let yaml_file = open_out (basename ^ ".yml") in
+
+  (*let (socs2yaml : task_type -> unit) = fun soc ->
+    match soc.key with
+    | (k, _, _) -> let s = k ^ " \naeaea\n" in
+      fprintf yaml_file "%s" s
+    |_ -> let s = "XXXXX" in fprintf yaml_file
+  in
+  List.iter socs2yaml socs;*)
+    
   
   let (var2yaml : int -> string) = fun i ->
     let choose_var : int -> variable_type -> bool = fun i var -> i = var.id in
@@ -26,15 +36,13 @@ let (f : Soc.key -> Soc.tbl -> string -> unit) = fun sk stbl basename ->
     s
   in
 
-  (* va y avoir des tâches à la place donc penser à changer pour utiliser les instances avec des tâches
-     PS : ident = la liste des ids des variables qui vont être utilisées*)
-  let (tasks2yaml : instance_type -> unit) = fun inst ->
-    let node = inst.node in
-    let f1 : node_type -> string = fun node -> node.file_name in
-    let s_vi = String.concat "" (List.map var2yaml inst.var_in) in
-    let s_vo = String.concat "" (List.map var2yaml inst.var_out) in
+  (*PS : ident = la liste des ids des variables qui vont être utilisées*)
+  (*Attention : 1 tâche pour le start, 1 pour le join donc rassembler les 2 tâches*)
+  let (tasks2yaml : task_type -> unit) = fun task ->
+    let s_vi = String.concat "" (List.map var2yaml task.var_in) in
+    let s_vo = String.concat "" (List.map var2yaml task.var_out) in
     let s = "  - task: "
-    ^ "\n      name: " ^ (f1 (List.nth nodes node))
+    ^ "\n      name: " ^ task.name
     ^ "\n      var_in:\n" ^ s_vi
     ^ "      var_out:\n" ^ s_vo
     in
@@ -42,22 +50,43 @@ let (f : Soc.key -> Soc.tbl -> string -> unit) = fun sk stbl basename ->
   in
   
   let (main2yaml : unit -> unit) = fun () ->
-    let s = "main_node: " ^ filename in
+    let s = "main_node: " ^ basename in
     fprintf yaml_file "\n%s" s
   in
   
   fprintf yaml_file "tasks:\n";
+  (* penser a fusionner les start et join d'une tache + toujours supprimer les duplicatas APRES AVOIR FUSIONNE (sinon risque de perdre join du start)*)
   let n = ref [] in
-  let rec (get_one_inst_by_node : instance_type list -> instance_type list) = fun inst_list ->
-    match inst_list with
+  let rec (remove_duplicate_task : task_type list -> task_type list) = fun task_list ->
+    match task_list with
     |[] -> []
-    |h::p -> if Bool.not (List.exists (fun v -> h.node = v) !n) then 
-      (n := (h.node)::!n;
-        h::(get_one_inst_by_node p))
-    else get_one_inst_by_node p
+    |h::p -> if Bool.not (List.exists (fun v -> h.name = v.name) !n) then 
+      (n := h::!n;
+        h::(remove_duplicate_task p))
+    else remove_duplicate_task p
   in
+  
+  let n = ref [] in
+  let rec (fuse_start_join_task : task_type list -> task_type list) = fun task_list ->
+    match task_list with
+    |[] -> []
+    |h::p -> if Bool.not (List.exists (fun v -> h.name = v.name) !n) then (*on trouve un nouveau start*)
+      (n := h::!n;
+        h::(fuse_start_join_task p))
+    else 
+      let t = List.find (fun v -> h.name = v.name) !n in 
+      if (List.length t.var_out = 0) then (*on check si la tâche est pas complète (on a un start mais pas de join)*)
+        match (List.length h.var_out) with
+        |0 -> fuse_start_join_task p
+        |_ -> 
+          let full_task = {name = t.name; var_in = t.var_in; var_out = h.var_out} in
+          n := full_task::!n;
+          full_task::(fuse_start_join_task p)              (*Comment actualiser n pour dire qu'on a trouvé ? penser à find_index f list, mais attention ça renvoie un type option*)
+      else fuse_start_join_task p (*la tâche est déjà complète c'est juste une autre avec le même noeud on en a pas besoin*)
+  in
+  
 
-  List.iter tasks2yaml (get_one_inst_by_node instances);
+  List.iter tasks2yaml (remove_duplicate_task (List.rev (fuse_start_join_task tasks)));
 
   main2yaml ();
   

lib/socNameC.ml

 (** Time-stamp: <modified the 19/06/2024 (at 17:50) by Erwan Jahier> *)
 
+
+
 type variable_type = {
   id: int;
   name: string;
@@ -20,6 +22,12 @@ type instance_type = {
   var_out: int list;
 }
 
+type task_type = {
+  name: string;
+  var_in: int list;
+  var_out: int list
+}
+
 let get_filename : Soc.t -> string = fun soc ->
   Soc2cIdent.get_base_name soc.key
 
@@ -170,33 +178,58 @@ let get_instances : Soc.t -> instance_type list = fun soc ->
   (* List.iter print_instance_type res; *)
   res
 
-  let get_tasks : Soc.t -> task list = fun soc ->
-    (*let gaol = get_gaol soc in*)
-    let task_list = soc.tasks in
-    task_list
-    (*let ltbl = Hashtbl.create 2 in
-    let node_cpt_ref = ref (-1) in
-    let all_vars = (get_inputs_assoc soc) @ (get_outputs_assoc soc) @ (get_variables_assoc soc) in
-    let gao_to_tasks i gao =
-      match gao with
-      | Call(_,Assign,_,_) -> assert false
-      | Call(args_out, Method((_,k), _,_), args_in, _)
-      | Call(args_out, Procedure (k,_)     , args_in, _) ->
-        let node_cpt, _inst_cpt = match Hashtbl.find_opt ltbl k with
-          | None  -> incr node_cpt_ref; Hashtbl.add ltbl k (!node_cpt_ref, 0); !node_cpt_ref, 0
-          | Some (node_cpt, inst_cpt) ->
-            let inst_cpt = inst_cpt+1 in
-            Hashtbl.add ltbl k (node_cpt, inst_cpt);
-            node_cpt, inst_cpt
-        in
+let get_tasks : Soc.t -> task_type list = fun soc ->
+  let gaol = get_gaol soc in
+  let all_vars = (get_inputs_assoc soc) @ (get_outputs_assoc soc) @ (get_variables_assoc soc) in
+  let (gao_to_tasks: gao -> task_type option) = fun gao ->
+    match gao with
+    | Call(_,Assign,_,_) -> assert false
+    | Call(args_out, Method(_, _, task), args_in, _)
+    | Call(args_out, Procedure (_, _, task)     , args_in, _) -> 
+      begin
+        match task with
+        | None -> let t : task_type option = None in t
+        | Some (_, (n, _, _)) ->
+          let x = Str.split (Str.regexp "::") n in
+          let t =
         {
-          id = i+1;
-          node = node_cpt;
+          name = List.nth x ((List.length x)-1);
           var_in = List.map (var_expr_to_index all_vars) args_in;
           var_out = List.map (var_expr_to_index all_vars) args_out
-        }
-      | Case(_, _,_) -> assert false
+        } in
+        Some t
+      end
+    | Case(_, _,_) -> assert false
+  in
+  let (to_list : task_type option -> task_type list) = fun a ->
+    match a with
+    | None -> []
+    | Some x -> [x]
+  in
+  let res = List.concat (List.map to_list (List.map gao_to_tasks gaol)) in
+  res
+
+(*faire ça : récup les socs de tous les noeuds
+let get_all_soc : Soc.t -> Soc.tbl -> Soc.t list = fun soc stbl ->
+  let gaol = get_gaol soc in 
+    let rec find_soc gao = fun gao ->
+      match gao with
+      | Case(_, [(_, gaoll)], _) -> List.map find_soc gaoll
+      | Call(_, Method((_, sk), _, _), _, _)
+      | Call(_, Procedure(sk, _, _), _, _) ->
+        (SocUtils.find (Lxm.dummy "aeaea") sk stbl)
     in
-    let res = List.mapi gao_to_tasks gaol in
-    (* List.iter print_instance_type res; *)
-    res*)
+  let socs = List.map find_soc gaol in
+  let n = ref [] in
+  let rec (remove_duplicate : Soc.t list -> Soc.t list) = fun socl ->
+    match socl with
+    | [] -> []
+    | h::p -> if Bool.not (List.exists n h) then
+      (n := soc::!n;
+      h::(remove_duplicate p))
+    else
+      remove_duplicate p
+  in
+  let x = List.map remove_duplicate socs in (*supprimer les duplicatas*)
+  x*)
+