OSDN > Buscar Software > Software Development > Compilers > JPL > SCM > SVN > Commit

JPL

R/O
SSH
HTTPS

jpl: Commit

Commit MetaInfo

Revisión	1075 (tree)
Tiempo	2021-01-19 07:21:42
Autor	jakobthomsen

Log Message

cleanup

Cambiar Resumen

modified: trunk/jpl_compiler_pragmatic/compiler.compiled.c (diff)
modified: trunk/jpl_compiler_pragmatic/compiler.source.c (diff)

Diferencia incremental

--- trunk/jpl_compiler_pragmatic/compiler.compiled.c (revision 1074)

+++ trunk/jpl_compiler_pragmatic/compiler.compiled.c (revision 1075)

		@@ -1196,15 +1196,13 @@
1196	1196	//#define arg0 1
1197	1197	//#define arg1 2
1198	1198	stack[base + 0]/found/ = 0;
1199		-//#define current 3
1200		- stack[base + 3/current/] = 0; // init
1201		- assign(stack[base + 1]/ids/, &stack[base + 4]/ids/);
	1199	+ assign(stack[base + 1]/ids/, &stack[base + 3]/ids/);
1202	1200	label = 13LLU; // start to repeat
1203	1201	break;
1204	1202	}
1205	1203	case 13LLU: // repeat from here
1206	1204	{
1207		- if(!stack[base + 4]/ids/)
	1205	+ if(!stack[base + 3]/ids/)
1208	1206	{
1209	1207	label = 14LLU; // break loop
1210	1208	break;

		@@ -1211,13 +1209,13 @@
1211	1209	}
1212	1210
1213	1211	// loop body
1214		-//#define current 5
1215		- stack[base + 5/current/] = 0; // init
1216		- stack[base + 5]/current/ = (uint64_t)(((const struct listnode )(stack[base + 4]/ids*/))->data);
1217		-//#define 6
1218		- stack[base + 6/**/] = 0; // init
1219		- stack[base + 6/previous/] = stack[base + 4]/ids/;
1220		- stack[base + 4]/ids/ = (uint64_t)(((const struct listnode )(stack[base + 4]/ids*/))->next);
	1212	+//#define current 4
	1213	+ stack[base + 4/current/] = 0; // init
	1214	+ stack[base + 4]/current/ = (uint64_t)(((const struct listnode )(stack[base + 3]/ids*/))->data);
	1215	+//#define 5
	1216	+ stack[base + 5/**/] = 0; // init
	1217	+ stack[base + 5/previous/] = stack[base + 3]/ids/;
	1218	+ stack[base + 3]/ids/ = (uint64_t)(((const struct listnode )(stack[base + 3]/ids*/))->next);
1221	1219	if(!stack[base + 0]/found/)
1222	1220	{
1223	1221	label = 15LLU; // jump to alternative

		@@ -1231,13 +1229,13 @@
1231	1229	case 15LLU: // alternative
1232	1230	{
1233	1231	// call equ from existsid
1234		- stack[base + 7LLU] = base;
1235		- stack[base + 8LLU] = 17LLU;
	1232	+ stack[base + 6LLU] = base;
	1233	+ stack[base + 7LLU] = 17LLU;
1236	1234	// arguments for call to equ
1237		- stack[base + 10LLU] = stack[base + 5]/current/;
1238		- stack[base + 11LLU] = stack[base + 2]/wanted/;
	1235	+ stack[base + 9LLU] = stack[base + 4]/current/;
	1236	+ stack[base + 10LLU] = stack[base + 2]/wanted/;
1239	1237	// set stack-base & callee-address
1240		- base += 9LLU;
	1238	+ base += 8LLU;
1241	1239	label = 18446744073709551600LLU; // equ
1242	1240	break;
1243	1241	}

		@@ -1245,13 +1243,13 @@
1245	1243	{
1246	1244	// copy mutable arguments back from call to equ
1247	1245	// copy back results provided by call to equ
1248		- stack[base + 0] = stack[base + 9LLU];
	1246	+ stack[base + 0] = stack[base + 8LLU];
1249	1247	label = 16LLU; // alternative complete
1250	1248	break;
1251	1249	}
1252	1250	case 16LLU: // completed if-then-else
1253	1251	{
1254		- ((struct listnode )(stack[base + 6/previous/]))->data = stack[base + 5]/current*/;
	1252	+ ((struct listnode )(stack[base + 5/previous/]))->data = stack[base + 4]/current*/;
1255	1253	label = 13LLU; // repeat
1256	1254	break;
1257	1255	}

		@@ -2717,15 +2715,13 @@
2717	2715	//#define arg0 1
2718	2716	//#define arg1 2
2719	2717	stack[base + 0]/found/ = 0;
2720		-//#define result 3
2721		- stack[base + 3/result/] = 0; // init
2722		- assign(stack[base + 1]/results/, &stack[base + 4]/results/);
	2718	+ assign(stack[base + 1]/results/, &stack[base + 3]/results/);
2723	2719	label = 131LLU; // start to repeat
2724	2720	break;
2725	2721	}
2726	2722	case 131LLU: // repeat from here
2727	2723	{
2728		- if(!stack[base + 4]/results/)
	2724	+ if(!stack[base + 3]/results/)
2729	2725	{
2730	2726	label = 132LLU; // break loop
2731	2727	break;

		@@ -2732,13 +2728,13 @@
2732	2728	}
2733	2729
2734	2730	// loop body
2735		-//#define result 5
2736		- stack[base + 5/result/] = 0; // init
2737		- stack[base + 5]/result/ = (uint64_t)(((const struct listnode )(stack[base + 4]/results*/))->data);
2738		-//#define 6
2739		- stack[base + 6/**/] = 0; // init
2740		- stack[base + 6/previous/] = stack[base + 4]/results/;
2741		- stack[base + 4]/results/ = (uint64_t)(((const struct listnode )(stack[base + 4]/results*/))->next);
	2731	+//#define result 4
	2732	+ stack[base + 4/result/] = 0; // init
	2733	+ stack[base + 4]/result/ = (uint64_t)(((const struct listnode )(stack[base + 3]/results*/))->data);
	2734	+//#define 5
	2735	+ stack[base + 5/**/] = 0; // init
	2736	+ stack[base + 5/previous/] = stack[base + 3]/results/;
	2737	+ stack[base + 3]/results/ = (uint64_t)(((const struct listnode )(stack[base + 3]/results*/))->next);
2742	2738	if(!stack[base + 0]/found/)
2743	2739	{
2744	2740	label = 133LLU; // jump to alternative

		@@ -2751,7 +2747,7 @@
2751	2747	}
2752	2748	case 133LLU: // alternative
2753	2749	{
2754		- if(/result/0 != ((uint64_t )(stack[base + 5]/result*/))[0])
	2750	+ if(/result/0 != ((uint64_t )(stack[base + 4]/result*/))[0])
2755	2751	{
2756	2752	label = 135LLU; // jump to alternative
2757	2753	break;

		@@ -2758,13 +2754,13 @@
2758	2754	}
2759	2755
2760	2756	// consequent
2761		-//#define typeid 7
2762		- stack[base + 7/typeid/] = 0; // init
2763		- stack[base + 7]/typeid/ = ((uint64_t *)(stack[base + 5]/result*/))[1][0];
2764		-//#define mutable 8
2765		- stack[base + 8/mutable/] = 0; // init
2766		- stack[base + 8]/mutable/ = ((uint64_t *)(stack[base + 5]/result*/))[1][1];
2767		- if(/typeid/0 != ((uint64_t )(stack[base + 7]/typeid*/))[0])
	2757	+//#define typeid 6
	2758	+ stack[base + 6/typeid/] = 0; // init
	2759	+ stack[base + 6]/typeid/ = ((uint64_t *)(stack[base + 4]/result*/))[1][0];
	2760	+//#define mutable 7
	2761	+ stack[base + 7/mutable/] = 0; // init
	2762	+ stack[base + 7]/mutable/ = ((uint64_t *)(stack[base + 4]/result*/))[1][1];
	2763	+ if(/typeid/0 != ((uint64_t )(stack[base + 6]/typeid*/))[0])
2768	2764	{
2769	2765	label = 137LLU; // jump to alternative
2770	2766	break;

		@@ -2771,20 +2767,20 @@
2771	2767	}
2772	2768
2773	2769	// consequent
2774		-//#define type 9
2775		- stack[base + 9/type/] = 0; // init
2776		- stack[base + 9]/type/ = ((uint64_t *)(stack[base + 7]/typeid*/))[1][0];
2777		-//#define id 10
2778		- stack[base + 10/id/] = 0; // init
2779		- stack[base + 10]/id/ = ((uint64_t *)(stack[base + 7]/typeid*/))[1][1];
	2770	+//#define type 8
	2771	+ stack[base + 8/type/] = 0; // init
	2772	+ stack[base + 8]/type/ = ((uint64_t *)(stack[base + 6]/typeid*/))[1][0];
	2773	+//#define id 9
	2774	+ stack[base + 9/id/] = 0; // init
	2775	+ stack[base + 9]/id/ = ((uint64_t *)(stack[base + 6]/typeid*/))[1][1];
2780	2776	// call equ from lookresult
2781		- stack[base + 11LLU] = base;
2782		- stack[base + 12LLU] = 139LLU;
	2777	+ stack[base + 10LLU] = base;
	2778	+ stack[base + 11LLU] = 139LLU;
2783	2779	// arguments for call to equ
2784		- stack[base + 14LLU] = stack[base + 10]/id/;
2785		- stack[base + 15LLU] = stack[base + 2]/wanted/;
	2780	+ stack[base + 13LLU] = stack[base + 9]/id/;
	2781	+ stack[base + 14LLU] = stack[base + 2]/wanted/;
2786	2782	// set stack-base & callee-address
2787		- base += 13LLU;
	2783	+ base += 12LLU;
2788	2784	label = 18446744073709551600LLU; // equ
2789	2785	break;
2790	2786	}

		@@ -2792,9 +2788,9 @@
2792	2788	{
2793	2789	// copy mutable arguments back from call to equ
2794	2790	// copy back results provided by call to equ
2795		- stack[base + 0] = stack[base + 13LLU];
2796		- ((uint64_t *)(stack[base + 7]/typeid/))[1][1] = stack[base + 10]/id*/;
2797		- ((uint64_t *)(stack[base + 7]/typeid/))[1][0] = stack[base + 9]/type*/;
	2791	+ stack[base + 0] = stack[base + 12LLU];
	2792	+ ((uint64_t *)(stack[base + 6]/typeid/))[1][1] = stack[base + 9]/id*/;
	2793	+ ((uint64_t *)(stack[base + 6]/typeid/))[1][0] = stack[base + 8]/type*/;
2798	2794	label = 138LLU; // consequent complete
2799	2795	break;
2800	2796	}

		@@ -2807,8 +2803,8 @@
2807	2803	}
2808	2804	case 138LLU: // completed if-then-else
2809	2805	{
2810		- ((uint64_t *)(stack[base + 5]/result/))[1][1] = stack[base + 8]/mutable*/;
2811		- ((uint64_t *)(stack[base + 5]/result/))[1][0] = stack[base + 7]/typeid*/;
	2806	+ ((uint64_t *)(stack[base + 4]/result/))[1][1] = stack[base + 7]/mutable*/;
	2807	+ ((uint64_t *)(stack[base + 4]/result/))[1][0] = stack[base + 6]/typeid*/;
2812	2808	label = 136LLU; // consequent complete
2813	2809	break;
2814	2810	}

		@@ -2826,7 +2822,7 @@
2826	2822	}
2827	2823	case 134LLU: // completed if-then-else
2828	2824	{
2829		- ((struct listnode )(stack[base + 6/previous/]))->data = stack[base + 5]/result*/;
	2825	+ ((struct listnode )(stack[base + 5/previous/]))->data = stack[base + 4]/result*/;
2830	2826	label = 131LLU; // repeat
2831	2827	break;
2832	2828	}

		@@ -3004,15 +3000,13 @@
3004	3000	//#define arg0 1
3005	3001	//#define arg1 2
3006	3002	stack[base + 0]/found/ = 0;
3007		-//#define param 3
3008		- stack[base + 3/param/] = 0; // init
3009		- assign(stack[base + 1]/params/, &stack[base + 4]/params/);
	3003	+ assign(stack[base + 1]/params/, &stack[base + 3]/params/);
3010	3004	label = 154LLU; // start to repeat
3011	3005	break;
3012	3006	}
3013	3007	case 154LLU: // repeat from here
3014	3008	{
3015		- if(!stack[base + 4]/params/)
	3009	+ if(!stack[base + 3]/params/)
3016	3010	{
3017	3011	label = 155LLU; // break loop
3018	3012	break;

		@@ -3019,13 +3013,13 @@
3019	3013	}
3020	3014
3021	3015	// loop body
3022		-//#define param 5
3023		- stack[base + 5/param/] = 0; // init
3024		- stack[base + 5]/param/ = (uint64_t)(((const struct listnode )(stack[base + 4]/params*/))->data);
3025		-//#define 6
3026		- stack[base + 6/**/] = 0; // init
3027		- stack[base + 6/previous/] = stack[base + 4]/params/;
3028		- stack[base + 4]/params/ = (uint64_t)(((const struct listnode )(stack[base + 4]/params*/))->next);
	3016	+//#define param 4
	3017	+ stack[base + 4/param/] = 0; // init
	3018	+ stack[base + 4]/param/ = (uint64_t)(((const struct listnode )(stack[base + 3]/params*/))->data);
	3019	+//#define 5
	3020	+ stack[base + 5/**/] = 0; // init
	3021	+ stack[base + 5/previous/] = stack[base + 3]/params/;
	3022	+ stack[base + 3]/params/ = (uint64_t)(((const struct listnode )(stack[base + 3]/params*/))->next);
3029	3023	if(!stack[base + 0]/found/)
3030	3024	{
3031	3025	label = 156LLU; // jump to alternative

		@@ -3038,7 +3032,7 @@
3038	3032	}
3039	3033	case 156LLU: // alternative
3040	3034	{
3041		- if(/param/0 != ((uint64_t )(stack[base + 5]/param*/))[0])
	3035	+ if(/param/0 != ((uint64_t )(stack[base + 4]/param*/))[0])
3042	3036	{
3043	3037	label = 158LLU; // jump to alternative
3044	3038	break;

		@@ -3045,13 +3039,13 @@
3045	3039	}
3046	3040
3047	3041	// consequent
3048		-//#define typeid 7
3049		- stack[base + 7/typeid/] = 0; // init
3050		- stack[base + 7]/typeid/ = ((uint64_t *)(stack[base + 5]/param*/))[1][0];
3051		-//#define mutable 8
3052		- stack[base + 8/mutable/] = 0; // init
3053		- stack[base + 8]/mutable/ = ((uint64_t *)(stack[base + 5]/param*/))[1][1];
3054		- if(/typeid/0 != ((uint64_t )(stack[base + 7]/typeid*/))[0])
	3042	+//#define typeid 6
	3043	+ stack[base + 6/typeid/] = 0; // init
	3044	+ stack[base + 6]/typeid/ = ((uint64_t *)(stack[base + 4]/param*/))[1][0];
	3045	+//#define mutable 7
	3046	+ stack[base + 7/mutable/] = 0; // init
	3047	+ stack[base + 7]/mutable/ = ((uint64_t *)(stack[base + 4]/param*/))[1][1];
	3048	+ if(/typeid/0 != ((uint64_t )(stack[base + 6]/typeid*/))[0])
3055	3049	{
3056	3050	label = 160LLU; // jump to alternative
3057	3051	break;

		@@ -3058,20 +3052,20 @@
3058	3052	}
3059	3053
3060	3054	// consequent
3061		-//#define type 9
3062		- stack[base + 9/type/] = 0; // init
3063		- stack[base + 9]/type/ = ((uint64_t *)(stack[base + 7]/typeid*/))[1][0];
3064		-//#define id 10
3065		- stack[base + 10/id/] = 0; // init
3066		- stack[base + 10]/id/ = ((uint64_t *)(stack[base + 7]/typeid*/))[1][1];
	3055	+//#define type 8
	3056	+ stack[base + 8/type/] = 0; // init
	3057	+ stack[base + 8]/type/ = ((uint64_t *)(stack[base + 6]/typeid*/))[1][0];
	3058	+//#define id 9
	3059	+ stack[base + 9/id/] = 0; // init
	3060	+ stack[base + 9]/id/ = ((uint64_t *)(stack[base + 6]/typeid*/))[1][1];
3067	3061	// call equ from lookparam
3068		- stack[base + 11LLU] = base;
3069		- stack[base + 12LLU] = 162LLU;
	3062	+ stack[base + 10LLU] = base;
	3063	+ stack[base + 11LLU] = 162LLU;
3070	3064	// arguments for call to equ
3071		- stack[base + 14LLU] = stack[base + 10]/id/;
3072		- stack[base + 15LLU] = stack[base + 2]/wanted/;
	3065	+ stack[base + 13LLU] = stack[base + 9]/id/;
	3066	+ stack[base + 14LLU] = stack[base + 2]/wanted/;
3073	3067	// set stack-base & callee-address
3074		- base += 13LLU;
	3068	+ base += 12LLU;
3075	3069	label = 18446744073709551600LLU; // equ
3076	3070	break;
3077	3071	}

		@@ -3079,9 +3073,9 @@
3079	3073	{
3080	3074	// copy mutable arguments back from call to equ
3081	3075	// copy back results provided by call to equ
3082		- stack[base + 0] = stack[base + 13LLU];
3083		- ((uint64_t *)(stack[base + 7]/typeid/))[1][1] = stack[base + 10]/id*/;
3084		- ((uint64_t *)(stack[base + 7]/typeid/))[1][0] = stack[base + 9]/type*/;
	3076	+ stack[base + 0] = stack[base + 12LLU];
	3077	+ ((uint64_t *)(stack[base + 6]/typeid/))[1][1] = stack[base + 9]/id*/;
	3078	+ ((uint64_t *)(stack[base + 6]/typeid/))[1][0] = stack[base + 8]/type*/;
3085	3079	label = 161LLU; // consequent complete
3086	3080	break;
3087	3081	}

		@@ -3094,8 +3088,8 @@
3094	3088	}
3095	3089	case 161LLU: // completed if-then-else
3096	3090	{
3097		- ((uint64_t *)(stack[base + 5]/param/))[1][1] = stack[base + 8]/mutable*/;
3098		- ((uint64_t *)(stack[base + 5]/param/))[1][0] = stack[base + 7]/typeid*/;
	3091	+ ((uint64_t *)(stack[base + 4]/param/))[1][1] = stack[base + 7]/mutable*/;
	3092	+ ((uint64_t *)(stack[base + 4]/param/))[1][0] = stack[base + 6]/typeid*/;
3099	3093	label = 159LLU; // consequent complete
3100	3094	break;
3101	3095	}

		@@ -3113,7 +3107,7 @@
3113	3107	}
3114	3108	case 157LLU: // completed if-then-else
3115	3109	{
3116		- ((struct listnode )(stack[base + 6/previous/]))->data = stack[base + 5]/param*/;
	3110	+ ((struct listnode )(stack[base + 5/previous/]))->data = stack[base + 4]/param*/;
3117	3111	label = 154LLU; // repeat
3118	3112	break;
3119	3113	}

		@@ -4465,15 +4459,13 @@
4465	4459	//#define arg0 1
4466	4460	//#define arg1 2
4467	4461	stack[base + 0]/found/ = 0;
4468		-//#define idnr 3
4469		- stack[base + 3/idnr/] = 0; // init
4470		- assign(stack[base + 1]/idnrs/, &stack[base + 4]/idnrs/);
	4462	+ assign(stack[base + 1]/idnrs/, &stack[base + 3]/idnrs/);
4471	4463	label = 253LLU; // start to repeat
4472	4464	break;
4473	4465	}
4474	4466	case 253LLU: // repeat from here
4475	4467	{
4476		- if(!stack[base + 4]/idnrs/)
	4468	+ if(!stack[base + 3]/idnrs/)
4477	4469	{
4478	4470	label = 254LLU; // break loop
4479	4471	break;

		@@ -4480,13 +4472,13 @@
4480	4472	}
4481	4473
4482	4474	// loop body
4483		-//#define idnr 5
4484		- stack[base + 5/idnr/] = 0; // init
4485		- stack[base + 5]/idnr/ = (uint64_t)(((const struct listnode )(stack[base + 4]/idnrs*/))->data);
4486		-//#define 6
4487		- stack[base + 6/**/] = 0; // init
4488		- stack[base + 6/previous/] = stack[base + 4]/idnrs/;
4489		- stack[base + 4]/idnrs/ = (uint64_t)(((const struct listnode )(stack[base + 4]/idnrs*/))->next);
	4475	+//#define idnr 4
	4476	+ stack[base + 4/idnr/] = 0; // init
	4477	+ stack[base + 4]/idnr/ = (uint64_t)(((const struct listnode )(stack[base + 3]/idnrs*/))->data);
	4478	+//#define 5
	4479	+ stack[base + 5/**/] = 0; // init
	4480	+ stack[base + 5/previous/] = stack[base + 3]/idnrs/;
	4481	+ stack[base + 3]/idnrs/ = (uint64_t)(((const struct listnode )(stack[base + 3]/idnrs*/))->next);
4490	4482	if(!stack[base + 0]/found/)
4491	4483	{
4492	4484	label = 255LLU; // jump to alternative

		@@ -4499,7 +4491,7 @@
4499	4491	}
4500	4492	case 255LLU: // alternative
4501	4493	{
4502		- if(/idnr/0 != ((uint64_t )(stack[base + 5]/idnr*/))[0])
	4494	+ if(/idnr/0 != ((uint64_t )(stack[base + 4]/idnr*/))[0])
4503	4495	{
4504	4496	label = 257LLU; // jump to alternative
4505	4497	break;

		@@ -4506,20 +4498,20 @@
4506	4498	}
4507	4499
4508	4500	// consequent
4509		-//#define id 7
4510		- stack[base + 7/id/] = 0; // init
4511		- stack[base + 7]/id/ = ((uint64_t *)(stack[base + 5]/idnr*/))[1][0];
4512		-//#define nr 8
4513		- stack[base + 8/nr/] = 0; // init
4514		- stack[base + 8]/nr/ = ((uint64_t *)(stack[base + 5]/idnr*/))[1][1];
	4501	+//#define id 6
	4502	+ stack[base + 6/id/] = 0; // init
	4503	+ stack[base + 6]/id/ = ((uint64_t *)(stack[base + 4]/idnr*/))[1][0];
	4504	+//#define nr 7
	4505	+ stack[base + 7/nr/] = 0; // init
	4506	+ stack[base + 7]/nr/ = ((uint64_t *)(stack[base + 4]/idnr*/))[1][1];
4515	4507	// call equ from lookidnr
4516		- stack[base + 9LLU] = base;
4517		- stack[base + 10LLU] = 259LLU;
	4508	+ stack[base + 8LLU] = base;
	4509	+ stack[base + 9LLU] = 259LLU;
4518	4510	// arguments for call to equ
4519		- stack[base + 12LLU] = stack[base + 7]/id/;
4520		- stack[base + 13LLU] = stack[base + 2]/wanted/;
	4511	+ stack[base + 11LLU] = stack[base + 6]/id/;
	4512	+ stack[base + 12LLU] = stack[base + 2]/wanted/;
4521	4513	// set stack-base & callee-address
4522		- base += 11LLU;
	4514	+ base += 10LLU;
4523	4515	label = 18446744073709551600LLU; // equ
4524	4516	break;
4525	4517	}

		@@ -4527,9 +4519,9 @@
4527	4519	{
4528	4520	// copy mutable arguments back from call to equ
4529	4521	// copy back results provided by call to equ
4530		- stack[base + 0] = stack[base + 11LLU];
4531		- ((uint64_t *)(stack[base + 5]/idnr/))[1][1] = stack[base + 8]/nr*/;
4532		- ((uint64_t *)(stack[base + 5]/idnr/))[1][0] = stack[base + 7]/id*/;
	4522	+ stack[base + 0] = stack[base + 10LLU];
	4523	+ ((uint64_t *)(stack[base + 4]/idnr/))[1][1] = stack[base + 7]/nr*/;
	4524	+ ((uint64_t *)(stack[base + 4]/idnr/))[1][0] = stack[base + 6]/id*/;
4533	4525	label = 258LLU; // consequent complete
4534	4526	break;
4535	4527	}

		@@ -4547,7 +4539,7 @@
4547	4539	}
4548	4540	case 256LLU: // completed if-then-else
4549	4541	{
4550		- ((struct listnode )(stack[base + 6/previous/]))->data = stack[base + 5]/idnr*/;
	4542	+ ((struct listnode )(stack[base + 5/previous/]))->data = stack[base + 4]/idnr*/;
4551	4543	label = 253LLU; // repeat
4552	4544	break;
4553	4545	}

		@@ -11657,15 +11649,13 @@
11657	11649	//#define cerec 24
11658	11650	stack[base + 24/cerec/] = 0; // init
11659	11651	stack[base + 24]/cerec/ = ((uint64_t *)(stack[base + 16]/calleedef*/))[1][5];
11660		-//#define result 25
11661		- stack[base + 25/result/] = 0; // init
11662		- assign(stack[base + 20]/cerestypes/, &stack[base + 26]/cerestypes/);
	11652	+ assign(stack[base + 20]/cerestypes/, &stack[base + 25]/cerestypes/);
11663	11653	label = 752LLU; // start to repeat
11664	11654	break;
11665	11655	}
11666	11656	case 752LLU: // repeat from here
11667	11657	{
11668		- if(!stack[base + 26]/cerestypes/)
	11658	+ if(!stack[base + 25]/cerestypes/)
11669	11659	{
11670	11660	label = 753LLU; // break loop
11671	11661	break;

		@@ -11672,15 +11662,15 @@
11672	11662	}
11673	11663
11674	11664	// loop body
11675		-//#define result 27
11676		- stack[base + 27/result/] = 0; // init
11677		- stack[base + 27]/result/ = (uint64_t)(((const struct listnode )(stack[base + 26]/cerestypes*/))->data);
11678		-//#define 28
11679		- stack[base + 28/**/] = 0; // init
11680		- stack[base + 28/previous/] = stack[base + 26]/cerestypes/;
11681		- stack[base + 26]/cerestypes/ = (uint64_t)(((const struct listnode )(stack[base + 26]/cerestypes*/))->next);
11682		-//#define RESULT 29
11683		- stack[base + 29/RESULT/] = 0; // init
	11665	+//#define result 26
	11666	+ stack[base + 26/result/] = 0; // init
	11667	+ stack[base + 26]/result/ = (uint64_t)(((const struct listnode )(stack[base + 25]/cerestypes*/))->data);
	11668	+//#define 27
	11669	+ stack[base + 27/**/] = 0; // init
	11670	+ stack[base + 27/previous/] = stack[base + 25]/cerestypes/;
	11671	+ stack[base + 25]/cerestypes/ = (uint64_t)(((const struct listnode )(stack[base + 25]/cerestypes*/))->next);
	11672	+//#define RESULT 28
	11673	+ stack[base + 28/RESULT/] = 0; // init
11684	11674	{ // if pop
11685	11675	struct listnode list = (struct listnode )stack[base + 17]/results/;
11686	11676	if(!list)

		@@ -11691,7 +11681,7 @@
11691	11681
11692	11682	// consequent
11693	11683	struct listnode *next = list->next;
11694		- stack[base + 29]/RESULT/ = list->data;
	11684	+ stack[base + 28]/RESULT/ = list->data;
11695	11685	Free(1, sizeof(struct listnode), list);
11696	11686	stack[base + 17]/results/ = (uint64_t)next;
11697	11687	}

		@@ -11702,12 +11692,12 @@
11702	11692	{
11703	11693	fprintf(stderr, "%s", "in function ");
11704	11694	// call reportid from PROCCALL
11705		- stack[base + 30LLU] = base;
11706		- stack[base + 31LLU] = 756LLU;
	11695	+ stack[base + 29LLU] = base;
	11696	+ stack[base + 30LLU] = 756LLU;
11707	11697	// arguments for call to reportid
11708		- stack[base + 32LLU] = stack[base + 5]/fnid/;
	11698	+ stack[base + 31LLU] = stack[base + 5]/fnid/;
11709	11699	// set stack-base & callee-address
11710		- base += 32LLU;
	11700	+ base += 31LLU;
11711	11701	label = 18446744073709551587LLU; // reportid
11712	11702	break;
11713	11703	}

		@@ -11716,12 +11706,12 @@
11716	11706	// copy mutable arguments back from call to reportid
11717	11707	fprintf(stderr, "%s", " call to ");
11718	11708	// call reportid from PROCCALL
11719		- stack[base + 30LLU] = base;
11720		- stack[base + 31LLU] = 757LLU;
	11709	+ stack[base + 29LLU] = base;
	11710	+ stack[base + 30LLU] = 757LLU;
11721	11711	// arguments for call to reportid
11722		- stack[base + 32LLU] = stack[base + 23]/ceid/;
	11712	+ stack[base + 31LLU] = stack[base + 23]/ceid/;
11723	11713	// set stack-base & callee-address
11724		- base += 32LLU;
	11714	+ base += 31LLU;
11725	11715	label = 18446744073709551587LLU; // reportid
11726	11716	break;
11727	11717	}

		@@ -11736,7 +11726,7 @@
11736	11726	}
11737	11727	case 755LLU: // completed if-then-else
11738	11728	{
11739		- if(/result/0 != ((uint64_t )(stack[base + 27]/result*/))[0])
	11729	+ if(/result/0 != ((uint64_t )(stack[base + 26]/result*/))[0])
11740	11730	{
11741	11731	label = 758LLU; // jump to alternative
11742	11732	break;

		@@ -11743,13 +11733,13 @@
11743	11733	}
11744	11734
11745	11735	// consequent
11746		-//#define typeid 30
11747		- stack[base + 30/typeid/] = 0; // init
11748		- stack[base + 30]/typeid/ = ((uint64_t *)(stack[base + 27]/result*/))[1][0];
11749		-//#define mutable 31
11750		- stack[base + 31/mutable/] = 0; // init
11751		- stack[base + 31]/mutable/ = ((uint64_t *)(stack[base + 27]/result*/))[1][1];
11752		- if(/typeid/0 != ((uint64_t )(stack[base + 30]/typeid*/))[0])
	11736	+//#define typeid 29
	11737	+ stack[base + 29/typeid/] = 0; // init
	11738	+ stack[base + 29]/typeid/ = ((uint64_t *)(stack[base + 26]/result*/))[1][0];
	11739	+//#define mutable 30
	11740	+ stack[base + 30/mutable/] = 0; // init
	11741	+ stack[base + 30]/mutable/ = ((uint64_t *)(stack[base + 26]/result*/))[1][1];
	11742	+ if(/typeid/0 != ((uint64_t )(stack[base + 29]/typeid*/))[0])
11753	11743	{
11754	11744	label = 760LLU; // jump to alternative
11755	11745	break;

		@@ -11756,13 +11746,13 @@
11756	11746	}
11757	11747
11758	11748	// consequent
11759		-//#define expected 32
11760		- stack[base + 32/expected/] = 0; // init
11761		- stack[base + 32]/expected/ = ((uint64_t *)(stack[base + 30]/typeid*/))[1][0];
11762		-//#define paramname 33
11763		- stack[base + 33/paramname/] = 0; // init
11764		- stack[base + 33]/paramname/ = ((uint64_t *)(stack[base + 30]/typeid*/))[1][1];
11765		- if(/letdef/0 != ((uint64_t )(stack[base + 29]/RESULT*/))[0])
	11749	+//#define expected 31
	11750	+ stack[base + 31/expected/] = 0; // init
	11751	+ stack[base + 31]/expected/ = ((uint64_t *)(stack[base + 29]/typeid*/))[1][0];
	11752	+//#define paramname 32
	11753	+ stack[base + 32/paramname/] = 0; // init
	11754	+ stack[base + 32]/paramname/ = ((uint64_t *)(stack[base + 29]/typeid*/))[1][1];
	11755	+ if(/letdef/0 != ((uint64_t )(stack[base + 28]/RESULT*/))[0])
11766	11756	{
11767	11757	label = 762LLU; // jump to alternative
11768	11758	break;

		@@ -11769,18 +11759,18 @@
11769	11759	}
11770	11760
11771	11761	// consequent
11772		-//#define type 34
11773		- stack[base + 34/type/] = 0; // init
11774		- stack[base + 34]/type/ = ((uint64_t *)(stack[base + 29]/RESULT*/))[1][0];
11775		-//#define id 35
11776		- stack[base + 35/id/] = 0; // init
11777		- stack[base + 35]/id/ = ((uint64_t *)(stack[base + 29]/RESULT*/))[1][1];
11778		-//#define INDEX 36
11779		- stack[base + 36/INDEX/] = 0; // init
11780		- stack[base + 36]/INDEX/ = ((uint64_t *)(stack[base + 29]/RESULT*/))[1][2];
11781		-//#define mutres 37
11782		- stack[base + 37/mutres/] = 0; // init
11783		- stack[base + 37]/mutres/ = ((uint64_t *)(stack[base + 29]/RESULT*/))[1][3];
	11762	+//#define type 33
	11763	+ stack[base + 33/type/] = 0; // init
	11764	+ stack[base + 33]/type/ = ((uint64_t *)(stack[base + 28]/RESULT*/))[1][0];
	11765	+//#define id 34
	11766	+ stack[base + 34/id/] = 0; // init
	11767	+ stack[base + 34]/id/ = ((uint64_t *)(stack[base + 28]/RESULT*/))[1][1];
	11768	+//#define INDEX 35
	11769	+ stack[base + 35/INDEX/] = 0; // init
	11770	+ stack[base + 35]/INDEX/ = ((uint64_t *)(stack[base + 28]/RESULT*/))[1][2];
	11771	+//#define mutres 36
	11772	+ stack[base + 36/mutres/] = 0; // init
	11773	+ stack[base + 36]/mutres/ = ((uint64_t *)(stack[base + 28]/RESULT*/))[1][3];
11784	11774	uint64_t newstack = (uint64_t )Calloc(13LLU + 1, sizeof(uint64_t));
11785	11775	newstack[13LLU] = 9876543210LLU; // overflow-marker
11786	11776	// call equtype from PROCCALL

		@@ -11788,8 +11778,8 @@
11788	11778	newstack[1] = base;
11789	11779	newstack[2] = 764LLU;
11790	11780	// arguments for call to equtype
11791		- newstack[4LLU] = stack[base + 34]/type/;
11792		- newstack[5LLU] = stack[base + 32]/expected/;
	11781	+ newstack[4LLU] = stack[base + 33]/type/;
	11782	+ newstack[5LLU] = stack[base + 31]/expected/;
11793	11783	stack = newstack;
11794	11784	// set stack-base & callee-address
11795	11785	base = 3;

		@@ -11823,12 +11813,12 @@
11823	11813	{
11824	11814	fprintf(stderr, "%s", "in function ");
11825	11815	// call reportid from PROCCALL
11826		- stack[base + 38LLU] = base;
11827		- stack[base + 39LLU] = 767LLU;
	11816	+ stack[base + 37LLU] = base;
	11817	+ stack[base + 38LLU] = 767LLU;
11828	11818	// arguments for call to reportid
11829		- stack[base + 40LLU] = stack[base + 5]/fnid/;
	11819	+ stack[base + 39LLU] = stack[base + 5]/fnid/;
11830	11820	// set stack-base & callee-address
11831		- base += 40LLU;
	11821	+ base += 39LLU;
11832	11822	label = 18446744073709551587LLU; // reportid
11833	11823	break;
11834	11824	}

		@@ -11837,12 +11827,12 @@
11837	11827	// copy mutable arguments back from call to reportid
11838	11828	fprintf(stderr, "%s", " call to ");
11839	11829	// call reportid from PROCCALL
11840		- stack[base + 38LLU] = base;
11841		- stack[base + 39LLU] = 768LLU;
	11830	+ stack[base + 37LLU] = base;
	11831	+ stack[base + 38LLU] = 768LLU;
11842	11832	// arguments for call to reportid
11843		- stack[base + 40LLU] = stack[base + 23]/ceid/;
	11833	+ stack[base + 39LLU] = stack[base + 23]/ceid/;
11844	11834	// set stack-base & callee-address
11845		- base += 40LLU;
	11835	+ base += 39LLU;
11846	11836	label = 18446744073709551587LLU; // reportid
11847	11837	break;
11848	11838	}

		@@ -11857,7 +11847,7 @@
11857	11847	newstack[1] = base;
11858	11848	newstack[2] = 769LLU;
11859	11849	// arguments for call to reporttype
11860		- newstack[3LLU] = stack[base + 32]/expected/;
	11850	+ newstack[3LLU] = stack[base + 31]/expected/;
11861	11851	stack = newstack;
11862	11852	// set stack-base & callee-address
11863	11853	base = 3;

		@@ -11883,7 +11873,7 @@
11883	11873	newstack[1] = base;
11884	11874	newstack[2] = 770LLU;
11885	11875	// arguments for call to reporttype
11886		- newstack[3LLU] = stack[base + 34]/type/;
	11876	+ newstack[3LLU] = stack[base + 33]/type/;
11887	11877	stack = newstack;
11888	11878	// set stack-base & callee-address
11889	11879	base = 3;

		@@ -11908,7 +11898,7 @@
11908	11898	}
11909	11899	case 766LLU: // completed if-then-else
11910	11900	{
11911		- if(!stack[base + 31]/mutable/)
	11901	+ if(!stack[base + 30]/mutable/)
11912	11902	{
11913	11903	label = 771LLU; // jump to alternative
11914	11904	break;

		@@ -11915,7 +11905,7 @@
11915	11905	}
11916	11906
11917	11907	// consequent
11918		- if(!stack[base + 37]/mutres/)
	11908	+ if(!stack[base + 36]/mutres/)
11919	11909	{
11920	11910	label = 773LLU; // jump to alternative
11921	11911	break;

		@@ -11929,12 +11919,12 @@
11929	11919	{
11930	11920	fprintf(stderr, "%s", "in function ");
11931	11921	// call reportid from PROCCALL
11932		- stack[base + 38LLU] = base;
11933		- stack[base + 39LLU] = 775LLU;
	11922	+ stack[base + 37LLU] = base;
	11923	+ stack[base + 38LLU] = 775LLU;
11934	11924	// arguments for call to reportid
11935		- stack[base + 40LLU] = stack[base + 5]/fnid/;
	11925	+ stack[base + 39LLU] = stack[base + 5]/fnid/;
11936	11926	// set stack-base & callee-address
11937		- base += 40LLU;
	11927	+ base += 39LLU;
11938	11928	label = 18446744073709551587LLU; // reportid
11939	11929	break;
11940	11930	}

		@@ -11943,12 +11933,12 @@
11943	11933	// copy mutable arguments back from call to reportid
11944	11934	fprintf(stderr, "%s", ", call to ");
11945	11935	// call reportid from PROCCALL
11946		- stack[base + 38LLU] = base;
11947		- stack[base + 39LLU] = 776LLU;
	11936	+ stack[base + 37LLU] = base;
	11937	+ stack[base + 38LLU] = 776LLU;
11948	11938	// arguments for call to reportid
11949		- stack[base + 40LLU] = stack[base + 23]/ceid/;
	11939	+ stack[base + 39LLU] = stack[base + 23]/ceid/;
11950	11940	// set stack-base & callee-address
11951		- base += 40LLU;
	11941	+ base += 39LLU;
11952	11942	label = 18446744073709551587LLU; // reportid
11953	11943	break;
11954	11944	}

		@@ -11963,7 +11953,7 @@
11963	11953	newstack[1] = base;
11964	11954	newstack[2] = 777LLU;
11965	11955	// arguments for call to reporttype
11966		- newstack[3LLU] = stack[base + 32]/expected/;
	11956	+ newstack[3LLU] = stack[base + 31]/expected/;
11967	11957	stack = newstack;
11968	11958	// set stack-base & callee-address
11969	11959	base = 3;

		@@ -11983,12 +11973,12 @@
11983	11973	stack = oldstack;
11984	11974	fprintf(stderr, "%s", " ");
11985	11975	// call reportid from PROCCALL
11986		- stack[base + 38LLU] = base;
11987		- stack[base + 39LLU] = 778LLU;
	11976	+ stack[base + 37LLU] = base;
	11977	+ stack[base + 38LLU] = 778LLU;
11988	11978	// arguments for call to reportid
11989		- stack[base + 40LLU] = stack[base + 33]/paramname/;
	11979	+ stack[base + 39LLU] = stack[base + 32]/paramname/;
11990	11980	// set stack-base & callee-address
11991		- base += 40LLU;
	11981	+ base += 39LLU;
11992	11982	label = 18446744073709551587LLU; // reportid
11993	11983	break;
11994	11984	}

		@@ -12003,7 +11993,7 @@
12003	11993	newstack[1] = base;
12004	11994	newstack[2] = 779LLU;
12005	11995	// arguments for call to reporttype
12006		- newstack[3LLU] = stack[base + 34]/type/;
	11996	+ newstack[3LLU] = stack[base + 33]/type/;
12007	11997	stack = newstack;
12008	11998	// set stack-base & callee-address
12009	11999	base = 3;

		@@ -12023,12 +12013,12 @@
12023	12013	stack = oldstack;
12024	12014	fprintf(stderr, "%s", " ");
12025	12015	// call reportid from PROCCALL
12026		- stack[base + 38LLU] = base;
12027		- stack[base + 39LLU] = 780LLU;
	12016	+ stack[base + 37LLU] = base;
	12017	+ stack[base + 38LLU] = 780LLU;
12028	12018	// arguments for call to reportid
12029		- stack[base + 40LLU] = stack[base + 12]/content/;
	12019	+ stack[base + 39LLU] = stack[base + 12]/content/;
12030	12020	// set stack-base & callee-address
12031		- base += 40LLU;
	12021	+ base += 39LLU;
12032	12022	label = 18446744073709551587LLU; // reportid
12033	12023	break;
12034	12024	}

		@@ -12056,17 +12046,17 @@
12056	12046	struct listnode list = (struct listnode )Calloc(1, sizeof(struct listnode));
12057	12047	list->next = (struct listnode )stack[base + 14]/verified*/;
12058	12048	stack[base + 14]/verified/ = (uint64_t)list;
12059		- list->data = stack[base + 36]/INDEX/;
	12049	+ list->data = stack[base + 35]/INDEX/;
12060	12050	}
12061	12051	{
12062	12052	struct listnode list = (struct listnode )Calloc(1, sizeof(struct listnode));
12063	12053	list->next = (struct listnode )stack[base + 15]/locked*/;
12064	12054	stack[base + 15]/locked/ = (uint64_t)list;
12065		- list->data = stack[base + 35]/id/;
	12055	+ list->data = stack[base + 34]/id/;
12066	12056	}
12067	12057	// releasing RESULT
12068		- Free(4, sizeof(uint64_t), ((uint64_t *)stack[base + 29]/RESULT*/)[1]);
12069		- Free(2, sizeof(uint64_t), (uint64_t )stack[base + 29]/RESULT*/);
	12058	+ Free(4, sizeof(uint64_t), ((uint64_t *)stack[base + 28]/RESULT*/)[1]);
	12059	+ Free(2, sizeof(uint64_t), (uint64_t )stack[base + 28]/RESULT*/);
12070	12060	label = 763LLU; // consequent complete
12071	12061	break;
12072	12062	}

		@@ -12079,8 +12069,8 @@
12079	12069	}
12080	12070	case 763LLU: // completed if-then-else
12081	12071	{
12082		- ((uint64_t *)(stack[base + 30]/typeid/))[1][1] = stack[base + 33]/paramname*/;
12083		- ((uint64_t *)(stack[base + 30]/typeid/))[1][0] = stack[base + 32]/expected*/;
	12072	+ ((uint64_t *)(stack[base + 29]/typeid/))[1][1] = stack[base + 32]/paramname*/;
	12073	+ ((uint64_t *)(stack[base + 29]/typeid/))[1][0] = stack[base + 31]/expected*/;
12084	12074	label = 761LLU; // consequent complete
12085	12075	break;
12086	12076	}

		@@ -12093,8 +12083,8 @@
12093	12083	}
12094	12084	case 761LLU: // completed if-then-else
12095	12085	{
12096		- ((uint64_t *)(stack[base + 27]/result/))[1][1] = stack[base + 31]/mutable*/;
12097		- ((uint64_t *)(stack[base + 27]/result/))[1][0] = stack[base + 30]/typeid*/;
	12086	+ ((uint64_t *)(stack[base + 26]/result/))[1][1] = stack[base + 30]/mutable*/;
	12087	+ ((uint64_t *)(stack[base + 26]/result/))[1][0] = stack[base + 29]/typeid*/;
12098	12088	label = 759LLU; // consequent complete
12099	12089	break;
12100	12090	}

		@@ -12107,7 +12097,7 @@
12107	12097	}
12108	12098	case 759LLU: // completed if-then-else
12109	12099	{
12110		- ((struct listnode )(stack[base + 28/previous/]))->data = stack[base + 27]/result*/;
	12100	+ ((struct listnode )(stack[base + 27/previous/]))->data = stack[base + 26]/result*/;
12111	12101	label = 752LLU; // repeat
12112	12102	break;
12113	12103	}

		@@ -19128,15 +19118,13 @@
19128	19118	//#define cerec 28
19129	19119	stack[base + 28/cerec/] = 0; // init
19130	19120	stack[base + 28]/cerec/ = ((uint64_t *)(stack[base + 22]/calleedef*/))[1][5];
19131		-//#define result 29
19132		- stack[base + 29/result/] = 0; // init
19133		- assign(stack[base + 24]/cerestypes/, &stack[base + 30]/cerestypes/);
	19121	+ assign(stack[base + 24]/cerestypes/, &stack[base + 29]/cerestypes/);
19134	19122	label = 1235LLU; // start to repeat
19135	19123	break;
19136	19124	}
19137	19125	case 1235LLU: // repeat from here
19138	19126	{
19139		- if(!stack[base + 30]/cerestypes/)
	19127	+ if(!stack[base + 29]/cerestypes/)
19140	19128	{
19141	19129	label = 1236LLU; // break loop
19142	19130	break;

		@@ -19143,15 +19131,15 @@
19143	19131	}
19144	19132
19145	19133	// loop body
19146		-//#define result 31
19147		- stack[base + 31/result/] = 0; // init
19148		- stack[base + 31]/result/ = (uint64_t)(((const struct listnode )(stack[base + 30]/cerestypes*/))->data);
19149		-//#define 32
19150		- stack[base + 32/**/] = 0; // init
19151		- stack[base + 32/previous/] = stack[base + 30]/cerestypes/;
19152		- stack[base + 30]/cerestypes/ = (uint64_t)(((const struct listnode )(stack[base + 30]/cerestypes*/))->next);
19153		-//#define RESULT 33
19154		- stack[base + 33/RESULT/] = 0; // init
	19134	+//#define result 30
	19135	+ stack[base + 30/result/] = 0; // init
	19136	+ stack[base + 30]/result/ = (uint64_t)(((const struct listnode )(stack[base + 29]/cerestypes*/))->data);
	19137	+//#define 31
	19138	+ stack[base + 31/**/] = 0; // init
	19139	+ stack[base + 31/previous/] = stack[base + 29]/cerestypes/;
	19140	+ stack[base + 29]/cerestypes/ = (uint64_t)(((const struct listnode )(stack[base + 29]/cerestypes*/))->next);
	19141	+//#define RESULT 32
	19142	+ stack[base + 32/RESULT/] = 0; // init
19155	19143	{ // if pop
19156	19144	struct listnode list = (struct listnode )stack[base + 21]/news/;
19157	19145	if(!list)

		@@ -19162,7 +19150,7 @@
19162	19150
19163	19151	// consequent
19164	19152	struct listnode *next = list->next;
19165		- stack[base + 33]/RESULT/ = list->data;
	19153	+ stack[base + 32]/RESULT/ = list->data;
19166	19154	Free(1, sizeof(struct listnode), list);
19167	19155	stack[base + 21]/news/ = (uint64_t)next;
19168	19156	}

		@@ -19173,12 +19161,12 @@
19173	19161	{
19174	19162	fprintf(stderr, "%s", "in function ");
19175	19163	// call reportid from procblock
19176		- stack[base + 34LLU] = base;
19177		- stack[base + 35LLU] = 1239LLU;
	19164	+ stack[base + 33LLU] = base;
	19165	+ stack[base + 34LLU] = 1239LLU;
19178	19166	// arguments for call to reportid
19179		- stack[base + 36LLU] = stack[base + 5]/fnid/;
	19167	+ stack[base + 35LLU] = stack[base + 5]/fnid/;
19180	19168	// set stack-base & callee-address
19181		- base += 36LLU;
	19169	+ base += 35LLU;
19182	19170	label = 18446744073709551587LLU; // reportid
19183	19171	break;
19184	19172	}

		@@ -19187,12 +19175,12 @@
19187	19175	// copy mutable arguments back from call to reportid
19188	19176	fprintf(stderr, "%s", " call to ");
19189	19177	// call reportid from procblock
19190		- stack[base + 34LLU] = base;
19191		- stack[base + 35LLU] = 1240LLU;
	19178	+ stack[base + 33LLU] = base;
	19179	+ stack[base + 34LLU] = 1240LLU;
19192	19180	// arguments for call to reportid
19193		- stack[base + 36LLU] = stack[base + 27]/ceid/;
	19181	+ stack[base + 35LLU] = stack[base + 27]/ceid/;
19194	19182	// set stack-base & callee-address
19195		- base += 36LLU;
	19183	+ base += 35LLU;
19196	19184	label = 18446744073709551587LLU; // reportid
19197	19185	break;
19198	19186	}

		@@ -19207,7 +19195,7 @@
19207	19195	}
19208	19196	case 1238LLU: // completed if-then-else
19209	19197	{
19210		- if(/result/0 != ((uint64_t )(stack[base + 31]/result*/))[0])
	19198	+ if(/result/0 != ((uint64_t )(stack[base + 30]/result*/))[0])
19211	19199	{
19212	19200	label = 1241LLU; // jump to alternative
19213	19201	break;

		@@ -19214,13 +19202,13 @@
19214	19202	}
19215	19203
19216	19204	// consequent
19217		-//#define typeid 34
19218		- stack[base + 34/typeid/] = 0; // init
19219		- stack[base + 34]/typeid/ = ((uint64_t *)(stack[base + 31]/result*/))[1][0];
19220		-//#define mutable 35
19221		- stack[base + 35/mutable/] = 0; // init
19222		- stack[base + 35]/mutable/ = ((uint64_t *)(stack[base + 31]/result*/))[1][1];
19223		- if(/typeid/0 != ((uint64_t )(stack[base + 34]/typeid*/))[0])
	19205	+//#define typeid 33
	19206	+ stack[base + 33/typeid/] = 0; // init
	19207	+ stack[base + 33]/typeid/ = ((uint64_t *)(stack[base + 30]/result*/))[1][0];
	19208	+//#define mutable 34
	19209	+ stack[base + 34/mutable/] = 0; // init
	19210	+ stack[base + 34]/mutable/ = ((uint64_t *)(stack[base + 30]/result*/))[1][1];
	19211	+ if(/typeid/0 != ((uint64_t )(stack[base + 33]/typeid*/))[0])
19224	19212	{
19225	19213	label = 1243LLU; // jump to alternative
19226	19214	break;

		@@ -19227,13 +19215,13 @@
19227	19215	}
19228	19216
19229	19217	// consequent
19230		-//#define expected 36
19231		- stack[base + 36/expected/] = 0; // init
19232		- stack[base + 36]/expected/ = ((uint64_t *)(stack[base + 34]/typeid*/))[1][0];
19233		-//#define paramname 37
19234		- stack[base + 37/paramname/] = 0; // init
19235		- stack[base + 37]/paramname/ = ((uint64_t *)(stack[base + 34]/typeid*/))[1][1];
19236		- if(/idnr/0 != ((uint64_t )(stack[base + 33]/RESULT*/))[0])
	19218	+//#define expected 35
	19219	+ stack[base + 35/expected/] = 0; // init
	19220	+ stack[base + 35]/expected/ = ((uint64_t *)(stack[base + 33]/typeid*/))[1][0];
	19221	+//#define paramname 36
	19222	+ stack[base + 36/paramname/] = 0; // init
	19223	+ stack[base + 36]/paramname/ = ((uint64_t *)(stack[base + 33]/typeid*/))[1][1];
	19224	+ if(/idnr/0 != ((uint64_t )(stack[base + 32]/RESULT*/))[0])
19237	19225	{
19238	19226	label = 1245LLU; // jump to alternative
19239	19227	break;

		@@ -19240,14 +19228,14 @@
19240	19228	}
19241	19229
19242	19230	// consequent
19243		-//#define id 38
19244		- stack[base + 38/id/] = 0; // init
19245		- stack[base + 38]/id/ = ((uint64_t *)(stack[base + 33]/RESULT*/))[1][0];
19246		-//#define mutres 39
19247		- stack[base + 39/mutres/] = 0; // init
19248		- stack[base + 39]/mutres/ = ((uint64_t *)(stack[base + 33]/RESULT*/))[1][1];
19249		-//#define type 40
19250		- stack[base + 40/type/] = 0; // init
	19231	+//#define id 37
	19232	+ stack[base + 37/id/] = 0; // init
	19233	+ stack[base + 37]/id/ = ((uint64_t *)(stack[base + 32]/RESULT*/))[1][0];
	19234	+//#define mutres 38
	19235	+ stack[base + 38/mutres/] = 0; // init
	19236	+ stack[base + 38]/mutres/ = ((uint64_t *)(stack[base + 32]/RESULT*/))[1][1];
	19237	+//#define type 39
	19238	+ stack[base + 39/type/] = 0; // init
19251	19239	uint64_t newstack = (uint64_t )Calloc(13LLU + 1, sizeof(uint64_t));
19252	19240	newstack[13LLU] = 9876543210LLU; // overflow-marker
19253	19241	// call copytype from procblock

		@@ -19255,7 +19243,7 @@
19255	19243	newstack[1] = base;
19256	19244	newstack[2] = 1247LLU;
19257	19245	// arguments for call to copytype
19258		- newstack[4LLU] = stack[base + 36]/expected/;
	19246	+ newstack[4LLU] = stack[base + 35]/expected/;
19259	19247	stack = newstack;
19260	19248	// set stack-base & callee-address
19261	19249	base = 3;

		@@ -19267,7 +19255,7 @@
19267	19255	uint64_t oldstack = (uint64_t )stack[0];
19268	19256	// copy mutable arguments back from call to copytype
19269	19257	// copy back results provided by call to copytype
19270		- oldstack[base + 40] = stack[3LLU];
	19258	+ oldstack[base + 39] = stack[3LLU];
19271	19259	if(stack[13LLU] != 9876543210LLU)
19272	19260	{
19273	19261	fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to copytype)!");

		@@ -19276,19 +19264,19 @@
19276	19264	Free(13LLU + 1, sizeof(uint64_t), stack);
19277	19265	stack = oldstack;
19278	19266	// call newvar from procblock
19279		- stack[base + 41LLU] = base;
19280		- stack[base + 42LLU] = 1248LLU;
	19267	+ stack[base + 40LLU] = base;
	19268	+ stack[base + 41LLU] = 1248LLU;
19281	19269	// arguments for call to newvar
19282		- stack[base + 43LLU] = stack[base + 40]/type/;
19283		- stack[base + 44LLU] = stack[base + 38]/id/;
19284		- stack[base + 45LLU] = stack[base + 39]/mutres/;
19285		- stack[base + 46LLU] = stack[base + 7]/fnrescount/;
19286		- stack[base + 47LLU] = stack[base + 8]/fnargcount/;
19287		- stack[base + 48LLU] = stack[base + 9]/fnmaxcount/;
19288		- stack[base + 49LLU] = stack[base + 16]/varcount/;
19289		- stack[base + 50LLU] = stack[base + 3]/scope/;
	19270	+ stack[base + 42LLU] = stack[base + 39]/type/;
	19271	+ stack[base + 43LLU] = stack[base + 37]/id/;
	19272	+ stack[base + 44LLU] = stack[base + 38]/mutres/;
	19273	+ stack[base + 45LLU] = stack[base + 7]/fnrescount/;
	19274	+ stack[base + 46LLU] = stack[base + 8]/fnargcount/;
	19275	+ stack[base + 47LLU] = stack[base + 9]/fnmaxcount/;
	19276	+ stack[base + 48LLU] = stack[base + 16]/varcount/;
	19277	+ stack[base + 49LLU] = stack[base + 3]/scope/;
19290	19278	// set stack-base & callee-address
19291		- base += 43LLU;
	19279	+ base += 42LLU;
19292	19280	label = 235LLU; // newvar
19293	19281	break;
19294	19282	}

		@@ -19295,20 +19283,20 @@
19295	19283	case 1248LLU: // return from newvar to procblock
19296	19284	{
19297	19285	// copy mutable arguments back from call to newvar
19298		- stack[base + 3]/scope/ = stack[base + 50LLU];
19299		- stack[base + 16]/varcount/ = stack[base + 49LLU];
19300		- stack[base + 9]/fnmaxcount/ = stack[base + 48LLU];
19301		-//#define INDEX 41
19302		- stack[base + 41/INDEX/] = 0; // init
	19286	+ stack[base + 3]/scope/ = stack[base + 49LLU];
	19287	+ stack[base + 16]/varcount/ = stack[base + 48LLU];
	19288	+ stack[base + 9]/fnmaxcount/ = stack[base + 47LLU];
	19289	+//#define INDEX 40
	19290	+ stack[base + 40/INDEX/] = 0; // init
19303	19291	// call findletidx from procblock
19304		- stack[base + 42LLU] = base;
19305		- stack[base + 43LLU] = 1249LLU;
	19292	+ stack[base + 41LLU] = base;
	19293	+ stack[base + 42LLU] = 1249LLU;
19306	19294	// arguments for call to findletidx
19307		- stack[base + 45LLU] = stack[base + 38]/id/;
19308		- stack[base + 46LLU] = stack[base + 2]/scopes/;
19309		- stack[base + 47LLU] = stack[base + 3]/scope/;
	19295	+ stack[base + 44LLU] = stack[base + 37]/id/;
	19296	+ stack[base + 45LLU] = stack[base + 2]/scopes/;
	19297	+ stack[base + 46LLU] = stack[base + 3]/scope/;
19310	19298	// set stack-base & callee-address
19311		- base += 44LLU;
	19299	+ base += 43LLU;
19312	19300	label = 215LLU; // findletidx
19313	19301	break;
19314	19302	}

		@@ -19316,22 +19304,22 @@
19316	19304	{
19317	19305	// copy mutable arguments back from call to findletidx
19318	19306	// copy back results provided by call to findletidx
19319		- stack[base + 41] = stack[base + 44LLU];
	19307	+ stack[base + 40] = stack[base + 43LLU];
19320	19308	{
19321	19309	struct listnode list = (struct listnode )Calloc(1, sizeof(struct listnode));
19322	19310	list->next = (struct listnode )stack[base + 19]/verified*/;
19323	19311	stack[base + 19]/verified/ = (uint64_t)list;
19324		- list->data = stack[base + 41]/INDEX/;
	19312	+ list->data = stack[base + 40]/INDEX/;
19325	19313	}
19326	19314	{
19327	19315	struct listnode list = (struct listnode )Calloc(1, sizeof(struct listnode));
19328	19316	list->next = (struct listnode )stack[base + 20]/locked*/;
19329	19317	stack[base + 20]/locked/ = (uint64_t)list;
19330		- list->data = stack[base + 38]/id/;
	19318	+ list->data = stack[base + 37]/id/;
19331	19319	}
19332	19320	// releasing RESULT
19333		- Free(2, sizeof(uint64_t), ((uint64_t *)stack[base + 33]/RESULT*/)[1]);
19334		- Free(2, sizeof(uint64_t), (uint64_t )stack[base + 33]/RESULT*/);
	19321	+ Free(2, sizeof(uint64_t), ((uint64_t *)stack[base + 32]/RESULT*/)[1]);
	19322	+ Free(2, sizeof(uint64_t), (uint64_t )stack[base + 32]/RESULT*/);
19335	19323	label = 1246LLU; // consequent complete
19336	19324	break;
19337	19325	}

		@@ -19344,8 +19332,8 @@
19344	19332	}
19345	19333	case 1246LLU: // completed if-then-else
19346	19334	{
19347		- ((uint64_t *)(stack[base + 34]/typeid/))[1][1] = stack[base + 37]/paramname*/;
19348		- ((uint64_t *)(stack[base + 34]/typeid/))[1][0] = stack[base + 36]/expected*/;
	19335	+ ((uint64_t *)(stack[base + 33]/typeid/))[1][1] = stack[base + 36]/paramname*/;
	19336	+ ((uint64_t *)(stack[base + 33]/typeid/))[1][0] = stack[base + 35]/expected*/;
19349	19337	label = 1244LLU; // consequent complete
19350	19338	break;
19351	19339	}

		@@ -19358,8 +19346,8 @@
19358	19346	}
19359	19347	case 1244LLU: // completed if-then-else
19360	19348	{
19361		- ((uint64_t *)(stack[base + 31]/result/))[1][1] = stack[base + 35]/mutable*/;
19362		- ((uint64_t *)(stack[base + 31]/result/))[1][0] = stack[base + 34]/typeid*/;
	19349	+ ((uint64_t *)(stack[base + 30]/result/))[1][1] = stack[base + 34]/mutable*/;
	19350	+ ((uint64_t *)(stack[base + 30]/result/))[1][0] = stack[base + 33]/typeid*/;
19363	19351	label = 1242LLU; // consequent complete
19364	19352	break;
19365	19353	}

		@@ -19372,7 +19360,7 @@
19372	19360	}
19373	19361	case 1242LLU: // completed if-then-else
19374	19362	{
19375		- ((struct listnode )(stack[base + 32/previous/]))->data = stack[base + 31]/result*/;
	19363	+ ((struct listnode )(stack[base + 31/previous/]))->data = stack[base + 30]/result*/;
19376	19364	label = 1235LLU; // repeat
19377	19365	break;
19378	19366	}

		@@ -19387,12 +19375,12 @@
19387	19375	// consequent
19388	19376	fprintf(stderr, "%s", "in function ");
19389	19377	// call reportid from procblock
19390		- stack[base + 33LLU] = base;
19391		- stack[base + 34LLU] = 1252LLU;
	19378	+ stack[base + 32LLU] = base;
	19379	+ stack[base + 33LLU] = 1252LLU;
19392	19380	// arguments for call to reportid
19393		- stack[base + 35LLU] = stack[base + 5]/fnid/;
	19381	+ stack[base + 34LLU] = stack[base + 5]/fnid/;
19394	19382	// set stack-base & callee-address
19395		- base += 35LLU;
	19383	+ base += 34LLU;
19396	19384	label = 18446744073709551587LLU; // reportid
19397	19385	break;
19398	19386	}

		@@ -19401,12 +19389,12 @@
19401	19389	// copy mutable arguments back from call to reportid
19402	19390	fprintf(stderr, "%s", " let-expression initialized by call to ");
19403	19391	// call reportid from procblock
19404		- stack[base + 33LLU] = base;
19405		- stack[base + 34LLU] = 1253LLU;
	19392	+ stack[base + 32LLU] = base;
	19393	+ stack[base + 33LLU] = 1253LLU;
19406	19394	// arguments for call to reportid
19407		- stack[base + 35LLU] = stack[base + 27]/ceid/;
	19395	+ stack[base + 34LLU] = stack[base + 27]/ceid/;
19408	19396	// set stack-base & callee-address
19409		- base += 35LLU;
	19397	+ base += 34LLU;
19410	19398	label = 18446744073709551587LLU; // reportid
19411	19399	break;
19412	19400	}

		@@ -20270,19 +20258,17 @@
20270	20258	stack[base + 11]/lookahead/ = stack[base + 34LLU];
20271	20259	//#define typeids 31
20272	20260	stack[base + 31/typeids/] = 0; // init
20273		-//#define typeid 32
20274		- stack[base + 32/typeid/] = 0; // init
20275	20261	stack[base + 31]/typeids/ = stack[base + 29]/TYPEIDS/;
20276		-//#define elemindex 33
20277		- stack[base + 33/elemindex/] = 0; // init
20278		- stack[base + 33]/elemindex/ = 0;
20279		- assign(stack[base + 31]/typeids/, &stack[base + 34]/typeids/);
	20262	+//#define elemindex 32
	20263	+ stack[base + 32/elemindex/] = 0; // init
	20264	+ stack[base + 32]/elemindex/ = 0;
	20265	+ assign(stack[base + 31]/typeids/, &stack[base + 33]/typeids/);
20280	20266	label = 1313LLU; // start to repeat
20281	20267	break;
20282	20268	}
20283	20269	case 1313LLU: // repeat from here
20284	20270	{
20285		- if(!stack[base + 34]/typeids/)
	20271	+ if(!stack[base + 33]/typeids/)
20286	20272	{
20287	20273	label = 1314LLU; // break loop
20288	20274	break;

		@@ -20289,14 +20275,14 @@
20289	20275	}
20290	20276
20291	20277	// loop body
20292		-//#define typeid 35
20293		- stack[base + 35/typeid/] = 0; // init
20294		- stack[base + 35]/typeid/ = (uint64_t)(((const struct listnode )(stack[base + 34]/typeids*/))->data);
20295		-//#define 36
20296		- stack[base + 36/**/] = 0; // init
20297		- stack[base + 36/previous/] = stack[base + 34]/typeids/;
20298		- stack[base + 34]/typeids/ = (uint64_t)(((const struct listnode )(stack[base + 34]/typeids*/))->next);
20299		- if(/typeid/0 != ((uint64_t )(stack[base + 35]/typeid*/))[0])
	20278	+//#define typeid 34
	20279	+ stack[base + 34/typeid/] = 0; // init
	20280	+ stack[base + 34]/typeid/ = (uint64_t)(((const struct listnode )(stack[base + 33]/typeids*/))->data);
	20281	+//#define 35
	20282	+ stack[base + 35/**/] = 0; // init
	20283	+ stack[base + 35/previous/] = stack[base + 33]/typeids/;
	20284	+ stack[base + 33]/typeids/ = (uint64_t)(((const struct listnode )(stack[base + 33]/typeids*/))->next);
	20285	+ if(/typeid/0 != ((uint64_t )(stack[base + 34]/typeid*/))[0])
20300	20286	{
20301	20287	label = 1315LLU; // jump to alternative
20302	20288	break;

		@@ -20303,13 +20289,13 @@
20303	20289	}
20304	20290
20305	20291	// consequent
20306		-//#define type 37
20307		- stack[base + 37/type/] = 0; // init
20308		- stack[base + 37]/type/ = ((uint64_t *)(stack[base + 35]/typeid*/))[1][0];
20309		-//#define elemid 38
20310		- stack[base + 38/elemid/] = 0; // init
20311		- stack[base + 38]/elemid/ = ((uint64_t *)(stack[base + 35]/typeid*/))[1][1];
20312		- if(!stack[base + 33]/elemindex/)
	20292	+//#define type 36
	20293	+ stack[base + 36/type/] = 0; // init
	20294	+ stack[base + 36]/type/ = ((uint64_t *)(stack[base + 34]/typeid*/))[1][0];
	20295	+//#define elemid 37
	20296	+ stack[base + 37/elemid/] = 0; // init
	20297	+ stack[base + 37]/elemid/ = ((uint64_t *)(stack[base + 34]/typeid*/))[1][1];
	20298	+ if(!stack[base + 32]/elemindex/)
20313	20299	{
20314	20300	label = 1317LLU; // jump to alternative
20315	20301	break;

		@@ -20317,13 +20303,13 @@
20317	20303
20318	20304	// consequent
20319	20305	// call matchsym from procblock
20320		- stack[base + 39LLU] = base;
20321		- stack[base + 40LLU] = 1319LLU;
	20306	+ stack[base + 38LLU] = base;
	20307	+ stack[base + 39LLU] = 1319LLU;
20322	20308	// arguments for call to matchsym
20323		- stack[base + 41LLU] = 44LLU;
20324		- stack[base + 42LLU] = stack[base + 11]/lookahead/;
	20309	+ stack[base + 40LLU] = 44LLU;
	20310	+ stack[base + 41LLU] = stack[base + 11]/lookahead/;
20325	20311	// set stack-base & callee-address
20326		- base += 41LLU;
	20312	+ base += 40LLU;
20327	20313	label = 27LLU; // matchsym
20328	20314	break;
20329	20315	}

		@@ -20330,7 +20316,7 @@
20330	20316	case 1319LLU: // return from matchsym to procblock
20331	20317	{
20332	20318	// copy mutable arguments back from call to matchsym
20333		- stack[base + 11]/lookahead/ = stack[base + 42LLU];
	20319	+ stack[base + 11]/lookahead/ = stack[base + 41LLU];
20334	20320	label = 1318LLU; // consequent complete
20335	20321	break;
20336	20322	}

		@@ -20342,12 +20328,12 @@
20342	20328	case 1318LLU: // completed if-then-else
20343	20329	{
20344	20330	// call parsetoken from procblock
20345		- stack[base + 39LLU] = base;
20346		- stack[base + 40LLU] = 1320LLU;
	20331	+ stack[base + 38LLU] = base;
	20332	+ stack[base + 39LLU] = 1320LLU;
20347	20333	// arguments for call to parsetoken
20348		- stack[base + 44LLU] = stack[base + 11]/lookahead/;
	20334	+ stack[base + 43LLU] = stack[base + 11]/lookahead/;
20349	20335	// set stack-base & callee-address
20350		- base += 41LLU;
	20336	+ base += 40LLU;
20351	20337	label = 18446744073709551585LLU; // parsetoken
20352	20338	break;
20353	20339	}

		@@ -20355,17 +20341,17 @@
20355	20341	{
20356	20342	// copy mutable arguments back from call to parsetoken
20357	20343	// copy back results provided by call to parsetoken
20358		- stack[base + 12] = stack[base + 41LLU];
20359		- stack[base + 13] = stack[base + 42LLU];
20360		- stack[base + 11] = stack[base + 43LLU];
	20344	+ stack[base + 12] = stack[base + 40LLU];
	20345	+ stack[base + 13] = stack[base + 41LLU];
	20346	+ stack[base + 11] = stack[base + 42LLU];
20361	20347	// call equ from procblock
20362		- stack[base + 39LLU] = base;
20363		- stack[base + 40LLU] = 1321LLU;
	20348	+ stack[base + 38LLU] = base;
	20349	+ stack[base + 39LLU] = 1321LLU;
20364	20350	// arguments for call to equ
20365		- stack[base + 42LLU] = stack[base + 12]/variant/;
20366		- stack[base + 43LLU] = 4LLU;
	20351	+ stack[base + 41LLU] = stack[base + 12]/variant/;
	20352	+ stack[base + 42LLU] = 4LLU;
20367	20353	// set stack-base & callee-address
20368		- base += 41LLU;
	20354	+ base += 40LLU;
20369	20355	label = 18446744073709551600LLU; // equ
20370	20356	break;
20371	20357	}

		@@ -20373,7 +20359,7 @@
20373	20359	{
20374	20360	// copy mutable arguments back from call to equ
20375	20361	// copy back results provided by call to equ
20376		- stack[base + 18] = stack[base + 41LLU];
	20362	+ stack[base + 18] = stack[base + 40LLU];
20377	20363	if(!stack[base + 18]/isequal/)
20378	20364	{
20379	20365	label = 1322LLU; // jump to alternative

		@@ -20388,13 +20374,13 @@
20388	20374	{
20389	20375	fprintf(stderr, "%s", "constructor requires variables but found ");
20390	20376	// call reporttok from procblock
20391		- stack[base + 39LLU] = base;
20392		- stack[base + 40LLU] = 1324LLU;
	20377	+ stack[base + 38LLU] = base;
	20378	+ stack[base + 39LLU] = 1324LLU;
20393	20379	// arguments for call to reporttok
20394		- stack[base + 41LLU] = stack[base + 12]/variant/;
20395		- stack[base + 42LLU] = stack[base + 13]/content/;
	20380	+ stack[base + 40LLU] = stack[base + 12]/variant/;
	20381	+ stack[base + 41LLU] = stack[base + 13]/content/;
20396	20382	// set stack-base & callee-address
20397		- base += 41LLU;
	20383	+ base += 40LLU;
20398	20384	label = 18446744073709551583LLU; // reporttok
20399	20385	break;
20400	20386	}

		@@ -20410,14 +20396,14 @@
20410	20396	{
20411	20397	printf("%s", "\n MOVE(&");
20412	20398	// call emitvar from procblock
20413		- stack[base + 39LLU] = base;
20414		- stack[base + 40LLU] = 1325LLU;
	20399	+ stack[base + 38LLU] = base;
	20400	+ stack[base + 39LLU] = 1325LLU;
20415	20401	// arguments for call to emitvar
20416		- stack[base + 41LLU] = stack[base + 13]/content/;
20417		- stack[base + 42LLU] = stack[base + 2]/scopes/;
20418		- stack[base + 43LLU] = stack[base + 3]/scope/;
	20402	+ stack[base + 40LLU] = stack[base + 13]/content/;
	20403	+ stack[base + 41LLU] = stack[base + 2]/scopes/;
	20404	+ stack[base + 42LLU] = stack[base + 3]/scope/;
20419	20405	// set stack-base & callee-address
20420		- base += 41LLU;
	20406	+ base += 40LLU;
20421	20407	label = 224LLU; // emitvar
20422	20408	break;
20423	20409	}

		@@ -20426,14 +20412,14 @@
20426	20412	// copy mutable arguments back from call to emitvar
20427	20413	printf("%s", ", &(((uint64_t **)(");
20428	20414	// call emitvar from procblock
20429		- stack[base + 39LLU] = base;
20430		- stack[base + 40LLU] = 1326LLU;
	20415	+ stack[base + 38LLU] = base;
	20416	+ stack[base + 39LLU] = 1326LLU;
20431	20417	// arguments for call to emitvar
20432		- stack[base + 41LLU] = stack[base + 20]/id/;
20433		- stack[base + 42LLU] = stack[base + 2]/scopes/;
20434		- stack[base + 43LLU] = stack[base + 3]/scope/;
	20418	+ stack[base + 40LLU] = stack[base + 20]/id/;
	20419	+ stack[base + 41LLU] = stack[base + 2]/scopes/;
	20420	+ stack[base + 42LLU] = stack[base + 3]/scope/;
20435	20421	// set stack-base & callee-address
20436		- base += 41LLU;
	20422	+ base += 40LLU;
20437	20423	label = 224LLU; // emitvar
20438	20424	break;
20439	20425	}

		@@ -20442,12 +20428,12 @@
20442	20428	// copy mutable arguments back from call to emitvar
20443	20429	printf("%s", "))[1][");
20444	20430	// call printnr from procblock
20445		- stack[base + 39LLU] = base;
20446		- stack[base + 40LLU] = 1327LLU;
	20431	+ stack[base + 38LLU] = base;
	20432	+ stack[base + 39LLU] = 1327LLU;
20447	20433	// arguments for call to printnr
20448		- stack[base + 41LLU] = stack[base + 33]/elemindex/;
	20434	+ stack[base + 40LLU] = stack[base + 32]/elemindex/;
20449	20435	// set stack-base & callee-address
20450		- base += 41LLU;
	20436	+ base += 40LLU;
20451	20437	label = 18446744073709551591LLU; // printnr
20452	20438	break;
20453	20439	}

		@@ -20455,8 +20441,8 @@
20455	20441	{
20456	20442	// copy mutable arguments back from call to printnr
20457	20443	printf("%s", "]));");
20458		- ((uint64_t *)(stack[base + 35]/typeid/))[1][1] = stack[base + 38]/elemid*/;
20459		- ((uint64_t *)(stack[base + 35]/typeid/))[1][0] = stack[base + 37]/type*/;
	20444	+ ((uint64_t *)(stack[base + 34]/typeid/))[1][1] = stack[base + 37]/elemid*/;
	20445	+ ((uint64_t *)(stack[base + 34]/typeid/))[1][0] = stack[base + 36]/type*/;
20460	20446	label = 1316LLU; // consequent complete
20461	20447	break;
20462	20448	}

		@@ -20470,13 +20456,13 @@
20470	20456	case 1316LLU: // completed if-then-else
20471	20457	{
20472	20458	// call add from procblock
20473		- stack[base + 37LLU] = base;
20474		- stack[base + 38LLU] = 1328LLU;
	20459	+ stack[base + 36LLU] = base;
	20460	+ stack[base + 37LLU] = 1328LLU;
20475	20461	// arguments for call to add
20476		- stack[base + 40LLU] = stack[base + 33]/elemindex/;
20477		- stack[base + 41LLU] = 1LLU;
	20462	+ stack[base + 39LLU] = stack[base + 32]/elemindex/;
	20463	+ stack[base + 40LLU] = 1LLU;
20478	20464	// set stack-base & callee-address
20479		- base += 39LLU;
	20465	+ base += 38LLU;
20480	20466	label = 18446744073709551605LLU; // add
20481	20467	break;
20482	20468	}

		@@ -20484,8 +20470,8 @@
20484	20470	{
20485	20471	// copy mutable arguments back from call to add
20486	20472	// copy back results provided by call to add
20487		- stack[base + 33] = stack[base + 39LLU];
20488		- ((struct listnode )(stack[base + 36/previous/]))->data = stack[base + 35]/typeid*/;
	20473	+ stack[base + 32] = stack[base + 38LLU];
	20474	+ ((struct listnode )(stack[base + 35/previous/]))->data = stack[base + 34]/typeid*/;
20489	20475	label = 1313LLU; // repeat
20490	20476	break;
20491	20477	}

		@@ -20492,13 +20478,13 @@
20492	20478	case 1314LLU: // loop finished
20493	20479	{
20494	20480	// call matchsym from procblock
20495		- stack[base + 37LLU] = base;
20496		- stack[base + 38LLU] = 1329LLU;
	20481	+ stack[base + 36LLU] = base;
	20482	+ stack[base + 37LLU] = 1329LLU;
20497	20483	// arguments for call to matchsym
20498		- stack[base + 39LLU] = 41LLU;
20499		- stack[base + 40LLU] = stack[base + 11]/lookahead/;
	20484	+ stack[base + 38LLU] = 41LLU;
	20485	+ stack[base + 39LLU] = stack[base + 11]/lookahead/;
20500	20486	// set stack-base & callee-address
20501		- base += 39LLU;
	20487	+ base += 38LLU;
20502	20488	label = 27LLU; // matchsym
20503	20489	break;
20504	20490	}

		@@ -20505,7 +20491,7 @@
20505	20491	case 1329LLU: // return from matchsym to procblock
20506	20492	{
20507	20493	// copy mutable arguments back from call to matchsym
20508		- stack[base + 11]/lookahead/ = stack[base + 40LLU];
	20494	+ stack[base + 11]/lookahead/ = stack[base + 39LLU];
20509	20495	((uint64_t *)(stack[base + 27]/constr/))[1][1] = stack[base + 29]/TYPEIDS*/;
20510	20496	((uint64_t *)(stack[base + 27]/constr/))[1][0] = stack[base + 28]/dummy*/;
20511	20497	label = 1304LLU; // consequent complete

--- trunk/jpl_compiler_pragmatic/compiler.source.c (revision 1074)

+++ trunk/jpl_compiler_pragmatic/compiler.source.c (revision 1075)

		@@ -293,7 +293,6 @@
293	293	(u64 found) existsid([u64] ids, u64 wanted)
294	294	{
295	295	found = 0
296		- NEW u64 current
297	296	while next(ids)->(current)
298	297	{
299	298	if(found)

		@@ -721,7 +720,6 @@
721	720	(u64 found) lookresult ([result] results, u64 wanted)
722	721	{
723	722	found = 0
724		- NEW mut result result
725	723	while next(results)->(result)
726	724	{
727	725	if(found)

		@@ -817,7 +815,6 @@
817	815	(u64 found) lookparam ([param] params, u64 wanted)
818	816	{
819	817	found = 0
820		- NEW mut param param
821	818	while next(params)->(param)
822	819	{
823	820	if(found)

		@@ -1191,7 +1188,6 @@
1191	1188	(u64 found) lookidnr([idnr] idnrs, u64 wanted)
1192	1189	{
1193	1190	found = 0
1194		- NEW idnr idnr
1195	1191	while next(idnrs)->(idnr)
1196	1192	{
1197	1193	if(found)

		@@ -2705,7 +2701,6 @@
2705	2701	calleedef.id -> ceid
2706	2702	calleedef.recursive -> cerec
2707	2703
2708		- NEW mut result result
2709	2704	while next(cerestypes)->(result)
2710	2705	{
2711	2706	NEW mut letdef RESULT

		@@ -4132,7 +4127,6 @@
4132	4127	calleedef.id -> ceid
4133	4128	calleedef.recursive -> cerec
4134	4129
4135		- NEW mut result result
4136	4130	while next(cerestypes)->(result)
4137	4131	{
4138	4132	NEW mut idnr RESULT

		@@ -4355,7 +4349,6 @@
4355	4349	matchsym('(', lookahead)
4356	4350
4357	4351	NEW mut [typeid] typeids
4358		- NEW mut typeid typeid
4359	4352	typeids = TYPEIDS // NOTE: must copy reference to avoid destruction of list in data-element!
4360	4353	NEW mut u64 elemindex
4361	4354	elemindex = 0

Show on old repository browser