diff --git a/src/soc2c.ml b/src/soc2c.ml
index 017d961f198f5b533bc8eee660b7acd4937594e3..fd3a30fecf9ca9c51fd66f89195fe122cd759273 100644
--- a/src/soc2c.ml
+++ b/src/soc2c.ml
@@ -1,4 +1,4 @@
-(* Time-stamp: <modified the 07/07/2014 (at 11:49) by Erwan Jahier> *)
+(* Time-stamp: <modified the 09/07/2014 (at 12:54) by Erwan Jahier> *)
(* let put (os: out_channel) (fmt:('a, unit, string, unit) format4) : 'a = *)
@@ -8,30 +8,6 @@ open Printf
open Soc2cIdent
open Data
-let rec (type_to_string : Data.t -> string -> string) =
- fun v n ->
- (* in order to print arrays of arrays type size in the good order,
- we accumulate the array size when v of of type array, and
- we print it otherwise (finish).
- *)
- let rec finish acc str =
- match acc with
- |[] -> str
- | s::ts -> Printf.sprintf "%s[%d]" (finish ts str) s
- in
- let rec aux acc v n =
- match v with
- | Bool -> finish acc ("_boolean "^n)
- | Int -> finish acc ("_integer "^n)
- | Real-> finish acc ("_real "^n)
- | Extern s -> finish acc ((id2s s)^" "^n)
- | Enum (s, sl) -> finish acc (id2s s ^" "^n)
- | Struct (sid,_) -> finish acc ((id2s sid)^" "^n)
- | Array (ty, sz) -> aux (sz::acc) ty n
- | Alpha nb -> finish acc ("alpha_"^(string_of_int nb)^" "^n)
- | Alias(a,_) -> finish acc (a^" "^n)
- in
- aux [] v n
let rec (type_to_string2 : Data.t -> string) =
fun v ->
@@ -49,39 +25,6 @@ let rec (type_to_string2 : Data.t -> string) =
in
str
-(****************************************************************************)
-let rec (lic_type_to_c: Lic.type_ -> string -> string) =
- fun t n ->
- match t with
- | Lic.Struct_type_eff (name, fl) ->
- let field_to_c (id,(tf,_opt)) =
- Printf.sprintf "\n %s;" (type_to_string (Lic2soc.lic_to_data_type tf) (id2s id))
- in
- ((Printf.sprintf "struct { %s\n }"
- (String.concat "" (List.map field_to_c fl)))^ " " ^ n)
- | Enum_type_eff (name, l) -> "_integer"^ " " ^ n
- | _ -> type_to_string (Lic2soc.lic_to_data_type t) n
-
-
-let rec (lic_type_to_c_old: Lic.type_ -> string -> string) =
- fun t n -> match t with
- | Bool_type_eff -> "_boolean"^ " " ^ n
- | Int_type_eff -> "_integer"^ " " ^ n
- | Real_type_eff -> "_real"^ " " ^ n
- | External_type_eff (name) -> (long2s name)^ " " ^ n
- | Abstract_type_eff (name, t) -> lic_type_to_c t n
- | Enum_type_eff (name, l) -> "_integer"^ " " ^ n
- | Array_type_eff (ty, sz) ->
- Printf.sprintf "%s %s[%d]" (lic_type_to_c ty "") n sz
- | Struct_type_eff (name, fl) ->
- let field_to_c (id,(tf,_opt)) =
- Printf.sprintf " %s %s;\n" (lic_type_to_c tf "") (id2s id)
- in
- (Printf.sprintf "struct %s { %s }"
- (long2s name)
- (String.concat "" (List.map field_to_c fl)))^ " " ^ n
- | TypeVar Any -> assert false
- | (TypeVar AnyNum) -> assert false
let (inline_soc : Soc.key -> bool) =
@@ -108,7 +51,7 @@ let (string_of_soc_key : Soc.key -> string) =
fun (name,_,_) -> (id2s name)
let string_of_flow_decl (id, t) =
- Printf.sprintf " %s;\n" (type_to_string t (id2s id))
+ Printf.sprintf " %s;\n" (Soc2cUtil.type_to_string t (id2s id))
let (is_memory_less : Soc.t -> bool) = SocUtils.is_memory_less
@@ -168,8 +111,6 @@ let (gao2c : Soc.tbl -> 'a soc_pp -> Soc.gao -> unit) =
in
sp.cput (gao2str gao)
-let needs_ext_call = ref false
-
let (step2c : Soc.tbl -> 'a soc_pp -> Soc.step_method -> unit) =
fun stbl sp sm ->
if inline_soc sp.soc.key then () (* don't generate code if inlined *) else
@@ -182,14 +123,12 @@ let (step2c : Soc.tbl -> 'a soc_pp -> Soc.step_method -> unit) =
let ctx_decl = if is_memory_less sp.soc then "" else
Printf.sprintf "%s_type*" (get_ctx_name sp.soc.key)
in
- if sm.impl=Extern then needs_ext_call := true
- else (
+ if sm.impl<>Extern then (
sp.hput (Printf.sprintf "void %s(%s);\n" sname ctx_decl);
sp.cput (Printf.sprintf "void %s(%s){\n" sname ctx);
(match sm.impl with
| Extern -> ()
- | Predef ->
- sp.cput (SocPredef2c.get_key sp.soc.key)
+ | Predef -> sp.cput (SocPredef2c.get_key sp.soc.key)
| Gaol(vl, gaol) -> (
List.iter (fun v -> sp.cput (string_of_flow_decl v)) vl ;
sp.cput "\n";
@@ -290,7 +229,7 @@ let (typedef_of_soc : Soc.t -> string) =
(match soc.memory with
| No_mem -> ""
| Mem t ->
- Printf.sprintf " /*Memory cell*/\n %s ;\n" (id2s (type_to_string t "_memory"))
+ Printf.sprintf " /*Memory cell*/\n %s ;\n" (id2s (Soc2cUtil.type_to_string t "_memory"))
| Mem_hidden -> ""
)
in
@@ -322,6 +261,11 @@ let (find_typedep_nf : Lic.type_ -> Lic.item_key list) =
in
aux true t
+let (is_extern_type: Lic.type_ -> bool) =
+ function
+ | External_type_eff _ -> true
+ | _ -> false
+
let (typedef : LicPrg.t -> Soc.tbl -> Soc.t -> string) =
fun licprg soc_tbl main_soc ->
(* We need to print the ctx typedef a good order
@@ -335,12 +279,12 @@ let (typedef : LicPrg.t -> Soc.tbl -> Soc.t -> string) =
if KeySet.mem soc.key visited then (acc,visited) else
let visited = KeySet.add soc.key visited in
let acc,visited =
- List.fold_left
- (fun (acc,visited) (iname, sk) ->
- let soc = SocUtils.find_no_exc sk soc_tbl in
- soc_with_mem (acc,visited) soc
- )
- (acc,visited) soc.instances
+ List.fold_left
+ (fun (acc,visited) (iname, sk) ->
+ let soc = SocUtils.find_no_exc sk soc_tbl in
+ soc_with_mem (acc,visited) soc
+ )
+ (acc,visited) soc.instances
in
let acc = acc ^ (typedef_of_soc soc) in
acc,visited
@@ -359,12 +303,13 @@ let (typedef : LicPrg.t -> Soc.tbl -> Soc.t -> string) =
List.fold_left memless_soc_to_string "" socs
in
let to_c k t =
- Printf.sprintf "typedef %s;\n" (lic_type_to_c t (long2s k))
+ Printf.sprintf "typedef %s;\n" (Soc2cUtil.lic_type_to_c t (long2s k))
in
let rec (typedef_to_string : Lic.item_key -> Lic.type_ -> string * ItemKeySet.t ->
string * ItemKeySet.t) =
fun k t acc ->
(* topological sort according to type dep *)
+ if is_extern_type t then acc else
if ItemKeySet.mem k (snd acc) then acc else
let type_list = find_typedep_nf t in
let acc = List.fold_left
@@ -372,7 +317,7 @@ let (typedef : LicPrg.t -> Soc.tbl -> Soc.t -> string) =
match LicPrg.find_type licprg k with
| Some t -> typedef_to_string k t acc
| None -> acc (* occurs ? *)
- )
+ )
acc type_list
in
((fst acc)^(to_c k t), ItemKeySet.add k (snd acc))
@@ -383,7 +328,8 @@ let (typedef : LicPrg.t -> Soc.tbl -> Soc.t -> string) =
^"// Memoryless soc ctx typedef \n"^soc_ctx_typedef_without
^"// Memoryfull soc ctx typedef \n"^soc_ctx_typedef_with
-
+
+
(****************************************************************************)
let rec (const_to_c: Lic.const -> string) =
@@ -410,10 +356,11 @@ let rec (const_to_c: Lic.const -> string) =
)
| Tuple_const_eff cl -> assert false
-
let (constdef : LicPrg.t -> string) =
fun licprg ->
- let to_c k c =
+ let to_c k = function
+ | Lic.Extern_const_eff _ -> ""
+ | c ->
Printf.sprintf "#define %s %s\n"
(* Printf.sprintf "const %s = %s;\n" *)
(long2s k)
@@ -421,6 +368,7 @@ let (constdef : LicPrg.t -> string) =
in
LicPrg.fold_consts (fun k t acc -> acc ^ (to_c k t)) licprg "\n// Constant definitions \n"
+
(****************************************************************************)
let (gen_memoryless_ctx : Soc.tbl -> string) =
@@ -592,11 +540,13 @@ let (f : Lv6MainArgs.t -> Soc.key -> Soc.tbl -> LicPrg.t -> unit) =
fun args msoc stbl licprg ->
let socs = Soc.SocMap.bindings stbl in
let socs = snd (List.split socs) in
- (* XXX que fait-on pour les soc predef ? *)
- (* let _, socs = List.partition is_predef socs in *)
+ (* XXX que fait-on pour les soc predef ? *)
+ (* let _, socs = List.partition is_predef socs in *)
let base = string_of_soc_key msoc in
let hfile = base ^ ".h" in
let cfile = base ^ ".c" in
+ let ext_cfile = Printf.sprintf "%s_ext.c" base in
+ let ext_hfile = Printf.sprintf "%s_ext.h" base in
let loopfile = base^"_loop.c" in
let occ = open_out cfile in
let och = open_out hfile in
@@ -605,9 +555,13 @@ let (f : Lv6MainArgs.t -> Soc.key -> Soc.tbl -> LicPrg.t -> unit) =
let putc s = output_string occ s ; flush occ in
let puth s = output_string och s ; flush och in
let main_soc = Soc.SocMap.find msoc stbl in
+ (* Generate ext files if necessary *)
+ let needs_cfile, needs_hfile =
+ Soc2cExtern.gen_files main_soc stbl licprg ext_cfile ext_hfile hfile
+ in
+
Lv6util.entete occ "/*" "*/" ;
Lv6util.entete och "/*" "*/";
-
gen_loop_file main_soc ocl stbl;
output_string och "
@@ -629,19 +583,21 @@ typedef float _float;
";
+ if needs_hfile then puth (Printf.sprintf "#include \"%s\"\n" ext_hfile);
puth (Printf.sprintf "#ifndef _%s_LUS2LIC_H_HILE\n" base);
puth (Printf.sprintf "#define _%s_LUS2LIC_H_HILE\n" base);
putc (Printf.sprintf "#include \"%s\"\n" hfile);
puth (typedef licprg stbl main_soc );
putc (constdef licprg);
+ putc (Soc2cExtern.cpy_declaration licprg);
+ putc (Soc2cExtern.const_declaration licprg);
puth "/////////////////////////////////////////////////\n";
puth "//// Static allocation of memoryless soc ctx\n";
List.iter (soc2c 1 och occ stbl) socs;
puth "/////////////////////////////////////////////////\n";
putc "//// Defining step functions\n";
List.iter (soc2c 2 och occ stbl) socs;
- if !needs_ext_call then (puth (Printf.sprintf "#include \"%s_ext.h\"\n" base));
puth "#endif\n";
flush occ; close_out occ;
flush och; close_out och;
@@ -649,7 +605,10 @@ typedef float _float;
Printf.printf "%s has been generated.\n" loopfile;
Printf.printf "%s has been generated.\n" hfile;
Printf.printf "%s has been generated.\n" cfile;
- let base = (string_of_soc_key main_soc.key) in
- let loopfile = base^"_loop.c" in
- Printf.printf "you can compile those files doing, e.g.,\n gcc %s %s\n" cfile loopfile;
+
+ if needs_cfile then
+ Printf.printf "you can compile those files doing, e.g.,\n gcc %s %s %s\n"
+ cfile ext_cfile loopfile
+ else
+ Printf.printf "you can compile those files doing, e.g.,\n gcc %s %s\n" cfile loopfile;
flush stdout
diff --git a/src/soc2cExtern.ml b/src/soc2cExtern.ml
new file mode 100644
index 0000000000000000000000000000000000000000..5265b29d4e80aecb9152829d2b005f17be3db0e4
--- /dev/null
+++ b/src/soc2cExtern.ml
@@ -0,0 +1,144 @@
+(* Time-stamp: <modified the 09/07/2014 (at 12:17) by Erwan Jahier> *)
+
+open Soc2cIdent
+
+let (is_extern_type: Lic.type_ -> bool) =
+ function
+ | Lic.External_type_eff _ -> true
+ | _ -> false
+
+let (is_extern_const: Lic.const -> bool) =
+ function
+ | Lic.Extern_const_eff _ -> true
+ | _ -> false
+
+let (type_decl : LicPrg.t -> string) =
+ fun prg ->
+ let type_to_string k t acc =
+ if is_extern_type t then
+ Printf.sprintf "%s\ntypedef FAKE_TYPE_DEF_2FIX %s;" acc (long2s k)
+ else acc
+ in
+ let preambule = "\n/* XXX FIXME: The following types must be defined/fixed */" ^
+ "\n#define FAKE_TYPE_DEF_2FIX int"
+ in
+ (LicPrg.fold_types type_to_string prg preambule)^"\n"
+
+let (cpy_def : LicPrg.t -> string) =
+ fun prg ->
+ let type_to_string k t acc =
+ match t with
+ | Lic.External_type_eff t ->
+ Printf.sprintf "%s\nvoid _assign_%s(%s* x,%s y){}" acc (long2s k) (long2s k) (long2s k)
+ | _ -> acc
+ in
+ let preambule = "\n/* XXX FIXME: The following copy functions must be defined/fixed */" in
+ (LicPrg.fold_types type_to_string prg preambule)^"\n"
+
+(* exported *)
+let (cpy_declaration : LicPrg.t -> string) =
+ fun prg ->
+ let type_to_string k t acc =
+ match t with
+ | Lic.External_type_eff t ->
+ Printf.sprintf "%s\nextern void _assign_%s(%s*,%s);" acc (long2s k) (long2s k) (long2s k)
+ | _ -> acc
+ in
+ let preambule = "/* */\n" in
+ (LicPrg.fold_types type_to_string prg preambule)^"\n"
+
+let (cpy_decl : LicPrg.t -> string) =
+ fun prg ->
+ let type_to_string k t acc =
+ match t with
+ | Lic.External_type_eff t ->
+ Printf.sprintf "%s\nvoid _assign_%s(%s*,%s);" acc (long2s k) (long2s k) (long2s k)
+ | _ -> acc
+ in
+ let preambule = "/* */\n" in
+ (LicPrg.fold_types type_to_string prg preambule)^"\n"
+
+
+let (const_def : LicPrg.t -> string) =
+ fun prg ->
+ let const_to_string k c acc =
+ match c with
+ | Lic.Extern_const_eff(_,t) ->
+ let t = Soc2cUtil.lic_type_to_c t (long2s k) in
+ Printf.sprintf "%s\n%s=FAKE_CONST_DEF_2FIX;" acc t
+ | _ -> acc
+ in
+ let preambule = "\n/* XXX FIXME: The following const def must be defined/fixed */" ^
+ "\n#define FAKE_CONST_DEF_2FIX 1" in
+ (LicPrg.fold_consts const_to_string prg preambule)^"\n"
+
+(* exported *)
+let (const_declaration : LicPrg.t -> string) =
+ fun prg ->
+ let const_to_string k c acc =
+ match c with
+ | Lic.Extern_const_eff(_,t) ->
+ let t = Soc2cUtil.lic_type_to_c t (long2s k) in
+ Printf.sprintf "%s\nextern %s;" acc t
+ | _ -> acc
+ in
+ let preambule = "/* */\n" in
+ (LicPrg.fold_consts const_to_string prg preambule)^"\n"
+
+open Soc
+
+let (gen_files : Soc.t -> Soc.tbl -> LicPrg.t -> string -> string-> string -> bool * bool) =
+ fun msoc stbl licprg ext_cfile ext_hfile hfile ->
+ let extern_steps = SocMap.fold
+ (fun sk soc acc ->
+ List.fold_left (fun acc sm -> if sm.impl=Extern then (sm,soc)::acc else acc)
+ acc soc.step
+ )
+ stbl []
+ in
+ let extern_types = LicPrg.fold_types
+ (fun _ t acc -> match t with External_type_eff et -> et::acc | _ -> acc)
+ licprg []
+ in
+ let extern_consts = LicPrg.fold_consts
+ (fun _ c acc -> match c with Extern_const_eff(ec,_) -> ec::acc | _ -> acc)
+ licprg []
+ in
+ let needs_cfile = extern_steps <> [] in
+ let needs_hfile = needs_cfile || extern_types<>[] || extern_consts<>[] in
+
+ if not (Sys.file_exists ext_hfile) then (
+ let ext_och = open_out ext_hfile in
+ output_string ext_och (type_decl licprg);
+ output_string ext_och (cpy_decl licprg);
+ List.iter (fun (sm,soc) ->
+ let sname = Soc2cUtil.step_name soc.key sm.name in
+ if SocUtils.is_memory_less soc then
+ output_string ext_och (Printf.sprintf "void %s();\n" sname)
+ else
+ let ctx = get_ctx_name soc.key in
+ output_string ext_och (Printf.sprintf "void %s(%s*);\n" sname ctx)
+ ) extern_steps;
+ close_out ext_och;
+ print_string (Printf.sprintf "%s has been generated.\n" ext_hfile);
+
+ );
+ if not (Sys.file_exists ext_cfile) then (
+ let ext_occ = open_out ext_cfile in
+ output_string ext_occ (Printf.sprintf "#include \"%s\"\n" hfile);
+ output_string ext_occ (cpy_def licprg);
+ output_string ext_occ (const_def licprg);
+ List.iter (fun (sm,soc) ->
+ let sname = Soc2cUtil.step_name soc.key sm.name in
+ if SocUtils.is_memory_less soc then
+ output_string ext_occ (Printf.sprintf "void %s(){\n /* finish me! */\n}\n" sname)
+ else
+ let ctx = get_ctx_name soc.key in
+ output_string ext_occ (
+ Printf.sprintf "void %s(%s* ctx){\n \\\\ finish me!\n}\n" sname ctx)
+ ) extern_steps;
+ close_out ext_occ;
+ print_string (Printf.sprintf "%s has been generated.\n" ext_cfile);
+ );
+ needs_cfile, needs_hfile
+
diff --git a/src/soc2cExtern.mli b/src/soc2cExtern.mli
new file mode 100644
index 0000000000000000000000000000000000000000..95ff1c9c222e963f5c482f0194668ef48b6d7d62
--- /dev/null
+++ b/src/soc2cExtern.mli
@@ -0,0 +1,24 @@
+(* Time-stamp: <modified the 09/07/2014 (at 11:06) by Erwan Jahier> *)
+
+
+(* [gen_files main_soc licprg cfile hfile] returns a pair of bool that
+ states if an extern C file (LHS) and an extern header file (RHS)
+ are necessary to compile the main soc.
+
+ A C file is necessary if an extern step exists.
+ A header file in necessary if an extern step, const, or types exists.
+
+ As a side effect, and as its name suggests, this function also
+ generates files, cfile and hfile, if they do not already exist in
+ the current directory.
+
+ nb: In order to ease the non reg tests, I've chosen to define
+ extern types as int, and empty step function that compiles, and to
+ add "XXX" comments where fixes are required. Is it really a good
+ idea ?
+*)
+val gen_files : Soc.t -> Soc.tbl -> LicPrg.t -> string -> string -> string -> bool * bool
+
+val cpy_declaration : LicPrg.t -> string
+val const_declaration : LicPrg.t -> string
+
diff --git a/src/soc2cUtil.ml b/src/soc2cUtil.ml
index 8a36b0c62a4f0eca2deb9ac91bc1f867b07b5517..ec1ff5c7240a55ed3a3cb2f770d7fafd6f8d6210 100644
--- a/src/soc2cUtil.ml
+++ b/src/soc2cUtil.ml
@@ -1,4 +1,4 @@
-(* Time-stamp: <modified the 01/07/2014 (at 09:43) by Erwan Jahier> *)
+(* Time-stamp: <modified the 09/07/2014 (at 11:48) by Erwan Jahier> *)
open Soc2cIdent
@@ -40,7 +40,7 @@ let rec (gen_assign : Data.t -> string -> string -> string -> string) =
| Extern (id) ->
(* what should i do for extern types? Ask the user to provide the
copy function I guess *)
- Printf.sprintf " cpy_%s(%s, %s);\n" id vi vo
+ Printf.sprintf " _assign_%s(&%s, %s);\n" (id2s id) vi vo
let (gen_assign_var_expr : Soc.t -> Soc.var_expr -> Soc.var_expr -> string) =
fun soc vi vo ->
@@ -128,4 +128,66 @@ let (gen_step_call : Soc.t -> Soc.t -> Soc.var_expr list -> Soc.var_expr list ->
(si_str ^ str ^ so_str)
+(****************************************************************************)
+open Data
+
+let rec (type_to_string : Data.t -> string -> string) =
+ fun v n ->
+ (* in order to print arrays of arrays type size in the good order,
+ we accumulate the array size when v of of type array, and
+ we print it otherwise (finish).
+ *)
+ let rec finish acc str =
+ match acc with
+ |[] -> str
+ | s::ts -> Printf.sprintf "%s[%d]" (finish ts str) s
+ in
+ let rec aux acc v n =
+ match v with
+ | Bool -> finish acc ("_boolean "^n)
+ | Int -> finish acc ("_integer "^n)
+ | Real-> finish acc ("_real "^n)
+ | Extern s -> finish acc ((id2s s)^" "^n)
+ | Enum (s, sl) -> finish acc (id2s s ^" "^n)
+ | Struct (sid,_) -> finish acc ((id2s sid)^" "^n)
+ | Array (ty, sz) -> aux (sz::acc) ty n
+ | Alpha nb -> finish acc ("alpha_"^(string_of_int nb)^" "^n)
+ | Alias(a,_) -> finish acc (a^" "^n)
+ in
+ aux [] v n
+
+
+let rec (lic_type_to_c: Lic.type_ -> string -> string) =
+ fun t n ->
+ match t with
+ | Lic.Struct_type_eff (name, fl) ->
+ let field_to_c (id,(tf,_opt)) =
+ Printf.sprintf "\n %s;" (type_to_string (Lic2soc.lic_to_data_type tf) (id2s id))
+ in
+ ((Printf.sprintf "struct { %s\n }"
+ (String.concat "" (List.map field_to_c fl)))^ " " ^ n)
+ | Enum_type_eff (name, l) -> "_integer"^ " " ^ n
+ | _ -> type_to_string (Lic2soc.lic_to_data_type t) n
+
+
+let rec (lic_type_to_c_old: Lic.type_ -> string -> string) =
+ fun t n -> match t with
+ | Bool_type_eff -> "_boolean"^ " " ^ n
+ | Int_type_eff -> "_integer"^ " " ^ n
+ | Real_type_eff -> "_real"^ " " ^ n
+ | External_type_eff (name) -> (long2s name)^ " " ^ n
+ | Abstract_type_eff (name, t) -> lic_type_to_c t n
+ | Enum_type_eff (name, l) -> "_integer"^ " " ^ n
+ | Array_type_eff (ty, sz) ->
+ Printf.sprintf "%s %s[%d]" (lic_type_to_c ty "") n sz
+ | Struct_type_eff (name, fl) ->
+ let field_to_c (id,(tf,_opt)) =
+ Printf.sprintf " %s %s;\n" (lic_type_to_c tf "") (id2s id)
+ in
+ (Printf.sprintf "struct %s { %s }"
+ (long2s name)
+ (String.concat "" (List.map field_to_c fl)))^ " " ^ n
+ | TypeVar Any -> assert false
+ | (TypeVar AnyNum) -> assert false
+
diff --git a/test/Makefile b/test/Makefile
index d5b8b3a5e934c191e8b89244005db3c9aae59418..f49d8db6b523e3e571d5acfc52f9fe4511b2bdc1 100644
--- a/test/Makefile
+++ b/test/Makefile
@@ -15,7 +15,7 @@ ltop:
copy_extern:
- cp extern_files/* .
+ cp -f extern_files/* .
testdir=$(shell pwd)
diff --git a/test/lus2lic.sum b/test/lus2lic.sum
index edd17412b717413d86aaf4321e70aeffe392814d..4a560434a1088ab4799f32775dd83b57e69c3e2b 100644
--- a/test/lus2lic.sum
+++ b/test/lus2lic.sum
@@ -1,4 +1,4 @@
-Test Run By jahier on Mon Jul 7 11:37:24 2014
+Test Run By jahier on Wed Jul 9 12:54:34 2014
Native configuration is i686-pc-linux-gnu
=== lus2lic tests ===
@@ -14,205 +14,205 @@ PASS: ./lus2lic {-ec -o /tmp/nc6.ec should_work/nc6.lus}
PASS: ./myec2c {-o /tmp/nc6.c /tmp/nc6.ec}
PASS: ../utils/test_lus2lic_no_node should_work/nc6.lus
PASS: ./lus2lic {-2c should_work/nc6.lus -n nc6}
-PASS: gcc nc6_nc6.c nc6_nc6_loop.c
+PASS: gcc nc6_nc6.c nc6_nc6_ext.c nc6_nc6_loop.c
PASS: ./lus2lic {-o /tmp/argos.lic should_work/argos.lus}
PASS: ./lus2lic {-ec -o /tmp/argos.ec should_work/argos.lus}
PASS: ./myec2c {-o /tmp/argos.c /tmp/argos.ec}
PASS: ../utils/test_lus2lic_no_node should_work/argos.lus
PASS: ./lus2lic {-2c should_work/argos.lus -n argos}
-PASS: gcc argos_argos.c argos_argos_loop.c
+PASS: gcc argos_argos.c argos_argos_ext.c argos_argos_loop.c
PASS: ./lus2lic {-o /tmp/ck5.lic should_work/ck5.lus}
PASS: ./lus2lic {-ec -o /tmp/ck5.ec should_work/ck5.lus}
PASS: ./myec2c {-o /tmp/ck5.c /tmp/ck5.ec}
PASS: ../utils/test_lus2lic_no_node should_work/ck5.lus
PASS: ./lus2lic {-2c should_work/ck5.lus -n ck5}
-PASS: gcc ck5_ck5.c ck5_ck5_loop.c
+PASS: gcc ck5_ck5.c ck5_ck5_ext.c ck5_ck5_loop.c
PASS: ./lus2lic {-o /tmp/normal.lic should_work/normal.lus}
PASS: ./lus2lic {-ec -o /tmp/normal.ec should_work/normal.lus}
PASS: ./myec2c {-o /tmp/normal.c /tmp/normal.ec}
PASS: ../utils/test_lus2lic_no_node should_work/normal.lus
PASS: ./lus2lic {-2c should_work/normal.lus -n normal}
-PASS: gcc normal_normal.c normal_normal_loop.c
+PASS: gcc normal_normal.c normal_normal_ext.c normal_normal_loop.c
PASS: ./lus2lic {-o /tmp/nodeparam.lic should_work/nodeparam.lus}
PASS: ./lus2lic {-ec -o /tmp/nodeparam.ec should_work/nodeparam.lus}
PASS: ./myec2c {-o /tmp/nodeparam.c /tmp/nodeparam.ec}
PASS: ../utils/test_lus2lic_no_node should_work/nodeparam.lus
PASS: ./lus2lic {-2c should_work/nodeparam.lus -n nodeparam}
-PASS: gcc nodeparam_nodeparam.c nodeparam_nodeparam_loop.c
+PASS: gcc nodeparam_nodeparam.c nodeparam_nodeparam_ext.c nodeparam_nodeparam_loop.c
PASS: ./lus2lic {-o /tmp/enum0.lic should_work/enum0.lus}
PASS: ./lus2lic {-ec -o /tmp/enum0.ec should_work/enum0.lus}
PASS: ./myec2c {-o /tmp/enum0.c /tmp/enum0.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/enum0.lus
PASS: ./lus2lic {-2c should_work/enum0.lus -n enum0}
-PASS: gcc enum0_enum0.c enum0_enum0_loop.c
+PASS: gcc enum0_enum0.c enum0_enum0_ext.c enum0_enum0_loop.c
PASS: ./lus2lic {-o /tmp/ck6.lic should_work/ck6.lus}
PASS: ./lus2lic {-ec -o /tmp/ck6.ec should_work/ck6.lus}
PASS: ./myec2c {-o /tmp/ck6.c /tmp/ck6.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/ck6.lus
PASS: ./lus2lic {-2c should_work/ck6.lus -n ck6}
-FAIL: Check that the generated C code compiles : gcc ck6_ck6.c ck6_ck6_loop.c
+PASS: gcc ck6_ck6.c ck6_ck6_ext.c ck6_ck6_loop.c
PASS: ./lus2lic {-o /tmp/Gyroscope2.lic should_work/Gyroscope2.lus}
PASS: ./lus2lic {-ec -o /tmp/Gyroscope2.ec should_work/Gyroscope2.lus}
PASS: ./myec2c {-o /tmp/Gyroscope2.c /tmp/Gyroscope2.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/Gyroscope2.lus
PASS: ./lus2lic {-2c should_work/Gyroscope2.lus -n Gyroscope2}
-PASS: gcc Gyroscope2_Gyroscope2.c Gyroscope2_Gyroscope2_loop.c
+PASS: gcc Gyroscope2_Gyroscope2.c Gyroscope2_Gyroscope2_ext.c Gyroscope2_Gyroscope2_loop.c
PASS: ./lus2lic {-o /tmp/mouse2.lic should_work/mouse2.lus}
PASS: ./lus2lic {-ec -o /tmp/mouse2.ec should_work/mouse2.lus}
PASS: ./myec2c {-o /tmp/mouse2.c /tmp/mouse2.ec}
PASS: ../utils/test_lus2lic_no_node should_work/mouse2.lus
PASS: ./lus2lic {-2c should_work/mouse2.lus -n mouse2}
-PASS: gcc mouse2_mouse2.c mouse2_mouse2_loop.c
+PASS: gcc mouse2_mouse2.c mouse2_mouse2_ext.c mouse2_mouse2_loop.c
PASS: ./lus2lic {-o /tmp/dep.lic should_work/dep.lus}
PASS: ./lus2lic {-ec -o /tmp/dep.ec should_work/dep.lus}
PASS: ./myec2c {-o /tmp/dep.c /tmp/dep.ec}
PASS: ../utils/test_lus2lic_no_node should_work/dep.lus
PASS: ./lus2lic {-2c should_work/dep.lus -n dep}
-PASS: gcc dep_dep.c dep_dep_loop.c
+PASS: gcc dep_dep.c dep_dep_ext.c dep_dep_loop.c
PASS: ./lus2lic {-o /tmp/ELMU.lic should_work/ELMU.lus}
PASS: ./lus2lic {-ec -o /tmp/ELMU.ec should_work/ELMU.lus}
PASS: ./myec2c {-o /tmp/ELMU.c /tmp/ELMU.ec}
PASS: ../utils/test_lus2lic_no_node should_work/ELMU.lus
PASS: ./lus2lic {-2c should_work/ELMU.lus -n ELMU}
-PASS: gcc ELMU_ELMU.c ELMU_ELMU_loop.c
+PASS: gcc ELMU_ELMU.c ELMU_ELMU_ext.c ELMU_ELMU_loop.c
PASS: ./lus2lic {-o /tmp/testPilote.lic should_work/testPilote.lus}
PASS: ./lus2lic {-ec -o /tmp/testPilote.ec should_work/testPilote.lus}
PASS: ./myec2c {-o /tmp/testPilote.c /tmp/testPilote.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/testPilote.lus
PASS: ./lus2lic {-2c should_work/testPilote.lus -n testPilote}
-PASS: gcc testPilote_testPilote.c testPilote_testPilote_loop.c
+PASS: gcc testPilote_testPilote.c testPilote_testPilote_ext.c testPilote_testPilote_loop.c
PASS: ./lus2lic {-o /tmp/redIf.lic should_work/redIf.lus}
PASS: ./lus2lic {-ec -o /tmp/redIf.ec should_work/redIf.lus}
PASS: ./myec2c {-o /tmp/redIf.c /tmp/redIf.ec}
PASS: ../utils/test_lus2lic_no_node should_work/redIf.lus
PASS: ./lus2lic {-2c should_work/redIf.lus -n redIf}
-PASS: gcc redIf_redIf.c redIf_redIf_loop.c
+PASS: gcc redIf_redIf.c redIf_redIf_ext.c redIf_redIf_loop.c
PASS: ./lus2lic {-o /tmp/t0.lic should_work/t0.lus}
PASS: ./lus2lic {-ec -o /tmp/t0.ec should_work/t0.lus}
PASS: ./myec2c {-o /tmp/t0.c /tmp/t0.ec}
PASS: ../utils/test_lus2lic_no_node should_work/t0.lus
PASS: ./lus2lic {-2c should_work/t0.lus -n t0}
-PASS: gcc t0_t0.c t0_t0_loop.c
+PASS: gcc t0_t0.c t0_t0_ext.c t0_t0_loop.c
PASS: ./lus2lic {-o /tmp/lucky.lic should_work/lucky.lus}
PASS: ./lus2lic {-ec -o /tmp/lucky.ec should_work/lucky.lus}
PASS: ./myec2c {-o /tmp/lucky.c /tmp/lucky.ec}
PASS: ../utils/test_lus2lic_no_node should_work/lucky.lus
PASS: ./lus2lic {-2c should_work/lucky.lus -n lucky}
-PASS: gcc lucky_lucky.c lucky_lucky_loop.c
+PASS: gcc lucky_lucky.c lucky_lucky_ext.c lucky_lucky_loop.c
PASS: ./lus2lic {-o /tmp/heater_control.lic should_work/heater_control.lus}
PASS: ./lus2lic {-ec -o /tmp/heater_control.ec should_work/heater_control.lus}
PASS: ./myec2c {-o /tmp/heater_control.c /tmp/heater_control.ec}
PASS: ../utils/test_lus2lic_no_node should_work/heater_control.lus
PASS: ./lus2lic {-2c should_work/heater_control.lus -n heater_control}
-PASS: gcc heater_control_heater_control.c heater_control_heater_control_loop.c
+PASS: gcc heater_control_heater_control.c heater_control_heater_control_ext.c heater_control_heater_control_loop.c
PASS: ./lus2lic {-o /tmp/titi.lic should_work/titi.lus}
PASS: ./lus2lic {-ec -o /tmp/titi.ec should_work/titi.lus}
PASS: ./myec2c {-o /tmp/titi.c /tmp/titi.ec}
PASS: ../utils/test_lus2lic_no_node should_work/titi.lus
PASS: ./lus2lic {-2c should_work/titi.lus -n titi}
-PASS: gcc titi_titi.c titi_titi_loop.c
+PASS: gcc titi_titi.c titi_titi_ext.c titi_titi_loop.c
PASS: ./lus2lic {-o /tmp/cminus.lic should_work/cminus.lus}
PASS: ./lus2lic {-ec -o /tmp/cminus.ec should_work/cminus.lus}
PASS: ./myec2c {-o /tmp/cminus.c /tmp/cminus.ec}
PASS: ../utils/test_lus2lic_no_node should_work/cminus.lus
PASS: ./lus2lic {-2c should_work/cminus.lus -n cminus}
-PASS: gcc cminus_cminus.c cminus_cminus_loop.c
+PASS: gcc cminus_cminus.c cminus_cminus_ext.c cminus_cminus_loop.c
PASS: ./lus2lic {-o /tmp/rs.lic should_work/rs.lus}
PASS: ./lus2lic {-ec -o /tmp/rs.ec should_work/rs.lus}
PASS: ./myec2c {-o /tmp/rs.c /tmp/rs.ec}
PASS: ../utils/test_lus2lic_no_node should_work/rs.lus
PASS: ./lus2lic {-2c should_work/rs.lus -n rs}
-PASS: gcc rs_rs.c rs_rs_loop.c
+PASS: gcc rs_rs.c rs_rs_ext.c rs_rs_loop.c
PASS: ./lus2lic {-o /tmp/access.lic should_work/access.lus}
PASS: ./lus2lic {-ec -o /tmp/access.ec should_work/access.lus}
PASS: ./myec2c {-o /tmp/access.c /tmp/access.ec}
PASS: ../utils/test_lus2lic_no_node should_work/access.lus
PASS: ./lus2lic {-2c should_work/access.lus -n access}
-PASS: gcc access_access.c access_access_loop.c
+PASS: gcc access_access.c access_access_ext.c access_access_loop.c
PASS: ./lus2lic {-o /tmp/consensus2.lic should_work/consensus2.lus}
PASS: ./lus2lic {-ec -o /tmp/consensus2.ec should_work/consensus2.lus}
PASS: ./myec2c {-o /tmp/consensus2.c /tmp/consensus2.ec}
PASS: ../utils/test_lus2lic_no_node should_work/consensus2.lus
PASS: ./lus2lic {-2c should_work/consensus2.lus -n consensus2}
-PASS: gcc consensus2_consensus2.c consensus2_consensus2_loop.c
+PASS: gcc consensus2_consensus2.c consensus2_consensus2_ext.c consensus2_consensus2_loop.c
PASS: ./lus2lic {-o /tmp/dependeur.lic should_work/dependeur.lus}
PASS: ./lus2lic {-ec -o /tmp/dependeur.ec should_work/dependeur.lus}
PASS: ./myec2c {-o /tmp/dependeur.c /tmp/dependeur.ec}
PASS: ../utils/test_lus2lic_no_node should_work/dependeur.lus
PASS: ./lus2lic {-2c should_work/dependeur.lus -n dependeur}
-PASS: gcc dependeur_dependeur.c dependeur_dependeur_loop.c
+PASS: gcc dependeur_dependeur.c dependeur_dependeur_ext.c dependeur_dependeur_loop.c
PASS: ./lus2lic {-o /tmp/mappredef.lic should_work/mappredef.lus}
PASS: ./lus2lic {-ec -o /tmp/mappredef.ec should_work/mappredef.lus}
PASS: ./myec2c {-o /tmp/mappredef.c /tmp/mappredef.ec}
PASS: ../utils/test_lus2lic_no_node should_work/mappredef.lus
PASS: ./lus2lic {-2c should_work/mappredef.lus -n mappredef}
-PASS: gcc mappredef_mappredef.c mappredef_mappredef_loop.c
+PASS: gcc mappredef_mappredef.c mappredef_mappredef_ext.c mappredef_mappredef_loop.c
PASS: ./lus2lic {-o /tmp/call06.lic should_work/call06.lus}
PASS: ./lus2lic {-ec -o /tmp/call06.ec should_work/call06.lus}
PASS: ./myec2c {-o /tmp/call06.c /tmp/call06.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/call06.lus
PASS: ./lus2lic {-2c should_work/call06.lus -n call06}
-FAIL: Check that the generated C code compiles : gcc call06_call06.c call06_call06_loop.c
+PASS: gcc call06_call06.c call06_call06_ext.c call06_call06_loop.c
PASS: ./lus2lic {-o /tmp/deSimone.lic should_work/deSimone.lus}
PASS: ./lus2lic {-ec -o /tmp/deSimone.ec should_work/deSimone.lus}
PASS: ./myec2c {-o /tmp/deSimone.c /tmp/deSimone.ec}
PASS: ../utils/test_lus2lic_no_node should_work/deSimone.lus
PASS: ./lus2lic {-2c should_work/deSimone.lus -n deSimone}
-PASS: gcc deSimone_deSimone.c deSimone_deSimone_loop.c
+PASS: gcc deSimone_deSimone.c deSimone_deSimone_ext.c deSimone_deSimone_loop.c
PASS: ./lus2lic {-o /tmp/bug2.lic should_work/bug2.lus}
PASS: ./lus2lic {-ec -o /tmp/bug2.ec should_work/bug2.lus}
PASS: ./myec2c {-o /tmp/bug2.c /tmp/bug2.ec}
PASS: ../utils/test_lus2lic_no_node should_work/bug2.lus
PASS: ./lus2lic {-2c should_work/bug2.lus -n bug2}
-PASS: gcc bug2_bug2.c bug2_bug2_loop.c
+PASS: gcc bug2_bug2.c bug2_bug2_ext.c bug2_bug2_loop.c
PASS: ./lus2lic {-o /tmp/mm.lic should_work/mm.lus}
PASS: ./lus2lic {-ec -o /tmp/mm.ec should_work/mm.lus}
PASS: ./myec2c {-o /tmp/mm.c /tmp/mm.ec}
PASS: ../utils/test_lus2lic_no_node should_work/mm.lus
PASS: ./lus2lic {-2c should_work/mm.lus -n mm}
-PASS: gcc mm_mm.c mm_mm_loop.c
+PASS: gcc mm_mm.c mm_mm_ext.c mm_mm_loop.c
PASS: ./lus2lic {-o /tmp/yyy.lic should_work/yyy.lus}
PASS: ./lus2lic {-ec -o /tmp/yyy.ec should_work/yyy.lus}
PASS: ./myec2c {-o /tmp/yyy.c /tmp/yyy.ec}
PASS: ../utils/test_lus2lic_no_node should_work/yyy.lus
PASS: ./lus2lic {-2c should_work/yyy.lus -n yyy}
-PASS: gcc yyy_yyy.c yyy_yyy_loop.c
+PASS: gcc yyy_yyy.c yyy_yyy_ext.c yyy_yyy_loop.c
PASS: ./lus2lic {-o /tmp/toolate.lic should_work/toolate.lus}
PASS: ./lus2lic {-ec -o /tmp/toolate.ec should_work/toolate.lus}
PASS: ./myec2c {-o /tmp/toolate.c /tmp/toolate.ec}
PASS: ../utils/test_lus2lic_no_node should_work/toolate.lus
PASS: ./lus2lic {-2c should_work/toolate.lus -n toolate}
-PASS: gcc toolate_toolate.c toolate_toolate_loop.c
+PASS: gcc toolate_toolate.c toolate_toolate_ext.c toolate_toolate_loop.c
PASS: ./lus2lic {-o /tmp/testCapt.lic should_work/testCapt.lus}
PASS: ./lus2lic {-ec -o /tmp/testCapt.ec should_work/testCapt.lus}
PASS: ./myec2c {-o /tmp/testCapt.c /tmp/testCapt.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/testCapt.lus
PASS: ./lus2lic {-2c should_work/testCapt.lus -n testCapt}
-PASS: gcc testCapt_testCapt.c testCapt_testCapt_loop.c
+PASS: gcc testCapt_testCapt.c testCapt_testCapt_ext.c testCapt_testCapt_loop.c
PASS: ./lus2lic {-o /tmp/nc7.lic should_work/nc7.lus}
PASS: ./lus2lic {-ec -o /tmp/nc7.ec should_work/nc7.lus}
PASS: ./myec2c {-o /tmp/nc7.c /tmp/nc7.ec}
PASS: ../utils/test_lus2lic_no_node should_work/nc7.lus
PASS: ./lus2lic {-2c should_work/nc7.lus -n nc7}
-PASS: gcc nc7_nc7.c nc7_nc7_loop.c
+PASS: gcc nc7_nc7.c nc7_nc7_ext.c nc7_nc7_loop.c
PASS: ./lus2lic {-o /tmp/predefOp.lic should_work/predefOp.lus}
PASS: ./lus2lic {-ec -o /tmp/predefOp.ec should_work/predefOp.lus}
PASS: ./myec2c {-o /tmp/predefOp.c /tmp/predefOp.ec}
PASS: ../utils/test_lus2lic_no_node should_work/predefOp.lus
PASS: ./lus2lic {-2c should_work/predefOp.lus -n predefOp}
-PASS: gcc predefOp_predefOp.c predefOp_predefOp_loop.c
+PASS: gcc predefOp_predefOp.c predefOp_predefOp_ext.c predefOp_predefOp_loop.c
PASS: ./lus2lic {-o /tmp/t1.lic should_work/t1.lus}
PASS: ./lus2lic {-ec -o /tmp/t1.ec should_work/t1.lus}
PASS: ./myec2c {-o /tmp/t1.c /tmp/t1.ec}
PASS: ../utils/test_lus2lic_no_node should_work/t1.lus
PASS: ./lus2lic {-2c should_work/t1.lus -n t1}
-PASS: gcc t1_t1.c t1_t1_loop.c
+PASS: gcc t1_t1.c t1_t1_ext.c t1_t1_loop.c
PASS: ./lus2lic {-o /tmp/nc9.lic should_work/nc9.lus}
PASS: ./lus2lic {-ec -o /tmp/nc9.ec should_work/nc9.lus}
PASS: ./myec2c {-o /tmp/nc9.c /tmp/nc9.ec}
PASS: ../utils/test_lus2lic_no_node should_work/nc9.lus
PASS: ./lus2lic {-2c should_work/nc9.lus -n nc9}
-PASS: gcc nc9_nc9.c nc9_nc9_loop.c
+PASS: gcc nc9_nc9.c nc9_nc9_ext.c nc9_nc9_loop.c
PASS: ./lus2lic {-o /tmp/packageTableau.lic should_work/packageTableau.lus}
PASS: ./lus2lic {-ec -o /tmp/packageTableau.ec should_work/packageTableau.lus}
PASS: ./myec2c {-o /tmp/packageTableau.c /tmp/packageTableau.ec}
@@ -223,49 +223,49 @@ PASS: ./lus2lic {-ec -o /tmp/test_poly.ec should_work/test_poly.lus}
PASS: ./myec2c {-o /tmp/test_poly.c /tmp/test_poly.ec}
PASS: ../utils/test_lus2lic_no_node should_work/test_poly.lus
PASS: ./lus2lic {-2c should_work/test_poly.lus -n test_poly}
-PASS: gcc test_poly_test_poly.c test_poly_test_poly_loop.c
+PASS: gcc test_poly_test_poly.c test_poly_test_poly_ext.c test_poly_test_poly_loop.c
PASS: ./lus2lic {-o /tmp/nc8.lic should_work/nc8.lus}
PASS: ./lus2lic {-ec -o /tmp/nc8.ec should_work/nc8.lus}
PASS: ./myec2c {-o /tmp/nc8.c /tmp/nc8.ec}
PASS: ../utils/test_lus2lic_no_node should_work/nc8.lus
PASS: ./lus2lic {-2c should_work/nc8.lus -n nc8}
-PASS: gcc nc8_nc8.c nc8_nc8_loop.c
+PASS: gcc nc8_nc8.c nc8_nc8_ext.c nc8_nc8_loop.c
PASS: ./lus2lic {-o /tmp/minmax5.lic should_work/minmax5.lus}
PASS: ./lus2lic {-ec -o /tmp/minmax5.ec should_work/minmax5.lus}
PASS: ./myec2c {-o /tmp/minmax5.c /tmp/minmax5.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/minmax5.lus
PASS: ./lus2lic {-2c should_work/minmax5.lus -n minmax5}
-FAIL: Check that the generated C code compiles : gcc minmax5_minmax5.c minmax5_minmax5_loop.c
+PASS: gcc minmax5_minmax5.c minmax5_minmax5_ext.c minmax5_minmax5_loop.c
PASS: ./lus2lic {-o /tmp/mm1.lic should_work/mm1.lus}
PASS: ./lus2lic {-ec -o /tmp/mm1.ec should_work/mm1.lus}
PASS: ./myec2c {-o /tmp/mm1.c /tmp/mm1.ec}
PASS: ../utils/test_lus2lic_no_node should_work/mm1.lus
PASS: ./lus2lic {-2c should_work/mm1.lus -n mm1}
-PASS: gcc mm1_mm1.c mm1_mm1_loop.c
+PASS: gcc mm1_mm1.c mm1_mm1_ext.c mm1_mm1_loop.c
PASS: ./lus2lic {-o /tmp/predef03.lic should_work/predef03.lus}
PASS: ./lus2lic {-ec -o /tmp/predef03.ec should_work/predef03.lus}
PASS: ./myec2c {-o /tmp/predef03.c /tmp/predef03.ec}
PASS: ../utils/test_lus2lic_no_node should_work/predef03.lus
PASS: ./lus2lic {-2c should_work/predef03.lus -n predef03}
-PASS: gcc predef03_predef03.c predef03_predef03_loop.c
+PASS: gcc predef03_predef03.c predef03_predef03_ext.c predef03_predef03_loop.c
PASS: ./lus2lic {-o /tmp/iter.lic should_work/iter.lus}
PASS: ./lus2lic {-ec -o /tmp/iter.ec should_work/iter.lus}
PASS: ./myec2c {-o /tmp/iter.c /tmp/iter.ec}
PASS: ../utils/test_lus2lic_no_node should_work/iter.lus
PASS: ./lus2lic {-2c should_work/iter.lus -n iter}
-PASS: gcc iter_iter.c iter_iter_loop.c
+PASS: gcc iter_iter.c iter_iter_ext.c iter_iter_loop.c
PASS: ./lus2lic {-o /tmp/call05.lic should_work/call05.lus}
PASS: ./lus2lic {-ec -o /tmp/call05.ec should_work/call05.lus}
PASS: ./myec2c {-o /tmp/call05.c /tmp/call05.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/call05.lus
PASS: ./lus2lic {-2c should_work/call05.lus -n call05}
-FAIL: Check that the generated C code compiles : gcc call05_call05.c call05_call05_loop.c
+PASS: gcc call05_call05.c call05_call05_ext.c call05_call05_loop.c
PASS: ./lus2lic {-o /tmp/Watch.lic should_work/Watch.lus}
PASS: ./lus2lic {-ec -o /tmp/Watch.ec should_work/Watch.lus}
PASS: ./myec2c {-o /tmp/Watch.c /tmp/Watch.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/Watch.lus
PASS: ./lus2lic {-2c should_work/Watch.lus -n Watch}
-FAIL: Check that the generated C code compiles : gcc Watch_Watch.c Watch_Watch_loop.c
+PASS: gcc Watch_Watch.c Watch_Watch_ext.c Watch_Watch_loop.c
PASS: ./lus2lic {-o /tmp/testBoite.lic should_work/testBoite.lus}
PASS: ./lus2lic {-ec -o /tmp/testBoite.ec should_work/testBoite.lus}
PASS: ./myec2c {-o /tmp/testBoite.c /tmp/testBoite.ec}
@@ -276,97 +276,97 @@ PASS: ./lus2lic {-ec -o /tmp/node_caller1.ec should_work/node_caller1.lus}
PASS: ./myec2c {-o /tmp/node_caller1.c /tmp/node_caller1.ec}
PASS: ../utils/test_lus2lic_no_node should_work/node_caller1.lus
PASS: ./lus2lic {-2c should_work/node_caller1.lus -n node_caller1}
-PASS: gcc node_caller1_node_caller1.c node_caller1_node_caller1_loop.c
+PASS: gcc node_caller1_node_caller1.c node_caller1_node_caller1_ext.c node_caller1_node_caller1_loop.c
PASS: ./lus2lic {-o /tmp/nc1.lic should_work/nc1.lus}
PASS: ./lus2lic {-ec -o /tmp/nc1.ec should_work/nc1.lus}
PASS: ./myec2c {-o /tmp/nc1.c /tmp/nc1.ec}
PASS: ../utils/test_lus2lic_no_node should_work/nc1.lus
PASS: ./lus2lic {-2c should_work/nc1.lus -n nc1}
-PASS: gcc nc1_nc1.c nc1_nc1_loop.c
+PASS: gcc nc1_nc1.c nc1_nc1_ext.c nc1_nc1_loop.c
PASS: ./lus2lic {-o /tmp/test_node_expand2.lic should_work/test_node_expand2.lus}
PASS: ./lus2lic {-ec -o /tmp/test_node_expand2.ec should_work/test_node_expand2.lus}
PASS: ./myec2c {-o /tmp/test_node_expand2.c /tmp/test_node_expand2.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/test_node_expand2.lus
PASS: ./lus2lic {-2c should_work/test_node_expand2.lus -n test_node_expand2}
-PASS: gcc test_node_expand2_test_node_expand2.c test_node_expand2_test_node_expand2_loop.c
+PASS: gcc test_node_expand2_test_node_expand2.c test_node_expand2_test_node_expand2_ext.c test_node_expand2_test_node_expand2_loop.c
PASS: ./lus2lic {-o /tmp/test.lic should_work/test.lus}
PASS: ./lus2lic {-ec -o /tmp/test.ec should_work/test.lus}
PASS: ./myec2c {-o /tmp/test.c /tmp/test.ec}
PASS: ../utils/test_lus2lic_no_node should_work/test.lus
PASS: ./lus2lic {-2c should_work/test.lus -n test}
-PASS: gcc test_test.c test_test_loop.c
+PASS: gcc test_test.c test_test_ext.c test_test_loop.c
PASS: ./lus2lic {-o /tmp/FALLING_EDGE.lic should_work/FALLING_EDGE.lus}
PASS: ./lus2lic {-ec -o /tmp/FALLING_EDGE.ec should_work/FALLING_EDGE.lus}
PASS: ./myec2c {-o /tmp/FALLING_EDGE.c /tmp/FALLING_EDGE.ec}
PASS: ../utils/test_lus2lic_no_node should_work/FALLING_EDGE.lus
PASS: ./lus2lic {-2c should_work/FALLING_EDGE.lus -n FALLING_EDGE}
-PASS: gcc FALLING_EDGE_FALLING_EDGE.c FALLING_EDGE_FALLING_EDGE_loop.c
+PASS: gcc FALLING_EDGE_FALLING_EDGE.c FALLING_EDGE_FALLING_EDGE_ext.c FALLING_EDGE_FALLING_EDGE_loop.c
PASS: ./lus2lic {-o /tmp/SWITCH.lic should_work/SWITCH.lus}
PASS: ./lus2lic {-ec -o /tmp/SWITCH.ec should_work/SWITCH.lus}
PASS: ./myec2c {-o /tmp/SWITCH.c /tmp/SWITCH.ec}
PASS: ../utils/test_lus2lic_no_node should_work/SWITCH.lus
PASS: ./lus2lic {-2c should_work/SWITCH.lus -n SWITCH}
-PASS: gcc SWITCH_SWITCH.c SWITCH_SWITCH_loop.c
+PASS: gcc SWITCH_SWITCH.c SWITCH_SWITCH_ext.c SWITCH_SWITCH_loop.c
PASS: ./lus2lic {-o /tmp/cst.lic should_work/cst.lus}
PASS: ./lus2lic {-ec -o /tmp/cst.ec should_work/cst.lus}
PASS: ./myec2c {-o /tmp/cst.c /tmp/cst.ec}
PASS: ../utils/test_lus2lic_no_node should_work/cst.lus
PASS: ./lus2lic {-2c should_work/cst.lus -n cst}
-PASS: gcc cst_cst.c cst_cst_loop.c
+PASS: gcc cst_cst.c cst_cst_ext.c cst_cst_loop.c
PASS: ./lus2lic {-o /tmp/minmax5_random.lic should_work/minmax5_random.lus}
PASS: ./lus2lic {-ec -o /tmp/minmax5_random.ec should_work/minmax5_random.lus}
PASS: ./myec2c {-o /tmp/minmax5_random.c /tmp/minmax5_random.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/minmax5_random.lus
PASS: ./lus2lic {-2c should_work/minmax5_random.lus -n minmax5_random}
-FAIL: Check that the generated C code compiles : gcc minmax5_random_minmax5_random.c minmax5_random_minmax5_random_loop.c
+PASS: gcc minmax5_random_minmax5_random.c minmax5_random_minmax5_random_ext.c minmax5_random_minmax5_random_loop.c
PASS: ./lus2lic {-o /tmp/matrice2.lic should_work/matrice2.lus}
PASS: ./lus2lic {-ec -o /tmp/matrice2.ec should_work/matrice2.lus}
PASS: ./myec2c {-o /tmp/matrice2.c /tmp/matrice2.ec}
PASS: ../utils/test_lus2lic_no_node should_work/matrice2.lus
PASS: ./lus2lic {-2c should_work/matrice2.lus -n matrice2}
-PASS: gcc matrice2_matrice2.c matrice2_matrice2_loop.c
+PASS: gcc matrice2_matrice2.c matrice2_matrice2_ext.c matrice2_matrice2_loop.c
PASS: ./lus2lic {-o /tmp/v1.lic should_work/v1.lus}
PASS: ./lus2lic {-ec -o /tmp/v1.ec should_work/v1.lus}
PASS: ./myec2c {-o /tmp/v1.c /tmp/v1.ec}
PASS: ../utils/test_lus2lic_no_node should_work/v1.lus
PASS: ./lus2lic {-2c should_work/v1.lus -n v1}
-PASS: gcc v1_v1.c v1_v1_loop.c
+PASS: gcc v1_v1.c v1_v1_ext.c v1_v1_loop.c
PASS: ./lus2lic {-o /tmp/call04.lic should_work/call04.lus}
PASS: ./lus2lic {-ec -o /tmp/call04.ec should_work/call04.lus}
PASS: ./myec2c {-o /tmp/call04.c /tmp/call04.ec}
PASS: ../utils/test_lus2lic_no_node should_work/call04.lus
PASS: ./lus2lic {-2c should_work/call04.lus -n call04}
-PASS: gcc call04_call04.c call04_call04_loop.c
+PASS: gcc call04_call04.c call04_call04_ext.c call04_call04_loop.c
PASS: ./lus2lic {-o /tmp/bascule.lic should_work/bascule.lus}
PASS: ./lus2lic {-ec -o /tmp/bascule.ec should_work/bascule.lus}
PASS: ./myec2c {-o /tmp/bascule.c /tmp/bascule.ec}
PASS: ../utils/test_lus2lic_no_node should_work/bascule.lus
PASS: ./lus2lic {-2c should_work/bascule.lus -n bascule}
-PASS: gcc bascule_bascule.c bascule_bascule_loop.c
+PASS: gcc bascule_bascule.c bascule_bascule_ext.c bascule_bascule_loop.c
PASS: ./lus2lic {-o /tmp/double_delay.lic should_work/double_delay.lus}
PASS: ./lus2lic {-ec -o /tmp/double_delay.ec should_work/double_delay.lus}
PASS: ./myec2c {-o /tmp/double_delay.c /tmp/double_delay.ec}
PASS: ../utils/test_lus2lic_no_node should_work/double_delay.lus
PASS: ./lus2lic {-2c should_work/double_delay.lus -n double_delay}
-PASS: gcc double_delay_double_delay.c double_delay_double_delay_loop.c
+PASS: gcc double_delay_double_delay.c double_delay_double_delay_ext.c double_delay_double_delay_loop.c
PASS: ./lus2lic {-o /tmp/struct_with.lic should_work/struct_with.lus}
PASS: ./lus2lic {-ec -o /tmp/struct_with.ec should_work/struct_with.lus}
PASS: ./myec2c {-o /tmp/struct_with.c /tmp/struct_with.ec}
PASS: ../utils/test_lus2lic_no_node should_work/struct_with.lus
PASS: ./lus2lic {-2c should_work/struct_with.lus -n struct_with}
-PASS: gcc struct_with_struct_with.c struct_with_struct_with_loop.c
+PASS: gcc struct_with_struct_with.c struct_with_struct_with_ext.c struct_with_struct_with_loop.c
PASS: ./lus2lic {-o /tmp/test_node_expand.lic should_work/test_node_expand.lus}
PASS: ./lus2lic {-ec -o /tmp/test_node_expand.ec should_work/test_node_expand.lus}
PASS: ./myec2c {-o /tmp/test_node_expand.c /tmp/test_node_expand.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/test_node_expand.lus
PASS: ./lus2lic {-2c should_work/test_node_expand.lus -n test_node_expand}
-PASS: gcc test_node_expand_test_node_expand.c test_node_expand_test_node_expand_loop.c
+PASS: gcc test_node_expand_test_node_expand.c test_node_expand_test_node_expand_ext.c test_node_expand_test_node_expand_loop.c
PASS: ./lus2lic {-o /tmp/mm22.lic should_work/mm22.lus}
PASS: ./lus2lic {-ec -o /tmp/mm22.ec should_work/mm22.lus}
PASS: ./myec2c {-o /tmp/mm22.c /tmp/mm22.ec}
PASS: ../utils/test_lus2lic_no_node should_work/mm22.lus
PASS: ./lus2lic {-2c should_work/mm22.lus -n mm22}
-PASS: gcc mm22_mm22.c mm22_mm22_loop.c
+PASS: gcc mm22_mm22.c mm22_mm22_ext.c mm22_mm22_loop.c
PASS: ./lus2lic {-o /tmp/array_concat2.lic should_work/array_concat2.lus}
PASS: ./lus2lic {-ec -o /tmp/array_concat2.ec should_work/array_concat2.lus}
FAIL: Try ec2c on the result: ./myec2c {-o /tmp/array_concat2.c /tmp/array_concat2.ec}
@@ -375,7 +375,7 @@ PASS: ./lus2lic {-ec -o /tmp/is_stable.ec should_work/is_stable.lus}
PASS: ./myec2c {-o /tmp/is_stable.c /tmp/is_stable.ec}
PASS: ../utils/test_lus2lic_no_node should_work/is_stable.lus
PASS: ./lus2lic {-2c should_work/is_stable.lus -n is_stable}
-PASS: gcc is_stable_is_stable.c is_stable_is_stable_loop.c
+PASS: gcc is_stable_is_stable.c is_stable_is_stable_ext.c is_stable_is_stable_loop.c
PASS: ./lus2lic {-o /tmp/test_clash.lic should_work/test_clash.lus}
PASS: ./lus2lic {-ec -o /tmp/test_clash.ec should_work/test_clash.lus}
PASS: ./myec2c {-o /tmp/test_clash.c /tmp/test_clash.ec}
@@ -391,7 +391,7 @@ PASS: ./lus2lic {-ec -o /tmp/onlyroll2.ec should_work/onlyroll2.lus}
PASS: ./myec2c {-o /tmp/onlyroll2.c /tmp/onlyroll2.ec}
PASS: ../utils/test_lus2lic_no_node should_work/onlyroll2.lus
PASS: ./lus2lic {-2c should_work/onlyroll2.lus -n onlyroll2}
-PASS: gcc onlyroll2_onlyroll2.c onlyroll2_onlyroll2_loop.c
+PASS: gcc onlyroll2_onlyroll2.c onlyroll2_onlyroll2_ext.c onlyroll2_onlyroll2_loop.c
PASS: ./lus2lic {-o /tmp/modes3x2_v2.lic should_work/modes3x2_v2.lus}
PASS: ./lus2lic {-ec -o /tmp/modes3x2_v2.ec should_work/modes3x2_v2.lus}
PASS: ./myec2c {-o /tmp/modes3x2_v2.c /tmp/modes3x2_v2.ec}
@@ -402,13 +402,13 @@ PASS: ./lus2lic {-ec -o /tmp/X6.ec should_work/X6.lus}
PASS: ./myec2c {-o /tmp/X6.c /tmp/X6.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/X6.lus
PASS: ./lus2lic {-2c should_work/X6.lus -n X6}
-PASS: gcc X6_X6.c X6_X6_loop.c
+PASS: gcc X6_X6.c X6_X6_ext.c X6_X6_loop.c
PASS: ./lus2lic {-o /tmp/zzz2.lic should_work/zzz2.lus}
PASS: ./lus2lic {-ec -o /tmp/zzz2.ec should_work/zzz2.lus}
PASS: ./myec2c {-o /tmp/zzz2.c /tmp/zzz2.ec}
PASS: ../utils/test_lus2lic_no_node should_work/zzz2.lus
PASS: ./lus2lic {-2c should_work/zzz2.lus -n zzz2}
-PASS: gcc zzz2_zzz2.c zzz2_zzz2_loop.c
+PASS: gcc zzz2_zzz2.c zzz2_zzz2_ext.c zzz2_zzz2_loop.c
PASS: ./lus2lic {-o /tmp/polymorphic_pack.lic should_work/polymorphic_pack.lus}
PASS: ./lus2lic {-ec -o /tmp/polymorphic_pack.ec should_work/polymorphic_pack.lus}
PASS: ./myec2c {-o /tmp/polymorphic_pack.c /tmp/polymorphic_pack.ec}
@@ -419,13 +419,13 @@ PASS: ./lus2lic {-ec -o /tmp/COUNTER.ec should_work/COUNTER.lus}
PASS: ./myec2c {-o /tmp/COUNTER.c /tmp/COUNTER.ec}
PASS: ../utils/test_lus2lic_no_node should_work/COUNTER.lus
PASS: ./lus2lic {-2c should_work/COUNTER.lus -n COUNTER}
-PASS: gcc COUNTER_COUNTER.c COUNTER_COUNTER_loop.c
+PASS: gcc COUNTER_COUNTER.c COUNTER_COUNTER_ext.c COUNTER_COUNTER_loop.c
PASS: ./lus2lic {-o /tmp/minmax3.lic should_work/minmax3.lus}
PASS: ./lus2lic {-ec -o /tmp/minmax3.ec should_work/minmax3.lus}
PASS: ./myec2c {-o /tmp/minmax3.c /tmp/minmax3.ec}
PASS: ../utils/test_lus2lic_no_node should_work/minmax3.lus
PASS: ./lus2lic {-2c should_work/minmax3.lus -n minmax3}
-PASS: gcc minmax3_minmax3.c minmax3_minmax3_loop.c
+PASS: gcc minmax3_minmax3.c minmax3_minmax3_ext.c minmax3_minmax3_loop.c
PASS: ./lus2lic {-o /tmp/filter.lic should_work/filter.lus}
PASS: ./lus2lic {-ec -o /tmp/filter.ec should_work/filter.lus}
PASS: ./myec2c {-o /tmp/filter.c /tmp/filter.ec}
@@ -436,61 +436,61 @@ PASS: ./lus2lic {-ec -o /tmp/ec.ec should_work/ec.lus}
PASS: ./myec2c {-o /tmp/ec.c /tmp/ec.ec}
PASS: ../utils/test_lus2lic_no_node should_work/ec.lus
PASS: ./lus2lic {-2c should_work/ec.lus -n ec}
-PASS: gcc ec_ec.c ec_ec_loop.c
+PASS: gcc ec_ec.c ec_ec_ext.c ec_ec_loop.c
PASS: ./lus2lic {-o /tmp/morel3.lic should_work/morel3.lus}
PASS: ./lus2lic {-ec -o /tmp/morel3.ec should_work/morel3.lus}
PASS: ./myec2c {-o /tmp/morel3.c /tmp/morel3.ec}
PASS: ../utils/test_lus2lic_no_node should_work/morel3.lus
FAIL: Generate c code : ./lus2lic {-2c should_work/morel3.lus -n morel3}
-FAIL: Check that the generated C code compiles : gcc morel3_morel3.c morel3_morel3_loop.c
+FAIL: Check that the generated C code compiles : gcc morel3_morel3.c morel3_morel3_ext.c morel3_morel3_loop.c
PASS: ./lus2lic {-o /tmp/fresh_name.lic should_work/fresh_name.lus}
PASS: ./lus2lic {-ec -o /tmp/fresh_name.ec should_work/fresh_name.lus}
PASS: ./myec2c {-o /tmp/fresh_name.c /tmp/fresh_name.ec}
PASS: ../utils/test_lus2lic_no_node should_work/fresh_name.lus
PASS: ./lus2lic {-2c should_work/fresh_name.lus -n fresh_name}
-PASS: gcc fresh_name_fresh_name.c fresh_name_fresh_name_loop.c
+PASS: gcc fresh_name_fresh_name.c fresh_name_fresh_name_ext.c fresh_name_fresh_name_loop.c
PASS: ./lus2lic {-o /tmp/ply03.lic should_work/ply03.lus}
PASS: ./lus2lic {-ec -o /tmp/ply03.ec should_work/ply03.lus}
PASS: ./myec2c {-o /tmp/ply03.c /tmp/ply03.ec}
PASS: ../utils/test_lus2lic_no_node should_work/ply03.lus
PASS: ./lus2lic {-2c should_work/ply03.lus -n ply03}
-PASS: gcc ply03_ply03.c ply03_ply03_loop.c
+PASS: gcc ply03_ply03.c ply03_ply03_ext.c ply03_ply03_loop.c
PASS: ./lus2lic {-o /tmp/param_struct.lic should_work/param_struct.lus}
PASS: ./lus2lic {-ec -o /tmp/param_struct.ec should_work/param_struct.lus}
PASS: ./myec2c {-o /tmp/param_struct.c /tmp/param_struct.ec}
PASS: ../utils/test_lus2lic_no_node should_work/param_struct.lus
PASS: ./lus2lic {-2c should_work/param_struct.lus -n param_struct}
-PASS: gcc param_struct_param_struct.c param_struct_param_struct_loop.c
+PASS: gcc param_struct_param_struct.c param_struct_param_struct_ext.c param_struct_param_struct_loop.c
PASS: ./lus2lic {-o /tmp/minmax2.lic should_work/minmax2.lus}
PASS: ./lus2lic {-ec -o /tmp/minmax2.ec should_work/minmax2.lus}
PASS: ./myec2c {-o /tmp/minmax2.c /tmp/minmax2.ec}
PASS: ../utils/test_lus2lic_no_node should_work/minmax2.lus
PASS: ./lus2lic {-2c should_work/minmax2.lus -n minmax2}
-PASS: gcc minmax2_minmax2.c minmax2_minmax2_loop.c
+PASS: gcc minmax2_minmax2.c minmax2_minmax2_ext.c minmax2_minmax2_loop.c
PASS: ./lus2lic {-o /tmp/plus.lic should_work/plus.lus}
PASS: ./lus2lic {-ec -o /tmp/plus.ec should_work/plus.lus}
PASS: ./myec2c {-o /tmp/plus.c /tmp/plus.ec}
PASS: ../utils/test_lus2lic_no_node should_work/plus.lus
PASS: ./lus2lic {-2c should_work/plus.lus -n plus}
-PASS: gcc plus_plus.c plus_plus_loop.c
+PASS: gcc plus_plus.c plus_plus_ext.c plus_plus_loop.c
PASS: ./lus2lic {-o /tmp/xx.lic should_work/xx.lus}
PASS: ./lus2lic {-ec -o /tmp/xx.ec should_work/xx.lus}
PASS: ./myec2c {-o /tmp/xx.c /tmp/xx.ec}
PASS: ../utils/test_lus2lic_no_node should_work/xx.lus
PASS: ./lus2lic {-2c should_work/xx.lus -n xx}
-PASS: gcc xx_xx.c xx_xx_loop.c
+PASS: gcc xx_xx.c xx_xx_ext.c xx_xx_loop.c
PASS: ./lus2lic {-o /tmp/call07.lic should_work/call07.lus}
PASS: ./lus2lic {-ec -o /tmp/call07.ec should_work/call07.lus}
PASS: ./myec2c {-o /tmp/call07.c /tmp/call07.ec}
PASS: ../utils/test_lus2lic_no_node should_work/call07.lus
PASS: ./lus2lic {-2c should_work/call07.lus -n call07}
-PASS: gcc call07_call07.c call07_call07_loop.c
+PASS: gcc call07_call07.c call07_call07_ext.c call07_call07_loop.c
PASS: ./lus2lic {-o /tmp/shift_ludic.lic should_work/shift_ludic.lus}
PASS: ./lus2lic {-ec -o /tmp/shift_ludic.ec should_work/shift_ludic.lus}
PASS: ./myec2c {-o /tmp/shift_ludic.c /tmp/shift_ludic.ec}
PASS: ../utils/test_lus2lic_no_node should_work/shift_ludic.lus
PASS: ./lus2lic {-2c should_work/shift_ludic.lus -n shift_ludic}
-PASS: gcc shift_ludic_shift_ludic.c shift_ludic_shift_ludic_loop.c
+PASS: gcc shift_ludic_shift_ludic.c shift_ludic_shift_ludic_ext.c shift_ludic_shift_ludic_loop.c
PASS: ./lus2lic {-o /tmp/pilote-1.0.lic should_work/pilote-1.0.lus}
PASS: ./lus2lic {-ec -o /tmp/pilote-1.0.ec should_work/pilote-1.0.lus}
PASS: ./myec2c {-o /tmp/pilote-1.0.c /tmp/pilote-1.0.ec}
@@ -501,7 +501,7 @@ PASS: ./lus2lic {-ec -o /tmp/trivial.ec should_work/trivial.lus}
PASS: ./myec2c {-o /tmp/trivial.c /tmp/trivial.ec}
PASS: ../utils/test_lus2lic_no_node should_work/trivial.lus
PASS: ./lus2lic {-2c should_work/trivial.lus -n trivial}
-PASS: gcc trivial_trivial.c trivial_trivial_loop.c
+PASS: gcc trivial_trivial.c trivial_trivial_ext.c trivial_trivial_loop.c
PASS: ./lus2lic {-o /tmp/packs.lic should_work/packs.lus}
PASS: ./lus2lic {-ec -o /tmp/packs.ec should_work/packs.lus}
PASS: ./myec2c {-o /tmp/packs.c /tmp/packs.ec}
@@ -512,7 +512,7 @@ PASS: ./lus2lic {-ec -o /tmp/sincos.ec should_work/sincos.lus}
PASS: ./myec2c {-o /tmp/sincos.c /tmp/sincos.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/sincos.lus
PASS: ./lus2lic {-2c should_work/sincos.lus -n sincos}
-PASS: gcc sincos_sincos.c sincos_sincos_loop.c
+PASS: gcc sincos_sincos.c sincos_sincos_ext.c sincos_sincos_loop.c
PASS: ./lus2lic {-o /tmp/newpacks.lic should_work/newpacks.lus}
PASS: ./lus2lic {-ec -o /tmp/newpacks.ec should_work/newpacks.lus}
PASS: ./myec2c {-o /tmp/newpacks.c /tmp/newpacks.ec}
@@ -523,67 +523,67 @@ PASS: ./lus2lic {-ec -o /tmp/morel5.ec should_work/morel5.lus}
PASS: ./myec2c {-o /tmp/morel5.c /tmp/morel5.ec}
PASS: ../utils/test_lus2lic_no_node should_work/morel5.lus
PASS: ./lus2lic {-2c should_work/morel5.lus -n morel5}
-PASS: gcc morel5_morel5.c morel5_morel5_loop.c
+PASS: gcc morel5_morel5.c morel5_morel5_ext.c morel5_morel5_loop.c
PASS: ./lus2lic {-o /tmp/bred.lic should_work/bred.lus}
PASS: ./lus2lic {-ec -o /tmp/bred.ec should_work/bred.lus}
PASS: ./myec2c {-o /tmp/bred.c /tmp/bred.ec}
PASS: ../utils/test_lus2lic_no_node should_work/bred.lus
PASS: ./lus2lic {-2c should_work/bred.lus -n bred}
-PASS: gcc bred_bred.c bred_bred_loop.c
+PASS: gcc bred_bred.c bred_bred_ext.c bred_bred_loop.c
PASS: ./lus2lic {-o /tmp/test_diese.lic should_work/test_diese.lus}
PASS: ./lus2lic {-ec -o /tmp/test_diese.ec should_work/test_diese.lus}
PASS: ./myec2c {-o /tmp/test_diese.c /tmp/test_diese.ec}
PASS: ../utils/test_lus2lic_no_node should_work/test_diese.lus
PASS: ./lus2lic {-2c should_work/test_diese.lus -n test_diese}
-PASS: gcc test_diese_test_diese.c test_diese_test_diese_loop.c
+PASS: gcc test_diese_test_diese.c test_diese_test_diese_ext.c test_diese_test_diese_loop.c
PASS: ./lus2lic {-o /tmp/tri.lic should_work/tri.lus}
PASS: ./lus2lic {-ec -o /tmp/tri.ec should_work/tri.lus}
PASS: ./myec2c {-o /tmp/tri.c /tmp/tri.ec}
PASS: ../utils/test_lus2lic_no_node should_work/tri.lus
PASS: ./lus2lic {-2c should_work/tri.lus -n tri}
-PASS: gcc tri_tri.c tri_tri_loop.c
+PASS: gcc tri_tri.c tri_tri_ext.c tri_tri_loop.c
PASS: ./lus2lic {-o /tmp/calculs_max.lic should_work/calculs_max.lus}
PASS: ./lus2lic {-ec -o /tmp/calculs_max.ec should_work/calculs_max.lus}
PASS: ./myec2c {-o /tmp/calculs_max.c /tmp/calculs_max.ec}
PASS: ../utils/test_lus2lic_no_node should_work/calculs_max.lus
PASS: ./lus2lic {-2c should_work/calculs_max.lus -n calculs_max}
-PASS: gcc calculs_max_calculs_max.c calculs_max_calculs_max_loop.c
+PASS: gcc calculs_max_calculs_max.c calculs_max_calculs_max_ext.c calculs_max_calculs_max_loop.c
PASS: ./lus2lic {-o /tmp/testCA.lic should_work/testCA.lus}
PASS: ./lus2lic {-ec -o /tmp/testCA.ec should_work/testCA.lus}
PASS: ./myec2c {-o /tmp/testCA.c /tmp/testCA.ec}
PASS: ../utils/test_lus2lic_no_node should_work/testCA.lus
PASS: ./lus2lic {-2c should_work/testCA.lus -n testCA}
-PASS: gcc testCA_testCA.c testCA_testCA_loop.c
+PASS: gcc testCA_testCA.c testCA_testCA_ext.c testCA_testCA_loop.c
PASS: ./lus2lic {-o /tmp/test_extern.lic should_work/test_extern.lus}
PASS: ./lus2lic {-ec -o /tmp/test_extern.ec should_work/test_extern.lus}
PASS: ./myec2c {-o /tmp/test_extern.c /tmp/test_extern.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/test_extern.lus
PASS: ./lus2lic {-2c should_work/test_extern.lus -n test_extern}
-FAIL: Check that the generated C code compiles : gcc test_extern_test_extern.c test_extern_test_extern_loop.c
+PASS: gcc test_extern_test_extern.c test_extern_test_extern_ext.c test_extern_test_extern_loop.c
PASS: ./lus2lic {-o /tmp/deconne.lic should_work/deconne.lus}
PASS: ./lus2lic {-ec -o /tmp/deconne.ec should_work/deconne.lus}
PASS: ./myec2c {-o /tmp/deconne.c /tmp/deconne.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/deconne.lus
PASS: ./lus2lic {-2c should_work/deconne.lus -n deconne}
-FAIL: Check that the generated C code compiles : gcc deconne_deconne.c deconne_deconne_loop.c
+PASS: gcc deconne_deconne.c deconne_deconne_ext.c deconne_deconne_loop.c
PASS: ./lus2lic {-o /tmp/noAlarm.lic should_work/noAlarm.lus}
PASS: ./lus2lic {-ec -o /tmp/noAlarm.ec should_work/noAlarm.lus}
PASS: ./myec2c {-o /tmp/noAlarm.c /tmp/noAlarm.ec}
PASS: ../utils/test_lus2lic_no_node should_work/noAlarm.lus
PASS: ./lus2lic {-2c should_work/noAlarm.lus -n noAlarm}
-PASS: gcc noAlarm_noAlarm.c noAlarm_noAlarm_loop.c
+PASS: gcc noAlarm_noAlarm.c noAlarm_noAlarm_ext.c noAlarm_noAlarm_loop.c
PASS: ./lus2lic {-o /tmp/clock_ite.lic should_work/clock_ite.lus}
PASS: ./lus2lic {-ec -o /tmp/clock_ite.ec should_work/clock_ite.lus}
PASS: ./myec2c {-o /tmp/clock_ite.c /tmp/clock_ite.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/clock_ite.lus
PASS: ./lus2lic {-2c should_work/clock_ite.lus -n clock_ite}
-PASS: gcc clock_ite_clock_ite.c clock_ite_clock_ite_loop.c
+PASS: gcc clock_ite_clock_ite.c clock_ite_clock_ite_ext.c clock_ite_clock_ite_loop.c
PASS: ./lus2lic {-o /tmp/morel4.lic should_work/morel4.lus}
PASS: ./lus2lic {-ec -o /tmp/morel4.ec should_work/morel4.lus}
PASS: ./myec2c {-o /tmp/morel4.c /tmp/morel4.ec}
PASS: ../utils/test_lus2lic_no_node should_work/morel4.lus
FAIL: Generate c code : ./lus2lic {-2c should_work/morel4.lus -n morel4}
-FAIL: Check that the generated C code compiles : gcc morel4_morel4.c morel4_morel4_loop.c
+FAIL: Check that the generated C code compiles : gcc morel4_morel4.c morel4_morel4_ext.c morel4_morel4_loop.c
PASS: ./lus2lic {-o /tmp/trivial_array.lic should_work/trivial_array.lus}
FAIL: Generate ec code : ./lus2lic {-ec -o /tmp/trivial_array.ec should_work/trivial_array.lus}
PASS: ./lus2lic {-o /tmp/param_node4.lic should_work/param_node4.lus}
@@ -591,145 +591,145 @@ PASS: ./lus2lic {-ec -o /tmp/param_node4.ec should_work/param_node4.lus}
PASS: ./myec2c {-o /tmp/param_node4.c /tmp/param_node4.ec}
PASS: ../utils/test_lus2lic_no_node should_work/param_node4.lus
PASS: ./lus2lic {-2c should_work/param_node4.lus -n param_node4}
-PASS: gcc param_node4_param_node4.c param_node4_param_node4_loop.c
+PASS: gcc param_node4_param_node4.c param_node4_param_node4_ext.c param_node4_param_node4_loop.c
PASS: ./lus2lic {-o /tmp/bad_call03.lic should_work/bad_call03.lus}
PASS: ./lus2lic {-ec -o /tmp/bad_call03.ec should_work/bad_call03.lus}
PASS: ./myec2c {-o /tmp/bad_call03.c /tmp/bad_call03.ec}
PASS: ../utils/test_lus2lic_no_node should_work/bad_call03.lus
PASS: ./lus2lic {-2c should_work/bad_call03.lus -n bad_call03}
-PASS: gcc bad_call03_bad_call03.c bad_call03_bad_call03_loop.c
+PASS: gcc bad_call03_bad_call03.c bad_call03_bad_call03_ext.c bad_call03_bad_call03_loop.c
PASS: ./lus2lic {-o /tmp/onlyroll.lic should_work/onlyroll.lus}
PASS: ./lus2lic {-ec -o /tmp/onlyroll.ec should_work/onlyroll.lus}
PASS: ./myec2c {-o /tmp/onlyroll.c /tmp/onlyroll.ec}
PASS: ../utils/test_lus2lic_no_node should_work/onlyroll.lus
PASS: ./lus2lic {-2c should_work/onlyroll.lus -n onlyroll}
-PASS: gcc onlyroll_onlyroll.c onlyroll_onlyroll_loop.c
+PASS: gcc onlyroll_onlyroll.c onlyroll_onlyroll_ext.c onlyroll_onlyroll_loop.c
PASS: ./lus2lic {-o /tmp/produitBool.lic should_work/produitBool.lus}
PASS: ./lus2lic {-ec -o /tmp/produitBool.ec should_work/produitBool.lus}
PASS: ./myec2c {-o /tmp/produitBool.c /tmp/produitBool.ec}
PASS: ../utils/test_lus2lic_no_node should_work/produitBool.lus
PASS: ./lus2lic {-2c should_work/produitBool.lus -n produitBool}
-PASS: gcc produitBool_produitBool.c produitBool_produitBool_loop.c
+PASS: gcc produitBool_produitBool.c produitBool_produitBool_ext.c produitBool_produitBool_loop.c
PASS: ./lus2lic {-o /tmp/noeudsIndependants.lic should_work/noeudsIndependants.lus}
PASS: ./lus2lic {-ec -o /tmp/noeudsIndependants.ec should_work/noeudsIndependants.lus}
PASS: ./myec2c {-o /tmp/noeudsIndependants.c /tmp/noeudsIndependants.ec}
PASS: ../utils/test_lus2lic_no_node should_work/noeudsIndependants.lus
PASS: ./lus2lic {-2c should_work/noeudsIndependants.lus -n noeudsIndependants}
-PASS: gcc noeudsIndependants_noeudsIndependants.c noeudsIndependants_noeudsIndependants_loop.c
+PASS: gcc noeudsIndependants_noeudsIndependants.c noeudsIndependants_noeudsIndependants_ext.c noeudsIndependants_noeudsIndependants_loop.c
PASS: ./lus2lic {-o /tmp/mouse.lic should_work/mouse.lus}
PASS: ./lus2lic {-ec -o /tmp/mouse.ec should_work/mouse.lus}
PASS: ./myec2c {-o /tmp/mouse.c /tmp/mouse.ec}
PASS: ../utils/test_lus2lic_no_node should_work/mouse.lus
PASS: ./lus2lic {-2c should_work/mouse.lus -n mouse}
-PASS: gcc mouse_mouse.c mouse_mouse_loop.c
+PASS: gcc mouse_mouse.c mouse_mouse_ext.c mouse_mouse_loop.c
PASS: ./lus2lic {-o /tmp/param_node3.lic should_work/param_node3.lus}
PASS: ./lus2lic {-ec -o /tmp/param_node3.ec should_work/param_node3.lus}
PASS: ./myec2c {-o /tmp/param_node3.c /tmp/param_node3.ec}
PASS: ../utils/test_lus2lic_no_node should_work/param_node3.lus
PASS: ./lus2lic {-2c should_work/param_node3.lus -n param_node3}
-PASS: gcc param_node3_param_node3.c param_node3_param_node3_loop.c
+PASS: gcc param_node3_param_node3.c param_node3_param_node3_ext.c param_node3_param_node3_loop.c
PASS: ./lus2lic {-o /tmp/pipeline.lic should_work/pipeline.lus}
PASS: ./lus2lic {-ec -o /tmp/pipeline.ec should_work/pipeline.lus}
PASS: ./myec2c {-o /tmp/pipeline.c /tmp/pipeline.ec}
PASS: ../utils/test_lus2lic_no_node should_work/pipeline.lus
PASS: ./lus2lic {-2c should_work/pipeline.lus -n pipeline}
-PASS: gcc pipeline_pipeline.c pipeline_pipeline_loop.c
+PASS: gcc pipeline_pipeline.c pipeline_pipeline_ext.c pipeline_pipeline_loop.c
PASS: ./lus2lic {-o /tmp/mapinf.lic should_work/mapinf.lus}
PASS: ./lus2lic {-ec -o /tmp/mapinf.ec should_work/mapinf.lus}
PASS: ./myec2c {-o /tmp/mapinf.c /tmp/mapinf.ec}
PASS: ../utils/test_lus2lic_no_node should_work/mapinf.lus
PASS: ./lus2lic {-2c should_work/mapinf.lus -n mapinf}
-PASS: gcc mapinf_mapinf.c mapinf_mapinf_loop.c
+PASS: gcc mapinf_mapinf.c mapinf_mapinf_ext.c mapinf_mapinf_loop.c
PASS: ./lus2lic {-o /tmp/integrator.lic should_work/integrator.lus}
PASS: ./lus2lic {-ec -o /tmp/integrator.ec should_work/integrator.lus}
PASS: ./myec2c {-o /tmp/integrator.c /tmp/integrator.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/integrator.lus
PASS: ./lus2lic {-2c should_work/integrator.lus -n integrator}
-PASS: gcc integrator_integrator.c integrator_integrator_loop.c
+PASS: gcc integrator_integrator.c integrator_integrator_ext.c integrator_integrator_loop.c
PASS: ./lus2lic {-o /tmp/nc4.lic should_work/nc4.lus}
PASS: ./lus2lic {-ec -o /tmp/nc4.ec should_work/nc4.lus}
PASS: ./myec2c {-o /tmp/nc4.c /tmp/nc4.ec}
PASS: ../utils/test_lus2lic_no_node should_work/nc4.lus
PASS: ./lus2lic {-2c should_work/nc4.lus -n nc4}
-PASS: gcc nc4_nc4.c nc4_nc4_loop.c
+PASS: gcc nc4_nc4.c nc4_nc4_ext.c nc4_nc4_loop.c
PASS: ./lus2lic {-o /tmp/mm3.lic should_work/mm3.lus}
PASS: ./lus2lic {-ec -o /tmp/mm3.ec should_work/mm3.lus}
PASS: ./myec2c {-o /tmp/mm3.c /tmp/mm3.ec}
PASS: ../utils/test_lus2lic_no_node should_work/mm3.lus
PASS: ./lus2lic {-2c should_work/mm3.lus -n mm3}
-PASS: gcc mm3_mm3.c mm3_mm3_loop.c
+PASS: gcc mm3_mm3.c mm3_mm3_ext.c mm3_mm3_loop.c
PASS: ./lus2lic {-o /tmp/over2.lic should_work/over2.lus}
PASS: ./lus2lic {-ec -o /tmp/over2.ec should_work/over2.lus}
PASS: ./myec2c {-o /tmp/over2.c /tmp/over2.ec}
PASS: ../utils/test_lus2lic_no_node should_work/over2.lus
PASS: ./lus2lic {-2c should_work/over2.lus -n over2}
-PASS: gcc over2_over2.c over2_over2_loop.c
+PASS: gcc over2_over2.c over2_over2_ext.c over2_over2_loop.c
PASS: ./lus2lic {-o /tmp/over3.lic should_work/over3.lus}
PASS: ./lus2lic {-ec -o /tmp/over3.ec should_work/over3.lus}
PASS: ./myec2c {-o /tmp/over3.c /tmp/over3.ec}
PASS: ../utils/test_lus2lic_no_node should_work/over3.lus
PASS: ./lus2lic {-2c should_work/over3.lus -n over3}
-PASS: gcc over3_over3.c over3_over3_loop.c
+PASS: gcc over3_over3.c over3_over3_ext.c over3_over3_loop.c
PASS: ./lus2lic {-o /tmp/complex.lic should_work/complex.lus}
PASS: ./lus2lic {-ec -o /tmp/complex.ec should_work/complex.lus}
PASS: ./myec2c {-o /tmp/complex.c /tmp/complex.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/complex.lus
PASS: ./lus2lic {-2c should_work/complex.lus -n complex}
-PASS: gcc complex_complex.c complex_complex_loop.c
+PASS: gcc complex_complex.c complex_complex_ext.c complex_complex_loop.c
PASS: ./lus2lic {-o /tmp/initial.lic should_work/initial.lus}
PASS: ./lus2lic {-ec -o /tmp/initial.ec should_work/initial.lus}
PASS: ./myec2c {-o /tmp/initial.c /tmp/initial.ec}
PASS: ../utils/test_lus2lic_no_node should_work/initial.lus
PASS: ./lus2lic {-2c should_work/initial.lus -n initial}
-PASS: gcc initial_initial.c initial_initial_loop.c
+PASS: gcc initial_initial.c initial_initial_ext.c initial_initial_loop.c
PASS: ./lus2lic {-o /tmp/declaration.lic should_work/declaration.lus}
PASS: ./lus2lic {-ec -o /tmp/declaration.ec should_work/declaration.lus}
PASS: ./myec2c {-o /tmp/declaration.c /tmp/declaration.ec}
PASS: ../utils/test_lus2lic_no_node should_work/declaration.lus
PASS: ./lus2lic {-2c should_work/declaration.lus -n declaration}
-PASS: gcc declaration_declaration.c declaration_declaration_loop.c
+PASS: gcc declaration_declaration.c declaration_declaration_ext.c declaration_declaration_loop.c
PASS: ./lus2lic {-o /tmp/PCOND1.lic should_work/PCOND1.lus}
PASS: ./lus2lic {-ec -o /tmp/PCOND1.ec should_work/PCOND1.lus}
PASS: ./myec2c {-o /tmp/PCOND1.c /tmp/PCOND1.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/PCOND1.lus
PASS: ./lus2lic {-2c should_work/PCOND1.lus -n PCOND1}
-PASS: gcc PCOND1_PCOND1.c PCOND1_PCOND1_loop.c
+PASS: gcc PCOND1_PCOND1.c PCOND1_PCOND1_ext.c PCOND1_PCOND1_loop.c
PASS: ./lus2lic {-o /tmp/TIME_STABLE1.lic should_work/TIME_STABLE1.lus}
PASS: ./lus2lic {-ec -o /tmp/TIME_STABLE1.ec should_work/TIME_STABLE1.lus}
PASS: ./myec2c {-o /tmp/TIME_STABLE1.c /tmp/TIME_STABLE1.ec}
PASS: ../utils/test_lus2lic_no_node should_work/TIME_STABLE1.lus
PASS: ./lus2lic {-2c should_work/TIME_STABLE1.lus -n TIME_STABLE1}
-PASS: gcc TIME_STABLE1_TIME_STABLE1.c TIME_STABLE1_TIME_STABLE1_loop.c
+PASS: gcc TIME_STABLE1_TIME_STABLE1.c TIME_STABLE1_TIME_STABLE1_ext.c TIME_STABLE1_TIME_STABLE1_loop.c
PASS: ./lus2lic {-o /tmp/nc5.lic should_work/nc5.lus}
PASS: ./lus2lic {-ec -o /tmp/nc5.ec should_work/nc5.lus}
PASS: ./myec2c {-o /tmp/nc5.c /tmp/nc5.ec}
PASS: ../utils/test_lus2lic_no_node should_work/nc5.lus
PASS: ./lus2lic {-2c should_work/nc5.lus -n nc5}
-PASS: gcc nc5_nc5.c nc5_nc5_loop.c
+PASS: gcc nc5_nc5.c nc5_nc5_ext.c nc5_nc5_loop.c
PASS: ./lus2lic {-o /tmp/call.lic should_work/call.lus}
PASS: ./lus2lic {-ec -o /tmp/call.ec should_work/call.lus}
PASS: ./myec2c {-o /tmp/call.c /tmp/call.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/call.lus
PASS: ./lus2lic {-2c should_work/call.lus -n call}
-FAIL: Check that the generated C code compiles : gcc call_call.c call_call_loop.c
+PASS: gcc call_call.c call_call_ext.c call_call_loop.c
PASS: ./lus2lic {-o /tmp/mouse1.lic should_work/mouse1.lus}
PASS: ./lus2lic {-ec -o /tmp/mouse1.ec should_work/mouse1.lus}
PASS: ./myec2c {-o /tmp/mouse1.c /tmp/mouse1.ec}
PASS: ../utils/test_lus2lic_no_node should_work/mouse1.lus
PASS: ./lus2lic {-2c should_work/mouse1.lus -n mouse1}
-PASS: gcc mouse1_mouse1.c mouse1_mouse1_loop.c
+PASS: gcc mouse1_mouse1.c mouse1_mouse1_ext.c mouse1_mouse1_loop.c
PASS: ./lus2lic {-o /tmp/lustre_test1_ok.lic should_work/lustre_test1_ok.lus}
PASS: ./lus2lic {-ec -o /tmp/lustre_test1_ok.ec should_work/lustre_test1_ok.lus}
PASS: ./myec2c {-o /tmp/lustre_test1_ok.c /tmp/lustre_test1_ok.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/lustre_test1_ok.lus
PASS: ./lus2lic {-2c should_work/lustre_test1_ok.lus -n lustre_test1_ok}
-PASS: gcc lustre_test1_ok_lustre_test1_ok.c lustre_test1_ok_lustre_test1_ok_loop.c
+PASS: gcc lustre_test1_ok_lustre_test1_ok.c lustre_test1_ok_lustre_test1_ok_ext.c lustre_test1_ok_lustre_test1_ok_loop.c
PASS: ./lus2lic {-o /tmp/compteur.lic should_work/compteur.lus}
PASS: ./lus2lic {-ec -o /tmp/compteur.ec should_work/compteur.lus}
PASS: ./myec2c {-o /tmp/compteur.c /tmp/compteur.ec}
PASS: ../utils/test_lus2lic_no_node should_work/compteur.lus
PASS: ./lus2lic {-2c should_work/compteur.lus -n compteur}
-PASS: gcc compteur_compteur.c compteur_compteur_loop.c
+PASS: gcc compteur_compteur.c compteur_compteur_ext.c compteur_compteur_loop.c
PASS: ./lus2lic {-o /tmp/Int.lic should_work/Int.lus}
PASS: ./lus2lic {-ec -o /tmp/Int.ec should_work/Int.lus}
PASS: ./myec2c {-o /tmp/Int.c /tmp/Int.ec}
@@ -742,19 +742,19 @@ PASS: ./lus2lic {-ec -o /tmp/t2.ec should_work/t2.lus}
PASS: ./myec2c {-o /tmp/t2.c /tmp/t2.ec}
PASS: ../utils/test_lus2lic_no_node should_work/t2.lus
PASS: ./lus2lic {-2c should_work/t2.lus -n t2}
-PASS: gcc t2_t2.c t2_t2_loop.c
+PASS: gcc t2_t2.c t2_t2_ext.c t2_t2_loop.c
PASS: ./lus2lic {-o /tmp/arbitre.lic should_work/arbitre.lus}
PASS: ./lus2lic {-ec -o /tmp/arbitre.ec should_work/arbitre.lus}
PASS: ./myec2c {-o /tmp/arbitre.c /tmp/arbitre.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/arbitre.lus
PASS: ./lus2lic {-2c should_work/arbitre.lus -n arbitre}
-FAIL: Check that the generated C code compiles : gcc arbitre_arbitre.c arbitre_arbitre_loop.c
+FAIL: Check that the generated C code compiles : gcc arbitre_arbitre.c arbitre_arbitre_ext.c arbitre_arbitre_loop.c
PASS: ./lus2lic {-o /tmp/test_const.lic should_work/test_const.lus}
PASS: ./lus2lic {-ec -o /tmp/test_const.ec should_work/test_const.lus}
PASS: ./myec2c {-o /tmp/test_const.c /tmp/test_const.ec}
PASS: ../utils/test_lus2lic_no_node should_work/test_const.lus
PASS: ./lus2lic {-2c should_work/test_const.lus -n test_const}
-PASS: gcc test_const_test_const.c test_const_test_const_loop.c
+PASS: gcc test_const_test_const.c test_const_test_const_ext.c test_const_test_const_loop.c
PASS: ./lus2lic {-o /tmp/when_tuple.lic should_work/when_tuple.lus}
PASS: ./lus2lic {-ec -o /tmp/when_tuple.ec should_work/when_tuple.lus}
PASS: ./myec2c {-o /tmp/when_tuple.c /tmp/when_tuple.ec}
@@ -765,7 +765,7 @@ PASS: ./lus2lic {-ec -o /tmp/carV2.ec should_work/carV2.lus}
PASS: ./myec2c {-o /tmp/carV2.c /tmp/carV2.ec}
PASS: ../utils/test_lus2lic_no_node should_work/carV2.lus
PASS: ./lus2lic {-2c should_work/carV2.lus -n carV2}
-PASS: gcc carV2_carV2.c carV2_carV2_loop.c
+PASS: gcc carV2_carV2.c carV2_carV2_ext.c carV2_carV2_loop.c
PASS: ./lus2lic {-o /tmp/test_merge.lic should_work/test_merge.lus}
PASS: ./lus2lic {-ec -o /tmp/test_merge.ec should_work/test_merge.lus}
FAIL: Try ec2c on the result: ./myec2c {-o /tmp/test_merge.c /tmp/test_merge.ec}
@@ -774,49 +774,49 @@ PASS: ./lus2lic {-ec -o /tmp/FillFollowedByRed.ec should_work/FillFollowedByRed.
PASS: ./myec2c {-o /tmp/FillFollowedByRed.c /tmp/FillFollowedByRed.ec}
PASS: ../utils/test_lus2lic_no_node should_work/FillFollowedByRed.lus
PASS: ./lus2lic {-2c should_work/FillFollowedByRed.lus -n FillFollowedByRed}
-PASS: gcc FillFollowedByRed_FillFollowedByRed.c FillFollowedByRed_FillFollowedByRed_loop.c
+PASS: gcc FillFollowedByRed_FillFollowedByRed.c FillFollowedByRed_FillFollowedByRed_ext.c FillFollowedByRed_FillFollowedByRed_loop.c
PASS: ./lus2lic {-o /tmp/sample_time_change.lic should_work/sample_time_change.lus}
PASS: ./lus2lic {-ec -o /tmp/sample_time_change.ec should_work/sample_time_change.lus}
PASS: ./myec2c {-o /tmp/sample_time_change.c /tmp/sample_time_change.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/sample_time_change.lus
PASS: ./lus2lic {-2c should_work/sample_time_change.lus -n sample_time_change}
-PASS: gcc sample_time_change_sample_time_change.c sample_time_change_sample_time_change_loop.c
+PASS: gcc sample_time_change_sample_time_change.c sample_time_change_sample_time_change_ext.c sample_time_change_sample_time_change_loop.c
PASS: ./lus2lic {-o /tmp/test_enum.lic should_work/test_enum.lus}
PASS: ./lus2lic {-ec -o /tmp/test_enum.ec should_work/test_enum.lus}
PASS: ./myec2c {-o /tmp/test_enum.c /tmp/test_enum.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/test_enum.lus
PASS: ./lus2lic {-2c should_work/test_enum.lus -n test_enum}
-PASS: gcc test_enum_test_enum.c test_enum_test_enum_loop.c
+PASS: gcc test_enum_test_enum.c test_enum_test_enum_ext.c test_enum_test_enum_loop.c
PASS: ./lus2lic {-o /tmp/predef01.lic should_work/predef01.lus}
PASS: ./lus2lic {-ec -o /tmp/predef01.ec should_work/predef01.lus}
PASS: ./myec2c {-o /tmp/predef01.c /tmp/predef01.ec}
PASS: ../utils/test_lus2lic_no_node should_work/predef01.lus
PASS: ./lus2lic {-2c should_work/predef01.lus -n predef01}
-PASS: gcc predef01_predef01.c predef01_predef01_loop.c
+PASS: gcc predef01_predef01.c predef01_predef01_ext.c predef01_predef01_loop.c
PASS: ./lus2lic {-o /tmp/long_et_stupide_nom_de_noeud.lic should_work/long_et_stupide_nom_de_noeud.lus}
PASS: ./lus2lic {-ec -o /tmp/long_et_stupide_nom_de_noeud.ec should_work/long_et_stupide_nom_de_noeud.lus}
PASS: ./myec2c {-o /tmp/long_et_stupide_nom_de_noeud.c /tmp/long_et_stupide_nom_de_noeud.ec}
PASS: ../utils/test_lus2lic_no_node should_work/long_et_stupide_nom_de_noeud.lus
PASS: ./lus2lic {-2c should_work/long_et_stupide_nom_de_noeud.lus -n long_et_stupide_nom_de_noeud}
-PASS: gcc long_et_stupide_nom_de_noeud_long_et_stupide_nom_de_noeud.c long_et_stupide_nom_de_noeud_long_et_stupide_nom_de_noeud_loop.c
+PASS: gcc long_et_stupide_nom_de_noeud_long_et_stupide_nom_de_noeud.c long_et_stupide_nom_de_noeud_long_et_stupide_nom_de_noeud_ext.c long_et_stupide_nom_de_noeud_long_et_stupide_nom_de_noeud_loop.c
PASS: ./lus2lic {-o /tmp/CURRENT.lic should_work/CURRENT.lus}
PASS: ./lus2lic {-ec -o /tmp/CURRENT.ec should_work/CURRENT.lus}
PASS: ./myec2c {-o /tmp/CURRENT.c /tmp/CURRENT.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/CURRENT.lus
PASS: ./lus2lic {-2c should_work/CURRENT.lus -n CURRENT}
-PASS: gcc CURRENT_CURRENT.c CURRENT_CURRENT_loop.c
+PASS: gcc CURRENT_CURRENT.c CURRENT_CURRENT_ext.c CURRENT_CURRENT_loop.c
PASS: ./lus2lic {-o /tmp/left.lic should_work/left.lus}
PASS: ./lus2lic {-ec -o /tmp/left.ec should_work/left.lus}
PASS: ./myec2c {-o /tmp/left.c /tmp/left.ec}
PASS: ../utils/test_lus2lic_no_node should_work/left.lus
FAIL: Generate c code : ./lus2lic {-2c should_work/left.lus -n left}
-FAIL: Check that the generated C code compiles : gcc left_left.c left_left_loop.c
+FAIL: Check that the generated C code compiles : gcc left_left.c left_left_ext.c left_left_loop.c
PASS: ./lus2lic {-o /tmp/ts04.lic should_work/ts04.lus}
PASS: ./lus2lic {-ec -o /tmp/ts04.ec should_work/ts04.lus}
PASS: ./myec2c {-o /tmp/ts04.c /tmp/ts04.ec}
PASS: ../utils/test_lus2lic_no_node should_work/ts04.lus
PASS: ./lus2lic {-2c should_work/ts04.lus -n ts04}
-PASS: gcc ts04_ts04.c ts04_ts04_loop.c
+PASS: gcc ts04_ts04.c ts04_ts04_ext.c ts04_ts04_loop.c
FAIL: without any option: ./lus2lic {-o /tmp/bug_map_fby.lic should_work/bug_map_fby.lus}
FAIL: Generate ec code : ./lus2lic {-ec -o /tmp/bug_map_fby.ec should_work/bug_map_fby.lus}
PASS: ./lus2lic {-o /tmp/multiclock.lic should_work/multiclock.lus}
@@ -824,37 +824,37 @@ PASS: ./lus2lic {-ec -o /tmp/multiclock.ec should_work/multiclock.lus}
PASS: ./myec2c {-o /tmp/multiclock.c /tmp/multiclock.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/multiclock.lus
PASS: ./lus2lic {-2c should_work/multiclock.lus -n multiclock}
-PASS: gcc multiclock_multiclock.c multiclock_multiclock_loop.c
+PASS: gcc multiclock_multiclock.c multiclock_multiclock_ext.c multiclock_multiclock_loop.c
PASS: ./lus2lic {-o /tmp/nc2.lic should_work/nc2.lus}
PASS: ./lus2lic {-ec -o /tmp/nc2.ec should_work/nc2.lus}
PASS: ./myec2c {-o /tmp/nc2.c /tmp/nc2.ec}
PASS: ../utils/test_lus2lic_no_node should_work/nc2.lus
PASS: ./lus2lic {-2c should_work/nc2.lus -n nc2}
-PASS: gcc nc2_nc2.c nc2_nc2_loop.c
+PASS: gcc nc2_nc2.c nc2_nc2_ext.c nc2_nc2_loop.c
PASS: ./lus2lic {-o /tmp/morel.lic should_work/morel.lus}
PASS: ./lus2lic {-ec -o /tmp/morel.ec should_work/morel.lus}
PASS: ./myec2c {-o /tmp/morel.c /tmp/morel.ec}
PASS: ../utils/test_lus2lic_no_node should_work/morel.lus
FAIL: Generate c code : ./lus2lic {-2c should_work/morel.lus -n morel}
-FAIL: Check that the generated C code compiles : gcc morel_morel.c morel_morel_loop.c
+FAIL: Check that the generated C code compiles : gcc morel_morel.c morel_morel_ext.c morel_morel_loop.c
PASS: ./lus2lic {-o /tmp/SOURIS.lic should_work/SOURIS.lus}
PASS: ./lus2lic {-ec -o /tmp/SOURIS.ec should_work/SOURIS.lus}
PASS: ./myec2c {-o /tmp/SOURIS.c /tmp/SOURIS.ec}
PASS: ../utils/test_lus2lic_no_node should_work/SOURIS.lus
PASS: ./lus2lic {-2c should_work/SOURIS.lus -n SOURIS}
-PASS: gcc SOURIS_SOURIS.c SOURIS_SOURIS_loop.c
+PASS: gcc SOURIS_SOURIS.c SOURIS_SOURIS_ext.c SOURIS_SOURIS_loop.c
PASS: ./lus2lic {-o /tmp/param_node2.lic should_work/param_node2.lus}
PASS: ./lus2lic {-ec -o /tmp/param_node2.ec should_work/param_node2.lus}
PASS: ./myec2c {-o /tmp/param_node2.c /tmp/param_node2.ec}
PASS: ../utils/test_lus2lic_no_node should_work/param_node2.lus
PASS: ./lus2lic {-2c should_work/param_node2.lus -n param_node2}
-PASS: gcc param_node2_param_node2.c param_node2_param_node2_loop.c
+PASS: gcc param_node2_param_node2.c param_node2_param_node2_ext.c param_node2_param_node2_loop.c
PASS: ./lus2lic {-o /tmp/o2l_feux_compl.lic should_work/o2l_feux_compl.lus}
PASS: ./lus2lic {-ec -o /tmp/o2l_feux_compl.ec should_work/o2l_feux_compl.lus}
PASS: ./myec2c {-o /tmp/o2l_feux_compl.c /tmp/o2l_feux_compl.ec}
PASS: ../utils/test_lus2lic_no_node should_work/o2l_feux_compl.lus
PASS: ./lus2lic {-2c should_work/o2l_feux_compl.lus -n o2l_feux_compl}
-PASS: gcc o2l_feux_compl_o2l_feux_compl.c o2l_feux_compl_o2l_feux_compl_loop.c
+PASS: gcc o2l_feux_compl_o2l_feux_compl.c o2l_feux_compl_o2l_feux_compl_ext.c o2l_feux_compl_o2l_feux_compl_loop.c
PASS: ./lus2lic {-o /tmp/model.lic should_work/model.lus}
PASS: ./lus2lic {-ec -o /tmp/model.ec should_work/model.lus}
PASS: ./myec2c {-o /tmp/model.c /tmp/model.ec}
@@ -865,55 +865,55 @@ PASS: ./lus2lic {-ec -o /tmp/matrice.ec should_work/matrice.lus}
PASS: ./myec2c {-o /tmp/matrice.c /tmp/matrice.ec}
PASS: ../utils/test_lus2lic_no_node should_work/matrice.lus
PASS: ./lus2lic {-2c should_work/matrice.lus -n matrice}
-PASS: gcc matrice_matrice.c matrice_matrice_loop.c
+PASS: gcc matrice_matrice.c matrice_matrice_ext.c matrice_matrice_loop.c
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: ./myec2c {-o /tmp/TIME_STABLE.c /tmp/TIME_STABLE.ec}
PASS: ../utils/test_lus2lic_no_node should_work/TIME_STABLE.lus
PASS: ./lus2lic {-2c should_work/TIME_STABLE.lus -n TIME_STABLE}
-PASS: gcc TIME_STABLE_TIME_STABLE.c TIME_STABLE_TIME_STABLE_loop.c
+PASS: gcc TIME_STABLE_TIME_STABLE.c TIME_STABLE_TIME_STABLE_ext.c TIME_STABLE_TIME_STABLE_loop.c
PASS: ./lus2lic {-o /tmp/cpt.lic should_work/cpt.lus}
PASS: ./lus2lic {-ec -o /tmp/cpt.ec should_work/cpt.lus}
PASS: ./myec2c {-o /tmp/cpt.c /tmp/cpt.ec}
PASS: ../utils/test_lus2lic_no_node should_work/cpt.lus
PASS: ./lus2lic {-2c should_work/cpt.lus -n cpt}
-PASS: gcc cpt_cpt.c cpt_cpt_loop.c
+PASS: gcc cpt_cpt.c cpt_cpt_ext.c cpt_cpt_loop.c
PASS: ./lus2lic {-o /tmp/multipar.lic should_work/multipar.lus}
PASS: ./lus2lic {-ec -o /tmp/multipar.ec should_work/multipar.lus}
PASS: ./myec2c {-o /tmp/multipar.c /tmp/multipar.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/multipar.lus
PASS: ./lus2lic {-2c should_work/multipar.lus -n multipar}
-PASS: gcc multipar_multipar.c multipar_multipar_loop.c
+PASS: gcc multipar_multipar.c multipar_multipar_ext.c multipar_multipar_loop.c
PASS: ./lus2lic {-o /tmp/activation_ec.lic should_work/activation_ec.lus}
PASS: ./lus2lic {-ec -o /tmp/activation_ec.ec should_work/activation_ec.lus}
PASS: ./myec2c {-o /tmp/activation_ec.c /tmp/activation_ec.ec}
PASS: ../utils/test_lus2lic_no_node should_work/activation_ec.lus
PASS: ./lus2lic {-2c should_work/activation_ec.lus -n activation_ec}
-PASS: gcc activation_ec_activation_ec.c activation_ec_activation_ec_loop.c
+PASS: gcc activation_ec_activation_ec.c activation_ec_activation_ec_ext.c activation_ec_activation_ec_loop.c
PASS: ./lus2lic {-o /tmp/impl_priority.lic should_work/impl_priority.lus}
PASS: ./lus2lic {-ec -o /tmp/impl_priority.ec should_work/impl_priority.lus}
PASS: ./myec2c {-o /tmp/impl_priority.c /tmp/impl_priority.ec}
PASS: ../utils/test_lus2lic_no_node should_work/impl_priority.lus
PASS: ./lus2lic {-2c should_work/impl_priority.lus -n impl_priority}
-PASS: gcc impl_priority_impl_priority.c impl_priority_impl_priority_loop.c
+PASS: gcc impl_priority_impl_priority.c impl_priority_impl_priority_ext.c impl_priority_impl_priority_loop.c
PASS: ./lus2lic {-o /tmp/exclusion.lic should_work/exclusion.lus}
PASS: ./lus2lic {-ec -o /tmp/exclusion.ec should_work/exclusion.lus}
PASS: ./myec2c {-o /tmp/exclusion.c /tmp/exclusion.ec}
PASS: ../utils/test_lus2lic_no_node should_work/exclusion.lus
PASS: ./lus2lic {-2c should_work/exclusion.lus -n exclusion}
-PASS: gcc exclusion_exclusion.c exclusion_exclusion_loop.c
+PASS: gcc exclusion_exclusion.c exclusion_exclusion_ext.c exclusion_exclusion_loop.c
PASS: ./lus2lic {-o /tmp/ply01.lic should_work/ply01.lus}
PASS: ./lus2lic {-ec -o /tmp/ply01.ec should_work/ply01.lus}
PASS: ./myec2c {-o /tmp/ply01.c /tmp/ply01.ec}
PASS: ../utils/test_lus2lic_no_node should_work/ply01.lus
PASS: ./lus2lic {-2c should_work/ply01.lus -n ply01}
-PASS: gcc ply01_ply01.c ply01_ply01_loop.c
+PASS: gcc ply01_ply01.c ply01_ply01_ext.c ply01_ply01_loop.c
PASS: ./lus2lic {-o /tmp/consensus.lic should_work/consensus.lus}
PASS: ./lus2lic {-ec -o /tmp/consensus.ec should_work/consensus.lus}
PASS: ./myec2c {-o /tmp/consensus.c /tmp/consensus.ec}
PASS: ../utils/test_lus2lic_no_node should_work/consensus.lus
PASS: ./lus2lic {-2c should_work/consensus.lus -n consensus}
-PASS: gcc consensus_consensus.c consensus_consensus_loop.c
+PASS: gcc consensus_consensus.c consensus_consensus_ext.c consensus_consensus_loop.c
PASS: ./lus2lic {-o /tmp/activation2.lic should_work/activation2.lus}
PASS: ./lus2lic {-ec -o /tmp/activation2.ec should_work/activation2.lus}
PASS: ./myec2c {-o /tmp/activation2.c /tmp/activation2.ec}
@@ -924,79 +924,79 @@ PASS: ./lus2lic {-ec -o /tmp/type_decl.ec should_work/type_decl.lus}
PASS: ./myec2c {-o /tmp/type_decl.c /tmp/type_decl.ec}
PASS: ../utils/test_lus2lic_no_node should_work/type_decl.lus
PASS: ./lus2lic {-2c should_work/type_decl.lus -n type_decl}
-PASS: gcc type_decl_type_decl.c type_decl_type_decl_loop.c
+PASS: gcc type_decl_type_decl.c type_decl_type_decl_ext.c type_decl_type_decl_loop.c
PASS: ./lus2lic {-o /tmp/import1.lic should_work/import1.lus}
PASS: ./lus2lic {-ec -o /tmp/import1.ec should_work/import1.lus}
PASS: ./myec2c {-o /tmp/import1.c /tmp/import1.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/import1.lus
PASS: ./lus2lic {-2c should_work/import1.lus -n import1}
-FAIL: Check that the generated C code compiles : gcc import1_import1.c import1_import1_loop.c
+FAIL: Check that the generated C code compiles : gcc import1_import1.c import1_import1_ext.c import1_import1_loop.c
PASS: ./lus2lic {-o /tmp/pack1.lic should_work/pack1.lus}
PASS: ./lus2lic {-ec -o /tmp/pack1.ec should_work/pack1.lus}
PASS: ./myec2c {-o /tmp/pack1.c /tmp/pack1.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/pack1.lus
PASS: ./lus2lic {-2c should_work/pack1.lus -n pack1}
-PASS: gcc pack1_pack1.c pack1_pack1_loop.c
+PASS: gcc pack1_pack1.c pack1_pack1_ext.c pack1_pack1_loop.c
PASS: ./lus2lic {-o /tmp/bob.lic should_work/bob.lus}
PASS: ./lus2lic {-ec -o /tmp/bob.ec should_work/bob.lus}
PASS: ./myec2c {-o /tmp/bob.c /tmp/bob.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/bob.lus
PASS: ./lus2lic {-2c should_work/bob.lus -n bob}
-PASS: gcc bob_bob.c bob_bob_loop.c
+PASS: gcc bob_bob.c bob_bob_ext.c bob_bob_loop.c
PASS: ./lus2lic {-o /tmp/notTwo.lic should_work/notTwo.lus}
PASS: ./lus2lic {-ec -o /tmp/notTwo.ec should_work/notTwo.lus}
PASS: ./myec2c {-o /tmp/notTwo.c /tmp/notTwo.ec}
PASS: ../utils/test_lus2lic_no_node should_work/notTwo.lus
PASS: ./lus2lic {-2c should_work/notTwo.lus -n notTwo}
-PASS: gcc notTwo_notTwo.c notTwo_notTwo_loop.c
+PASS: gcc notTwo_notTwo.c notTwo_notTwo_ext.c notTwo_notTwo_loop.c
PASS: ./lus2lic {-o /tmp/stopwatch.lic should_work/stopwatch.lus}
PASS: ./lus2lic {-ec -o /tmp/stopwatch.ec should_work/stopwatch.lus}
PASS: ./myec2c {-o /tmp/stopwatch.c /tmp/stopwatch.ec}
PASS: ../utils/test_lus2lic_no_node should_work/stopwatch.lus
PASS: ./lus2lic {-2c should_work/stopwatch.lus -n stopwatch}
-PASS: gcc stopwatch_stopwatch.c stopwatch_stopwatch_loop.c
+PASS: gcc stopwatch_stopwatch.c stopwatch_stopwatch_ext.c stopwatch_stopwatch_loop.c
PASS: ./lus2lic {-o /tmp/test_condact.lic should_work/test_condact.lus}
PASS: ./lus2lic {-ec -o /tmp/test_condact.ec should_work/test_condact.lus}
PASS: ./myec2c {-o /tmp/test_condact.c /tmp/test_condact.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/test_condact.lus
PASS: ./lus2lic {-2c should_work/test_condact.lus -n test_condact}
-PASS: gcc test_condact_test_condact.c test_condact_test_condact_loop.c
+PASS: gcc test_condact_test_condact.c test_condact_test_condact_ext.c test_condact_test_condact_loop.c
PASS: ./lus2lic {-o /tmp/contractForElementSelectionInArray.lic should_work/contractForElementSelectionInArray.lus}
PASS: ./lus2lic {-ec -o /tmp/contractForElementSelectionInArray.ec should_work/contractForElementSelectionInArray.lus}
PASS: ./myec2c {-o /tmp/contractForElementSelectionInArray.c /tmp/contractForElementSelectionInArray.ec}
PASS: ../utils/test_lus2lic_no_node should_work/contractForElementSelectionInArray.lus
PASS: ./lus2lic {-2c should_work/contractForElementSelectionInArray.lus -n contractForElementSelectionInArray}
-PASS: gcc contractForElementSelectionInArray_contractForElementSelectionInArray.c contractForElementSelectionInArray_contractForElementSelectionInArray_loop.c
+PASS: gcc contractForElementSelectionInArray_contractForElementSelectionInArray.c contractForElementSelectionInArray_contractForElementSelectionInArray_ext.c contractForElementSelectionInArray_contractForElementSelectionInArray_loop.c
PASS: ./lus2lic {-o /tmp/iterFibo.lic should_work/iterFibo.lus}
PASS: ./lus2lic {-ec -o /tmp/iterFibo.ec should_work/iterFibo.lus}
PASS: ./myec2c {-o /tmp/iterFibo.c /tmp/iterFibo.ec}
PASS: ../utils/test_lus2lic_no_node should_work/iterFibo.lus
PASS: ./lus2lic {-2c should_work/iterFibo.lus -n iterFibo}
-PASS: gcc iterFibo_iterFibo.c iterFibo_iterFibo_loop.c
+PASS: gcc iterFibo_iterFibo.c iterFibo_iterFibo_ext.c iterFibo_iterFibo_loop.c
PASS: ./lus2lic {-o /tmp/morel2.lic should_work/morel2.lus}
PASS: ./lus2lic {-ec -o /tmp/morel2.ec should_work/morel2.lus}
PASS: ./myec2c {-o /tmp/morel2.c /tmp/morel2.ec}
PASS: ../utils/test_lus2lic_no_node should_work/morel2.lus
FAIL: Generate c code : ./lus2lic {-2c should_work/morel2.lus -n morel2}
-FAIL: Check that the generated C code compiles : gcc morel2_morel2.c morel2_morel2_loop.c
+FAIL: Check that the generated C code compiles : gcc morel2_morel2.c morel2_morel2_ext.c morel2_morel2_loop.c
PASS: ./lus2lic {-o /tmp/minmax1.lic should_work/minmax1.lus}
PASS: ./lus2lic {-ec -o /tmp/minmax1.ec should_work/minmax1.lus}
PASS: ./myec2c {-o /tmp/minmax1.c /tmp/minmax1.ec}
PASS: ../utils/test_lus2lic_no_node should_work/minmax1.lus
PASS: ./lus2lic {-2c should_work/minmax1.lus -n minmax1}
-PASS: gcc minmax1_minmax1.c minmax1_minmax1_loop.c
+PASS: gcc minmax1_minmax1.c minmax1_minmax1_ext.c minmax1_minmax1_loop.c
PASS: ./lus2lic {-o /tmp/aa.lic should_work/aa.lus}
PASS: ./lus2lic {-ec -o /tmp/aa.ec should_work/aa.lus}
PASS: ./myec2c {-o /tmp/aa.c /tmp/aa.ec}
PASS: ../utils/test_lus2lic_no_node should_work/aa.lus
PASS: ./lus2lic {-2c should_work/aa.lus -n aa}
-PASS: gcc aa_aa.c aa_aa_loop.c
+PASS: gcc aa_aa.c aa_aa_ext.c aa_aa_loop.c
PASS: ./lus2lic {-o /tmp/mouse3.lic should_work/mouse3.lus}
PASS: ./lus2lic {-ec -o /tmp/mouse3.ec should_work/mouse3.lus}
PASS: ./myec2c {-o /tmp/mouse3.c /tmp/mouse3.ec}
PASS: ../utils/test_lus2lic_no_node should_work/mouse3.lus
PASS: ./lus2lic {-2c should_work/mouse3.lus -n mouse3}
-PASS: gcc mouse3_mouse3.c mouse3_mouse3_loop.c
+PASS: gcc mouse3_mouse3.c mouse3_mouse3_ext.c mouse3_mouse3_loop.c
PASS: ./lus2lic {-o /tmp/array_concat.lic should_work/array_concat.lus}
PASS: ./lus2lic {-ec -o /tmp/array_concat.ec should_work/array_concat.lus}
FAIL: Try ec2c on the result: ./myec2c {-o /tmp/array_concat.c /tmp/array_concat.ec}
@@ -1005,19 +1005,19 @@ PASS: ./lus2lic {-ec -o /tmp/ex.ec should_work/ex.lus}
PASS: ./myec2c {-o /tmp/ex.c /tmp/ex.ec}
PASS: ../utils/test_lus2lic_no_node should_work/ex.lus
PASS: ./lus2lic {-2c should_work/ex.lus -n ex}
-PASS: gcc ex_ex.c ex_ex_loop.c
+PASS: gcc ex_ex.c ex_ex_ext.c ex_ex_loop.c
PASS: ./lus2lic {-o /tmp/xxx.lic should_work/xxx.lus}
PASS: ./lus2lic {-ec -o /tmp/xxx.ec should_work/xxx.lus}
PASS: ./myec2c {-o /tmp/xxx.c /tmp/xxx.ec}
PASS: ../utils/test_lus2lic_no_node should_work/xxx.lus
PASS: ./lus2lic {-2c should_work/xxx.lus -n xxx}
-PASS: gcc xxx_xxx.c xxx_xxx_loop.c
+PASS: gcc xxx_xxx.c xxx_xxx_ext.c xxx_xxx_loop.c
PASS: ./lus2lic {-o /tmp/moyenne.lic should_work/moyenne.lus}
PASS: ./lus2lic {-ec -o /tmp/moyenne.ec should_work/moyenne.lus}
PASS: ./myec2c {-o /tmp/moyenne.c /tmp/moyenne.ec}
PASS: ../utils/test_lus2lic_no_node should_work/moyenne.lus
PASS: ./lus2lic {-2c should_work/moyenne.lus -n moyenne}
-PASS: gcc moyenne_moyenne.c moyenne_moyenne_loop.c
+PASS: gcc moyenne_moyenne.c moyenne_moyenne_ext.c moyenne_moyenne_loop.c
PASS: ./lus2lic {-o /tmp/activation1.lic should_work/activation1.lus}
PASS: ./lus2lic {-ec -o /tmp/activation1.ec should_work/activation1.lus}
PASS: ./myec2c {-o /tmp/activation1.c /tmp/activation1.ec}
@@ -1028,25 +1028,25 @@ PASS: ./lus2lic {-ec -o /tmp/call01.ec should_work/call01.lus}
PASS: ./myec2c {-o /tmp/call01.c /tmp/call01.ec}
PASS: ../utils/test_lus2lic_no_node should_work/call01.lus
PASS: ./lus2lic {-2c should_work/call01.lus -n call01}
-PASS: gcc call01_call01.c call01_call01_loop.c
+PASS: gcc call01_call01.c call01_call01_ext.c call01_call01_loop.c
PASS: ./lus2lic {-o /tmp/bug.lic should_work/bug.lus}
PASS: ./lus2lic {-ec -o /tmp/bug.ec should_work/bug.lus}
PASS: ./myec2c {-o /tmp/bug.c /tmp/bug.ec}
PASS: ../utils/test_lus2lic_no_node should_work/bug.lus
PASS: ./lus2lic {-2c should_work/bug.lus -n bug}
-PASS: gcc bug_bug.c bug_bug_loop.c
+PASS: gcc bug_bug.c bug_bug_ext.c bug_bug_loop.c
PASS: ./lus2lic {-o /tmp/ck4.lic should_work/ck4.lus}
PASS: ./lus2lic {-ec -o /tmp/ck4.ec should_work/ck4.lus}
PASS: ./myec2c {-o /tmp/ck4.c /tmp/ck4.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/ck4.lus
PASS: ./lus2lic {-2c should_work/ck4.lus -n ck4}
-PASS: gcc ck4_ck4.c ck4_ck4_loop.c
+PASS: gcc ck4_ck4.c ck4_ck4_ext.c ck4_ck4_loop.c
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: ./myec2c {-o /tmp/map_red_iter.c /tmp/map_red_iter.ec}
PASS: ../utils/test_lus2lic_no_node should_work/map_red_iter.lus
PASS: ./lus2lic {-2c should_work/map_red_iter.lus -n map_red_iter}
-PASS: gcc map_red_iter_map_red_iter.c map_red_iter_map_red_iter_loop.c
+PASS: gcc map_red_iter_map_red_iter.c map_red_iter_map_red_iter_ext.c map_red_iter_map_red_iter_loop.c
PASS: ./lus2lic {-o /tmp/p.lic should_work/p.lus}
PASS: ./lus2lic {-ec -o /tmp/p.ec should_work/p.lus}
PASS: ./myec2c {-o /tmp/p.c /tmp/p.ec}
@@ -1057,43 +1057,43 @@ PASS: ./lus2lic {-ec -o /tmp/struct0.ec should_work/struct0.lus}
PASS: ./myec2c {-o /tmp/struct0.c /tmp/struct0.ec}
PASS: ../utils/test_lus2lic_no_node should_work/struct0.lus
PASS: ./lus2lic {-2c should_work/struct0.lus -n struct0}
-PASS: gcc struct0_struct0.c struct0_struct0_loop.c
+PASS: gcc struct0_struct0.c struct0_struct0_ext.c struct0_struct0_loop.c
PASS: ./lus2lic {-o /tmp/filliter.lic should_work/filliter.lus}
PASS: ./lus2lic {-ec -o /tmp/filliter.ec should_work/filliter.lus}
PASS: ./myec2c {-o /tmp/filliter.c /tmp/filliter.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/filliter.lus
PASS: ./lus2lic {-2c should_work/filliter.lus -n filliter}
-PASS: gcc filliter_filliter.c filliter_filliter_loop.c
+PASS: gcc filliter_filliter.c filliter_filliter_ext.c filliter_filliter_loop.c
PASS: ./lus2lic {-o /tmp/minmax4.lic should_work/minmax4.lus}
PASS: ./lus2lic {-ec -o /tmp/minmax4.ec should_work/minmax4.lus}
PASS: ./myec2c {-o /tmp/minmax4.c /tmp/minmax4.ec}
PASS: ../utils/test_lus2lic_no_node should_work/minmax4.lus
PASS: ./lus2lic {-2c should_work/minmax4.lus -n minmax4}
-PASS: gcc minmax4_minmax4.c minmax4_minmax4_loop.c
+PASS: gcc minmax4_minmax4.c minmax4_minmax4_ext.c minmax4_minmax4_loop.c
PASS: ./lus2lic {-o /tmp/nested.lic should_work/nested.lus}
PASS: ./lus2lic {-ec -o /tmp/nested.ec should_work/nested.lus}
PASS: ./myec2c {-o /tmp/nested.c /tmp/nested.ec}
PASS: ../utils/test_lus2lic_no_node should_work/nested.lus
PASS: ./lus2lic {-2c should_work/nested.lus -n nested}
-PASS: gcc nested_nested.c nested_nested_loop.c
+PASS: gcc nested_nested.c nested_nested_ext.c nested_nested_loop.c
PASS: ./lus2lic {-o /tmp/Gyroscope.lic should_work/Gyroscope.lus}
PASS: ./lus2lic {-ec -o /tmp/Gyroscope.ec should_work/Gyroscope.lus}
PASS: ./myec2c {-o /tmp/Gyroscope.c /tmp/Gyroscope.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/Gyroscope.lus
PASS: ./lus2lic {-2c should_work/Gyroscope.lus -n Gyroscope}
-PASS: gcc Gyroscope_Gyroscope.c Gyroscope_Gyroscope_loop.c
+PASS: gcc Gyroscope_Gyroscope.c Gyroscope_Gyroscope_ext.c Gyroscope_Gyroscope_loop.c
PASS: ./lus2lic {-o /tmp/test_map.lic should_work/test_map.lus}
PASS: ./lus2lic {-ec -o /tmp/test_map.ec should_work/test_map.lus}
PASS: ./myec2c {-o /tmp/test_map.c /tmp/test_map.ec}
PASS: ../utils/test_lus2lic_no_node should_work/test_map.lus
PASS: ./lus2lic {-2c should_work/test_map.lus -n test_map}
-PASS: gcc test_map_test_map.c test_map_test_map_loop.c
+PASS: gcc test_map_test_map.c test_map_test_map_ext.c test_map_test_map_loop.c
PASS: ./lus2lic {-o /tmp/followed_by.lic should_work/followed_by.lus}
PASS: ./lus2lic {-ec -o /tmp/followed_by.ec should_work/followed_by.lus}
PASS: ./myec2c {-o /tmp/followed_by.c /tmp/followed_by.ec}
PASS: ../utils/test_lus2lic_no_node should_work/followed_by.lus
PASS: ./lus2lic {-2c should_work/followed_by.lus -n followed_by}
-PASS: gcc followed_by_followed_by.c followed_by_followed_by_loop.c
+PASS: gcc followed_by_followed_by.c followed_by_followed_by_ext.c followed_by_followed_by_loop.c
PASS: ./lus2lic {-o /tmp/asservi.lic should_work/asservi.lus}
PASS: ./lus2lic {-ec -o /tmp/asservi.ec should_work/asservi.lus}
PASS: ./myec2c {-o /tmp/asservi.c /tmp/asservi.ec}
@@ -1104,13 +1104,13 @@ PASS: ./lus2lic {-ec -o /tmp/rediter.ec should_work/rediter.lus}
PASS: ./myec2c {-o /tmp/rediter.c /tmp/rediter.ec}
PASS: ../utils/test_lus2lic_no_node should_work/rediter.lus
PASS: ./lus2lic {-2c should_work/rediter.lus -n rediter}
-PASS: gcc rediter_rediter.c rediter_rediter_loop.c
+PASS: gcc rediter_rediter.c rediter_rediter_ext.c rediter_rediter_loop.c
PASS: ./lus2lic {-o /tmp/mapdeRed.lic should_work/mapdeRed.lus}
PASS: ./lus2lic {-ec -o /tmp/mapdeRed.ec should_work/mapdeRed.lus}
PASS: ./myec2c {-o /tmp/mapdeRed.c /tmp/mapdeRed.ec}
PASS: ../utils/test_lus2lic_no_node should_work/mapdeRed.lus
PASS: ./lus2lic {-2c should_work/mapdeRed.lus -n mapdeRed}
-PASS: gcc mapdeRed_mapdeRed.c mapdeRed_mapdeRed_loop.c
+PASS: gcc mapdeRed_mapdeRed.c mapdeRed_mapdeRed_ext.c mapdeRed_mapdeRed_loop.c
PASS: ./lus2lic {-o /tmp/modelInst.lic should_work/modelInst.lus}
PASS: ./lus2lic {-ec -o /tmp/modelInst.ec should_work/modelInst.lus}
PASS: ./myec2c {-o /tmp/modelInst.c /tmp/modelInst.ec}
@@ -1121,19 +1121,19 @@ PASS: ./lus2lic {-ec -o /tmp/dependeur_struct.ec should_work/dependeur_struct.lu
PASS: ./myec2c {-o /tmp/dependeur_struct.c /tmp/dependeur_struct.ec}
PASS: ../utils/test_lus2lic_no_node should_work/dependeur_struct.lus
PASS: ./lus2lic {-2c should_work/dependeur_struct.lus -n dependeur_struct}
-PASS: gcc dependeur_struct_dependeur_struct.c dependeur_struct_dependeur_struct_loop.c
+PASS: gcc dependeur_struct_dependeur_struct.c dependeur_struct_dependeur_struct_ext.c dependeur_struct_dependeur_struct_loop.c
PASS: ./lus2lic {-o /tmp/minmax4_bis.lic should_work/minmax4_bis.lus}
PASS: ./lus2lic {-ec -o /tmp/minmax4_bis.ec should_work/minmax4_bis.lus}
PASS: ./myec2c {-o /tmp/minmax4_bis.c /tmp/minmax4_bis.ec}
PASS: ../utils/test_lus2lic_no_node should_work/minmax4_bis.lus
PASS: ./lus2lic {-2c should_work/minmax4_bis.lus -n minmax4_bis}
-PASS: gcc minmax4_bis_minmax4_bis.c minmax4_bis_minmax4_bis_loop.c
+PASS: gcc minmax4_bis_minmax4_bis.c minmax4_bis_minmax4_bis_ext.c minmax4_bis_minmax4_bis_loop.c
PASS: ./lus2lic {-o /tmp/test_struct.lic should_work/test_struct.lus}
PASS: ./lus2lic {-ec -o /tmp/test_struct.ec should_work/test_struct.lus}
PASS: ./myec2c {-o /tmp/test_struct.c /tmp/test_struct.ec}
PASS: ../utils/test_lus2lic_no_node should_work/test_struct.lus
PASS: ./lus2lic {-2c should_work/test_struct.lus -n test_struct}
-PASS: gcc test_struct_test_struct.c test_struct_test_struct_loop.c
+PASS: gcc test_struct_test_struct.c test_struct_test_struct_ext.c test_struct_test_struct_loop.c
PASS: ./lus2lic {-o /tmp/modes3x2_v4.lic should_work/modes3x2_v4.lus}
PASS: ./lus2lic {-ec -o /tmp/modes3x2_v4.ec should_work/modes3x2_v4.lus}
FAIL: Try ec2c on the result: ./myec2c {-o /tmp/modes3x2_v4.c /tmp/modes3x2_v4.ec}
@@ -1142,13 +1142,13 @@ PASS: ./lus2lic {-ec -o /tmp/uu.ec should_work/uu.lus}
PASS: ./myec2c {-o /tmp/uu.c /tmp/uu.ec}
PASS: ../utils/test_lus2lic_no_node should_work/uu.lus
PASS: ./lus2lic {-2c should_work/uu.lus -n uu}
-PASS: gcc uu_uu.c uu_uu_loop.c
+PASS: gcc uu_uu.c uu_uu_ext.c uu_uu_loop.c
PASS: ./lus2lic {-o /tmp/simpleRed.lic should_work/simpleRed.lus}
PASS: ./lus2lic {-ec -o /tmp/simpleRed.ec should_work/simpleRed.lus}
PASS: ./myec2c {-o /tmp/simpleRed.c /tmp/simpleRed.ec}
PASS: ../utils/test_lus2lic_no_node should_work/simpleRed.lus
PASS: ./lus2lic {-2c should_work/simpleRed.lus -n simpleRed}
-PASS: gcc simpleRed_simpleRed.c simpleRed_simpleRed_loop.c
+PASS: gcc simpleRed_simpleRed.c simpleRed_simpleRed_ext.c simpleRed_simpleRed_loop.c
PASS: ./lus2lic {-o /tmp/modes3x2_v3.lic should_work/modes3x2_v3.lus}
PASS: ./lus2lic {-ec -o /tmp/modes3x2_v3.ec should_work/modes3x2_v3.lus}
FAIL: Try ec2c on the result: ./myec2c {-o /tmp/modes3x2_v3.c /tmp/modes3x2_v3.ec}
@@ -1157,37 +1157,37 @@ PASS: ./lus2lic {-ec -o /tmp/pre_x.ec should_work/pre_x.lus}
PASS: ./myec2c {-o /tmp/pre_x.c /tmp/pre_x.ec}
PASS: ../utils/test_lus2lic_no_node should_work/pre_x.lus
PASS: ./lus2lic {-2c should_work/pre_x.lus -n pre_x}
-PASS: gcc pre_x_pre_x.c pre_x_pre_x_loop.c
+PASS: gcc pre_x_pre_x.c pre_x_pre_x_ext.c pre_x_pre_x_loop.c
PASS: ./lus2lic {-o /tmp/ts01.lic should_work/ts01.lus}
PASS: ./lus2lic {-ec -o /tmp/ts01.ec should_work/ts01.lus}
PASS: ./myec2c {-o /tmp/ts01.c /tmp/ts01.ec}
PASS: ../utils/test_lus2lic_no_node should_work/ts01.lus
PASS: ./lus2lic {-2c should_work/ts01.lus -n ts01}
-PASS: gcc ts01_ts01.c ts01_ts01_loop.c
+PASS: gcc ts01_ts01.c ts01_ts01_ext.c ts01_ts01_loop.c
PASS: ./lus2lic {-o /tmp/_N_uu.lic should_work/_N_uu.lus}
PASS: ./lus2lic {-ec -o /tmp/_N_uu.ec should_work/_N_uu.lus}
PASS: ./myec2c {-o /tmp/_N_uu.c /tmp/_N_uu.ec}
PASS: ../utils/test_lus2lic_no_node should_work/_N_uu.lus
PASS: ./lus2lic {-2c should_work/_N_uu.lus -n _N_uu}
-PASS: gcc _N_uu__N_uu.c _N_uu__N_uu_loop.c
+PASS: gcc _N_uu__N_uu.c _N_uu__N_uu_ext.c _N_uu__N_uu_loop.c
PASS: ./lus2lic {-o /tmp/X2.lic should_work/X2.lus}
PASS: ./lus2lic {-ec -o /tmp/X2.ec should_work/X2.lus}
PASS: ./myec2c {-o /tmp/X2.c /tmp/X2.ec}
PASS: ../utils/test_lus2lic_no_node should_work/X2.lus
PASS: ./lus2lic {-2c should_work/X2.lus -n X2}
-PASS: gcc X2_X2.c X2_X2_loop.c
+PASS: gcc X2_X2.c X2_X2_ext.c X2_X2_loop.c
PASS: ./lus2lic {-o /tmp/alias.lic should_work/alias.lus}
PASS: ./lus2lic {-ec -o /tmp/alias.ec should_work/alias.lus}
PASS: ./myec2c {-o /tmp/alias.c /tmp/alias.ec}
PASS: ../utils/test_lus2lic_no_node should_work/alias.lus
PASS: ./lus2lic {-2c should_work/alias.lus -n alias}
-PASS: gcc alias_alias.c alias_alias_loop.c
+PASS: gcc alias_alias.c alias_alias_ext.c alias_alias_loop.c
PASS: ./lus2lic {-o /tmp/hanane.lic should_work/hanane.lus}
PASS: ./lus2lic {-ec -o /tmp/hanane.ec should_work/hanane.lus}
PASS: ./myec2c {-o /tmp/hanane.c /tmp/hanane.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/hanane.lus
PASS: ./lus2lic {-2c should_work/hanane.lus -n hanane}
-PASS: gcc hanane_hanane.c hanane_hanane_loop.c
+PASS: gcc hanane_hanane.c hanane_hanane_ext.c hanane_hanane_loop.c
PASS: ./lus2lic {-o /tmp/lustre.lic should_work/lustre.lus}
PASS: ./lus2lic {-ec -o /tmp/lustre.ec should_work/lustre.lus}
PASS: ./myec2c {-o /tmp/lustre.c /tmp/lustre.ec}
@@ -1203,85 +1203,85 @@ PASS: ./lus2lic {-ec -o /tmp/predef02.ec should_work/predef02.lus}
PASS: ./myec2c {-o /tmp/predef02.c /tmp/predef02.ec}
PASS: ../utils/test_lus2lic_no_node should_work/predef02.lus
PASS: ./lus2lic {-2c should_work/predef02.lus -n predef02}
-PASS: gcc predef02_predef02.c predef02_predef02_loop.c
+PASS: gcc predef02_predef02.c predef02_predef02_ext.c predef02_predef02_loop.c
PASS: ./lus2lic {-o /tmp/toto.lic should_work/toto.lus}
PASS: ./lus2lic {-ec -o /tmp/toto.ec should_work/toto.lus}
PASS: ./myec2c {-o /tmp/toto.c /tmp/toto.ec}
PASS: ../utils/test_lus2lic_no_node should_work/toto.lus
PASS: ./lus2lic {-2c should_work/toto.lus -n toto}
-PASS: gcc toto_toto.c toto_toto_loop.c
+PASS: gcc toto_toto.c toto_toto_ext.c toto_toto_loop.c
PASS: ./lus2lic {-o /tmp/minmax6.lic should_work/minmax6.lus}
PASS: ./lus2lic {-ec -o /tmp/minmax6.ec should_work/minmax6.lus}
PASS: ./myec2c {-o /tmp/minmax6.c /tmp/minmax6.ec}
PASS: ../utils/test_lus2lic_no_node should_work/minmax6.lus
PASS: ./lus2lic {-2c should_work/minmax6.lus -n minmax6}
-PASS: gcc minmax6_minmax6.c minmax6_minmax6_loop.c
+PASS: gcc minmax6_minmax6.c minmax6_minmax6_ext.c minmax6_minmax6_loop.c
PASS: ./lus2lic {-o /tmp/ck3.lic should_work/ck3.lus}
PASS: ./lus2lic {-ec -o /tmp/ck3.ec should_work/ck3.lus}
PASS: ./myec2c {-o /tmp/ck3.c /tmp/ck3.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/ck3.lus
PASS: ./lus2lic {-2c should_work/ck3.lus -n ck3}
-PASS: gcc ck3_ck3.c ck3_ck3_loop.c
+PASS: gcc ck3_ck3.c ck3_ck3_ext.c ck3_ck3_loop.c
PASS: ./lus2lic {-o /tmp/zzz.lic should_work/zzz.lus}
PASS: ./lus2lic {-ec -o /tmp/zzz.ec should_work/zzz.lus}
PASS: ./myec2c {-o /tmp/zzz.c /tmp/zzz.ec}
PASS: ../utils/test_lus2lic_no_node should_work/zzz.lus
PASS: ./lus2lic {-2c should_work/zzz.lus -n zzz}
-PASS: gcc zzz_zzz.c zzz_zzz_loop.c
+PASS: gcc zzz_zzz.c zzz_zzz_ext.c zzz_zzz_loop.c
PASS: ./lus2lic {-o /tmp/STABLE.lic should_work/STABLE.lus}
PASS: ./lus2lic {-ec -o /tmp/STABLE.ec should_work/STABLE.lus}
PASS: ./myec2c {-o /tmp/STABLE.c /tmp/STABLE.ec}
PASS: ../utils/test_lus2lic_no_node should_work/STABLE.lus
PASS: ./lus2lic {-2c should_work/STABLE.lus -n STABLE}
-PASS: gcc STABLE_STABLE.c STABLE_STABLE_loop.c
+PASS: gcc STABLE_STABLE.c STABLE_STABLE_ext.c STABLE_STABLE_loop.c
PASS: ./lus2lic {-o /tmp/mapiter.lic should_work/mapiter.lus}
PASS: ./lus2lic {-ec -o /tmp/mapiter.ec should_work/mapiter.lus}
PASS: ./myec2c {-o /tmp/mapiter.c /tmp/mapiter.ec}
PASS: ../utils/test_lus2lic_no_node should_work/mapiter.lus
PASS: ./lus2lic {-2c should_work/mapiter.lus -n mapiter}
-PASS: gcc mapiter_mapiter.c mapiter_mapiter_loop.c
+PASS: gcc mapiter_mapiter.c mapiter_mapiter_ext.c mapiter_mapiter_loop.c
PASS: ./lus2lic {-o /tmp/tuple.lic should_work/tuple.lus}
PASS: ./lus2lic {-ec -o /tmp/tuple.ec should_work/tuple.lus}
PASS: ./myec2c {-o /tmp/tuple.c /tmp/tuple.ec}
PASS: ../utils/test_lus2lic_no_node should_work/tuple.lus
PASS: ./lus2lic {-2c should_work/tuple.lus -n tuple}
-PASS: gcc tuple_tuple.c tuple_tuple_loop.c
+PASS: gcc tuple_tuple.c tuple_tuple_ext.c tuple_tuple_loop.c
PASS: ./lus2lic {-o /tmp/call02.lic should_work/call02.lus}
PASS: ./lus2lic {-ec -o /tmp/call02.ec should_work/call02.lus}
PASS: ./myec2c {-o /tmp/call02.c /tmp/call02.ec}
PASS: ../utils/test_lus2lic_no_node should_work/call02.lus
PASS: ./lus2lic {-2c should_work/call02.lus -n call02}
-PASS: gcc call02_call02.c call02_call02_loop.c
+PASS: gcc call02_call02.c call02_call02_ext.c call02_call02_loop.c
PASS: ./lus2lic {-o /tmp/ck7.lic should_work/ck7.lus}
PASS: ./lus2lic {-ec -o /tmp/ck7.ec should_work/ck7.lus}
PASS: ./myec2c {-o /tmp/ck7.c /tmp/ck7.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/ck7.lus
PASS: ./lus2lic {-2c should_work/ck7.lus -n ck7}
-PASS: gcc ck7_ck7.c ck7_ck7_loop.c
+PASS: gcc ck7_ck7.c ck7_ck7_ext.c ck7_ck7_loop.c
PASS: ./lus2lic {-o /tmp/nc10.lic should_work/nc10.lus}
PASS: ./lus2lic {-ec -o /tmp/nc10.ec should_work/nc10.lus}
PASS: ./myec2c {-o /tmp/nc10.c /tmp/nc10.ec}
PASS: ../utils/test_lus2lic_no_node should_work/nc10.lus
PASS: ./lus2lic {-2c should_work/nc10.lus -n nc10}
-PASS: gcc nc10_nc10.c nc10_nc10_loop.c
+PASS: gcc nc10_nc10.c nc10_nc10_ext.c nc10_nc10_loop.c
PASS: ./lus2lic {-o /tmp/triSel.lic should_work/triSel.lus}
PASS: ./lus2lic {-ec -o /tmp/triSel.ec should_work/triSel.lus}
PASS: ./myec2c {-o /tmp/triSel.c /tmp/triSel.ec}
PASS: ../utils/test_lus2lic_no_node should_work/triSel.lus
PASS: ./lus2lic {-2c should_work/triSel.lus -n triSel}
-PASS: gcc triSel_triSel.c triSel_triSel_loop.c
+PASS: gcc triSel_triSel.c triSel_triSel_ext.c triSel_triSel_loop.c
PASS: ./lus2lic {-o /tmp/redoptest.lic should_work/redoptest.lus}
PASS: ./lus2lic {-ec -o /tmp/redoptest.ec should_work/redoptest.lus}
PASS: ./myec2c {-o /tmp/redoptest.c /tmp/redoptest.ec}
PASS: ../utils/test_lus2lic_no_node should_work/redoptest.lus
PASS: ./lus2lic {-2c should_work/redoptest.lus -n redoptest}
-PASS: gcc redoptest_redoptest.c redoptest_redoptest_loop.c
+PASS: gcc redoptest_redoptest.c redoptest_redoptest_ext.c redoptest_redoptest_loop.c
PASS: ./lus2lic {-o /tmp/flo.lic should_work/flo.lus}
PASS: ./lus2lic {-ec -o /tmp/flo.ec should_work/flo.lus}
PASS: ./myec2c {-o /tmp/flo.c /tmp/flo.ec}
PASS: ../utils/test_lus2lic_no_node should_work/flo.lus
PASS: ./lus2lic {-2c should_work/flo.lus -n flo}
-PASS: gcc flo_flo.c flo_flo_loop.c
+PASS: gcc flo_flo.c flo_flo_ext.c flo_flo_loop.c
PASS: ./lus2lic {-o /tmp/cond01.lic should_work/cond01.lus}
PASS: ./lus2lic {-ec -o /tmp/cond01.ec should_work/cond01.lus}
PASS: ./myec2c {-o /tmp/cond01.c /tmp/cond01.ec}
@@ -1292,31 +1292,31 @@ PASS: ./lus2lic {-ec -o /tmp/test_boolred.ec should_work/test_boolred.lus}
PASS: ./myec2c {-o /tmp/test_boolred.c /tmp/test_boolred.ec}
PASS: ../utils/test_lus2lic_no_node should_work/test_boolred.lus
PASS: ./lus2lic {-2c should_work/test_boolred.lus -n test_boolred}
-PASS: gcc test_boolred_test_boolred.c test_boolred_test_boolred_loop.c
+PASS: gcc test_boolred_test_boolred.c test_boolred_test_boolred_ext.c test_boolred_test_boolred_loop.c
PASS: ./lus2lic {-o /tmp/shiftFill_ludic.lic should_work/shiftFill_ludic.lus}
PASS: ./lus2lic {-ec -o /tmp/shiftFill_ludic.ec should_work/shiftFill_ludic.lus}
PASS: ./myec2c {-o /tmp/shiftFill_ludic.c /tmp/shiftFill_ludic.ec}
PASS: ../utils/test_lus2lic_no_node should_work/shiftFill_ludic.lus
PASS: ./lus2lic {-2c should_work/shiftFill_ludic.lus -n shiftFill_ludic}
-PASS: gcc shiftFill_ludic_shiftFill_ludic.c shiftFill_ludic_shiftFill_ludic_loop.c
+PASS: gcc shiftFill_ludic_shiftFill_ludic.c shiftFill_ludic_shiftFill_ludic_ext.c shiftFill_ludic_shiftFill_ludic_loop.c
PASS: ./lus2lic {-o /tmp/after.lic should_work/after.lus}
PASS: ./lus2lic {-ec -o /tmp/after.ec should_work/after.lus}
PASS: ./myec2c {-o /tmp/after.c /tmp/after.ec}
PASS: ../utils/test_lus2lic_no_node should_work/after.lus
PASS: ./lus2lic {-2c should_work/after.lus -n after}
-PASS: gcc after_after.c after_after_loop.c
+PASS: gcc after_after.c after_after_ext.c after_after_loop.c
PASS: ./lus2lic {-o /tmp/arrays.lic should_work/arrays.lus}
PASS: ./lus2lic {-ec -o /tmp/arrays.ec should_work/arrays.lus}
PASS: ./myec2c {-o /tmp/arrays.c /tmp/arrays.ec}
PASS: ../utils/test_lus2lic_no_node should_work/arrays.lus
PASS: ./lus2lic {-2c should_work/arrays.lus -n arrays}
-PASS: gcc arrays_arrays.c arrays_arrays_loop.c
+PASS: gcc arrays_arrays.c arrays_arrays_ext.c arrays_arrays_loop.c
PASS: ./lus2lic {-o /tmp/nc3.lic should_work/nc3.lus}
PASS: ./lus2lic {-ec -o /tmp/nc3.ec should_work/nc3.lus}
PASS: ./myec2c {-o /tmp/nc3.c /tmp/nc3.ec}
PASS: ../utils/test_lus2lic_no_node should_work/nc3.lus
PASS: ./lus2lic {-2c should_work/nc3.lus -n nc3}
-PASS: gcc nc3_nc3.c nc3_nc3_loop.c
+PASS: gcc nc3_nc3.c nc3_nc3_ext.c nc3_nc3_loop.c
PASS: ./lus2lic {-o /tmp/speedcontrol.lic should_work/speedcontrol.lus}
PASS: ./lus2lic {-ec -o /tmp/speedcontrol.ec should_work/speedcontrol.lus}
PASS: ./myec2c {-o /tmp/speedcontrol.c /tmp/speedcontrol.ec}
@@ -1327,25 +1327,25 @@ PASS: ./lus2lic {-ec -o /tmp/iterate.ec should_work/iterate.lus}
PASS: ./myec2c {-o /tmp/iterate.c /tmp/iterate.ec}
PASS: ../utils/test_lus2lic_no_node should_work/iterate.lus
PASS: ./lus2lic {-2c should_work/iterate.lus -n iterate}
-PASS: gcc iterate_iterate.c iterate_iterate_loop.c
+PASS: gcc iterate_iterate.c iterate_iterate_ext.c iterate_iterate_loop.c
PASS: ./lus2lic {-o /tmp/PCOND.lic should_work/PCOND.lus}
PASS: ./lus2lic {-ec -o /tmp/PCOND.ec should_work/PCOND.lus}
PASS: ./myec2c {-o /tmp/PCOND.c /tmp/PCOND.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/PCOND.lus
PASS: ./lus2lic {-2c should_work/PCOND.lus -n PCOND}
-PASS: gcc PCOND_PCOND.c PCOND_PCOND_loop.c
+PASS: gcc PCOND_PCOND.c PCOND_PCOND_ext.c PCOND_PCOND_loop.c
PASS: ./lus2lic {-o /tmp/EDGE.lic should_work/EDGE.lus}
PASS: ./lus2lic {-ec -o /tmp/EDGE.ec should_work/EDGE.lus}
PASS: ./myec2c {-o /tmp/EDGE.c /tmp/EDGE.ec}
PASS: ../utils/test_lus2lic_no_node should_work/EDGE.lus
PASS: ./lus2lic {-2c should_work/EDGE.lus -n EDGE}
-PASS: gcc EDGE_EDGE.c EDGE_EDGE_loop.c
+PASS: gcc EDGE_EDGE.c EDGE_EDGE_ext.c EDGE_EDGE_loop.c
PASS: ./lus2lic {-o /tmp/call03.lic should_work/call03.lus}
PASS: ./lus2lic {-ec -o /tmp/call03.ec should_work/call03.lus}
PASS: ./myec2c {-o /tmp/call03.c /tmp/call03.ec}
PASS: ../utils/test_lus2lic_no_node should_work/call03.lus
PASS: ./lus2lic {-2c should_work/call03.lus -n call03}
-PASS: gcc call03_call03.c call03_call03_loop.c
+PASS: gcc call03_call03.c call03_call03_ext.c call03_call03_loop.c
PASS: ./lus2lic {-o /tmp/modes3x2-simu.lic should_work/modes3x2-simu.lus}
PASS: ./lus2lic {-ec -o /tmp/modes3x2-simu.ec should_work/modes3x2-simu.lus}
FAIL: Try ec2c on the result: ./myec2c {-o /tmp/modes3x2-simu.c /tmp/modes3x2-simu.ec}
@@ -1354,19 +1354,19 @@ PASS: ./lus2lic {-ec -o /tmp/count.ec should_work/count.lus}
PASS: ./myec2c {-o /tmp/count.c /tmp/count.ec}
PASS: ../utils/test_lus2lic_no_node should_work/count.lus
PASS: ./lus2lic {-2c should_work/count.lus -n count}
-PASS: gcc count_count.c count_count_loop.c
+PASS: gcc count_count.c count_count_ext.c count_count_loop.c
PASS: ./lus2lic {-o /tmp/ck2.lic should_work/ck2.lus}
PASS: ./lus2lic {-ec -o /tmp/ck2.ec should_work/ck2.lus}
PASS: ./myec2c {-o /tmp/ck2.c /tmp/ck2.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/ck2.lus
PASS: ./lus2lic {-2c should_work/ck2.lus -n ck2}
-PASS: gcc ck2_ck2.c ck2_ck2_loop.c
+PASS: gcc ck2_ck2.c ck2_ck2_ext.c ck2_ck2_loop.c
PASS: ./lus2lic {-o /tmp/X.lic should_work/X.lus}
PASS: ./lus2lic {-ec -o /tmp/X.ec should_work/X.lus}
PASS: ./myec2c {-o /tmp/X.c /tmp/X.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/X.lus
PASS: ./lus2lic {-2c should_work/X.lus -n X}
-PASS: gcc X_X.c X_X_loop.c
+PASS: gcc X_X.c X_X_ext.c X_X_loop.c
PASS: ./lus2lic {-o /tmp/Condact.lic should_work/Condact.lus}
PASS: ./lus2lic {-ec -o /tmp/Condact.ec should_work/Condact.lus}
PASS: ./myec2c {-o /tmp/Condact.c /tmp/Condact.ec}
@@ -1377,61 +1377,61 @@ PASS: ./lus2lic {-ec -o /tmp/poussoir.ec should_work/poussoir.lus}
PASS: ./myec2c {-o /tmp/poussoir.c /tmp/poussoir.ec}
PASS: ../utils/test_lus2lic_no_node should_work/poussoir.lus
PASS: ./lus2lic {-2c should_work/poussoir.lus -n poussoir}
-PASS: gcc poussoir_poussoir.c poussoir_poussoir_loop.c
+PASS: gcc poussoir_poussoir.c poussoir_poussoir_ext.c poussoir_poussoir_loop.c
PASS: ./lus2lic {-o /tmp/SWITCH1.lic should_work/SWITCH1.lus}
PASS: ./lus2lic {-ec -o /tmp/SWITCH1.ec should_work/SWITCH1.lus}
PASS: ./myec2c {-o /tmp/SWITCH1.c /tmp/SWITCH1.ec}
PASS: ../utils/test_lus2lic_no_node should_work/SWITCH1.lus
PASS: ./lus2lic {-2c should_work/SWITCH1.lus -n SWITCH1}
-PASS: gcc SWITCH1_SWITCH1.c SWITCH1_SWITCH1_loop.c
+PASS: gcc SWITCH1_SWITCH1.c SWITCH1_SWITCH1_ext.c SWITCH1_SWITCH1_loop.c
PASS: ./lus2lic {-o /tmp/clock1_2ms.lic should_work/clock1_2ms.lus}
PASS: ./lus2lic {-ec -o /tmp/clock1_2ms.ec should_work/clock1_2ms.lus}
PASS: ./myec2c {-o /tmp/clock1_2ms.c /tmp/clock1_2ms.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/clock1_2ms.lus
PASS: ./lus2lic {-2c should_work/clock1_2ms.lus -n clock1_2ms}
-PASS: gcc clock1_2ms_clock1_2ms.c clock1_2ms_clock1_2ms_loop.c
+PASS: gcc clock1_2ms_clock1_2ms.c clock1_2ms_clock1_2ms_ext.c clock1_2ms_clock1_2ms_loop.c
PASS: ./lus2lic {-o /tmp/decl.lic should_work/decl.lus}
PASS: ./lus2lic {-ec -o /tmp/decl.ec should_work/decl.lus}
PASS: ./myec2c {-o /tmp/decl.c /tmp/decl.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/decl.lus
PASS: ./lus2lic {-2c should_work/decl.lus -n decl}
-FAIL: Check that the generated C code compiles : gcc decl_decl.c decl_decl_loop.c
+FAIL: Check that the generated C code compiles : gcc decl_decl.c decl_decl_ext.c decl_decl_loop.c
PASS: ./lus2lic {-o /tmp/bred_lv4.lic should_work/bred_lv4.lus}
PASS: ./lus2lic {-ec -o /tmp/bred_lv4.ec should_work/bred_lv4.lus}
PASS: ./myec2c {-o /tmp/bred_lv4.c /tmp/bred_lv4.ec}
PASS: ../utils/test_lus2lic_no_node should_work/bred_lv4.lus
PASS: ./lus2lic {-2c should_work/bred_lv4.lus -n bred_lv4}
-PASS: gcc bred_lv4_bred_lv4.c bred_lv4_bred_lv4_loop.c
+PASS: gcc bred_lv4_bred_lv4.c bred_lv4_bred_lv4_ext.c bred_lv4_bred_lv4_loop.c
PASS: ./lus2lic {-o /tmp/trivial2.lic should_work/trivial2.lus}
PASS: ./lus2lic {-ec -o /tmp/trivial2.ec should_work/trivial2.lus}
PASS: ./myec2c {-o /tmp/trivial2.c /tmp/trivial2.ec}
PASS: ../utils/test_lus2lic_no_node should_work/trivial2.lus
PASS: ./lus2lic {-2c should_work/trivial2.lus -n trivial2}
-PASS: gcc trivial2_trivial2.c trivial2_trivial2_loop.c
+PASS: gcc trivial2_trivial2.c trivial2_trivial2_ext.c trivial2_trivial2_loop.c
PASS: ./lus2lic {-o /tmp/param_node.lic should_work/param_node.lus}
PASS: ./lus2lic {-ec -o /tmp/param_node.ec should_work/param_node.lus}
PASS: ./myec2c {-o /tmp/param_node.c /tmp/param_node.ec}
PASS: ../utils/test_lus2lic_no_node should_work/param_node.lus
PASS: ./lus2lic {-2c should_work/param_node.lus -n param_node}
-PASS: gcc param_node_param_node.c param_node_param_node_loop.c
+PASS: gcc param_node_param_node.c param_node_param_node_ext.c param_node_param_node_loop.c
PASS: ./lus2lic {-o /tmp/simple.lic should_work/simple.lus}
PASS: ./lus2lic {-ec -o /tmp/simple.ec should_work/simple.lus}
PASS: ./myec2c {-o /tmp/simple.c /tmp/simple.ec}
FAIL: Try to compare lus2lic -exec and ecexe: ../utils/test_lus2lic_no_node should_work/simple.lus
PASS: ./lus2lic {-2c should_work/simple.lus -n simple}
-FAIL: Check that the generated C code compiles : gcc simple_simple.c simple_simple_loop.c
+FAIL: Check that the generated C code compiles : gcc simple_simple.c simple_simple_ext.c simple_simple_loop.c
PASS: ./lus2lic {-o /tmp/func_with_body.lic should_work/func_with_body.lus}
PASS: ./lus2lic {-ec -o /tmp/func_with_body.ec should_work/func_with_body.lus}
PASS: ./myec2c {-o /tmp/func_with_body.c /tmp/func_with_body.ec}
PASS: ../utils/test_lus2lic_no_node should_work/func_with_body.lus
PASS: ./lus2lic {-2c should_work/func_with_body.lus -n func_with_body}
-PASS: gcc func_with_body_func_with_body.c func_with_body_func_with_body_loop.c
+PASS: gcc func_with_body_func_with_body.c func_with_body_func_with_body_ext.c func_with_body_func_with_body_loop.c
PASS: ./lus2lic {-o /tmp/minus.lic should_work/minus.lus}
PASS: ./lus2lic {-ec -o /tmp/minus.ec should_work/minus.lus}
PASS: ./myec2c {-o /tmp/minus.c /tmp/minus.ec}
PASS: ../utils/test_lus2lic_no_node should_work/minus.lus
PASS: ./lus2lic {-2c should_work/minus.lus -n minus}
-PASS: gcc minus_minus.c minus_minus_loop.c
+PASS: gcc minus_minus.c minus_minus_ext.c minus_minus_loop.c
PASS: ./lus2lic {-o /tmp/remplissage-1.0.lic should_work/remplissage-1.0.lus}
PASS: ./lus2lic {-ec -o /tmp/remplissage-1.0.ec should_work/remplissage-1.0.lus}
PASS: ./myec2c {-o /tmp/remplissage-1.0.c /tmp/remplissage-1.0.ec}
@@ -1507,9 +1507,9 @@ XPASS: Test bad programs (semantics): lus2lic {-o /tmp/bug.lic should_fail/seman
=== lus2lic Summary ===
-# of expected passes 1327
-# of unexpected failures 110
+# of expected passes 1336
+# of unexpected failures 101
# of unexpected successes 21
# of expected failures 37
-testcase ./lus2lic.tests/non-reg.exp completed in 140 seconds
+testcase ./lus2lic.tests/non-reg.exp completed in 131 seconds
testcase ./lus2lic.tests/progression.exp completed in 0 seconds
diff --git a/test/lus2lic.tests/non-reg.exp b/test/lus2lic.tests/non-reg.exp
index 12eac416913fb2bf65d025122d3d4de5831b6777..50f03ca3793a64e32d8c065b4f6d41b8a5311cd2 100644
--- a/test/lus2lic.tests/non-reg.exp
+++ b/test/lus2lic.tests/non-reg.exp
@@ -32,7 +32,11 @@ foreach f $ok_files {
wait -i $id5
if { [emptyfile "${basef}_${basef}.c"] } {
- set id6 [should_work "Check that the generated C code compiles " "gcc ${basef}_${basef}.c ${basef}_${basef}_loop.c"]
+ if { [emptyfile "${basef}_${basef}_ext.c"] } {
+ set id6 [should_work "Check that the generated C code compiles " "gcc ${basef}_${basef}.c ${basef}_${basef}_ext.c ${basef}_${basef}_loop.c"]
+ } else {
+ set id6 [should_work "Check that the generated C code compiles " "gcc ${basef}_${basef}.c ${basef}_${basef}_loop.c"]
+ }
wait -i $id6
catch { exp_close -i $id6 }
catch { exp_wait -i $id6 } output
diff --git a/test/lus2lic.time b/test/lus2lic.time
index 60e57f011cedceeeee6776586af482f94caa69bf..c9657f639cce96aa6204a8c91cdd1c199e3969ac 100644
--- a/test/lus2lic.time
+++ b/test/lus2lic.time
@@ -1,2 +1,2 @@
-testcase ./lus2lic.tests/non-reg.exp completed in 140 seconds
+testcase ./lus2lic.tests/non-reg.exp completed in 131 seconds
testcase ./lus2lic.tests/progression.exp completed in 0 seconds