OSDN -- 开发和下载开源软件
简体中文翻译状态 translation status for zh
  • R/O
  • SSH
  • HTTPS

jpl: 提交


Commit MetaInfo

修订版35 (tree)
时间2018-07-18 03:44:20
作者jakobthomsen

Log Message

omit eof when iterating over StreamIn

更改概述

差异

--- trunk/pragmatic/memory_tests/mem_test_output.txt (revision 34)
+++ trunk/pragmatic/memory_tests/mem_test_output.txt (revision 35)
@@ -1,6 +1,6 @@
11 Test iterate stream-in
22 This is the input test file
3-.
3+.
44 [256, 255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240, 239, 238, 237, 236, 235, 234, 233, 232, 231, 230, 229, 228, 227, 226, 225, 224, 223, 222, 221, 220, 219, 218, 217, 216, 215, 214, 213, 212, 211, 210, 209, 208, 207, 206, 205, 204, 203, 202, 201, 200, 199, 198, 197, 196, 195, 194, 193, 192, 191, 190, 189, 188, 187, 186, 185, 184, 183, 182, 181, 180, 179, 178, 177, 176, 175, 174, 173, 172, 171, 170, 169, 168, 167, 166, 165, 164, 163, 162, 161, 160, 159, 158, 157, 156, 155, 154, 153, 152, 151, 150, 149, 148, 147, 146, 145, 144, 143, 142, 141, 140, 139, 138, 137, 136, 135, 134, 133, 132, 131, 130, 129, 128, 127, 126, 125, 124, 123, 122, 121, 120, 119, 118, 117, 116, 115, 114, 113, 112, 111, 110, 109, 108, 107, 106, 105, 104, 103, 102, 101, 100, 99, 98, 97, 96, 95, 94, 93, 92, 91, 90, 89, 88, 87, 86, 85, 84, 83, 82, 81, 80, 79, 78, 77, 76, 75, 74, 73, 72, 71, 70, 69, 68, 67, 66, 65, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0][][12345]
55 Test compare
66 for-test 0:
--- trunk/pragmatic/memory_tests/mem_tests.txt (revision 34)
+++ trunk/pragmatic/memory_tests/mem_tests.txt (revision 35)
@@ -1,6 +1,6 @@
11 Test iterate stream-in
22 This is the input test file
3-.
3+.
44 [256, 255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240, 239, 238, 237, 236, 235, 234, 233, 232, 231, 230, 229, 228, 227, 226, 225, 224, 223, 222, 221, 220, 219, 218, 217, 216, 215, 214, 213, 212, 211, 210, 209, 208, 207, 206, 205, 204, 203, 202, 201, 200, 199, 198, 197, 196, 195, 194, 193, 192, 191, 190, 189, 188, 187, 186, 185, 184, 183, 182, 181, 180, 179, 178, 177, 176, 175, 174, 173, 172, 171, 170, 169, 168, 167, 166, 165, 164, 163, 162, 161, 160, 159, 158, 157, 156, 155, 154, 153, 152, 151, 150, 149, 148, 147, 146, 145, 144, 143, 142, 141, 140, 139, 138, 137, 136, 135, 134, 133, 132, 131, 130, 129, 128, 127, 126, 125, 124, 123, 122, 121, 120, 119, 118, 117, 116, 115, 114, 113, 112, 111, 110, 109, 108, 107, 106, 105, 104, 103, 102, 101, 100, 99, 98, 97, 96, 95, 94, 93, 92, 91, 90, 89, 88, 87, 86, 85, 84, 83, 82, 81, 80, 79, 78, 77, 76, 75, 74, 73, 72, 71, 70, 69, 68, 67, 66, 65, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0][][12345]
55 Test compare
66 for-test 0:
--- trunk/pragmatic/memory_tests/mem_tests_compiled.c (revision 34)
+++ trunk/pragmatic/memory_tests/mem_tests_compiled.c (revision 35)
@@ -3344,60 +3344,45 @@
33443344 PutStrLn(0 /* _1 */, &*_2, &_3);
33453345 string$dest(&_3);
33463346 }
3347- uint8_t _c = 0;
3348- do {
3349- Get(&_c, &((*streams).in));
3347+ for(int _2 = getc(((*streams).in).f); _2 >= 0; _2 = getc(((*streams).in).f))
3348+ {
3349+ const uint8_t _c = (uint8_t)_2;
33503350 {
3351- const struct StreamOut *_3 = &(*streams).out;
3352- Put(0 /* _2 */, &*_3, &_c);
3351+ const struct StreamOut *_4 = &(*streams).out;
3352+ Put(0 /* _3 */, &*_4, &_c);
33533353 }
33543354 }
3355- while(_c);
33563355 {
3357- const struct StreamOut *_3 = &(*streams).out;
3358- struct string _4; memset(&_4, 0, sizeof(struct string));
3359- init$fromliteral(&_4, ".", 1);
3360- PutStrLn(0 /* _2 */, &*_3, &_4);
3361- string$dest(&_4);
3356+ const struct StreamOut *_4 = &(*streams).out;
3357+ struct string _5; memset(&_5, 0, sizeof(struct string));
3358+ init$fromliteral(&_5, ".", 1);
3359+ PutStrLn(0 /* _3 */, &*_4, &_5);
3360+ string$dest(&_5);
33623361 }
33633362 {
3364- TestStack$(0 /* _3 */, &*streams);
3363+ TestStack$(0 /* _4 */, &*streams);
33653364 }
33663365 {
3367- const struct StreamOut *_5 = &(*streams).out;
3368- struct string _6; memset(&_6, 0, sizeof(struct string));
3369- init$fromliteral(&_6, "Test compare", 12);
3370- PutStrLn(0 /* _4 */, &*_5, &_6);
3371- string$dest(&_6);
3366+ const struct StreamOut *_6 = &(*streams).out;
3367+ struct string _7; memset(&_7, 0, sizeof(struct string));
3368+ init$fromliteral(&_7, "Test compare", 12);
3369+ PutStrLn(0 /* _5 */, &*_6, &_7);
3370+ string$dest(&_7);
33723371 }
33733372 {
33743373 struct stack/*string2$*/ _data; memset(&_data, 0, sizeof(struct stack/*string2$*/));
33753374 {
3376- struct string2$ _7; memset(&_7, 0, sizeof(struct string2$));
3377- {
3378- struct string _8; memset(&_8, 0, sizeof(struct string));
3379- init$fromliteral(&_8, "abc", 3);
3380- struct string _9; memset(&_9, 0, sizeof(struct string));
3381- init$fromliteral(&_9, "abc", 3);
3382- string2$(&_7, &_8, &_9);
3383- string$dest(&_9);
3384- string$dest(&_8);
3385- }
3386- push(0 /* _6 */, &_data, &_7, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 482);
3387- string2$$dest(&_7);
3388- }
3389- {
33903375 struct string2$ _8; memset(&_8, 0, sizeof(struct string2$));
33913376 {
33923377 struct string _9; memset(&_9, 0, sizeof(struct string));
33933378 init$fromliteral(&_9, "abc", 3);
33943379 struct string _10; memset(&_10, 0, sizeof(struct string));
3395- init$fromliteral(&_10, "abcba", 5);
3380+ init$fromliteral(&_10, "abc", 3);
33963381 string2$(&_8, &_9, &_10);
33973382 string$dest(&_10);
33983383 string$dest(&_9);
33993384 }
3400- push(0 /* _7 */, &_data, &_8, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 483);
3385+ push(0 /* _7 */, &_data, &_8, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 482);
34013386 string2$$dest(&_8);
34023387 }
34033388 {
@@ -3404,14 +3389,14 @@
34043389 struct string2$ _9; memset(&_9, 0, sizeof(struct string2$));
34053390 {
34063391 struct string _10; memset(&_10, 0, sizeof(struct string));
3407- init$fromliteral(&_10, "abcba", 5);
3392+ init$fromliteral(&_10, "abc", 3);
34083393 struct string _11; memset(&_11, 0, sizeof(struct string));
3409- init$fromliteral(&_11, "abc", 3);
3394+ init$fromliteral(&_11, "abcba", 5);
34103395 string2$(&_9, &_10, &_11);
34113396 string$dest(&_11);
34123397 string$dest(&_10);
34133398 }
3414- push(0 /* _8 */, &_data, &_9, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 484);
3399+ push(0 /* _8 */, &_data, &_9, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 483);
34153400 string2$$dest(&_9);
34163401 }
34173402 {
@@ -3418,14 +3403,14 @@
34183403 struct string2$ _10; memset(&_10, 0, sizeof(struct string2$));
34193404 {
34203405 struct string _11; memset(&_11, 0, sizeof(struct string));
3421- init$fromliteral(&_11, "2abc1", 5);
3406+ init$fromliteral(&_11, "abcba", 5);
34223407 struct string _12; memset(&_12, 0, sizeof(struct string));
3423- init$fromliteral(&_12, "1abc2", 5);
3408+ init$fromliteral(&_12, "abc", 3);
34243409 string2$(&_10, &_11, &_12);
34253410 string$dest(&_12);
34263411 string$dest(&_11);
34273412 }
3428- push(0 /* _9 */, &_data, &_10, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 485);
3413+ push(0 /* _9 */, &_data, &_10, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 484);
34293414 string2$$dest(&_10);
34303415 }
34313416 {
@@ -3432,14 +3417,14 @@
34323417 struct string2$ _11; memset(&_11, 0, sizeof(struct string2$));
34333418 {
34343419 struct string _12; memset(&_12, 0, sizeof(struct string));
3435- init$fromliteral(&_12, "1abc2", 5);
3420+ init$fromliteral(&_12, "2abc1", 5);
34363421 struct string _13; memset(&_13, 0, sizeof(struct string));
3437- init$fromliteral(&_13, "2abc1", 5);
3422+ init$fromliteral(&_13, "1abc2", 5);
34383423 string2$(&_11, &_12, &_13);
34393424 string$dest(&_13);
34403425 string$dest(&_12);
34413426 }
3442- push(0 /* _10 */, &_data, &_11, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 486);
3427+ push(0 /* _10 */, &_data, &_11, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 485);
34433428 string2$$dest(&_11);
34443429 }
34453430 {
@@ -3446,14 +3431,14 @@
34463431 struct string2$ _12; memset(&_12, 0, sizeof(struct string2$));
34473432 {
34483433 struct string _13; memset(&_13, 0, sizeof(struct string));
3449- init$fromliteral(&_13, "abc1", 4);
3434+ init$fromliteral(&_13, "1abc2", 5);
34503435 struct string _14; memset(&_14, 0, sizeof(struct string));
3451- init$fromliteral(&_14, "abc2", 4);
3436+ init$fromliteral(&_14, "2abc1", 5);
34523437 string2$(&_12, &_13, &_14);
34533438 string$dest(&_14);
34543439 string$dest(&_13);
34553440 }
3456- push(0 /* _11 */, &_data, &_12, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 487);
3441+ push(0 /* _11 */, &_data, &_12, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 486);
34573442 string2$$dest(&_12);
34583443 }
34593444 {
@@ -3460,14 +3445,14 @@
34603445 struct string2$ _13; memset(&_13, 0, sizeof(struct string2$));
34613446 {
34623447 struct string _14; memset(&_14, 0, sizeof(struct string));
3463- init$fromliteral(&_14, "abc2", 4);
3448+ init$fromliteral(&_14, "abc1", 4);
34643449 struct string _15; memset(&_15, 0, sizeof(struct string));
3465- init$fromliteral(&_15, "abc1", 4);
3450+ init$fromliteral(&_15, "abc2", 4);
34663451 string2$(&_13, &_14, &_15);
34673452 string$dest(&_15);
34683453 string$dest(&_14);
34693454 }
3470- push(0 /* _12 */, &_data, &_13, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 488);
3455+ push(0 /* _12 */, &_data, &_13, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 487);
34713456 string2$$dest(&_13);
34723457 }
34733458 {
@@ -3474,14 +3459,14 @@
34743459 struct string2$ _14; memset(&_14, 0, sizeof(struct string2$));
34753460 {
34763461 struct string _15; memset(&_15, 0, sizeof(struct string));
3477- init$fromliteral(&_15, "1abc", 4);
3462+ init$fromliteral(&_15, "abc2", 4);
34783463 struct string _16; memset(&_16, 0, sizeof(struct string));
3479- init$fromliteral(&_16, "2abc", 4);
3464+ init$fromliteral(&_16, "abc1", 4);
34803465 string2$(&_14, &_15, &_16);
34813466 string$dest(&_16);
34823467 string$dest(&_15);
34833468 }
3484- push(0 /* _13 */, &_data, &_14, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 489);
3469+ push(0 /* _13 */, &_data, &_14, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 488);
34853470 string2$$dest(&_14);
34863471 }
34873472 {
@@ -3488,14 +3473,14 @@
34883473 struct string2$ _15; memset(&_15, 0, sizeof(struct string2$));
34893474 {
34903475 struct string _16; memset(&_16, 0, sizeof(struct string));
3491- init$fromliteral(&_16, "2abc", 4);
3476+ init$fromliteral(&_16, "1abc", 4);
34923477 struct string _17; memset(&_17, 0, sizeof(struct string));
3493- init$fromliteral(&_17, "1abc", 4);
3478+ init$fromliteral(&_17, "2abc", 4);
34943479 string2$(&_15, &_16, &_17);
34953480 string$dest(&_17);
34963481 string$dest(&_16);
34973482 }
3498- push(0 /* _14 */, &_data, &_15, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 490);
3483+ push(0 /* _14 */, &_data, &_15, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 489);
34993484 string2$$dest(&_15);
35003485 }
35013486 {
@@ -3502,52 +3487,66 @@
35023487 struct string2$ _16; memset(&_16, 0, sizeof(struct string2$));
35033488 {
35043489 struct string _17; memset(&_17, 0, sizeof(struct string));
3505- init$fromliteral(&_17, "bbcc", 4);
3490+ init$fromliteral(&_17, "2abc", 4);
35063491 struct string _18; memset(&_18, 0, sizeof(struct string));
3507- init$fromliteral(&_18, "abcd", 4);
3492+ init$fromliteral(&_18, "1abc", 4);
35083493 string2$(&_16, &_17, &_18);
35093494 string$dest(&_18);
35103495 string$dest(&_17);
35113496 }
3512- push(0 /* _15 */, &_data, &_16, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 491);
3497+ push(0 /* _15 */, &_data, &_16, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 490);
35133498 string2$$dest(&_16);
35143499 }
35153500 {
3516- const struct StreamOut *_17 = &(*streams).out;
3517- struct string _18; memset(&_18, 0, sizeof(struct string));
3518- init$fromliteral(&_18, "for-test 0: ", 12);
3519- PutStrLn(0 /* _16 */, &*_17, &_18);
3520- string$dest(&_18);
3501+ struct string2$ _17; memset(&_17, 0, sizeof(struct string2$));
3502+ {
3503+ struct string _18; memset(&_18, 0, sizeof(struct string));
3504+ init$fromliteral(&_18, "bbcc", 4);
3505+ struct string _19; memset(&_19, 0, sizeof(struct string));
3506+ init$fromliteral(&_19, "abcd", 4);
3507+ string2$(&_17, &_18, &_19);
3508+ string$dest(&_19);
3509+ string$dest(&_18);
3510+ }
3511+ push(0 /* _16 */, &_data, &_17, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 491);
3512+ string2$$dest(&_17);
35213513 }
3522- struct stack/*string2$*/ _17; memset(&_17, 0, sizeof(struct stack/*string2$*/));
3523- clone$(&_17, &(_data), sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy);
3524- for(uint64_t _18 = 0; _18 < _17.ptr; ++_18)
35253514 {
3515+ const struct StreamOut *_18 = &(*streams).out;
3516+ struct string _19; memset(&_19, 0, sizeof(struct string));
3517+ init$fromliteral(&_19, "for-test 0: ", 12);
3518+ PutStrLn(0 /* _17 */, &*_18, &_19);
3519+ string$dest(&_19);
3520+ }
3521+ struct stack/*string2$*/ _18; memset(&_18, 0, sizeof(struct stack/*string2$*/));
3522+ clone$(&_18, &(_data), sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy);
3523+ for(uint64_t _19 = 0; _19 < _18.ptr; ++_19)
3524+ {
35263525 struct string2$ _e; memset(&_e, 0, sizeof(struct string2$));
3527- at_get$(&_e, &_17, &_18, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 495);
3526+ at_get$(&_e, &_18, &_19, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 495);
35283527 {
3529- const struct StreamOut *_20 = &(*streams).out;
3530- Print$string2$(0 /* _19 */, &*_20, &_e);
3528+ const struct StreamOut *_21 = &(*streams).out;
3529+ Print$string2$(0 /* _20 */, &*_21, &_e);
35313530 }
35323531 {
3533- const struct StreamOut *_21 = &(*streams).out;
3534- struct string _22; memset(&_22, 0, sizeof(struct string));
3535- init$fromliteral(&_22, "", 0);
3536- PutStrLn(0 /* _20 */, &*_21, &_22);
3537- string$dest(&_22);
3532+ const struct StreamOut *_22 = &(*streams).out;
3533+ struct string _23; memset(&_23, 0, sizeof(struct string));
3534+ init$fromliteral(&_23, "", 0);
3535+ PutStrLn(0 /* _21 */, &*_22, &_23);
3536+ string$dest(&_23);
35383537 }
35393538 string2$$dest(&_e);
35403539 }
3541- free$(&_17, sizeof(struct string2$), (void (*)(void *))string2$$dest);
3540+ free$(&_18, sizeof(struct string2$), (void (*)(void *))string2$$dest);
35423541 {
3543- const struct StreamOut *_20 = &(*streams).out;
3544- struct string _21; memset(&_21, 0, sizeof(struct string));
3545- init$fromliteral(&_21, "---", 3);
3546- PutStrLn(0 /* _19 */, &*_20, &_21);
3547- string$dest(&_21);
3542+ const struct StreamOut *_21 = &(*streams).out;
3543+ struct string _22; memset(&_22, 0, sizeof(struct string));
3544+ init$fromliteral(&_22, "---", 3);
3545+ PutStrLn(0 /* _20 */, &*_21, &_22);
3546+ string$dest(&_22);
35483547 }
35493548 {
3550- TestCompareStrings$(0 /* _20 */, &*streams, &_data);
3549+ TestCompareStrings$(0 /* _21 */, &*streams, &_data);
35513550 }
35523551 free$(&_data, sizeof(struct string2$), (void (*)(void *))string2$$dest);
35533552 }
@@ -3554,108 +3553,6 @@
35543553 {
35553554 struct stack/*tree2$*/ _data; memset(&_data, 0, sizeof(struct stack/*tree2$*/));
35563555 {
3557- struct tree2$ _8; memset(&_8, 0, sizeof(struct tree2$));
3558- {
3559- struct tree$ _9; memset(&_9, 0, sizeof(struct tree$));
3560- {
3561- struct tree$ _10; memset(&_10, 0, sizeof(struct tree$));
3562- {
3563- struct tree$ _11; memset(&_11, 0, sizeof(struct tree$));
3564- {
3565- struct string _12; memset(&_12, 0, sizeof(struct string));
3566- init$fromliteral(&_12, "2", 1);
3567- leaf$(&_11, &_12);
3568- string$dest(&_12);
3569- }
3570- struct tree$ _12; memset(&_12, 0, sizeof(struct tree$));
3571- {
3572- struct string _13; memset(&_13, 0, sizeof(struct string));
3573- init$fromliteral(&_13, "B", 1);
3574- leaf$(&_12, &_13);
3575- string$dest(&_13);
3576- }
3577- node$(&_10, &_11, &_12);
3578- tree$$dest(&_12);
3579- tree$$dest(&_11);
3580- }
3581- struct tree$ _11; memset(&_11, 0, sizeof(struct tree$));
3582- {
3583- struct tree$ _12; memset(&_12, 0, sizeof(struct tree$));
3584- {
3585- struct string _13; memset(&_13, 0, sizeof(struct string));
3586- init$fromliteral(&_13, "C", 1);
3587- leaf$(&_12, &_13);
3588- string$dest(&_13);
3589- }
3590- struct tree$ _13; memset(&_13, 0, sizeof(struct tree$));
3591- {
3592- struct string _14; memset(&_14, 0, sizeof(struct string));
3593- init$fromliteral(&_14, "1", 1);
3594- leaf$(&_13, &_14);
3595- string$dest(&_14);
3596- }
3597- node$(&_11, &_12, &_13);
3598- tree$$dest(&_13);
3599- tree$$dest(&_12);
3600- }
3601- node$(&_9, &_10, &_11);
3602- tree$$dest(&_11);
3603- tree$$dest(&_10);
3604- }
3605- struct tree$ _10; memset(&_10, 0, sizeof(struct tree$));
3606- {
3607- struct tree$ _11; memset(&_11, 0, sizeof(struct tree$));
3608- {
3609- struct tree$ _12; memset(&_12, 0, sizeof(struct tree$));
3610- {
3611- struct string _13; memset(&_13, 0, sizeof(struct string));
3612- init$fromliteral(&_13, "1", 1);
3613- leaf$(&_12, &_13);
3614- string$dest(&_13);
3615- }
3616- struct tree$ _13; memset(&_13, 0, sizeof(struct tree$));
3617- {
3618- struct string _14; memset(&_14, 0, sizeof(struct string));
3619- init$fromliteral(&_14, "B", 1);
3620- leaf$(&_13, &_14);
3621- string$dest(&_14);
3622- }
3623- node$(&_11, &_12, &_13);
3624- tree$$dest(&_13);
3625- tree$$dest(&_12);
3626- }
3627- struct tree$ _12; memset(&_12, 0, sizeof(struct tree$));
3628- {
3629- struct tree$ _13; memset(&_13, 0, sizeof(struct tree$));
3630- {
3631- struct string _14; memset(&_14, 0, sizeof(struct string));
3632- init$fromliteral(&_14, "C", 1);
3633- leaf$(&_13, &_14);
3634- string$dest(&_14);
3635- }
3636- struct tree$ _14; memset(&_14, 0, sizeof(struct tree$));
3637- {
3638- struct string _15; memset(&_15, 0, sizeof(struct string));
3639- init$fromliteral(&_15, "2", 1);
3640- leaf$(&_14, &_15);
3641- string$dest(&_15);
3642- }
3643- node$(&_12, &_13, &_14);
3644- tree$$dest(&_14);
3645- tree$$dest(&_13);
3646- }
3647- node$(&_10, &_11, &_12);
3648- tree$$dest(&_12);
3649- tree$$dest(&_11);
3650- }
3651- tree2$(&_8, &_9, &_10);
3652- tree$$dest(&_10);
3653- tree$$dest(&_9);
3654- }
3655- push(0 /* _7 */, &_data, &_8, sizeof(struct tree2$), (void (*)(void *))tree2$$dest, (void (*)(void *, const void *))tree2$$copy, 507);
3656- tree2$$dest(&_8);
3657- }
3658- {
36593556 struct tree2$ _9; memset(&_9, 0, sizeof(struct tree2$));
36603557 {
36613558 struct tree$ _10; memset(&_10, 0, sizeof(struct tree$));
@@ -3665,7 +3562,7 @@
36653562 struct tree$ _12; memset(&_12, 0, sizeof(struct tree$));
36663563 {
36673564 struct string _13; memset(&_13, 0, sizeof(struct string));
3668- init$fromliteral(&_13, "1", 1);
3565+ init$fromliteral(&_13, "2", 1);
36693566 leaf$(&_12, &_13);
36703567 string$dest(&_13);
36713568 }
@@ -3692,7 +3589,7 @@
36923589 struct tree$ _14; memset(&_14, 0, sizeof(struct tree$));
36933590 {
36943591 struct string _15; memset(&_15, 0, sizeof(struct string));
3695- init$fromliteral(&_15, "2", 1);
3592+ init$fromliteral(&_15, "1", 1);
36963593 leaf$(&_14, &_15);
36973594 string$dest(&_15);
36983595 }
@@ -3711,7 +3608,7 @@
37113608 struct tree$ _13; memset(&_13, 0, sizeof(struct tree$));
37123609 {
37133610 struct string _14; memset(&_14, 0, sizeof(struct string));
3714- init$fromliteral(&_14, "2", 1);
3611+ init$fromliteral(&_14, "1", 1);
37153612 leaf$(&_13, &_14);
37163613 string$dest(&_14);
37173614 }
@@ -3738,7 +3635,7 @@
37383635 struct tree$ _15; memset(&_15, 0, sizeof(struct tree$));
37393636 {
37403637 struct string _16; memset(&_16, 0, sizeof(struct string));
3741- init$fromliteral(&_16, "1", 1);
3638+ init$fromliteral(&_16, "2", 1);
37423639 leaf$(&_15, &_16);
37433640 string$dest(&_16);
37443641 }
@@ -3754,7 +3651,7 @@
37543651 tree$$dest(&_11);
37553652 tree$$dest(&_10);
37563653 }
3757- push(0 /* _8 */, &_data, &_9, sizeof(struct tree2$), (void (*)(void *))tree2$$dest, (void (*)(void *, const void *))tree2$$copy, 508);
3654+ push(0 /* _8 */, &_data, &_9, sizeof(struct tree2$), (void (*)(void *))tree2$$dest, (void (*)(void *, const void *))tree2$$copy, 507);
37583655 tree2$$dest(&_9);
37593656 }
37603657 {
@@ -3767,7 +3664,7 @@
37673664 struct tree$ _13; memset(&_13, 0, sizeof(struct tree$));
37683665 {
37693666 struct string _14; memset(&_14, 0, sizeof(struct string));
3770- init$fromliteral(&_14, "A", 1);
3667+ init$fromliteral(&_14, "1", 1);
37713668 leaf$(&_13, &_14);
37723669 string$dest(&_14);
37733670 }
@@ -3794,7 +3691,7 @@
37943691 struct tree$ _15; memset(&_15, 0, sizeof(struct tree$));
37953692 {
37963693 struct string _16; memset(&_16, 0, sizeof(struct string));
3797- init$fromliteral(&_16, "D", 1);
3694+ init$fromliteral(&_16, "2", 1);
37983695 leaf$(&_15, &_16);
37993696 string$dest(&_16);
38003697 }
@@ -3813,7 +3710,7 @@
38133710 struct tree$ _14; memset(&_14, 0, sizeof(struct tree$));
38143711 {
38153712 struct string _15; memset(&_15, 0, sizeof(struct string));
3816- init$fromliteral(&_15, "A", 1);
3713+ init$fromliteral(&_15, "2", 1);
38173714 leaf$(&_14, &_15);
38183715 string$dest(&_15);
38193716 }
@@ -3840,7 +3737,7 @@
38403737 struct tree$ _16; memset(&_16, 0, sizeof(struct tree$));
38413738 {
38423739 struct string _17; memset(&_17, 0, sizeof(struct string));
3843- init$fromliteral(&_17, "D", 1);
3740+ init$fromliteral(&_17, "1", 1);
38443741 leaf$(&_16, &_17);
38453742 string$dest(&_17);
38463743 }
@@ -3856,7 +3753,7 @@
38563753 tree$$dest(&_12);
38573754 tree$$dest(&_11);
38583755 }
3859- push(0 /* _9 */, &_data, &_10, sizeof(struct tree2$), (void (*)(void *))tree2$$dest, (void (*)(void *, const void *))tree2$$copy, 509);
3756+ push(0 /* _9 */, &_data, &_10, sizeof(struct tree2$), (void (*)(void *))tree2$$dest, (void (*)(void *, const void *))tree2$$copy, 508);
38603757 tree2$$dest(&_10);
38613758 }
38623759 {
@@ -3866,17 +3763,43 @@
38663763 {
38673764 struct tree$ _13; memset(&_13, 0, sizeof(struct tree$));
38683765 {
3869- struct string _14; memset(&_14, 0, sizeof(struct string));
3870- init$fromliteral(&_14, "A", 1);
3871- leaf$(&_13, &_14);
3872- string$dest(&_14);
3766+ struct tree$ _14; memset(&_14, 0, sizeof(struct tree$));
3767+ {
3768+ struct string _15; memset(&_15, 0, sizeof(struct string));
3769+ init$fromliteral(&_15, "A", 1);
3770+ leaf$(&_14, &_15);
3771+ string$dest(&_15);
3772+ }
3773+ struct tree$ _15; memset(&_15, 0, sizeof(struct tree$));
3774+ {
3775+ struct string _16; memset(&_16, 0, sizeof(struct string));
3776+ init$fromliteral(&_16, "B", 1);
3777+ leaf$(&_15, &_16);
3778+ string$dest(&_16);
3779+ }
3780+ node$(&_13, &_14, &_15);
3781+ tree$$dest(&_15);
3782+ tree$$dest(&_14);
38733783 }
38743784 struct tree$ _14; memset(&_14, 0, sizeof(struct tree$));
38753785 {
3876- struct string _15; memset(&_15, 0, sizeof(struct string));
3877- init$fromliteral(&_15, "B", 1);
3878- leaf$(&_14, &_15);
3879- string$dest(&_15);
3786+ struct tree$ _15; memset(&_15, 0, sizeof(struct tree$));
3787+ {
3788+ struct string _16; memset(&_16, 0, sizeof(struct string));
3789+ init$fromliteral(&_16, "C", 1);
3790+ leaf$(&_15, &_16);
3791+ string$dest(&_16);
3792+ }
3793+ struct tree$ _16; memset(&_16, 0, sizeof(struct tree$));
3794+ {
3795+ struct string _17; memset(&_17, 0, sizeof(struct string));
3796+ init$fromliteral(&_17, "D", 1);
3797+ leaf$(&_16, &_17);
3798+ string$dest(&_17);
3799+ }
3800+ node$(&_14, &_15, &_16);
3801+ tree$$dest(&_16);
3802+ tree$$dest(&_15);
38803803 }
38813804 node$(&_12, &_13, &_14);
38823805 tree$$dest(&_14);
@@ -3886,17 +3809,43 @@
38863809 {
38873810 struct tree$ _14; memset(&_14, 0, sizeof(struct tree$));
38883811 {
3889- struct string _15; memset(&_15, 0, sizeof(struct string));
3890- init$fromliteral(&_15, "A", 1);
3891- leaf$(&_14, &_15);
3892- string$dest(&_15);
3812+ struct tree$ _15; memset(&_15, 0, sizeof(struct tree$));
3813+ {
3814+ struct string _16; memset(&_16, 0, sizeof(struct string));
3815+ init$fromliteral(&_16, "A", 1);
3816+ leaf$(&_15, &_16);
3817+ string$dest(&_16);
3818+ }
3819+ struct tree$ _16; memset(&_16, 0, sizeof(struct tree$));
3820+ {
3821+ struct string _17; memset(&_17, 0, sizeof(struct string));
3822+ init$fromliteral(&_17, "B", 1);
3823+ leaf$(&_16, &_17);
3824+ string$dest(&_17);
3825+ }
3826+ node$(&_14, &_15, &_16);
3827+ tree$$dest(&_16);
3828+ tree$$dest(&_15);
38933829 }
38943830 struct tree$ _15; memset(&_15, 0, sizeof(struct tree$));
38953831 {
3896- struct string _16; memset(&_16, 0, sizeof(struct string));
3897- init$fromliteral(&_16, "B", 1);
3898- leaf$(&_15, &_16);
3899- string$dest(&_16);
3832+ struct tree$ _16; memset(&_16, 0, sizeof(struct tree$));
3833+ {
3834+ struct string _17; memset(&_17, 0, sizeof(struct string));
3835+ init$fromliteral(&_17, "C", 1);
3836+ leaf$(&_16, &_17);
3837+ string$dest(&_17);
3838+ }
3839+ struct tree$ _17; memset(&_17, 0, sizeof(struct tree$));
3840+ {
3841+ struct string _18; memset(&_18, 0, sizeof(struct string));
3842+ init$fromliteral(&_18, "D", 1);
3843+ leaf$(&_17, &_18);
3844+ string$dest(&_18);
3845+ }
3846+ node$(&_15, &_16, &_17);
3847+ tree$$dest(&_17);
3848+ tree$$dest(&_16);
39003849 }
39013850 node$(&_13, &_14, &_15);
39023851 tree$$dest(&_15);
@@ -3906,7 +3855,7 @@
39063855 tree$$dest(&_13);
39073856 tree$$dest(&_12);
39083857 }
3909- push(0 /* _10 */, &_data, &_11, sizeof(struct tree2$), (void (*)(void *))tree2$$dest, (void (*)(void *, const void *))tree2$$copy, 510);
3858+ push(0 /* _10 */, &_data, &_11, sizeof(struct tree2$), (void (*)(void *))tree2$$dest, (void (*)(void *, const void *))tree2$$copy, 509);
39103859 tree2$$dest(&_11);
39113860 }
39123861 {
@@ -3914,10 +3863,23 @@
39143863 {
39153864 struct tree$ _13; memset(&_13, 0, sizeof(struct tree$));
39163865 {
3917- struct string _14; memset(&_14, 0, sizeof(struct string));
3918- init$fromliteral(&_14, "A", 1);
3919- leaf$(&_13, &_14);
3920- string$dest(&_14);
3866+ struct tree$ _14; memset(&_14, 0, sizeof(struct tree$));
3867+ {
3868+ struct string _15; memset(&_15, 0, sizeof(struct string));
3869+ init$fromliteral(&_15, "A", 1);
3870+ leaf$(&_14, &_15);
3871+ string$dest(&_15);
3872+ }
3873+ struct tree$ _15; memset(&_15, 0, sizeof(struct tree$));
3874+ {
3875+ struct string _16; memset(&_16, 0, sizeof(struct string));
3876+ init$fromliteral(&_16, "B", 1);
3877+ leaf$(&_15, &_16);
3878+ string$dest(&_16);
3879+ }
3880+ node$(&_13, &_14, &_15);
3881+ tree$$dest(&_15);
3882+ tree$$dest(&_14);
39213883 }
39223884 struct tree$ _14; memset(&_14, 0, sizeof(struct tree$));
39233885 {
@@ -3931,7 +3893,7 @@
39313893 struct tree$ _16; memset(&_16, 0, sizeof(struct tree$));
39323894 {
39333895 struct string _17; memset(&_17, 0, sizeof(struct string));
3934- init$fromliteral(&_17, "A", 1);
3896+ init$fromliteral(&_17, "B", 1);
39353897 leaf$(&_16, &_17);
39363898 string$dest(&_17);
39373899 }
@@ -3943,7 +3905,7 @@
39433905 tree$$dest(&_14);
39443906 tree$$dest(&_13);
39453907 }
3946- push(0 /* _11 */, &_data, &_12, sizeof(struct tree2$), (void (*)(void *))tree2$$dest, (void (*)(void *, const void *))tree2$$copy, 511);
3908+ push(0 /* _11 */, &_data, &_12, sizeof(struct tree2$), (void (*)(void *))tree2$$dest, (void (*)(void *, const void *))tree2$$copy, 510);
39473909 tree2$$dest(&_12);
39483910 }
39493911 {
@@ -3951,13 +3913,13 @@
39513913 {
39523914 struct tree$ _14; memset(&_14, 0, sizeof(struct tree$));
39533915 {
3954- struct tree$ _15; memset(&_15, 0, sizeof(struct tree$));
3955- {
3956- struct string _16; memset(&_16, 0, sizeof(struct string));
3957- init$fromliteral(&_16, "A", 1);
3958- leaf$(&_15, &_16);
3959- string$dest(&_16);
3960- }
3916+ struct string _15; memset(&_15, 0, sizeof(struct string));
3917+ init$fromliteral(&_15, "A", 1);
3918+ leaf$(&_14, &_15);
3919+ string$dest(&_15);
3920+ }
3921+ struct tree$ _15; memset(&_15, 0, sizeof(struct tree$));
3922+ {
39613923 struct tree$ _16; memset(&_16, 0, sizeof(struct tree$));
39623924 {
39633925 struct string _17; memset(&_17, 0, sizeof(struct string));
@@ -3965,22 +3927,22 @@
39653927 leaf$(&_16, &_17);
39663928 string$dest(&_17);
39673929 }
3968- node$(&_14, &_15, &_16);
3930+ struct tree$ _17; memset(&_17, 0, sizeof(struct tree$));
3931+ {
3932+ struct string _18; memset(&_18, 0, sizeof(struct string));
3933+ init$fromliteral(&_18, "A", 1);
3934+ leaf$(&_17, &_18);
3935+ string$dest(&_18);
3936+ }
3937+ node$(&_15, &_16, &_17);
3938+ tree$$dest(&_17);
39693939 tree$$dest(&_16);
3970- tree$$dest(&_15);
39713940 }
3972- struct tree$ _15; memset(&_15, 0, sizeof(struct tree$));
3973- {
3974- struct string _16; memset(&_16, 0, sizeof(struct string));
3975- init$fromliteral(&_16, "A", 1);
3976- leaf$(&_15, &_16);
3977- string$dest(&_16);
3978- }
39793941 tree2$(&_13, &_14, &_15);
39803942 tree$$dest(&_15);
39813943 tree$$dest(&_14);
39823944 }
3983- push(0 /* _12 */, &_data, &_13, sizeof(struct tree2$), (void (*)(void *))tree2$$dest, (void (*)(void *, const void *))tree2$$copy, 512);
3945+ push(0 /* _12 */, &_data, &_13, sizeof(struct tree2$), (void (*)(void *))tree2$$dest, (void (*)(void *, const void *))tree2$$copy, 511);
39843946 tree2$$dest(&_13);
39853947 }
39863948 {
@@ -3988,10 +3950,23 @@
39883950 {
39893951 struct tree$ _15; memset(&_15, 0, sizeof(struct tree$));
39903952 {
3991- struct string _16; memset(&_16, 0, sizeof(struct string));
3992- init$fromliteral(&_16, "A", 1);
3993- leaf$(&_15, &_16);
3994- string$dest(&_16);
3953+ struct tree$ _16; memset(&_16, 0, sizeof(struct tree$));
3954+ {
3955+ struct string _17; memset(&_17, 0, sizeof(struct string));
3956+ init$fromliteral(&_17, "A", 1);
3957+ leaf$(&_16, &_17);
3958+ string$dest(&_17);
3959+ }
3960+ struct tree$ _17; memset(&_17, 0, sizeof(struct tree$));
3961+ {
3962+ struct string _18; memset(&_18, 0, sizeof(struct string));
3963+ init$fromliteral(&_18, "A", 1);
3964+ leaf$(&_17, &_18);
3965+ string$dest(&_18);
3966+ }
3967+ node$(&_15, &_16, &_17);
3968+ tree$$dest(&_17);
3969+ tree$$dest(&_16);
39953970 }
39963971 struct tree$ _16; memset(&_16, 0, sizeof(struct tree$));
39973972 {
@@ -4004,75 +3979,99 @@
40043979 tree$$dest(&_16);
40053980 tree$$dest(&_15);
40063981 }
4007- push(0 /* _13 */, &_data, &_14, sizeof(struct tree2$), (void (*)(void *))tree2$$dest, (void (*)(void *, const void *))tree2$$copy, 513);
3982+ push(0 /* _13 */, &_data, &_14, sizeof(struct tree2$), (void (*)(void *))tree2$$dest, (void (*)(void *, const void *))tree2$$copy, 512);
40083983 tree2$$dest(&_14);
40093984 }
40103985 {
4011- TestCompareTrees$(0 /* _14 */, &*streams, &_data);
3986+ struct tree2$ _15; memset(&_15, 0, sizeof(struct tree2$));
3987+ {
3988+ struct tree$ _16; memset(&_16, 0, sizeof(struct tree$));
3989+ {
3990+ struct string _17; memset(&_17, 0, sizeof(struct string));
3991+ init$fromliteral(&_17, "A", 1);
3992+ leaf$(&_16, &_17);
3993+ string$dest(&_17);
3994+ }
3995+ struct tree$ _17; memset(&_17, 0, sizeof(struct tree$));
3996+ {
3997+ struct string _18; memset(&_18, 0, sizeof(struct string));
3998+ init$fromliteral(&_18, "A", 1);
3999+ leaf$(&_17, &_18);
4000+ string$dest(&_18);
4001+ }
4002+ tree2$(&_15, &_16, &_17);
4003+ tree$$dest(&_17);
4004+ tree$$dest(&_16);
4005+ }
4006+ push(0 /* _14 */, &_data, &_15, sizeof(struct tree2$), (void (*)(void *))tree2$$dest, (void (*)(void *, const void *))tree2$$copy, 513);
4007+ tree2$$dest(&_15);
40124008 }
4009+ {
4010+ TestCompareTrees$(0 /* _15 */, &*streams, &_data);
4011+ }
40134012 free$(&_data, sizeof(struct tree2$), (void (*)(void *))tree2$$dest);
40144013 }
40154014 struct stack/*string*/ _words; memset(&_words, 0, sizeof(struct stack/*string*/));
40164015 {
4017- struct string _8; memset(&_8, 0, sizeof(struct string));
4018- init$fromliteral(&_8, "123", 3);
4019- push(0 /* _7 */, &_words, &_8, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 519);
4020- string$dest(&_8);
4021- }
4022- {
40234016 struct string _9; memset(&_9, 0, sizeof(struct string));
4024- init$fromliteral(&_9, "456", 3);
4017+ init$fromliteral(&_9, "123", 3);
40254018 push(0 /* _8 */, &_words, &_9, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 519);
40264019 string$dest(&_9);
40274020 }
40284021 {
40294022 struct string _10; memset(&_10, 0, sizeof(struct string));
4030- init$fromliteral(&_10, "789", 3);
4023+ init$fromliteral(&_10, "456", 3);
40314024 push(0 /* _9 */, &_words, &_10, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 519);
40324025 string$dest(&_10);
40334026 }
40344027 {
4035- const struct StreamOut *_11 = &(*streams).out;
4036- Print$stack(0 /* _10 */, &*_11, &_words, sizeof(struct string), (void (*)(void *, const struct StreamOut *, const void *))Print$string);
4028+ struct string _11; memset(&_11, 0, sizeof(struct string));
4029+ init$fromliteral(&_11, "789", 3);
4030+ push(0 /* _10 */, &_words, &_11, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 519);
4031+ string$dest(&_11);
40374032 }
40384033 {
40394034 const struct StreamOut *_12 = &(*streams).out;
4040- struct string _13; memset(&_13, 0, sizeof(struct string));
4041- init$fromliteral(&_13, "\n", 1);
4042- PutStr(0 /* _11 */, &*_12, &_13);
4043- string$dest(&_13);
4035+ Print$stack(0 /* _11 */, &*_12, &_words, sizeof(struct string), (void (*)(void *, const struct StreamOut *, const void *))Print$string);
40444036 }
4037+ {
4038+ const struct StreamOut *_13 = &(*streams).out;
4039+ struct string _14; memset(&_14, 0, sizeof(struct string));
4040+ init$fromliteral(&_14, "\n", 1);
4041+ PutStr(0 /* _12 */, &*_13, &_14);
4042+ string$dest(&_14);
4043+ }
40454044 struct a$ _datatest; memset(&_datatest, 0, sizeof(struct a$));
40464045 {
4047- uint32_t _12; memset(&_12, 0, sizeof(uint32_t));
4048- _12 = 12345;
4049- d$(&_datatest, &_12);
4050- _IGNORE_(_12);
4046+ uint32_t _13; memset(&_13, 0, sizeof(uint32_t));
4047+ _13 = 12345;
4048+ d$(&_datatest, &_13);
4049+ _IGNORE_(_13);
40514050 }
40524051 {
4053- struct string _12; memset(&_12, 0, sizeof(struct string));
4054- init$fromliteral(&_12, "Hello NEW Data!", 15);
4055- uint64_t _13; memset(&_13, 0, sizeof(uint64_t));
4056- _13 = 42;
4057- uint8_t _14; memset(&_14, 0, sizeof(uint8_t));
4052+ struct string _13; memset(&_13, 0, sizeof(struct string));
4053+ init$fromliteral(&_13, "Hello NEW Data!", 15);
4054+ uint64_t _14; memset(&_14, 0, sizeof(uint64_t));
40584055 _14 = 42;
4059- b$(&_datatest, &_12, &_13, &_14);
4056+ uint8_t _15; memset(&_15, 0, sizeof(uint8_t));
4057+ _15 = 42;
4058+ b$(&_datatest, &_13, &_14, &_15);
4059+ _IGNORE_(_15);
40604060 _IGNORE_(_14);
4061- _IGNORE_(_13);
4062- string$dest(&_12);
4061+ string$dest(&_13);
40634062 }
4064- struct a$ _12; memset(&_12, 0, sizeof(struct a$));
4065- a$$copy(&_12, &(_datatest));
4066- switch((_12).type)
4063+ struct a$ _13; memset(&_13, 0, sizeof(struct a$));
4064+ a$$copy(&_13, &(_datatest));
4065+ switch((_13).type)
40674066 {
40684067 case 0: // struct stack/*b$*/ b$:
40694068 {
4070- const struct b$ *content = ((_12).b$).data;
4069+ const struct b$ *content = ((_13).b$).data;
40714070 {
40724071 {
4073- const struct StreamOut *_15 = &(*streams).out;
4074- const struct string *_16 = &(*content).s;
4075- PutStrLn(0 /* _14 */, &*_15, &*_16);
4072+ const struct StreamOut *_16 = &(*streams).out;
4073+ const struct string *_17 = &(*content).s;
4074+ PutStrLn(0 /* _15 */, &*_16, &*_17);
40764075 }
40774076 }
40784077 break;
@@ -4080,11 +4079,11 @@
40804079 case 1: // void c$:
40814080 {
40824081 {
4083- const struct StreamOut *_15 = &(*streams).out;
4084- struct string _16; memset(&_16, 0, sizeof(struct string));
4085- init$fromliteral(&_16, "", 0);
4086- PutStr(0 /* _14 */, &*_15, &_16);
4087- string$dest(&_16);
4082+ const struct StreamOut *_16 = &(*streams).out;
4083+ struct string _17; memset(&_17, 0, sizeof(struct string));
4084+ init$fromliteral(&_17, "", 0);
4085+ PutStr(0 /* _15 */, &*_16, &_17);
4086+ string$dest(&_17);
40884087 }
40894088 break;
40904089 }
@@ -4091,11 +4090,11 @@
40914090 case 2: // struct stack/*d$*/ d$:
40924091 {
40934092 {
4094- const struct StreamOut *_16 = &(*streams).out;
4095- struct string _17; memset(&_17, 0, sizeof(struct string));
4096- init$fromliteral(&_17, "", 0);
4097- PutStr(0 /* _15 */, &*_16, &_17);
4098- string$dest(&_17);
4093+ const struct StreamOut *_17 = &(*streams).out;
4094+ struct string _18; memset(&_18, 0, sizeof(struct string));
4095+ init$fromliteral(&_18, "", 0);
4096+ PutStr(0 /* _16 */, &*_17, &_18);
4097+ string$dest(&_18);
40994098 }
41004099 break;
41014100 }
@@ -4105,28 +4104,28 @@
41054104 break;
41064105 }
41074106 }
4108- a$$dest(&_12);
4107+ a$$dest(&_13);
41094108 {
4110- const struct StreamOut *_17 = &(*streams).out;
4111- struct string _18; memset(&_18, 0, sizeof(struct string));
4112- struct a$ _19; memset(&_19, 0, sizeof(struct a$));
4113- a$$copy(&_19, &(_datatest));
4114- switch((_19).type)
4109+ const struct StreamOut *_18 = &(*streams).out;
4110+ struct string _19; memset(&_19, 0, sizeof(struct string));
4111+ struct a$ _20; memset(&_20, 0, sizeof(struct a$));
4112+ a$$copy(&_20, &(_datatest));
4113+ switch((_20).type)
41154114 {
41164115 case 0: // struct stack/*b$*/ b$:
41174116 {
4118- const struct b$ *content = ((_19).b$).data;
4119- string$copy(&_18, &(*content).s);
4117+ const struct b$ *content = ((_20).b$).data;
4118+ string$copy(&_19, &(*content).s);
41204119 break;
41214120 }
41224121 case 1: // void c$:
41234122 {
4124- init$fromliteral(&_18, "", 0);
4123+ init$fromliteral(&_19, "", 0);
41254124 break;
41264125 }
41274126 case 2: // struct stack/*d$*/ d$:
41284127 {
4129- init$fromliteral(&_18, "", 0);
4128+ init$fromliteral(&_19, "", 0);
41304129 break;
41314130 }
41324131 default:
@@ -4135,49 +4134,29 @@
41354134 break;
41364135 }
41374136 }
4138- a$$dest(&_19);
4139- PutStrLn(0 /* _16 */, &*_17, &_18);
4140- string$dest(&_18);
4137+ a$$dest(&_20);
4138+ PutStrLn(0 /* _17 */, &*_18, &_19);
4139+ string$dest(&_19);
41414140 }
41424141 {
4143- const struct StreamOut *_18 = &(*streams).out;
4144- Print$a$(0 /* _17 */, &*_18, &_datatest);
4142+ const struct StreamOut *_19 = &(*streams).out;
4143+ Print$a$(0 /* _18 */, &*_19, &_datatest);
41454144 }
41464145 {
4147- const struct StreamOut *_19 = &(*streams).out;
4148- struct string _20; memset(&_20, 0, sizeof(struct string));
4149- init$fromliteral(&_20, "\n", 1);
4150- PutStr(0 /* _18 */, &*_19, &_20);
4151- string$dest(&_20);
4146+ const struct StreamOut *_20 = &(*streams).out;
4147+ struct string _21; memset(&_21, 0, sizeof(struct string));
4148+ init$fromliteral(&_21, "\n", 1);
4149+ PutStr(0 /* _19 */, &*_20, &_21);
4150+ string$dest(&_21);
41524151 }
41534152 struct tree$ _tree; memset(&_tree, 0, sizeof(struct tree$));
41544153 {
4155- struct tree$ _19; memset(&_19, 0, sizeof(struct tree$));
4156- {
4157- struct tree$ _20; memset(&_20, 0, sizeof(struct tree$));
4158- {
4159- struct string _21; memset(&_21, 0, sizeof(struct string));
4160- init$fromliteral(&_21, "A", 1);
4161- leaf$(&_20, &_21);
4162- string$dest(&_21);
4163- }
4164- struct tree$ _21; memset(&_21, 0, sizeof(struct tree$));
4165- {
4166- struct string _22; memset(&_22, 0, sizeof(struct string));
4167- init$fromliteral(&_22, "B", 1);
4168- leaf$(&_21, &_22);
4169- string$dest(&_22);
4170- }
4171- node$(&_19, &_20, &_21);
4172- tree$$dest(&_21);
4173- tree$$dest(&_20);
4174- }
41754154 struct tree$ _20; memset(&_20, 0, sizeof(struct tree$));
41764155 {
41774156 struct tree$ _21; memset(&_21, 0, sizeof(struct tree$));
41784157 {
41794158 struct string _22; memset(&_22, 0, sizeof(struct string));
4180- init$fromliteral(&_22, "C", 1);
4159+ init$fromliteral(&_22, "A", 1);
41814160 leaf$(&_21, &_22);
41824161 string$dest(&_22);
41834162 }
@@ -4184,7 +4163,7 @@
41844163 struct tree$ _22; memset(&_22, 0, sizeof(struct tree$));
41854164 {
41864165 struct string _23; memset(&_23, 0, sizeof(struct string));
4187- init$fromliteral(&_23, "D", 1);
4166+ init$fromliteral(&_23, "B", 1);
41884167 leaf$(&_22, &_23);
41894168 string$dest(&_23);
41904169 }
@@ -4192,39 +4171,59 @@
41924171 tree$$dest(&_22);
41934172 tree$$dest(&_21);
41944173 }
4195- node$(&_tree, &_19, &_20);
4174+ struct tree$ _21; memset(&_21, 0, sizeof(struct tree$));
4175+ {
4176+ struct tree$ _22; memset(&_22, 0, sizeof(struct tree$));
4177+ {
4178+ struct string _23; memset(&_23, 0, sizeof(struct string));
4179+ init$fromliteral(&_23, "C", 1);
4180+ leaf$(&_22, &_23);
4181+ string$dest(&_23);
4182+ }
4183+ struct tree$ _23; memset(&_23, 0, sizeof(struct tree$));
4184+ {
4185+ struct string _24; memset(&_24, 0, sizeof(struct string));
4186+ init$fromliteral(&_24, "D", 1);
4187+ leaf$(&_23, &_24);
4188+ string$dest(&_24);
4189+ }
4190+ node$(&_21, &_22, &_23);
4191+ tree$$dest(&_23);
4192+ tree$$dest(&_22);
4193+ }
4194+ node$(&_tree, &_20, &_21);
4195+ tree$$dest(&_21);
41964196 tree$$dest(&_20);
4197- tree$$dest(&_19);
41984197 }
41994198 {
4200- const struct StreamOut *_20 = &(*streams).out;
4201- PrintTree$(0 /* _19 */, &*_20, &_tree);
4202- }
4203- {
42044199 const struct StreamOut *_21 = &(*streams).out;
4205- struct string _22; memset(&_22, 0, sizeof(struct string));
4206- init$fromliteral(&_22, "", 0);
4207- PutStrLn(0 /* _20 */, &*_21, &_22);
4208- string$dest(&_22);
4200+ PrintTree$(0 /* _20 */, &*_21, &_tree);
42094201 }
42104202 {
42114203 const struct StreamOut *_22 = &(*streams).out;
4212- Print$tree$(0 /* _21 */, &*_22, &_tree);
4204+ struct string _23; memset(&_23, 0, sizeof(struct string));
4205+ init$fromliteral(&_23, "", 0);
4206+ PutStrLn(0 /* _21 */, &*_22, &_23);
4207+ string$dest(&_23);
42134208 }
42144209 {
42154210 const struct StreamOut *_23 = &(*streams).out;
4216- struct string _24; memset(&_24, 0, sizeof(struct string));
4217- init$fromliteral(&_24, "\n", 1);
4218- PutStr(0 /* _22 */, &*_23, &_24);
4219- string$dest(&_24);
4211+ Print$tree$(0 /* _22 */, &*_23, &_tree);
42204212 }
42214213 {
4214+ const struct StreamOut *_24 = &(*streams).out;
4215+ struct string _25; memset(&_25, 0, sizeof(struct string));
4216+ init$fromliteral(&_25, "\n", 1);
4217+ PutStr(0 /* _23 */, &*_24, &_25);
4218+ string$dest(&_25);
4219+ }
4220+ {
42224221 {
4223- const struct StreamOut *_25 = &(*streams).out;
4224- struct string _26; memset(&_26, 0, sizeof(struct string));
4225- init$fromliteral(&_26, "for-test 1: ", 12);
4226- PutStrLn(0 /* _24 */, &*_25, &_26);
4227- string$dest(&_26);
4222+ const struct StreamOut *_26 = &(*streams).out;
4223+ struct string _27; memset(&_27, 0, sizeof(struct string));
4224+ init$fromliteral(&_27, "for-test 1: ", 12);
4225+ PutStrLn(0 /* _25 */, &*_26, &_27);
4226+ string$dest(&_27);
42284227 }
42294228 uint32_t _i = 0;
42304229 _i = 5;
@@ -4231,170 +4230,170 @@
42314230 while(_i--)
42324231 {
42334232 {
4234- const struct StreamOut *_26 = &(*streams).out;
4235- Print$u32(0 /* _25 */, &*_26, &_i);
4233+ const struct StreamOut *_27 = &(*streams).out;
4234+ Print$u32(0 /* _26 */, &*_27, &_i);
42364235 }
42374236 }
42384237 {
4239- const struct StreamOut *_26 = &(*streams).out;
4240- struct string _27; memset(&_27, 0, sizeof(struct string));
4241- init$fromliteral(&_27, "", 0);
4242- PutStrLn(0 /* _25 */, &*_26, &_27);
4243- string$dest(&_27);
4244- }
4245- {
42464238 const struct StreamOut *_27 = &(*streams).out;
42474239 struct string _28; memset(&_28, 0, sizeof(struct string));
4248- init$fromliteral(&_28, "for-test 2: ", 12);
4240+ init$fromliteral(&_28, "", 0);
42494241 PutStrLn(0 /* _26 */, &*_27, &_28);
42504242 string$dest(&_28);
42514243 }
4252- uint32_t _27 = 0;
4253- _27 = 5;
4254- while(_27--)
42554244 {
4245+ const struct StreamOut *_28 = &(*streams).out;
4246+ struct string _29; memset(&_29, 0, sizeof(struct string));
4247+ init$fromliteral(&_29, "for-test 2: ", 12);
4248+ PutStrLn(0 /* _27 */, &*_28, &_29);
4249+ string$dest(&_29);
4250+ }
4251+ uint32_t _28 = 0;
4252+ _28 = 5;
4253+ while(_28--)
4254+ {
42564255 {
4257- const struct StreamOut *_29 = &(*streams).out;
4258- struct string _30; memset(&_30, 0, sizeof(struct string));
4259- init$fromliteral(&_30, ".", 1);
4260- PutStr(0 /* _28 */, &*_29, &_30);
4261- string$dest(&_30);
4256+ const struct StreamOut *_30 = &(*streams).out;
4257+ struct string _31; memset(&_31, 0, sizeof(struct string));
4258+ init$fromliteral(&_31, ".", 1);
4259+ PutStr(0 /* _29 */, &*_30, &_31);
4260+ string$dest(&_31);
42624261 }
42634262 }
42644263 {
4265- const struct StreamOut *_29 = &(*streams).out;
4266- struct string _30; memset(&_30, 0, sizeof(struct string));
4267- init$fromliteral(&_30, "", 0);
4268- PutStrLn(0 /* _28 */, &*_29, &_30);
4269- string$dest(&_30);
4270- }
4271- {
42724264 const struct StreamOut *_30 = &(*streams).out;
42734265 struct string _31; memset(&_31, 0, sizeof(struct string));
4274- init$fromliteral(&_31, "for-test 3: ", 12);
4266+ init$fromliteral(&_31, "", 0);
42754267 PutStrLn(0 /* _29 */, &*_30, &_31);
42764268 string$dest(&_31);
42774269 }
4270+ {
4271+ const struct StreamOut *_31 = &(*streams).out;
4272+ struct string _32; memset(&_32, 0, sizeof(struct string));
4273+ init$fromliteral(&_32, "for-test 3: ", 12);
4274+ PutStrLn(0 /* _30 */, &*_31, &_32);
4275+ string$dest(&_32);
4276+ }
42784277 struct string _s; memset(&_s, 0, sizeof(struct string));
42794278 init$fromliteral(&_s, "Test!", 5);
4280- struct stack/*u8*/ _31; memset(&_31, 0, sizeof(struct stack/*u8*/));
4281- clone$(&_31, &(_s).data, sizeof(uint8_t), 0/*DEST*/, 0/*COPY*/);
4282- for(uint64_t _32 = 0; _32 < _31.ptr; ++_32)
4279+ struct stack/*u8*/ _32; memset(&_32, 0, sizeof(struct stack/*u8*/));
4280+ clone$(&_32, &(_s).data, sizeof(uint8_t), 0/*DEST*/, 0/*COPY*/);
4281+ for(uint64_t _33 = 0; _33 < _32.ptr; ++_33)
42834282 {
42844283 {
4285- const struct StreamOut *_34 = &(*streams).out;
4286- struct string _35; memset(&_35, 0, sizeof(struct string));
4287- init$fromliteral(&_35, "#", 1);
4288- PutStr(0 /* _33 */, &*_34, &_35);
4289- string$dest(&_35);
4284+ const struct StreamOut *_35 = &(*streams).out;
4285+ struct string _36; memset(&_36, 0, sizeof(struct string));
4286+ init$fromliteral(&_36, "#", 1);
4287+ PutStr(0 /* _34 */, &*_35, &_36);
4288+ string$dest(&_36);
42904289 }
42914290 }
4292- free$(&_31, sizeof(uint8_t), 0/*DEST*/);
4291+ free$(&_32, sizeof(uint8_t), 0/*DEST*/);
42934292 {
4294- const struct StreamOut *_34 = &(*streams).out;
4295- struct string _35; memset(&_35, 0, sizeof(struct string));
4296- init$fromliteral(&_35, "", 0);
4297- PutStrLn(0 /* _33 */, &*_34, &_35);
4298- string$dest(&_35);
4299- }
4300- {
43014293 const struct StreamOut *_35 = &(*streams).out;
43024294 struct string _36; memset(&_36, 0, sizeof(struct string));
4303- init$fromliteral(&_36, "for-test 4: ", 12);
4295+ init$fromliteral(&_36, "", 0);
43044296 PutStrLn(0 /* _34 */, &*_35, &_36);
43054297 string$dest(&_36);
43064298 }
4307- struct stack/*u8*/ _35; memset(&_35, 0, sizeof(struct stack/*u8*/));
4308- clone$(&_35, &(_s).data, sizeof(uint8_t), 0/*DEST*/, 0/*COPY*/);
4309- for(uint64_t _36 = 0; _36 < _35.ptr; ++_36)
43104299 {
4300+ const struct StreamOut *_36 = &(*streams).out;
4301+ struct string _37; memset(&_37, 0, sizeof(struct string));
4302+ init$fromliteral(&_37, "for-test 4: ", 12);
4303+ PutStrLn(0 /* _35 */, &*_36, &_37);
4304+ string$dest(&_37);
4305+ }
4306+ struct stack/*u8*/ _36; memset(&_36, 0, sizeof(struct stack/*u8*/));
4307+ clone$(&_36, &(_s).data, sizeof(uint8_t), 0/*DEST*/, 0/*COPY*/);
4308+ for(uint64_t _37 = 0; _37 < _36.ptr; ++_37)
4309+ {
43114310 uint8_t _e; memset(&_e, 0, sizeof(uint8_t));
4312- at_get$(&_e, &_35, &_36, sizeof(uint8_t), 0/*DEST*/, 0/*COPY*/, 562);
4311+ at_get$(&_e, &_36, &_37, sizeof(uint8_t), 0/*DEST*/, 0/*COPY*/, 562);
43134312 {
4314- const struct StreamOut *_38 = &(*streams).out;
4315- Put(0 /* _37 */, &*_38, &_e);
4313+ const struct StreamOut *_39 = &(*streams).out;
4314+ Put(0 /* _38 */, &*_39, &_e);
43164315 }
43174316 _IGNORE_(_e);
43184317 }
4319- free$(&_35, sizeof(uint8_t), 0/*DEST*/);
4318+ free$(&_36, sizeof(uint8_t), 0/*DEST*/);
43204319 {
4321- const struct StreamOut *_38 = &(*streams).out;
4322- struct string _39; memset(&_39, 0, sizeof(struct string));
4323- init$fromliteral(&_39, "", 0);
4324- PutStrLn(0 /* _37 */, &*_38, &_39);
4325- string$dest(&_39);
4320+ const struct StreamOut *_39 = &(*streams).out;
4321+ struct string _40; memset(&_40, 0, sizeof(struct string));
4322+ init$fromliteral(&_40, "", 0);
4323+ PutStrLn(0 /* _38 */, &*_39, &_40);
4324+ string$dest(&_40);
43264325 }
43274326 string$dest(&_s);
43284327 }
43294328 {
4330- const struct StreamOut *_25 = &(*streams).out;
4331- TstStk$(0 /* _24 */, &*_25);
4329+ const struct StreamOut *_26 = &(*streams).out;
4330+ TstStk$(0 /* _25 */, &*_26);
43324331 }
43334332 {
4334- const struct StreamOut *_26 = &(*streams).out;
4335- TstDyn$(0 /* _25 */, &*_26);
4333+ const struct StreamOut *_27 = &(*streams).out;
4334+ TstDyn$(0 /* _26 */, &*_27);
43364335 }
43374336 {
4338- const struct StreamOut *_27 = &(*streams).out;
4339- struct string _28; memset(&_28, 0, sizeof(struct string));
4337+ const struct StreamOut *_28 = &(*streams).out;
4338+ struct string _29; memset(&_29, 0, sizeof(struct string));
43404339 {
4341- testTemporaryDynamics$(&_28);
4340+ testTemporaryDynamics$(&_29);
43424341 }
4343- PutStr(0 /* _26 */, &*_27, &_28);
4344- string$dest(&_28);
4342+ PutStr(0 /* _27 */, &*_28, &_29);
4343+ string$dest(&_29);
43454344 }
43464345 //PutStr(streams.out, "Hello World\n");
43474346 {
4348- const struct StreamOut *_28 = &(*streams).out;
4349- struct string _29; memset(&_29, 0, sizeof(struct string));
4347+ const struct StreamOut *_29 = &(*streams).out;
4348+ struct string _30; memset(&_30, 0, sizeof(struct string));
43504349 {
4351- struct string _30; memset(&_30, 0, sizeof(struct string));
4352- init$fromliteral(&_30, "Hello ", 6);
43534350 struct string _31; memset(&_31, 0, sizeof(struct string));
4354- init$fromliteral(&_31, "World\n", 6);
4355- strcat$(&_29, &_30, &_31, 572);
4351+ init$fromliteral(&_31, "Hello ", 6);
4352+ struct string _32; memset(&_32, 0, sizeof(struct string));
4353+ init$fromliteral(&_32, "World\n", 6);
4354+ strcat$(&_30, &_31, &_32, 572);
4355+ string$dest(&_32);
43564356 string$dest(&_31);
4357- string$dest(&_30);
43584357 }
4359- PutStr(0 /* _27 */, &*_28, &_29);
4360- string$dest(&_29);
4358+ PutStr(0 /* _28 */, &*_29, &_30);
4359+ string$dest(&_30);
43614360 }
43624361 //let U$ test = s$("Hello Union!");
43634362 struct U$ _test; memset(&_test, 0, sizeof(struct U$));
43644363 {
4365- struct string _28; memset(&_28, 0, sizeof(struct string));
4366- init$fromliteral(&_28, "Hello???", 8);
4367- s$(&_test, &_28);
4368- string$dest(&_28);
4364+ struct string _29; memset(&_29, 0, sizeof(struct string));
4365+ init$fromliteral(&_29, "Hello???", 8);
4366+ s$(&_test, &_29);
4367+ string$dest(&_29);
43694368 }
43704369 {
4371- struct string _28; memset(&_28, 0, sizeof(struct string));
4372- init$fromliteral(&_28, "Hello Union!!!", 14);
4373- s$(&_test, &_28);
4374- string$dest(&_28);
4370+ struct string _29; memset(&_29, 0, sizeof(struct string));
4371+ init$fromliteral(&_29, "Hello Union!!!", 14);
4372+ s$(&_test, &_29);
4373+ string$dest(&_29);
43754374 }
43764375 {
4377- const struct StreamOut *_29 = &(*streams).out;
4378- struct string _30; memset(&_30, 0, sizeof(struct string));
4376+ const struct StreamOut *_30 = &(*streams).out;
4377+ struct string _31; memset(&_31, 0, sizeof(struct string));
43794378 {
4380- getstr$(&_30, &_test);
4379+ getstr$(&_31, &_test);
43814380 }
4382- PutStrLn(0 /* _28 */, &*_29, &_30);
4383- string$dest(&_30);
4381+ PutStrLn(0 /* _29 */, &*_30, &_31);
4382+ string$dest(&_31);
43844383 }
4385- struct U$ _29; memset(&_29, 0, sizeof(struct U$));
4386- U$$copy(&_29, &(_test));
4387- switch((_29).type)
4384+ struct U$ _30; memset(&_30, 0, sizeof(struct U$));
4385+ U$$copy(&_30, &(_test));
4386+ switch((_30).type)
43884387 {
43894388 case 0: // uint32_t x:
43904389 {
43914390 {
43924391 {
4393- const struct StreamOut *_32 = &(*streams).out;
4394- struct string _33; memset(&_33, 0, sizeof(struct string));
4395- init$fromliteral(&_33, "u", 1);
4396- PutStrLn(0 /* _31 */, &*_32, &_33);
4397- string$dest(&_33);
4392+ const struct StreamOut *_33 = &(*streams).out;
4393+ struct string _34; memset(&_34, 0, sizeof(struct string));
4394+ init$fromliteral(&_34, "u", 1);
4395+ PutStrLn(0 /* _32 */, &*_33, &_34);
4396+ string$dest(&_34);
43984397 }
43994398 }
44004399 break;
@@ -4402,11 +4401,11 @@
44024401 case 1: // bool b:
44034402 {
44044403 {
4405- const struct StreamOut *_32 = &(*streams).out;
4406- struct string _33; memset(&_33, 0, sizeof(struct string));
4407- init$fromliteral(&_33, "nr", 2);
4408- PutStrLn(0 /* _31 */, &*_32, &_33);
4409- string$dest(&_33);
4404+ const struct StreamOut *_33 = &(*streams).out;
4405+ struct string _34; memset(&_34, 0, sizeof(struct string));
4406+ init$fromliteral(&_34, "nr", 2);
4407+ PutStrLn(0 /* _32 */, &*_33, &_34);
4408+ string$dest(&_34);
44104409 }
44114410 break;
44124411 }
@@ -4413,20 +4412,20 @@
44134412 case 2: // void v:
44144413 {
44154414 {
4416- const struct StreamOut *_33 = &(*streams).out;
4417- struct string _34; memset(&_34, 0, sizeof(struct string));
4418- init$fromliteral(&_34, "v", 1);
4419- PutStrLn(0 /* _32 */, &*_33, &_34);
4420- string$dest(&_34);
4415+ const struct StreamOut *_34 = &(*streams).out;
4416+ struct string _35; memset(&_35, 0, sizeof(struct string));
4417+ init$fromliteral(&_35, "v", 1);
4418+ PutStrLn(0 /* _33 */, &*_34, &_35);
4419+ string$dest(&_35);
44214420 }
44224421 break;
44234422 }
44244423 case 3: // struct string s$:
44254424 {
4426- const struct string *val = &((_29).s$);
4425+ const struct string *val = &((_30).s$);
44274426 {
4428- const struct StreamOut *_34 = &(*streams).out;
4429- PutStrLn(0 /* _33 */, &*_34, &*val);
4427+ const struct StreamOut *_35 = &(*streams).out;
4428+ PutStrLn(0 /* _34 */, &*_35, &*val);
44304429 }
44314430 break;
44324431 }
@@ -4436,7 +4435,7 @@
44364435 break;
44374436 }
44384437 }
4439- U$$dest(&_29);
4438+ U$$dest(&_30);
44404439 struct enu _en; memset(&_en, 0, sizeof(struct enu));
44414440 {
44424441 one(&_en);
@@ -4444,43 +4443,43 @@
44444443 {
44454444 two(&_en);
44464445 }
4447- struct enu _34; memset(&_34, 0, sizeof(struct enu));
4448- enu$copy(&_34, &(_en));
4449- switch((_34).type)
4446+ struct enu _35; memset(&_35, 0, sizeof(struct enu));
4447+ enu$copy(&_35, &(_en));
4448+ switch((_35).type)
44504449 {
44514450 case 0: // void zero:
44524451 {
44534452 {
4454- const struct StreamOut *_36 = &(*streams).out;
4455- struct string _37; memset(&_37, 0, sizeof(struct string));
4456- init$fromliteral(&_37, "zero", 4);
4457- PutStrLn(0 /* _35 */, &*_36, &_37);
4458- string$dest(&_37);
4459- }
4460- break;
4461- }
4462- case 1: // void one:
4463- {
4464- {
44654453 const struct StreamOut *_37 = &(*streams).out;
44664454 struct string _38; memset(&_38, 0, sizeof(struct string));
4467- init$fromliteral(&_38, "one", 3);
4455+ init$fromliteral(&_38, "zero", 4);
44684456 PutStrLn(0 /* _36 */, &*_37, &_38);
44694457 string$dest(&_38);
44704458 }
44714459 break;
44724460 }
4473- case 2: // void two:
4461+ case 1: // void one:
44744462 {
44754463 {
44764464 const struct StreamOut *_38 = &(*streams).out;
44774465 struct string _39; memset(&_39, 0, sizeof(struct string));
4478- init$fromliteral(&_39, "two", 3);
4466+ init$fromliteral(&_39, "one", 3);
44794467 PutStrLn(0 /* _37 */, &*_38, &_39);
44804468 string$dest(&_39);
44814469 }
44824470 break;
44834471 }
4472+ case 2: // void two:
4473+ {
4474+ {
4475+ const struct StreamOut *_39 = &(*streams).out;
4476+ struct string _40; memset(&_40, 0, sizeof(struct string));
4477+ init$fromliteral(&_40, "two", 3);
4478+ PutStrLn(0 /* _38 */, &*_39, &_40);
4479+ string$dest(&_40);
4480+ }
4481+ break;
4482+ }
44844483 default:
44854484 {
44864485 fprintf(stderr, "INTERNAL ERROR IN SWITCH");
@@ -4487,46 +4486,46 @@
44874486 break;
44884487 }
44894488 }
4490- enu$dest(&_34);
4491- struct enu2 _38; memset(&_38, 0, sizeof(struct enu2));
4489+ enu$dest(&_35);
4490+ struct enu2 _39; memset(&_39, 0, sizeof(struct enu2));
44924491 {
4493- zero2(&_38);
4492+ zero2(&_39);
44944493 }
4495- switch((_38).type)
4494+ switch((_39).type)
44964495 {
44974496 case 0: // void zero2:
44984497 {
44994498 {
4500- const struct StreamOut *_40 = &(*streams).out;
4501- struct string _41; memset(&_41, 0, sizeof(struct string));
4502- init$fromliteral(&_41, "zero2", 5);
4503- PutStrLn(0 /* _39 */, &*_40, &_41);
4504- string$dest(&_41);
4505- }
4506- break;
4507- }
4508- case 1: // void one2:
4509- {
4510- {
45114499 const struct StreamOut *_41 = &(*streams).out;
45124500 struct string _42; memset(&_42, 0, sizeof(struct string));
4513- init$fromliteral(&_42, "one2", 4);
4501+ init$fromliteral(&_42, "zero2", 5);
45144502 PutStrLn(0 /* _40 */, &*_41, &_42);
45154503 string$dest(&_42);
45164504 }
45174505 break;
45184506 }
4519- case 2: // void two2:
4507+ case 1: // void one2:
45204508 {
45214509 {
45224510 const struct StreamOut *_42 = &(*streams).out;
45234511 struct string _43; memset(&_43, 0, sizeof(struct string));
4524- init$fromliteral(&_43, "two2", 4);
4512+ init$fromliteral(&_43, "one2", 4);
45254513 PutStrLn(0 /* _41 */, &*_42, &_43);
45264514 string$dest(&_43);
45274515 }
45284516 break;
45294517 }
4518+ case 2: // void two2:
4519+ {
4520+ {
4521+ const struct StreamOut *_43 = &(*streams).out;
4522+ struct string _44; memset(&_44, 0, sizeof(struct string));
4523+ init$fromliteral(&_44, "two2", 4);
4524+ PutStrLn(0 /* _42 */, &*_43, &_44);
4525+ string$dest(&_44);
4526+ }
4527+ break;
4528+ }
45304529 default:
45314530 {
45324531 fprintf(stderr, "INTERNAL ERROR IN SWITCH");
@@ -4533,112 +4532,112 @@
45334532 break;
45344533 }
45354534 }
4536- enu2$dest(&_38);
4535+ enu2$dest(&_39);
45374536 struct stack/*string*/ _other; memset(&_other, 0, sizeof(struct stack/*string*/));
45384537 {
4539- struct string _42; memset(&_42, 0, sizeof(struct string));
4540- init$fromliteral(&_42, "SOLID", 5);
4541- solid(&_other, &_42, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 598);
4542- string$dest(&_42);
4538+ struct string _43; memset(&_43, 0, sizeof(struct string));
4539+ init$fromliteral(&_43, "SOLID", 5);
4540+ solid(&_other, &_43, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 598);
4541+ string$dest(&_43);
45434542 }
45444543 {
4545- const struct StreamOut *_43 = &(*streams).out;
4546- struct string _44; memset(&_44, 0, sizeof(struct string));
4547- struct stack/*string*/ _45; memset(&_45, 0, sizeof(struct stack/*string*/));
4548- clone$(&_45, &(_other), sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy);
4549- if(!(_45).size)
4544+ const struct StreamOut *_44 = &(*streams).out;
4545+ struct string _45; memset(&_45, 0, sizeof(struct string));
4546+ struct stack/*string*/ _46; memset(&_46, 0, sizeof(struct stack/*string*/));
4547+ clone$(&_46, &(_other), sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy);
4548+ if(!(_46).size)
45504549 {
4551- init$fromliteral(&_44, "EMPTY", 5);
4550+ init$fromliteral(&_45, "EMPTY", 5);
45524551 }
45534552 else
45544553 {
4555- const struct string *s = (_45).data;
4556- string$copy(&_44, &(*s));
4554+ const struct string *s = (_46).data;
4555+ string$copy(&_45, &(*s));
45574556 }
4558- free$(&_45, sizeof(struct string), (void (*)(void *))string$dest);
4559- PutStrLn(0 /* _42 */, &*_43, &_44);
4560- string$dest(&_44);
4557+ free$(&_46, sizeof(struct string), (void (*)(void *))string$dest);
4558+ PutStrLn(0 /* _43 */, &*_44, &_45);
4559+ string$dest(&_45);
45614560 }
4562- struct stack/*string*/ _43; memset(&_43, 0, sizeof(struct stack/*string*/));
4563- clone$(&_43, &(_other), sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy);
4564- if(!(_43).size)
4561+ struct stack/*string*/ _44; memset(&_44, 0, sizeof(struct stack/*string*/));
4562+ clone$(&_44, &(_other), sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy);
4563+ if(!(_44).size)
45654564 {
45664565 {
4567- const struct StreamOut *_45 = &(*streams).out;
4568- struct string _46; memset(&_46, 0, sizeof(struct string));
4569- init$fromliteral(&_46, "EMPTY", 5);
4570- PutStrLn(0 /* _44 */, &*_45, &_46);
4571- string$dest(&_46);
4566+ const struct StreamOut *_46 = &(*streams).out;
4567+ struct string _47; memset(&_47, 0, sizeof(struct string));
4568+ init$fromliteral(&_47, "EMPTY", 5);
4569+ PutStrLn(0 /* _45 */, &*_46, &_47);
4570+ string$dest(&_47);
45724571 }
45734572 }
45744573 else
45754574 {
4576- const struct string *s = (_43).data;
4575+ const struct string *s = (_44).data;
45774576 {
4578- const struct StreamOut *_46 = &(*streams).out;
4579- PutStrLn(0 /* _45 */, &*_46, &*s);
4577+ const struct StreamOut *_47 = &(*streams).out;
4578+ PutStrLn(0 /* _46 */, &*_47, &*s);
45804579 }
45814580 }
4582- free$(&_43, sizeof(struct string), (void (*)(void *))string$dest);
4581+ free$(&_44, sizeof(struct string), (void (*)(void *))string$dest);
45834582 // verify ignoring dynamic return values
45844583 struct string _str; memset(&_str, 0, sizeof(struct string));
45854584 init$fromliteral(&_str, "test...", 7);
45864585 struct stack/*string*/ _stk; memset(&_stk, 0, sizeof(struct stack/*string*/));
45874586 {
4588- push(0 /* _46 */, &_stk, &_str, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 607);
4587+ push(0 /* _47 */, &_stk, &_str, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 607);
45894588 }
45904589 {
4591- push(0 /* _47 */, &_stk, &_str, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 608);
4590+ push(0 /* _48 */, &_stk, &_str, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 608);
45924591 }
45934592 {
4594- struct stack/*string*/ _48; memset(&_48, 0, sizeof(struct stack/*string*/));
4595- pop_opt(&_48, &_stk, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 609);
4596- free$(&_48, sizeof(struct string), (void (*)(void *))string$dest);
4593+ struct stack/*string*/ _49; memset(&_49, 0, sizeof(struct stack/*string*/));
4594+ pop_opt(&_49, &_stk, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 609);
4595+ free$(&_49, sizeof(struct string), (void (*)(void *))string$dest);
45974596 }
45984597 {
45994598 stack(&_stk, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 610);
46004599 }
46014600 {
4602- struct stack/*u8*/ _48; memset(&_48, 0, sizeof(struct stack/*u8*/));
4603- access$(&_48, &_str);
4604- free$(&_48, sizeof(uint8_t), 0/*DEST*/);
4601+ struct stack/*u8*/ _49; memset(&_49, 0, sizeof(struct stack/*u8*/));
4602+ access$(&_49, &_str);
4603+ free$(&_49, sizeof(uint8_t), 0/*DEST*/);
46054604 }
46064605 struct Box$ _A; memset(&_A, 0, sizeof(struct Box$));
46074606 {
4608- struct string _48; memset(&_48, 0, sizeof(struct string));
4609- init$fromliteral(&_48, "ABC", 3);
4610- Box$(&_A, &_48);
4611- string$dest(&_48);
4612- }
4613- {
46144607 struct string _49; memset(&_49, 0, sizeof(struct string));
4615- init$fromliteral(&_49, "ref-count box test", 18);
4616- boxset$(0 /* _48 */, &_A, &_49);
4608+ init$fromliteral(&_49, "ABC", 3);
4609+ Box$(&_A, &_49);
46174610 string$dest(&_49);
46184611 }
4612+ {
4613+ struct string _50; memset(&_50, 0, sizeof(struct string));
4614+ init$fromliteral(&_50, "ref-count box test", 18);
4615+ boxset$(0 /* _49 */, &_A, &_50);
4616+ string$dest(&_50);
4617+ }
46194618 struct Box$ _B; memset(&_B, 0, sizeof(struct Box$));
46204619 Box$$copy(&_B, &(_A));
46214620 struct Box$ _C; memset(&_C, 0, sizeof(struct Box$));
46224621 {
4623- struct string _49; memset(&_49, 0, sizeof(struct string));
4624- init$fromliteral(&_49, "DEF", 3);
4625- Box$(&_C, &_49);
4626- string$dest(&_49);
4622+ struct string _50; memset(&_50, 0, sizeof(struct string));
4623+ init$fromliteral(&_50, "DEF", 3);
4624+ Box$(&_C, &_50);
4625+ string$dest(&_50);
46274626 }
46284627 Box$$copy(&_C, &(_B));
46294628 {
4630- const struct StreamOut *_50 = &(*streams).out;
4631- struct string _51; memset(&_51, 0, sizeof(struct string));
4629+ const struct StreamOut *_51 = &(*streams).out;
4630+ struct string _52; memset(&_52, 0, sizeof(struct string));
46324631 {
4633- boxget$(&_51, &_C);
4632+ boxget$(&_52, &_C);
46344633 }
4635- PutStrLn(0 /* _49 */, &*_50, &_51);
4636- string$dest(&_51);
4634+ PutStrLn(0 /* _50 */, &*_51, &_52);
4635+ string$dest(&_52);
46374636 }
4638- uint32_t _50; memset(&_50, 0, sizeof(uint32_t));
4639- _50 = 0;
4640- *_0 = _50;
4641- _IGNORE_(_50);
4637+ uint32_t _51; memset(&_51, 0, sizeof(uint32_t));
4638+ _51 = 0;
4639+ *_0 = _51;
4640+ _IGNORE_(_51);
46424641 Box$$dest(&_C);
46434642 Box$$dest(&_B);
46444643 Box$$dest(&_A);
--- trunk/pragmatic/self_hosting_compiled.c (revision 34)
+++ trunk/pragmatic/self_hosting_compiled.c (revision 35)
@@ -16899,6 +16899,9 @@
1689916899 Fail$(0 /* _18 */, &*_19, &*txtpos);
1690016900 }
1690116901 }
16902+ struct stack/*string*/ _path2; memset(&_path2, 0, sizeof(struct stack/*string*/));
16903+ clone$(&_path2, &(_path), sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy);
16904+ // PrintPath consumes path!
1690216905 struct qtypepureid _mut_elem; memset(&_mut_elem, 0, sizeof(struct qtypepureid));
1690316906 {
1690416907 struct qtypepure _16; memset(&_16, 0, sizeof(struct qtypepure));
@@ -16951,7 +16954,7 @@
1695116954 varinit(&_19, &_20);
1695216955 qtypepureid$dest(&_20);
1695316956 }
16954- push(0 /* _18 */, &*scope, &_19, sizeof(struct var), (void (*)(void *))var$dest, (void (*)(void *, const void *))var$copy, 3828);
16957+ push(0 /* _18 */, &*scope, &_19, sizeof(struct var), (void (*)(void *))var$dest, (void (*)(void *, const void *))var$copy, 3829);
1695516958 var$dest(&_19);
1695616959 }
1695716960 }
@@ -16961,7 +16964,11 @@
1696116964 AssertGet$(0 /* _18 */, &*streams, &*txtpos, &*level, &_19);
1696216965 _IGNORE_(_19);
1696316966 }
16967+ struct string _tmpid; memset(&_tmpid, 0, sizeof(struct string));
1696416968 {
16969+ GenVar$(&_tmpid, &*tmpnr);
16970+ }
16971+ {
1696516972 const struct StreamOut *_20 = &(*streams).out;
1696616973 Indent$(0 /* _19 */, &*_20, &*level);
1696716974 }
@@ -16968,70 +16975,62 @@
1696816975 {
1696916976 const struct StreamOut *_21 = &(*streams).out;
1697016977 struct string _22; memset(&_22, 0, sizeof(struct string));
16971- init$fromliteral(&_22, "uint8_t ", 8);
16978+ init$fromliteral(&_22, "for(int ", 8);
1697216979 PutStr(0 /* _20 */, &*_21, &_22);
1697316980 string$dest(&_22);
1697416981 }
1697516982 {
1697616983 const struct StreamOut *_22 = &(*streams).out;
16977- PutStr(0 /* _21 */, &*_22, &_elem_id);
16984+ PutStr(0 /* _21 */, &*_22, &_tmpid);
1697816985 }
1697916986 {
1698016987 const struct StreamOut *_23 = &(*streams).out;
1698116988 struct string _24; memset(&_24, 0, sizeof(struct string));
16982- init$fromliteral(&_24, " = 0;", 5);
16983- PutStrLn(0 /* _22 */, &*_23, &_24);
16989+ init$fromliteral(&_24, " = getc(((*", 11);
16990+ PutStr(0 /* _22 */, &*_23, &_24);
1698416991 string$dest(&_24);
1698516992 }
1698616993 {
1698716994 const struct StreamOut *_24 = &(*streams).out;
16988- Indent$(0 /* _23 */, &*_24, &*level);
16995+ PutStr(0 /* _23 */, &*_24, &_var);
1698916996 }
1699016997 {
1699116998 const struct StreamOut *_25 = &(*streams).out;
1699216999 struct string _26; memset(&_26, 0, sizeof(struct string));
16993- init$fromliteral(&_26, "do", 2);
17000+ init$fromliteral(&_26, ")", 1);
1699417001 PutStr(0 /* _24 */, &*_25, &_26);
1699517002 string$dest(&_26);
1699617003 }
1699717004 {
1699817005 const struct StreamOut *_26 = &(*streams).out;
16999- Indent$(0 /* _25 */, &*_26, &*level);
17006+ PrintPath$(0 /* _25 */, &*_26, &_path);
1700017007 }
1700117008 {
1700217009 const struct StreamOut *_27 = &(*streams).out;
1700317010 struct string _28; memset(&_28, 0, sizeof(struct string));
17004- init$fromliteral(&_28, "{", 1);
17005- PutStrLn(0 /* _26 */, &*_27, &_28);
17011+ init$fromliteral(&_28, ").f); ", 6);
17012+ PutStr(0 /* _26 */, &*_27, &_28);
1700617013 string$dest(&_28);
1700717014 }
1700817015 {
1700917016 const struct StreamOut *_28 = &(*streams).out;
17010- uint64_t _29; memset(&_29, 0, sizeof(uint64_t));
17011- {
17012- uint64_t _30; memset(&_30, 0, sizeof(uint64_t));
17013- _30 = 1;
17014- _29 = _30 + *level;
17015- _IGNORE_(_30);
17016- }
17017- Indent$(0 /* _27 */, &*_28, &_29);
17018- _IGNORE_(_29);
17017+ PutStr(0 /* _27 */, &*_28, &_tmpid);
1701917018 }
1702017019 {
1702117020 const struct StreamOut *_29 = &(*streams).out;
1702217021 struct string _30; memset(&_30, 0, sizeof(struct string));
17023- init$fromliteral(&_30, "Get(&", 5);
17022+ init$fromliteral(&_30, " >= 0; ", 7);
1702417023 PutStr(0 /* _28 */, &*_29, &_30);
1702517024 string$dest(&_30);
1702617025 }
1702717026 {
1702817027 const struct StreamOut *_30 = &(*streams).out;
17029- PutStr(0 /* _29 */, &*_30, &_elem_id);
17028+ PutStr(0 /* _29 */, &*_30, &_tmpid);
1703017029 }
1703117030 {
1703217031 const struct StreamOut *_31 = &(*streams).out;
1703317032 struct string _32; memset(&_32, 0, sizeof(struct string));
17034- init$fromliteral(&_32, ", &((*", 6);
17033+ init$fromliteral(&_32, " = getc(((*", 11);
1703517034 PutStr(0 /* _30 */, &*_31, &_32);
1703617035 string$dest(&_32);
1703717036 }
@@ -17048,71 +17047,103 @@
1704817047 }
1704917048 {
1705017049 const struct StreamOut *_34 = &(*streams).out;
17051- PrintPath$(0 /* _33 */, &*_34, &_path);
17050+ PrintPath$(0 /* _33 */, &*_34, &_path2);
1705217051 }
1705317052 {
1705417053 const struct StreamOut *_35 = &(*streams).out;
1705517054 struct string _36; memset(&_36, 0, sizeof(struct string));
17056- init$fromliteral(&_36, "));", 3);
17055+ init$fromliteral(&_36, ").f))", 5);
1705717056 PutStrLn(0 /* _34 */, &*_35, &_36);
1705817057 string$dest(&_36);
1705917058 }
1706017059 {
17061- uint64_t _36; memset(&_36, 0, sizeof(uint64_t));
17062- {
17063- uint64_t _37; memset(&_37, 0, sizeof(uint64_t));
17064- _37 = 1;
17065- _36 = _37 + *level;
17066- _IGNORE_(_37);
17067- }
17068- struct stack/*qtypepureid*/ _37; memset(&_37, 0, sizeof(struct stack/*qtypepureid*/));
17069- {
17070- empty(&_37, sizeof(struct qtypepureid), (void (*)(void *))qtypepureid$dest, (void (*)(void *, const void *))qtypepureid$copy, 3843);
17071- }
17072- ParseBlockRaw$(0 /* _35 */, &*streams, &*txtpos, &*state, &_36, &*scope, &*tmpnr, &_37, &*partial, &*action, &*self);
17073- free$(&_37, sizeof(struct qtypepureid), (void (*)(void *))qtypepureid$dest);
17074- _IGNORE_(_36);
17060+ const struct StreamOut *_36 = &(*streams).out;
17061+ Indent$(0 /* _35 */, &*_36, &*level);
1707517062 }
1707617063 {
1707717064 const struct StreamOut *_37 = &(*streams).out;
17078- Indent$(0 /* _36 */, &*_37, &*level);
17065+ struct string _38; memset(&_38, 0, sizeof(struct string));
17066+ init$fromliteral(&_38, "{", 1);
17067+ PutStrLn(0 /* _36 */, &*_37, &_38);
17068+ string$dest(&_38);
1707917069 }
1708017070 {
1708117071 const struct StreamOut *_38 = &(*streams).out;
17082- struct string _39; memset(&_39, 0, sizeof(struct string));
17083- init$fromliteral(&_39, "}", 1);
17084- PutStrLn(0 /* _37 */, &*_38, &_39);
17085- string$dest(&_39);
17072+ uint64_t _39; memset(&_39, 0, sizeof(uint64_t));
17073+ {
17074+ uint64_t _40; memset(&_40, 0, sizeof(uint64_t));
17075+ _40 = 1;
17076+ _39 = _40 + *level;
17077+ _IGNORE_(_40);
17078+ }
17079+ Indent$(0 /* _37 */, &*_38, &_39);
17080+ _IGNORE_(_39);
1708617081 }
1708717082 {
1708817083 const struct StreamOut *_39 = &(*streams).out;
17089- Indent$(0 /* _38 */, &*_39, &*level);
17084+ struct string _40; memset(&_40, 0, sizeof(struct string));
17085+ init$fromliteral(&_40, "const uint8_t ", 14);
17086+ PutStr(0 /* _38 */, &*_39, &_40);
17087+ string$dest(&_40);
1709017088 }
1709117089 {
1709217090 const struct StreamOut *_40 = &(*streams).out;
17093- struct string _41; memset(&_41, 0, sizeof(struct string));
17094- init$fromliteral(&_41, "while(", 6);
17095- PutStr(0 /* _39 */, &*_40, &_41);
17096- string$dest(&_41);
17091+ PutStr(0 /* _39 */, &*_40, &_elem_id);
1709717092 }
1709817093 {
1709917094 const struct StreamOut *_41 = &(*streams).out;
17100- PutStr(0 /* _40 */, &*_41, &_elem_id);
17095+ struct string _42; memset(&_42, 0, sizeof(struct string));
17096+ init$fromliteral(&_42, " = (uint8_t)", 12);
17097+ PutStr(0 /* _40 */, &*_41, &_42);
17098+ string$dest(&_42);
1710117099 }
1710217100 {
1710317101 const struct StreamOut *_42 = &(*streams).out;
17104- struct string _43; memset(&_43, 0, sizeof(struct string));
17105- init$fromliteral(&_43, ");", 2);
17106- PutStrLn(0 /* _41 */, &*_42, &_43);
17107- string$dest(&_43);
17102+ PutStr(0 /* _41 */, &*_42, &_tmpid);
1710817103 }
1710917104 {
17110- uint8_t _43; memset(&_43, 0, sizeof(uint8_t));
17111- _43 = 125;
17112- AssertGet$(0 /* _42 */, &*streams, &*txtpos, &*level, &_43);
17113- _IGNORE_(_43);
17105+ const struct StreamOut *_43 = &(*streams).out;
17106+ struct string _44; memset(&_44, 0, sizeof(struct string));
17107+ init$fromliteral(&_44, ";", 1);
17108+ PutStrLn(0 /* _42 */, &*_43, &_44);
17109+ string$dest(&_44);
1711417110 }
17111+ {
17112+ uint64_t _44; memset(&_44, 0, sizeof(uint64_t));
17113+ {
17114+ uint64_t _45; memset(&_45, 0, sizeof(uint64_t));
17115+ _45 = 1;
17116+ _44 = _45 + *level;
17117+ _IGNORE_(_45);
17118+ }
17119+ struct stack/*qtypepureid*/ _45; memset(&_45, 0, sizeof(struct stack/*qtypepureid*/));
17120+ {
17121+ empty(&_45, sizeof(struct qtypepureid), (void (*)(void *))qtypepureid$dest, (void (*)(void *, const void *))qtypepureid$copy, 3852);
17122+ }
17123+ ParseBlockRaw$(0 /* _43 */, &*streams, &*txtpos, &*state, &_44, &*scope, &*tmpnr, &_45, &*partial, &*action, &*self);
17124+ free$(&_45, sizeof(struct qtypepureid), (void (*)(void *))qtypepureid$dest);
17125+ _IGNORE_(_44);
17126+ }
17127+ {
17128+ const struct StreamOut *_45 = &(*streams).out;
17129+ Indent$(0 /* _44 */, &*_45, &*level);
17130+ }
17131+ {
17132+ const struct StreamOut *_46 = &(*streams).out;
17133+ struct string _47; memset(&_47, 0, sizeof(struct string));
17134+ init$fromliteral(&_47, "}", 1);
17135+ PutStrLn(0 /* _45 */, &*_46, &_47);
17136+ string$dest(&_47);
17137+ }
17138+ {
17139+ uint8_t _47; memset(&_47, 0, sizeof(uint8_t));
17140+ _47 = 125;
17141+ AssertGet$(0 /* _46 */, &*streams, &*txtpos, &*level, &_47);
17142+ _IGNORE_(_47);
17143+ }
17144+ string$dest(&_tmpid);
1711517145 qtypepureid$dest(&_mut_elem);
17146+ free$(&_path2, sizeof(struct string), (void (*)(void *))string$dest);
1711617147 type_pure$dest(&_type);
1711717148 free$(&_path, sizeof(struct string), (void (*)(void *))string$dest);
1711817149 var$dest(&_provide);
@@ -17161,7 +17192,7 @@
1716117192 varinit(&_12, &_13);
1716217193 qtypepureid$dest(&_13);
1716317194 }
17164- push(0 /* _11 */, &*scope, &_12, sizeof(struct var), (void (*)(void *))var$dest, (void (*)(void *, const void *))var$copy, 3855);
17195+ push(0 /* _11 */, &*scope, &_12, sizeof(struct var), (void (*)(void *))var$dest, (void (*)(void *, const void *))var$copy, 3863);
1716517196 var$dest(&_12);
1716617197 }
1716717198 }
@@ -17183,7 +17214,7 @@
1718317214 {
1718417215 struct stack/*qtypepureid*/ _15; memset(&_15, 0, sizeof(struct stack/*qtypepureid*/));
1718517216 {
17186- solid(&_15, &_mut_elem, sizeof(struct qtypepureid), (void (*)(void *))qtypepureid$dest, (void (*)(void *, const void *))qtypepureid$copy, 3858);
17217+ solid(&_15, &_mut_elem, sizeof(struct qtypepureid), (void (*)(void *))qtypepureid$dest, (void (*)(void *, const void *))qtypepureid$copy, 3866);
1718717218 }
1718817219 struct string _16; memset(&_16, 0, sizeof(struct string));
1718917220 {
@@ -17219,7 +17250,7 @@
1721917250 {
1722017251 struct stack/*qtypepureid*/ _20; memset(&_20, 0, sizeof(struct stack/*qtypepureid*/));
1722117252 {
17222- empty(&_20, sizeof(struct qtypepureid), (void (*)(void *))qtypepureid$dest, (void (*)(void *, const void *))qtypepureid$copy, 3860);
17253+ empty(&_20, sizeof(struct qtypepureid), (void (*)(void *))qtypepureid$dest, (void (*)(void *, const void *))qtypepureid$copy, 3868);
1722317254 }
1722417255 ParseBlock$(0 /* _19 */, &*streams, &*txtpos, &*state, &*level, &*scope, &*tmpnr, &_20, &*partial, &*action, &*self);
1722517256 free$(&_20, sizeof(struct qtypepureid), (void (*)(void *))qtypepureid$dest);
@@ -17255,7 +17286,7 @@
1725517286 {
1725617287 struct stack/*qtypepureid*/ _10; memset(&_10, 0, sizeof(struct stack/*qtypepureid*/));
1725717288 {
17258- solid(&_10, &_mut_container, sizeof(struct qtypepureid), (void (*)(void *))qtypepureid$dest, (void (*)(void *, const void *))qtypepureid$copy, 3867);
17289+ solid(&_10, &_mut_container, sizeof(struct qtypepureid), (void (*)(void *))qtypepureid$dest, (void (*)(void *, const void *))qtypepureid$copy, 3875);
1725917290 }
1726017291 struct string _11; memset(&_11, 0, sizeof(struct string));
1726117292 {
@@ -17410,7 +17441,7 @@
1741017441 varinit(&_31, &_32);
1741117442 qtypepureid$dest(&_32);
1741217443 }
17413- push(0 /* _30 */, &*scope, &_31, sizeof(struct var), (void (*)(void *))var$dest, (void (*)(void *, const void *))var$copy, 3883);
17444+ push(0 /* _30 */, &*scope, &_31, sizeof(struct var), (void (*)(void *))var$dest, (void (*)(void *, const void *))var$copy, 3891);
1741417445 var$dest(&_31);
1741517446 }
1741617447 {
@@ -17568,7 +17599,7 @@
1756817599 }
1756917600 struct stack/*qtypepureid*/ _47; memset(&_47, 0, sizeof(struct stack/*qtypepureid*/));
1757017601 {
17571- empty(&_47, sizeof(struct qtypepureid), (void (*)(void *))qtypepureid$dest, (void (*)(void *, const void *))qtypepureid$copy, 3904);
17602+ empty(&_47, sizeof(struct qtypepureid), (void (*)(void *))qtypepureid$dest, (void (*)(void *, const void *))qtypepureid$copy, 3912);
1757217603 }
1757317604 ParseBlockRaw$(0 /* _45 */, &*streams, &*txtpos, &*state, &_46, &*scope, &*tmpnr, &_47, &*partial, &*action, &*self);
1757417605 free$(&_47, sizeof(struct qtypepureid), (void (*)(void *))qtypepureid$dest);
@@ -17616,7 +17647,7 @@
1761617647 }
1761717648 struct stack/*qtypepureid*/ _31; memset(&_31, 0, sizeof(struct stack/*qtypepureid*/));
1761817649 {
17619- empty(&_31, sizeof(struct qtypepureid), (void (*)(void *))qtypepureid$dest, (void (*)(void *, const void *))qtypepureid$copy, 3910);
17650+ empty(&_31, sizeof(struct qtypepureid), (void (*)(void *))qtypepureid$dest, (void (*)(void *, const void *))qtypepureid$copy, 3918);
1762017651 }
1762117652 ParseBlockRaw$(0 /* _29 */, &*streams, &*txtpos, &*state, &_30, &*scope, &*tmpnr, &_31, &*partial, &*action, &*self);
1762217653 free$(&_31, sizeof(struct qtypepureid), (void (*)(void *))qtypepureid$dest);
@@ -17769,7 +17800,7 @@
1776917800 {
1777017801 struct stack/*qtypepureid*/ _6; memset(&_6, 0, sizeof(struct stack/*qtypepureid*/));
1777117802 {
17772- empty(&_6, sizeof(struct qtypepureid), (void (*)(void *))qtypepureid$dest, (void (*)(void *, const void *))qtypepureid$copy, 3944);
17803+ empty(&_6, sizeof(struct qtypepureid), (void (*)(void *))qtypepureid$dest, (void (*)(void *, const void *))qtypepureid$copy, 3952);
1777317804 }
1777417805 bool _7; memset(&_7, 0, sizeof(bool));
1777517806 _7 = 0;
@@ -18463,7 +18494,7 @@
1846318494 {
1846418495 struct typepureid _cur; memset(&_cur, 0, sizeof(struct typepureid));
1846518496 {
18466- at_get$(&_cur, &*elems, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4150);
18497+ at_get$(&_cur, &*elems, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4158);
1846718498 }
1846818499 {
1846918500 uint64_t _4; memset(&_4, 0, sizeof(uint64_t));
@@ -18727,7 +18758,7 @@
1872718758 }
1872818759 struct typepureid _cur; memset(&_cur, 0, sizeof(struct typepureid));
1872918760 {
18730- at_get$(&_cur, &*elems, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4201);
18761+ at_get$(&_cur, &*elems, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4209);
1873118762 }
1873218763 {
1873318764 uint64_t _6; memset(&_6, 0, sizeof(uint64_t));
@@ -18963,7 +18994,7 @@
1896318994 _IGNORE_(_4);
1896418995 }
1896518996 {
18966- push(0 /* _4 */, &*elems, &_ti, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4246);
18997+ push(0 /* _4 */, &*elems, &_ti, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4254);
1896718998 }
1896818999 {
1896919000 uint64_t _6; memset(&_6, 0, sizeof(uint64_t));
@@ -18998,7 +19029,7 @@
1899819029 {
1899919030 struct typepureid _cur; memset(&_cur, 0, sizeof(struct typepureid));
1900019031 {
19001- at_get$(&_cur, &*elems, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4258);
19032+ at_get$(&_cur, &*elems, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4266);
1900219033 }
1900319034 {
1900419035 uint64_t _4; memset(&_4, 0, sizeof(uint64_t));
@@ -19166,7 +19197,7 @@
1916619197 {
1916719198 struct typepureid _cur; memset(&_cur, 0, sizeof(struct typepureid));
1916819199 {
19169- at_get$(&_cur, &*elems, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4285);
19200+ at_get$(&_cur, &*elems, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4293);
1917019201 }
1917119202 {
1917219203 uint64_t _4; memset(&_4, 0, sizeof(uint64_t));
@@ -19314,7 +19345,7 @@
1931419345 {
1931519346 struct typepureid _cur; memset(&_cur, 0, sizeof(struct typepureid));
1931619347 {
19317- at_get$(&_cur, &*elems, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4311);
19348+ at_get$(&_cur, &*elems, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4319);
1931819349 }
1931919350 {
1932019351 uint64_t _4; memset(&_4, 0, sizeof(uint64_t));
@@ -19494,7 +19525,7 @@
1949419525 {
1949519526 struct typepureid _cur; memset(&_cur, 0, sizeof(struct typepureid));
1949619527 {
19497- at_get$(&_cur, &*elems, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4336);
19528+ at_get$(&_cur, &*elems, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4344);
1949819529 }
1949919530 {
1950019531 struct qtype _4; memset(&_4, 0, sizeof(struct qtype));
@@ -19712,11 +19743,11 @@
1971219743 {
1971319744 struct constr _c; memset(&_c, 0, sizeof(struct constr));
1971419745 {
19715- at_get$(&_c, &*constrs, &*idx, sizeof(struct constr), (void (*)(void *))constr$dest, (void (*)(void *, const void *))constr$copy, 4374);
19746+ at_get$(&_c, &*constrs, &*idx, sizeof(struct constr), (void (*)(void *))constr$dest, (void (*)(void *, const void *))constr$copy, 4382);
1971619747 }
1971719748 {
1971819749 const struct typepureid *_4 = &(_c).ti;
19719- push(0 /* _3 */, &*extracted, &*_4, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4375);
19750+ push(0 /* _3 */, &*extracted, &*_4, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4383);
1972019751 }
1972119752 {
1972219753 uint64_t _5; memset(&_5, 0, sizeof(uint64_t));
@@ -19777,11 +19808,11 @@
1977719808 struct typepureid _elem; memset(&_elem, 0, sizeof(struct typepureid));
1977819809 {
1977919810 const struct stack/*typepureid*/ *_4 = &(_sd).elems;
19780- at_get$(&_elem, &*_4, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4387);
19811+ at_get$(&_elem, &*_4, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4395);
1978119812 }
1978219813 struct constr _constr; memset(&_constr, 0, sizeof(struct constr));
1978319814 {
19784- at_get$(&_constr, &*constrs, &*idx, sizeof(struct constr), (void (*)(void *))constr$dest, (void (*)(void *, const void *))constr$copy, 4389);
19815+ at_get$(&_constr, &*constrs, &*idx, sizeof(struct constr), (void (*)(void *))constr$dest, (void (*)(void *, const void *))constr$copy, 4397);
1978519816 }
1978619817 bool _5;
1978719818 {
@@ -19998,7 +20029,7 @@
1999820029 }
1999920030 struct typepureid _cur; memset(&_cur, 0, sizeof(struct typepureid));
2000020031 {
20001- at_get$(&_cur, &*elems, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4415);
20032+ at_get$(&_cur, &*elems, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4423);
2000220033 }
2000320034 bool _10;
2000420035 {
@@ -20501,11 +20532,11 @@
2050120532 struct typepureid _elem; memset(&_elem, 0, sizeof(struct typepureid));
2050220533 {
2050320534 const struct stack/*typepureid*/ *_4 = &(_sd).elems;
20504- at_get$(&_elem, &*_4, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4490);
20535+ at_get$(&_elem, &*_4, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4498);
2050520536 }
2050620537 struct constr _constr; memset(&_constr, 0, sizeof(struct constr));
2050720538 {
20508- at_get$(&_constr, &*constrs, &*idx, sizeof(struct constr), (void (*)(void *))constr$dest, (void (*)(void *, const void *))constr$copy, 4492);
20539+ at_get$(&_constr, &*constrs, &*idx, sizeof(struct constr), (void (*)(void *))constr$dest, (void (*)(void *, const void *))constr$copy, 4500);
2050920540 }
2051020541 bool _5;
2051120542 {
@@ -20711,7 +20742,7 @@
2071120742 }
2071220743 struct typepureid _cur; memset(&_cur, 0, sizeof(struct typepureid));
2071320744 {
20714- at_get$(&_cur, &*elems, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4518);
20745+ at_get$(&_cur, &*elems, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4526);
2071520746 }
2071620747 bool _10;
2071720748 {
@@ -21067,7 +21098,7 @@
2106721098 {
2106821099 struct typepureid _cur; memset(&_cur, 0, sizeof(struct typepureid));
2106921100 {
21070- at_get$(&_cur, &*elems, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4579);
21101+ at_get$(&_cur, &*elems, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4587);
2107121102 }
2107221103 {
2107321104 uint64_t _4; memset(&_4, 0, sizeof(uint64_t));
@@ -21435,7 +21466,7 @@
2143521466 {
2143621467 struct typepureid _ti; memset(&_ti, 0, sizeof(struct typepureid));
2143721468 {
21438- at_get$(&_ti, &*elems, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4618);
21469+ at_get$(&_ti, &*elems, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4626);
2143921470 }
2144021471 {
2144121472 uint64_t _4; memset(&_4, 0, sizeof(uint64_t));
@@ -21700,7 +21731,7 @@
2170021731 struct typepureid _elem; memset(&_elem, 0, sizeof(struct typepureid));
2170121732 {
2170221733 const struct stack/*typepureid*/ *_3 = &(*sd).elems;
21703- at_get$(&_elem, &*_3, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4654);
21734+ at_get$(&_elem, &*_3, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4662);
2170421735 }
2170521736 {
2170621737 struct string _4; memset(&_4, 0, sizeof(struct string));
@@ -22029,11 +22060,11 @@
2202922060 {
2203022061 struct qtype _qt0; memset(&_qt0, 0, sizeof(struct qtype));
2203122062 {
22032- at_get$(&_qt0, &*decl, &*idx, sizeof(struct qtype), (void (*)(void *))qtype$dest, (void (*)(void *, const void *))qtype$copy, 4695);
22063+ at_get$(&_qt0, &*decl, &*idx, sizeof(struct qtype), (void (*)(void *))qtype$dest, (void (*)(void *, const void *))qtype$copy, 4703);
2203322064 }
2203422065 struct qtype _qt1; memset(&_qt1, 0, sizeof(struct qtype));
2203522066 {
22036- at_get$(&_qt1, &*def, &*idx, sizeof(struct qtype), (void (*)(void *))qtype$dest, (void (*)(void *, const void *))qtype$copy, 4696);
22067+ at_get$(&_qt1, &*def, &*idx, sizeof(struct qtype), (void (*)(void *))qtype$dest, (void (*)(void *, const void *))qtype$copy, 4704);
2203722068 }
2203822069 bool _4;
2203922070 {
@@ -22161,7 +22192,7 @@
2216122192 {
2216222193 struct typeid _elem; memset(&_elem, 0, sizeof(struct typeid));
2216322194 {
22164- at_get$(&_elem, &*elems, &*idx, sizeof(struct typeid), (void (*)(void *))typeid$dest, (void (*)(void *, const void *))typeid$copy, 4725);
22195+ at_get$(&_elem, &*elems, &*idx, sizeof(struct typeid), (void (*)(void *))typeid$dest, (void (*)(void *, const void *))typeid$copy, 4733);
2216522196 }
2216622197 {
2216722198 Indent$(0 /* _3 */, &*out, &*level);
@@ -22239,7 +22270,7 @@
2223922270 {
2224022271 struct typepureid _elem; memset(&_elem, 0, sizeof(struct typepureid));
2224122272 {
22242- at_get$(&_elem, &*elems, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4747);
22273+ at_get$(&_elem, &*elems, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4755);
2224322274 }
2224422275 {
2224522276 Indent$(0 /* _3 */, &*out, &*level);
@@ -22397,7 +22428,7 @@
2239722428 }
2239822429 {
2239922430 struct stack/*structdef*/ *_3 = &(*state).structs;
22400- push(0 /* _2 */, &*_3, &_strdef, sizeof(struct structdef), (void (*)(void *))structdef$dest, (void (*)(void *, const void *))structdef$copy, 4784);
22431+ push(0 /* _2 */, &*_3, &_strdef, sizeof(struct structdef), (void (*)(void *))structdef$dest, (void (*)(void *, const void *))structdef$copy, 4792);
2240122432 }
2240222433 {
2240322434 struct stack/*structdef*/ *_4 = &(*state).structs;
@@ -22740,7 +22771,7 @@
2274022771 {
2274122772 struct typeid _cur; memset(&_cur, 0, sizeof(struct typeid));
2274222773 {
22743- at_get$(&_cur, &*elems, &*idx, sizeof(struct typeid), (void (*)(void *))typeid$dest, (void (*)(void *, const void *))typeid$copy, 4847);
22774+ at_get$(&_cur, &*elems, &*idx, sizeof(struct typeid), (void (*)(void *))typeid$dest, (void (*)(void *, const void *))typeid$copy, 4855);
2274422775 }
2274522776 {
2274622777 struct string _4; memset(&_4, 0, sizeof(struct string));
@@ -22803,7 +22834,7 @@
2280322834 // mark internal structs used
2280422835 {
2280522836 struct stack/*structdef*/ *_2 = &(*state).structs;
22806- push(0 /* _1 */, &*_2, &_strdef, sizeof(struct structdef), (void (*)(void *))structdef$dest, (void (*)(void *, const void *))structdef$copy, 4859);
22837+ push(0 /* _1 */, &*_2, &_strdef, sizeof(struct structdef), (void (*)(void *))structdef$dest, (void (*)(void *, const void *))structdef$copy, 4867);
2280722838 }
2280822839 {
2280922840 struct stack/*structdef*/ *_3 = &(*state).structs;
@@ -22880,7 +22911,7 @@
2288022911 {
2288122912 struct typepureid _elem; memset(&_elem, 0, sizeof(struct typepureid));
2288222913 {
22883- at_get$(&_elem, &*elems, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4871);
22914+ at_get$(&_elem, &*elems, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4879);
2288422915 }
2288522916 bool _2; memset(&_2, 0, sizeof(bool));
2288622917 bool _3;
@@ -23090,7 +23121,7 @@
2309023121 }
2309123122 {
2309223123 struct stack/*structdef*/ *_3 = &(*state).structs;
23093- push(0 /* _2 */, &*_3, &_strdef, sizeof(struct structdef), (void (*)(void *))structdef$dest, (void (*)(void *, const void *))structdef$copy, 4904);
23124+ push(0 /* _2 */, &*_3, &_strdef, sizeof(struct structdef), (void (*)(void *))structdef$dest, (void (*)(void *, const void *))structdef$copy, 4912);
2309423125 }
2309523126 {
2309623127 struct stack/*structdef*/ *_4 = &(*state).structs;
@@ -23161,7 +23192,7 @@
2316123192 {
2316223193 struct typepureid _cur; memset(&_cur, 0, sizeof(struct typepureid));
2316323194 {
23164- at_get$(&_cur, &*elems, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4918);
23195+ at_get$(&_cur, &*elems, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4926);
2316523196 }
2316623197 {
2316723198 uint64_t _4; memset(&_4, 0, sizeof(uint64_t));
@@ -23341,7 +23372,7 @@
2334123372 {
2334223373 struct typepureid _cur; memset(&_cur, 0, sizeof(struct typepureid));
2334323374 {
23344- at_get$(&_cur, &*elems, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4943);
23375+ at_get$(&_cur, &*elems, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4951);
2334523376 }
2334623377 {
2334723378 struct qtype _4; memset(&_4, 0, sizeof(struct qtype));
@@ -23409,7 +23440,7 @@
2340923440 {
2341023441 struct constr _c; memset(&_c, 0, sizeof(struct constr));
2341123442 {
23412- at_get$(&_c, &*constrs, &*idx, sizeof(struct constr), (void (*)(void *))constr$dest, (void (*)(void *, const void *))constr$copy, 4957);
23443+ at_get$(&_c, &*constrs, &*idx, sizeof(struct constr), (void (*)(void *))constr$dest, (void (*)(void *, const void *))constr$copy, 4965);
2341323444 }
2341423445 bool _4;
2341523446 {
@@ -23492,11 +23523,11 @@
2349223523 struct typepureid _elem; memset(&_elem, 0, sizeof(struct typepureid));
2349323524 {
2349423525 const struct stack/*typepureid*/ *_4 = &(_sd).elems;
23495- at_get$(&_elem, &*_4, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4974);
23526+ at_get$(&_elem, &*_4, &*idx, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 4982);
2349623527 }
2349723528 struct constr _constr; memset(&_constr, 0, sizeof(struct constr));
2349823529 {
23499- at_get$(&_constr, &*constrs, &*idx, sizeof(struct constr), (void (*)(void *))constr$dest, (void (*)(void *, const void *))constr$copy, 4976);
23530+ at_get$(&_constr, &*constrs, &*idx, sizeof(struct constr), (void (*)(void *))constr$dest, (void (*)(void *, const void *))constr$copy, 4984);
2350023531 }
2350123532 struct stack/*qtype*/ _parts; memset(&_parts, 0, sizeof(struct stack/*qtype*/));
2350223533 {
@@ -23927,7 +23958,7 @@
2392723958 }
2392823959 {
2392923960 struct stack/*structdef*/ *_5 = &(*state).structs;
23930- push(0 /* _4 */, &*_5, &_strdef, sizeof(struct structdef), (void (*)(void *))structdef$dest, (void (*)(void *, const void *))structdef$copy, 5020);
23961+ push(0 /* _4 */, &*_5, &_strdef, sizeof(struct structdef), (void (*)(void *))structdef$dest, (void (*)(void *, const void *))structdef$copy, 5028);
2393123962 }
2393223963 {
2393323964 struct stack/*structdef*/ *_6 = &(*state).structs;
@@ -24131,7 +24162,7 @@
2413124162 _IGNORE_(_4);
2413224163 }
2413324164 {
24134- push(0 /* _4 */, &*elems, &_ti, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 5063);
24165+ push(0 /* _4 */, &*elems, &_ti, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 5071);
2413524166 }
2413624167 {
2413724168 uint64_t _6; memset(&_6, 0, sizeof(uint64_t));
@@ -24341,7 +24372,7 @@
2434124372 }
2434224373 }
2434324374 {
24344- push(0 /* _9 */, &*constrs, &_c, sizeof(struct constr), (void (*)(void *))constr$dest, (void (*)(void *, const void *))constr$copy, 5113);
24375+ push(0 /* _9 */, &*constrs, &_c, sizeof(struct constr), (void (*)(void *))constr$dest, (void (*)(void *, const void *))constr$copy, 5121);
2434524376 }
2434624377 bool _11;
2434724378 {
@@ -24370,7 +24401,7 @@
2437024401 {
2437124402 struct stack/*constr*/ _1; memset(&_1, 0, sizeof(struct stack/*constr*/));
2437224403 {
24373- pop_opt(&_1, &*constrs, sizeof(struct constr), (void (*)(void *))constr$dest, (void (*)(void *, const void *))constr$copy, 5123);
24404+ pop_opt(&_1, &*constrs, sizeof(struct constr), (void (*)(void *))constr$dest, (void (*)(void *, const void *))constr$copy, 5131);
2437424405 }
2437524406 if(!(_1).size)
2437624407 {
@@ -25186,7 +25217,7 @@
2518625217 struct def _cur; memset(&_cur, 0, sizeof(struct def));
2518725218 {
2518825219 struct stack/*def*/ *_19 = &(*state).defs;
25189- at_get$(&_cur, &*_19, &*fnidx, sizeof(struct def), (void (*)(void *))def$dest, (void (*)(void *, const void *))def$copy, 5311);
25220+ at_get$(&_cur, &*_19, &*fnidx, sizeof(struct def), (void (*)(void *))def$dest, (void (*)(void *, const void *))def$copy, 5319);
2519025221 }
2519125222 bool _20;
2519225223 {
@@ -25366,7 +25397,7 @@
2536625397 struct def _cur; memset(&_cur, 0, sizeof(struct def));
2536725398 {
2536825399 struct stack/*def*/ *_20 = &(*state).defs;
25369- at_get$(&_cur, &*_20, &*fnidx, sizeof(struct def), (void (*)(void *))def$dest, (void (*)(void *, const void *))def$copy, 5344);
25400+ at_get$(&_cur, &*_20, &*fnidx, sizeof(struct def), (void (*)(void *))def$dest, (void (*)(void *, const void *))def$copy, 5352);
2537025401 }
2537125402 {
2537225403 const struct StreamOut *_21 = &(*streams).err;
@@ -25597,7 +25628,7 @@
2559725628 varinit(&_37, &_38);
2559825629 qtypepureid$dest(&_38);
2559925630 }
25600- push(0 /* _36 */, &_scope, &_37, sizeof(struct var), (void (*)(void *))var$dest, (void (*)(void *, const void *))var$copy, 5377);
25631+ push(0 /* _36 */, &_scope, &_37, sizeof(struct var), (void (*)(void *))var$dest, (void (*)(void *, const void *))var$copy, 5385);
2560125632 var$dest(&_37);
2560225633 }
2560325634 {
@@ -25703,7 +25734,7 @@
2570325734 qtypepureid(&_30, &_31, &*_32);
2570425735 qtypepure$dest(&_31);
2570525736 }
25706- solid(&_29, &_30, sizeof(struct qtypepureid), (void (*)(void *))qtypepureid$dest, (void (*)(void *, const void *))qtypepureid$copy, 5392);
25737+ solid(&_29, &_30, sizeof(struct qtypepureid), (void (*)(void *))qtypepureid$dest, (void (*)(void *, const void *))qtypepureid$copy, 5400);
2570725738 qtypepureid$dest(&_30);
2570825739 }
2570925740 const struct string *_30 = &(_ti).id;
@@ -25871,7 +25902,7 @@
2587125902 {
2587225903 struct stack/*def*/ _1; memset(&_1, 0, sizeof(struct stack/*def*/));
2587325904 {
25874- pop_opt(&_1, &*defs, sizeof(struct def), (void (*)(void *))def$dest, (void (*)(void *, const void *))def$copy, 5429);
25905+ pop_opt(&_1, &*defs, sizeof(struct def), (void (*)(void *))def$dest, (void (*)(void *, const void *))def$copy, 5437);
2587525906 }
2587625907 if(!(_1).size)
2587725908 {
@@ -25918,7 +25949,7 @@
2591825949 {
2591925950 struct stack/*structdef*/ _1; memset(&_1, 0, sizeof(struct stack/*structdef*/));
2592025951 {
25921- pop_opt(&_1, &*structs, sizeof(struct structdef), (void (*)(void *))structdef$dest, (void (*)(void *, const void *))structdef$copy, 5445);
25952+ pop_opt(&_1, &*structs, sizeof(struct structdef), (void (*)(void *))structdef$dest, (void (*)(void *, const void *))structdef$copy, 5453);
2592225953 }
2592325954 if(!(_1).size)
2592425955 {
@@ -25979,11 +26010,11 @@
2597926010 {
2598026011 struct stack/*def*/ _1; memset(&_1, 0, sizeof(struct stack/*def*/));
2598126012 {
25982- stack(&_1, sizeof(struct def), (void (*)(void *))def$dest, (void (*)(void *, const void *))def$copy, 5467);
26013+ stack(&_1, sizeof(struct def), (void (*)(void *))def$dest, (void (*)(void *, const void *))def$copy, 5475);
2598326014 }
2598426015 struct stack/*structdef*/ _2; memset(&_2, 0, sizeof(struct stack/*structdef*/));
2598526016 {
25986- stack(&_2, sizeof(struct structdef), (void (*)(void *))structdef$dest, (void (*)(void *, const void *))structdef$copy, 5467);
26017+ stack(&_2, sizeof(struct structdef), (void (*)(void *))structdef$dest, (void (*)(void *, const void *))structdef$copy, 5475);
2598726018 }
2598826019 state(&_state, &_1, &_2);
2598926020 free$(&_2, sizeof(struct structdef), (void (*)(void *))structdef$dest);
@@ -26428,7 +26459,7 @@
2642826459 string$dest(&_5);
2642926460 type_pure$dest(&_4);
2643026461 }
26431- push(0 /* _2 */, &_elems, &_3, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 5882);
26462+ push(0 /* _2 */, &_elems, &_3, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 5890);
2643226463 typepureid$dest(&_3);
2643326464 }
2643426465 {
@@ -26468,13 +26499,13 @@
2646826499 }
2646926500 struct stack/*typepureid*/ _6; memset(&_6, 0, sizeof(struct stack/*typepureid*/));
2647026501 {
26471- stack(&_6, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 5889);
26502+ stack(&_6, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 5897);
2647226503 }
2647326504 constr(&_4, &_5, &_6);
2647426505 free$(&_6, sizeof(struct typepureid), (void (*)(void *))typepureid$dest);
2647526506 typepureid$dest(&_5);
2647626507 }
26477- push(0 /* _3 */, &_constrs, &_4, sizeof(struct constr), (void (*)(void *))constr$dest, (void (*)(void *, const void *))constr$copy, 5889);
26508+ push(0 /* _3 */, &_constrs, &_4, sizeof(struct constr), (void (*)(void *))constr$dest, (void (*)(void *, const void *))constr$copy, 5897);
2647826509 constr$dest(&_4);
2647926510 }
2648026511 {
@@ -26497,13 +26528,13 @@
2649726528 }
2649826529 struct stack/*typepureid*/ _7; memset(&_7, 0, sizeof(struct stack/*typepureid*/));
2649926530 {
26500- stack(&_7, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 5890);
26531+ stack(&_7, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 5898);
2650126532 }
2650226533 constr(&_5, &_6, &_7);
2650326534 free$(&_7, sizeof(struct typepureid), (void (*)(void *))typepureid$dest);
2650426535 typepureid$dest(&_6);
2650526536 }
26506- push(0 /* _4 */, &_constrs, &_5, sizeof(struct constr), (void (*)(void *))constr$dest, (void (*)(void *, const void *))constr$copy, 5890);
26537+ push(0 /* _4 */, &_constrs, &_5, sizeof(struct constr), (void (*)(void *))constr$dest, (void (*)(void *, const void *))constr$copy, 5898);
2650726538 constr$dest(&_5);
2650826539 }
2650926540 {
@@ -26526,13 +26557,13 @@
2652626557 }
2652726558 struct stack/*typepureid*/ _8; memset(&_8, 0, sizeof(struct stack/*typepureid*/));
2652826559 {
26529- stack(&_8, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 5891);
26560+ stack(&_8, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 5899);
2653026561 }
2653126562 constr(&_6, &_7, &_8);
2653226563 free$(&_8, sizeof(struct typepureid), (void (*)(void *))typepureid$dest);
2653326564 typepureid$dest(&_7);
2653426565 }
26535- push(0 /* _5 */, &_constrs, &_6, sizeof(struct constr), (void (*)(void *))constr$dest, (void (*)(void *, const void *))constr$copy, 5891);
26566+ push(0 /* _5 */, &_constrs, &_6, sizeof(struct constr), (void (*)(void *))constr$dest, (void (*)(void *, const void *))constr$copy, 5899);
2653626567 constr$dest(&_6);
2653726568 }
2653826569 {
@@ -29827,7 +29858,7 @@
2982729858 string$dest(&_53);
2982829859 type_pure$dest(&_52);
2982929860 }
29830- push(0 /* _50 */, &_elems, &_51, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 6518);
29861+ push(0 /* _50 */, &_elems, &_51, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 6526);
2983129862 typepureid$dest(&_51);
2983229863 }
2983329864 {
@@ -29846,7 +29877,7 @@
2984629877 string$dest(&_54);
2984729878 type_pure$dest(&_53);
2984829879 }
29849- push(0 /* _51 */, &_elems, &_52, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 6519);
29880+ push(0 /* _51 */, &_elems, &_52, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 6527);
2985029881 typepureid$dest(&_52);
2985129882 }
2985229883 {
@@ -29865,7 +29896,7 @@
2986529896 string$dest(&_55);
2986629897 type_pure$dest(&_54);
2986729898 }
29868- push(0 /* _52 */, &_elems, &_53, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 6520);
29899+ push(0 /* _52 */, &_elems, &_53, sizeof(struct typepureid), (void (*)(void *))typepureid$dest, (void (*)(void *, const void *))typepureid$copy, 6528);
2986929900 typepureid$dest(&_53);
2987029901 }
2987129902 {
@@ -29895,7 +29926,7 @@
2989529926 typepureid$dest(&_57);
2989629927 flavour$dest(&_56);
2989729928 }
29898- push(0 /* _53 */, &*_54, &_55, sizeof(struct structdef), (void (*)(void *))structdef$dest, (void (*)(void *, const void *))structdef$copy, 6521);
29929+ push(0 /* _53 */, &*_54, &_55, sizeof(struct structdef), (void (*)(void *))structdef$dest, (void (*)(void *, const void *))structdef$copy, 6529);
2989929930 structdef$dest(&_55);
2990029931 }
2990129932 free$(&_elems, sizeof(struct typepureid), (void (*)(void *))typepureid$dest);
--- trunk/pragmatic/self_hosting_source.c (revision 34)
+++ trunk/pragmatic/self_hosting_source.c (revision 35)
@@ -3822,6 +3822,7 @@
38223822 EPrTypePurePrim(streams.err, tn.prim);
38233823 Fail$(streams.err, txtpos);
38243824 };
3825+ let mut stack<string> path2 = path; // PrintPath consumes path!
38253826
38263827 let qtypepureid mut_elem = qtypepureid(mutqtp(type_pure_normal2("u8")), elem_id);
38273828 if not(istmp$(elem_id)) then
@@ -3830,20 +3831,27 @@
38303831 };
38313832
38323833 AssertGet$(streams, txtpos, level, '{');
3833- Indent$(streams.out, level); PutStr(streams.out, "uint8_t ");
3834- PutStr(streams.out, elem_id); PutStrLn(streams.out, " = 0;");
3835- Indent$(streams.out, level); PutStr(streams.out, "do");
3836- Indent$(streams.out, level); PutStrLn(streams.out, "{");
3837- Indent$(streams.out, add<u64>(1, level)); PutStr(streams.out, "Get(&");
3838- PutStr(streams.out, elem_id);
3839- PutStr(streams.out, ", &((*");
3834+ let string tmpid = GenVar$(tmpnr);
3835+ Indent$(streams.out, level); PutStr(streams.out, "for(int ");
3836+ PutStr(streams.out, tmpid);
3837+ PutStr(streams.out, " = getc(((*");
38403838 PutStr(streams.out, var);
38413839 PutStr(streams.out, ")");
38423840 PrintPath$(streams.out, path);
3843- PutStrLn(streams.out, "));");
3841+ PutStr(streams.out, ").f); ");
3842+ PutStr(streams.out, tmpid); PutStr(streams.out, " >= 0; ");
3843+ PutStr(streams.out, tmpid);
3844+ PutStr(streams.out, " = getc(((*");
3845+ PutStr(streams.out, var);
3846+ PutStr(streams.out, ")");
3847+ PrintPath$(streams.out, path2);
3848+ PutStrLn(streams.out, ").f))");
3849+ Indent$(streams.out, level); PutStrLn(streams.out, "{");
3850+ Indent$(streams.out, add<u64>(1, level)); PutStr(streams.out, "const uint8_t ");
3851+ PutStr(streams.out, elem_id); PutStr(streams.out, " = (uint8_t)");
3852+ PutStr(streams.out, tmpid); PutStrLn(streams.out, ";");
38443853 ParseBlockRaw$(streams, txtpos, state, add<u64>(1, level), scope, tmpnr, empty<qtypepureid>(), partial, action, self);
38453854 Indent$(streams.out, level); PutStrLn(streams.out, "}");
3846- Indent$(streams.out, level); PutStr(streams.out, "while("); PutStr(streams.out, elem_id); PutStrLn(streams.out, ");");
38473855 AssertGet$(streams, txtpos, level, '}');
38483856 };
38493857 };
Show on old repository browser