OSDN > Trouver un logiciel > Développement de logiciels > Compilers > JPL > SCM > SVN > Commit

JPL

R/O
SSH
HTTPS

jpl: Commit

Commit MetaInfo

Révision	406 (tree)
l'heure	2019-01-13 10:43:59
Auteur	jakobthomsen

Message de Log

regression-test for finity-check for recursion on matched optionals

Change Summary

modified: trunk/pragmatic/memory_tests/mem_test_output.txt (diff)
modified: trunk/pragmatic/memory_tests/mem_tests.c (diff)
modified: trunk/pragmatic/memory_tests/mem_tests.txt (diff)
modified: trunk/pragmatic/memory_tests/mem_tests_compiled.c (diff)

Modification

--- trunk/pragmatic/memory_tests/mem_test_output.txt (revision 405)

+++ trunk/pragmatic/memory_tests/mem_test_output.txt (revision 406)

		@@ -54,6 +54,7 @@
54	54	Hello NEW Data!
55	55	a$(box(b$("Hello NEW Data!", 42, 42))
56	56	((A,B),(C,D))
	57	+(((),()),((),()))
57	58	((,),(,))
58	59	tree(box(node(tree(box(node(tree(box(leaf("A")), tree(box(leaf("B")))), tree(box(node(tree(box(leaf("C")), tree(box(leaf("D"))))))
59	60	for-test 1:

--- trunk/pragmatic/memory_tests/mem_tests.c (revision 405)

+++ trunk/pragmatic/memory_tests/mem_tests.c (revision 406)

		@@ -405,6 +405,22 @@
405	405	opt<tree2> right;
406	406	}
407	407
	408	+u64 PrintTree2Match(StreamOut, opt<tree2>)
	409	+ \| (out, _) ->
	410	+ {
	411	+ PutStr(out, "()");
	412	+ result 0 // dummy
	413	+ }
	414	+ \| (out, (solid tree)) ->
	415	+ {
	416	+ PutStr(out, "(");
	417	+ let _ = PrintTree2Match(out, tree.left);
	418	+ PutStr(out, ",");
	419	+ let _ = PrintTree2Match(out, tree.right);
	420	+ PutStr(out, ")");
	421	+ result 0 // dummy
	422	+ };
	423	+
408	424	unit PrintTree2(StreamOut out, opt<tree2> t)
409	425	{
410	426	switch t

		@@ -711,6 +727,8 @@
711	727	let tree tree = node(node(leaf("A"), leaf("B")), node(leaf("C"), leaf("D")));
712	728	PrintTree(streams.out, tree);
713	729	PutStrLn(streams.out, "");
	730	+ let _ = PrintTree2Match(streams.out, tree_to_tree2(tree));
	731	+ PutStrLn(streams.out, "");
714	732	PrintTree2(streams.out, tree_to_tree2(tree));
715	733	PutStrLn(streams.out, "");
716	734	Print<tree>(streams.out, tree); PutStr(streams.out, "\n");

--- trunk/pragmatic/memory_tests/mem_tests.txt (revision 405)

+++ trunk/pragmatic/memory_tests/mem_tests.txt (revision 406)

		@@ -54,6 +54,7 @@
54	54	Hello NEW Data!
55	55	a$(box(b$("Hello NEW Data!", 42, 42))
56	56	((A,B),(C,D))
	57	+(((),()),((),()))
57	58	((,),(,))
58	59	tree(box(node(tree(box(node(tree(box(leaf("A")), tree(box(leaf("B")))), tree(box(node(tree(box(leaf("C")), tree(box(leaf("D"))))))
59	60	for-test 1:

--- trunk/pragmatic/memory_tests/mem_tests_compiled.c (revision 405)

+++ trunk/pragmatic/memory_tests/mem_tests_compiled.c (revision 406)

		@@ -3138,6 +3138,81 @@
3138	3138	return;
3139	3139	}
3140	3140
	3141	+
	3142	+void PrintTree2Match(uint64_t const _0, const struct StreamOut const _1, const struct stack/tree2/ *const _2);
	3143	+
	3144	+void PrintTree2Match$0(uint64_t const _0, const struct StreamOut const _1, const struct stack/tree2/ *const _2)
	3145	+{
	3146	+ const struct StreamOut out = &(_1);
	3147	+ // ignore parameter *_2;
	3148	+ {
	3149	+ {
	3150	+ struct string _2; memset(&_2, 0, sizeof(struct string));
	3151	+ init$fromliteral(&_2, "()", 2);
	3152	+ PutStr(0 /* _1 /, &out, &_2);
	3153	+ string$dest(&_2);
	3154	+ }
	3155	+ uint64_t _2; memset(&_2, 0, sizeof(uint64_t));
	3156	+ _2 = 0;
	3157	+ *_0 = _2;
	3158	+ _IGNORE_(_2);
	3159	+ }
	3160	+}
	3161	+
	3162	+void PrintTree2Match$1(uint64_t const _0, const struct StreamOut const _1, const struct stack/tree2/ *const _2)
	3163	+{
	3164	+ const struct StreamOut out = &(_1);
	3165	+ if((*_2).fill == 0)
	3166	+ {
	3167	+ PrintTree2Match$0(_0, &(_1), &(_2));
	3168	+ return;
	3169	+ }
	3170	+ const struct tree2 _3 = ((_2).data);
	3171	+ const struct tree2 tree = &(_3);
	3172	+ {
	3173	+ {
	3174	+ struct string _2; memset(&_2, 0, sizeof(struct string));
	3175	+ init$fromliteral(&_2, "(", 1);
	3176	+ PutStr(0 /* _1 /, &out, &_2);
	3177	+ string$dest(&_2);
	3178	+ }
	3179	+ {
	3180	+ uint64_t _2; memset(&_2, 0, sizeof(uint64_t));
	3181	+ const struct stack/tree2/ _3 = &(tree).left;
	3182	+ PrintTree2Match(&_2, &out, &_3);
	3183	+ _IGNORE_(_2);
	3184	+ }
	3185	+ {
	3186	+ struct string _3; memset(&_3, 0, sizeof(struct string));
	3187	+ init$fromliteral(&_3, ",", 1);
	3188	+ PutStr(0 /* _2 /, &out, &_3);
	3189	+ string$dest(&_3);
	3190	+ }
	3191	+ {
	3192	+ uint64_t _3; memset(&_3, 0, sizeof(uint64_t));
	3193	+ const struct stack/tree2/ _4 = &(tree).right;
	3194	+ PrintTree2Match(&_3, &out, &_4);
	3195	+ _IGNORE_(_3);
	3196	+ }
	3197	+ {
	3198	+ struct string _4; memset(&_4, 0, sizeof(struct string));
	3199	+ init$fromliteral(&_4, ")", 1);
	3200	+ PutStr(0 /* _3 /, &out, &_4);
	3201	+ string$dest(&_4);
	3202	+ }
	3203	+ uint64_t _4; memset(&_4, 0, sizeof(uint64_t));
	3204	+ _4 = 0;
	3205	+ *_0 = _4;
	3206	+ _IGNORE_(_4);
	3207	+ }
	3208	+}
	3209	+
	3210	+
	3211	+void PrintTree2Match(uint64_t const _0, const struct StreamOut const _1, const struct stack/tree2/ *const _2)
	3212	+{
	3213	+ PrintTree2Match$1(_0, &(_1), &(_2));
	3214	+}
	3215	+
3141	3216	void PrintTree2(void const _0, const struct StreamOut const out, const struct stack/tree2/ *const t)
3142	3217	{
3143	3218	{

		@@ -3197,7 +3272,7 @@
3197	3272	{
3198	3273	const struct leaf t = ((_1).leaf).data;
3199	3274	{
3200		- empty(&_0, sizeof(struct tree2), (void ()(void ))tree2$dest, (void ()(void , const void ))tree2$copy, 426);
	3275	+ empty(&_0, sizeof(struct tree2), (void ()(void ))tree2$dest, (void ()(void , const void ))tree2$copy, 442);
3201	3276	}
3202	3277	__SUPPRESS_WARNING_UNUSED_VARIABLE__(t);
3203	3278	break;

		@@ -3222,7 +3297,7 @@
3222	3297	free$(&_4, sizeof(struct tree2), (void ()(void ))tree2$dest);
3223	3298	free$(&_3, sizeof(struct tree2), (void ()(void ))tree2$dest);
3224	3299	}
3225		- solid(&_0, &_2, sizeof(struct tree2), (void ()(void ))tree2$dest, (void ()(void , const void ))tree2$copy, 427);
	3300	+ solid(&_0, &_2, sizeof(struct tree2), (void ()(void ))tree2$dest, (void ()(void , const void ))tree2$copy, 443);
3226	3301	tree2$dest(&_2);
3227	3302	}
3228	3303	break;

		@@ -3285,7 +3360,7 @@
3285	3360	{
3286	3361	struct stack/string2$/ _pair; memset(&_pair, 0, sizeof(struct stack/string2$/));
3287	3362	{
3288		- pop_opt(&_pair, &data, sizeof(struct string2$), (void ()(void ))string2$$dest, (void ()(void , const void ))string2$$copy, 437);
	3363	+ pop_opt(&_pair, &data, sizeof(struct string2$), (void ()(void ))string2$$dest, (void ()(void , const void ))string2$$copy, 453);
3289	3364	}
3290	3365	const struct stack/string2$/ *_1 = &(_pair);
3291	3366	if(!(*_1).size)

		@@ -3405,7 +3480,7 @@
3405	3480	{
3406	3481	struct stack/tree2$/ _pair; memset(&_pair, 0, sizeof(struct stack/tree2$/));
3407	3482	{
3408		- pop_opt(&_pair, &data, sizeof(struct tree2$), (void ()(void ))tree2$$dest, (void ()(void , const void ))tree2$$copy, 464);
	3483	+ pop_opt(&_pair, &data, sizeof(struct tree2$), (void ()(void ))tree2$$dest, (void ()(void , const void ))tree2$$copy, 480);
3409	3484	}
3410	3485	const struct stack/tree2$/ *_1 = &(_pair);
3411	3486	if(!(*_1).size)

		@@ -3484,7 +3559,7 @@
3484	3559	_n = *n - 1;
3485	3560	{
3486	3561	{
3487		- push(0 /* _2 /, &s, &_n, sizeof(uint64_t), 0/DEST/, 0/COPY/, 483);
	3562	+ push(0 /* _2 /, &s, &_n, sizeof(uint64_t), 0/DEST/, 0/COPY/, 499);
3488	3563	}
3489	3564	{
3490	3565	fill(0 /* _3 /, &s, &_n);

		@@ -3505,7 +3580,7 @@
3505	3580	{
3506	3581	struct stack/u64/ _v; memset(&_v, 0, sizeof(struct stack/u64/));
3507	3582	{
3508		- pop_opt(&_v, &s, sizeof(uint64_t), 0/DEST/, 0/COPY*/, 493);
	3583	+ pop_opt(&_v, &s, sizeof(uint64_t), 0/DEST/, 0/COPY*/, 509);
3509	3584	}
3510	3585	const struct stack/u64/ *_1 = &(_v);
3511	3586	if(!(*_1).size)

		@@ -3591,7 +3666,7 @@
3591	3666	{
3592	3667	uint64_t _6; memset(&_6, 0, sizeof(uint64_t));
3593	3668	_6 = 12345;
3594		- push(0 /* _5 /, &_s, &_6, sizeof(uint64_t), 0/DEST/, 0/COPY*/, 520);
	3669	+ push(0 /* _5 /, &_s, &_6, sizeof(uint64_t), 0/DEST/, 0/COPY*/, 536);
3595	3670	_IGNORE_(_6);
3596	3671	}
3597	3672	{

		@@ -3789,7 +3864,7 @@
3789	3864	{
3790	3865	struct stack/u8/ _t; memset(&_t, 0, sizeof(struct stack/u8/));
3791	3866	{
3792		- push(0 /* _5 /, &_t, &s, sizeof(uint8_t), 0/DEST/, 0/COPY/, 593);
	3867	+ push(0 /* _5 /, &_t, &s, sizeof(uint8_t), 0/DEST/, 0/COPY/, 609);
3793	3868	}
3794	3869	clone$(&_4, &_t, sizeof(uint8_t), 0/DEST/, 0/COPY/);
3795	3870	free$(&_t, sizeof(uint8_t), 0/DEST/);

		@@ -4546,7 +4621,7 @@
4546	4621	_9 = 5;
4547	4622	struct stack/string/ _10; memset(&_10, 0, sizeof(struct stack/string/));
4548	4623	{
4549		- empty(&_10, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void *))string$copy, 622);
	4624	+ empty(&_10, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void *))string$copy, 638);
4550	4625	}
4551	4626	F(&_4, &*_5, &_6, &_7, &_8, &_9, &_10);
4552	4627	free$(&_10, sizeof(struct string), (void ()(void ))string$dest);

		@@ -4614,7 +4689,7 @@
4614	4689	_11 = 0;
4615	4690	struct stack/string/ _12; memset(&_12, 0, sizeof(struct stack/string/));
4616	4691	{
4617		- empty(&_12, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void *))string$copy, 623);
	4692	+ empty(&_12, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void *))string$copy, 639);
4618	4693	}
4619	4694	F(&_6, &*_7, &_8, &_9, &_10, &_11, &_12);
4620	4695	free$(&_12, sizeof(struct string), (void ()(void ))string$dest);

		@@ -4684,7 +4759,7 @@
4684	4759	{
4685	4760	struct string _15; memset(&_15, 0, sizeof(struct string));
4686	4761	init$fromliteral(&_15, "test optional", 13);
4687		- solid(&_14, &_15, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void *))string$copy, 624);
	4762	+ solid(&_14, &_15, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void *))string$copy, 640);
4688	4763	string$dest(&_15);
4689	4764	}
4690	4765	F(&_8, &*_9, &_10, &_11, &_12, &_13, &_14);

		@@ -4757,7 +4832,7 @@
4757	4832	_13 = 0;
4758	4833	struct stack/string/ _14; memset(&_14, 0, sizeof(struct stack/string/));
4759	4834	{
4760		- empty(&_14, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void *))string$copy, 625);
	4835	+ empty(&_14, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void *))string$copy, 641);
4761	4836	}
4762	4837	F(&_8, &*_9, &_10, &_11, &_12, &_13, &_14);
4763	4838	free$(&_14, sizeof(struct string), (void ()(void ))string$dest);

		@@ -4824,7 +4899,7 @@
4824	4899	_14 = 0;
4825	4900	struct stack/string/ _15; memset(&_15, 0, sizeof(struct stack/string/));
4826	4901	{
4827		- empty(&_15, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void *))string$copy, 626);
	4902	+ empty(&_15, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void *))string$copy, 642);
4828	4903	}
4829	4904	F(&_9, &*_10, &_11, &_12, &_13, &_14, &_15);
4830	4905	free$(&_15, sizeof(struct string), (void ()(void ))string$dest);

		@@ -4891,25 +4966,25 @@
4891	4966	{
4892	4967	struct string _14; memset(&_14, 0, sizeof(struct string));
4893	4968	init$fromliteral(&_14, "This", 4);
4894		- push(0 /* _13 /, &_orig, &_14, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void ))string$copy, 635);
	4969	+ push(0 /* _13 /, &_orig, &_14, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void ))string$copy, 651);
4895	4970	string$dest(&_14);
4896	4971	}
4897	4972	{
4898	4973	struct string _15; memset(&_15, 0, sizeof(struct string));
4899	4974	init$fromliteral(&_15, "is", 2);
4900		- push(0 /* _14 /, &_orig, &_15, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void ))string$copy, 636);
	4975	+ push(0 /* _14 /, &_orig, &_15, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void ))string$copy, 652);
4901	4976	string$dest(&_15);
4902	4977	}
4903	4978	{
4904	4979	struct string _16; memset(&_16, 0, sizeof(struct string));
4905	4980	init$fromliteral(&_16, "not", 3);
4906		- push(0 /* _15 /, &_orig, &_16, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void ))string$copy, 637);
	4981	+ push(0 /* _15 /, &_orig, &_16, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void ))string$copy, 653);
4907	4982	string$dest(&_16);
4908	4983	}
4909	4984	{
4910	4985	struct string _17; memset(&_17, 0, sizeof(struct string));
4911	4986	init$fromliteral(&_17, "reduced", 7);
4912		- push(0 /* _16 /, &_orig, &_17, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void ))string$copy, 638);
	4987	+ push(0 /* _16 /, &_orig, &_17, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void ))string$copy, 654);
4913	4988	string$dest(&_17);
4914	4989	}
4915	4990	{

		@@ -4983,7 +5058,7 @@
4983	5058	string$dest(&_30);
4984	5059	string$dest(&_29);
4985	5060	}
4986		- push(0 /* _27 /, &_data, &_28, sizeof(struct string2$), (void ()(void ))string2$$dest, (void ()(void , const void ))string2$$copy, 655);
	5061	+ push(0 /* _27 /, &_data, &_28, sizeof(struct string2$), (void ()(void ))string2$$dest, (void ()(void , const void ))string2$$copy, 671);
4987	5062	string2$$dest(&_28);
4988	5063	}
4989	5064	{

		@@ -4997,7 +5072,7 @@
4997	5072	string$dest(&_31);
4998	5073	string$dest(&_30);
4999	5074	}
5000		- push(0 /* _28 /, &_data, &_29, sizeof(struct string2$), (void ()(void ))string2$$dest, (void ()(void , const void ))string2$$copy, 656);
	5075	+ push(0 /* _28 /, &_data, &_29, sizeof(struct string2$), (void ()(void ))string2$$dest, (void ()(void , const void ))string2$$copy, 672);
5001	5076	string2$$dest(&_29);
5002	5077	}
5003	5078	{

		@@ -5011,7 +5086,7 @@
5011	5086	string$dest(&_32);
5012	5087	string$dest(&_31);
5013	5088	}
5014		- push(0 /* _29 /, &_data, &_30, sizeof(struct string2$), (void ()(void ))string2$$dest, (void ()(void , const void ))string2$$copy, 657);
	5089	+ push(0 /* _29 /, &_data, &_30, sizeof(struct string2$), (void ()(void ))string2$$dest, (void ()(void , const void ))string2$$copy, 673);
5015	5090	string2$$dest(&_30);
5016	5091	}
5017	5092	{

		@@ -5025,7 +5100,7 @@
5025	5100	string$dest(&_33);
5026	5101	string$dest(&_32);
5027	5102	}
5028		- push(0 /* _30 /, &_data, &_31, sizeof(struct string2$), (void ()(void ))string2$$dest, (void ()(void , const void ))string2$$copy, 658);
	5103	+ push(0 /* _30 /, &_data, &_31, sizeof(struct string2$), (void ()(void ))string2$$dest, (void ()(void , const void ))string2$$copy, 674);
5029	5104	string2$$dest(&_31);
5030	5105	}
5031	5106	{

		@@ -5039,7 +5114,7 @@
5039	5114	string$dest(&_34);
5040	5115	string$dest(&_33);
5041	5116	}
5042		- push(0 /* _31 /, &_data, &_32, sizeof(struct string2$), (void ()(void ))string2$$dest, (void ()(void , const void ))string2$$copy, 659);
	5117	+ push(0 /* _31 /, &_data, &_32, sizeof(struct string2$), (void ()(void ))string2$$dest, (void ()(void , const void ))string2$$copy, 675);
5043	5118	string2$$dest(&_32);
5044	5119	}
5045	5120	{

		@@ -5053,7 +5128,7 @@
5053	5128	string$dest(&_35);
5054	5129	string$dest(&_34);
5055	5130	}
5056		- push(0 /* _32 /, &_data, &_33, sizeof(struct string2$), (void ()(void ))string2$$dest, (void ()(void , const void ))string2$$copy, 660);
	5131	+ push(0 /* _32 /, &_data, &_33, sizeof(struct string2$), (void ()(void ))string2$$dest, (void ()(void , const void ))string2$$copy, 676);
5057	5132	string2$$dest(&_33);
5058	5133	}
5059	5134	{

		@@ -5067,7 +5142,7 @@
5067	5142	string$dest(&_36);
5068	5143	string$dest(&_35);
5069	5144	}
5070		- push(0 /* _33 /, &_data, &_34, sizeof(struct string2$), (void ()(void ))string2$$dest, (void ()(void , const void ))string2$$copy, 661);
	5145	+ push(0 /* _33 /, &_data, &_34, sizeof(struct string2$), (void ()(void ))string2$$dest, (void ()(void , const void ))string2$$copy, 677);
5071	5146	string2$$dest(&_34);
5072	5147	}
5073	5148	{

		@@ -5081,7 +5156,7 @@
5081	5156	string$dest(&_37);
5082	5157	string$dest(&_36);
5083	5158	}
5084		- push(0 /* _34 /, &_data, &_35, sizeof(struct string2$), (void ()(void ))string2$$dest, (void ()(void , const void ))string2$$copy, 662);
	5159	+ push(0 /* _34 /, &_data, &_35, sizeof(struct string2$), (void ()(void ))string2$$dest, (void ()(void , const void ))string2$$copy, 678);
5085	5160	string2$$dest(&_35);
5086	5161	}
5087	5162	{

		@@ -5095,7 +5170,7 @@
5095	5170	string$dest(&_38);
5096	5171	string$dest(&_37);
5097	5172	}
5098		- push(0 /* _35 /, &_data, &_36, sizeof(struct string2$), (void ()(void ))string2$$dest, (void ()(void , const void ))string2$$copy, 663);
	5173	+ push(0 /* _35 /, &_data, &_36, sizeof(struct string2$), (void ()(void ))string2$$dest, (void ()(void , const void ))string2$$copy, 679);
5099	5174	string2$$dest(&_36);
5100	5175	}
5101	5176	{

		@@ -5109,7 +5184,7 @@
5109	5184	string$dest(&_39);
5110	5185	string$dest(&_38);
5111	5186	}
5112		- push(0 /* _36 /, &_data, &_37, sizeof(struct string2$), (void ()(void ))string2$$dest, (void ()(void , const void ))string2$$copy, 664);
	5187	+ push(0 /* _36 /, &_data, &_37, sizeof(struct string2$), (void ()(void ))string2$$dest, (void ()(void , const void ))string2$$copy, 680);
5113	5188	string2$$dest(&_37);
5114	5189	}
5115	5190	{

		@@ -5248,7 +5323,7 @@
5248	5323	tree$dest(&_31);
5249	5324	tree$dest(&_30);
5250	5325	}
5251		- push(0 /* _28 /, &_data, &_29, sizeof(struct tree2$), (void ()(void ))tree2$$dest, (void ()(void , const void ))tree2$$copy, 680);
	5326	+ push(0 /* _28 /, &_data, &_29, sizeof(struct tree2$), (void ()(void ))tree2$$dest, (void ()(void , const void ))tree2$$copy, 696);
5252	5327	tree2$$dest(&_29);
5253	5328	}
5254	5329	{

		@@ -5350,7 +5425,7 @@
5350	5425	tree$dest(&_32);
5351	5426	tree$dest(&_31);
5352	5427	}
5353		- push(0 /* _29 /, &_data, &_30, sizeof(struct tree2$), (void ()(void ))tree2$$dest, (void ()(void , const void ))tree2$$copy, 681);
	5428	+ push(0 /* _29 /, &_data, &_30, sizeof(struct tree2$), (void ()(void ))tree2$$dest, (void ()(void , const void ))tree2$$copy, 697);
5354	5429	tree2$$dest(&_30);
5355	5430	}
5356	5431	{

		@@ -5452,7 +5527,7 @@
5452	5527	tree$dest(&_33);
5453	5528	tree$dest(&_32);
5454	5529	}
5455		- push(0 /* _30 /, &_data, &_31, sizeof(struct tree2$), (void ()(void ))tree2$$dest, (void ()(void , const void ))tree2$$copy, 682);
	5530	+ push(0 /* _30 /, &_data, &_31, sizeof(struct tree2$), (void ()(void ))tree2$$dest, (void ()(void , const void ))tree2$$copy, 698);
5456	5531	tree2$$dest(&_31);
5457	5532	}
5458	5533	{

		@@ -5502,7 +5577,7 @@
5502	5577	tree$dest(&_34);
5503	5578	tree$dest(&_33);
5504	5579	}
5505		- push(0 /* _31 /, &_data, &_32, sizeof(struct tree2$), (void ()(void ))tree2$$dest, (void ()(void , const void ))tree2$$copy, 683);
	5580	+ push(0 /* _31 /, &_data, &_32, sizeof(struct tree2$), (void ()(void ))tree2$$dest, (void ()(void , const void ))tree2$$copy, 699);
5506	5581	tree2$$dest(&_32);
5507	5582	}
5508	5583	{

		@@ -5539,7 +5614,7 @@
5539	5614	tree$dest(&_35);
5540	5615	tree$dest(&_34);
5541	5616	}
5542		- push(0 /* _32 /, &_data, &_33, sizeof(struct tree2$), (void ()(void ))tree2$$dest, (void ()(void , const void ))tree2$$copy, 684);
	5617	+ push(0 /* _32 /, &_data, &_33, sizeof(struct tree2$), (void ()(void ))tree2$$dest, (void ()(void , const void ))tree2$$copy, 700);
5543	5618	tree2$$dest(&_33);
5544	5619	}
5545	5620	{

		@@ -5576,7 +5651,7 @@
5576	5651	tree$dest(&_36);
5577	5652	tree$dest(&_35);
5578	5653	}
5579		- push(0 /* _33 /, &_data, &_34, sizeof(struct tree2$), (void ()(void ))tree2$$dest, (void ()(void , const void ))tree2$$copy, 685);
	5654	+ push(0 /* _33 /, &_data, &_34, sizeof(struct tree2$), (void ()(void ))tree2$$dest, (void ()(void , const void ))tree2$$copy, 701);
5580	5655	tree2$$dest(&_34);
5581	5656	}
5582	5657	{

		@@ -5600,7 +5675,7 @@
5600	5675	tree$dest(&_37);
5601	5676	tree$dest(&_36);
5602	5677	}
5603		- push(0 /* _34 /, &_data, &_35, sizeof(struct tree2$), (void ()(void ))tree2$$dest, (void ()(void , const void ))tree2$$copy, 686);
	5678	+ push(0 /* _34 /, &_data, &_35, sizeof(struct tree2$), (void ()(void ))tree2$$dest, (void ()(void , const void ))tree2$$copy, 702);
5604	5679	tree2$$dest(&_35);
5605	5680	}
5606	5681	{

		@@ -5612,19 +5687,19 @@
5612	5687	{
5613	5688	struct string _29; memset(&_29, 0, sizeof(struct string));
5614	5689	init$fromliteral(&_29, "123", 3);
5615		- push(0 /* _28 /, &_words, &_29, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void ))string$copy, 692);
	5690	+ push(0 /* _28 /, &_words, &_29, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void ))string$copy, 708);
5616	5691	string$dest(&_29);
5617	5692	}
5618	5693	{
5619	5694	struct string _30; memset(&_30, 0, sizeof(struct string));
5620	5695	init$fromliteral(&_30, "456", 3);
5621		- push(0 /* _29 /, &_words, &_30, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void ))string$copy, 692);
	5696	+ push(0 /* _29 /, &_words, &_30, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void ))string$copy, 708);
5622	5697	string$dest(&_30);
5623	5698	}
5624	5699	{
5625	5700	struct string _31; memset(&_31, 0, sizeof(struct string));
5626	5701	init$fromliteral(&_31, "789", 3);
5627		- push(0 /* _30 /, &_words, &_31, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void ))string$copy, 692);
	5702	+ push(0 /* _30 /, &_words, &_31, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void ))string$copy, 708);
5628	5703	string$dest(&_31);
5629	5704	}
5630	5705	{

		@@ -5814,184 +5889,202 @@
5814	5889	string$dest(&_45);
5815	5890	}
5816	5891	{
	5892	+ uint64_t _44; memset(&_44, 0, sizeof(uint64_t));
5817	5893	const struct StreamOut _45 = &(streams).out;
5818	5894	struct stack/tree2/ _46; memset(&_46, 0, sizeof(struct stack/tree2/));
5819	5895	{
5820	5896	tree_to_tree2(&_46, &_tree);
5821	5897	}
5822		- PrintTree2(0 /* _44 /, &_45, &_46);
	5898	+ PrintTree2Match(&_44, &*_45, &_46);
5823	5899	free$(&_46, sizeof(struct tree2), (void ()(void ))tree2$dest);
	5900	+ _IGNORE_(_44);
5824	5901	}
5825	5902	{
	5903	+ const struct StreamOut _45 = &(streams).out;
	5904	+ struct string _46; memset(&_46, 0, sizeof(struct string));
	5905	+ init$fromliteral(&_46, "", 0);
	5906	+ PutStrLn(0 /* _44 /, &_45, &_46);
	5907	+ string$dest(&_46);
	5908	+ }
	5909	+ {
5826	5910	const struct StreamOut _46 = &(streams).out;
5827		- struct string _47; memset(&_47, 0, sizeof(struct string));
5828		- init$fromliteral(&_47, "", 0);
5829		- PutStrLn(0 /* _45 /, &_46, &_47);
5830		- string$dest(&_47);
	5911	+ struct stack/tree2/ _47; memset(&_47, 0, sizeof(struct stack/tree2/));
	5912	+ {
	5913	+ tree_to_tree2(&_47, &_tree);
	5914	+ }
	5915	+ PrintTree2(0 /* _45 /, &_46, &_47);
	5916	+ free$(&_47, sizeof(struct tree2), (void ()(void ))tree2$dest);
5831	5917	}
5832	5918	{
5833	5919	const struct StreamOut _47 = &(streams).out;
5834		- Print$tree(0 /* _46 /, &_47, &_tree);
	5920	+ struct string _48; memset(&_48, 0, sizeof(struct string));
	5921	+ init$fromliteral(&_48, "", 0);
	5922	+ PutStrLn(0 /* _46 /, &_47, &_48);
	5923	+ string$dest(&_48);
5835	5924	}
5836	5925	{
5837	5926	const struct StreamOut _48 = &(streams).out;
5838		- struct string _49; memset(&_49, 0, sizeof(struct string));
5839		- init$fromliteral(&_49, "\n", 1);
5840		- PutStr(0 /* _47 /, &_48, &_49);
5841		- string$dest(&_49);
	5927	+ Print$tree(0 /* _47 /, &_48, &_tree);
5842	5928	}
5843	5929	{
	5930	+ const struct StreamOut _49 = &(streams).out;
	5931	+ struct string _50; memset(&_50, 0, sizeof(struct string));
	5932	+ init$fromliteral(&_50, "\n", 1);
	5933	+ PutStr(0 /* _48 /, &_49, &_50);
	5934	+ string$dest(&_50);
	5935	+ }
	5936	+ {
5844	5937	{
5845		- const struct StreamOut _50 = &(streams).out;
5846		- struct string _51; memset(&_51, 0, sizeof(struct string));
5847		- init$fromliteral(&_51, "for-test 1: ", 12);
5848		- PutStrLn(0 /* _49 /, &_50, &_51);
5849		- string$dest(&_51);
	5938	+ const struct StreamOut _51 = &(streams).out;
	5939	+ struct string _52; memset(&_52, 0, sizeof(struct string));
	5940	+ init$fromliteral(&_52, "for-test 1: ", 12);
	5941	+ PutStrLn(0 /* _50 /, &_51, &_52);
	5942	+ string$dest(&_52);
5850	5943	}
5851	5944	uint32_t _n; memset(&_n, 0, sizeof(uint32_t));
5852	5945	_n = 5;
5853	5946	{
5854		- uint32_t _50 = _n;
5855		- uint32_t *n = &_50;
	5947	+ uint32_t _51 = _n;
	5948	+ uint32_t *n = &_51;
5856	5949	while((*n)--)
5857	5950	{
5858	5951	{
5859		- const struct StreamOut _52 = &(streams).out;
5860		- Print$u32(0 /* _51 /, &_52, &*n);
	5952	+ const struct StreamOut _53 = &(streams).out;
	5953	+ Print$u32(0 /* _52 /, &_53, &*n);
5861	5954	}
5862	5955	}
5863	5956	}
5864	5957	{
5865		- const struct StreamOut _52 = &(streams).out;
5866		- struct string _53; memset(&_53, 0, sizeof(struct string));
5867		- init$fromliteral(&_53, "", 0);
5868		- PutStrLn(0 /* _51 /, &_52, &_53);
5869		- string$dest(&_53);
5870		- }
5871		- {
5872	5958	const struct StreamOut _53 = &(streams).out;
5873	5959	struct string _54; memset(&_54, 0, sizeof(struct string));
5874		- init$fromliteral(&_54, "for-test 2: ", 12);
	5960	+ init$fromliteral(&_54, "", 0);
5875	5961	PutStrLn(0 /* _52 /, &_53, &_54);
5876	5962	string$dest(&_54);
5877	5963	}
5878	5964	{
5879		- uint32_t _53 = _n;
5880		- uint32_t *n = &_53;
	5965	+ const struct StreamOut _54 = &(streams).out;
	5966	+ struct string _55; memset(&_55, 0, sizeof(struct string));
	5967	+ init$fromliteral(&_55, "for-test 2: ", 12);
	5968	+ PutStrLn(0 /* _53 /, &_54, &_55);
	5969	+ string$dest(&_55);
	5970	+ }
	5971	+ {
	5972	+ uint32_t _54 = _n;
	5973	+ uint32_t *n = &_54;
5881	5974	while((*n)--)
5882	5975	{
5883	5976	{
5884		- const struct StreamOut _55 = &(streams).out;
5885		- struct string _56; memset(&_56, 0, sizeof(struct string));
5886		- init$fromliteral(&_56, ".", 1);
5887		- PutStr(0 /* _54 /, &_55, &_56);
5888		- string$dest(&_56);
	5977	+ const struct StreamOut _56 = &(streams).out;
	5978	+ struct string _57; memset(&_57, 0, sizeof(struct string));
	5979	+ init$fromliteral(&_57, ".", 1);
	5980	+ PutStr(0 /* _55 /, &_56, &_57);
	5981	+ string$dest(&_57);
5889	5982	}
5890	5983	}
5891	5984	__SUPPRESS_WARNING_UNUSED_VARIABLE__(&*n);
5892	5985	}
5893	5986	{
5894		- const struct StreamOut _55 = &(streams).out;
5895		- struct string _56; memset(&_56, 0, sizeof(struct string));
5896		- init$fromliteral(&_56, "", 0);
5897		- PutStrLn(0 /* _54 /, &_55, &_56);
5898		- string$dest(&_56);
5899		- }
5900		- {
5901	5987	const struct StreamOut _56 = &(streams).out;
5902	5988	struct string _57; memset(&_57, 0, sizeof(struct string));
5903		- init$fromliteral(&_57, "for-test 3: ", 12);
	5989	+ init$fromliteral(&_57, "", 0);
5904	5990	PutStrLn(0 /* _55 /, &_56, &_57);
5905	5991	string$dest(&_57);
5906	5992	}
	5993	+ {
	5994	+ const struct StreamOut _57 = &(streams).out;
	5995	+ struct string _58; memset(&_58, 0, sizeof(struct string));
	5996	+ init$fromliteral(&_58, "for-test 3: ", 12);
	5997	+ PutStrLn(0 /* _56 /, &_57, &_58);
	5998	+ string$dest(&_58);
	5999	+ }
5907	6000	struct string _s; memset(&_s, 0, sizeof(struct string));
5908	6001	init$fromliteral(&_s, "Test!", 5);
5909	6002	struct stack/u8/ _sd; memset(&_sd, 0, sizeof(struct stack/u8/));
5910	6003	clone$(&_sd, &(_s).data, sizeof(uint8_t), 0/DEST/, 0/COPY/);
5911		- const struct stack/u8/ *_56 = &(_sd);
5912		- for(uint64_t _57 = 0; _57 < (*_56).fill; ++_57)
	6004	+ const struct stack/u8/ *_57 = &(_sd);
	6005	+ for(uint64_t _58 = 0; _58 < (*_57).fill; ++_58)
5913	6006	{
5914		- const uint8_t sd = &((uint8_t )((*_56).data))[_57];
	6007	+ const uint8_t sd = &((uint8_t )((*_57).data))[_58];
5915	6008	{
5916		- const struct StreamOut _59 = &(streams).out;
5917		- uint8_t _60; memset(&_60, 0, sizeof(uint8_t));
5918		- _60 = 35;
5919		- Put(0 /* _58 /, &_59, &_60);
5920		- _IGNORE_(_60);
	6009	+ const struct StreamOut _60 = &(streams).out;
	6010	+ uint8_t _61; memset(&_61, 0, sizeof(uint8_t));
	6011	+ _61 = 35;
	6012	+ Put(0 /* _59 /, &_60, &_61);
	6013	+ _IGNORE_(_61);
5921	6014	}
5922	6015	__SUPPRESS_WARNING_UNUSED_VARIABLE__(&*sd);
5923	6016	}
5924	6017	{
5925		- const struct StreamOut _59 = &(streams).out;
5926		- struct string _60; memset(&_60, 0, sizeof(struct string));
5927		- init$fromliteral(&_60, "", 0);
5928		- PutStrLn(0 /* _58 /, &_59, &_60);
5929		- string$dest(&_60);
5930		- }
5931		- {
5932	6018	const struct StreamOut _60 = &(streams).out;
5933	6019	struct string _61; memset(&_61, 0, sizeof(struct string));
5934		- init$fromliteral(&_61, "for-test 4: ", 12);
	6020	+ init$fromliteral(&_61, "", 0);
5935	6021	PutStrLn(0 /* _59 /, &_60, &_61);
5936	6022	string$dest(&_61);
5937	6023	}
5938	6024	{
	6025	+ const struct StreamOut _61 = &(streams).out;
	6026	+ struct string _62; memset(&_62, 0, sizeof(struct string));
	6027	+ init$fromliteral(&_62, "for-test 4: ", 12);
	6028	+ PutStrLn(0 /* _60 /, &_61, &_62);
	6029	+ string$dest(&_62);
	6030	+ }
	6031	+ {
5939	6032	{
5940		- struct string _61; memset(&_61, 0, sizeof(struct string));
5941		- init$fromliteral(&_61, "Test!", 5);
5942		- struct string *s = &_61;
	6033	+ struct string _62; memset(&_62, 0, sizeof(struct string));
	6034	+ init$fromliteral(&_62, "Test!", 5);
	6035	+ struct string *s = &_62;
5943	6036	{
5944		- struct stack/u8/ _62; memset(&_62, 0, sizeof(struct stack/u8/));
5945		- clone$(&_62, &(s).data, sizeof(uint8_t), 0/DEST/, 0/COPY*/);
5946		- struct stack/u8/ *sd = &_62;
	6037	+ struct stack/u8/ _63; memset(&_63, 0, sizeof(struct stack/u8/));
	6038	+ clone$(&_63, &(s).data, sizeof(uint8_t), 0/DEST/, 0/COPY*/);
	6039	+ struct stack/u8/ *sd = &_63;
5947	6040	{
5948		- const struct StreamOut _64 = &(streams).out;
5949		- PrintStack(0 /* _63 /, &_64, &*sd);
5950		- }
5951		- {
5952	6041	const struct StreamOut _65 = &(streams).out;
5953		- struct string _66; memset(&_66, 0, sizeof(struct string));
5954		- init$fromliteral(&_66, "", 0);
5955		- PutStrLn(0 /* _64 /, &_65, &_66);
5956		- string$dest(&_66);
	6042	+ PrintStack(0 /* _64 /, &_65, &*sd);
5957	6043	}
5958	6044	{
5959		- uint8_t _66; memset(&_66, 0, sizeof(uint8_t));
5960		- _66 = 35;
5961		- WipeMutStack(0 /* _65 /, &sd, &_66);
5962		- _IGNORE_(_66);
	6045	+ const struct StreamOut _66 = &(streams).out;
	6046	+ struct string _67; memset(&_67, 0, sizeof(struct string));
	6047	+ init$fromliteral(&_67, "", 0);
	6048	+ PutStrLn(0 /* _65 /, &_66, &_67);
	6049	+ string$dest(&_67);
5963	6050	}
5964	6051	{
5965		- const struct StreamOut _67 = &(streams).out;
5966		- PrintStack(0 /* _66 /, &_67, &*sd);
	6052	+ uint8_t _67; memset(&_67, 0, sizeof(uint8_t));
	6053	+ _67 = 35;
	6054	+ WipeMutStack(0 /* _66 /, &sd, &_67);
	6055	+ _IGNORE_(_67);
5967	6056	}
5968	6057	{
5969	6058	const struct StreamOut _68 = &(streams).out;
5970		- struct string _69; memset(&_69, 0, sizeof(struct string));
5971		- init$fromliteral(&_69, "", 0);
5972		- PutStrLn(0 /* _67 /, &_68, &_69);
5973		- string$dest(&_69);
	6059	+ PrintStack(0 /* _67 /, &_68, &*sd);
5974	6060	}
5975	6061	{
5976		- uint8_t _69; memset(&_69, 0, sizeof(uint8_t));
5977		- _69 = 42;
5978		- WipeStackMut(0 /* _68 /, &sd, &_69);
5979		- _IGNORE_(_69);
	6062	+ const struct StreamOut _69 = &(streams).out;
	6063	+ struct string _70; memset(&_70, 0, sizeof(struct string));
	6064	+ init$fromliteral(&_70, "", 0);
	6065	+ PutStrLn(0 /* _68 /, &_69, &_70);
	6066	+ string$dest(&_70);
5980	6067	}
5981	6068	{
5982		- const struct StreamOut _70 = &(streams).out;
5983		- PrintStack(0 /* _69 /, &_70, &*sd);
	6069	+ uint8_t _70; memset(&_70, 0, sizeof(uint8_t));
	6070	+ _70 = 42;
	6071	+ WipeStackMut(0 /* _69 /, &sd, &_70);
	6072	+ _IGNORE_(_70);
5984	6073	}
5985	6074	{
5986	6075	const struct StreamOut _71 = &(streams).out;
5987		- struct string _72; memset(&_72, 0, sizeof(struct string));
5988		- init$fromliteral(&_72, "", 0);
5989		- PutStrLn(0 /* _70 /, &_71, &_72);
5990		- string$dest(&_72);
	6076	+ PrintStack(0 /* _70 /, &_71, &*sd);
5991	6077	}
5992		- free$(&_62, sizeof(uint8_t), 0/DEST/);
	6078	+ {
	6079	+ const struct StreamOut _72 = &(streams).out;
	6080	+ struct string _73; memset(&_73, 0, sizeof(struct string));
	6081	+ init$fromliteral(&_73, "", 0);
	6082	+ PutStrLn(0 /* _71 /, &_72, &_73);
	6083	+ string$dest(&_73);
5993	6084	}
5994		- string$dest(&_61);
	6085	+ free$(&_63, sizeof(uint8_t), 0/DEST/);
	6086	+ }
	6087	+ string$dest(&_62);
5995	6088	}
5996	6089	}
5997	6090	free$(&_sd, sizeof(uint8_t), 0/DEST/);

		@@ -5999,72 +6092,72 @@
5999	6092	_IGNORE_(_n);
6000	6093	}
6001	6094	{
6002		- const struct StreamOut _50 = &(streams).out;
6003		- TstStk$(0 /* _49 /, &_50);
6004		- }
6005		- {
6006	6095	const struct StreamOut _51 = &(streams).out;
6007		- TstDyn$(0 /* _50 /, &_51);
	6096	+ TstStk$(0 /* _50 /, &_51);
6008	6097	}
6009	6098	{
6010	6099	const struct StreamOut _52 = &(streams).out;
6011		- struct string _53; memset(&_53, 0, sizeof(struct string));
6012		- {
6013		- testTemporaryDynamics$(&_53);
6014		- }
6015		- PutStr(0 /* _51 /, &_52, &_53);
6016		- string$dest(&_53);
	6100	+ TstDyn$(0 /* _51 /, &_52);
6017	6101	}
6018	6102	{
6019	6103	const struct StreamOut _53 = &(streams).out;
6020	6104	struct string _54; memset(&_54, 0, sizeof(struct string));
6021	6105	{
6022		- struct string _55; memset(&_55, 0, sizeof(struct string));
6023		- init$fromliteral(&_55, "Hello ", 6);
6024		- struct string _56; memset(&_56, 0, sizeof(struct string));
6025		- init$fromliteral(&_56, "World\n", 6);
6026		- strcat$(&_54, &_55, &_56, 759);
6027		- string$dest(&_56);
6028		- string$dest(&_55);
	6106	+ testTemporaryDynamics$(&_54);
6029	6107	}
6030	6108	PutStr(0 /* _52 /, &_53, &_54);
6031	6109	string$dest(&_54);
6032	6110	}
	6111	+ {
	6112	+ const struct StreamOut _54 = &(streams).out;
	6113	+ struct string _55; memset(&_55, 0, sizeof(struct string));
	6114	+ {
	6115	+ struct string _56; memset(&_56, 0, sizeof(struct string));
	6116	+ init$fromliteral(&_56, "Hello ", 6);
	6117	+ struct string _57; memset(&_57, 0, sizeof(struct string));
	6118	+ init$fromliteral(&_57, "World\n", 6);
	6119	+ strcat$(&_55, &_56, &_57, 777);
	6120	+ string$dest(&_57);
	6121	+ string$dest(&_56);
	6122	+ }
	6123	+ PutStr(0 /* _53 /, &_54, &_55);
	6124	+ string$dest(&_55);
	6125	+ }
6033	6126	struct U$ _test; memset(&_test, 0, sizeof(struct U$));
6034	6127	{
6035		- struct string _53; memset(&_53, 0, sizeof(struct string));
6036		- init$fromliteral(&_53, "Hello???", 8);
6037		- s$(&_test, &_53);
6038		- string$dest(&_53);
	6128	+ struct string _54; memset(&_54, 0, sizeof(struct string));
	6129	+ init$fromliteral(&_54, "Hello???", 8);
	6130	+ s$(&_test, &_54);
	6131	+ string$dest(&_54);
6039	6132	}
6040	6133	{
6041		- struct string _53; memset(&_53, 0, sizeof(struct string));
6042		- init$fromliteral(&_53, "Hello Union!!!", 14);
6043		- s$(&_test, &_53);
6044		- string$dest(&_53);
	6134	+ struct string _54; memset(&_54, 0, sizeof(struct string));
	6135	+ init$fromliteral(&_54, "Hello Union!!!", 14);
	6136	+ s$(&_test, &_54);
	6137	+ string$dest(&_54);
6045	6138	}
6046	6139	{
6047		- const struct StreamOut _54 = &(streams).out;
6048		- struct string _55; memset(&_55, 0, sizeof(struct string));
	6140	+ const struct StreamOut _55 = &(streams).out;
	6141	+ struct string _56; memset(&_56, 0, sizeof(struct string));
6049	6142	{
6050		- getstr$(&_55, &_test);
	6143	+ getstr$(&_56, &_test);
6051	6144	}
6052		- PutStrLn(0 /* _53 /, &_54, &_55);
6053		- string$dest(&_55);
	6145	+ PutStrLn(0 /* _54 /, &_55, &_56);
	6146	+ string$dest(&_56);
6054	6147	}
6055		- struct U$ *_54 = &(_test);
6056		- switch((*_54).type)
	6148	+ struct U$ *_55 = &(_test);
	6149	+ switch((*_55).type)
6057	6150	{
6058	6151	case 0: // uint32_t x:
6059	6152	{
6060		- uint32_t test = &((_54).x);
	6153	+ uint32_t test = &((_55).x);
6061	6154	{
6062	6155	{
6063		- const struct StreamOut _57 = &(streams).out;
6064		- struct string _58; memset(&_58, 0, sizeof(struct string));
6065		- init$fromliteral(&_58, "u", 1);
6066		- PutStrLn(0 /* _56 /, &_57, &_58);
6067		- string$dest(&_58);
	6156	+ const struct StreamOut _58 = &(streams).out;
	6157	+ struct string _59; memset(&_59, 0, sizeof(struct string));
	6158	+ init$fromliteral(&_59, "u", 1);
	6159	+ PutStrLn(0 /* _57 /, &_58, &_59);
	6160	+ string$dest(&_59);
6068	6161	}
6069	6162	}
6070	6163	__SUPPRESS_WARNING_UNUSED_VARIABLE__(test);

		@@ -6072,13 +6165,13 @@
6072	6165	}
6073	6166	case 1: // bool b:
6074	6167	{
6075		- bool test = &((_54).b);
	6168	+ bool test = &((_55).b);
6076	6169	{
6077		- const struct StreamOut _57 = &(streams).out;
6078		- struct string _58; memset(&_58, 0, sizeof(struct string));
6079		- init$fromliteral(&_58, "nr", 2);
6080		- PutStrLn(0 /* _56 /, &_57, &_58);
6081		- string$dest(&_58);
	6170	+ const struct StreamOut _58 = &(streams).out;
	6171	+ struct string _59; memset(&_59, 0, sizeof(struct string));
	6172	+ init$fromliteral(&_59, "nr", 2);
	6173	+ PutStrLn(0 /* _57 /, &_58, &_59);
	6174	+ string$dest(&_59);
6082	6175	}
6083	6176	__SUPPRESS_WARNING_UNUSED_VARIABLE__(test);
6084	6177	break;

		@@ -6086,20 +6179,20 @@
6086	6179	case 2: // void v:
6087	6180	{
6088	6181	{
6089		- const struct StreamOut _58 = &(streams).out;
6090		- struct string _59; memset(&_59, 0, sizeof(struct string));
6091		- init$fromliteral(&_59, "v", 1);
6092		- PutStrLn(0 /* _57 /, &_58, &_59);
6093		- string$dest(&_59);
	6182	+ const struct StreamOut _59 = &(streams).out;
	6183	+ struct string _60; memset(&_60, 0, sizeof(struct string));
	6184	+ init$fromliteral(&_60, "v", 1);
	6185	+ PutStrLn(0 /* _58 /, &_59, &_60);
	6186	+ string$dest(&_60);
6094	6187	}
6095	6188	break;
6096	6189	}
6097	6190	case 3: // struct string s$:
6098	6191	{
6099		- struct string test = &((_54).s$);
	6192	+ struct string test = &((_55).s$);
6100	6193	{
6101		- const struct StreamOut _59 = &(streams).out;
6102		- PutStrLn(0 /* _58 /, &_59, &*test);
	6194	+ const struct StreamOut _60 = &(streams).out;
	6195	+ PutStrLn(0 /* _59 /, &_60, &*test);
6103	6196	}
6104	6197	break;
6105	6198	}

		@@ -6116,42 +6209,42 @@
6116	6209	{
6117	6210	two(&_en);
6118	6211	}
6119		- struct enu *_59 = &(_en);
6120		- switch((*_59).type)
	6212	+ struct enu *_60 = &(_en);
	6213	+ switch((*_60).type)
6121	6214	{
6122	6215	case 0: // void zero:
6123	6216	{
6124	6217	{
6125		- const struct StreamOut _61 = &(streams).out;
6126		- struct string _62; memset(&_62, 0, sizeof(struct string));
6127		- init$fromliteral(&_62, "zero", 4);
6128		- PutStrLn(0 /* _60 /, &_61, &_62);
6129		- string$dest(&_62);
6130		- }
6131		- break;
6132		- }
6133		- case 1: // void one:
6134		- {
6135		- {
6136	6218	const struct StreamOut _62 = &(streams).out;
6137	6219	struct string _63; memset(&_63, 0, sizeof(struct string));
6138		- init$fromliteral(&_63, "one", 3);
	6220	+ init$fromliteral(&_63, "zero", 4);
6139	6221	PutStrLn(0 /* _61 /, &_62, &_63);
6140	6222	string$dest(&_63);
6141	6223	}
6142	6224	break;
6143	6225	}
6144		- case 2: // void two:
	6226	+ case 1: // void one:
6145	6227	{
6146	6228	{
6147	6229	const struct StreamOut _63 = &(streams).out;
6148	6230	struct string _64; memset(&_64, 0, sizeof(struct string));
6149		- init$fromliteral(&_64, "two", 3);
	6231	+ init$fromliteral(&_64, "one", 3);
6150	6232	PutStrLn(0 /* _62 /, &_63, &_64);
6151	6233	string$dest(&_64);
6152	6234	}
6153	6235	break;
6154	6236	}
	6237	+ case 2: // void two:
	6238	+ {
	6239	+ {
	6240	+ const struct StreamOut _64 = &(streams).out;
	6241	+ struct string _65; memset(&_65, 0, sizeof(struct string));
	6242	+ init$fromliteral(&_65, "two", 3);
	6243	+ PutStrLn(0 /* _63 /, &_64, &_65);
	6244	+ string$dest(&_65);
	6245	+ }
	6246	+ break;
	6247	+ }
6155	6248	default:
6156	6249	{
6157	6250	fprintf(stderr, "INTERNAL ERROR IN SWITCH");

		@@ -6162,42 +6255,42 @@
6162	6255	{
6163	6256	zero2(&_en2);
6164	6257	}
6165		- struct enu2 *_63 = &(_en2);
6166		- switch((*_63).type)
	6258	+ struct enu2 *_64 = &(_en2);
	6259	+ switch((*_64).type)
6167	6260	{
6168	6261	case 0: // void zero2:
6169	6262	{
6170	6263	{
6171		- const struct StreamOut _65 = &(streams).out;
6172		- struct string _66; memset(&_66, 0, sizeof(struct string));
6173		- init$fromliteral(&_66, "zero2", 5);
6174		- PutStrLn(0 /* _64 /, &_65, &_66);
6175		- string$dest(&_66);
6176		- }
6177		- break;
6178		- }
6179		- case 1: // void one2:
6180		- {
6181		- {
6182	6264	const struct StreamOut _66 = &(streams).out;
6183	6265	struct string _67; memset(&_67, 0, sizeof(struct string));
6184		- init$fromliteral(&_67, "one2", 4);
	6266	+ init$fromliteral(&_67, "zero2", 5);
6185	6267	PutStrLn(0 /* _65 /, &_66, &_67);
6186	6268	string$dest(&_67);
6187	6269	}
6188	6270	break;
6189	6271	}
6190		- case 2: // void two2:
	6272	+ case 1: // void one2:
6191	6273	{
6192	6274	{
6193	6275	const struct StreamOut _67 = &(streams).out;
6194	6276	struct string _68; memset(&_68, 0, sizeof(struct string));
6195		- init$fromliteral(&_68, "two2", 4);
	6277	+ init$fromliteral(&_68, "one2", 4);
6196	6278	PutStrLn(0 /* _66 /, &_67, &_68);
6197	6279	string$dest(&_68);
6198	6280	}
6199	6281	break;
6200	6282	}
	6283	+ case 2: // void two2:
	6284	+ {
	6285	+ {
	6286	+ const struct StreamOut _68 = &(streams).out;
	6287	+ struct string _69; memset(&_69, 0, sizeof(struct string));
	6288	+ init$fromliteral(&_69, "two2", 4);
	6289	+ PutStrLn(0 /* _67 /, &_68, &_69);
	6290	+ string$dest(&_69);
	6291	+ }
	6292	+ break;
	6293	+ }
6201	6294	default:
6202	6295	{
6203	6296	fprintf(stderr, "INTERNAL ERROR IN SWITCH");

		@@ -6206,44 +6299,44 @@
6206	6299	}
6207	6300	struct stack/string/ _other; memset(&_other, 0, sizeof(struct stack/string/));
6208	6301	{
6209		- struct string _67; memset(&_67, 0, sizeof(struct string));
6210		- init$fromliteral(&_67, "SOLID", 5);
6211		- solid(&_other, &_67, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void *))string$copy, 786);
6212		- string$dest(&_67);
	6302	+ struct string _68; memset(&_68, 0, sizeof(struct string));
	6303	+ init$fromliteral(&_68, "SOLID", 5);
	6304	+ solid(&_other, &_68, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void *))string$copy, 804);
	6305	+ string$dest(&_68);
6213	6306	}
6214	6307	{
6215		- const struct StreamOut _68 = &(streams).out;
6216		- struct string _69; memset(&_69, 0, sizeof(struct string));
6217		- const struct stack/string/ *_70 = &(_other);
6218		- if(!(*_70).size)
	6308	+ const struct StreamOut _69 = &(streams).out;
	6309	+ struct string _70; memset(&_70, 0, sizeof(struct string));
	6310	+ const struct stack/string/ *_71 = &(_other);
	6311	+ if(!(*_71).size)
6219	6312	{
6220		- init$fromliteral(&_69, "EMPTY", 5);
	6313	+ init$fromliteral(&_70, "EMPTY", 5);
6221	6314	}
6222	6315	else
6223	6316	{
6224		- const struct string other = (_70).data;
6225		- string$copy(&_69, &(*other));
	6317	+ const struct string other = (_71).data;
	6318	+ string$copy(&_70, &(*other));
6226	6319	}
6227		- PutStrLn(0 /* _67 /, &_68, &_69);
6228		- string$dest(&_69);
	6320	+ PutStrLn(0 /* _68 /, &_69, &_70);
	6321	+ string$dest(&_70);
6229	6322	}
6230		- const struct stack/string/ *_68 = &(_other);
6231		- if(!(*_68).size)
	6323	+ const struct stack/string/ *_69 = &(_other);
	6324	+ if(!(*_69).size)
6232	6325	{
6233	6326	{
6234		- const struct StreamOut _70 = &(streams).out;
6235		- struct string _71; memset(&_71, 0, sizeof(struct string));
6236		- init$fromliteral(&_71, "EMPTY", 5);
6237		- PutStrLn(0 /* _69 /, &_70, &_71);
6238		- string$dest(&_71);
	6327	+ const struct StreamOut _71 = &(streams).out;
	6328	+ struct string _72; memset(&_72, 0, sizeof(struct string));
	6329	+ init$fromliteral(&_72, "EMPTY", 5);
	6330	+ PutStrLn(0 /* _70 /, &_71, &_72);
	6331	+ string$dest(&_72);
6239	6332	}
6240	6333	}
6241	6334	else
6242	6335	{
6243		- const struct string other = (_68).data;
	6336	+ const struct string other = (_69).data;
6244	6337	{
6245		- const struct StreamOut _71 = &(streams).out;
6246		- PutStrLn(0 /* _70 /, &_71, &*other);
	6338	+ const struct StreamOut _72 = &(streams).out;
	6339	+ PutStrLn(0 /* _71 /, &_72, &*other);
6247	6340	}
6248	6341	}
6249	6342	struct string _str; memset(&_str, 0, sizeof(struct string));

		@@ -6250,76 +6343,76 @@
6250	6343	init$fromliteral(&_str, "test...", 7);
6251	6344	struct stack/string/ _stk; memset(&_stk, 0, sizeof(struct stack/string/));
6252	6345	{
6253		- push(0 /* _71 /, &_stk, &_str, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void ))string$copy, 795);
	6346	+ push(0 /* _72 /, &_stk, &_str, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void ))string$copy, 813);
6254	6347	}
6255	6348	{
6256		- push(0 /* _72 /, &_stk, &_str, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void ))string$copy, 796);
	6349	+ push(0 /* _73 /, &_stk, &_str, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void ))string$copy, 814);
6257	6350	}
6258	6351	{
6259		- struct stack/string/ _73; memset(&_73, 0, sizeof(struct stack/string/));
6260		- pop_opt(&_73, &_stk, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void *))string$copy, 797);
6261		- free$(&_73, sizeof(struct string), (void ()(void ))string$dest);
	6352	+ struct stack/string/ _74; memset(&_74, 0, sizeof(struct stack/string/));
	6353	+ pop_opt(&_74, &_stk, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void *))string$copy, 815);
	6354	+ free$(&_74, sizeof(struct string), (void ()(void ))string$dest);
6262	6355	}
6263	6356	{
6264		- stack(&_stk, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void *))string$copy, 798);
	6357	+ stack(&_stk, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void *))string$copy, 816);
6265	6358	}
6266	6359	{
6267		- struct stack/u8/ _73; memset(&_73, 0, sizeof(struct stack/u8/));
6268		- access$(&_73, &_str);
6269		- free$(&_73, sizeof(uint8_t), 0/DEST/);
	6360	+ struct stack/u8/ _74; memset(&_74, 0, sizeof(struct stack/u8/));
	6361	+ access$(&_74, &_str);
	6362	+ free$(&_74, sizeof(uint8_t), 0/DEST/);
6270	6363	}
6271	6364	struct box$ _A; memset(&_A, 0, sizeof(struct box$));
6272	6365	{
6273		- struct string _73; memset(&_73, 0, sizeof(struct string));
6274		- init$fromliteral(&_73, "ABC", 3);
6275		- box$(&_A, &_73);
6276		- string$dest(&_73);
6277		- }
6278		- {
6279	6366	struct string _74; memset(&_74, 0, sizeof(struct string));
6280		- init$fromliteral(&_74, "ref-count box test", 18);
6281		- boxset$(0 /* _73 */, &_A, &_74);
	6367	+ init$fromliteral(&_74, "ABC", 3);
	6368	+ box$(&_A, &_74);
6282	6369	string$dest(&_74);
6283	6370	}
	6371	+ {
	6372	+ struct string _75; memset(&_75, 0, sizeof(struct string));
	6373	+ init$fromliteral(&_75, "ref-count box test", 18);
	6374	+ boxset$(0 /* _74 */, &_A, &_75);
	6375	+ string$dest(&_75);
	6376	+ }
6284	6377	struct box$ _B; memset(&_B, 0, sizeof(struct box$));
6285	6378	box$$copy(&_B, &(_A));
6286	6379	struct box$ _C; memset(&_C, 0, sizeof(struct box$));
6287	6380	{
6288		- struct string _74; memset(&_74, 0, sizeof(struct string));
6289		- init$fromliteral(&_74, "DEF", 3);
6290		- box$(&_C, &_74);
6291		- string$dest(&_74);
	6381	+ struct string _75; memset(&_75, 0, sizeof(struct string));
	6382	+ init$fromliteral(&_75, "DEF", 3);
	6383	+ box$(&_C, &_75);
	6384	+ string$dest(&_75);
6292	6385	}
6293	6386	box$$copy(&_C, &(_B));
6294	6387	{
6295		- const struct StreamOut _75 = &(streams).out;
6296		- struct string _76; memset(&_76, 0, sizeof(struct string));
6297		- {
6298		- boxget$(&_76, &_C);
6299		- }
6300		- PutStrLn(0 /* _74 /, &_75, &_76);
6301		- string$dest(&_76);
6302		- }
6303		- {
6304	6388	const struct StreamOut _76 = &(streams).out;
6305	6389	struct string _77; memset(&_77, 0, sizeof(struct string));
6306	6390	{
6307		- shadow(&_77);
	6391	+ boxget$(&_77, &_C);
6308	6392	}
6309		- Print$string(0 /* _75 /, &_76, &_77);
	6393	+ PutStrLn(0 /* _75 /, &_76, &_77);
6310	6394	string$dest(&_77);
6311	6395	}
6312	6396	{
6313	6397	const struct StreamOut _77 = &(streams).out;
6314	6398	struct string _78; memset(&_78, 0, sizeof(struct string));
6315		- init$fromliteral(&_78, "", 0);
6316		- PutStrLn(0 /* _76 /, &_77, &_78);
	6399	+ {
	6400	+ shadow(&_78);
	6401	+ }
	6402	+ Print$string(0 /* _76 /, &_77, &_78);
6317	6403	string$dest(&_78);
6318	6404	}
6319		- int32_t _77; memset(&_77, 0, sizeof(int32_t));
6320		- _77 = 0;
6321		- *_0 = _77;
6322		- _IGNORE_(_77);
	6405	+ {
	6406	+ const struct StreamOut _78 = &(streams).out;
	6407	+ struct string _79; memset(&_79, 0, sizeof(struct string));
	6408	+ init$fromliteral(&_79, "", 0);
	6409	+ PutStrLn(0 /* _77 /, &_78, &_79);
	6410	+ string$dest(&_79);
	6411	+ }
	6412	+ int32_t _78; memset(&_78, 0, sizeof(int32_t));
	6413	+ _78 = 0;
	6414	+ *_0 = _78;
	6415	+ _IGNORE_(_78);
6323	6416	box$$dest(&_C);
6324	6417	box$$dest(&_B);
6325	6418	box$$dest(&_A);

Afficher sur ancien navigateur de dépôt.