Revision | 1164 (tree) |
---|---|
Time | 2021-02-23 22:47:07 |
Author | jakobthomsen |
allow memory-allocation only in explicitly marked environment
@@ -16073,8 +16073,9 @@ | ||
16073 | 16073 | // release element id |
16074 | 16074 | // release element recursive |
16075 | 16075 | // release element fallible |
16076 | + // release element canthrow | |
16076 | 16077 | // release variant container |
16077 | - Free(7, sizeof(uint64_t), ((uint64_t *)stack[base + 1]/*variant*/)); | |
16078 | + Free(8, sizeof(uint64_t), ((uint64_t *)stack[base + 1]/*variant*/)); | |
16078 | 16079 | label = stack[base - 1]; |
16079 | 16080 | base = stack[base - 2]; |
16080 | 16081 | break; |
@@ -16312,10 +16313,29 @@ | ||
16312 | 16313 | case 1303LLU: // deleter |
16313 | 16314 | { |
16314 | 16315 | // throw from mkfndummy |
16316 | + if(!stack[base + 8]) | |
16317 | + { | |
16318 | + fprintf(stderr, "in function mkfndummy: unrolling stack, skipping already deleted/unscoped variable u64 \n"); | |
16319 | + label = 1301LLU; // skip, variable already deleted/unscoped | |
16320 | + break; | |
16321 | + } | |
16322 | + fprintf(stderr, "in function mkfndummy: unrolling stack, variable u64 \n"); | |
16323 | + label = 1301LLU; // continue unrolling stack, delete next variable | |
16324 | + break; | |
16325 | + } | |
16326 | + case 1304LLU: // skipped deleter | |
16327 | + { | |
16328 | + stack[base + 8] = 0; | |
16329 | + label = 1306LLU; // skip deleter | |
16330 | + break; | |
16331 | + } | |
16332 | + case 1305LLU: // deleter | |
16333 | + { | |
16334 | + // throw from mkfndummy | |
16315 | 16335 | if(!stack[base + 0]) |
16316 | 16336 | { |
16317 | 16337 | fprintf(stderr, "in function mkfndummy: unrolling stack, skipping already deleted/unscoped variable fndef \n"); |
16318 | - label = 1301LLU; // skip, variable already deleted/unscoped | |
16338 | + label = 1303LLU; // skip, variable already deleted/unscoped | |
16319 | 16339 | break; |
16320 | 16340 | } |
16321 | 16341 | fprintf(stderr, "in function mkfndummy: unrolling stack, variable fndef \n"); |
@@ -16325,7 +16345,7 @@ | ||
16325 | 16345 | newstack[0] = (uint64_t)stack; // backup stack location |
16326 | 16346 | newstack[1] = 1234567890; |
16327 | 16347 | newstack[2] = base; |
16328 | - newstack[3] = 1305LLU; | |
16348 | + newstack[3] = 1307LLU; | |
16329 | 16349 | stack = newstack; |
16330 | 16350 | // set stack-base & callee-address |
16331 | 16351 | base = 4/*deloffset*/; |
@@ -16332,21 +16352,21 @@ | ||
16332 | 16352 | label = 1273LLU; // ~fndef |
16333 | 16353 | break; |
16334 | 16354 | } |
16335 | - case 1305LLU: // return from ~fndef to mkfndummy | |
16355 | + case 1307LLU: // return from ~fndef to mkfndummy | |
16336 | 16356 | { |
16337 | 16357 | stack = (uint64_t *)stack[0]; |
16338 | 16358 | // releasing toplevel container |
16339 | 16359 | Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4)); |
16340 | 16360 | |
16341 | - label = 1301LLU; // continue unrolling stack, delete next variable | |
16361 | + label = 1303LLU; // continue unrolling stack, delete next variable | |
16342 | 16362 | break; |
16343 | 16363 | } |
16344 | - case 1304LLU: // skipped deleter | |
16364 | + case 1306LLU: // skipped deleter | |
16345 | 16365 | { |
16346 | 16366 | // construct fndef.fndef |
16347 | - if(!(stack[base + 0] = construct(7))) | |
16367 | + if(!(stack[base + 0] = construct(8))) | |
16348 | 16368 | { |
16349 | - label = 1301LLU; // throw: begin to unroll stack | |
16369 | + label = 1303LLU; // throw: begin to unroll stack | |
16350 | 16370 | break; |
16351 | 16371 | } |
16352 | 16372 |
@@ -16359,12 +16379,13 @@ | ||
16359 | 16379 | (((uint64_t **)(stack[base + 0]))[1][4]) = stack[base + 5]/*id*/; |
16360 | 16380 | (((uint64_t **)(stack[base + 0]))[1][5]) = stack[base + 6]/*recursive*/; |
16361 | 16381 | (((uint64_t **)(stack[base + 0]))[1][6]) = stack[base + 7]/*fallible*/; |
16382 | + (((uint64_t **)(stack[base + 0]))[1][7]) = stack[base + 8]/*canthrow*/; | |
16362 | 16383 | // return from mkfndummy |
16363 | 16384 | label = stack[base - 1]; |
16364 | 16385 | base = stack[base - 2]; |
16365 | 16386 | break; |
16366 | 16387 | } |
16367 | - case 1307LLU: // function copyfndef failed | |
16388 | + case 1309LLU: // function copyfndef failed | |
16368 | 16389 | { |
16369 | 16390 | fprintf(stderr, "function copyfndef failed\n"); |
16370 | 16391 | label = stack[base - 3]; |
@@ -16371,13 +16392,13 @@ | ||
16371 | 16392 | base = stack[base - 2]; |
16372 | 16393 | break; |
16373 | 16394 | } |
16374 | - case 1306LLU: // copyfndef | |
16395 | + case 1308LLU: // copyfndef | |
16375 | 16396 | { |
16376 | 16397 | //#define res0 0 |
16377 | 16398 | //#define arg0 1 |
16378 | 16399 | if(/*fndef*/0 != ((uint64_t *)(stack[base + 1]/*original*/))[0]) |
16379 | 16400 | { |
16380 | - label = 1309LLU; // jump to alternative | |
16401 | + label = 1311LLU; // jump to alternative | |
16381 | 16402 | break; |
16382 | 16403 | } |
16383 | 16404 |
@@ -16388,60 +16409,61 @@ | ||
16388 | 16409 | /*oid*/stack[base + 6] = ((uint64_t **)(stack[base + 1]/*original*/))[1][4]/*id*/; |
16389 | 16410 | /*orecursive*/stack[base + 7] = ((uint64_t **)(stack[base + 1]/*original*/))[1][5]/*recursive*/; |
16390 | 16411 | /*ofallible*/stack[base + 8] = ((uint64_t **)(stack[base + 1]/*original*/))[1][6]/*fallible*/; |
16412 | + /*ocanthrow*/stack[base + 9] = ((uint64_t **)(stack[base + 1]/*original*/))[1][7]/*canthrow*/; | |
16391 | 16413 | |
16392 | 16414 | // case |
16393 | - label = 1311LLU; // skip deleter | |
16415 | + label = 1313LLU; // skip deleter | |
16394 | 16416 | break; |
16395 | 16417 | } |
16396 | - case 1310LLU: // deleter | |
16418 | + case 1312LLU: // deleter | |
16397 | 16419 | { |
16398 | 16420 | // throw from copyfndef |
16399 | - if(!stack[base + 9]) | |
16421 | + if(!stack[base + 10]) | |
16400 | 16422 | { |
16401 | 16423 | fprintf(stderr, "in function copyfndef: unrolling stack, skipping already deleted/unscoped variable u64 \n"); |
16402 | - label = 1307LLU; // skip, variable already deleted/unscoped | |
16424 | + label = 1309LLU; // skip, variable already deleted/unscoped | |
16403 | 16425 | break; |
16404 | 16426 | } |
16405 | 16427 | fprintf(stderr, "in function copyfndef: unrolling stack, variable u64 \n"); |
16406 | - label = 1307LLU; // continue unrolling stack, delete next variable | |
16428 | + label = 1309LLU; // continue unrolling stack, delete next variable | |
16407 | 16429 | break; |
16408 | 16430 | } |
16409 | - case 1311LLU: // skipped deleter | |
16431 | + case 1313LLU: // skipped deleter | |
16410 | 16432 | { |
16411 | - stack[base + 9] = stack[base + 2]/*olabel*/; | |
16412 | - label = 1313LLU; // skip deleter | |
16433 | + stack[base + 10] = stack[base + 2]/*olabel*/; | |
16434 | + label = 1315LLU; // skip deleter | |
16413 | 16435 | break; |
16414 | 16436 | } |
16415 | - case 1312LLU: // deleter | |
16437 | + case 1314LLU: // deleter | |
16416 | 16438 | { |
16417 | 16439 | // throw from copyfndef |
16418 | - if(!stack[base + 10]) | |
16440 | + if(!stack[base + 11]) | |
16419 | 16441 | { |
16420 | 16442 | fprintf(stderr, "in function copyfndef: unrolling stack, skipping already deleted/unscoped variable [result] \n"); |
16421 | - label = 1310LLU; // skip, variable already deleted/unscoped | |
16443 | + label = 1312LLU; // skip, variable already deleted/unscoped | |
16422 | 16444 | break; |
16423 | 16445 | } |
16424 | 16446 | fprintf(stderr, "in function copyfndef: unrolling stack, variable [result] \n"); |
16425 | 16447 | // delete list |
16426 | - label = 1314LLU; // start to repeat | |
16448 | + label = 1316LLU; // start to repeat | |
16427 | 16449 | break; |
16428 | 16450 | } |
16429 | - case 1314LLU: // repeat from here | |
16451 | + case 1316LLU: // repeat from here | |
16430 | 16452 | { |
16431 | - if(!stack[base + 10]) | |
16453 | + if(!stack[base + 11]) | |
16432 | 16454 | { |
16433 | - label = 1315LLU; // break loop | |
16455 | + label = 1317LLU; // break loop | |
16434 | 16456 | break; |
16435 | 16457 | } |
16436 | 16458 | |
16437 | 16459 | // delete list loop body |
16438 | 16460 | |
16439 | - uint64_t *newstack = (uint64_t *)(((struct listnode *)stack[base + 10])->data - sizeof(uint64_t) * 4); | |
16461 | + uint64_t *newstack = (uint64_t *)(((struct listnode *)stack[base + 11])->data - sizeof(uint64_t) * 4); | |
16440 | 16462 | // call ~result from copyfndef |
16441 | 16463 | newstack[0] = (uint64_t)stack; // backup stack location |
16442 | 16464 | newstack[1] = 1234567890; |
16443 | 16465 | newstack[2] = base; |
16444 | - newstack[3] = 1316LLU; | |
16466 | + newstack[3] = 1318LLU; | |
16445 | 16467 | stack = newstack; |
16446 | 16468 | // set stack-base & callee-address |
16447 | 16469 | base = 4/*deloffset*/; |
@@ -16448,61 +16470,61 @@ | ||
16448 | 16470 | label = 382LLU; // ~result |
16449 | 16471 | break; |
16450 | 16472 | } |
16451 | - case 1316LLU: // return from ~result to copyfndef | |
16473 | + case 1318LLU: // return from ~result to copyfndef | |
16452 | 16474 | { |
16453 | 16475 | stack = (uint64_t *)stack[0]; |
16454 | 16476 | // releasing toplevel container |
16455 | - Free(2 + 4, sizeof(uint64_t), (uint64_t *)(((struct listnode *)stack[base + 10])->data - sizeof(uint64_t) * 4)); | |
16477 | + Free(2 + 4, sizeof(uint64_t), (uint64_t *)(((struct listnode *)stack[base + 11])->data - sizeof(uint64_t) * 4)); | |
16456 | 16478 | |
16457 | 16479 | { |
16458 | - struct listnode *list = (struct listnode *)stack[base + 10]; | |
16459 | - stack[base + 10] = (uint64_t)list->next; | |
16480 | + struct listnode *list = (struct listnode *)stack[base + 11]; | |
16481 | + stack[base + 11] = (uint64_t)list->next; | |
16460 | 16482 | Free(1, sizeof(struct listnode), list); |
16461 | 16483 | } |
16462 | - label = 1314LLU; // repeat | |
16484 | + label = 1316LLU; // repeat | |
16463 | 16485 | break; |
16464 | 16486 | } |
16465 | - case 1315LLU: // loop finished | |
16487 | + case 1317LLU: // loop finished | |
16466 | 16488 | { |
16467 | - label = 1310LLU; // continue unrolling stack, delete next variable | |
16489 | + label = 1312LLU; // continue unrolling stack, delete next variable | |
16468 | 16490 | break; |
16469 | 16491 | } |
16470 | - case 1313LLU: // skipped deleter | |
16492 | + case 1315LLU: // skipped deleter | |
16471 | 16493 | { |
16472 | - stack[base + 10] = 0; | |
16473 | - label = 1318LLU; // skip deleter | |
16494 | + stack[base + 11] = 0; | |
16495 | + label = 1320LLU; // skip deleter | |
16474 | 16496 | break; |
16475 | 16497 | } |
16476 | - case 1317LLU: // deleter | |
16498 | + case 1319LLU: // deleter | |
16477 | 16499 | { |
16478 | 16500 | // throw from copyfndef |
16479 | - if(!stack[base + 11]) | |
16501 | + if(!stack[base + 12]) | |
16480 | 16502 | { |
16481 | 16503 | fprintf(stderr, "in function copyfndef: unrolling stack, skipping already deleted/unscoped variable [param] \n"); |
16482 | - label = 1312LLU; // skip, variable already deleted/unscoped | |
16504 | + label = 1314LLU; // skip, variable already deleted/unscoped | |
16483 | 16505 | break; |
16484 | 16506 | } |
16485 | 16507 | fprintf(stderr, "in function copyfndef: unrolling stack, variable [param] \n"); |
16486 | 16508 | // delete list |
16487 | - label = 1319LLU; // start to repeat | |
16509 | + label = 1321LLU; // start to repeat | |
16488 | 16510 | break; |
16489 | 16511 | } |
16490 | - case 1319LLU: // repeat from here | |
16512 | + case 1321LLU: // repeat from here | |
16491 | 16513 | { |
16492 | - if(!stack[base + 11]) | |
16514 | + if(!stack[base + 12]) | |
16493 | 16515 | { |
16494 | - label = 1320LLU; // break loop | |
16516 | + label = 1322LLU; // break loop | |
16495 | 16517 | break; |
16496 | 16518 | } |
16497 | 16519 | |
16498 | 16520 | // delete list loop body |
16499 | 16521 | |
16500 | - uint64_t *newstack = (uint64_t *)(((struct listnode *)stack[base + 11])->data - sizeof(uint64_t) * 4); | |
16522 | + uint64_t *newstack = (uint64_t *)(((struct listnode *)stack[base + 12])->data - sizeof(uint64_t) * 4); | |
16501 | 16523 | // call ~param from copyfndef |
16502 | 16524 | newstack[0] = (uint64_t)stack; // backup stack location |
16503 | 16525 | newstack[1] = 1234567890; |
16504 | 16526 | newstack[2] = base; |
16505 | - newstack[3] = 1321LLU; | |
16527 | + newstack[3] = 1323LLU; | |
16506 | 16528 | stack = newstack; |
16507 | 16529 | // set stack-base & callee-address |
16508 | 16530 | base = 4/*deloffset*/; |
@@ -16509,47 +16531,28 @@ | ||
16509 | 16531 | label = 400LLU; // ~param |
16510 | 16532 | break; |
16511 | 16533 | } |
16512 | - case 1321LLU: // return from ~param to copyfndef | |
16534 | + case 1323LLU: // return from ~param to copyfndef | |
16513 | 16535 | { |
16514 | 16536 | stack = (uint64_t *)stack[0]; |
16515 | 16537 | // releasing toplevel container |
16516 | - Free(2 + 4, sizeof(uint64_t), (uint64_t *)(((struct listnode *)stack[base + 11])->data - sizeof(uint64_t) * 4)); | |
16538 | + Free(2 + 4, sizeof(uint64_t), (uint64_t *)(((struct listnode *)stack[base + 12])->data - sizeof(uint64_t) * 4)); | |
16517 | 16539 | |
16518 | 16540 | { |
16519 | - struct listnode *list = (struct listnode *)stack[base + 11]; | |
16520 | - stack[base + 11] = (uint64_t)list->next; | |
16541 | + struct listnode *list = (struct listnode *)stack[base + 12]; | |
16542 | + stack[base + 12] = (uint64_t)list->next; | |
16521 | 16543 | Free(1, sizeof(struct listnode), list); |
16522 | 16544 | } |
16523 | - label = 1319LLU; // repeat | |
16545 | + label = 1321LLU; // repeat | |
16524 | 16546 | break; |
16525 | 16547 | } |
16526 | - case 1320LLU: // loop finished | |
16548 | + case 1322LLU: // loop finished | |
16527 | 16549 | { |
16528 | - label = 1312LLU; // continue unrolling stack, delete next variable | |
16550 | + label = 1314LLU; // continue unrolling stack, delete next variable | |
16529 | 16551 | break; |
16530 | 16552 | } |
16531 | - case 1318LLU: // skipped deleter | |
16553 | + case 1320LLU: // skipped deleter | |
16532 | 16554 | { |
16533 | - stack[base + 11] = 0; | |
16534 | - label = 1323LLU; // skip deleter | |
16535 | - break; | |
16536 | - } | |
16537 | - case 1322LLU: // deleter | |
16538 | - { | |
16539 | - // throw from copyfndef | |
16540 | - if(!stack[base + 12]) | |
16541 | - { | |
16542 | - fprintf(stderr, "in function copyfndef: unrolling stack, skipping already deleted/unscoped variable u64 \n"); | |
16543 | - label = 1317LLU; // skip, variable already deleted/unscoped | |
16544 | - break; | |
16545 | - } | |
16546 | - fprintf(stderr, "in function copyfndef: unrolling stack, variable u64 \n"); | |
16547 | - label = 1317LLU; // continue unrolling stack, delete next variable | |
16548 | - break; | |
16549 | - } | |
16550 | - case 1323LLU: // skipped deleter | |
16551 | - { | |
16552 | - stack[base + 12] = stack[base + 5]/*omaxcount*/; | |
16555 | + stack[base + 12] = 0; | |
16553 | 16556 | label = 1325LLU; // skip deleter |
16554 | 16557 | break; |
16555 | 16558 | } |
@@ -16559,16 +16562,16 @@ | ||
16559 | 16562 | if(!stack[base + 13]) |
16560 | 16563 | { |
16561 | 16564 | fprintf(stderr, "in function copyfndef: unrolling stack, skipping already deleted/unscoped variable u64 \n"); |
16562 | - label = 1322LLU; // skip, variable already deleted/unscoped | |
16565 | + label = 1319LLU; // skip, variable already deleted/unscoped | |
16563 | 16566 | break; |
16564 | 16567 | } |
16565 | 16568 | fprintf(stderr, "in function copyfndef: unrolling stack, variable u64 \n"); |
16566 | - label = 1322LLU; // continue unrolling stack, delete next variable | |
16569 | + label = 1319LLU; // continue unrolling stack, delete next variable | |
16567 | 16570 | break; |
16568 | 16571 | } |
16569 | 16572 | case 1325LLU: // skipped deleter |
16570 | 16573 | { |
16571 | - stack[base + 13] = stack[base + 6]/*oid*/; | |
16574 | + stack[base + 13] = stack[base + 5]/*omaxcount*/; | |
16572 | 16575 | label = 1327LLU; // skip deleter |
16573 | 16576 | break; |
16574 | 16577 | } |
@@ -16587,7 +16590,7 @@ | ||
16587 | 16590 | } |
16588 | 16591 | case 1327LLU: // skipped deleter |
16589 | 16592 | { |
16590 | - stack[base + 14] = stack[base + 7]/*orecursive*/; | |
16593 | + stack[base + 14] = stack[base + 6]/*oid*/; | |
16591 | 16594 | label = 1329LLU; // skip deleter |
16592 | 16595 | break; |
16593 | 16596 | } |
@@ -16606,46 +16609,84 @@ | ||
16606 | 16609 | } |
16607 | 16610 | case 1329LLU: // skipped deleter |
16608 | 16611 | { |
16609 | - stack[base + 15] = stack[base + 8]/*ofallible*/; | |
16610 | - flippedassign(stack[base + 3]/*orestypes*/, &stack[base + 16]); | |
16611 | - label = 1330LLU; // start to repeat | |
16612 | + stack[base + 15] = stack[base + 7]/*orecursive*/; | |
16613 | + label = 1331LLU; // skip deleter | |
16612 | 16614 | break; |
16613 | 16615 | } |
16614 | - case 1330LLU: // repeat from here | |
16616 | + case 1330LLU: // deleter | |
16615 | 16617 | { |
16618 | + // throw from copyfndef | |
16616 | 16619 | if(!stack[base + 16]) |
16617 | 16620 | { |
16618 | - label = 1331LLU; // break loop | |
16621 | + fprintf(stderr, "in function copyfndef: unrolling stack, skipping already deleted/unscoped variable u64 \n"); | |
16622 | + label = 1328LLU; // skip, variable already deleted/unscoped | |
16619 | 16623 | break; |
16620 | 16624 | } |
16625 | + fprintf(stderr, "in function copyfndef: unrolling stack, variable u64 \n"); | |
16626 | + label = 1328LLU; // continue unrolling stack, delete next variable | |
16627 | + break; | |
16628 | + } | |
16629 | + case 1331LLU: // skipped deleter | |
16630 | + { | |
16631 | + stack[base + 16] = stack[base + 8]/*ofallible*/; | |
16632 | + label = 1333LLU; // skip deleter | |
16633 | + break; | |
16634 | + } | |
16635 | + case 1332LLU: // deleter | |
16636 | + { | |
16637 | + // throw from copyfndef | |
16638 | + if(!stack[base + 17]) | |
16639 | + { | |
16640 | + fprintf(stderr, "in function copyfndef: unrolling stack, skipping already deleted/unscoped variable u64 \n"); | |
16641 | + label = 1330LLU; // skip, variable already deleted/unscoped | |
16642 | + break; | |
16643 | + } | |
16644 | + fprintf(stderr, "in function copyfndef: unrolling stack, variable u64 \n"); | |
16645 | + label = 1330LLU; // continue unrolling stack, delete next variable | |
16646 | + break; | |
16647 | + } | |
16648 | + case 1333LLU: // skipped deleter | |
16649 | + { | |
16650 | + stack[base + 17] = stack[base + 9]/*ocanthrow*/; | |
16651 | + flippedassign(stack[base + 3]/*orestypes*/, &stack[base + 18]); | |
16652 | + label = 1334LLU; // start to repeat | |
16653 | + break; | |
16654 | + } | |
16655 | + case 1334LLU: // repeat from here | |
16656 | + { | |
16657 | + if(!stack[base + 18]) | |
16658 | + { | |
16659 | + label = 1335LLU; // break loop | |
16660 | + break; | |
16661 | + } | |
16621 | 16662 | |
16622 | 16663 | // loop body |
16623 | - stack[base + 17] = (uint64_t)(((const struct listnode *)(stack[base + 16]))->data); | |
16624 | - stack[base + 18]/*previous*/ = stack[base + 16]; | |
16625 | - stack[base + 16] = (uint64_t)(((const struct listnode *)(stack[base + 16]))->next); | |
16664 | + stack[base + 19] = (uint64_t)(((const struct listnode *)(stack[base + 18]))->data); | |
16665 | + stack[base + 20]/*previous*/ = stack[base + 18]; | |
16666 | + stack[base + 18] = (uint64_t)(((const struct listnode *)(stack[base + 18]))->next); | |
16626 | 16667 | // call copyresult from copyfndef |
16627 | - stack[base + 20LLU] = 1332LLU/*throw to this address*/; | |
16628 | - stack[base + 21LLU] = base; | |
16629 | - stack[base + 22LLU] = 1333LLU; | |
16668 | + stack[base + 22LLU] = 1336LLU/*throw to this address*/; | |
16669 | + stack[base + 23LLU] = base; | |
16670 | + stack[base + 24LLU] = 1337LLU; | |
16630 | 16671 | // arguments for call to copyresult |
16631 | - stack[base + 24LLU] = stack[base + 17]/*origresult*/; | |
16672 | + stack[base + 26LLU] = stack[base + 19]/*origresult*/; | |
16632 | 16673 | // set stack-base & callee-address |
16633 | - base += 23LLU; | |
16674 | + base += 25LLU; | |
16634 | 16675 | label = 385LLU; // copyresult |
16635 | 16676 | break; |
16636 | 16677 | } |
16637 | - case 1332LLU: // copy-back deleter (copyresult to copyfndef) | |
16678 | + case 1336LLU: // copy-back deleter (copyresult to copyfndef) | |
16638 | 16679 | { |
16639 | 16680 | fprintf(stderr, "in function copyfndef: unrolling stack, copy-back (copyresult to copyfndef)\n"); |
16640 | 16681 | // copy mutable arguments back from call to copyresult |
16641 | - label = 1328LLU; // continue to roll stack | |
16682 | + label = 1332LLU; // continue to roll stack | |
16642 | 16683 | break; |
16643 | 16684 | } |
16644 | - case 1333LLU: // return from copyresult to copyfndef | |
16685 | + case 1337LLU: // return from copyresult to copyfndef | |
16645 | 16686 | { |
16646 | 16687 | // copy mutable arguments back from call to copyresult |
16647 | 16688 | // copy back results provided by call to copyresult |
16648 | - stack[base + 19] = stack[base + 23LLU]; | |
16689 | + stack[base + 21] = stack[base + 25LLU]; | |
16649 | 16690 | { |
16650 | 16691 | struct listnode *list = (struct listnode *)Calloc(1, sizeof(struct listnode)); |
16651 | 16692 | if(!list) |
@@ -16653,56 +16694,56 @@ | ||
16653 | 16694 | fprintf(stderr, "in function copyfndef push to [result]: OUT OF MEMORY!"); |
16654 | 16695 | exit(-1); |
16655 | 16696 | } |
16656 | - list->next = (struct listnode *)stack[base + 10]/*crestypes*/; | |
16657 | - stack[base + 10]/*crestypes*/ = (uint64_t)list; | |
16658 | - MOVE(&list->data, &stack[base + 19]/*copyresult*/); | |
16697 | + list->next = (struct listnode *)stack[base + 11]/*crestypes*/; | |
16698 | + stack[base + 11]/*crestypes*/ = (uint64_t)list; | |
16699 | + MOVE(&list->data, &stack[base + 21]/*copyresult*/); | |
16659 | 16700 | } |
16660 | - ((struct listnode *)(stack[base + 18]/*previous*/))->data = stack[base + 17]; | |
16661 | - label = 1330LLU; // repeat | |
16701 | + ((struct listnode *)(stack[base + 20]/*previous*/))->data = stack[base + 19]; | |
16702 | + label = 1334LLU; // repeat | |
16662 | 16703 | break; |
16663 | 16704 | } |
16664 | - case 1331LLU: // loop finished | |
16705 | + case 1335LLU: // loop finished | |
16665 | 16706 | { |
16666 | - list_reverse(((struct listnode **)(&stack[base + 10]/*crestypes*/))); | |
16667 | - flippedassign(stack[base + 4]/*oargtypes*/, &stack[base + 19]); | |
16668 | - label = 1334LLU; // start to repeat | |
16707 | + list_reverse(((struct listnode **)(&stack[base + 11]/*crestypes*/))); | |
16708 | + flippedassign(stack[base + 4]/*oargtypes*/, &stack[base + 21]); | |
16709 | + label = 1338LLU; // start to repeat | |
16669 | 16710 | break; |
16670 | 16711 | } |
16671 | - case 1334LLU: // repeat from here | |
16712 | + case 1338LLU: // repeat from here | |
16672 | 16713 | { |
16673 | - if(!stack[base + 19]) | |
16714 | + if(!stack[base + 21]) | |
16674 | 16715 | { |
16675 | - label = 1335LLU; // break loop | |
16716 | + label = 1339LLU; // break loop | |
16676 | 16717 | break; |
16677 | 16718 | } |
16678 | 16719 | |
16679 | 16720 | // loop body |
16680 | - stack[base + 20] = (uint64_t)(((const struct listnode *)(stack[base + 19]))->data); | |
16681 | - stack[base + 21]/*previous*/ = stack[base + 19]; | |
16682 | - stack[base + 19] = (uint64_t)(((const struct listnode *)(stack[base + 19]))->next); | |
16721 | + stack[base + 22] = (uint64_t)(((const struct listnode *)(stack[base + 21]))->data); | |
16722 | + stack[base + 23]/*previous*/ = stack[base + 21]; | |
16723 | + stack[base + 21] = (uint64_t)(((const struct listnode *)(stack[base + 21]))->next); | |
16683 | 16724 | // call copyparam from copyfndef |
16684 | - stack[base + 23LLU] = 1336LLU/*throw to this address*/; | |
16685 | - stack[base + 24LLU] = base; | |
16686 | - stack[base + 25LLU] = 1337LLU; | |
16725 | + stack[base + 25LLU] = 1340LLU/*throw to this address*/; | |
16726 | + stack[base + 26LLU] = base; | |
16727 | + stack[base + 27LLU] = 1341LLU; | |
16687 | 16728 | // arguments for call to copyparam |
16688 | - stack[base + 27LLU] = stack[base + 20]/*origparam*/; | |
16729 | + stack[base + 29LLU] = stack[base + 22]/*origparam*/; | |
16689 | 16730 | // set stack-base & callee-address |
16690 | - base += 26LLU; | |
16731 | + base += 28LLU; | |
16691 | 16732 | label = 403LLU; // copyparam |
16692 | 16733 | break; |
16693 | 16734 | } |
16694 | - case 1336LLU: // copy-back deleter (copyparam to copyfndef) | |
16735 | + case 1340LLU: // copy-back deleter (copyparam to copyfndef) | |
16695 | 16736 | { |
16696 | 16737 | fprintf(stderr, "in function copyfndef: unrolling stack, copy-back (copyparam to copyfndef)\n"); |
16697 | 16738 | // copy mutable arguments back from call to copyparam |
16698 | - label = 1328LLU; // continue to roll stack | |
16739 | + label = 1332LLU; // continue to roll stack | |
16699 | 16740 | break; |
16700 | 16741 | } |
16701 | - case 1337LLU: // return from copyparam to copyfndef | |
16742 | + case 1341LLU: // return from copyparam to copyfndef | |
16702 | 16743 | { |
16703 | 16744 | // copy mutable arguments back from call to copyparam |
16704 | 16745 | // copy back results provided by call to copyparam |
16705 | - stack[base + 22] = stack[base + 26LLU]; | |
16746 | + stack[base + 24] = stack[base + 28LLU]; | |
16706 | 16747 | { |
16707 | 16748 | struct listnode *list = (struct listnode *)Calloc(1, sizeof(struct listnode)); |
16708 | 16749 | if(!list) |
@@ -16710,27 +16751,27 @@ | ||
16710 | 16751 | fprintf(stderr, "in function copyfndef push to [param]: OUT OF MEMORY!"); |
16711 | 16752 | exit(-1); |
16712 | 16753 | } |
16713 | - list->next = (struct listnode *)stack[base + 11]/*cargtypes*/; | |
16714 | - stack[base + 11]/*cargtypes*/ = (uint64_t)list; | |
16715 | - MOVE(&list->data, &stack[base + 22]/*copyparam*/); | |
16754 | + list->next = (struct listnode *)stack[base + 12]/*cargtypes*/; | |
16755 | + stack[base + 12]/*cargtypes*/ = (uint64_t)list; | |
16756 | + MOVE(&list->data, &stack[base + 24]/*copyparam*/); | |
16716 | 16757 | } |
16717 | - ((struct listnode *)(stack[base + 21]/*previous*/))->data = stack[base + 20]; | |
16718 | - label = 1334LLU; // repeat | |
16758 | + ((struct listnode *)(stack[base + 23]/*previous*/))->data = stack[base + 22]; | |
16759 | + label = 1338LLU; // repeat | |
16719 | 16760 | break; |
16720 | 16761 | } |
16721 | - case 1335LLU: // loop finished | |
16762 | + case 1339LLU: // loop finished | |
16722 | 16763 | { |
16723 | - list_reverse(((struct listnode **)(&stack[base + 11]/*cargtypes*/))); | |
16724 | - label = 1339LLU; // skip deleter | |
16764 | + list_reverse(((struct listnode **)(&stack[base + 12]/*cargtypes*/))); | |
16765 | + label = 1343LLU; // skip deleter | |
16725 | 16766 | break; |
16726 | 16767 | } |
16727 | - case 1338LLU: // deleter | |
16768 | + case 1342LLU: // deleter | |
16728 | 16769 | { |
16729 | 16770 | // throw from copyfndef |
16730 | 16771 | if(!stack[base + 0]) |
16731 | 16772 | { |
16732 | 16773 | fprintf(stderr, "in function copyfndef: unrolling stack, skipping already deleted/unscoped variable fndef \n"); |
16733 | - label = 1328LLU; // skip, variable already deleted/unscoped | |
16774 | + label = 1332LLU; // skip, variable already deleted/unscoped | |
16734 | 16775 | break; |
16735 | 16776 | } |
16736 | 16777 | fprintf(stderr, "in function copyfndef: unrolling stack, variable fndef \n"); |
@@ -16740,7 +16781,7 @@ | ||
16740 | 16781 | newstack[0] = (uint64_t)stack; // backup stack location |
16741 | 16782 | newstack[1] = 1234567890; |
16742 | 16783 | newstack[2] = base; |
16743 | - newstack[3] = 1340LLU; | |
16784 | + newstack[3] = 1344LLU; | |
16744 | 16785 | stack = newstack; |
16745 | 16786 | // set stack-base & callee-address |
16746 | 16787 | base = 4/*deloffset*/; |
@@ -16747,33 +16788,35 @@ | ||
16747 | 16788 | label = 1273LLU; // ~fndef |
16748 | 16789 | break; |
16749 | 16790 | } |
16750 | - case 1340LLU: // return from ~fndef to copyfndef | |
16791 | + case 1344LLU: // return from ~fndef to copyfndef | |
16751 | 16792 | { |
16752 | 16793 | stack = (uint64_t *)stack[0]; |
16753 | 16794 | // releasing toplevel container |
16754 | 16795 | Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4)); |
16755 | 16796 | |
16756 | - label = 1328LLU; // continue unrolling stack, delete next variable | |
16797 | + label = 1332LLU; // continue unrolling stack, delete next variable | |
16757 | 16798 | break; |
16758 | 16799 | } |
16759 | - case 1339LLU: // skipped deleter | |
16800 | + case 1343LLU: // skipped deleter | |
16760 | 16801 | { |
16761 | 16802 | // construct fndef.fndef |
16762 | - if(!(stack[base + 0] = construct(7))) | |
16803 | + if(!(stack[base + 0] = construct(8))) | |
16763 | 16804 | { |
16764 | - label = 1328LLU; // throw: begin to unroll stack | |
16805 | + label = 1332LLU; // throw: begin to unroll stack | |
16765 | 16806 | break; |
16766 | 16807 | } |
16767 | 16808 | |
16768 | 16809 | // consequent |
16769 | 16810 | ((uint64_t *)stack[base + 0])[0] = 0; |
16770 | - (((uint64_t **)(stack[base + 0]))[1][0]) = stack[base + 9]/*clabel*/; | |
16771 | - INIT(&(((uint64_t **)(stack[base + 0]))[1][1]), &stack[base + 10]/*crestypes*/); | |
16772 | - INIT(&(((uint64_t **)(stack[base + 0]))[1][2]), &stack[base + 11]/*cargtypes*/); | |
16773 | - (((uint64_t **)(stack[base + 0]))[1][3]) = stack[base + 12]/*cmaxcount*/; | |
16774 | - (((uint64_t **)(stack[base + 0]))[1][4]) = stack[base + 13]/*cid*/; | |
16775 | - (((uint64_t **)(stack[base + 0]))[1][5]) = stack[base + 14]/*crecursive*/; | |
16776 | - (((uint64_t **)(stack[base + 0]))[1][6]) = stack[base + 15]/*cfallible*/; | |
16811 | + (((uint64_t **)(stack[base + 0]))[1][0]) = stack[base + 10]/*clabel*/; | |
16812 | + INIT(&(((uint64_t **)(stack[base + 0]))[1][1]), &stack[base + 11]/*crestypes*/); | |
16813 | + INIT(&(((uint64_t **)(stack[base + 0]))[1][2]), &stack[base + 12]/*cargtypes*/); | |
16814 | + (((uint64_t **)(stack[base + 0]))[1][3]) = stack[base + 13]/*cmaxcount*/; | |
16815 | + (((uint64_t **)(stack[base + 0]))[1][4]) = stack[base + 14]/*cid*/; | |
16816 | + (((uint64_t **)(stack[base + 0]))[1][5]) = stack[base + 15]/*crecursive*/; | |
16817 | + (((uint64_t **)(stack[base + 0]))[1][6]) = stack[base + 16]/*cfallible*/; | |
16818 | + (((uint64_t **)(stack[base + 0]))[1][7]) = stack[base + 17]/*ccanthrow*/; | |
16819 | + ((uint64_t **)(stack[base + 1]))[1][7] = stack[base + 9]; | |
16777 | 16820 | ((uint64_t **)(stack[base + 1]))[1][6] = stack[base + 8]; |
16778 | 16821 | ((uint64_t **)(stack[base + 1]))[1][5] = stack[base + 7]; |
16779 | 16822 | ((uint64_t **)(stack[base + 1]))[1][4] = stack[base + 6]; |
@@ -16781,15 +16824,15 @@ | ||
16781 | 16824 | ((uint64_t **)(stack[base + 1]))[1][2] = stack[base + 4]; |
16782 | 16825 | ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3]; |
16783 | 16826 | ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2]; |
16784 | - label = 1308LLU; // case complete | |
16827 | + label = 1310LLU; // case complete | |
16785 | 16828 | break; |
16786 | 16829 | } |
16787 | - case 1309LLU: // try next case | |
16830 | + case 1311LLU: // try next case | |
16788 | 16831 | { |
16789 | 16832 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
16790 | 16833 | exit(-1); |
16791 | 16834 | } |
16792 | - case 1308LLU: // completed switch | |
16835 | + case 1310LLU: // completed switch | |
16793 | 16836 | { |
16794 | 16837 | // return from copyfndef |
16795 | 16838 | label = stack[base - 1]; |
@@ -16796,7 +16839,7 @@ | ||
16796 | 16839 | base = stack[base - 2]; |
16797 | 16840 | break; |
16798 | 16841 | } |
16799 | - case 1342LLU: // function FindFn failed | |
16842 | + case 1346LLU: // function FindFn failed | |
16800 | 16843 | { |
16801 | 16844 | fprintf(stderr, "function FindFn failed\n"); |
16802 | 16845 | label = stack[base - 3]; |
@@ -16803,7 +16846,7 @@ | ||
16803 | 16846 | base = stack[base - 2]; |
16804 | 16847 | break; |
16805 | 16848 | } |
16806 | - case 1341LLU: // FindFn | |
16849 | + case 1345LLU: // FindFn | |
16807 | 16850 | { |
16808 | 16851 | //#define res0 0 |
16809 | 16852 | //#define arg0 1 |
@@ -16810,9 +16853,9 @@ | ||
16810 | 16853 | //#define arg1 2 |
16811 | 16854 | //#define arg2 3 |
16812 | 16855 | // call mkfndummy from FindFn |
16813 | - stack[base + 5LLU] = 1343LLU/*throw to this address*/; | |
16856 | + stack[base + 5LLU] = 1347LLU/*throw to this address*/; | |
16814 | 16857 | stack[base + 6LLU] = base; |
16815 | - stack[base + 7LLU] = 1344LLU; | |
16858 | + stack[base + 7LLU] = 1348LLU; | |
16816 | 16859 | // arguments for call to mkfndummy |
16817 | 16860 | // set stack-base & callee-address |
16818 | 16861 | base += 8LLU; |
@@ -16819,46 +16862,46 @@ | ||
16819 | 16862 | label = 1281LLU; // mkfndummy |
16820 | 16863 | break; |
16821 | 16864 | } |
16822 | - case 1343LLU: // copy-back deleter (mkfndummy to FindFn) | |
16865 | + case 1347LLU: // copy-back deleter (mkfndummy to FindFn) | |
16823 | 16866 | { |
16824 | 16867 | fprintf(stderr, "in function FindFn: unrolling stack, copy-back (mkfndummy to FindFn)\n"); |
16825 | 16868 | // copy mutable arguments back from call to mkfndummy |
16826 | - label = 1342LLU; // continue to roll stack | |
16869 | + label = 1346LLU; // continue to roll stack | |
16827 | 16870 | break; |
16828 | 16871 | } |
16829 | - case 1344LLU: // return from mkfndummy to FindFn | |
16872 | + case 1348LLU: // return from mkfndummy to FindFn | |
16830 | 16873 | { |
16831 | 16874 | // copy mutable arguments back from call to mkfndummy |
16832 | 16875 | // copy back results provided by call to mkfndummy |
16833 | 16876 | stack[base + 4] = stack[base + 8LLU]; |
16834 | - label = 1346LLU; // skip deleter | |
16877 | + label = 1350LLU; // skip deleter | |
16835 | 16878 | break; |
16836 | 16879 | } |
16837 | - case 1345LLU: // deleter | |
16880 | + case 1349LLU: // deleter | |
16838 | 16881 | { |
16839 | 16882 | // throw from FindFn |
16840 | 16883 | if(!stack[base + 5]) |
16841 | 16884 | { |
16842 | 16885 | fprintf(stderr, "in function FindFn: unrolling stack, skipping already deleted/unscoped variable u64 \n"); |
16843 | - label = 1342LLU; // skip, variable already deleted/unscoped | |
16886 | + label = 1346LLU; // skip, variable already deleted/unscoped | |
16844 | 16887 | break; |
16845 | 16888 | } |
16846 | 16889 | fprintf(stderr, "in function FindFn: unrolling stack, variable u64 \n"); |
16847 | - label = 1342LLU; // continue unrolling stack, delete next variable | |
16890 | + label = 1346LLU; // continue unrolling stack, delete next variable | |
16848 | 16891 | break; |
16849 | 16892 | } |
16850 | - case 1346LLU: // skipped deleter | |
16893 | + case 1350LLU: // skipped deleter | |
16851 | 16894 | { |
16852 | 16895 | stack[base + 5] = 0; |
16853 | 16896 | flippedassign(stack[base + 2]/*fndefs*/, &stack[base + 6]); |
16854 | - label = 1347LLU; // start to repeat | |
16897 | + label = 1351LLU; // start to repeat | |
16855 | 16898 | break; |
16856 | 16899 | } |
16857 | - case 1347LLU: // repeat from here | |
16900 | + case 1351LLU: // repeat from here | |
16858 | 16901 | { |
16859 | 16902 | if(!stack[base + 6]) |
16860 | 16903 | { |
16861 | - label = 1348LLU; // break loop | |
16904 | + label = 1352LLU; // break loop | |
16862 | 16905 | break; |
16863 | 16906 | } |
16864 | 16907 |
@@ -16868,19 +16911,19 @@ | ||
16868 | 16911 | stack[base + 6] = (uint64_t)(((const struct listnode *)(stack[base + 6]))->next); |
16869 | 16912 | if(!stack[base + 5]/*found*/) |
16870 | 16913 | { |
16871 | - label = 1349LLU; // jump to alternative | |
16914 | + label = 1353LLU; // jump to alternative | |
16872 | 16915 | break; |
16873 | 16916 | } |
16874 | 16917 | |
16875 | 16918 | // consequent |
16876 | - label = 1350LLU; // consequent complete | |
16919 | + label = 1354LLU; // consequent complete | |
16877 | 16920 | break; |
16878 | 16921 | } |
16879 | - case 1349LLU: // alternative | |
16922 | + case 1353LLU: // alternative | |
16880 | 16923 | { |
16881 | 16924 | if(/*fndef*/0 != ((uint64_t *)(stack[base + 7]/*fndef*/))[0]) |
16882 | 16925 | { |
16883 | - label = 1352LLU; // jump to alternative | |
16926 | + label = 1356LLU; // jump to alternative | |
16884 | 16927 | break; |
16885 | 16928 | } |
16886 | 16929 |
@@ -16891,90 +16934,91 @@ | ||
16891 | 16934 | /*defid*/stack[base + 13] = ((uint64_t **)(stack[base + 7]/*fndef*/))[1][4]/*id*/; |
16892 | 16935 | /*recursive*/stack[base + 14] = ((uint64_t **)(stack[base + 7]/*fndef*/))[1][5]/*recursive*/; |
16893 | 16936 | /*fallible*/stack[base + 15] = ((uint64_t **)(stack[base + 7]/*fndef*/))[1][6]/*fallible*/; |
16937 | + /*canthrow*/stack[base + 16] = ((uint64_t **)(stack[base + 7]/*fndef*/))[1][7]/*canthrow*/; | |
16894 | 16938 | |
16895 | 16939 | // case |
16896 | - label = 1354LLU; // skip deleter | |
16940 | + label = 1358LLU; // skip deleter | |
16897 | 16941 | break; |
16898 | 16942 | } |
16899 | - case 1353LLU: // deleter | |
16943 | + case 1357LLU: // deleter | |
16900 | 16944 | { |
16901 | 16945 | // throw from FindFn |
16902 | - if(!stack[base + 16]) | |
16946 | + if(!stack[base + 17]) | |
16903 | 16947 | { |
16904 | 16948 | fprintf(stderr, "in function FindFn: unrolling stack, skipping already deleted/unscoped variable u64 \n"); |
16905 | - label = 1345LLU; // skip, variable already deleted/unscoped | |
16949 | + label = 1349LLU; // skip, variable already deleted/unscoped | |
16906 | 16950 | break; |
16907 | 16951 | } |
16908 | 16952 | fprintf(stderr, "in function FindFn: unrolling stack, variable u64 \n"); |
16909 | - label = 1345LLU; // continue unrolling stack, delete next variable | |
16953 | + label = 1349LLU; // continue unrolling stack, delete next variable | |
16910 | 16954 | break; |
16911 | 16955 | } |
16912 | - case 1354LLU: // skipped deleter | |
16956 | + case 1358LLU: // skipped deleter | |
16913 | 16957 | { |
16914 | - stack[base + 16] = 0; | |
16958 | + stack[base + 17] = 0; | |
16915 | 16959 | // call equ from FindFn |
16916 | - stack[base + 17LLU] = 1355LLU/*throw to this address*/; | |
16917 | - stack[base + 18LLU] = base; | |
16918 | - stack[base + 19LLU] = 1356LLU; | |
16960 | + stack[base + 18LLU] = 1359LLU/*throw to this address*/; | |
16961 | + stack[base + 19LLU] = base; | |
16962 | + stack[base + 20LLU] = 1360LLU; | |
16919 | 16963 | // arguments for call to equ |
16920 | - stack[base + 21LLU] = stack[base + 3]/*id*/; | |
16921 | - stack[base + 22LLU] = stack[base + 13]/*defid*/; | |
16964 | + stack[base + 22LLU] = stack[base + 3]/*id*/; | |
16965 | + stack[base + 23LLU] = stack[base + 13]/*defid*/; | |
16922 | 16966 | // set stack-base & callee-address |
16923 | - base += 20LLU; | |
16967 | + base += 21LLU; | |
16924 | 16968 | label = 18446744073709551600LLU; // equ |
16925 | 16969 | break; |
16926 | 16970 | } |
16927 | - case 1355LLU: // copy-back deleter (equ to FindFn) | |
16971 | + case 1359LLU: // copy-back deleter (equ to FindFn) | |
16928 | 16972 | { |
16929 | 16973 | fprintf(stderr, "in function FindFn: unrolling stack, copy-back (equ to FindFn)\n"); |
16930 | 16974 | // copy mutable arguments back from call to equ |
16931 | - label = 1353LLU; // continue to roll stack | |
16975 | + label = 1357LLU; // continue to roll stack | |
16932 | 16976 | break; |
16933 | 16977 | } |
16934 | - case 1356LLU: // return from equ to FindFn | |
16978 | + case 1360LLU: // return from equ to FindFn | |
16935 | 16979 | { |
16936 | 16980 | // copy mutable arguments back from call to equ |
16937 | 16981 | // copy back results provided by call to equ |
16938 | - stack[base + 16] = stack[base + 20LLU]; | |
16939 | - if(!stack[base + 16]/*isequal*/) | |
16982 | + stack[base + 17] = stack[base + 21LLU]; | |
16983 | + if(!stack[base + 17]/*isequal*/) | |
16940 | 16984 | { |
16941 | - label = 1357LLU; // jump to alternative | |
16985 | + label = 1361LLU; // jump to alternative | |
16942 | 16986 | break; |
16943 | 16987 | } |
16944 | 16988 | |
16945 | 16989 | // consequent |
16946 | 16990 | // call copyfndef from FindFn |
16947 | - stack[base + 18LLU] = 1359LLU/*throw to this address*/; | |
16948 | - stack[base + 19LLU] = base; | |
16949 | - stack[base + 20LLU] = 1360LLU; | |
16991 | + stack[base + 19LLU] = 1363LLU/*throw to this address*/; | |
16992 | + stack[base + 20LLU] = base; | |
16993 | + stack[base + 21LLU] = 1364LLU; | |
16950 | 16994 | // arguments for call to copyfndef |
16951 | - stack[base + 22LLU] = stack[base + 7]/*fndef*/; | |
16995 | + stack[base + 23LLU] = stack[base + 7]/*fndef*/; | |
16952 | 16996 | // set stack-base & callee-address |
16953 | - base += 21LLU; | |
16954 | - label = 1306LLU; // copyfndef | |
16997 | + base += 22LLU; | |
16998 | + label = 1308LLU; // copyfndef | |
16955 | 16999 | break; |
16956 | 17000 | } |
16957 | - case 1359LLU: // copy-back deleter (copyfndef to FindFn) | |
17001 | + case 1363LLU: // copy-back deleter (copyfndef to FindFn) | |
16958 | 17002 | { |
16959 | 17003 | fprintf(stderr, "in function FindFn: unrolling stack, copy-back (copyfndef to FindFn)\n"); |
16960 | 17004 | // copy mutable arguments back from call to copyfndef |
16961 | - label = 1353LLU; // continue to roll stack | |
17005 | + label = 1357LLU; // continue to roll stack | |
16962 | 17006 | break; |
16963 | 17007 | } |
16964 | - case 1360LLU: // return from copyfndef to FindFn | |
17008 | + case 1364LLU: // return from copyfndef to FindFn | |
16965 | 17009 | { |
16966 | 17010 | // copy mutable arguments back from call to copyfndef |
16967 | 17011 | // copy back results provided by call to copyfndef |
16968 | - stack[base + 17] = stack[base + 21LLU]; | |
16969 | - swap(&stack[base + 4], &stack[base + 17]); | |
17012 | + stack[base + 18] = stack[base + 22LLU]; | |
17013 | + swap(&stack[base + 4], &stack[base + 18]); | |
16970 | 17014 | stack[base + 5]/*found*/ = 1; |
16971 | 17015 | |
16972 | - uint64_t *newstack = (uint64_t *)(stack[base + 17] - sizeof(uint64_t) * 4); | |
17016 | + uint64_t *newstack = (uint64_t *)(stack[base + 18] - sizeof(uint64_t) * 4); | |
16973 | 17017 | // call ~fndef from FindFn |
16974 | 17018 | newstack[0] = (uint64_t)stack; // backup stack location |
16975 | 17019 | newstack[1] = 1234567890; |
16976 | 17020 | newstack[2] = base; |
16977 | - newstack[3] = 1361LLU; | |
17021 | + newstack[3] = 1365LLU; | |
16978 | 17022 | stack = newstack; |
16979 | 17023 | // set stack-base & callee-address |
16980 | 17024 | base = 4/*deloffset*/; |
@@ -16981,22 +17025,23 @@ | ||
16981 | 17025 | label = 1273LLU; // ~fndef |
16982 | 17026 | break; |
16983 | 17027 | } |
16984 | - case 1361LLU: // return from ~fndef to FindFn | |
17028 | + case 1365LLU: // return from ~fndef to FindFn | |
16985 | 17029 | { |
16986 | 17030 | stack = (uint64_t *)stack[0]; |
16987 | 17031 | // releasing toplevel container |
16988 | - Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 17] - sizeof(uint64_t) * 4)); | |
17032 | + Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 18] - sizeof(uint64_t) * 4)); | |
16989 | 17033 | |
16990 | - label = 1358LLU; // consequent complete | |
17034 | + label = 1362LLU; // consequent complete | |
16991 | 17035 | break; |
16992 | 17036 | } |
16993 | - case 1357LLU: // alternative | |
17037 | + case 1361LLU: // alternative | |
16994 | 17038 | { |
16995 | - label = 1358LLU; // alternative complete | |
17039 | + label = 1362LLU; // alternative complete | |
16996 | 17040 | break; |
16997 | 17041 | } |
16998 | - case 1358LLU: // completed if-then-else | |
17042 | + case 1362LLU: // completed if-then-else | |
16999 | 17043 | { |
17044 | + ((uint64_t **)(stack[base + 7]))[1][7] = stack[base + 16]; | |
17000 | 17045 | ((uint64_t **)(stack[base + 7]))[1][6] = stack[base + 15]; |
17001 | 17046 | ((uint64_t **)(stack[base + 7]))[1][5] = stack[base + 14]; |
17002 | 17047 | ((uint64_t **)(stack[base + 7]))[1][4] = stack[base + 13]; |
@@ -17004,44 +17049,44 @@ | ||
17004 | 17049 | ((uint64_t **)(stack[base + 7]))[1][2] = stack[base + 11]; |
17005 | 17050 | ((uint64_t **)(stack[base + 7]))[1][1] = stack[base + 10]; |
17006 | 17051 | ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 9]; |
17007 | - label = 1351LLU; // case complete | |
17052 | + label = 1355LLU; // case complete | |
17008 | 17053 | break; |
17009 | 17054 | } |
17010 | - case 1352LLU: // try next case | |
17055 | + case 1356LLU: // try next case | |
17011 | 17056 | { |
17012 | 17057 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
17013 | 17058 | exit(-1); |
17014 | 17059 | } |
17015 | - case 1351LLU: // completed switch | |
17060 | + case 1355LLU: // completed switch | |
17016 | 17061 | { |
17017 | - label = 1350LLU; // alternative complete | |
17062 | + label = 1354LLU; // alternative complete | |
17018 | 17063 | break; |
17019 | 17064 | } |
17020 | - case 1350LLU: // completed if-then-else | |
17065 | + case 1354LLU: // completed if-then-else | |
17021 | 17066 | { |
17022 | 17067 | ((struct listnode *)(stack[base + 8]/*previous*/))->data = stack[base + 7]; |
17023 | - label = 1347LLU; // repeat | |
17068 | + label = 1351LLU; // repeat | |
17024 | 17069 | break; |
17025 | 17070 | } |
17026 | - case 1348LLU: // loop finished | |
17071 | + case 1352LLU: // loop finished | |
17027 | 17072 | { |
17028 | 17073 | if(!stack[base + 5]/*found*/) |
17029 | 17074 | { |
17030 | - label = 1362LLU; // jump to alternative | |
17075 | + label = 1366LLU; // jump to alternative | |
17031 | 17076 | break; |
17032 | 17077 | } |
17033 | 17078 | |
17034 | 17079 | // consequent |
17035 | - label = 1363LLU; // consequent complete | |
17080 | + label = 1367LLU; // consequent complete | |
17036 | 17081 | break; |
17037 | 17082 | } |
17038 | - case 1362LLU: // alternative | |
17083 | + case 1366LLU: // alternative | |
17039 | 17084 | { |
17040 | 17085 | fprintf(stderr, "%s", "in function "); |
17041 | 17086 | // call reportid from FindFn |
17042 | - stack[base + 9LLU] = 1364LLU/*throw to this address*/; | |
17087 | + stack[base + 9LLU] = 1368LLU/*throw to this address*/; | |
17043 | 17088 | stack[base + 10LLU] = base; |
17044 | - stack[base + 11LLU] = 1365LLU; | |
17089 | + stack[base + 11LLU] = 1369LLU; | |
17045 | 17090 | // arguments for call to reportid |
17046 | 17091 | stack[base + 12LLU] = stack[base + 1]/*fnid*/; |
17047 | 17092 | // set stack-base & callee-address |
@@ -17049,22 +17094,22 @@ | ||
17049 | 17094 | label = 18446744073709551586LLU; // reportid |
17050 | 17095 | break; |
17051 | 17096 | } |
17052 | - case 1364LLU: // copy-back deleter (reportid to FindFn) | |
17097 | + case 1368LLU: // copy-back deleter (reportid to FindFn) | |
17053 | 17098 | { |
17054 | 17099 | fprintf(stderr, "in function FindFn: unrolling stack, copy-back (reportid to FindFn)\n"); |
17055 | 17100 | // copy mutable arguments back from call to reportid |
17056 | - label = 1345LLU; // continue to roll stack | |
17101 | + label = 1349LLU; // continue to roll stack | |
17057 | 17102 | break; |
17058 | 17103 | } |
17059 | - case 1365LLU: // return from reportid to FindFn | |
17104 | + case 1369LLU: // return from reportid to FindFn | |
17060 | 17105 | { |
17061 | 17106 | // copy mutable arguments back from call to reportid |
17062 | 17107 | fprintf(stderr, "%s", ": "); |
17063 | 17108 | fprintf(stderr, "%s", "function "); |
17064 | 17109 | // call reportid from FindFn |
17065 | - stack[base + 9LLU] = 1366LLU/*throw to this address*/; | |
17110 | + stack[base + 9LLU] = 1370LLU/*throw to this address*/; | |
17066 | 17111 | stack[base + 10LLU] = base; |
17067 | - stack[base + 11LLU] = 1367LLU; | |
17112 | + stack[base + 11LLU] = 1371LLU; | |
17068 | 17113 | // arguments for call to reportid |
17069 | 17114 | stack[base + 12LLU] = stack[base + 3]/*id*/; |
17070 | 17115 | // set stack-base & callee-address |
@@ -17072,33 +17117,33 @@ | ||
17072 | 17117 | label = 18446744073709551586LLU; // reportid |
17073 | 17118 | break; |
17074 | 17119 | } |
17075 | - case 1366LLU: // copy-back deleter (reportid to FindFn) | |
17120 | + case 1370LLU: // copy-back deleter (reportid to FindFn) | |
17076 | 17121 | { |
17077 | 17122 | fprintf(stderr, "in function FindFn: unrolling stack, copy-back (reportid to FindFn)\n"); |
17078 | 17123 | // copy mutable arguments back from call to reportid |
17079 | - label = 1345LLU; // continue to roll stack | |
17124 | + label = 1349LLU; // continue to roll stack | |
17080 | 17125 | break; |
17081 | 17126 | } |
17082 | - case 1367LLU: // return from reportid to FindFn | |
17127 | + case 1371LLU: // return from reportid to FindFn | |
17083 | 17128 | { |
17084 | 17129 | // copy mutable arguments back from call to reportid |
17085 | 17130 | fprintf(stderr, "%s", " not defined\n"); |
17086 | 17131 | exit(-1); |
17087 | - label = 1363LLU; // alternative complete | |
17132 | + label = 1367LLU; // alternative complete | |
17088 | 17133 | break; |
17089 | 17134 | } |
17090 | - case 1363LLU: // completed if-then-else | |
17135 | + case 1367LLU: // completed if-then-else | |
17091 | 17136 | { |
17092 | - label = 1369LLU; // skip deleter | |
17137 | + label = 1373LLU; // skip deleter | |
17093 | 17138 | break; |
17094 | 17139 | } |
17095 | - case 1368LLU: // deleter | |
17140 | + case 1372LLU: // deleter | |
17096 | 17141 | { |
17097 | 17142 | // throw from FindFn |
17098 | 17143 | if(!stack[base + 0]) |
17099 | 17144 | { |
17100 | 17145 | fprintf(stderr, "in function FindFn: unrolling stack, skipping already deleted/unscoped variable fndef \n"); |
17101 | - label = 1345LLU; // skip, variable already deleted/unscoped | |
17146 | + label = 1349LLU; // skip, variable already deleted/unscoped | |
17102 | 17147 | break; |
17103 | 17148 | } |
17104 | 17149 | fprintf(stderr, "in function FindFn: unrolling stack, variable fndef \n"); |
@@ -17108,7 +17153,7 @@ | ||
17108 | 17153 | newstack[0] = (uint64_t)stack; // backup stack location |
17109 | 17154 | newstack[1] = 1234567890; |
17110 | 17155 | newstack[2] = base; |
17111 | - newstack[3] = 1370LLU; | |
17156 | + newstack[3] = 1374LLU; | |
17112 | 17157 | stack = newstack; |
17113 | 17158 | // set stack-base & callee-address |
17114 | 17159 | base = 4/*deloffset*/; |
@@ -17115,16 +17160,16 @@ | ||
17115 | 17160 | label = 1273LLU; // ~fndef |
17116 | 17161 | break; |
17117 | 17162 | } |
17118 | - case 1370LLU: // return from ~fndef to FindFn | |
17163 | + case 1374LLU: // return from ~fndef to FindFn | |
17119 | 17164 | { |
17120 | 17165 | stack = (uint64_t *)stack[0]; |
17121 | 17166 | // releasing toplevel container |
17122 | 17167 | Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4)); |
17123 | 17168 | |
17124 | - label = 1345LLU; // continue unrolling stack, delete next variable | |
17169 | + label = 1349LLU; // continue unrolling stack, delete next variable | |
17125 | 17170 | break; |
17126 | 17171 | } |
17127 | - case 1369LLU: // skipped deleter | |
17172 | + case 1373LLU: // skipped deleter | |
17128 | 17173 | { |
17129 | 17174 | INIT(&stack[base + 0], &stack[base + 4]/*copy*/); |
17130 | 17175 | // return from FindFn |
@@ -17132,7 +17177,7 @@ | ||
17132 | 17177 | base = stack[base - 2]; |
17133 | 17178 | break; |
17134 | 17179 | } |
17135 | - case 1372LLU: // function existsfn failed | |
17180 | + case 1376LLU: // function existsfn failed | |
17136 | 17181 | { |
17137 | 17182 | fprintf(stderr, "function existsfn failed\n"); |
17138 | 17183 | label = stack[base - 3]; |
@@ -17139,39 +17184,39 @@ | ||
17139 | 17184 | base = stack[base - 2]; |
17140 | 17185 | break; |
17141 | 17186 | } |
17142 | - case 1371LLU: // existsfn | |
17187 | + case 1375LLU: // existsfn | |
17143 | 17188 | { |
17144 | 17189 | //#define res0 0 |
17145 | 17190 | //#define arg0 1 |
17146 | 17191 | //#define arg1 2 |
17147 | - label = 1374LLU; // skip deleter | |
17192 | + label = 1378LLU; // skip deleter | |
17148 | 17193 | break; |
17149 | 17194 | } |
17150 | - case 1373LLU: // deleter | |
17195 | + case 1377LLU: // deleter | |
17151 | 17196 | { |
17152 | 17197 | // throw from existsfn |
17153 | 17198 | if(!stack[base + 3]) |
17154 | 17199 | { |
17155 | 17200 | fprintf(stderr, "in function existsfn: unrolling stack, skipping already deleted/unscoped variable u64 \n"); |
17156 | - label = 1372LLU; // skip, variable already deleted/unscoped | |
17201 | + label = 1376LLU; // skip, variable already deleted/unscoped | |
17157 | 17202 | break; |
17158 | 17203 | } |
17159 | 17204 | fprintf(stderr, "in function existsfn: unrolling stack, variable u64 \n"); |
17160 | - label = 1372LLU; // continue unrolling stack, delete next variable | |
17205 | + label = 1376LLU; // continue unrolling stack, delete next variable | |
17161 | 17206 | break; |
17162 | 17207 | } |
17163 | - case 1374LLU: // skipped deleter | |
17208 | + case 1378LLU: // skipped deleter | |
17164 | 17209 | { |
17165 | 17210 | stack[base + 3] = 0; |
17166 | 17211 | flippedassign(stack[base + 1]/*fndefs*/, &stack[base + 4]); |
17167 | - label = 1375LLU; // start to repeat | |
17212 | + label = 1379LLU; // start to repeat | |
17168 | 17213 | break; |
17169 | 17214 | } |
17170 | - case 1375LLU: // repeat from here | |
17215 | + case 1379LLU: // repeat from here | |
17171 | 17216 | { |
17172 | 17217 | if(!stack[base + 4]) |
17173 | 17218 | { |
17174 | - label = 1376LLU; // break loop | |
17219 | + label = 1380LLU; // break loop | |
17175 | 17220 | break; |
17176 | 17221 | } |
17177 | 17222 |
@@ -17181,19 +17226,19 @@ | ||
17181 | 17226 | stack[base + 4] = (uint64_t)(((const struct listnode *)(stack[base + 4]))->next); |
17182 | 17227 | if(!stack[base + 3]/*found*/) |
17183 | 17228 | { |
17184 | - label = 1377LLU; // jump to alternative | |
17229 | + label = 1381LLU; // jump to alternative | |
17185 | 17230 | break; |
17186 | 17231 | } |
17187 | 17232 | |
17188 | 17233 | // consequent |
17189 | - label = 1378LLU; // consequent complete | |
17234 | + label = 1382LLU; // consequent complete | |
17190 | 17235 | break; |
17191 | 17236 | } |
17192 | - case 1377LLU: // alternative | |
17237 | + case 1381LLU: // alternative | |
17193 | 17238 | { |
17194 | 17239 | if(/*fndef*/0 != ((uint64_t *)(stack[base + 5]/*fndef*/))[0]) |
17195 | 17240 | { |
17196 | - label = 1380LLU; // jump to alternative | |
17241 | + label = 1384LLU; // jump to alternative | |
17197 | 17242 | break; |
17198 | 17243 | } |
17199 | 17244 |
@@ -17204,69 +17249,71 @@ | ||
17204 | 17249 | /*defid*/stack[base + 11] = ((uint64_t **)(stack[base + 5]/*fndef*/))[1][4]/*id*/; |
17205 | 17250 | /*recursive*/stack[base + 12] = ((uint64_t **)(stack[base + 5]/*fndef*/))[1][5]/*recursive*/; |
17206 | 17251 | /*fallible*/stack[base + 13] = ((uint64_t **)(stack[base + 5]/*fndef*/))[1][6]/*fallible*/; |
17252 | + /*canthrow*/stack[base + 14] = ((uint64_t **)(stack[base + 5]/*fndef*/))[1][7]/*canthrow*/; | |
17207 | 17253 | |
17208 | 17254 | // case |
17209 | - label = 1382LLU; // skip deleter | |
17255 | + label = 1386LLU; // skip deleter | |
17210 | 17256 | break; |
17211 | 17257 | } |
17212 | - case 1381LLU: // deleter | |
17258 | + case 1385LLU: // deleter | |
17213 | 17259 | { |
17214 | 17260 | // throw from existsfn |
17215 | - if(!stack[base + 14]) | |
17261 | + if(!stack[base + 15]) | |
17216 | 17262 | { |
17217 | 17263 | fprintf(stderr, "in function existsfn: unrolling stack, skipping already deleted/unscoped variable u64 \n"); |
17218 | - label = 1373LLU; // skip, variable already deleted/unscoped | |
17264 | + label = 1377LLU; // skip, variable already deleted/unscoped | |
17219 | 17265 | break; |
17220 | 17266 | } |
17221 | 17267 | fprintf(stderr, "in function existsfn: unrolling stack, variable u64 \n"); |
17222 | - label = 1373LLU; // continue unrolling stack, delete next variable | |
17268 | + label = 1377LLU; // continue unrolling stack, delete next variable | |
17223 | 17269 | break; |
17224 | 17270 | } |
17225 | - case 1382LLU: // skipped deleter | |
17271 | + case 1386LLU: // skipped deleter | |
17226 | 17272 | { |
17227 | - stack[base + 14] = 0; | |
17273 | + stack[base + 15] = 0; | |
17228 | 17274 | // call equ from existsfn |
17229 | - stack[base + 15LLU] = 1383LLU/*throw to this address*/; | |
17230 | - stack[base + 16LLU] = base; | |
17231 | - stack[base + 17LLU] = 1384LLU; | |
17275 | + stack[base + 16LLU] = 1387LLU/*throw to this address*/; | |
17276 | + stack[base + 17LLU] = base; | |
17277 | + stack[base + 18LLU] = 1388LLU; | |
17232 | 17278 | // arguments for call to equ |
17233 | - stack[base + 19LLU] = stack[base + 2]/*id*/; | |
17234 | - stack[base + 20LLU] = stack[base + 11]/*defid*/; | |
17279 | + stack[base + 20LLU] = stack[base + 2]/*id*/; | |
17280 | + stack[base + 21LLU] = stack[base + 11]/*defid*/; | |
17235 | 17281 | // set stack-base & callee-address |
17236 | - base += 18LLU; | |
17282 | + base += 19LLU; | |
17237 | 17283 | label = 18446744073709551600LLU; // equ |
17238 | 17284 | break; |
17239 | 17285 | } |
17240 | - case 1383LLU: // copy-back deleter (equ to existsfn) | |
17286 | + case 1387LLU: // copy-back deleter (equ to existsfn) | |
17241 | 17287 | { |
17242 | 17288 | fprintf(stderr, "in function existsfn: unrolling stack, copy-back (equ to existsfn)\n"); |
17243 | 17289 | // copy mutable arguments back from call to equ |
17244 | - label = 1381LLU; // continue to roll stack | |
17290 | + label = 1385LLU; // continue to roll stack | |
17245 | 17291 | break; |
17246 | 17292 | } |
17247 | - case 1384LLU: // return from equ to existsfn | |
17293 | + case 1388LLU: // return from equ to existsfn | |
17248 | 17294 | { |
17249 | 17295 | // copy mutable arguments back from call to equ |
17250 | 17296 | // copy back results provided by call to equ |
17251 | - stack[base + 14] = stack[base + 18LLU]; | |
17252 | - if(!stack[base + 14]/*isequal*/) | |
17297 | + stack[base + 15] = stack[base + 19LLU]; | |
17298 | + if(!stack[base + 15]/*isequal*/) | |
17253 | 17299 | { |
17254 | - label = 1385LLU; // jump to alternative | |
17300 | + label = 1389LLU; // jump to alternative | |
17255 | 17301 | break; |
17256 | 17302 | } |
17257 | 17303 | |
17258 | 17304 | // consequent |
17259 | 17305 | stack[base + 3]/*found*/ = 1; |
17260 | - label = 1386LLU; // consequent complete | |
17306 | + label = 1390LLU; // consequent complete | |
17261 | 17307 | break; |
17262 | 17308 | } |
17263 | - case 1385LLU: // alternative | |
17309 | + case 1389LLU: // alternative | |
17264 | 17310 | { |
17265 | - label = 1386LLU; // alternative complete | |
17311 | + label = 1390LLU; // alternative complete | |
17266 | 17312 | break; |
17267 | 17313 | } |
17268 | - case 1386LLU: // completed if-then-else | |
17314 | + case 1390LLU: // completed if-then-else | |
17269 | 17315 | { |
17316 | + ((uint64_t **)(stack[base + 5]))[1][7] = stack[base + 14]; | |
17270 | 17317 | ((uint64_t **)(stack[base + 5]))[1][6] = stack[base + 13]; |
17271 | 17318 | ((uint64_t **)(stack[base + 5]))[1][5] = stack[base + 12]; |
17272 | 17319 | ((uint64_t **)(stack[base + 5]))[1][4] = stack[base + 11]; |
@@ -17274,44 +17321,44 @@ | ||
17274 | 17321 | ((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 9]; |
17275 | 17322 | ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8]; |
17276 | 17323 | ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7]; |
17277 | - label = 1379LLU; // case complete | |
17324 | + label = 1383LLU; // case complete | |
17278 | 17325 | break; |
17279 | 17326 | } |
17280 | - case 1380LLU: // try next case | |
17327 | + case 1384LLU: // try next case | |
17281 | 17328 | { |
17282 | 17329 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
17283 | 17330 | exit(-1); |
17284 | 17331 | } |
17285 | - case 1379LLU: // completed switch | |
17332 | + case 1383LLU: // completed switch | |
17286 | 17333 | { |
17287 | - label = 1378LLU; // alternative complete | |
17334 | + label = 1382LLU; // alternative complete | |
17288 | 17335 | break; |
17289 | 17336 | } |
17290 | - case 1378LLU: // completed if-then-else | |
17337 | + case 1382LLU: // completed if-then-else | |
17291 | 17338 | { |
17292 | 17339 | ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5]; |
17293 | - label = 1375LLU; // repeat | |
17340 | + label = 1379LLU; // repeat | |
17294 | 17341 | break; |
17295 | 17342 | } |
17296 | - case 1376LLU: // loop finished | |
17343 | + case 1380LLU: // loop finished | |
17297 | 17344 | { |
17298 | - label = 1388LLU; // skip deleter | |
17345 | + label = 1392LLU; // skip deleter | |
17299 | 17346 | break; |
17300 | 17347 | } |
17301 | - case 1387LLU: // deleter | |
17348 | + case 1391LLU: // deleter | |
17302 | 17349 | { |
17303 | 17350 | // throw from existsfn |
17304 | 17351 | if(!stack[base + 0]) |
17305 | 17352 | { |
17306 | 17353 | fprintf(stderr, "in function existsfn: unrolling stack, skipping already deleted/unscoped variable u64 \n"); |
17307 | - label = 1373LLU; // skip, variable already deleted/unscoped | |
17354 | + label = 1377LLU; // skip, variable already deleted/unscoped | |
17308 | 17355 | break; |
17309 | 17356 | } |
17310 | 17357 | fprintf(stderr, "in function existsfn: unrolling stack, variable u64 \n"); |
17311 | - label = 1373LLU; // continue unrolling stack, delete next variable | |
17358 | + label = 1377LLU; // continue unrolling stack, delete next variable | |
17312 | 17359 | break; |
17313 | 17360 | } |
17314 | - case 1388LLU: // skipped deleter | |
17361 | + case 1392LLU: // skipped deleter | |
17315 | 17362 | { |
17316 | 17363 | stack[base + 0] = stack[base + 3]/*found*/; |
17317 | 17364 | // return from existsfn |
@@ -17319,7 +17366,7 @@ | ||
17319 | 17366 | base = stack[base - 2]; |
17320 | 17367 | break; |
17321 | 17368 | } |
17322 | - case 1389LLU: // ~idfndef | |
17369 | + case 1393LLU: // ~idfndef | |
17323 | 17370 | { |
17324 | 17371 | if(stack[base + 0]/*variant-nr*/ >= 1) |
17325 | 17372 | { |
@@ -17326,10 +17373,10 @@ | ||
17326 | 17373 | fprintf(stderr, "in ~idfndef: unknown variant-nr %d\n", (int)stack[base + 0]/*variant-nr*/); |
17327 | 17374 | exit(-1); |
17328 | 17375 | } |
17329 | - label = 1389LLU + 1LLU + stack[base + 0]/*variant-nr*/; | |
17376 | + label = 1393LLU + 1LLU + stack[base + 0]/*variant-nr*/; | |
17330 | 17377 | break; |
17331 | 17378 | } |
17332 | - case 1389LLU + 1LLU + 0LLU: // ~idfndef.idfndef | |
17379 | + case 1393LLU + 1LLU + 0LLU: // ~idfndef.idfndef | |
17333 | 17380 | { |
17334 | 17381 | // release element id |
17335 | 17382 | // release element fndef |
@@ -17340,7 +17387,7 @@ | ||
17340 | 17387 | newstack[0] = (uint64_t)stack; // backup stack location |
17341 | 17388 | newstack[1] = 1234567890; |
17342 | 17389 | newstack[2] = base; |
17343 | - newstack[3] = 1391LLU; | |
17390 | + newstack[3] = 1395LLU; | |
17344 | 17391 | stack = newstack; |
17345 | 17392 | // set stack-base & callee-address |
17346 | 17393 | base = 4/*deloffset*/; |
@@ -17347,7 +17394,7 @@ | ||
17347 | 17394 | label = 1273LLU; // ~fndef |
17348 | 17395 | break; |
17349 | 17396 | } |
17350 | - case 1391LLU: // return from ~fndef to idfndef | |
17397 | + case 1395LLU: // return from ~fndef to idfndef | |
17351 | 17398 | { |
17352 | 17399 | stack = (uint64_t *)stack[0]; |
17353 | 17400 | // releasing toplevel container |
@@ -17359,7 +17406,7 @@ | ||
17359 | 17406 | base = stack[base - 2]; |
17360 | 17407 | break; |
17361 | 17408 | } |
17362 | - case 1393LLU: // function existsidfn failed | |
17409 | + case 1397LLU: // function existsidfn failed | |
17363 | 17410 | { |
17364 | 17411 | fprintf(stderr, "function existsidfn failed\n"); |
17365 | 17412 | label = stack[base - 3]; |
@@ -17366,39 +17413,39 @@ | ||
17366 | 17413 | base = stack[base - 2]; |
17367 | 17414 | break; |
17368 | 17415 | } |
17369 | - case 1392LLU: // existsidfn | |
17416 | + case 1396LLU: // existsidfn | |
17370 | 17417 | { |
17371 | 17418 | //#define res0 0 |
17372 | 17419 | //#define arg0 1 |
17373 | 17420 | //#define arg1 2 |
17374 | - label = 1395LLU; // skip deleter | |
17421 | + label = 1399LLU; // skip deleter | |
17375 | 17422 | break; |
17376 | 17423 | } |
17377 | - case 1394LLU: // deleter | |
17424 | + case 1398LLU: // deleter | |
17378 | 17425 | { |
17379 | 17426 | // throw from existsidfn |
17380 | 17427 | if(!stack[base + 3]) |
17381 | 17428 | { |
17382 | 17429 | fprintf(stderr, "in function existsidfn: unrolling stack, skipping already deleted/unscoped variable u64 \n"); |
17383 | - label = 1393LLU; // skip, variable already deleted/unscoped | |
17430 | + label = 1397LLU; // skip, variable already deleted/unscoped | |
17384 | 17431 | break; |
17385 | 17432 | } |
17386 | 17433 | fprintf(stderr, "in function existsidfn: unrolling stack, variable u64 \n"); |
17387 | - label = 1393LLU; // continue unrolling stack, delete next variable | |
17434 | + label = 1397LLU; // continue unrolling stack, delete next variable | |
17388 | 17435 | break; |
17389 | 17436 | } |
17390 | - case 1395LLU: // skipped deleter | |
17437 | + case 1399LLU: // skipped deleter | |
17391 | 17438 | { |
17392 | 17439 | stack[base + 3] = 0; |
17393 | 17440 | flippedassign(stack[base + 1]/*idfndefs*/, &stack[base + 4]); |
17394 | - label = 1396LLU; // start to repeat | |
17441 | + label = 1400LLU; // start to repeat | |
17395 | 17442 | break; |
17396 | 17443 | } |
17397 | - case 1396LLU: // repeat from here | |
17444 | + case 1400LLU: // repeat from here | |
17398 | 17445 | { |
17399 | 17446 | if(!stack[base + 4]) |
17400 | 17447 | { |
17401 | - label = 1397LLU; // break loop | |
17448 | + label = 1401LLU; // break loop | |
17402 | 17449 | break; |
17403 | 17450 | } |
17404 | 17451 |
@@ -17408,19 +17455,19 @@ | ||
17408 | 17455 | stack[base + 4] = (uint64_t)(((const struct listnode *)(stack[base + 4]))->next); |
17409 | 17456 | if(!stack[base + 3]/*found*/) |
17410 | 17457 | { |
17411 | - label = 1398LLU; // jump to alternative | |
17458 | + label = 1402LLU; // jump to alternative | |
17412 | 17459 | break; |
17413 | 17460 | } |
17414 | 17461 | |
17415 | 17462 | // consequent |
17416 | - label = 1399LLU; // consequent complete | |
17463 | + label = 1403LLU; // consequent complete | |
17417 | 17464 | break; |
17418 | 17465 | } |
17419 | - case 1398LLU: // alternative | |
17466 | + case 1402LLU: // alternative | |
17420 | 17467 | { |
17421 | 17468 | if(/*idfndef*/0 != ((uint64_t *)(stack[base + 5]/*idfndef*/))[0]) |
17422 | 17469 | { |
17423 | - label = 1401LLU; // jump to alternative | |
17470 | + label = 1405LLU; // jump to alternative | |
17424 | 17471 | break; |
17425 | 17472 | } |
17426 | 17473 |
@@ -17428,29 +17475,29 @@ | ||
17428 | 17475 | /*fndef*/stack[base + 8] = ((uint64_t **)(stack[base + 5]/*idfndef*/))[1][1]/*fndef*/; |
17429 | 17476 | |
17430 | 17477 | // case |
17431 | - label = 1403LLU; // skip deleter | |
17478 | + label = 1407LLU; // skip deleter | |
17432 | 17479 | break; |
17433 | 17480 | } |
17434 | - case 1402LLU: // deleter | |
17481 | + case 1406LLU: // deleter | |
17435 | 17482 | { |
17436 | 17483 | // throw from existsidfn |
17437 | 17484 | if(!stack[base + 9]) |
17438 | 17485 | { |
17439 | 17486 | fprintf(stderr, "in function existsidfn: unrolling stack, skipping already deleted/unscoped variable u64 \n"); |
17440 | - label = 1394LLU; // skip, variable already deleted/unscoped | |
17487 | + label = 1398LLU; // skip, variable already deleted/unscoped | |
17441 | 17488 | break; |
17442 | 17489 | } |
17443 | 17490 | fprintf(stderr, "in function existsidfn: unrolling stack, variable u64 \n"); |
17444 | - label = 1394LLU; // continue unrolling stack, delete next variable | |
17491 | + label = 1398LLU; // continue unrolling stack, delete next variable | |
17445 | 17492 | break; |
17446 | 17493 | } |
17447 | - case 1403LLU: // skipped deleter | |
17494 | + case 1407LLU: // skipped deleter | |
17448 | 17495 | { |
17449 | 17496 | stack[base + 9] = 0; |
17450 | 17497 | // call equ from existsidfn |
17451 | - stack[base + 10LLU] = 1404LLU/*throw to this address*/; | |
17498 | + stack[base + 10LLU] = 1408LLU/*throw to this address*/; | |
17452 | 17499 | stack[base + 11LLU] = base; |
17453 | - stack[base + 12LLU] = 1405LLU; | |
17500 | + stack[base + 12LLU] = 1409LLU; | |
17454 | 17501 | // arguments for call to equ |
17455 | 17502 | stack[base + 14LLU] = stack[base + 7]/*id*/; |
17456 | 17503 | stack[base + 15LLU] = stack[base + 2]/*searchid*/; |
@@ -17459,14 +17506,14 @@ | ||
17459 | 17506 | label = 18446744073709551600LLU; // equ |
17460 | 17507 | break; |
17461 | 17508 | } |
17462 | - case 1404LLU: // copy-back deleter (equ to existsidfn) | |
17509 | + case 1408LLU: // copy-back deleter (equ to existsidfn) | |
17463 | 17510 | { |
17464 | 17511 | fprintf(stderr, "in function existsidfn: unrolling stack, copy-back (equ to existsidfn)\n"); |
17465 | 17512 | // copy mutable arguments back from call to equ |
17466 | - label = 1402LLU; // continue to roll stack | |
17513 | + label = 1406LLU; // continue to roll stack | |
17467 | 17514 | break; |
17468 | 17515 | } |
17469 | - case 1405LLU: // return from equ to existsidfn | |
17516 | + case 1409LLU: // return from equ to existsidfn | |
17470 | 17517 | { |
17471 | 17518 | // copy mutable arguments back from call to equ |
17472 | 17519 | // copy back results provided by call to equ |
@@ -17473,62 +17520,62 @@ | ||
17473 | 17520 | stack[base + 9] = stack[base + 13LLU]; |
17474 | 17521 | if(!stack[base + 9]/*isequal*/) |
17475 | 17522 | { |
17476 | - label = 1406LLU; // jump to alternative | |
17523 | + label = 1410LLU; // jump to alternative | |
17477 | 17524 | break; |
17478 | 17525 | } |
17479 | 17526 | |
17480 | 17527 | // consequent |
17481 | 17528 | stack[base + 3]/*found*/ = 1; |
17482 | - label = 1407LLU; // consequent complete | |
17529 | + label = 1411LLU; // consequent complete | |
17483 | 17530 | break; |
17484 | 17531 | } |
17485 | - case 1406LLU: // alternative | |
17532 | + case 1410LLU: // alternative | |
17486 | 17533 | { |
17487 | - label = 1407LLU; // alternative complete | |
17534 | + label = 1411LLU; // alternative complete | |
17488 | 17535 | break; |
17489 | 17536 | } |
17490 | - case 1407LLU: // completed if-then-else | |
17537 | + case 1411LLU: // completed if-then-else | |
17491 | 17538 | { |
17492 | 17539 | ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8]; |
17493 | 17540 | ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7]; |
17494 | - label = 1400LLU; // case complete | |
17541 | + label = 1404LLU; // case complete | |
17495 | 17542 | break; |
17496 | 17543 | } |
17497 | - case 1401LLU: // try next case | |
17544 | + case 1405LLU: // try next case | |
17498 | 17545 | { |
17499 | 17546 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
17500 | 17547 | exit(-1); |
17501 | 17548 | } |
17502 | - case 1400LLU: // completed switch | |
17549 | + case 1404LLU: // completed switch | |
17503 | 17550 | { |
17504 | - label = 1399LLU; // alternative complete | |
17551 | + label = 1403LLU; // alternative complete | |
17505 | 17552 | break; |
17506 | 17553 | } |
17507 | - case 1399LLU: // completed if-then-else | |
17554 | + case 1403LLU: // completed if-then-else | |
17508 | 17555 | { |
17509 | 17556 | ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5]; |
17510 | - label = 1396LLU; // repeat | |
17557 | + label = 1400LLU; // repeat | |
17511 | 17558 | break; |
17512 | 17559 | } |
17513 | - case 1397LLU: // loop finished | |
17560 | + case 1401LLU: // loop finished | |
17514 | 17561 | { |
17515 | - label = 1409LLU; // skip deleter | |
17562 | + label = 1413LLU; // skip deleter | |
17516 | 17563 | break; |
17517 | 17564 | } |
17518 | - case 1408LLU: // deleter | |
17565 | + case 1412LLU: // deleter | |
17519 | 17566 | { |
17520 | 17567 | // throw from existsidfn |
17521 | 17568 | if(!stack[base + 0]) |
17522 | 17569 | { |
17523 | 17570 | fprintf(stderr, "in function existsidfn: unrolling stack, skipping already deleted/unscoped variable u64 \n"); |
17524 | - label = 1394LLU; // skip, variable already deleted/unscoped | |
17571 | + label = 1398LLU; // skip, variable already deleted/unscoped | |
17525 | 17572 | break; |
17526 | 17573 | } |
17527 | 17574 | fprintf(stderr, "in function existsidfn: unrolling stack, variable u64 \n"); |
17528 | - label = 1394LLU; // continue unrolling stack, delete next variable | |
17575 | + label = 1398LLU; // continue unrolling stack, delete next variable | |
17529 | 17576 | break; |
17530 | 17577 | } |
17531 | - case 1409LLU: // skipped deleter | |
17578 | + case 1413LLU: // skipped deleter | |
17532 | 17579 | { |
17533 | 17580 | stack[base + 0] = stack[base + 3]/*found*/; |
17534 | 17581 | // return from existsidfn |
@@ -17536,7 +17583,7 @@ | ||
17536 | 17583 | base = stack[base - 2]; |
17537 | 17584 | break; |
17538 | 17585 | } |
17539 | - case 1411LLU: // function emitcase failed | |
17586 | + case 1415LLU: // function emitcase failed | |
17540 | 17587 | { |
17541 | 17588 | fprintf(stderr, "function emitcase failed\n"); |
17542 | 17589 | label = stack[base - 3]; |
@@ -17543,15 +17590,15 @@ | ||
17543 | 17590 | base = stack[base - 2]; |
17544 | 17591 | break; |
17545 | 17592 | } |
17546 | - case 1410LLU: // emitcase | |
17593 | + case 1414LLU: // emitcase | |
17547 | 17594 | { |
17548 | 17595 | //#define arg0 0 |
17549 | 17596 | //#define arg1 1 |
17550 | 17597 | printf("%s", "\n case -"); |
17551 | 17598 | // call printnr from emitcase |
17552 | - stack[base + 2LLU] = 1412LLU/*throw to this address*/; | |
17599 | + stack[base + 2LLU] = 1416LLU/*throw to this address*/; | |
17553 | 17600 | stack[base + 3LLU] = base; |
17554 | - stack[base + 4LLU] = 1413LLU; | |
17601 | + stack[base + 4LLU] = 1417LLU; | |
17555 | 17602 | // arguments for call to printnr |
17556 | 17603 | stack[base + 5LLU] = stack[base + 0]/*label*/; |
17557 | 17604 | // set stack-base & callee-address |
@@ -17559,21 +17606,21 @@ | ||
17559 | 17606 | label = 18446744073709551590LLU; // printnr |
17560 | 17607 | break; |
17561 | 17608 | } |
17562 | - case 1412LLU: // copy-back deleter (printnr to emitcase) | |
17609 | + case 1416LLU: // copy-back deleter (printnr to emitcase) | |
17563 | 17610 | { |
17564 | 17611 | fprintf(stderr, "in function emitcase: unrolling stack, copy-back (printnr to emitcase)\n"); |
17565 | 17612 | // copy mutable arguments back from call to printnr |
17566 | - label = 1411LLU; // continue to roll stack | |
17613 | + label = 1415LLU; // continue to roll stack | |
17567 | 17614 | break; |
17568 | 17615 | } |
17569 | - case 1413LLU: // return from printnr to emitcase | |
17616 | + case 1417LLU: // return from printnr to emitcase | |
17570 | 17617 | { |
17571 | 17618 | // copy mutable arguments back from call to printnr |
17572 | 17619 | printf("%s", ": // "); |
17573 | 17620 | // call printid from emitcase |
17574 | - stack[base + 2LLU] = 1414LLU/*throw to this address*/; | |
17621 | + stack[base + 2LLU] = 1418LLU/*throw to this address*/; | |
17575 | 17622 | stack[base + 3LLU] = base; |
17576 | - stack[base + 4LLU] = 1415LLU; | |
17623 | + stack[base + 4LLU] = 1419LLU; | |
17577 | 17624 | // arguments for call to printid |
17578 | 17625 | stack[base + 5LLU] = stack[base + 1]/*defid*/; |
17579 | 17626 | // set stack-base & callee-address |
@@ -17581,14 +17628,14 @@ | ||
17581 | 17628 | label = 18446744073709551587LLU; // printid |
17582 | 17629 | break; |
17583 | 17630 | } |
17584 | - case 1414LLU: // copy-back deleter (printid to emitcase) | |
17631 | + case 1418LLU: // copy-back deleter (printid to emitcase) | |
17585 | 17632 | { |
17586 | 17633 | fprintf(stderr, "in function emitcase: unrolling stack, copy-back (printid to emitcase)\n"); |
17587 | 17634 | // copy mutable arguments back from call to printid |
17588 | - label = 1411LLU; // continue to roll stack | |
17635 | + label = 1415LLU; // continue to roll stack | |
17589 | 17636 | break; |
17590 | 17637 | } |
17591 | - case 1415LLU: // return from printid to emitcase | |
17638 | + case 1419LLU: // return from printid to emitcase | |
17592 | 17639 | { |
17593 | 17640 | // copy mutable arguments back from call to printid |
17594 | 17641 | printf("%s", "\n {"); |
@@ -17597,7 +17644,7 @@ | ||
17597 | 17644 | base = stack[base - 2]; |
17598 | 17645 | break; |
17599 | 17646 | } |
17600 | - case 1417LLU: // function emitreturn failed | |
17647 | + case 1421LLU: // function emitreturn failed | |
17601 | 17648 | { |
17602 | 17649 | fprintf(stderr, "function emitreturn failed\n"); |
17603 | 17650 | label = stack[base - 3]; |
@@ -17604,7 +17651,7 @@ | ||
17604 | 17651 | base = stack[base - 2]; |
17605 | 17652 | break; |
17606 | 17653 | } |
17607 | - case 1416LLU: // emitreturn | |
17654 | + case 1420LLU: // emitreturn | |
17608 | 17655 | { |
17609 | 17656 | printf("%s", "\n"); |
17610 | 17657 | printf("%s", "\n label = stack[base - 1];"); |
@@ -17616,7 +17663,7 @@ | ||
17616 | 17663 | base = stack[base - 2]; |
17617 | 17664 | break; |
17618 | 17665 | } |
17619 | - case 1419LLU: // function isparam failed | |
17666 | + case 1423LLU: // function isparam failed | |
17620 | 17667 | { |
17621 | 17668 | fprintf(stderr, "function isparam failed\n"); |
17622 | 17669 | label = stack[base - 3]; |
@@ -17623,7 +17670,7 @@ | ||
17623 | 17670 | base = stack[base - 2]; |
17624 | 17671 | break; |
17625 | 17672 | } |
17626 | - case 1418LLU: // isparam | |
17673 | + case 1422LLU: // isparam | |
17627 | 17674 | { |
17628 | 17675 | //#define res0 0 |
17629 | 17676 | //#define arg0 1 |
@@ -17630,9 +17677,9 @@ | ||
17630 | 17677 | //#define arg1 2 |
17631 | 17678 | //#define arg2 3 |
17632 | 17679 | // call add from isparam |
17633 | - stack[base + 5LLU] = 1420LLU/*throw to this address*/; | |
17680 | + stack[base + 5LLU] = 1424LLU/*throw to this address*/; | |
17634 | 17681 | stack[base + 6LLU] = base; |
17635 | - stack[base + 7LLU] = 1421LLU; | |
17682 | + stack[base + 7LLU] = 1425LLU; | |
17636 | 17683 | // arguments for call to add |
17637 | 17684 | stack[base + 9LLU] = stack[base + 1]/*rescount*/; |
17638 | 17685 | stack[base + 10LLU] = stack[base + 2]/*argcount*/; |
@@ -17641,22 +17688,22 @@ | ||
17641 | 17688 | label = 18446744073709551605LLU; // add |
17642 | 17689 | break; |
17643 | 17690 | } |
17644 | - case 1420LLU: // copy-back deleter (add to isparam) | |
17691 | + case 1424LLU: // copy-back deleter (add to isparam) | |
17645 | 17692 | { |
17646 | 17693 | fprintf(stderr, "in function isparam: unrolling stack, copy-back (add to isparam)\n"); |
17647 | 17694 | // copy mutable arguments back from call to add |
17648 | - label = 1419LLU; // continue to roll stack | |
17695 | + label = 1423LLU; // continue to roll stack | |
17649 | 17696 | break; |
17650 | 17697 | } |
17651 | - case 1421LLU: // return from add to isparam | |
17698 | + case 1425LLU: // return from add to isparam | |
17652 | 17699 | { |
17653 | 17700 | // copy mutable arguments back from call to add |
17654 | 17701 | // copy back results provided by call to add |
17655 | 17702 | stack[base + 4] = stack[base + 8LLU]; |
17656 | 17703 | // call lss from isparam |
17657 | - stack[base + 5LLU] = 1422LLU/*throw to this address*/; | |
17704 | + stack[base + 5LLU] = 1426LLU/*throw to this address*/; | |
17658 | 17705 | stack[base + 6LLU] = base; |
17659 | - stack[base + 7LLU] = 1423LLU; | |
17706 | + stack[base + 7LLU] = 1427LLU; | |
17660 | 17707 | // arguments for call to lss |
17661 | 17708 | stack[base + 9LLU] = stack[base + 3]/*index*/; |
17662 | 17709 | stack[base + 10LLU] = stack[base + 4]/*varbase*/; |
@@ -17665,14 +17712,14 @@ | ||
17665 | 17712 | label = 18446744073709551597LLU; // lss |
17666 | 17713 | break; |
17667 | 17714 | } |
17668 | - case 1422LLU: // copy-back deleter (lss to isparam) | |
17715 | + case 1426LLU: // copy-back deleter (lss to isparam) | |
17669 | 17716 | { |
17670 | 17717 | fprintf(stderr, "in function isparam: unrolling stack, copy-back (lss to isparam)\n"); |
17671 | 17718 | // copy mutable arguments back from call to lss |
17672 | - label = 1419LLU; // continue to roll stack | |
17719 | + label = 1423LLU; // continue to roll stack | |
17673 | 17720 | break; |
17674 | 17721 | } |
17675 | - case 1423LLU: // return from lss to isparam | |
17722 | + case 1427LLU: // return from lss to isparam | |
17676 | 17723 | { |
17677 | 17724 | // copy mutable arguments back from call to lss |
17678 | 17725 | // copy back results provided by call to lss |
@@ -17682,7 +17729,7 @@ | ||
17682 | 17729 | base = stack[base - 2]; |
17683 | 17730 | break; |
17684 | 17731 | } |
17685 | - case 1425LLU: // function register failed | |
17732 | + case 1429LLU: // function register failed | |
17686 | 17733 | { |
17687 | 17734 | fprintf(stderr, "function register failed\n"); |
17688 | 17735 | label = stack[base - 3]; |
@@ -17689,7 +17736,7 @@ | ||
17689 | 17736 | base = stack[base - 2]; |
17690 | 17737 | break; |
17691 | 17738 | } |
17692 | - case 1424LLU: // register | |
17739 | + case 1428LLU: // register | |
17693 | 17740 | { |
17694 | 17741 | //#define arg0 0 |
17695 | 17742 | //#define arg1 1 |
@@ -17699,47 +17746,47 @@ | ||
17699 | 17746 | //#define arg5 5 |
17700 | 17747 | //#define arg6 6 |
17701 | 17748 | // call emitreturn from register |
17702 | - stack[base + 7LLU] = 1426LLU/*throw to this address*/; | |
17749 | + stack[base + 7LLU] = 1430LLU/*throw to this address*/; | |
17703 | 17750 | stack[base + 8LLU] = base; |
17704 | - stack[base + 9LLU] = 1427LLU; | |
17751 | + stack[base + 9LLU] = 1431LLU; | |
17705 | 17752 | // arguments for call to emitreturn |
17706 | 17753 | // set stack-base & callee-address |
17707 | 17754 | base += 10LLU; |
17708 | - label = 1416LLU; // emitreturn | |
17755 | + label = 1420LLU; // emitreturn | |
17709 | 17756 | break; |
17710 | 17757 | } |
17711 | - case 1426LLU: // copy-back deleter (emitreturn to register) | |
17758 | + case 1430LLU: // copy-back deleter (emitreturn to register) | |
17712 | 17759 | { |
17713 | 17760 | fprintf(stderr, "in function register: unrolling stack, copy-back (emitreturn to register)\n"); |
17714 | 17761 | // copy mutable arguments back from call to emitreturn |
17715 | - label = 1425LLU; // continue to roll stack | |
17762 | + label = 1429LLU; // continue to roll stack | |
17716 | 17763 | break; |
17717 | 17764 | } |
17718 | - case 1427LLU: // return from emitreturn to register | |
17765 | + case 1431LLU: // return from emitreturn to register | |
17719 | 17766 | { |
17720 | 17767 | // copy mutable arguments back from call to emitreturn |
17721 | - label = 1429LLU; // skip deleter | |
17768 | + label = 1433LLU; // skip deleter | |
17722 | 17769 | break; |
17723 | 17770 | } |
17724 | - case 1428LLU: // deleter | |
17771 | + case 1432LLU: // deleter | |
17725 | 17772 | { |
17726 | 17773 | // throw from register |
17727 | 17774 | if(!stack[base + 7]) |
17728 | 17775 | { |
17729 | 17776 | fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable [result] \n"); |
17730 | - label = 1425LLU; // skip, variable already deleted/unscoped | |
17777 | + label = 1429LLU; // skip, variable already deleted/unscoped | |
17731 | 17778 | break; |
17732 | 17779 | } |
17733 | 17780 | fprintf(stderr, "in function register: unrolling stack, variable [result] \n"); |
17734 | 17781 | // delete list |
17735 | - label = 1430LLU; // start to repeat | |
17782 | + label = 1434LLU; // start to repeat | |
17736 | 17783 | break; |
17737 | 17784 | } |
17738 | - case 1430LLU: // repeat from here | |
17785 | + case 1434LLU: // repeat from here | |
17739 | 17786 | { |
17740 | 17787 | if(!stack[base + 7]) |
17741 | 17788 | { |
17742 | - label = 1431LLU; // break loop | |
17789 | + label = 1435LLU; // break loop | |
17743 | 17790 | break; |
17744 | 17791 | } |
17745 | 17792 |
@@ -17750,7 +17797,7 @@ | ||
17750 | 17797 | newstack[0] = (uint64_t)stack; // backup stack location |
17751 | 17798 | newstack[1] = 1234567890; |
17752 | 17799 | newstack[2] = base; |
17753 | - newstack[3] = 1432LLU; | |
17800 | + newstack[3] = 1436LLU; | |
17754 | 17801 | stack = newstack; |
17755 | 17802 | // set stack-base & callee-address |
17756 | 17803 | base = 4/*deloffset*/; |
@@ -17757,7 +17804,7 @@ | ||
17757 | 17804 | label = 382LLU; // ~result |
17758 | 17805 | break; |
17759 | 17806 | } |
17760 | - case 1432LLU: // return from ~result to register | |
17807 | + case 1436LLU: // return from ~result to register | |
17761 | 17808 | { |
17762 | 17809 | stack = (uint64_t *)stack[0]; |
17763 | 17810 | // releasing toplevel container |
@@ -17768,35 +17815,35 @@ | ||
17768 | 17815 | stack[base + 7] = (uint64_t)list->next; |
17769 | 17816 | Free(1, sizeof(struct listnode), list); |
17770 | 17817 | } |
17771 | - label = 1430LLU; // repeat | |
17818 | + label = 1434LLU; // repeat | |
17772 | 17819 | break; |
17773 | 17820 | } |
17774 | - case 1431LLU: // loop finished | |
17821 | + case 1435LLU: // loop finished | |
17775 | 17822 | { |
17776 | - label = 1425LLU; // continue unrolling stack, delete next variable | |
17823 | + label = 1429LLU; // continue unrolling stack, delete next variable | |
17777 | 17824 | break; |
17778 | 17825 | } |
17779 | - case 1429LLU: // skipped deleter | |
17826 | + case 1433LLU: // skipped deleter | |
17780 | 17827 | { |
17781 | 17828 | stack[base + 7] = 0; |
17782 | 17829 | stack[base + 8] = stack[base + 0]/*rescount*/; |
17783 | 17830 | |
17784 | - label = 1433LLU; // start to repeat | |
17831 | + label = 1437LLU; // start to repeat | |
17785 | 17832 | break; |
17786 | 17833 | } |
17787 | - case 1433LLU: // repeat from here | |
17834 | + case 1437LLU: // repeat from here | |
17788 | 17835 | { |
17789 | 17836 | if(!stack[base + 8]--) |
17790 | 17837 | { |
17791 | - label = 1434LLU; // break loop | |
17838 | + label = 1438LLU; // break loop | |
17792 | 17839 | break; |
17793 | 17840 | } |
17794 | 17841 | |
17795 | 17842 | // loop body |
17796 | 17843 | // call mktypename from register |
17797 | - stack[base + 10LLU] = 1435LLU/*throw to this address*/; | |
17844 | + stack[base + 10LLU] = 1439LLU/*throw to this address*/; | |
17798 | 17845 | stack[base + 11LLU] = base; |
17799 | - stack[base + 12LLU] = 1436LLU; | |
17846 | + stack[base + 12LLU] = 1440LLU; | |
17800 | 17847 | // arguments for call to mktypename |
17801 | 17848 | stack[base + 14LLU] = 881834713755418624LLU; |
17802 | 17849 | // set stack-base & callee-address |
@@ -17804,47 +17851,47 @@ | ||
17804 | 17851 | label = 299LLU; // mktypename |
17805 | 17852 | break; |
17806 | 17853 | } |
17807 | - case 1435LLU: // copy-back deleter (mktypename to register) | |
17854 | + case 1439LLU: // copy-back deleter (mktypename to register) | |
17808 | 17855 | { |
17809 | 17856 | fprintf(stderr, "in function register: unrolling stack, copy-back (mktypename to register)\n"); |
17810 | 17857 | // copy mutable arguments back from call to mktypename |
17811 | - label = 1428LLU; // continue to roll stack | |
17858 | + label = 1432LLU; // continue to roll stack | |
17812 | 17859 | break; |
17813 | 17860 | } |
17814 | - case 1436LLU: // return from mktypename to register | |
17861 | + case 1440LLU: // return from mktypename to register | |
17815 | 17862 | { |
17816 | 17863 | // copy mutable arguments back from call to mktypename |
17817 | 17864 | // copy back results provided by call to mktypename |
17818 | 17865 | stack[base + 9] = stack[base + 13LLU]; |
17819 | - label = 1438LLU; // skip deleter | |
17866 | + label = 1442LLU; // skip deleter | |
17820 | 17867 | break; |
17821 | 17868 | } |
17822 | - case 1437LLU: // deleter | |
17869 | + case 1441LLU: // deleter | |
17823 | 17870 | { |
17824 | 17871 | // throw from register |
17825 | 17872 | if(!stack[base + 10]) |
17826 | 17873 | { |
17827 | 17874 | fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable u64 \n"); |
17828 | - label = 1428LLU; // skip, variable already deleted/unscoped | |
17875 | + label = 1432LLU; // skip, variable already deleted/unscoped | |
17829 | 17876 | break; |
17830 | 17877 | } |
17831 | 17878 | fprintf(stderr, "in function register: unrolling stack, variable u64 \n"); |
17832 | - label = 1428LLU; // continue unrolling stack, delete next variable | |
17879 | + label = 1432LLU; // continue unrolling stack, delete next variable | |
17833 | 17880 | break; |
17834 | 17881 | } |
17835 | - case 1438LLU: // skipped deleter | |
17882 | + case 1442LLU: // skipped deleter | |
17836 | 17883 | { |
17837 | 17884 | stack[base + 10] = 1; |
17838 | - label = 1440LLU; // skip deleter | |
17885 | + label = 1444LLU; // skip deleter | |
17839 | 17886 | break; |
17840 | 17887 | } |
17841 | - case 1439LLU: // deleter | |
17888 | + case 1443LLU: // deleter | |
17842 | 17889 | { |
17843 | 17890 | // throw from register |
17844 | 17891 | if(!stack[base + 11]) |
17845 | 17892 | { |
17846 | 17893 | fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable result \n"); |
17847 | - label = 1437LLU; // skip, variable already deleted/unscoped | |
17894 | + label = 1441LLU; // skip, variable already deleted/unscoped | |
17848 | 17895 | break; |
17849 | 17896 | } |
17850 | 17897 | fprintf(stderr, "in function register: unrolling stack, variable result \n"); |
@@ -17854,7 +17901,7 @@ | ||
17854 | 17901 | newstack[0] = (uint64_t)stack; // backup stack location |
17855 | 17902 | newstack[1] = 1234567890; |
17856 | 17903 | newstack[2] = base; |
17857 | - newstack[3] = 1441LLU; | |
17904 | + newstack[3] = 1445LLU; | |
17858 | 17905 | stack = newstack; |
17859 | 17906 | // set stack-base & callee-address |
17860 | 17907 | base = 4/*deloffset*/; |
@@ -17861,21 +17908,21 @@ | ||
17861 | 17908 | label = 382LLU; // ~result |
17862 | 17909 | break; |
17863 | 17910 | } |
17864 | - case 1441LLU: // return from ~result to register | |
17911 | + case 1445LLU: // return from ~result to register | |
17865 | 17912 | { |
17866 | 17913 | stack = (uint64_t *)stack[0]; |
17867 | 17914 | // releasing toplevel container |
17868 | 17915 | Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 11] - sizeof(uint64_t) * 4)); |
17869 | 17916 | |
17870 | - label = 1437LLU; // continue unrolling stack, delete next variable | |
17917 | + label = 1441LLU; // continue unrolling stack, delete next variable | |
17871 | 17918 | break; |
17872 | 17919 | } |
17873 | - case 1440LLU: // skipped deleter | |
17920 | + case 1444LLU: // skipped deleter | |
17874 | 17921 | { |
17875 | 17922 | // construct result.result |
17876 | 17923 | if(!(stack[base + 11] = construct(2))) |
17877 | 17924 | { |
17878 | - label = 1437LLU; // throw: begin to unroll stack | |
17925 | + label = 1441LLU; // throw: begin to unroll stack | |
17879 | 17926 | break; |
17880 | 17927 | } |
17881 | 17928 |
@@ -17894,33 +17941,33 @@ | ||
17894 | 17941 | stack[base + 7]/*fnrestypes*/ = (uint64_t)list; |
17895 | 17942 | MOVE(&list->data, &stack[base + 11]/*result*/); |
17896 | 17943 | } |
17897 | - label = 1433LLU; // repeat | |
17944 | + label = 1437LLU; // repeat | |
17898 | 17945 | break; |
17899 | 17946 | } |
17900 | - case 1434LLU: // loop finished | |
17947 | + case 1438LLU: // loop finished | |
17901 | 17948 | { |
17902 | - label = 1443LLU; // skip deleter | |
17949 | + label = 1447LLU; // skip deleter | |
17903 | 17950 | break; |
17904 | 17951 | } |
17905 | - case 1442LLU: // deleter | |
17952 | + case 1446LLU: // deleter | |
17906 | 17953 | { |
17907 | 17954 | // throw from register |
17908 | 17955 | if(!stack[base + 9]) |
17909 | 17956 | { |
17910 | 17957 | fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable [param] \n"); |
17911 | - label = 1428LLU; // skip, variable already deleted/unscoped | |
17958 | + label = 1432LLU; // skip, variable already deleted/unscoped | |
17912 | 17959 | break; |
17913 | 17960 | } |
17914 | 17961 | fprintf(stderr, "in function register: unrolling stack, variable [param] \n"); |
17915 | 17962 | // delete list |
17916 | - label = 1444LLU; // start to repeat | |
17963 | + label = 1448LLU; // start to repeat | |
17917 | 17964 | break; |
17918 | 17965 | } |
17919 | - case 1444LLU: // repeat from here | |
17966 | + case 1448LLU: // repeat from here | |
17920 | 17967 | { |
17921 | 17968 | if(!stack[base + 9]) |
17922 | 17969 | { |
17923 | - label = 1445LLU; // break loop | |
17970 | + label = 1449LLU; // break loop | |
17924 | 17971 | break; |
17925 | 17972 | } |
17926 | 17973 |
@@ -17931,7 +17978,7 @@ | ||
17931 | 17978 | newstack[0] = (uint64_t)stack; // backup stack location |
17932 | 17979 | newstack[1] = 1234567890; |
17933 | 17980 | newstack[2] = base; |
17934 | - newstack[3] = 1446LLU; | |
17981 | + newstack[3] = 1450LLU; | |
17935 | 17982 | stack = newstack; |
17936 | 17983 | // set stack-base & callee-address |
17937 | 17984 | base = 4/*deloffset*/; |
@@ -17938,7 +17985,7 @@ | ||
17938 | 17985 | label = 400LLU; // ~param |
17939 | 17986 | break; |
17940 | 17987 | } |
17941 | - case 1446LLU: // return from ~param to register | |
17988 | + case 1450LLU: // return from ~param to register | |
17942 | 17989 | { |
17943 | 17990 | stack = (uint64_t *)stack[0]; |
17944 | 17991 | // releasing toplevel container |
@@ -17949,35 +17996,35 @@ | ||
17949 | 17996 | stack[base + 9] = (uint64_t)list->next; |
17950 | 17997 | Free(1, sizeof(struct listnode), list); |
17951 | 17998 | } |
17952 | - label = 1444LLU; // repeat | |
17999 | + label = 1448LLU; // repeat | |
17953 | 18000 | break; |
17954 | 18001 | } |
17955 | - case 1445LLU: // loop finished | |
18002 | + case 1449LLU: // loop finished | |
17956 | 18003 | { |
17957 | - label = 1428LLU; // continue unrolling stack, delete next variable | |
18004 | + label = 1432LLU; // continue unrolling stack, delete next variable | |
17958 | 18005 | break; |
17959 | 18006 | } |
17960 | - case 1443LLU: // skipped deleter | |
18007 | + case 1447LLU: // skipped deleter | |
17961 | 18008 | { |
17962 | 18009 | stack[base + 9] = 0; |
17963 | 18010 | stack[base + 10] = stack[base + 1]/*argcount*/; |
17964 | 18011 | |
17965 | - label = 1447LLU; // start to repeat | |
18012 | + label = 1451LLU; // start to repeat | |
17966 | 18013 | break; |
17967 | 18014 | } |
17968 | - case 1447LLU: // repeat from here | |
18015 | + case 1451LLU: // repeat from here | |
17969 | 18016 | { |
17970 | 18017 | if(!stack[base + 10]--) |
17971 | 18018 | { |
17972 | - label = 1448LLU; // break loop | |
18019 | + label = 1452LLU; // break loop | |
17973 | 18020 | break; |
17974 | 18021 | } |
17975 | 18022 | |
17976 | 18023 | // loop body |
17977 | 18024 | // call mktypename from register |
17978 | - stack[base + 12LLU] = 1449LLU/*throw to this address*/; | |
18025 | + stack[base + 12LLU] = 1453LLU/*throw to this address*/; | |
17979 | 18026 | stack[base + 13LLU] = base; |
17980 | - stack[base + 14LLU] = 1450LLU; | |
18027 | + stack[base + 14LLU] = 1454LLU; | |
17981 | 18028 | // arguments for call to mktypename |
17982 | 18029 | stack[base + 16LLU] = 881834713755418624LLU; |
17983 | 18030 | // set stack-base & callee-address |
@@ -17985,22 +18032,22 @@ | ||
17985 | 18032 | label = 299LLU; // mktypename |
17986 | 18033 | break; |
17987 | 18034 | } |
17988 | - case 1449LLU: // copy-back deleter (mktypename to register) | |
18035 | + case 1453LLU: // copy-back deleter (mktypename to register) | |
17989 | 18036 | { |
17990 | 18037 | fprintf(stderr, "in function register: unrolling stack, copy-back (mktypename to register)\n"); |
17991 | 18038 | // copy mutable arguments back from call to mktypename |
17992 | - label = 1442LLU; // continue to roll stack | |
18039 | + label = 1446LLU; // continue to roll stack | |
17993 | 18040 | break; |
17994 | 18041 | } |
17995 | - case 1450LLU: // return from mktypename to register | |
18042 | + case 1454LLU: // return from mktypename to register | |
17996 | 18043 | { |
17997 | 18044 | // copy mutable arguments back from call to mktypename |
17998 | 18045 | // copy back results provided by call to mktypename |
17999 | 18046 | stack[base + 11] = stack[base + 15LLU]; |
18000 | 18047 | // call idwithnr from register |
18001 | - stack[base + 13LLU] = 1451LLU/*throw to this address*/; | |
18048 | + stack[base + 13LLU] = 1455LLU/*throw to this address*/; | |
18002 | 18049 | stack[base + 14LLU] = base; |
18003 | - stack[base + 15LLU] = 1452LLU; | |
18050 | + stack[base + 15LLU] = 1456LLU; | |
18004 | 18051 | // arguments for call to idwithnr |
18005 | 18052 | stack[base + 17LLU] = 517219065798852608LLU; |
18006 | 18053 | stack[base + 18LLU] = stack[base + 10]/*ARGCOUNT*/; |
@@ -18009,28 +18056,28 @@ | ||
18009 | 18056 | label = 18446744073709551579LLU; // idwithnr |
18010 | 18057 | break; |
18011 | 18058 | } |
18012 | - case 1451LLU: // copy-back deleter (idwithnr to register) | |
18059 | + case 1455LLU: // copy-back deleter (idwithnr to register) | |
18013 | 18060 | { |
18014 | 18061 | fprintf(stderr, "in function register: unrolling stack, copy-back (idwithnr to register)\n"); |
18015 | 18062 | // copy mutable arguments back from call to idwithnr |
18016 | - label = 1442LLU; // continue to roll stack | |
18063 | + label = 1446LLU; // continue to roll stack | |
18017 | 18064 | break; |
18018 | 18065 | } |
18019 | - case 1452LLU: // return from idwithnr to register | |
18066 | + case 1456LLU: // return from idwithnr to register | |
18020 | 18067 | { |
18021 | 18068 | // copy mutable arguments back from call to idwithnr |
18022 | 18069 | // copy back results provided by call to idwithnr |
18023 | 18070 | stack[base + 12] = stack[base + 16LLU]; |
18024 | - label = 1454LLU; // skip deleter | |
18071 | + label = 1458LLU; // skip deleter | |
18025 | 18072 | break; |
18026 | 18073 | } |
18027 | - case 1453LLU: // deleter | |
18074 | + case 1457LLU: // deleter | |
18028 | 18075 | { |
18029 | 18076 | // throw from register |
18030 | 18077 | if(!stack[base + 13]) |
18031 | 18078 | { |
18032 | 18079 | fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable typeid \n"); |
18033 | - label = 1442LLU; // skip, variable already deleted/unscoped | |
18080 | + label = 1446LLU; // skip, variable already deleted/unscoped | |
18034 | 18081 | break; |
18035 | 18082 | } |
18036 | 18083 | fprintf(stderr, "in function register: unrolling stack, variable typeid \n"); |
@@ -18040,7 +18087,7 @@ | ||
18040 | 18087 | newstack[0] = (uint64_t)stack; // backup stack location |
18041 | 18088 | newstack[1] = 1234567890; |
18042 | 18089 | newstack[2] = base; |
18043 | - newstack[3] = 1455LLU; | |
18090 | + newstack[3] = 1459LLU; | |
18044 | 18091 | stack = newstack; |
18045 | 18092 | // set stack-base & callee-address |
18046 | 18093 | base = 4/*deloffset*/; |
@@ -18047,21 +18094,21 @@ | ||
18047 | 18094 | label = 346LLU; // ~typeid |
18048 | 18095 | break; |
18049 | 18096 | } |
18050 | - case 1455LLU: // return from ~typeid to register | |
18097 | + case 1459LLU: // return from ~typeid to register | |
18051 | 18098 | { |
18052 | 18099 | stack = (uint64_t *)stack[0]; |
18053 | 18100 | // releasing toplevel container |
18054 | 18101 | Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 13] - sizeof(uint64_t) * 4)); |
18055 | 18102 | |
18056 | - label = 1442LLU; // continue unrolling stack, delete next variable | |
18103 | + label = 1446LLU; // continue unrolling stack, delete next variable | |
18057 | 18104 | break; |
18058 | 18105 | } |
18059 | - case 1454LLU: // skipped deleter | |
18106 | + case 1458LLU: // skipped deleter | |
18060 | 18107 | { |
18061 | 18108 | // construct typeid.typeid |
18062 | 18109 | if(!(stack[base + 13] = construct(2))) |
18063 | 18110 | { |
18064 | - label = 1442LLU; // throw: begin to unroll stack | |
18111 | + label = 1446LLU; // throw: begin to unroll stack | |
18065 | 18112 | break; |
18066 | 18113 | } |
18067 | 18114 |
@@ -18069,35 +18116,35 @@ | ||
18069 | 18116 | ((uint64_t *)stack[base + 13])[0] = 0; |
18070 | 18117 | INIT(&(((uint64_t **)(stack[base + 13]))[1][0]), &stack[base + 11]/*type*/); |
18071 | 18118 | (((uint64_t **)(stack[base + 13]))[1][1]) = stack[base + 12]/*id*/; |
18072 | - label = 1457LLU; // skip deleter | |
18119 | + label = 1461LLU; // skip deleter | |
18073 | 18120 | break; |
18074 | 18121 | } |
18075 | - case 1456LLU: // deleter | |
18122 | + case 1460LLU: // deleter | |
18076 | 18123 | { |
18077 | 18124 | // throw from register |
18078 | 18125 | if(!stack[base + 14]) |
18079 | 18126 | { |
18080 | 18127 | fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable u64 \n"); |
18081 | - label = 1453LLU; // skip, variable already deleted/unscoped | |
18128 | + label = 1457LLU; // skip, variable already deleted/unscoped | |
18082 | 18129 | break; |
18083 | 18130 | } |
18084 | 18131 | fprintf(stderr, "in function register: unrolling stack, variable u64 \n"); |
18085 | - label = 1453LLU; // continue unrolling stack, delete next variable | |
18132 | + label = 1457LLU; // continue unrolling stack, delete next variable | |
18086 | 18133 | break; |
18087 | 18134 | } |
18088 | - case 1457LLU: // skipped deleter | |
18135 | + case 1461LLU: // skipped deleter | |
18089 | 18136 | { |
18090 | 18137 | stack[base + 14] = 0; |
18091 | - label = 1459LLU; // skip deleter | |
18138 | + label = 1463LLU; // skip deleter | |
18092 | 18139 | break; |
18093 | 18140 | } |
18094 | - case 1458LLU: // deleter | |
18141 | + case 1462LLU: // deleter | |
18095 | 18142 | { |
18096 | 18143 | // throw from register |
18097 | 18144 | if(!stack[base + 15]) |
18098 | 18145 | { |
18099 | 18146 | fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable param \n"); |
18100 | - label = 1456LLU; // skip, variable already deleted/unscoped | |
18147 | + label = 1460LLU; // skip, variable already deleted/unscoped | |
18101 | 18148 | break; |
18102 | 18149 | } |
18103 | 18150 | fprintf(stderr, "in function register: unrolling stack, variable param \n"); |
@@ -18107,7 +18154,7 @@ | ||
18107 | 18154 | newstack[0] = (uint64_t)stack; // backup stack location |
18108 | 18155 | newstack[1] = 1234567890; |
18109 | 18156 | newstack[2] = base; |
18110 | - newstack[3] = 1460LLU; | |
18157 | + newstack[3] = 1464LLU; | |
18111 | 18158 | stack = newstack; |
18112 | 18159 | // set stack-base & callee-address |
18113 | 18160 | base = 4/*deloffset*/; |
@@ -18114,21 +18161,21 @@ | ||
18114 | 18161 | label = 400LLU; // ~param |
18115 | 18162 | break; |
18116 | 18163 | } |
18117 | - case 1460LLU: // return from ~param to register | |
18164 | + case 1464LLU: // return from ~param to register | |
18118 | 18165 | { |
18119 | 18166 | stack = (uint64_t *)stack[0]; |
18120 | 18167 | // releasing toplevel container |
18121 | 18168 | Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 15] - sizeof(uint64_t) * 4)); |
18122 | 18169 | |
18123 | - label = 1456LLU; // continue unrolling stack, delete next variable | |
18170 | + label = 1460LLU; // continue unrolling stack, delete next variable | |
18124 | 18171 | break; |
18125 | 18172 | } |
18126 | - case 1459LLU: // skipped deleter | |
18173 | + case 1463LLU: // skipped deleter | |
18127 | 18174 | { |
18128 | 18175 | // construct param.param |
18129 | 18176 | if(!(stack[base + 15] = construct(2))) |
18130 | 18177 | { |
18131 | - label = 1456LLU; // throw: begin to unroll stack | |
18178 | + label = 1460LLU; // throw: begin to unroll stack | |
18132 | 18179 | break; |
18133 | 18180 | } |
18134 | 18181 |
@@ -18147,53 +18194,53 @@ | ||
18147 | 18194 | stack[base + 9]/*fnargtypes*/ = (uint64_t)list; |
18148 | 18195 | MOVE(&list->data, &stack[base + 15]/*param*/); |
18149 | 18196 | } |
18150 | - label = 1447LLU; // repeat | |
18197 | + label = 1451LLU; // repeat | |
18151 | 18198 | break; |
18152 | 18199 | } |
18153 | - case 1448LLU: // loop finished | |
18200 | + case 1452LLU: // loop finished | |
18154 | 18201 | { |
18155 | - label = 1462LLU; // skip deleter | |
18202 | + label = 1466LLU; // skip deleter | |
18156 | 18203 | break; |
18157 | 18204 | } |
18158 | - case 1461LLU: // deleter | |
18205 | + case 1465LLU: // deleter | |
18159 | 18206 | { |
18160 | 18207 | // throw from register |
18161 | 18208 | if(!stack[base + 11]) |
18162 | 18209 | { |
18163 | 18210 | fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable u64 \n"); |
18164 | - label = 1442LLU; // skip, variable already deleted/unscoped | |
18211 | + label = 1446LLU; // skip, variable already deleted/unscoped | |
18165 | 18212 | break; |
18166 | 18213 | } |
18167 | 18214 | fprintf(stderr, "in function register: unrolling stack, variable u64 \n"); |
18168 | - label = 1442LLU; // continue unrolling stack, delete next variable | |
18215 | + label = 1446LLU; // continue unrolling stack, delete next variable | |
18169 | 18216 | break; |
18170 | 18217 | } |
18171 | - case 1462LLU: // skipped deleter | |
18218 | + case 1466LLU: // skipped deleter | |
18172 | 18219 | { |
18173 | 18220 | stack[base + 11] = 0; |
18174 | - label = 1464LLU; // skip deleter | |
18221 | + label = 1468LLU; // skip deleter | |
18175 | 18222 | break; |
18176 | 18223 | } |
18177 | - case 1463LLU: // deleter | |
18224 | + case 1467LLU: // deleter | |
18178 | 18225 | { |
18179 | 18226 | // throw from register |
18180 | 18227 | if(!stack[base + 12]) |
18181 | 18228 | { |
18182 | 18229 | fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable u64 \n"); |
18183 | - label = 1461LLU; // skip, variable already deleted/unscoped | |
18230 | + label = 1465LLU; // skip, variable already deleted/unscoped | |
18184 | 18231 | break; |
18185 | 18232 | } |
18186 | 18233 | fprintf(stderr, "in function register: unrolling stack, variable u64 \n"); |
18187 | - label = 1461LLU; // continue unrolling stack, delete next variable | |
18234 | + label = 1465LLU; // continue unrolling stack, delete next variable | |
18188 | 18235 | break; |
18189 | 18236 | } |
18190 | - case 1464LLU: // skipped deleter | |
18237 | + case 1468LLU: // skipped deleter | |
18191 | 18238 | { |
18192 | 18239 | stack[base + 12] = 0; |
18193 | 18240 | // call sub from register |
18194 | - stack[base + 13LLU] = 1465LLU/*throw to this address*/; | |
18241 | + stack[base + 13LLU] = 1469LLU/*throw to this address*/; | |
18195 | 18242 | stack[base + 14LLU] = base; |
18196 | - stack[base + 15LLU] = 1466LLU; | |
18243 | + stack[base + 15LLU] = 1470LLU; | |
18197 | 18244 | // arguments for call to sub |
18198 | 18245 | stack[base + 17LLU] = stack[base + 12]/*fnlabel*/; |
18199 | 18246 | stack[base + 18LLU] = stack[base + 5]/*defcount*/; |
@@ -18202,22 +18249,22 @@ | ||
18202 | 18249 | label = 18446744073709551604LLU; // sub |
18203 | 18250 | break; |
18204 | 18251 | } |
18205 | - case 1465LLU: // copy-back deleter (sub to register) | |
18252 | + case 1469LLU: // copy-back deleter (sub to register) | |
18206 | 18253 | { |
18207 | 18254 | fprintf(stderr, "in function register: unrolling stack, copy-back (sub to register)\n"); |
18208 | 18255 | // copy mutable arguments back from call to sub |
18209 | - label = 1463LLU; // continue to roll stack | |
18256 | + label = 1467LLU; // continue to roll stack | |
18210 | 18257 | break; |
18211 | 18258 | } |
18212 | - case 1466LLU: // return from sub to register | |
18259 | + case 1470LLU: // return from sub to register | |
18213 | 18260 | { |
18214 | 18261 | // copy mutable arguments back from call to sub |
18215 | 18262 | // copy back results provided by call to sub |
18216 | 18263 | stack[base + 12] = stack[base + 16LLU]; |
18217 | 18264 | // call sub from register |
18218 | - stack[base + 13LLU] = 1467LLU/*throw to this address*/; | |
18265 | + stack[base + 13LLU] = 1471LLU/*throw to this address*/; | |
18219 | 18266 | stack[base + 14LLU] = base; |
18220 | - stack[base + 15LLU] = 1468LLU; | |
18267 | + stack[base + 15LLU] = 1472LLU; | |
18221 | 18268 | // arguments for call to sub |
18222 | 18269 | stack[base + 17LLU] = stack[base + 12]/*fnlabel*/; |
18223 | 18270 | stack[base + 18LLU] = 1LLU; |
@@ -18226,38 +18273,57 @@ | ||
18226 | 18273 | label = 18446744073709551604LLU; // sub |
18227 | 18274 | break; |
18228 | 18275 | } |
18229 | - case 1467LLU: // copy-back deleter (sub to register) | |
18276 | + case 1471LLU: // copy-back deleter (sub to register) | |
18230 | 18277 | { |
18231 | 18278 | fprintf(stderr, "in function register: unrolling stack, copy-back (sub to register)\n"); |
18232 | 18279 | // copy mutable arguments back from call to sub |
18233 | - label = 1463LLU; // continue to roll stack | |
18280 | + label = 1467LLU; // continue to roll stack | |
18234 | 18281 | break; |
18235 | 18282 | } |
18236 | - case 1468LLU: // return from sub to register | |
18283 | + case 1472LLU: // return from sub to register | |
18237 | 18284 | { |
18238 | 18285 | // copy mutable arguments back from call to sub |
18239 | 18286 | // copy back results provided by call to sub |
18240 | 18287 | stack[base + 12] = stack[base + 16LLU]; |
18241 | - label = 1470LLU; // skip deleter | |
18288 | + label = 1474LLU; // skip deleter | |
18242 | 18289 | break; |
18243 | 18290 | } |
18244 | - case 1469LLU: // deleter | |
18291 | + case 1473LLU: // deleter | |
18245 | 18292 | { |
18246 | 18293 | // throw from register |
18247 | 18294 | if(!stack[base + 13]) |
18248 | 18295 | { |
18296 | + fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable u64 \n"); | |
18297 | + label = 1467LLU; // skip, variable already deleted/unscoped | |
18298 | + break; | |
18299 | + } | |
18300 | + fprintf(stderr, "in function register: unrolling stack, variable u64 \n"); | |
18301 | + label = 1467LLU; // continue unrolling stack, delete next variable | |
18302 | + break; | |
18303 | + } | |
18304 | + case 1474LLU: // skipped deleter | |
18305 | + { | |
18306 | + stack[base + 13] = 0; | |
18307 | + label = 1476LLU; // skip deleter | |
18308 | + break; | |
18309 | + } | |
18310 | + case 1475LLU: // deleter | |
18311 | + { | |
18312 | + // throw from register | |
18313 | + if(!stack[base + 14]) | |
18314 | + { | |
18249 | 18315 | fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable fndef \n"); |
18250 | - label = 1463LLU; // skip, variable already deleted/unscoped | |
18316 | + label = 1473LLU; // skip, variable already deleted/unscoped | |
18251 | 18317 | break; |
18252 | 18318 | } |
18253 | 18319 | fprintf(stderr, "in function register: unrolling stack, variable fndef \n"); |
18254 | 18320 | |
18255 | - uint64_t *newstack = (uint64_t *)(stack[base + 13] - sizeof(uint64_t) * 4); | |
18321 | + uint64_t *newstack = (uint64_t *)(stack[base + 14] - sizeof(uint64_t) * 4); | |
18256 | 18322 | // call ~fndef from register |
18257 | 18323 | newstack[0] = (uint64_t)stack; // backup stack location |
18258 | 18324 | newstack[1] = 1234567890; |
18259 | 18325 | newstack[2] = base; |
18260 | - newstack[3] = 1471LLU; | |
18326 | + newstack[3] = 1477LLU; | |
18261 | 18327 | stack = newstack; |
18262 | 18328 | // set stack-base & callee-address |
18263 | 18329 | base = 4/*deloffset*/; |
@@ -18264,33 +18330,34 @@ | ||
18264 | 18330 | label = 1273LLU; // ~fndef |
18265 | 18331 | break; |
18266 | 18332 | } |
18267 | - case 1471LLU: // return from ~fndef to register | |
18333 | + case 1477LLU: // return from ~fndef to register | |
18268 | 18334 | { |
18269 | 18335 | stack = (uint64_t *)stack[0]; |
18270 | 18336 | // releasing toplevel container |
18271 | - Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 13] - sizeof(uint64_t) * 4)); | |
18337 | + Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 14] - sizeof(uint64_t) * 4)); | |
18272 | 18338 | |
18273 | - label = 1463LLU; // continue unrolling stack, delete next variable | |
18339 | + label = 1473LLU; // continue unrolling stack, delete next variable | |
18274 | 18340 | break; |
18275 | 18341 | } |
18276 | - case 1470LLU: // skipped deleter | |
18342 | + case 1476LLU: // skipped deleter | |
18277 | 18343 | { |
18278 | 18344 | // construct fndef.fndef |
18279 | - if(!(stack[base + 13] = construct(7))) | |
18345 | + if(!(stack[base + 14] = construct(8))) | |
18280 | 18346 | { |
18281 | - label = 1463LLU; // throw: begin to unroll stack | |
18347 | + label = 1473LLU; // throw: begin to unroll stack | |
18282 | 18348 | break; |
18283 | 18349 | } |
18284 | 18350 | |
18285 | 18351 | // consequent |
18286 | - ((uint64_t *)stack[base + 13])[0] = 0; | |
18287 | - (((uint64_t **)(stack[base + 13]))[1][0]) = stack[base + 12]/*fnlabel*/; | |
18288 | - INIT(&(((uint64_t **)(stack[base + 13]))[1][1]), &stack[base + 7]/*fnrestypes*/); | |
18289 | - INIT(&(((uint64_t **)(stack[base + 13]))[1][2]), &stack[base + 9]/*fnargtypes*/); | |
18290 | - (((uint64_t **)(stack[base + 13]))[1][3]) = stack[base + 2]/*maxcount*/; | |
18291 | - (((uint64_t **)(stack[base + 13]))[1][4]) = stack[base + 3]/*fnid*/; | |
18292 | - (((uint64_t **)(stack[base + 13]))[1][5]) = stack[base + 11]/*fnrec*/; | |
18293 | - (((uint64_t **)(stack[base + 13]))[1][6]) = stack[base + 6]/*fallible*/; | |
18352 | + ((uint64_t *)stack[base + 14])[0] = 0; | |
18353 | + (((uint64_t **)(stack[base + 14]))[1][0]) = stack[base + 12]/*fnlabel*/; | |
18354 | + INIT(&(((uint64_t **)(stack[base + 14]))[1][1]), &stack[base + 7]/*fnrestypes*/); | |
18355 | + INIT(&(((uint64_t **)(stack[base + 14]))[1][2]), &stack[base + 9]/*fnargtypes*/); | |
18356 | + (((uint64_t **)(stack[base + 14]))[1][3]) = stack[base + 2]/*maxcount*/; | |
18357 | + (((uint64_t **)(stack[base + 14]))[1][4]) = stack[base + 3]/*fnid*/; | |
18358 | + (((uint64_t **)(stack[base + 14]))[1][5]) = stack[base + 11]/*fnrec*/; | |
18359 | + (((uint64_t **)(stack[base + 14]))[1][6]) = stack[base + 6]/*fallible*/; | |
18360 | + (((uint64_t **)(stack[base + 14]))[1][7]) = stack[base + 13]/*canthrow*/; | |
18294 | 18361 | { |
18295 | 18362 | struct listnode *list = (struct listnode *)Calloc(1, sizeof(struct listnode)); |
18296 | 18363 | if(!list) |
@@ -18300,52 +18367,52 @@ | ||
18300 | 18367 | } |
18301 | 18368 | list->next = (struct listnode *)stack[base + 4]/*fndefs*/; |
18302 | 18369 | stack[base + 4]/*fndefs*/ = (uint64_t)list; |
18303 | - MOVE(&list->data, &stack[base + 13]/*fndef*/); | |
18370 | + MOVE(&list->data, &stack[base + 14]/*fndef*/); | |
18304 | 18371 | } |
18305 | 18372 | // call add from register |
18306 | - stack[base + 14LLU] = 1472LLU/*throw to this address*/; | |
18307 | - stack[base + 15LLU] = base; | |
18308 | - stack[base + 16LLU] = 1473LLU; | |
18373 | + stack[base + 15LLU] = 1478LLU/*throw to this address*/; | |
18374 | + stack[base + 16LLU] = base; | |
18375 | + stack[base + 17LLU] = 1479LLU; | |
18309 | 18376 | // arguments for call to add |
18310 | - stack[base + 18LLU] = stack[base + 5]/*defcount*/; | |
18311 | - stack[base + 19LLU] = 1LLU; | |
18377 | + stack[base + 19LLU] = stack[base + 5]/*defcount*/; | |
18378 | + stack[base + 20LLU] = 1LLU; | |
18312 | 18379 | // set stack-base & callee-address |
18313 | - base += 17LLU; | |
18380 | + base += 18LLU; | |
18314 | 18381 | label = 18446744073709551605LLU; // add |
18315 | 18382 | break; |
18316 | 18383 | } |
18317 | - case 1472LLU: // copy-back deleter (add to register) | |
18384 | + case 1478LLU: // copy-back deleter (add to register) | |
18318 | 18385 | { |
18319 | 18386 | fprintf(stderr, "in function register: unrolling stack, copy-back (add to register)\n"); |
18320 | 18387 | // copy mutable arguments back from call to add |
18321 | - label = 1469LLU; // continue to roll stack | |
18388 | + label = 1475LLU; // continue to roll stack | |
18322 | 18389 | break; |
18323 | 18390 | } |
18324 | - case 1473LLU: // return from add to register | |
18391 | + case 1479LLU: // return from add to register | |
18325 | 18392 | { |
18326 | 18393 | // copy mutable arguments back from call to add |
18327 | 18394 | // copy back results provided by call to add |
18328 | - stack[base + 5] = stack[base + 17LLU]; | |
18395 | + stack[base + 5] = stack[base + 18LLU]; | |
18329 | 18396 | // call emitcase from register |
18330 | - stack[base + 14LLU] = 1474LLU/*throw to this address*/; | |
18331 | - stack[base + 15LLU] = base; | |
18332 | - stack[base + 16LLU] = 1475LLU; | |
18397 | + stack[base + 15LLU] = 1480LLU/*throw to this address*/; | |
18398 | + stack[base + 16LLU] = base; | |
18399 | + stack[base + 17LLU] = 1481LLU; | |
18333 | 18400 | // arguments for call to emitcase |
18334 | - stack[base + 17LLU] = stack[base + 5]/*defcount*/; | |
18335 | - stack[base + 18LLU] = stack[base + 3]/*fnid*/; | |
18401 | + stack[base + 18LLU] = stack[base + 5]/*defcount*/; | |
18402 | + stack[base + 19LLU] = stack[base + 3]/*fnid*/; | |
18336 | 18403 | // set stack-base & callee-address |
18337 | - base += 17LLU; | |
18338 | - label = 1410LLU; // emitcase | |
18404 | + base += 18LLU; | |
18405 | + label = 1414LLU; // emitcase | |
18339 | 18406 | break; |
18340 | 18407 | } |
18341 | - case 1474LLU: // copy-back deleter (emitcase to register) | |
18408 | + case 1480LLU: // copy-back deleter (emitcase to register) | |
18342 | 18409 | { |
18343 | 18410 | fprintf(stderr, "in function register: unrolling stack, copy-back (emitcase to register)\n"); |
18344 | 18411 | // copy mutable arguments back from call to emitcase |
18345 | - label = 1469LLU; // continue to roll stack | |
18412 | + label = 1475LLU; // continue to roll stack | |
18346 | 18413 | break; |
18347 | 18414 | } |
18348 | - case 1475LLU: // return from emitcase to register | |
18415 | + case 1481LLU: // return from emitcase to register | |
18349 | 18416 | { |
18350 | 18417 | // copy mutable arguments back from call to emitcase |
18351 | 18418 | // return from register |
@@ -18353,7 +18420,7 @@ | ||
18353 | 18420 | base = stack[base - 2]; |
18354 | 18421 | break; |
18355 | 18422 | } |
18356 | - case 1477LLU: // function linkthrow failed | |
18423 | + case 1483LLU: // function linkthrow failed | |
18357 | 18424 | { |
18358 | 18425 | fprintf(stderr, "function linkthrow failed\n"); |
18359 | 18426 | label = stack[base - 3]; |
@@ -18360,13 +18427,13 @@ | ||
18360 | 18427 | base = stack[base - 2]; |
18361 | 18428 | break; |
18362 | 18429 | } |
18363 | - case 1476LLU: // linkthrow | |
18430 | + case 1482LLU: // linkthrow | |
18364 | 18431 | { |
18365 | 18432 | //#define arg0 0 |
18366 | 18433 | //#define arg1 1 |
18367 | 18434 | if(/*scope*/0 != ((uint64_t *)(stack[base + 0]/*scope*/))[0]) |
18368 | 18435 | { |
18369 | - label = 1479LLU; // jump to alternative | |
18436 | + label = 1485LLU; // jump to alternative | |
18370 | 18437 | break; |
18371 | 18438 | } |
18372 | 18439 |
@@ -18377,15 +18444,15 @@ | ||
18377 | 18444 | stack[base + 2]/*labelthrow*/ = stack[base + 1]/*labelfail*/; |
18378 | 18445 | ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 3]; |
18379 | 18446 | ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 2]; |
18380 | - label = 1478LLU; // case complete | |
18447 | + label = 1484LLU; // case complete | |
18381 | 18448 | break; |
18382 | 18449 | } |
18383 | - case 1479LLU: // try next case | |
18450 | + case 1485LLU: // try next case | |
18384 | 18451 | { |
18385 | 18452 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
18386 | 18453 | exit(-1); |
18387 | 18454 | } |
18388 | - case 1478LLU: // completed switch | |
18455 | + case 1484LLU: // completed switch | |
18389 | 18456 | { |
18390 | 18457 | // return from linkthrow |
18391 | 18458 | label = stack[base - 1]; |
@@ -18392,7 +18459,7 @@ | ||
18392 | 18459 | base = stack[base - 2]; |
18393 | 18460 | break; |
18394 | 18461 | } |
18395 | - case 1481LLU: // function emitthrow failed | |
18462 | + case 1487LLU: // function emitthrow failed | |
18396 | 18463 | { |
18397 | 18464 | fprintf(stderr, "function emitthrow failed\n"); |
18398 | 18465 | label = stack[base - 3]; |
@@ -18399,13 +18466,13 @@ | ||
18399 | 18466 | base = stack[base - 2]; |
18400 | 18467 | break; |
18401 | 18468 | } |
18402 | - case 1480LLU: // emitthrow | |
18469 | + case 1486LLU: // emitthrow | |
18403 | 18470 | { |
18404 | 18471 | //#define arg0 0 |
18405 | 18472 | printf("%s", "\n {"); |
18406 | 18473 | if(/*scope*/0 != ((uint64_t *)(stack[base + 0]/*scope*/))[0]) |
18407 | 18474 | { |
18408 | - label = 1483LLU; // jump to alternative | |
18475 | + label = 1489LLU; // jump to alternative | |
18409 | 18476 | break; |
18410 | 18477 | } |
18411 | 18478 |
@@ -18415,9 +18482,9 @@ | ||
18415 | 18482 | // case |
18416 | 18483 | printf("%s", "\n label = "); |
18417 | 18484 | // call printnr from emitthrow |
18418 | - stack[base + 3LLU] = 1484LLU/*throw to this address*/; | |
18485 | + stack[base + 3LLU] = 1490LLU/*throw to this address*/; | |
18419 | 18486 | stack[base + 4LLU] = base; |
18420 | - stack[base + 5LLU] = 1485LLU; | |
18487 | + stack[base + 5LLU] = 1491LLU; | |
18421 | 18488 | // arguments for call to printnr |
18422 | 18489 | stack[base + 6LLU] = stack[base + 1]/*labelthrow*/; |
18423 | 18490 | // set stack-base & callee-address |
@@ -18425,28 +18492,28 @@ | ||
18425 | 18492 | label = 18446744073709551590LLU; // printnr |
18426 | 18493 | break; |
18427 | 18494 | } |
18428 | - case 1484LLU: // copy-back deleter (printnr to emitthrow) | |
18495 | + case 1490LLU: // copy-back deleter (printnr to emitthrow) | |
18429 | 18496 | { |
18430 | 18497 | fprintf(stderr, "in function emitthrow: unrolling stack, copy-back (printnr to emitthrow)\n"); |
18431 | 18498 | // copy mutable arguments back from call to printnr |
18432 | - label = 1481LLU; // continue to roll stack | |
18499 | + label = 1487LLU; // continue to roll stack | |
18433 | 18500 | break; |
18434 | 18501 | } |
18435 | - case 1485LLU: // return from printnr to emitthrow | |
18502 | + case 1491LLU: // return from printnr to emitthrow | |
18436 | 18503 | { |
18437 | 18504 | // copy mutable arguments back from call to printnr |
18438 | 18505 | printf("%s", "LLU; // throw: begin to unroll stack"); |
18439 | 18506 | ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2]; |
18440 | 18507 | ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1]; |
18441 | - label = 1482LLU; // case complete | |
18508 | + label = 1488LLU; // case complete | |
18442 | 18509 | break; |
18443 | 18510 | } |
18444 | - case 1483LLU: // try next case | |
18511 | + case 1489LLU: // try next case | |
18445 | 18512 | { |
18446 | 18513 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
18447 | 18514 | exit(-1); |
18448 | 18515 | } |
18449 | - case 1482LLU: // completed switch | |
18516 | + case 1488LLU: // completed switch | |
18450 | 18517 | { |
18451 | 18518 | printf("%s", "\n break;"); |
18452 | 18519 | printf("%s", "\n }"); |
@@ -18456,7 +18523,7 @@ | ||
18456 | 18523 | base = stack[base - 2]; |
18457 | 18524 | break; |
18458 | 18525 | } |
18459 | - case 1487LLU: // function ProcCall failed | |
18526 | + case 1493LLU: // function ProcCall failed | |
18460 | 18527 | { |
18461 | 18528 | fprintf(stderr, "function ProcCall failed\n"); |
18462 | 18529 | label = stack[base - 3]; |
@@ -18463,7 +18530,7 @@ | ||
18463 | 18530 | base = stack[base - 2]; |
18464 | 18531 | break; |
18465 | 18532 | } |
18466 | - case 1486LLU: // ProcCall | |
18533 | + case 1492LLU: // ProcCall | |
18467 | 18534 | { |
18468 | 18535 | //#define arg0 0 |
18469 | 18536 | //#define arg1 1 |
@@ -18482,58 +18549,59 @@ | ||
18482 | 18549 | //#define arg14 14 |
18483 | 18550 | //#define arg15 15 |
18484 | 18551 | //#define arg16 16 |
18485 | - label = 1489LLU; // skip deleter | |
18552 | +//#define arg17 17 | |
18553 | + label = 1495LLU; // skip deleter | |
18486 | 18554 | break; |
18487 | 18555 | } |
18488 | - case 1488LLU: // deleter | |
18556 | + case 1494LLU: // deleter | |
18489 | 18557 | { |
18490 | 18558 | // throw from ProcCall |
18491 | - if(!stack[base + 17]) | |
18559 | + if(!stack[base + 18]) | |
18492 | 18560 | { |
18493 | 18561 | fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 \n"); |
18494 | - label = 1487LLU; // skip, variable already deleted/unscoped | |
18562 | + label = 1493LLU; // skip, variable already deleted/unscoped | |
18495 | 18563 | break; |
18496 | 18564 | } |
18497 | 18565 | fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 \n"); |
18498 | - label = 1487LLU; // continue unrolling stack, delete next variable | |
18566 | + label = 1493LLU; // continue unrolling stack, delete next variable | |
18499 | 18567 | break; |
18500 | 18568 | } |
18501 | - case 1489LLU: // skipped deleter | |
18569 | + case 1495LLU: // skipped deleter | |
18502 | 18570 | { |
18503 | - stack[base + 17] = 0; | |
18504 | - label = 1491LLU; // skip deleter | |
18571 | + stack[base + 18] = 0; | |
18572 | + label = 1497LLU; // skip deleter | |
18505 | 18573 | break; |
18506 | 18574 | } |
18507 | - case 1490LLU: // deleter | |
18575 | + case 1496LLU: // deleter | |
18508 | 18576 | { |
18509 | 18577 | // throw from ProcCall |
18510 | - if(!stack[base + 18]) | |
18578 | + if(!stack[base + 19]) | |
18511 | 18579 | { |
18512 | 18580 | fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable [idnr] \n"); |
18513 | - label = 1488LLU; // skip, variable already deleted/unscoped | |
18581 | + label = 1494LLU; // skip, variable already deleted/unscoped | |
18514 | 18582 | break; |
18515 | 18583 | } |
18516 | 18584 | fprintf(stderr, "in function ProcCall: unrolling stack, variable [idnr] \n"); |
18517 | 18585 | // delete list |
18518 | - label = 1492LLU; // start to repeat | |
18586 | + label = 1498LLU; // start to repeat | |
18519 | 18587 | break; |
18520 | 18588 | } |
18521 | - case 1492LLU: // repeat from here | |
18589 | + case 1498LLU: // repeat from here | |
18522 | 18590 | { |
18523 | - if(!stack[base + 18]) | |
18591 | + if(!stack[base + 19]) | |
18524 | 18592 | { |
18525 | - label = 1493LLU; // break loop | |
18593 | + label = 1499LLU; // break loop | |
18526 | 18594 | break; |
18527 | 18595 | } |
18528 | 18596 | |
18529 | 18597 | // delete list loop body |
18530 | 18598 | |
18531 | - uint64_t *newstack = (uint64_t *)(((struct listnode *)stack[base + 18])->data - sizeof(uint64_t) * 4); | |
18599 | + uint64_t *newstack = (uint64_t *)(((struct listnode *)stack[base + 19])->data - sizeof(uint64_t) * 4); | |
18532 | 18600 | // call ~idnr from ProcCall |
18533 | 18601 | newstack[0] = (uint64_t)stack; // backup stack location |
18534 | 18602 | newstack[1] = 1234567890; |
18535 | 18603 | newstack[2] = base; |
18536 | - newstack[3] = 1494LLU; | |
18604 | + newstack[3] = 1500LLU; | |
18537 | 18605 | stack = newstack; |
18538 | 18606 | // set stack-base & callee-address |
18539 | 18607 | base = 4/*deloffset*/; |
@@ -18540,58 +18608,59 @@ | ||
18540 | 18608 | label = 758LLU; // ~idnr |
18541 | 18609 | break; |
18542 | 18610 | } |
18543 | - case 1494LLU: // return from ~idnr to ProcCall | |
18611 | + case 1500LLU: // return from ~idnr to ProcCall | |
18544 | 18612 | { |
18545 | 18613 | stack = (uint64_t *)stack[0]; |
18546 | 18614 | // releasing toplevel container |
18547 | - Free(2 + 4, sizeof(uint64_t), (uint64_t *)(((struct listnode *)stack[base + 18])->data - sizeof(uint64_t) * 4)); | |
18615 | + Free(2 + 4, sizeof(uint64_t), (uint64_t *)(((struct listnode *)stack[base + 19])->data - sizeof(uint64_t) * 4)); | |
18548 | 18616 | |
18549 | 18617 | { |
18550 | - struct listnode *list = (struct listnode *)stack[base + 18]; | |
18551 | - stack[base + 18] = (uint64_t)list->next; | |
18618 | + struct listnode *list = (struct listnode *)stack[base + 19]; | |
18619 | + stack[base + 19] = (uint64_t)list->next; | |
18552 | 18620 | Free(1, sizeof(struct listnode), list); |
18553 | 18621 | } |
18554 | - label = 1492LLU; // repeat | |
18622 | + label = 1498LLU; // repeat | |
18555 | 18623 | break; |
18556 | 18624 | } |
18557 | - case 1493LLU: // loop finished | |
18625 | + case 1499LLU: // loop finished | |
18558 | 18626 | { |
18559 | - label = 1488LLU; // continue unrolling stack, delete next variable | |
18627 | + label = 1494LLU; // continue unrolling stack, delete next variable | |
18560 | 18628 | break; |
18561 | 18629 | } |
18562 | - case 1491LLU: // skipped deleter | |
18630 | + case 1497LLU: // skipped deleter | |
18563 | 18631 | { |
18564 | - stack[base + 18] = 0; | |
18565 | - if(/*fndef*/0 != ((uint64_t *)(stack[base + 12]/*calleedef*/))[0]) | |
18632 | + stack[base + 19] = 0; | |
18633 | + if(/*fndef*/0 != ((uint64_t *)(stack[base + 13]/*calleedef*/))[0]) | |
18566 | 18634 | { |
18567 | - label = 1496LLU; // jump to alternative | |
18635 | + label = 1502LLU; // jump to alternative | |
18568 | 18636 | break; |
18569 | 18637 | } |
18570 | 18638 | |
18571 | - /*celabel*/stack[base + 19] = ((uint64_t **)(stack[base + 12]/*calleedef*/))[1][0]/*label*/; | |
18572 | - /*cerestypes*/stack[base + 20] = ((uint64_t **)(stack[base + 12]/*calleedef*/))[1][1]/*restypes*/; | |
18573 | - /*ceargtypes*/stack[base + 21] = ((uint64_t **)(stack[base + 12]/*calleedef*/))[1][2]/*argtypes*/; | |
18574 | - /*cemaxcount*/stack[base + 22] = ((uint64_t **)(stack[base + 12]/*calleedef*/))[1][3]/*maxcount*/; | |
18575 | - /*ceid*/stack[base + 23] = ((uint64_t **)(stack[base + 12]/*calleedef*/))[1][4]/*id*/; | |
18576 | - /*cerec*/stack[base + 24] = ((uint64_t **)(stack[base + 12]/*calleedef*/))[1][5]/*recursive*/; | |
18577 | - /*ceerr*/stack[base + 25] = ((uint64_t **)(stack[base + 12]/*calleedef*/))[1][6]/*fallible*/; | |
18639 | + /*celabel*/stack[base + 20] = ((uint64_t **)(stack[base + 13]/*calleedef*/))[1][0]/*label*/; | |
18640 | + /*cerestypes*/stack[base + 21] = ((uint64_t **)(stack[base + 13]/*calleedef*/))[1][1]/*restypes*/; | |
18641 | + /*ceargtypes*/stack[base + 22] = ((uint64_t **)(stack[base + 13]/*calleedef*/))[1][2]/*argtypes*/; | |
18642 | + /*cemaxcount*/stack[base + 23] = ((uint64_t **)(stack[base + 13]/*calleedef*/))[1][3]/*maxcount*/; | |
18643 | + /*ceid*/stack[base + 24] = ((uint64_t **)(stack[base + 13]/*calleedef*/))[1][4]/*id*/; | |
18644 | + /*cerec*/stack[base + 25] = ((uint64_t **)(stack[base + 13]/*calleedef*/))[1][5]/*recursive*/; | |
18645 | + /*ceerr*/stack[base + 26] = ((uint64_t **)(stack[base + 13]/*calleedef*/))[1][6]/*fallible*/; | |
18646 | + /*cecanthrow*/stack[base + 27] = ((uint64_t **)(stack[base + 13]/*calleedef*/))[1][7]/*canthrow*/; | |
18578 | 18647 | |
18579 | 18648 | // case |
18580 | 18649 | if(!stack[base + 6]/*fnerr*/) |
18581 | 18650 | { |
18582 | - label = 1497LLU; // jump to alternative | |
18651 | + label = 1503LLU; // jump to alternative | |
18583 | 18652 | break; |
18584 | 18653 | } |
18585 | 18654 | |
18586 | 18655 | // consequent |
18587 | - label = 1498LLU; // consequent complete | |
18656 | + label = 1504LLU; // consequent complete | |
18588 | 18657 | break; |
18589 | 18658 | } |
18590 | - case 1497LLU: // alternative | |
18659 | + case 1503LLU: // alternative | |
18591 | 18660 | { |
18592 | - if(!stack[base + 25]/*ceerr*/) | |
18661 | + if(!stack[base + 26]/*ceerr*/) | |
18593 | 18662 | { |
18594 | - label = 1499LLU; // jump to alternative | |
18663 | + label = 1505LLU; // jump to alternative | |
18595 | 18664 | break; |
18596 | 18665 | } |
18597 | 18666 |
@@ -18598,855 +18667,935 @@ | ||
18598 | 18667 | // consequent |
18599 | 18668 | fprintf(stderr, "%s", "in function "); |
18600 | 18669 | // call reportid from ProcCall |
18601 | - stack[base + 26LLU] = 1501LLU/*throw to this address*/; | |
18602 | - stack[base + 27LLU] = base; | |
18603 | - stack[base + 28LLU] = 1502LLU; | |
18670 | + stack[base + 28LLU] = 1507LLU/*throw to this address*/; | |
18671 | + stack[base + 29LLU] = base; | |
18672 | + stack[base + 30LLU] = 1508LLU; | |
18604 | 18673 | // arguments for call to reportid |
18605 | - stack[base + 29LLU] = stack[base + 7]/*fnid*/; | |
18674 | + stack[base + 31LLU] = stack[base + 8]/*fnid*/; | |
18606 | 18675 | // set stack-base & callee-address |
18607 | - base += 29LLU; | |
18676 | + base += 31LLU; | |
18608 | 18677 | label = 18446744073709551586LLU; // reportid |
18609 | 18678 | break; |
18610 | 18679 | } |
18611 | - case 1501LLU: // copy-back deleter (reportid to ProcCall) | |
18680 | + case 1507LLU: // copy-back deleter (reportid to ProcCall) | |
18612 | 18681 | { |
18613 | 18682 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
18614 | 18683 | // copy mutable arguments back from call to reportid |
18615 | - label = 1490LLU; // continue to roll stack | |
18684 | + label = 1496LLU; // continue to roll stack | |
18616 | 18685 | break; |
18617 | 18686 | } |
18618 | - case 1502LLU: // return from reportid to ProcCall | |
18687 | + case 1508LLU: // return from reportid to ProcCall | |
18619 | 18688 | { |
18620 | 18689 | // copy mutable arguments back from call to reportid |
18621 | 18690 | fprintf(stderr, "%s", ": partial function "); |
18622 | 18691 | // call reportid from ProcCall |
18623 | - stack[base + 26LLU] = 1503LLU/*throw to this address*/; | |
18624 | - stack[base + 27LLU] = base; | |
18625 | - stack[base + 28LLU] = 1504LLU; | |
18692 | + stack[base + 28LLU] = 1509LLU/*throw to this address*/; | |
18693 | + stack[base + 29LLU] = base; | |
18694 | + stack[base + 30LLU] = 1510LLU; | |
18626 | 18695 | // arguments for call to reportid |
18627 | - stack[base + 29LLU] = stack[base + 23]/*ceid*/; | |
18696 | + stack[base + 31LLU] = stack[base + 24]/*ceid*/; | |
18628 | 18697 | // set stack-base & callee-address |
18629 | - base += 29LLU; | |
18698 | + base += 31LLU; | |
18630 | 18699 | label = 18446744073709551586LLU; // reportid |
18631 | 18700 | break; |
18632 | 18701 | } |
18633 | - case 1503LLU: // copy-back deleter (reportid to ProcCall) | |
18702 | + case 1509LLU: // copy-back deleter (reportid to ProcCall) | |
18634 | 18703 | { |
18635 | 18704 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
18636 | 18705 | // copy mutable arguments back from call to reportid |
18637 | - label = 1490LLU; // continue to roll stack | |
18706 | + label = 1496LLU; // continue to roll stack | |
18638 | 18707 | break; |
18639 | 18708 | } |
18640 | - case 1504LLU: // return from reportid to ProcCall | |
18709 | + case 1510LLU: // return from reportid to ProcCall | |
18641 | 18710 | { |
18642 | 18711 | // copy mutable arguments back from call to reportid |
18643 | 18712 | fprintf(stderr, "%s", " cannot be called from total function - define caller-function as fallible: prefix return-type with '!'\n"); |
18644 | 18713 | exit(-1); |
18645 | - label = 1500LLU; // consequent complete | |
18714 | + label = 1506LLU; // consequent complete | |
18646 | 18715 | break; |
18647 | 18716 | } |
18648 | - case 1499LLU: // alternative | |
18717 | + case 1505LLU: // alternative | |
18649 | 18718 | { |
18650 | - label = 1500LLU; // alternative complete | |
18719 | + label = 1506LLU; // alternative complete | |
18651 | 18720 | break; |
18652 | 18721 | } |
18653 | - case 1500LLU: // completed if-then-else | |
18722 | + case 1506LLU: // completed if-then-else | |
18654 | 18723 | { |
18655 | - label = 1498LLU; // alternative complete | |
18724 | + label = 1504LLU; // alternative complete | |
18656 | 18725 | break; |
18657 | 18726 | } |
18658 | - case 1498LLU: // completed if-then-else | |
18727 | + case 1504LLU: // completed if-then-else | |
18659 | 18728 | { |
18660 | - label = 1506LLU; // skip deleter | |
18729 | + if(!stack[base + 7]/*fncanthrow*/) | |
18730 | + { | |
18731 | + label = 1511LLU; // jump to alternative | |
18732 | + break; | |
18733 | + } | |
18734 | + | |
18735 | + // consequent | |
18736 | + label = 1512LLU; // consequent complete | |
18661 | 18737 | break; |
18662 | 18738 | } |
18663 | - case 1505LLU: // deleter | |
18739 | + case 1511LLU: // alternative | |
18664 | 18740 | { |
18741 | + if(!stack[base + 27]/*cecanthrow*/) | |
18742 | + { | |
18743 | + label = 1513LLU; // jump to alternative | |
18744 | + break; | |
18745 | + } | |
18746 | + | |
18747 | + // consequent | |
18748 | + fprintf(stderr, "%s", "in function "); | |
18749 | + // call reportid from ProcCall | |
18750 | + stack[base + 28LLU] = 1515LLU/*throw to this address*/; | |
18751 | + stack[base + 29LLU] = base; | |
18752 | + stack[base + 30LLU] = 1516LLU; | |
18753 | + // arguments for call to reportid | |
18754 | + stack[base + 31LLU] = stack[base + 8]/*fnid*/; | |
18755 | + // set stack-base & callee-address | |
18756 | + base += 31LLU; | |
18757 | + label = 18446744073709551586LLU; // reportid | |
18758 | + break; | |
18759 | + } | |
18760 | + case 1515LLU: // copy-back deleter (reportid to ProcCall) | |
18761 | + { | |
18762 | + fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); | |
18763 | + // copy mutable arguments back from call to reportid | |
18764 | + label = 1496LLU; // continue to roll stack | |
18765 | + break; | |
18766 | + } | |
18767 | + case 1516LLU: // return from reportid to ProcCall | |
18768 | + { | |
18769 | + // copy mutable arguments back from call to reportid | |
18770 | + fprintf(stderr, "%s", ": call to function "); | |
18771 | + // call reportid from ProcCall | |
18772 | + stack[base + 28LLU] = 1517LLU/*throw to this address*/; | |
18773 | + stack[base + 29LLU] = base; | |
18774 | + stack[base + 30LLU] = 1518LLU; | |
18775 | + // arguments for call to reportid | |
18776 | + stack[base + 31LLU] = stack[base + 24]/*ceid*/; | |
18777 | + // set stack-base & callee-address | |
18778 | + base += 31LLU; | |
18779 | + label = 18446744073709551586LLU; // reportid | |
18780 | + break; | |
18781 | + } | |
18782 | + case 1517LLU: // copy-back deleter (reportid to ProcCall) | |
18783 | + { | |
18784 | + fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); | |
18785 | + // copy mutable arguments back from call to reportid | |
18786 | + label = 1496LLU; // continue to roll stack | |
18787 | + break; | |
18788 | + } | |
18789 | + case 1518LLU: // return from reportid to ProcCall | |
18790 | + { | |
18791 | + // copy mutable arguments back from call to reportid | |
18792 | + fprintf(stderr, "%s", " (which may throw) in no-throw environment\n"); | |
18793 | + exit(-1); | |
18794 | + label = 1514LLU; // consequent complete | |
18795 | + break; | |
18796 | + } | |
18797 | + case 1513LLU: // alternative | |
18798 | + { | |
18799 | + label = 1514LLU; // alternative complete | |
18800 | + break; | |
18801 | + } | |
18802 | + case 1514LLU: // completed if-then-else | |
18803 | + { | |
18804 | + label = 1512LLU; // alternative complete | |
18805 | + break; | |
18806 | + } | |
18807 | + case 1512LLU: // completed if-then-else | |
18808 | + { | |
18809 | + label = 1520LLU; // skip deleter | |
18810 | + break; | |
18811 | + } | |
18812 | + case 1519LLU: // deleter | |
18813 | + { | |
18665 | 18814 | // throw from ProcCall |
18666 | - if(!stack[base + 26]) | |
18815 | + if(!stack[base + 28]) | |
18667 | 18816 | { |
18668 | 18817 | fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 \n"); |
18669 | - label = 1490LLU; // skip, variable already deleted/unscoped | |
18818 | + label = 1496LLU; // skip, variable already deleted/unscoped | |
18670 | 18819 | break; |
18671 | 18820 | } |
18672 | 18821 | fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 \n"); |
18673 | - label = 1490LLU; // continue unrolling stack, delete next variable | |
18822 | + label = 1496LLU; // continue unrolling stack, delete next variable | |
18674 | 18823 | break; |
18675 | 18824 | } |
18676 | - case 1506LLU: // skipped deleter | |
18825 | + case 1520LLU: // skipped deleter | |
18677 | 18826 | { |
18678 | - stack[base + 26] = 0; | |
18679 | - stack[base + 26]/*cerescount*/ = list_size(((struct listnode *)(stack[base + 20]/*cerestypes*/))); | |
18680 | - label = 1508LLU; // skip deleter | |
18827 | + stack[base + 28] = 0; | |
18828 | + stack[base + 28]/*cerescount*/ = list_size(((struct listnode *)(stack[base + 21]/*cerestypes*/))); | |
18829 | + label = 1522LLU; // skip deleter | |
18681 | 18830 | break; |
18682 | 18831 | } |
18683 | - case 1507LLU: // deleter | |
18832 | + case 1521LLU: // deleter | |
18684 | 18833 | { |
18685 | 18834 | // throw from ProcCall |
18686 | - if(!stack[base + 27]) | |
18835 | + if(!stack[base + 29]) | |
18687 | 18836 | { |
18688 | 18837 | fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 \n"); |
18689 | - label = 1505LLU; // skip, variable already deleted/unscoped | |
18838 | + label = 1519LLU; // skip, variable already deleted/unscoped | |
18690 | 18839 | break; |
18691 | 18840 | } |
18692 | 18841 | fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 \n"); |
18693 | - label = 1505LLU; // continue unrolling stack, delete next variable | |
18842 | + label = 1519LLU; // continue unrolling stack, delete next variable | |
18694 | 18843 | break; |
18695 | 18844 | } |
18696 | - case 1508LLU: // skipped deleter | |
18845 | + case 1522LLU: // skipped deleter | |
18697 | 18846 | { |
18698 | - stack[base + 27] = 0; | |
18699 | - stack[base + 27]/*ceargcount*/ = list_size(((struct listnode *)(stack[base + 21]/*ceargtypes*/))); | |
18700 | - if(!stack[base + 19]/*celabel*/) | |
18847 | + stack[base + 29] = 0; | |
18848 | + stack[base + 29]/*ceargcount*/ = list_size(((struct listnode *)(stack[base + 22]/*ceargtypes*/))); | |
18849 | + if(!stack[base + 20]/*celabel*/) | |
18701 | 18850 | { |
18702 | - label = 1509LLU; // jump to alternative | |
18851 | + label = 1523LLU; // jump to alternative | |
18703 | 18852 | break; |
18704 | 18853 | } |
18705 | 18854 | |
18706 | 18855 | // consequent |
18707 | - label = 1510LLU; // consequent complete | |
18856 | + label = 1524LLU; // consequent complete | |
18708 | 18857 | break; |
18709 | 18858 | } |
18710 | - case 1509LLU: // alternative | |
18859 | + case 1523LLU: // alternative | |
18711 | 18860 | { |
18712 | 18861 | fprintf(stderr, "%s", " NULL-label!\n"); |
18713 | 18862 | exit(-1); |
18714 | - label = 1510LLU; // alternative complete | |
18863 | + label = 1524LLU; // alternative complete | |
18715 | 18864 | break; |
18716 | 18865 | } |
18717 | - case 1510LLU: // completed if-then-else | |
18866 | + case 1524LLU: // completed if-then-else | |
18718 | 18867 | { |
18719 | - label = 1512LLU; // skip deleter | |
18868 | + label = 1526LLU; // skip deleter | |
18720 | 18869 | break; |
18721 | 18870 | } |
18722 | - case 1511LLU: // deleter | |
18871 | + case 1525LLU: // deleter | |
18723 | 18872 | { |
18724 | 18873 | // throw from ProcCall |
18725 | - if(!stack[base + 28]) | |
18874 | + if(!stack[base + 30]) | |
18726 | 18875 | { |
18727 | 18876 | fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 \n"); |
18728 | - label = 1507LLU; // skip, variable already deleted/unscoped | |
18877 | + label = 1521LLU; // skip, variable already deleted/unscoped | |
18729 | 18878 | break; |
18730 | 18879 | } |
18731 | 18880 | fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 \n"); |
18732 | - label = 1507LLU; // continue unrolling stack, delete next variable | |
18881 | + label = 1521LLU; // continue unrolling stack, delete next variable | |
18733 | 18882 | break; |
18734 | 18883 | } |
18735 | - case 1512LLU: // skipped deleter | |
18884 | + case 1526LLU: // skipped deleter | |
18736 | 18885 | { |
18737 | - stack[base + 28] = 0; | |
18738 | - label = 1514LLU; // skip deleter | |
18886 | + stack[base + 30] = 0; | |
18887 | + label = 1528LLU; // skip deleter | |
18739 | 18888 | break; |
18740 | 18889 | } |
18741 | - case 1513LLU: // deleter | |
18890 | + case 1527LLU: // deleter | |
18742 | 18891 | { |
18743 | 18892 | // throw from ProcCall |
18744 | - if(!stack[base + 29]) | |
18893 | + if(!stack[base + 31]) | |
18745 | 18894 | { |
18746 | 18895 | fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 \n"); |
18747 | - label = 1511LLU; // skip, variable already deleted/unscoped | |
18896 | + label = 1525LLU; // skip, variable already deleted/unscoped | |
18748 | 18897 | break; |
18749 | 18898 | } |
18750 | 18899 | fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 \n"); |
18751 | - label = 1511LLU; // continue unrolling stack, delete next variable | |
18900 | + label = 1525LLU; // continue unrolling stack, delete next variable | |
18752 | 18901 | break; |
18753 | 18902 | } |
18754 | - case 1514LLU: // skipped deleter | |
18903 | + case 1528LLU: // skipped deleter | |
18755 | 18904 | { |
18756 | - stack[base + 29] = 0; | |
18757 | - label = 1516LLU; // skip deleter | |
18905 | + stack[base + 31] = 0; | |
18906 | + label = 1530LLU; // skip deleter | |
18758 | 18907 | break; |
18759 | 18908 | } |
18760 | - case 1515LLU: // deleter | |
18909 | + case 1529LLU: // deleter | |
18761 | 18910 | { |
18762 | 18911 | // throw from ProcCall |
18763 | - if(!stack[base + 30]) | |
18912 | + if(!stack[base + 32]) | |
18764 | 18913 | { |
18765 | 18914 | fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 \n"); |
18766 | - label = 1513LLU; // skip, variable already deleted/unscoped | |
18915 | + label = 1527LLU; // skip, variable already deleted/unscoped | |
18767 | 18916 | break; |
18768 | 18917 | } |
18769 | 18918 | fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 \n"); |
18770 | - label = 1513LLU; // continue unrolling stack, delete next variable | |
18919 | + label = 1527LLU; // continue unrolling stack, delete next variable | |
18771 | 18920 | break; |
18772 | 18921 | } |
18773 | - case 1516LLU: // skipped deleter | |
18922 | + case 1530LLU: // skipped deleter | |
18774 | 18923 | { |
18775 | - stack[base + 30] = 0; | |
18776 | - if(!stack[base + 24]/*cerec*/) | |
18924 | + stack[base + 32] = 0; | |
18925 | + if(!stack[base + 25]/*cerec*/) | |
18777 | 18926 | { |
18778 | - label = 1517LLU; // jump to alternative | |
18927 | + label = 1531LLU; // jump to alternative | |
18779 | 18928 | break; |
18780 | 18929 | } |
18781 | 18930 | |
18782 | 18931 | // consequent |
18783 | 18932 | // call add from ProcCall |
18784 | - stack[base + 31LLU] = 1519LLU/*throw to this address*/; | |
18785 | - stack[base + 32LLU] = base; | |
18786 | - stack[base + 33LLU] = 1520LLU; | |
18933 | + stack[base + 33LLU] = 1533LLU/*throw to this address*/; | |
18934 | + stack[base + 34LLU] = base; | |
18935 | + stack[base + 35LLU] = 1534LLU; | |
18787 | 18936 | // arguments for call to add |
18788 | - stack[base + 35LLU] = 1LLU; | |
18789 | - stack[base + 36LLU] = stack[base + 16]/*label*/; | |
18937 | + stack[base + 37LLU] = 1LLU; | |
18938 | + stack[base + 38LLU] = stack[base + 17]/*label*/; | |
18790 | 18939 | // set stack-base & callee-address |
18791 | - base += 34LLU; | |
18940 | + base += 36LLU; | |
18792 | 18941 | label = 18446744073709551605LLU; // add |
18793 | 18942 | break; |
18794 | 18943 | } |
18795 | - case 1519LLU: // copy-back deleter (add to ProcCall) | |
18944 | + case 1533LLU: // copy-back deleter (add to ProcCall) | |
18796 | 18945 | { |
18797 | 18946 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
18798 | 18947 | // copy mutable arguments back from call to add |
18799 | - label = 1515LLU; // continue to roll stack | |
18948 | + label = 1529LLU; // continue to roll stack | |
18800 | 18949 | break; |
18801 | 18950 | } |
18802 | - case 1520LLU: // return from add to ProcCall | |
18951 | + case 1534LLU: // return from add to ProcCall | |
18803 | 18952 | { |
18804 | 18953 | // copy mutable arguments back from call to add |
18805 | 18954 | // copy back results provided by call to add |
18806 | - stack[base + 16] = stack[base + 34LLU]; | |
18807 | - label = 1522LLU; // skip deleter | |
18955 | + stack[base + 17] = stack[base + 36LLU]; | |
18956 | + label = 1536LLU; // skip deleter | |
18808 | 18957 | break; |
18809 | 18958 | } |
18810 | - case 1521LLU: // deleter | |
18959 | + case 1535LLU: // deleter | |
18811 | 18960 | { |
18812 | 18961 | // throw from ProcCall |
18813 | - if(!stack[base + 31]) | |
18962 | + if(!stack[base + 33]) | |
18814 | 18963 | { |
18815 | 18964 | fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 \n"); |
18816 | - label = 1515LLU; // skip, variable already deleted/unscoped | |
18965 | + label = 1529LLU; // skip, variable already deleted/unscoped | |
18817 | 18966 | break; |
18818 | 18967 | } |
18819 | 18968 | fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 \n"); |
18820 | - label = 1515LLU; // continue unrolling stack, delete next variable | |
18969 | + label = 1529LLU; // continue unrolling stack, delete next variable | |
18821 | 18970 | break; |
18822 | 18971 | } |
18823 | - case 1522LLU: // skipped deleter | |
18972 | + case 1536LLU: // skipped deleter | |
18824 | 18973 | { |
18825 | - stack[base + 31] = stack[base + 16]/*label*/; | |
18826 | - label = 1524LLU; // skip deleter | |
18974 | + stack[base + 33] = stack[base + 17]/*label*/; | |
18975 | + label = 1538LLU; // skip deleter | |
18827 | 18976 | break; |
18828 | 18977 | } |
18829 | - case 1523LLU: // deleter | |
18978 | + case 1537LLU: // deleter | |
18830 | 18979 | { |
18831 | 18980 | // throw from ProcCall |
18832 | - if(!stack[base + 32]) | |
18981 | + if(!stack[base + 34]) | |
18833 | 18982 | { |
18834 | 18983 | fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 \n"); |
18835 | - label = 1521LLU; // skip, variable already deleted/unscoped | |
18984 | + label = 1535LLU; // skip, variable already deleted/unscoped | |
18836 | 18985 | break; |
18837 | 18986 | } |
18838 | 18987 | fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 \n"); |
18839 | - label = 1521LLU; // continue unrolling stack, delete next variable | |
18988 | + label = 1535LLU; // continue unrolling stack, delete next variable | |
18840 | 18989 | break; |
18841 | 18990 | } |
18842 | - case 1524LLU: // skipped deleter | |
18991 | + case 1538LLU: // skipped deleter | |
18843 | 18992 | { |
18844 | - stack[base + 32] = 0; | |
18845 | - stack[base + 32]/*recsztotal*/ = 0; | |
18993 | + stack[base + 34] = 0; | |
18994 | + stack[base + 34]/*recsztotal*/ = 0; | |
18846 | 18995 | // call add from ProcCall |
18847 | - stack[base + 33LLU] = 1525LLU/*throw to this address*/; | |
18848 | - stack[base + 34LLU] = base; | |
18849 | - stack[base + 35LLU] = 1526LLU; | |
18996 | + stack[base + 35LLU] = 1539LLU/*throw to this address*/; | |
18997 | + stack[base + 36LLU] = base; | |
18998 | + stack[base + 37LLU] = 1540LLU; | |
18850 | 18999 | // arguments for call to add |
18851 | - stack[base + 37LLU] = 4LLU; | |
18852 | - stack[base + 38LLU] = stack[base + 32]/*recsztotal*/; | |
19000 | + stack[base + 39LLU] = 4LLU; | |
19001 | + stack[base + 40LLU] = stack[base + 34]/*recsztotal*/; | |
18853 | 19002 | // set stack-base & callee-address |
18854 | - base += 36LLU; | |
19003 | + base += 38LLU; | |
18855 | 19004 | label = 18446744073709551605LLU; // add |
18856 | 19005 | break; |
18857 | 19006 | } |
18858 | - case 1525LLU: // copy-back deleter (add to ProcCall) | |
19007 | + case 1539LLU: // copy-back deleter (add to ProcCall) | |
18859 | 19008 | { |
18860 | 19009 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
18861 | 19010 | // copy mutable arguments back from call to add |
18862 | - label = 1523LLU; // continue to roll stack | |
19011 | + label = 1537LLU; // continue to roll stack | |
18863 | 19012 | break; |
18864 | 19013 | } |
18865 | - case 1526LLU: // return from add to ProcCall | |
19014 | + case 1540LLU: // return from add to ProcCall | |
18866 | 19015 | { |
18867 | 19016 | // copy mutable arguments back from call to add |
18868 | 19017 | // copy back results provided by call to add |
18869 | - stack[base + 32] = stack[base + 36LLU]; | |
19018 | + stack[base + 34] = stack[base + 38LLU]; | |
18870 | 19019 | // call add from ProcCall |
18871 | - stack[base + 33LLU] = 1527LLU/*throw to this address*/; | |
18872 | - stack[base + 34LLU] = base; | |
18873 | - stack[base + 35LLU] = 1528LLU; | |
19020 | + stack[base + 35LLU] = 1541LLU/*throw to this address*/; | |
19021 | + stack[base + 36LLU] = base; | |
19022 | + stack[base + 37LLU] = 1542LLU; | |
18874 | 19023 | // arguments for call to add |
18875 | - stack[base + 37LLU] = stack[base + 26]/*cerescount*/; | |
18876 | - stack[base + 38LLU] = stack[base + 32]/*recsztotal*/; | |
19024 | + stack[base + 39LLU] = stack[base + 28]/*cerescount*/; | |
19025 | + stack[base + 40LLU] = stack[base + 34]/*recsztotal*/; | |
18877 | 19026 | // set stack-base & callee-address |
18878 | - base += 36LLU; | |
19027 | + base += 38LLU; | |
18879 | 19028 | label = 18446744073709551605LLU; // add |
18880 | 19029 | break; |
18881 | 19030 | } |
18882 | - case 1527LLU: // copy-back deleter (add to ProcCall) | |
19031 | + case 1541LLU: // copy-back deleter (add to ProcCall) | |
18883 | 19032 | { |
18884 | 19033 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
18885 | 19034 | // copy mutable arguments back from call to add |
18886 | - label = 1523LLU; // continue to roll stack | |
19035 | + label = 1537LLU; // continue to roll stack | |
18887 | 19036 | break; |
18888 | 19037 | } |
18889 | - case 1528LLU: // return from add to ProcCall | |
19038 | + case 1542LLU: // return from add to ProcCall | |
18890 | 19039 | { |
18891 | 19040 | // copy mutable arguments back from call to add |
18892 | 19041 | // copy back results provided by call to add |
18893 | - stack[base + 32] = stack[base + 36LLU]; | |
19042 | + stack[base + 34] = stack[base + 38LLU]; | |
18894 | 19043 | // call add from ProcCall |
18895 | - stack[base + 33LLU] = 1529LLU/*throw to this address*/; | |
18896 | - stack[base + 34LLU] = base; | |
18897 | - stack[base + 35LLU] = 1530LLU; | |
19044 | + stack[base + 35LLU] = 1543LLU/*throw to this address*/; | |
19045 | + stack[base + 36LLU] = base; | |
19046 | + stack[base + 37LLU] = 1544LLU; | |
18898 | 19047 | // arguments for call to add |
18899 | - stack[base + 37LLU] = stack[base + 27]/*ceargcount*/; | |
18900 | - stack[base + 38LLU] = stack[base + 32]/*recsztotal*/; | |
19048 | + stack[base + 39LLU] = stack[base + 29]/*ceargcount*/; | |
19049 | + stack[base + 40LLU] = stack[base + 34]/*recsztotal*/; | |
18901 | 19050 | // set stack-base & callee-address |
18902 | - base += 36LLU; | |
19051 | + base += 38LLU; | |
18903 | 19052 | label = 18446744073709551605LLU; // add |
18904 | 19053 | break; |
18905 | 19054 | } |
18906 | - case 1529LLU: // copy-back deleter (add to ProcCall) | |
19055 | + case 1543LLU: // copy-back deleter (add to ProcCall) | |
18907 | 19056 | { |
18908 | 19057 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
18909 | 19058 | // copy mutable arguments back from call to add |
18910 | - label = 1523LLU; // continue to roll stack | |
19059 | + label = 1537LLU; // continue to roll stack | |
18911 | 19060 | break; |
18912 | 19061 | } |
18913 | - case 1530LLU: // return from add to ProcCall | |
19062 | + case 1544LLU: // return from add to ProcCall | |
18914 | 19063 | { |
18915 | 19064 | // copy mutable arguments back from call to add |
18916 | 19065 | // copy back results provided by call to add |
18917 | - stack[base + 32] = stack[base + 36LLU]; | |
19066 | + stack[base + 34] = stack[base + 38LLU]; | |
18918 | 19067 | // call add from ProcCall |
18919 | - stack[base + 33LLU] = 1531LLU/*throw to this address*/; | |
18920 | - stack[base + 34LLU] = base; | |
18921 | - stack[base + 35LLU] = 1532LLU; | |
19068 | + stack[base + 35LLU] = 1545LLU/*throw to this address*/; | |
19069 | + stack[base + 36LLU] = base; | |
19070 | + stack[base + 37LLU] = 1546LLU; | |
18922 | 19071 | // arguments for call to add |
18923 | - stack[base + 37LLU] = stack[base + 22]/*cemaxcount*/; | |
18924 | - stack[base + 38LLU] = stack[base + 32]/*recsztotal*/; | |
19072 | + stack[base + 39LLU] = stack[base + 23]/*cemaxcount*/; | |
19073 | + stack[base + 40LLU] = stack[base + 34]/*recsztotal*/; | |
18925 | 19074 | // set stack-base & callee-address |
18926 | - base += 36LLU; | |
19075 | + base += 38LLU; | |
18927 | 19076 | label = 18446744073709551605LLU; // add |
18928 | 19077 | break; |
18929 | 19078 | } |
18930 | - case 1531LLU: // copy-back deleter (add to ProcCall) | |
19079 | + case 1545LLU: // copy-back deleter (add to ProcCall) | |
18931 | 19080 | { |
18932 | 19081 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
18933 | 19082 | // copy mutable arguments back from call to add |
18934 | - label = 1523LLU; // continue to roll stack | |
19083 | + label = 1537LLU; // continue to roll stack | |
18935 | 19084 | break; |
18936 | 19085 | } |
18937 | - case 1532LLU: // return from add to ProcCall | |
19086 | + case 1546LLU: // return from add to ProcCall | |
18938 | 19087 | { |
18939 | 19088 | // copy mutable arguments back from call to add |
18940 | 19089 | // copy back results provided by call to add |
18941 | - stack[base + 32] = stack[base + 36LLU]; | |
19090 | + stack[base + 34] = stack[base + 38LLU]; | |
18942 | 19091 | printf("%s", "\n uint64_t *newstack = (uint64_t *)Calloc("); |
18943 | 19092 | // call printnr from ProcCall |
18944 | - stack[base + 33LLU] = 1533LLU/*throw to this address*/; | |
18945 | - stack[base + 34LLU] = base; | |
18946 | - stack[base + 35LLU] = 1534LLU; | |
19093 | + stack[base + 35LLU] = 1547LLU/*throw to this address*/; | |
19094 | + stack[base + 36LLU] = base; | |
19095 | + stack[base + 37LLU] = 1548LLU; | |
18947 | 19096 | // arguments for call to printnr |
18948 | - stack[base + 36LLU] = stack[base + 32]/*recsztotal*/; | |
19097 | + stack[base + 38LLU] = stack[base + 34]/*recsztotal*/; | |
18949 | 19098 | // set stack-base & callee-address |
18950 | - base += 36LLU; | |
19099 | + base += 38LLU; | |
18951 | 19100 | label = 18446744073709551590LLU; // printnr |
18952 | 19101 | break; |
18953 | 19102 | } |
18954 | - case 1533LLU: // copy-back deleter (printnr to ProcCall) | |
19103 | + case 1547LLU: // copy-back deleter (printnr to ProcCall) | |
18955 | 19104 | { |
18956 | 19105 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n"); |
18957 | 19106 | // copy mutable arguments back from call to printnr |
18958 | - label = 1523LLU; // continue to roll stack | |
19107 | + label = 1537LLU; // continue to roll stack | |
18959 | 19108 | break; |
18960 | 19109 | } |
18961 | - case 1534LLU: // return from printnr to ProcCall | |
19110 | + case 1548LLU: // return from printnr to ProcCall | |
18962 | 19111 | { |
18963 | 19112 | // copy mutable arguments back from call to printnr |
18964 | 19113 | printf("%s", "LLU + 1, sizeof(uint64_t));"); |
18965 | 19114 | printf("%s", "\n if(!newstack)"); |
18966 | 19115 | // call emitthrow from ProcCall |
18967 | - stack[base + 33LLU] = 1535LLU/*throw to this address*/; | |
18968 | - stack[base + 34LLU] = base; | |
18969 | - stack[base + 35LLU] = 1536LLU; | |
19116 | + stack[base + 35LLU] = 1549LLU/*throw to this address*/; | |
19117 | + stack[base + 36LLU] = base; | |
19118 | + stack[base + 37LLU] = 1550LLU; | |
18970 | 19119 | // arguments for call to emitthrow |
18971 | - stack[base + 36LLU] = stack[base + 3]/*scope*/; | |
19120 | + stack[base + 38LLU] = stack[base + 3]/*scope*/; | |
18972 | 19121 | // set stack-base & callee-address |
18973 | - base += 36LLU; | |
18974 | - label = 1480LLU; // emitthrow | |
19122 | + base += 38LLU; | |
19123 | + label = 1486LLU; // emitthrow | |
18975 | 19124 | break; |
18976 | 19125 | } |
18977 | - case 1535LLU: // copy-back deleter (emitthrow to ProcCall) | |
19126 | + case 1549LLU: // copy-back deleter (emitthrow to ProcCall) | |
18978 | 19127 | { |
18979 | 19128 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (emitthrow to ProcCall)\n"); |
18980 | 19129 | // copy mutable arguments back from call to emitthrow |
18981 | - label = 1523LLU; // continue to roll stack | |
19130 | + label = 1537LLU; // continue to roll stack | |
18982 | 19131 | break; |
18983 | 19132 | } |
18984 | - case 1536LLU: // return from emitthrow to ProcCall | |
19133 | + case 1550LLU: // return from emitthrow to ProcCall | |
18985 | 19134 | { |
18986 | 19135 | // copy mutable arguments back from call to emitthrow |
18987 | 19136 | printf("%s", "\n newstack["); |
18988 | 19137 | // call printnr from ProcCall |
18989 | - stack[base + 33LLU] = 1537LLU/*throw to this address*/; | |
18990 | - stack[base + 34LLU] = base; | |
18991 | - stack[base + 35LLU] = 1538LLU; | |
19138 | + stack[base + 35LLU] = 1551LLU/*throw to this address*/; | |
19139 | + stack[base + 36LLU] = base; | |
19140 | + stack[base + 37LLU] = 1552LLU; | |
18992 | 19141 | // arguments for call to printnr |
18993 | - stack[base + 36LLU] = stack[base + 32]/*recsztotal*/; | |
19142 | + stack[base + 38LLU] = stack[base + 34]/*recsztotal*/; | |
18994 | 19143 | // set stack-base & callee-address |
18995 | - base += 36LLU; | |
19144 | + base += 38LLU; | |
18996 | 19145 | label = 18446744073709551590LLU; // printnr |
18997 | 19146 | break; |
18998 | 19147 | } |
18999 | - case 1537LLU: // copy-back deleter (printnr to ProcCall) | |
19148 | + case 1551LLU: // copy-back deleter (printnr to ProcCall) | |
19000 | 19149 | { |
19001 | 19150 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n"); |
19002 | 19151 | // copy mutable arguments back from call to printnr |
19003 | - label = 1523LLU; // continue to roll stack | |
19152 | + label = 1537LLU; // continue to roll stack | |
19004 | 19153 | break; |
19005 | 19154 | } |
19006 | - case 1538LLU: // return from printnr to ProcCall | |
19155 | + case 1552LLU: // return from printnr to ProcCall | |
19007 | 19156 | { |
19008 | 19157 | // copy mutable arguments back from call to printnr |
19009 | 19158 | printf("%s", "LLU] = 9876543210LLU; // overflow-marker"); |
19010 | 19159 | printf("%s", "\n // call "); |
19011 | 19160 | // call printid from ProcCall |
19012 | - stack[base + 33LLU] = 1539LLU/*throw to this address*/; | |
19013 | - stack[base + 34LLU] = base; | |
19014 | - stack[base + 35LLU] = 1540LLU; | |
19161 | + stack[base + 35LLU] = 1553LLU/*throw to this address*/; | |
19162 | + stack[base + 36LLU] = base; | |
19163 | + stack[base + 37LLU] = 1554LLU; | |
19015 | 19164 | // arguments for call to printid |
19016 | - stack[base + 36LLU] = stack[base + 23]/*ceid*/; | |
19165 | + stack[base + 38LLU] = stack[base + 24]/*ceid*/; | |
19017 | 19166 | // set stack-base & callee-address |
19018 | - base += 36LLU; | |
19167 | + base += 38LLU; | |
19019 | 19168 | label = 18446744073709551587LLU; // printid |
19020 | 19169 | break; |
19021 | 19170 | } |
19022 | - case 1539LLU: // copy-back deleter (printid to ProcCall) | |
19171 | + case 1553LLU: // copy-back deleter (printid to ProcCall) | |
19023 | 19172 | { |
19024 | 19173 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n"); |
19025 | 19174 | // copy mutable arguments back from call to printid |
19026 | - label = 1523LLU; // continue to roll stack | |
19175 | + label = 1537LLU; // continue to roll stack | |
19027 | 19176 | break; |
19028 | 19177 | } |
19029 | - case 1540LLU: // return from printid to ProcCall | |
19178 | + case 1554LLU: // return from printid to ProcCall | |
19030 | 19179 | { |
19031 | 19180 | // copy mutable arguments back from call to printid |
19032 | 19181 | printf("%s", " from "); |
19033 | 19182 | // call printid from ProcCall |
19034 | - stack[base + 33LLU] = 1541LLU/*throw to this address*/; | |
19035 | - stack[base + 34LLU] = base; | |
19036 | - stack[base + 35LLU] = 1542LLU; | |
19183 | + stack[base + 35LLU] = 1555LLU/*throw to this address*/; | |
19184 | + stack[base + 36LLU] = base; | |
19185 | + stack[base + 37LLU] = 1556LLU; | |
19037 | 19186 | // arguments for call to printid |
19038 | - stack[base + 36LLU] = stack[base + 7]/*fnid*/; | |
19187 | + stack[base + 38LLU] = stack[base + 8]/*fnid*/; | |
19039 | 19188 | // set stack-base & callee-address |
19040 | - base += 36LLU; | |
19189 | + base += 38LLU; | |
19041 | 19190 | label = 18446744073709551587LLU; // printid |
19042 | 19191 | break; |
19043 | 19192 | } |
19044 | - case 1541LLU: // copy-back deleter (printid to ProcCall) | |
19193 | + case 1555LLU: // copy-back deleter (printid to ProcCall) | |
19045 | 19194 | { |
19046 | 19195 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n"); |
19047 | 19196 | // copy mutable arguments back from call to printid |
19048 | - label = 1523LLU; // continue to roll stack | |
19197 | + label = 1537LLU; // continue to roll stack | |
19049 | 19198 | break; |
19050 | 19199 | } |
19051 | - case 1542LLU: // return from printid to ProcCall | |
19200 | + case 1556LLU: // return from printid to ProcCall | |
19052 | 19201 | { |
19053 | 19202 | // copy mutable arguments back from call to printid |
19054 | 19203 | printf("%s", "\n newstack[0] = (uint64_t)stack; // backup stack location"); |
19055 | 19204 | printf("%s", "\n newstack[1] = "); |
19056 | 19205 | // call printnr from ProcCall |
19057 | - stack[base + 33LLU] = 1543LLU/*throw to this address*/; | |
19058 | - stack[base + 34LLU] = base; | |
19059 | - stack[base + 35LLU] = 1544LLU; | |
19206 | + stack[base + 35LLU] = 1557LLU/*throw to this address*/; | |
19207 | + stack[base + 36LLU] = base; | |
19208 | + stack[base + 37LLU] = 1558LLU; | |
19060 | 19209 | // arguments for call to printnr |
19061 | - stack[base + 36LLU] = stack[base + 31]/*labelfail*/; | |
19210 | + stack[base + 38LLU] = stack[base + 33]/*labelfail*/; | |
19062 | 19211 | // set stack-base & callee-address |
19063 | - base += 36LLU; | |
19212 | + base += 38LLU; | |
19064 | 19213 | label = 18446744073709551590LLU; // printnr |
19065 | 19214 | break; |
19066 | 19215 | } |
19067 | - case 1543LLU: // copy-back deleter (printnr to ProcCall) | |
19216 | + case 1557LLU: // copy-back deleter (printnr to ProcCall) | |
19068 | 19217 | { |
19069 | 19218 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n"); |
19070 | 19219 | // copy mutable arguments back from call to printnr |
19071 | - label = 1523LLU; // continue to roll stack | |
19220 | + label = 1537LLU; // continue to roll stack | |
19072 | 19221 | break; |
19073 | 19222 | } |
19074 | - case 1544LLU: // return from printnr to ProcCall | |
19223 | + case 1558LLU: // return from printnr to ProcCall | |
19075 | 19224 | { |
19076 | 19225 | // copy mutable arguments back from call to printnr |
19077 | 19226 | printf("%s", "LLU;"); |
19078 | 19227 | printf("%s", "\n newstack[2] = base;"); |
19079 | 19228 | // call add from ProcCall |
19080 | - stack[base + 33LLU] = 1545LLU/*throw to this address*/; | |
19081 | - stack[base + 34LLU] = base; | |
19082 | - stack[base + 35LLU] = 1546LLU; | |
19229 | + stack[base + 35LLU] = 1559LLU/*throw to this address*/; | |
19230 | + stack[base + 36LLU] = base; | |
19231 | + stack[base + 37LLU] = 1560LLU; | |
19083 | 19232 | // arguments for call to add |
19084 | - stack[base + 37LLU] = 1LLU; | |
19085 | - stack[base + 38LLU] = stack[base + 16]/*label*/; | |
19233 | + stack[base + 39LLU] = 1LLU; | |
19234 | + stack[base + 40LLU] = stack[base + 17]/*label*/; | |
19086 | 19235 | // set stack-base & callee-address |
19087 | - base += 36LLU; | |
19236 | + base += 38LLU; | |
19088 | 19237 | label = 18446744073709551605LLU; // add |
19089 | 19238 | break; |
19090 | 19239 | } |
19091 | - case 1545LLU: // copy-back deleter (add to ProcCall) | |
19240 | + case 1559LLU: // copy-back deleter (add to ProcCall) | |
19092 | 19241 | { |
19093 | 19242 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
19094 | 19243 | // copy mutable arguments back from call to add |
19095 | - label = 1523LLU; // continue to roll stack | |
19244 | + label = 1537LLU; // continue to roll stack | |
19096 | 19245 | break; |
19097 | 19246 | } |
19098 | - case 1546LLU: // return from add to ProcCall | |
19247 | + case 1560LLU: // return from add to ProcCall | |
19099 | 19248 | { |
19100 | 19249 | // copy mutable arguments back from call to add |
19101 | 19250 | // copy back results provided by call to add |
19102 | - stack[base + 16] = stack[base + 36LLU]; | |
19251 | + stack[base + 17] = stack[base + 38LLU]; | |
19103 | 19252 | printf("%s", "\n newstack[3] = "); |
19104 | 19253 | // call printnr from ProcCall |
19105 | - stack[base + 33LLU] = 1547LLU/*throw to this address*/; | |
19106 | - stack[base + 34LLU] = base; | |
19107 | - stack[base + 35LLU] = 1548LLU; | |
19254 | + stack[base + 35LLU] = 1561LLU/*throw to this address*/; | |
19255 | + stack[base + 36LLU] = base; | |
19256 | + stack[base + 37LLU] = 1562LLU; | |
19108 | 19257 | // arguments for call to printnr |
19109 | - stack[base + 36LLU] = stack[base + 16]/*label*/; | |
19258 | + stack[base + 38LLU] = stack[base + 17]/*label*/; | |
19110 | 19259 | // set stack-base & callee-address |
19111 | - base += 36LLU; | |
19260 | + base += 38LLU; | |
19112 | 19261 | label = 18446744073709551590LLU; // printnr |
19113 | 19262 | break; |
19114 | 19263 | } |
19115 | - case 1547LLU: // copy-back deleter (printnr to ProcCall) | |
19264 | + case 1561LLU: // copy-back deleter (printnr to ProcCall) | |
19116 | 19265 | { |
19117 | 19266 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n"); |
19118 | 19267 | // copy mutable arguments back from call to printnr |
19119 | - label = 1523LLU; // continue to roll stack | |
19268 | + label = 1537LLU; // continue to roll stack | |
19120 | 19269 | break; |
19121 | 19270 | } |
19122 | - case 1548LLU: // return from printnr to ProcCall | |
19271 | + case 1562LLU: // return from printnr to ProcCall | |
19123 | 19272 | { |
19124 | 19273 | // copy mutable arguments back from call to printnr |
19125 | 19274 | printf("%s", "LLU;"); |
19126 | - stack[base + 29]/*n*/ = stack[base + 27]/*ceargcount*/; | |
19275 | + stack[base + 31]/*n*/ = stack[base + 29]/*ceargcount*/; | |
19127 | 19276 | printf("%s", "\n // arguments for call to "); |
19128 | 19277 | // call printid from ProcCall |
19129 | - stack[base + 33LLU] = 1549LLU/*throw to this address*/; | |
19130 | - stack[base + 34LLU] = base; | |
19131 | - stack[base + 35LLU] = 1550LLU; | |
19278 | + stack[base + 35LLU] = 1563LLU/*throw to this address*/; | |
19279 | + stack[base + 36LLU] = base; | |
19280 | + stack[base + 37LLU] = 1564LLU; | |
19132 | 19281 | // arguments for call to printid |
19133 | - stack[base + 36LLU] = stack[base + 23]/*ceid*/; | |
19282 | + stack[base + 38LLU] = stack[base + 24]/*ceid*/; | |
19134 | 19283 | // set stack-base & callee-address |
19135 | - base += 36LLU; | |
19284 | + base += 38LLU; | |
19136 | 19285 | label = 18446744073709551587LLU; // printid |
19137 | 19286 | break; |
19138 | 19287 | } |
19139 | - case 1549LLU: // copy-back deleter (printid to ProcCall) | |
19288 | + case 1563LLU: // copy-back deleter (printid to ProcCall) | |
19140 | 19289 | { |
19141 | 19290 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n"); |
19142 | 19291 | // copy mutable arguments back from call to printid |
19143 | - label = 1523LLU; // continue to roll stack | |
19292 | + label = 1537LLU; // continue to roll stack | |
19144 | 19293 | break; |
19145 | 19294 | } |
19146 | - case 1550LLU: // return from printid to ProcCall | |
19295 | + case 1564LLU: // return from printid to ProcCall | |
19147 | 19296 | { |
19148 | 19297 | // copy mutable arguments back from call to printid |
19149 | - label = 1552LLU; // skip deleter | |
19298 | + label = 1566LLU; // skip deleter | |
19150 | 19299 | break; |
19151 | 19300 | } |
19152 | - case 1551LLU: // deleter | |
19301 | + case 1565LLU: // deleter | |
19153 | 19302 | { |
19154 | 19303 | // throw from ProcCall |
19155 | - if(!stack[base + 33]) | |
19304 | + if(!stack[base + 35]) | |
19156 | 19305 | { |
19157 | 19306 | fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 \n"); |
19158 | - label = 1523LLU; // skip, variable already deleted/unscoped | |
19307 | + label = 1537LLU; // skip, variable already deleted/unscoped | |
19159 | 19308 | break; |
19160 | 19309 | } |
19161 | 19310 | fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 \n"); |
19162 | - label = 1523LLU; // continue unrolling stack, delete next variable | |
19311 | + label = 1537LLU; // continue unrolling stack, delete next variable | |
19163 | 19312 | break; |
19164 | 19313 | } |
19165 | - case 1552LLU: // skipped deleter | |
19314 | + case 1566LLU: // skipped deleter | |
19166 | 19315 | { |
19167 | - stack[base + 33] = 0; | |
19168 | - flippedassign(stack[base + 21]/*ceargtypes*/, &stack[base + 34]); | |
19169 | - label = 1553LLU; // start to repeat | |
19316 | + stack[base + 35] = 0; | |
19317 | + flippedassign(stack[base + 22]/*ceargtypes*/, &stack[base + 36]); | |
19318 | + label = 1567LLU; // start to repeat | |
19170 | 19319 | break; |
19171 | 19320 | } |
19172 | - case 1553LLU: // repeat from here | |
19321 | + case 1567LLU: // repeat from here | |
19173 | 19322 | { |
19174 | - if(!stack[base + 34]) | |
19323 | + if(!stack[base + 36]) | |
19175 | 19324 | { |
19176 | - label = 1554LLU; // break loop | |
19325 | + label = 1568LLU; // break loop | |
19177 | 19326 | break; |
19178 | 19327 | } |
19179 | 19328 | |
19180 | 19329 | // loop body |
19181 | - stack[base + 35] = (uint64_t)(((const struct listnode *)(stack[base + 34]))->data); | |
19182 | - stack[base + 36]/*previous*/ = stack[base + 34]; | |
19183 | - stack[base + 34] = (uint64_t)(((const struct listnode *)(stack[base + 34]))->next); | |
19330 | + stack[base + 37] = (uint64_t)(((const struct listnode *)(stack[base + 36]))->data); | |
19331 | + stack[base + 38]/*previous*/ = stack[base + 36]; | |
19332 | + stack[base + 36] = (uint64_t)(((const struct listnode *)(stack[base + 36]))->next); | |
19184 | 19333 | // call sub from ProcCall |
19185 | - stack[base + 37LLU] = 1555LLU/*throw to this address*/; | |
19186 | - stack[base + 38LLU] = base; | |
19187 | - stack[base + 39LLU] = 1556LLU; | |
19334 | + stack[base + 39LLU] = 1569LLU/*throw to this address*/; | |
19335 | + stack[base + 40LLU] = base; | |
19336 | + stack[base + 41LLU] = 1570LLU; | |
19188 | 19337 | // arguments for call to sub |
19189 | - stack[base + 41LLU] = stack[base + 27]/*ceargcount*/; | |
19190 | - stack[base + 42LLU] = stack[base + 29]/*n*/; | |
19338 | + stack[base + 43LLU] = stack[base + 29]/*ceargcount*/; | |
19339 | + stack[base + 44LLU] = stack[base + 31]/*n*/; | |
19191 | 19340 | // set stack-base & callee-address |
19192 | - base += 40LLU; | |
19341 | + base += 42LLU; | |
19193 | 19342 | label = 18446744073709551604LLU; // sub |
19194 | 19343 | break; |
19195 | 19344 | } |
19196 | - case 1555LLU: // copy-back deleter (sub to ProcCall) | |
19345 | + case 1569LLU: // copy-back deleter (sub to ProcCall) | |
19197 | 19346 | { |
19198 | 19347 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (sub to ProcCall)\n"); |
19199 | 19348 | // copy mutable arguments back from call to sub |
19200 | - label = 1551LLU; // continue to roll stack | |
19349 | + label = 1565LLU; // continue to roll stack | |
19201 | 19350 | break; |
19202 | 19351 | } |
19203 | - case 1556LLU: // return from sub to ProcCall | |
19352 | + case 1570LLU: // return from sub to ProcCall | |
19204 | 19353 | { |
19205 | 19354 | // copy mutable arguments back from call to sub |
19206 | 19355 | // copy back results provided by call to sub |
19207 | - stack[base + 30] = stack[base + 40LLU]; | |
19356 | + stack[base + 32] = stack[base + 42LLU]; | |
19208 | 19357 | // call sub from ProcCall |
19209 | - stack[base + 37LLU] = 1557LLU/*throw to this address*/; | |
19210 | - stack[base + 38LLU] = base; | |
19211 | - stack[base + 39LLU] = 1558LLU; | |
19358 | + stack[base + 39LLU] = 1571LLU/*throw to this address*/; | |
19359 | + stack[base + 40LLU] = base; | |
19360 | + stack[base + 41LLU] = 1572LLU; | |
19212 | 19361 | // arguments for call to sub |
19213 | - stack[base + 41LLU] = stack[base + 29]/*n*/; | |
19214 | - stack[base + 42LLU] = 1LLU; | |
19362 | + stack[base + 43LLU] = stack[base + 31]/*n*/; | |
19363 | + stack[base + 44LLU] = 1LLU; | |
19215 | 19364 | // set stack-base & callee-address |
19216 | - base += 40LLU; | |
19365 | + base += 42LLU; | |
19217 | 19366 | label = 18446744073709551604LLU; // sub |
19218 | 19367 | break; |
19219 | 19368 | } |
19220 | - case 1557LLU: // copy-back deleter (sub to ProcCall) | |
19369 | + case 1571LLU: // copy-back deleter (sub to ProcCall) | |
19221 | 19370 | { |
19222 | 19371 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (sub to ProcCall)\n"); |
19223 | 19372 | // copy mutable arguments back from call to sub |
19224 | - label = 1551LLU; // continue to roll stack | |
19373 | + label = 1565LLU; // continue to roll stack | |
19225 | 19374 | break; |
19226 | 19375 | } |
19227 | - case 1558LLU: // return from sub to ProcCall | |
19376 | + case 1572LLU: // return from sub to ProcCall | |
19228 | 19377 | { |
19229 | 19378 | // copy mutable arguments back from call to sub |
19230 | 19379 | // copy back results provided by call to sub |
19231 | - stack[base + 29] = stack[base + 40LLU]; | |
19232 | - if(!stack[base + 30]/*index*/) | |
19380 | + stack[base + 31] = stack[base + 42LLU]; | |
19381 | + if(!stack[base + 32]/*index*/) | |
19233 | 19382 | { |
19234 | - label = 1559LLU; // jump to alternative | |
19383 | + label = 1573LLU; // jump to alternative | |
19235 | 19384 | break; |
19236 | 19385 | } |
19237 | 19386 | |
19238 | 19387 | // consequent |
19239 | 19388 | // call matchsym from ProcCall |
19240 | - stack[base + 37LLU] = 1561LLU/*throw to this address*/; | |
19241 | - stack[base + 38LLU] = base; | |
19242 | - stack[base + 39LLU] = 1562LLU; | |
19389 | + stack[base + 39LLU] = 1575LLU/*throw to this address*/; | |
19390 | + stack[base + 40LLU] = base; | |
19391 | + stack[base + 41LLU] = 1576LLU; | |
19243 | 19392 | // arguments for call to matchsym |
19244 | - stack[base + 40LLU] = stack[base + 7]/*fnid*/; | |
19245 | - stack[base + 41LLU] = 44LLU; | |
19246 | - stack[base + 42LLU] = stack[base + 13]/*lookahead*/; | |
19393 | + stack[base + 42LLU] = stack[base + 8]/*fnid*/; | |
19394 | + stack[base + 43LLU] = 44LLU; | |
19395 | + stack[base + 44LLU] = stack[base + 14]/*lookahead*/; | |
19247 | 19396 | // set stack-base & callee-address |
19248 | - base += 40LLU; | |
19397 | + base += 42LLU; | |
19249 | 19398 | label = 211LLU; // matchsym |
19250 | 19399 | break; |
19251 | 19400 | } |
19252 | - case 1561LLU: // copy-back deleter (matchsym to ProcCall) | |
19401 | + case 1575LLU: // copy-back deleter (matchsym to ProcCall) | |
19253 | 19402 | { |
19254 | 19403 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (matchsym to ProcCall)\n"); |
19255 | 19404 | // copy mutable arguments back from call to matchsym |
19256 | - stack[base + 13]/*lookahead*/ = stack[base + 42LLU]; | |
19257 | - label = 1551LLU; // continue to roll stack | |
19405 | + stack[base + 14]/*lookahead*/ = stack[base + 44LLU]; | |
19406 | + label = 1565LLU; // continue to roll stack | |
19258 | 19407 | break; |
19259 | 19408 | } |
19260 | - case 1562LLU: // return from matchsym to ProcCall | |
19409 | + case 1576LLU: // return from matchsym to ProcCall | |
19261 | 19410 | { |
19262 | 19411 | // copy mutable arguments back from call to matchsym |
19263 | - stack[base + 13]/*lookahead*/ = stack[base + 42LLU]; | |
19264 | - label = 1560LLU; // consequent complete | |
19412 | + stack[base + 14]/*lookahead*/ = stack[base + 44LLU]; | |
19413 | + label = 1574LLU; // consequent complete | |
19265 | 19414 | break; |
19266 | 19415 | } |
19267 | - case 1559LLU: // alternative | |
19416 | + case 1573LLU: // alternative | |
19268 | 19417 | { |
19269 | - label = 1560LLU; // alternative complete | |
19418 | + label = 1574LLU; // alternative complete | |
19270 | 19419 | break; |
19271 | 19420 | } |
19272 | - case 1560LLU: // completed if-then-else | |
19421 | + case 1574LLU: // completed if-then-else | |
19273 | 19422 | { |
19274 | - stack[base + 28]/*sum*/ = 0; | |
19423 | + stack[base + 30]/*sum*/ = 0; | |
19275 | 19424 | // call add from ProcCall |
19276 | - stack[base + 37LLU] = 1563LLU/*throw to this address*/; | |
19277 | - stack[base + 38LLU] = base; | |
19278 | - stack[base + 39LLU] = 1564LLU; | |
19425 | + stack[base + 39LLU] = 1577LLU/*throw to this address*/; | |
19426 | + stack[base + 40LLU] = base; | |
19427 | + stack[base + 41LLU] = 1578LLU; | |
19279 | 19428 | // arguments for call to add |
19280 | - stack[base + 41LLU] = 4LLU; | |
19281 | - stack[base + 42LLU] = stack[base + 28]/*sum*/; | |
19429 | + stack[base + 43LLU] = 4LLU; | |
19430 | + stack[base + 44LLU] = stack[base + 30]/*sum*/; | |
19282 | 19431 | // set stack-base & callee-address |
19283 | - base += 40LLU; | |
19432 | + base += 42LLU; | |
19284 | 19433 | label = 18446744073709551605LLU; // add |
19285 | 19434 | break; |
19286 | 19435 | } |
19287 | - case 1563LLU: // copy-back deleter (add to ProcCall) | |
19436 | + case 1577LLU: // copy-back deleter (add to ProcCall) | |
19288 | 19437 | { |
19289 | 19438 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
19290 | 19439 | // copy mutable arguments back from call to add |
19291 | - label = 1551LLU; // continue to roll stack | |
19440 | + label = 1565LLU; // continue to roll stack | |
19292 | 19441 | break; |
19293 | 19442 | } |
19294 | - case 1564LLU: // return from add to ProcCall | |
19443 | + case 1578LLU: // return from add to ProcCall | |
19295 | 19444 | { |
19296 | 19445 | // copy mutable arguments back from call to add |
19297 | 19446 | // copy back results provided by call to add |
19298 | - stack[base + 28] = stack[base + 40LLU]; | |
19447 | + stack[base + 30] = stack[base + 42LLU]; | |
19299 | 19448 | // call add from ProcCall |
19300 | - stack[base + 37LLU] = 1565LLU/*throw to this address*/; | |
19301 | - stack[base + 38LLU] = base; | |
19302 | - stack[base + 39LLU] = 1566LLU; | |
19449 | + stack[base + 39LLU] = 1579LLU/*throw to this address*/; | |
19450 | + stack[base + 40LLU] = base; | |
19451 | + stack[base + 41LLU] = 1580LLU; | |
19303 | 19452 | // arguments for call to add |
19304 | - stack[base + 41LLU] = stack[base + 26]/*cerescount*/; | |
19305 | - stack[base + 42LLU] = stack[base + 28]/*sum*/; | |
19453 | + stack[base + 43LLU] = stack[base + 28]/*cerescount*/; | |
19454 | + stack[base + 44LLU] = stack[base + 30]/*sum*/; | |
19306 | 19455 | // set stack-base & callee-address |
19307 | - base += 40LLU; | |
19456 | + base += 42LLU; | |
19308 | 19457 | label = 18446744073709551605LLU; // add |
19309 | 19458 | break; |
19310 | 19459 | } |
19311 | - case 1565LLU: // copy-back deleter (add to ProcCall) | |
19460 | + case 1579LLU: // copy-back deleter (add to ProcCall) | |
19312 | 19461 | { |
19313 | 19462 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
19314 | 19463 | // copy mutable arguments back from call to add |
19315 | - label = 1551LLU; // continue to roll stack | |
19464 | + label = 1565LLU; // continue to roll stack | |
19316 | 19465 | break; |
19317 | 19466 | } |
19318 | - case 1566LLU: // return from add to ProcCall | |
19467 | + case 1580LLU: // return from add to ProcCall | |
19319 | 19468 | { |
19320 | 19469 | // copy mutable arguments back from call to add |
19321 | 19470 | // copy back results provided by call to add |
19322 | - stack[base + 28] = stack[base + 40LLU]; | |
19471 | + stack[base + 30] = stack[base + 42LLU]; | |
19323 | 19472 | // call add from ProcCall |
19324 | - stack[base + 37LLU] = 1567LLU/*throw to this address*/; | |
19325 | - stack[base + 38LLU] = base; | |
19326 | - stack[base + 39LLU] = 1568LLU; | |
19473 | + stack[base + 39LLU] = 1581LLU/*throw to this address*/; | |
19474 | + stack[base + 40LLU] = base; | |
19475 | + stack[base + 41LLU] = 1582LLU; | |
19327 | 19476 | // arguments for call to add |
19328 | - stack[base + 41LLU] = stack[base + 30]/*index*/; | |
19329 | - stack[base + 42LLU] = stack[base + 28]/*sum*/; | |
19477 | + stack[base + 43LLU] = stack[base + 32]/*index*/; | |
19478 | + stack[base + 44LLU] = stack[base + 30]/*sum*/; | |
19330 | 19479 | // set stack-base & callee-address |
19331 | - base += 40LLU; | |
19480 | + base += 42LLU; | |
19332 | 19481 | label = 18446744073709551605LLU; // add |
19333 | 19482 | break; |
19334 | 19483 | } |
19335 | - case 1567LLU: // copy-back deleter (add to ProcCall) | |
19484 | + case 1581LLU: // copy-back deleter (add to ProcCall) | |
19336 | 19485 | { |
19337 | 19486 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
19338 | 19487 | // copy mutable arguments back from call to add |
19339 | - label = 1551LLU; // continue to roll stack | |
19488 | + label = 1565LLU; // continue to roll stack | |
19340 | 19489 | break; |
19341 | 19490 | } |
19342 | - case 1568LLU: // return from add to ProcCall | |
19491 | + case 1582LLU: // return from add to ProcCall | |
19343 | 19492 | { |
19344 | 19493 | // copy mutable arguments back from call to add |
19345 | 19494 | // copy back results provided by call to add |
19346 | - stack[base + 28] = stack[base + 40LLU]; | |
19495 | + stack[base + 30] = stack[base + 42LLU]; | |
19347 | 19496 | // call ParseToken from ProcCall |
19348 | - stack[base + 37LLU] = 1569LLU/*throw to this address*/; | |
19349 | - stack[base + 38LLU] = base; | |
19350 | - stack[base + 39LLU] = 1570LLU; | |
19497 | + stack[base + 39LLU] = 1583LLU/*throw to this address*/; | |
19498 | + stack[base + 40LLU] = base; | |
19499 | + stack[base + 41LLU] = 1584LLU; | |
19351 | 19500 | // arguments for call to ParseToken |
19352 | - stack[base + 42LLU] = stack[base + 13]/*lookahead*/; | |
19501 | + stack[base + 44LLU] = stack[base + 14]/*lookahead*/; | |
19353 | 19502 | // set stack-base & callee-address |
19354 | - base += 40LLU; | |
19503 | + base += 42LLU; | |
19355 | 19504 | label = 3LLU; // ParseToken |
19356 | 19505 | break; |
19357 | 19506 | } |
19358 | - case 1569LLU: // copy-back deleter (ParseToken to ProcCall) | |
19507 | + case 1583LLU: // copy-back deleter (ParseToken to ProcCall) | |
19359 | 19508 | { |
19360 | 19509 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (ParseToken to ProcCall)\n"); |
19361 | 19510 | // copy mutable arguments back from call to ParseToken |
19362 | - stack[base + 13]/*lookahead*/ = stack[base + 42LLU]; | |
19363 | - label = 1551LLU; // continue to roll stack | |
19511 | + stack[base + 14]/*lookahead*/ = stack[base + 44LLU]; | |
19512 | + label = 1565LLU; // continue to roll stack | |
19364 | 19513 | break; |
19365 | 19514 | } |
19366 | - case 1570LLU: // return from ParseToken to ProcCall | |
19515 | + case 1584LLU: // return from ParseToken to ProcCall | |
19367 | 19516 | { |
19368 | 19517 | // copy mutable arguments back from call to ParseToken |
19369 | - stack[base + 13]/*lookahead*/ = stack[base + 42LLU]; | |
19518 | + stack[base + 14]/*lookahead*/ = stack[base + 44LLU]; | |
19370 | 19519 | // copy back results provided by call to ParseToken |
19371 | - stack[base + 14] = stack[base + 40LLU]; | |
19372 | - stack[base + 15] = stack[base + 41LLU]; | |
19520 | + stack[base + 15] = stack[base + 42LLU]; | |
19521 | + stack[base + 16] = stack[base + 43LLU]; | |
19373 | 19522 | // call isncs from ProcCall |
19374 | - stack[base + 37LLU] = 1571LLU/*throw to this address*/; | |
19375 | - stack[base + 38LLU] = base; | |
19376 | - stack[base + 39LLU] = 1572LLU; | |
19523 | + stack[base + 39LLU] = 1585LLU/*throw to this address*/; | |
19524 | + stack[base + 40LLU] = base; | |
19525 | + stack[base + 41LLU] = 1586LLU; | |
19377 | 19526 | // arguments for call to isncs |
19378 | - stack[base + 41LLU] = stack[base + 14]/*variant*/; | |
19527 | + stack[base + 43LLU] = stack[base + 15]/*variant*/; | |
19379 | 19528 | // set stack-base & callee-address |
19380 | - base += 40LLU; | |
19529 | + base += 42LLU; | |
19381 | 19530 | label = 271LLU; // isncs |
19382 | 19531 | break; |
19383 | 19532 | } |
19384 | - case 1571LLU: // copy-back deleter (isncs to ProcCall) | |
19533 | + case 1585LLU: // copy-back deleter (isncs to ProcCall) | |
19385 | 19534 | { |
19386 | 19535 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (isncs to ProcCall)\n"); |
19387 | 19536 | // copy mutable arguments back from call to isncs |
19388 | - label = 1551LLU; // continue to roll stack | |
19537 | + label = 1565LLU; // continue to roll stack | |
19389 | 19538 | break; |
19390 | 19539 | } |
19391 | - case 1572LLU: // return from isncs to ProcCall | |
19540 | + case 1586LLU: // return from isncs to ProcCall | |
19392 | 19541 | { |
19393 | 19542 | // copy mutable arguments back from call to isncs |
19394 | 19543 | // copy back results provided by call to isncs |
19395 | - stack[base + 17] = stack[base + 40LLU]; | |
19396 | - if(!stack[base + 17]/*isequal*/) | |
19544 | + stack[base + 18] = stack[base + 42LLU]; | |
19545 | + if(!stack[base + 18]/*isequal*/) | |
19397 | 19546 | { |
19398 | - label = 1573LLU; // jump to alternative | |
19547 | + label = 1587LLU; // jump to alternative | |
19399 | 19548 | break; |
19400 | 19549 | } |
19401 | 19550 | |
19402 | 19551 | // consequent |
19403 | - if(/*param*/0 != ((uint64_t *)(stack[base + 35]/*param*/))[0]) | |
19552 | + if(/*param*/0 != ((uint64_t *)(stack[base + 37]/*param*/))[0]) | |
19404 | 19553 | { |
19405 | - label = 1576LLU; // jump to alternative | |
19554 | + label = 1590LLU; // jump to alternative | |
19406 | 19555 | break; |
19407 | 19556 | } |
19408 | 19557 | |
19409 | - /*typeid*/stack[base + 37] = ((uint64_t **)(stack[base + 35]/*param*/))[1][0]/*typeid*/; | |
19410 | - /*mutable*/stack[base + 38] = ((uint64_t **)(stack[base + 35]/*param*/))[1][1]/*mutable*/; | |
19558 | + /*typeid*/stack[base + 39] = ((uint64_t **)(stack[base + 37]/*param*/))[1][0]/*typeid*/; | |
19559 | + /*mutable*/stack[base + 40] = ((uint64_t **)(stack[base + 37]/*param*/))[1][1]/*mutable*/; | |
19411 | 19560 | |
19412 | 19561 | // case |
19413 | - if(/*typeid*/0 != ((uint64_t *)(stack[base + 37]/*typeid*/))[0]) | |
19562 | + if(/*typeid*/0 != ((uint64_t *)(stack[base + 39]/*typeid*/))[0]) | |
19414 | 19563 | { |
19415 | - label = 1578LLU; // jump to alternative | |
19564 | + label = 1592LLU; // jump to alternative | |
19416 | 19565 | break; |
19417 | 19566 | } |
19418 | 19567 | |
19419 | - /*expected*/stack[base + 39] = ((uint64_t **)(stack[base + 37]/*typeid*/))[1][0]/*type*/; | |
19420 | - /*paramname*/stack[base + 40] = ((uint64_t **)(stack[base + 37]/*typeid*/))[1][1]/*id*/; | |
19568 | + /*expected*/stack[base + 41] = ((uint64_t **)(stack[base + 39]/*typeid*/))[1][0]/*type*/; | |
19569 | + /*paramname*/stack[base + 42] = ((uint64_t **)(stack[base + 39]/*typeid*/))[1][1]/*id*/; | |
19421 | 19570 | |
19422 | 19571 | // case |
19423 | 19572 | // call mktypename from ProcCall |
19424 | - stack[base + 42LLU] = 1579LLU/*throw to this address*/; | |
19425 | - stack[base + 43LLU] = base; | |
19426 | - stack[base + 44LLU] = 1580LLU; | |
19573 | + stack[base + 44LLU] = 1593LLU/*throw to this address*/; | |
19574 | + stack[base + 45LLU] = base; | |
19575 | + stack[base + 46LLU] = 1594LLU; | |
19427 | 19576 | // arguments for call to mktypename |
19428 | - stack[base + 46LLU] = 881834713755418624LLU; | |
19577 | + stack[base + 48LLU] = 881834713755418624LLU; | |
19429 | 19578 | // set stack-base & callee-address |
19430 | - base += 45LLU; | |
19579 | + base += 47LLU; | |
19431 | 19580 | label = 299LLU; // mktypename |
19432 | 19581 | break; |
19433 | 19582 | } |
19434 | - case 1579LLU: // copy-back deleter (mktypename to ProcCall) | |
19583 | + case 1593LLU: // copy-back deleter (mktypename to ProcCall) | |
19435 | 19584 | { |
19436 | 19585 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (mktypename to ProcCall)\n"); |
19437 | 19586 | // copy mutable arguments back from call to mktypename |
19438 | - label = 1551LLU; // continue to roll stack | |
19587 | + label = 1565LLU; // continue to roll stack | |
19439 | 19588 | break; |
19440 | 19589 | } |
19441 | - case 1580LLU: // return from mktypename to ProcCall | |
19590 | + case 1594LLU: // return from mktypename to ProcCall | |
19442 | 19591 | { |
19443 | 19592 | // copy mutable arguments back from call to mktypename |
19444 | 19593 | // copy back results provided by call to mktypename |
19445 | - stack[base + 41] = stack[base + 45LLU]; | |
19594 | + stack[base + 43] = stack[base + 47LLU]; | |
19446 | 19595 | uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t)); |
19447 | 19596 | if(!newstack) |
19448 | 19597 | { |
19449 | - label = 1551LLU; // throw: begin to unroll stack | |
19598 | + label = 1565LLU; // throw: begin to unroll stack | |
19450 | 19599 | break; |
19451 | 19600 | } |
19452 | 19601 |
@@ -19453,12 +19602,12 @@ | ||
19453 | 19602 | newstack[15LLU] = 9876543210LLU; // overflow-marker |
19454 | 19603 | // call equtype from ProcCall |
19455 | 19604 | newstack[0] = (uint64_t)stack; // backup stack location |
19456 | - newstack[1] = 1581LLU; | |
19605 | + newstack[1] = 1595LLU; | |
19457 | 19606 | newstack[2] = base; |
19458 | - newstack[3] = 1582LLU; | |
19607 | + newstack[3] = 1596LLU; | |
19459 | 19608 | // arguments for call to equtype |
19460 | - newstack[5LLU] = stack[base + 41]/*type*/; | |
19461 | - newstack[6LLU] = stack[base + 39]/*expected*/; | |
19609 | + newstack[5LLU] = stack[base + 43]/*type*/; | |
19610 | + newstack[6LLU] = stack[base + 41]/*expected*/; | |
19462 | 19611 | stack = newstack; |
19463 | 19612 | // set stack-base & callee-address |
19464 | 19613 | base = 4/*deloffset*/; |
@@ -19465,7 +19614,7 @@ | ||
19465 | 19614 | label = 335LLU; // equtype |
19466 | 19615 | break; |
19467 | 19616 | } |
19468 | - case 1581LLU: // copy-back deleter (equtype to ProcCall) | |
19617 | + case 1595LLU: // copy-back deleter (equtype to ProcCall) | |
19469 | 19618 | { |
19470 | 19619 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (equtype to ProcCall)\n"); |
19471 | 19620 | uint64_t *oldstack = (uint64_t *)stack[0]; |
@@ -19477,15 +19626,15 @@ | ||
19477 | 19626 | } |
19478 | 19627 | Free(15LLU + 1, sizeof(uint64_t), stack); |
19479 | 19628 | stack = oldstack; |
19480 | - label = 1551LLU; // continue to unroll stack | |
19629 | + label = 1565LLU; // continue to unroll stack | |
19481 | 19630 | break; |
19482 | 19631 | } |
19483 | - case 1582LLU: // return from equtype to ProcCall | |
19632 | + case 1596LLU: // return from equtype to ProcCall | |
19484 | 19633 | { |
19485 | 19634 | uint64_t *oldstack = (uint64_t *)stack[0]; |
19486 | 19635 | // copy mutable arguments back from call to equtype |
19487 | 19636 | // copy back results provided by call to equtype |
19488 | - oldstack[base + 17] = stack[4LLU]; | |
19637 | + oldstack[base + 18] = stack[4LLU]; | |
19489 | 19638 | if(stack[15LLU] != 9876543210LLU) |
19490 | 19639 | { |
19491 | 19640 | fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to equtype)!"); |
@@ -19493,82 +19642,82 @@ | ||
19493 | 19642 | } |
19494 | 19643 | Free(15LLU + 1, sizeof(uint64_t), stack); |
19495 | 19644 | stack = oldstack; |
19496 | - if(!stack[base + 17]/*isequal*/) | |
19645 | + if(!stack[base + 18]/*isequal*/) | |
19497 | 19646 | { |
19498 | - label = 1583LLU; // jump to alternative | |
19647 | + label = 1597LLU; // jump to alternative | |
19499 | 19648 | break; |
19500 | 19649 | } |
19501 | 19650 | |
19502 | 19651 | // consequent |
19503 | - label = 1584LLU; // consequent complete | |
19652 | + label = 1598LLU; // consequent complete | |
19504 | 19653 | break; |
19505 | 19654 | } |
19506 | - case 1583LLU: // alternative | |
19655 | + case 1597LLU: // alternative | |
19507 | 19656 | { |
19508 | 19657 | fprintf(stderr, "%s", "in function "); |
19509 | 19658 | // call reportid from ProcCall |
19510 | - stack[base + 42LLU] = 1585LLU/*throw to this address*/; | |
19511 | - stack[base + 43LLU] = base; | |
19512 | - stack[base + 44LLU] = 1586LLU; | |
19659 | + stack[base + 44LLU] = 1599LLU/*throw to this address*/; | |
19660 | + stack[base + 45LLU] = base; | |
19661 | + stack[base + 46LLU] = 1600LLU; | |
19513 | 19662 | // arguments for call to reportid |
19514 | - stack[base + 45LLU] = stack[base + 7]/*fnid*/; | |
19663 | + stack[base + 47LLU] = stack[base + 8]/*fnid*/; | |
19515 | 19664 | // set stack-base & callee-address |
19516 | - base += 45LLU; | |
19665 | + base += 47LLU; | |
19517 | 19666 | label = 18446744073709551586LLU; // reportid |
19518 | 19667 | break; |
19519 | 19668 | } |
19520 | - case 1585LLU: // copy-back deleter (reportid to ProcCall) | |
19669 | + case 1599LLU: // copy-back deleter (reportid to ProcCall) | |
19521 | 19670 | { |
19522 | 19671 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
19523 | 19672 | // copy mutable arguments back from call to reportid |
19524 | - label = 1551LLU; // continue to roll stack | |
19673 | + label = 1565LLU; // continue to roll stack | |
19525 | 19674 | break; |
19526 | 19675 | } |
19527 | - case 1586LLU: // return from reportid to ProcCall | |
19676 | + case 1600LLU: // return from reportid to ProcCall | |
19528 | 19677 | { |
19529 | 19678 | // copy mutable arguments back from call to reportid |
19530 | 19679 | fprintf(stderr, "%s", " call to "); |
19531 | 19680 | // call reportid from ProcCall |
19532 | - stack[base + 42LLU] = 1587LLU/*throw to this address*/; | |
19533 | - stack[base + 43LLU] = base; | |
19534 | - stack[base + 44LLU] = 1588LLU; | |
19681 | + stack[base + 44LLU] = 1601LLU/*throw to this address*/; | |
19682 | + stack[base + 45LLU] = base; | |
19683 | + stack[base + 46LLU] = 1602LLU; | |
19535 | 19684 | // arguments for call to reportid |
19536 | - stack[base + 45LLU] = stack[base + 23]/*ceid*/; | |
19685 | + stack[base + 47LLU] = stack[base + 24]/*ceid*/; | |
19537 | 19686 | // set stack-base & callee-address |
19538 | - base += 45LLU; | |
19687 | + base += 47LLU; | |
19539 | 19688 | label = 18446744073709551586LLU; // reportid |
19540 | 19689 | break; |
19541 | 19690 | } |
19542 | - case 1587LLU: // copy-back deleter (reportid to ProcCall) | |
19691 | + case 1601LLU: // copy-back deleter (reportid to ProcCall) | |
19543 | 19692 | { |
19544 | 19693 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
19545 | 19694 | // copy mutable arguments back from call to reportid |
19546 | - label = 1551LLU; // continue to roll stack | |
19695 | + label = 1565LLU; // continue to roll stack | |
19547 | 19696 | break; |
19548 | 19697 | } |
19549 | - case 1588LLU: // return from reportid to ProcCall | |
19698 | + case 1602LLU: // return from reportid to ProcCall | |
19550 | 19699 | { |
19551 | 19700 | // copy mutable arguments back from call to reportid |
19552 | 19701 | fprintf(stderr, "%s", " at position "); |
19553 | 19702 | // call reportnr from ProcCall |
19554 | - stack[base + 42LLU] = 1589LLU/*throw to this address*/; | |
19555 | - stack[base + 43LLU] = base; | |
19556 | - stack[base + 44LLU] = 1590LLU; | |
19703 | + stack[base + 44LLU] = 1603LLU/*throw to this address*/; | |
19704 | + stack[base + 45LLU] = base; | |
19705 | + stack[base + 46LLU] = 1604LLU; | |
19557 | 19706 | // arguments for call to reportnr |
19558 | - stack[base + 45LLU] = stack[base + 30]/*index*/; | |
19707 | + stack[base + 47LLU] = stack[base + 32]/*index*/; | |
19559 | 19708 | // set stack-base & callee-address |
19560 | - base += 45LLU; | |
19709 | + base += 47LLU; | |
19561 | 19710 | label = 18446744073709551589LLU; // reportnr |
19562 | 19711 | break; |
19563 | 19712 | } |
19564 | - case 1589LLU: // copy-back deleter (reportnr to ProcCall) | |
19713 | + case 1603LLU: // copy-back deleter (reportnr to ProcCall) | |
19565 | 19714 | { |
19566 | 19715 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportnr to ProcCall)\n"); |
19567 | 19716 | // copy mutable arguments back from call to reportnr |
19568 | - label = 1551LLU; // continue to roll stack | |
19717 | + label = 1565LLU; // continue to roll stack | |
19569 | 19718 | break; |
19570 | 19719 | } |
19571 | - case 1590LLU: // return from reportnr to ProcCall | |
19720 | + case 1604LLU: // return from reportnr to ProcCall | |
19572 | 19721 | { |
19573 | 19722 | // copy mutable arguments back from call to reportnr |
19574 | 19723 | fprintf(stderr, "%s", " expected parameter of type "); |
@@ -19575,7 +19724,7 @@ | ||
19575 | 19724 | uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t)); |
19576 | 19725 | if(!newstack) |
19577 | 19726 | { |
19578 | - label = 1551LLU; // throw: begin to unroll stack | |
19727 | + label = 1565LLU; // throw: begin to unroll stack | |
19579 | 19728 | break; |
19580 | 19729 | } |
19581 | 19730 |
@@ -19582,11 +19731,11 @@ | ||
19582 | 19731 | newstack[10LLU] = 9876543210LLU; // overflow-marker |
19583 | 19732 | // call reporttype from ProcCall |
19584 | 19733 | newstack[0] = (uint64_t)stack; // backup stack location |
19585 | - newstack[1] = 1591LLU; | |
19734 | + newstack[1] = 1605LLU; | |
19586 | 19735 | newstack[2] = base; |
19587 | - newstack[3] = 1592LLU; | |
19736 | + newstack[3] = 1606LLU; | |
19588 | 19737 | // arguments for call to reporttype |
19589 | - newstack[4LLU] = stack[base + 39]/*expected*/; | |
19738 | + newstack[4LLU] = stack[base + 41]/*expected*/; | |
19590 | 19739 | stack = newstack; |
19591 | 19740 | // set stack-base & callee-address |
19592 | 19741 | base = 4/*deloffset*/; |
@@ -19593,7 +19742,7 @@ | ||
19593 | 19742 | label = 313LLU; // reporttype |
19594 | 19743 | break; |
19595 | 19744 | } |
19596 | - case 1591LLU: // copy-back deleter (reporttype to ProcCall) | |
19745 | + case 1605LLU: // copy-back deleter (reporttype to ProcCall) | |
19597 | 19746 | { |
19598 | 19747 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n"); |
19599 | 19748 | uint64_t *oldstack = (uint64_t *)stack[0]; |
@@ -19605,10 +19754,10 @@ | ||
19605 | 19754 | } |
19606 | 19755 | Free(10LLU + 1, sizeof(uint64_t), stack); |
19607 | 19756 | stack = oldstack; |
19608 | - label = 1551LLU; // continue to unroll stack | |
19757 | + label = 1565LLU; // continue to unroll stack | |
19609 | 19758 | break; |
19610 | 19759 | } |
19611 | - case 1592LLU: // return from reporttype to ProcCall | |
19760 | + case 1606LLU: // return from reporttype to ProcCall | |
19612 | 19761 | { |
19613 | 19762 | uint64_t *oldstack = (uint64_t *)stack[0]; |
19614 | 19763 | // copy mutable arguments back from call to reporttype |
@@ -19622,18 +19771,18 @@ | ||
19622 | 19771 | fprintf(stderr, "%s", " but found constant-argument of type u64"); |
19623 | 19772 | fprintf(stderr, "%s", "\n"); |
19624 | 19773 | exit(-1); |
19625 | - label = 1584LLU; // alternative complete | |
19774 | + label = 1598LLU; // alternative complete | |
19626 | 19775 | break; |
19627 | 19776 | } |
19628 | - case 1584LLU: // completed if-then-else | |
19777 | + case 1598LLU: // completed if-then-else | |
19629 | 19778 | { |
19630 | 19779 | |
19631 | - uint64_t *newstack = (uint64_t *)(stack[base + 41] - sizeof(uint64_t) * 4); | |
19780 | + uint64_t *newstack = (uint64_t *)(stack[base + 43] - sizeof(uint64_t) * 4); | |
19632 | 19781 | // call ~type from ProcCall |
19633 | 19782 | newstack[0] = (uint64_t)stack; // backup stack location |
19634 | 19783 | newstack[1] = 1234567890; |
19635 | 19784 | newstack[2] = base; |
19636 | - newstack[3] = 1593LLU; | |
19785 | + newstack[3] = 1607LLU; | |
19637 | 19786 | stack = newstack; |
19638 | 19787 | // set stack-base & callee-address |
19639 | 19788 | base = 4/*deloffset*/; |
@@ -19640,27 +19789,27 @@ | ||
19640 | 19789 | label = 295LLU; // ~type |
19641 | 19790 | break; |
19642 | 19791 | } |
19643 | - case 1593LLU: // return from ~type to ProcCall | |
19792 | + case 1607LLU: // return from ~type to ProcCall | |
19644 | 19793 | { |
19645 | 19794 | stack = (uint64_t *)stack[0]; |
19646 | 19795 | // releasing toplevel container |
19647 | - Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 41] - sizeof(uint64_t) * 4)); | |
19796 | + Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 43] - sizeof(uint64_t) * 4)); | |
19648 | 19797 | |
19649 | - ((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40]; | |
19650 | - ((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39]; | |
19651 | - label = 1577LLU; // case complete | |
19798 | + ((uint64_t **)(stack[base + 39]))[1][1] = stack[base + 42]; | |
19799 | + ((uint64_t **)(stack[base + 39]))[1][0] = stack[base + 41]; | |
19800 | + label = 1591LLU; // case complete | |
19652 | 19801 | break; |
19653 | 19802 | } |
19654 | - case 1578LLU: // try next case | |
19803 | + case 1592LLU: // try next case | |
19655 | 19804 | { |
19656 | 19805 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
19657 | 19806 | exit(-1); |
19658 | 19807 | } |
19659 | - case 1577LLU: // completed switch | |
19808 | + case 1591LLU: // completed switch | |
19660 | 19809 | { |
19661 | - if(!stack[base + 38]/*mutable*/) | |
19810 | + if(!stack[base + 40]/*mutable*/) | |
19662 | 19811 | { |
19663 | - label = 1594LLU; // jump to alternative | |
19812 | + label = 1608LLU; // jump to alternative | |
19664 | 19813 | break; |
19665 | 19814 | } |
19666 | 19815 |
@@ -19667,363 +19816,363 @@ | ||
19667 | 19816 | // consequent |
19668 | 19817 | fprintf(stderr, "%s", "in function "); |
19669 | 19818 | // call reportid from ProcCall |
19670 | - stack[base + 39LLU] = 1596LLU/*throw to this address*/; | |
19671 | - stack[base + 40LLU] = base; | |
19672 | - stack[base + 41LLU] = 1597LLU; | |
19819 | + stack[base + 41LLU] = 1610LLU/*throw to this address*/; | |
19820 | + stack[base + 42LLU] = base; | |
19821 | + stack[base + 43LLU] = 1611LLU; | |
19673 | 19822 | // arguments for call to reportid |
19674 | - stack[base + 42LLU] = stack[base + 7]/*fnid*/; | |
19823 | + stack[base + 44LLU] = stack[base + 8]/*fnid*/; | |
19675 | 19824 | // set stack-base & callee-address |
19676 | - base += 42LLU; | |
19825 | + base += 44LLU; | |
19677 | 19826 | label = 18446744073709551586LLU; // reportid |
19678 | 19827 | break; |
19679 | 19828 | } |
19680 | - case 1596LLU: // copy-back deleter (reportid to ProcCall) | |
19829 | + case 1610LLU: // copy-back deleter (reportid to ProcCall) | |
19681 | 19830 | { |
19682 | 19831 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
19683 | 19832 | // copy mutable arguments back from call to reportid |
19684 | - label = 1551LLU; // continue to roll stack | |
19833 | + label = 1565LLU; // continue to roll stack | |
19685 | 19834 | break; |
19686 | 19835 | } |
19687 | - case 1597LLU: // return from reportid to ProcCall | |
19836 | + case 1611LLU: // return from reportid to ProcCall | |
19688 | 19837 | { |
19689 | 19838 | // copy mutable arguments back from call to reportid |
19690 | 19839 | fprintf(stderr, "%s", ", calling "); |
19691 | 19840 | // call reportid from ProcCall |
19692 | - stack[base + 39LLU] = 1598LLU/*throw to this address*/; | |
19693 | - stack[base + 40LLU] = base; | |
19694 | - stack[base + 41LLU] = 1599LLU; | |
19841 | + stack[base + 41LLU] = 1612LLU/*throw to this address*/; | |
19842 | + stack[base + 42LLU] = base; | |
19843 | + stack[base + 43LLU] = 1613LLU; | |
19695 | 19844 | // arguments for call to reportid |
19696 | - stack[base + 42LLU] = stack[base + 23]/*ceid*/; | |
19845 | + stack[base + 44LLU] = stack[base + 24]/*ceid*/; | |
19697 | 19846 | // set stack-base & callee-address |
19698 | - base += 42LLU; | |
19847 | + base += 44LLU; | |
19699 | 19848 | label = 18446744073709551586LLU; // reportid |
19700 | 19849 | break; |
19701 | 19850 | } |
19702 | - case 1598LLU: // copy-back deleter (reportid to ProcCall) | |
19851 | + case 1612LLU: // copy-back deleter (reportid to ProcCall) | |
19703 | 19852 | { |
19704 | 19853 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
19705 | 19854 | // copy mutable arguments back from call to reportid |
19706 | - label = 1551LLU; // continue to roll stack | |
19855 | + label = 1565LLU; // continue to roll stack | |
19707 | 19856 | break; |
19708 | 19857 | } |
19709 | - case 1599LLU: // return from reportid to ProcCall | |
19858 | + case 1613LLU: // return from reportid to ProcCall | |
19710 | 19859 | { |
19711 | 19860 | // copy mutable arguments back from call to reportid |
19712 | 19861 | fprintf(stderr, "%s", ": "); |
19713 | 19862 | fprintf(stderr, "%s", "can't use constant argument "); |
19714 | 19863 | // call printnr from ProcCall |
19715 | - stack[base + 39LLU] = 1600LLU/*throw to this address*/; | |
19716 | - stack[base + 40LLU] = base; | |
19717 | - stack[base + 41LLU] = 1601LLU; | |
19864 | + stack[base + 41LLU] = 1614LLU/*throw to this address*/; | |
19865 | + stack[base + 42LLU] = base; | |
19866 | + stack[base + 43LLU] = 1615LLU; | |
19718 | 19867 | // arguments for call to printnr |
19719 | - stack[base + 42LLU] = stack[base + 15]/*content*/; | |
19868 | + stack[base + 44LLU] = stack[base + 16]/*content*/; | |
19720 | 19869 | // set stack-base & callee-address |
19721 | - base += 42LLU; | |
19870 | + base += 44LLU; | |
19722 | 19871 | label = 18446744073709551590LLU; // printnr |
19723 | 19872 | break; |
19724 | 19873 | } |
19725 | - case 1600LLU: // copy-back deleter (printnr to ProcCall) | |
19874 | + case 1614LLU: // copy-back deleter (printnr to ProcCall) | |
19726 | 19875 | { |
19727 | 19876 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n"); |
19728 | 19877 | // copy mutable arguments back from call to printnr |
19729 | - label = 1551LLU; // continue to roll stack | |
19878 | + label = 1565LLU; // continue to roll stack | |
19730 | 19879 | break; |
19731 | 19880 | } |
19732 | - case 1601LLU: // return from printnr to ProcCall | |
19881 | + case 1615LLU: // return from printnr to ProcCall | |
19733 | 19882 | { |
19734 | 19883 | // copy mutable arguments back from call to printnr |
19735 | 19884 | printf("%s", " for mutable parameter "); |
19736 | 19885 | // call reportti from ProcCall |
19737 | - stack[base + 39LLU] = 1602LLU/*throw to this address*/; | |
19738 | - stack[base + 40LLU] = base; | |
19739 | - stack[base + 41LLU] = 1603LLU; | |
19886 | + stack[base + 41LLU] = 1616LLU/*throw to this address*/; | |
19887 | + stack[base + 42LLU] = base; | |
19888 | + stack[base + 43LLU] = 1617LLU; | |
19740 | 19889 | // arguments for call to reportti |
19741 | - stack[base + 42LLU] = stack[base + 37]/*typeid*/; | |
19890 | + stack[base + 44LLU] = stack[base + 39]/*typeid*/; | |
19742 | 19891 | // set stack-base & callee-address |
19743 | - base += 42LLU; | |
19892 | + base += 44LLU; | |
19744 | 19893 | label = 360LLU; // reportti |
19745 | 19894 | break; |
19746 | 19895 | } |
19747 | - case 1602LLU: // copy-back deleter (reportti to ProcCall) | |
19896 | + case 1616LLU: // copy-back deleter (reportti to ProcCall) | |
19748 | 19897 | { |
19749 | 19898 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportti to ProcCall)\n"); |
19750 | 19899 | // copy mutable arguments back from call to reportti |
19751 | - label = 1551LLU; // continue to roll stack | |
19900 | + label = 1565LLU; // continue to roll stack | |
19752 | 19901 | break; |
19753 | 19902 | } |
19754 | - case 1603LLU: // return from reportti to ProcCall | |
19903 | + case 1617LLU: // return from reportti to ProcCall | |
19755 | 19904 | { |
19756 | 19905 | // copy mutable arguments back from call to reportti |
19757 | 19906 | fprintf(stderr, "%s", "\n"); |
19758 | 19907 | exit(-1); |
19759 | - label = 1595LLU; // consequent complete | |
19908 | + label = 1609LLU; // consequent complete | |
19760 | 19909 | break; |
19761 | 19910 | } |
19762 | - case 1594LLU: // alternative | |
19911 | + case 1608LLU: // alternative | |
19763 | 19912 | { |
19764 | - label = 1595LLU; // alternative complete | |
19913 | + label = 1609LLU; // alternative complete | |
19765 | 19914 | break; |
19766 | 19915 | } |
19767 | - case 1595LLU: // completed if-then-else | |
19916 | + case 1609LLU: // completed if-then-else | |
19768 | 19917 | { |
19769 | - ((uint64_t **)(stack[base + 35]))[1][1] = stack[base + 38]; | |
19770 | - ((uint64_t **)(stack[base + 35]))[1][0] = stack[base + 37]; | |
19771 | - label = 1575LLU; // case complete | |
19918 | + ((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40]; | |
19919 | + ((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39]; | |
19920 | + label = 1589LLU; // case complete | |
19772 | 19921 | break; |
19773 | 19922 | } |
19774 | - case 1576LLU: // try next case | |
19923 | + case 1590LLU: // try next case | |
19775 | 19924 | { |
19776 | 19925 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
19777 | 19926 | exit(-1); |
19778 | 19927 | } |
19779 | - case 1575LLU: // completed switch | |
19928 | + case 1589LLU: // completed switch | |
19780 | 19929 | { |
19781 | 19930 | printf("%s", "\n newstack["); |
19782 | 19931 | // call printnr from ProcCall |
19783 | - stack[base + 37LLU] = 1604LLU/*throw to this address*/; | |
19784 | - stack[base + 38LLU] = base; | |
19785 | - stack[base + 39LLU] = 1605LLU; | |
19932 | + stack[base + 39LLU] = 1618LLU/*throw to this address*/; | |
19933 | + stack[base + 40LLU] = base; | |
19934 | + stack[base + 41LLU] = 1619LLU; | |
19786 | 19935 | // arguments for call to printnr |
19787 | - stack[base + 40LLU] = stack[base + 28]/*sum*/; | |
19936 | + stack[base + 42LLU] = stack[base + 30]/*sum*/; | |
19788 | 19937 | // set stack-base & callee-address |
19789 | - base += 40LLU; | |
19938 | + base += 42LLU; | |
19790 | 19939 | label = 18446744073709551590LLU; // printnr |
19791 | 19940 | break; |
19792 | 19941 | } |
19793 | - case 1604LLU: // copy-back deleter (printnr to ProcCall) | |
19942 | + case 1618LLU: // copy-back deleter (printnr to ProcCall) | |
19794 | 19943 | { |
19795 | 19944 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n"); |
19796 | 19945 | // copy mutable arguments back from call to printnr |
19797 | - label = 1551LLU; // continue to roll stack | |
19946 | + label = 1565LLU; // continue to roll stack | |
19798 | 19947 | break; |
19799 | 19948 | } |
19800 | - case 1605LLU: // return from printnr to ProcCall | |
19949 | + case 1619LLU: // return from printnr to ProcCall | |
19801 | 19950 | { |
19802 | 19951 | // copy mutable arguments back from call to printnr |
19803 | 19952 | printf("%s", "LLU] = "); |
19804 | 19953 | // call printnr from ProcCall |
19805 | - stack[base + 37LLU] = 1606LLU/*throw to this address*/; | |
19806 | - stack[base + 38LLU] = base; | |
19807 | - stack[base + 39LLU] = 1607LLU; | |
19954 | + stack[base + 39LLU] = 1620LLU/*throw to this address*/; | |
19955 | + stack[base + 40LLU] = base; | |
19956 | + stack[base + 41LLU] = 1621LLU; | |
19808 | 19957 | // arguments for call to printnr |
19809 | - stack[base + 40LLU] = stack[base + 15]/*content*/; | |
19958 | + stack[base + 42LLU] = stack[base + 16]/*content*/; | |
19810 | 19959 | // set stack-base & callee-address |
19811 | - base += 40LLU; | |
19960 | + base += 42LLU; | |
19812 | 19961 | label = 18446744073709551590LLU; // printnr |
19813 | 19962 | break; |
19814 | 19963 | } |
19815 | - case 1606LLU: // copy-back deleter (printnr to ProcCall) | |
19964 | + case 1620LLU: // copy-back deleter (printnr to ProcCall) | |
19816 | 19965 | { |
19817 | 19966 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n"); |
19818 | 19967 | // copy mutable arguments back from call to printnr |
19819 | - label = 1551LLU; // continue to roll stack | |
19968 | + label = 1565LLU; // continue to roll stack | |
19820 | 19969 | break; |
19821 | 19970 | } |
19822 | - case 1607LLU: // return from printnr to ProcCall | |
19971 | + case 1621LLU: // return from printnr to ProcCall | |
19823 | 19972 | { |
19824 | 19973 | // copy mutable arguments back from call to printnr |
19825 | 19974 | printf("%s", "LLU; // "); |
19826 | 19975 | // call printid from ProcCall |
19827 | - stack[base + 37LLU] = 1608LLU/*throw to this address*/; | |
19828 | - stack[base + 38LLU] = base; | |
19829 | - stack[base + 39LLU] = 1609LLU; | |
19976 | + stack[base + 39LLU] = 1622LLU/*throw to this address*/; | |
19977 | + stack[base + 40LLU] = base; | |
19978 | + stack[base + 41LLU] = 1623LLU; | |
19830 | 19979 | // arguments for call to printid |
19831 | - stack[base + 40LLU] = stack[base + 15]/*content*/; | |
19980 | + stack[base + 42LLU] = stack[base + 16]/*content*/; | |
19832 | 19981 | // set stack-base & callee-address |
19833 | - base += 40LLU; | |
19982 | + base += 42LLU; | |
19834 | 19983 | label = 18446744073709551587LLU; // printid |
19835 | 19984 | break; |
19836 | 19985 | } |
19837 | - case 1608LLU: // copy-back deleter (printid to ProcCall) | |
19986 | + case 1622LLU: // copy-back deleter (printid to ProcCall) | |
19838 | 19987 | { |
19839 | 19988 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n"); |
19840 | 19989 | // copy mutable arguments back from call to printid |
19841 | - label = 1551LLU; // continue to roll stack | |
19990 | + label = 1565LLU; // continue to roll stack | |
19842 | 19991 | break; |
19843 | 19992 | } |
19844 | - case 1609LLU: // return from printid to ProcCall | |
19993 | + case 1623LLU: // return from printid to ProcCall | |
19845 | 19994 | { |
19846 | 19995 | // copy mutable arguments back from call to printid |
19847 | - label = 1574LLU; // consequent complete | |
19996 | + label = 1588LLU; // consequent complete | |
19848 | 19997 | break; |
19849 | 19998 | } |
19850 | - case 1573LLU: // alternative | |
19999 | + case 1587LLU: // alternative | |
19851 | 20000 | { |
19852 | 20001 | // call equ from ProcCall |
19853 | - stack[base + 37LLU] = 1610LLU/*throw to this address*/; | |
19854 | - stack[base + 38LLU] = base; | |
19855 | - stack[base + 39LLU] = 1611LLU; | |
20002 | + stack[base + 39LLU] = 1624LLU/*throw to this address*/; | |
20003 | + stack[base + 40LLU] = base; | |
20004 | + stack[base + 41LLU] = 1625LLU; | |
19856 | 20005 | // arguments for call to equ |
19857 | - stack[base + 41LLU] = stack[base + 14]/*variant*/; | |
19858 | - stack[base + 42LLU] = 4LLU; | |
20006 | + stack[base + 43LLU] = stack[base + 15]/*variant*/; | |
20007 | + stack[base + 44LLU] = 4LLU; | |
19859 | 20008 | // set stack-base & callee-address |
19860 | - base += 40LLU; | |
20009 | + base += 42LLU; | |
19861 | 20010 | label = 18446744073709551600LLU; // equ |
19862 | 20011 | break; |
19863 | 20012 | } |
19864 | - case 1610LLU: // copy-back deleter (equ to ProcCall) | |
20013 | + case 1624LLU: // copy-back deleter (equ to ProcCall) | |
19865 | 20014 | { |
19866 | 20015 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (equ to ProcCall)\n"); |
19867 | 20016 | // copy mutable arguments back from call to equ |
19868 | - label = 1551LLU; // continue to roll stack | |
20017 | + label = 1565LLU; // continue to roll stack | |
19869 | 20018 | break; |
19870 | 20019 | } |
19871 | - case 1611LLU: // return from equ to ProcCall | |
20020 | + case 1625LLU: // return from equ to ProcCall | |
19872 | 20021 | { |
19873 | 20022 | // copy mutable arguments back from call to equ |
19874 | 20023 | // copy back results provided by call to equ |
19875 | - stack[base + 17] = stack[base + 40LLU]; | |
19876 | - if(!stack[base + 17]/*isequal*/) | |
20024 | + stack[base + 18] = stack[base + 42LLU]; | |
20025 | + if(!stack[base + 18]/*isequal*/) | |
19877 | 20026 | { |
19878 | - label = 1612LLU; // jump to alternative | |
20027 | + label = 1626LLU; // jump to alternative | |
19879 | 20028 | break; |
19880 | 20029 | } |
19881 | 20030 | |
19882 | 20031 | // consequent |
19883 | - if(/*param*/0 != ((uint64_t *)(stack[base + 35]/*param*/))[0]) | |
20032 | + if(/*param*/0 != ((uint64_t *)(stack[base + 37]/*param*/))[0]) | |
19884 | 20033 | { |
19885 | - label = 1615LLU; // jump to alternative | |
20034 | + label = 1629LLU; // jump to alternative | |
19886 | 20035 | break; |
19887 | 20036 | } |
19888 | 20037 | |
19889 | - /*typeid*/stack[base + 37] = ((uint64_t **)(stack[base + 35]/*param*/))[1][0]/*typeid*/; | |
19890 | - /*mutable*/stack[base + 38] = ((uint64_t **)(stack[base + 35]/*param*/))[1][1]/*mutable*/; | |
20038 | + /*typeid*/stack[base + 39] = ((uint64_t **)(stack[base + 37]/*param*/))[1][0]/*typeid*/; | |
20039 | + /*mutable*/stack[base + 40] = ((uint64_t **)(stack[base + 37]/*param*/))[1][1]/*mutable*/; | |
19891 | 20040 | |
19892 | 20041 | // case |
19893 | - if(/*typeid*/0 != ((uint64_t *)(stack[base + 37]/*typeid*/))[0]) | |
20042 | + if(/*typeid*/0 != ((uint64_t *)(stack[base + 39]/*typeid*/))[0]) | |
19894 | 20043 | { |
19895 | - label = 1617LLU; // jump to alternative | |
20044 | + label = 1631LLU; // jump to alternative | |
19896 | 20045 | break; |
19897 | 20046 | } |
19898 | 20047 | |
19899 | - /*expected*/stack[base + 39] = ((uint64_t **)(stack[base + 37]/*typeid*/))[1][0]/*type*/; | |
19900 | - /*paramname*/stack[base + 40] = ((uint64_t **)(stack[base + 37]/*typeid*/))[1][1]/*id*/; | |
20048 | + /*expected*/stack[base + 41] = ((uint64_t **)(stack[base + 39]/*typeid*/))[1][0]/*type*/; | |
20049 | + /*paramname*/stack[base + 42] = ((uint64_t **)(stack[base + 39]/*typeid*/))[1][1]/*id*/; | |
19901 | 20050 | |
19902 | 20051 | // case |
19903 | 20052 | // call equ from ProcCall |
19904 | - stack[base + 41LLU] = 1618LLU/*throw to this address*/; | |
19905 | - stack[base + 42LLU] = base; | |
19906 | - stack[base + 43LLU] = 1619LLU; | |
20053 | + stack[base + 43LLU] = 1632LLU/*throw to this address*/; | |
20054 | + stack[base + 44LLU] = base; | |
20055 | + stack[base + 45LLU] = 1633LLU; | |
19907 | 20056 | // arguments for call to equ |
19908 | - stack[base + 45LLU] = stack[base + 15]/*content*/; | |
19909 | - stack[base + 46LLU] = 621705506259468288LLU; | |
20057 | + stack[base + 47LLU] = stack[base + 16]/*content*/; | |
20058 | + stack[base + 48LLU] = 621705506259468288LLU; | |
19910 | 20059 | // set stack-base & callee-address |
19911 | - base += 44LLU; | |
20060 | + base += 46LLU; | |
19912 | 20061 | label = 18446744073709551600LLU; // equ |
19913 | 20062 | break; |
19914 | 20063 | } |
19915 | - case 1618LLU: // copy-back deleter (equ to ProcCall) | |
20064 | + case 1632LLU: // copy-back deleter (equ to ProcCall) | |
19916 | 20065 | { |
19917 | 20066 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (equ to ProcCall)\n"); |
19918 | 20067 | // copy mutable arguments back from call to equ |
19919 | - label = 1551LLU; // continue to roll stack | |
20068 | + label = 1565LLU; // continue to roll stack | |
19920 | 20069 | break; |
19921 | 20070 | } |
19922 | - case 1619LLU: // return from equ to ProcCall | |
20071 | + case 1633LLU: // return from equ to ProcCall | |
19923 | 20072 | { |
19924 | 20073 | // copy mutable arguments back from call to equ |
19925 | 20074 | // copy back results provided by call to equ |
19926 | - stack[base + 17] = stack[base + 44LLU]; | |
19927 | - if(!stack[base + 17]/*isequal*/) | |
20075 | + stack[base + 18] = stack[base + 46LLU]; | |
20076 | + if(!stack[base + 18]/*isequal*/) | |
19928 | 20077 | { |
19929 | - label = 1620LLU; // jump to alternative | |
20078 | + label = 1634LLU; // jump to alternative | |
19930 | 20079 | break; |
19931 | 20080 | } |
19932 | 20081 | |
19933 | 20082 | // consequent |
19934 | 20083 | // call matchsym from ProcCall |
19935 | - stack[base + 41LLU] = 1622LLU/*throw to this address*/; | |
19936 | - stack[base + 42LLU] = base; | |
19937 | - stack[base + 43LLU] = 1623LLU; | |
20084 | + stack[base + 43LLU] = 1636LLU/*throw to this address*/; | |
20085 | + stack[base + 44LLU] = base; | |
20086 | + stack[base + 45LLU] = 1637LLU; | |
19938 | 20087 | // arguments for call to matchsym |
19939 | - stack[base + 44LLU] = stack[base + 7]/*fnid*/; | |
19940 | - stack[base + 45LLU] = 40LLU; | |
19941 | - stack[base + 46LLU] = stack[base + 13]/*lookahead*/; | |
20088 | + stack[base + 46LLU] = stack[base + 8]/*fnid*/; | |
20089 | + stack[base + 47LLU] = 40LLU; | |
20090 | + stack[base + 48LLU] = stack[base + 14]/*lookahead*/; | |
19942 | 20091 | // set stack-base & callee-address |
19943 | - base += 44LLU; | |
20092 | + base += 46LLU; | |
19944 | 20093 | label = 211LLU; // matchsym |
19945 | 20094 | break; |
19946 | 20095 | } |
19947 | - case 1622LLU: // copy-back deleter (matchsym to ProcCall) | |
20096 | + case 1636LLU: // copy-back deleter (matchsym to ProcCall) | |
19948 | 20097 | { |
19949 | 20098 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (matchsym to ProcCall)\n"); |
19950 | 20099 | // copy mutable arguments back from call to matchsym |
19951 | - stack[base + 13]/*lookahead*/ = stack[base + 46LLU]; | |
19952 | - label = 1551LLU; // continue to roll stack | |
20100 | + stack[base + 14]/*lookahead*/ = stack[base + 48LLU]; | |
20101 | + label = 1565LLU; // continue to roll stack | |
19953 | 20102 | break; |
19954 | 20103 | } |
19955 | - case 1623LLU: // return from matchsym to ProcCall | |
20104 | + case 1637LLU: // return from matchsym to ProcCall | |
19956 | 20105 | { |
19957 | 20106 | // copy mutable arguments back from call to matchsym |
19958 | - stack[base + 13]/*lookahead*/ = stack[base + 46LLU]; | |
20107 | + stack[base + 14]/*lookahead*/ = stack[base + 48LLU]; | |
19959 | 20108 | // call matchsym from ProcCall |
19960 | - stack[base + 41LLU] = 1624LLU/*throw to this address*/; | |
19961 | - stack[base + 42LLU] = base; | |
19962 | - stack[base + 43LLU] = 1625LLU; | |
20109 | + stack[base + 43LLU] = 1638LLU/*throw to this address*/; | |
20110 | + stack[base + 44LLU] = base; | |
20111 | + stack[base + 45LLU] = 1639LLU; | |
19963 | 20112 | // arguments for call to matchsym |
19964 | - stack[base + 44LLU] = stack[base + 7]/*fnid*/; | |
19965 | - stack[base + 45LLU] = 41LLU; | |
19966 | - stack[base + 46LLU] = stack[base + 13]/*lookahead*/; | |
20113 | + stack[base + 46LLU] = stack[base + 8]/*fnid*/; | |
20114 | + stack[base + 47LLU] = 41LLU; | |
20115 | + stack[base + 48LLU] = stack[base + 14]/*lookahead*/; | |
19967 | 20116 | // set stack-base & callee-address |
19968 | - base += 44LLU; | |
20117 | + base += 46LLU; | |
19969 | 20118 | label = 211LLU; // matchsym |
19970 | 20119 | break; |
19971 | 20120 | } |
19972 | - case 1624LLU: // copy-back deleter (matchsym to ProcCall) | |
20121 | + case 1638LLU: // copy-back deleter (matchsym to ProcCall) | |
19973 | 20122 | { |
19974 | 20123 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (matchsym to ProcCall)\n"); |
19975 | 20124 | // copy mutable arguments back from call to matchsym |
19976 | - stack[base + 13]/*lookahead*/ = stack[base + 46LLU]; | |
19977 | - label = 1551LLU; // continue to roll stack | |
20125 | + stack[base + 14]/*lookahead*/ = stack[base + 48LLU]; | |
20126 | + label = 1565LLU; // continue to roll stack | |
19978 | 20127 | break; |
19979 | 20128 | } |
19980 | - case 1625LLU: // return from matchsym to ProcCall | |
20129 | + case 1639LLU: // return from matchsym to ProcCall | |
19981 | 20130 | { |
19982 | 20131 | // copy mutable arguments back from call to matchsym |
19983 | - stack[base + 13]/*lookahead*/ = stack[base + 46LLU]; | |
19984 | - if(/*typename*/0 != ((uint64_t *)(stack[base + 39]/*expected*/))[0]) | |
20132 | + stack[base + 14]/*lookahead*/ = stack[base + 48LLU]; | |
20133 | + if(/*typename*/0 != ((uint64_t *)(stack[base + 41]/*expected*/))[0]) | |
19985 | 20134 | { |
19986 | - label = 1627LLU; // jump to alternative | |
20135 | + label = 1641LLU; // jump to alternative | |
19987 | 20136 | break; |
19988 | 20137 | } |
19989 | 20138 | |
19990 | - /*name*/stack[base + 41] = ((uint64_t **)(stack[base + 39]/*expected*/))[1][0]/*name*/; | |
20139 | + /*name*/stack[base + 43] = ((uint64_t **)(stack[base + 41]/*expected*/))[1][0]/*name*/; | |
19991 | 20140 | |
19992 | 20141 | // case |
19993 | 20142 | // call equ from ProcCall |
19994 | - stack[base + 42LLU] = 1628LLU/*throw to this address*/; | |
19995 | - stack[base + 43LLU] = base; | |
19996 | - stack[base + 44LLU] = 1629LLU; | |
20143 | + stack[base + 44LLU] = 1642LLU/*throw to this address*/; | |
20144 | + stack[base + 45LLU] = base; | |
20145 | + stack[base + 46LLU] = 1643LLU; | |
19997 | 20146 | // arguments for call to equ |
19998 | - stack[base + 46LLU] = stack[base + 41]/*name*/; | |
19999 | - stack[base + 47LLU] = 881834713755418624LLU; | |
20147 | + stack[base + 48LLU] = stack[base + 43]/*name*/; | |
20148 | + stack[base + 49LLU] = 881834713755418624LLU; | |
20000 | 20149 | // set stack-base & callee-address |
20001 | - base += 45LLU; | |
20150 | + base += 47LLU; | |
20002 | 20151 | label = 18446744073709551600LLU; // equ |
20003 | 20152 | break; |
20004 | 20153 | } |
20005 | - case 1628LLU: // copy-back deleter (equ to ProcCall) | |
20154 | + case 1642LLU: // copy-back deleter (equ to ProcCall) | |
20006 | 20155 | { |
20007 | 20156 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (equ to ProcCall)\n"); |
20008 | 20157 | // copy mutable arguments back from call to equ |
20009 | - label = 1551LLU; // continue to roll stack | |
20158 | + label = 1565LLU; // continue to roll stack | |
20010 | 20159 | break; |
20011 | 20160 | } |
20012 | - case 1629LLU: // return from equ to ProcCall | |
20161 | + case 1643LLU: // return from equ to ProcCall | |
20013 | 20162 | { |
20014 | 20163 | // copy mutable arguments back from call to equ |
20015 | 20164 | // copy back results provided by call to equ |
20016 | - stack[base + 17] = stack[base + 45LLU]; | |
20017 | - if(!stack[base + 17]/*isequal*/) | |
20165 | + stack[base + 18] = stack[base + 47LLU]; | |
20166 | + if(!stack[base + 18]/*isequal*/) | |
20018 | 20167 | { |
20019 | - label = 1630LLU; // jump to alternative | |
20168 | + label = 1644LLU; // jump to alternative | |
20020 | 20169 | break; |
20021 | 20170 | } |
20022 | 20171 | |
20023 | 20172 | // consequent |
20024 | - if(!stack[base + 38]/*mutable*/) | |
20173 | + if(!stack[base + 40]/*mutable*/) | |
20025 | 20174 | { |
20026 | - label = 1632LLU; // jump to alternative | |
20175 | + label = 1646LLU; // jump to alternative | |
20027 | 20176 | break; |
20028 | 20177 | } |
20029 | 20178 |
@@ -20030,46 +20179,46 @@ | ||
20030 | 20179 | // consequent |
20031 | 20180 | fprintf(stderr, "%s", "in function "); |
20032 | 20181 | // call reportid from ProcCall |
20033 | - stack[base + 42LLU] = 1634LLU/*throw to this address*/; | |
20034 | - stack[base + 43LLU] = base; | |
20035 | - stack[base + 44LLU] = 1635LLU; | |
20182 | + stack[base + 44LLU] = 1648LLU/*throw to this address*/; | |
20183 | + stack[base + 45LLU] = base; | |
20184 | + stack[base + 46LLU] = 1649LLU; | |
20036 | 20185 | // arguments for call to reportid |
20037 | - stack[base + 45LLU] = stack[base + 7]/*fnid*/; | |
20186 | + stack[base + 47LLU] = stack[base + 8]/*fnid*/; | |
20038 | 20187 | // set stack-base & callee-address |
20039 | - base += 45LLU; | |
20188 | + base += 47LLU; | |
20040 | 20189 | label = 18446744073709551586LLU; // reportid |
20041 | 20190 | break; |
20042 | 20191 | } |
20043 | - case 1634LLU: // copy-back deleter (reportid to ProcCall) | |
20192 | + case 1648LLU: // copy-back deleter (reportid to ProcCall) | |
20044 | 20193 | { |
20045 | 20194 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
20046 | 20195 | // copy mutable arguments back from call to reportid |
20047 | - label = 1551LLU; // continue to roll stack | |
20196 | + label = 1565LLU; // continue to roll stack | |
20048 | 20197 | break; |
20049 | 20198 | } |
20050 | - case 1635LLU: // return from reportid to ProcCall | |
20199 | + case 1649LLU: // return from reportid to ProcCall | |
20051 | 20200 | { |
20052 | 20201 | // copy mutable arguments back from call to reportid |
20053 | 20202 | fprintf(stderr, "%s", ", call to "); |
20054 | 20203 | // call reportid from ProcCall |
20055 | - stack[base + 42LLU] = 1636LLU/*throw to this address*/; | |
20056 | - stack[base + 43LLU] = base; | |
20057 | - stack[base + 44LLU] = 1637LLU; | |
20204 | + stack[base + 44LLU] = 1650LLU/*throw to this address*/; | |
20205 | + stack[base + 45LLU] = base; | |
20206 | + stack[base + 46LLU] = 1651LLU; | |
20058 | 20207 | // arguments for call to reportid |
20059 | - stack[base + 45LLU] = stack[base + 23]/*ceid*/; | |
20208 | + stack[base + 47LLU] = stack[base + 24]/*ceid*/; | |
20060 | 20209 | // set stack-base & callee-address |
20061 | - base += 45LLU; | |
20210 | + base += 47LLU; | |
20062 | 20211 | label = 18446744073709551586LLU; // reportid |
20063 | 20212 | break; |
20064 | 20213 | } |
20065 | - case 1636LLU: // copy-back deleter (reportid to ProcCall) | |
20214 | + case 1650LLU: // copy-back deleter (reportid to ProcCall) | |
20066 | 20215 | { |
20067 | 20216 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
20068 | 20217 | // copy mutable arguments back from call to reportid |
20069 | - label = 1551LLU; // continue to roll stack | |
20218 | + label = 1565LLU; // continue to roll stack | |
20070 | 20219 | break; |
20071 | 20220 | } |
20072 | - case 1637LLU: // return from reportid to ProcCall | |
20221 | + case 1651LLU: // return from reportid to ProcCall | |
20073 | 20222 | { |
20074 | 20223 | // copy mutable arguments back from call to reportid |
20075 | 20224 | fprintf(stderr, "%s", ": can't put constant argument u64 getbyte() into mutable parameter "); |
@@ -20076,7 +20225,7 @@ | ||
20076 | 20225 | uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t)); |
20077 | 20226 | if(!newstack) |
20078 | 20227 | { |
20079 | - label = 1551LLU; // throw: begin to unroll stack | |
20228 | + label = 1565LLU; // throw: begin to unroll stack | |
20080 | 20229 | break; |
20081 | 20230 | } |
20082 | 20231 |
@@ -20083,11 +20232,11 @@ | ||
20083 | 20232 | newstack[10LLU] = 9876543210LLU; // overflow-marker |
20084 | 20233 | // call reporttype from ProcCall |
20085 | 20234 | newstack[0] = (uint64_t)stack; // backup stack location |
20086 | - newstack[1] = 1638LLU; | |
20235 | + newstack[1] = 1652LLU; | |
20087 | 20236 | newstack[2] = base; |
20088 | - newstack[3] = 1639LLU; | |
20237 | + newstack[3] = 1653LLU; | |
20089 | 20238 | // arguments for call to reporttype |
20090 | - newstack[4LLU] = stack[base + 39]/*expected*/; | |
20239 | + newstack[4LLU] = stack[base + 41]/*expected*/; | |
20091 | 20240 | stack = newstack; |
20092 | 20241 | // set stack-base & callee-address |
20093 | 20242 | base = 4/*deloffset*/; |
@@ -20094,7 +20243,7 @@ | ||
20094 | 20243 | label = 313LLU; // reporttype |
20095 | 20244 | break; |
20096 | 20245 | } |
20097 | - case 1638LLU: // copy-back deleter (reporttype to ProcCall) | |
20246 | + case 1652LLU: // copy-back deleter (reporttype to ProcCall) | |
20098 | 20247 | { |
20099 | 20248 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n"); |
20100 | 20249 | uint64_t *oldstack = (uint64_t *)stack[0]; |
@@ -20106,10 +20255,10 @@ | ||
20106 | 20255 | } |
20107 | 20256 | Free(10LLU + 1, sizeof(uint64_t), stack); |
20108 | 20257 | stack = oldstack; |
20109 | - label = 1551LLU; // continue to unroll stack | |
20258 | + label = 1565LLU; // continue to unroll stack | |
20110 | 20259 | break; |
20111 | 20260 | } |
20112 | - case 1639LLU: // return from reporttype to ProcCall | |
20261 | + case 1653LLU: // return from reporttype to ProcCall | |
20113 | 20262 | { |
20114 | 20263 | uint64_t *oldstack = (uint64_t *)stack[0]; |
20115 | 20264 | // copy mutable arguments back from call to reporttype |
@@ -20121,131 +20270,131 @@ | ||
20121 | 20270 | Free(10LLU + 1, sizeof(uint64_t), stack); |
20122 | 20271 | stack = oldstack; |
20123 | 20272 | // call reportid from ProcCall |
20124 | - stack[base + 42LLU] = 1640LLU/*throw to this address*/; | |
20125 | - stack[base + 43LLU] = base; | |
20126 | - stack[base + 44LLU] = 1641LLU; | |
20273 | + stack[base + 44LLU] = 1654LLU/*throw to this address*/; | |
20274 | + stack[base + 45LLU] = base; | |
20275 | + stack[base + 46LLU] = 1655LLU; | |
20127 | 20276 | // arguments for call to reportid |
20128 | - stack[base + 45LLU] = stack[base + 40]/*paramname*/; | |
20277 | + stack[base + 47LLU] = stack[base + 42]/*paramname*/; | |
20129 | 20278 | // set stack-base & callee-address |
20130 | - base += 45LLU; | |
20279 | + base += 47LLU; | |
20131 | 20280 | label = 18446744073709551586LLU; // reportid |
20132 | 20281 | break; |
20133 | 20282 | } |
20134 | - case 1640LLU: // copy-back deleter (reportid to ProcCall) | |
20283 | + case 1654LLU: // copy-back deleter (reportid to ProcCall) | |
20135 | 20284 | { |
20136 | 20285 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
20137 | 20286 | // copy mutable arguments back from call to reportid |
20138 | - label = 1551LLU; // continue to roll stack | |
20287 | + label = 1565LLU; // continue to roll stack | |
20139 | 20288 | break; |
20140 | 20289 | } |
20141 | - case 1641LLU: // return from reportid to ProcCall | |
20290 | + case 1655LLU: // return from reportid to ProcCall | |
20142 | 20291 | { |
20143 | 20292 | // copy mutable arguments back from call to reportid |
20144 | 20293 | fprintf(stderr, "%s", "\n"); |
20145 | 20294 | exit(-1); |
20146 | - label = 1633LLU; // consequent complete | |
20295 | + label = 1647LLU; // consequent complete | |
20147 | 20296 | break; |
20148 | 20297 | } |
20149 | - case 1632LLU: // alternative | |
20298 | + case 1646LLU: // alternative | |
20150 | 20299 | { |
20151 | - stack[base + 33]/*csubstruct*/ = 1; | |
20300 | + stack[base + 35]/*csubstruct*/ = 1; | |
20152 | 20301 | printf("%s", "\n newstack["); |
20153 | 20302 | // call printnr from ProcCall |
20154 | - stack[base + 42LLU] = 1642LLU/*throw to this address*/; | |
20155 | - stack[base + 43LLU] = base; | |
20156 | - stack[base + 44LLU] = 1643LLU; | |
20303 | + stack[base + 44LLU] = 1656LLU/*throw to this address*/; | |
20304 | + stack[base + 45LLU] = base; | |
20305 | + stack[base + 46LLU] = 1657LLU; | |
20157 | 20306 | // arguments for call to printnr |
20158 | - stack[base + 45LLU] = stack[base + 28]/*sum*/; | |
20307 | + stack[base + 47LLU] = stack[base + 30]/*sum*/; | |
20159 | 20308 | // set stack-base & callee-address |
20160 | - base += 45LLU; | |
20309 | + base += 47LLU; | |
20161 | 20310 | label = 18446744073709551590LLU; // printnr |
20162 | 20311 | break; |
20163 | 20312 | } |
20164 | - case 1642LLU: // copy-back deleter (printnr to ProcCall) | |
20313 | + case 1656LLU: // copy-back deleter (printnr to ProcCall) | |
20165 | 20314 | { |
20166 | 20315 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n"); |
20167 | 20316 | // copy mutable arguments back from call to printnr |
20168 | - label = 1551LLU; // continue to roll stack | |
20317 | + label = 1565LLU; // continue to roll stack | |
20169 | 20318 | break; |
20170 | 20319 | } |
20171 | - case 1643LLU: // return from printnr to ProcCall | |
20320 | + case 1657LLU: // return from printnr to ProcCall | |
20172 | 20321 | { |
20173 | 20322 | // copy mutable arguments back from call to printnr |
20174 | 20323 | printf("%s", "LLU] = getchar();"); |
20175 | - label = 1633LLU; // alternative complete | |
20324 | + label = 1647LLU; // alternative complete | |
20176 | 20325 | break; |
20177 | 20326 | } |
20178 | - case 1633LLU: // completed if-then-else | |
20327 | + case 1647LLU: // completed if-then-else | |
20179 | 20328 | { |
20180 | - label = 1631LLU; // consequent complete | |
20329 | + label = 1645LLU; // consequent complete | |
20181 | 20330 | break; |
20182 | 20331 | } |
20183 | - case 1630LLU: // alternative | |
20332 | + case 1644LLU: // alternative | |
20184 | 20333 | { |
20185 | 20334 | fprintf(stderr, "%s", "in function "); |
20186 | 20335 | // call reportid from ProcCall |
20187 | - stack[base + 42LLU] = 1644LLU/*throw to this address*/; | |
20188 | - stack[base + 43LLU] = base; | |
20189 | - stack[base + 44LLU] = 1645LLU; | |
20336 | + stack[base + 44LLU] = 1658LLU/*throw to this address*/; | |
20337 | + stack[base + 45LLU] = base; | |
20338 | + stack[base + 46LLU] = 1659LLU; | |
20190 | 20339 | // arguments for call to reportid |
20191 | - stack[base + 45LLU] = stack[base + 7]/*fnid*/; | |
20340 | + stack[base + 47LLU] = stack[base + 8]/*fnid*/; | |
20192 | 20341 | // set stack-base & callee-address |
20193 | - base += 45LLU; | |
20342 | + base += 47LLU; | |
20194 | 20343 | label = 18446744073709551586LLU; // reportid |
20195 | 20344 | break; |
20196 | 20345 | } |
20197 | - case 1644LLU: // copy-back deleter (reportid to ProcCall) | |
20346 | + case 1658LLU: // copy-back deleter (reportid to ProcCall) | |
20198 | 20347 | { |
20199 | 20348 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
20200 | 20349 | // copy mutable arguments back from call to reportid |
20201 | - label = 1551LLU; // continue to roll stack | |
20350 | + label = 1565LLU; // continue to roll stack | |
20202 | 20351 | break; |
20203 | 20352 | } |
20204 | - case 1645LLU: // return from reportid to ProcCall | |
20353 | + case 1659LLU: // return from reportid to ProcCall | |
20205 | 20354 | { |
20206 | 20355 | // copy mutable arguments back from call to reportid |
20207 | 20356 | fprintf(stderr, "%s", " recursive call to "); |
20208 | 20357 | // call reportid from ProcCall |
20209 | - stack[base + 42LLU] = 1646LLU/*throw to this address*/; | |
20210 | - stack[base + 43LLU] = base; | |
20211 | - stack[base + 44LLU] = 1647LLU; | |
20358 | + stack[base + 44LLU] = 1660LLU/*throw to this address*/; | |
20359 | + stack[base + 45LLU] = base; | |
20360 | + stack[base + 46LLU] = 1661LLU; | |
20212 | 20361 | // arguments for call to reportid |
20213 | - stack[base + 45LLU] = stack[base + 23]/*ceid*/; | |
20362 | + stack[base + 47LLU] = stack[base + 24]/*ceid*/; | |
20214 | 20363 | // set stack-base & callee-address |
20215 | - base += 45LLU; | |
20364 | + base += 47LLU; | |
20216 | 20365 | label = 18446744073709551586LLU; // reportid |
20217 | 20366 | break; |
20218 | 20367 | } |
20219 | - case 1646LLU: // copy-back deleter (reportid to ProcCall) | |
20368 | + case 1660LLU: // copy-back deleter (reportid to ProcCall) | |
20220 | 20369 | { |
20221 | 20370 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
20222 | 20371 | // copy mutable arguments back from call to reportid |
20223 | - label = 1551LLU; // continue to roll stack | |
20372 | + label = 1565LLU; // continue to roll stack | |
20224 | 20373 | break; |
20225 | 20374 | } |
20226 | - case 1647LLU: // return from reportid to ProcCall | |
20375 | + case 1661LLU: // return from reportid to ProcCall | |
20227 | 20376 | { |
20228 | 20377 | // copy mutable arguments back from call to reportid |
20229 | 20378 | fprintf(stderr, "%s", " at position "); |
20230 | 20379 | // call reportnr from ProcCall |
20231 | - stack[base + 42LLU] = 1648LLU/*throw to this address*/; | |
20232 | - stack[base + 43LLU] = base; | |
20233 | - stack[base + 44LLU] = 1649LLU; | |
20380 | + stack[base + 44LLU] = 1662LLU/*throw to this address*/; | |
20381 | + stack[base + 45LLU] = base; | |
20382 | + stack[base + 46LLU] = 1663LLU; | |
20234 | 20383 | // arguments for call to reportnr |
20235 | - stack[base + 45LLU] = stack[base + 30]/*index*/; | |
20384 | + stack[base + 47LLU] = stack[base + 32]/*index*/; | |
20236 | 20385 | // set stack-base & callee-address |
20237 | - base += 45LLU; | |
20386 | + base += 47LLU; | |
20238 | 20387 | label = 18446744073709551589LLU; // reportnr |
20239 | 20388 | break; |
20240 | 20389 | } |
20241 | - case 1648LLU: // copy-back deleter (reportnr to ProcCall) | |
20390 | + case 1662LLU: // copy-back deleter (reportnr to ProcCall) | |
20242 | 20391 | { |
20243 | 20392 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportnr to ProcCall)\n"); |
20244 | 20393 | // copy mutable arguments back from call to reportnr |
20245 | - label = 1551LLU; // continue to roll stack | |
20394 | + label = 1565LLU; // continue to roll stack | |
20246 | 20395 | break; |
20247 | 20396 | } |
20248 | - case 1649LLU: // return from reportnr to ProcCall | |
20397 | + case 1663LLU: // return from reportnr to ProcCall | |
20249 | 20398 | { |
20250 | 20399 | // copy mutable arguments back from call to reportnr |
20251 | 20400 | fprintf(stderr, "%s", " argument getbyte() requires parameter of type u64 but found "); |
@@ -20253,7 +20402,7 @@ | ||
20253 | 20402 | uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t)); |
20254 | 20403 | if(!newstack) |
20255 | 20404 | { |
20256 | - label = 1551LLU; // throw: begin to unroll stack | |
20405 | + label = 1565LLU; // throw: begin to unroll stack | |
20257 | 20406 | break; |
20258 | 20407 | } |
20259 | 20408 |
@@ -20260,11 +20409,11 @@ | ||
20260 | 20409 | newstack[10LLU] = 9876543210LLU; // overflow-marker |
20261 | 20410 | // call reporttype from ProcCall |
20262 | 20411 | newstack[0] = (uint64_t)stack; // backup stack location |
20263 | - newstack[1] = 1650LLU; | |
20412 | + newstack[1] = 1664LLU; | |
20264 | 20413 | newstack[2] = base; |
20265 | - newstack[3] = 1651LLU; | |
20414 | + newstack[3] = 1665LLU; | |
20266 | 20415 | // arguments for call to reporttype |
20267 | - newstack[4LLU] = stack[base + 39]/*expected*/; | |
20416 | + newstack[4LLU] = stack[base + 41]/*expected*/; | |
20268 | 20417 | stack = newstack; |
20269 | 20418 | // set stack-base & callee-address |
20270 | 20419 | base = 4/*deloffset*/; |
@@ -20271,7 +20420,7 @@ | ||
20271 | 20420 | label = 313LLU; // reporttype |
20272 | 20421 | break; |
20273 | 20422 | } |
20274 | - case 1650LLU: // copy-back deleter (reporttype to ProcCall) | |
20423 | + case 1664LLU: // copy-back deleter (reporttype to ProcCall) | |
20275 | 20424 | { |
20276 | 20425 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n"); |
20277 | 20426 | uint64_t *oldstack = (uint64_t *)stack[0]; |
@@ -20283,10 +20432,10 @@ | ||
20283 | 20432 | } |
20284 | 20433 | Free(10LLU + 1, sizeof(uint64_t), stack); |
20285 | 20434 | stack = oldstack; |
20286 | - label = 1551LLU; // continue to unroll stack | |
20435 | + label = 1565LLU; // continue to unroll stack | |
20287 | 20436 | break; |
20288 | 20437 | } |
20289 | - case 1651LLU: // return from reporttype to ProcCall | |
20438 | + case 1665LLU: // return from reporttype to ProcCall | |
20290 | 20439 | { |
20291 | 20440 | uint64_t *oldstack = (uint64_t *)stack[0]; |
20292 | 20441 | // copy mutable arguments back from call to reporttype |
@@ -20299,82 +20448,82 @@ | ||
20299 | 20448 | stack = oldstack; |
20300 | 20449 | fprintf(stderr, "%s", "\n"); |
20301 | 20450 | exit(-1); |
20302 | - label = 1631LLU; // alternative complete | |
20451 | + label = 1645LLU; // alternative complete | |
20303 | 20452 | break; |
20304 | 20453 | } |
20305 | - case 1631LLU: // completed if-then-else | |
20454 | + case 1645LLU: // completed if-then-else | |
20306 | 20455 | { |
20307 | - ((uint64_t **)(stack[base + 39]))[1][0] = stack[base + 41]; | |
20308 | - label = 1626LLU; // case complete | |
20456 | + ((uint64_t **)(stack[base + 41]))[1][0] = stack[base + 43]; | |
20457 | + label = 1640LLU; // case complete | |
20309 | 20458 | break; |
20310 | 20459 | } |
20311 | - case 1627LLU: // try next case | |
20460 | + case 1641LLU: // try next case | |
20312 | 20461 | { |
20313 | 20462 | // default |
20314 | 20463 | fprintf(stderr, "%s", "in function "); |
20315 | 20464 | // call reportid from ProcCall |
20316 | - stack[base + 41LLU] = 1652LLU/*throw to this address*/; | |
20317 | - stack[base + 42LLU] = base; | |
20318 | - stack[base + 43LLU] = 1653LLU; | |
20465 | + stack[base + 43LLU] = 1666LLU/*throw to this address*/; | |
20466 | + stack[base + 44LLU] = base; | |
20467 | + stack[base + 45LLU] = 1667LLU; | |
20319 | 20468 | // arguments for call to reportid |
20320 | - stack[base + 44LLU] = stack[base + 7]/*fnid*/; | |
20469 | + stack[base + 46LLU] = stack[base + 8]/*fnid*/; | |
20321 | 20470 | // set stack-base & callee-address |
20322 | - base += 44LLU; | |
20471 | + base += 46LLU; | |
20323 | 20472 | label = 18446744073709551586LLU; // reportid |
20324 | 20473 | break; |
20325 | 20474 | } |
20326 | - case 1652LLU: // copy-back deleter (reportid to ProcCall) | |
20475 | + case 1666LLU: // copy-back deleter (reportid to ProcCall) | |
20327 | 20476 | { |
20328 | 20477 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
20329 | 20478 | // copy mutable arguments back from call to reportid |
20330 | - label = 1551LLU; // continue to roll stack | |
20479 | + label = 1565LLU; // continue to roll stack | |
20331 | 20480 | break; |
20332 | 20481 | } |
20333 | - case 1653LLU: // return from reportid to ProcCall | |
20482 | + case 1667LLU: // return from reportid to ProcCall | |
20334 | 20483 | { |
20335 | 20484 | // copy mutable arguments back from call to reportid |
20336 | 20485 | fprintf(stderr, "%s", " recursive call to "); |
20337 | 20486 | // call reportid from ProcCall |
20338 | - stack[base + 41LLU] = 1654LLU/*throw to this address*/; | |
20339 | - stack[base + 42LLU] = base; | |
20340 | - stack[base + 43LLU] = 1655LLU; | |
20487 | + stack[base + 43LLU] = 1668LLU/*throw to this address*/; | |
20488 | + stack[base + 44LLU] = base; | |
20489 | + stack[base + 45LLU] = 1669LLU; | |
20341 | 20490 | // arguments for call to reportid |
20342 | - stack[base + 44LLU] = stack[base + 23]/*ceid*/; | |
20491 | + stack[base + 46LLU] = stack[base + 24]/*ceid*/; | |
20343 | 20492 | // set stack-base & callee-address |
20344 | - base += 44LLU; | |
20493 | + base += 46LLU; | |
20345 | 20494 | label = 18446744073709551586LLU; // reportid |
20346 | 20495 | break; |
20347 | 20496 | } |
20348 | - case 1654LLU: // copy-back deleter (reportid to ProcCall) | |
20497 | + case 1668LLU: // copy-back deleter (reportid to ProcCall) | |
20349 | 20498 | { |
20350 | 20499 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
20351 | 20500 | // copy mutable arguments back from call to reportid |
20352 | - label = 1551LLU; // continue to roll stack | |
20501 | + label = 1565LLU; // continue to roll stack | |
20353 | 20502 | break; |
20354 | 20503 | } |
20355 | - case 1655LLU: // return from reportid to ProcCall | |
20504 | + case 1669LLU: // return from reportid to ProcCall | |
20356 | 20505 | { |
20357 | 20506 | // copy mutable arguments back from call to reportid |
20358 | 20507 | fprintf(stderr, "%s", " at position "); |
20359 | 20508 | // call reportnr from ProcCall |
20360 | - stack[base + 41LLU] = 1656LLU/*throw to this address*/; | |
20361 | - stack[base + 42LLU] = base; | |
20362 | - stack[base + 43LLU] = 1657LLU; | |
20509 | + stack[base + 43LLU] = 1670LLU/*throw to this address*/; | |
20510 | + stack[base + 44LLU] = base; | |
20511 | + stack[base + 45LLU] = 1671LLU; | |
20363 | 20512 | // arguments for call to reportnr |
20364 | - stack[base + 44LLU] = stack[base + 30]/*index*/; | |
20513 | + stack[base + 46LLU] = stack[base + 32]/*index*/; | |
20365 | 20514 | // set stack-base & callee-address |
20366 | - base += 44LLU; | |
20515 | + base += 46LLU; | |
20367 | 20516 | label = 18446744073709551589LLU; // reportnr |
20368 | 20517 | break; |
20369 | 20518 | } |
20370 | - case 1656LLU: // copy-back deleter (reportnr to ProcCall) | |
20519 | + case 1670LLU: // copy-back deleter (reportnr to ProcCall) | |
20371 | 20520 | { |
20372 | 20521 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportnr to ProcCall)\n"); |
20373 | 20522 | // copy mutable arguments back from call to reportnr |
20374 | - label = 1551LLU; // continue to roll stack | |
20523 | + label = 1565LLU; // continue to roll stack | |
20375 | 20524 | break; |
20376 | 20525 | } |
20377 | - case 1657LLU: // return from reportnr to ProcCall | |
20526 | + case 1671LLU: // return from reportnr to ProcCall | |
20378 | 20527 | { |
20379 | 20528 | // copy mutable arguments back from call to reportnr |
20380 | 20529 | fprintf(stderr, "%s", " argument getbyte() requires parameter of type u64 but found "); |
@@ -20382,7 +20531,7 @@ | ||
20382 | 20531 | uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t)); |
20383 | 20532 | if(!newstack) |
20384 | 20533 | { |
20385 | - label = 1551LLU; // throw: begin to unroll stack | |
20534 | + label = 1565LLU; // throw: begin to unroll stack | |
20386 | 20535 | break; |
20387 | 20536 | } |
20388 | 20537 |
@@ -20389,11 +20538,11 @@ | ||
20389 | 20538 | newstack[10LLU] = 9876543210LLU; // overflow-marker |
20390 | 20539 | // call reporttype from ProcCall |
20391 | 20540 | newstack[0] = (uint64_t)stack; // backup stack location |
20392 | - newstack[1] = 1658LLU; | |
20541 | + newstack[1] = 1672LLU; | |
20393 | 20542 | newstack[2] = base; |
20394 | - newstack[3] = 1659LLU; | |
20543 | + newstack[3] = 1673LLU; | |
20395 | 20544 | // arguments for call to reporttype |
20396 | - newstack[4LLU] = stack[base + 39]/*expected*/; | |
20545 | + newstack[4LLU] = stack[base + 41]/*expected*/; | |
20397 | 20546 | stack = newstack; |
20398 | 20547 | // set stack-base & callee-address |
20399 | 20548 | base = 4/*deloffset*/; |
@@ -20400,7 +20549,7 @@ | ||
20400 | 20549 | label = 313LLU; // reporttype |
20401 | 20550 | break; |
20402 | 20551 | } |
20403 | - case 1658LLU: // copy-back deleter (reporttype to ProcCall) | |
20552 | + case 1672LLU: // copy-back deleter (reporttype to ProcCall) | |
20404 | 20553 | { |
20405 | 20554 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n"); |
20406 | 20555 | uint64_t *oldstack = (uint64_t *)stack[0]; |
@@ -20412,10 +20561,10 @@ | ||
20412 | 20561 | } |
20413 | 20562 | Free(10LLU + 1, sizeof(uint64_t), stack); |
20414 | 20563 | stack = oldstack; |
20415 | - label = 1551LLU; // continue to unroll stack | |
20564 | + label = 1565LLU; // continue to unroll stack | |
20416 | 20565 | break; |
20417 | 20566 | } |
20418 | - case 1659LLU: // return from reporttype to ProcCall | |
20567 | + case 1673LLU: // return from reporttype to ProcCall | |
20419 | 20568 | { |
20420 | 20569 | uint64_t *oldstack = (uint64_t *)stack[0]; |
20421 | 20570 | // copy mutable arguments back from call to reporttype |
@@ -20428,83 +20577,83 @@ | ||
20428 | 20577 | stack = oldstack; |
20429 | 20578 | fprintf(stderr, "%s", "\n"); |
20430 | 20579 | exit(-1); |
20431 | - label = 1626LLU; // default complete | |
20580 | + label = 1640LLU; // default complete | |
20432 | 20581 | break; |
20433 | 20582 | } |
20434 | - case 1626LLU: // completed switch | |
20583 | + case 1640LLU: // completed switch | |
20435 | 20584 | { |
20436 | - label = 1621LLU; // consequent complete | |
20585 | + label = 1635LLU; // consequent complete | |
20437 | 20586 | break; |
20438 | 20587 | } |
20439 | - case 1620LLU: // alternative | |
20588 | + case 1634LLU: // alternative | |
20440 | 20589 | { |
20441 | 20590 | // call FindLetNew from ProcCall |
20442 | - stack[base + 42LLU] = 1660LLU/*throw to this address*/; | |
20443 | - stack[base + 43LLU] = base; | |
20444 | - stack[base + 44LLU] = 1661LLU; | |
20591 | + stack[base + 44LLU] = 1674LLU/*throw to this address*/; | |
20592 | + stack[base + 45LLU] = base; | |
20593 | + stack[base + 46LLU] = 1675LLU; | |
20445 | 20594 | // arguments for call to FindLetNew |
20446 | - stack[base + 46LLU] = stack[base + 7]/*fnid*/; | |
20447 | - stack[base + 47LLU] = stack[base + 15]/*content*/; | |
20448 | - stack[base + 48LLU] = stack[base + 2]/*scopes*/; | |
20449 | - stack[base + 49LLU] = stack[base + 3]/*scope*/; | |
20595 | + stack[base + 48LLU] = stack[base + 8]/*fnid*/; | |
20596 | + stack[base + 49LLU] = stack[base + 16]/*content*/; | |
20597 | + stack[base + 50LLU] = stack[base + 2]/*scopes*/; | |
20598 | + stack[base + 51LLU] = stack[base + 3]/*scope*/; | |
20450 | 20599 | // set stack-base & callee-address |
20451 | - base += 45LLU; | |
20600 | + base += 47LLU; | |
20452 | 20601 | label = 561LLU; // FindLetNew |
20453 | 20602 | break; |
20454 | 20603 | } |
20455 | - case 1660LLU: // copy-back deleter (FindLetNew to ProcCall) | |
20604 | + case 1674LLU: // copy-back deleter (FindLetNew to ProcCall) | |
20456 | 20605 | { |
20457 | 20606 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (FindLetNew to ProcCall)\n"); |
20458 | 20607 | // copy mutable arguments back from call to FindLetNew |
20459 | - label = 1551LLU; // continue to roll stack | |
20608 | + label = 1565LLU; // continue to roll stack | |
20460 | 20609 | break; |
20461 | 20610 | } |
20462 | - case 1661LLU: // return from FindLetNew to ProcCall | |
20611 | + case 1675LLU: // return from FindLetNew to ProcCall | |
20463 | 20612 | { |
20464 | 20613 | // copy mutable arguments back from call to FindLetNew |
20465 | 20614 | // copy back results provided by call to FindLetNew |
20466 | - stack[base + 41] = stack[base + 45LLU]; | |
20467 | - if(/*letdef*/0 != ((uint64_t *)(stack[base + 41]/*letdef*/))[0]) | |
20615 | + stack[base + 43] = stack[base + 47LLU]; | |
20616 | + if(/*letdef*/0 != ((uint64_t *)(stack[base + 43]/*letdef*/))[0]) | |
20468 | 20617 | { |
20469 | - label = 1663LLU; // jump to alternative | |
20618 | + label = 1677LLU; // jump to alternative | |
20470 | 20619 | break; |
20471 | 20620 | } |
20472 | 20621 | |
20473 | - /*type*/stack[base + 42] = ((uint64_t **)(stack[base + 41]/*letdef*/))[1][0]/*type*/; | |
20474 | - /*ldid*/stack[base + 43] = ((uint64_t **)(stack[base + 41]/*letdef*/))[1][1]/*id*/; | |
20475 | - /*ldindex*/stack[base + 44] = ((uint64_t **)(stack[base + 41]/*letdef*/))[1][2]/*index*/; | |
20476 | - /*mutarg*/stack[base + 45] = ((uint64_t **)(stack[base + 41]/*letdef*/))[1][3]/*mutable*/; | |
20477 | - /*substruct*/stack[base + 46] = ((uint64_t **)(stack[base + 41]/*letdef*/))[1][4]/*substruct*/; | |
20622 | + /*type*/stack[base + 44] = ((uint64_t **)(stack[base + 43]/*letdef*/))[1][0]/*type*/; | |
20623 | + /*ldid*/stack[base + 45] = ((uint64_t **)(stack[base + 43]/*letdef*/))[1][1]/*id*/; | |
20624 | + /*ldindex*/stack[base + 46] = ((uint64_t **)(stack[base + 43]/*letdef*/))[1][2]/*index*/; | |
20625 | + /*mutarg*/stack[base + 47] = ((uint64_t **)(stack[base + 43]/*letdef*/))[1][3]/*mutable*/; | |
20626 | + /*substruct*/stack[base + 48] = ((uint64_t **)(stack[base + 43]/*letdef*/))[1][4]/*substruct*/; | |
20478 | 20627 | |
20479 | 20628 | // case |
20480 | 20629 | // call or from ProcCall |
20481 | - stack[base + 47LLU] = 1664LLU/*throw to this address*/; | |
20482 | - stack[base + 48LLU] = base; | |
20483 | - stack[base + 49LLU] = 1665LLU; | |
20630 | + stack[base + 49LLU] = 1678LLU/*throw to this address*/; | |
20631 | + stack[base + 50LLU] = base; | |
20632 | + stack[base + 51LLU] = 1679LLU; | |
20484 | 20633 | // arguments for call to or |
20485 | - stack[base + 51LLU] = stack[base + 33]/*csubstruct*/; | |
20486 | - stack[base + 52LLU] = stack[base + 46]/*substruct*/; | |
20634 | + stack[base + 53LLU] = stack[base + 35]/*csubstruct*/; | |
20635 | + stack[base + 54LLU] = stack[base + 48]/*substruct*/; | |
20487 | 20636 | // set stack-base & callee-address |
20488 | - base += 50LLU; | |
20637 | + base += 52LLU; | |
20489 | 20638 | label = 18446744073709551611LLU; // or |
20490 | 20639 | break; |
20491 | 20640 | } |
20492 | - case 1664LLU: // copy-back deleter (or to ProcCall) | |
20641 | + case 1678LLU: // copy-back deleter (or to ProcCall) | |
20493 | 20642 | { |
20494 | 20643 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (or to ProcCall)\n"); |
20495 | 20644 | // copy mutable arguments back from call to or |
20496 | - label = 1551LLU; // continue to roll stack | |
20645 | + label = 1565LLU; // continue to roll stack | |
20497 | 20646 | break; |
20498 | 20647 | } |
20499 | - case 1665LLU: // return from or to ProcCall | |
20648 | + case 1679LLU: // return from or to ProcCall | |
20500 | 20649 | { |
20501 | 20650 | // copy mutable arguments back from call to or |
20502 | 20651 | // copy back results provided by call to or |
20503 | - stack[base + 33] = stack[base + 50LLU]; | |
20652 | + stack[base + 35] = stack[base + 52LLU]; | |
20504 | 20653 | uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t)); |
20505 | 20654 | if(!newstack) |
20506 | 20655 | { |
20507 | - label = 1551LLU; // throw: begin to unroll stack | |
20656 | + label = 1565LLU; // throw: begin to unroll stack | |
20508 | 20657 | break; |
20509 | 20658 | } |
20510 | 20659 |
@@ -20511,12 +20660,12 @@ | ||
20511 | 20660 | newstack[15LLU] = 9876543210LLU; // overflow-marker |
20512 | 20661 | // call equtype from ProcCall |
20513 | 20662 | newstack[0] = (uint64_t)stack; // backup stack location |
20514 | - newstack[1] = 1666LLU; | |
20663 | + newstack[1] = 1680LLU; | |
20515 | 20664 | newstack[2] = base; |
20516 | - newstack[3] = 1667LLU; | |
20665 | + newstack[3] = 1681LLU; | |
20517 | 20666 | // arguments for call to equtype |
20518 | - newstack[5LLU] = stack[base + 42]/*type*/; | |
20519 | - newstack[6LLU] = stack[base + 39]/*expected*/; | |
20667 | + newstack[5LLU] = stack[base + 44]/*type*/; | |
20668 | + newstack[6LLU] = stack[base + 41]/*expected*/; | |
20520 | 20669 | stack = newstack; |
20521 | 20670 | // set stack-base & callee-address |
20522 | 20671 | base = 4/*deloffset*/; |
@@ -20523,7 +20672,7 @@ | ||
20523 | 20672 | label = 335LLU; // equtype |
20524 | 20673 | break; |
20525 | 20674 | } |
20526 | - case 1666LLU: // copy-back deleter (equtype to ProcCall) | |
20675 | + case 1680LLU: // copy-back deleter (equtype to ProcCall) | |
20527 | 20676 | { |
20528 | 20677 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (equtype to ProcCall)\n"); |
20529 | 20678 | uint64_t *oldstack = (uint64_t *)stack[0]; |
@@ -20535,15 +20684,15 @@ | ||
20535 | 20684 | } |
20536 | 20685 | Free(15LLU + 1, sizeof(uint64_t), stack); |
20537 | 20686 | stack = oldstack; |
20538 | - label = 1551LLU; // continue to unroll stack | |
20687 | + label = 1565LLU; // continue to unroll stack | |
20539 | 20688 | break; |
20540 | 20689 | } |
20541 | - case 1667LLU: // return from equtype to ProcCall | |
20690 | + case 1681LLU: // return from equtype to ProcCall | |
20542 | 20691 | { |
20543 | 20692 | uint64_t *oldstack = (uint64_t *)stack[0]; |
20544 | 20693 | // copy mutable arguments back from call to equtype |
20545 | 20694 | // copy back results provided by call to equtype |
20546 | - oldstack[base + 17] = stack[4LLU]; | |
20695 | + oldstack[base + 18] = stack[4LLU]; | |
20547 | 20696 | if(stack[15LLU] != 9876543210LLU) |
20548 | 20697 | { |
20549 | 20698 | fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to equtype)!"); |
@@ -20551,82 +20700,82 @@ | ||
20551 | 20700 | } |
20552 | 20701 | Free(15LLU + 1, sizeof(uint64_t), stack); |
20553 | 20702 | stack = oldstack; |
20554 | - if(!stack[base + 17]/*isequal*/) | |
20703 | + if(!stack[base + 18]/*isequal*/) | |
20555 | 20704 | { |
20556 | - label = 1668LLU; // jump to alternative | |
20705 | + label = 1682LLU; // jump to alternative | |
20557 | 20706 | break; |
20558 | 20707 | } |
20559 | 20708 | |
20560 | 20709 | // consequent |
20561 | - label = 1669LLU; // consequent complete | |
20710 | + label = 1683LLU; // consequent complete | |
20562 | 20711 | break; |
20563 | 20712 | } |
20564 | - case 1668LLU: // alternative | |
20713 | + case 1682LLU: // alternative | |
20565 | 20714 | { |
20566 | 20715 | fprintf(stderr, "%s", "in function "); |
20567 | 20716 | // call reportid from ProcCall |
20568 | - stack[base + 47LLU] = 1670LLU/*throw to this address*/; | |
20569 | - stack[base + 48LLU] = base; | |
20570 | - stack[base + 49LLU] = 1671LLU; | |
20717 | + stack[base + 49LLU] = 1684LLU/*throw to this address*/; | |
20718 | + stack[base + 50LLU] = base; | |
20719 | + stack[base + 51LLU] = 1685LLU; | |
20571 | 20720 | // arguments for call to reportid |
20572 | - stack[base + 50LLU] = stack[base + 7]/*fnid*/; | |
20721 | + stack[base + 52LLU] = stack[base + 8]/*fnid*/; | |
20573 | 20722 | // set stack-base & callee-address |
20574 | - base += 50LLU; | |
20723 | + base += 52LLU; | |
20575 | 20724 | label = 18446744073709551586LLU; // reportid |
20576 | 20725 | break; |
20577 | 20726 | } |
20578 | - case 1670LLU: // copy-back deleter (reportid to ProcCall) | |
20727 | + case 1684LLU: // copy-back deleter (reportid to ProcCall) | |
20579 | 20728 | { |
20580 | 20729 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
20581 | 20730 | // copy mutable arguments back from call to reportid |
20582 | - label = 1551LLU; // continue to roll stack | |
20731 | + label = 1565LLU; // continue to roll stack | |
20583 | 20732 | break; |
20584 | 20733 | } |
20585 | - case 1671LLU: // return from reportid to ProcCall | |
20734 | + case 1685LLU: // return from reportid to ProcCall | |
20586 | 20735 | { |
20587 | 20736 | // copy mutable arguments back from call to reportid |
20588 | 20737 | fprintf(stderr, "%s", " call to "); |
20589 | 20738 | // call reportid from ProcCall |
20590 | - stack[base + 47LLU] = 1672LLU/*throw to this address*/; | |
20591 | - stack[base + 48LLU] = base; | |
20592 | - stack[base + 49LLU] = 1673LLU; | |
20739 | + stack[base + 49LLU] = 1686LLU/*throw to this address*/; | |
20740 | + stack[base + 50LLU] = base; | |
20741 | + stack[base + 51LLU] = 1687LLU; | |
20593 | 20742 | // arguments for call to reportid |
20594 | - stack[base + 50LLU] = stack[base + 23]/*ceid*/; | |
20743 | + stack[base + 52LLU] = stack[base + 24]/*ceid*/; | |
20595 | 20744 | // set stack-base & callee-address |
20596 | - base += 50LLU; | |
20745 | + base += 52LLU; | |
20597 | 20746 | label = 18446744073709551586LLU; // reportid |
20598 | 20747 | break; |
20599 | 20748 | } |
20600 | - case 1672LLU: // copy-back deleter (reportid to ProcCall) | |
20749 | + case 1686LLU: // copy-back deleter (reportid to ProcCall) | |
20601 | 20750 | { |
20602 | 20751 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
20603 | 20752 | // copy mutable arguments back from call to reportid |
20604 | - label = 1551LLU; // continue to roll stack | |
20753 | + label = 1565LLU; // continue to roll stack | |
20605 | 20754 | break; |
20606 | 20755 | } |
20607 | - case 1673LLU: // return from reportid to ProcCall | |
20756 | + case 1687LLU: // return from reportid to ProcCall | |
20608 | 20757 | { |
20609 | 20758 | // copy mutable arguments back from call to reportid |
20610 | 20759 | fprintf(stderr, "%s", " at position "); |
20611 | 20760 | // call reportnr from ProcCall |
20612 | - stack[base + 47LLU] = 1674LLU/*throw to this address*/; | |
20613 | - stack[base + 48LLU] = base; | |
20614 | - stack[base + 49LLU] = 1675LLU; | |
20761 | + stack[base + 49LLU] = 1688LLU/*throw to this address*/; | |
20762 | + stack[base + 50LLU] = base; | |
20763 | + stack[base + 51LLU] = 1689LLU; | |
20615 | 20764 | // arguments for call to reportnr |
20616 | - stack[base + 50LLU] = stack[base + 30]/*index*/; | |
20765 | + stack[base + 52LLU] = stack[base + 32]/*index*/; | |
20617 | 20766 | // set stack-base & callee-address |
20618 | - base += 50LLU; | |
20767 | + base += 52LLU; | |
20619 | 20768 | label = 18446744073709551589LLU; // reportnr |
20620 | 20769 | break; |
20621 | 20770 | } |
20622 | - case 1674LLU: // copy-back deleter (reportnr to ProcCall) | |
20771 | + case 1688LLU: // copy-back deleter (reportnr to ProcCall) | |
20623 | 20772 | { |
20624 | 20773 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportnr to ProcCall)\n"); |
20625 | 20774 | // copy mutable arguments back from call to reportnr |
20626 | - label = 1551LLU; // continue to roll stack | |
20775 | + label = 1565LLU; // continue to roll stack | |
20627 | 20776 | break; |
20628 | 20777 | } |
20629 | - case 1675LLU: // return from reportnr to ProcCall | |
20778 | + case 1689LLU: // return from reportnr to ProcCall | |
20630 | 20779 | { |
20631 | 20780 | // copy mutable arguments back from call to reportnr |
20632 | 20781 | fprintf(stderr, "%s", " parameter type "); |
@@ -20633,7 +20782,7 @@ | ||
20633 | 20782 | uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t)); |
20634 | 20783 | if(!newstack) |
20635 | 20784 | { |
20636 | - label = 1551LLU; // throw: begin to unroll stack | |
20785 | + label = 1565LLU; // throw: begin to unroll stack | |
20637 | 20786 | break; |
20638 | 20787 | } |
20639 | 20788 |
@@ -20640,11 +20789,11 @@ | ||
20640 | 20789 | newstack[10LLU] = 9876543210LLU; // overflow-marker |
20641 | 20790 | // call reporttype from ProcCall |
20642 | 20791 | newstack[0] = (uint64_t)stack; // backup stack location |
20643 | - newstack[1] = 1676LLU; | |
20792 | + newstack[1] = 1690LLU; | |
20644 | 20793 | newstack[2] = base; |
20645 | - newstack[3] = 1677LLU; | |
20794 | + newstack[3] = 1691LLU; | |
20646 | 20795 | // arguments for call to reporttype |
20647 | - newstack[4LLU] = stack[base + 39]/*expected*/; | |
20796 | + newstack[4LLU] = stack[base + 41]/*expected*/; | |
20648 | 20797 | stack = newstack; |
20649 | 20798 | // set stack-base & callee-address |
20650 | 20799 | base = 4/*deloffset*/; |
@@ -20651,7 +20800,7 @@ | ||
20651 | 20800 | label = 313LLU; // reporttype |
20652 | 20801 | break; |
20653 | 20802 | } |
20654 | - case 1676LLU: // copy-back deleter (reporttype to ProcCall) | |
20803 | + case 1690LLU: // copy-back deleter (reporttype to ProcCall) | |
20655 | 20804 | { |
20656 | 20805 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n"); |
20657 | 20806 | uint64_t *oldstack = (uint64_t *)stack[0]; |
@@ -20663,10 +20812,10 @@ | ||
20663 | 20812 | } |
20664 | 20813 | Free(10LLU + 1, sizeof(uint64_t), stack); |
20665 | 20814 | stack = oldstack; |
20666 | - label = 1551LLU; // continue to unroll stack | |
20815 | + label = 1565LLU; // continue to unroll stack | |
20667 | 20816 | break; |
20668 | 20817 | } |
20669 | - case 1677LLU: // return from reporttype to ProcCall | |
20818 | + case 1691LLU: // return from reporttype to ProcCall | |
20670 | 20819 | { |
20671 | 20820 | uint64_t *oldstack = (uint64_t *)stack[0]; |
20672 | 20821 | // copy mutable arguments back from call to reporttype |
@@ -20681,7 +20830,7 @@ | ||
20681 | 20830 | uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t)); |
20682 | 20831 | if(!newstack) |
20683 | 20832 | { |
20684 | - label = 1551LLU; // throw: begin to unroll stack | |
20833 | + label = 1565LLU; // throw: begin to unroll stack | |
20685 | 20834 | break; |
20686 | 20835 | } |
20687 | 20836 |
@@ -20688,11 +20837,11 @@ | ||
20688 | 20837 | newstack[10LLU] = 9876543210LLU; // overflow-marker |
20689 | 20838 | // call reporttype from ProcCall |
20690 | 20839 | newstack[0] = (uint64_t)stack; // backup stack location |
20691 | - newstack[1] = 1678LLU; | |
20840 | + newstack[1] = 1692LLU; | |
20692 | 20841 | newstack[2] = base; |
20693 | - newstack[3] = 1679LLU; | |
20842 | + newstack[3] = 1693LLU; | |
20694 | 20843 | // arguments for call to reporttype |
20695 | - newstack[4LLU] = stack[base + 42]/*type*/; | |
20844 | + newstack[4LLU] = stack[base + 44]/*type*/; | |
20696 | 20845 | stack = newstack; |
20697 | 20846 | // set stack-base & callee-address |
20698 | 20847 | base = 4/*deloffset*/; |
@@ -20699,7 +20848,7 @@ | ||
20699 | 20848 | label = 313LLU; // reporttype |
20700 | 20849 | break; |
20701 | 20850 | } |
20702 | - case 1678LLU: // copy-back deleter (reporttype to ProcCall) | |
20851 | + case 1692LLU: // copy-back deleter (reporttype to ProcCall) | |
20703 | 20852 | { |
20704 | 20853 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n"); |
20705 | 20854 | uint64_t *oldstack = (uint64_t *)stack[0]; |
@@ -20711,10 +20860,10 @@ | ||
20711 | 20860 | } |
20712 | 20861 | Free(10LLU + 1, sizeof(uint64_t), stack); |
20713 | 20862 | stack = oldstack; |
20714 | - label = 1551LLU; // continue to unroll stack | |
20863 | + label = 1565LLU; // continue to unroll stack | |
20715 | 20864 | break; |
20716 | 20865 | } |
20717 | - case 1679LLU: // return from reporttype to ProcCall | |
20866 | + case 1693LLU: // return from reporttype to ProcCall | |
20718 | 20867 | { |
20719 | 20868 | uint64_t *oldstack = (uint64_t *)stack[0]; |
20720 | 20869 | // copy mutable arguments back from call to reporttype |
@@ -20727,52 +20876,52 @@ | ||
20727 | 20876 | stack = oldstack; |
20728 | 20877 | fprintf(stderr, "%s", "\n"); |
20729 | 20878 | exit(-1); |
20730 | - label = 1669LLU; // alternative complete | |
20879 | + label = 1683LLU; // alternative complete | |
20731 | 20880 | break; |
20732 | 20881 | } |
20733 | - case 1669LLU: // completed if-then-else | |
20882 | + case 1683LLU: // completed if-then-else | |
20734 | 20883 | { |
20735 | - if(!stack[base + 38]/*mutable*/) | |
20884 | + if(!stack[base + 40]/*mutable*/) | |
20736 | 20885 | { |
20737 | - label = 1680LLU; // jump to alternative | |
20886 | + label = 1694LLU; // jump to alternative | |
20738 | 20887 | break; |
20739 | 20888 | } |
20740 | 20889 | |
20741 | 20890 | // consequent |
20742 | - if(!stack[base + 45]/*mutarg*/) | |
20891 | + if(!stack[base + 47]/*mutarg*/) | |
20743 | 20892 | { |
20744 | - label = 1682LLU; // jump to alternative | |
20893 | + label = 1696LLU; // jump to alternative | |
20745 | 20894 | break; |
20746 | 20895 | } |
20747 | 20896 | |
20748 | 20897 | // consequent |
20749 | 20898 | // call lookidnr from ProcCall |
20750 | - stack[base + 48LLU] = 1684LLU/*throw to this address*/; | |
20751 | - stack[base + 49LLU] = base; | |
20752 | - stack[base + 50LLU] = 1685LLU; | |
20899 | + stack[base + 50LLU] = 1698LLU/*throw to this address*/; | |
20900 | + stack[base + 51LLU] = base; | |
20901 | + stack[base + 52LLU] = 1699LLU; | |
20753 | 20902 | // arguments for call to lookidnr |
20754 | - stack[base + 52LLU] = stack[base + 18]/*copyback*/; | |
20755 | - stack[base + 53LLU] = stack[base + 15]/*content*/; | |
20903 | + stack[base + 54LLU] = stack[base + 19]/*copyback*/; | |
20904 | + stack[base + 55LLU] = stack[base + 16]/*content*/; | |
20756 | 20905 | // set stack-base & callee-address |
20757 | - base += 51LLU; | |
20906 | + base += 53LLU; | |
20758 | 20907 | label = 760LLU; // lookidnr |
20759 | 20908 | break; |
20760 | 20909 | } |
20761 | - case 1684LLU: // copy-back deleter (lookidnr to ProcCall) | |
20910 | + case 1698LLU: // copy-back deleter (lookidnr to ProcCall) | |
20762 | 20911 | { |
20763 | 20912 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (lookidnr to ProcCall)\n"); |
20764 | 20913 | // copy mutable arguments back from call to lookidnr |
20765 | - label = 1551LLU; // continue to roll stack | |
20914 | + label = 1565LLU; // continue to roll stack | |
20766 | 20915 | break; |
20767 | 20916 | } |
20768 | - case 1685LLU: // return from lookidnr to ProcCall | |
20917 | + case 1699LLU: // return from lookidnr to ProcCall | |
20769 | 20918 | { |
20770 | 20919 | // copy mutable arguments back from call to lookidnr |
20771 | 20920 | // copy back results provided by call to lookidnr |
20772 | - stack[base + 47] = stack[base + 51LLU]; | |
20773 | - if(!stack[base + 47]/*found*/) | |
20921 | + stack[base + 49] = stack[base + 53LLU]; | |
20922 | + if(!stack[base + 49]/*found*/) | |
20774 | 20923 | { |
20775 | - label = 1686LLU; // jump to alternative | |
20924 | + label = 1700LLU; // jump to alternative | |
20776 | 20925 | break; |
20777 | 20926 | } |
20778 | 20927 |
@@ -20779,102 +20928,102 @@ | ||
20779 | 20928 | // consequent |
20780 | 20929 | fprintf(stderr, "%s", "in function "); |
20781 | 20930 | // call reportid from ProcCall |
20782 | - stack[base + 48LLU] = 1688LLU/*throw to this address*/; | |
20783 | - stack[base + 49LLU] = base; | |
20784 | - stack[base + 50LLU] = 1689LLU; | |
20931 | + stack[base + 50LLU] = 1702LLU/*throw to this address*/; | |
20932 | + stack[base + 51LLU] = base; | |
20933 | + stack[base + 52LLU] = 1703LLU; | |
20785 | 20934 | // arguments for call to reportid |
20786 | - stack[base + 51LLU] = stack[base + 7]/*fnid*/; | |
20935 | + stack[base + 53LLU] = stack[base + 8]/*fnid*/; | |
20787 | 20936 | // set stack-base & callee-address |
20788 | - base += 51LLU; | |
20937 | + base += 53LLU; | |
20789 | 20938 | label = 18446744073709551586LLU; // reportid |
20790 | 20939 | break; |
20791 | 20940 | } |
20792 | - case 1688LLU: // copy-back deleter (reportid to ProcCall) | |
20941 | + case 1702LLU: // copy-back deleter (reportid to ProcCall) | |
20793 | 20942 | { |
20794 | 20943 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
20795 | 20944 | // copy mutable arguments back from call to reportid |
20796 | - label = 1551LLU; // continue to roll stack | |
20945 | + label = 1565LLU; // continue to roll stack | |
20797 | 20946 | break; |
20798 | 20947 | } |
20799 | - case 1689LLU: // return from reportid to ProcCall | |
20948 | + case 1703LLU: // return from reportid to ProcCall | |
20800 | 20949 | { |
20801 | 20950 | // copy mutable arguments back from call to reportid |
20802 | 20951 | fprintf(stderr, "%s", " call to "); |
20803 | 20952 | // call reportid from ProcCall |
20804 | - stack[base + 48LLU] = 1690LLU/*throw to this address*/; | |
20805 | - stack[base + 49LLU] = base; | |
20806 | - stack[base + 50LLU] = 1691LLU; | |
20953 | + stack[base + 50LLU] = 1704LLU/*throw to this address*/; | |
20954 | + stack[base + 51LLU] = base; | |
20955 | + stack[base + 52LLU] = 1705LLU; | |
20807 | 20956 | // arguments for call to reportid |
20808 | - stack[base + 51LLU] = stack[base + 23]/*ceid*/; | |
20957 | + stack[base + 53LLU] = stack[base + 24]/*ceid*/; | |
20809 | 20958 | // set stack-base & callee-address |
20810 | - base += 51LLU; | |
20959 | + base += 53LLU; | |
20811 | 20960 | label = 18446744073709551586LLU; // reportid |
20812 | 20961 | break; |
20813 | 20962 | } |
20814 | - case 1690LLU: // copy-back deleter (reportid to ProcCall) | |
20963 | + case 1704LLU: // copy-back deleter (reportid to ProcCall) | |
20815 | 20964 | { |
20816 | 20965 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
20817 | 20966 | // copy mutable arguments back from call to reportid |
20818 | - label = 1551LLU; // continue to roll stack | |
20967 | + label = 1565LLU; // continue to roll stack | |
20819 | 20968 | break; |
20820 | 20969 | } |
20821 | - case 1691LLU: // return from reportid to ProcCall | |
20970 | + case 1705LLU: // return from reportid to ProcCall | |
20822 | 20971 | { |
20823 | 20972 | // copy mutable arguments back from call to reportid |
20824 | 20973 | fprintf(stderr, "%s", " - duplicate mutable argument "); |
20825 | 20974 | // call reportid from ProcCall |
20826 | - stack[base + 48LLU] = 1692LLU/*throw to this address*/; | |
20827 | - stack[base + 49LLU] = base; | |
20828 | - stack[base + 50LLU] = 1693LLU; | |
20975 | + stack[base + 50LLU] = 1706LLU/*throw to this address*/; | |
20976 | + stack[base + 51LLU] = base; | |
20977 | + stack[base + 52LLU] = 1707LLU; | |
20829 | 20978 | // arguments for call to reportid |
20830 | - stack[base + 51LLU] = stack[base + 15]/*content*/; | |
20979 | + stack[base + 53LLU] = stack[base + 16]/*content*/; | |
20831 | 20980 | // set stack-base & callee-address |
20832 | - base += 51LLU; | |
20981 | + base += 53LLU; | |
20833 | 20982 | label = 18446744073709551586LLU; // reportid |
20834 | 20983 | break; |
20835 | 20984 | } |
20836 | - case 1692LLU: // copy-back deleter (reportid to ProcCall) | |
20985 | + case 1706LLU: // copy-back deleter (reportid to ProcCall) | |
20837 | 20986 | { |
20838 | 20987 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
20839 | 20988 | // copy mutable arguments back from call to reportid |
20840 | - label = 1551LLU; // continue to roll stack | |
20989 | + label = 1565LLU; // continue to roll stack | |
20841 | 20990 | break; |
20842 | 20991 | } |
20843 | - case 1693LLU: // return from reportid to ProcCall | |
20992 | + case 1707LLU: // return from reportid to ProcCall | |
20844 | 20993 | { |
20845 | 20994 | // copy mutable arguments back from call to reportid |
20846 | 20995 | fprintf(stderr, "%s", "\n"); |
20847 | 20996 | exit(-1); |
20848 | - label = 1687LLU; // consequent complete | |
20997 | + label = 1701LLU; // consequent complete | |
20849 | 20998 | break; |
20850 | 20999 | } |
20851 | - case 1686LLU: // alternative | |
21000 | + case 1700LLU: // alternative | |
20852 | 21001 | { |
20853 | - label = 1687LLU; // alternative complete | |
21002 | + label = 1701LLU; // alternative complete | |
20854 | 21003 | break; |
20855 | 21004 | } |
20856 | - case 1687LLU: // completed if-then-else | |
21005 | + case 1701LLU: // completed if-then-else | |
20857 | 21006 | { |
20858 | - label = 1695LLU; // skip deleter | |
21007 | + label = 1709LLU; // skip deleter | |
20859 | 21008 | break; |
20860 | 21009 | } |
20861 | - case 1694LLU: // deleter | |
21010 | + case 1708LLU: // deleter | |
20862 | 21011 | { |
20863 | 21012 | // throw from ProcCall |
20864 | - if(!stack[base + 47]) | |
21013 | + if(!stack[base + 49]) | |
20865 | 21014 | { |
20866 | 21015 | fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable idnr \n"); |
20867 | - label = 1551LLU; // skip, variable already deleted/unscoped | |
21016 | + label = 1565LLU; // skip, variable already deleted/unscoped | |
20868 | 21017 | break; |
20869 | 21018 | } |
20870 | 21019 | fprintf(stderr, "in function ProcCall: unrolling stack, variable idnr \n"); |
20871 | 21020 | |
20872 | - uint64_t *newstack = (uint64_t *)(stack[base + 47] - sizeof(uint64_t) * 4); | |
21021 | + uint64_t *newstack = (uint64_t *)(stack[base + 49] - sizeof(uint64_t) * 4); | |
20873 | 21022 | // call ~idnr from ProcCall |
20874 | 21023 | newstack[0] = (uint64_t)stack; // backup stack location |
20875 | 21024 | newstack[1] = 1234567890; |
20876 | 21025 | newstack[2] = base; |
20877 | - newstack[3] = 1696LLU; | |
21026 | + newstack[3] = 1710LLU; | |
20878 | 21027 | stack = newstack; |
20879 | 21028 | // set stack-base & callee-address |
20880 | 21029 | base = 4/*deloffset*/; |
@@ -20881,28 +21030,28 @@ | ||
20881 | 21030 | label = 758LLU; // ~idnr |
20882 | 21031 | break; |
20883 | 21032 | } |
20884 | - case 1696LLU: // return from ~idnr to ProcCall | |
21033 | + case 1710LLU: // return from ~idnr to ProcCall | |
20885 | 21034 | { |
20886 | 21035 | stack = (uint64_t *)stack[0]; |
20887 | 21036 | // releasing toplevel container |
20888 | - Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 47] - sizeof(uint64_t) * 4)); | |
21037 | + Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 49] - sizeof(uint64_t) * 4)); | |
20889 | 21038 | |
20890 | - label = 1551LLU; // continue unrolling stack, delete next variable | |
21039 | + label = 1565LLU; // continue unrolling stack, delete next variable | |
20891 | 21040 | break; |
20892 | 21041 | } |
20893 | - case 1695LLU: // skipped deleter | |
21042 | + case 1709LLU: // skipped deleter | |
20894 | 21043 | { |
20895 | 21044 | // construct idnr.idnr |
20896 | - if(!(stack[base + 47] = construct(2))) | |
21045 | + if(!(stack[base + 49] = construct(2))) | |
20897 | 21046 | { |
20898 | - label = 1551LLU; // throw: begin to unroll stack | |
21047 | + label = 1565LLU; // throw: begin to unroll stack | |
20899 | 21048 | break; |
20900 | 21049 | } |
20901 | 21050 | |
20902 | 21051 | // consequent |
20903 | - ((uint64_t *)stack[base + 47])[0] = 0; | |
20904 | - (((uint64_t **)(stack[base + 47]))[1][0]) = stack[base + 15]/*content*/; | |
20905 | - (((uint64_t **)(stack[base + 47]))[1][1]) = stack[base + 28]/*sum*/; | |
21052 | + ((uint64_t *)stack[base + 49])[0] = 0; | |
21053 | + (((uint64_t **)(stack[base + 49]))[1][0]) = stack[base + 16]/*content*/; | |
21054 | + (((uint64_t **)(stack[base + 49]))[1][1]) = stack[base + 30]/*sum*/; | |
20906 | 21055 | { |
20907 | 21056 | struct listnode *list = (struct listnode *)Calloc(1, sizeof(struct listnode)); |
20908 | 21057 | if(!list) |
@@ -20910,57 +21059,57 @@ | ||
20910 | 21059 | fprintf(stderr, "in function ProcCall push to [idnr]: OUT OF MEMORY!"); |
20911 | 21060 | exit(-1); |
20912 | 21061 | } |
20913 | - list->next = (struct listnode *)stack[base + 18]/*copyback*/; | |
20914 | - stack[base + 18]/*copyback*/ = (uint64_t)list; | |
20915 | - MOVE(&list->data, &stack[base + 47]/*idnr*/); | |
21062 | + list->next = (struct listnode *)stack[base + 19]/*copyback*/; | |
21063 | + stack[base + 19]/*copyback*/ = (uint64_t)list; | |
21064 | + MOVE(&list->data, &stack[base + 49]/*idnr*/); | |
20916 | 21065 | } |
20917 | - label = 1683LLU; // consequent complete | |
21066 | + label = 1697LLU; // consequent complete | |
20918 | 21067 | break; |
20919 | 21068 | } |
20920 | - case 1682LLU: // alternative | |
21069 | + case 1696LLU: // alternative | |
20921 | 21070 | { |
20922 | 21071 | fprintf(stderr, "%s", "in function "); |
20923 | 21072 | // call reportid from ProcCall |
20924 | - stack[base + 47LLU] = 1697LLU/*throw to this address*/; | |
20925 | - stack[base + 48LLU] = base; | |
20926 | - stack[base + 49LLU] = 1698LLU; | |
21073 | + stack[base + 49LLU] = 1711LLU/*throw to this address*/; | |
21074 | + stack[base + 50LLU] = base; | |
21075 | + stack[base + 51LLU] = 1712LLU; | |
20927 | 21076 | // arguments for call to reportid |
20928 | - stack[base + 50LLU] = stack[base + 7]/*fnid*/; | |
21077 | + stack[base + 52LLU] = stack[base + 8]/*fnid*/; | |
20929 | 21078 | // set stack-base & callee-address |
20930 | - base += 50LLU; | |
21079 | + base += 52LLU; | |
20931 | 21080 | label = 18446744073709551586LLU; // reportid |
20932 | 21081 | break; |
20933 | 21082 | } |
20934 | - case 1697LLU: // copy-back deleter (reportid to ProcCall) | |
21083 | + case 1711LLU: // copy-back deleter (reportid to ProcCall) | |
20935 | 21084 | { |
20936 | 21085 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
20937 | 21086 | // copy mutable arguments back from call to reportid |
20938 | - label = 1551LLU; // continue to roll stack | |
21087 | + label = 1565LLU; // continue to roll stack | |
20939 | 21088 | break; |
20940 | 21089 | } |
20941 | - case 1698LLU: // return from reportid to ProcCall | |
21090 | + case 1712LLU: // return from reportid to ProcCall | |
20942 | 21091 | { |
20943 | 21092 | // copy mutable arguments back from call to reportid |
20944 | 21093 | fprintf(stderr, "%s", ", call to "); |
20945 | 21094 | // call reportid from ProcCall |
20946 | - stack[base + 47LLU] = 1699LLU/*throw to this address*/; | |
20947 | - stack[base + 48LLU] = base; | |
20948 | - stack[base + 49LLU] = 1700LLU; | |
21095 | + stack[base + 49LLU] = 1713LLU/*throw to this address*/; | |
21096 | + stack[base + 50LLU] = base; | |
21097 | + stack[base + 51LLU] = 1714LLU; | |
20949 | 21098 | // arguments for call to reportid |
20950 | - stack[base + 50LLU] = stack[base + 23]/*ceid*/; | |
21099 | + stack[base + 52LLU] = stack[base + 24]/*ceid*/; | |
20951 | 21100 | // set stack-base & callee-address |
20952 | - base += 50LLU; | |
21101 | + base += 52LLU; | |
20953 | 21102 | label = 18446744073709551586LLU; // reportid |
20954 | 21103 | break; |
20955 | 21104 | } |
20956 | - case 1699LLU: // copy-back deleter (reportid to ProcCall) | |
21105 | + case 1713LLU: // copy-back deleter (reportid to ProcCall) | |
20957 | 21106 | { |
20958 | 21107 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
20959 | 21108 | // copy mutable arguments back from call to reportid |
20960 | - label = 1551LLU; // continue to roll stack | |
21109 | + label = 1565LLU; // continue to roll stack | |
20961 | 21110 | break; |
20962 | 21111 | } |
20963 | - case 1700LLU: // return from reportid to ProcCall | |
21112 | + case 1714LLU: // return from reportid to ProcCall | |
20964 | 21113 | { |
20965 | 21114 | // copy mutable arguments back from call to reportid |
20966 | 21115 | fprintf(stderr, "%s", ": can't put constant argument "); |
@@ -20967,7 +21116,7 @@ | ||
20967 | 21116 | uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t)); |
20968 | 21117 | if(!newstack) |
20969 | 21118 | { |
20970 | - label = 1551LLU; // throw: begin to unroll stack | |
21119 | + label = 1565LLU; // throw: begin to unroll stack | |
20971 | 21120 | break; |
20972 | 21121 | } |
20973 | 21122 |
@@ -20974,11 +21123,11 @@ | ||
20974 | 21123 | newstack[10LLU] = 9876543210LLU; // overflow-marker |
20975 | 21124 | // call reporttype from ProcCall |
20976 | 21125 | newstack[0] = (uint64_t)stack; // backup stack location |
20977 | - newstack[1] = 1701LLU; | |
21126 | + newstack[1] = 1715LLU; | |
20978 | 21127 | newstack[2] = base; |
20979 | - newstack[3] = 1702LLU; | |
21128 | + newstack[3] = 1716LLU; | |
20980 | 21129 | // arguments for call to reporttype |
20981 | - newstack[4LLU] = stack[base + 42]/*type*/; | |
21130 | + newstack[4LLU] = stack[base + 44]/*type*/; | |
20982 | 21131 | stack = newstack; |
20983 | 21132 | // set stack-base & callee-address |
20984 | 21133 | base = 4/*deloffset*/; |
@@ -20985,7 +21134,7 @@ | ||
20985 | 21134 | label = 313LLU; // reporttype |
20986 | 21135 | break; |
20987 | 21136 | } |
20988 | - case 1701LLU: // copy-back deleter (reporttype to ProcCall) | |
21137 | + case 1715LLU: // copy-back deleter (reporttype to ProcCall) | |
20989 | 21138 | { |
20990 | 21139 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n"); |
20991 | 21140 | uint64_t *oldstack = (uint64_t *)stack[0]; |
@@ -20997,10 +21146,10 @@ | ||
20997 | 21146 | } |
20998 | 21147 | Free(10LLU + 1, sizeof(uint64_t), stack); |
20999 | 21148 | stack = oldstack; |
21000 | - label = 1551LLU; // continue to unroll stack | |
21149 | + label = 1565LLU; // continue to unroll stack | |
21001 | 21150 | break; |
21002 | 21151 | } |
21003 | - case 1702LLU: // return from reporttype to ProcCall | |
21152 | + case 1716LLU: // return from reporttype to ProcCall | |
21004 | 21153 | { |
21005 | 21154 | uint64_t *oldstack = (uint64_t *)stack[0]; |
21006 | 21155 | // copy mutable arguments back from call to reporttype |
@@ -21013,24 +21162,24 @@ | ||
21013 | 21162 | stack = oldstack; |
21014 | 21163 | fprintf(stderr, "%s", " "); |
21015 | 21164 | // call reportid from ProcCall |
21016 | - stack[base + 47LLU] = 1703LLU/*throw to this address*/; | |
21017 | - stack[base + 48LLU] = base; | |
21018 | - stack[base + 49LLU] = 1704LLU; | |
21165 | + stack[base + 49LLU] = 1717LLU/*throw to this address*/; | |
21166 | + stack[base + 50LLU] = base; | |
21167 | + stack[base + 51LLU] = 1718LLU; | |
21019 | 21168 | // arguments for call to reportid |
21020 | - stack[base + 50LLU] = stack[base + 15]/*content*/; | |
21169 | + stack[base + 52LLU] = stack[base + 16]/*content*/; | |
21021 | 21170 | // set stack-base & callee-address |
21022 | - base += 50LLU; | |
21171 | + base += 52LLU; | |
21023 | 21172 | label = 18446744073709551586LLU; // reportid |
21024 | 21173 | break; |
21025 | 21174 | } |
21026 | - case 1703LLU: // copy-back deleter (reportid to ProcCall) | |
21175 | + case 1717LLU: // copy-back deleter (reportid to ProcCall) | |
21027 | 21176 | { |
21028 | 21177 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
21029 | 21178 | // copy mutable arguments back from call to reportid |
21030 | - label = 1551LLU; // continue to roll stack | |
21179 | + label = 1565LLU; // continue to roll stack | |
21031 | 21180 | break; |
21032 | 21181 | } |
21033 | - case 1704LLU: // return from reportid to ProcCall | |
21182 | + case 1718LLU: // return from reportid to ProcCall | |
21034 | 21183 | { |
21035 | 21184 | // copy mutable arguments back from call to reportid |
21036 | 21185 | fprintf(stderr, "%s", " into mutable parameter "); |
@@ -21037,7 +21186,7 @@ | ||
21037 | 21186 | uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t)); |
21038 | 21187 | if(!newstack) |
21039 | 21188 | { |
21040 | - label = 1551LLU; // throw: begin to unroll stack | |
21189 | + label = 1565LLU; // throw: begin to unroll stack | |
21041 | 21190 | break; |
21042 | 21191 | } |
21043 | 21192 |
@@ -21044,11 +21193,11 @@ | ||
21044 | 21193 | newstack[10LLU] = 9876543210LLU; // overflow-marker |
21045 | 21194 | // call reporttype from ProcCall |
21046 | 21195 | newstack[0] = (uint64_t)stack; // backup stack location |
21047 | - newstack[1] = 1705LLU; | |
21196 | + newstack[1] = 1719LLU; | |
21048 | 21197 | newstack[2] = base; |
21049 | - newstack[3] = 1706LLU; | |
21198 | + newstack[3] = 1720LLU; | |
21050 | 21199 | // arguments for call to reporttype |
21051 | - newstack[4LLU] = stack[base + 39]/*expected*/; | |
21200 | + newstack[4LLU] = stack[base + 41]/*expected*/; | |
21052 | 21201 | stack = newstack; |
21053 | 21202 | // set stack-base & callee-address |
21054 | 21203 | base = 4/*deloffset*/; |
@@ -21055,7 +21204,7 @@ | ||
21055 | 21204 | label = 313LLU; // reporttype |
21056 | 21205 | break; |
21057 | 21206 | } |
21058 | - case 1705LLU: // copy-back deleter (reporttype to ProcCall) | |
21207 | + case 1719LLU: // copy-back deleter (reporttype to ProcCall) | |
21059 | 21208 | { |
21060 | 21209 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n"); |
21061 | 21210 | uint64_t *oldstack = (uint64_t *)stack[0]; |
@@ -21067,10 +21216,10 @@ | ||
21067 | 21216 | } |
21068 | 21217 | Free(10LLU + 1, sizeof(uint64_t), stack); |
21069 | 21218 | stack = oldstack; |
21070 | - label = 1551LLU; // continue to unroll stack | |
21219 | + label = 1565LLU; // continue to unroll stack | |
21071 | 21220 | break; |
21072 | 21221 | } |
21073 | - case 1706LLU: // return from reporttype to ProcCall | |
21222 | + case 1720LLU: // return from reporttype to ProcCall | |
21074 | 21223 | { |
21075 | 21224 | uint64_t *oldstack = (uint64_t *)stack[0]; |
21076 | 21225 | // copy mutable arguments back from call to reporttype |
@@ -21082,113 +21231,113 @@ | ||
21082 | 21231 | Free(10LLU + 1, sizeof(uint64_t), stack); |
21083 | 21232 | stack = oldstack; |
21084 | 21233 | // call reportid from ProcCall |
21085 | - stack[base + 47LLU] = 1707LLU/*throw to this address*/; | |
21086 | - stack[base + 48LLU] = base; | |
21087 | - stack[base + 49LLU] = 1708LLU; | |
21234 | + stack[base + 49LLU] = 1721LLU/*throw to this address*/; | |
21235 | + stack[base + 50LLU] = base; | |
21236 | + stack[base + 51LLU] = 1722LLU; | |
21088 | 21237 | // arguments for call to reportid |
21089 | - stack[base + 50LLU] = stack[base + 40]/*paramname*/; | |
21238 | + stack[base + 52LLU] = stack[base + 42]/*paramname*/; | |
21090 | 21239 | // set stack-base & callee-address |
21091 | - base += 50LLU; | |
21240 | + base += 52LLU; | |
21092 | 21241 | label = 18446744073709551586LLU; // reportid |
21093 | 21242 | break; |
21094 | 21243 | } |
21095 | - case 1707LLU: // copy-back deleter (reportid to ProcCall) | |
21244 | + case 1721LLU: // copy-back deleter (reportid to ProcCall) | |
21096 | 21245 | { |
21097 | 21246 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
21098 | 21247 | // copy mutable arguments back from call to reportid |
21099 | - label = 1551LLU; // continue to roll stack | |
21248 | + label = 1565LLU; // continue to roll stack | |
21100 | 21249 | break; |
21101 | 21250 | } |
21102 | - case 1708LLU: // return from reportid to ProcCall | |
21251 | + case 1722LLU: // return from reportid to ProcCall | |
21103 | 21252 | { |
21104 | 21253 | // copy mutable arguments back from call to reportid |
21105 | 21254 | fprintf(stderr, "%s", "\n"); |
21106 | 21255 | exit(-1); |
21107 | - label = 1683LLU; // alternative complete | |
21256 | + label = 1697LLU; // alternative complete | |
21108 | 21257 | break; |
21109 | 21258 | } |
21110 | - case 1683LLU: // completed if-then-else | |
21259 | + case 1697LLU: // completed if-then-else | |
21111 | 21260 | { |
21112 | - label = 1681LLU; // consequent complete | |
21261 | + label = 1695LLU; // consequent complete | |
21113 | 21262 | break; |
21114 | 21263 | } |
21115 | - case 1680LLU: // alternative | |
21264 | + case 1694LLU: // alternative | |
21116 | 21265 | { |
21117 | - label = 1681LLU; // alternative complete | |
21266 | + label = 1695LLU; // alternative complete | |
21118 | 21267 | break; |
21119 | 21268 | } |
21120 | - case 1681LLU: // completed if-then-else | |
21269 | + case 1695LLU: // completed if-then-else | |
21121 | 21270 | { |
21122 | - ((uint64_t **)(stack[base + 41]))[1][4] = stack[base + 46]; | |
21123 | - ((uint64_t **)(stack[base + 41]))[1][3] = stack[base + 45]; | |
21124 | - ((uint64_t **)(stack[base + 41]))[1][2] = stack[base + 44]; | |
21125 | - ((uint64_t **)(stack[base + 41]))[1][1] = stack[base + 43]; | |
21126 | - ((uint64_t **)(stack[base + 41]))[1][0] = stack[base + 42]; | |
21127 | - label = 1662LLU; // case complete | |
21271 | + ((uint64_t **)(stack[base + 43]))[1][4] = stack[base + 48]; | |
21272 | + ((uint64_t **)(stack[base + 43]))[1][3] = stack[base + 47]; | |
21273 | + ((uint64_t **)(stack[base + 43]))[1][2] = stack[base + 46]; | |
21274 | + ((uint64_t **)(stack[base + 43]))[1][1] = stack[base + 45]; | |
21275 | + ((uint64_t **)(stack[base + 43]))[1][0] = stack[base + 44]; | |
21276 | + label = 1676LLU; // case complete | |
21128 | 21277 | break; |
21129 | 21278 | } |
21130 | - case 1663LLU: // try next case | |
21279 | + case 1677LLU: // try next case | |
21131 | 21280 | { |
21132 | 21281 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
21133 | 21282 | exit(-1); |
21134 | 21283 | } |
21135 | - case 1662LLU: // completed switch | |
21284 | + case 1676LLU: // completed switch | |
21136 | 21285 | { |
21137 | 21286 | printf("%s", "\n newstack["); |
21138 | 21287 | // call printnr from ProcCall |
21139 | - stack[base + 42LLU] = 1709LLU/*throw to this address*/; | |
21140 | - stack[base + 43LLU] = base; | |
21141 | - stack[base + 44LLU] = 1710LLU; | |
21288 | + stack[base + 44LLU] = 1723LLU/*throw to this address*/; | |
21289 | + stack[base + 45LLU] = base; | |
21290 | + stack[base + 46LLU] = 1724LLU; | |
21142 | 21291 | // arguments for call to printnr |
21143 | - stack[base + 45LLU] = stack[base + 28]/*sum*/; | |
21292 | + stack[base + 47LLU] = stack[base + 30]/*sum*/; | |
21144 | 21293 | // set stack-base & callee-address |
21145 | - base += 45LLU; | |
21294 | + base += 47LLU; | |
21146 | 21295 | label = 18446744073709551590LLU; // printnr |
21147 | 21296 | break; |
21148 | 21297 | } |
21149 | - case 1709LLU: // copy-back deleter (printnr to ProcCall) | |
21298 | + case 1723LLU: // copy-back deleter (printnr to ProcCall) | |
21150 | 21299 | { |
21151 | 21300 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n"); |
21152 | 21301 | // copy mutable arguments back from call to printnr |
21153 | - label = 1551LLU; // continue to roll stack | |
21302 | + label = 1565LLU; // continue to roll stack | |
21154 | 21303 | break; |
21155 | 21304 | } |
21156 | - case 1710LLU: // return from printnr to ProcCall | |
21305 | + case 1724LLU: // return from printnr to ProcCall | |
21157 | 21306 | { |
21158 | 21307 | // copy mutable arguments back from call to printnr |
21159 | 21308 | printf("%s", "LLU] = "); |
21160 | 21309 | // call emitvar from ProcCall |
21161 | - stack[base + 42LLU] = 1711LLU/*throw to this address*/; | |
21162 | - stack[base + 43LLU] = base; | |
21163 | - stack[base + 44LLU] = 1712LLU; | |
21310 | + stack[base + 44LLU] = 1725LLU/*throw to this address*/; | |
21311 | + stack[base + 45LLU] = base; | |
21312 | + stack[base + 46LLU] = 1726LLU; | |
21164 | 21313 | // arguments for call to emitvar |
21165 | - stack[base + 45LLU] = stack[base + 7]/*fnid*/; | |
21166 | - stack[base + 46LLU] = stack[base + 15]/*content*/; | |
21167 | - stack[base + 47LLU] = stack[base + 2]/*scopes*/; | |
21168 | - stack[base + 48LLU] = stack[base + 3]/*scope*/; | |
21314 | + stack[base + 47LLU] = stack[base + 8]/*fnid*/; | |
21315 | + stack[base + 48LLU] = stack[base + 16]/*content*/; | |
21316 | + stack[base + 49LLU] = stack[base + 2]/*scopes*/; | |
21317 | + stack[base + 50LLU] = stack[base + 3]/*scope*/; | |
21169 | 21318 | // set stack-base & callee-address |
21170 | - base += 45LLU; | |
21319 | + base += 47LLU; | |
21171 | 21320 | label = 659LLU; // emitvar |
21172 | 21321 | break; |
21173 | 21322 | } |
21174 | - case 1711LLU: // copy-back deleter (emitvar to ProcCall) | |
21323 | + case 1725LLU: // copy-back deleter (emitvar to ProcCall) | |
21175 | 21324 | { |
21176 | 21325 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (emitvar to ProcCall)\n"); |
21177 | 21326 | // copy mutable arguments back from call to emitvar |
21178 | - label = 1551LLU; // continue to roll stack | |
21327 | + label = 1565LLU; // continue to roll stack | |
21179 | 21328 | break; |
21180 | 21329 | } |
21181 | - case 1712LLU: // return from emitvar to ProcCall | |
21330 | + case 1726LLU: // return from emitvar to ProcCall | |
21182 | 21331 | { |
21183 | 21332 | // copy mutable arguments back from call to emitvar |
21184 | 21333 | printf("%s", ";"); |
21185 | 21334 | |
21186 | - uint64_t *newstack = (uint64_t *)(stack[base + 41] - sizeof(uint64_t) * 4); | |
21335 | + uint64_t *newstack = (uint64_t *)(stack[base + 43] - sizeof(uint64_t) * 4); | |
21187 | 21336 | // call ~letdef from ProcCall |
21188 | 21337 | newstack[0] = (uint64_t)stack; // backup stack location |
21189 | 21338 | newstack[1] = 1234567890; |
21190 | 21339 | newstack[2] = base; |
21191 | - newstack[3] = 1713LLU; | |
21340 | + newstack[3] = 1727LLU; | |
21192 | 21341 | stack = newstack; |
21193 | 21342 | // set stack-base & callee-address |
21194 | 21343 | base = 4/*deloffset*/; |
@@ -21195,234 +21344,234 @@ | ||
21195 | 21344 | label = 438LLU; // ~letdef |
21196 | 21345 | break; |
21197 | 21346 | } |
21198 | - case 1713LLU: // return from ~letdef to ProcCall | |
21347 | + case 1727LLU: // return from ~letdef to ProcCall | |
21199 | 21348 | { |
21200 | 21349 | stack = (uint64_t *)stack[0]; |
21201 | 21350 | // releasing toplevel container |
21202 | - Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 41] - sizeof(uint64_t) * 4)); | |
21351 | + Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 43] - sizeof(uint64_t) * 4)); | |
21203 | 21352 | |
21204 | - label = 1621LLU; // alternative complete | |
21353 | + label = 1635LLU; // alternative complete | |
21205 | 21354 | break; |
21206 | 21355 | } |
21207 | - case 1621LLU: // completed if-then-else | |
21356 | + case 1635LLU: // completed if-then-else | |
21208 | 21357 | { |
21209 | - ((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40]; | |
21210 | - ((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39]; | |
21211 | - label = 1616LLU; // case complete | |
21358 | + ((uint64_t **)(stack[base + 39]))[1][1] = stack[base + 42]; | |
21359 | + ((uint64_t **)(stack[base + 39]))[1][0] = stack[base + 41]; | |
21360 | + label = 1630LLU; // case complete | |
21212 | 21361 | break; |
21213 | 21362 | } |
21214 | - case 1617LLU: // try next case | |
21363 | + case 1631LLU: // try next case | |
21215 | 21364 | { |
21216 | 21365 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
21217 | 21366 | exit(-1); |
21218 | 21367 | } |
21219 | - case 1616LLU: // completed switch | |
21368 | + case 1630LLU: // completed switch | |
21220 | 21369 | { |
21221 | - ((uint64_t **)(stack[base + 35]))[1][1] = stack[base + 38]; | |
21222 | - ((uint64_t **)(stack[base + 35]))[1][0] = stack[base + 37]; | |
21223 | - label = 1614LLU; // case complete | |
21370 | + ((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40]; | |
21371 | + ((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39]; | |
21372 | + label = 1628LLU; // case complete | |
21224 | 21373 | break; |
21225 | 21374 | } |
21226 | - case 1615LLU: // try next case | |
21375 | + case 1629LLU: // try next case | |
21227 | 21376 | { |
21228 | 21377 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
21229 | 21378 | exit(-1); |
21230 | 21379 | } |
21231 | - case 1614LLU: // completed switch | |
21380 | + case 1628LLU: // completed switch | |
21232 | 21381 | { |
21233 | - label = 1613LLU; // consequent complete | |
21382 | + label = 1627LLU; // consequent complete | |
21234 | 21383 | break; |
21235 | 21384 | } |
21236 | - case 1612LLU: // alternative | |
21385 | + case 1626LLU: // alternative | |
21237 | 21386 | { |
21238 | 21387 | fprintf(stderr, "%s", "in function "); |
21239 | 21388 | // call reportid from ProcCall |
21240 | - stack[base + 37LLU] = 1714LLU/*throw to this address*/; | |
21241 | - stack[base + 38LLU] = base; | |
21242 | - stack[base + 39LLU] = 1715LLU; | |
21389 | + stack[base + 39LLU] = 1728LLU/*throw to this address*/; | |
21390 | + stack[base + 40LLU] = base; | |
21391 | + stack[base + 41LLU] = 1729LLU; | |
21243 | 21392 | // arguments for call to reportid |
21244 | - stack[base + 40LLU] = stack[base + 7]/*fnid*/; | |
21393 | + stack[base + 42LLU] = stack[base + 8]/*fnid*/; | |
21245 | 21394 | // set stack-base & callee-address |
21246 | - base += 40LLU; | |
21395 | + base += 42LLU; | |
21247 | 21396 | label = 18446744073709551586LLU; // reportid |
21248 | 21397 | break; |
21249 | 21398 | } |
21250 | - case 1714LLU: // copy-back deleter (reportid to ProcCall) | |
21399 | + case 1728LLU: // copy-back deleter (reportid to ProcCall) | |
21251 | 21400 | { |
21252 | 21401 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
21253 | 21402 | // copy mutable arguments back from call to reportid |
21254 | - label = 1551LLU; // continue to roll stack | |
21403 | + label = 1565LLU; // continue to roll stack | |
21255 | 21404 | break; |
21256 | 21405 | } |
21257 | - case 1715LLU: // return from reportid to ProcCall | |
21406 | + case 1729LLU: // return from reportid to ProcCall | |
21258 | 21407 | { |
21259 | 21408 | // copy mutable arguments back from call to reportid |
21260 | 21409 | fprintf(stderr, "%s", " call to "); |
21261 | 21410 | // call reportid from ProcCall |
21262 | - stack[base + 37LLU] = 1716LLU/*throw to this address*/; | |
21263 | - stack[base + 38LLU] = base; | |
21264 | - stack[base + 39LLU] = 1717LLU; | |
21411 | + stack[base + 39LLU] = 1730LLU/*throw to this address*/; | |
21412 | + stack[base + 40LLU] = base; | |
21413 | + stack[base + 41LLU] = 1731LLU; | |
21265 | 21414 | // arguments for call to reportid |
21266 | - stack[base + 40LLU] = stack[base + 23]/*ceid*/; | |
21415 | + stack[base + 42LLU] = stack[base + 24]/*ceid*/; | |
21267 | 21416 | // set stack-base & callee-address |
21268 | - base += 40LLU; | |
21417 | + base += 42LLU; | |
21269 | 21418 | label = 18446744073709551586LLU; // reportid |
21270 | 21419 | break; |
21271 | 21420 | } |
21272 | - case 1716LLU: // copy-back deleter (reportid to ProcCall) | |
21421 | + case 1730LLU: // copy-back deleter (reportid to ProcCall) | |
21273 | 21422 | { |
21274 | 21423 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
21275 | 21424 | // copy mutable arguments back from call to reportid |
21276 | - label = 1551LLU; // continue to roll stack | |
21425 | + label = 1565LLU; // continue to roll stack | |
21277 | 21426 | break; |
21278 | 21427 | } |
21279 | - case 1717LLU: // return from reportid to ProcCall | |
21428 | + case 1731LLU: // return from reportid to ProcCall | |
21280 | 21429 | { |
21281 | 21430 | // copy mutable arguments back from call to reportid |
21282 | 21431 | fprintf(stderr, "%s", ": expected identifier or constant argument but found "); |
21283 | 21432 | // call printtoken from ProcCall |
21284 | - stack[base + 37LLU] = 1718LLU/*throw to this address*/; | |
21285 | - stack[base + 38LLU] = base; | |
21286 | - stack[base + 39LLU] = 1719LLU; | |
21433 | + stack[base + 39LLU] = 1732LLU/*throw to this address*/; | |
21434 | + stack[base + 40LLU] = base; | |
21435 | + stack[base + 41LLU] = 1733LLU; | |
21287 | 21436 | // arguments for call to printtoken |
21288 | - stack[base + 40LLU] = stack[base + 14]/*variant*/; | |
21289 | - stack[base + 41LLU] = stack[base + 15]/*content*/; | |
21437 | + stack[base + 42LLU] = stack[base + 15]/*variant*/; | |
21438 | + stack[base + 43LLU] = stack[base + 16]/*content*/; | |
21290 | 21439 | // set stack-base & callee-address |
21291 | - base += 40LLU; | |
21440 | + base += 42LLU; | |
21292 | 21441 | label = 18446744073709551583LLU; // printtoken |
21293 | 21442 | break; |
21294 | 21443 | } |
21295 | - case 1718LLU: // copy-back deleter (printtoken to ProcCall) | |
21444 | + case 1732LLU: // copy-back deleter (printtoken to ProcCall) | |
21296 | 21445 | { |
21297 | 21446 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printtoken to ProcCall)\n"); |
21298 | 21447 | // copy mutable arguments back from call to printtoken |
21299 | - label = 1551LLU; // continue to roll stack | |
21448 | + label = 1565LLU; // continue to roll stack | |
21300 | 21449 | break; |
21301 | 21450 | } |
21302 | - case 1719LLU: // return from printtoken to ProcCall | |
21451 | + case 1733LLU: // return from printtoken to ProcCall | |
21303 | 21452 | { |
21304 | 21453 | // copy mutable arguments back from call to printtoken |
21305 | 21454 | fprintf(stderr, "%s", "\n"); |
21306 | 21455 | exit(-1); |
21307 | - label = 1613LLU; // alternative complete | |
21456 | + label = 1627LLU; // alternative complete | |
21308 | 21457 | break; |
21309 | 21458 | } |
21310 | - case 1613LLU: // completed if-then-else | |
21459 | + case 1627LLU: // completed if-then-else | |
21311 | 21460 | { |
21312 | - label = 1574LLU; // alternative complete | |
21461 | + label = 1588LLU; // alternative complete | |
21313 | 21462 | break; |
21314 | 21463 | } |
21315 | - case 1574LLU: // completed if-then-else | |
21464 | + case 1588LLU: // completed if-then-else | |
21316 | 21465 | { |
21317 | - ((struct listnode *)(stack[base + 36]/*previous*/))->data = stack[base + 35]; | |
21318 | - label = 1553LLU; // repeat | |
21466 | + ((struct listnode *)(stack[base + 38]/*previous*/))->data = stack[base + 37]; | |
21467 | + label = 1567LLU; // repeat | |
21319 | 21468 | break; |
21320 | 21469 | } |
21321 | - case 1554LLU: // loop finished | |
21470 | + case 1568LLU: // loop finished | |
21322 | 21471 | { |
21323 | 21472 | // call equ from ProcCall |
21324 | - stack[base + 37LLU] = 1720LLU/*throw to this address*/; | |
21325 | - stack[base + 38LLU] = base; | |
21326 | - stack[base + 39LLU] = 1721LLU; | |
21473 | + stack[base + 39LLU] = 1734LLU/*throw to this address*/; | |
21474 | + stack[base + 40LLU] = base; | |
21475 | + stack[base + 41LLU] = 1735LLU; | |
21327 | 21476 | // arguments for call to equ |
21328 | - stack[base + 41LLU] = stack[base + 7]/*fnid*/; | |
21329 | - stack[base + 42LLU] = stack[base + 23]/*ceid*/; | |
21477 | + stack[base + 43LLU] = stack[base + 8]/*fnid*/; | |
21478 | + stack[base + 44LLU] = stack[base + 24]/*ceid*/; | |
21330 | 21479 | // set stack-base & callee-address |
21331 | - base += 40LLU; | |
21480 | + base += 42LLU; | |
21332 | 21481 | label = 18446744073709551600LLU; // equ |
21333 | 21482 | break; |
21334 | 21483 | } |
21335 | - case 1720LLU: // copy-back deleter (equ to ProcCall) | |
21484 | + case 1734LLU: // copy-back deleter (equ to ProcCall) | |
21336 | 21485 | { |
21337 | 21486 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (equ to ProcCall)\n"); |
21338 | 21487 | // copy mutable arguments back from call to equ |
21339 | - label = 1551LLU; // continue to roll stack | |
21488 | + label = 1565LLU; // continue to roll stack | |
21340 | 21489 | break; |
21341 | 21490 | } |
21342 | - case 1721LLU: // return from equ to ProcCall | |
21491 | + case 1735LLU: // return from equ to ProcCall | |
21343 | 21492 | { |
21344 | 21493 | // copy mutable arguments back from call to equ |
21345 | 21494 | // copy back results provided by call to equ |
21346 | - stack[base + 17] = stack[base + 40LLU]; | |
21347 | - if(!stack[base + 17]/*isequal*/) | |
21495 | + stack[base + 18] = stack[base + 42LLU]; | |
21496 | + if(!stack[base + 18]/*isequal*/) | |
21348 | 21497 | { |
21349 | - label = 1722LLU; // jump to alternative | |
21498 | + label = 1736LLU; // jump to alternative | |
21350 | 21499 | break; |
21351 | 21500 | } |
21352 | 21501 | |
21353 | 21502 | // consequent |
21354 | - if(!stack[base + 33]/*csubstruct*/) | |
21503 | + if(!stack[base + 35]/*csubstruct*/) | |
21355 | 21504 | { |
21356 | - label = 1724LLU; // jump to alternative | |
21505 | + label = 1738LLU; // jump to alternative | |
21357 | 21506 | break; |
21358 | 21507 | } |
21359 | 21508 | |
21360 | 21509 | // consequent |
21361 | - label = 1725LLU; // consequent complete | |
21510 | + label = 1739LLU; // consequent complete | |
21362 | 21511 | break; |
21363 | 21512 | } |
21364 | - case 1724LLU: // alternative | |
21513 | + case 1738LLU: // alternative | |
21365 | 21514 | { |
21366 | 21515 | fprintf(stderr, "%s", "in function "); |
21367 | 21516 | // call reportid from ProcCall |
21368 | - stack[base + 37LLU] = 1726LLU/*throw to this address*/; | |
21369 | - stack[base + 38LLU] = base; | |
21370 | - stack[base + 39LLU] = 1727LLU; | |
21517 | + stack[base + 39LLU] = 1740LLU/*throw to this address*/; | |
21518 | + stack[base + 40LLU] = base; | |
21519 | + stack[base + 41LLU] = 1741LLU; | |
21371 | 21520 | // arguments for call to reportid |
21372 | - stack[base + 40LLU] = stack[base + 7]/*fnid*/; | |
21521 | + stack[base + 42LLU] = stack[base + 8]/*fnid*/; | |
21373 | 21522 | // set stack-base & callee-address |
21374 | - base += 40LLU; | |
21523 | + base += 42LLU; | |
21375 | 21524 | label = 18446744073709551586LLU; // reportid |
21376 | 21525 | break; |
21377 | 21526 | } |
21378 | - case 1726LLU: // copy-back deleter (reportid to ProcCall) | |
21527 | + case 1740LLU: // copy-back deleter (reportid to ProcCall) | |
21379 | 21528 | { |
21380 | 21529 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
21381 | 21530 | // copy mutable arguments back from call to reportid |
21382 | - label = 1551LLU; // continue to roll stack | |
21531 | + label = 1565LLU; // continue to roll stack | |
21383 | 21532 | break; |
21384 | 21533 | } |
21385 | - case 1727LLU: // return from reportid to ProcCall | |
21534 | + case 1741LLU: // return from reportid to ProcCall | |
21386 | 21535 | { |
21387 | 21536 | // copy mutable arguments back from call to reportid |
21388 | 21537 | fprintf(stderr, "%s", " recursive call to "); |
21389 | 21538 | // call reportid from ProcCall |
21390 | - stack[base + 37LLU] = 1728LLU/*throw to this address*/; | |
21391 | - stack[base + 38LLU] = base; | |
21392 | - stack[base + 39LLU] = 1729LLU; | |
21539 | + stack[base + 39LLU] = 1742LLU/*throw to this address*/; | |
21540 | + stack[base + 40LLU] = base; | |
21541 | + stack[base + 41LLU] = 1743LLU; | |
21393 | 21542 | // arguments for call to reportid |
21394 | - stack[base + 40LLU] = stack[base + 23]/*ceid*/; | |
21543 | + stack[base + 42LLU] = stack[base + 24]/*ceid*/; | |
21395 | 21544 | // set stack-base & callee-address |
21396 | - base += 40LLU; | |
21545 | + base += 42LLU; | |
21397 | 21546 | label = 18446744073709551586LLU; // reportid |
21398 | 21547 | break; |
21399 | 21548 | } |
21400 | - case 1728LLU: // copy-back deleter (reportid to ProcCall) | |
21549 | + case 1742LLU: // copy-back deleter (reportid to ProcCall) | |
21401 | 21550 | { |
21402 | 21551 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
21403 | 21552 | // copy mutable arguments back from call to reportid |
21404 | - label = 1551LLU; // continue to roll stack | |
21553 | + label = 1565LLU; // continue to roll stack | |
21405 | 21554 | break; |
21406 | 21555 | } |
21407 | - case 1729LLU: // return from reportid to ProcCall | |
21556 | + case 1743LLU: // return from reportid to ProcCall | |
21408 | 21557 | { |
21409 | 21558 | // copy mutable arguments back from call to reportid |
21410 | 21559 | fprintf(stderr, "%s", ": at least one argument must be a substructure (i.e. part of parameter obtained by switch)\n"); |
21411 | 21560 | exit(-1); |
21412 | - label = 1725LLU; // alternative complete | |
21561 | + label = 1739LLU; // alternative complete | |
21413 | 21562 | break; |
21414 | 21563 | } |
21415 | - case 1725LLU: // completed if-then-else | |
21564 | + case 1739LLU: // completed if-then-else | |
21416 | 21565 | { |
21417 | - label = 1723LLU; // consequent complete | |
21566 | + label = 1737LLU; // consequent complete | |
21418 | 21567 | break; |
21419 | 21568 | } |
21420 | - case 1722LLU: // alternative | |
21569 | + case 1736LLU: // alternative | |
21421 | 21570 | { |
21422 | - label = 1723LLU; // alternative complete | |
21571 | + label = 1737LLU; // alternative complete | |
21423 | 21572 | break; |
21424 | 21573 | } |
21425 | - case 1723LLU: // completed if-then-else | |
21574 | + case 1737LLU: // completed if-then-else | |
21426 | 21575 | { |
21427 | 21576 | printf("%s", "\n stack = newstack;"); |
21428 | 21577 | printf("%s", "\n // set stack-base & callee-address"); |
@@ -21429,46 +21578,46 @@ | ||
21429 | 21578 | printf("%s", "\n base = 4/*deloffset*/;"); |
21430 | 21579 | printf("%s", "\n label = "); |
21431 | 21580 | // call printnr from ProcCall |
21432 | - stack[base + 33LLU] = 1730LLU/*throw to this address*/; | |
21433 | - stack[base + 34LLU] = base; | |
21434 | - stack[base + 35LLU] = 1731LLU; | |
21581 | + stack[base + 35LLU] = 1744LLU/*throw to this address*/; | |
21582 | + stack[base + 36LLU] = base; | |
21583 | + stack[base + 37LLU] = 1745LLU; | |
21435 | 21584 | // arguments for call to printnr |
21436 | - stack[base + 36LLU] = stack[base + 19]/*celabel*/; | |
21585 | + stack[base + 38LLU] = stack[base + 20]/*celabel*/; | |
21437 | 21586 | // set stack-base & callee-address |
21438 | - base += 36LLU; | |
21587 | + base += 38LLU; | |
21439 | 21588 | label = 18446744073709551590LLU; // printnr |
21440 | 21589 | break; |
21441 | 21590 | } |
21442 | - case 1730LLU: // copy-back deleter (printnr to ProcCall) | |
21591 | + case 1744LLU: // copy-back deleter (printnr to ProcCall) | |
21443 | 21592 | { |
21444 | 21593 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n"); |
21445 | 21594 | // copy mutable arguments back from call to printnr |
21446 | - label = 1523LLU; // continue to roll stack | |
21595 | + label = 1537LLU; // continue to roll stack | |
21447 | 21596 | break; |
21448 | 21597 | } |
21449 | - case 1731LLU: // return from printnr to ProcCall | |
21598 | + case 1745LLU: // return from printnr to ProcCall | |
21450 | 21599 | { |
21451 | 21600 | // copy mutable arguments back from call to printnr |
21452 | 21601 | printf("%s", "LLU; // "); |
21453 | 21602 | // call printid from ProcCall |
21454 | - stack[base + 33LLU] = 1732LLU/*throw to this address*/; | |
21455 | - stack[base + 34LLU] = base; | |
21456 | - stack[base + 35LLU] = 1733LLU; | |
21603 | + stack[base + 35LLU] = 1746LLU/*throw to this address*/; | |
21604 | + stack[base + 36LLU] = base; | |
21605 | + stack[base + 37LLU] = 1747LLU; | |
21457 | 21606 | // arguments for call to printid |
21458 | - stack[base + 36LLU] = stack[base + 23]/*ceid*/; | |
21607 | + stack[base + 38LLU] = stack[base + 24]/*ceid*/; | |
21459 | 21608 | // set stack-base & callee-address |
21460 | - base += 36LLU; | |
21609 | + base += 38LLU; | |
21461 | 21610 | label = 18446744073709551587LLU; // printid |
21462 | 21611 | break; |
21463 | 21612 | } |
21464 | - case 1732LLU: // copy-back deleter (printid to ProcCall) | |
21613 | + case 1746LLU: // copy-back deleter (printid to ProcCall) | |
21465 | 21614 | { |
21466 | 21615 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n"); |
21467 | 21616 | // copy mutable arguments back from call to printid |
21468 | - label = 1523LLU; // continue to roll stack | |
21617 | + label = 1537LLU; // continue to roll stack | |
21469 | 21618 | break; |
21470 | 21619 | } |
21471 | - case 1733LLU: // return from printid to ProcCall | |
21620 | + case 1747LLU: // return from printid to ProcCall | |
21472 | 21621 | { |
21473 | 21622 | // copy mutable arguments back from call to printid |
21474 | 21623 | printf("%s", "\n break;"); |
@@ -21475,78 +21624,78 @@ | ||
21475 | 21624 | printf("%s", "\n }"); |
21476 | 21625 | if(/*scope*/0 != ((uint64_t *)(stack[base + 3]/*scope*/))[0]) |
21477 | 21626 | { |
21478 | - label = 1735LLU; // jump to alternative | |
21627 | + label = 1749LLU; // jump to alternative | |
21479 | 21628 | break; |
21480 | 21629 | } |
21481 | 21630 | |
21482 | - /*labelthrow*/stack[base + 33] = ((uint64_t **)(stack[base + 3]/*scope*/))[1][0]/*deleteaddr*/; | |
21483 | - /*dummy*/stack[base + 34] = ((uint64_t **)(stack[base + 3]/*scope*/))[1][1]/*letdefs*/; | |
21631 | + /*labelthrow*/stack[base + 35] = ((uint64_t **)(stack[base + 3]/*scope*/))[1][0]/*deleteaddr*/; | |
21632 | + /*dummy*/stack[base + 36] = ((uint64_t **)(stack[base + 3]/*scope*/))[1][1]/*letdefs*/; | |
21484 | 21633 | |
21485 | 21634 | // case |
21486 | 21635 | printf("%s", "\n case "); |
21487 | 21636 | // call printnr from ProcCall |
21488 | - stack[base + 35LLU] = 1736LLU/*throw to this address*/; | |
21489 | - stack[base + 36LLU] = base; | |
21490 | - stack[base + 37LLU] = 1737LLU; | |
21637 | + stack[base + 37LLU] = 1750LLU/*throw to this address*/; | |
21638 | + stack[base + 38LLU] = base; | |
21639 | + stack[base + 39LLU] = 1751LLU; | |
21491 | 21640 | // arguments for call to printnr |
21492 | - stack[base + 38LLU] = stack[base + 31]/*labelfail*/; | |
21641 | + stack[base + 40LLU] = stack[base + 33]/*labelfail*/; | |
21493 | 21642 | // set stack-base & callee-address |
21494 | - base += 38LLU; | |
21643 | + base += 40LLU; | |
21495 | 21644 | label = 18446744073709551590LLU; // printnr |
21496 | 21645 | break; |
21497 | 21646 | } |
21498 | - case 1736LLU: // copy-back deleter (printnr to ProcCall) | |
21647 | + case 1750LLU: // copy-back deleter (printnr to ProcCall) | |
21499 | 21648 | { |
21500 | 21649 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n"); |
21501 | 21650 | // copy mutable arguments back from call to printnr |
21502 | - label = 1523LLU; // continue to roll stack | |
21651 | + label = 1537LLU; // continue to roll stack | |
21503 | 21652 | break; |
21504 | 21653 | } |
21505 | - case 1737LLU: // return from printnr to ProcCall | |
21654 | + case 1751LLU: // return from printnr to ProcCall | |
21506 | 21655 | { |
21507 | 21656 | // copy mutable arguments back from call to printnr |
21508 | 21657 | printf("%s", "LLU: // copy-back deleter ("); |
21509 | 21658 | // call printid from ProcCall |
21510 | - stack[base + 35LLU] = 1738LLU/*throw to this address*/; | |
21511 | - stack[base + 36LLU] = base; | |
21512 | - stack[base + 37LLU] = 1739LLU; | |
21659 | + stack[base + 37LLU] = 1752LLU/*throw to this address*/; | |
21660 | + stack[base + 38LLU] = base; | |
21661 | + stack[base + 39LLU] = 1753LLU; | |
21513 | 21662 | // arguments for call to printid |
21514 | - stack[base + 38LLU] = stack[base + 23]/*ceid*/; | |
21663 | + stack[base + 40LLU] = stack[base + 24]/*ceid*/; | |
21515 | 21664 | // set stack-base & callee-address |
21516 | - base += 38LLU; | |
21665 | + base += 40LLU; | |
21517 | 21666 | label = 18446744073709551587LLU; // printid |
21518 | 21667 | break; |
21519 | 21668 | } |
21520 | - case 1738LLU: // copy-back deleter (printid to ProcCall) | |
21669 | + case 1752LLU: // copy-back deleter (printid to ProcCall) | |
21521 | 21670 | { |
21522 | 21671 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n"); |
21523 | 21672 | // copy mutable arguments back from call to printid |
21524 | - label = 1523LLU; // continue to roll stack | |
21673 | + label = 1537LLU; // continue to roll stack | |
21525 | 21674 | break; |
21526 | 21675 | } |
21527 | - case 1739LLU: // return from printid to ProcCall | |
21676 | + case 1753LLU: // return from printid to ProcCall | |
21528 | 21677 | { |
21529 | 21678 | // copy mutable arguments back from call to printid |
21530 | 21679 | printf("%s", " to "); |
21531 | 21680 | // call printid from ProcCall |
21532 | - stack[base + 35LLU] = 1740LLU/*throw to this address*/; | |
21533 | - stack[base + 36LLU] = base; | |
21534 | - stack[base + 37LLU] = 1741LLU; | |
21681 | + stack[base + 37LLU] = 1754LLU/*throw to this address*/; | |
21682 | + stack[base + 38LLU] = base; | |
21683 | + stack[base + 39LLU] = 1755LLU; | |
21535 | 21684 | // arguments for call to printid |
21536 | - stack[base + 38LLU] = stack[base + 7]/*fnid*/; | |
21685 | + stack[base + 40LLU] = stack[base + 8]/*fnid*/; | |
21537 | 21686 | // set stack-base & callee-address |
21538 | - base += 38LLU; | |
21687 | + base += 40LLU; | |
21539 | 21688 | label = 18446744073709551587LLU; // printid |
21540 | 21689 | break; |
21541 | 21690 | } |
21542 | - case 1740LLU: // copy-back deleter (printid to ProcCall) | |
21691 | + case 1754LLU: // copy-back deleter (printid to ProcCall) | |
21543 | 21692 | { |
21544 | 21693 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n"); |
21545 | 21694 | // copy mutable arguments back from call to printid |
21546 | - label = 1523LLU; // continue to roll stack | |
21695 | + label = 1537LLU; // continue to roll stack | |
21547 | 21696 | break; |
21548 | 21697 | } |
21549 | - case 1741LLU: // return from printid to ProcCall | |
21698 | + case 1755LLU: // return from printid to ProcCall | |
21550 | 21699 | { |
21551 | 21700 | // copy mutable arguments back from call to printid |
21552 | 21701 | printf("%s", ")"); |
@@ -21553,68 +21702,68 @@ | ||
21553 | 21702 | printf("%s", "\n {"); |
21554 | 21703 | printf("%s", "\n fprintf(stderr, \"in function "); |
21555 | 21704 | // call printid from ProcCall |
21556 | - stack[base + 35LLU] = 1742LLU/*throw to this address*/; | |
21557 | - stack[base + 36LLU] = base; | |
21558 | - stack[base + 37LLU] = 1743LLU; | |
21705 | + stack[base + 37LLU] = 1756LLU/*throw to this address*/; | |
21706 | + stack[base + 38LLU] = base; | |
21707 | + stack[base + 39LLU] = 1757LLU; | |
21559 | 21708 | // arguments for call to printid |
21560 | - stack[base + 38LLU] = stack[base + 7]/*fnid*/; | |
21709 | + stack[base + 40LLU] = stack[base + 8]/*fnid*/; | |
21561 | 21710 | // set stack-base & callee-address |
21562 | - base += 38LLU; | |
21711 | + base += 40LLU; | |
21563 | 21712 | label = 18446744073709551587LLU; // printid |
21564 | 21713 | break; |
21565 | 21714 | } |
21566 | - case 1742LLU: // copy-back deleter (printid to ProcCall) | |
21715 | + case 1756LLU: // copy-back deleter (printid to ProcCall) | |
21567 | 21716 | { |
21568 | 21717 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n"); |
21569 | 21718 | // copy mutable arguments back from call to printid |
21570 | - label = 1523LLU; // continue to roll stack | |
21719 | + label = 1537LLU; // continue to roll stack | |
21571 | 21720 | break; |
21572 | 21721 | } |
21573 | - case 1743LLU: // return from printid to ProcCall | |
21722 | + case 1757LLU: // return from printid to ProcCall | |
21574 | 21723 | { |
21575 | 21724 | // copy mutable arguments back from call to printid |
21576 | 21725 | printf("%s", ": unrolling stack, copy-back ("); |
21577 | 21726 | // call printid from ProcCall |
21578 | - stack[base + 35LLU] = 1744LLU/*throw to this address*/; | |
21579 | - stack[base + 36LLU] = base; | |
21580 | - stack[base + 37LLU] = 1745LLU; | |
21727 | + stack[base + 37LLU] = 1758LLU/*throw to this address*/; | |
21728 | + stack[base + 38LLU] = base; | |
21729 | + stack[base + 39LLU] = 1759LLU; | |
21581 | 21730 | // arguments for call to printid |
21582 | - stack[base + 38LLU] = stack[base + 23]/*ceid*/; | |
21731 | + stack[base + 40LLU] = stack[base + 24]/*ceid*/; | |
21583 | 21732 | // set stack-base & callee-address |
21584 | - base += 38LLU; | |
21733 | + base += 40LLU; | |
21585 | 21734 | label = 18446744073709551587LLU; // printid |
21586 | 21735 | break; |
21587 | 21736 | } |
21588 | - case 1744LLU: // copy-back deleter (printid to ProcCall) | |
21737 | + case 1758LLU: // copy-back deleter (printid to ProcCall) | |
21589 | 21738 | { |
21590 | 21739 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n"); |
21591 | 21740 | // copy mutable arguments back from call to printid |
21592 | - label = 1523LLU; // continue to roll stack | |
21741 | + label = 1537LLU; // continue to roll stack | |
21593 | 21742 | break; |
21594 | 21743 | } |
21595 | - case 1745LLU: // return from printid to ProcCall | |
21744 | + case 1759LLU: // return from printid to ProcCall | |
21596 | 21745 | { |
21597 | 21746 | // copy mutable arguments back from call to printid |
21598 | 21747 | printf("%s", " to "); |
21599 | 21748 | // call printid from ProcCall |
21600 | - stack[base + 35LLU] = 1746LLU/*throw to this address*/; | |
21601 | - stack[base + 36LLU] = base; | |
21602 | - stack[base + 37LLU] = 1747LLU; | |
21749 | + stack[base + 37LLU] = 1760LLU/*throw to this address*/; | |
21750 | + stack[base + 38LLU] = base; | |
21751 | + stack[base + 39LLU] = 1761LLU; | |
21603 | 21752 | // arguments for call to printid |
21604 | - stack[base + 38LLU] = stack[base + 7]/*fnid*/; | |
21753 | + stack[base + 40LLU] = stack[base + 8]/*fnid*/; | |
21605 | 21754 | // set stack-base & callee-address |
21606 | - base += 38LLU; | |
21755 | + base += 40LLU; | |
21607 | 21756 | label = 18446744073709551587LLU; // printid |
21608 | 21757 | break; |
21609 | 21758 | } |
21610 | - case 1746LLU: // copy-back deleter (printid to ProcCall) | |
21759 | + case 1760LLU: // copy-back deleter (printid to ProcCall) | |
21611 | 21760 | { |
21612 | 21761 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n"); |
21613 | 21762 | // copy mutable arguments back from call to printid |
21614 | - label = 1523LLU; // continue to roll stack | |
21763 | + label = 1537LLU; // continue to roll stack | |
21615 | 21764 | break; |
21616 | 21765 | } |
21617 | - case 1747LLU: // return from printid to ProcCall | |
21766 | + case 1761LLU: // return from printid to ProcCall | |
21618 | 21767 | { |
21619 | 21768 | // copy mutable arguments back from call to printid |
21620 | 21769 | printf("%s", ")"); |
@@ -21622,138 +21771,138 @@ | ||
21622 | 21771 | printf("%s", "\n uint64_t *oldstack = (uint64_t *)stack[0];"); |
21623 | 21772 | printf("%s", "\n // copy mutable arguments back from call to "); |
21624 | 21773 | // call printid from ProcCall |
21625 | - stack[base + 35LLU] = 1748LLU/*throw to this address*/; | |
21626 | - stack[base + 36LLU] = base; | |
21627 | - stack[base + 37LLU] = 1749LLU; | |
21774 | + stack[base + 37LLU] = 1762LLU/*throw to this address*/; | |
21775 | + stack[base + 38LLU] = base; | |
21776 | + stack[base + 39LLU] = 1763LLU; | |
21628 | 21777 | // arguments for call to printid |
21629 | - stack[base + 38LLU] = stack[base + 23]/*ceid*/; | |
21778 | + stack[base + 40LLU] = stack[base + 24]/*ceid*/; | |
21630 | 21779 | // set stack-base & callee-address |
21631 | - base += 38LLU; | |
21780 | + base += 40LLU; | |
21632 | 21781 | label = 18446744073709551587LLU; // printid |
21633 | 21782 | break; |
21634 | 21783 | } |
21635 | - case 1748LLU: // copy-back deleter (printid to ProcCall) | |
21784 | + case 1762LLU: // copy-back deleter (printid to ProcCall) | |
21636 | 21785 | { |
21637 | 21786 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n"); |
21638 | 21787 | // copy mutable arguments back from call to printid |
21639 | - label = 1523LLU; // continue to roll stack | |
21788 | + label = 1537LLU; // continue to roll stack | |
21640 | 21789 | break; |
21641 | 21790 | } |
21642 | - case 1749LLU: // return from printid to ProcCall | |
21791 | + case 1763LLU: // return from printid to ProcCall | |
21643 | 21792 | { |
21644 | 21793 | // copy mutable arguments back from call to printid |
21645 | - flippedassign(stack[base + 18]/*copyback*/, &stack[base + 35]); | |
21646 | - label = 1750LLU; // start to repeat | |
21794 | + flippedassign(stack[base + 19]/*copyback*/, &stack[base + 37]); | |
21795 | + label = 1764LLU; // start to repeat | |
21647 | 21796 | break; |
21648 | 21797 | } |
21649 | - case 1750LLU: // repeat from here | |
21798 | + case 1764LLU: // repeat from here | |
21650 | 21799 | { |
21651 | - if(!stack[base + 35]) | |
21800 | + if(!stack[base + 37]) | |
21652 | 21801 | { |
21653 | - label = 1751LLU; // break loop | |
21802 | + label = 1765LLU; // break loop | |
21654 | 21803 | break; |
21655 | 21804 | } |
21656 | 21805 | |
21657 | 21806 | // loop body |
21658 | - stack[base + 36] = (uint64_t)(((const struct listnode *)(stack[base + 35]))->data); | |
21659 | - stack[base + 37]/*previous*/ = stack[base + 35]; | |
21660 | - stack[base + 35] = (uint64_t)(((const struct listnode *)(stack[base + 35]))->next); | |
21661 | - if(/*idnr*/0 != ((uint64_t *)(stack[base + 36]/*idnr*/))[0]) | |
21807 | + stack[base + 38] = (uint64_t)(((const struct listnode *)(stack[base + 37]))->data); | |
21808 | + stack[base + 39]/*previous*/ = stack[base + 37]; | |
21809 | + stack[base + 37] = (uint64_t)(((const struct listnode *)(stack[base + 37]))->next); | |
21810 | + if(/*idnr*/0 != ((uint64_t *)(stack[base + 38]/*idnr*/))[0]) | |
21662 | 21811 | { |
21663 | - label = 1753LLU; // jump to alternative | |
21812 | + label = 1767LLU; // jump to alternative | |
21664 | 21813 | break; |
21665 | 21814 | } |
21666 | 21815 | |
21667 | - /*content*/stack[base + 38] = ((uint64_t **)(stack[base + 36]/*idnr*/))[1][0]/*id*/; | |
21668 | - /*sum*/stack[base + 39] = ((uint64_t **)(stack[base + 36]/*idnr*/))[1][1]/*nr*/; | |
21816 | + /*content*/stack[base + 40] = ((uint64_t **)(stack[base + 38]/*idnr*/))[1][0]/*id*/; | |
21817 | + /*sum*/stack[base + 41] = ((uint64_t **)(stack[base + 38]/*idnr*/))[1][1]/*nr*/; | |
21669 | 21818 | |
21670 | 21819 | // case |
21671 | 21820 | printf("%s", "\n old"); |
21672 | 21821 | // call emitvar from ProcCall |
21673 | - stack[base + 40LLU] = 1754LLU/*throw to this address*/; | |
21674 | - stack[base + 41LLU] = base; | |
21675 | - stack[base + 42LLU] = 1755LLU; | |
21822 | + stack[base + 42LLU] = 1768LLU/*throw to this address*/; | |
21823 | + stack[base + 43LLU] = base; | |
21824 | + stack[base + 44LLU] = 1769LLU; | |
21676 | 21825 | // arguments for call to emitvar |
21677 | - stack[base + 43LLU] = stack[base + 7]/*fnid*/; | |
21678 | - stack[base + 44LLU] = stack[base + 38]/*content*/; | |
21679 | - stack[base + 45LLU] = stack[base + 2]/*scopes*/; | |
21680 | - stack[base + 46LLU] = stack[base + 3]/*scope*/; | |
21826 | + stack[base + 45LLU] = stack[base + 8]/*fnid*/; | |
21827 | + stack[base + 46LLU] = stack[base + 40]/*content*/; | |
21828 | + stack[base + 47LLU] = stack[base + 2]/*scopes*/; | |
21829 | + stack[base + 48LLU] = stack[base + 3]/*scope*/; | |
21681 | 21830 | // set stack-base & callee-address |
21682 | - base += 43LLU; | |
21831 | + base += 45LLU; | |
21683 | 21832 | label = 659LLU; // emitvar |
21684 | 21833 | break; |
21685 | 21834 | } |
21686 | - case 1754LLU: // copy-back deleter (emitvar to ProcCall) | |
21835 | + case 1768LLU: // copy-back deleter (emitvar to ProcCall) | |
21687 | 21836 | { |
21688 | 21837 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (emitvar to ProcCall)\n"); |
21689 | 21838 | // copy mutable arguments back from call to emitvar |
21690 | - label = 1523LLU; // continue to roll stack | |
21839 | + label = 1537LLU; // continue to roll stack | |
21691 | 21840 | break; |
21692 | 21841 | } |
21693 | - case 1755LLU: // return from emitvar to ProcCall | |
21842 | + case 1769LLU: // return from emitvar to ProcCall | |
21694 | 21843 | { |
21695 | 21844 | // copy mutable arguments back from call to emitvar |
21696 | 21845 | printf("%s", " = stack["); |
21697 | 21846 | // call printnr from ProcCall |
21698 | - stack[base + 40LLU] = 1756LLU/*throw to this address*/; | |
21699 | - stack[base + 41LLU] = base; | |
21700 | - stack[base + 42LLU] = 1757LLU; | |
21847 | + stack[base + 42LLU] = 1770LLU/*throw to this address*/; | |
21848 | + stack[base + 43LLU] = base; | |
21849 | + stack[base + 44LLU] = 1771LLU; | |
21701 | 21850 | // arguments for call to printnr |
21702 | - stack[base + 43LLU] = stack[base + 39]/*sum*/; | |
21851 | + stack[base + 45LLU] = stack[base + 41]/*sum*/; | |
21703 | 21852 | // set stack-base & callee-address |
21704 | - base += 43LLU; | |
21853 | + base += 45LLU; | |
21705 | 21854 | label = 18446744073709551590LLU; // printnr |
21706 | 21855 | break; |
21707 | 21856 | } |
21708 | - case 1756LLU: // copy-back deleter (printnr to ProcCall) | |
21857 | + case 1770LLU: // copy-back deleter (printnr to ProcCall) | |
21709 | 21858 | { |
21710 | 21859 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n"); |
21711 | 21860 | // copy mutable arguments back from call to printnr |
21712 | - label = 1523LLU; // continue to roll stack | |
21861 | + label = 1537LLU; // continue to roll stack | |
21713 | 21862 | break; |
21714 | 21863 | } |
21715 | - case 1757LLU: // return from printnr to ProcCall | |
21864 | + case 1771LLU: // return from printnr to ProcCall | |
21716 | 21865 | { |
21717 | 21866 | // copy mutable arguments back from call to printnr |
21718 | 21867 | printf("%s", "LLU];"); |
21719 | - ((uint64_t **)(stack[base + 36]))[1][1] = stack[base + 39]; | |
21720 | - ((uint64_t **)(stack[base + 36]))[1][0] = stack[base + 38]; | |
21721 | - label = 1752LLU; // case complete | |
21868 | + ((uint64_t **)(stack[base + 38]))[1][1] = stack[base + 41]; | |
21869 | + ((uint64_t **)(stack[base + 38]))[1][0] = stack[base + 40]; | |
21870 | + label = 1766LLU; // case complete | |
21722 | 21871 | break; |
21723 | 21872 | } |
21724 | - case 1753LLU: // try next case | |
21873 | + case 1767LLU: // try next case | |
21725 | 21874 | { |
21726 | 21875 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
21727 | 21876 | exit(-1); |
21728 | 21877 | } |
21729 | - case 1752LLU: // completed switch | |
21878 | + case 1766LLU: // completed switch | |
21730 | 21879 | { |
21731 | - ((struct listnode *)(stack[base + 37]/*previous*/))->data = stack[base + 36]; | |
21732 | - label = 1750LLU; // repeat | |
21880 | + ((struct listnode *)(stack[base + 39]/*previous*/))->data = stack[base + 38]; | |
21881 | + label = 1764LLU; // repeat | |
21733 | 21882 | break; |
21734 | 21883 | } |
21735 | - case 1751LLU: // loop finished | |
21884 | + case 1765LLU: // loop finished | |
21736 | 21885 | { |
21737 | 21886 | printf("%s", "\n if(stack["); |
21738 | 21887 | // call printnr from ProcCall |
21739 | - stack[base + 38LLU] = 1758LLU/*throw to this address*/; | |
21740 | - stack[base + 39LLU] = base; | |
21741 | - stack[base + 40LLU] = 1759LLU; | |
21888 | + stack[base + 40LLU] = 1772LLU/*throw to this address*/; | |
21889 | + stack[base + 41LLU] = base; | |
21890 | + stack[base + 42LLU] = 1773LLU; | |
21742 | 21891 | // arguments for call to printnr |
21743 | - stack[base + 41LLU] = stack[base + 32]/*recsztotal*/; | |
21892 | + stack[base + 43LLU] = stack[base + 34]/*recsztotal*/; | |
21744 | 21893 | // set stack-base & callee-address |
21745 | - base += 41LLU; | |
21894 | + base += 43LLU; | |
21746 | 21895 | label = 18446744073709551590LLU; // printnr |
21747 | 21896 | break; |
21748 | 21897 | } |
21749 | - case 1758LLU: // copy-back deleter (printnr to ProcCall) | |
21898 | + case 1772LLU: // copy-back deleter (printnr to ProcCall) | |
21750 | 21899 | { |
21751 | 21900 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n"); |
21752 | 21901 | // copy mutable arguments back from call to printnr |
21753 | - label = 1523LLU; // continue to roll stack | |
21902 | + label = 1537LLU; // continue to roll stack | |
21754 | 21903 | break; |
21755 | 21904 | } |
21756 | - case 1759LLU: // return from printnr to ProcCall | |
21905 | + case 1773LLU: // return from printnr to ProcCall | |
21757 | 21906 | { |
21758 | 21907 | // copy mutable arguments back from call to printnr |
21759 | 21908 | printf("%s", "LLU] != 9876543210LLU)"); |
@@ -21760,24 +21909,24 @@ | ||
21760 | 21909 | printf("%s", "\n {"); |
21761 | 21910 | printf("%s", "\n fprintf(stderr, \"INTERNAL ERROR - OVERFLOW (in recursive call to "); |
21762 | 21911 | // call printid from ProcCall |
21763 | - stack[base + 38LLU] = 1760LLU/*throw to this address*/; | |
21764 | - stack[base + 39LLU] = base; | |
21765 | - stack[base + 40LLU] = 1761LLU; | |
21912 | + stack[base + 40LLU] = 1774LLU/*throw to this address*/; | |
21913 | + stack[base + 41LLU] = base; | |
21914 | + stack[base + 42LLU] = 1775LLU; | |
21766 | 21915 | // arguments for call to printid |
21767 | - stack[base + 41LLU] = stack[base + 23]/*ceid*/; | |
21916 | + stack[base + 43LLU] = stack[base + 24]/*ceid*/; | |
21768 | 21917 | // set stack-base & callee-address |
21769 | - base += 41LLU; | |
21918 | + base += 43LLU; | |
21770 | 21919 | label = 18446744073709551587LLU; // printid |
21771 | 21920 | break; |
21772 | 21921 | } |
21773 | - case 1760LLU: // copy-back deleter (printid to ProcCall) | |
21922 | + case 1774LLU: // copy-back deleter (printid to ProcCall) | |
21774 | 21923 | { |
21775 | 21924 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n"); |
21776 | 21925 | // copy mutable arguments back from call to printid |
21777 | - label = 1523LLU; // continue to roll stack | |
21926 | + label = 1537LLU; // continue to roll stack | |
21778 | 21927 | break; |
21779 | 21928 | } |
21780 | - case 1761LLU: // return from printid to ProcCall | |
21929 | + case 1775LLU: // return from printid to ProcCall | |
21781 | 21930 | { |
21782 | 21931 | // copy mutable arguments back from call to printid |
21783 | 21932 | printf("%s", ")!\");"); |
@@ -21785,24 +21934,24 @@ | ||
21785 | 21934 | printf("%s", "\n }"); |
21786 | 21935 | printf("%s", "\n Free("); |
21787 | 21936 | // call printnr from ProcCall |
21788 | - stack[base + 38LLU] = 1762LLU/*throw to this address*/; | |
21789 | - stack[base + 39LLU] = base; | |
21790 | - stack[base + 40LLU] = 1763LLU; | |
21937 | + stack[base + 40LLU] = 1776LLU/*throw to this address*/; | |
21938 | + stack[base + 41LLU] = base; | |
21939 | + stack[base + 42LLU] = 1777LLU; | |
21791 | 21940 | // arguments for call to printnr |
21792 | - stack[base + 41LLU] = stack[base + 32]/*recsztotal*/; | |
21941 | + stack[base + 43LLU] = stack[base + 34]/*recsztotal*/; | |
21793 | 21942 | // set stack-base & callee-address |
21794 | - base += 41LLU; | |
21943 | + base += 43LLU; | |
21795 | 21944 | label = 18446744073709551590LLU; // printnr |
21796 | 21945 | break; |
21797 | 21946 | } |
21798 | - case 1762LLU: // copy-back deleter (printnr to ProcCall) | |
21947 | + case 1776LLU: // copy-back deleter (printnr to ProcCall) | |
21799 | 21948 | { |
21800 | 21949 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n"); |
21801 | 21950 | // copy mutable arguments back from call to printnr |
21802 | - label = 1523LLU; // continue to roll stack | |
21951 | + label = 1537LLU; // continue to roll stack | |
21803 | 21952 | break; |
21804 | 21953 | } |
21805 | - case 1763LLU: // return from printnr to ProcCall | |
21954 | + case 1777LLU: // return from printnr to ProcCall | |
21806 | 21955 | { |
21807 | 21956 | // copy mutable arguments back from call to printnr |
21808 | 21957 | printf("%s", "LLU + 1, sizeof(uint64_t), stack);"); |
@@ -21809,105 +21958,105 @@ | ||
21809 | 21958 | printf("%s", "\n stack = oldstack;"); |
21810 | 21959 | printf("%s", "\n label = "); |
21811 | 21960 | // call printnr from ProcCall |
21812 | - stack[base + 38LLU] = 1764LLU/*throw to this address*/; | |
21813 | - stack[base + 39LLU] = base; | |
21814 | - stack[base + 40LLU] = 1765LLU; | |
21961 | + stack[base + 40LLU] = 1778LLU/*throw to this address*/; | |
21962 | + stack[base + 41LLU] = base; | |
21963 | + stack[base + 42LLU] = 1779LLU; | |
21815 | 21964 | // arguments for call to printnr |
21816 | - stack[base + 41LLU] = stack[base + 33]/*labelthrow*/; | |
21965 | + stack[base + 43LLU] = stack[base + 35]/*labelthrow*/; | |
21817 | 21966 | // set stack-base & callee-address |
21818 | - base += 41LLU; | |
21967 | + base += 43LLU; | |
21819 | 21968 | label = 18446744073709551590LLU; // printnr |
21820 | 21969 | break; |
21821 | 21970 | } |
21822 | - case 1764LLU: // copy-back deleter (printnr to ProcCall) | |
21971 | + case 1778LLU: // copy-back deleter (printnr to ProcCall) | |
21823 | 21972 | { |
21824 | 21973 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n"); |
21825 | 21974 | // copy mutable arguments back from call to printnr |
21826 | - label = 1523LLU; // continue to roll stack | |
21975 | + label = 1537LLU; // continue to roll stack | |
21827 | 21976 | break; |
21828 | 21977 | } |
21829 | - case 1765LLU: // return from printnr to ProcCall | |
21978 | + case 1779LLU: // return from printnr to ProcCall | |
21830 | 21979 | { |
21831 | 21980 | // copy mutable arguments back from call to printnr |
21832 | 21981 | printf("%s", "LLU; // continue to unroll stack"); |
21833 | 21982 | printf("%s", "\n break;"); |
21834 | 21983 | printf("%s", "\n }"); |
21835 | - ((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 34]; | |
21836 | - ((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 33]; | |
21837 | - label = 1734LLU; // case complete | |
21984 | + ((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 36]; | |
21985 | + ((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 35]; | |
21986 | + label = 1748LLU; // case complete | |
21838 | 21987 | break; |
21839 | 21988 | } |
21840 | - case 1735LLU: // try next case | |
21989 | + case 1749LLU: // try next case | |
21841 | 21990 | { |
21842 | 21991 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
21843 | 21992 | exit(-1); |
21844 | 21993 | } |
21845 | - case 1734LLU: // completed switch | |
21994 | + case 1748LLU: // completed switch | |
21846 | 21995 | { |
21847 | 21996 | printf("%s", "\n case "); |
21848 | 21997 | // call printnr from ProcCall |
21849 | - stack[base + 33LLU] = 1766LLU/*throw to this address*/; | |
21850 | - stack[base + 34LLU] = base; | |
21851 | - stack[base + 35LLU] = 1767LLU; | |
21998 | + stack[base + 35LLU] = 1780LLU/*throw to this address*/; | |
21999 | + stack[base + 36LLU] = base; | |
22000 | + stack[base + 37LLU] = 1781LLU; | |
21852 | 22001 | // arguments for call to printnr |
21853 | - stack[base + 36LLU] = stack[base + 16]/*label*/; | |
22002 | + stack[base + 38LLU] = stack[base + 17]/*label*/; | |
21854 | 22003 | // set stack-base & callee-address |
21855 | - base += 36LLU; | |
22004 | + base += 38LLU; | |
21856 | 22005 | label = 18446744073709551590LLU; // printnr |
21857 | 22006 | break; |
21858 | 22007 | } |
21859 | - case 1766LLU: // copy-back deleter (printnr to ProcCall) | |
22008 | + case 1780LLU: // copy-back deleter (printnr to ProcCall) | |
21860 | 22009 | { |
21861 | 22010 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n"); |
21862 | 22011 | // copy mutable arguments back from call to printnr |
21863 | - label = 1523LLU; // continue to roll stack | |
22012 | + label = 1537LLU; // continue to roll stack | |
21864 | 22013 | break; |
21865 | 22014 | } |
21866 | - case 1767LLU: // return from printnr to ProcCall | |
22015 | + case 1781LLU: // return from printnr to ProcCall | |
21867 | 22016 | { |
21868 | 22017 | // copy mutable arguments back from call to printnr |
21869 | 22018 | printf("%s", "LLU: // return from "); |
21870 | 22019 | // call printid from ProcCall |
21871 | - stack[base + 33LLU] = 1768LLU/*throw to this address*/; | |
21872 | - stack[base + 34LLU] = base; | |
21873 | - stack[base + 35LLU] = 1769LLU; | |
22020 | + stack[base + 35LLU] = 1782LLU/*throw to this address*/; | |
22021 | + stack[base + 36LLU] = base; | |
22022 | + stack[base + 37LLU] = 1783LLU; | |
21874 | 22023 | // arguments for call to printid |
21875 | - stack[base + 36LLU] = stack[base + 23]/*ceid*/; | |
22024 | + stack[base + 38LLU] = stack[base + 24]/*ceid*/; | |
21876 | 22025 | // set stack-base & callee-address |
21877 | - base += 36LLU; | |
22026 | + base += 38LLU; | |
21878 | 22027 | label = 18446744073709551587LLU; // printid |
21879 | 22028 | break; |
21880 | 22029 | } |
21881 | - case 1768LLU: // copy-back deleter (printid to ProcCall) | |
22030 | + case 1782LLU: // copy-back deleter (printid to ProcCall) | |
21882 | 22031 | { |
21883 | 22032 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n"); |
21884 | 22033 | // copy mutable arguments back from call to printid |
21885 | - label = 1523LLU; // continue to roll stack | |
22034 | + label = 1537LLU; // continue to roll stack | |
21886 | 22035 | break; |
21887 | 22036 | } |
21888 | - case 1769LLU: // return from printid to ProcCall | |
22037 | + case 1783LLU: // return from printid to ProcCall | |
21889 | 22038 | { |
21890 | 22039 | // copy mutable arguments back from call to printid |
21891 | 22040 | printf("%s", " to "); |
21892 | 22041 | // call printid from ProcCall |
21893 | - stack[base + 33LLU] = 1770LLU/*throw to this address*/; | |
21894 | - stack[base + 34LLU] = base; | |
21895 | - stack[base + 35LLU] = 1771LLU; | |
22042 | + stack[base + 35LLU] = 1784LLU/*throw to this address*/; | |
22043 | + stack[base + 36LLU] = base; | |
22044 | + stack[base + 37LLU] = 1785LLU; | |
21896 | 22045 | // arguments for call to printid |
21897 | - stack[base + 36LLU] = stack[base + 7]/*fnid*/; | |
22046 | + stack[base + 38LLU] = stack[base + 8]/*fnid*/; | |
21898 | 22047 | // set stack-base & callee-address |
21899 | - base += 36LLU; | |
22048 | + base += 38LLU; | |
21900 | 22049 | label = 18446744073709551587LLU; // printid |
21901 | 22050 | break; |
21902 | 22051 | } |
21903 | - case 1770LLU: // copy-back deleter (printid to ProcCall) | |
22052 | + case 1784LLU: // copy-back deleter (printid to ProcCall) | |
21904 | 22053 | { |
21905 | 22054 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n"); |
21906 | 22055 | // copy mutable arguments back from call to printid |
21907 | - label = 1523LLU; // continue to roll stack | |
22056 | + label = 1537LLU; // continue to roll stack | |
21908 | 22057 | break; |
21909 | 22058 | } |
21910 | - case 1771LLU: // return from printid to ProcCall | |
22059 | + case 1785LLU: // return from printid to ProcCall | |
21911 | 22060 | { |
21912 | 22061 | // copy mutable arguments back from call to printid |
21913 | 22062 | printf("%s", "\n {"); |
@@ -21914,121 +22063,121 @@ | ||
21914 | 22063 | printf("%s", "\n uint64_t *oldstack = (uint64_t *)stack[0];"); |
21915 | 22064 | printf("%s", "\n // copy mutable arguments back from call to "); |
21916 | 22065 | // call printid from ProcCall |
21917 | - stack[base + 33LLU] = 1772LLU/*throw to this address*/; | |
21918 | - stack[base + 34LLU] = base; | |
21919 | - stack[base + 35LLU] = 1773LLU; | |
22066 | + stack[base + 35LLU] = 1786LLU/*throw to this address*/; | |
22067 | + stack[base + 36LLU] = base; | |
22068 | + stack[base + 37LLU] = 1787LLU; | |
21920 | 22069 | // arguments for call to printid |
21921 | - stack[base + 36LLU] = stack[base + 23]/*ceid*/; | |
22070 | + stack[base + 38LLU] = stack[base + 24]/*ceid*/; | |
21922 | 22071 | // set stack-base & callee-address |
21923 | - base += 36LLU; | |
22072 | + base += 38LLU; | |
21924 | 22073 | label = 18446744073709551587LLU; // printid |
21925 | 22074 | break; |
21926 | 22075 | } |
21927 | - case 1772LLU: // copy-back deleter (printid to ProcCall) | |
22076 | + case 1786LLU: // copy-back deleter (printid to ProcCall) | |
21928 | 22077 | { |
21929 | 22078 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n"); |
21930 | 22079 | // copy mutable arguments back from call to printid |
21931 | - label = 1523LLU; // continue to roll stack | |
22080 | + label = 1537LLU; // continue to roll stack | |
21932 | 22081 | break; |
21933 | 22082 | } |
21934 | - case 1773LLU: // return from printid to ProcCall | |
22083 | + case 1787LLU: // return from printid to ProcCall | |
21935 | 22084 | { |
21936 | 22085 | // copy mutable arguments back from call to printid |
21937 | - label = 1774LLU; // start to repeat | |
22086 | + label = 1788LLU; // start to repeat | |
21938 | 22087 | break; |
21939 | 22088 | } |
21940 | - case 1774LLU: // repeat from here | |
22089 | + case 1788LLU: // repeat from here | |
21941 | 22090 | { |
21942 | - if(!stack[base + 18]) | |
22091 | + if(!stack[base + 19]) | |
21943 | 22092 | { |
21944 | - label = 1775LLU; // break loop | |
22093 | + label = 1789LLU; // break loop | |
21945 | 22094 | break; |
21946 | 22095 | } |
21947 | 22096 | |
21948 | 22097 | // loop body |
21949 | - stack[base + 33] = (uint64_t)(((const struct listnode *)(stack[base + 18]))->data); | |
22098 | + stack[base + 35] = (uint64_t)(((const struct listnode *)(stack[base + 19]))->data); | |
21950 | 22099 | { |
21951 | - struct listnode *list = (struct listnode *)(stack[base + 18]); | |
21952 | - stack[base + 18] = (uint64_t)list->next; | |
22100 | + struct listnode *list = (struct listnode *)(stack[base + 19]); | |
22101 | + stack[base + 19] = (uint64_t)list->next; | |
21953 | 22102 | Free(1, sizeof(struct listnode), list); |
21954 | 22103 | } |
21955 | - if(/*idnr*/0 != ((uint64_t *)(stack[base + 33]/*idnr*/))[0]) | |
22104 | + if(/*idnr*/0 != ((uint64_t *)(stack[base + 35]/*idnr*/))[0]) | |
21956 | 22105 | { |
21957 | - label = 1777LLU; // jump to alternative | |
22106 | + label = 1791LLU; // jump to alternative | |
21958 | 22107 | break; |
21959 | 22108 | } |
21960 | 22109 | |
21961 | - /*content*/stack[base + 34] = ((uint64_t **)(stack[base + 33]/*idnr*/))[1][0]/*id*/; | |
21962 | - /*sum*/stack[base + 35] = ((uint64_t **)(stack[base + 33]/*idnr*/))[1][1]/*nr*/; | |
22110 | + /*content*/stack[base + 36] = ((uint64_t **)(stack[base + 35]/*idnr*/))[1][0]/*id*/; | |
22111 | + /*sum*/stack[base + 37] = ((uint64_t **)(stack[base + 35]/*idnr*/))[1][1]/*nr*/; | |
21963 | 22112 | |
21964 | 22113 | // case |
21965 | 22114 | printf("%s", "\n old"); |
21966 | 22115 | // call emitvar from ProcCall |
21967 | - stack[base + 36LLU] = 1778LLU/*throw to this address*/; | |
21968 | - stack[base + 37LLU] = base; | |
21969 | - stack[base + 38LLU] = 1779LLU; | |
22116 | + stack[base + 38LLU] = 1792LLU/*throw to this address*/; | |
22117 | + stack[base + 39LLU] = base; | |
22118 | + stack[base + 40LLU] = 1793LLU; | |
21970 | 22119 | // arguments for call to emitvar |
21971 | - stack[base + 39LLU] = stack[base + 7]/*fnid*/; | |
21972 | - stack[base + 40LLU] = stack[base + 34]/*content*/; | |
21973 | - stack[base + 41LLU] = stack[base + 2]/*scopes*/; | |
21974 | - stack[base + 42LLU] = stack[base + 3]/*scope*/; | |
22120 | + stack[base + 41LLU] = stack[base + 8]/*fnid*/; | |
22121 | + stack[base + 42LLU] = stack[base + 36]/*content*/; | |
22122 | + stack[base + 43LLU] = stack[base + 2]/*scopes*/; | |
22123 | + stack[base + 44LLU] = stack[base + 3]/*scope*/; | |
21975 | 22124 | // set stack-base & callee-address |
21976 | - base += 39LLU; | |
22125 | + base += 41LLU; | |
21977 | 22126 | label = 659LLU; // emitvar |
21978 | 22127 | break; |
21979 | 22128 | } |
21980 | - case 1778LLU: // copy-back deleter (emitvar to ProcCall) | |
22129 | + case 1792LLU: // copy-back deleter (emitvar to ProcCall) | |
21981 | 22130 | { |
21982 | 22131 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (emitvar to ProcCall)\n"); |
21983 | 22132 | // copy mutable arguments back from call to emitvar |
21984 | - label = 1523LLU; // continue to roll stack | |
22133 | + label = 1537LLU; // continue to roll stack | |
21985 | 22134 | break; |
21986 | 22135 | } |
21987 | - case 1779LLU: // return from emitvar to ProcCall | |
22136 | + case 1793LLU: // return from emitvar to ProcCall | |
21988 | 22137 | { |
21989 | 22138 | // copy mutable arguments back from call to emitvar |
21990 | 22139 | printf("%s", " = stack["); |
21991 | 22140 | // call printnr from ProcCall |
21992 | - stack[base + 36LLU] = 1780LLU/*throw to this address*/; | |
21993 | - stack[base + 37LLU] = base; | |
21994 | - stack[base + 38LLU] = 1781LLU; | |
22141 | + stack[base + 38LLU] = 1794LLU/*throw to this address*/; | |
22142 | + stack[base + 39LLU] = base; | |
22143 | + stack[base + 40LLU] = 1795LLU; | |
21995 | 22144 | // arguments for call to printnr |
21996 | - stack[base + 39LLU] = stack[base + 35]/*sum*/; | |
22145 | + stack[base + 41LLU] = stack[base + 37]/*sum*/; | |
21997 | 22146 | // set stack-base & callee-address |
21998 | - base += 39LLU; | |
22147 | + base += 41LLU; | |
21999 | 22148 | label = 18446744073709551590LLU; // printnr |
22000 | 22149 | break; |
22001 | 22150 | } |
22002 | - case 1780LLU: // copy-back deleter (printnr to ProcCall) | |
22151 | + case 1794LLU: // copy-back deleter (printnr to ProcCall) | |
22003 | 22152 | { |
22004 | 22153 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n"); |
22005 | 22154 | // copy mutable arguments back from call to printnr |
22006 | - label = 1523LLU; // continue to roll stack | |
22155 | + label = 1537LLU; // continue to roll stack | |
22007 | 22156 | break; |
22008 | 22157 | } |
22009 | - case 1781LLU: // return from printnr to ProcCall | |
22158 | + case 1795LLU: // return from printnr to ProcCall | |
22010 | 22159 | { |
22011 | 22160 | // copy mutable arguments back from call to printnr |
22012 | 22161 | printf("%s", "LLU];"); |
22013 | - ((uint64_t **)(stack[base + 33]))[1][1] = stack[base + 35]; | |
22014 | - ((uint64_t **)(stack[base + 33]))[1][0] = stack[base + 34]; | |
22015 | - label = 1776LLU; // case complete | |
22162 | + ((uint64_t **)(stack[base + 35]))[1][1] = stack[base + 37]; | |
22163 | + ((uint64_t **)(stack[base + 35]))[1][0] = stack[base + 36]; | |
22164 | + label = 1790LLU; // case complete | |
22016 | 22165 | break; |
22017 | 22166 | } |
22018 | - case 1777LLU: // try next case | |
22167 | + case 1791LLU: // try next case | |
22019 | 22168 | { |
22020 | 22169 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
22021 | 22170 | exit(-1); |
22022 | 22171 | } |
22023 | - case 1776LLU: // completed switch | |
22172 | + case 1790LLU: // completed switch | |
22024 | 22173 | { |
22025 | 22174 | |
22026 | - uint64_t *newstack = (uint64_t *)(stack[base + 33] - sizeof(uint64_t) * 4); | |
22175 | + uint64_t *newstack = (uint64_t *)(stack[base + 35] - sizeof(uint64_t) * 4); | |
22027 | 22176 | // call ~idnr from ProcCall |
22028 | 22177 | newstack[0] = (uint64_t)stack; // backup stack location |
22029 | 22178 | newstack[1] = 1234567890; |
22030 | 22179 | newstack[2] = base; |
22031 | - newstack[3] = 1782LLU; | |
22180 | + newstack[3] = 1796LLU; | |
22032 | 22181 | stack = newstack; |
22033 | 22182 | // set stack-base & callee-address |
22034 | 22183 | base = 4/*deloffset*/; |
@@ -22035,20 +22184,20 @@ | ||
22035 | 22184 | label = 758LLU; // ~idnr |
22036 | 22185 | break; |
22037 | 22186 | } |
22038 | - case 1782LLU: // return from ~idnr to ProcCall | |
22187 | + case 1796LLU: // return from ~idnr to ProcCall | |
22039 | 22188 | { |
22040 | 22189 | stack = (uint64_t *)stack[0]; |
22041 | 22190 | // releasing toplevel container |
22042 | - Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 33] - sizeof(uint64_t) * 4)); | |
22191 | + Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 35] - sizeof(uint64_t) * 4)); | |
22043 | 22192 | |
22044 | - label = 1774LLU; // repeat | |
22193 | + label = 1788LLU; // repeat | |
22045 | 22194 | break; |
22046 | 22195 | } |
22047 | - case 1775LLU: // loop finished | |
22196 | + case 1789LLU: // loop finished | |
22048 | 22197 | { |
22049 | - if(!stack[base + 26]/*cerescount*/) | |
22198 | + if(!stack[base + 28]/*cerescount*/) | |
22050 | 22199 | { |
22051 | - label = 1783LLU; // jump to alternative | |
22200 | + label = 1797LLU; // jump to alternative | |
22052 | 22201 | break; |
22053 | 22202 | } |
22054 | 22203 |
@@ -22055,129 +22204,129 @@ | ||
22055 | 22204 | // consequent |
22056 | 22205 | printf("%s", "\n // copy back results provided by call to "); |
22057 | 22206 | // call printid from ProcCall |
22058 | - stack[base + 33LLU] = 1785LLU/*throw to this address*/; | |
22059 | - stack[base + 34LLU] = base; | |
22060 | - stack[base + 35LLU] = 1786LLU; | |
22207 | + stack[base + 35LLU] = 1799LLU/*throw to this address*/; | |
22208 | + stack[base + 36LLU] = base; | |
22209 | + stack[base + 37LLU] = 1800LLU; | |
22061 | 22210 | // arguments for call to printid |
22062 | - stack[base + 36LLU] = stack[base + 23]/*ceid*/; | |
22211 | + stack[base + 38LLU] = stack[base + 24]/*ceid*/; | |
22063 | 22212 | // set stack-base & callee-address |
22064 | - base += 36LLU; | |
22213 | + base += 38LLU; | |
22065 | 22214 | label = 18446744073709551587LLU; // printid |
22066 | 22215 | break; |
22067 | 22216 | } |
22068 | - case 1785LLU: // copy-back deleter (printid to ProcCall) | |
22217 | + case 1799LLU: // copy-back deleter (printid to ProcCall) | |
22069 | 22218 | { |
22070 | 22219 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n"); |
22071 | 22220 | // copy mutable arguments back from call to printid |
22072 | - label = 1523LLU; // continue to roll stack | |
22221 | + label = 1537LLU; // continue to roll stack | |
22073 | 22222 | break; |
22074 | 22223 | } |
22075 | - case 1786LLU: // return from printid to ProcCall | |
22224 | + case 1800LLU: // return from printid to ProcCall | |
22076 | 22225 | { |
22077 | 22226 | // copy mutable arguments back from call to printid |
22078 | - stack[base + 29]/*n*/ = stack[base + 26]/*cerescount*/; | |
22079 | - flippedassign(stack[base + 20]/*cerestypes*/, &stack[base + 33]); | |
22080 | - label = 1787LLU; // start to repeat | |
22227 | + stack[base + 31]/*n*/ = stack[base + 28]/*cerescount*/; | |
22228 | + flippedassign(stack[base + 21]/*cerestypes*/, &stack[base + 35]); | |
22229 | + label = 1801LLU; // start to repeat | |
22081 | 22230 | break; |
22082 | 22231 | } |
22083 | - case 1787LLU: // repeat from here | |
22232 | + case 1801LLU: // repeat from here | |
22084 | 22233 | { |
22085 | - if(!stack[base + 33]) | |
22234 | + if(!stack[base + 35]) | |
22086 | 22235 | { |
22087 | - label = 1788LLU; // break loop | |
22236 | + label = 1802LLU; // break loop | |
22088 | 22237 | break; |
22089 | 22238 | } |
22090 | 22239 | |
22091 | 22240 | // loop body |
22092 | - stack[base + 34] = (uint64_t)(((const struct listnode *)(stack[base + 33]))->data); | |
22093 | - stack[base + 35]/*previous*/ = stack[base + 33]; | |
22094 | - stack[base + 33] = (uint64_t)(((const struct listnode *)(stack[base + 33]))->next); | |
22241 | + stack[base + 36] = (uint64_t)(((const struct listnode *)(stack[base + 35]))->data); | |
22242 | + stack[base + 37]/*previous*/ = stack[base + 35]; | |
22243 | + stack[base + 35] = (uint64_t)(((const struct listnode *)(stack[base + 35]))->next); | |
22095 | 22244 | // call sub from ProcCall |
22096 | - stack[base + 36LLU] = 1789LLU/*throw to this address*/; | |
22097 | - stack[base + 37LLU] = base; | |
22098 | - stack[base + 38LLU] = 1790LLU; | |
22245 | + stack[base + 38LLU] = 1803LLU/*throw to this address*/; | |
22246 | + stack[base + 39LLU] = base; | |
22247 | + stack[base + 40LLU] = 1804LLU; | |
22099 | 22248 | // arguments for call to sub |
22100 | - stack[base + 40LLU] = stack[base + 26]/*cerescount*/; | |
22101 | - stack[base + 41LLU] = stack[base + 29]/*n*/; | |
22249 | + stack[base + 42LLU] = stack[base + 28]/*cerescount*/; | |
22250 | + stack[base + 43LLU] = stack[base + 31]/*n*/; | |
22102 | 22251 | // set stack-base & callee-address |
22103 | - base += 39LLU; | |
22252 | + base += 41LLU; | |
22104 | 22253 | label = 18446744073709551604LLU; // sub |
22105 | 22254 | break; |
22106 | 22255 | } |
22107 | - case 1789LLU: // copy-back deleter (sub to ProcCall) | |
22256 | + case 1803LLU: // copy-back deleter (sub to ProcCall) | |
22108 | 22257 | { |
22109 | 22258 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (sub to ProcCall)\n"); |
22110 | 22259 | // copy mutable arguments back from call to sub |
22111 | - label = 1523LLU; // continue to roll stack | |
22260 | + label = 1537LLU; // continue to roll stack | |
22112 | 22261 | break; |
22113 | 22262 | } |
22114 | - case 1790LLU: // return from sub to ProcCall | |
22263 | + case 1804LLU: // return from sub to ProcCall | |
22115 | 22264 | { |
22116 | 22265 | // copy mutable arguments back from call to sub |
22117 | 22266 | // copy back results provided by call to sub |
22118 | - stack[base + 30] = stack[base + 39LLU]; | |
22267 | + stack[base + 32] = stack[base + 41LLU]; | |
22119 | 22268 | // call sub from ProcCall |
22120 | - stack[base + 36LLU] = 1791LLU/*throw to this address*/; | |
22121 | - stack[base + 37LLU] = base; | |
22122 | - stack[base + 38LLU] = 1792LLU; | |
22269 | + stack[base + 38LLU] = 1805LLU/*throw to this address*/; | |
22270 | + stack[base + 39LLU] = base; | |
22271 | + stack[base + 40LLU] = 1806LLU; | |
22123 | 22272 | // arguments for call to sub |
22124 | - stack[base + 40LLU] = stack[base + 29]/*n*/; | |
22125 | - stack[base + 41LLU] = 1LLU; | |
22273 | + stack[base + 42LLU] = stack[base + 31]/*n*/; | |
22274 | + stack[base + 43LLU] = 1LLU; | |
22126 | 22275 | // set stack-base & callee-address |
22127 | - base += 39LLU; | |
22276 | + base += 41LLU; | |
22128 | 22277 | label = 18446744073709551604LLU; // sub |
22129 | 22278 | break; |
22130 | 22279 | } |
22131 | - case 1791LLU: // copy-back deleter (sub to ProcCall) | |
22280 | + case 1805LLU: // copy-back deleter (sub to ProcCall) | |
22132 | 22281 | { |
22133 | 22282 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (sub to ProcCall)\n"); |
22134 | 22283 | // copy mutable arguments back from call to sub |
22135 | - label = 1523LLU; // continue to roll stack | |
22284 | + label = 1537LLU; // continue to roll stack | |
22136 | 22285 | break; |
22137 | 22286 | } |
22138 | - case 1792LLU: // return from sub to ProcCall | |
22287 | + case 1806LLU: // return from sub to ProcCall | |
22139 | 22288 | { |
22140 | 22289 | // copy mutable arguments back from call to sub |
22141 | 22290 | // copy back results provided by call to sub |
22142 | - stack[base + 29] = stack[base + 39LLU]; | |
22291 | + stack[base + 31] = stack[base + 41LLU]; | |
22143 | 22292 | { // if pop |
22144 | 22293 | struct listnode *list = (struct listnode *)stack[base + 0]/*dsttypeids*/; |
22145 | 22294 | if(!list) |
22146 | 22295 | { |
22147 | - label = 1793LLU; // jump to alternative | |
22296 | + label = 1807LLU; // jump to alternative | |
22148 | 22297 | break; |
22149 | 22298 | } |
22150 | 22299 | |
22151 | 22300 | // consequent |
22152 | 22301 | struct listnode *next = list->next; |
22153 | - stack[base + 36]/*typeidx*/ = list->data; | |
22302 | + stack[base + 38]/*typeidx*/ = list->data; | |
22154 | 22303 | Free(1, sizeof(struct listnode), list); |
22155 | 22304 | stack[base + 0]/*dsttypeids*/ = (uint64_t)next; |
22156 | 22305 | } |
22157 | - if(/*typeidx*/0 != ((uint64_t *)(stack[base + 36]/*typeidx*/))[0]) | |
22306 | + if(/*typeidx*/0 != ((uint64_t *)(stack[base + 38]/*typeidx*/))[0]) | |
22158 | 22307 | { |
22159 | - label = 1796LLU; // jump to alternative | |
22308 | + label = 1810LLU; // jump to alternative | |
22160 | 22309 | break; |
22161 | 22310 | } |
22162 | 22311 | |
22163 | - /*dsttype*/stack[base + 37] = ((uint64_t **)(stack[base + 36]/*typeidx*/))[1][0]/*type*/; | |
22164 | - /*INDEX*/stack[base + 38] = ((uint64_t **)(stack[base + 36]/*typeidx*/))[1][1]/*idx*/; | |
22312 | + /*dsttype*/stack[base + 39] = ((uint64_t **)(stack[base + 38]/*typeidx*/))[1][0]/*type*/; | |
22313 | + /*INDEX*/stack[base + 40] = ((uint64_t **)(stack[base + 38]/*typeidx*/))[1][1]/*idx*/; | |
22165 | 22314 | |
22166 | 22315 | // case |
22167 | - if(/*result*/0 != ((uint64_t *)(stack[base + 34]/*result*/))[0]) | |
22316 | + if(/*result*/0 != ((uint64_t *)(stack[base + 36]/*result*/))[0]) | |
22168 | 22317 | { |
22169 | - label = 1798LLU; // jump to alternative | |
22318 | + label = 1812LLU; // jump to alternative | |
22170 | 22319 | break; |
22171 | 22320 | } |
22172 | 22321 | |
22173 | - /*srctype*/stack[base + 39] = ((uint64_t **)(stack[base + 34]/*result*/))[1][0]/*type*/; | |
22174 | - /*RESERVED*/stack[base + 40] = ((uint64_t **)(stack[base + 34]/*result*/))[1][1]/*RESERVED*/; | |
22322 | + /*srctype*/stack[base + 41] = ((uint64_t **)(stack[base + 36]/*result*/))[1][0]/*type*/; | |
22323 | + /*RESERVED*/stack[base + 42] = ((uint64_t **)(stack[base + 36]/*result*/))[1][1]/*RESERVED*/; | |
22175 | 22324 | |
22176 | 22325 | // case |
22177 | 22326 | uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t)); |
22178 | 22327 | if(!newstack) |
22179 | 22328 | { |
22180 | - label = 1523LLU; // throw: begin to unroll stack | |
22329 | + label = 1537LLU; // throw: begin to unroll stack | |
22181 | 22330 | break; |
22182 | 22331 | } |
22183 | 22332 |
@@ -22184,12 +22333,12 @@ | ||
22184 | 22333 | newstack[15LLU] = 9876543210LLU; // overflow-marker |
22185 | 22334 | // call equtype from ProcCall |
22186 | 22335 | newstack[0] = (uint64_t)stack; // backup stack location |
22187 | - newstack[1] = 1799LLU; | |
22336 | + newstack[1] = 1813LLU; | |
22188 | 22337 | newstack[2] = base; |
22189 | - newstack[3] = 1800LLU; | |
22338 | + newstack[3] = 1814LLU; | |
22190 | 22339 | // arguments for call to equtype |
22191 | - newstack[5LLU] = stack[base + 37]/*dsttype*/; | |
22192 | - newstack[6LLU] = stack[base + 39]/*srctype*/; | |
22340 | + newstack[5LLU] = stack[base + 39]/*dsttype*/; | |
22341 | + newstack[6LLU] = stack[base + 41]/*srctype*/; | |
22193 | 22342 | stack = newstack; |
22194 | 22343 | // set stack-base & callee-address |
22195 | 22344 | base = 4/*deloffset*/; |
@@ -22196,7 +22345,7 @@ | ||
22196 | 22345 | label = 335LLU; // equtype |
22197 | 22346 | break; |
22198 | 22347 | } |
22199 | - case 1799LLU: // copy-back deleter (equtype to ProcCall) | |
22348 | + case 1813LLU: // copy-back deleter (equtype to ProcCall) | |
22200 | 22349 | { |
22201 | 22350 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (equtype to ProcCall)\n"); |
22202 | 22351 | uint64_t *oldstack = (uint64_t *)stack[0]; |
@@ -22208,15 +22357,15 @@ | ||
22208 | 22357 | } |
22209 | 22358 | Free(15LLU + 1, sizeof(uint64_t), stack); |
22210 | 22359 | stack = oldstack; |
22211 | - label = 1523LLU; // continue to unroll stack | |
22360 | + label = 1537LLU; // continue to unroll stack | |
22212 | 22361 | break; |
22213 | 22362 | } |
22214 | - case 1800LLU: // return from equtype to ProcCall | |
22363 | + case 1814LLU: // return from equtype to ProcCall | |
22215 | 22364 | { |
22216 | 22365 | uint64_t *oldstack = (uint64_t *)stack[0]; |
22217 | 22366 | // copy mutable arguments back from call to equtype |
22218 | 22367 | // copy back results provided by call to equtype |
22219 | - oldstack[base + 17] = stack[4LLU]; | |
22368 | + oldstack[base + 18] = stack[4LLU]; | |
22220 | 22369 | if(stack[15LLU] != 9876543210LLU) |
22221 | 22370 | { |
22222 | 22371 | fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to equtype)!"); |
@@ -22224,82 +22373,82 @@ | ||
22224 | 22373 | } |
22225 | 22374 | Free(15LLU + 1, sizeof(uint64_t), stack); |
22226 | 22375 | stack = oldstack; |
22227 | - if(!stack[base + 17]/*isequal*/) | |
22376 | + if(!stack[base + 18]/*isequal*/) | |
22228 | 22377 | { |
22229 | - label = 1801LLU; // jump to alternative | |
22378 | + label = 1815LLU; // jump to alternative | |
22230 | 22379 | break; |
22231 | 22380 | } |
22232 | 22381 | |
22233 | 22382 | // consequent |
22234 | - label = 1802LLU; // consequent complete | |
22383 | + label = 1816LLU; // consequent complete | |
22235 | 22384 | break; |
22236 | 22385 | } |
22237 | - case 1801LLU: // alternative | |
22386 | + case 1815LLU: // alternative | |
22238 | 22387 | { |
22239 | 22388 | fprintf(stderr, "%s", "in function "); |
22240 | 22389 | // call reportid from ProcCall |
22241 | - stack[base + 41LLU] = 1803LLU/*throw to this address*/; | |
22242 | - stack[base + 42LLU] = base; | |
22243 | - stack[base + 43LLU] = 1804LLU; | |
22390 | + stack[base + 43LLU] = 1817LLU/*throw to this address*/; | |
22391 | + stack[base + 44LLU] = base; | |
22392 | + stack[base + 45LLU] = 1818LLU; | |
22244 | 22393 | // arguments for call to reportid |
22245 | - stack[base + 44LLU] = stack[base + 7]/*fnid*/; | |
22394 | + stack[base + 46LLU] = stack[base + 8]/*fnid*/; | |
22246 | 22395 | // set stack-base & callee-address |
22247 | - base += 44LLU; | |
22396 | + base += 46LLU; | |
22248 | 22397 | label = 18446744073709551586LLU; // reportid |
22249 | 22398 | break; |
22250 | 22399 | } |
22251 | - case 1803LLU: // copy-back deleter (reportid to ProcCall) | |
22400 | + case 1817LLU: // copy-back deleter (reportid to ProcCall) | |
22252 | 22401 | { |
22253 | 22402 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
22254 | 22403 | // copy mutable arguments back from call to reportid |
22255 | - label = 1523LLU; // continue to roll stack | |
22404 | + label = 1537LLU; // continue to roll stack | |
22256 | 22405 | break; |
22257 | 22406 | } |
22258 | - case 1804LLU: // return from reportid to ProcCall | |
22407 | + case 1818LLU: // return from reportid to ProcCall | |
22259 | 22408 | { |
22260 | 22409 | // copy mutable arguments back from call to reportid |
22261 | 22410 | fprintf(stderr, "%s", " call to "); |
22262 | 22411 | // call reportid from ProcCall |
22263 | - stack[base + 41LLU] = 1805LLU/*throw to this address*/; | |
22264 | - stack[base + 42LLU] = base; | |
22265 | - stack[base + 43LLU] = 1806LLU; | |
22412 | + stack[base + 43LLU] = 1819LLU/*throw to this address*/; | |
22413 | + stack[base + 44LLU] = base; | |
22414 | + stack[base + 45LLU] = 1820LLU; | |
22266 | 22415 | // arguments for call to reportid |
22267 | - stack[base + 44LLU] = stack[base + 23]/*ceid*/; | |
22416 | + stack[base + 46LLU] = stack[base + 24]/*ceid*/; | |
22268 | 22417 | // set stack-base & callee-address |
22269 | - base += 44LLU; | |
22418 | + base += 46LLU; | |
22270 | 22419 | label = 18446744073709551586LLU; // reportid |
22271 | 22420 | break; |
22272 | 22421 | } |
22273 | - case 1805LLU: // copy-back deleter (reportid to ProcCall) | |
22422 | + case 1819LLU: // copy-back deleter (reportid to ProcCall) | |
22274 | 22423 | { |
22275 | 22424 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
22276 | 22425 | // copy mutable arguments back from call to reportid |
22277 | - label = 1523LLU; // continue to roll stack | |
22426 | + label = 1537LLU; // continue to roll stack | |
22278 | 22427 | break; |
22279 | 22428 | } |
22280 | - case 1806LLU: // return from reportid to ProcCall | |
22429 | + case 1820LLU: // return from reportid to ProcCall | |
22281 | 22430 | { |
22282 | 22431 | // copy mutable arguments back from call to reportid |
22283 | 22432 | fprintf(stderr, "%s", " at position "); |
22284 | 22433 | // call reportnr from ProcCall |
22285 | - stack[base + 41LLU] = 1807LLU/*throw to this address*/; | |
22286 | - stack[base + 42LLU] = base; | |
22287 | - stack[base + 43LLU] = 1808LLU; | |
22434 | + stack[base + 43LLU] = 1821LLU/*throw to this address*/; | |
22435 | + stack[base + 44LLU] = base; | |
22436 | + stack[base + 45LLU] = 1822LLU; | |
22288 | 22437 | // arguments for call to reportnr |
22289 | - stack[base + 44LLU] = stack[base + 30]/*index*/; | |
22438 | + stack[base + 46LLU] = stack[base + 32]/*index*/; | |
22290 | 22439 | // set stack-base & callee-address |
22291 | - base += 44LLU; | |
22440 | + base += 46LLU; | |
22292 | 22441 | label = 18446744073709551589LLU; // reportnr |
22293 | 22442 | break; |
22294 | 22443 | } |
22295 | - case 1807LLU: // copy-back deleter (reportnr to ProcCall) | |
22444 | + case 1821LLU: // copy-back deleter (reportnr to ProcCall) | |
22296 | 22445 | { |
22297 | 22446 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportnr to ProcCall)\n"); |
22298 | 22447 | // copy mutable arguments back from call to reportnr |
22299 | - label = 1523LLU; // continue to roll stack | |
22448 | + label = 1537LLU; // continue to roll stack | |
22300 | 22449 | break; |
22301 | 22450 | } |
22302 | - case 1808LLU: // return from reportnr to ProcCall | |
22451 | + case 1822LLU: // return from reportnr to ProcCall | |
22303 | 22452 | { |
22304 | 22453 | // copy mutable arguments back from call to reportnr |
22305 | 22454 | fprintf(stderr, "%s", " cannot return source of type "); |
@@ -22306,7 +22455,7 @@ | ||
22306 | 22455 | uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t)); |
22307 | 22456 | if(!newstack) |
22308 | 22457 | { |
22309 | - label = 1523LLU; // throw: begin to unroll stack | |
22458 | + label = 1537LLU; // throw: begin to unroll stack | |
22310 | 22459 | break; |
22311 | 22460 | } |
22312 | 22461 |
@@ -22313,11 +22462,11 @@ | ||
22313 | 22462 | newstack[10LLU] = 9876543210LLU; // overflow-marker |
22314 | 22463 | // call reporttype from ProcCall |
22315 | 22464 | newstack[0] = (uint64_t)stack; // backup stack location |
22316 | - newstack[1] = 1809LLU; | |
22465 | + newstack[1] = 1823LLU; | |
22317 | 22466 | newstack[2] = base; |
22318 | - newstack[3] = 1810LLU; | |
22467 | + newstack[3] = 1824LLU; | |
22319 | 22468 | // arguments for call to reporttype |
22320 | - newstack[4LLU] = stack[base + 39]/*srctype*/; | |
22469 | + newstack[4LLU] = stack[base + 41]/*srctype*/; | |
22321 | 22470 | stack = newstack; |
22322 | 22471 | // set stack-base & callee-address |
22323 | 22472 | base = 4/*deloffset*/; |
@@ -22324,7 +22473,7 @@ | ||
22324 | 22473 | label = 313LLU; // reporttype |
22325 | 22474 | break; |
22326 | 22475 | } |
22327 | - case 1809LLU: // copy-back deleter (reporttype to ProcCall) | |
22476 | + case 1823LLU: // copy-back deleter (reporttype to ProcCall) | |
22328 | 22477 | { |
22329 | 22478 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n"); |
22330 | 22479 | uint64_t *oldstack = (uint64_t *)stack[0]; |
@@ -22336,10 +22485,10 @@ | ||
22336 | 22485 | } |
22337 | 22486 | Free(10LLU + 1, sizeof(uint64_t), stack); |
22338 | 22487 | stack = oldstack; |
22339 | - label = 1523LLU; // continue to unroll stack | |
22488 | + label = 1537LLU; // continue to unroll stack | |
22340 | 22489 | break; |
22341 | 22490 | } |
22342 | - case 1810LLU: // return from reporttype to ProcCall | |
22491 | + case 1824LLU: // return from reporttype to ProcCall | |
22343 | 22492 | { |
22344 | 22493 | uint64_t *oldstack = (uint64_t *)stack[0]; |
22345 | 22494 | // copy mutable arguments back from call to reporttype |
@@ -22354,7 +22503,7 @@ | ||
22354 | 22503 | uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t)); |
22355 | 22504 | if(!newstack) |
22356 | 22505 | { |
22357 | - label = 1523LLU; // throw: begin to unroll stack | |
22506 | + label = 1537LLU; // throw: begin to unroll stack | |
22358 | 22507 | break; |
22359 | 22508 | } |
22360 | 22509 |
@@ -22361,11 +22510,11 @@ | ||
22361 | 22510 | newstack[10LLU] = 9876543210LLU; // overflow-marker |
22362 | 22511 | // call reporttype from ProcCall |
22363 | 22512 | newstack[0] = (uint64_t)stack; // backup stack location |
22364 | - newstack[1] = 1811LLU; | |
22513 | + newstack[1] = 1825LLU; | |
22365 | 22514 | newstack[2] = base; |
22366 | - newstack[3] = 1812LLU; | |
22515 | + newstack[3] = 1826LLU; | |
22367 | 22516 | // arguments for call to reporttype |
22368 | - newstack[4LLU] = stack[base + 37]/*dsttype*/; | |
22517 | + newstack[4LLU] = stack[base + 39]/*dsttype*/; | |
22369 | 22518 | stack = newstack; |
22370 | 22519 | // set stack-base & callee-address |
22371 | 22520 | base = 4/*deloffset*/; |
@@ -22372,7 +22521,7 @@ | ||
22372 | 22521 | label = 313LLU; // reporttype |
22373 | 22522 | break; |
22374 | 22523 | } |
22375 | - case 1811LLU: // copy-back deleter (reporttype to ProcCall) | |
22524 | + case 1825LLU: // copy-back deleter (reporttype to ProcCall) | |
22376 | 22525 | { |
22377 | 22526 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n"); |
22378 | 22527 | uint64_t *oldstack = (uint64_t *)stack[0]; |
@@ -22384,10 +22533,10 @@ | ||
22384 | 22533 | } |
22385 | 22534 | Free(10LLU + 1, sizeof(uint64_t), stack); |
22386 | 22535 | stack = oldstack; |
22387 | - label = 1523LLU; // continue to unroll stack | |
22536 | + label = 1537LLU; // continue to unroll stack | |
22388 | 22537 | break; |
22389 | 22538 | } |
22390 | - case 1812LLU: // return from reporttype to ProcCall | |
22539 | + case 1826LLU: // return from reporttype to ProcCall | |
22391 | 22540 | { |
22392 | 22541 | uint64_t *oldstack = (uint64_t *)stack[0]; |
22393 | 22542 | // copy mutable arguments back from call to reporttype |
@@ -22400,136 +22549,136 @@ | ||
22400 | 22549 | stack = oldstack; |
22401 | 22550 | fprintf(stderr, "%s", "\n"); |
22402 | 22551 | exit(-1); |
22403 | - label = 1802LLU; // alternative complete | |
22552 | + label = 1816LLU; // alternative complete | |
22404 | 22553 | break; |
22405 | 22554 | } |
22406 | - case 1802LLU: // completed if-then-else | |
22555 | + case 1816LLU: // completed if-then-else | |
22407 | 22556 | { |
22408 | - stack[base + 28]/*sum*/ = 0; | |
22557 | + stack[base + 30]/*sum*/ = 0; | |
22409 | 22558 | // call add from ProcCall |
22410 | - stack[base + 41LLU] = 1813LLU/*throw to this address*/; | |
22411 | - stack[base + 42LLU] = base; | |
22412 | - stack[base + 43LLU] = 1814LLU; | |
22559 | + stack[base + 43LLU] = 1827LLU/*throw to this address*/; | |
22560 | + stack[base + 44LLU] = base; | |
22561 | + stack[base + 45LLU] = 1828LLU; | |
22413 | 22562 | // arguments for call to add |
22414 | - stack[base + 45LLU] = 4LLU; | |
22415 | - stack[base + 46LLU] = stack[base + 28]/*sum*/; | |
22563 | + stack[base + 47LLU] = 4LLU; | |
22564 | + stack[base + 48LLU] = stack[base + 30]/*sum*/; | |
22416 | 22565 | // set stack-base & callee-address |
22417 | - base += 44LLU; | |
22566 | + base += 46LLU; | |
22418 | 22567 | label = 18446744073709551605LLU; // add |
22419 | 22568 | break; |
22420 | 22569 | } |
22421 | - case 1813LLU: // copy-back deleter (add to ProcCall) | |
22570 | + case 1827LLU: // copy-back deleter (add to ProcCall) | |
22422 | 22571 | { |
22423 | 22572 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
22424 | 22573 | // copy mutable arguments back from call to add |
22425 | - label = 1523LLU; // continue to roll stack | |
22574 | + label = 1537LLU; // continue to roll stack | |
22426 | 22575 | break; |
22427 | 22576 | } |
22428 | - case 1814LLU: // return from add to ProcCall | |
22577 | + case 1828LLU: // return from add to ProcCall | |
22429 | 22578 | { |
22430 | 22579 | // copy mutable arguments back from call to add |
22431 | 22580 | // copy back results provided by call to add |
22432 | - stack[base + 28] = stack[base + 44LLU]; | |
22581 | + stack[base + 30] = stack[base + 46LLU]; | |
22433 | 22582 | // call add from ProcCall |
22434 | - stack[base + 41LLU] = 1815LLU/*throw to this address*/; | |
22435 | - stack[base + 42LLU] = base; | |
22436 | - stack[base + 43LLU] = 1816LLU; | |
22583 | + stack[base + 43LLU] = 1829LLU/*throw to this address*/; | |
22584 | + stack[base + 44LLU] = base; | |
22585 | + stack[base + 45LLU] = 1830LLU; | |
22437 | 22586 | // arguments for call to add |
22438 | - stack[base + 45LLU] = stack[base + 30]/*index*/; | |
22439 | - stack[base + 46LLU] = stack[base + 28]/*sum*/; | |
22587 | + stack[base + 47LLU] = stack[base + 32]/*index*/; | |
22588 | + stack[base + 48LLU] = stack[base + 30]/*sum*/; | |
22440 | 22589 | // set stack-base & callee-address |
22441 | - base += 44LLU; | |
22590 | + base += 46LLU; | |
22442 | 22591 | label = 18446744073709551605LLU; // add |
22443 | 22592 | break; |
22444 | 22593 | } |
22445 | - case 1815LLU: // copy-back deleter (add to ProcCall) | |
22594 | + case 1829LLU: // copy-back deleter (add to ProcCall) | |
22446 | 22595 | { |
22447 | 22596 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
22448 | 22597 | // copy mutable arguments back from call to add |
22449 | - label = 1523LLU; // continue to roll stack | |
22598 | + label = 1537LLU; // continue to roll stack | |
22450 | 22599 | break; |
22451 | 22600 | } |
22452 | - case 1816LLU: // return from add to ProcCall | |
22601 | + case 1830LLU: // return from add to ProcCall | |
22453 | 22602 | { |
22454 | 22603 | // copy mutable arguments back from call to add |
22455 | 22604 | // copy back results provided by call to add |
22456 | - stack[base + 28] = stack[base + 44LLU]; | |
22605 | + stack[base + 30] = stack[base + 46LLU]; | |
22457 | 22606 | printf("%s", "\n old"); |
22458 | 22607 | // call emitvaridx from ProcCall |
22459 | - stack[base + 41LLU] = 1817LLU/*throw to this address*/; | |
22460 | - stack[base + 42LLU] = base; | |
22461 | - stack[base + 43LLU] = 1818LLU; | |
22608 | + stack[base + 43LLU] = 1831LLU/*throw to this address*/; | |
22609 | + stack[base + 44LLU] = base; | |
22610 | + stack[base + 45LLU] = 1832LLU; | |
22462 | 22611 | // arguments for call to emitvaridx |
22463 | - stack[base + 44LLU] = stack[base + 38]/*INDEX*/; | |
22612 | + stack[base + 46LLU] = stack[base + 40]/*INDEX*/; | |
22464 | 22613 | // set stack-base & callee-address |
22465 | - base += 44LLU; | |
22614 | + base += 46LLU; | |
22466 | 22615 | label = 655LLU; // emitvaridx |
22467 | 22616 | break; |
22468 | 22617 | } |
22469 | - case 1817LLU: // copy-back deleter (emitvaridx to ProcCall) | |
22618 | + case 1831LLU: // copy-back deleter (emitvaridx to ProcCall) | |
22470 | 22619 | { |
22471 | 22620 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (emitvaridx to ProcCall)\n"); |
22472 | 22621 | // copy mutable arguments back from call to emitvaridx |
22473 | - label = 1523LLU; // continue to roll stack | |
22622 | + label = 1537LLU; // continue to roll stack | |
22474 | 22623 | break; |
22475 | 22624 | } |
22476 | - case 1818LLU: // return from emitvaridx to ProcCall | |
22625 | + case 1832LLU: // return from emitvaridx to ProcCall | |
22477 | 22626 | { |
22478 | 22627 | // copy mutable arguments back from call to emitvaridx |
22479 | 22628 | printf("%s", " = stack["); |
22480 | 22629 | // call printnr from ProcCall |
22481 | - stack[base + 41LLU] = 1819LLU/*throw to this address*/; | |
22482 | - stack[base + 42LLU] = base; | |
22483 | - stack[base + 43LLU] = 1820LLU; | |
22630 | + stack[base + 43LLU] = 1833LLU/*throw to this address*/; | |
22631 | + stack[base + 44LLU] = base; | |
22632 | + stack[base + 45LLU] = 1834LLU; | |
22484 | 22633 | // arguments for call to printnr |
22485 | - stack[base + 44LLU] = stack[base + 28]/*sum*/; | |
22634 | + stack[base + 46LLU] = stack[base + 30]/*sum*/; | |
22486 | 22635 | // set stack-base & callee-address |
22487 | - base += 44LLU; | |
22636 | + base += 46LLU; | |
22488 | 22637 | label = 18446744073709551590LLU; // printnr |
22489 | 22638 | break; |
22490 | 22639 | } |
22491 | - case 1819LLU: // copy-back deleter (printnr to ProcCall) | |
22640 | + case 1833LLU: // copy-back deleter (printnr to ProcCall) | |
22492 | 22641 | { |
22493 | 22642 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n"); |
22494 | 22643 | // copy mutable arguments back from call to printnr |
22495 | - label = 1523LLU; // continue to roll stack | |
22644 | + label = 1537LLU; // continue to roll stack | |
22496 | 22645 | break; |
22497 | 22646 | } |
22498 | - case 1820LLU: // return from printnr to ProcCall | |
22647 | + case 1834LLU: // return from printnr to ProcCall | |
22499 | 22648 | { |
22500 | 22649 | // copy mutable arguments back from call to printnr |
22501 | 22650 | printf("%s", "LLU];"); |
22502 | - ((uint64_t **)(stack[base + 34]))[1][1] = stack[base + 40]; | |
22503 | - ((uint64_t **)(stack[base + 34]))[1][0] = stack[base + 39]; | |
22504 | - label = 1797LLU; // case complete | |
22651 | + ((uint64_t **)(stack[base + 36]))[1][1] = stack[base + 42]; | |
22652 | + ((uint64_t **)(stack[base + 36]))[1][0] = stack[base + 41]; | |
22653 | + label = 1811LLU; // case complete | |
22505 | 22654 | break; |
22506 | 22655 | } |
22507 | - case 1798LLU: // try next case | |
22656 | + case 1812LLU: // try next case | |
22508 | 22657 | { |
22509 | 22658 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
22510 | 22659 | exit(-1); |
22511 | 22660 | } |
22512 | - case 1797LLU: // completed switch | |
22661 | + case 1811LLU: // completed switch | |
22513 | 22662 | { |
22514 | - ((uint64_t **)(stack[base + 36]))[1][1] = stack[base + 38]; | |
22515 | - ((uint64_t **)(stack[base + 36]))[1][0] = stack[base + 37]; | |
22516 | - label = 1795LLU; // case complete | |
22663 | + ((uint64_t **)(stack[base + 38]))[1][1] = stack[base + 40]; | |
22664 | + ((uint64_t **)(stack[base + 38]))[1][0] = stack[base + 39]; | |
22665 | + label = 1809LLU; // case complete | |
22517 | 22666 | break; |
22518 | 22667 | } |
22519 | - case 1796LLU: // try next case | |
22668 | + case 1810LLU: // try next case | |
22520 | 22669 | { |
22521 | 22670 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
22522 | 22671 | exit(-1); |
22523 | 22672 | } |
22524 | - case 1795LLU: // completed switch | |
22673 | + case 1809LLU: // completed switch | |
22525 | 22674 | { |
22526 | 22675 | |
22527 | - uint64_t *newstack = (uint64_t *)(stack[base + 36] - sizeof(uint64_t) * 4); | |
22676 | + uint64_t *newstack = (uint64_t *)(stack[base + 38] - sizeof(uint64_t) * 4); | |
22528 | 22677 | // call ~typeidx from ProcCall |
22529 | 22678 | newstack[0] = (uint64_t)stack; // backup stack location |
22530 | 22679 | newstack[1] = 1234567890; |
22531 | 22680 | newstack[2] = base; |
22532 | - newstack[3] = 1821LLU; | |
22681 | + newstack[3] = 1835LLU; | |
22533 | 22682 | stack = newstack; |
22534 | 22683 | // set stack-base & callee-address |
22535 | 22684 | base = 4/*deloffset*/; |
@@ -22536,127 +22685,127 @@ | ||
22536 | 22685 | label = 368LLU; // ~typeidx |
22537 | 22686 | break; |
22538 | 22687 | } |
22539 | - case 1821LLU: // return from ~typeidx to ProcCall | |
22688 | + case 1835LLU: // return from ~typeidx to ProcCall | |
22540 | 22689 | { |
22541 | 22690 | stack = (uint64_t *)stack[0]; |
22542 | 22691 | // releasing toplevel container |
22543 | - Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 36] - sizeof(uint64_t) * 4)); | |
22692 | + Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 38] - sizeof(uint64_t) * 4)); | |
22544 | 22693 | |
22545 | - label = 1794LLU; // consequent complete | |
22694 | + label = 1808LLU; // consequent complete | |
22546 | 22695 | break; |
22547 | 22696 | } |
22548 | - case 1793LLU: // alternative | |
22697 | + case 1807LLU: // alternative | |
22549 | 22698 | { |
22550 | 22699 | fprintf(stderr, "%s", "in function "); |
22551 | 22700 | // call reportid from ProcCall |
22552 | - stack[base + 37LLU] = 1822LLU/*throw to this address*/; | |
22553 | - stack[base + 38LLU] = base; | |
22554 | - stack[base + 39LLU] = 1823LLU; | |
22701 | + stack[base + 39LLU] = 1836LLU/*throw to this address*/; | |
22702 | + stack[base + 40LLU] = base; | |
22703 | + stack[base + 41LLU] = 1837LLU; | |
22555 | 22704 | // arguments for call to reportid |
22556 | - stack[base + 40LLU] = stack[base + 7]/*fnid*/; | |
22705 | + stack[base + 42LLU] = stack[base + 8]/*fnid*/; | |
22557 | 22706 | // set stack-base & callee-address |
22558 | - base += 40LLU; | |
22707 | + base += 42LLU; | |
22559 | 22708 | label = 18446744073709551586LLU; // reportid |
22560 | 22709 | break; |
22561 | 22710 | } |
22562 | - case 1822LLU: // copy-back deleter (reportid to ProcCall) | |
22711 | + case 1836LLU: // copy-back deleter (reportid to ProcCall) | |
22563 | 22712 | { |
22564 | 22713 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
22565 | 22714 | // copy mutable arguments back from call to reportid |
22566 | - label = 1523LLU; // continue to roll stack | |
22715 | + label = 1537LLU; // continue to roll stack | |
22567 | 22716 | break; |
22568 | 22717 | } |
22569 | - case 1823LLU: // return from reportid to ProcCall | |
22718 | + case 1837LLU: // return from reportid to ProcCall | |
22570 | 22719 | { |
22571 | 22720 | // copy mutable arguments back from call to reportid |
22572 | 22721 | fprintf(stderr, "%s", " call to "); |
22573 | 22722 | // call reportid from ProcCall |
22574 | - stack[base + 37LLU] = 1824LLU/*throw to this address*/; | |
22575 | - stack[base + 38LLU] = base; | |
22576 | - stack[base + 39LLU] = 1825LLU; | |
22723 | + stack[base + 39LLU] = 1838LLU/*throw to this address*/; | |
22724 | + stack[base + 40LLU] = base; | |
22725 | + stack[base + 41LLU] = 1839LLU; | |
22577 | 22726 | // arguments for call to reportid |
22578 | - stack[base + 40LLU] = stack[base + 23]/*ceid*/; | |
22727 | + stack[base + 42LLU] = stack[base + 24]/*ceid*/; | |
22579 | 22728 | // set stack-base & callee-address |
22580 | - base += 40LLU; | |
22729 | + base += 42LLU; | |
22581 | 22730 | label = 18446744073709551586LLU; // reportid |
22582 | 22731 | break; |
22583 | 22732 | } |
22584 | - case 1824LLU: // copy-back deleter (reportid to ProcCall) | |
22733 | + case 1838LLU: // copy-back deleter (reportid to ProcCall) | |
22585 | 22734 | { |
22586 | 22735 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
22587 | 22736 | // copy mutable arguments back from call to reportid |
22588 | - label = 1523LLU; // continue to roll stack | |
22737 | + label = 1537LLU; // continue to roll stack | |
22589 | 22738 | break; |
22590 | 22739 | } |
22591 | - case 1825LLU: // return from reportid to ProcCall | |
22740 | + case 1839LLU: // return from reportid to ProcCall | |
22592 | 22741 | { |
22593 | 22742 | // copy mutable arguments back from call to reportid |
22594 | 22743 | fprintf(stderr, "%s", " at position "); |
22595 | 22744 | // call reportnr from ProcCall |
22596 | - stack[base + 37LLU] = 1826LLU/*throw to this address*/; | |
22597 | - stack[base + 38LLU] = base; | |
22598 | - stack[base + 39LLU] = 1827LLU; | |
22745 | + stack[base + 39LLU] = 1840LLU/*throw to this address*/; | |
22746 | + stack[base + 40LLU] = base; | |
22747 | + stack[base + 41LLU] = 1841LLU; | |
22599 | 22748 | // arguments for call to reportnr |
22600 | - stack[base + 40LLU] = stack[base + 30]/*index*/; | |
22749 | + stack[base + 42LLU] = stack[base + 32]/*index*/; | |
22601 | 22750 | // set stack-base & callee-address |
22602 | - base += 40LLU; | |
22751 | + base += 42LLU; | |
22603 | 22752 | label = 18446744073709551589LLU; // reportnr |
22604 | 22753 | break; |
22605 | 22754 | } |
22606 | - case 1826LLU: // copy-back deleter (reportnr to ProcCall) | |
22755 | + case 1840LLU: // copy-back deleter (reportnr to ProcCall) | |
22607 | 22756 | { |
22608 | 22757 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportnr to ProcCall)\n"); |
22609 | 22758 | // copy mutable arguments back from call to reportnr |
22610 | - label = 1523LLU; // continue to roll stack | |
22759 | + label = 1537LLU; // continue to roll stack | |
22611 | 22760 | break; |
22612 | 22761 | } |
22613 | - case 1827LLU: // return from reportnr to ProcCall | |
22762 | + case 1841LLU: // return from reportnr to ProcCall | |
22614 | 22763 | { |
22615 | 22764 | // copy mutable arguments back from call to reportnr |
22616 | 22765 | fprintf(stderr, "%s", " not enough destination-variables for results"); |
22617 | 22766 | fprintf(stderr, "%s", "\n"); |
22618 | 22767 | exit(-1); |
22619 | - label = 1794LLU; // alternative complete | |
22768 | + label = 1808LLU; // alternative complete | |
22620 | 22769 | break; |
22621 | 22770 | } |
22622 | - case 1794LLU: // completed if-then-else | |
22771 | + case 1808LLU: // completed if-then-else | |
22623 | 22772 | { |
22624 | - ((struct listnode *)(stack[base + 35]/*previous*/))->data = stack[base + 34]; | |
22625 | - label = 1787LLU; // repeat | |
22773 | + ((struct listnode *)(stack[base + 37]/*previous*/))->data = stack[base + 36]; | |
22774 | + label = 1801LLU; // repeat | |
22626 | 22775 | break; |
22627 | 22776 | } |
22628 | - case 1788LLU: // loop finished | |
22777 | + case 1802LLU: // loop finished | |
22629 | 22778 | { |
22630 | - label = 1784LLU; // consequent complete | |
22779 | + label = 1798LLU; // consequent complete | |
22631 | 22780 | break; |
22632 | 22781 | } |
22633 | - case 1783LLU: // alternative | |
22782 | + case 1797LLU: // alternative | |
22634 | 22783 | { |
22635 | - label = 1784LLU; // alternative complete | |
22784 | + label = 1798LLU; // alternative complete | |
22636 | 22785 | break; |
22637 | 22786 | } |
22638 | - case 1784LLU: // completed if-then-else | |
22787 | + case 1798LLU: // completed if-then-else | |
22639 | 22788 | { |
22640 | 22789 | printf("%s", "\n if(stack["); |
22641 | 22790 | // call printnr from ProcCall |
22642 | - stack[base + 33LLU] = 1828LLU/*throw to this address*/; | |
22643 | - stack[base + 34LLU] = base; | |
22644 | - stack[base + 35LLU] = 1829LLU; | |
22791 | + stack[base + 35LLU] = 1842LLU/*throw to this address*/; | |
22792 | + stack[base + 36LLU] = base; | |
22793 | + stack[base + 37LLU] = 1843LLU; | |
22645 | 22794 | // arguments for call to printnr |
22646 | - stack[base + 36LLU] = stack[base + 32]/*recsztotal*/; | |
22795 | + stack[base + 38LLU] = stack[base + 34]/*recsztotal*/; | |
22647 | 22796 | // set stack-base & callee-address |
22648 | - base += 36LLU; | |
22797 | + base += 38LLU; | |
22649 | 22798 | label = 18446744073709551590LLU; // printnr |
22650 | 22799 | break; |
22651 | 22800 | } |
22652 | - case 1828LLU: // copy-back deleter (printnr to ProcCall) | |
22801 | + case 1842LLU: // copy-back deleter (printnr to ProcCall) | |
22653 | 22802 | { |
22654 | 22803 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n"); |
22655 | 22804 | // copy mutable arguments back from call to printnr |
22656 | - label = 1523LLU; // continue to roll stack | |
22805 | + label = 1537LLU; // continue to roll stack | |
22657 | 22806 | break; |
22658 | 22807 | } |
22659 | - case 1829LLU: // return from printnr to ProcCall | |
22808 | + case 1843LLU: // return from printnr to ProcCall | |
22660 | 22809 | { |
22661 | 22810 | // copy mutable arguments back from call to printnr |
22662 | 22811 | printf("%s", "LLU] != 9876543210LLU)"); |
@@ -22663,24 +22812,24 @@ | ||
22663 | 22812 | printf("%s", "\n {"); |
22664 | 22813 | printf("%s", "\n fprintf(stderr, \"INTERNAL ERROR - OVERFLOW (in recursive call to "); |
22665 | 22814 | // call printid from ProcCall |
22666 | - stack[base + 33LLU] = 1830LLU/*throw to this address*/; | |
22667 | - stack[base + 34LLU] = base; | |
22668 | - stack[base + 35LLU] = 1831LLU; | |
22815 | + stack[base + 35LLU] = 1844LLU/*throw to this address*/; | |
22816 | + stack[base + 36LLU] = base; | |
22817 | + stack[base + 37LLU] = 1845LLU; | |
22669 | 22818 | // arguments for call to printid |
22670 | - stack[base + 36LLU] = stack[base + 23]/*ceid*/; | |
22819 | + stack[base + 38LLU] = stack[base + 24]/*ceid*/; | |
22671 | 22820 | // set stack-base & callee-address |
22672 | - base += 36LLU; | |
22821 | + base += 38LLU; | |
22673 | 22822 | label = 18446744073709551587LLU; // printid |
22674 | 22823 | break; |
22675 | 22824 | } |
22676 | - case 1830LLU: // copy-back deleter (printid to ProcCall) | |
22825 | + case 1844LLU: // copy-back deleter (printid to ProcCall) | |
22677 | 22826 | { |
22678 | 22827 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n"); |
22679 | 22828 | // copy mutable arguments back from call to printid |
22680 | - label = 1523LLU; // continue to roll stack | |
22829 | + label = 1537LLU; // continue to roll stack | |
22681 | 22830 | break; |
22682 | 22831 | } |
22683 | - case 1831LLU: // return from printid to ProcCall | |
22832 | + case 1845LLU: // return from printid to ProcCall | |
22684 | 22833 | { |
22685 | 22834 | // copy mutable arguments back from call to printid |
22686 | 22835 | printf("%s", ")!\");"); |
@@ -22688,925 +22837,925 @@ | ||
22688 | 22837 | printf("%s", "\n }"); |
22689 | 22838 | printf("%s", "\n Free("); |
22690 | 22839 | // call printnr from ProcCall |
22691 | - stack[base + 33LLU] = 1832LLU/*throw to this address*/; | |
22692 | - stack[base + 34LLU] = base; | |
22693 | - stack[base + 35LLU] = 1833LLU; | |
22840 | + stack[base + 35LLU] = 1846LLU/*throw to this address*/; | |
22841 | + stack[base + 36LLU] = base; | |
22842 | + stack[base + 37LLU] = 1847LLU; | |
22694 | 22843 | // arguments for call to printnr |
22695 | - stack[base + 36LLU] = stack[base + 32]/*recsztotal*/; | |
22844 | + stack[base + 38LLU] = stack[base + 34]/*recsztotal*/; | |
22696 | 22845 | // set stack-base & callee-address |
22697 | - base += 36LLU; | |
22846 | + base += 38LLU; | |
22698 | 22847 | label = 18446744073709551590LLU; // printnr |
22699 | 22848 | break; |
22700 | 22849 | } |
22701 | - case 1832LLU: // copy-back deleter (printnr to ProcCall) | |
22850 | + case 1846LLU: // copy-back deleter (printnr to ProcCall) | |
22702 | 22851 | { |
22703 | 22852 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n"); |
22704 | 22853 | // copy mutable arguments back from call to printnr |
22705 | - label = 1523LLU; // continue to roll stack | |
22854 | + label = 1537LLU; // continue to roll stack | |
22706 | 22855 | break; |
22707 | 22856 | } |
22708 | - case 1833LLU: // return from printnr to ProcCall | |
22857 | + case 1847LLU: // return from printnr to ProcCall | |
22709 | 22858 | { |
22710 | 22859 | // copy mutable arguments back from call to printnr |
22711 | 22860 | printf("%s", "LLU + 1, sizeof(uint64_t), stack);"); |
22712 | 22861 | printf("%s", "\n stack = oldstack;"); |
22713 | - label = 1518LLU; // consequent complete | |
22862 | + label = 1532LLU; // consequent complete | |
22714 | 22863 | break; |
22715 | 22864 | } |
22716 | - case 1517LLU: // alternative | |
22865 | + case 1531LLU: // alternative | |
22717 | 22866 | { |
22718 | 22867 | // call add from ProcCall |
22719 | - stack[base + 31LLU] = 1834LLU/*throw to this address*/; | |
22720 | - stack[base + 32LLU] = base; | |
22721 | - stack[base + 33LLU] = 1835LLU; | |
22868 | + stack[base + 33LLU] = 1848LLU/*throw to this address*/; | |
22869 | + stack[base + 34LLU] = base; | |
22870 | + stack[base + 35LLU] = 1849LLU; | |
22722 | 22871 | // arguments for call to add |
22723 | - stack[base + 35LLU] = 1LLU; | |
22724 | - stack[base + 36LLU] = stack[base + 16]/*label*/; | |
22872 | + stack[base + 37LLU] = 1LLU; | |
22873 | + stack[base + 38LLU] = stack[base + 17]/*label*/; | |
22725 | 22874 | // set stack-base & callee-address |
22726 | - base += 34LLU; | |
22875 | + base += 36LLU; | |
22727 | 22876 | label = 18446744073709551605LLU; // add |
22728 | 22877 | break; |
22729 | 22878 | } |
22730 | - case 1834LLU: // copy-back deleter (add to ProcCall) | |
22879 | + case 1848LLU: // copy-back deleter (add to ProcCall) | |
22731 | 22880 | { |
22732 | 22881 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
22733 | 22882 | // copy mutable arguments back from call to add |
22734 | - label = 1515LLU; // continue to roll stack | |
22883 | + label = 1529LLU; // continue to roll stack | |
22735 | 22884 | break; |
22736 | 22885 | } |
22737 | - case 1835LLU: // return from add to ProcCall | |
22886 | + case 1849LLU: // return from add to ProcCall | |
22738 | 22887 | { |
22739 | 22888 | // copy mutable arguments back from call to add |
22740 | 22889 | // copy back results provided by call to add |
22741 | - stack[base + 16] = stack[base + 34LLU]; | |
22742 | - label = 1837LLU; // skip deleter | |
22890 | + stack[base + 17] = stack[base + 36LLU]; | |
22891 | + label = 1851LLU; // skip deleter | |
22743 | 22892 | break; |
22744 | 22893 | } |
22745 | - case 1836LLU: // deleter | |
22894 | + case 1850LLU: // deleter | |
22746 | 22895 | { |
22747 | 22896 | // throw from ProcCall |
22748 | - if(!stack[base + 31]) | |
22897 | + if(!stack[base + 33]) | |
22749 | 22898 | { |
22750 | 22899 | fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 \n"); |
22751 | - label = 1515LLU; // skip, variable already deleted/unscoped | |
22900 | + label = 1529LLU; // skip, variable already deleted/unscoped | |
22752 | 22901 | break; |
22753 | 22902 | } |
22754 | 22903 | fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 \n"); |
22755 | - label = 1515LLU; // continue unrolling stack, delete next variable | |
22904 | + label = 1529LLU; // continue unrolling stack, delete next variable | |
22756 | 22905 | break; |
22757 | 22906 | } |
22758 | - case 1837LLU: // skipped deleter | |
22907 | + case 1851LLU: // skipped deleter | |
22759 | 22908 | { |
22760 | - stack[base + 31] = stack[base + 16]/*label*/; | |
22909 | + stack[base + 33] = stack[base + 17]/*label*/; | |
22761 | 22910 | printf("%s", "\n // call "); |
22762 | 22911 | // call printid from ProcCall |
22763 | - stack[base + 32LLU] = 1838LLU/*throw to this address*/; | |
22764 | - stack[base + 33LLU] = base; | |
22765 | - stack[base + 34LLU] = 1839LLU; | |
22912 | + stack[base + 34LLU] = 1852LLU/*throw to this address*/; | |
22913 | + stack[base + 35LLU] = base; | |
22914 | + stack[base + 36LLU] = 1853LLU; | |
22766 | 22915 | // arguments for call to printid |
22767 | - stack[base + 35LLU] = stack[base + 23]/*ceid*/; | |
22916 | + stack[base + 37LLU] = stack[base + 24]/*ceid*/; | |
22768 | 22917 | // set stack-base & callee-address |
22769 | - base += 35LLU; | |
22918 | + base += 37LLU; | |
22770 | 22919 | label = 18446744073709551587LLU; // printid |
22771 | 22920 | break; |
22772 | 22921 | } |
22773 | - case 1838LLU: // copy-back deleter (printid to ProcCall) | |
22922 | + case 1852LLU: // copy-back deleter (printid to ProcCall) | |
22774 | 22923 | { |
22775 | 22924 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n"); |
22776 | 22925 | // copy mutable arguments back from call to printid |
22777 | - label = 1836LLU; // continue to roll stack | |
22926 | + label = 1850LLU; // continue to roll stack | |
22778 | 22927 | break; |
22779 | 22928 | } |
22780 | - case 1839LLU: // return from printid to ProcCall | |
22929 | + case 1853LLU: // return from printid to ProcCall | |
22781 | 22930 | { |
22782 | 22931 | // copy mutable arguments back from call to printid |
22783 | 22932 | printf("%s", " from "); |
22784 | 22933 | // call printid from ProcCall |
22785 | - stack[base + 32LLU] = 1840LLU/*throw to this address*/; | |
22786 | - stack[base + 33LLU] = base; | |
22787 | - stack[base + 34LLU] = 1841LLU; | |
22934 | + stack[base + 34LLU] = 1854LLU/*throw to this address*/; | |
22935 | + stack[base + 35LLU] = base; | |
22936 | + stack[base + 36LLU] = 1855LLU; | |
22788 | 22937 | // arguments for call to printid |
22789 | - stack[base + 35LLU] = stack[base + 7]/*fnid*/; | |
22938 | + stack[base + 37LLU] = stack[base + 8]/*fnid*/; | |
22790 | 22939 | // set stack-base & callee-address |
22791 | - base += 35LLU; | |
22940 | + base += 37LLU; | |
22792 | 22941 | label = 18446744073709551587LLU; // printid |
22793 | 22942 | break; |
22794 | 22943 | } |
22795 | - case 1840LLU: // copy-back deleter (printid to ProcCall) | |
22944 | + case 1854LLU: // copy-back deleter (printid to ProcCall) | |
22796 | 22945 | { |
22797 | 22946 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n"); |
22798 | 22947 | // copy mutable arguments back from call to printid |
22799 | - label = 1836LLU; // continue to roll stack | |
22948 | + label = 1850LLU; // continue to roll stack | |
22800 | 22949 | break; |
22801 | 22950 | } |
22802 | - case 1841LLU: // return from printid to ProcCall | |
22951 | + case 1855LLU: // return from printid to ProcCall | |
22803 | 22952 | { |
22804 | 22953 | // copy mutable arguments back from call to printid |
22805 | - stack[base + 28]/*sum*/ = 0; | |
22954 | + stack[base + 30]/*sum*/ = 0; | |
22806 | 22955 | // call add from ProcCall |
22807 | - stack[base + 32LLU] = 1842LLU/*throw to this address*/; | |
22808 | - stack[base + 33LLU] = base; | |
22809 | - stack[base + 34LLU] = 1843LLU; | |
22956 | + stack[base + 34LLU] = 1856LLU/*throw to this address*/; | |
22957 | + stack[base + 35LLU] = base; | |
22958 | + stack[base + 36LLU] = 1857LLU; | |
22810 | 22959 | // arguments for call to add |
22811 | - stack[base + 36LLU] = stack[base + 4]/*offset*/; | |
22812 | - stack[base + 37LLU] = stack[base + 28]/*sum*/; | |
22960 | + stack[base + 38LLU] = stack[base + 4]/*offset*/; | |
22961 | + stack[base + 39LLU] = stack[base + 30]/*sum*/; | |
22813 | 22962 | // set stack-base & callee-address |
22814 | - base += 35LLU; | |
22963 | + base += 37LLU; | |
22815 | 22964 | label = 18446744073709551605LLU; // add |
22816 | 22965 | break; |
22817 | 22966 | } |
22818 | - case 1842LLU: // copy-back deleter (add to ProcCall) | |
22967 | + case 1856LLU: // copy-back deleter (add to ProcCall) | |
22819 | 22968 | { |
22820 | 22969 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
22821 | 22970 | // copy mutable arguments back from call to add |
22822 | - label = 1836LLU; // continue to roll stack | |
22971 | + label = 1850LLU; // continue to roll stack | |
22823 | 22972 | break; |
22824 | 22973 | } |
22825 | - case 1843LLU: // return from add to ProcCall | |
22974 | + case 1857LLU: // return from add to ProcCall | |
22826 | 22975 | { |
22827 | 22976 | // copy mutable arguments back from call to add |
22828 | 22977 | // copy back results provided by call to add |
22829 | - stack[base + 28] = stack[base + 35LLU]; | |
22978 | + stack[base + 30] = stack[base + 37LLU]; | |
22830 | 22979 | // call add from ProcCall |
22831 | - stack[base + 32LLU] = 1844LLU/*throw to this address*/; | |
22832 | - stack[base + 33LLU] = base; | |
22833 | - stack[base + 34LLU] = 1845LLU; | |
22980 | + stack[base + 34LLU] = 1858LLU/*throw to this address*/; | |
22981 | + stack[base + 35LLU] = base; | |
22982 | + stack[base + 36LLU] = 1859LLU; | |
22834 | 22983 | // arguments for call to add |
22835 | - stack[base + 36LLU] = stack[base + 9]/*fnrescount*/; | |
22836 | - stack[base + 37LLU] = stack[base + 28]/*sum*/; | |
22984 | + stack[base + 38LLU] = stack[base + 10]/*fnrescount*/; | |
22985 | + stack[base + 39LLU] = stack[base + 30]/*sum*/; | |
22837 | 22986 | // set stack-base & callee-address |
22838 | - base += 35LLU; | |
22987 | + base += 37LLU; | |
22839 | 22988 | label = 18446744073709551605LLU; // add |
22840 | 22989 | break; |
22841 | 22990 | } |
22842 | - case 1844LLU: // copy-back deleter (add to ProcCall) | |
22991 | + case 1858LLU: // copy-back deleter (add to ProcCall) | |
22843 | 22992 | { |
22844 | 22993 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
22845 | 22994 | // copy mutable arguments back from call to add |
22846 | - label = 1836LLU; // continue to roll stack | |
22995 | + label = 1850LLU; // continue to roll stack | |
22847 | 22996 | break; |
22848 | 22997 | } |
22849 | - case 1845LLU: // return from add to ProcCall | |
22998 | + case 1859LLU: // return from add to ProcCall | |
22850 | 22999 | { |
22851 | 23000 | // copy mutable arguments back from call to add |
22852 | 23001 | // copy back results provided by call to add |
22853 | - stack[base + 28] = stack[base + 35LLU]; | |
23002 | + stack[base + 30] = stack[base + 37LLU]; | |
22854 | 23003 | // call add from ProcCall |
22855 | - stack[base + 32LLU] = 1846LLU/*throw to this address*/; | |
22856 | - stack[base + 33LLU] = base; | |
22857 | - stack[base + 34LLU] = 1847LLU; | |
23004 | + stack[base + 34LLU] = 1860LLU/*throw to this address*/; | |
23005 | + stack[base + 35LLU] = base; | |
23006 | + stack[base + 36LLU] = 1861LLU; | |
22858 | 23007 | // arguments for call to add |
22859 | - stack[base + 36LLU] = stack[base + 10]/*fnargcount*/; | |
22860 | - stack[base + 37LLU] = stack[base + 28]/*sum*/; | |
23008 | + stack[base + 38LLU] = stack[base + 11]/*fnargcount*/; | |
23009 | + stack[base + 39LLU] = stack[base + 30]/*sum*/; | |
22861 | 23010 | // set stack-base & callee-address |
22862 | - base += 35LLU; | |
23011 | + base += 37LLU; | |
22863 | 23012 | label = 18446744073709551605LLU; // add |
22864 | 23013 | break; |
22865 | 23014 | } |
22866 | - case 1846LLU: // copy-back deleter (add to ProcCall) | |
23015 | + case 1860LLU: // copy-back deleter (add to ProcCall) | |
22867 | 23016 | { |
22868 | 23017 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
22869 | 23018 | // copy mutable arguments back from call to add |
22870 | - label = 1836LLU; // continue to roll stack | |
23019 | + label = 1850LLU; // continue to roll stack | |
22871 | 23020 | break; |
22872 | 23021 | } |
22873 | - case 1847LLU: // return from add to ProcCall | |
23022 | + case 1861LLU: // return from add to ProcCall | |
22874 | 23023 | { |
22875 | 23024 | // copy mutable arguments back from call to add |
22876 | 23025 | // copy back results provided by call to add |
22877 | - stack[base + 28] = stack[base + 35LLU]; | |
23026 | + stack[base + 30] = stack[base + 37LLU]; | |
22878 | 23027 | // call add from ProcCall |
22879 | - stack[base + 32LLU] = 1848LLU/*throw to this address*/; | |
22880 | - stack[base + 33LLU] = base; | |
22881 | - stack[base + 34LLU] = 1849LLU; | |
23028 | + stack[base + 34LLU] = 1862LLU/*throw to this address*/; | |
23029 | + stack[base + 35LLU] = base; | |
23030 | + stack[base + 36LLU] = 1863LLU; | |
22882 | 23031 | // arguments for call to add |
22883 | - stack[base + 36LLU] = 0LLU; | |
22884 | - stack[base + 37LLU] = stack[base + 28]/*sum*/; | |
23032 | + stack[base + 38LLU] = 0LLU; | |
23033 | + stack[base + 39LLU] = stack[base + 30]/*sum*/; | |
22885 | 23034 | // set stack-base & callee-address |
22886 | - base += 35LLU; | |
23035 | + base += 37LLU; | |
22887 | 23036 | label = 18446744073709551605LLU; // add |
22888 | 23037 | break; |
22889 | 23038 | } |
22890 | - case 1848LLU: // copy-back deleter (add to ProcCall) | |
23039 | + case 1862LLU: // copy-back deleter (add to ProcCall) | |
22891 | 23040 | { |
22892 | 23041 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
22893 | 23042 | // copy mutable arguments back from call to add |
22894 | - label = 1836LLU; // continue to roll stack | |
23043 | + label = 1850LLU; // continue to roll stack | |
22895 | 23044 | break; |
22896 | 23045 | } |
22897 | - case 1849LLU: // return from add to ProcCall | |
23046 | + case 1863LLU: // return from add to ProcCall | |
22898 | 23047 | { |
22899 | 23048 | // copy mutable arguments back from call to add |
22900 | 23049 | // copy back results provided by call to add |
22901 | - stack[base + 28] = stack[base + 35LLU]; | |
23050 | + stack[base + 30] = stack[base + 37LLU]; | |
22902 | 23051 | printf("%s", "\n stack[base + "); |
22903 | 23052 | // call printnr from ProcCall |
22904 | - stack[base + 32LLU] = 1850LLU/*throw to this address*/; | |
22905 | - stack[base + 33LLU] = base; | |
22906 | - stack[base + 34LLU] = 1851LLU; | |
23053 | + stack[base + 34LLU] = 1864LLU/*throw to this address*/; | |
23054 | + stack[base + 35LLU] = base; | |
23055 | + stack[base + 36LLU] = 1865LLU; | |
22907 | 23056 | // arguments for call to printnr |
22908 | - stack[base + 35LLU] = stack[base + 28]/*sum*/; | |
23057 | + stack[base + 37LLU] = stack[base + 30]/*sum*/; | |
22909 | 23058 | // set stack-base & callee-address |
22910 | - base += 35LLU; | |
23059 | + base += 37LLU; | |
22911 | 23060 | label = 18446744073709551590LLU; // printnr |
22912 | 23061 | break; |
22913 | 23062 | } |
22914 | - case 1850LLU: // copy-back deleter (printnr to ProcCall) | |
23063 | + case 1864LLU: // copy-back deleter (printnr to ProcCall) | |
22915 | 23064 | { |
22916 | 23065 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n"); |
22917 | 23066 | // copy mutable arguments back from call to printnr |
22918 | - label = 1836LLU; // continue to roll stack | |
23067 | + label = 1850LLU; // continue to roll stack | |
22919 | 23068 | break; |
22920 | 23069 | } |
22921 | - case 1851LLU: // return from printnr to ProcCall | |
23070 | + case 1865LLU: // return from printnr to ProcCall | |
22922 | 23071 | { |
22923 | 23072 | // copy mutable arguments back from call to printnr |
22924 | 23073 | printf("%s", "LLU] = "); |
22925 | 23074 | // call printnr from ProcCall |
22926 | - stack[base + 32LLU] = 1852LLU/*throw to this address*/; | |
22927 | - stack[base + 33LLU] = base; | |
22928 | - stack[base + 34LLU] = 1853LLU; | |
23075 | + stack[base + 34LLU] = 1866LLU/*throw to this address*/; | |
23076 | + stack[base + 35LLU] = base; | |
23077 | + stack[base + 36LLU] = 1867LLU; | |
22929 | 23078 | // arguments for call to printnr |
22930 | - stack[base + 35LLU] = stack[base + 31]/*labelfail*/; | |
23079 | + stack[base + 37LLU] = stack[base + 33]/*labelfail*/; | |
22931 | 23080 | // set stack-base & callee-address |
22932 | - base += 35LLU; | |
23081 | + base += 37LLU; | |
22933 | 23082 | label = 18446744073709551590LLU; // printnr |
22934 | 23083 | break; |
22935 | 23084 | } |
22936 | - case 1852LLU: // copy-back deleter (printnr to ProcCall) | |
23085 | + case 1866LLU: // copy-back deleter (printnr to ProcCall) | |
22937 | 23086 | { |
22938 | 23087 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n"); |
22939 | 23088 | // copy mutable arguments back from call to printnr |
22940 | - label = 1836LLU; // continue to roll stack | |
23089 | + label = 1850LLU; // continue to roll stack | |
22941 | 23090 | break; |
22942 | 23091 | } |
22943 | - case 1853LLU: // return from printnr to ProcCall | |
23092 | + case 1867LLU: // return from printnr to ProcCall | |
22944 | 23093 | { |
22945 | 23094 | // copy mutable arguments back from call to printnr |
22946 | 23095 | printf("%s", "LLU/*throw to this address*/;"); |
22947 | - stack[base + 28]/*sum*/ = 0; | |
23096 | + stack[base + 30]/*sum*/ = 0; | |
22948 | 23097 | // call add from ProcCall |
22949 | - stack[base + 32LLU] = 1854LLU/*throw to this address*/; | |
22950 | - stack[base + 33LLU] = base; | |
22951 | - stack[base + 34LLU] = 1855LLU; | |
23098 | + stack[base + 34LLU] = 1868LLU/*throw to this address*/; | |
23099 | + stack[base + 35LLU] = base; | |
23100 | + stack[base + 36LLU] = 1869LLU; | |
22952 | 23101 | // arguments for call to add |
22953 | - stack[base + 36LLU] = stack[base + 4]/*offset*/; | |
22954 | - stack[base + 37LLU] = stack[base + 28]/*sum*/; | |
23102 | + stack[base + 38LLU] = stack[base + 4]/*offset*/; | |
23103 | + stack[base + 39LLU] = stack[base + 30]/*sum*/; | |
22955 | 23104 | // set stack-base & callee-address |
22956 | - base += 35LLU; | |
23105 | + base += 37LLU; | |
22957 | 23106 | label = 18446744073709551605LLU; // add |
22958 | 23107 | break; |
22959 | 23108 | } |
22960 | - case 1854LLU: // copy-back deleter (add to ProcCall) | |
23109 | + case 1868LLU: // copy-back deleter (add to ProcCall) | |
22961 | 23110 | { |
22962 | 23111 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
22963 | 23112 | // copy mutable arguments back from call to add |
22964 | - label = 1836LLU; // continue to roll stack | |
23113 | + label = 1850LLU; // continue to roll stack | |
22965 | 23114 | break; |
22966 | 23115 | } |
22967 | - case 1855LLU: // return from add to ProcCall | |
23116 | + case 1869LLU: // return from add to ProcCall | |
22968 | 23117 | { |
22969 | 23118 | // copy mutable arguments back from call to add |
22970 | 23119 | // copy back results provided by call to add |
22971 | - stack[base + 28] = stack[base + 35LLU]; | |
23120 | + stack[base + 30] = stack[base + 37LLU]; | |
22972 | 23121 | // call add from ProcCall |
22973 | - stack[base + 32LLU] = 1856LLU/*throw to this address*/; | |
22974 | - stack[base + 33LLU] = base; | |
22975 | - stack[base + 34LLU] = 1857LLU; | |
23122 | + stack[base + 34LLU] = 1870LLU/*throw to this address*/; | |
23123 | + stack[base + 35LLU] = base; | |
23124 | + stack[base + 36LLU] = 1871LLU; | |
22976 | 23125 | // arguments for call to add |
22977 | - stack[base + 36LLU] = stack[base + 9]/*fnrescount*/; | |
22978 | - stack[base + 37LLU] = stack[base + 28]/*sum*/; | |
23126 | + stack[base + 38LLU] = stack[base + 10]/*fnrescount*/; | |
23127 | + stack[base + 39LLU] = stack[base + 30]/*sum*/; | |
22979 | 23128 | // set stack-base & callee-address |
22980 | - base += 35LLU; | |
23129 | + base += 37LLU; | |
22981 | 23130 | label = 18446744073709551605LLU; // add |
22982 | 23131 | break; |
22983 | 23132 | } |
22984 | - case 1856LLU: // copy-back deleter (add to ProcCall) | |
23133 | + case 1870LLU: // copy-back deleter (add to ProcCall) | |
22985 | 23134 | { |
22986 | 23135 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
22987 | 23136 | // copy mutable arguments back from call to add |
22988 | - label = 1836LLU; // continue to roll stack | |
23137 | + label = 1850LLU; // continue to roll stack | |
22989 | 23138 | break; |
22990 | 23139 | } |
22991 | - case 1857LLU: // return from add to ProcCall | |
23140 | + case 1871LLU: // return from add to ProcCall | |
22992 | 23141 | { |
22993 | 23142 | // copy mutable arguments back from call to add |
22994 | 23143 | // copy back results provided by call to add |
22995 | - stack[base + 28] = stack[base + 35LLU]; | |
23144 | + stack[base + 30] = stack[base + 37LLU]; | |
22996 | 23145 | // call add from ProcCall |
22997 | - stack[base + 32LLU] = 1858LLU/*throw to this address*/; | |
22998 | - stack[base + 33LLU] = base; | |
22999 | - stack[base + 34LLU] = 1859LLU; | |
23146 | + stack[base + 34LLU] = 1872LLU/*throw to this address*/; | |
23147 | + stack[base + 35LLU] = base; | |
23148 | + stack[base + 36LLU] = 1873LLU; | |
23000 | 23149 | // arguments for call to add |
23001 | - stack[base + 36LLU] = stack[base + 10]/*fnargcount*/; | |
23002 | - stack[base + 37LLU] = stack[base + 28]/*sum*/; | |
23150 | + stack[base + 38LLU] = stack[base + 11]/*fnargcount*/; | |
23151 | + stack[base + 39LLU] = stack[base + 30]/*sum*/; | |
23003 | 23152 | // set stack-base & callee-address |
23004 | - base += 35LLU; | |
23153 | + base += 37LLU; | |
23005 | 23154 | label = 18446744073709551605LLU; // add |
23006 | 23155 | break; |
23007 | 23156 | } |
23008 | - case 1858LLU: // copy-back deleter (add to ProcCall) | |
23157 | + case 1872LLU: // copy-back deleter (add to ProcCall) | |
23009 | 23158 | { |
23010 | 23159 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
23011 | 23160 | // copy mutable arguments back from call to add |
23012 | - label = 1836LLU; // continue to roll stack | |
23161 | + label = 1850LLU; // continue to roll stack | |
23013 | 23162 | break; |
23014 | 23163 | } |
23015 | - case 1859LLU: // return from add to ProcCall | |
23164 | + case 1873LLU: // return from add to ProcCall | |
23016 | 23165 | { |
23017 | 23166 | // copy mutable arguments back from call to add |
23018 | 23167 | // copy back results provided by call to add |
23019 | - stack[base + 28] = stack[base + 35LLU]; | |
23168 | + stack[base + 30] = stack[base + 37LLU]; | |
23020 | 23169 | // call add from ProcCall |
23021 | - stack[base + 32LLU] = 1860LLU/*throw to this address*/; | |
23022 | - stack[base + 33LLU] = base; | |
23023 | - stack[base + 34LLU] = 1861LLU; | |
23170 | + stack[base + 34LLU] = 1874LLU/*throw to this address*/; | |
23171 | + stack[base + 35LLU] = base; | |
23172 | + stack[base + 36LLU] = 1875LLU; | |
23024 | 23173 | // arguments for call to add |
23025 | - stack[base + 36LLU] = 1LLU; | |
23026 | - stack[base + 37LLU] = stack[base + 28]/*sum*/; | |
23174 | + stack[base + 38LLU] = 1LLU; | |
23175 | + stack[base + 39LLU] = stack[base + 30]/*sum*/; | |
23027 | 23176 | // set stack-base & callee-address |
23028 | - base += 35LLU; | |
23177 | + base += 37LLU; | |
23029 | 23178 | label = 18446744073709551605LLU; // add |
23030 | 23179 | break; |
23031 | 23180 | } |
23032 | - case 1860LLU: // copy-back deleter (add to ProcCall) | |
23181 | + case 1874LLU: // copy-back deleter (add to ProcCall) | |
23033 | 23182 | { |
23034 | 23183 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
23035 | 23184 | // copy mutable arguments back from call to add |
23036 | - label = 1836LLU; // continue to roll stack | |
23185 | + label = 1850LLU; // continue to roll stack | |
23037 | 23186 | break; |
23038 | 23187 | } |
23039 | - case 1861LLU: // return from add to ProcCall | |
23188 | + case 1875LLU: // return from add to ProcCall | |
23040 | 23189 | { |
23041 | 23190 | // copy mutable arguments back from call to add |
23042 | 23191 | // copy back results provided by call to add |
23043 | - stack[base + 28] = stack[base + 35LLU]; | |
23192 | + stack[base + 30] = stack[base + 37LLU]; | |
23044 | 23193 | printf("%s", "\n stack[base + "); |
23045 | 23194 | // call printnr from ProcCall |
23046 | - stack[base + 32LLU] = 1862LLU/*throw to this address*/; | |
23047 | - stack[base + 33LLU] = base; | |
23048 | - stack[base + 34LLU] = 1863LLU; | |
23195 | + stack[base + 34LLU] = 1876LLU/*throw to this address*/; | |
23196 | + stack[base + 35LLU] = base; | |
23197 | + stack[base + 36LLU] = 1877LLU; | |
23049 | 23198 | // arguments for call to printnr |
23050 | - stack[base + 35LLU] = stack[base + 28]/*sum*/; | |
23199 | + stack[base + 37LLU] = stack[base + 30]/*sum*/; | |
23051 | 23200 | // set stack-base & callee-address |
23052 | - base += 35LLU; | |
23201 | + base += 37LLU; | |
23053 | 23202 | label = 18446744073709551590LLU; // printnr |
23054 | 23203 | break; |
23055 | 23204 | } |
23056 | - case 1862LLU: // copy-back deleter (printnr to ProcCall) | |
23205 | + case 1876LLU: // copy-back deleter (printnr to ProcCall) | |
23057 | 23206 | { |
23058 | 23207 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n"); |
23059 | 23208 | // copy mutable arguments back from call to printnr |
23060 | - label = 1836LLU; // continue to roll stack | |
23209 | + label = 1850LLU; // continue to roll stack | |
23061 | 23210 | break; |
23062 | 23211 | } |
23063 | - case 1863LLU: // return from printnr to ProcCall | |
23212 | + case 1877LLU: // return from printnr to ProcCall | |
23064 | 23213 | { |
23065 | 23214 | // copy mutable arguments back from call to printnr |
23066 | 23215 | printf("%s", "LLU] = base;"); |
23067 | - stack[base + 28]/*sum*/ = 0; | |
23216 | + stack[base + 30]/*sum*/ = 0; | |
23068 | 23217 | // call add from ProcCall |
23069 | - stack[base + 32LLU] = 1864LLU/*throw to this address*/; | |
23070 | - stack[base + 33LLU] = base; | |
23071 | - stack[base + 34LLU] = 1865LLU; | |
23218 | + stack[base + 34LLU] = 1878LLU/*throw to this address*/; | |
23219 | + stack[base + 35LLU] = base; | |
23220 | + stack[base + 36LLU] = 1879LLU; | |
23072 | 23221 | // arguments for call to add |
23073 | - stack[base + 36LLU] = stack[base + 4]/*offset*/; | |
23074 | - stack[base + 37LLU] = stack[base + 28]/*sum*/; | |
23222 | + stack[base + 38LLU] = stack[base + 4]/*offset*/; | |
23223 | + stack[base + 39LLU] = stack[base + 30]/*sum*/; | |
23075 | 23224 | // set stack-base & callee-address |
23076 | - base += 35LLU; | |
23225 | + base += 37LLU; | |
23077 | 23226 | label = 18446744073709551605LLU; // add |
23078 | 23227 | break; |
23079 | 23228 | } |
23080 | - case 1864LLU: // copy-back deleter (add to ProcCall) | |
23229 | + case 1878LLU: // copy-back deleter (add to ProcCall) | |
23081 | 23230 | { |
23082 | 23231 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
23083 | 23232 | // copy mutable arguments back from call to add |
23084 | - label = 1836LLU; // continue to roll stack | |
23233 | + label = 1850LLU; // continue to roll stack | |
23085 | 23234 | break; |
23086 | 23235 | } |
23087 | - case 1865LLU: // return from add to ProcCall | |
23236 | + case 1879LLU: // return from add to ProcCall | |
23088 | 23237 | { |
23089 | 23238 | // copy mutable arguments back from call to add |
23090 | 23239 | // copy back results provided by call to add |
23091 | - stack[base + 28] = stack[base + 35LLU]; | |
23240 | + stack[base + 30] = stack[base + 37LLU]; | |
23092 | 23241 | // call add from ProcCall |
23093 | - stack[base + 32LLU] = 1866LLU/*throw to this address*/; | |
23094 | - stack[base + 33LLU] = base; | |
23095 | - stack[base + 34LLU] = 1867LLU; | |
23242 | + stack[base + 34LLU] = 1880LLU/*throw to this address*/; | |
23243 | + stack[base + 35LLU] = base; | |
23244 | + stack[base + 36LLU] = 1881LLU; | |
23096 | 23245 | // arguments for call to add |
23097 | - stack[base + 36LLU] = stack[base + 9]/*fnrescount*/; | |
23098 | - stack[base + 37LLU] = stack[base + 28]/*sum*/; | |
23246 | + stack[base + 38LLU] = stack[base + 10]/*fnrescount*/; | |
23247 | + stack[base + 39LLU] = stack[base + 30]/*sum*/; | |
23099 | 23248 | // set stack-base & callee-address |
23100 | - base += 35LLU; | |
23249 | + base += 37LLU; | |
23101 | 23250 | label = 18446744073709551605LLU; // add |
23102 | 23251 | break; |
23103 | 23252 | } |
23104 | - case 1866LLU: // copy-back deleter (add to ProcCall) | |
23253 | + case 1880LLU: // copy-back deleter (add to ProcCall) | |
23105 | 23254 | { |
23106 | 23255 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
23107 | 23256 | // copy mutable arguments back from call to add |
23108 | - label = 1836LLU; // continue to roll stack | |
23257 | + label = 1850LLU; // continue to roll stack | |
23109 | 23258 | break; |
23110 | 23259 | } |
23111 | - case 1867LLU: // return from add to ProcCall | |
23260 | + case 1881LLU: // return from add to ProcCall | |
23112 | 23261 | { |
23113 | 23262 | // copy mutable arguments back from call to add |
23114 | 23263 | // copy back results provided by call to add |
23115 | - stack[base + 28] = stack[base + 35LLU]; | |
23264 | + stack[base + 30] = stack[base + 37LLU]; | |
23116 | 23265 | // call add from ProcCall |
23117 | - stack[base + 32LLU] = 1868LLU/*throw to this address*/; | |
23118 | - stack[base + 33LLU] = base; | |
23119 | - stack[base + 34LLU] = 1869LLU; | |
23266 | + stack[base + 34LLU] = 1882LLU/*throw to this address*/; | |
23267 | + stack[base + 35LLU] = base; | |
23268 | + stack[base + 36LLU] = 1883LLU; | |
23120 | 23269 | // arguments for call to add |
23121 | - stack[base + 36LLU] = stack[base + 10]/*fnargcount*/; | |
23122 | - stack[base + 37LLU] = stack[base + 28]/*sum*/; | |
23270 | + stack[base + 38LLU] = stack[base + 11]/*fnargcount*/; | |
23271 | + stack[base + 39LLU] = stack[base + 30]/*sum*/; | |
23123 | 23272 | // set stack-base & callee-address |
23124 | - base += 35LLU; | |
23273 | + base += 37LLU; | |
23125 | 23274 | label = 18446744073709551605LLU; // add |
23126 | 23275 | break; |
23127 | 23276 | } |
23128 | - case 1868LLU: // copy-back deleter (add to ProcCall) | |
23277 | + case 1882LLU: // copy-back deleter (add to ProcCall) | |
23129 | 23278 | { |
23130 | 23279 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
23131 | 23280 | // copy mutable arguments back from call to add |
23132 | - label = 1836LLU; // continue to roll stack | |
23281 | + label = 1850LLU; // continue to roll stack | |
23133 | 23282 | break; |
23134 | 23283 | } |
23135 | - case 1869LLU: // return from add to ProcCall | |
23284 | + case 1883LLU: // return from add to ProcCall | |
23136 | 23285 | { |
23137 | 23286 | // copy mutable arguments back from call to add |
23138 | 23287 | // copy back results provided by call to add |
23139 | - stack[base + 28] = stack[base + 35LLU]; | |
23288 | + stack[base + 30] = stack[base + 37LLU]; | |
23140 | 23289 | // call add from ProcCall |
23141 | - stack[base + 32LLU] = 1870LLU/*throw to this address*/; | |
23142 | - stack[base + 33LLU] = base; | |
23143 | - stack[base + 34LLU] = 1871LLU; | |
23290 | + stack[base + 34LLU] = 1884LLU/*throw to this address*/; | |
23291 | + stack[base + 35LLU] = base; | |
23292 | + stack[base + 36LLU] = 1885LLU; | |
23144 | 23293 | // arguments for call to add |
23145 | - stack[base + 36LLU] = 2LLU; | |
23146 | - stack[base + 37LLU] = stack[base + 28]/*sum*/; | |
23294 | + stack[base + 38LLU] = 2LLU; | |
23295 | + stack[base + 39LLU] = stack[base + 30]/*sum*/; | |
23147 | 23296 | // set stack-base & callee-address |
23148 | - base += 35LLU; | |
23297 | + base += 37LLU; | |
23149 | 23298 | label = 18446744073709551605LLU; // add |
23150 | 23299 | break; |
23151 | 23300 | } |
23152 | - case 1870LLU: // copy-back deleter (add to ProcCall) | |
23301 | + case 1884LLU: // copy-back deleter (add to ProcCall) | |
23153 | 23302 | { |
23154 | 23303 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
23155 | 23304 | // copy mutable arguments back from call to add |
23156 | - label = 1836LLU; // continue to roll stack | |
23305 | + label = 1850LLU; // continue to roll stack | |
23157 | 23306 | break; |
23158 | 23307 | } |
23159 | - case 1871LLU: // return from add to ProcCall | |
23308 | + case 1885LLU: // return from add to ProcCall | |
23160 | 23309 | { |
23161 | 23310 | // copy mutable arguments back from call to add |
23162 | 23311 | // copy back results provided by call to add |
23163 | - stack[base + 28] = stack[base + 35LLU]; | |
23312 | + stack[base + 30] = stack[base + 37LLU]; | |
23164 | 23313 | // call add from ProcCall |
23165 | - stack[base + 32LLU] = 1872LLU/*throw to this address*/; | |
23166 | - stack[base + 33LLU] = base; | |
23167 | - stack[base + 34LLU] = 1873LLU; | |
23314 | + stack[base + 34LLU] = 1886LLU/*throw to this address*/; | |
23315 | + stack[base + 35LLU] = base; | |
23316 | + stack[base + 36LLU] = 1887LLU; | |
23168 | 23317 | // arguments for call to add |
23169 | - stack[base + 36LLU] = 1LLU; | |
23170 | - stack[base + 37LLU] = stack[base + 16]/*label*/; | |
23318 | + stack[base + 38LLU] = 1LLU; | |
23319 | + stack[base + 39LLU] = stack[base + 17]/*label*/; | |
23171 | 23320 | // set stack-base & callee-address |
23172 | - base += 35LLU; | |
23321 | + base += 37LLU; | |
23173 | 23322 | label = 18446744073709551605LLU; // add |
23174 | 23323 | break; |
23175 | 23324 | } |
23176 | - case 1872LLU: // copy-back deleter (add to ProcCall) | |
23325 | + case 1886LLU: // copy-back deleter (add to ProcCall) | |
23177 | 23326 | { |
23178 | 23327 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
23179 | 23328 | // copy mutable arguments back from call to add |
23180 | - label = 1836LLU; // continue to roll stack | |
23329 | + label = 1850LLU; // continue to roll stack | |
23181 | 23330 | break; |
23182 | 23331 | } |
23183 | - case 1873LLU: // return from add to ProcCall | |
23332 | + case 1887LLU: // return from add to ProcCall | |
23184 | 23333 | { |
23185 | 23334 | // copy mutable arguments back from call to add |
23186 | 23335 | // copy back results provided by call to add |
23187 | - stack[base + 16] = stack[base + 35LLU]; | |
23336 | + stack[base + 17] = stack[base + 37LLU]; | |
23188 | 23337 | printf("%s", "\n stack[base + "); |
23189 | 23338 | // call printnr from ProcCall |
23190 | - stack[base + 32LLU] = 1874LLU/*throw to this address*/; | |
23191 | - stack[base + 33LLU] = base; | |
23192 | - stack[base + 34LLU] = 1875LLU; | |
23339 | + stack[base + 34LLU] = 1888LLU/*throw to this address*/; | |
23340 | + stack[base + 35LLU] = base; | |
23341 | + stack[base + 36LLU] = 1889LLU; | |
23193 | 23342 | // arguments for call to printnr |
23194 | - stack[base + 35LLU] = stack[base + 28]/*sum*/; | |
23343 | + stack[base + 37LLU] = stack[base + 30]/*sum*/; | |
23195 | 23344 | // set stack-base & callee-address |
23196 | - base += 35LLU; | |
23345 | + base += 37LLU; | |
23197 | 23346 | label = 18446744073709551590LLU; // printnr |
23198 | 23347 | break; |
23199 | 23348 | } |
23200 | - case 1874LLU: // copy-back deleter (printnr to ProcCall) | |
23349 | + case 1888LLU: // copy-back deleter (printnr to ProcCall) | |
23201 | 23350 | { |
23202 | 23351 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n"); |
23203 | 23352 | // copy mutable arguments back from call to printnr |
23204 | - label = 1836LLU; // continue to roll stack | |
23353 | + label = 1850LLU; // continue to roll stack | |
23205 | 23354 | break; |
23206 | 23355 | } |
23207 | - case 1875LLU: // return from printnr to ProcCall | |
23356 | + case 1889LLU: // return from printnr to ProcCall | |
23208 | 23357 | { |
23209 | 23358 | // copy mutable arguments back from call to printnr |
23210 | 23359 | printf("%s", "LLU] = "); |
23211 | 23360 | // call printnr from ProcCall |
23212 | - stack[base + 32LLU] = 1876LLU/*throw to this address*/; | |
23213 | - stack[base + 33LLU] = base; | |
23214 | - stack[base + 34LLU] = 1877LLU; | |
23361 | + stack[base + 34LLU] = 1890LLU/*throw to this address*/; | |
23362 | + stack[base + 35LLU] = base; | |
23363 | + stack[base + 36LLU] = 1891LLU; | |
23215 | 23364 | // arguments for call to printnr |
23216 | - stack[base + 35LLU] = stack[base + 16]/*label*/; | |
23365 | + stack[base + 37LLU] = stack[base + 17]/*label*/; | |
23217 | 23366 | // set stack-base & callee-address |
23218 | - base += 35LLU; | |
23367 | + base += 37LLU; | |
23219 | 23368 | label = 18446744073709551590LLU; // printnr |
23220 | 23369 | break; |
23221 | 23370 | } |
23222 | - case 1876LLU: // copy-back deleter (printnr to ProcCall) | |
23371 | + case 1890LLU: // copy-back deleter (printnr to ProcCall) | |
23223 | 23372 | { |
23224 | 23373 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n"); |
23225 | 23374 | // copy mutable arguments back from call to printnr |
23226 | - label = 1836LLU; // continue to roll stack | |
23375 | + label = 1850LLU; // continue to roll stack | |
23227 | 23376 | break; |
23228 | 23377 | } |
23229 | - case 1877LLU: // return from printnr to ProcCall | |
23378 | + case 1891LLU: // return from printnr to ProcCall | |
23230 | 23379 | { |
23231 | 23380 | // copy mutable arguments back from call to printnr |
23232 | 23381 | printf("%s", "LLU;"); |
23233 | - stack[base + 29]/*n*/ = stack[base + 27]/*ceargcount*/; | |
23382 | + stack[base + 31]/*n*/ = stack[base + 29]/*ceargcount*/; | |
23234 | 23383 | printf("%s", "\n // arguments for call to "); |
23235 | 23384 | // call printid from ProcCall |
23236 | - stack[base + 32LLU] = 1878LLU/*throw to this address*/; | |
23237 | - stack[base + 33LLU] = base; | |
23238 | - stack[base + 34LLU] = 1879LLU; | |
23385 | + stack[base + 34LLU] = 1892LLU/*throw to this address*/; | |
23386 | + stack[base + 35LLU] = base; | |
23387 | + stack[base + 36LLU] = 1893LLU; | |
23239 | 23388 | // arguments for call to printid |
23240 | - stack[base + 35LLU] = stack[base + 23]/*ceid*/; | |
23389 | + stack[base + 37LLU] = stack[base + 24]/*ceid*/; | |
23241 | 23390 | // set stack-base & callee-address |
23242 | - base += 35LLU; | |
23391 | + base += 37LLU; | |
23243 | 23392 | label = 18446744073709551587LLU; // printid |
23244 | 23393 | break; |
23245 | 23394 | } |
23246 | - case 1878LLU: // copy-back deleter (printid to ProcCall) | |
23395 | + case 1892LLU: // copy-back deleter (printid to ProcCall) | |
23247 | 23396 | { |
23248 | 23397 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n"); |
23249 | 23398 | // copy mutable arguments back from call to printid |
23250 | - label = 1836LLU; // continue to roll stack | |
23399 | + label = 1850LLU; // continue to roll stack | |
23251 | 23400 | break; |
23252 | 23401 | } |
23253 | - case 1879LLU: // return from printid to ProcCall | |
23402 | + case 1893LLU: // return from printid to ProcCall | |
23254 | 23403 | { |
23255 | 23404 | // copy mutable arguments back from call to printid |
23256 | - flippedassign(stack[base + 21]/*ceargtypes*/, &stack[base + 32]); | |
23257 | - label = 1880LLU; // start to repeat | |
23405 | + flippedassign(stack[base + 22]/*ceargtypes*/, &stack[base + 34]); | |
23406 | + label = 1894LLU; // start to repeat | |
23258 | 23407 | break; |
23259 | 23408 | } |
23260 | - case 1880LLU: // repeat from here | |
23409 | + case 1894LLU: // repeat from here | |
23261 | 23410 | { |
23262 | - if(!stack[base + 32]) | |
23411 | + if(!stack[base + 34]) | |
23263 | 23412 | { |
23264 | - label = 1881LLU; // break loop | |
23413 | + label = 1895LLU; // break loop | |
23265 | 23414 | break; |
23266 | 23415 | } |
23267 | 23416 | |
23268 | 23417 | // loop body |
23269 | - stack[base + 33] = (uint64_t)(((const struct listnode *)(stack[base + 32]))->data); | |
23270 | - stack[base + 34]/*previous*/ = stack[base + 32]; | |
23271 | - stack[base + 32] = (uint64_t)(((const struct listnode *)(stack[base + 32]))->next); | |
23418 | + stack[base + 35] = (uint64_t)(((const struct listnode *)(stack[base + 34]))->data); | |
23419 | + stack[base + 36]/*previous*/ = stack[base + 34]; | |
23420 | + stack[base + 34] = (uint64_t)(((const struct listnode *)(stack[base + 34]))->next); | |
23272 | 23421 | // call sub from ProcCall |
23273 | - stack[base + 35LLU] = 1882LLU/*throw to this address*/; | |
23274 | - stack[base + 36LLU] = base; | |
23275 | - stack[base + 37LLU] = 1883LLU; | |
23422 | + stack[base + 37LLU] = 1896LLU/*throw to this address*/; | |
23423 | + stack[base + 38LLU] = base; | |
23424 | + stack[base + 39LLU] = 1897LLU; | |
23276 | 23425 | // arguments for call to sub |
23277 | - stack[base + 39LLU] = stack[base + 27]/*ceargcount*/; | |
23278 | - stack[base + 40LLU] = stack[base + 29]/*n*/; | |
23426 | + stack[base + 41LLU] = stack[base + 29]/*ceargcount*/; | |
23427 | + stack[base + 42LLU] = stack[base + 31]/*n*/; | |
23279 | 23428 | // set stack-base & callee-address |
23280 | - base += 38LLU; | |
23429 | + base += 40LLU; | |
23281 | 23430 | label = 18446744073709551604LLU; // sub |
23282 | 23431 | break; |
23283 | 23432 | } |
23284 | - case 1882LLU: // copy-back deleter (sub to ProcCall) | |
23433 | + case 1896LLU: // copy-back deleter (sub to ProcCall) | |
23285 | 23434 | { |
23286 | 23435 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (sub to ProcCall)\n"); |
23287 | 23436 | // copy mutable arguments back from call to sub |
23288 | - label = 1836LLU; // continue to roll stack | |
23437 | + label = 1850LLU; // continue to roll stack | |
23289 | 23438 | break; |
23290 | 23439 | } |
23291 | - case 1883LLU: // return from sub to ProcCall | |
23440 | + case 1897LLU: // return from sub to ProcCall | |
23292 | 23441 | { |
23293 | 23442 | // copy mutable arguments back from call to sub |
23294 | 23443 | // copy back results provided by call to sub |
23295 | - stack[base + 30] = stack[base + 38LLU]; | |
23444 | + stack[base + 32] = stack[base + 40LLU]; | |
23296 | 23445 | // call sub from ProcCall |
23297 | - stack[base + 35LLU] = 1884LLU/*throw to this address*/; | |
23298 | - stack[base + 36LLU] = base; | |
23299 | - stack[base + 37LLU] = 1885LLU; | |
23446 | + stack[base + 37LLU] = 1898LLU/*throw to this address*/; | |
23447 | + stack[base + 38LLU] = base; | |
23448 | + stack[base + 39LLU] = 1899LLU; | |
23300 | 23449 | // arguments for call to sub |
23301 | - stack[base + 39LLU] = stack[base + 29]/*n*/; | |
23302 | - stack[base + 40LLU] = 1LLU; | |
23450 | + stack[base + 41LLU] = stack[base + 31]/*n*/; | |
23451 | + stack[base + 42LLU] = 1LLU; | |
23303 | 23452 | // set stack-base & callee-address |
23304 | - base += 38LLU; | |
23453 | + base += 40LLU; | |
23305 | 23454 | label = 18446744073709551604LLU; // sub |
23306 | 23455 | break; |
23307 | 23456 | } |
23308 | - case 1884LLU: // copy-back deleter (sub to ProcCall) | |
23457 | + case 1898LLU: // copy-back deleter (sub to ProcCall) | |
23309 | 23458 | { |
23310 | 23459 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (sub to ProcCall)\n"); |
23311 | 23460 | // copy mutable arguments back from call to sub |
23312 | - label = 1836LLU; // continue to roll stack | |
23461 | + label = 1850LLU; // continue to roll stack | |
23313 | 23462 | break; |
23314 | 23463 | } |
23315 | - case 1885LLU: // return from sub to ProcCall | |
23464 | + case 1899LLU: // return from sub to ProcCall | |
23316 | 23465 | { |
23317 | 23466 | // copy mutable arguments back from call to sub |
23318 | 23467 | // copy back results provided by call to sub |
23319 | - stack[base + 29] = stack[base + 38LLU]; | |
23320 | - if(!stack[base + 30]/*index*/) | |
23468 | + stack[base + 31] = stack[base + 40LLU]; | |
23469 | + if(!stack[base + 32]/*index*/) | |
23321 | 23470 | { |
23322 | - label = 1886LLU; // jump to alternative | |
23471 | + label = 1900LLU; // jump to alternative | |
23323 | 23472 | break; |
23324 | 23473 | } |
23325 | 23474 | |
23326 | 23475 | // consequent |
23327 | 23476 | // call matchsym from ProcCall |
23328 | - stack[base + 35LLU] = 1888LLU/*throw to this address*/; | |
23329 | - stack[base + 36LLU] = base; | |
23330 | - stack[base + 37LLU] = 1889LLU; | |
23477 | + stack[base + 37LLU] = 1902LLU/*throw to this address*/; | |
23478 | + stack[base + 38LLU] = base; | |
23479 | + stack[base + 39LLU] = 1903LLU; | |
23331 | 23480 | // arguments for call to matchsym |
23332 | - stack[base + 38LLU] = stack[base + 7]/*fnid*/; | |
23333 | - stack[base + 39LLU] = 44LLU; | |
23334 | - stack[base + 40LLU] = stack[base + 13]/*lookahead*/; | |
23481 | + stack[base + 40LLU] = stack[base + 8]/*fnid*/; | |
23482 | + stack[base + 41LLU] = 44LLU; | |
23483 | + stack[base + 42LLU] = stack[base + 14]/*lookahead*/; | |
23335 | 23484 | // set stack-base & callee-address |
23336 | - base += 38LLU; | |
23485 | + base += 40LLU; | |
23337 | 23486 | label = 211LLU; // matchsym |
23338 | 23487 | break; |
23339 | 23488 | } |
23340 | - case 1888LLU: // copy-back deleter (matchsym to ProcCall) | |
23489 | + case 1902LLU: // copy-back deleter (matchsym to ProcCall) | |
23341 | 23490 | { |
23342 | 23491 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (matchsym to ProcCall)\n"); |
23343 | 23492 | // copy mutable arguments back from call to matchsym |
23344 | - stack[base + 13]/*lookahead*/ = stack[base + 40LLU]; | |
23345 | - label = 1836LLU; // continue to roll stack | |
23493 | + stack[base + 14]/*lookahead*/ = stack[base + 42LLU]; | |
23494 | + label = 1850LLU; // continue to roll stack | |
23346 | 23495 | break; |
23347 | 23496 | } |
23348 | - case 1889LLU: // return from matchsym to ProcCall | |
23497 | + case 1903LLU: // return from matchsym to ProcCall | |
23349 | 23498 | { |
23350 | 23499 | // copy mutable arguments back from call to matchsym |
23351 | - stack[base + 13]/*lookahead*/ = stack[base + 40LLU]; | |
23352 | - label = 1887LLU; // consequent complete | |
23500 | + stack[base + 14]/*lookahead*/ = stack[base + 42LLU]; | |
23501 | + label = 1901LLU; // consequent complete | |
23353 | 23502 | break; |
23354 | 23503 | } |
23355 | - case 1886LLU: // alternative | |
23504 | + case 1900LLU: // alternative | |
23356 | 23505 | { |
23357 | - label = 1887LLU; // alternative complete | |
23506 | + label = 1901LLU; // alternative complete | |
23358 | 23507 | break; |
23359 | 23508 | } |
23360 | - case 1887LLU: // completed if-then-else | |
23509 | + case 1901LLU: // completed if-then-else | |
23361 | 23510 | { |
23362 | - stack[base + 28]/*sum*/ = 0; | |
23511 | + stack[base + 30]/*sum*/ = 0; | |
23363 | 23512 | // call add from ProcCall |
23364 | - stack[base + 35LLU] = 1890LLU/*throw to this address*/; | |
23365 | - stack[base + 36LLU] = base; | |
23366 | - stack[base + 37LLU] = 1891LLU; | |
23513 | + stack[base + 37LLU] = 1904LLU/*throw to this address*/; | |
23514 | + stack[base + 38LLU] = base; | |
23515 | + stack[base + 39LLU] = 1905LLU; | |
23367 | 23516 | // arguments for call to add |
23368 | - stack[base + 39LLU] = stack[base + 4]/*offset*/; | |
23369 | - stack[base + 40LLU] = stack[base + 28]/*sum*/; | |
23517 | + stack[base + 41LLU] = stack[base + 4]/*offset*/; | |
23518 | + stack[base + 42LLU] = stack[base + 30]/*sum*/; | |
23370 | 23519 | // set stack-base & callee-address |
23371 | - base += 38LLU; | |
23520 | + base += 40LLU; | |
23372 | 23521 | label = 18446744073709551605LLU; // add |
23373 | 23522 | break; |
23374 | 23523 | } |
23375 | - case 1890LLU: // copy-back deleter (add to ProcCall) | |
23524 | + case 1904LLU: // copy-back deleter (add to ProcCall) | |
23376 | 23525 | { |
23377 | 23526 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
23378 | 23527 | // copy mutable arguments back from call to add |
23379 | - label = 1836LLU; // continue to roll stack | |
23528 | + label = 1850LLU; // continue to roll stack | |
23380 | 23529 | break; |
23381 | 23530 | } |
23382 | - case 1891LLU: // return from add to ProcCall | |
23531 | + case 1905LLU: // return from add to ProcCall | |
23383 | 23532 | { |
23384 | 23533 | // copy mutable arguments back from call to add |
23385 | 23534 | // copy back results provided by call to add |
23386 | - stack[base + 28] = stack[base + 38LLU]; | |
23535 | + stack[base + 30] = stack[base + 40LLU]; | |
23387 | 23536 | // call add from ProcCall |
23388 | - stack[base + 35LLU] = 1892LLU/*throw to this address*/; | |
23389 | - stack[base + 36LLU] = base; | |
23390 | - stack[base + 37LLU] = 1893LLU; | |
23537 | + stack[base + 37LLU] = 1906LLU/*throw to this address*/; | |
23538 | + stack[base + 38LLU] = base; | |
23539 | + stack[base + 39LLU] = 1907LLU; | |
23391 | 23540 | // arguments for call to add |
23392 | - stack[base + 39LLU] = 3LLU; | |
23393 | - stack[base + 40LLU] = stack[base + 28]/*sum*/; | |
23541 | + stack[base + 41LLU] = 3LLU; | |
23542 | + stack[base + 42LLU] = stack[base + 30]/*sum*/; | |
23394 | 23543 | // set stack-base & callee-address |
23395 | - base += 38LLU; | |
23544 | + base += 40LLU; | |
23396 | 23545 | label = 18446744073709551605LLU; // add |
23397 | 23546 | break; |
23398 | 23547 | } |
23399 | - case 1892LLU: // copy-back deleter (add to ProcCall) | |
23548 | + case 1906LLU: // copy-back deleter (add to ProcCall) | |
23400 | 23549 | { |
23401 | 23550 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
23402 | 23551 | // copy mutable arguments back from call to add |
23403 | - label = 1836LLU; // continue to roll stack | |
23552 | + label = 1850LLU; // continue to roll stack | |
23404 | 23553 | break; |
23405 | 23554 | } |
23406 | - case 1893LLU: // return from add to ProcCall | |
23555 | + case 1907LLU: // return from add to ProcCall | |
23407 | 23556 | { |
23408 | 23557 | // copy mutable arguments back from call to add |
23409 | 23558 | // copy back results provided by call to add |
23410 | - stack[base + 28] = stack[base + 38LLU]; | |
23559 | + stack[base + 30] = stack[base + 40LLU]; | |
23411 | 23560 | // call add from ProcCall |
23412 | - stack[base + 35LLU] = 1894LLU/*throw to this address*/; | |
23413 | - stack[base + 36LLU] = base; | |
23414 | - stack[base + 37LLU] = 1895LLU; | |
23561 | + stack[base + 37LLU] = 1908LLU/*throw to this address*/; | |
23562 | + stack[base + 38LLU] = base; | |
23563 | + stack[base + 39LLU] = 1909LLU; | |
23415 | 23564 | // arguments for call to add |
23416 | - stack[base + 39LLU] = stack[base + 9]/*fnrescount*/; | |
23417 | - stack[base + 40LLU] = stack[base + 28]/*sum*/; | |
23565 | + stack[base + 41LLU] = stack[base + 10]/*fnrescount*/; | |
23566 | + stack[base + 42LLU] = stack[base + 30]/*sum*/; | |
23418 | 23567 | // set stack-base & callee-address |
23419 | - base += 38LLU; | |
23568 | + base += 40LLU; | |
23420 | 23569 | label = 18446744073709551605LLU; // add |
23421 | 23570 | break; |
23422 | 23571 | } |
23423 | - case 1894LLU: // copy-back deleter (add to ProcCall) | |
23572 | + case 1908LLU: // copy-back deleter (add to ProcCall) | |
23424 | 23573 | { |
23425 | 23574 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
23426 | 23575 | // copy mutable arguments back from call to add |
23427 | - label = 1836LLU; // continue to roll stack | |
23576 | + label = 1850LLU; // continue to roll stack | |
23428 | 23577 | break; |
23429 | 23578 | } |
23430 | - case 1895LLU: // return from add to ProcCall | |
23579 | + case 1909LLU: // return from add to ProcCall | |
23431 | 23580 | { |
23432 | 23581 | // copy mutable arguments back from call to add |
23433 | 23582 | // copy back results provided by call to add |
23434 | - stack[base + 28] = stack[base + 38LLU]; | |
23583 | + stack[base + 30] = stack[base + 40LLU]; | |
23435 | 23584 | // call add from ProcCall |
23436 | - stack[base + 35LLU] = 1896LLU/*throw to this address*/; | |
23437 | - stack[base + 36LLU] = base; | |
23438 | - stack[base + 37LLU] = 1897LLU; | |
23585 | + stack[base + 37LLU] = 1910LLU/*throw to this address*/; | |
23586 | + stack[base + 38LLU] = base; | |
23587 | + stack[base + 39LLU] = 1911LLU; | |
23439 | 23588 | // arguments for call to add |
23440 | - stack[base + 39LLU] = stack[base + 10]/*fnargcount*/; | |
23441 | - stack[base + 40LLU] = stack[base + 28]/*sum*/; | |
23589 | + stack[base + 41LLU] = stack[base + 11]/*fnargcount*/; | |
23590 | + stack[base + 42LLU] = stack[base + 30]/*sum*/; | |
23442 | 23591 | // set stack-base & callee-address |
23443 | - base += 38LLU; | |
23592 | + base += 40LLU; | |
23444 | 23593 | label = 18446744073709551605LLU; // add |
23445 | 23594 | break; |
23446 | 23595 | } |
23447 | - case 1896LLU: // copy-back deleter (add to ProcCall) | |
23596 | + case 1910LLU: // copy-back deleter (add to ProcCall) | |
23448 | 23597 | { |
23449 | 23598 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
23450 | 23599 | // copy mutable arguments back from call to add |
23451 | - label = 1836LLU; // continue to roll stack | |
23600 | + label = 1850LLU; // continue to roll stack | |
23452 | 23601 | break; |
23453 | 23602 | } |
23454 | - case 1897LLU: // return from add to ProcCall | |
23603 | + case 1911LLU: // return from add to ProcCall | |
23455 | 23604 | { |
23456 | 23605 | // copy mutable arguments back from call to add |
23457 | 23606 | // copy back results provided by call to add |
23458 | - stack[base + 28] = stack[base + 38LLU]; | |
23607 | + stack[base + 30] = stack[base + 40LLU]; | |
23459 | 23608 | // call add from ProcCall |
23460 | - stack[base + 35LLU] = 1898LLU/*throw to this address*/; | |
23461 | - stack[base + 36LLU] = base; | |
23462 | - stack[base + 37LLU] = 1899LLU; | |
23609 | + stack[base + 37LLU] = 1912LLU/*throw to this address*/; | |
23610 | + stack[base + 38LLU] = base; | |
23611 | + stack[base + 39LLU] = 1913LLU; | |
23463 | 23612 | // arguments for call to add |
23464 | - stack[base + 39LLU] = stack[base + 26]/*cerescount*/; | |
23465 | - stack[base + 40LLU] = stack[base + 28]/*sum*/; | |
23613 | + stack[base + 41LLU] = stack[base + 28]/*cerescount*/; | |
23614 | + stack[base + 42LLU] = stack[base + 30]/*sum*/; | |
23466 | 23615 | // set stack-base & callee-address |
23467 | - base += 38LLU; | |
23616 | + base += 40LLU; | |
23468 | 23617 | label = 18446744073709551605LLU; // add |
23469 | 23618 | break; |
23470 | 23619 | } |
23471 | - case 1898LLU: // copy-back deleter (add to ProcCall) | |
23620 | + case 1912LLU: // copy-back deleter (add to ProcCall) | |
23472 | 23621 | { |
23473 | 23622 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
23474 | 23623 | // copy mutable arguments back from call to add |
23475 | - label = 1836LLU; // continue to roll stack | |
23624 | + label = 1850LLU; // continue to roll stack | |
23476 | 23625 | break; |
23477 | 23626 | } |
23478 | - case 1899LLU: // return from add to ProcCall | |
23627 | + case 1913LLU: // return from add to ProcCall | |
23479 | 23628 | { |
23480 | 23629 | // copy mutable arguments back from call to add |
23481 | 23630 | // copy back results provided by call to add |
23482 | - stack[base + 28] = stack[base + 38LLU]; | |
23631 | + stack[base + 30] = stack[base + 40LLU]; | |
23483 | 23632 | // call add from ProcCall |
23484 | - stack[base + 35LLU] = 1900LLU/*throw to this address*/; | |
23485 | - stack[base + 36LLU] = base; | |
23486 | - stack[base + 37LLU] = 1901LLU; | |
23633 | + stack[base + 37LLU] = 1914LLU/*throw to this address*/; | |
23634 | + stack[base + 38LLU] = base; | |
23635 | + stack[base + 39LLU] = 1915LLU; | |
23487 | 23636 | // arguments for call to add |
23488 | - stack[base + 39LLU] = stack[base + 30]/*index*/; | |
23489 | - stack[base + 40LLU] = stack[base + 28]/*sum*/; | |
23637 | + stack[base + 41LLU] = stack[base + 32]/*index*/; | |
23638 | + stack[base + 42LLU] = stack[base + 30]/*sum*/; | |
23490 | 23639 | // set stack-base & callee-address |
23491 | - base += 38LLU; | |
23640 | + base += 40LLU; | |
23492 | 23641 | label = 18446744073709551605LLU; // add |
23493 | 23642 | break; |
23494 | 23643 | } |
23495 | - case 1900LLU: // copy-back deleter (add to ProcCall) | |
23644 | + case 1914LLU: // copy-back deleter (add to ProcCall) | |
23496 | 23645 | { |
23497 | 23646 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
23498 | 23647 | // copy mutable arguments back from call to add |
23499 | - label = 1836LLU; // continue to roll stack | |
23648 | + label = 1850LLU; // continue to roll stack | |
23500 | 23649 | break; |
23501 | 23650 | } |
23502 | - case 1901LLU: // return from add to ProcCall | |
23651 | + case 1915LLU: // return from add to ProcCall | |
23503 | 23652 | { |
23504 | 23653 | // copy mutable arguments back from call to add |
23505 | 23654 | // copy back results provided by call to add |
23506 | - stack[base + 28] = stack[base + 38LLU]; | |
23655 | + stack[base + 30] = stack[base + 40LLU]; | |
23507 | 23656 | // call ParseToken from ProcCall |
23508 | - stack[base + 35LLU] = 1902LLU/*throw to this address*/; | |
23509 | - stack[base + 36LLU] = base; | |
23510 | - stack[base + 37LLU] = 1903LLU; | |
23657 | + stack[base + 37LLU] = 1916LLU/*throw to this address*/; | |
23658 | + stack[base + 38LLU] = base; | |
23659 | + stack[base + 39LLU] = 1917LLU; | |
23511 | 23660 | // arguments for call to ParseToken |
23512 | - stack[base + 40LLU] = stack[base + 13]/*lookahead*/; | |
23661 | + stack[base + 42LLU] = stack[base + 14]/*lookahead*/; | |
23513 | 23662 | // set stack-base & callee-address |
23514 | - base += 38LLU; | |
23663 | + base += 40LLU; | |
23515 | 23664 | label = 3LLU; // ParseToken |
23516 | 23665 | break; |
23517 | 23666 | } |
23518 | - case 1902LLU: // copy-back deleter (ParseToken to ProcCall) | |
23667 | + case 1916LLU: // copy-back deleter (ParseToken to ProcCall) | |
23519 | 23668 | { |
23520 | 23669 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (ParseToken to ProcCall)\n"); |
23521 | 23670 | // copy mutable arguments back from call to ParseToken |
23522 | - stack[base + 13]/*lookahead*/ = stack[base + 40LLU]; | |
23523 | - label = 1836LLU; // continue to roll stack | |
23671 | + stack[base + 14]/*lookahead*/ = stack[base + 42LLU]; | |
23672 | + label = 1850LLU; // continue to roll stack | |
23524 | 23673 | break; |
23525 | 23674 | } |
23526 | - case 1903LLU: // return from ParseToken to ProcCall | |
23675 | + case 1917LLU: // return from ParseToken to ProcCall | |
23527 | 23676 | { |
23528 | 23677 | // copy mutable arguments back from call to ParseToken |
23529 | - stack[base + 13]/*lookahead*/ = stack[base + 40LLU]; | |
23678 | + stack[base + 14]/*lookahead*/ = stack[base + 42LLU]; | |
23530 | 23679 | // copy back results provided by call to ParseToken |
23531 | - stack[base + 14] = stack[base + 38LLU]; | |
23532 | - stack[base + 15] = stack[base + 39LLU]; | |
23680 | + stack[base + 15] = stack[base + 40LLU]; | |
23681 | + stack[base + 16] = stack[base + 41LLU]; | |
23533 | 23682 | // call isncs from ProcCall |
23534 | - stack[base + 35LLU] = 1904LLU/*throw to this address*/; | |
23535 | - stack[base + 36LLU] = base; | |
23536 | - stack[base + 37LLU] = 1905LLU; | |
23683 | + stack[base + 37LLU] = 1918LLU/*throw to this address*/; | |
23684 | + stack[base + 38LLU] = base; | |
23685 | + stack[base + 39LLU] = 1919LLU; | |
23537 | 23686 | // arguments for call to isncs |
23538 | - stack[base + 39LLU] = stack[base + 14]/*variant*/; | |
23687 | + stack[base + 41LLU] = stack[base + 15]/*variant*/; | |
23539 | 23688 | // set stack-base & callee-address |
23540 | - base += 38LLU; | |
23689 | + base += 40LLU; | |
23541 | 23690 | label = 271LLU; // isncs |
23542 | 23691 | break; |
23543 | 23692 | } |
23544 | - case 1904LLU: // copy-back deleter (isncs to ProcCall) | |
23693 | + case 1918LLU: // copy-back deleter (isncs to ProcCall) | |
23545 | 23694 | { |
23546 | 23695 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (isncs to ProcCall)\n"); |
23547 | 23696 | // copy mutable arguments back from call to isncs |
23548 | - label = 1836LLU; // continue to roll stack | |
23697 | + label = 1850LLU; // continue to roll stack | |
23549 | 23698 | break; |
23550 | 23699 | } |
23551 | - case 1905LLU: // return from isncs to ProcCall | |
23700 | + case 1919LLU: // return from isncs to ProcCall | |
23552 | 23701 | { |
23553 | 23702 | // copy mutable arguments back from call to isncs |
23554 | 23703 | // copy back results provided by call to isncs |
23555 | - stack[base + 17] = stack[base + 38LLU]; | |
23556 | - if(!stack[base + 17]/*isequal*/) | |
23704 | + stack[base + 18] = stack[base + 40LLU]; | |
23705 | + if(!stack[base + 18]/*isequal*/) | |
23557 | 23706 | { |
23558 | - label = 1906LLU; // jump to alternative | |
23707 | + label = 1920LLU; // jump to alternative | |
23559 | 23708 | break; |
23560 | 23709 | } |
23561 | 23710 | |
23562 | 23711 | // consequent |
23563 | - if(/*param*/0 != ((uint64_t *)(stack[base + 33]/*param*/))[0]) | |
23712 | + if(/*param*/0 != ((uint64_t *)(stack[base + 35]/*param*/))[0]) | |
23564 | 23713 | { |
23565 | - label = 1909LLU; // jump to alternative | |
23714 | + label = 1923LLU; // jump to alternative | |
23566 | 23715 | break; |
23567 | 23716 | } |
23568 | 23717 | |
23569 | - /*typeid*/stack[base + 35] = ((uint64_t **)(stack[base + 33]/*param*/))[1][0]/*typeid*/; | |
23570 | - /*mutable*/stack[base + 36] = ((uint64_t **)(stack[base + 33]/*param*/))[1][1]/*mutable*/; | |
23718 | + /*typeid*/stack[base + 37] = ((uint64_t **)(stack[base + 35]/*param*/))[1][0]/*typeid*/; | |
23719 | + /*mutable*/stack[base + 38] = ((uint64_t **)(stack[base + 35]/*param*/))[1][1]/*mutable*/; | |
23571 | 23720 | |
23572 | 23721 | // case |
23573 | - if(/*typeid*/0 != ((uint64_t *)(stack[base + 35]/*typeid*/))[0]) | |
23722 | + if(/*typeid*/0 != ((uint64_t *)(stack[base + 37]/*typeid*/))[0]) | |
23574 | 23723 | { |
23575 | - label = 1911LLU; // jump to alternative | |
23724 | + label = 1925LLU; // jump to alternative | |
23576 | 23725 | break; |
23577 | 23726 | } |
23578 | 23727 | |
23579 | - /*expected*/stack[base + 37] = ((uint64_t **)(stack[base + 35]/*typeid*/))[1][0]/*type*/; | |
23580 | - /*paramname*/stack[base + 38] = ((uint64_t **)(stack[base + 35]/*typeid*/))[1][1]/*id*/; | |
23728 | + /*expected*/stack[base + 39] = ((uint64_t **)(stack[base + 37]/*typeid*/))[1][0]/*type*/; | |
23729 | + /*paramname*/stack[base + 40] = ((uint64_t **)(stack[base + 37]/*typeid*/))[1][1]/*id*/; | |
23581 | 23730 | |
23582 | 23731 | // case |
23583 | 23732 | // call mktypename from ProcCall |
23584 | - stack[base + 40LLU] = 1912LLU/*throw to this address*/; | |
23585 | - stack[base + 41LLU] = base; | |
23586 | - stack[base + 42LLU] = 1913LLU; | |
23733 | + stack[base + 42LLU] = 1926LLU/*throw to this address*/; | |
23734 | + stack[base + 43LLU] = base; | |
23735 | + stack[base + 44LLU] = 1927LLU; | |
23587 | 23736 | // arguments for call to mktypename |
23588 | - stack[base + 44LLU] = 881834713755418624LLU; | |
23737 | + stack[base + 46LLU] = 881834713755418624LLU; | |
23589 | 23738 | // set stack-base & callee-address |
23590 | - base += 43LLU; | |
23739 | + base += 45LLU; | |
23591 | 23740 | label = 299LLU; // mktypename |
23592 | 23741 | break; |
23593 | 23742 | } |
23594 | - case 1912LLU: // copy-back deleter (mktypename to ProcCall) | |
23743 | + case 1926LLU: // copy-back deleter (mktypename to ProcCall) | |
23595 | 23744 | { |
23596 | 23745 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (mktypename to ProcCall)\n"); |
23597 | 23746 | // copy mutable arguments back from call to mktypename |
23598 | - label = 1836LLU; // continue to roll stack | |
23747 | + label = 1850LLU; // continue to roll stack | |
23599 | 23748 | break; |
23600 | 23749 | } |
23601 | - case 1913LLU: // return from mktypename to ProcCall | |
23750 | + case 1927LLU: // return from mktypename to ProcCall | |
23602 | 23751 | { |
23603 | 23752 | // copy mutable arguments back from call to mktypename |
23604 | 23753 | // copy back results provided by call to mktypename |
23605 | - stack[base + 39] = stack[base + 43LLU]; | |
23754 | + stack[base + 41] = stack[base + 45LLU]; | |
23606 | 23755 | uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t)); |
23607 | 23756 | if(!newstack) |
23608 | 23757 | { |
23609 | - label = 1836LLU; // throw: begin to unroll stack | |
23758 | + label = 1850LLU; // throw: begin to unroll stack | |
23610 | 23759 | break; |
23611 | 23760 | } |
23612 | 23761 |
@@ -23613,12 +23762,12 @@ | ||
23613 | 23762 | newstack[15LLU] = 9876543210LLU; // overflow-marker |
23614 | 23763 | // call equtype from ProcCall |
23615 | 23764 | newstack[0] = (uint64_t)stack; // backup stack location |
23616 | - newstack[1] = 1914LLU; | |
23765 | + newstack[1] = 1928LLU; | |
23617 | 23766 | newstack[2] = base; |
23618 | - newstack[3] = 1915LLU; | |
23767 | + newstack[3] = 1929LLU; | |
23619 | 23768 | // arguments for call to equtype |
23620 | - newstack[5LLU] = stack[base + 39]/*type*/; | |
23621 | - newstack[6LLU] = stack[base + 37]/*expected*/; | |
23769 | + newstack[5LLU] = stack[base + 41]/*type*/; | |
23770 | + newstack[6LLU] = stack[base + 39]/*expected*/; | |
23622 | 23771 | stack = newstack; |
23623 | 23772 | // set stack-base & callee-address |
23624 | 23773 | base = 4/*deloffset*/; |
@@ -23625,7 +23774,7 @@ | ||
23625 | 23774 | label = 335LLU; // equtype |
23626 | 23775 | break; |
23627 | 23776 | } |
23628 | - case 1914LLU: // copy-back deleter (equtype to ProcCall) | |
23777 | + case 1928LLU: // copy-back deleter (equtype to ProcCall) | |
23629 | 23778 | { |
23630 | 23779 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (equtype to ProcCall)\n"); |
23631 | 23780 | uint64_t *oldstack = (uint64_t *)stack[0]; |
@@ -23637,15 +23786,15 @@ | ||
23637 | 23786 | } |
23638 | 23787 | Free(15LLU + 1, sizeof(uint64_t), stack); |
23639 | 23788 | stack = oldstack; |
23640 | - label = 1836LLU; // continue to unroll stack | |
23789 | + label = 1850LLU; // continue to unroll stack | |
23641 | 23790 | break; |
23642 | 23791 | } |
23643 | - case 1915LLU: // return from equtype to ProcCall | |
23792 | + case 1929LLU: // return from equtype to ProcCall | |
23644 | 23793 | { |
23645 | 23794 | uint64_t *oldstack = (uint64_t *)stack[0]; |
23646 | 23795 | // copy mutable arguments back from call to equtype |
23647 | 23796 | // copy back results provided by call to equtype |
23648 | - oldstack[base + 17] = stack[4LLU]; | |
23797 | + oldstack[base + 18] = stack[4LLU]; | |
23649 | 23798 | if(stack[15LLU] != 9876543210LLU) |
23650 | 23799 | { |
23651 | 23800 | fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to equtype)!"); |
@@ -23653,82 +23802,82 @@ | ||
23653 | 23802 | } |
23654 | 23803 | Free(15LLU + 1, sizeof(uint64_t), stack); |
23655 | 23804 | stack = oldstack; |
23656 | - if(!stack[base + 17]/*isequal*/) | |
23805 | + if(!stack[base + 18]/*isequal*/) | |
23657 | 23806 | { |
23658 | - label = 1916LLU; // jump to alternative | |
23807 | + label = 1930LLU; // jump to alternative | |
23659 | 23808 | break; |
23660 | 23809 | } |
23661 | 23810 | |
23662 | 23811 | // consequent |
23663 | - label = 1917LLU; // consequent complete | |
23812 | + label = 1931LLU; // consequent complete | |
23664 | 23813 | break; |
23665 | 23814 | } |
23666 | - case 1916LLU: // alternative | |
23815 | + case 1930LLU: // alternative | |
23667 | 23816 | { |
23668 | 23817 | fprintf(stderr, "%s", "in function "); |
23669 | 23818 | // call reportid from ProcCall |
23670 | - stack[base + 40LLU] = 1918LLU/*throw to this address*/; | |
23671 | - stack[base + 41LLU] = base; | |
23672 | - stack[base + 42LLU] = 1919LLU; | |
23819 | + stack[base + 42LLU] = 1932LLU/*throw to this address*/; | |
23820 | + stack[base + 43LLU] = base; | |
23821 | + stack[base + 44LLU] = 1933LLU; | |
23673 | 23822 | // arguments for call to reportid |
23674 | - stack[base + 43LLU] = stack[base + 7]/*fnid*/; | |
23823 | + stack[base + 45LLU] = stack[base + 8]/*fnid*/; | |
23675 | 23824 | // set stack-base & callee-address |
23676 | - base += 43LLU; | |
23825 | + base += 45LLU; | |
23677 | 23826 | label = 18446744073709551586LLU; // reportid |
23678 | 23827 | break; |
23679 | 23828 | } |
23680 | - case 1918LLU: // copy-back deleter (reportid to ProcCall) | |
23829 | + case 1932LLU: // copy-back deleter (reportid to ProcCall) | |
23681 | 23830 | { |
23682 | 23831 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
23683 | 23832 | // copy mutable arguments back from call to reportid |
23684 | - label = 1836LLU; // continue to roll stack | |
23833 | + label = 1850LLU; // continue to roll stack | |
23685 | 23834 | break; |
23686 | 23835 | } |
23687 | - case 1919LLU: // return from reportid to ProcCall | |
23836 | + case 1933LLU: // return from reportid to ProcCall | |
23688 | 23837 | { |
23689 | 23838 | // copy mutable arguments back from call to reportid |
23690 | 23839 | fprintf(stderr, "%s", " call to "); |
23691 | 23840 | // call reportid from ProcCall |
23692 | - stack[base + 40LLU] = 1920LLU/*throw to this address*/; | |
23693 | - stack[base + 41LLU] = base; | |
23694 | - stack[base + 42LLU] = 1921LLU; | |
23841 | + stack[base + 42LLU] = 1934LLU/*throw to this address*/; | |
23842 | + stack[base + 43LLU] = base; | |
23843 | + stack[base + 44LLU] = 1935LLU; | |
23695 | 23844 | // arguments for call to reportid |
23696 | - stack[base + 43LLU] = stack[base + 23]/*ceid*/; | |
23845 | + stack[base + 45LLU] = stack[base + 24]/*ceid*/; | |
23697 | 23846 | // set stack-base & callee-address |
23698 | - base += 43LLU; | |
23847 | + base += 45LLU; | |
23699 | 23848 | label = 18446744073709551586LLU; // reportid |
23700 | 23849 | break; |
23701 | 23850 | } |
23702 | - case 1920LLU: // copy-back deleter (reportid to ProcCall) | |
23851 | + case 1934LLU: // copy-back deleter (reportid to ProcCall) | |
23703 | 23852 | { |
23704 | 23853 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
23705 | 23854 | // copy mutable arguments back from call to reportid |
23706 | - label = 1836LLU; // continue to roll stack | |
23855 | + label = 1850LLU; // continue to roll stack | |
23707 | 23856 | break; |
23708 | 23857 | } |
23709 | - case 1921LLU: // return from reportid to ProcCall | |
23858 | + case 1935LLU: // return from reportid to ProcCall | |
23710 | 23859 | { |
23711 | 23860 | // copy mutable arguments back from call to reportid |
23712 | 23861 | fprintf(stderr, "%s", " at position "); |
23713 | 23862 | // call reportnr from ProcCall |
23714 | - stack[base + 40LLU] = 1922LLU/*throw to this address*/; | |
23715 | - stack[base + 41LLU] = base; | |
23716 | - stack[base + 42LLU] = 1923LLU; | |
23863 | + stack[base + 42LLU] = 1936LLU/*throw to this address*/; | |
23864 | + stack[base + 43LLU] = base; | |
23865 | + stack[base + 44LLU] = 1937LLU; | |
23717 | 23866 | // arguments for call to reportnr |
23718 | - stack[base + 43LLU] = stack[base + 30]/*index*/; | |
23867 | + stack[base + 45LLU] = stack[base + 32]/*index*/; | |
23719 | 23868 | // set stack-base & callee-address |
23720 | - base += 43LLU; | |
23869 | + base += 45LLU; | |
23721 | 23870 | label = 18446744073709551589LLU; // reportnr |
23722 | 23871 | break; |
23723 | 23872 | } |
23724 | - case 1922LLU: // copy-back deleter (reportnr to ProcCall) | |
23873 | + case 1936LLU: // copy-back deleter (reportnr to ProcCall) | |
23725 | 23874 | { |
23726 | 23875 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportnr to ProcCall)\n"); |
23727 | 23876 | // copy mutable arguments back from call to reportnr |
23728 | - label = 1836LLU; // continue to roll stack | |
23877 | + label = 1850LLU; // continue to roll stack | |
23729 | 23878 | break; |
23730 | 23879 | } |
23731 | - case 1923LLU: // return from reportnr to ProcCall | |
23880 | + case 1937LLU: // return from reportnr to ProcCall | |
23732 | 23881 | { |
23733 | 23882 | // copy mutable arguments back from call to reportnr |
23734 | 23883 | fprintf(stderr, "%s", " expected parameter of type "); |
@@ -23735,7 +23884,7 @@ | ||
23735 | 23884 | uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t)); |
23736 | 23885 | if(!newstack) |
23737 | 23886 | { |
23738 | - label = 1836LLU; // throw: begin to unroll stack | |
23887 | + label = 1850LLU; // throw: begin to unroll stack | |
23739 | 23888 | break; |
23740 | 23889 | } |
23741 | 23890 |
@@ -23742,11 +23891,11 @@ | ||
23742 | 23891 | newstack[10LLU] = 9876543210LLU; // overflow-marker |
23743 | 23892 | // call reporttype from ProcCall |
23744 | 23893 | newstack[0] = (uint64_t)stack; // backup stack location |
23745 | - newstack[1] = 1924LLU; | |
23894 | + newstack[1] = 1938LLU; | |
23746 | 23895 | newstack[2] = base; |
23747 | - newstack[3] = 1925LLU; | |
23896 | + newstack[3] = 1939LLU; | |
23748 | 23897 | // arguments for call to reporttype |
23749 | - newstack[4LLU] = stack[base + 37]/*expected*/; | |
23898 | + newstack[4LLU] = stack[base + 39]/*expected*/; | |
23750 | 23899 | stack = newstack; |
23751 | 23900 | // set stack-base & callee-address |
23752 | 23901 | base = 4/*deloffset*/; |
@@ -23753,7 +23902,7 @@ | ||
23753 | 23902 | label = 313LLU; // reporttype |
23754 | 23903 | break; |
23755 | 23904 | } |
23756 | - case 1924LLU: // copy-back deleter (reporttype to ProcCall) | |
23905 | + case 1938LLU: // copy-back deleter (reporttype to ProcCall) | |
23757 | 23906 | { |
23758 | 23907 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n"); |
23759 | 23908 | uint64_t *oldstack = (uint64_t *)stack[0]; |
@@ -23765,10 +23914,10 @@ | ||
23765 | 23914 | } |
23766 | 23915 | Free(10LLU + 1, sizeof(uint64_t), stack); |
23767 | 23916 | stack = oldstack; |
23768 | - label = 1836LLU; // continue to unroll stack | |
23917 | + label = 1850LLU; // continue to unroll stack | |
23769 | 23918 | break; |
23770 | 23919 | } |
23771 | - case 1925LLU: // return from reporttype to ProcCall | |
23920 | + case 1939LLU: // return from reporttype to ProcCall | |
23772 | 23921 | { |
23773 | 23922 | uint64_t *oldstack = (uint64_t *)stack[0]; |
23774 | 23923 | // copy mutable arguments back from call to reporttype |
@@ -23782,18 +23931,18 @@ | ||
23782 | 23931 | fprintf(stderr, "%s", " but found constant-argument of type u64"); |
23783 | 23932 | fprintf(stderr, "%s", "\n"); |
23784 | 23933 | exit(-1); |
23785 | - label = 1917LLU; // alternative complete | |
23934 | + label = 1931LLU; // alternative complete | |
23786 | 23935 | break; |
23787 | 23936 | } |
23788 | - case 1917LLU: // completed if-then-else | |
23937 | + case 1931LLU: // completed if-then-else | |
23789 | 23938 | { |
23790 | 23939 | |
23791 | - uint64_t *newstack = (uint64_t *)(stack[base + 39] - sizeof(uint64_t) * 4); | |
23940 | + uint64_t *newstack = (uint64_t *)(stack[base + 41] - sizeof(uint64_t) * 4); | |
23792 | 23941 | // call ~type from ProcCall |
23793 | 23942 | newstack[0] = (uint64_t)stack; // backup stack location |
23794 | 23943 | newstack[1] = 1234567890; |
23795 | 23944 | newstack[2] = base; |
23796 | - newstack[3] = 1926LLU; | |
23945 | + newstack[3] = 1940LLU; | |
23797 | 23946 | stack = newstack; |
23798 | 23947 | // set stack-base & callee-address |
23799 | 23948 | base = 4/*deloffset*/; |
@@ -23800,27 +23949,27 @@ | ||
23800 | 23949 | label = 295LLU; // ~type |
23801 | 23950 | break; |
23802 | 23951 | } |
23803 | - case 1926LLU: // return from ~type to ProcCall | |
23952 | + case 1940LLU: // return from ~type to ProcCall | |
23804 | 23953 | { |
23805 | 23954 | stack = (uint64_t *)stack[0]; |
23806 | 23955 | // releasing toplevel container |
23807 | - Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 39] - sizeof(uint64_t) * 4)); | |
23956 | + Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 41] - sizeof(uint64_t) * 4)); | |
23808 | 23957 | |
23809 | - ((uint64_t **)(stack[base + 35]))[1][1] = stack[base + 38]; | |
23810 | - ((uint64_t **)(stack[base + 35]))[1][0] = stack[base + 37]; | |
23811 | - label = 1910LLU; // case complete | |
23958 | + ((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40]; | |
23959 | + ((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39]; | |
23960 | + label = 1924LLU; // case complete | |
23812 | 23961 | break; |
23813 | 23962 | } |
23814 | - case 1911LLU: // try next case | |
23963 | + case 1925LLU: // try next case | |
23815 | 23964 | { |
23816 | 23965 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
23817 | 23966 | exit(-1); |
23818 | 23967 | } |
23819 | - case 1910LLU: // completed switch | |
23968 | + case 1924LLU: // completed switch | |
23820 | 23969 | { |
23821 | - if(!stack[base + 36]/*mutable*/) | |
23970 | + if(!stack[base + 38]/*mutable*/) | |
23822 | 23971 | { |
23823 | - label = 1927LLU; // jump to alternative | |
23972 | + label = 1941LLU; // jump to alternative | |
23824 | 23973 | break; |
23825 | 23974 | } |
23826 | 23975 |
@@ -23827,274 +23976,274 @@ | ||
23827 | 23976 | // consequent |
23828 | 23977 | fprintf(stderr, "%s", "in function "); |
23829 | 23978 | // call reportid from ProcCall |
23830 | - stack[base + 37LLU] = 1929LLU/*throw to this address*/; | |
23831 | - stack[base + 38LLU] = base; | |
23832 | - stack[base + 39LLU] = 1930LLU; | |
23979 | + stack[base + 39LLU] = 1943LLU/*throw to this address*/; | |
23980 | + stack[base + 40LLU] = base; | |
23981 | + stack[base + 41LLU] = 1944LLU; | |
23833 | 23982 | // arguments for call to reportid |
23834 | - stack[base + 40LLU] = stack[base + 7]/*fnid*/; | |
23983 | + stack[base + 42LLU] = stack[base + 8]/*fnid*/; | |
23835 | 23984 | // set stack-base & callee-address |
23836 | - base += 40LLU; | |
23985 | + base += 42LLU; | |
23837 | 23986 | label = 18446744073709551586LLU; // reportid |
23838 | 23987 | break; |
23839 | 23988 | } |
23840 | - case 1929LLU: // copy-back deleter (reportid to ProcCall) | |
23989 | + case 1943LLU: // copy-back deleter (reportid to ProcCall) | |
23841 | 23990 | { |
23842 | 23991 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
23843 | 23992 | // copy mutable arguments back from call to reportid |
23844 | - label = 1836LLU; // continue to roll stack | |
23993 | + label = 1850LLU; // continue to roll stack | |
23845 | 23994 | break; |
23846 | 23995 | } |
23847 | - case 1930LLU: // return from reportid to ProcCall | |
23996 | + case 1944LLU: // return from reportid to ProcCall | |
23848 | 23997 | { |
23849 | 23998 | // copy mutable arguments back from call to reportid |
23850 | 23999 | fprintf(stderr, "%s", ", calling "); |
23851 | 24000 | // call reportid from ProcCall |
23852 | - stack[base + 37LLU] = 1931LLU/*throw to this address*/; | |
23853 | - stack[base + 38LLU] = base; | |
23854 | - stack[base + 39LLU] = 1932LLU; | |
24001 | + stack[base + 39LLU] = 1945LLU/*throw to this address*/; | |
24002 | + stack[base + 40LLU] = base; | |
24003 | + stack[base + 41LLU] = 1946LLU; | |
23855 | 24004 | // arguments for call to reportid |
23856 | - stack[base + 40LLU] = stack[base + 23]/*ceid*/; | |
24005 | + stack[base + 42LLU] = stack[base + 24]/*ceid*/; | |
23857 | 24006 | // set stack-base & callee-address |
23858 | - base += 40LLU; | |
24007 | + base += 42LLU; | |
23859 | 24008 | label = 18446744073709551586LLU; // reportid |
23860 | 24009 | break; |
23861 | 24010 | } |
23862 | - case 1931LLU: // copy-back deleter (reportid to ProcCall) | |
24011 | + case 1945LLU: // copy-back deleter (reportid to ProcCall) | |
23863 | 24012 | { |
23864 | 24013 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
23865 | 24014 | // copy mutable arguments back from call to reportid |
23866 | - label = 1836LLU; // continue to roll stack | |
24015 | + label = 1850LLU; // continue to roll stack | |
23867 | 24016 | break; |
23868 | 24017 | } |
23869 | - case 1932LLU: // return from reportid to ProcCall | |
24018 | + case 1946LLU: // return from reportid to ProcCall | |
23870 | 24019 | { |
23871 | 24020 | // copy mutable arguments back from call to reportid |
23872 | 24021 | fprintf(stderr, "%s", ": "); |
23873 | 24022 | fprintf(stderr, "%s", "can't use constant argument "); |
23874 | 24023 | // call printnr from ProcCall |
23875 | - stack[base + 37LLU] = 1933LLU/*throw to this address*/; | |
23876 | - stack[base + 38LLU] = base; | |
23877 | - stack[base + 39LLU] = 1934LLU; | |
24024 | + stack[base + 39LLU] = 1947LLU/*throw to this address*/; | |
24025 | + stack[base + 40LLU] = base; | |
24026 | + stack[base + 41LLU] = 1948LLU; | |
23878 | 24027 | // arguments for call to printnr |
23879 | - stack[base + 40LLU] = stack[base + 15]/*content*/; | |
24028 | + stack[base + 42LLU] = stack[base + 16]/*content*/; | |
23880 | 24029 | // set stack-base & callee-address |
23881 | - base += 40LLU; | |
24030 | + base += 42LLU; | |
23882 | 24031 | label = 18446744073709551590LLU; // printnr |
23883 | 24032 | break; |
23884 | 24033 | } |
23885 | - case 1933LLU: // copy-back deleter (printnr to ProcCall) | |
24034 | + case 1947LLU: // copy-back deleter (printnr to ProcCall) | |
23886 | 24035 | { |
23887 | 24036 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n"); |
23888 | 24037 | // copy mutable arguments back from call to printnr |
23889 | - label = 1836LLU; // continue to roll stack | |
24038 | + label = 1850LLU; // continue to roll stack | |
23890 | 24039 | break; |
23891 | 24040 | } |
23892 | - case 1934LLU: // return from printnr to ProcCall | |
24041 | + case 1948LLU: // return from printnr to ProcCall | |
23893 | 24042 | { |
23894 | 24043 | // copy mutable arguments back from call to printnr |
23895 | 24044 | printf("%s", " for mutable parameter "); |
23896 | 24045 | // call reportti from ProcCall |
23897 | - stack[base + 37LLU] = 1935LLU/*throw to this address*/; | |
23898 | - stack[base + 38LLU] = base; | |
23899 | - stack[base + 39LLU] = 1936LLU; | |
24046 | + stack[base + 39LLU] = 1949LLU/*throw to this address*/; | |
24047 | + stack[base + 40LLU] = base; | |
24048 | + stack[base + 41LLU] = 1950LLU; | |
23900 | 24049 | // arguments for call to reportti |
23901 | - stack[base + 40LLU] = stack[base + 35]/*typeid*/; | |
24050 | + stack[base + 42LLU] = stack[base + 37]/*typeid*/; | |
23902 | 24051 | // set stack-base & callee-address |
23903 | - base += 40LLU; | |
24052 | + base += 42LLU; | |
23904 | 24053 | label = 360LLU; // reportti |
23905 | 24054 | break; |
23906 | 24055 | } |
23907 | - case 1935LLU: // copy-back deleter (reportti to ProcCall) | |
24056 | + case 1949LLU: // copy-back deleter (reportti to ProcCall) | |
23908 | 24057 | { |
23909 | 24058 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportti to ProcCall)\n"); |
23910 | 24059 | // copy mutable arguments back from call to reportti |
23911 | - label = 1836LLU; // continue to roll stack | |
24060 | + label = 1850LLU; // continue to roll stack | |
23912 | 24061 | break; |
23913 | 24062 | } |
23914 | - case 1936LLU: // return from reportti to ProcCall | |
24063 | + case 1950LLU: // return from reportti to ProcCall | |
23915 | 24064 | { |
23916 | 24065 | // copy mutable arguments back from call to reportti |
23917 | 24066 | fprintf(stderr, "%s", "\n"); |
23918 | 24067 | exit(-1); |
23919 | - label = 1928LLU; // consequent complete | |
24068 | + label = 1942LLU; // consequent complete | |
23920 | 24069 | break; |
23921 | 24070 | } |
23922 | - case 1927LLU: // alternative | |
24071 | + case 1941LLU: // alternative | |
23923 | 24072 | { |
23924 | - label = 1928LLU; // alternative complete | |
24073 | + label = 1942LLU; // alternative complete | |
23925 | 24074 | break; |
23926 | 24075 | } |
23927 | - case 1928LLU: // completed if-then-else | |
24076 | + case 1942LLU: // completed if-then-else | |
23928 | 24077 | { |
23929 | - ((uint64_t **)(stack[base + 33]))[1][1] = stack[base + 36]; | |
23930 | - ((uint64_t **)(stack[base + 33]))[1][0] = stack[base + 35]; | |
23931 | - label = 1908LLU; // case complete | |
24078 | + ((uint64_t **)(stack[base + 35]))[1][1] = stack[base + 38]; | |
24079 | + ((uint64_t **)(stack[base + 35]))[1][0] = stack[base + 37]; | |
24080 | + label = 1922LLU; // case complete | |
23932 | 24081 | break; |
23933 | 24082 | } |
23934 | - case 1909LLU: // try next case | |
24083 | + case 1923LLU: // try next case | |
23935 | 24084 | { |
23936 | 24085 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
23937 | 24086 | exit(-1); |
23938 | 24087 | } |
23939 | - case 1908LLU: // completed switch | |
24088 | + case 1922LLU: // completed switch | |
23940 | 24089 | { |
23941 | 24090 | printf("%s", "\n stack[base + "); |
23942 | 24091 | // call printnr from ProcCall |
23943 | - stack[base + 35LLU] = 1937LLU/*throw to this address*/; | |
23944 | - stack[base + 36LLU] = base; | |
23945 | - stack[base + 37LLU] = 1938LLU; | |
24092 | + stack[base + 37LLU] = 1951LLU/*throw to this address*/; | |
24093 | + stack[base + 38LLU] = base; | |
24094 | + stack[base + 39LLU] = 1952LLU; | |
23946 | 24095 | // arguments for call to printnr |
23947 | - stack[base + 38LLU] = stack[base + 28]/*sum*/; | |
24096 | + stack[base + 40LLU] = stack[base + 30]/*sum*/; | |
23948 | 24097 | // set stack-base & callee-address |
23949 | - base += 38LLU; | |
24098 | + base += 40LLU; | |
23950 | 24099 | label = 18446744073709551590LLU; // printnr |
23951 | 24100 | break; |
23952 | 24101 | } |
23953 | - case 1937LLU: // copy-back deleter (printnr to ProcCall) | |
24102 | + case 1951LLU: // copy-back deleter (printnr to ProcCall) | |
23954 | 24103 | { |
23955 | 24104 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n"); |
23956 | 24105 | // copy mutable arguments back from call to printnr |
23957 | - label = 1836LLU; // continue to roll stack | |
24106 | + label = 1850LLU; // continue to roll stack | |
23958 | 24107 | break; |
23959 | 24108 | } |
23960 | - case 1938LLU: // return from printnr to ProcCall | |
24109 | + case 1952LLU: // return from printnr to ProcCall | |
23961 | 24110 | { |
23962 | 24111 | // copy mutable arguments back from call to printnr |
23963 | 24112 | printf("%s", "LLU] = "); |
23964 | 24113 | // call printnr from ProcCall |
23965 | - stack[base + 35LLU] = 1939LLU/*throw to this address*/; | |
23966 | - stack[base + 36LLU] = base; | |
23967 | - stack[base + 37LLU] = 1940LLU; | |
24114 | + stack[base + 37LLU] = 1953LLU/*throw to this address*/; | |
24115 | + stack[base + 38LLU] = base; | |
24116 | + stack[base + 39LLU] = 1954LLU; | |
23968 | 24117 | // arguments for call to printnr |
23969 | - stack[base + 38LLU] = stack[base + 15]/*content*/; | |
24118 | + stack[base + 40LLU] = stack[base + 16]/*content*/; | |
23970 | 24119 | // set stack-base & callee-address |
23971 | - base += 38LLU; | |
24120 | + base += 40LLU; | |
23972 | 24121 | label = 18446744073709551590LLU; // printnr |
23973 | 24122 | break; |
23974 | 24123 | } |
23975 | - case 1939LLU: // copy-back deleter (printnr to ProcCall) | |
24124 | + case 1953LLU: // copy-back deleter (printnr to ProcCall) | |
23976 | 24125 | { |
23977 | 24126 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n"); |
23978 | 24127 | // copy mutable arguments back from call to printnr |
23979 | - label = 1836LLU; // continue to roll stack | |
24128 | + label = 1850LLU; // continue to roll stack | |
23980 | 24129 | break; |
23981 | 24130 | } |
23982 | - case 1940LLU: // return from printnr to ProcCall | |
24131 | + case 1954LLU: // return from printnr to ProcCall | |
23983 | 24132 | { |
23984 | 24133 | // copy mutable arguments back from call to printnr |
23985 | 24134 | printf("%s", "LLU;"); |
23986 | - label = 1907LLU; // consequent complete | |
24135 | + label = 1921LLU; // consequent complete | |
23987 | 24136 | break; |
23988 | 24137 | } |
23989 | - case 1906LLU: // alternative | |
24138 | + case 1920LLU: // alternative | |
23990 | 24139 | { |
23991 | 24140 | // call equ from ProcCall |
23992 | - stack[base + 35LLU] = 1941LLU/*throw to this address*/; | |
23993 | - stack[base + 36LLU] = base; | |
23994 | - stack[base + 37LLU] = 1942LLU; | |
24141 | + stack[base + 37LLU] = 1955LLU/*throw to this address*/; | |
24142 | + stack[base + 38LLU] = base; | |
24143 | + stack[base + 39LLU] = 1956LLU; | |
23995 | 24144 | // arguments for call to equ |
23996 | - stack[base + 39LLU] = stack[base + 14]/*variant*/; | |
23997 | - stack[base + 40LLU] = 4LLU; | |
24145 | + stack[base + 41LLU] = stack[base + 15]/*variant*/; | |
24146 | + stack[base + 42LLU] = 4LLU; | |
23998 | 24147 | // set stack-base & callee-address |
23999 | - base += 38LLU; | |
24148 | + base += 40LLU; | |
24000 | 24149 | label = 18446744073709551600LLU; // equ |
24001 | 24150 | break; |
24002 | 24151 | } |
24003 | - case 1941LLU: // copy-back deleter (equ to ProcCall) | |
24152 | + case 1955LLU: // copy-back deleter (equ to ProcCall) | |
24004 | 24153 | { |
24005 | 24154 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (equ to ProcCall)\n"); |
24006 | 24155 | // copy mutable arguments back from call to equ |
24007 | - label = 1836LLU; // continue to roll stack | |
24156 | + label = 1850LLU; // continue to roll stack | |
24008 | 24157 | break; |
24009 | 24158 | } |
24010 | - case 1942LLU: // return from equ to ProcCall | |
24159 | + case 1956LLU: // return from equ to ProcCall | |
24011 | 24160 | { |
24012 | 24161 | // copy mutable arguments back from call to equ |
24013 | 24162 | // copy back results provided by call to equ |
24014 | - stack[base + 17] = stack[base + 38LLU]; | |
24015 | - if(!stack[base + 17]/*isequal*/) | |
24163 | + stack[base + 18] = stack[base + 40LLU]; | |
24164 | + if(!stack[base + 18]/*isequal*/) | |
24016 | 24165 | { |
24017 | - label = 1943LLU; // jump to alternative | |
24166 | + label = 1957LLU; // jump to alternative | |
24018 | 24167 | break; |
24019 | 24168 | } |
24020 | 24169 | |
24021 | 24170 | // consequent |
24022 | - if(/*param*/0 != ((uint64_t *)(stack[base + 33]/*param*/))[0]) | |
24171 | + if(/*param*/0 != ((uint64_t *)(stack[base + 35]/*param*/))[0]) | |
24023 | 24172 | { |
24024 | - label = 1946LLU; // jump to alternative | |
24173 | + label = 1960LLU; // jump to alternative | |
24025 | 24174 | break; |
24026 | 24175 | } |
24027 | 24176 | |
24028 | - /*typeid*/stack[base + 35] = ((uint64_t **)(stack[base + 33]/*param*/))[1][0]/*typeid*/; | |
24029 | - /*mutable*/stack[base + 36] = ((uint64_t **)(stack[base + 33]/*param*/))[1][1]/*mutable*/; | |
24177 | + /*typeid*/stack[base + 37] = ((uint64_t **)(stack[base + 35]/*param*/))[1][0]/*typeid*/; | |
24178 | + /*mutable*/stack[base + 38] = ((uint64_t **)(stack[base + 35]/*param*/))[1][1]/*mutable*/; | |
24030 | 24179 | |
24031 | 24180 | // case |
24032 | - if(/*typeid*/0 != ((uint64_t *)(stack[base + 35]/*typeid*/))[0]) | |
24181 | + if(/*typeid*/0 != ((uint64_t *)(stack[base + 37]/*typeid*/))[0]) | |
24033 | 24182 | { |
24034 | - label = 1948LLU; // jump to alternative | |
24183 | + label = 1962LLU; // jump to alternative | |
24035 | 24184 | break; |
24036 | 24185 | } |
24037 | 24186 | |
24038 | - /*expected*/stack[base + 37] = ((uint64_t **)(stack[base + 35]/*typeid*/))[1][0]/*type*/; | |
24039 | - /*paramname*/stack[base + 38] = ((uint64_t **)(stack[base + 35]/*typeid*/))[1][1]/*id*/; | |
24187 | + /*expected*/stack[base + 39] = ((uint64_t **)(stack[base + 37]/*typeid*/))[1][0]/*type*/; | |
24188 | + /*paramname*/stack[base + 40] = ((uint64_t **)(stack[base + 37]/*typeid*/))[1][1]/*id*/; | |
24040 | 24189 | |
24041 | 24190 | // case |
24042 | 24191 | // call getlettype from ProcCall |
24043 | - stack[base + 40LLU] = 1949LLU/*throw to this address*/; | |
24044 | - stack[base + 41LLU] = base; | |
24045 | - stack[base + 42LLU] = 1950LLU; | |
24192 | + stack[base + 42LLU] = 1963LLU/*throw to this address*/; | |
24193 | + stack[base + 43LLU] = base; | |
24194 | + stack[base + 44LLU] = 1964LLU; | |
24046 | 24195 | // arguments for call to getlettype |
24047 | - stack[base + 44LLU] = stack[base + 7]/*fnid*/; | |
24048 | - stack[base + 45LLU] = stack[base + 15]/*content*/; | |
24049 | - stack[base + 46LLU] = stack[base + 2]/*scopes*/; | |
24050 | - stack[base + 47LLU] = stack[base + 3]/*scope*/; | |
24196 | + stack[base + 46LLU] = stack[base + 8]/*fnid*/; | |
24197 | + stack[base + 47LLU] = stack[base + 16]/*content*/; | |
24198 | + stack[base + 48LLU] = stack[base + 2]/*scopes*/; | |
24199 | + stack[base + 49LLU] = stack[base + 3]/*scope*/; | |
24051 | 24200 | // set stack-base & callee-address |
24052 | - base += 43LLU; | |
24201 | + base += 45LLU; | |
24053 | 24202 | label = 618LLU; // getlettype |
24054 | 24203 | break; |
24055 | 24204 | } |
24056 | - case 1949LLU: // copy-back deleter (getlettype to ProcCall) | |
24205 | + case 1963LLU: // copy-back deleter (getlettype to ProcCall) | |
24057 | 24206 | { |
24058 | 24207 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (getlettype to ProcCall)\n"); |
24059 | 24208 | // copy mutable arguments back from call to getlettype |
24060 | - label = 1836LLU; // continue to roll stack | |
24209 | + label = 1850LLU; // continue to roll stack | |
24061 | 24210 | break; |
24062 | 24211 | } |
24063 | - case 1950LLU: // return from getlettype to ProcCall | |
24212 | + case 1964LLU: // return from getlettype to ProcCall | |
24064 | 24213 | { |
24065 | 24214 | // copy mutable arguments back from call to getlettype |
24066 | 24215 | // copy back results provided by call to getlettype |
24067 | - stack[base + 39] = stack[base + 43LLU]; | |
24216 | + stack[base + 41] = stack[base + 45LLU]; | |
24068 | 24217 | // call findletmut from ProcCall |
24069 | - stack[base + 41LLU] = 1951LLU/*throw to this address*/; | |
24070 | - stack[base + 42LLU] = base; | |
24071 | - stack[base + 43LLU] = 1952LLU; | |
24218 | + stack[base + 43LLU] = 1965LLU/*throw to this address*/; | |
24219 | + stack[base + 44LLU] = base; | |
24220 | + stack[base + 45LLU] = 1966LLU; | |
24072 | 24221 | // arguments for call to findletmut |
24073 | - stack[base + 45LLU] = stack[base + 7]/*fnid*/; | |
24074 | - stack[base + 46LLU] = stack[base + 15]/*content*/; | |
24075 | - stack[base + 47LLU] = stack[base + 2]/*scopes*/; | |
24076 | - stack[base + 48LLU] = stack[base + 3]/*scope*/; | |
24222 | + stack[base + 47LLU] = stack[base + 8]/*fnid*/; | |
24223 | + stack[base + 48LLU] = stack[base + 16]/*content*/; | |
24224 | + stack[base + 49LLU] = stack[base + 2]/*scopes*/; | |
24225 | + stack[base + 50LLU] = stack[base + 3]/*scope*/; | |
24077 | 24226 | // set stack-base & callee-address |
24078 | - base += 44LLU; | |
24227 | + base += 46LLU; | |
24079 | 24228 | label = 636LLU; // findletmut |
24080 | 24229 | break; |
24081 | 24230 | } |
24082 | - case 1951LLU: // copy-back deleter (findletmut to ProcCall) | |
24231 | + case 1965LLU: // copy-back deleter (findletmut to ProcCall) | |
24083 | 24232 | { |
24084 | 24233 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (findletmut to ProcCall)\n"); |
24085 | 24234 | // copy mutable arguments back from call to findletmut |
24086 | - label = 1836LLU; // continue to roll stack | |
24235 | + label = 1850LLU; // continue to roll stack | |
24087 | 24236 | break; |
24088 | 24237 | } |
24089 | - case 1952LLU: // return from findletmut to ProcCall | |
24238 | + case 1966LLU: // return from findletmut to ProcCall | |
24090 | 24239 | { |
24091 | 24240 | // copy mutable arguments back from call to findletmut |
24092 | 24241 | // copy back results provided by call to findletmut |
24093 | - stack[base + 40] = stack[base + 44LLU]; | |
24242 | + stack[base + 42] = stack[base + 46LLU]; | |
24094 | 24243 | uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t)); |
24095 | 24244 | if(!newstack) |
24096 | 24245 | { |
24097 | - label = 1836LLU; // throw: begin to unroll stack | |
24246 | + label = 1850LLU; // throw: begin to unroll stack | |
24098 | 24247 | break; |
24099 | 24248 | } |
24100 | 24249 |
@@ -24101,12 +24250,12 @@ | ||
24101 | 24250 | newstack[15LLU] = 9876543210LLU; // overflow-marker |
24102 | 24251 | // call equtype from ProcCall |
24103 | 24252 | newstack[0] = (uint64_t)stack; // backup stack location |
24104 | - newstack[1] = 1953LLU; | |
24253 | + newstack[1] = 1967LLU; | |
24105 | 24254 | newstack[2] = base; |
24106 | - newstack[3] = 1954LLU; | |
24255 | + newstack[3] = 1968LLU; | |
24107 | 24256 | // arguments for call to equtype |
24108 | - newstack[5LLU] = stack[base + 39]/*type*/; | |
24109 | - newstack[6LLU] = stack[base + 37]/*expected*/; | |
24257 | + newstack[5LLU] = stack[base + 41]/*type*/; | |
24258 | + newstack[6LLU] = stack[base + 39]/*expected*/; | |
24110 | 24259 | stack = newstack; |
24111 | 24260 | // set stack-base & callee-address |
24112 | 24261 | base = 4/*deloffset*/; |
@@ -24113,7 +24262,7 @@ | ||
24113 | 24262 | label = 335LLU; // equtype |
24114 | 24263 | break; |
24115 | 24264 | } |
24116 | - case 1953LLU: // copy-back deleter (equtype to ProcCall) | |
24265 | + case 1967LLU: // copy-back deleter (equtype to ProcCall) | |
24117 | 24266 | { |
24118 | 24267 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (equtype to ProcCall)\n"); |
24119 | 24268 | uint64_t *oldstack = (uint64_t *)stack[0]; |
@@ -24125,15 +24274,15 @@ | ||
24125 | 24274 | } |
24126 | 24275 | Free(15LLU + 1, sizeof(uint64_t), stack); |
24127 | 24276 | stack = oldstack; |
24128 | - label = 1836LLU; // continue to unroll stack | |
24277 | + label = 1850LLU; // continue to unroll stack | |
24129 | 24278 | break; |
24130 | 24279 | } |
24131 | - case 1954LLU: // return from equtype to ProcCall | |
24280 | + case 1968LLU: // return from equtype to ProcCall | |
24132 | 24281 | { |
24133 | 24282 | uint64_t *oldstack = (uint64_t *)stack[0]; |
24134 | 24283 | // copy mutable arguments back from call to equtype |
24135 | 24284 | // copy back results provided by call to equtype |
24136 | - oldstack[base + 17] = stack[4LLU]; | |
24285 | + oldstack[base + 18] = stack[4LLU]; | |
24137 | 24286 | if(stack[15LLU] != 9876543210LLU) |
24138 | 24287 | { |
24139 | 24288 | fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to equtype)!"); |
@@ -24141,82 +24290,82 @@ | ||
24141 | 24290 | } |
24142 | 24291 | Free(15LLU + 1, sizeof(uint64_t), stack); |
24143 | 24292 | stack = oldstack; |
24144 | - if(!stack[base + 17]/*isequal*/) | |
24293 | + if(!stack[base + 18]/*isequal*/) | |
24145 | 24294 | { |
24146 | - label = 1955LLU; // jump to alternative | |
24295 | + label = 1969LLU; // jump to alternative | |
24147 | 24296 | break; |
24148 | 24297 | } |
24149 | 24298 | |
24150 | 24299 | // consequent |
24151 | - label = 1956LLU; // consequent complete | |
24300 | + label = 1970LLU; // consequent complete | |
24152 | 24301 | break; |
24153 | 24302 | } |
24154 | - case 1955LLU: // alternative | |
24303 | + case 1969LLU: // alternative | |
24155 | 24304 | { |
24156 | 24305 | fprintf(stderr, "%s", "in function "); |
24157 | 24306 | // call reportid from ProcCall |
24158 | - stack[base + 41LLU] = 1957LLU/*throw to this address*/; | |
24159 | - stack[base + 42LLU] = base; | |
24160 | - stack[base + 43LLU] = 1958LLU; | |
24307 | + stack[base + 43LLU] = 1971LLU/*throw to this address*/; | |
24308 | + stack[base + 44LLU] = base; | |
24309 | + stack[base + 45LLU] = 1972LLU; | |
24161 | 24310 | // arguments for call to reportid |
24162 | - stack[base + 44LLU] = stack[base + 7]/*fnid*/; | |
24311 | + stack[base + 46LLU] = stack[base + 8]/*fnid*/; | |
24163 | 24312 | // set stack-base & callee-address |
24164 | - base += 44LLU; | |
24313 | + base += 46LLU; | |
24165 | 24314 | label = 18446744073709551586LLU; // reportid |
24166 | 24315 | break; |
24167 | 24316 | } |
24168 | - case 1957LLU: // copy-back deleter (reportid to ProcCall) | |
24317 | + case 1971LLU: // copy-back deleter (reportid to ProcCall) | |
24169 | 24318 | { |
24170 | 24319 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
24171 | 24320 | // copy mutable arguments back from call to reportid |
24172 | - label = 1836LLU; // continue to roll stack | |
24321 | + label = 1850LLU; // continue to roll stack | |
24173 | 24322 | break; |
24174 | 24323 | } |
24175 | - case 1958LLU: // return from reportid to ProcCall | |
24324 | + case 1972LLU: // return from reportid to ProcCall | |
24176 | 24325 | { |
24177 | 24326 | // copy mutable arguments back from call to reportid |
24178 | 24327 | fprintf(stderr, "%s", " call to "); |
24179 | 24328 | // call reportid from ProcCall |
24180 | - stack[base + 41LLU] = 1959LLU/*throw to this address*/; | |
24181 | - stack[base + 42LLU] = base; | |
24182 | - stack[base + 43LLU] = 1960LLU; | |
24329 | + stack[base + 43LLU] = 1973LLU/*throw to this address*/; | |
24330 | + stack[base + 44LLU] = base; | |
24331 | + stack[base + 45LLU] = 1974LLU; | |
24183 | 24332 | // arguments for call to reportid |
24184 | - stack[base + 44LLU] = stack[base + 23]/*ceid*/; | |
24333 | + stack[base + 46LLU] = stack[base + 24]/*ceid*/; | |
24185 | 24334 | // set stack-base & callee-address |
24186 | - base += 44LLU; | |
24335 | + base += 46LLU; | |
24187 | 24336 | label = 18446744073709551586LLU; // reportid |
24188 | 24337 | break; |
24189 | 24338 | } |
24190 | - case 1959LLU: // copy-back deleter (reportid to ProcCall) | |
24339 | + case 1973LLU: // copy-back deleter (reportid to ProcCall) | |
24191 | 24340 | { |
24192 | 24341 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
24193 | 24342 | // copy mutable arguments back from call to reportid |
24194 | - label = 1836LLU; // continue to roll stack | |
24343 | + label = 1850LLU; // continue to roll stack | |
24195 | 24344 | break; |
24196 | 24345 | } |
24197 | - case 1960LLU: // return from reportid to ProcCall | |
24346 | + case 1974LLU: // return from reportid to ProcCall | |
24198 | 24347 | { |
24199 | 24348 | // copy mutable arguments back from call to reportid |
24200 | 24349 | fprintf(stderr, "%s", " at position "); |
24201 | 24350 | // call reportnr from ProcCall |
24202 | - stack[base + 41LLU] = 1961LLU/*throw to this address*/; | |
24203 | - stack[base + 42LLU] = base; | |
24204 | - stack[base + 43LLU] = 1962LLU; | |
24351 | + stack[base + 43LLU] = 1975LLU/*throw to this address*/; | |
24352 | + stack[base + 44LLU] = base; | |
24353 | + stack[base + 45LLU] = 1976LLU; | |
24205 | 24354 | // arguments for call to reportnr |
24206 | - stack[base + 44LLU] = stack[base + 30]/*index*/; | |
24355 | + stack[base + 46LLU] = stack[base + 32]/*index*/; | |
24207 | 24356 | // set stack-base & callee-address |
24208 | - base += 44LLU; | |
24357 | + base += 46LLU; | |
24209 | 24358 | label = 18446744073709551589LLU; // reportnr |
24210 | 24359 | break; |
24211 | 24360 | } |
24212 | - case 1961LLU: // copy-back deleter (reportnr to ProcCall) | |
24361 | + case 1975LLU: // copy-back deleter (reportnr to ProcCall) | |
24213 | 24362 | { |
24214 | 24363 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportnr to ProcCall)\n"); |
24215 | 24364 | // copy mutable arguments back from call to reportnr |
24216 | - label = 1836LLU; // continue to roll stack | |
24365 | + label = 1850LLU; // continue to roll stack | |
24217 | 24366 | break; |
24218 | 24367 | } |
24219 | - case 1962LLU: // return from reportnr to ProcCall | |
24368 | + case 1976LLU: // return from reportnr to ProcCall | |
24220 | 24369 | { |
24221 | 24370 | // copy mutable arguments back from call to reportnr |
24222 | 24371 | fprintf(stderr, "%s", " parameter type "); |
@@ -24223,7 +24372,7 @@ | ||
24223 | 24372 | uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t)); |
24224 | 24373 | if(!newstack) |
24225 | 24374 | { |
24226 | - label = 1836LLU; // throw: begin to unroll stack | |
24375 | + label = 1850LLU; // throw: begin to unroll stack | |
24227 | 24376 | break; |
24228 | 24377 | } |
24229 | 24378 |
@@ -24230,11 +24379,11 @@ | ||
24230 | 24379 | newstack[10LLU] = 9876543210LLU; // overflow-marker |
24231 | 24380 | // call reporttype from ProcCall |
24232 | 24381 | newstack[0] = (uint64_t)stack; // backup stack location |
24233 | - newstack[1] = 1963LLU; | |
24382 | + newstack[1] = 1977LLU; | |
24234 | 24383 | newstack[2] = base; |
24235 | - newstack[3] = 1964LLU; | |
24384 | + newstack[3] = 1978LLU; | |
24236 | 24385 | // arguments for call to reporttype |
24237 | - newstack[4LLU] = stack[base + 37]/*expected*/; | |
24386 | + newstack[4LLU] = stack[base + 39]/*expected*/; | |
24238 | 24387 | stack = newstack; |
24239 | 24388 | // set stack-base & callee-address |
24240 | 24389 | base = 4/*deloffset*/; |
@@ -24241,7 +24390,7 @@ | ||
24241 | 24390 | label = 313LLU; // reporttype |
24242 | 24391 | break; |
24243 | 24392 | } |
24244 | - case 1963LLU: // copy-back deleter (reporttype to ProcCall) | |
24393 | + case 1977LLU: // copy-back deleter (reporttype to ProcCall) | |
24245 | 24394 | { |
24246 | 24395 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n"); |
24247 | 24396 | uint64_t *oldstack = (uint64_t *)stack[0]; |
@@ -24253,10 +24402,10 @@ | ||
24253 | 24402 | } |
24254 | 24403 | Free(10LLU + 1, sizeof(uint64_t), stack); |
24255 | 24404 | stack = oldstack; |
24256 | - label = 1836LLU; // continue to unroll stack | |
24405 | + label = 1850LLU; // continue to unroll stack | |
24257 | 24406 | break; |
24258 | 24407 | } |
24259 | - case 1964LLU: // return from reporttype to ProcCall | |
24408 | + case 1978LLU: // return from reporttype to ProcCall | |
24260 | 24409 | { |
24261 | 24410 | uint64_t *oldstack = (uint64_t *)stack[0]; |
24262 | 24411 | // copy mutable arguments back from call to reporttype |
@@ -24271,7 +24420,7 @@ | ||
24271 | 24420 | uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t)); |
24272 | 24421 | if(!newstack) |
24273 | 24422 | { |
24274 | - label = 1836LLU; // throw: begin to unroll stack | |
24423 | + label = 1850LLU; // throw: begin to unroll stack | |
24275 | 24424 | break; |
24276 | 24425 | } |
24277 | 24426 |
@@ -24278,11 +24427,11 @@ | ||
24278 | 24427 | newstack[10LLU] = 9876543210LLU; // overflow-marker |
24279 | 24428 | // call reporttype from ProcCall |
24280 | 24429 | newstack[0] = (uint64_t)stack; // backup stack location |
24281 | - newstack[1] = 1965LLU; | |
24430 | + newstack[1] = 1979LLU; | |
24282 | 24431 | newstack[2] = base; |
24283 | - newstack[3] = 1966LLU; | |
24432 | + newstack[3] = 1980LLU; | |
24284 | 24433 | // arguments for call to reporttype |
24285 | - newstack[4LLU] = stack[base + 39]/*type*/; | |
24434 | + newstack[4LLU] = stack[base + 41]/*type*/; | |
24286 | 24435 | stack = newstack; |
24287 | 24436 | // set stack-base & callee-address |
24288 | 24437 | base = 4/*deloffset*/; |
@@ -24289,7 +24438,7 @@ | ||
24289 | 24438 | label = 313LLU; // reporttype |
24290 | 24439 | break; |
24291 | 24440 | } |
24292 | - case 1965LLU: // copy-back deleter (reporttype to ProcCall) | |
24441 | + case 1979LLU: // copy-back deleter (reporttype to ProcCall) | |
24293 | 24442 | { |
24294 | 24443 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n"); |
24295 | 24444 | uint64_t *oldstack = (uint64_t *)stack[0]; |
@@ -24301,10 +24450,10 @@ | ||
24301 | 24450 | } |
24302 | 24451 | Free(10LLU + 1, sizeof(uint64_t), stack); |
24303 | 24452 | stack = oldstack; |
24304 | - label = 1836LLU; // continue to unroll stack | |
24453 | + label = 1850LLU; // continue to unroll stack | |
24305 | 24454 | break; |
24306 | 24455 | } |
24307 | - case 1966LLU: // return from reporttype to ProcCall | |
24456 | + case 1980LLU: // return from reporttype to ProcCall | |
24308 | 24457 | { |
24309 | 24458 | uint64_t *oldstack = (uint64_t *)stack[0]; |
24310 | 24459 | // copy mutable arguments back from call to reporttype |
@@ -24317,52 +24466,52 @@ | ||
24317 | 24466 | stack = oldstack; |
24318 | 24467 | fprintf(stderr, "%s", "\n"); |
24319 | 24468 | exit(-1); |
24320 | - label = 1956LLU; // alternative complete | |
24469 | + label = 1970LLU; // alternative complete | |
24321 | 24470 | break; |
24322 | 24471 | } |
24323 | - case 1956LLU: // completed if-then-else | |
24472 | + case 1970LLU: // completed if-then-else | |
24324 | 24473 | { |
24325 | - if(!stack[base + 36]/*mutable*/) | |
24474 | + if(!stack[base + 38]/*mutable*/) | |
24326 | 24475 | { |
24327 | - label = 1967LLU; // jump to alternative | |
24476 | + label = 1981LLU; // jump to alternative | |
24328 | 24477 | break; |
24329 | 24478 | } |
24330 | 24479 | |
24331 | 24480 | // consequent |
24332 | - if(!stack[base + 40]/*mutarg*/) | |
24481 | + if(!stack[base + 42]/*mutarg*/) | |
24333 | 24482 | { |
24334 | - label = 1969LLU; // jump to alternative | |
24483 | + label = 1983LLU; // jump to alternative | |
24335 | 24484 | break; |
24336 | 24485 | } |
24337 | 24486 | |
24338 | 24487 | // consequent |
24339 | 24488 | // call lookidnr from ProcCall |
24340 | - stack[base + 42LLU] = 1971LLU/*throw to this address*/; | |
24341 | - stack[base + 43LLU] = base; | |
24342 | - stack[base + 44LLU] = 1972LLU; | |
24489 | + stack[base + 44LLU] = 1985LLU/*throw to this address*/; | |
24490 | + stack[base + 45LLU] = base; | |
24491 | + stack[base + 46LLU] = 1986LLU; | |
24343 | 24492 | // arguments for call to lookidnr |
24344 | - stack[base + 46LLU] = stack[base + 18]/*copyback*/; | |
24345 | - stack[base + 47LLU] = stack[base + 15]/*content*/; | |
24493 | + stack[base + 48LLU] = stack[base + 19]/*copyback*/; | |
24494 | + stack[base + 49LLU] = stack[base + 16]/*content*/; | |
24346 | 24495 | // set stack-base & callee-address |
24347 | - base += 45LLU; | |
24496 | + base += 47LLU; | |
24348 | 24497 | label = 760LLU; // lookidnr |
24349 | 24498 | break; |
24350 | 24499 | } |
24351 | - case 1971LLU: // copy-back deleter (lookidnr to ProcCall) | |
24500 | + case 1985LLU: // copy-back deleter (lookidnr to ProcCall) | |
24352 | 24501 | { |
24353 | 24502 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (lookidnr to ProcCall)\n"); |
24354 | 24503 | // copy mutable arguments back from call to lookidnr |
24355 | - label = 1836LLU; // continue to roll stack | |
24504 | + label = 1850LLU; // continue to roll stack | |
24356 | 24505 | break; |
24357 | 24506 | } |
24358 | - case 1972LLU: // return from lookidnr to ProcCall | |
24507 | + case 1986LLU: // return from lookidnr to ProcCall | |
24359 | 24508 | { |
24360 | 24509 | // copy mutable arguments back from call to lookidnr |
24361 | 24510 | // copy back results provided by call to lookidnr |
24362 | - stack[base + 41] = stack[base + 45LLU]; | |
24363 | - if(!stack[base + 41]/*found*/) | |
24511 | + stack[base + 43] = stack[base + 47LLU]; | |
24512 | + if(!stack[base + 43]/*found*/) | |
24364 | 24513 | { |
24365 | - label = 1973LLU; // jump to alternative | |
24514 | + label = 1987LLU; // jump to alternative | |
24366 | 24515 | break; |
24367 | 24516 | } |
24368 | 24517 |
@@ -24369,102 +24518,102 @@ | ||
24369 | 24518 | // consequent |
24370 | 24519 | fprintf(stderr, "%s", "in function "); |
24371 | 24520 | // call reportid from ProcCall |
24372 | - stack[base + 42LLU] = 1975LLU/*throw to this address*/; | |
24373 | - stack[base + 43LLU] = base; | |
24374 | - stack[base + 44LLU] = 1976LLU; | |
24521 | + stack[base + 44LLU] = 1989LLU/*throw to this address*/; | |
24522 | + stack[base + 45LLU] = base; | |
24523 | + stack[base + 46LLU] = 1990LLU; | |
24375 | 24524 | // arguments for call to reportid |
24376 | - stack[base + 45LLU] = stack[base + 7]/*fnid*/; | |
24525 | + stack[base + 47LLU] = stack[base + 8]/*fnid*/; | |
24377 | 24526 | // set stack-base & callee-address |
24378 | - base += 45LLU; | |
24527 | + base += 47LLU; | |
24379 | 24528 | label = 18446744073709551586LLU; // reportid |
24380 | 24529 | break; |
24381 | 24530 | } |
24382 | - case 1975LLU: // copy-back deleter (reportid to ProcCall) | |
24531 | + case 1989LLU: // copy-back deleter (reportid to ProcCall) | |
24383 | 24532 | { |
24384 | 24533 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
24385 | 24534 | // copy mutable arguments back from call to reportid |
24386 | - label = 1836LLU; // continue to roll stack | |
24535 | + label = 1850LLU; // continue to roll stack | |
24387 | 24536 | break; |
24388 | 24537 | } |
24389 | - case 1976LLU: // return from reportid to ProcCall | |
24538 | + case 1990LLU: // return from reportid to ProcCall | |
24390 | 24539 | { |
24391 | 24540 | // copy mutable arguments back from call to reportid |
24392 | 24541 | fprintf(stderr, "%s", " call to "); |
24393 | 24542 | // call reportid from ProcCall |
24394 | - stack[base + 42LLU] = 1977LLU/*throw to this address*/; | |
24395 | - stack[base + 43LLU] = base; | |
24396 | - stack[base + 44LLU] = 1978LLU; | |
24543 | + stack[base + 44LLU] = 1991LLU/*throw to this address*/; | |
24544 | + stack[base + 45LLU] = base; | |
24545 | + stack[base + 46LLU] = 1992LLU; | |
24397 | 24546 | // arguments for call to reportid |
24398 | - stack[base + 45LLU] = stack[base + 23]/*ceid*/; | |
24547 | + stack[base + 47LLU] = stack[base + 24]/*ceid*/; | |
24399 | 24548 | // set stack-base & callee-address |
24400 | - base += 45LLU; | |
24549 | + base += 47LLU; | |
24401 | 24550 | label = 18446744073709551586LLU; // reportid |
24402 | 24551 | break; |
24403 | 24552 | } |
24404 | - case 1977LLU: // copy-back deleter (reportid to ProcCall) | |
24553 | + case 1991LLU: // copy-back deleter (reportid to ProcCall) | |
24405 | 24554 | { |
24406 | 24555 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
24407 | 24556 | // copy mutable arguments back from call to reportid |
24408 | - label = 1836LLU; // continue to roll stack | |
24557 | + label = 1850LLU; // continue to roll stack | |
24409 | 24558 | break; |
24410 | 24559 | } |
24411 | - case 1978LLU: // return from reportid to ProcCall | |
24560 | + case 1992LLU: // return from reportid to ProcCall | |
24412 | 24561 | { |
24413 | 24562 | // copy mutable arguments back from call to reportid |
24414 | 24563 | fprintf(stderr, "%s", " - duplicate mutable argument "); |
24415 | 24564 | // call reportid from ProcCall |
24416 | - stack[base + 42LLU] = 1979LLU/*throw to this address*/; | |
24417 | - stack[base + 43LLU] = base; | |
24418 | - stack[base + 44LLU] = 1980LLU; | |
24565 | + stack[base + 44LLU] = 1993LLU/*throw to this address*/; | |
24566 | + stack[base + 45LLU] = base; | |
24567 | + stack[base + 46LLU] = 1994LLU; | |
24419 | 24568 | // arguments for call to reportid |
24420 | - stack[base + 45LLU] = stack[base + 15]/*content*/; | |
24569 | + stack[base + 47LLU] = stack[base + 16]/*content*/; | |
24421 | 24570 | // set stack-base & callee-address |
24422 | - base += 45LLU; | |
24571 | + base += 47LLU; | |
24423 | 24572 | label = 18446744073709551586LLU; // reportid |
24424 | 24573 | break; |
24425 | 24574 | } |
24426 | - case 1979LLU: // copy-back deleter (reportid to ProcCall) | |
24575 | + case 1993LLU: // copy-back deleter (reportid to ProcCall) | |
24427 | 24576 | { |
24428 | 24577 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
24429 | 24578 | // copy mutable arguments back from call to reportid |
24430 | - label = 1836LLU; // continue to roll stack | |
24579 | + label = 1850LLU; // continue to roll stack | |
24431 | 24580 | break; |
24432 | 24581 | } |
24433 | - case 1980LLU: // return from reportid to ProcCall | |
24582 | + case 1994LLU: // return from reportid to ProcCall | |
24434 | 24583 | { |
24435 | 24584 | // copy mutable arguments back from call to reportid |
24436 | 24585 | fprintf(stderr, "%s", "\n"); |
24437 | 24586 | exit(-1); |
24438 | - label = 1974LLU; // consequent complete | |
24587 | + label = 1988LLU; // consequent complete | |
24439 | 24588 | break; |
24440 | 24589 | } |
24441 | - case 1973LLU: // alternative | |
24590 | + case 1987LLU: // alternative | |
24442 | 24591 | { |
24443 | - label = 1974LLU; // alternative complete | |
24592 | + label = 1988LLU; // alternative complete | |
24444 | 24593 | break; |
24445 | 24594 | } |
24446 | - case 1974LLU: // completed if-then-else | |
24595 | + case 1988LLU: // completed if-then-else | |
24447 | 24596 | { |
24448 | - label = 1982LLU; // skip deleter | |
24597 | + label = 1996LLU; // skip deleter | |
24449 | 24598 | break; |
24450 | 24599 | } |
24451 | - case 1981LLU: // deleter | |
24600 | + case 1995LLU: // deleter | |
24452 | 24601 | { |
24453 | 24602 | // throw from ProcCall |
24454 | - if(!stack[base + 41]) | |
24603 | + if(!stack[base + 43]) | |
24455 | 24604 | { |
24456 | 24605 | fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable idnr \n"); |
24457 | - label = 1836LLU; // skip, variable already deleted/unscoped | |
24606 | + label = 1850LLU; // skip, variable already deleted/unscoped | |
24458 | 24607 | break; |
24459 | 24608 | } |
24460 | 24609 | fprintf(stderr, "in function ProcCall: unrolling stack, variable idnr \n"); |
24461 | 24610 | |
24462 | - uint64_t *newstack = (uint64_t *)(stack[base + 41] - sizeof(uint64_t) * 4); | |
24611 | + uint64_t *newstack = (uint64_t *)(stack[base + 43] - sizeof(uint64_t) * 4); | |
24463 | 24612 | // call ~idnr from ProcCall |
24464 | 24613 | newstack[0] = (uint64_t)stack; // backup stack location |
24465 | 24614 | newstack[1] = 1234567890; |
24466 | 24615 | newstack[2] = base; |
24467 | - newstack[3] = 1983LLU; | |
24616 | + newstack[3] = 1997LLU; | |
24468 | 24617 | stack = newstack; |
24469 | 24618 | // set stack-base & callee-address |
24470 | 24619 | base = 4/*deloffset*/; |
@@ -24471,28 +24620,28 @@ | ||
24471 | 24620 | label = 758LLU; // ~idnr |
24472 | 24621 | break; |
24473 | 24622 | } |
24474 | - case 1983LLU: // return from ~idnr to ProcCall | |
24623 | + case 1997LLU: // return from ~idnr to ProcCall | |
24475 | 24624 | { |
24476 | 24625 | stack = (uint64_t *)stack[0]; |
24477 | 24626 | // releasing toplevel container |
24478 | - Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 41] - sizeof(uint64_t) * 4)); | |
24627 | + Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 43] - sizeof(uint64_t) * 4)); | |
24479 | 24628 | |
24480 | - label = 1836LLU; // continue unrolling stack, delete next variable | |
24629 | + label = 1850LLU; // continue unrolling stack, delete next variable | |
24481 | 24630 | break; |
24482 | 24631 | } |
24483 | - case 1982LLU: // skipped deleter | |
24632 | + case 1996LLU: // skipped deleter | |
24484 | 24633 | { |
24485 | 24634 | // construct idnr.idnr |
24486 | - if(!(stack[base + 41] = construct(2))) | |
24635 | + if(!(stack[base + 43] = construct(2))) | |
24487 | 24636 | { |
24488 | - label = 1836LLU; // throw: begin to unroll stack | |
24637 | + label = 1850LLU; // throw: begin to unroll stack | |
24489 | 24638 | break; |
24490 | 24639 | } |
24491 | 24640 | |
24492 | 24641 | // consequent |
24493 | - ((uint64_t *)stack[base + 41])[0] = 0; | |
24494 | - (((uint64_t **)(stack[base + 41]))[1][0]) = stack[base + 15]/*content*/; | |
24495 | - (((uint64_t **)(stack[base + 41]))[1][1]) = stack[base + 28]/*sum*/; | |
24642 | + ((uint64_t *)stack[base + 43])[0] = 0; | |
24643 | + (((uint64_t **)(stack[base + 43]))[1][0]) = stack[base + 16]/*content*/; | |
24644 | + (((uint64_t **)(stack[base + 43]))[1][1]) = stack[base + 30]/*sum*/; | |
24496 | 24645 | { |
24497 | 24646 | struct listnode *list = (struct listnode *)Calloc(1, sizeof(struct listnode)); |
24498 | 24647 | if(!list) |
@@ -24500,57 +24649,57 @@ | ||
24500 | 24649 | fprintf(stderr, "in function ProcCall push to [idnr]: OUT OF MEMORY!"); |
24501 | 24650 | exit(-1); |
24502 | 24651 | } |
24503 | - list->next = (struct listnode *)stack[base + 18]/*copyback*/; | |
24504 | - stack[base + 18]/*copyback*/ = (uint64_t)list; | |
24505 | - MOVE(&list->data, &stack[base + 41]/*idnr*/); | |
24652 | + list->next = (struct listnode *)stack[base + 19]/*copyback*/; | |
24653 | + stack[base + 19]/*copyback*/ = (uint64_t)list; | |
24654 | + MOVE(&list->data, &stack[base + 43]/*idnr*/); | |
24506 | 24655 | } |
24507 | - label = 1970LLU; // consequent complete | |
24656 | + label = 1984LLU; // consequent complete | |
24508 | 24657 | break; |
24509 | 24658 | } |
24510 | - case 1969LLU: // alternative | |
24659 | + case 1983LLU: // alternative | |
24511 | 24660 | { |
24512 | 24661 | fprintf(stderr, "%s", "in function "); |
24513 | 24662 | // call reportid from ProcCall |
24514 | - stack[base + 41LLU] = 1984LLU/*throw to this address*/; | |
24515 | - stack[base + 42LLU] = base; | |
24516 | - stack[base + 43LLU] = 1985LLU; | |
24663 | + stack[base + 43LLU] = 1998LLU/*throw to this address*/; | |
24664 | + stack[base + 44LLU] = base; | |
24665 | + stack[base + 45LLU] = 1999LLU; | |
24517 | 24666 | // arguments for call to reportid |
24518 | - stack[base + 44LLU] = stack[base + 7]/*fnid*/; | |
24667 | + stack[base + 46LLU] = stack[base + 8]/*fnid*/; | |
24519 | 24668 | // set stack-base & callee-address |
24520 | - base += 44LLU; | |
24669 | + base += 46LLU; | |
24521 | 24670 | label = 18446744073709551586LLU; // reportid |
24522 | 24671 | break; |
24523 | 24672 | } |
24524 | - case 1984LLU: // copy-back deleter (reportid to ProcCall) | |
24673 | + case 1998LLU: // copy-back deleter (reportid to ProcCall) | |
24525 | 24674 | { |
24526 | 24675 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
24527 | 24676 | // copy mutable arguments back from call to reportid |
24528 | - label = 1836LLU; // continue to roll stack | |
24677 | + label = 1850LLU; // continue to roll stack | |
24529 | 24678 | break; |
24530 | 24679 | } |
24531 | - case 1985LLU: // return from reportid to ProcCall | |
24680 | + case 1999LLU: // return from reportid to ProcCall | |
24532 | 24681 | { |
24533 | 24682 | // copy mutable arguments back from call to reportid |
24534 | 24683 | fprintf(stderr, "%s", ", call to "); |
24535 | 24684 | // call reportid from ProcCall |
24536 | - stack[base + 41LLU] = 1986LLU/*throw to this address*/; | |
24537 | - stack[base + 42LLU] = base; | |
24538 | - stack[base + 43LLU] = 1987LLU; | |
24685 | + stack[base + 43LLU] = 2000LLU/*throw to this address*/; | |
24686 | + stack[base + 44LLU] = base; | |
24687 | + stack[base + 45LLU] = 2001LLU; | |
24539 | 24688 | // arguments for call to reportid |
24540 | - stack[base + 44LLU] = stack[base + 23]/*ceid*/; | |
24689 | + stack[base + 46LLU] = stack[base + 24]/*ceid*/; | |
24541 | 24690 | // set stack-base & callee-address |
24542 | - base += 44LLU; | |
24691 | + base += 46LLU; | |
24543 | 24692 | label = 18446744073709551586LLU; // reportid |
24544 | 24693 | break; |
24545 | 24694 | } |
24546 | - case 1986LLU: // copy-back deleter (reportid to ProcCall) | |
24695 | + case 2000LLU: // copy-back deleter (reportid to ProcCall) | |
24547 | 24696 | { |
24548 | 24697 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
24549 | 24698 | // copy mutable arguments back from call to reportid |
24550 | - label = 1836LLU; // continue to roll stack | |
24699 | + label = 1850LLU; // continue to roll stack | |
24551 | 24700 | break; |
24552 | 24701 | } |
24553 | - case 1987LLU: // return from reportid to ProcCall | |
24702 | + case 2001LLU: // return from reportid to ProcCall | |
24554 | 24703 | { |
24555 | 24704 | // copy mutable arguments back from call to reportid |
24556 | 24705 | fprintf(stderr, "%s", ": can't put constant argument "); |
@@ -24557,7 +24706,7 @@ | ||
24557 | 24706 | uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t)); |
24558 | 24707 | if(!newstack) |
24559 | 24708 | { |
24560 | - label = 1836LLU; // throw: begin to unroll stack | |
24709 | + label = 1850LLU; // throw: begin to unroll stack | |
24561 | 24710 | break; |
24562 | 24711 | } |
24563 | 24712 |
@@ -24564,11 +24713,11 @@ | ||
24564 | 24713 | newstack[10LLU] = 9876543210LLU; // overflow-marker |
24565 | 24714 | // call reporttype from ProcCall |
24566 | 24715 | newstack[0] = (uint64_t)stack; // backup stack location |
24567 | - newstack[1] = 1988LLU; | |
24716 | + newstack[1] = 2002LLU; | |
24568 | 24717 | newstack[2] = base; |
24569 | - newstack[3] = 1989LLU; | |
24718 | + newstack[3] = 2003LLU; | |
24570 | 24719 | // arguments for call to reporttype |
24571 | - newstack[4LLU] = stack[base + 39]/*type*/; | |
24720 | + newstack[4LLU] = stack[base + 41]/*type*/; | |
24572 | 24721 | stack = newstack; |
24573 | 24722 | // set stack-base & callee-address |
24574 | 24723 | base = 4/*deloffset*/; |
@@ -24575,7 +24724,7 @@ | ||
24575 | 24724 | label = 313LLU; // reporttype |
24576 | 24725 | break; |
24577 | 24726 | } |
24578 | - case 1988LLU: // copy-back deleter (reporttype to ProcCall) | |
24727 | + case 2002LLU: // copy-back deleter (reporttype to ProcCall) | |
24579 | 24728 | { |
24580 | 24729 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n"); |
24581 | 24730 | uint64_t *oldstack = (uint64_t *)stack[0]; |
@@ -24587,10 +24736,10 @@ | ||
24587 | 24736 | } |
24588 | 24737 | Free(10LLU + 1, sizeof(uint64_t), stack); |
24589 | 24738 | stack = oldstack; |
24590 | - label = 1836LLU; // continue to unroll stack | |
24739 | + label = 1850LLU; // continue to unroll stack | |
24591 | 24740 | break; |
24592 | 24741 | } |
24593 | - case 1989LLU: // return from reporttype to ProcCall | |
24742 | + case 2003LLU: // return from reporttype to ProcCall | |
24594 | 24743 | { |
24595 | 24744 | uint64_t *oldstack = (uint64_t *)stack[0]; |
24596 | 24745 | // copy mutable arguments back from call to reporttype |
@@ -24603,24 +24752,24 @@ | ||
24603 | 24752 | stack = oldstack; |
24604 | 24753 | fprintf(stderr, "%s", " "); |
24605 | 24754 | // call reportid from ProcCall |
24606 | - stack[base + 41LLU] = 1990LLU/*throw to this address*/; | |
24607 | - stack[base + 42LLU] = base; | |
24608 | - stack[base + 43LLU] = 1991LLU; | |
24755 | + stack[base + 43LLU] = 2004LLU/*throw to this address*/; | |
24756 | + stack[base + 44LLU] = base; | |
24757 | + stack[base + 45LLU] = 2005LLU; | |
24609 | 24758 | // arguments for call to reportid |
24610 | - stack[base + 44LLU] = stack[base + 15]/*content*/; | |
24759 | + stack[base + 46LLU] = stack[base + 16]/*content*/; | |
24611 | 24760 | // set stack-base & callee-address |
24612 | - base += 44LLU; | |
24761 | + base += 46LLU; | |
24613 | 24762 | label = 18446744073709551586LLU; // reportid |
24614 | 24763 | break; |
24615 | 24764 | } |
24616 | - case 1990LLU: // copy-back deleter (reportid to ProcCall) | |
24765 | + case 2004LLU: // copy-back deleter (reportid to ProcCall) | |
24617 | 24766 | { |
24618 | 24767 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
24619 | 24768 | // copy mutable arguments back from call to reportid |
24620 | - label = 1836LLU; // continue to roll stack | |
24769 | + label = 1850LLU; // continue to roll stack | |
24621 | 24770 | break; |
24622 | 24771 | } |
24623 | - case 1991LLU: // return from reportid to ProcCall | |
24772 | + case 2005LLU: // return from reportid to ProcCall | |
24624 | 24773 | { |
24625 | 24774 | // copy mutable arguments back from call to reportid |
24626 | 24775 | fprintf(stderr, "%s", " into mutable parameter "); |
@@ -24627,7 +24776,7 @@ | ||
24627 | 24776 | uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t)); |
24628 | 24777 | if(!newstack) |
24629 | 24778 | { |
24630 | - label = 1836LLU; // throw: begin to unroll stack | |
24779 | + label = 1850LLU; // throw: begin to unroll stack | |
24631 | 24780 | break; |
24632 | 24781 | } |
24633 | 24782 |
@@ -24634,11 +24783,11 @@ | ||
24634 | 24783 | newstack[10LLU] = 9876543210LLU; // overflow-marker |
24635 | 24784 | // call reporttype from ProcCall |
24636 | 24785 | newstack[0] = (uint64_t)stack; // backup stack location |
24637 | - newstack[1] = 1992LLU; | |
24786 | + newstack[1] = 2006LLU; | |
24638 | 24787 | newstack[2] = base; |
24639 | - newstack[3] = 1993LLU; | |
24788 | + newstack[3] = 2007LLU; | |
24640 | 24789 | // arguments for call to reporttype |
24641 | - newstack[4LLU] = stack[base + 37]/*expected*/; | |
24790 | + newstack[4LLU] = stack[base + 39]/*expected*/; | |
24642 | 24791 | stack = newstack; |
24643 | 24792 | // set stack-base & callee-address |
24644 | 24793 | base = 4/*deloffset*/; |
@@ -24645,7 +24794,7 @@ | ||
24645 | 24794 | label = 313LLU; // reporttype |
24646 | 24795 | break; |
24647 | 24796 | } |
24648 | - case 1992LLU: // copy-back deleter (reporttype to ProcCall) | |
24797 | + case 2006LLU: // copy-back deleter (reporttype to ProcCall) | |
24649 | 24798 | { |
24650 | 24799 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n"); |
24651 | 24800 | uint64_t *oldstack = (uint64_t *)stack[0]; |
@@ -24657,10 +24806,10 @@ | ||
24657 | 24806 | } |
24658 | 24807 | Free(10LLU + 1, sizeof(uint64_t), stack); |
24659 | 24808 | stack = oldstack; |
24660 | - label = 1836LLU; // continue to unroll stack | |
24809 | + label = 1850LLU; // continue to unroll stack | |
24661 | 24810 | break; |
24662 | 24811 | } |
24663 | - case 1993LLU: // return from reporttype to ProcCall | |
24812 | + case 2007LLU: // return from reporttype to ProcCall | |
24664 | 24813 | { |
24665 | 24814 | uint64_t *oldstack = (uint64_t *)stack[0]; |
24666 | 24815 | // copy mutable arguments back from call to reporttype |
@@ -24672,50 +24821,50 @@ | ||
24672 | 24821 | Free(10LLU + 1, sizeof(uint64_t), stack); |
24673 | 24822 | stack = oldstack; |
24674 | 24823 | // call reportid from ProcCall |
24675 | - stack[base + 41LLU] = 1994LLU/*throw to this address*/; | |
24676 | - stack[base + 42LLU] = base; | |
24677 | - stack[base + 43LLU] = 1995LLU; | |
24824 | + stack[base + 43LLU] = 2008LLU/*throw to this address*/; | |
24825 | + stack[base + 44LLU] = base; | |
24826 | + stack[base + 45LLU] = 2009LLU; | |
24678 | 24827 | // arguments for call to reportid |
24679 | - stack[base + 44LLU] = stack[base + 38]/*paramname*/; | |
24828 | + stack[base + 46LLU] = stack[base + 40]/*paramname*/; | |
24680 | 24829 | // set stack-base & callee-address |
24681 | - base += 44LLU; | |
24830 | + base += 46LLU; | |
24682 | 24831 | label = 18446744073709551586LLU; // reportid |
24683 | 24832 | break; |
24684 | 24833 | } |
24685 | - case 1994LLU: // copy-back deleter (reportid to ProcCall) | |
24834 | + case 2008LLU: // copy-back deleter (reportid to ProcCall) | |
24686 | 24835 | { |
24687 | 24836 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n"); |
24688 | 24837 | // copy mutable arguments back from call to reportid |
24689 | - label = 1836LLU; // continue to roll stack | |
24838 | + label = 1850LLU; // continue to roll stack | |
24690 | 24839 | break; |
24691 | 24840 | } |
24692 | - case 1995LLU: // return from reportid to ProcCall | |
24841 | + case 2009LLU: // return from reportid to ProcCall | |
24693 | 24842 | { |
24694 | 24843 | // copy mutable arguments back from call to reportid |
24695 | 24844 | fprintf(stderr, "%s", "\n"); |
24696 | 24845 | exit(-1); |
24697 | - label = 1970LLU; // alternative complete | |
24846 | + label = 1984LLU; // alternative complete | |
24698 | 24847 | break; |
24699 | 24848 | } |
24700 | - case 1970LLU: // completed if-then-else | |
24849 | + case 1984LLU: // completed if-then-else | |
24701 | 24850 | { |
24702 | - label = 1968LLU; // consequent complete | |
24851 | + label = 1982LLU; // consequent complete | |
24703 | 24852 | break; |
24704 | 24853 | } |
24705 | - case 1967LLU: // alternative | |
24854 | + case 1981LLU: // alternative | |
24706 | 24855 | { |
24707 | - label = 1968LLU; // alternative complete | |
24856 | + label = 1982LLU; // alternative complete | |
24708 | 24857 | break; |
24709 | 24858 | } |
24710 | - case 1968LLU: // completed if-then-else | |
24859 | + case 1982LLU: // completed if-then-else | |
24711 | 24860 | { |
24712 | 24861 | |
24713 | - uint64_t *newstack = (uint64_t *)(stack[base + 39] - sizeof(uint64_t) * 4); | |
24862 | + uint64_t *newstack = (uint64_t *)(stack[base + 41] - sizeof(uint64_t) * 4); | |
24714 | 24863 | // call ~type from ProcCall |
24715 | 24864 | newstack[0] = (uint64_t)stack; // backup stack location |
24716 | 24865 | newstack[1] = 1234567890; |
24717 | 24866 | newstack[2] = base; |
24718 | - newstack[3] = 1996LLU; | |
24867 | + newstack[3] = 2010LLU; | |
24719 | 24868 | stack = newstack; |
24720 | 24869 | // set stack-base & callee-address |
24721 | 24870 | base = 4/*deloffset*/; |
@@ -24722,293 +24871,293 @@ | ||
24722 | 24871 | label = 295LLU; // ~type |
24723 | 24872 | break; |
24724 | 24873 | } |
24725 | - case 1996LLU: // return from ~type to ProcCall | |
24874 | + case 2010LLU: // return from ~type to ProcCall | |
24726 | 24875 | { |
24727 | 24876 | stack = (uint64_t *)stack[0]; |
24728 | 24877 | // releasing toplevel container |
24729 | - Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 39] - sizeof(uint64_t) * 4)); | |
24878 | + Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 41] - sizeof(uint64_t) * 4)); | |
24730 | 24879 | |
24731 | - ((uint64_t **)(stack[base + 35]))[1][1] = stack[base + 38]; | |
24732 | - ((uint64_t **)(stack[base + 35]))[1][0] = stack[base + 37]; | |
24733 | - label = 1947LLU; // case complete | |
24880 | + ((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40]; | |
24881 | + ((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39]; | |
24882 | + label = 1961LLU; // case complete | |
24734 | 24883 | break; |
24735 | 24884 | } |
24736 | - case 1948LLU: // try next case | |
24885 | + case 1962LLU: // try next case | |
24737 | 24886 | { |
24738 | 24887 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
24739 | 24888 | exit(-1); |
24740 | 24889 | } |
24741 | - case 1947LLU: // completed switch | |
24890 | + case 1961LLU: // completed switch | |
24742 | 24891 | { |
24743 | 24892 | printf("%s", "\n stack[base + "); |
24744 | 24893 | // call printnr from ProcCall |
24745 | - stack[base + 37LLU] = 1997LLU/*throw to this address*/; | |
24746 | - stack[base + 38LLU] = base; | |
24747 | - stack[base + 39LLU] = 1998LLU; | |
24894 | + stack[base + 39LLU] = 2011LLU/*throw to this address*/; | |
24895 | + stack[base + 40LLU] = base; | |
24896 | + stack[base + 41LLU] = 2012LLU; | |
24748 | 24897 | // arguments for call to printnr |
24749 | - stack[base + 40LLU] = stack[base + 28]/*sum*/; | |
24898 | + stack[base + 42LLU] = stack[base + 30]/*sum*/; | |
24750 | 24899 | // set stack-base & callee-address |
24751 | - base += 40LLU; | |
24900 | + base += 42LLU; | |
24752 | 24901 | label = 18446744073709551590LLU; // printnr |
24753 | 24902 | break; |
24754 | 24903 | } |
24755 | - case 1997LLU: // copy-back deleter (printnr to ProcCall) | |
24904 | + case 2011LLU: // copy-back deleter (printnr to ProcCall) | |
24756 | 24905 | { |
24757 | 24906 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n"); |
24758 | 24907 | // copy mutable arguments back from call to printnr |
24759 | - label = 1836LLU; // continue to roll stack | |
24908 | + label = 1850LLU; // continue to roll stack | |
24760 | 24909 | break; |
24761 | 24910 | } |
24762 | - case 1998LLU: // return from printnr to ProcCall | |
24911 | + case 2012LLU: // return from printnr to ProcCall | |
24763 | 24912 | { |
24764 | 24913 | // copy mutable arguments back from call to printnr |
24765 | 24914 | printf("%s", "LLU] = "); |
24766 | 24915 | // call emitvar from ProcCall |
24767 | - stack[base + 37LLU] = 1999LLU/*throw to this address*/; | |
24768 | - stack[base + 38LLU] = base; | |
24769 | - stack[base + 39LLU] = 2000LLU; | |
24916 | + stack[base + 39LLU] = 2013LLU/*throw to this address*/; | |
24917 | + stack[base + 40LLU] = base; | |
24918 | + stack[base + 41LLU] = 2014LLU; | |
24770 | 24919 | // arguments for call to emitvar |
24771 | - stack[base + 40LLU] = stack[base + 7]/*fnid*/; | |
24772 | - stack[base + 41LLU] = stack[base + 15]/*content*/; | |
24773 | - stack[base + 42LLU] = stack[base + 2]/*scopes*/; | |
24774 | - stack[base + 43LLU] = stack[base + 3]/*scope*/; | |
24920 | + stack[base + 42LLU] = stack[base + 8]/*fnid*/; | |
24921 | + stack[base + 43LLU] = stack[base + 16]/*content*/; | |
24922 | + stack[base + 44LLU] = stack[base + 2]/*scopes*/; | |
24923 | + stack[base + 45LLU] = stack[base + 3]/*scope*/; | |
24775 | 24924 | // set stack-base & callee-address |
24776 | - base += 40LLU; | |
24925 | + base += 42LLU; | |
24777 | 24926 | label = 659LLU; // emitvar |
24778 | 24927 | break; |
24779 | 24928 | } |
24780 | - case 1999LLU: // copy-back deleter (emitvar to ProcCall) | |
24929 | + case 2013LLU: // copy-back deleter (emitvar to ProcCall) | |
24781 | 24930 | { |
24782 | 24931 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (emitvar to ProcCall)\n"); |
24783 | 24932 | // copy mutable arguments back from call to emitvar |
24784 | - label = 1836LLU; // continue to roll stack | |
24933 | + label = 1850LLU; // continue to roll stack | |
24785 | 24934 | break; |
24786 | 24935 | } |
24787 | - case 2000LLU: // return from emitvar to ProcCall | |
24936 | + case 2014LLU: // return from emitvar to ProcCall | |
24788 | 24937 | { |
24789 | 24938 | // copy mutable arguments back from call to emitvar |
24790 | 24939 | printf("%s", ";"); |
24791 | - ((uint64_t **)(stack[base + 33]))[1][1] = stack[base + 36]; | |
24792 | - ((uint64_t **)(stack[base + 33]))[1][0] = stack[base + 35]; | |
24793 | - label = 1945LLU; // case complete | |
24940 | + ((uint64_t **)(stack[base + 35]))[1][1] = stack[base + 38]; | |
24941 | + ((uint64_t **)(stack[base + 35]))[1][0] = stack[base + 37]; | |
24942 | + label = 1959LLU; // case complete | |
24794 | 24943 | break; |
24795 | 24944 | } |
24796 | - case 1946LLU: // try next case | |
24945 | + case 1960LLU: // try next case | |
24797 | 24946 | { |
24798 | 24947 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
24799 | 24948 | exit(-1); |
24800 | 24949 | } |
24801 | - case 1945LLU: // completed switch | |
24950 | + case 1959LLU: // completed switch | |
24802 | 24951 | { |
24803 | - label = 1944LLU; // consequent complete | |
24952 | + label = 1958LLU; // consequent complete | |
24804 | 24953 | break; |
24805 | 24954 | } |
24806 | - case 1943LLU: // alternative | |
24955 | + case 1957LLU: // alternative | |
24807 | 24956 | { |
24808 | 24957 | fprintf(stderr, "%s", "expected identifier or constant argument but found "); |
24809 | 24958 | // call printtoken from ProcCall |
24810 | - stack[base + 35LLU] = 2001LLU/*throw to this address*/; | |
24811 | - stack[base + 36LLU] = base; | |
24812 | - stack[base + 37LLU] = 2002LLU; | |
24959 | + stack[base + 37LLU] = 2015LLU/*throw to this address*/; | |
24960 | + stack[base + 38LLU] = base; | |
24961 | + stack[base + 39LLU] = 2016LLU; | |
24813 | 24962 | // arguments for call to printtoken |
24814 | - stack[base + 38LLU] = stack[base + 14]/*variant*/; | |
24815 | - stack[base + 39LLU] = stack[base + 15]/*content*/; | |
24963 | + stack[base + 40LLU] = stack[base + 15]/*variant*/; | |
24964 | + stack[base + 41LLU] = stack[base + 16]/*content*/; | |
24816 | 24965 | // set stack-base & callee-address |
24817 | - base += 38LLU; | |
24966 | + base += 40LLU; | |
24818 | 24967 | label = 18446744073709551583LLU; // printtoken |
24819 | 24968 | break; |
24820 | 24969 | } |
24821 | - case 2001LLU: // copy-back deleter (printtoken to ProcCall) | |
24970 | + case 2015LLU: // copy-back deleter (printtoken to ProcCall) | |
24822 | 24971 | { |
24823 | 24972 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printtoken to ProcCall)\n"); |
24824 | 24973 | // copy mutable arguments back from call to printtoken |
24825 | - label = 1836LLU; // continue to roll stack | |
24974 | + label = 1850LLU; // continue to roll stack | |
24826 | 24975 | break; |
24827 | 24976 | } |
24828 | - case 2002LLU: // return from printtoken to ProcCall | |
24977 | + case 2016LLU: // return from printtoken to ProcCall | |
24829 | 24978 | { |
24830 | 24979 | // copy mutable arguments back from call to printtoken |
24831 | 24980 | fprintf(stderr, "%s", "\n"); |
24832 | 24981 | exit(-1); |
24833 | - label = 1944LLU; // alternative complete | |
24982 | + label = 1958LLU; // alternative complete | |
24834 | 24983 | break; |
24835 | 24984 | } |
24836 | - case 1944LLU: // completed if-then-else | |
24985 | + case 1958LLU: // completed if-then-else | |
24837 | 24986 | { |
24838 | - label = 1907LLU; // alternative complete | |
24987 | + label = 1921LLU; // alternative complete | |
24839 | 24988 | break; |
24840 | 24989 | } |
24841 | - case 1907LLU: // completed if-then-else | |
24990 | + case 1921LLU: // completed if-then-else | |
24842 | 24991 | { |
24843 | - ((struct listnode *)(stack[base + 34]/*previous*/))->data = stack[base + 33]; | |
24844 | - label = 1880LLU; // repeat | |
24992 | + ((struct listnode *)(stack[base + 36]/*previous*/))->data = stack[base + 35]; | |
24993 | + label = 1894LLU; // repeat | |
24845 | 24994 | break; |
24846 | 24995 | } |
24847 | - case 1881LLU: // loop finished | |
24996 | + case 1895LLU: // loop finished | |
24848 | 24997 | { |
24849 | 24998 | printf("%s", "\n // set stack-base & callee-address"); |
24850 | - stack[base + 28]/*sum*/ = 0; | |
24999 | + stack[base + 30]/*sum*/ = 0; | |
24851 | 25000 | // call add from ProcCall |
24852 | - stack[base + 32LLU] = 2003LLU/*throw to this address*/; | |
24853 | - stack[base + 33LLU] = base; | |
24854 | - stack[base + 34LLU] = 2004LLU; | |
25001 | + stack[base + 34LLU] = 2017LLU/*throw to this address*/; | |
25002 | + stack[base + 35LLU] = base; | |
25003 | + stack[base + 36LLU] = 2018LLU; | |
24855 | 25004 | // arguments for call to add |
24856 | - stack[base + 36LLU] = stack[base + 4]/*offset*/; | |
24857 | - stack[base + 37LLU] = stack[base + 28]/*sum*/; | |
25005 | + stack[base + 38LLU] = stack[base + 4]/*offset*/; | |
25006 | + stack[base + 39LLU] = stack[base + 30]/*sum*/; | |
24858 | 25007 | // set stack-base & callee-address |
24859 | - base += 35LLU; | |
25008 | + base += 37LLU; | |
24860 | 25009 | label = 18446744073709551605LLU; // add |
24861 | 25010 | break; |
24862 | 25011 | } |
24863 | - case 2003LLU: // copy-back deleter (add to ProcCall) | |
25012 | + case 2017LLU: // copy-back deleter (add to ProcCall) | |
24864 | 25013 | { |
24865 | 25014 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
24866 | 25015 | // copy mutable arguments back from call to add |
24867 | - label = 1836LLU; // continue to roll stack | |
25016 | + label = 1850LLU; // continue to roll stack | |
24868 | 25017 | break; |
24869 | 25018 | } |
24870 | - case 2004LLU: // return from add to ProcCall | |
25019 | + case 2018LLU: // return from add to ProcCall | |
24871 | 25020 | { |
24872 | 25021 | // copy mutable arguments back from call to add |
24873 | 25022 | // copy back results provided by call to add |
24874 | - stack[base + 28] = stack[base + 35LLU]; | |
25023 | + stack[base + 30] = stack[base + 37LLU]; | |
24875 | 25024 | // call add from ProcCall |
24876 | - stack[base + 32LLU] = 2005LLU/*throw to this address*/; | |
24877 | - stack[base + 33LLU] = base; | |
24878 | - stack[base + 34LLU] = 2006LLU; | |
25025 | + stack[base + 34LLU] = 2019LLU/*throw to this address*/; | |
25026 | + stack[base + 35LLU] = base; | |
25027 | + stack[base + 36LLU] = 2020LLU; | |
24879 | 25028 | // arguments for call to add |
24880 | - stack[base + 36LLU] = 3LLU; | |
24881 | - stack[base + 37LLU] = stack[base + 28]/*sum*/; | |
25029 | + stack[base + 38LLU] = 3LLU; | |
25030 | + stack[base + 39LLU] = stack[base + 30]/*sum*/; | |
24882 | 25031 | // set stack-base & callee-address |
24883 | - base += 35LLU; | |
25032 | + base += 37LLU; | |
24884 | 25033 | label = 18446744073709551605LLU; // add |
24885 | 25034 | break; |
24886 | 25035 | } |
24887 | - case 2005LLU: // copy-back deleter (add to ProcCall) | |
25036 | + case 2019LLU: // copy-back deleter (add to ProcCall) | |
24888 | 25037 | { |
24889 | 25038 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
24890 | 25039 | // copy mutable arguments back from call to add |
24891 | - label = 1836LLU; // continue to roll stack | |
25040 | + label = 1850LLU; // continue to roll stack | |
24892 | 25041 | break; |
24893 | 25042 | } |
24894 | - case 2006LLU: // return from add to ProcCall | |
25043 | + case 2020LLU: // return from add to ProcCall | |
24895 | 25044 | { |
24896 | 25045 | // copy mutable arguments back from call to add |
24897 | 25046 | // copy back results provided by call to add |
24898 | - stack[base + 28] = stack[base + 35LLU]; | |
25047 | + stack[base + 30] = stack[base + 37LLU]; | |
24899 | 25048 | // call add from ProcCall |
24900 | - stack[base + 32LLU] = 2007LLU/*throw to this address*/; | |
24901 | - stack[base + 33LLU] = base; | |
24902 | - stack[base + 34LLU] = 2008LLU; | |
25049 | + stack[base + 34LLU] = 2021LLU/*throw to this address*/; | |
25050 | + stack[base + 35LLU] = base; | |
25051 | + stack[base + 36LLU] = 2022LLU; | |
24903 | 25052 | // arguments for call to add |
24904 | - stack[base + 36LLU] = stack[base + 9]/*fnrescount*/; | |
24905 | - stack[base + 37LLU] = stack[base + 28]/*sum*/; | |
25053 | + stack[base + 38LLU] = stack[base + 10]/*fnrescount*/; | |
25054 | + stack[base + 39LLU] = stack[base + 30]/*sum*/; | |
24906 | 25055 | // set stack-base & callee-address |
24907 | - base += 35LLU; | |
25056 | + base += 37LLU; | |
24908 | 25057 | label = 18446744073709551605LLU; // add |
24909 | 25058 | break; |
24910 | 25059 | } |
24911 | - case 2007LLU: // copy-back deleter (add to ProcCall) | |
25060 | + case 2021LLU: // copy-back deleter (add to ProcCall) | |
24912 | 25061 | { |
24913 | 25062 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
24914 | 25063 | // copy mutable arguments back from call to add |
24915 | - label = 1836LLU; // continue to roll stack | |
25064 | + label = 1850LLU; // continue to roll stack | |
24916 | 25065 | break; |
24917 | 25066 | } |
24918 | - case 2008LLU: // return from add to ProcCall | |
25067 | + case 2022LLU: // return from add to ProcCall | |
24919 | 25068 | { |
24920 | 25069 | // copy mutable arguments back from call to add |
24921 | 25070 | // copy back results provided by call to add |
24922 | - stack[base + 28] = stack[base + 35LLU]; | |
25071 | + stack[base + 30] = stack[base + 37LLU]; | |
24923 | 25072 | // call add from ProcCall |
24924 | - stack[base + 32LLU] = 2009LLU/*throw to this address*/; | |
24925 | - stack[base + 33LLU] = base; | |
24926 | - stack[base + 34LLU] = 2010LLU; | |
25073 | + stack[base + 34LLU] = 2023LLU/*throw to this address*/; | |
25074 | + stack[base + 35LLU] = base; | |
25075 | + stack[base + 36LLU] = 2024LLU; | |
24927 | 25076 | // arguments for call to add |
24928 | - stack[base + 36LLU] = stack[base + 10]/*fnargcount*/; | |
24929 | - stack[base + 37LLU] = stack[base + 28]/*sum*/; | |
25077 | + stack[base + 38LLU] = stack[base + 11]/*fnargcount*/; | |
25078 | + stack[base + 39LLU] = stack[base + 30]/*sum*/; | |
24930 | 25079 | // set stack-base & callee-address |
24931 | - base += 35LLU; | |
25080 | + base += 37LLU; | |
24932 | 25081 | label = 18446744073709551605LLU; // add |
24933 | 25082 | break; |
24934 | 25083 | } |
24935 | - case 2009LLU: // copy-back deleter (add to ProcCall) | |
25084 | + case 2023LLU: // copy-back deleter (add to ProcCall) | |
24936 | 25085 | { |
24937 | 25086 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n"); |
24938 | 25087 | // copy mutable arguments back from call to add |
24939 | - label = 1836LLU; // continue to roll stack | |
25088 | + label = 1850LLU; // continue to roll stack | |
24940 | 25089 | break; |
24941 | 25090 | } |
24942 | - case 2010LLU: // return from add to ProcCall | |
25091 | + case 2024LLU: // return from add to ProcCall | |
24943 | 25092 | { |
24944 | 25093 | // copy mutable arguments back from call to add |
24945 | 25094 | // copy back results provided by call to add |
24946 | - stack[base + 28] = stack[base + 35LLU]; | |
25095 | + stack[base + 30] = stack[base + 37LLU]; | |
24947 | 25096 | printf("%s", "\n base += "); |
24948 | 25097 | // call printnr from ProcCall |
24949 | - stack[base + 32LLU] = 2011LLU/*throw to this address*/; | |
24950 | - stack[base + 33LLU] = base; | |
24951 | - stack[base + 34LLU] = 2012LLU; | |
25098 | + stack[base + 34LLU] = 2025LLU/*throw to this address*/; | |
25099 | + stack[base + 35LLU] = base; | |
25100 | + stack[base + 36LLU] = 2026LLU; | |
24952 | 25101 | // arguments for call to printnr |
24953 | - stack[base + 35LLU] = stack[base + 28]/*sum*/; | |
25102 | + stack[base + 37LLU] = stack[base + 30]/*sum*/; | |
24954 | 25103 | // set stack-base & callee-address |
24955 | - base += 35LLU; | |
25104 | + base += 37LLU; | |
24956 | 25105 | label = 18446744073709551590LLU; // printnr |
24957 | 25106 | break; |
24958 | 25107 | } |
24959 | - case 2011LLU: // copy-back deleter (printnr to ProcCall) | |
25108 | + case 2025LLU: // copy-back deleter (printnr to ProcCall) | |
24960 | 25109 | { |
24961 | 25110 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n"); |
24962 | 25111 | // copy mutable arguments back from call to printnr |
24963 | - label = 1836LLU; // continue to roll stack | |
25112 | + label = 1850LLU; // continue to roll stack | |
24964 | 25113 | break; |
24965 | 25114 | } |
24966 | - case 2012LLU: // return from printnr to ProcCall | |
25115 | + case 2026LLU: // return from printnr to ProcCall | |
24967 | 25116 | { |
24968 | 25117 | // copy mutable arguments back from call to printnr |
24969 | 25118 | printf("%s", "LLU;"); |
24970 | 25119 | printf("%s", "\n label = "); |
24971 | 25120 | // call printnr from ProcCall |
24972 | - stack[base + 32LLU] = 2013LLU/*throw to this address*/; | |
24973 | - stack[base + 33LLU] = base; | |
24974 | - stack[base + 34LLU] = 2014LLU; | |
25121 | + stack[base + 34LLU] = 2027LLU/*throw to this address*/; | |
25122 | + stack[base + 35LLU] = base; | |
25123 | + stack[base + 36LLU] = 2028LLU; | |
24975 | 25124 | // arguments for call to printnr |
24976 | - stack[base + 35LLU] = stack[base + 19]/*celabel*/; | |
25125 | + stack[base + 37LLU] = stack[base + 20]/*celabel*/; | |
24977 | 25126 | // set stack-base & callee-address |
24978 | - base += 35LLU; | |
25127 | + base += 37LLU; | |
24979 | 25128 | label = 18446744073709551590LLU; // printnr |
24980 | 25129 | break; |
24981 | 25130 | } |
24982 | - case 2013LLU: // copy-back deleter (printnr to ProcCall) | |
25131 | + case 2027LLU: // copy-back deleter (printnr to ProcCall) | |
24983 | 25132 | { |
24984 | 25133 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n"); |
24985 | 25134 | // copy mutable arguments back from call to printnr |
24986 | - label = 1836LLU; // continue to roll stack | |
25135 | + label = 1850LLU; // continue to roll stack | |
24987 | 25136 | break; |
24988 | 25137 | } |
24989 | - case 2014LLU: // return from printnr to ProcCall | |
25138 | + case 2028LLU: // return from printnr to ProcCall | |
24990 | 25139 | { |
24991 | 25140 | // copy mutable arguments back from call to printnr |
24992 | 25141 | printf("%s", "LLU; // "); |
24993 | 25142 | // call printid from ProcCall |
24994 | - stack[base + 32LLU] = 2015LLU/*throw to this address*/; | |
24995 | - stack[base + 33LLU] = base; | |
24996 | - stack[base + 34LLU] = 2016LLU; | |
25143 | + stack[base + 34LLU] = 2029LLU/*throw to this address*/; | |
25144 | + stack[base + 35LLU] = base; | |
25145 | + stack[base + 36LLU] = 2030LLU; | |
24997 | 25146 | // arguments for call to printid |
24998 | - stack[base + 35LLU] = stack[base + 23]/*ceid*/; | |
25147 | + stack[base + 37LLU] = stack[base + 24]/*ceid*/; | |
24999 | 25148 | // set stack-base & callee-address |
25000 | - base += 35LLU; | |
25149 | + base += 37LLU; | |
25001 | 25150 | label = 18446744073709551587LLU; // printid |
25002 | 25151 | break; |
25003 | 25152 | } |
25004 | - case 2015LLU: // copy-back deleter (printid to ProcCall) | |
25153 | + case 2029LLU: // copy-back deleter (printid to ProcCall) | |
25005 | 25154 | { |
25006 | 25155 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n"); |
25007 | 25156 | // copy mutable arguments back from call to printid |
25008 | - label = 1836LLU; // continue to roll stack | |
25157 | + label = 1850LLU; // continue to roll stack | |
25009 | 25158 | break; |
25010 | 25159 | } |
25011 | - case 2016LLU: // return from printid to ProcCall | |
25160 | + case 2030LLU: // return from printid to ProcCall | |
25012 | 25161 | { |
25013 | 25162 | // copy mutable arguments back from call to printid |
25014 | 25163 | printf("%s", "\n break;"); |
@@ -25015,78 +25164,78 @@ | ||
25015 | 25164 | printf("%s", "\n }"); |
25016 | 25165 | if(/*scope*/0 != ((uint64_t *)(stack[base + 3]/*scope*/))[0]) |
25017 | 25166 | { |
25018 | - label = 2018LLU; // jump to alternative | |
25167 | + label = 2032LLU; // jump to alternative | |
25019 | 25168 | break; |
25020 | 25169 | } |
25021 | 25170 | |
25022 | - /*labelthrow*/stack[base + 32] = ((uint64_t **)(stack[base + 3]/*scope*/))[1][0]/*deleteaddr*/; | |
25023 | - /*dummy*/stack[base + 33] = ((uint64_t **)(stack[base + 3]/*scope*/))[1][1]/*letdefs*/; | |
25171 | + /*labelthrow*/stack[base + 34] = ((uint64_t **)(stack[base + 3]/*scope*/))[1][0]/*deleteaddr*/; | |
25172 | + /*dummy*/stack[base + 35] = ((uint64_t **)(stack[base + 3]/*scope*/))[1][1]/*letdefs*/; | |
25024 | 25173 | |
25025 | 25174 | // case |
25026 | 25175 | printf("%s", "\n case "); |
25027 | 25176 | // call printnr from ProcCall |
25028 | - stack[base + 34LLU] = 2019LLU/*throw to this address*/; | |
25029 | - stack[base + 35LLU] = base; | |
25030 | - stack[base + 36LLU] = 2020LLU; | |
25177 | + stack[base + 36LLU] = 2033LLU/*throw to this address*/; | |
25178 | + stack[base + 37LLU] = base; | |
25179 | + stack[base + 38LLU] = 2034LLU; | |
25031 | 25180 | // arguments for call to printnr |
25032 | - stack[base + 37LLU] = stack[base + 31]/*labelfail*/; | |
25181 | + stack[base + 39LLU] = stack[base + 33]/*labelfail*/; | |
25033 | 25182 | // set stack-base & callee-address |
25034 | - base += 37LLU; | |
25183 | + base += 39LLU; | |
25035 | 25184 | label = 18446744073709551590LLU; // printnr |
25036 | 25185 | break; |
25037 | 25186 | } |
25038 | - case 2019LLU: // copy-back deleter (printnr to ProcCall) | |
25187 | + case 2033LLU: // copy-back deleter (printnr to ProcCall) | |
25039 | 25188 | { |
25040 | 25189 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n"); |
25041 | 25190 | // copy mutable arguments back from call to printnr |
25042 | - label = 1836LLU; // continue to roll stack | |
25191 | + label = 1850LLU; // continue to roll stack | |
25043 | 25192 | break; |
25044 | 25193 | } |
25045 | - case 2020LLU: // return from printnr to ProcCall | |
25194 | + case 2034LLU: // return from printnr to ProcCall | |
25046 | 25195 | { |
25047 | 25196 | // copy mutable arguments back from call to printnr |
25048 | 25197 | printf("%s", "LLU: // copy-back deleter ("); |
25049 | 25198 | // call printid from ProcCall |
25050 | - stack[base + 34LLU] = 2021LLU/*throw to this address*/; | |
25051 | - stack[base + 35LLU] = base; | |
25052 | - stack[base + 36LLU] = 2022LLU; | |
25199 | + stack[base + 36LLU] = 2035LLU/*throw to this address*/; | |
25200 | + stack[base + 37LLU] = base; | |
25201 | + stack[base + 38LLU] = 2036LLU; | |
25053 | 25202 | // arguments for call to printid |
25054 | - stack[base + 37LLU] = stack[base + 23]/*ceid*/; | |
25203 | + stack[base + 39LLU] = stack[base + 24]/*ceid*/; | |
25055 | 25204 | // set stack-base & callee-address |
25056 | - base += 37LLU; | |
25205 | + base += 39LLU; | |
25057 | 25206 | label = 18446744073709551587LLU; // printid |
25058 | 25207 | break; |
25059 | 25208 | } |
25060 | - case 2021LLU: // copy-back deleter (printid to ProcCall) | |
25209 | + case 2035LLU: // copy-back deleter (printid to ProcCall) | |
25061 | 25210 | { |
25062 | 25211 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n"); |
25063 | 25212 | // copy mutable arguments back from call to printid |
25064 | - label = 1836LLU; // continue to roll stack | |
25213 | + label = 1850LLU; // continue to roll stack | |
25065 | 25214 | break; |
25066 | 25215 | } |
25067 | - case 2022LLU: // return from printid to ProcCall | |
25216 | + case 2036LLU: // return from printid to ProcCall | |
25068 | 25217 | { |
25069 | 25218 | // copy mutable arguments back from call to printid |
25070 | 25219 | printf("%s", " to "); |
25071 | 25220 | // call printid from ProcCall |
25072 | - stack[base + 34LLU] = 2023LLU/*throw to this address*/; | |
25073 | - stack[base + 35LLU] = base; | |
25074 | - stack[base + 36LLU] = 2024LLU; | |
25221 | + stack[base + 36LLU] = 2037LLU/*throw to this address*/; | |
25222 | + stack[base + 37LLU] = base; | |
25223 | + stack[base + 38LLU] = 2038LLU; | |
25075 | 25224 | // arguments for call to printid |
25076 | - stack[base + 37LLU] = stack[base + 7]/*fnid*/; | |
25225 | + stack[base + 39LLU] = stack[base + 8]/*fnid*/; | |
25077 | 25226 | // set stack-base & callee-address |
25078 | - base += 37LLU; | |
25227 | + base += 39LLU; | |
25079 | 25228 | label = 18446744073709551587LLU; // printid |
25080 | 25229 | break; |
25081 | 25230 | } |
25082 | - case 2023LLU: // copy-back deleter (printid to ProcCall) | |
25231 | + case 2037LLU: // copy-back deleter (printid to ProcCall) | |
25083 | 25232 | { |
25084 | 25233 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n"); |
25085 | 25234 | // copy mutable arguments back from call to printid |
25086 | - label = 1836LLU; // continue to roll stack | |
25235 | + label = 1850LLU; // continue to roll stack | |
25087 | 25236 | break; |
25088 | 25237 | } |
25089 | - case 2024LLU: // return from printid to ProcCall | |
25238 | + case 2038LLU: // return from printid to ProcCall | |
25090 | 25239 | { |
25091 | 25240 | // copy mutable arguments back from call to printid |
25092 | 25241 | printf("%s", ")"); |
@@ -25093,68 +25242,68 @@ | ||
25093 | 25242 | printf("%s", "\n {"); |
25094 | 25243 | printf("%s", "\n fprintf(stderr, \"in function "); |
25095 | 25244 | // call printid from ProcCall |
25096 | - stack[base + 34LLU] = 2025LLU/*throw to this address*/; | |
25097 | - stack[base + 35LLU] = base; | |
25098 | - stack[base + 36LLU] = 2026LLU; | |
25245 | + stack[base + 36LLU] = 2039LLU/*throw to this address*/; | |
25246 | + stack[base + 37LLU] = base; | |
25247 | + stack[base + 38LLU] = 2040LLU; | |
25099 | 25248 | // arguments for call to printid |
25100 | - stack[base + 37LLU] = stack[base + 7]/*fnid*/; | |
25249 | + stack[base + 39LLU] = stack[base + 8]/*fnid*/; | |
25101 | 25250 | // set stack-base & callee-address |
25102 | - base += 37LLU; | |
25251 | + base += 39LLU; | |
25103 | 25252 | label = 18446744073709551587LLU; // printid |
25104 | 25253 | break; |
25105 | 25254 | } |
25106 | - case 2025LLU: // copy-back deleter (printid to ProcCall) | |
25255 | + case 2039LLU: // copy-back deleter (printid to ProcCall) | |
25107 | 25256 | { |
25108 | 25257 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n"); |
25109 | 25258 | // copy mutable arguments back from call to printid |
25110 | - label = 1836LLU; // continue to roll stack | |
25259 | + label = 1850LLU; // continue to roll stack | |
25111 | 25260 | break; |
25112 | 25261 | } |
25113 | - case 2026LLU: // return from printid to ProcCall | |
25262 | + case 2040LLU: // return from printid to ProcCall | |
25114 | 25263 | { |
25115 | 25264 | // copy mutable arguments back from call to printid |
25116 | 25265 | printf("%s", ": unrolling stack, copy-back ("); |
25117 | 25266 | // call printid from ProcCall |
25118 | - stack[base + 34LLU] = 2027LLU/*throw to this address*/; | |
25119 | - stack[base + 35LLU] = base; | |
25120 | - stack[base + 36LLU] = 2028LLU; | |
25267 | + stack[base + 36LLU] = 2041LLU/*throw to this address*/; | |
25268 | + stack[base + 37LLU] = base; | |
25269 | + stack[base + 38LLU] = 2042LLU; | |
25121 | 25270 | // arguments for call to printid |
25122 | - stack[base + 37LLU] = stack[base + 23]/*ceid*/; | |
25271 | + stack[base + 39LLU] = stack[base + 24]/*ceid*/; | |
25123 | 25272 | // set stack-base & callee-address |
25124 | - base += 37LLU; | |
25273 | + base += 39LLU; | |
25125 | 25274 | label = 18446744073709551587LLU; // printid |
25126 | 25275 | break; |
25127 | 25276 | } |
25128 | - case 2027LLU: // copy-back deleter (printid to ProcCall) | |
25277 | + case 2041LLU: // copy-back deleter (printid to ProcCall) | |
25129 | 25278 | { |
25130 | 25279 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n"); |
25131 | 25280 | // copy mutable arguments back from call to printid |
25132 | - label = 1836LLU; // continue to roll stack | |
25281 | + label = 1850LLU; // continue to roll stack | |
25133 | 25282 | break; |
25134 | 25283 | } |
25135 | - case 2028LLU: // return from printid to ProcCall | |
25284 | + case 2042LLU: // return from printid to ProcCall | |
25136 | 25285 | { |
25137 | 25286 | // copy mutable arguments back from call to printid |
25138 | 25287 | printf("%s", " to "); |
25139 | 25288 | // call printid from ProcCall |
25140 | - stack[base + 34LLU] = 2029LLU/*throw to this address*/; | |
25141 | - stack[base + 35LLU] = base; | |
25142 | - stack[base + 36LLU] = 2030LLU; | |
25289 | + stack[base + 36LLU] = 2043LLU/*throw to this address*/; | |
25290 | + stack[base + 37LLU] = base; | |
25291 | + stack[base + 38LLU] = 2044LLU; | |
25143 | 25292 | // arguments for call to printid |
25144 | - stack[base + 37LLU] = stack[base + 7]/*fnid*/; | |
25293 | + stack[base + 39LLU] = stack[base + 8]/*fnid*/; | |
25145 | 25294 | // set stack-base & callee-address |
25146 | - base += 37LLU; | |
25295 | + base += 39LLU; | |
25147 | 25296 | label = 18446744073709551587LLU; // printid |
25148 | 25297 | break; |
25149 | 25298 | } |
25150 | - case 2029LLU: // copy-back deleter (printid to ProcCall) | |
25299 | + case 2043LLU: // copy-back deleter (printid to ProcCall) | |
25151 | 25300 | { |
25152 | 25301 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n"); |
25153 | 25302 | // copy mutable arguments back from call to printid |
25154 | - label = 1836LLU; // continue to roll stack | |
25303 | + label = 1850LLU; // continue to roll stack | |
25155 | 25304 | break; |
25156 | 25305 | } |
25157 | - case 2030LLU: // return from printid to ProcCall | |
25306 | + case 2044LLU: // return from printid to ProcCall | |
25158 | 25307 | { |
25159 | 25308 | // copy mutable arguments back from call to printid |
25160 | 25309 | printf("%s", ")"); |
@@ -25161,339 +25310,339 @@ | ||
25161 | 25310 | printf("%s", "\\n\");"); |
25162 | 25311 | printf("%s", "\n // copy mutable arguments back from call to "); |
25163 | 25312 | // call printid from ProcCall |
25164 | - stack[base + 34LLU] = 2031LLU/*throw to this address*/; | |
25165 | - stack[base + 35LLU] = base; | |
25166 | - stack[base + 36LLU] = 2032LLU; | |
25313 | + stack[base + 36LLU] = 2045LLU/*throw to this address*/; | |
25314 | + stack[base + 37LLU] = base; | |
25315 | + stack[base + 38LLU] = 2046LLU; | |
25167 | 25316 | // arguments for call to printid |
25168 | - stack[base + 37LLU] = stack[base + 23]/*ceid*/; | |
25317 | + stack[base + 39LLU] = stack[base + 24]/*ceid*/; | |
25169 | 25318 | // set stack-base & callee-address |
25170 | - base += 37LLU; | |
25319 | + base += 39LLU; | |
25171 | 25320 | label = 18446744073709551587LLU; // printid |
25172 | 25321 | break; |
25173 | 25322 | } |
25174 | - case 2031LLU: // copy-back deleter (printid to ProcCall) | |
25323 | + case 2045LLU: // copy-back deleter (printid to ProcCall) | |
25175 | 25324 | { |
25176 | 25325 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n"); |
25177 | 25326 | // copy mutable arguments back from call to printid |
25178 | - label = 1836LLU; // continue to roll stack | |
25327 | + label = 1850LLU; // continue to roll stack | |
25179 | 25328 | break; |
25180 | 25329 | } |
25181 | - case 2032LLU: // return from printid to ProcCall | |
25330 | + case 2046LLU: // return from printid to ProcCall | |
25182 | 25331 | { |
25183 | 25332 | // copy mutable arguments back from call to printid |
25184 | - flippedassign(stack[base + 18]/*copyback*/, &stack[base + 34]); | |
25185 | - label = 2033LLU; // start to repeat | |
25333 | + flippedassign(stack[base + 19]/*copyback*/, &stack[base + 36]); | |
25334 | + label = 2047LLU; // start to repeat | |
25186 | 25335 | break; |
25187 | 25336 | } |
25188 | - case 2033LLU: // repeat from here | |
25337 | + case 2047LLU: // repeat from here | |
25189 | 25338 | { |
25190 | - if(!stack[base + 34]) | |
25339 | + if(!stack[base + 36]) | |
25191 | 25340 | { |
25192 | - label = 2034LLU; // break loop | |
25341 | + label = 2048LLU; // break loop | |
25193 | 25342 | break; |
25194 | 25343 | } |
25195 | 25344 | |
25196 | 25345 | // loop body |
25197 | - stack[base + 35] = (uint64_t)(((const struct listnode *)(stack[base + 34]))->data); | |
25198 | - stack[base + 36]/*previous*/ = stack[base + 34]; | |
25199 | - stack[base + 34] = (uint64_t)(((const struct listnode *)(stack[base + 34]))->next); | |
25200 | - if(/*idnr*/0 != ((uint64_t *)(stack[base + 35]/*idnr*/))[0]) | |
25346 | + stack[base + 37] = (uint64_t)(((const struct listnode *)(stack[base + 36]))->data); | |
25347 | + stack[base + 38]/*previous*/ = stack[base + 36]; | |
25348 | + stack[base + 36] = (uint64_t)(((const struct listnode *)(stack[base + 36]))->next); | |
25349 | + if(/*idnr*/0 != ((uint64_t *)(stack[base + 37]/*idnr*/))[0]) | |
25201 | 25350 | { |
25202 | - label = 2036LLU; // jump to alternative | |
25351 | + label = 2050LLU; // jump to alternative | |
25203 | 25352 | break; |
25204 | 25353 | } |
25205 | 25354 | |
25206 | - /*content*/stack[base + 37] = ((uint64_t **)(stack[base + 35]/*idnr*/))[1][0]/*id*/; | |
25207 | - /*sum*/stack[base + 38] = ((uint64_t **)(stack[base + 35]/*idnr*/))[1][1]/*nr*/; | |
25355 | + /*content*/stack[base + 39] = ((uint64_t **)(stack[base + 37]/*idnr*/))[1][0]/*id*/; | |
25356 | + /*sum*/stack[base + 40] = ((uint64_t **)(stack[base + 37]/*idnr*/))[1][1]/*nr*/; | |
25208 | 25357 | |
25209 | 25358 | // case |
25210 | 25359 | printf("%s", "\n "); |
25211 | 25360 | // call emitvar from ProcCall |
25212 | - stack[base + 39LLU] = 2037LLU/*throw to this address*/; | |
25213 | - stack[base + 40LLU] = base; | |
25214 | - stack[base + 41LLU] = 2038LLU; | |
25361 | + stack[base + 41LLU] = 2051LLU/*throw to this address*/; | |
25362 | + stack[base + 42LLU] = base; | |
25363 | + stack[base + 43LLU] = 2052LLU; | |
25215 | 25364 | // arguments for call to emitvar |
25216 | - stack[base + 42LLU] = stack[base + 7]/*fnid*/; | |
25217 | - stack[base + 43LLU] = stack[base + 37]/*content*/; | |
25218 | - stack[base + 44LLU] = stack[base + 2]/*scopes*/; | |
25219 | - stack[base + 45LLU] = stack[base + 3]/*scope*/; | |
25365 | + stack[base + 44LLU] = stack[base + 8]/*fnid*/; | |
25366 | + stack[base + 45LLU] = stack[base + 39]/*content*/; | |
25367 | + stack[base + 46LLU] = stack[base + 2]/*scopes*/; | |
25368 | + stack[base + 47LLU] = stack[base + 3]/*scope*/; | |
25220 | 25369 | // set stack-base & callee-address |
25221 | - base += 42LLU; | |
25370 | + base += 44LLU; | |
25222 | 25371 | label = 659LLU; // emitvar |
25223 | 25372 | break; |
25224 | 25373 | } |
25225 | - case 2037LLU: // copy-back deleter (emitvar to ProcCall) | |
25374 | + case 2051LLU: // copy-back deleter (emitvar to ProcCall) | |
25226 | 25375 | { |
25227 | 25376 | fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (emitvar to ProcCall)\n"); |
25228 | 25377 | // copy mutable arguments back from call to emitvar |
25229 | - label = 1836LLU; // continue to roll stack | |
25378 | + label = 1850LLU; // continue to roll stack | |
25230 | 25379 | break; |
25231 | 25380 | } |
25232 | - case 2038LLU: // return from emitvar to ProcCall | |
25381 | + case 2052LLU: // return from emitvar to ProcCall | |
25233 | 25382 | { |
25234 | 25383 | // copy mutable arguments back from call to emitvar |
25235 | 25384 | printf("%s", " = stack[base + "); |
25236 | 25385 | // call printnr from ProcCall |
25237 | - stack[base + 39LLU] = 2039LLU/*throw to this address*/; | |
25238 | - stack[base + 40LLU] = base; | |
25239 | - stack[base + 41LLU] = 2040LLU; | |
25386 | + stack[base + 41LLU] = 2053LLU/*throw to this address*/; | |
25387 | + s |
Part of diff was cut off due to size limit. Use your local client to view the full diff.