légère modif de l'écriture/lecture du yaml

bin/lustre-mt/parser.ml

@@ -78,7 +78,7 @@ let (intlist : Yaml.value list -> int list) =
 let (save_variable_attributes : Types.variable -> (string * Yaml.value) -> unit) =
   fun v (key, value) -> 
   match key, value with
-  |"name", `String s -> v.name <- Str.string_after s 1
+  |"name", `String s -> v.name <- s
   |"type", `String s -> v.var_type <- s
   |_ -> assert false
 
@@ -113,7 +113,7 @@ let (save_data_one_task : Types.task -> (string * Yaml.value) -> unit) =
 let (save_data_task : Types.task -> (string * Yaml.value) -> unit) = 
   fun task (key, value) ->
     match (key, value) with
-    | "task", `O l -> List.iter (save_data_one_task task) l
+    | "para_node", `O l -> List.iter (save_data_one_task task) l
     |_ -> ()
 
 let (save_data_tasks : Yaml.value -> unit) = fun x ->
@@ -126,7 +126,7 @@ let (save_data_tasks : Yaml.value -> unit) = fun x ->
 
 let (save_data : (string * Yaml.value) -> unit) = fun (key, value) ->
   match (key, value) with
-  |"tasks", `A l -> List.iter save_data_tasks l;
+  |"all_para_nodes", `A l -> List.iter save_data_tasks l;
   |"main_node",  `String n -> name := n
   |_ -> assert false
 

lib/soc2yaml.ml

@@ -58,7 +58,6 @@ let (f : Soc.key -> Soc.tbl -> string -> unit) = fun sk stbl basename ->
     s
   in*)
 
-  (*changer ça pour utiliser les listes de var des tâches*)
   let (var2yaml : Soc.var -> string) = fun var ->
     let (name, var_type) = var in
     let var_type_str = match var_type with
@@ -68,9 +67,9 @@ let (f : Soc.key -> Soc.tbl -> string -> unit) = fun sk stbl basename ->
     | String -> "_char*"
     | _ -> ""
     in
-    let s = "        - name: _" ^ name
-    ^ "\n          type: " ^ var_type_str
-    ^ "\n" in
+    let s = "        - name: \"" ^ name
+    ^ "\"\n          type: \"" ^ var_type_str
+    ^ "\"\n" in
     s
   in
 
@@ -85,9 +84,9 @@ let (f : Soc.key -> Soc.tbl -> string -> unit) = fun sk stbl basename ->
     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 mem = memory2string task.memory in
-    let s = "  - task: "
-    ^ "\n      name: " ^ name
-    ^ "\n      var_in:\n" ^ s_vi
+    let s = "  - para_node: "
+    ^ "\n      name: \"" ^ name
+    ^ "\"\n      var_in:\n" ^ s_vi
     ^ "      var_out:\n" ^ s_vo
     ^ "      memory: " ^ mem
     ^ "\n"
@@ -100,7 +99,7 @@ let (f : Soc.key -> Soc.tbl -> string -> unit) = fun sk stbl basename ->
     fprintf yaml_file "\n%s" s
   in
   
-  fprintf yaml_file "tasks:\n";
+  fprintf yaml_file "all_para_nodes:\n";
   let n = ref [] in
   let rec (remove_duplicate_task : task_type list -> task_type list) = fun task_list ->
     match task_list with

lib/socNameC.ml

@@ -236,8 +236,6 @@ let (var_expr_to_index : (string * variable_type) list -> var_expr -> int) =
     
   let compare_name : string -> Soc.t -> bool = fun name soc ->
     let (x, _, _) = soc.key in
-    (*let split_soc_name = Str.split (Str.regexp "::") x in
-    let soc_name = List.nth split_soc_name ((List.length split_soc_name)-1) in*)
     String.equal x name
     
   let get_task_profile : string -> Soc.t list -> Soc.var list * Soc.var list = fun name socs ->
@@ -245,13 +243,7 @@ let (var_expr_to_index : (string * variable_type) list -> var_expr -> int) =
     let (var_in, var_out):Soc.var list * Soc.var list = soc.profile in
     (var_in, var_out)
   
-  (*let memory_soc : Soc.t -> unit = fun soc ->
-    let (x, _, _) = soc.key in
-    match soc.memory with
-    | No_mem -> Printf.printf "aeaeaea %s\n" x
-    | Mem _ -> Printf.printf "A clamitous disaster indeed %s\n" x (*uniquement dans les lustre pre : trouver si un lustre pre quelque part dans le soc pour dire mem = true*)
-    | Mem_hidden -> Printf.printf "It's wizard time %s\n" x (*idée : ne pas explorer les méthodes/procédures, juste regarder le nom pour trouver un pre ?*)
-*)
+
   let find_memory_soc : Soc.t -> bool = fun soc ->
     let gaol = get_gaol soc in
     let gao_has_memory = fun gao ->
@@ -260,7 +252,7 @@ let (var_expr_to_index : (string * variable_type) list -> var_expr -> int) =
       | Call(_, Method((_, sk), _, _), _, _)
       | Call(_, Procedure (sk, _, _), _, _) -> 
         let (name, _, _) = sk in
-        (String.equal "Lustre::pre" name) || (String.equal "Lustre::arrow" name)
+        (String.equal "Lustre::pre" name) || (String.equal "Lustre::arrow" name) (*les 2 socs qui ont de la mémoire*)
       | Case(_, _, _) -> assert false
     in
     List.exists (fun x -> x = true) (List.map gao_has_memory gaol)
@@ -272,8 +264,6 @@ let (var_expr_to_index : (string * variable_type) list -> var_expr -> int) =
     
   let get_tasks : Soc.tbl -> Soc.t -> Soc.t -> task_type list = fun stbl main_soc soc ->
     let gaol = get_gaol soc in
-    (*let socs_all = (get_literally_all_socs main_soc stbl) @ [main_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
@@ -283,8 +273,7 @@ let (var_expr_to_index : (string * variable_type) list -> var_expr -> int) =
           match task with
         | None -> let t : task_type option = None in t
         | Some (_, (n, _, _)) ->
-          (*let x = Str.split (Str.regexp "::") n in*)
-          let name_task = (*List.nth x ((List.length x)-1)*) n in
+          let name_task = n in
           let socs = (get_all_soc main_soc stbl) @ [main_soc] in
           let (var_ins, var_outs) = get_task_profile name_task socs in
           let mem = has_memory name_task socs in