diff --git a/src/Makefile b/src/Makefile
index 4577bb2d60fff13ec6b9577e71c7be8c530291c7..335f52b8b166317435c7fabe293ed5c111f93f26 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -60,6 +60,8 @@ SOURCES = \
./split.ml \
./nodesExpand.mli \
./nodesExpand.ml \
+ ./structExpand.mli \
+ ./structExpand.ml \
./inline.mli \
./inline.ml \
./lazyCompiler.ml \
diff --git a/src/eff.ml b/src/eff.ml
index c98d9dd6e947affcb5e6b830102fc531e0f155a4..7abb869ffff8e0f66814a372e127959b418d7d96 100644
--- a/src/eff.ml
+++ b/src/eff.ml
@@ -1,4 +1,4 @@
-(** Time-stamp: <modified the 22/01/2009 (at 11:23) by Erwan Jahier> *)
+(** Time-stamp: <modified the 28/01/2009 (at 10:33) by Erwan Jahier> *)
(**
@@ -190,7 +190,7 @@ and by_pos_op =
| CONCAT
| HAT of int * val_exp
| ARRAY of val_exp list
- | STRUCT_ACCESS of Ident.t
+ | STRUCT_ACCESS of Ident.t * type_
(* those are different from [by_pos_op] *)
diff --git a/src/evalClock.mli b/src/evalClock.mli
index 93b7412e7f247b4b3a55a05b891ca8d155ff5409..1df6de805132518a4e5023b8ec8559f6096ed07a 100644
--- a/src/evalClock.mli
+++ b/src/evalClock.mli
@@ -1,4 +1,4 @@
-(** Time-stamp: <modified the 11/09/2008 (at 16:16) by Erwan Jahier> *)
+(** Time-stamp: <modified the 28/01/2009 (at 14:43) by Erwan Jahier> *)
open UnifyClock
@@ -30,3 +30,4 @@ val check_res : Lxm.t -> subst -> Eff.left list -> Eff.id_clock list -> unit
an internal table, and therefore it should not be called before
the clock checking has been done (by the function f above).*)
val get_val_exp_eff : Eff.val_exp -> Eff.id_clock list
+(* XXX should be named "lookup_val_eff_clock" *)
diff --git a/src/evalType.ml b/src/evalType.ml
index ef7253f23439d24d914d521508b08c9fe21e398d..713aff97cfad95a49837cf094973e597a52ab030 100644
--- a/src/evalType.ml
+++ b/src/evalType.ml
@@ -1,4 +1,4 @@
-(** Time-stamp: <modified the 11/12/2008 (at 11:50) by Erwan Jahier> *)
+(** Time-stamp: <modified the 28/01/2009 (at 10:54) by Erwan Jahier> *)
open Predef
@@ -115,21 +115,8 @@ and (eval_by_pos_type :
raise(EvalType_error(sprintf "arity error: 2 expected instead of %d"
(List.length args)))
)
- | Eff.STRUCT_ACCESS fid -> (
- let type_args_eff = List.flatten (List.map (f id_solver) args) in
- match type_args_eff with
- | [Struct_type_eff (name, fl)] -> (
- try [fst (List.assoc fid fl)]
- with Not_found ->
- raise (EvalType_error
- (Printf.sprintf "%s is not a field of struct %s"
- (Ident.to_string fid)
- (LicDump.string_of_type_eff4msg(List.hd type_args_eff))))
- )
- | [x] -> type_error [x] "struct type"
- | x -> arity_error x "1"
- )
- | Eff.ARRAY_ACCES (_, teff) -> [teff] (* XXX check args type! *)
+ | Eff.STRUCT_ACCESS (fid,teff) -> [teff]
+ | Eff.ARRAY_ACCES (_, teff) -> [teff]
| Eff.ARRAY_SLICE (sieff,teff) ->
[Array_type_eff(teff, sieff.se_width)]
diff --git a/src/evalType.mli b/src/evalType.mli
index 0b46196d7377a3a5d874afd2a7ad64abfd05470d..1572bf119fa65500ac3f94a95d544fb86235891f 100644
--- a/src/evalType.mli
+++ b/src/evalType.mli
@@ -1,4 +1,4 @@
-(** Time-stamp: <modified the 28/08/2008 (at 15:31) by Erwan Jahier> *)
+(** Time-stamp: <modified the 28/01/2009 (at 10:25) by Erwan Jahier> *)
(** Evaluates the type of an expression. *)
@@ -9,3 +9,4 @@ val f : Eff.id_solver -> Eff.val_exp -> Eff.type_ list
an internal table, and therefore it should not be called before
the type checking has been done (by the function f above).*)
val val_exp_eff : Eff.val_exp -> Eff.type_ list
+(* XXX should be named "lookup_val_eff_type" *)
diff --git a/src/getEff.ml b/src/getEff.ml
index 4ace0e717c13acf095701740d6b3c96bda3b80dd..a6604cd7d4fc19a85208dfe5beddf5bfb6dd3c07 100644
--- a/src/getEff.ml
+++ b/src/getEff.ml
@@ -1,4 +1,4 @@
-(** Time-stamp: <modified the 10/12/2008 (at 16:18) by Erwan Jahier> *)
+(** Time-stamp: <modified the 28/01/2009 (at 10:56) by Erwan Jahier> *)
open Lxm
@@ -71,7 +71,12 @@ and (type_check_equation: Eff.id_solver -> Lxm.t -> Eff.left list ->
(string_of_int (List.length lpl_teff)) ^
" for the left-hand-side, and \n***\t" ^
(string_of_int (List.length right_part)) ^
- " for the right-hand-side"))
+ " for the right-hand-side (in " ^
+ (String.concat ","
+ (List.map LicDump.string_of_leff lpl_eff)) ^ " = " ^
+ (LicDump.string_of_val_exp_eff ve_eff) ^
+ ")\n"
+ ))
else
List.iter2
(fun le re ->
@@ -420,7 +425,26 @@ and (translate_val_exp : Eff.id_solver -> SyntaxTreeCore.val_exp -> Eff.val_exp)
mk_by_pos_op (Eff.WITH (translate_val_exp id_solver e1))
else
mk_by_pos_op (Eff.WITH (translate_val_exp id_solver e2))
- | STRUCT_ACCESS_n id -> mk_by_pos_op (Eff.STRUCT_ACCESS id)
+ | STRUCT_ACCESS_n fid ->
+ let teff =
+ assert (List.length vel = 1);
+ EvalType.f id_solver (translate_val_exp id_solver (List.hd vel))
+ in
+ let teff_field =
+ match teff with
+ | [Struct_type_eff (name, fl)] -> (
+ try fst (List.assoc fid fl)
+ with Not_found ->
+ raise (
+ PredefEvalType.EvalType_error
+ (Printf.sprintf "%s is not a field of struct %s"
+ (Ident.to_string fid)
+ (LicDump.string_of_type_eff4msg (List.hd teff))))
+ )
+ | [x] -> PredefEvalType.type_error [x] "struct type"
+ | x -> PredefEvalType.arity_error x "1"
+ in
+ mk_by_pos_op (Eff.STRUCT_ACCESS (fid,teff_field))
| WHEN_n Base -> mk_by_pos_op (Eff.WHEN Base)
| WHEN_n (NamedClock { it = (cc,cv) ; src = lxm }) ->
diff --git a/src/global.ml b/src/global.ml
index 38e23be6ab2ffcd071d5078a0d5b1c49b7ad07db..68c3c0dd3b44f9720c1b0c81c8028bdbc287986a 100644
--- a/src/global.ml
+++ b/src/global.ml
@@ -10,7 +10,7 @@ let (outfile:string ref) = ref ""
let (infiles:string list ref) = ref []
let current_file = ref ""
let main_node = ref ""
-let compile_all_items = ref false
+let compile_all_items = ref true
let run_unit_test = ref false
let one_op_per_equation = ref true
let inline_iterator = ref false
diff --git a/src/ident.ml b/src/ident.ml
index 7a72d5e47805f3de39ead0a8b5899ca4a740966a..35bbc958f5a9cbe80885e0f730f01c2089af4ff6 100644
--- a/src/ident.ml
+++ b/src/ident.ml
@@ -1,4 +1,4 @@
-(** Time-stamp: <modified the 26/11/2008 (at 11:18) by Erwan Jahier> *)
+(** Time-stamp: <modified the 27/01/2009 (at 16:57) by Erwan Jahier> *)
(* J'ai appele ca symbol (mais ca remplace le ident) :
c'est juste une couche qui garantit l'unicite en memoire
@@ -119,6 +119,10 @@ let string_of_idref i = (
| None -> i.id_id
)
+let (wrap_idref : idref -> string -> string -> idref) =
+ fun { id_pack = p ; id_id = id } pref suff ->
+ { id_pack = p ; id_id = of_string (pref ^ (to_string id)^suff) }
+
let (of_idref : idref -> t) =
fun idref ->
of_string (string_of_idref idref)
diff --git a/src/ident.mli b/src/ident.mli
index 7d8eeb6a9ac5f615488d2e5369d3e49981d751f6..a12499f20f93c80306fa27f9bb02500e1b86c836 100644
--- a/src/ident.mli
+++ b/src/ident.mli
@@ -1,4 +1,4 @@
-(** Time-stamp: <modified the 24/11/2008 (at 17:10) by Erwan Jahier> *)
+(** Time-stamp: <modified the 27/01/2009 (at 16:57) by Erwan Jahier> *)
type t
@@ -61,3 +61,4 @@ type clk = idref * t
e.g., NamedClock("C",v), or NamedClock("True", clk) *)
val string_of_clk : clk -> string
+val wrap_idref : idref -> string -> string -> idref
diff --git a/src/lazyCompiler.ml b/src/lazyCompiler.ml
index 83417b88903feb01f84f3fae93b7fe1d945e86c2..6b6719760146f3f2a151b4ad36a5f2170be4e926 100644
--- a/src/lazyCompiler.ml
+++ b/src/lazyCompiler.ml
@@ -1,4 +1,4 @@
-(** Time-stamp: <modified the 23/01/2009 (at 09:27) by Erwan Jahier> *)
+(** Time-stamp: <modified the 29/01/2009 (at 11:04) by Erwan Jahier> *)
open Lxm
@@ -407,7 +407,8 @@ and (type_check_do: t -> Ident.long -> Lxm.t -> SymbolTab.t -> bool ->
Struct_type_eff (n, eff_fields)
)
in
- if not provide_flag then
+ let is_struct = match type_def.it with StructType _ -> true | _ -> false in
+ if (not provide_flag) & (not (!Global.expand_structs & is_struct)) then
output_string !Global.oc (LicDump.type_decl type_name type_eff);
type_eff
)
@@ -826,16 +827,30 @@ and (node_check_do: t -> Eff.node_key -> Lxm.t -> SymbolTab.t ->
then Inline.iterators local_env node_id_solver res
else res
in
- UniqueOutput.check res node_def.src;
+ let res_struct =
+ if !Global.expand_structs then
+ let new_res = StructExpand.node local_env node_id_solver res in
+ UniqueOutput.check res node_def.src;
+ UniqueOutput.check new_res node_def.src; (* is it useful to check both?*)
+ new_res
+ else (
+ UniqueOutput.check res node_def.src;
+ res
+ )
+ in
if not provide_flag then
(
if res.is_polym_eff then
- LicDump.push_on_polymorphic_node_stack res
+ LicDump.push_on_polymorphic_node_stack res_struct
else
- let str = LicDump.node_of_node_exp_eff res in
+ let str = LicDump.node_of_node_exp_eff res_struct in
if not !Global.expand_nodes || is_main_node then
output_string !Global.oc str
);
+ (* nb: we print res_struct, but we return res, because the structure and
+ array expansion modify the node profiles.
+
+ *)
res
diff --git a/src/licDump.ml b/src/licDump.ml
index 9c23811a2c0c0a503e3a18ae068ccedb76f22317..281fee337b043675d009cd2e7db5b102785f3c73 100644
--- a/src/licDump.ml
+++ b/src/licDump.ml
@@ -1,4 +1,4 @@
-(** Time-stamp: <modified the 11/12/2008 (at 15:30) by Erwan Jahier> *)
+(** Time-stamp: <modified the 28/01/2009 (at 10:43) by Erwan Jahier> *)
open Printf
open Lxm
@@ -28,6 +28,12 @@ let (get_rank : 'a -> 'a list -> int) =
aux 1 l
let _ = assert (get_rank 5 [1;3;5] = 3)
+
+let (is_a_tuple : Eff.val_exp -> bool) =
+ function
+ | CallByPosEff ({ it = TUPLE }, _) -> true
+ | _ -> false
+
(******************************************************************************)
(* prefix used to prefix user type name in order to avoid name clashed with
the alias type name that are generated by the compiler. *)
@@ -50,7 +56,7 @@ let rec string_of_const_eff =
| Struct_const_eff (fl, t) -> (
let string_of_field =
function (id, veff) ->
- (Ident.to_string id)^" = "^(string_of_const_eff veff)
+ (Ident.to_string id)^" = "^ (string_of_const_eff veff)
in
let flst = List.map string_of_field fl in
(string_of_type_eff t)^"{"^(String.concat "; " flst)^"}"
@@ -265,19 +271,19 @@ and (string_of_by_pos_op_eff: Eff.by_pos_op srcflagged -> Eff.val_exp list -> st
" else " ^ (string_of_val_exp_eff ve3)
| Predef(op,sargs), vel ->
- if Predef.is_infix op then (
- match vel with
- | [ve1; ve2] ->
- (string_of_val_exp_eff ve1) ^ " " ^ (op2string op) ^
- " " ^ (string_of_val_exp_eff ve2)
- | _ -> assert false
- )
- else
- ((op2string op) ^
- (if sargs = [] then
- match op with
- | Predef.ICONST_n _ | Predef.RCONST_n _ | Predef.NOT_n
- | Predef.UMINUS_n | Predef.IUMINUS_n | Predef.RUMINUS_n
+ if Predef.is_infix op then (
+ match vel with
+ | [ve1; ve2] ->
+ (string_of_val_exp_eff ve1) ^ " " ^ (op2string op) ^
+ " " ^ (string_of_val_exp_eff ve2)
+ | _ -> assert false
+ )
+ else
+ ((op2string op) ^
+ (if sargs = [] then
+ match op with
+ | Predef.ICONST_n _ | Predef.RCONST_n _ | Predef.NOT_n
+ | Predef.UMINUS_n | Predef.IUMINUS_n | Predef.RUMINUS_n
| Predef.FALSE_n | Predef.TRUE_n -> tuple vel
| _ -> tuple_par vel
else
@@ -315,7 +321,7 @@ and (string_of_by_pos_op_eff: Eff.by_pos_op srcflagged -> Eff.val_exp list -> st
(string_of_val_exp_eff ve1) ^ " | " ^ (string_of_val_exp_eff ve2)
| HAT (i, ve), _ -> (string_of_val_exp_eff ve) ^ "^" ^ (string_of_int i)
| ARRAY vel, _ -> tuple_square vel
- | STRUCT_ACCESS(id), [ve1] ->
+ | STRUCT_ACCESS(id,_), [ve1] ->
(string_of_val_exp_eff ve1) ^ "." ^ (Ident.to_string id)
| ARRAY_ACCES(i, type_eff), [ve1] ->
@@ -360,6 +366,7 @@ and (string_of_by_pos_op_eff: Eff.by_pos_op srcflagged -> Eff.val_exp list -> st
else
("(" ^ str ^ ")")
+
and string_of_val_exp_eff = function
| CallByPosEff (by_pos_op_eff, OperEff vel) ->
(string_of_by_pos_op_eff by_pos_op_eff vel)
@@ -377,7 +384,9 @@ and string_of_val_exp_eff = function
"{" ^ (String.concat ";"
(List.map
(fun (id,veff) ->
- (Ident.to_string id.it) ^ "=" ^ (string_of_val_exp_eff veff)
+ let str = string_of_val_exp_eff veff in
+ (Ident.to_string id.it) ^ "=" ^
+ (if is_a_tuple veff then ("("^ str^")") else str)
)
fl)) ^
"}"
@@ -402,9 +411,12 @@ and wrap_long_line str =
in
new_str ^ " " ^ reste
+
and string_of_eq_info_eff (leff_list, vee) =
- wrap_long_line (
- (string_of_leff_list leff_list) ^ " = " ^ (string_of_val_exp_eff vee) ^ ";")
+ let str = string_of_val_exp_eff vee in
+ wrap_long_line (
+ (string_of_leff_list leff_list) ^ " = " ^
+ (if is_a_tuple vee then ("("^ str^")") else str) ^ ";")
and (string_of_assert : Eff.val_exp srcflagged -> string ) =
fun eq_eff ->
diff --git a/src/licDump.mli b/src/licDump.mli
index fe765faffe450f219fabc6eadf43cfa5d5e10c4d..39ccd9ff4ddf341c35ca19e13f301960901349b2 100644
--- a/src/licDump.mli
+++ b/src/licDump.mli
@@ -5,6 +5,7 @@ val string_of_node_key_rec : Eff.node_key -> string
val node_of_node_exp_eff: Eff.node_exp -> string
val string_of_const_eff : Eff.const -> string
+val string_of_leff : Eff.left -> string
val string_of_type_eff : Eff.type_ -> string
val string_of_type_eff4msg : Eff.type_ -> string
diff --git a/src/main.ml b/src/main.ml
index dffdd8a1309c4f449064c1efb5a3b861029cea6f..419e91cbf4dd553287dc0d40269059378867d720 100644
--- a/src/main.ml
+++ b/src/main.ml
@@ -1,4 +1,4 @@
-(** Time-stamp: <modified the 22/01/2009 (at 12:27) by Erwan Jahier> *)
+(** Time-stamp: <modified the 27/01/2009 (at 16:00) by Erwan Jahier> *)
(** Here follows a description of the different modules used by this lus2lic compiler.
@@ -58,83 +58,117 @@ let print_version = function (x: unit) -> (
)
let usage_msg =
- "usage: "^(Version.tool)^" [options] <lustre files> | "^(Version.tool)^" -help"
+ "usage: "^(Version.tool)^" [options] <lustre files>\nwhere [options] can be:"
let rec arg_list = [
- ( "--version", Arg.Unit(fun x -> print_version () ; exit 0),
- "\tPrint the current version then exit"
- );
- ( "--output-file", Arg.String(fun x -> Global.outfile := x), "<file>"
- );
- ( "-o", Arg.String(fun x -> Global.outfile := x),
- "<file>\tSet the output file name"
- );
- ( "--node", Arg.String(fun x -> Global.main_node := x),
+ ( "--node", Arg.String(fun x -> Global.main_node := x; Global.compile_all_items := false),
"<node>"
);
- ( "-n", Arg.String(fun x -> Global.main_node := x),
- "<node>\tSet the main node (all items are compiled if unset)"
- );
- ( "--compile-all-items", Arg.Unit
- (function x -> Global.compile_all_items := true),
- "\t"
+ ( "-n", Arg.String(fun x -> Global.main_node := x; Global.compile_all_items := false),
+ "<node>\n\t Set the main node (all items are compiled if unset)"
);
- ( "-all", Arg.Unit
- (function x -> Global.compile_all_items := true),
- "\t\tCompile all items of the program"
+
+ ( "--output-file", Arg.String(fun x -> Global.outfile := x), "<file>"
);
- ( "-unit", Arg.Unit (fun x -> Global.run_unit_test := true),
- "\tRun some (internal) unit tests"
+ ( "-o", Arg.String(fun x -> Global.outfile := x),
+ "<file>\n\t Set the output file name."
);
- ( "--verbose", Arg.Unit (fun vl -> Verbose.set_level 1 ),
+
+ ( "--keep-nested-calls", Arg.Unit (fun _ -> Global.one_op_per_equation := false),
""
);
- ( "-v", Arg.Unit (fun vl -> Verbose.set_level 1 ),
- "\t\tSet verbose mode on (i.e., verbose level = 1)"
+ ( "-knc", Arg.Unit (fun _ -> Global.one_op_per_equation := false),
+ "\n\t Keep nested calls. By default, only one node per equation is generated."
);
- ( "--verbose-level", Arg.Int(fun vl -> Verbose.set_level vl ), "<int>"
+
+ ( "--expand-iterators", Arg.Unit (fun _ -> Global.inline_iterator := true),
+ ""
);
- ( "-vl", Arg.Int(fun vl -> Verbose.set_level vl ),
- "<int>\tSet verbose level"
+ ( "-ei", Arg.Unit (fun _ -> Global.inline_iterator := true),
+ "\n\t Expand array iterators."
);
- ( "--keep-nested-calls", Arg.Unit (fun _ -> Global.one_op_per_equation := false),
- "\tKeep nested calls"
+ ( "--expand-enums", Arg.Unit (fun _ -> Global.expand_enums := true),
+ ""
+ );
+ ( "-ee", Arg.Unit (fun _ -> Global.expand_enums := true),
+ "\n\t Translate enums into integers."
);
- ( "--expand-iterators", Arg.Unit (fun _ -> Global.inline_iterator := true),
- "\texpand iterators"
+ ( "--expand-structs-and-arrays", Arg.Unit
+ (fun _ -> Global.expand_structs := true),
+ ""
);
- ( "--expand-enums", Arg.Unit (fun _ -> Global.expand_enums := true),
- "\tTranslate enums into integers"
+ ( "-esa", Arg.Unit
+ (fun _ -> Global.expand_structs := true),
+ "\n\t Expand structures and arrays using as many variables as necessary."
);
+
( "--expand-nodes", Arg.Unit (fun _ -> Global.expand_nodes := true),
- "\tExpand nodes (hence, only one node is generated)."
+ ""
+ );
+ ( "-en", Arg.Unit (fun _ -> Global.expand_nodes := true),
+ "\n\t Expand the main node (use the first node if no one is specified)."
);
-(* ( "--expand-structs", Arg.Unit *)
-(* (fun _ -> Global.expand_enums := true), *)
-(* "\tReplace structures by as many variables as necessary" *)
-(* ); *)
( "--lustre-v4", Arg.Unit
(fun _ -> set_v4_options ()),
- "\tGenerate Lustre V4 compatible Lustre (if possible)"
+ "\t"
);
+
( "-lv4", Arg.Unit
(fun _ -> set_v4_options ()),
- "\tGenerate Lustre V4 compatible Lustre (if possible)"
+ "\n\t Use Lustre V4 syntax (automatically impose '-ei -ee -esa')."
+ );
+
+ ( "--expanded-code", Arg.Unit
+ (fun _ -> set_ec_options ()),
+ ""
+ );
+ ( "-ec", Arg.Unit
+ (fun _ -> set_ec_options ()),
+ "\n\t Generate ec (actually just an alias for '-en -lv4')."
);
+ ( "-unit", Arg.Unit (fun x -> Global.run_unit_test := true),
+ "\n\t Run some (internal) unit tests"
+ );
+
+ ( "--verbose-level", Arg.Int(fun vl -> Verbose.set_level vl ), "<int>"
+ );
+ ( "-vl", Arg.Int(fun vl -> Verbose.set_level vl ),
+ "<int>\n\t Set the verbose level."
+ );
+
+ ( "--verbose", Arg.Unit (fun vl -> Verbose.set_level 1 ),
+ ""
+ );
+ ( "-v", Arg.Unit (fun vl -> Verbose.set_level 1 ),
+ "\n\t Set the verbose level to 1."
+ );
+
+ ( "--version", Arg.Unit(fun x -> print_version () ; exit 0),
+ ""
+ );
+ ( "-version", Arg.Unit(fun x -> print_version () ; exit 0),
+ "\n\t Display the current version of the tool."
+ );
+
+
("-h", Arg.Unit (fun _ -> (Arg.usage arg_list usage_msg; exit 0)), "" );
("-help", Arg.Unit (fun _ -> (Arg.usage arg_list usage_msg; exit 0)),"" );
("--help", Arg.Unit (fun _ -> (Arg.usage arg_list usage_msg; exit 0)),
- "\tDisplay this list of options" )
+ "\n\t Display this message." )
]
and set_v4_options () =
Global.lv4 := true;
Global.inline_iterator := true;
Global.expand_enums := true;
Global.expand_structs := true
+and set_ec_options () =
+ set_v4_options ();
+ Global.expand_nodes := true
+
and
parse_args () = (
Arg.parse arg_list (* liste des options *)
diff --git a/src/name.mli b/src/name.mli
index d3c776445aec99d95dd3ebebb977e3c89d70c26f..202a3642465500ad8f6ad25a346b36cdb9c51fb6 100644
--- a/src/name.mli
+++ b/src/name.mli
@@ -1,4 +1,4 @@
-(** Time-stamp: <modified the 09/12/2008 (at 11:03) by Erwan Jahier> *)
+(** Time-stamp: <modified the 26/01/2009 (at 14:28) by Erwan Jahier> *)
(** All new identifier names ougth to be created via this module.
@@ -23,7 +23,7 @@ val node_key: Eff.node_key -> string -> string
(** Dealing with fresh local (to the node) variable idents *)
(** Returns a fresh local var name *)
-val new_local_var : string -> string
+val new_local_var : string -> string (* mv new_var? *)
(** since those are local to the node, name can be re-used *)
val reset_local_var_prefix : string -> unit
diff --git a/src/nodesExpand.ml b/src/nodesExpand.ml
index 700b3511956ea39a18db35be4d0cfef10c6af143..e3cb0c0a095b2440d920e4752651a5251c4bd19c 100644
--- a/src/nodesExpand.ml
+++ b/src/nodesExpand.ml
@@ -1,4 +1,4 @@
-(** Time-stamp: <modified the 23/01/2009 (at 09:32) by Erwan Jahier> *)
+(** Time-stamp: <modified the 23/01/2009 (at 11:28) by Erwan Jahier> *)
(**
nb : only user nodes are expanded.
@@ -219,16 +219,16 @@ let (mk_output_subst : Eff.local_env -> Lxm.t -> var_info list -> Eff.left list
vl
leftl
-let rec (eq : Eff.local_env -> acc -> Eff.eq_info Lxm.srcflagged -> acc) =
+let rec (expand_eq : Eff.local_env -> acc -> Eff.eq_info Lxm.srcflagged -> acc) =
fun node_env (asserts, eqs, locs) { src = lxm_eq ; it = eq } ->
- match expand_node node_env eq with
+ match expand_eq_aux node_env eq with
| None -> asserts, { src = lxm_eq ; it = eq }::eqs, locs
| Some(nasserts, neqs, nlocs) ->
List.rev_append nasserts asserts,
List.rev_append neqs eqs,
List.rev_append nlocs locs
-and (expand_node: Eff.local_env -> Eff.eq_info -> acc option)=
+and (expand_eq_aux: Eff.local_env -> Eff.eq_info -> acc option)=
fun node_env (lhs,ve) ->
match ve with
| CallByPosEff( { it = Eff.CALL node ; src = lxm }, OperEff vel) ->
@@ -248,7 +248,7 @@ and (expand_node: Eff.local_env -> Eff.eq_info -> acc option)=
let node_eqs = List.map (substitute s) node_eqs in
let subst_assert x = Lxm.flagit (subst_in_val_exp s x.it) x.src in
let asserts = List.map subst_assert asserts in
- let acc = List.fold_left (eq node_env) acc node_eqs in
+ let acc = List.fold_left (expand_eq node_env) acc node_eqs in
let acc = List.fold_left (expand_assert node_env) acc asserts in
Some acc
)
@@ -266,7 +266,7 @@ and (expand_assert : Eff.local_env -> acc -> val_exp srcflagged -> acc) =
let assert_op = Eff.IDENT(Ident.to_idref assert_var.var_name_eff) in
let ve = Lxm.flagit (CallByPosEff((Lxm.flagit assert_op lxm, OperEff []))) lxm in
- eq n_env (ve::a_acc, e_acc, assert_var::v_acc) assert_eq
+ expand_eq n_env (ve::a_acc, e_acc, assert_var::v_acc) assert_eq
(* exported *)
@@ -277,7 +277,7 @@ let (f : Eff.local_env -> Eff.node_exp -> Eff.node_exp) =
| AbstractEff -> n
| BodyEff b ->
let locs = get_locals n in
- let acc = List.fold_left (eq n_env) ([],[],locs) b.eqs_eff in
+ let acc = List.fold_left (expand_eq n_env) ([],[],locs) b.eqs_eff in
let acc = List.fold_left (expand_assert n_env) acc b.asserts_eff in
let (asserts,neqs, nv) = acc in
let nb = {
diff --git a/src/structExpand.ml b/src/structExpand.ml
index 8f7e14b79085a13e1e8ef859eda7915cd89ea28b..b0e7b1f20d3c5258ce717a03b226ba10272bdacb 100644
--- a/src/structExpand.ml
+++ b/src/structExpand.ml
@@ -1,27 +1,448 @@
-(** Time-stamp: <modified the 05/12/2008 (at 15:38) by Erwan Jahier> *)
+(** Time-stamp: <modified the 29/01/2009 (at 16:56) by Erwan Jahier> *)
-(* Replace structures by as many variables as necessary *)
+(* Replace structures and arrays by as many variables as necessary.
+ Since structures can be recursive, it migth be a lot of new variables...
+
+ For instance, a variable
+ v : Toto { f1 : int ; f2 : int ^ 3 ; f3 : t^2 }
+ where
+ type t = T { x:int ; y:int }
+ will be expanded into
+ _v_f1 : int;
+ _v_f2_0 : int;
+ _v_f2_1 : int;
+ _v_f2_2 : int;
+ _v_f3_1_x : int;
+ _v_f3_1_y : int;
+ _v_f3_2_x : int;
+ _v_f3_3_y : int;
+ nb : if 't' was a type that does not contain any struct type, we would just
+ have 3 variables.
+ *)
+
+open Lxm
+open Eff
+open Predef
+
+type acc =
+ Eff.val_exp srcflagged list (* assertions *)
+ * (Eff.eq_info srcflagged) list (* equations *)
+ * Eff.var_info list (* new local vars *)
+
+
+(********************************************************************************)
+
+
+(* stuff to create fresh var names.
+ XXX code dupl. with Split.new_var
+*)
+let new_var str node_env type_eff clock_eff =
+ let id = Ident.of_string (Name.new_local_var str) in
+ let var =
+ {
+ var_name_eff = id;
+ var_nature_eff = SyntaxTreeCore.VarLocal;
+ var_number_eff = -1; (* this field is used only for i/o.
+ Should i rather put something sensible there ? *)
+ var_type_eff = type_eff;
+ var_clock_eff = clock_eff;
+ }
+ in
+ Hashtbl.add node_env.lenv_vars id var;
+ var
+
+(* returns a new var based on [vi] with type [type_eff]. *)
+let clone_var node_env vi str type_eff =
+ let str = (Ident.to_string vi.var_name_eff) ^ str in
+ let id = Ident.of_string (str) in
+ let var =
+ {
+ var_name_eff = id;
+ var_nature_eff = vi.var_nature_eff;
+ var_number_eff = vi.var_number_eff; (* this field is useless: to be removed. *)
+ var_type_eff = type_eff;
+ var_clock_eff = vi.var_clock_eff;
+ }
+ in
+(* Hashtbl.add node_env.lenv_vars id var; *)
+ var
+
+
+let rec (is_a_basic_type : Eff.type_ -> bool) =
+ function
+ | Array_type_eff _ | Struct_type_eff _ -> false
+ | _ -> true
+
+let soi = string_of_int
+
+
+(* [expand_var "toto" acc type]
+ adds in [acc] all the strings corresponding to the set of atomic variables
+ defined by "toto". For instance, if "toto" is of type "s^2" where s is a structure
+ with two integer fields f1 and f2, expand var returns :
+
+ ["toto_0_f1",int ; "toto_0_f2",int ;"toto_1_f1",int ; "toto_1_f2",int ] @ acc
+
+ This function is used to expand left val_exp expressions.
+
+*)
+let (expand_var : string -> Eff.type_ -> (string * Eff.type_) list) =
+ fun prefix teff ->
+ let rec aux prefix acc teff =
+ match teff with
+ | Any | Overload -> assert false (* should not occur *)
+ | Bool_type_eff
+ | Int_type_eff
+ | Real_type_eff
+ | External_type_eff _
+ | Enum_type_eff(_) -> (prefix,teff)::acc
+ | Array_type_eff(teff_elt,i) ->
+ let rec unfold acc cpt =
+ if cpt = i then acc else
+ let acc = aux (prefix^"_"^(soi cpt)) acc teff_elt in
+ unfold acc (cpt+1)
+ in
+ unfold acc 0
+ | Struct_type_eff(l, fl) ->
+ List.fold_left
+ (fun acc (fn, (teff_elt,opt)) ->
+ aux (prefix^"_"^(Ident.to_string fn)) acc teff_elt)
+ acc
+ fl
+ in
+ List.rev (aux prefix [] teff)
+
+
+
+let (index_list_of_slice_info : Eff.slice_info -> int list) =
+ fun si ->
+ let sign = if si.se_step > 0 then 1 else -1 in
+ let rec aux acc cpt =
+ if ((si.se_step > 0 & cpt > si.se_last) || (si.se_step < 0 & cpt < si.se_last))
+ then acc else aux (cpt::acc) (cpt + si.se_step)
+ in
+ List.rev (aux [] si.se_first)
+
+
+(** left expr expansion.
+
+ The objective is to generate the set of vars defined by a left expr.
+
+ First step: var_trees_of_left recursively traverse the left structure
+ to compute the left expr variable. E.g., in the left expr "X.f2[4]" we
+ want to find "X" (and its type).
+
+ Second step: Using the type of X, we compute the set of variables defined
+ by "X" (gen_var_trees). The set is actually structured into a tree-like
+ data struture var_tree (to be able to deal with slices).
+
+ Third step (var_trees_of_left again): cut off some branches of the tree using
+ the left filter ("f2[4]") to keep only the variable effectivily defined
+ by the left expr (exercise for the reader: try to do the same with a flat data
+ type ; it's just a nigthmare because of slices).
+
+ In other words:
+ - when we find a left leave, we generate all the possible names
+ corresponding to that var, in a data structure (a tree) that reflect
+ the lustre data structure (w.r.t. array and struct)
+ - Then, struct or array accesses remove some branches of that tree
+
+*)
+(* var_trees are used to represent left var_tree, and val_exp var_tree *)
+type 'a var_tree =
+ A of 'a var_tree list (* should i use an array there? *)
+ | S of (Ident.t * 'a var_tree) list (* A Map.t ? *)
+ | L of 'a
+(* Quite similar to UniqueOutput.var_def_state, which is logic. *)
+
+let rec (flatten_var_tree : 'a var_tree -> 'a list) =
+ function
+ | A array -> List.flatten (List.map flatten_var_tree array)
+ | S fl -> List.flatten (List.map (fun (id,vt) -> flatten_var_tree vt) fl)
+ | L str -> [str]
+
+let rec (gen_var_trees :
+ (string -> Eff.type_ -> 'a) -> string -> Eff.type_ -> 'a var_tree) =
+ fun make_leave prefix teff ->
+ match teff with
+ | Bool_type_eff | Int_type_eff | Real_type_eff
+ | External_type_eff _ | Enum_type_eff(_)
+ | Any | Overload (* should not occur *)
+ ->
+ L (make_leave prefix teff)
+
+ | Array_type_eff(teff_elt,i) ->
+ let rec unfold acc cpt =
+ if cpt < 0 then acc else
+ let prefix = prefix ^ "_" ^ (soi cpt) in
+ let vt = gen_var_trees make_leave prefix teff_elt in
+ unfold (vt::acc) (cpt-1)
+ in
+ A (unfold [] (i-1))
+
+ | Struct_type_eff(_, fl) ->
+ S (List.map
+ (fun (fn, (steff,_)) ->
+ let prefix = prefix^"_"^(Ident.to_string fn) in
+ (fn, gen_var_trees make_leave prefix steff)
+ )
+ fl)
+
+
+let (expand_left : Eff.local_env -> left -> left list) =
+ fun nenv left ->
+ let rec (var_trees_of_left : left -> left var_tree) =
+ fun left ->
+ match left with
+ | LeftVarEff (vi,lxm) ->
+ let make_left nenv lxm vi prefix teff =
+ LeftVarEff (clone_var nenv vi prefix teff, lxm)
+ in
+ gen_var_trees (make_left nenv lxm vi) "" vi.var_type_eff
+ | LeftFieldEff (l,id,t) ->
+ (match var_trees_of_left l with
+ | S fl -> List.assoc id fl
+ | A _ | L _ -> assert false
+ )
+ | LeftArrayEff (l,i,t) ->
+ (match var_trees_of_left l with
+ | A array -> List.nth array i
+ | S _ | L _ -> assert false
+ )
+ | LeftSliceEff (l,si,t) ->
+ (match var_trees_of_left l with
+ | A array ->
+ let index_list = index_list_of_slice_info si in
+ let l = List.map (fun i -> List.nth array i) index_list in
+ A l
+ | S _ | L _ -> assert false
+ )
+ in
+ let vt = try var_trees_of_left left
+ with _ -> assert false
+ (* should not occur: just a defense against nth and assoc *)
+ in
+ flatten_var_tree vt
+
+(********************************************************************************)
+
+(** build a new loc that will alias ve, and add its definition in the
+ set of equations (cf acc) *)
+let rec (make_new_loc : Eff.local_env -> Eff.id_solver -> Lxm.t -> acc ->
+ Eff.val_exp -> acc * var_info) =
+ fun nenv id_solver lxm acc ve ->
+ let teff = List.hd (EvalType.val_exp_eff ve) in
+ let ceff = List.hd (EvalClock.get_val_exp_eff ve) in
+ let nv = new_var "v" nenv teff ceff in
+ let neq = [LeftVarEff(nv,lxm)], ve in
+ let neq = flagit neq lxm in
+ let nvl, (asserts,eqs,locs) = expand_var_info nenv id_solver ([],acc) nv in
+ let acc = (asserts,eqs, List.rev_append nvl locs) in
+ expand_eq nenv id_solver acc neq, nv
+
+and (var_trees_of_val_exp : Eff.local_env -> Eff.id_solver -> acc -> Eff.val_exp
+ -> acc * Eff.val_exp var_tree) =
+ fun nenv id_solver acc ve ->
+ let make_val_exp nenv lxm vi prefix teff =
+ let prefix = (Ident.to_string vi.var_name_eff) ^ prefix in
+ let idref = Ident.idref_of_string prefix in
+ CallByPosEff({src=lxm;it=(IDENT idref)}, OperEff [])
+ in
+ let loop = var_trees_of_val_exp nenv id_solver acc in
+ match ve with
+ | CallByPosEff (by_pos_op, OperEff vel) ->
+ let lxm = by_pos_op.src in
+ let by_pos_op = by_pos_op.it in
+ (match by_pos_op with
+ | STRUCT_ACCESS (id,teff) ->
+ let ve = try List.hd vel with _ -> assert false in
+ (match loop ve with
+ | acc, S fl -> acc, List.assoc id fl
+ | _, (A _ | L _) -> assert false
+ )
+ | ARRAY_ACCES (i,teff) ->
+ let ve = try List.hd vel with _ -> assert false in
+ (match loop ve with
+ | acc, A array -> acc, List.nth array i
+ | _, (S _ | L _) -> assert false
+ )
+ | ARRAY_SLICE (si,t) ->
+ let ve = try List.hd vel with _ -> assert false in
+ (match loop ve with
+ | acc, A array ->
+ let index_list = index_list_of_slice_info si in
+ let l = List.map (fun i -> List.nth array i) index_list in
+ acc, A l
+ | _, (S _ | L _) -> assert false
+ )
+ | IDENT idref ->
+ let vi = id_solver.id2var idref lxm in
+ acc, gen_var_trees (make_val_exp nenv lxm vi) "" vi.var_type_eff
+
+ | WITH(_) | HAT(_) | CONCAT | ARRAY(_)
+ | Predef _ | CALL _ | MERGE _ | CONST _
+ | PRE | ARROW | FBY | CURRENT | WHEN _ | TUPLE
+ ->
+ (* Create a new loc var to alias such expressions *)
+ let acc, nloc = make_new_loc nenv id_solver lxm acc ve in
+ acc,
+ gen_var_trees (make_val_exp nenv lxm nloc) "" nloc.var_type_eff
+ )
+ | CallByNameEff(by_name_op, fl) ->
+ let lxm = by_name_op.src in
+ let acc, nloc = make_new_loc nenv id_solver lxm acc ve in
+ acc,
+ gen_var_trees (make_val_exp nenv lxm nloc) "" nloc.var_type_eff
+
+
+and (expand_eq :
+ Eff.local_env -> Eff.id_solver -> acc -> Eff.eq_info srcflagged -> acc) =
+ fun nenv id_solver acc eqf ->
+ let { src = lxm_eq ; it = (left_list, ve) } = eqf in
+ let left_list = List.flatten (List.map (expand_left nenv) left_list) in
+ let ve,acc = expand_val_exp nenv id_solver acc ve in
+ let eqf = { src = lxm_eq ; it = (left_list, ve) } in
+ let (asserts, eqs, locs) = acc in
+ (asserts, eqf::eqs, locs)
+
+and expand_val_exp_list n_env id_solver acc vel =
+ List.fold_left
+ (fun (vel,acc) ve ->
+ let ve,acc = expand_val_exp n_env id_solver acc ve in
+ ve::vel, acc
+ )
+ ([],acc) (List.rev vel)
+
+and (expand_val_exp: Eff.local_env -> Eff.id_solver -> acc -> val_exp ->
+ val_exp * acc) =
+ fun n_env id_solver acc ve ->
+ match ve with
+
+ | CallByPosEff (by_pos_op, OperEff vel) ->
+ let lxm = by_pos_op.src in
+ let by_pos_op = by_pos_op.it in
+ let by_pos_op, acc, vel =
+ match by_pos_op with
+ | WITH(ve) ->
+ let ve, acc = expand_val_exp n_env id_solver acc ve in
+ let vel,acc = expand_val_exp_list n_env id_solver acc vel in
+ WITH(ve), acc, vel
+ | HAT(i,ve) ->
+ let ve, acc = expand_val_exp n_env id_solver acc ve in
+ let rec unfold cpt =
+ if cpt = 0 then [] else ve::(unfold (cpt-1))
+ in
+ TUPLE, acc, unfold i
+ | ARRAY(vel) ->
+ let vel,acc = expand_val_exp_list n_env id_solver acc vel in
+ TUPLE, acc, vel
+
+ | CONCAT | Predef _ | CALL _ | MERGE _ | CONST _
+ | PRE | ARROW | FBY | CURRENT | WHEN _ | TUPLE
+ ->
+ let vel,acc = expand_val_exp_list n_env id_solver acc vel in
+ by_pos_op, acc, vel
+
+ | STRUCT_ACCESS (_)
+ | ARRAY_ACCES (_)
+ | ARRAY_SLICE (_)
+ | IDENT _ ->
+ let acc, vt = try var_trees_of_val_exp n_env id_solver acc ve
+ with _ -> assert false (* just a defense against nth and assoc *)
+ in
+ TUPLE, acc, flatten_var_tree vt
+ in
+ CallByPosEff(Lxm.flagit by_pos_op lxm, OperEff vel), acc
+
+ | CallByNameEff(by_name_op, fl) ->
+ let lxm = by_name_op.src in
+ let vel,acc = List.fold_left
+ (fun (vel,acc) (id,ve) ->
+ let ve,acc = expand_val_exp n_env id_solver acc ve in
+ ve::vel, acc
+ )
+ ([],acc)
+ fl
+ in
+ CallByPosEff({ src = lxm ; it = TUPLE }, OperEff (List.rev vel)), acc
+
+and (expand_val_exp_flag: Eff.local_env -> Eff.id_solver -> acc ->
+ val_exp srcflagged -> val_exp srcflagged * acc) =
+ fun n_env id_solver acc { src = lxm ; it = ve } ->
+ let ve,acc = expand_val_exp n_env id_solver acc ve in
+ { src = lxm ; it = ve }, acc
+
+and (expand_assert:
+ Eff.local_env -> Eff.id_solver -> acc -> val_exp srcflagged -> acc) =
+ fun n_env id_solver acc ve ->
+ let (ve, (asserts, eqs, locs)) = expand_val_exp_flag n_env id_solver acc ve in
+ (ve::asserts, eqs, locs)
+
+and (expand_var_info: Eff.local_env -> Eff.id_solver -> var_info list * acc ->
+ var_info -> var_info list * acc) =
+ fun nenv id_solver (vil, acc) vi ->
+ match vi.var_type_eff with
+ | Struct_type_eff (name, fl) ->
+ List.fold_left
+ (fun (vil,acc) (fn, (ft,_)) ->
+ let new_var = clone_var nenv vi ("_" ^ Ident.to_string fn) ft in
+ let new_vil, new_acc = expand_var_info nenv id_solver (vil,acc) new_var in
+ if new_vil = new_var::vil then (
+ (* [new_var] type is not made of structure *)
+ assert (is_a_basic_type ft);
+ Hashtbl.add nenv.lenv_vars new_var.var_name_eff new_var);
+ new_vil, new_acc
+ )
+ (vil, acc)
+ fl
+
+ | Array_type_eff(at,size) ->
+ let rec aux i (vil,acc) =
+ if i=size then (vil,acc) else
+ let new_var = clone_var nenv vi ("_" ^ soi i) at in
+ let new_vil, new_acc = expand_var_info nenv id_solver (vil,acc) new_var in
+ if new_vil = new_var::vil then (
+ (* [new_var] type is not made of structure *)
+ assert (is_a_basic_type at);
+ Hashtbl.add nenv.lenv_vars new_var.var_name_eff new_var);
+ aux (i+1) (new_vil, new_acc)
+ in
+ aux 0 (vil,acc)
+
+ | _ -> vi::vil, acc
let (node : Eff.local_env -> Eff.id_solver -> Eff.node_exp -> Eff.node_exp) =
- fun node_env id_solver n ->
+ fun n_env is n ->
+ match n.def_eff with
| ExternEff
| AbstractEff -> n
- | BodyEff b ->
- let loc = match n.loclist_eff with None -> [] | Some l -> l in
- let (neqs, nv) =
- List.fold_left (inline_eq node_env id_solver) ([], loc) b.eqs_eff
+ | BodyEff b ->
+ let loclist = match n.loclist_eff with None -> [] | Some l -> l in
+ let inlist = n.inlist_eff in
+ let outlist = n.outlist_eff in
+ let acc = ([],[],[]) in
+ let inlist, acc = List.fold_left (expand_var_info n_env is) ([],acc) inlist in
+ let outlist, acc = List.fold_left (expand_var_info n_env is) ([],acc) outlist in
+ let loclist, acc = List.fold_left (expand_var_info n_env is) ([],acc) loclist in
+ let acc = List.fold_left (expand_eq n_env is) acc b.eqs_eff in
+ let acc = List.fold_left (expand_assert n_env is) acc b.asserts_eff in
+ let (asserts,neqs, nv) = acc in
+ let nb = {
+ eqs_eff = neqs ;
+ asserts_eff = asserts
+ }
in
- let nb = { b with eqs_eff = List.rev neqs } in
let res =
{ n with
- loclist_eff = Some nv;
+ inlist_eff = List.rev inlist;
+ outlist_eff = List.rev outlist;
+ loclist_eff = Some (List.rev_append loclist nv);
def_eff = BodyEff nb
}
in
res
-
diff --git a/src/structExpand.ml.save b/src/structExpand.ml.save
new file mode 100644
index 0000000000000000000000000000000000000000..32b62424963c0e51e2fd05918b5e0774385ef0f7
--- /dev/null
+++ b/src/structExpand.ml.save
@@ -0,0 +1,490 @@
+(** Time-stamp: <modified the 29/01/2009 (at 16:56) by Erwan Jahier> *)
+
+(* Replace structures by as many variables as necessary.
+ Since structures can be recursive, it migth be a lot of new variables...
+
+
+
+ For instance, a variable
+ v : Toto { f1 : int ; f2 : int ^ 3 ; f3 : t^2
+
+ where
+ type t = T { x:int ; y:int }
+
+ will be expanded into
+
+ _v_f1 : int;
+ _v_f2 : int ^ 3;
+ _v_f3_1_x : int;
+ _v_f3_1_y : int;
+ _v_f3_2_x : int;
+ _v_f3_3_y : int;
+
+
+ nb : if 't' was a type that does not contain any struct type, we would just
+ have 3 variables.
+
+
+ nb : I needed to be quite clever to program that module, but I'm not...
+ so it's certainly buggy.
+ *)
+
+open Lxm
+open Eff
+open Predef
+
+type acc =
+ Eff.val_exp srcflagged list (* assertions *)
+ * (Eff.eq_info srcflagged) list (* equations *)
+ * Eff.var_info list (* new local vars *)
+
+
+(********************************************************************************)
+
+
+(* stuff to create fresh var names.
+ XXX code dupl. with Split.new_var
+*)
+let new_var str node_env type_eff clock_eff =
+ let id = Ident.of_string (Name.new_local_var str) in
+(* let id = Ident.of_string (Name.new_local_var "h") in *)
+ let var =
+ {
+ var_name_eff = id;
+ var_nature_eff = SyntaxTreeCore.VarLocal;
+ var_number_eff = -1; (* this field is used only for i/o.
+ Should i rather put something sensible there ? *)
+ var_type_eff = type_eff;
+ var_clock_eff = clock_eff;
+ }
+ in
+ Hashtbl.add node_env.lenv_vars id var;
+ var
+
+(* returns a new var based on [vi] with type [type_eff]. *)
+let clone_var str vi node_env type_eff =
+ let str = (Ident.to_string vi.var_name_eff) ^ str in
+(* let id = Ident.of_string (if str.[0] = '_' then str else "_" ^ str) in *)
+ let id = Ident.of_string (str) in
+ let var =
+ {
+ var_name_eff = id;
+ var_nature_eff = vi.var_nature_eff;
+ var_number_eff = vi.var_number_eff; (* this field is useless: to be removed. *)
+ var_type_eff = type_eff;
+ var_clock_eff = vi.var_clock_eff;
+ }
+ in
+(* Hashtbl.add node_env.lenv_vars id var; *)
+ var
+
+
+let rec (is_a_basic_type : Eff.type_ -> bool) =
+ function
+ | Array_type_eff _ | Struct_type_eff _ -> false
+ | _ -> true
+
+let soi = string_of_int
+
+
+(* [expand_var "toto" acc type]
+ adds in [acc] all the strings corresponding to the set of atomic variables
+ defined by "toto". For instance, if "toto" is of type "s^2" where s is a structure
+ with two integer fields f1 and f2, expand var returns :
+
+ ["toto_0_f1",int ; "toto_0_f2",int ;"toto_1_f1",int ; "toto_1_f2",int ] @ acc
+
+ This function is used to expand left val_exp expressions.
+
+*)
+let (expand_var : string -> Eff.type_ -> (string * Eff.type_) list) =
+ fun prefix teff ->
+ let rec aux prefix acc teff =
+ match teff with
+ | Bool_type_eff
+ | Int_type_eff
+ | Real_type_eff
+ | External_type_eff _
+ | Enum_type_eff(_) -> (prefix,teff)::acc
+
+ | Any -> assert false (* should not occur *)
+ | Overload -> assert false (* should not occur *)
+
+ | Array_type_eff(teff_elt,i) ->
+ let rec unfold acc cpt =
+ if cpt = i then acc else
+ let acc = aux (prefix^"_"^(soi cpt)) acc teff_elt in
+ unfold acc (cpt+1)
+ in
+ unfold acc 0
+ | Struct_type_eff(l, fl) ->
+ List.fold_left
+ (fun acc (fn, (teff_elt,opt)) ->
+ aux (prefix^"_"^(Ident.to_string fn)) acc teff_elt)
+ acc
+ fl
+ in
+ List.rev (aux prefix [] teff)
+
+
+(* XXX code dupl!! j'ai deja ecrit ce genre de chose... Bon. *)
+let (index_list_of_slice_info : Eff.slice_info -> int list) =
+ fun si ->
+ let sign = if si.se_step > 0 then 1 else -1 in
+ let rec aux acc cpt =
+ if cpt > si.se_last*sign then acc else
+ aux (cpt::acc) (cpt + si.se_step)
+ in
+ List.rev (aux [] si.se_first)
+
+(*
+ for ex, t of type int^3 is expanded into [t_0,t_1,t_2]
+
+*)
+
+type 'a var_tree = A of 'a var_tree list | S of (Ident.t * 'a var_tree) list | L of 'a
+
+let (expand_left : Eff.local_env -> left -> left list) =
+ fun nenv left ->
+ (* First step: recursively traverse the left structure to compute the variable
+ prefix (e.g., "X.f2[4]" -> "X_f2_4")
+
+ But because of slices, things are not so simple...
+ The algo is the following:
+ - when we find a left leave, we generate all the possible names
+ corresponding to that var, in a data structure (a tree) that reflect
+ the lustre data structure (array and struct)
+ - Then, struct or array accesses just remove some branches of that tree
+
+ *)
+ let rec (gen_var_trees :
+ Lxm.t -> Eff.var_info -> string -> Eff.type_ -> left var_tree) =
+ fun lxm vi prefix teff -> match teff with
+ | Bool_type_eff
+ | Int_type_eff
+ | Real_type_eff
+ | External_type_eff _
+ | Enum_type_eff(_)
+ | Any (* should not occur *)
+ | Overload (* should not occur *)
+ ->
+ let new_left = LeftVarEff (clone_var prefix vi nenv teff, lxm) in
+ L new_left
+
+ | Array_type_eff(teff_elt,i) ->
+ let rec unfold acc cpt =
+ if cpt < 0 then acc else
+ let prefix = prefix ^ "_" ^ (soi cpt) in
+ let vt = gen_var_trees lxm vi prefix teff_elt in
+ unfold (vt::acc) (cpt-1)
+ in
+ let lvt = unfold [] (i-1) in
+ A lvt
+
+ | Struct_type_eff(_, fl) ->
+ S (List.map
+ (fun (fn, (steff,_)) ->
+ let prefix = prefix^"_"^(Ident.to_string fn) in
+ (fn, gen_var_trees lxm vi prefix steff)
+ )
+ fl)
+
+ in
+ let rec (var_trees_of_left : left -> left var_tree) =
+ fun left ->
+ match left with
+ | LeftVarEff (vi,lxm) ->
+ gen_var_trees lxm vi (Ident.to_string vi.var_name_eff) vi.var_type_eff
+ | LeftFieldEff (l,id,t) ->
+ (match var_trees_of_left l with
+ | S fl -> (try List.assoc id fl with _ -> assert false)
+ | A _ | L _ -> assert false
+ )
+ | LeftArrayEff (l,i,t) ->
+ (match var_trees_of_left l with
+ | A array -> List.nth array i
+ | S _ | L _ -> assert false
+ )
+ | LeftSliceEff (l,si,t) ->
+ (match var_trees_of_left l with
+ | A array ->
+ let index_list = index_list_of_slice_info si in
+ let l = List.map (fun i -> List.nth array i) index_list in
+ A l
+ | S _ | L _ -> assert false
+ )
+ in
+ let rec (flatten_var_tree : 'a var_tree -> 'a list) =
+ function
+ | A array -> List.flatten (List.map flatten_var_tree array)
+ | S fl -> List.flatten (List.map (fun (id,vt) -> flatten_var_tree vt) fl)
+ | L str -> [str]
+ in
+
+
+ let vt = var_trees_of_left left in
+ flatten_var_tree vt
+
+(********************************************************************************)
+
+let rec (make_new_loc : Eff.local_env -> Eff.id_solver -> Lxm.t -> acc ->
+ Eff.val_exp -> acc * string list) =
+ fun nenv id_solver lxm acc ve -> (* build a new loc that will alias ve *)
+ let teff = List.hd (EvalType.val_exp_eff ve) in
+ let ceff = List.hd (EvalClock.get_val_exp_eff ve) in
+ let nv = new_var "v" nenv teff ceff in
+ let neq = [LeftVarEff(nv,lxm)], ve in
+ let neq = flagit neq lxm in
+ let nvl, (asserts,eqs,locs) = expand_var_info nenv id_solver ([],acc) nv in
+ let acc = (asserts,eqs, List.rev_append nvl locs) in
+ expand_eq nenv id_solver acc neq, [Ident.to_string nv.var_name_eff]
+
+and (step1_val_exp : Eff.local_env -> Eff.id_solver -> Lxm.t -> acc -> Eff.val_exp ->
+ acc * string list) =
+ fun nenv id_solver lxm acc ve ->
+ (* First step: recursively traverse the val_exp structure to compute the variable
+ prefix (e.g., "X.f2[4]" -> "X_f2_4") *)
+ let rec aux acc ve prefix =
+ match ve with
+ | CallByPosEff (by_pos_op, OperEff vel) ->
+ let lxm = by_pos_op.src in
+ let by_pos_op = by_pos_op.it in
+ (match by_pos_op with
+ | STRUCT_ACCESS (id,teff) ->
+ (match vel with
+ | [ve] ->
+ let prefix = "_" ^ (Ident.of_string id) ^ prefix in
+ aux acc ve prefix
+ | _ -> assert false (* should not occur *)
+ )
+ | ARRAY_ACCES (i,teff) ->
+ (match vel with
+ | [ve] ->
+ let prefix = "_" ^ (soi i) ^ prefix in
+ aux acc ve prefix
+ | _ -> assert false (* should not occur *)
+ )
+ | ARRAY_SLICE (si,t) ->
+ (match vel with
+ | [ve] ->
+ (*
+ Non. Je dois,
+ - generer tous les elements du tableau
+ - jeter ceux qui ne sont pas dans la tranche
+ *)
+(* let ve_elt, ve_size = *)
+(* match EvalType.val_exp_eff ve with *)
+(* | Array_type_eff(t,s) -> t,s *)
+(* | _ -> assert false *)
+(* in *)
+ let index_list = index_list_of_slice_info si in
+ let acc,ll =
+ List.fold_left
+ (fun (acc, ll) i ->
+ let prefix = "_" ^ (soi i) ^ prefix in
+ let (acc, l) = aux acc ve prefix in
+ acc, l::ll)
+ (acc,[])
+ index_list
+ in
+ let l = List.flatten ll in
+ acc, l
+
+ | _ -> assert false (* should not occur *)
+ )
+
+ | IDENT idref ->
+ let prefix = (Ident.string_of_idref idref) ^ prefix in
+ acc, [prefix]
+
+ | WITH(_) | HAT(_) | CONCAT | ARRAY(_)
+ | Predef _ | CALL _ | MERGE _ | CONST _
+ | PRE | ARROW | FBY | CURRENT | WHEN _ | TUPLE
+ ->
+ (* Create a new loc var to alias such expressions *)
+ let acc, nv_str_list = make_new_loc nenv id_solver lxm acc ve in
+ acc, List.map (fun nv_str -> nv_str ^ prefix) nv_str_list
+
+ )
+ | CallByNameEff(by_name_op, fl) -> make_new_loc nenv id_solver lxm acc ve
+
+ in
+ aux acc ve ""
+
+and (step2_val_exp : string -> Lxm.t -> Eff.type_ -> acc -> acc * Eff.val_exp list) =
+ fun prefix lxm teff acc ->
+ (* compute the expansion from the type using the prefix computed in step1 *)
+ let name_list = expand_var prefix teff in
+ let vel = List.map
+ (fun (str, teff) ->
+ let idref = Ident.idref_of_string str in
+ CallByPosEff({src=lxm;it=(IDENT idref)}, OperEff [])
+ )
+ name_list
+ in
+ acc, vel
+
+(********************************************************************************)
+and (expand_eq :
+ Eff.local_env -> Eff.id_solver -> acc -> Eff.eq_info srcflagged -> acc) =
+ fun nenv id_solver acc eqf ->
+ let { src = lxm_eq ; it = (left_list, ve) } = eqf in
+ let left_list = List.flatten (List.map (expand_left nenv) left_list) in
+ let ve,acc = expand_val_exp nenv id_solver acc ve in
+ let eqf = { src = lxm_eq ; it = (left_list, ve) } in
+ let (asserts, eqs, locs) = acc in
+ (asserts, eqf::eqs, locs)
+
+and expand_val_exp_list n_env id_solver acc vel =
+ List.fold_left
+ (fun (vel,acc) ve ->
+ let ve,acc = expand_val_exp n_env id_solver acc ve in
+ ve::vel, acc
+ )
+ ([],acc) (List.rev vel)
+
+and (expand_val_exp: Eff.local_env -> Eff.id_solver -> acc -> val_exp ->
+ val_exp * acc) =
+ fun n_env id_solver acc ve ->
+ match ve with
+ | CallByPosEff (by_pos_op, OperEff vel) ->
+ let lxm = by_pos_op.src in
+ let by_pos_op = by_pos_op.it in
+ let by_pos_op, acc, vel = match by_pos_op with
+ | WITH(ve) ->
+ let ve, acc = expand_val_exp n_env id_solver acc ve in
+ let vel,acc = expand_val_exp_list n_env id_solver acc vel in
+ WITH(ve), acc, vel
+ | HAT(i,ve) ->
+ let ve, acc = expand_val_exp n_env id_solver acc ve in
+ let rec unfold cpt =
+ if cpt = 0 then [] else ve::(unfold (cpt-1))
+ in
+ TUPLE, acc, unfold i
+ | CONCAT ->
+ let vel,acc = expand_val_exp_list n_env id_solver acc vel in
+ TUPLE, acc, vel
+ | ARRAY(vel) ->
+ let vel,acc = expand_val_exp_list n_env id_solver acc vel in
+ TUPLE, acc, vel
+
+ | STRUCT_ACCESS (_,teff)
+ | ARRAY_ACCES (_,teff)
+ | ARRAY_SLICE (_,teff) ->
+ let acc,prefix_list = step1_val_exp n_env id_solver lxm acc ve in
+ let acc,vel =
+ List.fold_left
+ (fun (acc,vel_acc) prefix ->
+ let acc, vel = step2_val_exp prefix lxm teff acc in
+ acc, List.append vel vel_acc
+ )
+ (acc,[])
+ prefix_list
+ in
+ TUPLE, acc, vel
+
+ | IDENT idref ->
+ let prefix = Ident.string_of_idref idref in
+ let teff = (id_solver.id2var idref lxm).var_type_eff in
+ let acc,vel = step2_val_exp prefix lxm teff acc in
+ TUPLE, acc, vel
+
+ | Predef _ | CALL _ | MERGE _ | CONST _
+ | PRE | ARROW | FBY | CURRENT | WHEN _ | TUPLE
+ ->
+ let vel,acc = expand_val_exp_list n_env id_solver acc vel in
+ by_pos_op, acc, vel
+ in
+ CallByPosEff(Lxm.flagit by_pos_op lxm, OperEff vel), acc
+
+ | CallByNameEff(by_name_op, fl) ->
+ let lxm = by_name_op.src in
+ let vel,acc = List.fold_left
+ (fun (vel,acc) (id,ve) ->
+ let ve,acc = expand_val_exp n_env id_solver acc ve in
+ ve::vel, acc
+ )
+ ([],acc)
+ fl
+ in
+ CallByPosEff({ src = lxm ; it = TUPLE}, OperEff (List.rev vel)), acc
+
+
+
+and (expand_val_exp_flag: Eff.local_env -> Eff.id_solver -> acc ->
+ val_exp srcflagged -> val_exp srcflagged * acc) =
+ fun n_env id_solver acc { src = lxm ; it = ve } ->
+ let ve,acc = expand_val_exp n_env id_solver acc ve in
+ { src = lxm ; it = ve }, acc
+
+and (expand_assert:
+ Eff.local_env -> Eff.id_solver -> acc -> val_exp srcflagged -> acc) =
+ fun n_env id_solver acc ve ->
+ let (ve, (asserts, eqs, locs)) = expand_val_exp_flag n_env id_solver acc ve in
+ (ve::asserts, eqs, locs)
+
+and (expand_var_info: Eff.local_env -> Eff.id_solver -> var_info list * acc ->
+ var_info -> var_info list * acc) =
+ fun nenv id_solver (vil, acc) vi ->
+ match vi.var_type_eff with
+ | Struct_type_eff (name, fl) ->
+ List.fold_left
+ (fun (vil,acc) (fn, (ft,_)) ->
+ let new_var = clone_var ("_" ^ Ident.to_string fn) vi nenv ft in
+ let new_vil, new_acc = expand_var_info nenv id_solver (vil,acc) new_var in
+ if new_vil = new_var::vil then (
+ (* [new_var] type is not made of structure *)
+ assert (is_a_basic_type ft);
+ Hashtbl.add nenv.lenv_vars new_var.var_name_eff new_var);
+ new_vil, new_acc
+ )
+ (vil, acc)
+ fl
+
+ | Array_type_eff(at,size) ->
+ let rec aux i (vil,acc) =
+ if i=size then (vil,acc) else
+ let new_var = clone_var ("_" ^ soi i) vi nenv at in
+ let new_vil, new_acc = expand_var_info nenv id_solver (vil,acc) new_var in
+ if new_vil = new_var::vil then (
+ (* [new_var] type is not made of structure *)
+ assert (is_a_basic_type at);
+ Hashtbl.add nenv.lenv_vars new_var.var_name_eff new_var);
+ aux (i+1) (new_vil, new_acc)
+ in
+ aux 0 (vil,acc)
+
+ | _ -> vi::vil, acc
+
+
+let (node : Eff.local_env -> Eff.id_solver -> Eff.node_exp -> Eff.node_exp) =
+ fun n_env is n ->
+ match n.def_eff with
+ | ExternEff
+ | AbstractEff -> n
+ | BodyEff b ->
+ let loclist = match n.loclist_eff with None -> [] | Some l -> l in
+ let inlist = n.inlist_eff in
+ let outlist = n.outlist_eff in
+ let acc = ([],[],[]) in
+ let inlist, acc = List.fold_left (expand_var_info n_env is) ([],acc) inlist in
+ let outlist, acc = List.fold_left (expand_var_info n_env is) ([],acc) outlist in
+ let loclist, acc = List.fold_left (expand_var_info n_env is) ([],acc) loclist in
+ let acc = List.fold_left (expand_eq n_env is) acc b.eqs_eff in
+ let acc = List.fold_left (expand_assert n_env is) acc b.asserts_eff in
+ let (asserts,neqs, nv) = acc in
+ let nb = {
+ eqs_eff = neqs ;
+ asserts_eff = asserts
+ }
+ in
+ let res =
+ { n with
+ inlist_eff = List.rev inlist;
+ outlist_eff = List.rev outlist;
+ loclist_eff = Some (List.rev_append loclist nv);
+ def_eff = BodyEff nb
+ }
+ in
+ res
+
diff --git a/src/structExpand.mli b/src/structExpand.mli
index b565e1b60e3f73ebdcee31ff6799c61aad8d088a..e805f76f3a199978936c9c18fe827ea8acc82aa2 100644
--- a/src/structExpand.mli
+++ b/src/structExpand.mli
@@ -1,4 +1,5 @@
-(** Time-stamp: <modified the 05/12/2008 (at 15:38) by Erwan Jahier> *)
+(** Time-stamp: <modified the 26/01/2009 (at 15:45) by Erwan Jahier> *)
+(** Expand strutures and arrays *)
val node : Eff.local_env -> Eff.id_solver -> Eff.node_exp -> Eff.node_exp
diff --git a/src/test/Makefile b/src/test/Makefile
index 453fcbf398dfba0ee2a27b311da56ae2fc44cde7..004f87e5f40c641dad47b7a428c66296e2a21c9c 100644
--- a/src/test/Makefile
+++ b/src/test/Makefile
@@ -1,6 +1,6 @@
LC0=../lus2lic
-LC=../lus2lic -vl 2 --compile-all-items
-LC2=../lus2lic --compile-all-items
+LC=../lus2lic -vl 2
+LC2=../lus2lic
NL="----------------------------------------------------------------------\\n"
filter_line=grep -v Opening\ file
diff --git a/src/test/should_work/Pascal/left.lus b/src/test/should_work/Pascal/left.lus
index 8d9d541577a43eaada81e3f695340ae9f71ad5b2..d9735332f77c95c7d742f94569141e55553a8c11 100644
--- a/src/test/should_work/Pascal/left.lus
+++ b/src/test/should_work/Pascal/left.lus
@@ -8,7 +8,7 @@ type truc = struct {
node toto(x : bool) returns (t : truc^3);
let
t[0].a[0..98 step 2][48..0 step -2] = true^25;
--- t[0].a[0..98 step 2][0..48 step 2] = true^25;
+-- t[0].a[0..98 step 2][0..48 step 2] = true^25;
t[0].a[0..98 step 2][1..49 step 2] = false^25;
t[0].a[1..99 step 2][0] = true;
t[0].a[1..99 step 2][1] = true;
diff --git a/src/test/test.res.exp b/src/test/test.res.exp
index bb85378fce1129a840af892c0e41af897001a362..6d180136b90d2f5b04f5151fcefac01b2c5e4892 100644
--- a/src/test/test.res.exp
+++ b/src/test/test.res.exp
@@ -1,26 +1,48 @@
Non-regression tests
-usage: lus2lic [options] <lustre files> | lus2lic -help
- --version Print the current version then exit
- --output-file <file>
- -o <file> Set the output file name
+usage: lus2lic [options] <lustre files>
+where [options] can be:
--node <node>
- -n <node> Set the main node (all items are compiled if unset)
- --compile-all-items
- -all Compile all items of the program
- -unit Run some (internal) unit tests
- --verbose
- -v Set verbose mode on (i.e., verbose level = 1)
+ -n <node>
+ Set the main node (all items are compiled if unset)
+ --output-file <file>
+ -o <file>
+ Set the output file name.
+ --keep-nested-calls
+ -knc
+ Keep nested calls. By default, only one node per equation is generated.
+ --expand-iterators
+ -ei
+ Expand array iterators.
+ --expand-enums
+ -ee
+ Translate enums into integers.
+ --expand-structs-and-arrays
+ -esa
+ Expand structures and arrays using as many variables as necessary.
+ --expand-nodes
+ -en
+ Expand the main node (use the first node if no one is specified).
+ --lustre-v4
+ -lv4
+ Use Lustre V4 syntax (automatically impose '-ei -ee -esa').
+ --expanded-code
+ -ec
+ Generate ec (actually just an alias for '-en -lv4').
+ -unit
+ Run some (internal) unit tests
--verbose-level <int>
- -vl <int> Set verbose level
- --keep-nested-calls Keep nested calls
- --expand-iterators expand iterators
- --expand-enums Translate enums into integers
- --expand-nodes Expand nodes (hence, only one node is generated).
- --lustre-v4 Generate Lustre V4 compatible Lustre (if possible)
- -lv4 Generate Lustre V4 compatible Lustre (if possible)
+ -vl <int>
+ Set the verbose level.
+ --verbose
+ -v
+ Set the verbose level to 1.
+ --version
+ -version
+ Display the current version of the tool.
-h
-help
- --help Display this list of options
+ --help
+ Display this message.
Opening file should_work/NONREG/ex.lus
type _ex::t = A_A_A_int_1_2_3^4;
type _ex::t1 = A_A_A_A_int_1_2_3_4^4;
@@ -63,7 +85,7 @@ type A_A_A_int_1_2_3 = A_A_int_1_2^3;
type A_A_int_1_2 = A_int_1^2;
type A_int_1 = int^1;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/COUNTER.lus
+====> ../lus2lic -vl 2 should_work/NONREG/COUNTER.lus
Opening file should_work/NONREG/COUNTER.lus
node COUNTER::COUNTER(
@@ -88,7 +110,7 @@ tel
-- end of node COUNTER::COUNTER
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/CURRENT.lus
+====> ../lus2lic -vl 2 should_work/NONREG/CURRENT.lus
Opening file should_work/NONREG/CURRENT.lus
node CURRENT::CURRENT(x:bool; y:bool when x) returns (z:bool when x);
let
@@ -97,7 +119,7 @@ tel
-- end of node CURRENT::CURRENT
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/EDGE.lus
+====> ../lus2lic -vl 2 should_work/NONREG/EDGE.lus
Opening file should_work/NONREG/EDGE.lus
node EDGE::EDGE(X:bool) returns (Y:bool);
var
@@ -113,7 +135,7 @@ tel
-- end of node EDGE::EDGE
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/FALLING_EDGE.lus
+====> ../lus2lic -vl 2 should_work/NONREG/FALLING_EDGE.lus
Opening file should_work/NONREG/FALLING_EDGE.lus
node FALLING_EDGE::EDGE(X:bool) returns (Y:bool);
var
@@ -137,7 +159,7 @@ tel
-- end of node FALLING_EDGE::FALLING_EDGE
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/Int.lus
+====> ../lus2lic -vl 2 should_work/NONREG/Int.lus
Opening file should_work/NONREG/Int.lus
const Int8::n = 8;
type _Int8::Int = bool^8;
@@ -201,7 +223,7 @@ tel
-- automatically defined aliases:
type A_bool_8 = bool^8;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/PCOND.lus
+====> ../lus2lic -vl 2 should_work/NONREG/PCOND.lus
Opening file should_work/NONREG/PCOND.lus
node PCOND::PCOND(
@@ -257,7 +279,7 @@ tel
-- end of node PCOND::PCOND
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/PCOND1.lus
+====> ../lus2lic -vl 2 should_work/NONREG/PCOND1.lus
Opening file should_work/NONREG/PCOND1.lus
node PCOND1::PCOND1(
@@ -285,7 +307,7 @@ tel
-- end of node PCOND1::PCOND1
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/SOURIS.lus
+====> ../lus2lic -vl 2 should_work/NONREG/SOURIS.lus
Opening file should_work/NONREG/SOURIS.lus
node SOURIS::SOURIS(
@@ -710,7 +732,7 @@ tel
-- end of node SOURIS::SOURIS
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/STABLE.lus
+====> ../lus2lic -vl 2 should_work/NONREG/STABLE.lus
Opening file should_work/NONREG/STABLE.lus
node STABLE::STABLE(set:bool; delay:int) returns (level:bool);
var
@@ -732,7 +754,7 @@ tel
-- end of node STABLE::STABLE
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/SWITCH.lus
+====> ../lus2lic -vl 2 should_work/NONREG/SWITCH.lus
Opening file should_work/NONREG/SWITCH.lus
node SWITCH::SWITCH(
@@ -760,7 +782,7 @@ tel
-- end of node SWITCH::SWITCH
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/SWITCH1.lus
+====> ../lus2lic -vl 2 should_work/NONREG/SWITCH1.lus
Opening file should_work/NONREG/SWITCH1.lus
node SWITCH1::SWITCH1(
@@ -782,7 +804,7 @@ tel
-- end of node SWITCH1::SWITCH1
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/TIME_STABLE.lus
+====> ../lus2lic -vl 2 should_work/NONREG/TIME_STABLE.lus
Opening file should_work/NONREG/TIME_STABLE.lus
node TIME_STABLE::STABLE(set:bool; delay:int) returns (level:bool);
var
@@ -826,7 +848,7 @@ tel
-- end of node TIME_STABLE::TIME_STABLE
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/TIME_STABLE1.lus
+====> ../lus2lic -vl 2 should_work/NONREG/TIME_STABLE1.lus
Opening file should_work/NONREG/TIME_STABLE1.lus
node TIME_STABLE1::TIME1_STABLE1(
@@ -860,7 +882,7 @@ tel
-- end of node TIME_STABLE1::TIME1_STABLE1
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/Watch.lus
+====> ../lus2lic -vl 2 should_work/NONREG/Watch.lus
Opening file should_work/NONREG/Watch.lus
type _Watch::STATUS_TYPE;
type _Watch::ALARM_TIME_TYPE;
@@ -1619,7 +1641,7 @@ tel
-- end of node Watch::MORE_RECENT
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/X.lus
+====> ../lus2lic -vl 2 should_work/NONREG/X.lus
Opening file should_work/NONREG/X.lus
node X::X(
@@ -1656,7 +1678,7 @@ tel
-- end of node X::X
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/X1.lus
+====> ../lus2lic -vl 2 should_work/NONREG/X1.lus
Opening file should_work/NONREG/X1.lus
node X1::X1(b:bool; n:int) returns (m:int);
var
@@ -1668,7 +1690,7 @@ tel
-- end of node X1::X1
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/X2.lus
+====> ../lus2lic -vl 2 should_work/NONREG/X2.lus
Opening file should_work/NONREG/X2.lus
node X2::X2(b:bool; n:int) returns (m:int);
var
@@ -1682,7 +1704,7 @@ tel
-- end of node X2::X2
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/X3.lus
+====> ../lus2lic -vl 2 should_work/NONREG/X3.lus
Opening file should_work/NONREG/X3.lus
node X3::X3(n:int; b:bool) returns (m:int);
var
@@ -1712,7 +1734,7 @@ tel
-- end of node X3::X3
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/X6.lus
+====> ../lus2lic -vl 2 should_work/NONREG/X6.lus
Opening file should_work/NONREG/X6.lus
node X6::X6(
@@ -1747,7 +1769,7 @@ tel
-- end of node X6::X6
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/_N_uu.lus
+====> ../lus2lic -vl 2 should_work/NONREG/_N_uu.lus
Opening file should_work/NONREG/_N_uu.lus
node _N_uu::_N_uu(I_x:bool; I_y:bool; I_z:bool) returns (O_a:bool);
var
@@ -1847,7 +1869,7 @@ tel
-- end of node _N_uu::_N_uu
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/activation_ec.lus
+====> ../lus2lic -vl 2 should_work/NONREG/activation_ec.lus
Opening file should_work/NONREG/activation_ec.lus
node activation_ec::activation_ec(evt:bool) returns (scie:int);
var
@@ -1887,7 +1909,7 @@ tel
-- end of node activation_ec::activation_ec
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/after.lus
+====> ../lus2lic -vl 2 should_work/NONREG/after.lus
Opening file should_work/NONREG/after.lus
node after::after(x:bool) returns (after:bool);
var
@@ -1901,7 +1923,7 @@ tel
-- end of node after::after
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/alarme.lus
+====> ../lus2lic -vl 2 should_work/NONREG/alarme.lus
Opening file should_work/NONREG/alarme.lus
const alarme::delai_reprise = 4;
const alarme::delai_vigilence = 3;
@@ -2092,7 +2114,7 @@ tel
-- end of node alarme::alarme
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/arbitre.lus
+====> ../lus2lic -vl 2 should_work/NONREG/arbitre.lus
Opening file should_work/NONREG/arbitre.lus
node arbitre::my_switch(
@@ -2213,7 +2235,7 @@ tel
-- end of node arbitre::arbitre
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/argos.lus
+====> ../lus2lic -vl 2 should_work/NONREG/argos.lus
Opening file should_work/NONREG/argos.lus
node argos::argos(a:bool; b:bool) returns (s0:bool; s1:bool; s2:bool);
var
@@ -2277,7 +2299,7 @@ tel
-- end of node argos::argos
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/assertion.lus
+====> ../lus2lic -vl 2 should_work/NONREG/assertion.lus
Opening file should_work/NONREG/assertion.lus
node assertion::assertion(
@@ -2297,7 +2319,7 @@ tel
-- end of node assertion::assertion
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/aux.lus
+====> ../lus2lic -vl 2 should_work/NONREG/aux.lus
Opening file should_work/NONREG/aux.lus
node aux::aux(ck:bool) returns (x:int);
var
@@ -2309,7 +2331,7 @@ tel
-- end of node aux::aux
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/aux1.lus
+====> ../lus2lic -vl 2 should_work/NONREG/aux1.lus
Opening file should_work/NONREG/aux1.lus
node aux1::aux1(a:int; b:int) returns (c:int; d:int);
var
@@ -2334,7 +2356,7 @@ tel
-- end of node aux1::aux1
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/bascule.lus
+====> ../lus2lic -vl 2 should_work/NONREG/bascule.lus
Opening file should_work/NONREG/bascule.lus
node bascule::bascule(r:bool; s:bool) returns (q:bool; n:bool);
var
@@ -2365,7 +2387,7 @@ tel
-- end of node bascule::bascule
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/call.lus
+====> ../lus2lic -vl 2 should_work/NONREG/call.lus
Opening file should_work/NONREG/call.lus
extern function call::f(a:int) returns (b:int);
node call::n(a:int; b:bool) returns (x:int; y:int);
@@ -2389,7 +2411,7 @@ tel
-- end of node call::call
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/ck2.lus
+====> ../lus2lic -vl 2 should_work/NONREG/ck2.lus
Opening file should_work/NONREG/ck2.lus
node ck2::ck2(c:bool; d:bool when c; e:int when d) returns (n:int);
var
@@ -2407,7 +2429,7 @@ tel
-- end of node ck2::ck2
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/ck3.lus
+====> ../lus2lic -vl 2 should_work/NONREG/ck3.lus
Opening file should_work/NONREG/ck3.lus
node ck3::ck3(a:bool; b:bool when a; c:bool when b) returns (x:bool);
var
@@ -2419,7 +2441,7 @@ tel
-- end of node ck3::ck3
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/ck4.lus
+====> ../lus2lic -vl 2 should_work/NONREG/ck4.lus
Opening file should_work/NONREG/ck4.lus
node ck4::ck4(a:int when b; b:bool) returns (c:int);
let
@@ -2428,7 +2450,7 @@ tel
-- end of node ck4::ck4
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/ck5.lus
+====> ../lus2lic -vl 2 should_work/NONREG/ck5.lus
Opening file should_work/NONREG/ck5.lus
node ck5::edge(x:bool) returns (y:bool);
var
@@ -2454,7 +2476,7 @@ tel
-- end of node ck5::ck5
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/ck6.lus
+====> ../lus2lic -vl 2 should_work/NONREG/ck6.lus
Opening file should_work/NONREG/ck6.lus
extern function ck6::p(d:int) returns (e:int; f:int);
node ck6::N(a:bool; m:int; n:int) returns (q:int; r:int when a);
@@ -2484,7 +2506,7 @@ tel
-- end of node ck6::ck6
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/ck7.lus
+====> ../lus2lic -vl 2 should_work/NONREG/ck7.lus
Opening file should_work/NONREG/ck7.lus
node ck7::ck7(a:bool; m:int; n:int) returns (q:int; r:int when a);
let
@@ -2494,7 +2516,7 @@ tel
-- end of node ck7::ck7
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/clock.lus
+====> ../lus2lic -vl 2 should_work/NONREG/clock.lus
Opening file should_work/NONREG/clock.lus
extern node clock::outOnIn(a:bool; b:bool) returns (c:bool when b);
extern node clock::inOnIn(a:bool; b:bool when a) returns (c:bool);
@@ -2557,7 +2579,7 @@ tel
-- automatically defined aliases:
type A_bool_7 = bool^7;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/cminus.lus
+====> ../lus2lic -vl 2 should_work/NONREG/cminus.lus
Opening file should_work/NONREG/cminus.lus
node cminus::TWO_STATES(
@@ -2629,7 +2651,7 @@ tel
-- end of node cminus::cminus
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/compteur.lus
+====> ../lus2lic -vl 2 should_work/NONREG/compteur.lus
Opening file should_work/NONREG/compteur.lus
node compteur::compteur(evt:bool) returns (cpt:int);
var
@@ -2645,7 +2667,7 @@ tel
-- end of node compteur::compteur
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/count.lus
+====> ../lus2lic -vl 2 should_work/NONREG/count.lus
Opening file should_work/NONREG/count.lus
node count::count(x:int; y:int) returns (s:int);
var
@@ -2657,7 +2679,7 @@ tel
-- end of node count::count
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/cpt.lus
+====> ../lus2lic -vl 2 should_work/NONREG/cpt.lus
Opening file should_work/NONREG/cpt.lus
node cpt::cpt(evt:bool; reset:bool) returns (cpt:int);
var
@@ -2675,7 +2697,7 @@ tel
-- end of node cpt::cpt
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/cst.lus
+====> ../lus2lic -vl 2 should_work/NONREG/cst.lus
Opening file should_work/NONREG/cst.lus
const cst::i:int;
const cst::j:int;
@@ -2698,7 +2720,7 @@ tel
-- end of node cst::cst
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/deconne.lus
+====> ../lus2lic -vl 2 should_work/NONREG/deconne.lus
Opening file should_work/NONREG/deconne.lus
type _deconne::pendule;
const deconne::G = 10.0;
@@ -2740,7 +2762,7 @@ tel
-- end of node deconne::deconne
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/dep.lus
+====> ../lus2lic -vl 2 should_work/NONREG/dep.lus
Opening file should_work/NONREG/dep.lus
node dep::dep(x:int) returns (u:int; v:int; y:int);
var
@@ -2764,7 +2786,7 @@ tel
-- end of node dep::dep
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/dependeur.lus
+====> ../lus2lic -vl 2 should_work/NONREG/dependeur.lus
Opening file should_work/NONREG/dependeur.lus
node dependeur::dependeur(
@@ -2788,7 +2810,7 @@ tel
-- end of node dependeur::dependeur
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/dependeur_struct.lus
+====> ../lus2lic -vl 2 should_work/NONREG/dependeur_struct.lus
Opening file should_work/NONREG/dependeur_struct.lus
type _dependeur_struct::time = struct {h : int; m : int; s : int; ms : int};
@@ -2810,7 +2832,7 @@ tel
-- end of node dependeur_struct::dependeur_struct
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/drapfab.lus
+====> ../lus2lic -vl 2 should_work/NONREG/drapfab.lus
Opening file should_work/NONREG/drapfab.lus
node drapfab::drapfab(
@@ -2938,7 +2960,7 @@ tel
-- end of node drapfab::drapfab
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/enum.lus
+====> ../lus2lic -vl 2 should_work/NONREG/enum.lus
Opening file should_work/NONREG/enum.lus
type _enum::couleur = enum {enum::bleu, enum::blanc, enum::rouge};
type _enum::color = enum {enum::blue, enum::white, enum::redd};
@@ -2963,13 +2985,13 @@ tel
-- end of node enum::boo
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/enum0.lus
+====> ../lus2lic -vl 2 should_work/NONREG/enum0.lus
Opening file should_work/NONREG/enum0.lus
type _enum0::color1 = enum {enum0::blue, enum0::white, enum0::black};
type _enum0::color2 = enum {enum0::green, enum0::orange, enum0::yellow};
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/eq1.lus
+====> ../lus2lic -vl 2 should_work/NONREG/eq1.lus
Opening file should_work/NONREG/eq1.lus
node eq1::eq1(
@@ -3006,7 +3028,7 @@ tel
-- end of node eq1::eq1
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/ex.lus
+====> ../lus2lic -vl 2 should_work/NONREG/ex.lus
Opening file should_work/NONREG/ex.lus
type _ex::t = A_A_A_int_1_2_3^4;
type _ex::t1 = A_A_A_A_int_1_2_3_4^4;
@@ -3049,7 +3071,7 @@ type A_A_A_int_1_2_3 = A_A_int_1_2^3;
type A_A_int_1_2 = A_int_1^2;
type A_int_1 = int^1;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/exclusion.lus
+====> ../lus2lic -vl 2 should_work/NONREG/exclusion.lus
Opening file should_work/NONREG/exclusion.lus
node exclusion::exclusion(
@@ -3078,7 +3100,7 @@ tel
-- end of node exclusion::exclusion
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/fby.lus
+====> ../lus2lic -vl 2 should_work/NONREG/fby.lus
Opening file should_work/NONREG/fby.lus
node fby::followed_by(ck:bool) returns (x:int);
var
@@ -3092,7 +3114,7 @@ tel
-- end of node fby::followed_by
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/flo.lus
+====> ../lus2lic -vl 2 should_work/NONREG/flo.lus
Opening file should_work/NONREG/flo.lus
node flo::SWITCH(init:bool; on:bool; off:bool) returns (state:bool);
var
@@ -3127,7 +3149,7 @@ tel
-- end of node flo::flo
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/hanane.lus
+====> ../lus2lic -vl 2 should_work/NONREG/hanane.lus
Opening file should_work/NONREG/hanane.lus
type _hanane::t1;
const hanane::a = 4;
@@ -3205,7 +3227,7 @@ type A_A_int_4_4 = A_int_4^4;
type A__hanane::structT_2 = _hanane::structT^2;
type A_int_4 = int^4;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/import1.lus
+====> ../lus2lic -vl 2 should_work/NONREG/import1.lus
Opening file should_work/NONREG/import1.lus
extern node import1::imp(x:int) returns (y:int);
node import1::import1(a:int; b:int) returns (c:int);
@@ -3220,7 +3242,7 @@ tel
-- end of node import1::import1
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/initial.lus
+====> ../lus2lic -vl 2 should_work/NONREG/initial.lus
Opening file should_work/NONREG/initial.lus
node initial::initial(justDoIt:bool) returns (oa:bool; ob:int; oc:real);
var
@@ -3238,7 +3260,7 @@ tel
-- end of node initial::initial
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/integrator.lus
+====> ../lus2lic -vl 2 should_work/NONREG/integrator.lus
Opening file should_work/NONREG/integrator.lus
node integrator::integrator(
@@ -3266,7 +3288,7 @@ tel
-- end of node integrator::integrator
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/long_et_stupide_nom_de_noeud.lus
+====> ../lus2lic -vl 2 should_work/NONREG/long_et_stupide_nom_de_noeud.lus
Opening file should_work/NONREG/long_et_stupide_nom_de_noeud.lus
node long_et_stupide_nom_de_noeud::long_et_stupide_nom_de_noeud(
@@ -3282,14 +3304,14 @@ tel
-- end of node long_et_stupide_nom_de_noeud::long_et_stupide_nom_de_noeud
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/merge.lus
+====> ../lus2lic -vl 2 should_work/NONREG/merge.lus
Opening file should_work/NONREG/merge.lus
*** Error in file "should_work/NONREG/merge.lus", line 3, col 7 to 10, token 'when':
*** syntax error
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/minmax1.lus
+====> ../lus2lic -vl 2 should_work/NONREG/minmax1.lus
Opening file should_work/NONREG/minmax1.lus
node minmax1::minmax1(a:int; b:int) returns (min:int; max:int);
var
@@ -3302,7 +3324,7 @@ tel
-- end of node minmax1::minmax1
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/minmax2.lus
+====> ../lus2lic -vl 2 should_work/NONREG/minmax2.lus
Opening file should_work/NONREG/minmax2.lus
node minmax2::minmax(a:int; b:int) returns (min:int; max:int);
var
@@ -3320,7 +3342,7 @@ tel
-- end of node minmax2::minmax2
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/minmax3.lus
+====> ../lus2lic -vl 2 should_work/NONREG/minmax3.lus
Opening file should_work/NONREG/minmax3.lus
node minmax3::minmax(a:int; b:int) returns (min:int; max:int);
var
@@ -3352,7 +3374,7 @@ tel
-- end of node minmax3::minmax3
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/minmax4.lus
+====> ../lus2lic -vl 2 should_work/NONREG/minmax4.lus
Opening file should_work/NONREG/minmax4.lus
node minmax4::minmax(a:int; b:int) returns (min:int; max:int);
var
@@ -3391,7 +3413,7 @@ tel
-- end of node minmax4::minmax4
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/minmax4_bis.lus
+====> ../lus2lic -vl 2 should_work/NONREG/minmax4_bis.lus
Opening file should_work/NONREG/minmax4_bis.lus
node minmax4_bis::minmax(a:int; b:int) returns (min:int; max:int);
var
@@ -3430,7 +3452,7 @@ tel
-- end of node minmax4_bis::minmax4_bis
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/minmax5.lus
+====> ../lus2lic -vl 2 should_work/NONREG/minmax5.lus
Opening file should_work/NONREG/minmax5.lus
extern function minmax5::minmax(a:int; b:int) returns (min:int; max:int);
@@ -3461,7 +3483,7 @@ tel
-- end of node minmax5::minmax5
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/minmax5_random.lus
+====> ../lus2lic -vl 2 should_work/NONREG/minmax5_random.lus
Opening file should_work/NONREG/minmax5_random.lus
extern function minmax5_random::minmax(
@@ -3498,7 +3520,7 @@ tel
-- end of node minmax5_random::minmax5_random
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/minmax6.lus
+====> ../lus2lic -vl 2 should_work/NONREG/minmax6.lus
Opening file should_work/NONREG/minmax6.lus
node minmax6::minmax(a:int; b:int) returns (min:int; max:int);
var
@@ -3554,7 +3576,7 @@ tel
-- end of node minmax6::minmax6
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/mm.lus
+====> ../lus2lic -vl 2 should_work/NONREG/mm.lus
Opening file should_work/NONREG/mm.lus
type _mm::pair = struct {a : int; b : int};
type _mm::pairpair = struct {a : _mm::pair; b : _mm::pair};
@@ -3569,7 +3591,7 @@ tel
-- end of node mm::mm
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/mm1.lus
+====> ../lus2lic -vl 2 should_work/NONREG/mm1.lus
Opening file should_work/NONREG/mm1.lus
type _mm1::pair = struct {a : int; b : int};
type _mm1::pairpair = struct {a : _mm1::pair; b : _mm1::pair};
@@ -3584,7 +3606,7 @@ tel
-- end of node mm1::mm1
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/mm22.lus
+====> ../lus2lic -vl 2 should_work/NONREG/mm22.lus
Opening file should_work/NONREG/mm22.lus
type _mm22::pair = struct {a : int; b : int};
type _mm22::pairpair = struct {a : _mm22::pair; b : _mm22::pair};
@@ -3601,7 +3623,7 @@ tel
-- end of node mm22::mm22
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/mm3.lus
+====> ../lus2lic -vl 2 should_work/NONREG/mm3.lus
Opening file should_work/NONREG/mm3.lus
type _mm3::pair = struct {a : int; b : int};
type _mm3::pairpair = struct {a : _mm3::pair; b : _mm3::pair};
@@ -3628,7 +3650,7 @@ tel
-- end of node mm3::mm3
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/model.lus
+====> ../lus2lic -vl 2 should_work/NONREG/model.lus
Opening file should_work/NONREG/model.lus
node u::egal(i1:int; i2:int) returns (o:bool);
let
@@ -3648,7 +3670,7 @@ tel
-- end of node p::est_egal
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/mouse.lus
+====> ../lus2lic -vl 2 should_work/NONREG/mouse.lus
Opening file should_work/NONREG/mouse.lus
node mouse::edge(x:bool) returns (e:bool);
var
@@ -3734,7 +3756,7 @@ tel
-- end of node mouse::mouse
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/mouse1.lus
+====> ../lus2lic -vl 2 should_work/NONREG/mouse1.lus
Opening file should_work/NONREG/mouse1.lus
node mouse1::mouse1(
@@ -3804,7 +3826,7 @@ tel
-- end of node mouse1::mouse1
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/mouse2.lus
+====> ../lus2lic -vl 2 should_work/NONREG/mouse2.lus
Opening file should_work/NONREG/mouse2.lus
node mouse2::edge(x:bool) returns (e:bool);
var
@@ -3890,7 +3912,7 @@ tel
-- end of node mouse2::mouse2
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/mouse3.lus
+====> ../lus2lic -vl 2 should_work/NONREG/mouse3.lus
Opening file should_work/NONREG/mouse3.lus
node mouse3::mouse3(
@@ -3936,7 +3958,7 @@ tel
-- end of node mouse3::mouse3
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/multiclock.lus
+====> ../lus2lic -vl 2 should_work/NONREG/multiclock.lus
Opening file should_work/NONREG/multiclock.lus
node multiclock::moyenne(x:int; y:int) returns (m:int);
var
@@ -3981,7 +4003,7 @@ tel
-- end of node multiclock::multiclock
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/nc1.lus
+====> ../lus2lic -vl 2 should_work/NONREG/nc1.lus
Opening file should_work/NONREG/nc1.lus
node nc1::n1(n1e1:bool; n1e2:bool) returns (n1s:bool);
var
@@ -4003,7 +4025,7 @@ tel
-- end of node nc1::nc1
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/nc10.lus
+====> ../lus2lic -vl 2 should_work/NONREG/nc10.lus
Opening file should_work/NONREG/nc10.lus
node nc10::n4(
@@ -4064,7 +4086,7 @@ tel
-- end of node nc10::nc10
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/nc2.lus
+====> ../lus2lic -vl 2 should_work/NONREG/nc2.lus
Opening file should_work/NONREG/nc2.lus
node nc2::n1(n1e1:bool; n1e2:bool) returns (n1s:bool);
var
@@ -4092,7 +4114,7 @@ tel
-- end of node nc2::nc2
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/nc3.lus
+====> ../lus2lic -vl 2 should_work/NONREG/nc3.lus
Opening file should_work/NONREG/nc3.lus
node nc3::n1(n1e1:bool; n1e2:bool) returns (n1s:bool);
var
@@ -4126,7 +4148,7 @@ tel
-- end of node nc3::nc3
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/nc4.lus
+====> ../lus2lic -vl 2 should_work/NONREG/nc4.lus
Opening file should_work/NONREG/nc4.lus
node nc4::n1(n1e1:bool; n1e2:bool) returns (n1s:bool);
var
@@ -4170,7 +4192,7 @@ tel
-- end of node nc4::nc4
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/nc5.lus
+====> ../lus2lic -vl 2 should_work/NONREG/nc5.lus
Opening file should_work/NONREG/nc5.lus
node nc5::n4(n4e1:int) returns (n4s:int);
let
@@ -4204,7 +4226,7 @@ tel
-- end of node nc5::nc5
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/nc6.lus
+====> ../lus2lic -vl 2 should_work/NONREG/nc6.lus
Opening file should_work/NONREG/nc6.lus
node nc6::n4(n4e1:int) returns (n4s:int);
let
@@ -4247,7 +4269,7 @@ tel
-- end of node nc6::nc6
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/nc7.lus
+====> ../lus2lic -vl 2 should_work/NONREG/nc7.lus
Opening file should_work/NONREG/nc7.lus
node nc7::n4(
@@ -4296,7 +4318,7 @@ tel
-- end of node nc7::nc7
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/nc8.lus
+====> ../lus2lic -vl 2 should_work/NONREG/nc8.lus
Opening file should_work/NONREG/nc8.lus
node nc8::n4(n4e1:int; n4e2:int; n4e3:int; n4e4:int) returns (n4s:int);
var
@@ -4350,7 +4372,7 @@ tel
-- end of node nc8::nc8
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/nc9.lus
+====> ../lus2lic -vl 2 should_work/NONREG/nc9.lus
Opening file should_work/NONREG/nc9.lus
node nc9::n4(
@@ -4407,7 +4429,7 @@ tel
-- end of node nc9::nc9
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/nested.lus
+====> ../lus2lic -vl 2 should_work/NONREG/nested.lus
Opening file should_work/NONREG/nested.lus
node nested::incr(x:int) returns (y:int);
let
@@ -4434,7 +4456,7 @@ type A_A_int_3_5 = A_int_3^5;
type A_A_A_int_3_5_42 = A_A_int_3_5^42;
type A_int_3 = int^3;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/node_caller1.lus
+====> ../lus2lic -vl 2 should_work/NONREG/node_caller1.lus
Opening file should_work/NONREG/node_caller1.lus
node node_caller1::ex5(a:int) returns (b:int);
let
@@ -4480,7 +4502,7 @@ tel
-- end of node node_caller1::node_caller1
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/o2l_feux_compl.lus
+====> ../lus2lic -vl 2 should_work/NONREG/o2l_feux_compl.lus
Opening file should_work/NONREG/o2l_feux_compl.lus
node o2l_feux_compl::o2l_feux_compl(
@@ -7380,7 +7402,7 @@ tel
-- end of node o2l_feux_compl::o2l_feux_compl
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/packed_cst.lus
+====> ../lus2lic -vl 2 should_work/NONREG/packed_cst.lus
Opening file should_work/NONREG/packed_cst.lus
const cst::i = 1;
const cst::j = 1;
@@ -7403,7 +7425,7 @@ tel
-- end of node cst::cst
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/param_node.lus
+====> ../lus2lic -vl 2 should_work/NONREG/param_node.lus
Opening file should_work/NONREG/param_node.lus
node n_param_node::toto_n_Lustre::iplus_3(a:int) returns (x:A_int_3);
var
@@ -7421,7 +7443,7 @@ tel
-- automatically defined aliases:
type A_int_3 = int^3;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/param_node2.lus
+====> ../lus2lic -vl 2 should_work/NONREG/param_node2.lus
Opening file should_work/NONREG/param_node2.lus
node n_param_node2::mk_tab_int_0_3(a:int) returns (res:A_int_3);
let
@@ -7447,7 +7469,7 @@ tel
type A_bool_4 = bool^4;
type A_int_3 = int^3;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/param_node3.lus
+====> ../lus2lic -vl 2 should_work/NONREG/param_node3.lus
Opening file should_work/NONREG/param_node3.lus
node n_param_node3::mk_tab_int_0_3(a:int) returns (res:A_int_3);
let
@@ -7467,7 +7489,7 @@ tel
-- automatically defined aliases:
type A_int_3 = int^3;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/param_node4.lus
+====> ../lus2lic -vl 2 should_work/NONREG/param_node4.lus
Opening file should_work/NONREG/param_node4.lus
node param_node4::monplus(i1:int; i2:int) returns (o:int);
let
@@ -7494,7 +7516,7 @@ tel
-- automatically defined aliases:
type A_int_3 = int^3;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/param_struct.lus
+====> ../lus2lic -vl 2 should_work/NONREG/param_struct.lus
Opening file should_work/NONREG/param_struct.lus
type _param_struct::toto = struct {a : int; b : int};
const param_struct::c = _param_struct::toto{a = 1; b = 1};
@@ -7522,7 +7544,7 @@ tel
-- automatically defined aliases:
type A__param_struct::toto_3 = _param_struct::toto^3;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/patrick.lus
+====> ../lus2lic -vl 2 should_work/NONREG/patrick.lus
Opening file should_work/NONREG/patrick.lus
node patrick::patrick(a:int; b:int; c:bool; d:bool) returns (s:int);
var
@@ -7536,7 +7558,7 @@ tel
-- end of node patrick::patrick
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/poussoir.lus
+====> ../lus2lic -vl 2 should_work/NONREG/poussoir.lus
Opening file should_work/NONREG/poussoir.lus
node poussoir::TWO_STATES(
@@ -7588,7 +7610,7 @@ tel
-- end of node poussoir::poussoir
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/rs.lus
+====> ../lus2lic -vl 2 should_work/NONREG/rs.lus
Opening file should_work/NONREG/rs.lus
node rs::rs(r:bool; s:bool) returns (q:bool);
var
@@ -7620,7 +7642,7 @@ tel
-- end of node rs::rs
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/s.lus
+====> ../lus2lic -vl 2 should_work/NONREG/s.lus
Opening file should_work/NONREG/s.lus
node s::s(a:int; b:int) returns (t:int);
let
@@ -7630,7 +7652,7 @@ tel
-- end of node s::s
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/simple.lus
+====> ../lus2lic -vl 2 should_work/NONREG/simple.lus
Opening file should_work/NONREG/simple.lus
type _simple::S;
type _simple::T = int;
@@ -7659,7 +7681,7 @@ extern function simple::f1(x:int) returns (y:int);
extern function simple::f2(u:int; v:int) returns (s:int; t:bool);
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/sincos.lus
+====> ../lus2lic -vl 2 should_work/NONREG/sincos.lus
Opening file should_work/NONREG/sincos.lus
node sincos::integrator(F:real; STEP:real; init:real) returns (Y:real);
var
@@ -7694,7 +7716,7 @@ tel
-- end of node sincos::sincos
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/speedcontrol.lus
+====> ../lus2lic -vl 2 should_work/NONREG/speedcontrol.lus
Opening file should_work/NONREG/speedcontrol.lus
node speedcontrol::f(x:int) returns (y:int);
var
@@ -7716,7 +7738,7 @@ tel
-- end of node speedcontrol::speedcontrol
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/stopwatch.lus
+====> ../lus2lic -vl 2 should_work/NONREG/stopwatch.lus
Opening file should_work/NONREG/stopwatch.lus
node stopwatch::simple_stopwatch(
@@ -7802,7 +7824,7 @@ tel
-- end of node stopwatch::stopwatch
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/testCA.lus
+====> ../lus2lic -vl 2 should_work/NONREG/testCA.lus
Opening file should_work/NONREG/testCA.lus
node testCA::testCA(
@@ -7826,7 +7848,7 @@ tel
-- end of node testCA::testCA
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/test_clash.lus
+====> ../lus2lic -vl 2 should_work/NONREG/test_clash.lus
Opening file should_work/NONREG/test_clash.lus
type _test::t = bool;
const test::c = true;
@@ -7845,7 +7867,7 @@ tel
-- end of node test::toto
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/test_node_expand.lus
+====> ../lus2lic -vl 2 should_work/NONREG/test_node_expand.lus
Opening file should_work/NONREG/test_node_expand.lus
node test_node_expand::n(x:int; y:int) returns (a:int; b:int);
var
@@ -7865,7 +7887,7 @@ tel
-- end of node test_node_expand::test
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/test_node_expand2.lus
+====> ../lus2lic -vl 2 should_work/NONREG/test_node_expand2.lus
Opening file should_work/NONREG/test_node_expand2.lus
node test_node_expand2::f(i:int) returns (o:int);
let
@@ -7912,7 +7934,7 @@ tel
-- automatically defined aliases:
type A_int_2 = int^2;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/trivial.lus
+====> ../lus2lic -vl 2 should_work/NONREG/trivial.lus
Opening file should_work/NONREG/trivial.lus
node trivial::edge(x:bool) returns (e:bool);
var
@@ -7933,7 +7955,7 @@ tel
-- end of node trivial::trivial
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/trivial2.lus
+====> ../lus2lic -vl 2 should_work/NONREG/trivial2.lus
Opening file should_work/NONREG/trivial2.lus
node trivial2::edge(x:bool) returns (e:bool);
var
@@ -7957,7 +7979,7 @@ tel
-- end of node trivial2::trivial2
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/tuple.lus
+====> ../lus2lic -vl 2 should_work/NONREG/tuple.lus
Opening file should_work/NONREG/tuple.lus
node tuple::toto(x:int) returns (a:int; b:int; c:int);
let
@@ -7968,14 +7990,14 @@ tel
-- end of node tuple::toto
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/type_decl.lus
+====> ../lus2lic -vl 2 should_work/NONREG/type_decl.lus
Opening file should_work/NONREG/type_decl.lus
type _type_decl::alias = int;
type _type_decl::pair = struct {a : int; b : int};
type _type_decl::color = enum {type_decl::blue, type_decl::white, type_decl::black};
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/uu.lus
+====> ../lus2lic -vl 2 should_work/NONREG/uu.lus
Opening file should_work/NONREG/uu.lus
node uu::uu(x:bool; y:bool; z:bool) returns (a:bool);
var
@@ -8075,7 +8097,7 @@ tel
-- end of node uu::uu
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/NONREG/v1.lus
+====> ../lus2lic -vl 2 should_work/NONREG/v1.lus
Opening file should_work/NONREG/v1.lus
node v1::v1(m:int; b:bool) returns (n:int);
var
@@ -8087,7 +8109,7 @@ tel
-- end of node v1::v1
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/Pascal/consensus.lus
+====> ../lus2lic -vl 2 should_work/Pascal/consensus.lus
Opening file should_work/Pascal/consensus.lus
node n_consensus::consensus_1(T:A_bool_1) returns (a:bool);
var
@@ -8250,7 +8272,7 @@ type A_bool_6 = bool^6;
type A_bool_10 = bool^10;
type A_bool_3 = bool^3;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/Pascal/consensus2.lus
+====> ../lus2lic -vl 2 should_work/Pascal/consensus2.lus
Opening file should_work/Pascal/consensus2.lus
node n_consensus2::consensus_1(T:A_bool_1) returns (a:bool);
var
@@ -8373,7 +8395,7 @@ type A_bool_2 = bool^2;
type A_bool_6 = bool^6;
type A_bool_3 = bool^3;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/Pascal/fby.lus
+====> ../lus2lic -vl 2 should_work/Pascal/fby.lus
Opening file should_work/Pascal/fby.lus
node fby::rising_edge_bis(X:bool) returns (ok:bool);
var
@@ -8399,7 +8421,7 @@ tel
-- end of node fby::rising_edge
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/Pascal/func_with_body.lus
+====> ../lus2lic -vl 2 should_work/Pascal/func_with_body.lus
Opening file should_work/Pascal/func_with_body.lus
extern node func_with_body::ext(x:int) returns (y:int);
function func_with_body::trivial(x:int) returns (y:int);
@@ -8409,7 +8431,7 @@ tel
-- end of node func_with_body::trivial
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/Pascal/heater_control.lus
+====> ../lus2lic -vl 2 should_work/Pascal/heater_control.lus
Opening file should_work/Pascal/heater_control.lus
const heater_control::FAILURE = -999.0;
const heater_control::TMIN = 6.0;
@@ -8654,7 +8676,7 @@ tel
-- end of node heater_control::not_a_sauna
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/Pascal/left.lus
+====> ../lus2lic -vl 2 should_work/Pascal/left.lus
Opening file should_work/Pascal/left.lus
type _left::truc = struct {a : A_bool_100; b : int};
node left::toto(x:bool) returns (t:A__left::truc_3);
@@ -8677,7 +8699,7 @@ tel
type A__left::truc_3 = _left::truc^3;
type A_bool_100 = bool^100;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/Pascal/newpacks.lus
+====> ../lus2lic -vl 2 should_work/Pascal/newpacks.lus
Opening file should_work/Pascal/newpacks.lus
type _preal::t = real;
node preal::fby1(init:real; fb:real) returns (next:real);
@@ -8743,7 +8765,7 @@ tel
const inter::n = -4;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/Pascal/onlyroll.lus
+====> ../lus2lic -vl 2 should_work/Pascal/onlyroll.lus
Opening file should_work/Pascal/onlyroll.lus
const onlyroll::NRminP = -5.1;
const onlyroll::NRminR = -25.3;
@@ -9851,7 +9873,7 @@ tel
-- end of node onlyroll::InHardoverRange
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/Pascal/p.lus
+====> ../lus2lic -vl 2 should_work/Pascal/p.lus
Opening file should_work/Pascal/p.lus
type _preal::t = real;
node preal::fby1(init:real; fb:real) returns (next:real);
@@ -9917,7 +9939,7 @@ tel
const inter::n = -4;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/Pascal/packs.lus
+====> ../lus2lic -vl 2 should_work/Pascal/packs.lus
Opening file should_work/Pascal/packs.lus
type _preal::t = real;
node preal::fby1(init:real; fb:real) returns (next:real);
@@ -9988,14 +10010,14 @@ tel
type _inter::toto = enum {inter::X, inter::Y};
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/Pascal/pfs.lus
+====> ../lus2lic -vl 2 should_work/Pascal/pfs.lus
Opening file should_work/Pascal/pfs.lus
*** Error in file "should_work/Pascal/pfs.lus", line 43, col 22 to 22, token '[':
*** syntax error
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/Pascal/struct.lus
+====> ../lus2lic -vl 2 should_work/Pascal/struct.lus
Opening file should_work/Pascal/struct.lus
type _struct::complex = struct {re : real = 0.; im : real = 0.};
@@ -10023,7 +10045,7 @@ tel
-- end of node struct::plus
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/Pascal/struct0.lus
+====> ../lus2lic -vl 2 should_work/Pascal/struct0.lus
Opening file should_work/Pascal/struct0.lus
type _struct0::Toto = struct {x : int = 1; y : int = 2};
node struct0::bibi(dummy:int) returns (z:_struct0::Toto);
@@ -10033,7 +10055,7 @@ tel
-- end of node struct0::bibi
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/Pascal/t.lus
+====> ../lus2lic -vl 2 should_work/Pascal/t.lus
Opening file should_work/Pascal/t.lus
const t::A = [[1, 1], [1, 1], [1, 1]];
const t::B = [2, 2];
@@ -10054,7 +10076,7 @@ tel
type A_A_int_2_3 = A_int_2^3;
type A_int_2 = int^2;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/Pascal/t0.lus
+====> ../lus2lic -vl 2 should_work/Pascal/t0.lus
Opening file should_work/Pascal/t0.lus
node n_t0::min_n_1(T:A_int_1) returns (mn:int);
var
@@ -10131,7 +10153,7 @@ type A_int_3 = int^3;
type A_int_4 = int^4;
type A_int_1 = int^1;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/Pascal/t1.lus
+====> ../lus2lic -vl 2 should_work/Pascal/t1.lus
Opening file should_work/Pascal/t1.lus
node n_t1::consensus_1(T:A_bool_1) returns (a:bool);
var
@@ -10194,7 +10216,7 @@ type A_bool_4 = bool^4;
type A_bool_1 = bool^1;
type A_bool_2 = bool^2;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/Pascal/t2.lus
+====> ../lus2lic -vl 2 should_work/Pascal/t2.lus
Opening file should_work/Pascal/t2.lus
node n_t2::fold_left_bool_bool_1_Lustre::and(
@@ -10324,13 +10346,13 @@ type A_bool_1 = bool^1;
type A_bool_5 = bool^5;
type A_bool_2 = bool^2;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/Pascal/test.lus
+====> ../lus2lic -vl 2 should_work/Pascal/test.lus
Opening file should_work/Pascal/test.lus
const P1::y = 3;
type _P1::titi = int^5;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/Pascal/trivial.lus
+====> ../lus2lic -vl 2 should_work/Pascal/trivial.lus
Opening file should_work/Pascal/trivial.lus
node trivial::trivial(x:int) returns (y:int);
let
@@ -10339,7 +10361,7 @@ tel
-- end of node trivial::trivial
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/call/bad_call02.lus
+====> ../lus2lic -vl 2 should_work/call/bad_call02.lus
Opening file should_work/call/bad_call02.lus
node bad_call02::bad_call02(a:int; c:bool) returns (x:int when c);
let
@@ -10348,7 +10370,7 @@ tel
-- end of node bad_call02::bad_call02
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/call/call01.lus
+====> ../lus2lic -vl 2 should_work/call/call01.lus
Opening file should_work/call/call01.lus
node call01::toto(i1:bool; i2:bool) returns (o:bool);
let
@@ -10363,7 +10385,7 @@ tel
extern function call01::momo(x:bool; y:bool) returns (z:bool);
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/call/call02.lus
+====> ../lus2lic -vl 2 should_work/call/call02.lus
Opening file should_work/call/call02.lus
node call02::toto(i1:bool; i2:bool) returns (o:bool);
let
@@ -10382,7 +10404,7 @@ tel
-- end of node call02::call02
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/call/call03.lus
+====> ../lus2lic -vl 2 should_work/call/call03.lus
Opening file should_work/call/call03.lus
node call03::tutu(i1:A_bool_2; i2:A_bool_2) returns (o:A_bool_2);
let
@@ -10398,7 +10420,7 @@ extern function call03::momo(x:bool; y:bool) returns (z:bool);
-- automatically defined aliases:
type A_bool_2 = bool^2;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/call/call04.lus
+====> ../lus2lic -vl 2 should_work/call/call04.lus
Opening file should_work/call/call04.lus
node call04::toto(i1:bool; i2:bool) returns (o:bool);
let
@@ -10423,7 +10445,7 @@ tel
-- automatically defined aliases:
type A_bool_2 = bool^2;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/call/call05.lus
+====> ../lus2lic -vl 2 should_work/call/call05.lus
Opening file should_work/call/call05.lus
extern function call05::momo(x:bool; y:bool) returns (z:bool);
node call05::call05(x:bool; y:bool) returns (z:bool);
@@ -10433,7 +10455,7 @@ tel
-- end of node call05::call05
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/call/call06.lus
+====> ../lus2lic -vl 2 should_work/call/call06.lus
Opening file should_work/call/call06.lus
extern function call06::bip(x:bool; y:bool) returns (z:bool; t:bool);
node call06::call06(x:bool; y:bool) returns (z:bool; t:bool);
@@ -10444,7 +10466,7 @@ tel
-- end of node call06::call06
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/call/call07.lus
+====> ../lus2lic -vl 2 should_work/call/call07.lus
Opening file should_work/call/call07.lus
node call07::call07(x:bool; y:bool; z:bool) returns (t:bool);
let
@@ -10453,7 +10475,7 @@ tel
-- end of node call07::call07
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/clock/clock.lus
+====> ../lus2lic -vl 2 should_work/clock/clock.lus
Opening file should_work/clock/clock.lus
type _clock::s = struct {x : A_bool_10; y : bool};
@@ -10508,7 +10530,7 @@ returns (
-- automatically defined aliases:
type A_bool_10 = bool^10;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/clock/clock2.lus
+====> ../lus2lic -vl 2 should_work/clock/clock2.lus
Opening file should_work/clock/clock2.lus
node clock2::clock(a:bool; b:int) returns (c:int when a);
var
@@ -10522,7 +10544,7 @@ tel
-- end of node clock2::clock
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/clock/clock_ite.lus
+====> ../lus2lic -vl 2 should_work/clock/clock_ite.lus
Opening file should_work/clock/clock_ite.lus
node clock_ite::clock(a:bool; b:bool) returns (c:bool when a);
var
@@ -10540,7 +10562,7 @@ tel
-- end of node clock_ite::clock
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/clock/when_enum.lus
+====> ../lus2lic -vl 2 should_work/clock/when_enum.lus
Opening file should_work/clock/when_enum.lus
type _when_enum::t = enum {when_enum::A, when_enum::B, when_enum::C};
extern node when_enum::tutu(u:_when_enum::t) returns (x:bool);
@@ -10566,7 +10588,7 @@ tel
-- end of node when_enum::clock
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/clock/when_node.lus
+====> ../lus2lic -vl 2 should_work/clock/when_node.lus
Opening file should_work/clock/when_node.lus
extern node when_node::tutu(u:bool) returns (x:bool);
extern node when_node::toto(u:bool; v:bool) returns (x:bool; y:bool);
@@ -10578,7 +10600,7 @@ extern node when_node::toto(u:bool; v:bool) returns (x:bool; y:bool);
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/clock/when_not.lus
+====> ../lus2lic -vl 2 should_work/clock/when_not.lus
Opening file should_work/clock/when_not.lus
extern node when_not::clock4(
@@ -10595,7 +10617,7 @@ returns (
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/clock/when_tuple.lus
+====> ../lus2lic -vl 2 should_work/clock/when_tuple.lus
Opening file should_work/clock/when_tuple.lus
node when_tuple::titi(
@@ -10631,7 +10653,7 @@ tel
-- end of node when_tuple::clock
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/demo/Gyroscope2.lus
+====> ../lus2lic -vl 2 should_work/demo/Gyroscope2.lus
Opening file should_work/demo/Gyroscope2.lus
type _Gyroscope2::Valid_ChannelT = struct {local_failure : bool; local_value : real};
type _Gyroscope2::CFF_Eltstruct = struct {indx : int; indx_toChange : int; value : _Gyroscope2::Valid_ChannelT};
@@ -11288,7 +11310,7 @@ type A__Gyroscope2::Faulty_ChannelT_4 = _Gyroscope2::Faulty_ChannelT^4;
type A_A__Gyroscope2::Faulty_ChannelT_4_3 = A__Gyroscope2::Faulty_ChannelT_4^3;
type A_bool_3 = bool^3;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/demo/alias.lus
+====> ../lus2lic -vl 2 should_work/demo/alias.lus
Opening file should_work/demo/alias.lus
const alias::SIZE = 3;
node alias::aliasIterOp(i1:int; i2:A_int_3) returns (o:int);
@@ -11338,7 +11360,7 @@ tel
type A_bool_2 = bool^2;
type A_int_3 = int^3;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/demo/bred.lus
+====> ../lus2lic -vl 2 should_work/demo/bred.lus
Opening file should_work/demo/bred.lus
node bred::bred(a:A_bool_2) returns (x:bool);
let
@@ -11348,7 +11370,7 @@ tel
-- automatically defined aliases:
type A_bool_2 = bool^2;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/demo/bred_lv4.lus
+====> ../lus2lic -vl 2 should_work/demo/bred_lv4.lus
Opening file should_work/demo/bred_lv4.lus
type _bred_lv4::T1_ARRAY = bool^2;
node bred_lv4::bred(i_a:A_bool_2) returns (o_x:bool);
@@ -11359,7 +11381,7 @@ tel
-- automatically defined aliases:
type A_bool_2 = bool^2;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/demo/clock.lus
+====> ../lus2lic -vl 2 should_work/demo/clock.lus
Opening file should_work/demo/clock.lus
extern node clock::clock2(u:bool; v:bool when u) returns (y:bool);
extern node clock::clock3(u:bool) returns (x:bool; y:bool when x);
@@ -11391,7 +11413,7 @@ tel
-- end of node clock::clock
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/demo/clock1_2ms.lus
+====> ../lus2lic -vl 2 should_work/demo/clock1_2ms.lus
Opening file should_work/demo/clock1_2ms.lus
node clock1_2ms::Clock1ms_node(dummy:bool) returns (Clock1ms:bool);
var
@@ -11429,7 +11451,7 @@ tel
-- end of node clock1_2ms::clock1_2ms
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/demo/decl.lus
+====> ../lus2lic -vl 2 should_work/demo/decl.lus
Opening file should_work/demo/decl.lus
type _decl::t1;
type _decl::t2;
@@ -11473,7 +11495,7 @@ type A_A__decl::t1_8_5 = A__decl::t1_8^5;
type A__decl::t1_8 = _decl::t1^8;
type A_bool_2 = bool^2;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/demo/declaration.lus
+====> ../lus2lic -vl 2 should_work/demo/declaration.lus
Opening file should_work/demo/declaration.lus
type _declaration::t1;
type _declaration::t2;
@@ -11542,7 +11564,7 @@ type A_A__declaration::t1_8_5 = A__declaration::t1_8^5;
type A__declaration::t1_8 = _declaration::t1^8;
type A_bool_2 = bool^2;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/demo/def.lus
+====> ../lus2lic -vl 2 should_work/demo/def.lus
Opening file should_work/demo/def.lus
type _def::t1;
const def::a = 4;
@@ -11748,7 +11770,7 @@ type A_A_int_4_4 = A_int_4^4;
type A__def::structT_2 = _def::structT^2;
type A_int_4 = int^4;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/demo/filliter.lus
+====> ../lus2lic -vl 2 should_work/demo/filliter.lus
Opening file should_work/demo/filliter.lus
type _filliter::t = int^5;
const filliter::NBC = 3;
@@ -11786,7 +11808,7 @@ tel
type A_int_3 = int^3;
type A_int_4 = int^4;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/demo/filter.lus
+====> ../lus2lic -vl 2 should_work/demo/filter.lus
Opening file should_work/demo/filter.lus
type _filter::complexe = struct {x : real; y : real};
type _filter::cdouble = struct {x : _filter::complexe; y : _filter::complexe};
@@ -11819,7 +11841,7 @@ tel
-- end of node filter::filter
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/demo/lustre_test1_ok.lus
+====> ../lus2lic -vl 2 should_work/demo/lustre_test1_ok.lus
Opening file should_work/demo/lustre_test1_ok.lus
node lustre_test1_ok::rising(in:bool) returns (out:bool);
var
@@ -11940,7 +11962,7 @@ tel
-- end of node lustre_test1_ok::lustre_test1_ok
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/demo/map_red_iter.lus
+====> ../lus2lic -vl 2 should_work/demo/map_red_iter.lus
Opening file should_work/demo/map_red_iter.lus
const map_red_iter::NBC = 20;
type _map_red_iter::INTNBC = int^20;
@@ -11989,7 +12011,7 @@ type A_int_20 = int^20;
type A_bool_20 = bool^20;
type A_int_4 = int^4;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/demo/mapdeRed.lus
+====> ../lus2lic -vl 2 should_work/demo/mapdeRed.lus
Opening file should_work/demo/mapdeRed.lus
const mapdeRed::m = 3;
const mapdeRed::n = 2;
@@ -12032,7 +12054,7 @@ tel
type A_int_2 = int^2;
type A_A_int_2_3 = A_int_2^3;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/demo/mapinf.lus
+====> ../lus2lic -vl 2 should_work/demo/mapinf.lus
Opening file should_work/demo/mapinf.lus
node mapinf::mapinf(t1:A_int_10; t2:A_int_10) returns (res:A_bool_10);
let
@@ -12043,7 +12065,7 @@ tel
type A_int_10 = int^10;
type A_bool_10 = bool^10;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/demo/mapiter.lus
+====> ../lus2lic -vl 2 should_work/demo/mapiter.lus
Opening file should_work/demo/mapiter.lus
node mapiter::incr_tab(a:int) returns (b:int);
let
@@ -12064,7 +12086,7 @@ tel
type A_A_int_7_3 = A_int_7^3;
type A_int_7 = int^7;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/demo/mappredef.lus
+====> ../lus2lic -vl 2 should_work/demo/mappredef.lus
Opening file should_work/demo/mappredef.lus
const mappredef::N = 3;
type _mappredef::tab_int = int^3;
@@ -12095,7 +12117,7 @@ tel
type A_bool_3 = bool^3;
type A_int_3 = int^3;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/demo/plus.lus
+====> ../lus2lic -vl 2 should_work/demo/plus.lus
Opening file should_work/demo/plus.lus
node plus::plus(a:int; b:int) returns (c:int; d:int; e:int; f:int);
var
@@ -12131,7 +12153,7 @@ tel
-- automatically defined aliases:
type A_bool_2 = bool^2;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/demo/pre_x.lus
+====> ../lus2lic -vl 2 should_work/demo/pre_x.lus
Opening file should_work/demo/pre_x.lus
node pre_x::pre_x(a:int; b:int) returns (x:bool);
var
@@ -12155,7 +12177,7 @@ tel
-- end of node pre_x::pre_x
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/demo/rediter.lus
+====> ../lus2lic -vl 2 should_work/demo/rediter.lus
Opening file should_work/demo/rediter.lus
node rediter::max(init:int; a:int) returns (b:int);
var
@@ -12179,7 +12201,7 @@ tel
type A_A_int_5_3 = A_int_5^3;
type A_int_5 = int^5;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/demo/redoptest.lus
+====> ../lus2lic -vl 2 should_work/demo/redoptest.lus
Opening file should_work/demo/redoptest.lus
node redoptest::max(init:int; a:int) returns (b:int);
var
@@ -12203,7 +12225,7 @@ tel
type A_int_5 = int^5;
type A_A_int_5_3 = A_int_5^3;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/demo/sample_time_change.lus
+====> ../lus2lic -vl 2 should_work/demo/sample_time_change.lus
Opening file should_work/demo/sample_time_change.lus
node sample_time_change::make_cl1_4_2(in:bool) returns (out:bool);
var
@@ -12347,7 +12369,7 @@ tel
-- end of node sample_time_change::MainNode
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/fab_test/bob.lus
+====> ../lus2lic -vl 2 should_work/fab_test/bob.lus
Opening file should_work/fab_test/bob.lus
node bob::bob(i:bool) returns (o:bool when i);
var
@@ -12370,7 +12392,7 @@ tel
-- end of node bob::bob
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/fab_test/def.lus
+====> ../lus2lic -vl 2 should_work/fab_test/def.lus
Opening file should_work/fab_test/def.lus
node def::def(i:bool) returns (a:bool; b:bool);
let
@@ -12380,7 +12402,7 @@ tel
-- end of node def::def
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/fab_test/ex.lus
+====> ../lus2lic -vl 2 should_work/fab_test/ex.lus
Opening file should_work/fab_test/ex.lus
node ex::id(f:bool; a:bool) returns (g:bool);
let
@@ -12409,7 +12431,7 @@ tel
-- end of node ex::ex
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/fab_test/iter.lus
+====> ../lus2lic -vl 2 should_work/fab_test/iter.lus
Opening file should_work/fab_test/iter.lus
const iter::n = 5;
node iter::filled(accu_in:int) returns (accu_out:int; elt:int);
@@ -12465,7 +12487,7 @@ tel
-- automatically defined aliases:
type A_int_5 = int^5;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/fab_test/iterate.lus
+====> ../lus2lic -vl 2 should_work/fab_test/iterate.lus
Opening file should_work/fab_test/iterate.lus
node iterate::mapped(
@@ -12550,7 +12572,7 @@ tel
-- automatically defined aliases:
type A_int_10 = int^10;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/fab_test/lecteur.lus
+====> ../lus2lic -vl 2 should_work/fab_test/lecteur.lus
Opening file should_work/fab_test/lecteur.lus
node lecteur::Propriete(vitesse:int) returns (ok:bool);
var
@@ -12649,7 +12671,7 @@ tel
-- end of node lecteur::lecteur
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/fab_test/lucky.lus
+====> ../lus2lic -vl 2 should_work/fab_test/lucky.lus
Opening file should_work/fab_test/lucky.lus
node lucky::implies(X:bool; Y:bool) returns (XimpliesY:bool);
var
@@ -12759,7 +12781,7 @@ tel
-- end of node lucky::lucky
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/fab_test/morel.lus
+====> ../lus2lic -vl 2 should_work/fab_test/morel.lus
Opening file should_work/fab_test/morel.lus
type _morel::arrayb = bool^3;
type _morel::arrayi = A_int_2^3;
@@ -12820,15 +12842,15 @@ var
_v19:A_int_2;
_v20:A_int_2;
let
- b1 = _v1;
- b2 = _v2;
- b3 = _v3;
+ b1 = (_v1);
+ b2 = (_v2);
+ b3 = (_v3);
_v1 = tabb[0];
_v2 = tabb[1];
_v3 = tabb[2];
- i1 = _v8;
- i2 = _v13;
- i3 = _v18;
+ i1 = (_v8);
+ i2 = (_v13);
+ i3 = (_v18);
_v4 = tabi[0];
_v5 = _v4[0];
_v6 = tabi[0];
@@ -12872,7 +12894,7 @@ type A_bool_3 = bool^3;
type A_int_2 = int^2;
type A_A_int_2_3 = A_int_2^3;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/fab_test/morel2.lus
+====> ../lus2lic -vl 2 should_work/fab_test/morel2.lus
Opening file should_work/fab_test/morel2.lus
type _morel2::a2 = int^2;
type _morel2::a32 = A_int_2^3;
@@ -12936,15 +12958,15 @@ var
_v19:A_int_2;
_v20:A_int_2;
let
- b1 = _v1;
- b2 = _v2;
- b3 = _v3;
+ b1 = (_v1);
+ b2 = (_v2);
+ b3 = (_v3);
_v1 = tabb[0];
_v2 = tabb[1];
_v3 = tabb[2];
- i1 = _v8;
- i2 = _v13;
- i3 = _v18;
+ i1 = (_v8);
+ i2 = (_v13);
+ i3 = (_v18);
_v4 = tabi[0];
_v5 = _v4[0];
_v6 = tabi[0];
@@ -12974,7 +12996,7 @@ type A_bool_3 = bool^3;
type A_int_2 = int^2;
type A_A_int_2_3 = A_int_2^3;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/fab_test/morel3.lus
+====> ../lus2lic -vl 2 should_work/fab_test/morel3.lus
Opening file should_work/fab_test/morel3.lus
type _morel3::arrayb = bool^3;
type _morel3::arrayi = A_int_2^3;
@@ -13029,15 +13051,15 @@ var
_v19:A_int_2;
_v20:A_int_2;
let
- b1 = _v1;
- b2 = _v2;
- b3 = _v3;
+ b1 = (_v1);
+ b2 = (_v2);
+ b3 = (_v3);
_v1 = tabb[0];
_v2 = tabb[1];
_v3 = tabb[2];
- i1 = _v8;
- i2 = _v13;
- i3 = _v18;
+ i1 = (_v8);
+ i2 = (_v13);
+ i3 = (_v18);
_v4 = tabi[0];
_v5 = _v4[0];
_v6 = tabi[0];
@@ -13081,7 +13103,7 @@ type A_bool_3 = bool^3;
type A_int_2 = int^2;
type A_A_int_2_3 = A_int_2^3;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/fab_test/morel4.lus
+====> ../lus2lic -vl 2 should_work/fab_test/morel4.lus
Opening file should_work/fab_test/morel4.lus
type _morel4::tube = struct {in : int; out : int};
type _morel4::toto = struct {titi : _morel4::tube; tutu : bool};
@@ -13155,15 +13177,15 @@ var
_v19:A_int_2;
_v20:A_int_2;
let
- b1 = _v1;
- b2 = _v2;
- b3 = _v3;
+ b1 = (_v1);
+ b2 = (_v2);
+ b3 = (_v3);
_v1 = tabb[0];
_v2 = tabb[1];
_v3 = tabb[2];
- i1 = _v8;
- i2 = _v13;
- i3 = _v18;
+ i1 = (_v8);
+ i2 = (_v13);
+ i3 = (_v18);
_v4 = tabi[0];
_v5 = _v4[0];
_v6 = tabi[0];
@@ -13207,7 +13229,7 @@ type A_bool_3 = bool^3;
type A_int_2 = int^2;
type A_A_int_2_3 = A_int_2^3;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/fab_test/morel5.lus
+====> ../lus2lic -vl 2 should_work/fab_test/morel5.lus
Opening file should_work/fab_test/morel5.lus
type _morel5::tube = struct {in : int; out : int};
type _morel5::toto = struct {titi : _morel5::tube; tutu : bool};
@@ -13253,17 +13275,17 @@ var
_v25:int;
_v26:int;
let
- b1 = _v1;
- b2 = _v2;
- b3 = _v5;
+ b1 = (_v1);
+ b2 = (_v2);
+ b3 = (_v5);
_v1 = tabb[0];
_v2 = tabb[1];
_v3 = tabb[2];
_v4 = yo.tutu;
_v5 = _v3 or _v4;
- i1 = _v10;
- i2 = _v18;
- i3 = _v26;
+ i1 = (_v10);
+ i2 = (_v18);
+ i3 = (_v26);
_v6 = tabi[0];
_v7 = _v6[0];
_v8 = tabi[0];
@@ -13347,7 +13369,7 @@ type A_bool_3 = bool^3;
type A_int_2 = int^2;
type A_A_int_2_3 = A_int_2^3;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/fab_test/noAlarm.lus
+====> ../lus2lic -vl 2 should_work/fab_test/noAlarm.lus
Opening file should_work/fab_test/noAlarm.lus
node noAlarm::noAlarm(alarm:bool) returns (ok:bool);
let
@@ -13356,7 +13378,7 @@ tel
-- end of node noAlarm::noAlarm
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/fab_test/notTwo.lus
+====> ../lus2lic -vl 2 should_work/fab_test/notTwo.lus
Opening file should_work/fab_test/notTwo.lus
node notTwo::notTwo(a:bool; b:bool) returns (o:bool);
var
@@ -13368,7 +13390,7 @@ tel
-- end of node notTwo::notTwo
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/fab_test/onlyroll.lus
+====> ../lus2lic -vl 2 should_work/fab_test/onlyroll.lus
Opening file should_work/fab_test/onlyroll.lus
const onlyroll::NRminP = -5.1;
const onlyroll::NRminR = -25.3;
@@ -14482,7 +14504,7 @@ tel
-- end of node onlyroll::InHardoverRange
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/fab_test/onlyroll2.lus
+====> ../lus2lic -vl 2 should_work/fab_test/onlyroll2.lus
Opening file should_work/fab_test/onlyroll2.lus
const onlyroll2::NRminP = -5.1;
const onlyroll2::NRminR = -25.3;
@@ -15596,7 +15618,7 @@ tel
-- end of node onlyroll2::InHardoverRange
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/fab_test/test.lus
+====> ../lus2lic -vl 2 should_work/fab_test/test.lus
Opening file should_work/fab_test/test.lus
node test::three_outputs(
@@ -15647,17 +15669,17 @@ var
_v4:bool;
_v5:bool;
let
- b3 = _v3;
- b4 = _v4;
- b5 = _v5;
- b6 = false;
+ b3 = (_v3);
+ b4 = (_v4);
+ b5 = (_v5);
+ b6 = (false);
(_v1, _v2) = test::two_outputs(b1, b2);
(_v3, _v4, _v5) = test::three_outputs(_v1, _v2, true);
tel
-- end of node test::test
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/fab_test/titi.lus
+====> ../lus2lic -vl 2 should_work/fab_test/titi.lus
Opening file should_work/fab_test/titi.lus
node titi::titi(a:bool; b:bool) returns (x:bool);
var
@@ -15669,7 +15691,7 @@ tel
-- end of node titi::titi
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/fab_test/toolate.lus
+====> ../lus2lic -vl 2 should_work/fab_test/toolate.lus
Opening file should_work/fab_test/toolate.lus
type _toolate::tab1 = int^2;
type _toolate::tab2 = A_int_3^4;
@@ -15795,7 +15817,7 @@ type A_int_5 = int^5;
type A_int_3 = int^3;
type A_A_int_5_6 = A_int_5^6;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/fab_test/toto.lus
+====> ../lus2lic -vl 2 should_work/fab_test/toto.lus
Opening file should_work/fab_test/toto.lus
node toto::toto(a:bool; b:bool) returns (x:bool);
var
@@ -15813,7 +15835,7 @@ tel
-- end of node toto::toto
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/lionel/FillFollowedByRed.lus
+====> ../lus2lic -vl 2 should_work/lionel/FillFollowedByRed.lus
Opening file should_work/lionel/FillFollowedByRed.lus
node FillFollowedByRed::reduced(
@@ -15855,7 +15877,7 @@ tel
-- automatically defined aliases:
type A_real_10 = real^10;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/lionel/Gyroscope.lus
+====> ../lus2lic -vl 2 should_work/lionel/Gyroscope.lus
Opening file should_work/lionel/Gyroscope.lus
type _Gyroscope::Faulty_ChannelT = struct {valuea : real; valueb : real};
type _Gyroscope::Faulty_Array = A__Gyroscope::Faulty_ChannelT_4^3;
@@ -16305,7 +16327,7 @@ type A__Gyroscope::Faulty_ChannelT_4 = _Gyroscope::Faulty_ChannelT^4;
type A_real_3 = real^3;
type A__Gyroscope::Valid_ChannelT_4 = _Gyroscope::Valid_ChannelT^4;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/lionel/ProduitBool/produitBool.lus
+====> ../lus2lic -vl 2 should_work/lionel/ProduitBool/produitBool.lus
Opening file should_work/lionel/ProduitBool/produitBool.lus
const produitBool::size = 10;
type _produitBool::Tacc_in = struct {multiplieur : A_bool_10; rank : int};
@@ -16496,7 +16518,7 @@ type A_A_bool_20_10 = A_bool_20^10;
type A_bool_10 = bool^10;
type A_bool_20 = bool^20;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/lionel/ProduitBool/shiftFill_ludic.lus
+====> ../lus2lic -vl 2 should_work/lionel/ProduitBool/shiftFill_ludic.lus
Opening file should_work/lionel/ProduitBool/shiftFill_ludic.lus
type _shiftFill_ludic::T1_ARRAY = bool^10;
type _shiftFill_ludic::T4_STRUCT = struct {multiplieur : A_bool_10; rank : int};
@@ -16603,7 +16625,7 @@ tel
-- automatically defined aliases:
type A_bool_10 = bool^10;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/lionel/ProduitBool/shift_ludic.lus
+====> ../lus2lic -vl 2 should_work/lionel/ProduitBool/shift_ludic.lus
Opening file should_work/lionel/ProduitBool/shift_ludic.lus
type _shift_ludic::T1_ARRAY = bool^10;
type _shift_ludic::T4_STRUCT = struct {currentRank : int; rankToSelect : int; elementSelected : bool};
@@ -16729,7 +16751,7 @@ tel
type A_bool_20 = bool^20;
type A_bool_10 = bool^10;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/lionel/arrays.lus
+====> ../lus2lic -vl 2 should_work/lionel/arrays.lus
Opening file should_work/lionel/arrays.lus
const arrays::n = 4;
const arrays::m = 3;
@@ -16906,7 +16928,7 @@ type A_A_int_4_3 = A_int_4^3;
type A_A_A_int_4_3_2 = A_A_int_4_3^2;
type A_A_int_4_3 = A_int_4^3;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/lionel/calculs_max.lus
+====> ../lus2lic -vl 2 should_work/lionel/calculs_max.lus
Opening file should_work/lionel/calculs_max.lus
const calculs_max::taille = 10;
type _calculs_max::bool_arrays = bool^10;
@@ -17039,7 +17061,7 @@ tel
type A_int_10 = int^10;
type A_bool_10 = bool^10;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/lionel/deSimone.lus
+====> ../lus2lic -vl 2 should_work/lionel/deSimone.lus
Opening file should_work/lionel/deSimone.lus
const deSimone::size = 10;
type _deSimone::tabType = bool^10;
@@ -17119,7 +17141,7 @@ tel
-- automatically defined aliases:
type A_bool_10 = bool^10;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/lionel/iterFibo.lus
+====> ../lus2lic -vl 2 should_work/lionel/iterFibo.lus
Opening file should_work/lionel/iterFibo.lus
type _iterFibo::T_fibo = int^2;
node iterFibo::fibo(accu_in:A_int_2) returns (accu_out:A_int_2; elt:int);
@@ -17154,7 +17176,7 @@ tel
type A_int_10 = int^10;
type A_int_2 = int^2;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/lionel/mapiter.lus
+====> ../lus2lic -vl 2 should_work/lionel/mapiter.lus
Opening file should_work/lionel/mapiter.lus
const mapiter::L = 2;
type _mapiter::Reg_L = bool^2;
@@ -17241,7 +17263,7 @@ tel
type A_A_bool_2_3 = A_bool_2^3;
type A_bool_2 = bool^2;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/lionel/matrice.lus
+====> ../lus2lic -vl 2 should_work/lionel/matrice.lus
Opening file should_work/lionel/matrice.lus
type _matrice::T_fibo = int^2;
const matrice::m = 3;
@@ -17300,7 +17322,7 @@ type A_int_2 = int^2;
type A_A_int_3_2 = A_int_3^2;
type A_int_3 = int^3;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/lionel/matrice2.lus
+====> ../lus2lic -vl 2 should_work/lionel/matrice2.lus
Opening file should_work/lionel/matrice2.lus
const matrice2::m = 2;
const matrice2::n = 2;
@@ -17323,7 +17345,7 @@ tel
type A_A_int_2_2 = A_int_2^2;
type A_int_2 = int^2;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/lionel/minus.lus
+====> ../lus2lic -vl 2 should_work/lionel/minus.lus
Opening file should_work/lionel/minus.lus
const minus::m = 2;
const minus::n = 3;
@@ -17383,7 +17405,7 @@ tel
type A_A_bool_3_2 = A_bool_3^2;
type A_bool_3 = bool^3;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/lionel/moyenne.lus
+====> ../lus2lic -vl 2 should_work/lionel/moyenne.lus
Opening file should_work/lionel/moyenne.lus
type _moyenne::moyenne_accu = struct {sum : real; moyenne : real; rank : real};
const moyenne::size = 10;
@@ -17429,7 +17451,7 @@ tel
-- automatically defined aliases:
type A_real_10 = real^10;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/lionel/normal.lus
+====> ../lus2lic -vl 2 should_work/lionel/normal.lus
Opening file should_work/lionel/normal.lus
const normal::NBC = 20;
type _normal::INTNBC = int^20;
@@ -17809,7 +17831,7 @@ type A_A_bool_20_4 = A_bool_20^4;
type A_A_int_20_4 = A_int_20^4;
type A_int_20 = int^20;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/lionel/pipeline.lus
+====> ../lus2lic -vl 2 should_work/lionel/pipeline.lus
Opening file should_work/lionel/pipeline.lus
const pipeline::size = 10;
@@ -17843,7 +17865,7 @@ tel
-- automatically defined aliases:
type A_bool_10 = bool^10;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/lionel/predefOp.lus
+====> ../lus2lic -vl 2 should_work/lionel/predefOp.lus
Opening file should_work/lionel/predefOp.lus
const predefOp::L = 2;
type _predefOp::Reg_L = bool^2;
@@ -18017,7 +18039,7 @@ type A_A_bool_2_3 = A_bool_2^3;
type A_A_int_2_3 = A_int_2^3;
type A_bool_2 = bool^2;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/lionel/redIf.lus
+====> ../lus2lic -vl 2 should_work/lionel/redIf.lus
Opening file should_work/lionel/redIf.lus
node redIf::monIf(a:bool; b:bool; c:bool) returns (r:bool);
let
@@ -18032,7 +18054,7 @@ tel
-- automatically defined aliases:
type A_bool_3 = bool^3;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/lionel/simpleRed.lus
+====> ../lus2lic -vl 2 should_work/lionel/simpleRed.lus
Opening file should_work/lionel/simpleRed.lus
const simpleRed::m = 3;
const simpleRed::n = 2;
@@ -18047,7 +18069,7 @@ tel
-- automatically defined aliases:
type A_int_3 = int^3;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/lionel/testSilus.lus
+====> ../lus2lic -vl 2 should_work/lionel/testSilus.lus
Opening file should_work/lionel/testSilus.lus
const testSilus::NBC = 20;
type _testSilus::INTNBC = int^20;
@@ -18367,7 +18389,7 @@ type A_A_bool_20_4 = A_bool_20^4;
type A_A_int_20_4 = A_int_20^4;
type A_int_20 = int^20;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/lionel/triSel.lus
+====> ../lus2lic -vl 2 should_work/lionel/triSel.lus
Opening file should_work/lionel/triSel.lus
const triSel::size = 50;
type _triSel::tabSize = int^50;
@@ -18625,7 +18647,7 @@ tel
-- automatically defined aliases:
type A_int_50 = int^50;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/packEnvTest/Condact.lus
+====> ../lus2lic -vl 2 should_work/packEnvTest/Condact.lus
Opening file should_work/packEnvTest/Condact.lus
node Util::carre(e:int) returns (s:int);
let
@@ -18658,7 +18680,7 @@ tel
-- end of node Main::Condact
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/packEnvTest/complex.lus
+====> ../lus2lic -vl 2 should_work/packEnvTest/complex.lus
Opening file should_work/packEnvTest/complex.lus
type _complex::t = struct {re : real; im : real};
const complex::i = _complex::t{re = 0.; im = 1.};
@@ -18669,7 +18691,7 @@ tel
-- end of node complex::re
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/packEnvTest/contractForElementSelectionInArray/contractForElementSelectionInArray.lus
+====> ../lus2lic -vl 2 should_work/packEnvTest/contractForElementSelectionInArray/contractForElementSelectionInArray.lus
Opening file should_work/packEnvTest/contractForElementSelectionInArray/contractForElementSelectionInArray.lus
type _contractForElementSelectionInArray::elementType = int;
type _contractForElementSelectionInArray::iteratedStruct = struct {currentRank : int; rankToSelect : int; elementSelected : int};
@@ -18722,7 +18744,7 @@ tel
-- automatically defined aliases:
type A_int_10 = int^10;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/packEnvTest/contractForElementSelectionInArray/main.lus
+====> ../lus2lic -vl 2 should_work/packEnvTest/contractForElementSelectionInArray/main.lus
Opening file should_work/packEnvTest/contractForElementSelectionInArray/main.lus
Opening file should_work/packEnvTest/contractForElementSelectionInArray/packageTableau.lus
type _intArray::elementType = int;
@@ -19225,7 +19247,7 @@ tel
-- automatically defined aliases:
type A_int_10 = int^10;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/packEnvTest/contractForElementSelectionInArray/noeudsIndependants.lus
+====> ../lus2lic -vl 2 should_work/packEnvTest/contractForElementSelectionInArray/noeudsIndependants.lus
Opening file should_work/packEnvTest/contractForElementSelectionInArray/noeudsIndependants.lus
node noeudsIndependants::equals(a:int; b:int) returns (r:bool);
let
@@ -19239,12 +19261,12 @@ tel
-- end of node noeudsIndependants::gt
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/packEnvTest/contractForElementSelectionInArray/packageTableau.lus
+====> ../lus2lic -vl 2 should_work/packEnvTest/contractForElementSelectionInArray/packageTableau.lus
Opening file should_work/packEnvTest/contractForElementSelectionInArray/packageTableau.lus
Error. No package has been provided
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/packEnvTest/contractForElementSelectionInArray/tri.lus
+====> ../lus2lic -vl 2 should_work/packEnvTest/contractForElementSelectionInArray/tri.lus
Opening file should_work/packEnvTest/contractForElementSelectionInArray/tri.lus
const tri::size = 10;
type _tri::INTSIZE = int^10;
@@ -19486,7 +19508,7 @@ tel
-- automatically defined aliases:
type A_int_10 = int^10;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/packEnvTest/iter.lus
+====> ../lus2lic -vl 2 should_work/packEnvTest/iter.lus
Opening file should_work/packEnvTest/iter.lus
type _p::t = int;
const p::size = 3;
@@ -19508,7 +19530,7 @@ tel
-- automatically defined aliases:
type A_int_3 = int^3;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/packEnvTest/model.lus
+====> ../lus2lic -vl 2 should_work/packEnvTest/model.lus
Opening file should_work/packEnvTest/model.lus
type _pint::t = int;
node pint::fby1(init:int; fb:int) returns (next:int);
@@ -19521,7 +19543,7 @@ tel
-- end of node pint::fby1
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/packEnvTest/modelInst.lus
+====> ../lus2lic -vl 2 should_work/packEnvTest/modelInst.lus
Opening file should_work/packEnvTest/modelInst.lus
type _Pint::t = int;
node Pint::n(init:int; in:int) returns (ok:int);
@@ -19576,7 +19598,7 @@ tel
-- end of node main::main
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/packEnvTest/packages.lus
+====> ../lus2lic -vl 2 should_work/packEnvTest/packages.lus
Opening file should_work/packEnvTest/packages.lus
type _preal::t = real;
node preal::fby1(init:real; fb:real) returns (next:real);
@@ -19642,7 +19664,7 @@ tel
const inter::n = -4;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/packEnvTest/packages2.lus
+====> ../lus2lic -vl 2 should_work/packEnvTest/packages2.lus
Opening file should_work/packEnvTest/packages2.lus
type _preal::t = real;
node preal::fby1(init:real; fb:real) returns (next:real);
@@ -19706,7 +19728,7 @@ tel
-- end of node main::foo
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/packEnvTest/polymorphic_pack.lus
+====> ../lus2lic -vl 2 should_work/packEnvTest/polymorphic_pack.lus
Opening file should_work/packEnvTest/polymorphic_pack.lus
type _p::t = int;
const p::size = 3;
@@ -19723,7 +19745,7 @@ tel
-- automatically defined aliases:
type A_int_3 = int^3;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_work/to_sort_out/asservi.lus
+====> ../lus2lic -vl 2 should_work/to_sort_out/asservi.lus
Opening file should_work/to_sort_out/asservi.lus
type _asservi::pendule;
const asservi::G = 10.0;
@@ -19889,7 +19911,7 @@ Opening file do_not_exist.lus
do_not_exist.lus: No such file or directory
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_fail/clock/bad_call02.lus
+====> ../lus2lic -vl 2 should_fail/clock/bad_call02.lus
Opening file should_fail/clock/bad_call02.lus
*** Error in file "should_fail/clock/bad_call02.lus", line 6, col 4 to 4, token '=':
***
@@ -19899,7 +19921,7 @@ Opening file should_fail/clock/bad_call02.lus
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_fail/clock/bad_id.lus
+====> ../lus2lic -vl 2 should_fail/clock/bad_id.lus
Opening file should_fail/clock/bad_id.lus
*** Error in file "should_fail/clock/bad_id.lus", line 3, col 6 to 9, token 'toto':
***
@@ -19907,7 +19929,7 @@ Opening file should_fail/clock/bad_id.lus
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_fail/clock/clock.lus
+====> ../lus2lic -vl 2 should_fail/clock/clock.lus
Opening file should_fail/clock/clock.lus
extern node clock::clock2(u:bool; v:bool when u) returns (y:bool);
extern node clock::clock3(u:bool) returns (x:bool; y:bool when x);
@@ -19926,14 +19948,14 @@ returns (
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_fail/clock/clock2.lus
+====> ../lus2lic -vl 2 should_fail/clock/clock2.lus
Opening file should_fail/clock/clock2.lus
*** Error in file "should_fail/clock/clock2.lus", line 6, col 22 to 22, token 'a':
*** the type of a clock cannot be int
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_fail/clock/inonout.lus
+====> ../lus2lic -vl 2 should_fail/clock/inonout.lus
Opening file should_fail/clock/inonout.lus
*** Error in file "should_fail/clock/inonout.lus", line 3, col 46 to 46, token 'c':
***
@@ -19943,7 +19965,7 @@ Opening file should_fail/clock/inonout.lus
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_fail/clock/when_enum.lus
+====> ../lus2lic -vl 2 should_fail/clock/when_enum.lus
Opening file should_fail/clock/when_enum.lus
type _when_enum::t = enum {when_enum::A, when_enum::B, when_enum::C};
extern node when_enum::tutu(u:_when_enum::t) returns (x:bool);
@@ -19956,7 +19978,7 @@ extern node when_enum::toto(u:bool; v:bool) returns (x:bool; y:bool);
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_fail/semantics/activation1.lus
+====> ../lus2lic -vl 2 should_fail/semantics/activation1.lus
Opening file should_fail/semantics/activation1.lus
node activation1::up(in:int) returns (out:int);
var
@@ -20006,7 +20028,7 @@ tel
-- end of node activation1::activation1
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_fail/semantics/activation2.lus
+====> ../lus2lic -vl 2 should_fail/semantics/activation2.lus
Opening file should_fail/semantics/activation2.lus
node activation2::up(in:int) returns (out:int);
var
@@ -20058,7 +20080,7 @@ tel
-- end of node activation2::activation2
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_fail/semantics/bad_call01.lus
+====> ../lus2lic -vl 2 should_fail/semantics/bad_call01.lus
Opening file should_fail/semantics/bad_call01.lus
*** Error in file "should_fail/semantics/bad_call01.lus", line 2, col 13 to 16, token 'titi':
*** Recursion loop detected in node bad_call01::titi
@@ -20066,7 +20088,7 @@ Opening file should_fail/semantics/bad_call01.lus
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_fail/semantics/bug.lus
+====> ../lus2lic -vl 2 should_fail/semantics/bug.lus
Opening file should_fail/semantics/bug.lus
type _bug::tab1 = int^2;
type _bug::tab2 = A_int_3^4;
@@ -20223,21 +20245,21 @@ type A_int_5 = int^5;
type A_int_3 = int^3;
type A_A_int_5_6 = A_int_5^6;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_fail/semantics/const.lus
+====> ../lus2lic -vl 2 should_fail/semantics/const.lus
Opening file should_fail/semantics/const.lus
*** Error in file "should_fail/semantics/const.lus", line 19, col 42 to 43, token 'c4':
*** bad field declaration, ident already linked at line:19, col:10 to 11
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_fail/semantics/const2.lus
+====> ../lus2lic -vl 2 should_fail/semantics/const2.lus
Opening file should_fail/semantics/const2.lus
*** Error in file "should_fail/semantics/const2.lus", line 4, col 18 to 22, token 'false':
*** syntax error
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_fail/semantics/const3.lus
+====> ../lus2lic -vl 2 should_fail/semantics/const3.lus
Opening file should_fail/semantics/const3.lus
*** Error in file "should_fail/semantics/const3.lus", line 2, col 17 to 17, token '/':
***
@@ -20246,7 +20268,7 @@ Opening file should_fail/semantics/const3.lus
const const3::pi = 3.1416;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_fail/semantics/cpt_dc.lus
+====> ../lus2lic -vl 2 should_fail/semantics/cpt_dc.lus
Opening file should_fail/semantics/cpt_dc.lus
node cpt_dc::cpt_dc(evt:bool; reset:bool) returns (cpt:int);
var
@@ -20266,7 +20288,7 @@ tel
-- end of node cpt_dc::cpt_dc
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_fail/semantics/def.lus
+====> ../lus2lic -vl 2 should_fail/semantics/def.lus
Opening file should_fail/semantics/def.lus
type _def::int4 = int^4;
type _def::st = struct {x : A_int_4};
@@ -20303,28 +20325,28 @@ tel
-- automatically defined aliases:
type A_int_4 = int^4;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_fail/semantics/import2.lus
+====> ../lus2lic -vl 2 should_fail/semantics/import2.lus
Opening file should_fail/semantics/import2.lus
*** Error in file "should_fail/semantics/import2.lus", line 2, col 1 to 4, token 'node':
*** syntax error
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_fail/semantics/m.lus
+====> ../lus2lic -vl 2 should_fail/semantics/m.lus
Opening file should_fail/semantics/m.lus
*** Error in file "should_fail/semantics/m.lus", line 3, col 23 to 23, token ',':
*** syntax error
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_fail/semantics/not_a_constant.lus
+====> ../lus2lic -vl 2 should_fail/semantics/not_a_constant.lus
Opening file should_fail/semantics/not_a_constant.lus
*** Error in file "should_fail/semantics/not_a_constant.lus", line 10, col 23 to 24, token '--':
*** syntax error
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_fail/semantics/piege.lus
+====> ../lus2lic -vl 2 should_fail/semantics/piege.lus
Opening file should_fail/semantics/piege.lus
node piege::aux2(in1:bool; in2:bool) returns (out1:bool; out2:bool);
var
@@ -20358,7 +20380,7 @@ tel
-- end of node piege::piege
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_fail/semantics/tranche.lus
+====> ../lus2lic -vl 2 should_fail/semantics/tranche.lus
Opening file should_fail/semantics/tranche.lus
type _tranche::t2 = A_A_A_bool_7_8_9^10;
type _tranche::t = A_bool_3^4;
@@ -20370,7 +20392,7 @@ type _tranche::t = A_bool_3^4;
const tranche::n:A_A_bool_3_4;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_fail/semantics/x.lus
+====> ../lus2lic -vl 2 should_fail/semantics/x.lus
Opening file should_fail/semantics/x.lus
*** Error in file "should_fail/semantics/x.lus", line 4, col 7 to 7, token 'm':
*** Recursion loop detected:
@@ -20381,28 +20403,28 @@ Opening file should_fail/semantics/x.lus
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_fail/syntax/old_style_and_pack.lus
+====> ../lus2lic -vl 2 should_fail/syntax/old_style_and_pack.lus
Opening file should_fail/syntax/old_style_and_pack.lus
*** Error in file "should_fail/syntax/old_style_and_pack.lus", line 17, col 1 to 4, token 'node':
*** syntax error
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_fail/syntax/record.lus
+====> ../lus2lic -vl 2 should_fail/syntax/record.lus
Opening file should_fail/syntax/record.lus
*** Error in file "should_fail/syntax/record.lus", line 7, col 29 to 29, token '{':
*** syntax error
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_fail/type/Gyro.lus
+====> ../lus2lic -vl 2 should_fail/type/Gyro.lus
Opening file should_fail/type/Gyro.lus
*** Error in file "should_fail/type/Gyro.lus", line 11, col 42 to 42, token ',':
*** syntax error
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_fail/type/bad_call03.lus
+====> ../lus2lic -vl 2 should_fail/type/bad_call03.lus
Opening file should_fail/type/bad_call03.lus
node bad_call03::titi(c:A_real_3; d:A_real_3) returns (y:A_real_3);
let
@@ -20427,7 +20449,7 @@ tel
type A_int_3 = int^3;
type A_real_3 = real^3;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_fail/type/const2.lus
+====> ../lus2lic -vl 2 should_fail/type/const2.lus
Opening file should_fail/type/const2.lus
type _const2::t1 = int;
const const2::c1 = 2;
@@ -20454,28 +20476,28 @@ type _const2::t8 = A_A_A_A_A_A_int_3_7_8_9_3_8^8;
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_fail/type/parametric_node.lus
+====> ../lus2lic -vl 2 should_fail/type/parametric_node.lus
Opening file should_fail/type/parametric_node.lus
*** Error in file "should_fail/type/parametric_node.lus", line 3, col 60 to 62, token 'int':
*** Bad (static) type argument: 'real' and 'int' differs.
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_fail/type/parametric_node2.lus
+====> ../lus2lic -vl 2 should_fail/type/parametric_node2.lus
Opening file should_fail/type/parametric_node2.lus
*** Error in file "should_fail/type/parametric_node2.lus", line 12, col 23 to 35, token 'Lustre::iplus':
*** Bad (static) node argument: wrong output type profile.
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_fail/type/parametric_node3.lus
+====> ../lus2lic -vl 2 should_fail/type/parametric_node3.lus
Opening file should_fail/type/parametric_node3.lus
*** Error in file "should_fail/type/parametric_node3.lus", line 10, col 18 to 23, token 'toto_n':
*** Bad number of (static) arguments: 3 expected, and 2 provided.
----------------------------------------------------------------------
-====> ../lus2lic -vl 2 --compile-all-items should_fail/type/parametric_node4.lus
+====> ../lus2lic -vl 2 should_fail/type/parametric_node4.lus
Opening file should_fail/type/parametric_node4.lus
const parametric_node4::x = 3.0;
*** Error in file "should_fail/type/parametric_node4.lus", line 3, col 60 to 62, token 'int':
diff --git a/src/uniqueOutput.ml b/src/uniqueOutput.ml
index d8d1af2fac63e262aa754915dd5638b5c042289f..bb62da81e309b438d96f6fef2fb26461f7369f90 100644
--- a/src/uniqueOutput.ml
+++ b/src/uniqueOutput.ml
@@ -1,4 +1,4 @@
-(** Time-stamp: <modified the 29/08/2008 (at 10:42) by Erwan Jahier> *)
+(** Time-stamp: <modified the 26/01/2009 (at 16:48) by Erwan Jahier> *)
open Lxm
open Errors
@@ -7,7 +7,7 @@ open Eff
(*********************************************************************************)
(** [left_eff] is a kind of list, but which is in a « bad » order for
easy checking; [filtered_left] contains just the same information, but
- the list is made explicit and the infomartion (struct or array
+ the list is made explicit and the information (struct or array
accesses) is ordered in the « good » way.
*)
@@ -47,6 +47,8 @@ let rec (left_eff_to_filtered_left: Eff.left -> filtered_left) =
in
(v,lxm, List.rev f)
+
+
(*********************************************************************************)
(** Used to represent how much « defined » a variable is. *)
type var_def_state =
diff --git a/src/uniqueOutput.mli b/src/uniqueOutput.mli
index 88786202cd403b16f7307db5f5f57a9457461690..892ec391173e4b8a992bf2bf7ebe6e6a28aa3997 100644
--- a/src/uniqueOutput.mli
+++ b/src/uniqueOutput.mli
@@ -1,6 +1,6 @@
-(** Time-stamp: <modified the 28/08/2008 (at 15:52) by Erwan Jahier> *)
+(** Time-stamp: <modified the 29/01/2009 (at 11:05) by Erwan Jahier> *)
(** Check that each output and each local variable is defined at most
- and at least once. Also check that one does not try ti define an input. *)
+ and at least once. Also check that one does not try to define an input. *)
val check : Eff.node_exp -> Lxm.t -> unit