pas grand chose

ALIRE

@@ -23,7 +23,21 @@ En cours :
 
 ETAT COURANT
 
-19/07
+-----------------------------------------------------------
+12/07/09
+
+--> Les expressions de noeud qui s'avèrent polymorphes et/ou
+  surchargés, sont :
+  - acceptées dans les val_exp, à condition que l'utilisation
+    lève l'ambiguité
+  - refusées dans les "node alias"
+
+  = PLUS TARD : il faudrait que les noeuds qui s'avèrent polymorphes
+    et/ou surchargés soient traités comme de MACROS avec un STATIG ARG
+    de nature TYPE implicite
+
+-----------------------------------------------------------
+12/07/05
 
 - completement séparé la compil de l'affichage, du coup
   on a débranché l'ancien source_to_source

ALIRE.compil-des-nodes

+
+compile_all ->
+
+compile_all_nodes ->
+
+compile_all_item node_check_interface ->
+  node_check_interface:cache on ->
+
+node_check_interface_do
+
+node_check
+
+node_check_do
+

moretests/test.res.exp

@@ -54,20 +54,40 @@ where [options] can be:
 	 Display this message.
 
 ----------------------------------------------------------------------
-====> ../obj/lus2lic -vl 2 --nonreg-test should_work/aliases/alias.lus
---  ../obj/lus2lic -vl 2 --nonreg-test should_work/aliases/alias.lus
+====> ../objlinux/lus2lic -vl 2 --nonreg-test should_work/aliases/alias.lus
+--  ../objlinux/lus2lic -vl 2 --nonreg-test should_work/aliases/alias.lus
+type bool_4 = bool^4 (*abstract in the source*);
+type bool_4_5 = bool_4^5 (*abstract in the source*);
 type alias::a = int^42;
 type alias::bool_4;
 type alias::bool_4a;
 type alias::bool_4b;
-type alias::bool_4c = bool^4 (*abstract in the source*);
-type alias::bool_4c_5 = alias::bool_4c^5 (*abstract in the source*);
-type alias::str = struct  {foo : alias::t_42_9; bar : alias::bool_4c_5};
+type alias::str = struct  {foo : alias::t_42_9; bar : bool_4_5};
 type alias::t = enum {alias::Bleu, alias::Blanc};
-type alias::t1 = alias::bool_4c^5;
+type alias::t1 = bool_4^5;
 type alias::t_42 = alias::t^42 (*abstract in the source*);
 type alias::t_42_9 = alias::t_42^9 (*abstract in the source*);
 const alias::c2 : alias::t;
 const alias::huit = 9;
 const alias::toto = 42;
+
+----------------------------------------------------------------------
+====> ../objlinux/lus2lic -vl 2 --nonreg-test should_work/aliases/ex.lus
+--  ../objlinux/lus2lic -vl 2 --nonreg-test should_work/aliases/ex.lus
+type bool_11 = bool^11 (*abstract in the source*);
+type bool_11_22 = bool_11^22 (*abstract in the source*);
+type int_1 = int^1 (*abstract in the source*);
+type int_1_2 = int_1^2 (*abstract in the source*);
+type int_1_2_3 = int_1_2^3 (*abstract in the source*);
+type int_1_2_3_4 = int_1_2_3^4 (*abstract in the source*);
+type ex::s = struct  {x : int_1_2_3_4; y : ex::s1};
+type ex::s1 = struct  {x : int; y : int_1_2_3_4};
+type ex::t = int_1_2_3^4;
+type ex::t1 = int_1_2_3_4^4;
+type ex::t2 = struct  {a : int; b : bool_11_22};
+node ex::ex(a:ex::s) returns (b:int);
+let
+   b = a.x[0][0][0][0] + a.y.y[0][0][0][0];
+tel
+-- end of node ex::ex
 Those tests are supposed to generate errors

map2.lus → overload.lus

 
+
 node titi = map<<+,4>>;
 
 node toto(x,y: int^4) returns (o: int^4);
-let
-	(* o = map<<+, 4>>(x,y); *)
-	o = titi(x,y);
-tel
+let o = titi(x,y); tel
 
 node tutu(x,y: real^4) returns (o: real^4);
-let
-	o = titi(x,y);
-tel
+let o = titi(x,y); tel