Fix several issues w.r.t. clocks during node expansion.

(1) equations such as
 (x,y,z)=[0,0,0];
were generated with -en unless -ec was specified.

I've fixed that by always breaking tuples, even when global_opt.ec
is false (this condition was strange anyway).

(2) During node expansion, I create a fresh variable for each local
var in the expanded node, but old var names were still appering in
clock expression

indeed, consider that example :
var
  c:bool;
  x when c :bool;

I was generating something equivalent to

var
  c_fresh:bool;
  x_fresh when c :bool;

bou... Of course, it was working because in -ec mode, I need to
remove clock annotation when declaring local variables, which was
hidding the problem.

nb : because I've change test_lus2lic_no_node to use -lv4 instead of
-ec to generate the lustre oracle, which exposes new pbs (cf above).

(3) When expanding a node on the base clock with arguments on another
clock, I was not propagating that information (let's keep the
finger-crossed and hope the current fix is complete).

nb : the number of failing test cases is the same (5 new pass, but 5
new fail!!), but it actually is a progression. Indeed, the new test
failures ares due to the fact that this current change fixes a
problem that expose yet another one!

Actually, the newly exposed bug is not in the compliler, but in the
oracle I generate via the --auto-test option ; indeed, for testing
nodes which not all interface variables are one the base clock, I
should generate oracle that do take them into account.

src/l2lExpandArrays.ml

-(** Time-stamp: <modified the 12/04/2013 (at 08:46) by Erwan Jahier> *)
+(** Time-stamp: <modified the 23/04/2013 (at 16:20) by Erwan Jahier> *)
 
 (* Replace structures and arrays by as many variables as necessary.
    Since structures can be recursive, it migth be a lot of new variables...
@@ -343,14 +343,9 @@ and do_const acc lctx lxm const =
 
 and (break_tuple : Lxm.t -> left list -> val_exp -> Lic.eq_info srcflagged list) =
   fun lxm left_list ve ->
-    if not Lv6MainArgs.global_opt.Lv6MainArgs.ec then
-      [{ src = lxm ; it = (left_list, ve) }] 
-    else
-      (* we only need to break tuples in this mode ...
-	      Note that this work only if the node expansion has already been done!
-	      (otherwise, we would not have the same number of items in the left and 
-	      in the rigth part)
-      *)
+      (* Note that this work only if the node expansion has already
+	      been done!  (otherwise, we would not have the same number of
+	      items in the left and in the rigth part) *)
       let rec aux ve = (* flatten val exp*)
 	     match ve.ve_core with 
 	       | CallByPosLic ({it= TUPLE}, vel) 
@@ -361,8 +356,6 @@ and (break_tuple : Lxm.t -> left list -> val_exp -> Lic.eq_info srcflagged list)
 		      List.map
 		        (fun ve1 -> { ve1 with ve_core = CallByPosLic ({src=lxm;it= HAT(i)}, [ve1])} ) 
 		        ve1l 
-
-
 	       | CallByPosLic (unop, [ve1]) ->
 	         let ve1l = aux ve1 in
 		      List.map

src/l2lExpandNodes.ml

-(* Time-stamp: <modified the 11/04/2013 (at 17:32) by Erwan Jahier> *)
+(* Time-stamp: <modified the 23/04/2013 (at 16:35) by Erwan Jahier> *)
 
 
 open Lxm
@@ -65,6 +65,15 @@ and subst_in_left s left =
     | LeftArrayLic(left,i, t) -> LeftArrayLic(subst_in_left s left,i, t)
     | LeftSliceLic(left,si,t) -> LeftSliceLic(subst_in_left s left,si,t)
 
+and (subst_in_clock : subst -> clock -> clock) =
+  fun s clk -> 
+    match clk with
+      | BaseLic -> BaseLic
+      | ClockVar i -> ClockVar i
+      | On ((cc,cv,ct),clk) -> 
+        let cv = try (List.assoc cv s).var_name_eff with Not_found -> cv in 
+        On ((cc,cv,ct), subst_in_clock s clk) 
+
 and (subst_in_val_exp : subst -> val_exp -> val_exp) =
   fun s ve -> 
     let newve = {
@@ -84,8 +93,8 @@ and (subst_in_val_exp : subst -> val_exp -> val_exp) =
                   with Not_found -> id
                 in
                 VAR_REF id'
+              | WHEN(clk) -> WHEN(subst_in_clock s clk)
               | HAT(i) -> HAT(i)
-              | WHEN(_) -> by_pos_op
               | PREDEF_CALL _| CALL _ | PRE | ARROW | FBY | CURRENT  | TUPLE
               | ARRAY | CONCAT | STRUCT_ACCESS _ | ARRAY_ACCES _ | ARRAY_SLICE _ 
               | CONST _ 
@@ -117,38 +126,60 @@ type acc =
     * (Lic.eq_info srcflagged) list  (* equations *)
     * Lic.var_info list              (* new local vars *)
 
-let (mk_fresh_loc : local_ctx -> var_info -> var_info) =
-  fun lctx v -> 
-    new_var (Ident.to_string v.var_name_eff) lctx v.var_type_eff v.var_clock_eff  
+let (mk_fresh_loc : local_ctx -> var_info -> clock -> var_info) =
+  fun lctx v c ->
+    new_var (Ident.to_string v.var_name_eff) lctx v.var_type_eff (fst v.var_clock_eff, c)
       
+(* When expanding a node call such as 
+
+    x = toto(a when c);
+
+   when toto params are (for example) on the base clock, we need to
+   propagate the substitution between the toto base clock and "on(c)"
+   ; for the toto arguments, it's been done during clock checking ;
+   but we need to remember this information to substitute the clock
+   of toto in its local variables.
+*)
+type clock_substs = (clock * clock) list
+    
+let (add_clock_subst: clock -> clock -> clock_substs -> clock_substs) =
+  fun c1 c2 cs -> 
+    if List.mem_assoc c1 cs then cs else (c1,c2)::cs
+
 let (mk_input_subst: local_ctx -> Lxm.t -> var_info list -> 
-     Lic.val_exp list -> acc -> subst * acc) = 
+     Lic.val_exp list -> acc -> subst * acc * clock_substs) = 
   fun lctx lxm vl vel acc -> 
     assert(List.length vl = List.length vel);
     List.fold_left2
-      (fun (s,(a_acc,e_acc,v_acc)) v ve ->
-         (* we create a new var for each node argument, which is a little
-            bit  bourrin  if ever ve is a simple ident... *)
-        let nv = mk_fresh_loc lctx v in
+      (fun (s,(a_acc,e_acc,v_acc),cs) v ve ->
+        (* we create a new var for each node argument, which is a little
+           bit  bourrin  if ever ve is a simple ident... *)
+        let clk = match ve.ve_clk with
+          | [c] ->  c
+          | _ -> assert false
+        in
+        let nv = mk_fresh_loc lctx v clk in
         let neq = [LeftVarLic(nv,lxm)],ve in
         let neq = flagit neq lxm in
-        (v.var_name_eff,nv)::s,(a_acc, neq::e_acc, nv::v_acc)
+        let cs = add_clock_subst (snd v.var_clock_eff) clk cs in 
+        (v.var_name_eff,nv)::s,(a_acc, neq::e_acc, nv::v_acc), cs
       )
-      ([],acc)
+      ([],acc,[])
       vl
       vel
 
 (* create fresh vars if necessary *)
-let (mk_output_subst : local_ctx -> Lxm.t -> var_info list -> Lic.left list -> 
-     acc -> subst * acc) = 
-  fun lctx lxm vl leftl acc ->
+let (mk_output_subst : local_ctx -> Lxm.t -> var_info list -> Lic.left list -> clock_substs -> 
+     acc -> subst * acc * clock_substs) = 
+  fun lctx lxm vl leftl cs acc ->
     assert(List.length vl = List.length leftl);
     List.fold_left2
-      (fun (s,acc) v left -> 
+      (fun (s,acc,cs) v left -> 
         match left with
-          | LeftVarLic(v2,lxm) -> (v.var_name_eff,v2)::s, acc
+          | LeftVarLic(v2,lxm) -> (v.var_name_eff,v2)::s, acc,cs
           | _ -> 
-            let nv = mk_fresh_loc lctx v in
+            let clk = Lic.clock_of_left left in
+            let nv = mk_fresh_loc lctx v clk in
             let nv_id = nv.var_name_eff in
 	         let nve = {
               ve_core = CallByPosLic({it=VAR_REF nv_id;src = lxm },[]);
@@ -158,17 +189,18 @@ let (mk_output_subst : local_ctx -> Lxm.t -> var_info list -> Lic.left list ->
             in
             let neq = [left], nve in
             let neq = flagit neq lxm in
-               (* for equations of the form 
-                  x.field = n(...);
-                  we create 
-                  - a fresh var "_v" 
-                  - define the equation "x.field = _v;"
-                  - create the substition n_output_par/_v
-               *)
+            (* for equations of the form 
+               x.field = n(...);
+               we create 
+               - a fresh var "_v" 
+               - define the equation "x.field = _v;"
+               - create the substition n_output_par/_v
+            *)
             let (aa,ae,av) = acc in
-            (v.var_name_eff,nv)::s, (aa, neq::ae, nv::av)
+            let cs = add_clock_subst (snd v.var_clock_eff) clk cs in 
+            (v.var_name_eff,nv)::s, (aa, neq::ae, nv::av), cs
       )
-      ([],acc)
+      ([],acc,cs)
       vl 
       leftl
 
@@ -217,12 +249,30 @@ and (expand_eq_aux: local_ctx -> Lic.eq_info -> acc option)=
               and asserts = node_body.asserts_eff in
               let node = node.it in
               let node_locs = get_locals node in
-              let fresh_locs = List.map (mk_fresh_loc lctx) node_locs in
-              let acc = [],[],fresh_locs in
-              let is,acc = mk_input_subst lctx lxm node.inlist_eff vel acc in
-              let os,acc = mk_output_subst lctx lxm node.outlist_eff lhs acc in
+              let acc = [],[],[] in
+              let is,acc,cs = mk_input_subst lctx lxm node.inlist_eff vel acc in
+              let os,acc,cs = mk_output_subst lctx lxm node.outlist_eff lhs cs acc in
+              let rec (substitute_clock : clock -> clock) = 
+                fun c -> 
+                  try List.assoc c cs
+                  with Not_found ->
+                    match c with
+                      | BaseLic
+                      | ClockVar _ -> c (* XXX should/can it happen? *)
+                      | On(v,clk) -> On(v, substitute_clock clk)
+              in
+              let clks = List.map (fun v -> substitute_clock (snd v.var_clock_eff)) node_locs in
+              let fresh_locs = List.map2 (mk_fresh_loc lctx) node_locs clks in
+
               let ls = mk_loc_subst node_locs fresh_locs in
               let s = List.rev_append is (List.rev_append os ls) in
+              let fresh_locs = (* substitute the new vars in clocks *)
+                List.map (fun v -> 
+                  let id,clk = v.var_clock_eff in
+                  { v with var_clock_eff = id, subst_in_clock s clk }) 
+                  fresh_locs
+              in
+              let acc = match acc with (a,b,c) ->  (a,b,c@fresh_locs) in
               let node_eqs = List.map (substitute s) node_eqs in
               let subst_assert x = Lxm.flagit (subst_in_val_exp s x.it) x.src in
               let asserts = List.map subst_assert asserts in

src/main.ml

-(* Time-stamp: <modified the 19/04/2013 (at 13:53) by Erwan Jahier> *)
+(* Time-stamp: <modified the 23/04/2013 (at 16:41) by Erwan Jahier> *)
 
 open Verbose
 open AstV6
@@ -74,6 +74,8 @@ let (gen_autotest_files : LicPrg.t -> Ident.idref option -> Lv6MainArgs.t -> uni
     let oracle_file_name = ("_"^name^"_oracle.lus") in
     let oc = open_out oracle_file_name in
     let locals = List.map (fun (n,t) -> n^"_bis",t) outvars in
+    let invars_str  = List.map (fun (n,t) -> n^":"^(Data.type_to_string t)) invars in
+    let outvars_str = List.map (fun (n,t) -> n^":"^(Data.type_to_string t)) outvars in
     let prg = "node "^name^"_oracle("^(String.concat ";" (invars_str@outvars_str)) in
     let locals_str = List.map (fun (n,t) -> n^":"^(Data.type_to_string t)) locals in
     let ok = (* avoid name clash*)

test/lus2lic.sum

-Test Run By jahier on Mon Apr 22 17:27:21 2013
+Test Run By jahier on Tue Apr 23 16:03:56 2013
 Native configuration is i686-pc-linux-gnu
 
 		=== lus2lic tests ===
@@ -20,7 +20,7 @@ PASS: ../utils/test_lus2lic_no_node should_work/argos.lus
 PASS: ./lus2lic {-o /tmp/ck5.lic should_work/ck5.lus}
 PASS: ./lus2lic {-ec -o /tmp/ck5.ec should_work/ck5.lus}
 PASS: ./ec2c {-o /tmp/ck5.c /tmp/ck5.ec}
-FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/ck5.lus
+PASS: ../utils/test_lus2lic_no_node should_work/ck5.lus
 PASS: ./lus2lic {-o /tmp/fby.lic should_work/fby.lus}
 PASS: ./lus2lic {-ec -o /tmp/fby.ec should_work/fby.lus}
 PASS: ./ec2c {-o /tmp/fby.c /tmp/fby.ec}
@@ -262,7 +262,7 @@ PASS: ../utils/test_lus2lic_no_node should_work/mm22.lus
 PASS: ./lus2lic {-o /tmp/X1.lic should_work/X1.lus}
 PASS: ./lus2lic {-ec -o /tmp/X1.ec should_work/X1.lus}
 PASS: ./ec2c {-o /tmp/X1.c /tmp/X1.ec}
-FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/X1.lus
+PASS: ../utils/test_lus2lic_no_node should_work/X1.lus
 PASS: ./lus2lic {-o /tmp/is_stable.lic should_work/is_stable.lus}
 PASS: ./lus2lic {-ec -o /tmp/is_stable.ec should_work/is_stable.lus}
 PASS: ./ec2c {-o /tmp/is_stable.c /tmp/is_stable.ec}
@@ -306,7 +306,7 @@ PASS: ../utils/test_lus2lic_no_node should_work/minmax3.lus
 PASS: ./lus2lic {-o /tmp/X3.lic should_work/X3.lus}
 PASS: ./lus2lic {-ec -o /tmp/X3.ec should_work/X3.lus}
 PASS: ./ec2c {-o /tmp/X3.c /tmp/X3.ec}
-FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/X3.lus
+PASS: ../utils/test_lus2lic_no_node should_work/X3.lus
 PASS: ./lus2lic {-o /tmp/filter.lic should_work/filter.lus}
 PASS: ./lus2lic {-ec -o /tmp/filter.ec should_work/filter.lus}
 PASS: ./ec2c {-o /tmp/filter.c /tmp/filter.ec}
@@ -410,8 +410,6 @@ PASS: ./lus2lic {-o /tmp/enum.lic should_work/enum.lus}
 PASS: ./lus2lic {-ec -o /tmp/enum.ec should_work/enum.lus}
 PASS: ./ec2c {-o /tmp/enum.c /tmp/enum.ec}
 FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/enum.lus
-FAIL: without any option: ./lus2lic {-o /tmp/_matrice_oracle.lic should_work/_matrice_oracle.lus}
-FAIL: Generate ec code  : ./lus2lic {-ec -o /tmp/_matrice_oracle.ec should_work/_matrice_oracle.lus}
 PASS: ./lus2lic {-o /tmp/param_node4.lic should_work/param_node4.lus}
 PASS: ./lus2lic {-ec -o /tmp/param_node4.ec should_work/param_node4.lus}
 PASS: ./ec2c {-o /tmp/param_node4.c /tmp/param_node4.ec}
@@ -544,7 +542,7 @@ PASS: ../utils/test_lus2lic_no_node should_work/long_et_stupide_nom_de_noeud.lus
 PASS: ./lus2lic {-o /tmp/CURRENT.lic should_work/CURRENT.lus}
 PASS: ./lus2lic {-ec -o /tmp/CURRENT.ec should_work/CURRENT.lus}
 PASS: ./ec2c {-o /tmp/CURRENT.c /tmp/CURRENT.ec}
-PASS: ../utils/test_lus2lic_no_node should_work/CURRENT.lus
+FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/CURRENT.lus
 PASS: ./lus2lic {-o /tmp/left.lic should_work/left.lus}
 PASS: ./lus2lic {-ec -o /tmp/left.ec should_work/left.lus}
 PASS: ./ec2c {-o /tmp/left.c /tmp/left.ec}
@@ -590,7 +588,7 @@ PASS: ../utils/test_lus2lic_no_node should_work/matrice.lus
 PASS: ./lus2lic {-o /tmp/TIME_STABLE.lic should_work/TIME_STABLE.lus}
 PASS: ./lus2lic {-ec -o /tmp/TIME_STABLE.ec should_work/TIME_STABLE.lus}
 PASS: ./ec2c {-o /tmp/TIME_STABLE.c /tmp/TIME_STABLE.ec}
-FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/TIME_STABLE.lus
+PASS: ../utils/test_lus2lic_no_node should_work/TIME_STABLE.lus
 PASS: ./lus2lic {-o /tmp/cpt.lic should_work/cpt.lus}
 PASS: ./lus2lic {-ec -o /tmp/cpt.ec should_work/cpt.lus}
 PASS: ./ec2c {-o /tmp/cpt.c /tmp/cpt.ec}
@@ -710,7 +708,7 @@ FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node shou
 PASS: ./lus2lic {-o /tmp/ck4.lic should_work/ck4.lus}
 PASS: ./lus2lic {-ec -o /tmp/ck4.ec should_work/ck4.lus}
 PASS: ./ec2c {-o /tmp/ck4.c /tmp/ck4.ec}
-PASS: ../utils/test_lus2lic_no_node should_work/ck4.lus
+FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/ck4.lus
 PASS: ./lus2lic {-o /tmp/map_red_iter.lic should_work/map_red_iter.lus}
 PASS: ./lus2lic {-ec -o /tmp/map_red_iter.ec should_work/map_red_iter.lus}
 PASS: ./ec2c {-o /tmp/map_red_iter.c /tmp/map_red_iter.ec}
@@ -726,7 +724,7 @@ FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node shou
 PASS: ./lus2lic {-o /tmp/filliter.lic should_work/filliter.lus}
 PASS: ./lus2lic {-ec -o /tmp/filliter.ec should_work/filliter.lus}
 PASS: ./ec2c {-o /tmp/filliter.c /tmp/filliter.ec}
-PASS: ../utils/test_lus2lic_no_node should_work/filliter.lus
+FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/filliter.lus
 PASS: ./lus2lic {-o /tmp/minmax4.lic should_work/minmax4.lus}
 PASS: ./lus2lic {-ec -o /tmp/minmax4.ec should_work/minmax4.lus}
 PASS: ./ec2c {-o /tmp/minmax4.c /tmp/minmax4.ec}
@@ -794,7 +792,7 @@ PASS: ../utils/test_lus2lic_no_node should_work/_N_uu.lus
 PASS: ./lus2lic {-o /tmp/X2.lic should_work/X2.lus}
 PASS: ./lus2lic {-ec -o /tmp/X2.ec should_work/X2.lus}
 PASS: ./ec2c {-o /tmp/X2.c /tmp/X2.ec}
-FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/X2.lus
+PASS: ../utils/test_lus2lic_no_node should_work/X2.lus
 PASS: ./lus2lic {-o /tmp/alias.lic should_work/alias.lus}
 PASS: ./lus2lic {-ec -o /tmp/alias.ec should_work/alias.lus}
 PASS: ./ec2c {-o /tmp/alias.c /tmp/alias.ec}
@@ -826,7 +824,7 @@ PASS: ../utils/test_lus2lic_no_node should_work/minmax6.lus
 PASS: ./lus2lic {-o /tmp/ck3.lic should_work/ck3.lus}
 PASS: ./lus2lic {-ec -o /tmp/ck3.ec should_work/ck3.lus}
 PASS: ./ec2c {-o /tmp/ck3.c /tmp/ck3.ec}
-PASS: ../utils/test_lus2lic_no_node should_work/ck3.lus
+FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/ck3.lus
 PASS: ./lus2lic {-o /tmp/zzz.lic should_work/zzz.lus}
 PASS: ./lus2lic {-ec -o /tmp/zzz.ec should_work/zzz.lus}
 PASS: ./ec2c {-o /tmp/zzz.c /tmp/zzz.ec}
@@ -930,7 +928,7 @@ PASS: ../utils/test_lus2lic_no_node should_work/count.lus
 PASS: ./lus2lic {-o /tmp/ck2.lic should_work/ck2.lus}
 PASS: ./lus2lic {-ec -o /tmp/ck2.ec should_work/ck2.lus}
 PASS: ./ec2c {-o /tmp/ck2.c /tmp/ck2.ec}
-PASS: ../utils/test_lus2lic_no_node should_work/ck2.lus
+FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/ck2.lus
 PASS: ./lus2lic {-o /tmp/X.lic should_work/X.lus}
 PASS: ./lus2lic {-ec -o /tmp/X.ec should_work/X.lus}
 PASS: ./ec2c {-o /tmp/X.c /tmp/X.ec}
@@ -1048,7 +1046,7 @@ XPASS: Test bad programs (semantics): lus2lic {-o /tmp/bug.lic should_fail/seman
 		=== lus2lic Summary ===
 
 # of expected passes		871
-# of unexpected failures	114
+# of unexpected failures	112
 # of unexpected successes	11
 # of expected failures		37
 # of unresolved testcases	2

todo.org

@@ -3,28 +3,6 @@
 
 * lus2lic -exec
 
-** TODO Trouver un moyen d'automatiser des tests
-   - State "TODO"       from ""           [2013-03-19 Tue 10:35]
-via lurette ?
-en comparant le mode -exec avec le résultat obtenu via ec puis ec2c
-
-faudrait rajouter une option dans lurette qui, en cas de variables 
-manquantes, genere le programme lutin qui va bien (loop true) plutot
-que de lancer luciole
-
-Un truc de ce gout là semble fonctionner :
-
-
- ./lus2lic  _trivial3_condact_oracle.lus -n trivial3_condact_oracle -ec > trivial3_condact_oracl
-
-
-./lus2lic trivial3.lus -n trivial3_condact --gen-autotest
-./lus2lic trivial3.lus -n trivial3_condact -ec >> _trivial3_condact_oracle.lus
-./lus2lic  _trivial3_condact_oracle.lus -n trivial3_condact_oracle -ec > trivial3_condact_oracle.ec
-~/lurette/bin/lurettetop -rp "sut:v6:trivial3.lus:trivial3_condact" -rp "env:lutin:_trivial3_condact_env.lut" -rp "oracle:ec:trivial3_condact_oracle.ec:" -go 
-
-Reste à l'integrer dans file:test/lus2lic.tests/non-reg.exp
-
 ** TODO ce noeud ne compile pas en mode -ec
    - State "TODO"       from ""           [2013-04-17 Wed 15:51]
 

todo.org_archive

@@ -666,6 +666,36 @@ Question : comment j'integre ? via un lus2lic.a ?
 
 file:~/lurette/source/common/lustreRun.mli
 
+* TODO Trouver un moyen d'automatiser des tests
+   - State "TODO"       from ""           [2013-03-19 Tue 10:35]
+  :PROPERTIES:
+  :ARCHIVE_TIME: 2013-04-23 Tue 16:54
+  :ARCHIVE_FILE: ~/lus2lic/todo.org
+  :ARCHIVE_OLPATH: lus2lic -exec
+  :ARCHIVE_CATEGORY: lv6
+  :ARCHIVE_TODO: TODO
+  :END:
+via lurette ?
+en comparant le mode -exec avec le résultat obtenu via ec puis ec2c
+
+faudrait rajouter une option dans lurette qui, en cas de variables 
+manquantes, genere le programme lutin qui va bien (loop true) plutot
+que de lancer luciole
+
+Un truc de ce gout là semble fonctionner :
+
+
+ ./lus2lic  _trivial3_condact_oracle.lus -n trivial3_condact_oracle -ec > trivial3_condact_oracl
+
+
+./lus2lic trivial3.lus -n trivial3_condact --gen-autotest
+./lus2lic trivial3.lus -n trivial3_condact -ec >> _trivial3_condact_oracle.lus
+./lus2lic  _trivial3_condact_oracle.lus -n trivial3_condact_oracle -ec > trivial3_condact_oracle.ec
+~/lurette/bin/lurettetop -rp "sut:v6:trivial3.lus:trivial3_condact" -rp "env:lutin:_trivial3_condact_env.lut" -rp "oracle:ec:trivial3_condact_oracle.ec:" -go 
+
+Reste à l'integrer dans file:test/lus2lic.tests/non-reg.exp
+
+
 
 
 

utils/test_lus2lic_no_node

@@ -10,7 +10,7 @@ env=_"$node"_env.lut
 set -x verbose #echo on
 
 ./lus2lic $lustre_file -n $node --gen-autotest || exit 2
-./lus2lic $lustre_file -n $node -ec >> $_oracle || exit 2
+./lus2lic $lustre_file -n $node -lv4 -en --no-prefix >> $_oracle || exit 2
 ./lus2lic  $_oracle -n $oracle -ec -o $oracle.ec || exit 2
 ./lurettetop -rp "sut:v6:$lustre_file:$node" -rp "env:lutin:$env" -rp "oracle:ec:$oracle.ec:$oracle" -go -l 10 -ns2c --stop-on-oracle-error || exit 2