Revisão | 1210 (tree) |
---|---|
Hora | 2021-03-28 08:13:23 |
Autor | jakobthomsen |
cleanup
@@ -37304,13 +37304,13 @@ | ||
37304 | 37304 | base = stack[base - 2]; |
37305 | 37305 | break; |
37306 | 37306 | } |
37307 | - case 3142LLU: // function AssignFrom failed | |
37307 | + case 3142LLU: // function assignment failed | |
37308 | 37308 | { |
37309 | 37309 | label = stack[base - 3]; |
37310 | 37310 | base = stack[base - 2]; |
37311 | 37311 | break; |
37312 | 37312 | } |
37313 | - case 3141LLU: // AssignFrom | |
37313 | + case 3141LLU: // assignment | |
37314 | 37314 | { |
37315 | 37315 | //#define arg0 0 |
37316 | 37316 | //#define arg1 1 |
@@ -37318,20 +37318,13 @@ | ||
37318 | 37318 | //#define arg3 3 |
37319 | 37319 | //#define arg4 4 |
37320 | 37320 | //#define arg5 5 |
37321 | -//#define arg6 6 | |
37322 | -//#define arg7 7 | |
37323 | -//#define arg8 8 | |
37324 | -//#define arg9 9 | |
37325 | -//#define arg10 10 | |
37326 | -//#define arg11 11 | |
37327 | -//#define arg12 12 | |
37328 | 37321 | label = 3144LLU; // skip deleter |
37329 | 37322 | break; |
37330 | 37323 | } |
37331 | 37324 | case 3143LLU: // deleter |
37332 | 37325 | { |
37333 | - // throw from AssignFrom | |
37334 | - if(!stack[base + 13]) | |
37326 | + // throw from assignment | |
37327 | + if(!stack[base + 6]) | |
37335 | 37328 | { |
37336 | 37329 | label = 3142LLU; // skip, variable already deleted/unscoped |
37337 | 37330 | break; |
@@ -37341,332 +37334,407 @@ | ||
37341 | 37334 | } |
37342 | 37335 | case 3144LLU: // skipped deleter |
37343 | 37336 | { |
37344 | - stack[base + 13] = 0; | |
37345 | - label = 3146LLU; // skip deleter | |
37337 | + stack[base + 6] = 0; | |
37338 | + if(/*letdef*/0 != ((uint64_t *)(stack[base + 1]/*letdef*/))[0]) | |
37339 | + { | |
37340 | + label = 3146LLU; // jump to alternative | |
37341 | + break; | |
37342 | + } | |
37343 | + | |
37344 | + /*type*/stack[base + 7] = ((uint64_t **)(stack[base + 1]/*letdef*/))[1][0]/*type*/; | |
37345 | + /*id*/stack[base + 8] = ((uint64_t **)(stack[base + 1]/*letdef*/))[1][1]/*id*/; | |
37346 | + /*index*/stack[base + 9] = ((uint64_t **)(stack[base + 1]/*letdef*/))[1][2]/*index*/; | |
37347 | + /*mutable*/stack[base + 10] = ((uint64_t **)(stack[base + 1]/*letdef*/))[1][3]/*mutable*/; | |
37348 | + /*substruct*/stack[base + 11] = ((uint64_t **)(stack[base + 1]/*letdef*/))[1][4]/*substruct*/; | |
37349 | + | |
37350 | + // case | |
37351 | + if(!stack[base + 10]/*mutable*/) | |
37352 | + { | |
37353 | + label = 3148LLU; // jump to alternative | |
37354 | + break; | |
37355 | + } | |
37356 | + | |
37357 | + // consequent | |
37358 | + label = 3149LLU; // consequent complete | |
37346 | 37359 | break; |
37347 | 37360 | } |
37348 | - case 3145LLU: // deleter | |
37361 | + case 3148LLU: // alternative | |
37349 | 37362 | { |
37350 | - // throw from AssignFrom | |
37351 | - if(!stack[base + 14]) | |
37363 | + fprintf(stderr, "%s", "in function "); | |
37364 | + // call reportid from assignment | |
37365 | + stack[base + 12LLU] = 3150LLU/*throw to this address*/; | |
37366 | + stack[base + 13LLU] = base; | |
37367 | + stack[base + 14LLU] = 3151LLU; | |
37368 | + // arguments for call to reportid | |
37369 | + stack[base + 15LLU] = stack[base + 0]/*fnid*/; | |
37370 | + // set stack-base & callee-address | |
37371 | + base += 15LLU; | |
37372 | + label = 18446744073709551586LLU; // reportid | |
37373 | + break; | |
37374 | + } | |
37375 | + case 3150LLU: // copy-back deleter (reportid to assignment) | |
37376 | + { | |
37377 | + // copy mutable arguments back from call to reportid | |
37378 | + label = 3147LLU; // continue to roll stack | |
37379 | + break; | |
37380 | + } | |
37381 | + case 3151LLU: // return from reportid to assignment | |
37382 | + { | |
37383 | + // copy mutable arguments back from call to reportid | |
37384 | + fprintf(stderr, "%s", ": assignment to constant "); | |
37385 | + // call reportid from assignment | |
37386 | + stack[base + 12LLU] = 3152LLU/*throw to this address*/; | |
37387 | + stack[base + 13LLU] = base; | |
37388 | + stack[base + 14LLU] = 3153LLU; | |
37389 | + // arguments for call to reportid | |
37390 | + stack[base + 15LLU] = stack[base + 8]/*id*/; | |
37391 | + // set stack-base & callee-address | |
37392 | + base += 15LLU; | |
37393 | + label = 18446744073709551586LLU; // reportid | |
37394 | + break; | |
37395 | + } | |
37396 | + case 3152LLU: // copy-back deleter (reportid to assignment) | |
37397 | + { | |
37398 | + // copy mutable arguments back from call to reportid | |
37399 | + label = 3147LLU; // continue to roll stack | |
37400 | + break; | |
37401 | + } | |
37402 | + case 3153LLU: // return from reportid to assignment | |
37403 | + { | |
37404 | + // copy mutable arguments back from call to reportid | |
37405 | + fprintf(stderr, "%s", "\n"); | |
37352 | 37406 | { |
37353 | - label = 3143LLU; // skip, variable already deleted/unscoped | |
37407 | + label = 3147LLU; // throw: begin to unroll stack | |
37354 | 37408 | break; |
37355 | 37409 | } |
37356 | 37410 | |
37357 | - uint64_t *newstack = (uint64_t *)(stack[base + 14] - sizeof(uint64_t) * 4); | |
37358 | - // call ~type from AssignFrom | |
37359 | - newstack[0] = (uint64_t)stack; // backup stack location | |
37360 | - newstack[1] = 1234567890; | |
37361 | - newstack[2] = base; | |
37362 | - newstack[3] = 3147LLU; | |
37363 | - stack = newstack; | |
37364 | - // set stack-base & callee-address | |
37365 | - base = 4/*deloffset*/; | |
37366 | - label = 310LLU; // ~type | |
37411 | + label = 3149LLU; // alternative complete | |
37367 | 37412 | break; |
37368 | 37413 | } |
37369 | - case 3147LLU: // return from ~type to AssignFrom | |
37414 | + case 3149LLU: // completed if-then-else | |
37370 | 37415 | { |
37371 | - stack = (uint64_t *)stack[0]; | |
37372 | - // releasing toplevel container | |
37373 | - Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 14] - sizeof(uint64_t) * 4)); | |
37374 | - | |
37375 | - label = 3143LLU; // continue unrolling stack, delete next variable | |
37416 | + label = 3155LLU; // skip deleter | |
37376 | 37417 | break; |
37377 | 37418 | } |
37378 | - case 3146LLU: // skipped deleter | |
37419 | + case 3154LLU: // deleter | |
37379 | 37420 | { |
37380 | - // call getlettype from AssignFrom | |
37381 | - stack[base + 15LLU] = 3148LLU/*throw to this address*/; | |
37382 | - stack[base + 16LLU] = base; | |
37383 | - stack[base + 17LLU] = 3149LLU; | |
37384 | - // arguments for call to getlettype | |
37385 | - stack[base + 19LLU] = stack[base + 0]/*fnid*/; | |
37386 | - stack[base + 20LLU] = stack[base + 1]/*id*/; | |
37387 | - stack[base + 21LLU] = stack[base + 4]/*scopes*/; | |
37388 | - stack[base + 22LLU] = stack[base + 5]/*scope*/; | |
37421 | + // throw from assignment | |
37422 | + if(!stack[base + 12]) | |
37423 | + { | |
37424 | + label = 3147LLU; // skip, variable already deleted/unscoped | |
37425 | + break; | |
37426 | + } | |
37427 | + label = 3147LLU; // continue unrolling stack, delete next variable | |
37428 | + break; | |
37429 | + } | |
37430 | + case 3155LLU: // skipped deleter | |
37431 | + { | |
37432 | + label = 3157LLU; // skip deleter | |
37433 | + break; | |
37434 | + } | |
37435 | + case 3156LLU: // deleter | |
37436 | + { | |
37437 | + // throw from assignment | |
37438 | + if(!stack[base + 13]) | |
37439 | + { | |
37440 | + label = 3154LLU; // skip, variable already deleted/unscoped | |
37441 | + break; | |
37442 | + } | |
37443 | + label = 3154LLU; // continue unrolling stack, delete next variable | |
37444 | + break; | |
37445 | + } | |
37446 | + case 3157LLU: // skipped deleter | |
37447 | + { | |
37448 | + // call ParseToken from assignment | |
37449 | + stack[base + 14LLU] = 3158LLU/*throw to this address*/; | |
37450 | + stack[base + 15LLU] = base; | |
37451 | + stack[base + 16LLU] = 3159LLU; | |
37452 | + // arguments for call to ParseToken | |
37453 | + stack[base + 19LLU] = stack[base + 5]/*lookahead*/; | |
37389 | 37454 | // set stack-base & callee-address |
37390 | - base += 18LLU; | |
37391 | - label = 692LLU; // getlettype | |
37455 | + base += 17LLU; | |
37456 | + label = 3LLU; // ParseToken | |
37392 | 37457 | break; |
37393 | 37458 | } |
37394 | - case 3148LLU: // copy-back deleter (getlettype to AssignFrom) | |
37459 | + case 3158LLU: // copy-back deleter (ParseToken to assignment) | |
37395 | 37460 | { |
37396 | - // copy mutable arguments back from call to getlettype | |
37397 | - label = 3143LLU; // continue to roll stack | |
37461 | + // copy mutable arguments back from call to ParseToken | |
37462 | + stack[base + 5]/*lookahead*/ = stack[base + 19LLU]; | |
37463 | + label = 3147LLU; // continue to roll stack | |
37398 | 37464 | break; |
37399 | 37465 | } |
37400 | - case 3149LLU: // return from getlettype to AssignFrom | |
37466 | + case 3159LLU: // return from ParseToken to assignment | |
37401 | 37467 | { |
37402 | - // copy mutable arguments back from call to getlettype | |
37403 | - // copy back results provided by call to getlettype | |
37404 | - stack[base + 14] = stack[base + 18LLU]; | |
37405 | - if(/*typedata*/0 != ((uint64_t *)(stack[base + 14]/*type*/))[0]) | |
37468 | + // copy mutable arguments back from call to ParseToken | |
37469 | + stack[base + 5]/*lookahead*/ = stack[base + 19LLU]; | |
37470 | + // copy back results provided by call to ParseToken | |
37471 | + stack[base + 12] = stack[base + 17LLU]; | |
37472 | + stack[base + 13] = stack[base + 18LLU]; | |
37473 | + if(/*typedata*/0 != ((uint64_t *)(stack[base + 7]/*type*/))[0]) | |
37406 | 37474 | { |
37407 | - label = 3151LLU; // jump to alternative | |
37475 | + label = 3161LLU; // jump to alternative | |
37408 | 37476 | break; |
37409 | 37477 | } |
37410 | 37478 | |
37411 | - /*name*/stack[base + 15] = ((uint64_t **)(stack[base + 14]/*type*/))[1][0]/*name*/; | |
37479 | + /*name*/stack[base + 14] = ((uint64_t **)(stack[base + 7]/*type*/))[1][0]/*name*/; | |
37412 | 37480 | |
37413 | 37481 | // case |
37414 | - // call equ from AssignFrom | |
37415 | - stack[base + 16LLU] = 3153LLU/*throw to this address*/; | |
37416 | - stack[base + 17LLU] = base; | |
37417 | - stack[base + 18LLU] = 3154LLU; | |
37482 | + // call equ from assignment | |
37483 | + stack[base + 15LLU] = 3163LLU/*throw to this address*/; | |
37484 | + stack[base + 16LLU] = base; | |
37485 | + stack[base + 17LLU] = 3164LLU; | |
37418 | 37486 | // arguments for call to equ |
37419 | - stack[base + 20LLU] = 881834713755418624LLU; | |
37420 | - stack[base + 21LLU] = stack[base + 15]/*name*/; | |
37487 | + stack[base + 19LLU] = 881834713755418624LLU; | |
37488 | + stack[base + 20LLU] = stack[base + 14]/*name*/; | |
37421 | 37489 | // set stack-base & callee-address |
37422 | - base += 19LLU; | |
37490 | + base += 18LLU; | |
37423 | 37491 | label = 18446744073709551600LLU; // equ |
37424 | 37492 | break; |
37425 | 37493 | } |
37426 | - case 3153LLU: // copy-back deleter (equ to AssignFrom) | |
37494 | + case 3163LLU: // copy-back deleter (equ to assignment) | |
37427 | 37495 | { |
37428 | 37496 | // copy mutable arguments back from call to equ |
37429 | - label = 3152LLU; // continue to roll stack | |
37497 | + label = 3162LLU; // continue to roll stack | |
37430 | 37498 | break; |
37431 | 37499 | } |
37432 | - case 3154LLU: // return from equ to AssignFrom | |
37500 | + case 3164LLU: // return from equ to assignment | |
37433 | 37501 | { |
37434 | 37502 | // copy mutable arguments back from call to equ |
37435 | 37503 | // copy back results provided by call to equ |
37436 | - stack[base + 13] = stack[base + 19LLU]; | |
37437 | - if(!stack[base + 13]/*isequal*/) | |
37504 | + stack[base + 6] = stack[base + 18LLU]; | |
37505 | + if(!stack[base + 6]/*isequal*/) | |
37438 | 37506 | { |
37439 | - label = 3155LLU; // jump to alternative | |
37507 | + label = 3165LLU; // jump to alternative | |
37440 | 37508 | break; |
37441 | 37509 | } |
37442 | 37510 | |
37443 | 37511 | // consequent |
37444 | - // call isncs from AssignFrom | |
37445 | - stack[base + 16LLU] = 3157LLU/*throw to this address*/; | |
37446 | - stack[base + 17LLU] = base; | |
37447 | - stack[base + 18LLU] = 3158LLU; | |
37512 | + // call isncs from assignment | |
37513 | + stack[base + 15LLU] = 3167LLU/*throw to this address*/; | |
37514 | + stack[base + 16LLU] = base; | |
37515 | + stack[base + 17LLU] = 3168LLU; | |
37448 | 37516 | // arguments for call to isncs |
37449 | - stack[base + 20LLU] = stack[base + 11]/*variant*/; | |
37517 | + stack[base + 19LLU] = stack[base + 12]/*variant*/; | |
37450 | 37518 | // set stack-base & callee-address |
37451 | - base += 19LLU; | |
37519 | + base += 18LLU; | |
37452 | 37520 | label = 286LLU; // isncs |
37453 | 37521 | break; |
37454 | 37522 | } |
37455 | - case 3157LLU: // copy-back deleter (isncs to AssignFrom) | |
37523 | + case 3167LLU: // copy-back deleter (isncs to assignment) | |
37456 | 37524 | { |
37457 | 37525 | // copy mutable arguments back from call to isncs |
37458 | - label = 3152LLU; // continue to roll stack | |
37526 | + label = 3162LLU; // continue to roll stack | |
37459 | 37527 | break; |
37460 | 37528 | } |
37461 | - case 3158LLU: // return from isncs to AssignFrom | |
37529 | + case 3168LLU: // return from isncs to assignment | |
37462 | 37530 | { |
37463 | 37531 | // copy mutable arguments back from call to isncs |
37464 | 37532 | // copy back results provided by call to isncs |
37465 | - stack[base + 13] = stack[base + 19LLU]; | |
37466 | - if(!stack[base + 13]/*isequal*/) | |
37533 | + stack[base + 6] = stack[base + 18LLU]; | |
37534 | + if(!stack[base + 6]/*isequal*/) | |
37467 | 37535 | { |
37468 | - label = 3159LLU; // jump to alternative | |
37536 | + label = 3169LLU; // jump to alternative | |
37469 | 37537 | break; |
37470 | 37538 | } |
37471 | 37539 | |
37472 | 37540 | // consequent |
37473 | 37541 | printf("%s", "\n "); |
37474 | - // call emitvar from AssignFrom | |
37475 | - stack[base + 16LLU] = 3161LLU/*throw to this address*/; | |
37476 | - stack[base + 17LLU] = base; | |
37477 | - stack[base + 18LLU] = 3162LLU; | |
37542 | + // call emitvar from assignment | |
37543 | + stack[base + 15LLU] = 3171LLU/*throw to this address*/; | |
37544 | + stack[base + 16LLU] = base; | |
37545 | + stack[base + 17LLU] = 3172LLU; | |
37478 | 37546 | // arguments for call to emitvar |
37479 | - stack[base + 19LLU] = stack[base + 0]/*fnid*/; | |
37480 | - stack[base + 20LLU] = stack[base + 1]/*id*/; | |
37481 | - stack[base + 21LLU] = stack[base + 4]/*scopes*/; | |
37482 | - stack[base + 22LLU] = stack[base + 5]/*scope*/; | |
37547 | + stack[base + 18LLU] = stack[base + 0]/*fnid*/; | |
37548 | + stack[base + 19LLU] = stack[base + 8]/*id*/; | |
37549 | + stack[base + 20LLU] = stack[base + 3]/*scopes*/; | |
37550 | + stack[base + 21LLU] = stack[base + 4]/*scope*/; | |
37483 | 37551 | // set stack-base & callee-address |
37484 | - base += 19LLU; | |
37552 | + base += 18LLU; | |
37485 | 37553 | label = 749LLU; // emitvar |
37486 | 37554 | break; |
37487 | 37555 | } |
37488 | - case 3161LLU: // copy-back deleter (emitvar to AssignFrom) | |
37556 | + case 3171LLU: // copy-back deleter (emitvar to assignment) | |
37489 | 37557 | { |
37490 | 37558 | // copy mutable arguments back from call to emitvar |
37491 | - label = 3152LLU; // continue to roll stack | |
37559 | + label = 3162LLU; // continue to roll stack | |
37492 | 37560 | break; |
37493 | 37561 | } |
37494 | - case 3162LLU: // return from emitvar to AssignFrom | |
37562 | + case 3172LLU: // return from emitvar to assignment | |
37495 | 37563 | { |
37496 | 37564 | // copy mutable arguments back from call to emitvar |
37497 | 37565 | printf("%s", " = "); |
37498 | - // call printnr from AssignFrom | |
37499 | - stack[base + 16LLU] = 3163LLU/*throw to this address*/; | |
37500 | - stack[base + 17LLU] = base; | |
37501 | - stack[base + 18LLU] = 3164LLU; | |
37566 | + // call printnr from assignment | |
37567 | + stack[base + 15LLU] = 3173LLU/*throw to this address*/; | |
37568 | + stack[base + 16LLU] = base; | |
37569 | + stack[base + 17LLU] = 3174LLU; | |
37502 | 37570 | // arguments for call to printnr |
37503 | - stack[base + 19LLU] = stack[base + 12]/*content*/; | |
37571 | + stack[base + 18LLU] = stack[base + 13]/*content*/; | |
37504 | 37572 | // set stack-base & callee-address |
37505 | - base += 19LLU; | |
37573 | + base += 18LLU; | |
37506 | 37574 | label = 18446744073709551590LLU; // printnr |
37507 | 37575 | break; |
37508 | 37576 | } |
37509 | - case 3163LLU: // copy-back deleter (printnr to AssignFrom) | |
37577 | + case 3173LLU: // copy-back deleter (printnr to assignment) | |
37510 | 37578 | { |
37511 | 37579 | // copy mutable arguments back from call to printnr |
37512 | - label = 3152LLU; // continue to roll stack | |
37580 | + label = 3162LLU; // continue to roll stack | |
37513 | 37581 | break; |
37514 | 37582 | } |
37515 | - case 3164LLU: // return from printnr to AssignFrom | |
37583 | + case 3174LLU: // return from printnr to assignment | |
37516 | 37584 | { |
37517 | 37585 | // copy mutable arguments back from call to printnr |
37518 | 37586 | printf("%s", ";"); |
37519 | - label = 3160LLU; // consequent complete | |
37587 | + label = 3170LLU; // consequent complete | |
37520 | 37588 | break; |
37521 | 37589 | } |
37522 | - case 3159LLU: // alternative | |
37590 | + case 3169LLU: // alternative | |
37523 | 37591 | { |
37524 | - // call equ from AssignFrom | |
37525 | - stack[base + 16LLU] = 3165LLU/*throw to this address*/; | |
37526 | - stack[base + 17LLU] = base; | |
37527 | - stack[base + 18LLU] = 3166LLU; | |
37592 | + // call equ from assignment | |
37593 | + stack[base + 15LLU] = 3175LLU/*throw to this address*/; | |
37594 | + stack[base + 16LLU] = base; | |
37595 | + stack[base + 17LLU] = 3176LLU; | |
37528 | 37596 | // arguments for call to equ |
37529 | - stack[base + 20LLU] = stack[base + 11]/*variant*/; | |
37530 | - stack[base + 21LLU] = 4LLU; | |
37597 | + stack[base + 19LLU] = stack[base + 12]/*variant*/; | |
37598 | + stack[base + 20LLU] = 4LLU; | |
37531 | 37599 | // set stack-base & callee-address |
37532 | - base += 19LLU; | |
37600 | + base += 18LLU; | |
37533 | 37601 | label = 18446744073709551600LLU; // equ |
37534 | 37602 | break; |
37535 | 37603 | } |
37536 | - case 3165LLU: // copy-back deleter (equ to AssignFrom) | |
37604 | + case 3175LLU: // copy-back deleter (equ to assignment) | |
37537 | 37605 | { |
37538 | 37606 | // copy mutable arguments back from call to equ |
37539 | - label = 3152LLU; // continue to roll stack | |
37607 | + label = 3162LLU; // continue to roll stack | |
37540 | 37608 | break; |
37541 | 37609 | } |
37542 | - case 3166LLU: // return from equ to AssignFrom | |
37610 | + case 3176LLU: // return from equ to assignment | |
37543 | 37611 | { |
37544 | 37612 | // copy mutable arguments back from call to equ |
37545 | 37613 | // copy back results provided by call to equ |
37546 | - stack[base + 13] = stack[base + 19LLU]; | |
37547 | - if(!stack[base + 13]/*isequal*/) | |
37614 | + stack[base + 6] = stack[base + 18LLU]; | |
37615 | + if(!stack[base + 6]/*isequal*/) | |
37548 | 37616 | { |
37549 | - label = 3167LLU; // jump to alternative | |
37617 | + label = 3177LLU; // jump to alternative | |
37550 | 37618 | break; |
37551 | 37619 | } |
37552 | 37620 | |
37553 | 37621 | // consequent |
37554 | 37622 | printf("%s", "\n "); |
37555 | - // call emitvar from AssignFrom | |
37556 | - stack[base + 16LLU] = 3169LLU/*throw to this address*/; | |
37557 | - stack[base + 17LLU] = base; | |
37558 | - stack[base + 18LLU] = 3170LLU; | |
37623 | + // call emitvar from assignment | |
37624 | + stack[base + 15LLU] = 3179LLU/*throw to this address*/; | |
37625 | + stack[base + 16LLU] = base; | |
37626 | + stack[base + 17LLU] = 3180LLU; | |
37559 | 37627 | // arguments for call to emitvar |
37560 | - stack[base + 19LLU] = stack[base + 0]/*fnid*/; | |
37561 | - stack[base + 20LLU] = stack[base + 1]/*id*/; | |
37562 | - stack[base + 21LLU] = stack[base + 4]/*scopes*/; | |
37563 | - stack[base + 22LLU] = stack[base + 5]/*scope*/; | |
37628 | + stack[base + 18LLU] = stack[base + 0]/*fnid*/; | |
37629 | + stack[base + 19LLU] = stack[base + 8]/*id*/; | |
37630 | + stack[base + 20LLU] = stack[base + 3]/*scopes*/; | |
37631 | + stack[base + 21LLU] = stack[base + 4]/*scope*/; | |
37564 | 37632 | // set stack-base & callee-address |
37565 | - base += 19LLU; | |
37633 | + base += 18LLU; | |
37566 | 37634 | label = 749LLU; // emitvar |
37567 | 37635 | break; |
37568 | 37636 | } |
37569 | - case 3169LLU: // copy-back deleter (emitvar to AssignFrom) | |
37637 | + case 3179LLU: // copy-back deleter (emitvar to assignment) | |
37570 | 37638 | { |
37571 | 37639 | // copy mutable arguments back from call to emitvar |
37572 | - label = 3152LLU; // continue to roll stack | |
37640 | + label = 3162LLU; // continue to roll stack | |
37573 | 37641 | break; |
37574 | 37642 | } |
37575 | - case 3170LLU: // return from emitvar to AssignFrom | |
37643 | + case 3180LLU: // return from emitvar to assignment | |
37576 | 37644 | { |
37577 | 37645 | // copy mutable arguments back from call to emitvar |
37578 | 37646 | printf("%s", " = "); |
37579 | - // call emitvar from AssignFrom | |
37580 | - stack[base + 16LLU] = 3171LLU/*throw to this address*/; | |
37581 | - stack[base + 17LLU] = base; | |
37582 | - stack[base + 18LLU] = 3172LLU; | |
37647 | + // call emitvar from assignment | |
37648 | + stack[base + 15LLU] = 3181LLU/*throw to this address*/; | |
37649 | + stack[base + 16LLU] = base; | |
37650 | + stack[base + 17LLU] = 3182LLU; | |
37583 | 37651 | // arguments for call to emitvar |
37584 | - stack[base + 19LLU] = stack[base + 0]/*fnid*/; | |
37585 | - stack[base + 20LLU] = stack[base + 12]/*content*/; | |
37586 | - stack[base + 21LLU] = stack[base + 4]/*scopes*/; | |
37587 | - stack[base + 22LLU] = stack[base + 5]/*scope*/; | |
37652 | + stack[base + 18LLU] = stack[base + 0]/*fnid*/; | |
37653 | + stack[base + 19LLU] = stack[base + 13]/*content*/; | |
37654 | + stack[base + 20LLU] = stack[base + 3]/*scopes*/; | |
37655 | + stack[base + 21LLU] = stack[base + 4]/*scope*/; | |
37588 | 37656 | // set stack-base & callee-address |
37589 | - base += 19LLU; | |
37657 | + base += 18LLU; | |
37590 | 37658 | label = 749LLU; // emitvar |
37591 | 37659 | break; |
37592 | 37660 | } |
37593 | - case 3171LLU: // copy-back deleter (emitvar to AssignFrom) | |
37661 | + case 3181LLU: // copy-back deleter (emitvar to assignment) | |
37594 | 37662 | { |
37595 | 37663 | // copy mutable arguments back from call to emitvar |
37596 | - label = 3152LLU; // continue to roll stack | |
37664 | + label = 3162LLU; // continue to roll stack | |
37597 | 37665 | break; |
37598 | 37666 | } |
37599 | - case 3172LLU: // return from emitvar to AssignFrom | |
37667 | + case 3182LLU: // return from emitvar to assignment | |
37600 | 37668 | { |
37601 | 37669 | // copy mutable arguments back from call to emitvar |
37602 | 37670 | printf("%s", ";"); |
37603 | - label = 3168LLU; // consequent complete | |
37671 | + label = 3178LLU; // consequent complete | |
37604 | 37672 | break; |
37605 | 37673 | } |
37606 | - case 3167LLU: // alternative | |
37674 | + case 3177LLU: // alternative | |
37607 | 37675 | { |
37608 | 37676 | fprintf(stderr, "%s", "parsing assignment unexpected token "); |
37609 | - // call reporttok from AssignFrom | |
37610 | - stack[base + 16LLU] = 3173LLU/*throw to this address*/; | |
37611 | - stack[base + 17LLU] = base; | |
37612 | - stack[base + 18LLU] = 3174LLU; | |
37677 | + // call reporttok from assignment | |
37678 | + stack[base + 15LLU] = 3183LLU/*throw to this address*/; | |
37679 | + stack[base + 16LLU] = base; | |
37680 | + stack[base + 17LLU] = 3184LLU; | |
37613 | 37681 | // arguments for call to reporttok |
37614 | - stack[base + 19LLU] = stack[base + 11]/*variant*/; | |
37615 | - stack[base + 20LLU] = stack[base + 12]/*content*/; | |
37682 | + stack[base + 18LLU] = stack[base + 12]/*variant*/; | |
37683 | + stack[base + 19LLU] = stack[base + 13]/*content*/; | |
37616 | 37684 | // set stack-base & callee-address |
37617 | - base += 19LLU; | |
37685 | + base += 18LLU; | |
37618 | 37686 | label = 18446744073709551582LLU; // reporttok |
37619 | 37687 | break; |
37620 | 37688 | } |
37621 | - case 3173LLU: // copy-back deleter (reporttok to AssignFrom) | |
37689 | + case 3183LLU: // copy-back deleter (reporttok to assignment) | |
37622 | 37690 | { |
37623 | 37691 | // copy mutable arguments back from call to reporttok |
37624 | - label = 3152LLU; // continue to roll stack | |
37692 | + label = 3162LLU; // continue to roll stack | |
37625 | 37693 | break; |
37626 | 37694 | } |
37627 | - case 3174LLU: // return from reporttok to AssignFrom | |
37695 | + case 3184LLU: // return from reporttok to assignment | |
37628 | 37696 | { |
37629 | 37697 | // copy mutable arguments back from call to reporttok |
37630 | 37698 | fprintf(stderr, "%s", "\n"); |
37631 | 37699 | { |
37632 | - label = 3152LLU; // throw: begin to unroll stack | |
37700 | + label = 3162LLU; // throw: begin to unroll stack | |
37633 | 37701 | break; |
37634 | 37702 | } |
37635 | 37703 | |
37636 | - label = 3168LLU; // alternative complete | |
37704 | + label = 3178LLU; // alternative complete | |
37637 | 37705 | break; |
37638 | 37706 | } |
37639 | - case 3168LLU: // completed if-then-else | |
37707 | + case 3178LLU: // completed if-then-else | |
37640 | 37708 | { |
37641 | - label = 3160LLU; // alternative complete | |
37709 | + label = 3170LLU; // alternative complete | |
37642 | 37710 | break; |
37643 | 37711 | } |
37644 | - case 3160LLU: // completed if-then-else | |
37712 | + case 3170LLU: // completed if-then-else | |
37645 | 37713 | { |
37646 | - label = 3156LLU; // consequent complete | |
37714 | + label = 3166LLU; // consequent complete | |
37647 | 37715 | break; |
37648 | 37716 | } |
37649 | - case 3155LLU: // alternative | |
37717 | + case 3165LLU: // alternative | |
37650 | 37718 | { |
37651 | 37719 | fprintf(stderr, "%s", "in function "); |
37652 | - // call reportid from AssignFrom | |
37653 | - stack[base + 16LLU] = 3175LLU/*throw to this address*/; | |
37654 | - stack[base + 17LLU] = base; | |
37655 | - stack[base + 18LLU] = 3176LLU; | |
37720 | + // call reportid from assignment | |
37721 | + stack[base + 15LLU] = 3185LLU/*throw to this address*/; | |
37722 | + stack[base + 16LLU] = base; | |
37723 | + stack[base + 17LLU] = 3186LLU; | |
37656 | 37724 | // arguments for call to reportid |
37657 | - stack[base + 19LLU] = stack[base + 0]/*fnid*/; | |
37725 | + stack[base + 18LLU] = stack[base + 0]/*fnid*/; | |
37658 | 37726 | // set stack-base & callee-address |
37659 | - base += 19LLU; | |
37727 | + base += 18LLU; | |
37660 | 37728 | label = 18446744073709551586LLU; // reportid |
37661 | 37729 | break; |
37662 | 37730 | } |
37663 | - case 3175LLU: // copy-back deleter (reportid to AssignFrom) | |
37731 | + case 3185LLU: // copy-back deleter (reportid to assignment) | |
37664 | 37732 | { |
37665 | 37733 | // copy mutable arguments back from call to reportid |
37666 | - label = 3152LLU; // continue to roll stack | |
37734 | + label = 3162LLU; // continue to roll stack | |
37667 | 37735 | break; |
37668 | 37736 | } |
37669 | - case 3176LLU: // return from reportid to AssignFrom | |
37737 | + case 3186LLU: // return from reportid to assignment | |
37670 | 37738 | { |
37671 | 37739 | // copy mutable arguments back from call to reportid |
37672 | 37740 | fprintf(stderr, "%s", ": can only assign to u64 but found "); |
@@ -37673,18 +37741,18 @@ | ||
37673 | 37741 | uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t)); |
37674 | 37742 | if(!newstack) |
37675 | 37743 | { |
37676 | - label = 3152LLU; // throw: begin to unroll stack | |
37744 | + label = 3162LLU; // throw: begin to unroll stack | |
37677 | 37745 | break; |
37678 | 37746 | } |
37679 | 37747 | |
37680 | 37748 | newstack[10LLU] = 9876543210LLU; // overflow-marker |
37681 | - // call reporttype from AssignFrom | |
37749 | + // call reporttype from assignment | |
37682 | 37750 | newstack[0] = (uint64_t)stack; // backup stack location |
37683 | - newstack[1] = 3177LLU; | |
37751 | + newstack[1] = 3187LLU; | |
37684 | 37752 | newstack[2] = base; |
37685 | - newstack[3] = 3178LLU; | |
37753 | + newstack[3] = 3188LLU; | |
37686 | 37754 | // arguments for call to reporttype |
37687 | - newstack[4LLU] = stack[base + 14]/*type*/; | |
37755 | + newstack[4LLU] = stack[base + 7]/*type*/; | |
37688 | 37756 | stack = newstack; |
37689 | 37757 | // set stack-base & callee-address |
37690 | 37758 | base = 4/*deloffset*/; |
@@ -37691,7 +37759,7 @@ | ||
37691 | 37759 | label = 330LLU; // reporttype |
37692 | 37760 | break; |
37693 | 37761 | } |
37694 | - case 3177LLU: // copy-back deleter (reporttype to AssignFrom) | |
37762 | + case 3187LLU: // copy-back deleter (reporttype to assignment) | |
37695 | 37763 | { |
37696 | 37764 | uint64_t *oldstack = (uint64_t *)stack[0]; |
37697 | 37765 | // copy mutable arguments back from call to reporttype |
@@ -37702,10 +37770,10 @@ | ||
37702 | 37770 | } |
37703 | 37771 | Free(10LLU + 1, sizeof(uint64_t), stack); |
37704 | 37772 | stack = oldstack; |
37705 | - label = 3152LLU; // continue to unroll stack | |
37773 | + label = 3162LLU; // continue to unroll stack | |
37706 | 37774 | break; |
37707 | 37775 | } |
37708 | - case 3178LLU: // return from reporttype to AssignFrom | |
37776 | + case 3188LLU: // return from reporttype to assignment | |
37709 | 37777 | { |
37710 | 37778 | uint64_t *oldstack = (uint64_t *)stack[0]; |
37711 | 37779 | // copy mutable arguments back from call to reporttype |
@@ -37717,77 +37785,77 @@ | ||
37717 | 37785 | Free(10LLU + 1, sizeof(uint64_t), stack); |
37718 | 37786 | stack = oldstack; |
37719 | 37787 | fprintf(stderr, "%s", " "); |
37720 | - // call reportid from AssignFrom | |
37721 | - stack[base + 16LLU] = 3179LLU/*throw to this address*/; | |
37722 | - stack[base + 17LLU] = base; | |
37723 | - stack[base + 18LLU] = 3180LLU; | |
37788 | + // call reportid from assignment | |
37789 | + stack[base + 15LLU] = 3189LLU/*throw to this address*/; | |
37790 | + stack[base + 16LLU] = base; | |
37791 | + stack[base + 17LLU] = 3190LLU; | |
37724 | 37792 | // arguments for call to reportid |
37725 | - stack[base + 19LLU] = stack[base + 1]/*id*/; | |
37793 | + stack[base + 18LLU] = stack[base + 8]/*id*/; | |
37726 | 37794 | // set stack-base & callee-address |
37727 | - base += 19LLU; | |
37795 | + base += 18LLU; | |
37728 | 37796 | label = 18446744073709551586LLU; // reportid |
37729 | 37797 | break; |
37730 | 37798 | } |
37731 | - case 3179LLU: // copy-back deleter (reportid to AssignFrom) | |
37799 | + case 3189LLU: // copy-back deleter (reportid to assignment) | |
37732 | 37800 | { |
37733 | 37801 | // copy mutable arguments back from call to reportid |
37734 | - label = 3152LLU; // continue to roll stack | |
37802 | + label = 3162LLU; // continue to roll stack | |
37735 | 37803 | break; |
37736 | 37804 | } |
37737 | - case 3180LLU: // return from reportid to AssignFrom | |
37805 | + case 3190LLU: // return from reportid to assignment | |
37738 | 37806 | { |
37739 | 37807 | // copy mutable arguments back from call to reportid |
37740 | 37808 | fprintf(stderr, "%s", " instead - use SWAP\n"); |
37741 | 37809 | { |
37742 | - label = 3152LLU; // throw: begin to unroll stack | |
37810 | + label = 3162LLU; // throw: begin to unroll stack | |
37743 | 37811 | break; |
37744 | 37812 | } |
37745 | 37813 | |
37746 | - label = 3156LLU; // alternative complete | |
37814 | + label = 3166LLU; // alternative complete | |
37747 | 37815 | break; |
37748 | 37816 | } |
37749 | - case 3156LLU: // completed if-then-else | |
37817 | + case 3166LLU: // completed if-then-else | |
37750 | 37818 | { |
37751 | - ((uint64_t **)(stack[base + 14]))[1][0] = stack[base + 15]; | |
37752 | - label = 3150LLU; // case complete | |
37819 | + ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 14]; | |
37820 | + label = 3160LLU; // case complete | |
37753 | 37821 | break; |
37754 | 37822 | } |
37755 | - case 3152LLU: // copy-back deleter (switch) | |
37823 | + case 3162LLU: // copy-back deleter (switch) | |
37756 | 37824 | { |
37757 | - ((uint64_t **)(stack[base + 14]))[1][0] = stack[base + 15]; | |
37758 | - label = 3145LLU; // continue to unroll stack | |
37825 | + ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 14]; | |
37826 | + label = 3156LLU; // continue to unroll stack | |
37759 | 37827 | break; |
37760 | 37828 | } |
37761 | - case 3151LLU: // try next case | |
37829 | + case 3161LLU: // try next case | |
37762 | 37830 | { |
37763 | - if(/*typelist*/1 != ((uint64_t *)(stack[base + 14]/*type*/))[0]) | |
37831 | + if(/*typelist*/1 != ((uint64_t *)(stack[base + 7]/*type*/))[0]) | |
37764 | 37832 | { |
37765 | - label = 3181LLU; // jump to alternative | |
37833 | + label = 3191LLU; // jump to alternative | |
37766 | 37834 | break; |
37767 | 37835 | } |
37768 | 37836 | |
37769 | - /*subtype*/stack[base + 15] = ((uint64_t **)(stack[base + 14]/*type*/))[1][0]/*subtype*/; | |
37837 | + /*subtype*/stack[base + 14] = ((uint64_t **)(stack[base + 7]/*type*/))[1][0]/*subtype*/; | |
37770 | 37838 | |
37771 | 37839 | // case |
37772 | 37840 | fprintf(stderr, "%s", "in function "); |
37773 | - // call reportid from AssignFrom | |
37774 | - stack[base + 16LLU] = 3183LLU/*throw to this address*/; | |
37775 | - stack[base + 17LLU] = base; | |
37776 | - stack[base + 18LLU] = 3184LLU; | |
37841 | + // call reportid from assignment | |
37842 | + stack[base + 15LLU] = 3193LLU/*throw to this address*/; | |
37843 | + stack[base + 16LLU] = base; | |
37844 | + stack[base + 17LLU] = 3194LLU; | |
37777 | 37845 | // arguments for call to reportid |
37778 | - stack[base + 19LLU] = stack[base + 0]/*fnid*/; | |
37846 | + stack[base + 18LLU] = stack[base + 0]/*fnid*/; | |
37779 | 37847 | // set stack-base & callee-address |
37780 | - base += 19LLU; | |
37848 | + base += 18LLU; | |
37781 | 37849 | label = 18446744073709551586LLU; // reportid |
37782 | 37850 | break; |
37783 | 37851 | } |
37784 | - case 3183LLU: // copy-back deleter (reportid to AssignFrom) | |
37852 | + case 3193LLU: // copy-back deleter (reportid to assignment) | |
37785 | 37853 | { |
37786 | 37854 | // copy mutable arguments back from call to reportid |
37787 | - label = 3182LLU; // continue to roll stack | |
37855 | + label = 3192LLU; // continue to roll stack | |
37788 | 37856 | break; |
37789 | 37857 | } |
37790 | - case 3184LLU: // return from reportid to AssignFrom | |
37858 | + case 3194LLU: // return from reportid to assignment | |
37791 | 37859 | { |
37792 | 37860 | // copy mutable arguments back from call to reportid |
37793 | 37861 | fprintf(stderr, "%s", ": cannot assign to list "); |
@@ -37794,18 +37862,18 @@ | ||
37794 | 37862 | uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t)); |
37795 | 37863 | if(!newstack) |
37796 | 37864 | { |
37797 | - label = 3182LLU; // throw: begin to unroll stack | |
37865 | + label = 3192LLU; // throw: begin to unroll stack | |
37798 | 37866 | break; |
37799 | 37867 | } |
37800 | 37868 | |
37801 | 37869 | newstack[10LLU] = 9876543210LLU; // overflow-marker |
37802 | - // call reporttype from AssignFrom | |
37870 | + // call reporttype from assignment | |
37803 | 37871 | newstack[0] = (uint64_t)stack; // backup stack location |
37804 | - newstack[1] = 3185LLU; | |
37872 | + newstack[1] = 3195LLU; | |
37805 | 37873 | newstack[2] = base; |
37806 | - newstack[3] = 3186LLU; | |
37874 | + newstack[3] = 3196LLU; | |
37807 | 37875 | // arguments for call to reporttype |
37808 | - newstack[4LLU] = stack[base + 14]/*type*/; | |
37876 | + newstack[4LLU] = stack[base + 7]/*type*/; | |
37809 | 37877 | stack = newstack; |
37810 | 37878 | // set stack-base & callee-address |
37811 | 37879 | base = 4/*deloffset*/; |
@@ -37812,7 +37880,7 @@ | ||
37812 | 37880 | label = 330LLU; // reporttype |
37813 | 37881 | break; |
37814 | 37882 | } |
37815 | - case 3185LLU: // copy-back deleter (reporttype to AssignFrom) | |
37883 | + case 3195LLU: // copy-back deleter (reporttype to assignment) | |
37816 | 37884 | { |
37817 | 37885 | uint64_t *oldstack = (uint64_t *)stack[0]; |
37818 | 37886 | // copy mutable arguments back from call to reporttype |
@@ -37823,10 +37891,10 @@ | ||
37823 | 37891 | } |
37824 | 37892 | Free(10LLU + 1, sizeof(uint64_t), stack); |
37825 | 37893 | stack = oldstack; |
37826 | - label = 3182LLU; // continue to unroll stack | |
37894 | + label = 3192LLU; // continue to unroll stack | |
37827 | 37895 | break; |
37828 | 37896 | } |
37829 | - case 3186LLU: // return from reporttype to AssignFrom | |
37897 | + case 3196LLU: // return from reporttype to assignment | |
37830 | 37898 | { |
37831 | 37899 | uint64_t *oldstack = (uint64_t *)stack[0]; |
37832 | 37900 | // copy mutable arguments back from call to reporttype |
@@ -37838,80 +37906,86 @@ | ||
37838 | 37906 | Free(10LLU + 1, sizeof(uint64_t), stack); |
37839 | 37907 | stack = oldstack; |
37840 | 37908 | fprintf(stderr, "%s", " "); |
37841 | - // call reportid from AssignFrom | |
37842 | - stack[base + 16LLU] = 3187LLU/*throw to this address*/; | |
37843 | - stack[base + 17LLU] = base; | |
37844 | - stack[base + 18LLU] = 3188LLU; | |
37909 | + // call reportid from assignment | |
37910 | + stack[base + 15LLU] = 3197LLU/*throw to this address*/; | |
37911 | + stack[base + 16LLU] = base; | |
37912 | + stack[base + 17LLU] = 3198LLU; | |
37845 | 37913 | // arguments for call to reportid |
37846 | - stack[base + 19LLU] = stack[base + 1]/*id*/; | |
37914 | + stack[base + 18LLU] = stack[base + 8]/*id*/; | |
37847 | 37915 | // set stack-base & callee-address |
37848 | - base += 19LLU; | |
37916 | + base += 18LLU; | |
37849 | 37917 | label = 18446744073709551586LLU; // reportid |
37850 | 37918 | break; |
37851 | 37919 | } |
37852 | - case 3187LLU: // copy-back deleter (reportid to AssignFrom) | |
37920 | + case 3197LLU: // copy-back deleter (reportid to assignment) | |
37853 | 37921 | { |
37854 | 37922 | // copy mutable arguments back from call to reportid |
37855 | - label = 3182LLU; // continue to roll stack | |
37923 | + label = 3192LLU; // continue to roll stack | |
37856 | 37924 | break; |
37857 | 37925 | } |
37858 | - case 3188LLU: // return from reportid to AssignFrom | |
37926 | + case 3198LLU: // return from reportid to assignment | |
37859 | 37927 | { |
37860 | 37928 | // copy mutable arguments back from call to reportid |
37861 | 37929 | fprintf(stderr, "%s", " - use SWAP instead\n"); |
37862 | 37930 | { |
37863 | - label = 3182LLU; // throw: begin to unroll stack | |
37931 | + label = 3192LLU; // throw: begin to unroll stack | |
37864 | 37932 | break; |
37865 | 37933 | } |
37866 | 37934 | |
37867 | - ((uint64_t **)(stack[base + 14]))[1][0] = stack[base + 15]; | |
37868 | - label = 3150LLU; // case complete | |
37935 | + ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 14]; | |
37936 | + label = 3160LLU; // case complete | |
37869 | 37937 | break; |
37870 | 37938 | } |
37871 | - case 3182LLU: // copy-back deleter (switch) | |
37939 | + case 3192LLU: // copy-back deleter (switch) | |
37872 | 37940 | { |
37873 | - ((uint64_t **)(stack[base + 14]))[1][0] = stack[base + 15]; | |
37874 | - label = 3145LLU; // continue to unroll stack | |
37941 | + ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 14]; | |
37942 | + label = 3156LLU; // continue to unroll stack | |
37875 | 37943 | break; |
37876 | 37944 | } |
37877 | - case 3181LLU: // try next case | |
37945 | + case 3191LLU: // try next case | |
37878 | 37946 | { |
37879 | 37947 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
37880 | 37948 | exit(-1); |
37881 | 37949 | } |
37882 | - case 3150LLU: // completed switch | |
37950 | + case 3160LLU: // completed switch | |
37883 | 37951 | { |
37884 | - | |
37885 | - uint64_t *newstack = (uint64_t *)(stack[base + 14] - sizeof(uint64_t) * 4); | |
37886 | - // call ~type from AssignFrom | |
37887 | - newstack[0] = (uint64_t)stack; // backup stack location | |
37888 | - newstack[1] = 1234567890; | |
37889 | - newstack[2] = base; | |
37890 | - newstack[3] = 3189LLU; | |
37891 | - stack = newstack; | |
37892 | - // set stack-base & callee-address | |
37893 | - base = 4/*deloffset*/; | |
37894 | - label = 310LLU; // ~type | |
37952 | + ((uint64_t **)(stack[base + 1]))[1][4] = stack[base + 11]; | |
37953 | + ((uint64_t **)(stack[base + 1]))[1][3] = stack[base + 10]; | |
37954 | + ((uint64_t **)(stack[base + 1]))[1][2] = stack[base + 9]; | |
37955 | + ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 8]; | |
37956 | + ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 7]; | |
37957 | + label = 3145LLU; // case complete | |
37895 | 37958 | break; |
37896 | 37959 | } |
37897 | - case 3189LLU: // return from ~type to AssignFrom | |
37960 | + case 3147LLU: // copy-back deleter (switch) | |
37898 | 37961 | { |
37899 | - stack = (uint64_t *)stack[0]; | |
37900 | - // releasing toplevel container | |
37901 | - Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 14] - sizeof(uint64_t) * 4)); | |
37902 | - | |
37903 | - // return from AssignFrom | |
37962 | + ((uint64_t **)(stack[base + 1]))[1][4] = stack[base + 11]; | |
37963 | + ((uint64_t **)(stack[base + 1]))[1][3] = stack[base + 10]; | |
37964 | + ((uint64_t **)(stack[base + 1]))[1][2] = stack[base + 9]; | |
37965 | + ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 8]; | |
37966 | + ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 7]; | |
37967 | + label = 3143LLU; // continue to unroll stack | |
37968 | + break; | |
37969 | + } | |
37970 | + case 3146LLU: // try next case | |
37971 | + { | |
37972 | + fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); | |
37973 | + exit(-1); | |
37974 | + } | |
37975 | + case 3145LLU: // completed switch | |
37976 | + { | |
37977 | + // return from assignment | |
37904 | 37978 | label = stack[base - 1]; |
37905 | 37979 | base = stack[base - 2]; |
37906 | 37980 | break; |
37907 | 37981 | } |
37908 | - case 3191LLU: // function closescope failed | |
37982 | + case 3200LLU: // function closescope failed | |
37909 | 37983 | { |
37910 | 37984 | label = stack[base - 3]; |
37911 | 37985 | base = stack[base - 2]; |
37912 | 37986 | break; |
37913 | 37987 | } |
37914 | - case 3190LLU: // closescope | |
37988 | + case 3199LLU: // closescope | |
37915 | 37989 | { |
37916 | 37990 | //#define arg0 0 |
37917 | 37991 | //#define arg1 1 |
@@ -37919,7 +37993,7 @@ | ||
37919 | 37993 | //#define arg3 3 |
37920 | 37994 | if(/*scope*/0 != ((uint64_t *)(stack[base + 2]/*scope*/))[0]) |
37921 | 37995 | { |
37922 | - label = 3193LLU; // jump to alternative | |
37996 | + label = 3202LLU; // jump to alternative | |
37923 | 37997 | break; |
37924 | 37998 | } |
37925 | 37999 |
@@ -37928,14 +38002,14 @@ | ||
37928 | 38002 | |
37929 | 38003 | // case |
37930 | 38004 | flippedassign(stack[base + 5]/*letdefs*/, &stack[base + 6]); |
37931 | - label = 3195LLU; // start to repeat | |
38005 | + label = 3204LLU; // start to repeat | |
37932 | 38006 | break; |
37933 | 38007 | } |
37934 | - case 3195LLU: // repeat from here | |
38008 | + case 3204LLU: // repeat from here | |
37935 | 38009 | { |
37936 | 38010 | if(!stack[base + 6]) |
37937 | 38011 | { |
37938 | - label = 3196LLU; // break loop | |
38012 | + label = 3205LLU; // break loop | |
37939 | 38013 | break; |
37940 | 38014 | } |
37941 | 38015 |
@@ -37945,7 +38019,7 @@ | ||
37945 | 38019 | stack[base + 6] = (uint64_t)(((const struct listnode *)(stack[base + 6]))->next); |
37946 | 38020 | if(/*letdef*/0 != ((uint64_t *)(stack[base + 7]/*letdef*/))[0]) |
37947 | 38021 | { |
37948 | - label = 3199LLU; // jump to alternative | |
38022 | + label = 3208LLU; // jump to alternative | |
37949 | 38023 | break; |
37950 | 38024 | } |
37951 | 38025 |
@@ -37959,7 +38033,7 @@ | ||
37959 | 38033 | uint64_t *newstack = (uint64_t *)Calloc(75LLU + 1, sizeof(uint64_t)); |
37960 | 38034 | if(!newstack) |
37961 | 38035 | { |
37962 | - label = 3200LLU; // throw: begin to unroll stack | |
38036 | + label = 3209LLU; // throw: begin to unroll stack | |
37963 | 38037 | break; |
37964 | 38038 | } |
37965 | 38039 |
@@ -37966,9 +38040,9 @@ | ||
37966 | 38040 | newstack[75LLU] = 9876543210LLU; // overflow-marker |
37967 | 38041 | // call calldestr from closescope |
37968 | 38042 | newstack[0] = (uint64_t)stack; // backup stack location |
37969 | - newstack[1] = 3201LLU; | |
38043 | + newstack[1] = 3210LLU; | |
37970 | 38044 | newstack[2] = base; |
37971 | - newstack[3] = 3202LLU; | |
38045 | + newstack[3] = 3211LLU; | |
37972 | 38046 | // arguments for call to calldestr |
37973 | 38047 | newstack[4LLU] = stack[base + 0]/*fnid*/; |
37974 | 38048 | newstack[5LLU] = stack[base + 1]/*datadefs*/; |
@@ -37982,7 +38056,7 @@ | ||
37982 | 38056 | label = 1150LLU; // calldestr |
37983 | 38057 | break; |
37984 | 38058 | } |
37985 | - case 3201LLU: // copy-back deleter (calldestr to closescope) | |
38059 | + case 3210LLU: // copy-back deleter (calldestr to closescope) | |
37986 | 38060 | { |
37987 | 38061 | uint64_t *oldstack = (uint64_t *)stack[0]; |
37988 | 38062 | // copy mutable arguments back from call to calldestr |
@@ -37994,10 +38068,10 @@ | ||
37994 | 38068 | } |
37995 | 38069 | Free(75LLU + 1, sizeof(uint64_t), stack); |
37996 | 38070 | stack = oldstack; |
37997 | - label = 3200LLU; // continue to unroll stack | |
38071 | + label = 3209LLU; // continue to unroll stack | |
37998 | 38072 | break; |
37999 | 38073 | } |
38000 | - case 3202LLU: // return from calldestr to closescope | |
38074 | + case 3211LLU: // return from calldestr to closescope | |
38001 | 38075 | { |
38002 | 38076 | uint64_t *oldstack = (uint64_t *)stack[0]; |
38003 | 38077 | // copy mutable arguments back from call to calldestr |
@@ -38014,10 +38088,10 @@ | ||
38014 | 38088 | ((uint64_t **)(stack[base + 7]))[1][2] = stack[base + 11]; |
38015 | 38089 | ((uint64_t **)(stack[base + 7]))[1][1] = stack[base + 10]; |
38016 | 38090 | ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 9]; |
38017 | - label = 3198LLU; // case complete | |
38091 | + label = 3207LLU; // case complete | |
38018 | 38092 | break; |
38019 | 38093 | } |
38020 | - case 3200LLU: // copy-back deleter (switch) | |
38094 | + case 3209LLU: // copy-back deleter (switch) | |
38021 | 38095 | { |
38022 | 38096 | ((uint64_t **)(stack[base + 7]))[1][4] = stack[base + 13]; |
38023 | 38097 | ((uint64_t **)(stack[base + 7]))[1][3] = stack[base + 12]; |
@@ -38024,46 +38098,46 @@ | ||
38024 | 38098 | ((uint64_t **)(stack[base + 7]))[1][2] = stack[base + 11]; |
38025 | 38099 | ((uint64_t **)(stack[base + 7]))[1][1] = stack[base + 10]; |
38026 | 38100 | ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 9]; |
38027 | - label = 3197LLU; // continue to unroll stack | |
38101 | + label = 3206LLU; // continue to unroll stack | |
38028 | 38102 | break; |
38029 | 38103 | } |
38030 | - case 3199LLU: // try next case | |
38104 | + case 3208LLU: // try next case | |
38031 | 38105 | { |
38032 | 38106 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
38033 | 38107 | exit(-1); |
38034 | 38108 | } |
38035 | - case 3198LLU: // completed switch | |
38109 | + case 3207LLU: // completed switch | |
38036 | 38110 | { |
38037 | 38111 | ((struct listnode *)(stack[base + 8]/*previous*/))->data = stack[base + 7]; |
38038 | - label = 3195LLU; // repeat | |
38112 | + label = 3204LLU; // repeat | |
38039 | 38113 | break; |
38040 | 38114 | } |
38041 | - case 3197LLU: // copy-back deleter for while next | |
38115 | + case 3206LLU: // copy-back deleter for while next | |
38042 | 38116 | { |
38043 | 38117 | ((struct listnode *)(stack[base + 8]/*previous*/))->data = stack[base + 7]; |
38044 | - label = 3194LLU; // continue to unroll stack | |
38118 | + label = 3203LLU; // continue to unroll stack | |
38045 | 38119 | break; |
38046 | 38120 | } |
38047 | - case 3196LLU: // loop finished | |
38121 | + case 3205LLU: // loop finished | |
38048 | 38122 | { |
38049 | 38123 | ((uint64_t **)(stack[base + 2]))[1][1] = stack[base + 5]; |
38050 | 38124 | ((uint64_t **)(stack[base + 2]))[1][0] = stack[base + 4]; |
38051 | - label = 3192LLU; // case complete | |
38125 | + label = 3201LLU; // case complete | |
38052 | 38126 | break; |
38053 | 38127 | } |
38054 | - case 3194LLU: // copy-back deleter (switch) | |
38128 | + case 3203LLU: // copy-back deleter (switch) | |
38055 | 38129 | { |
38056 | 38130 | ((uint64_t **)(stack[base + 2]))[1][1] = stack[base + 5]; |
38057 | 38131 | ((uint64_t **)(stack[base + 2]))[1][0] = stack[base + 4]; |
38058 | - label = 3191LLU; // continue to unroll stack | |
38132 | + label = 3200LLU; // continue to unroll stack | |
38059 | 38133 | break; |
38060 | 38134 | } |
38061 | - case 3193LLU: // try next case | |
38135 | + case 3202LLU: // try next case | |
38062 | 38136 | { |
38063 | 38137 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
38064 | 38138 | exit(-1); |
38065 | 38139 | } |
38066 | - case 3192LLU: // completed switch | |
38140 | + case 3201LLU: // completed switch | |
38067 | 38141 | { |
38068 | 38142 | // return from closescope |
38069 | 38143 | label = stack[base - 1]; |
@@ -38070,13 +38144,13 @@ | ||
38070 | 38144 | base = stack[base - 2]; |
38071 | 38145 | break; |
38072 | 38146 | } |
38073 | - case 3204LLU: // function VERBATIM failed | |
38147 | + case 3213LLU: // function VERBATIM failed | |
38074 | 38148 | { |
38075 | 38149 | label = stack[base - 3]; |
38076 | 38150 | base = stack[base - 2]; |
38077 | 38151 | break; |
38078 | 38152 | } |
38079 | - case 3203LLU: // VERBATIM | |
38153 | + case 3212LLU: // VERBATIM | |
38080 | 38154 | { |
38081 | 38155 | //#define arg0 0 |
38082 | 38156 | #define lookahead stack[base + 0] |
@@ -38097,38 +38171,38 @@ | ||
38097 | 38171 | |
38098 | 38172 | #undef lookahead |
38099 | 38173 | printf("%s", "\n"); |
38100 | - label = 3205LLU; // start to repeat | |
38174 | + label = 3214LLU; // start to repeat | |
38101 | 38175 | break; |
38102 | 38176 | } |
38103 | - case 3205LLU: // repeat from here | |
38177 | + case 3214LLU: // repeat from here | |
38104 | 38178 | { |
38105 | 38179 | if(stack[base + 0]/*lookahead*/ > 0xFF) |
38106 | 38180 | { |
38107 | - label = 3206LLU; // break loop | |
38181 | + label = 3215LLU; // break loop | |
38108 | 38182 | break; |
38109 | 38183 | } |
38110 | 38184 | |
38111 | 38185 | // loop body |
38112 | - label = 3208LLU; // skip deleter | |
38186 | + label = 3217LLU; // skip deleter | |
38113 | 38187 | break; |
38114 | 38188 | } |
38115 | - case 3207LLU: // deleter | |
38189 | + case 3216LLU: // deleter | |
38116 | 38190 | { |
38117 | 38191 | // throw from VERBATIM |
38118 | 38192 | if(!stack[base + 1]) |
38119 | 38193 | { |
38120 | - label = 3204LLU; // skip, variable already deleted/unscoped | |
38194 | + label = 3213LLU; // skip, variable already deleted/unscoped | |
38121 | 38195 | break; |
38122 | 38196 | } |
38123 | - label = 3204LLU; // continue unrolling stack, delete next variable | |
38197 | + label = 3213LLU; // continue unrolling stack, delete next variable | |
38124 | 38198 | break; |
38125 | 38199 | } |
38126 | - case 3208LLU: // skipped deleter | |
38200 | + case 3217LLU: // skipped deleter | |
38127 | 38201 | { |
38128 | 38202 | // call equ from VERBATIM |
38129 | - stack[base + 2LLU] = 3209LLU/*throw to this address*/; | |
38203 | + stack[base + 2LLU] = 3218LLU/*throw to this address*/; | |
38130 | 38204 | stack[base + 3LLU] = base; |
38131 | - stack[base + 4LLU] = 3210LLU; | |
38205 | + stack[base + 4LLU] = 3219LLU; | |
38132 | 38206 | // arguments for call to equ |
38133 | 38207 | stack[base + 6LLU] = stack[base + 0]/*lookahead*/; |
38134 | 38208 | stack[base + 7LLU] = 96LLU; |
@@ -38137,13 +38211,13 @@ | ||
38137 | 38211 | label = 18446744073709551600LLU; // equ |
38138 | 38212 | break; |
38139 | 38213 | } |
38140 | - case 3209LLU: // copy-back deleter (equ to VERBATIM) | |
38214 | + case 3218LLU: // copy-back deleter (equ to VERBATIM) | |
38141 | 38215 | { |
38142 | 38216 | // copy mutable arguments back from call to equ |
38143 | - label = 3204LLU; // continue to roll stack | |
38217 | + label = 3213LLU; // continue to roll stack | |
38144 | 38218 | break; |
38145 | 38219 | } |
38146 | - case 3210LLU: // return from equ to VERBATIM | |
38220 | + case 3219LLU: // return from equ to VERBATIM | |
38147 | 38221 | { |
38148 | 38222 | // copy mutable arguments back from call to equ |
38149 | 38223 | // copy back results provided by call to equ |
@@ -38150,15 +38224,15 @@ | ||
38150 | 38224 | stack[base + 1] = stack[base + 5LLU]; |
38151 | 38225 | if(!stack[base + 1]/*isequal*/) |
38152 | 38226 | { |
38153 | - label = 3211LLU; // jump to alternative | |
38227 | + label = 3220LLU; // jump to alternative | |
38154 | 38228 | break; |
38155 | 38229 | } |
38156 | 38230 | |
38157 | 38231 | // consequent |
38158 | 38232 | // call EOSbyte from VERBATIM |
38159 | - stack[base + 2LLU] = 3213LLU/*throw to this address*/; | |
38233 | + stack[base + 2LLU] = 3222LLU/*throw to this address*/; | |
38160 | 38234 | stack[base + 3LLU] = base; |
38161 | - stack[base + 4LLU] = 3214LLU; | |
38235 | + stack[base + 4LLU] = 3223LLU; | |
38162 | 38236 | // arguments for call to EOSbyte |
38163 | 38237 | // set stack-base & callee-address |
38164 | 38238 | base += 5LLU; |
@@ -38165,26 +38239,26 @@ | ||
38165 | 38239 | label = 77LLU; // EOSbyte |
38166 | 38240 | break; |
38167 | 38241 | } |
38168 | - case 3213LLU: // copy-back deleter (EOSbyte to VERBATIM) | |
38242 | + case 3222LLU: // copy-back deleter (EOSbyte to VERBATIM) | |
38169 | 38243 | { |
38170 | 38244 | // copy mutable arguments back from call to EOSbyte |
38171 | - label = 3207LLU; // continue to roll stack | |
38245 | + label = 3216LLU; // continue to roll stack | |
38172 | 38246 | break; |
38173 | 38247 | } |
38174 | - case 3214LLU: // return from EOSbyte to VERBATIM | |
38248 | + case 3223LLU: // return from EOSbyte to VERBATIM | |
38175 | 38249 | { |
38176 | 38250 | // copy mutable arguments back from call to EOSbyte |
38177 | 38251 | // copy back results provided by call to EOSbyte |
38178 | 38252 | stack[base + 0] = stack[base + 5LLU]; |
38179 | - label = 3212LLU; // consequent complete | |
38253 | + label = 3221LLU; // consequent complete | |
38180 | 38254 | break; |
38181 | 38255 | } |
38182 | - case 3211LLU: // alternative | |
38256 | + case 3220LLU: // alternative | |
38183 | 38257 | { |
38184 | 38258 | // call printbyte from VERBATIM |
38185 | - stack[base + 2LLU] = 3215LLU/*throw to this address*/; | |
38259 | + stack[base + 2LLU] = 3224LLU/*throw to this address*/; | |
38186 | 38260 | stack[base + 3LLU] = base; |
38187 | - stack[base + 4LLU] = 3216LLU; | |
38261 | + stack[base + 4LLU] = 3225LLU; | |
38188 | 38262 | // arguments for call to printbyte |
38189 | 38263 | stack[base + 5LLU] = stack[base + 0]/*lookahead*/; |
38190 | 38264 | // set stack-base & callee-address |
@@ -38192,25 +38266,25 @@ | ||
38192 | 38266 | label = 18446744073709551592LLU; // printbyte |
38193 | 38267 | break; |
38194 | 38268 | } |
38195 | - case 3215LLU: // copy-back deleter (printbyte to VERBATIM) | |
38269 | + case 3224LLU: // copy-back deleter (printbyte to VERBATIM) | |
38196 | 38270 | { |
38197 | 38271 | // copy mutable arguments back from call to printbyte |
38198 | - label = 3207LLU; // continue to roll stack | |
38272 | + label = 3216LLU; // continue to roll stack | |
38199 | 38273 | break; |
38200 | 38274 | } |
38201 | - case 3216LLU: // return from printbyte to VERBATIM | |
38275 | + case 3225LLU: // return from printbyte to VERBATIM | |
38202 | 38276 | { |
38203 | 38277 | // copy mutable arguments back from call to printbyte |
38204 | - label = 3212LLU; // alternative complete | |
38278 | + label = 3221LLU; // alternative complete | |
38205 | 38279 | break; |
38206 | 38280 | } |
38207 | - case 3212LLU: // completed if-then-else | |
38281 | + case 3221LLU: // completed if-then-else | |
38208 | 38282 | { |
38209 | 38283 | if(stack[base + 0]/*lookahead*/ <= 0xFF) stack[base + 0]/*lookahead*/ = getchar(); |
38210 | - label = 3205LLU; // repeat | |
38284 | + label = 3214LLU; // repeat | |
38211 | 38285 | break; |
38212 | 38286 | } |
38213 | - case 3206LLU: // loop finished | |
38287 | + case 3215LLU: // loop finished | |
38214 | 38288 | { |
38215 | 38289 | stack[base + 0]/*lookahead*/ = 32; |
38216 | 38290 | // return from VERBATIM |
@@ -38218,18 +38292,18 @@ | ||
38218 | 38292 | base = stack[base - 2]; |
38219 | 38293 | break; |
38220 | 38294 | } |
38221 | - case 3218LLU: // function emitdefine failed | |
38295 | + case 3227LLU: // function emitdefine failed | |
38222 | 38296 | { |
38223 | 38297 | label = stack[base - 3]; |
38224 | 38298 | base = stack[base - 2]; |
38225 | 38299 | break; |
38226 | 38300 | } |
38227 | - case 3217LLU: // emitdefine | |
38301 | + case 3226LLU: // emitdefine | |
38228 | 38302 | { |
38229 | 38303 | //#define arg0 0 |
38230 | 38304 | if(/*scope*/0 != ((uint64_t *)(stack[base + 0]/*scope*/))[0]) |
38231 | 38305 | { |
38232 | - label = 3220LLU; // jump to alternative | |
38306 | + label = 3229LLU; // jump to alternative | |
38233 | 38307 | break; |
38234 | 38308 | } |
38235 | 38309 |
@@ -38238,14 +38312,14 @@ | ||
38238 | 38312 | |
38239 | 38313 | // case |
38240 | 38314 | flippedassign(stack[base + 2]/*letdefs*/, &stack[base + 3]); |
38241 | - label = 3222LLU; // start to repeat | |
38315 | + label = 3231LLU; // start to repeat | |
38242 | 38316 | break; |
38243 | 38317 | } |
38244 | - case 3222LLU: // repeat from here | |
38318 | + case 3231LLU: // repeat from here | |
38245 | 38319 | { |
38246 | 38320 | if(!stack[base + 3]) |
38247 | 38321 | { |
38248 | - label = 3223LLU; // break loop | |
38322 | + label = 3232LLU; // break loop | |
38249 | 38323 | break; |
38250 | 38324 | } |
38251 | 38325 |
@@ -38255,7 +38329,7 @@ | ||
38255 | 38329 | stack[base + 3] = (uint64_t)(((const struct listnode *)(stack[base + 3]))->next); |
38256 | 38330 | if(/*letdef*/0 != ((uint64_t *)(stack[base + 4]/*letdef*/))[0]) |
38257 | 38331 | { |
38258 | - label = 3226LLU; // jump to alternative | |
38332 | + label = 3235LLU; // jump to alternative | |
38259 | 38333 | break; |
38260 | 38334 | } |
38261 | 38335 |
@@ -38268,9 +38342,9 @@ | ||
38268 | 38342 | // case |
38269 | 38343 | printf("%s", "\n#define "); |
38270 | 38344 | // call printid from emitdefine |
38271 | - stack[base + 11LLU] = 3228LLU/*throw to this address*/; | |
38345 | + stack[base + 11LLU] = 3237LLU/*throw to this address*/; | |
38272 | 38346 | stack[base + 12LLU] = base; |
38273 | - stack[base + 13LLU] = 3229LLU; | |
38347 | + stack[base + 13LLU] = 3238LLU; | |
38274 | 38348 | // arguments for call to printid |
38275 | 38349 | stack[base + 14LLU] = stack[base + 7]/*id*/; |
38276 | 38350 | // set stack-base & callee-address |
@@ -38278,20 +38352,20 @@ | ||
38278 | 38352 | label = 18446744073709551587LLU; // printid |
38279 | 38353 | break; |
38280 | 38354 | } |
38281 | - case 3228LLU: // copy-back deleter (printid to emitdefine) | |
38355 | + case 3237LLU: // copy-back deleter (printid to emitdefine) | |
38282 | 38356 | { |
38283 | 38357 | // copy mutable arguments back from call to printid |
38284 | - label = 3227LLU; // continue to roll stack | |
38358 | + label = 3236LLU; // continue to roll stack | |
38285 | 38359 | break; |
38286 | 38360 | } |
38287 | - case 3229LLU: // return from printid to emitdefine | |
38361 | + case 3238LLU: // return from printid to emitdefine | |
38288 | 38362 | { |
38289 | 38363 | // copy mutable arguments back from call to printid |
38290 | 38364 | printf("%s", " "); |
38291 | 38365 | // call emitvaridx from emitdefine |
38292 | - stack[base + 11LLU] = 3230LLU/*throw to this address*/; | |
38366 | + stack[base + 11LLU] = 3239LLU/*throw to this address*/; | |
38293 | 38367 | stack[base + 12LLU] = base; |
38294 | - stack[base + 13LLU] = 3231LLU; | |
38368 | + stack[base + 13LLU] = 3240LLU; | |
38295 | 38369 | // arguments for call to emitvaridx |
38296 | 38370 | stack[base + 14LLU] = stack[base + 8]/*index*/; |
38297 | 38371 | // set stack-base & callee-address |
@@ -38299,13 +38373,13 @@ | ||
38299 | 38373 | label = 745LLU; // emitvaridx |
38300 | 38374 | break; |
38301 | 38375 | } |
38302 | - case 3230LLU: // copy-back deleter (emitvaridx to emitdefine) | |
38376 | + case 3239LLU: // copy-back deleter (emitvaridx to emitdefine) | |
38303 | 38377 | { |
38304 | 38378 | // copy mutable arguments back from call to emitvaridx |
38305 | - label = 3227LLU; // continue to roll stack | |
38379 | + label = 3236LLU; // continue to roll stack | |
38306 | 38380 | break; |
38307 | 38381 | } |
38308 | - case 3231LLU: // return from emitvaridx to emitdefine | |
38382 | + case 3240LLU: // return from emitvaridx to emitdefine | |
38309 | 38383 | { |
38310 | 38384 | // copy mutable arguments back from call to emitvaridx |
38311 | 38385 | ((uint64_t **)(stack[base + 4]))[1][4] = stack[base + 10]; |
@@ -38313,10 +38387,10 @@ | ||
38313 | 38387 | ((uint64_t **)(stack[base + 4]))[1][2] = stack[base + 8]; |
38314 | 38388 | ((uint64_t **)(stack[base + 4]))[1][1] = stack[base + 7]; |
38315 | 38389 | ((uint64_t **)(stack[base + 4]))[1][0] = stack[base + 6]; |
38316 | - label = 3225LLU; // case complete | |
38390 | + label = 3234LLU; // case complete | |
38317 | 38391 | break; |
38318 | 38392 | } |
38319 | - case 3227LLU: // copy-back deleter (switch) | |
38393 | + case 3236LLU: // copy-back deleter (switch) | |
38320 | 38394 | { |
38321 | 38395 | ((uint64_t **)(stack[base + 4]))[1][4] = stack[base + 10]; |
38322 | 38396 | ((uint64_t **)(stack[base + 4]))[1][3] = stack[base + 9]; |
@@ -38323,46 +38397,46 @@ | ||
38323 | 38397 | ((uint64_t **)(stack[base + 4]))[1][2] = stack[base + 8]; |
38324 | 38398 | ((uint64_t **)(stack[base + 4]))[1][1] = stack[base + 7]; |
38325 | 38399 | ((uint64_t **)(stack[base + 4]))[1][0] = stack[base + 6]; |
38326 | - label = 3224LLU; // continue to unroll stack | |
38400 | + label = 3233LLU; // continue to unroll stack | |
38327 | 38401 | break; |
38328 | 38402 | } |
38329 | - case 3226LLU: // try next case | |
38403 | + case 3235LLU: // try next case | |
38330 | 38404 | { |
38331 | 38405 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
38332 | 38406 | exit(-1); |
38333 | 38407 | } |
38334 | - case 3225LLU: // completed switch | |
38408 | + case 3234LLU: // completed switch | |
38335 | 38409 | { |
38336 | 38410 | ((struct listnode *)(stack[base + 5]/*previous*/))->data = stack[base + 4]; |
38337 | - label = 3222LLU; // repeat | |
38411 | + label = 3231LLU; // repeat | |
38338 | 38412 | break; |
38339 | 38413 | } |
38340 | - case 3224LLU: // copy-back deleter for while next | |
38414 | + case 3233LLU: // copy-back deleter for while next | |
38341 | 38415 | { |
38342 | 38416 | ((struct listnode *)(stack[base + 5]/*previous*/))->data = stack[base + 4]; |
38343 | - label = 3221LLU; // continue to unroll stack | |
38417 | + label = 3230LLU; // continue to unroll stack | |
38344 | 38418 | break; |
38345 | 38419 | } |
38346 | - case 3223LLU: // loop finished | |
38420 | + case 3232LLU: // loop finished | |
38347 | 38421 | { |
38348 | 38422 | ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2]; |
38349 | 38423 | ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1]; |
38350 | - label = 3219LLU; // case complete | |
38424 | + label = 3228LLU; // case complete | |
38351 | 38425 | break; |
38352 | 38426 | } |
38353 | - case 3221LLU: // copy-back deleter (switch) | |
38427 | + case 3230LLU: // copy-back deleter (switch) | |
38354 | 38428 | { |
38355 | 38429 | ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2]; |
38356 | 38430 | ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1]; |
38357 | - label = 3218LLU; // continue to unroll stack | |
38431 | + label = 3227LLU; // continue to unroll stack | |
38358 | 38432 | break; |
38359 | 38433 | } |
38360 | - case 3220LLU: // try next case | |
38434 | + case 3229LLU: // try next case | |
38361 | 38435 | { |
38362 | 38436 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
38363 | 38437 | exit(-1); |
38364 | 38438 | } |
38365 | - case 3219LLU: // completed switch | |
38439 | + case 3228LLU: // completed switch | |
38366 | 38440 | { |
38367 | 38441 | // return from emitdefine |
38368 | 38442 | label = stack[base - 1]; |
@@ -38369,18 +38443,18 @@ | ||
38369 | 38443 | base = stack[base - 2]; |
38370 | 38444 | break; |
38371 | 38445 | } |
38372 | - case 3233LLU: // function emitundef failed | |
38446 | + case 3242LLU: // function emitundef failed | |
38373 | 38447 | { |
38374 | 38448 | label = stack[base - 3]; |
38375 | 38449 | base = stack[base - 2]; |
38376 | 38450 | break; |
38377 | 38451 | } |
38378 | - case 3232LLU: // emitundef | |
38452 | + case 3241LLU: // emitundef | |
38379 | 38453 | { |
38380 | 38454 | //#define arg0 0 |
38381 | 38455 | if(/*scope*/0 != ((uint64_t *)(stack[base + 0]/*scope*/))[0]) |
38382 | 38456 | { |
38383 | - label = 3235LLU; // jump to alternative | |
38457 | + label = 3244LLU; // jump to alternative | |
38384 | 38458 | break; |
38385 | 38459 | } |
38386 | 38460 |
@@ -38389,14 +38463,14 @@ | ||
38389 | 38463 | |
38390 | 38464 | // case |
38391 | 38465 | flippedassign(stack[base + 2]/*letdefs*/, &stack[base + 3]); |
38392 | - label = 3237LLU; // start to repeat | |
38466 | + label = 3246LLU; // start to repeat | |
38393 | 38467 | break; |
38394 | 38468 | } |
38395 | - case 3237LLU: // repeat from here | |
38469 | + case 3246LLU: // repeat from here | |
38396 | 38470 | { |
38397 | 38471 | if(!stack[base + 3]) |
38398 | 38472 | { |
38399 | - label = 3238LLU; // break loop | |
38473 | + label = 3247LLU; // break loop | |
38400 | 38474 | break; |
38401 | 38475 | } |
38402 | 38476 |
@@ -38406,7 +38480,7 @@ | ||
38406 | 38480 | stack[base + 3] = (uint64_t)(((const struct listnode *)(stack[base + 3]))->next); |
38407 | 38481 | if(/*letdef*/0 != ((uint64_t *)(stack[base + 4]/*letdef*/))[0]) |
38408 | 38482 | { |
38409 | - label = 3241LLU; // jump to alternative | |
38483 | + label = 3250LLU; // jump to alternative | |
38410 | 38484 | break; |
38411 | 38485 | } |
38412 | 38486 |
@@ -38419,9 +38493,9 @@ | ||
38419 | 38493 | // case |
38420 | 38494 | printf("%s", "\n#undef "); |
38421 | 38495 | // call printid from emitundef |
38422 | - stack[base + 11LLU] = 3243LLU/*throw to this address*/; | |
38496 | + stack[base + 11LLU] = 3252LLU/*throw to this address*/; | |
38423 | 38497 | stack[base + 12LLU] = base; |
38424 | - stack[base + 13LLU] = 3244LLU; | |
38498 | + stack[base + 13LLU] = 3253LLU; | |
38425 | 38499 | // arguments for call to printid |
38426 | 38500 | stack[base + 14LLU] = stack[base + 7]/*id*/; |
38427 | 38501 | // set stack-base & callee-address |
@@ -38429,13 +38503,13 @@ | ||
38429 | 38503 | label = 18446744073709551587LLU; // printid |
38430 | 38504 | break; |
38431 | 38505 | } |
38432 | - case 3243LLU: // copy-back deleter (printid to emitundef) | |
38506 | + case 3252LLU: // copy-back deleter (printid to emitundef) | |
38433 | 38507 | { |
38434 | 38508 | // copy mutable arguments back from call to printid |
38435 | - label = 3242LLU; // continue to roll stack | |
38509 | + label = 3251LLU; // continue to roll stack | |
38436 | 38510 | break; |
38437 | 38511 | } |
38438 | - case 3244LLU: // return from printid to emitundef | |
38512 | + case 3253LLU: // return from printid to emitundef | |
38439 | 38513 | { |
38440 | 38514 | // copy mutable arguments back from call to printid |
38441 | 38515 | ((uint64_t **)(stack[base + 4]))[1][4] = stack[base + 10]; |
@@ -38443,10 +38517,10 @@ | ||
38443 | 38517 | ((uint64_t **)(stack[base + 4]))[1][2] = stack[base + 8]; |
38444 | 38518 | ((uint64_t **)(stack[base + 4]))[1][1] = stack[base + 7]; |
38445 | 38519 | ((uint64_t **)(stack[base + 4]))[1][0] = stack[base + 6]; |
38446 | - label = 3240LLU; // case complete | |
38520 | + label = 3249LLU; // case complete | |
38447 | 38521 | break; |
38448 | 38522 | } |
38449 | - case 3242LLU: // copy-back deleter (switch) | |
38523 | + case 3251LLU: // copy-back deleter (switch) | |
38450 | 38524 | { |
38451 | 38525 | ((uint64_t **)(stack[base + 4]))[1][4] = stack[base + 10]; |
38452 | 38526 | ((uint64_t **)(stack[base + 4]))[1][3] = stack[base + 9]; |
@@ -38453,46 +38527,46 @@ | ||
38453 | 38527 | ((uint64_t **)(stack[base + 4]))[1][2] = stack[base + 8]; |
38454 | 38528 | ((uint64_t **)(stack[base + 4]))[1][1] = stack[base + 7]; |
38455 | 38529 | ((uint64_t **)(stack[base + 4]))[1][0] = stack[base + 6]; |
38456 | - label = 3239LLU; // continue to unroll stack | |
38530 | + label = 3248LLU; // continue to unroll stack | |
38457 | 38531 | break; |
38458 | 38532 | } |
38459 | - case 3241LLU: // try next case | |
38533 | + case 3250LLU: // try next case | |
38460 | 38534 | { |
38461 | 38535 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
38462 | 38536 | exit(-1); |
38463 | 38537 | } |
38464 | - case 3240LLU: // completed switch | |
38538 | + case 3249LLU: // completed switch | |
38465 | 38539 | { |
38466 | 38540 | ((struct listnode *)(stack[base + 5]/*previous*/))->data = stack[base + 4]; |
38467 | - label = 3237LLU; // repeat | |
38541 | + label = 3246LLU; // repeat | |
38468 | 38542 | break; |
38469 | 38543 | } |
38470 | - case 3239LLU: // copy-back deleter for while next | |
38544 | + case 3248LLU: // copy-back deleter for while next | |
38471 | 38545 | { |
38472 | 38546 | ((struct listnode *)(stack[base + 5]/*previous*/))->data = stack[base + 4]; |
38473 | - label = 3236LLU; // continue to unroll stack | |
38547 | + label = 3245LLU; // continue to unroll stack | |
38474 | 38548 | break; |
38475 | 38549 | } |
38476 | - case 3238LLU: // loop finished | |
38550 | + case 3247LLU: // loop finished | |
38477 | 38551 | { |
38478 | 38552 | ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2]; |
38479 | 38553 | ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1]; |
38480 | - label = 3234LLU; // case complete | |
38554 | + label = 3243LLU; // case complete | |
38481 | 38555 | break; |
38482 | 38556 | } |
38483 | - case 3236LLU: // copy-back deleter (switch) | |
38557 | + case 3245LLU: // copy-back deleter (switch) | |
38484 | 38558 | { |
38485 | 38559 | ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2]; |
38486 | 38560 | ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1]; |
38487 | - label = 3233LLU; // continue to unroll stack | |
38561 | + label = 3242LLU; // continue to unroll stack | |
38488 | 38562 | break; |
38489 | 38563 | } |
38490 | - case 3235LLU: // try next case | |
38564 | + case 3244LLU: // try next case | |
38491 | 38565 | { |
38492 | 38566 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
38493 | 38567 | exit(-1); |
38494 | 38568 | } |
38495 | - case 3234LLU: // completed switch | |
38569 | + case 3243LLU: // completed switch | |
38496 | 38570 | { |
38497 | 38571 | // return from emitundef |
38498 | 38572 | label = stack[base - 1]; |
@@ -38499,26 +38573,26 @@ | ||
38499 | 38573 | base = stack[base - 2]; |
38500 | 38574 | break; |
38501 | 38575 | } |
38502 | - case 3246LLU: // function verbatim failed | |
38576 | + case 3255LLU: // function verbatim failed | |
38503 | 38577 | { |
38504 | 38578 | label = stack[base - 3]; |
38505 | 38579 | base = stack[base - 2]; |
38506 | 38580 | break; |
38507 | 38581 | } |
38508 | - case 3245LLU: // verbatim | |
38582 | + case 3254LLU: // verbatim | |
38509 | 38583 | { |
38510 | 38584 | //#define arg0 0 |
38511 | 38585 | //#define arg1 1 |
38512 | 38586 | //#define arg2 2 |
38513 | 38587 | flippedassign(stack[base + 0]/*scopes*/, &stack[base + 3]); |
38514 | - label = 3247LLU; // start to repeat | |
38588 | + label = 3256LLU; // start to repeat | |
38515 | 38589 | break; |
38516 | 38590 | } |
38517 | - case 3247LLU: // repeat from here | |
38591 | + case 3256LLU: // repeat from here | |
38518 | 38592 | { |
38519 | 38593 | if(!stack[base + 3]) |
38520 | 38594 | { |
38521 | - label = 3248LLU; // break loop | |
38595 | + label = 3257LLU; // break loop | |
38522 | 38596 | break; |
38523 | 38597 | } |
38524 | 38598 |
@@ -38527,88 +38601,88 @@ | ||
38527 | 38601 | stack[base + 5]/*previous*/ = stack[base + 3]; |
38528 | 38602 | stack[base + 3] = (uint64_t)(((const struct listnode *)(stack[base + 3]))->next); |
38529 | 38603 | // call emitdefine from verbatim |
38530 | - stack[base + 6LLU] = 3250LLU/*throw to this address*/; | |
38604 | + stack[base + 6LLU] = 3259LLU/*throw to this address*/; | |
38531 | 38605 | stack[base + 7LLU] = base; |
38532 | - stack[base + 8LLU] = 3251LLU; | |
38606 | + stack[base + 8LLU] = 3260LLU; | |
38533 | 38607 | // arguments for call to emitdefine |
38534 | 38608 | stack[base + 9LLU] = stack[base + 4]/*scope*/; |
38535 | 38609 | // set stack-base & callee-address |
38536 | 38610 | base += 9LLU; |
38537 | - label = 3217LLU; // emitdefine | |
38611 | + label = 3226LLU; // emitdefine | |
38538 | 38612 | break; |
38539 | 38613 | } |
38540 | - case 3250LLU: // copy-back deleter (emitdefine to verbatim) | |
38614 | + case 3259LLU: // copy-back deleter (emitdefine to verbatim) | |
38541 | 38615 | { |
38542 | 38616 | // copy mutable arguments back from call to emitdefine |
38543 | - label = 3249LLU; // continue to roll stack | |
38617 | + label = 3258LLU; // continue to roll stack | |
38544 | 38618 | break; |
38545 | 38619 | } |
38546 | - case 3251LLU: // return from emitdefine to verbatim | |
38620 | + case 3260LLU: // return from emitdefine to verbatim | |
38547 | 38621 | { |
38548 | 38622 | // copy mutable arguments back from call to emitdefine |
38549 | 38623 | ((struct listnode *)(stack[base + 5]/*previous*/))->data = stack[base + 4]; |
38550 | - label = 3247LLU; // repeat | |
38624 | + label = 3256LLU; // repeat | |
38551 | 38625 | break; |
38552 | 38626 | } |
38553 | - case 3249LLU: // copy-back deleter for while next | |
38627 | + case 3258LLU: // copy-back deleter for while next | |
38554 | 38628 | { |
38555 | 38629 | ((struct listnode *)(stack[base + 5]/*previous*/))->data = stack[base + 4]; |
38556 | - label = 3246LLU; // continue to unroll stack | |
38630 | + label = 3255LLU; // continue to unroll stack | |
38557 | 38631 | break; |
38558 | 38632 | } |
38559 | - case 3248LLU: // loop finished | |
38633 | + case 3257LLU: // loop finished | |
38560 | 38634 | { |
38561 | 38635 | // call emitdefine from verbatim |
38562 | - stack[base + 6LLU] = 3252LLU/*throw to this address*/; | |
38636 | + stack[base + 6LLU] = 3261LLU/*throw to this address*/; | |
38563 | 38637 | stack[base + 7LLU] = base; |
38564 | - stack[base + 8LLU] = 3253LLU; | |
38638 | + stack[base + 8LLU] = 3262LLU; | |
38565 | 38639 | // arguments for call to emitdefine |
38566 | 38640 | stack[base + 9LLU] = stack[base + 1]/*scope*/; |
38567 | 38641 | // set stack-base & callee-address |
38568 | 38642 | base += 9LLU; |
38569 | - label = 3217LLU; // emitdefine | |
38643 | + label = 3226LLU; // emitdefine | |
38570 | 38644 | break; |
38571 | 38645 | } |
38572 | - case 3252LLU: // copy-back deleter (emitdefine to verbatim) | |
38646 | + case 3261LLU: // copy-back deleter (emitdefine to verbatim) | |
38573 | 38647 | { |
38574 | 38648 | // copy mutable arguments back from call to emitdefine |
38575 | - label = 3246LLU; // continue to roll stack | |
38649 | + label = 3255LLU; // continue to roll stack | |
38576 | 38650 | break; |
38577 | 38651 | } |
38578 | - case 3253LLU: // return from emitdefine to verbatim | |
38652 | + case 3262LLU: // return from emitdefine to verbatim | |
38579 | 38653 | { |
38580 | 38654 | // copy mutable arguments back from call to emitdefine |
38581 | 38655 | // call VERBATIM from verbatim |
38582 | - stack[base + 6LLU] = 3254LLU/*throw to this address*/; | |
38656 | + stack[base + 6LLU] = 3263LLU/*throw to this address*/; | |
38583 | 38657 | stack[base + 7LLU] = base; |
38584 | - stack[base + 8LLU] = 3255LLU; | |
38658 | + stack[base + 8LLU] = 3264LLU; | |
38585 | 38659 | // arguments for call to VERBATIM |
38586 | 38660 | stack[base + 9LLU] = stack[base + 2]/*lookahead*/; |
38587 | 38661 | // set stack-base & callee-address |
38588 | 38662 | base += 9LLU; |
38589 | - label = 3203LLU; // VERBATIM | |
38663 | + label = 3212LLU; // VERBATIM | |
38590 | 38664 | break; |
38591 | 38665 | } |
38592 | - case 3254LLU: // copy-back deleter (VERBATIM to verbatim) | |
38666 | + case 3263LLU: // copy-back deleter (VERBATIM to verbatim) | |
38593 | 38667 | { |
38594 | 38668 | // copy mutable arguments back from call to VERBATIM |
38595 | 38669 | stack[base + 2]/*lookahead*/ = stack[base + 9LLU]; |
38596 | - label = 3246LLU; // continue to roll stack | |
38670 | + label = 3255LLU; // continue to roll stack | |
38597 | 38671 | break; |
38598 | 38672 | } |
38599 | - case 3255LLU: // return from VERBATIM to verbatim | |
38673 | + case 3264LLU: // return from VERBATIM to verbatim | |
38600 | 38674 | { |
38601 | 38675 | // copy mutable arguments back from call to VERBATIM |
38602 | 38676 | stack[base + 2]/*lookahead*/ = stack[base + 9LLU]; |
38603 | 38677 | flippedassign(stack[base + 0]/*scopes*/, &stack[base + 6]); |
38604 | - label = 3256LLU; // start to repeat | |
38678 | + label = 3265LLU; // start to repeat | |
38605 | 38679 | break; |
38606 | 38680 | } |
38607 | - case 3256LLU: // repeat from here | |
38681 | + case 3265LLU: // repeat from here | |
38608 | 38682 | { |
38609 | 38683 | if(!stack[base + 6]) |
38610 | 38684 | { |
38611 | - label = 3257LLU; // break loop | |
38685 | + label = 3266LLU; // break loop | |
38612 | 38686 | break; |
38613 | 38687 | } |
38614 | 38688 |
@@ -38617,55 +38691,55 @@ | ||
38617 | 38691 | stack[base + 8]/*previous*/ = stack[base + 6]; |
38618 | 38692 | stack[base + 6] = (uint64_t)(((const struct listnode *)(stack[base + 6]))->next); |
38619 | 38693 | // call emitundef from verbatim |
38620 | - stack[base + 9LLU] = 3259LLU/*throw to this address*/; | |
38694 | + stack[base + 9LLU] = 3268LLU/*throw to this address*/; | |
38621 | 38695 | stack[base + 10LLU] = base; |
38622 | - stack[base + 11LLU] = 3260LLU; | |
38696 | + stack[base + 11LLU] = 3269LLU; | |
38623 | 38697 | // arguments for call to emitundef |
38624 | 38698 | stack[base + 12LLU] = stack[base + 7]/*scope*/; |
38625 | 38699 | // set stack-base & callee-address |
38626 | 38700 | base += 12LLU; |
38627 | - label = 3232LLU; // emitundef | |
38701 | + label = 3241LLU; // emitundef | |
38628 | 38702 | break; |
38629 | 38703 | } |
38630 | - case 3259LLU: // copy-back deleter (emitundef to verbatim) | |
38704 | + case 3268LLU: // copy-back deleter (emitundef to verbatim) | |
38631 | 38705 | { |
38632 | 38706 | // copy mutable arguments back from call to emitundef |
38633 | - label = 3258LLU; // continue to roll stack | |
38707 | + label = 3267LLU; // continue to roll stack | |
38634 | 38708 | break; |
38635 | 38709 | } |
38636 | - case 3260LLU: // return from emitundef to verbatim | |
38710 | + case 3269LLU: // return from emitundef to verbatim | |
38637 | 38711 | { |
38638 | 38712 | // copy mutable arguments back from call to emitundef |
38639 | 38713 | ((struct listnode *)(stack[base + 8]/*previous*/))->data = stack[base + 7]; |
38640 | - label = 3256LLU; // repeat | |
38714 | + label = 3265LLU; // repeat | |
38641 | 38715 | break; |
38642 | 38716 | } |
38643 | - case 3258LLU: // copy-back deleter for while next | |
38717 | + case 3267LLU: // copy-back deleter for while next | |
38644 | 38718 | { |
38645 | 38719 | ((struct listnode *)(stack[base + 8]/*previous*/))->data = stack[base + 7]; |
38646 | - label = 3246LLU; // continue to unroll stack | |
38720 | + label = 3255LLU; // continue to unroll stack | |
38647 | 38721 | break; |
38648 | 38722 | } |
38649 | - case 3257LLU: // loop finished | |
38723 | + case 3266LLU: // loop finished | |
38650 | 38724 | { |
38651 | 38725 | // call emitundef from verbatim |
38652 | - stack[base + 9LLU] = 3261LLU/*throw to this address*/; | |
38726 | + stack[base + 9LLU] = 3270LLU/*throw to this address*/; | |
38653 | 38727 | stack[base + 10LLU] = base; |
38654 | - stack[base + 11LLU] = 3262LLU; | |
38728 | + stack[base + 11LLU] = 3271LLU; | |
38655 | 38729 | // arguments for call to emitundef |
38656 | 38730 | stack[base + 12LLU] = stack[base + 1]/*scope*/; |
38657 | 38731 | // set stack-base & callee-address |
38658 | 38732 | base += 12LLU; |
38659 | - label = 3232LLU; // emitundef | |
38733 | + label = 3241LLU; // emitundef | |
38660 | 38734 | break; |
38661 | 38735 | } |
38662 | - case 3261LLU: // copy-back deleter (emitundef to verbatim) | |
38736 | + case 3270LLU: // copy-back deleter (emitundef to verbatim) | |
38663 | 38737 | { |
38664 | 38738 | // copy mutable arguments back from call to emitundef |
38665 | - label = 3246LLU; // continue to roll stack | |
38739 | + label = 3255LLU; // continue to roll stack | |
38666 | 38740 | break; |
38667 | 38741 | } |
38668 | - case 3262LLU: // return from emitundef to verbatim | |
38742 | + case 3271LLU: // return from emitundef to verbatim | |
38669 | 38743 | { |
38670 | 38744 | // copy mutable arguments back from call to emitundef |
38671 | 38745 | // return from verbatim |
@@ -38673,39 +38747,39 @@ | ||
38673 | 38747 | base = stack[base - 2]; |
38674 | 38748 | break; |
38675 | 38749 | } |
38676 | - case 3264LLU: // function listtoelem failed | |
38750 | + case 3273LLU: // function listtoelem failed | |
38677 | 38751 | { |
38678 | 38752 | label = stack[base - 3]; |
38679 | 38753 | base = stack[base - 2]; |
38680 | 38754 | break; |
38681 | 38755 | } |
38682 | - case 3263LLU: // listtoelem | |
38756 | + case 3272LLU: // listtoelem | |
38683 | 38757 | { |
38684 | 38758 | //#define res0 0 |
38685 | 38759 | //#define res1 1 |
38686 | 38760 | //#define arg0 2 |
38687 | 38761 | //#define arg1 3 |
38688 | - label = 3266LLU; // skip deleter | |
38762 | + label = 3275LLU; // skip deleter | |
38689 | 38763 | break; |
38690 | 38764 | } |
38691 | - case 3265LLU: // deleter | |
38765 | + case 3274LLU: // deleter | |
38692 | 38766 | { |
38693 | 38767 | // throw from listtoelem |
38694 | 38768 | if(!stack[base + 4]) |
38695 | 38769 | { |
38696 | - label = 3264LLU; // skip, variable already deleted/unscoped | |
38770 | + label = 3273LLU; // skip, variable already deleted/unscoped | |
38697 | 38771 | break; |
38698 | 38772 | } |
38699 | - label = 3264LLU; // continue unrolling stack, delete next variable | |
38773 | + label = 3273LLU; // continue unrolling stack, delete next variable | |
38700 | 38774 | break; |
38701 | 38775 | } |
38702 | - case 3266LLU: // skipped deleter | |
38776 | + case 3275LLU: // skipped deleter | |
38703 | 38777 | { |
38704 | 38778 | stack[base + 4] = 0; |
38705 | 38779 | // call matchsym from listtoelem |
38706 | - stack[base + 5LLU] = 3267LLU/*throw to this address*/; | |
38780 | + stack[base + 5LLU] = 3276LLU/*throw to this address*/; | |
38707 | 38781 | stack[base + 6LLU] = base; |
38708 | - stack[base + 7LLU] = 3268LLU; | |
38782 | + stack[base + 7LLU] = 3277LLU; | |
38709 | 38783 | // arguments for call to matchsym |
38710 | 38784 | stack[base + 8LLU] = stack[base + 2]/*fnid*/; |
38711 | 38785 | stack[base + 9LLU] = 40LLU; |
@@ -38715,53 +38789,53 @@ | ||
38715 | 38789 | label = 246LLU; // matchsym |
38716 | 38790 | break; |
38717 | 38791 | } |
38718 | - case 3267LLU: // copy-back deleter (matchsym to listtoelem) | |
38792 | + case 3276LLU: // copy-back deleter (matchsym to listtoelem) | |
38719 | 38793 | { |
38720 | 38794 | // copy mutable arguments back from call to matchsym |
38721 | 38795 | stack[base + 3]/*lookahead*/ = stack[base + 10LLU]; |
38722 | - label = 3265LLU; // continue to roll stack | |
38796 | + label = 3274LLU; // continue to roll stack | |
38723 | 38797 | break; |
38724 | 38798 | } |
38725 | - case 3268LLU: // return from matchsym to listtoelem | |
38799 | + case 3277LLU: // return from matchsym to listtoelem | |
38726 | 38800 | { |
38727 | 38801 | // copy mutable arguments back from call to matchsym |
38728 | 38802 | stack[base + 3]/*lookahead*/ = stack[base + 10LLU]; |
38729 | - label = 3270LLU; // skip deleter | |
38803 | + label = 3279LLU; // skip deleter | |
38730 | 38804 | break; |
38731 | 38805 | } |
38732 | - case 3269LLU: // deleter | |
38806 | + case 3278LLU: // deleter | |
38733 | 38807 | { |
38734 | 38808 | // throw from listtoelem |
38735 | 38809 | if(!stack[base + 5]) |
38736 | 38810 | { |
38737 | - label = 3265LLU; // skip, variable already deleted/unscoped | |
38811 | + label = 3274LLU; // skip, variable already deleted/unscoped | |
38738 | 38812 | break; |
38739 | 38813 | } |
38740 | - label = 3265LLU; // continue unrolling stack, delete next variable | |
38814 | + label = 3274LLU; // continue unrolling stack, delete next variable | |
38741 | 38815 | break; |
38742 | 38816 | } |
38743 | - case 3270LLU: // skipped deleter | |
38817 | + case 3279LLU: // skipped deleter | |
38744 | 38818 | { |
38745 | - label = 3272LLU; // skip deleter | |
38819 | + label = 3281LLU; // skip deleter | |
38746 | 38820 | break; |
38747 | 38821 | } |
38748 | - case 3271LLU: // deleter | |
38822 | + case 3280LLU: // deleter | |
38749 | 38823 | { |
38750 | 38824 | // throw from listtoelem |
38751 | 38825 | if(!stack[base + 6]) |
38752 | 38826 | { |
38753 | - label = 3269LLU; // skip, variable already deleted/unscoped | |
38827 | + label = 3278LLU; // skip, variable already deleted/unscoped | |
38754 | 38828 | break; |
38755 | 38829 | } |
38756 | - label = 3269LLU; // continue unrolling stack, delete next variable | |
38830 | + label = 3278LLU; // continue unrolling stack, delete next variable | |
38757 | 38831 | break; |
38758 | 38832 | } |
38759 | - case 3272LLU: // skipped deleter | |
38833 | + case 3281LLU: // skipped deleter | |
38760 | 38834 | { |
38761 | 38835 | // call ParseToken from listtoelem |
38762 | - stack[base + 7LLU] = 3273LLU/*throw to this address*/; | |
38836 | + stack[base + 7LLU] = 3282LLU/*throw to this address*/; | |
38763 | 38837 | stack[base + 8LLU] = base; |
38764 | - stack[base + 9LLU] = 3274LLU; | |
38838 | + stack[base + 9LLU] = 3283LLU; | |
38765 | 38839 | // arguments for call to ParseToken |
38766 | 38840 | stack[base + 12LLU] = stack[base + 3]/*lookahead*/; |
38767 | 38841 | // set stack-base & callee-address |
@@ -38769,14 +38843,14 @@ | ||
38769 | 38843 | label = 3LLU; // ParseToken |
38770 | 38844 | break; |
38771 | 38845 | } |
38772 | - case 3273LLU: // copy-back deleter (ParseToken to listtoelem) | |
38846 | + case 3282LLU: // copy-back deleter (ParseToken to listtoelem) | |
38773 | 38847 | { |
38774 | 38848 | // copy mutable arguments back from call to ParseToken |
38775 | 38849 | stack[base + 3]/*lookahead*/ = stack[base + 12LLU]; |
38776 | - label = 3265LLU; // continue to roll stack | |
38850 | + label = 3274LLU; // continue to roll stack | |
38777 | 38851 | break; |
38778 | 38852 | } |
38779 | - case 3274LLU: // return from ParseToken to listtoelem | |
38853 | + case 3283LLU: // return from ParseToken to listtoelem | |
38780 | 38854 | { |
38781 | 38855 | // copy mutable arguments back from call to ParseToken |
38782 | 38856 | stack[base + 3]/*lookahead*/ = stack[base + 12LLU]; |
@@ -38784,9 +38858,9 @@ | ||
38784 | 38858 | stack[base + 5] = stack[base + 10LLU]; |
38785 | 38859 | stack[base + 6] = stack[base + 11LLU]; |
38786 | 38860 | // call equ from listtoelem |
38787 | - stack[base + 7LLU] = 3275LLU/*throw to this address*/; | |
38861 | + stack[base + 7LLU] = 3284LLU/*throw to this address*/; | |
38788 | 38862 | stack[base + 8LLU] = base; |
38789 | - stack[base + 9LLU] = 3276LLU; | |
38863 | + stack[base + 9LLU] = 3285LLU; | |
38790 | 38864 | // arguments for call to equ |
38791 | 38865 | stack[base + 11LLU] = stack[base + 5]/*variant*/; |
38792 | 38866 | stack[base + 12LLU] = 4LLU; |
@@ -38795,13 +38869,13 @@ | ||
38795 | 38869 | label = 18446744073709551600LLU; // equ |
38796 | 38870 | break; |
38797 | 38871 | } |
38798 | - case 3275LLU: // copy-back deleter (equ to listtoelem) | |
38872 | + case 3284LLU: // copy-back deleter (equ to listtoelem) | |
38799 | 38873 | { |
38800 | 38874 | // copy mutable arguments back from call to equ |
38801 | - label = 3271LLU; // continue to roll stack | |
38875 | + label = 3280LLU; // continue to roll stack | |
38802 | 38876 | break; |
38803 | 38877 | } |
38804 | - case 3276LLU: // return from equ to listtoelem | |
38878 | + case 3285LLU: // return from equ to listtoelem | |
38805 | 38879 | { |
38806 | 38880 | // copy mutable arguments back from call to equ |
38807 | 38881 | // copy back results provided by call to equ |
@@ -38808,21 +38882,21 @@ | ||
38808 | 38882 | stack[base + 4] = stack[base + 10LLU]; |
38809 | 38883 | if(!stack[base + 4]/*isequal*/) |
38810 | 38884 | { |
38811 | - label = 3277LLU; // jump to alternative | |
38885 | + label = 3286LLU; // jump to alternative | |
38812 | 38886 | break; |
38813 | 38887 | } |
38814 | 38888 | |
38815 | 38889 | // consequent |
38816 | - label = 3278LLU; // consequent complete | |
38890 | + label = 3287LLU; // consequent complete | |
38817 | 38891 | break; |
38818 | 38892 | } |
38819 | - case 3277LLU: // alternative | |
38893 | + case 3286LLU: // alternative | |
38820 | 38894 | { |
38821 | 38895 | fprintf(stderr, "%s", "expected identifier in while next but found "); |
38822 | 38896 | // call reporttok from listtoelem |
38823 | - stack[base + 7LLU] = 3279LLU/*throw to this address*/; | |
38897 | + stack[base + 7LLU] = 3288LLU/*throw to this address*/; | |
38824 | 38898 | stack[base + 8LLU] = base; |
38825 | - stack[base + 9LLU] = 3280LLU; | |
38899 | + stack[base + 9LLU] = 3289LLU; | |
38826 | 38900 | // arguments for call to reporttok |
38827 | 38901 | stack[base + 10LLU] = stack[base + 5]/*variant*/; |
38828 | 38902 | stack[base + 11LLU] = stack[base + 6]/*listid*/; |
@@ -38831,30 +38905,30 @@ | ||
38831 | 38905 | label = 18446744073709551582LLU; // reporttok |
38832 | 38906 | break; |
38833 | 38907 | } |
38834 | - case 3279LLU: // copy-back deleter (reporttok to listtoelem) | |
38908 | + case 3288LLU: // copy-back deleter (reporttok to listtoelem) | |
38835 | 38909 | { |
38836 | 38910 | // copy mutable arguments back from call to reporttok |
38837 | - label = 3271LLU; // continue to roll stack | |
38911 | + label = 3280LLU; // continue to roll stack | |
38838 | 38912 | break; |
38839 | 38913 | } |
38840 | - case 3280LLU: // return from reporttok to listtoelem | |
38914 | + case 3289LLU: // return from reporttok to listtoelem | |
38841 | 38915 | { |
38842 | 38916 | // copy mutable arguments back from call to reporttok |
38843 | 38917 | fprintf(stderr, "%s", "\n"); |
38844 | 38918 | { |
38845 | - label = 3271LLU; // throw: begin to unroll stack | |
38919 | + label = 3280LLU; // throw: begin to unroll stack | |
38846 | 38920 | break; |
38847 | 38921 | } |
38848 | 38922 | |
38849 | - label = 3278LLU; // alternative complete | |
38923 | + label = 3287LLU; // alternative complete | |
38850 | 38924 | break; |
38851 | 38925 | } |
38852 | - case 3278LLU: // completed if-then-else | |
38926 | + case 3287LLU: // completed if-then-else | |
38853 | 38927 | { |
38854 | 38928 | // call matchsym from listtoelem |
38855 | - stack[base + 7LLU] = 3281LLU/*throw to this address*/; | |
38929 | + stack[base + 7LLU] = 3290LLU/*throw to this address*/; | |
38856 | 38930 | stack[base + 8LLU] = base; |
38857 | - stack[base + 9LLU] = 3282LLU; | |
38931 | + stack[base + 9LLU] = 3291LLU; | |
38858 | 38932 | // arguments for call to matchsym |
38859 | 38933 | stack[base + 10LLU] = stack[base + 2]/*fnid*/; |
38860 | 38934 | stack[base + 11LLU] = 41LLU; |
@@ -38864,21 +38938,21 @@ | ||
38864 | 38938 | label = 246LLU; // matchsym |
38865 | 38939 | break; |
38866 | 38940 | } |
38867 | - case 3281LLU: // copy-back deleter (matchsym to listtoelem) | |
38941 | + case 3290LLU: // copy-back deleter (matchsym to listtoelem) | |
38868 | 38942 | { |
38869 | 38943 | // copy mutable arguments back from call to matchsym |
38870 | 38944 | stack[base + 3]/*lookahead*/ = stack[base + 12LLU]; |
38871 | - label = 3271LLU; // continue to roll stack | |
38945 | + label = 3280LLU; // continue to roll stack | |
38872 | 38946 | break; |
38873 | 38947 | } |
38874 | - case 3282LLU: // return from matchsym to listtoelem | |
38948 | + case 3291LLU: // return from matchsym to listtoelem | |
38875 | 38949 | { |
38876 | 38950 | // copy mutable arguments back from call to matchsym |
38877 | 38951 | stack[base + 3]/*lookahead*/ = stack[base + 12LLU]; |
38878 | 38952 | // call matchsym from listtoelem |
38879 | - stack[base + 7LLU] = 3283LLU/*throw to this address*/; | |
38953 | + stack[base + 7LLU] = 3292LLU/*throw to this address*/; | |
38880 | 38954 | stack[base + 8LLU] = base; |
38881 | - stack[base + 9LLU] = 3284LLU; | |
38955 | + stack[base + 9LLU] = 3293LLU; | |
38882 | 38956 | // arguments for call to matchsym |
38883 | 38957 | stack[base + 10LLU] = stack[base + 2]/*fnid*/; |
38884 | 38958 | stack[base + 11LLU] = 45LLU; |
@@ -38888,21 +38962,21 @@ | ||
38888 | 38962 | label = 246LLU; // matchsym |
38889 | 38963 | break; |
38890 | 38964 | } |
38891 | - case 3283LLU: // copy-back deleter (matchsym to listtoelem) | |
38965 | + case 3292LLU: // copy-back deleter (matchsym to listtoelem) | |
38892 | 38966 | { |
38893 | 38967 | // copy mutable arguments back from call to matchsym |
38894 | 38968 | stack[base + 3]/*lookahead*/ = stack[base + 12LLU]; |
38895 | - label = 3271LLU; // continue to roll stack | |
38969 | + label = 3280LLU; // continue to roll stack | |
38896 | 38970 | break; |
38897 | 38971 | } |
38898 | - case 3284LLU: // return from matchsym to listtoelem | |
38972 | + case 3293LLU: // return from matchsym to listtoelem | |
38899 | 38973 | { |
38900 | 38974 | // copy mutable arguments back from call to matchsym |
38901 | 38975 | stack[base + 3]/*lookahead*/ = stack[base + 12LLU]; |
38902 | 38976 | // call matchsym from listtoelem |
38903 | - stack[base + 7LLU] = 3285LLU/*throw to this address*/; | |
38977 | + stack[base + 7LLU] = 3294LLU/*throw to this address*/; | |
38904 | 38978 | stack[base + 8LLU] = base; |
38905 | - stack[base + 9LLU] = 3286LLU; | |
38979 | + stack[base + 9LLU] = 3295LLU; | |
38906 | 38980 | // arguments for call to matchsym |
38907 | 38981 | stack[base + 10LLU] = stack[base + 2]/*fnid*/; |
38908 | 38982 | stack[base + 11LLU] = 62LLU; |
@@ -38912,21 +38986,21 @@ | ||
38912 | 38986 | label = 246LLU; // matchsym |
38913 | 38987 | break; |
38914 | 38988 | } |
38915 | - case 3285LLU: // copy-back deleter (matchsym to listtoelem) | |
38989 | + case 3294LLU: // copy-back deleter (matchsym to listtoelem) | |
38916 | 38990 | { |
38917 | 38991 | // copy mutable arguments back from call to matchsym |
38918 | 38992 | stack[base + 3]/*lookahead*/ = stack[base + 12LLU]; |
38919 | - label = 3271LLU; // continue to roll stack | |
38993 | + label = 3280LLU; // continue to roll stack | |
38920 | 38994 | break; |
38921 | 38995 | } |
38922 | - case 3286LLU: // return from matchsym to listtoelem | |
38996 | + case 3295LLU: // return from matchsym to listtoelem | |
38923 | 38997 | { |
38924 | 38998 | // copy mutable arguments back from call to matchsym |
38925 | 38999 | stack[base + 3]/*lookahead*/ = stack[base + 12LLU]; |
38926 | 39000 | // call matchsym from listtoelem |
38927 | - stack[base + 7LLU] = 3287LLU/*throw to this address*/; | |
39001 | + stack[base + 7LLU] = 3296LLU/*throw to this address*/; | |
38928 | 39002 | stack[base + 8LLU] = base; |
38929 | - stack[base + 9LLU] = 3288LLU; | |
39003 | + stack[base + 9LLU] = 3297LLU; | |
38930 | 39004 | // arguments for call to matchsym |
38931 | 39005 | stack[base + 10LLU] = stack[base + 2]/*fnid*/; |
38932 | 39006 | stack[base + 11LLU] = 40LLU; |
@@ -38936,53 +39010,53 @@ | ||
38936 | 39010 | label = 246LLU; // matchsym |
38937 | 39011 | break; |
38938 | 39012 | } |
38939 | - case 3287LLU: // copy-back deleter (matchsym to listtoelem) | |
39013 | + case 3296LLU: // copy-back deleter (matchsym to listtoelem) | |
38940 | 39014 | { |
38941 | 39015 | // copy mutable arguments back from call to matchsym |
38942 | 39016 | stack[base + 3]/*lookahead*/ = stack[base + 12LLU]; |
38943 | - label = 3271LLU; // continue to roll stack | |
39017 | + label = 3280LLU; // continue to roll stack | |
38944 | 39018 | break; |
38945 | 39019 | } |
38946 | - case 3288LLU: // return from matchsym to listtoelem | |
39020 | + case 3297LLU: // return from matchsym to listtoelem | |
38947 | 39021 | { |
38948 | 39022 | // copy mutable arguments back from call to matchsym |
38949 | 39023 | stack[base + 3]/*lookahead*/ = stack[base + 12LLU]; |
38950 | - label = 3290LLU; // skip deleter | |
39024 | + label = 3299LLU; // skip deleter | |
38951 | 39025 | break; |
38952 | 39026 | } |
38953 | - case 3289LLU: // deleter | |
39027 | + case 3298LLU: // deleter | |
38954 | 39028 | { |
38955 | 39029 | // throw from listtoelem |
38956 | 39030 | if(!stack[base + 7]) |
38957 | 39031 | { |
38958 | - label = 3271LLU; // skip, variable already deleted/unscoped | |
39032 | + label = 3280LLU; // skip, variable already deleted/unscoped | |
38959 | 39033 | break; |
38960 | 39034 | } |
38961 | - label = 3271LLU; // continue unrolling stack, delete next variable | |
39035 | + label = 3280LLU; // continue unrolling stack, delete next variable | |
38962 | 39036 | break; |
38963 | 39037 | } |
38964 | - case 3290LLU: // skipped deleter | |
39038 | + case 3299LLU: // skipped deleter | |
38965 | 39039 | { |
38966 | - label = 3292LLU; // skip deleter | |
39040 | + label = 3301LLU; // skip deleter | |
38967 | 39041 | break; |
38968 | 39042 | } |
38969 | - case 3291LLU: // deleter | |
39043 | + case 3300LLU: // deleter | |
38970 | 39044 | { |
38971 | 39045 | // throw from listtoelem |
38972 | 39046 | if(!stack[base + 8]) |
38973 | 39047 | { |
38974 | - label = 3289LLU; // skip, variable already deleted/unscoped | |
39048 | + label = 3298LLU; // skip, variable already deleted/unscoped | |
38975 | 39049 | break; |
38976 | 39050 | } |
38977 | - label = 3289LLU; // continue unrolling stack, delete next variable | |
39051 | + label = 3298LLU; // continue unrolling stack, delete next variable | |
38978 | 39052 | break; |
38979 | 39053 | } |
38980 | - case 3292LLU: // skipped deleter | |
39054 | + case 3301LLU: // skipped deleter | |
38981 | 39055 | { |
38982 | 39056 | // call ParseToken from listtoelem |
38983 | - stack[base + 9LLU] = 3293LLU/*throw to this address*/; | |
39057 | + stack[base + 9LLU] = 3302LLU/*throw to this address*/; | |
38984 | 39058 | stack[base + 10LLU] = base; |
38985 | - stack[base + 11LLU] = 3294LLU; | |
39059 | + stack[base + 11LLU] = 3303LLU; | |
38986 | 39060 | // arguments for call to ParseToken |
38987 | 39061 | stack[base + 14LLU] = stack[base + 3]/*lookahead*/; |
38988 | 39062 | // set stack-base & callee-address |
@@ -38990,14 +39064,14 @@ | ||
38990 | 39064 | label = 3LLU; // ParseToken |
38991 | 39065 | break; |
38992 | 39066 | } |
38993 | - case 3293LLU: // copy-back deleter (ParseToken to listtoelem) | |
39067 | + case 3302LLU: // copy-back deleter (ParseToken to listtoelem) | |
38994 | 39068 | { |
38995 | 39069 | // copy mutable arguments back from call to ParseToken |
38996 | 39070 | stack[base + 3]/*lookahead*/ = stack[base + 14LLU]; |
38997 | - label = 3271LLU; // continue to roll stack | |
39071 | + label = 3280LLU; // continue to roll stack | |
38998 | 39072 | break; |
38999 | 39073 | } |
39000 | - case 3294LLU: // return from ParseToken to listtoelem | |
39074 | + case 3303LLU: // return from ParseToken to listtoelem | |
39001 | 39075 | { |
39002 | 39076 | // copy mutable arguments back from call to ParseToken |
39003 | 39077 | stack[base + 3]/*lookahead*/ = stack[base + 14LLU]; |
@@ -39005,9 +39079,9 @@ | ||
39005 | 39079 | stack[base + 7] = stack[base + 12LLU]; |
39006 | 39080 | stack[base + 8] = stack[base + 13LLU]; |
39007 | 39081 | // call equ from listtoelem |
39008 | - stack[base + 9LLU] = 3295LLU/*throw to this address*/; | |
39082 | + stack[base + 9LLU] = 3304LLU/*throw to this address*/; | |
39009 | 39083 | stack[base + 10LLU] = base; |
39010 | - stack[base + 11LLU] = 3296LLU; | |
39084 | + stack[base + 11LLU] = 3305LLU; | |
39011 | 39085 | // arguments for call to equ |
39012 | 39086 | stack[base + 13LLU] = stack[base + 7]/*variant*/; |
39013 | 39087 | stack[base + 14LLU] = 4LLU; |
@@ -39016,13 +39090,13 @@ | ||
39016 | 39090 | label = 18446744073709551600LLU; // equ |
39017 | 39091 | break; |
39018 | 39092 | } |
39019 | - case 3295LLU: // copy-back deleter (equ to listtoelem) | |
39093 | + case 3304LLU: // copy-back deleter (equ to listtoelem) | |
39020 | 39094 | { |
39021 | 39095 | // copy mutable arguments back from call to equ |
39022 | - label = 3291LLU; // continue to roll stack | |
39096 | + label = 3300LLU; // continue to roll stack | |
39023 | 39097 | break; |
39024 | 39098 | } |
39025 | - case 3296LLU: // return from equ to listtoelem | |
39099 | + case 3305LLU: // return from equ to listtoelem | |
39026 | 39100 | { |
39027 | 39101 | // copy mutable arguments back from call to equ |
39028 | 39102 | // copy back results provided by call to equ |
@@ -39029,21 +39103,21 @@ | ||
39029 | 39103 | stack[base + 4] = stack[base + 12LLU]; |
39030 | 39104 | if(!stack[base + 4]/*isequal*/) |
39031 | 39105 | { |
39032 | - label = 3297LLU; // jump to alternative | |
39106 | + label = 3306LLU; // jump to alternative | |
39033 | 39107 | break; |
39034 | 39108 | } |
39035 | 39109 | |
39036 | 39110 | // consequent |
39037 | - label = 3298LLU; // consequent complete | |
39111 | + label = 3307LLU; // consequent complete | |
39038 | 39112 | break; |
39039 | 39113 | } |
39040 | - case 3297LLU: // alternative | |
39114 | + case 3306LLU: // alternative | |
39041 | 39115 | { |
39042 | 39116 | fprintf(stderr, "%s", "expected identifier in while next but found "); |
39043 | 39117 | // call reporttok from listtoelem |
39044 | - stack[base + 9LLU] = 3299LLU/*throw to this address*/; | |
39118 | + stack[base + 9LLU] = 3308LLU/*throw to this address*/; | |
39045 | 39119 | stack[base + 10LLU] = base; |
39046 | - stack[base + 11LLU] = 3300LLU; | |
39120 | + stack[base + 11LLU] = 3309LLU; | |
39047 | 39121 | // arguments for call to reporttok |
39048 | 39122 | stack[base + 12LLU] = stack[base + 7]/*variant*/; |
39049 | 39123 | stack[base + 13LLU] = stack[base + 8]/*elemid*/; |
@@ -39052,30 +39126,30 @@ | ||
39052 | 39126 | label = 18446744073709551582LLU; // reporttok |
39053 | 39127 | break; |
39054 | 39128 | } |
39055 | - case 3299LLU: // copy-back deleter (reporttok to listtoelem) | |
39129 | + case 3308LLU: // copy-back deleter (reporttok to listtoelem) | |
39056 | 39130 | { |
39057 | 39131 | // copy mutable arguments back from call to reporttok |
39058 | - label = 3291LLU; // continue to roll stack | |
39132 | + label = 3300LLU; // continue to roll stack | |
39059 | 39133 | break; |
39060 | 39134 | } |
39061 | - case 3300LLU: // return from reporttok to listtoelem | |
39135 | + case 3309LLU: // return from reporttok to listtoelem | |
39062 | 39136 | { |
39063 | 39137 | // copy mutable arguments back from call to reporttok |
39064 | 39138 | fprintf(stderr, "%s", "\n"); |
39065 | 39139 | { |
39066 | - label = 3291LLU; // throw: begin to unroll stack | |
39140 | + label = 3300LLU; // throw: begin to unroll stack | |
39067 | 39141 | break; |
39068 | 39142 | } |
39069 | 39143 | |
39070 | - label = 3298LLU; // alternative complete | |
39144 | + label = 3307LLU; // alternative complete | |
39071 | 39145 | break; |
39072 | 39146 | } |
39073 | - case 3298LLU: // completed if-then-else | |
39147 | + case 3307LLU: // completed if-then-else | |
39074 | 39148 | { |
39075 | 39149 | // call matchsym from listtoelem |
39076 | - stack[base + 9LLU] = 3301LLU/*throw to this address*/; | |
39150 | + stack[base + 9LLU] = 3310LLU/*throw to this address*/; | |
39077 | 39151 | stack[base + 10LLU] = base; |
39078 | - stack[base + 11LLU] = 3302LLU; | |
39152 | + stack[base + 11LLU] = 3311LLU; | |
39079 | 39153 | // arguments for call to matchsym |
39080 | 39154 | stack[base + 12LLU] = stack[base + 2]/*fnid*/; |
39081 | 39155 | stack[base + 13LLU] = 41LLU; |
@@ -39085,49 +39159,49 @@ | ||
39085 | 39159 | label = 246LLU; // matchsym |
39086 | 39160 | break; |
39087 | 39161 | } |
39088 | - case 3301LLU: // copy-back deleter (matchsym to listtoelem) | |
39162 | + case 3310LLU: // copy-back deleter (matchsym to listtoelem) | |
39089 | 39163 | { |
39090 | 39164 | // copy mutable arguments back from call to matchsym |
39091 | 39165 | stack[base + 3]/*lookahead*/ = stack[base + 14LLU]; |
39092 | - label = 3291LLU; // continue to roll stack | |
39166 | + label = 3300LLU; // continue to roll stack | |
39093 | 39167 | break; |
39094 | 39168 | } |
39095 | - case 3302LLU: // return from matchsym to listtoelem | |
39169 | + case 3311LLU: // return from matchsym to listtoelem | |
39096 | 39170 | { |
39097 | 39171 | // copy mutable arguments back from call to matchsym |
39098 | 39172 | stack[base + 3]/*lookahead*/ = stack[base + 14LLU]; |
39099 | - label = 3304LLU; // skip deleter | |
39173 | + label = 3313LLU; // skip deleter | |
39100 | 39174 | break; |
39101 | 39175 | } |
39102 | - case 3303LLU: // deleter | |
39176 | + case 3312LLU: // deleter | |
39103 | 39177 | { |
39104 | 39178 | // throw from listtoelem |
39105 | 39179 | if(!stack[base + 0]) |
39106 | 39180 | { |
39107 | - label = 3291LLU; // skip, variable already deleted/unscoped | |
39181 | + label = 3300LLU; // skip, variable already deleted/unscoped | |
39108 | 39182 | break; |
39109 | 39183 | } |
39110 | - label = 3291LLU; // continue unrolling stack, delete next variable | |
39184 | + label = 3300LLU; // continue unrolling stack, delete next variable | |
39111 | 39185 | break; |
39112 | 39186 | } |
39113 | - case 3304LLU: // skipped deleter | |
39187 | + case 3313LLU: // skipped deleter | |
39114 | 39188 | { |
39115 | 39189 | stack[base + 0] = stack[base + 6]/*listid*/; |
39116 | - label = 3306LLU; // skip deleter | |
39190 | + label = 3315LLU; // skip deleter | |
39117 | 39191 | break; |
39118 | 39192 | } |
39119 | - case 3305LLU: // deleter | |
39193 | + case 3314LLU: // deleter | |
39120 | 39194 | { |
39121 | 39195 | // throw from listtoelem |
39122 | 39196 | if(!stack[base + 1]) |
39123 | 39197 | { |
39124 | - label = 3303LLU; // skip, variable already deleted/unscoped | |
39198 | + label = 3312LLU; // skip, variable already deleted/unscoped | |
39125 | 39199 | break; |
39126 | 39200 | } |
39127 | - label = 3303LLU; // continue unrolling stack, delete next variable | |
39201 | + label = 3312LLU; // continue unrolling stack, delete next variable | |
39128 | 39202 | break; |
39129 | 39203 | } |
39130 | - case 3306LLU: // skipped deleter | |
39204 | + case 3315LLU: // skipped deleter | |
39131 | 39205 | { |
39132 | 39206 | stack[base + 1] = stack[base + 8]/*elemid*/; |
39133 | 39207 | // return from listtoelem |
@@ -39135,7 +39209,7 @@ | ||
39135 | 39209 | base = stack[base - 2]; |
39136 | 39210 | break; |
39137 | 39211 | } |
39138 | - case 3307LLU: // ~popnext | |
39212 | + case 3316LLU: // ~popnext | |
39139 | 39213 | { |
39140 | 39214 | if(stack[base + 0]/*variant-nr*/ >= 2) |
39141 | 39215 | { |
@@ -39142,10 +39216,10 @@ | ||
39142 | 39216 | fprintf(stderr, "in ~popnext: unknown variant-nr %d\n", (int)stack[base + 0]/*variant-nr*/); |
39143 | 39217 | exit(-1); |
39144 | 39218 | } |
39145 | - label = 3307LLU + 1LLU + stack[base + 0]/*variant-nr*/; | |
39219 | + label = 3316LLU + 1LLU + stack[base + 0]/*variant-nr*/; | |
39146 | 39220 | break; |
39147 | 39221 | } |
39148 | - case 3307LLU + 1LLU + 0LLU: // ~popnext.pop | |
39222 | + case 3316LLU + 1LLU + 0LLU: // ~popnext.pop | |
39149 | 39223 | { |
39150 | 39224 | // release variant container |
39151 | 39225 | Free(0, sizeof(uint64_t), ((uint64_t *)stack[base + 1]/*variant*/)); |
@@ -39153,7 +39227,7 @@ | ||
39153 | 39227 | base = stack[base - 2]; |
39154 | 39228 | break; |
39155 | 39229 | } |
39156 | - case 3307LLU + 1LLU + 1LLU: // ~popnext.next | |
39230 | + case 3316LLU + 1LLU + 1LLU: // ~popnext.next | |
39157 | 39231 | { |
39158 | 39232 | // release element previdx |
39159 | 39233 | // release variant container |
@@ -39162,7 +39236,7 @@ | ||
39162 | 39236 | base = stack[base - 2]; |
39163 | 39237 | break; |
39164 | 39238 | } |
39165 | - case 3310LLU: // ~listtoelem | |
39239 | + case 3319LLU: // ~listtoelem | |
39166 | 39240 | { |
39167 | 39241 | if(stack[base + 0]/*variant-nr*/ >= 1) |
39168 | 39242 | { |
@@ -39169,10 +39243,10 @@ | ||
39169 | 39243 | fprintf(stderr, "in ~listtoelem: unknown variant-nr %d\n", (int)stack[base + 0]/*variant-nr*/); |
39170 | 39244 | exit(-1); |
39171 | 39245 | } |
39172 | - label = 3310LLU + 1LLU + stack[base + 0]/*variant-nr*/; | |
39246 | + label = 3319LLU + 1LLU + stack[base + 0]/*variant-nr*/; | |
39173 | 39247 | break; |
39174 | 39248 | } |
39175 | - case 3310LLU + 1LLU + 0LLU: // ~listtoelem.listtoelem | |
39249 | + case 3319LLU + 1LLU + 0LLU: // ~listtoelem.listtoelem | |
39176 | 39250 | { |
39177 | 39251 | // release element listindex |
39178 | 39252 | // release element popnext |
@@ -39183,14 +39257,14 @@ | ||
39183 | 39257 | newstack[0] = (uint64_t)stack; // backup stack location |
39184 | 39258 | newstack[1] = 1234567890; |
39185 | 39259 | newstack[2] = base; |
39186 | - newstack[3] = 3312LLU; | |
39260 | + newstack[3] = 3321LLU; | |
39187 | 39261 | stack = newstack; |
39188 | 39262 | // set stack-base & callee-address |
39189 | 39263 | base = 4/*deloffset*/; |
39190 | - label = 3307LLU; // ~popnext | |
39264 | + label = 3316LLU; // ~popnext | |
39191 | 39265 | break; |
39192 | 39266 | } |
39193 | - case 3312LLU: // return from ~popnext to listtoelem | |
39267 | + case 3321LLU: // return from ~popnext to listtoelem | |
39194 | 39268 | { |
39195 | 39269 | stack = (uint64_t *)stack[0]; |
39196 | 39270 | // releasing toplevel container |
@@ -39204,7 +39278,7 @@ | ||
39204 | 39278 | newstack[0] = (uint64_t)stack; // backup stack location |
39205 | 39279 | newstack[1] = 1234567890; |
39206 | 39280 | newstack[2] = base; |
39207 | - newstack[3] = 3313LLU; | |
39281 | + newstack[3] = 3322LLU; | |
39208 | 39282 | stack = newstack; |
39209 | 39283 | // set stack-base & callee-address |
39210 | 39284 | base = 4/*deloffset*/; |
@@ -39211,7 +39285,7 @@ | ||
39211 | 39285 | label = 310LLU; // ~type |
39212 | 39286 | break; |
39213 | 39287 | } |
39214 | - case 3313LLU: // return from ~type to listtoelem | |
39288 | + case 3322LLU: // return from ~type to listtoelem | |
39215 | 39289 | { |
39216 | 39290 | stack = (uint64_t *)stack[0]; |
39217 | 39291 | // releasing toplevel container |
@@ -39224,13 +39298,13 @@ | ||
39224 | 39298 | base = stack[base - 2]; |
39225 | 39299 | break; |
39226 | 39300 | } |
39227 | - case 3315LLU: // function shadowlock failed | |
39301 | + case 3324LLU: // function shadowlock failed | |
39228 | 39302 | { |
39229 | 39303 | label = stack[base - 3]; |
39230 | 39304 | base = stack[base - 2]; |
39231 | 39305 | break; |
39232 | 39306 | } |
39233 | - case 3314LLU: // shadowlock | |
39307 | + case 3323LLU: // shadowlock | |
39234 | 39308 | { |
39235 | 39309 | //#define res0 0 |
39236 | 39310 | //#define arg0 1 |
@@ -39244,15 +39318,15 @@ | ||
39244 | 39318 | //#define arg8 9 |
39245 | 39319 | //#define arg9 10 |
39246 | 39320 | //#define arg10 11 |
39247 | - label = 3317LLU; // skip deleter | |
39321 | + label = 3326LLU; // skip deleter | |
39248 | 39322 | break; |
39249 | 39323 | } |
39250 | - case 3316LLU: // deleter | |
39324 | + case 3325LLU: // deleter | |
39251 | 39325 | { |
39252 | 39326 | // throw from shadowlock |
39253 | 39327 | if(!stack[base + 12]) |
39254 | 39328 | { |
39255 | - label = 3315LLU; // skip, variable already deleted/unscoped | |
39329 | + label = 3324LLU; // skip, variable already deleted/unscoped | |
39256 | 39330 | break; |
39257 | 39331 | } |
39258 | 39332 |
@@ -39261,7 +39335,7 @@ | ||
39261 | 39335 | newstack[0] = (uint64_t)stack; // backup stack location |
39262 | 39336 | newstack[1] = 1234567890; |
39263 | 39337 | newstack[2] = base; |
39264 | - newstack[3] = 3318LLU; | |
39338 | + newstack[3] = 3327LLU; | |
39265 | 39339 | stack = newstack; |
39266 | 39340 | // set stack-base & callee-address |
39267 | 39341 | base = 4/*deloffset*/; |
@@ -39268,21 +39342,21 @@ | ||
39268 | 39342 | label = 486LLU; // ~letdef |
39269 | 39343 | break; |
39270 | 39344 | } |
39271 | - case 3318LLU: // return from ~letdef to shadowlock | |
39345 | + case 3327LLU: // return from ~letdef to shadowlock | |
39272 | 39346 | { |
39273 | 39347 | stack = (uint64_t *)stack[0]; |
39274 | 39348 | // releasing toplevel container |
39275 | 39349 | Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 12] - sizeof(uint64_t) * 4)); |
39276 | 39350 | |
39277 | - label = 3315LLU; // continue unrolling stack, delete next variable | |
39351 | + label = 3324LLU; // continue unrolling stack, delete next variable | |
39278 | 39352 | break; |
39279 | 39353 | } |
39280 | - case 3317LLU: // skipped deleter | |
39354 | + case 3326LLU: // skipped deleter | |
39281 | 39355 | { |
39282 | 39356 | // call FindLet from shadowlock |
39283 | - stack[base + 13LLU] = 3319LLU/*throw to this address*/; | |
39357 | + stack[base + 13LLU] = 3328LLU/*throw to this address*/; | |
39284 | 39358 | stack[base + 14LLU] = base; |
39285 | - stack[base + 15LLU] = 3320LLU; | |
39359 | + stack[base + 15LLU] = 3329LLU; | |
39286 | 39360 | // arguments for call to FindLet |
39287 | 39361 | stack[base + 17LLU] = stack[base + 1]/*fnid*/; |
39288 | 39362 | stack[base + 18LLU] = stack[base + 9]/*listid*/; |
@@ -39293,13 +39367,13 @@ | ||
39293 | 39367 | label = 619LLU; // FindLet |
39294 | 39368 | break; |
39295 | 39369 | } |
39296 | - case 3319LLU: // copy-back deleter (FindLet to shadowlock) | |
39370 | + case 3328LLU: // copy-back deleter (FindLet to shadowlock) | |
39297 | 39371 | { |
39298 | 39372 | // copy mutable arguments back from call to FindLet |
39299 | - label = 3315LLU; // continue to roll stack | |
39373 | + label = 3324LLU; // continue to roll stack | |
39300 | 39374 | break; |
39301 | 39375 | } |
39302 | - case 3320LLU: // return from FindLet to shadowlock | |
39376 | + case 3329LLU: // return from FindLet to shadowlock | |
39303 | 39377 | { |
39304 | 39378 | // copy mutable arguments back from call to FindLet |
39305 | 39379 | // copy back results provided by call to FindLet |
@@ -39306,7 +39380,7 @@ | ||
39306 | 39380 | stack[base + 12] = stack[base + 16LLU]; |
39307 | 39381 | if(/*letdef*/0 != ((uint64_t *)(stack[base + 12]/*letdef*/))[0]) |
39308 | 39382 | { |
39309 | - label = 3322LLU; // jump to alternative | |
39383 | + label = 3331LLU; // jump to alternative | |
39310 | 39384 | break; |
39311 | 39385 | } |
39312 | 39386 |
@@ -39317,15 +39391,15 @@ | ||
39317 | 39391 | /*substruct*/stack[base + 17] = ((uint64_t **)(stack[base + 12]/*letdef*/))[1][4]/*substruct*/; |
39318 | 39392 | |
39319 | 39393 | // case |
39320 | - label = 3325LLU; // skip deleter | |
39394 | + label = 3334LLU; // skip deleter | |
39321 | 39395 | break; |
39322 | 39396 | } |
39323 | - case 3324LLU: // deleter | |
39397 | + case 3333LLU: // deleter | |
39324 | 39398 | { |
39325 | 39399 | // throw from shadowlock |
39326 | 39400 | if(!stack[base + 18]) |
39327 | 39401 | { |
39328 | - label = 3323LLU; // skip, variable already deleted/unscoped | |
39402 | + label = 3332LLU; // skip, variable already deleted/unscoped | |
39329 | 39403 | break; |
39330 | 39404 | } |
39331 | 39405 |
@@ -39334,7 +39408,7 @@ | ||
39334 | 39408 | newstack[0] = (uint64_t)stack; // backup stack location |
39335 | 39409 | newstack[1] = 1234567890; |
39336 | 39410 | newstack[2] = base; |
39337 | - newstack[3] = 3326LLU; | |
39411 | + newstack[3] = 3335LLU; | |
39338 | 39412 | stack = newstack; |
39339 | 39413 | // set stack-base & callee-address |
39340 | 39414 | base = 4/*deloffset*/; |
@@ -39341,20 +39415,20 @@ | ||
39341 | 39415 | label = 310LLU; // ~type |
39342 | 39416 | break; |
39343 | 39417 | } |
39344 | - case 3326LLU: // return from ~type to shadowlock | |
39418 | + case 3335LLU: // return from ~type to shadowlock | |
39345 | 39419 | { |
39346 | 39420 | stack = (uint64_t *)stack[0]; |
39347 | 39421 | // releasing toplevel container |
39348 | 39422 | Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 18] - sizeof(uint64_t) * 4)); |
39349 | 39423 | |
39350 | - label = 3323LLU; // continue unrolling stack, delete next variable | |
39424 | + label = 3332LLU; // continue unrolling stack, delete next variable | |
39351 | 39425 | break; |
39352 | 39426 | } |
39353 | - case 3325LLU: // skipped deleter | |
39427 | + case 3334LLU: // skipped deleter | |
39354 | 39428 | { |
39355 | 39429 | if(/*typelist*/1 != ((uint64_t *)(stack[base + 13]/*listtype*/))[0]) |
39356 | 39430 | { |
39357 | - label = 3328LLU; // jump to alternative | |
39431 | + label = 3337LLU; // jump to alternative | |
39358 | 39432 | break; |
39359 | 39433 | } |
39360 | 39434 |
@@ -39364,7 +39438,7 @@ | ||
39364 | 39438 | uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t)); |
39365 | 39439 | if(!newstack) |
39366 | 39440 | { |
39367 | - label = 3329LLU; // throw: begin to unroll stack | |
39441 | + label = 3338LLU; // throw: begin to unroll stack | |
39368 | 39442 | break; |
39369 | 39443 | } |
39370 | 39444 |
@@ -39371,9 +39445,9 @@ | ||
39371 | 39445 | newstack[15LLU] = 9876543210LLU; // overflow-marker |
39372 | 39446 | // call copytype from shadowlock |
39373 | 39447 | newstack[0] = (uint64_t)stack; // backup stack location |
39374 | - newstack[1] = 3330LLU; | |
39448 | + newstack[1] = 3339LLU; | |
39375 | 39449 | newstack[2] = base; |
39376 | - newstack[3] = 3331LLU; | |
39450 | + newstack[3] = 3340LLU; | |
39377 | 39451 | // arguments for call to copytype |
39378 | 39452 | newstack[5LLU] = stack[base + 19]/*elemtype*/; |
39379 | 39453 | stack = newstack; |
@@ -39382,7 +39456,7 @@ | ||
39382 | 39456 | label = 341LLU; // copytype |
39383 | 39457 | break; |
39384 | 39458 | } |
39385 | - case 3330LLU: // copy-back deleter (copytype to shadowlock) | |
39459 | + case 3339LLU: // copy-back deleter (copytype to shadowlock) | |
39386 | 39460 | { |
39387 | 39461 | uint64_t *oldstack = (uint64_t *)stack[0]; |
39388 | 39462 | // copy mutable arguments back from call to copytype |
@@ -39393,10 +39467,10 @@ | ||
39393 | 39467 | } |
39394 | 39468 | Free(15LLU + 1, sizeof(uint64_t), stack); |
39395 | 39469 | stack = oldstack; |
39396 | - label = 3329LLU; // continue to unroll stack | |
39470 | + label = 3338LLU; // continue to unroll stack | |
39397 | 39471 | break; |
39398 | 39472 | } |
39399 | - case 3331LLU: // return from copytype to shadowlock | |
39473 | + case 3340LLU: // return from copytype to shadowlock | |
39400 | 39474 | { |
39401 | 39475 | uint64_t *oldstack = (uint64_t *)stack[0]; |
39402 | 39476 | // copy mutable arguments back from call to copytype |
@@ -39410,23 +39484,23 @@ | ||
39410 | 39484 | Free(15LLU + 1, sizeof(uint64_t), stack); |
39411 | 39485 | stack = oldstack; |
39412 | 39486 | ((uint64_t **)(stack[base + 13]))[1][0] = stack[base + 19]; |
39413 | - label = 3327LLU; // case complete | |
39487 | + label = 3336LLU; // case complete | |
39414 | 39488 | break; |
39415 | 39489 | } |
39416 | - case 3329LLU: // copy-back deleter (switch) | |
39490 | + case 3338LLU: // copy-back deleter (switch) | |
39417 | 39491 | { |
39418 | 39492 | ((uint64_t **)(stack[base + 13]))[1][0] = stack[base + 19]; |
39419 | - label = 3323LLU; // continue to unroll stack | |
39493 | + label = 3332LLU; // continue to unroll stack | |
39420 | 39494 | break; |
39421 | 39495 | } |
39422 | - case 3328LLU: // try next case | |
39496 | + case 3337LLU: // try next case | |
39423 | 39497 | { |
39424 | 39498 | // default |
39425 | 39499 | fprintf(stderr, "%s", "in function "); |
39426 | 39500 | // call reportid from shadowlock |
39427 | - stack[base + 19LLU] = 3332LLU/*throw to this address*/; | |
39501 | + stack[base + 19LLU] = 3341LLU/*throw to this address*/; | |
39428 | 39502 | stack[base + 20LLU] = base; |
39429 | - stack[base + 21LLU] = 3333LLU; | |
39503 | + stack[base + 21LLU] = 3342LLU; | |
39430 | 39504 | // arguments for call to reportid |
39431 | 39505 | stack[base + 22LLU] = stack[base + 1]/*fnid*/; |
39432 | 39506 | // set stack-base & callee-address |
@@ -39434,13 +39508,13 @@ | ||
39434 | 39508 | label = 18446744073709551586LLU; // reportid |
39435 | 39509 | break; |
39436 | 39510 | } |
39437 | - case 3332LLU: // copy-back deleter (reportid to shadowlock) | |
39511 | + case 3341LLU: // copy-back deleter (reportid to shadowlock) | |
39438 | 39512 | { |
39439 | 39513 | // copy mutable arguments back from call to reportid |
39440 | - label = 3323LLU; // continue to roll stack | |
39514 | + label = 3332LLU; // continue to roll stack | |
39441 | 39515 | break; |
39442 | 39516 | } |
39443 | - case 3333LLU: // return from reportid to shadowlock | |
39517 | + case 3342LLU: // return from reportid to shadowlock | |
39444 | 39518 | { |
39445 | 39519 | // copy mutable arguments back from call to reportid |
39446 | 39520 | fprintf(stderr, "%s", ": "); |
@@ -39448,7 +39522,7 @@ | ||
39448 | 39522 | uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t)); |
39449 | 39523 | if(!newstack) |
39450 | 39524 | { |
39451 | - label = 3323LLU; // throw: begin to unroll stack | |
39525 | + label = 3332LLU; // throw: begin to unroll stack | |
39452 | 39526 | break; |
39453 | 39527 | } |
39454 | 39528 |
@@ -39455,9 +39529,9 @@ | ||
39455 | 39529 | newstack[10LLU] = 9876543210LLU; // overflow-marker |
39456 | 39530 | // call reporttype from shadowlock |
39457 | 39531 | newstack[0] = (uint64_t)stack; // backup stack location |
39458 | - newstack[1] = 3334LLU; | |
39532 | + newstack[1] = 3343LLU; | |
39459 | 39533 | newstack[2] = base; |
39460 | - newstack[3] = 3335LLU; | |
39534 | + newstack[3] = 3344LLU; | |
39461 | 39535 | // arguments for call to reporttype |
39462 | 39536 | newstack[4LLU] = stack[base + 13]/*listtype*/; |
39463 | 39537 | stack = newstack; |
@@ -39466,7 +39540,7 @@ | ||
39466 | 39540 | label = 330LLU; // reporttype |
39467 | 39541 | break; |
39468 | 39542 | } |
39469 | - case 3334LLU: // copy-back deleter (reporttype to shadowlock) | |
39543 | + case 3343LLU: // copy-back deleter (reporttype to shadowlock) | |
39470 | 39544 | { |
39471 | 39545 | uint64_t *oldstack = (uint64_t *)stack[0]; |
39472 | 39546 | // copy mutable arguments back from call to reporttype |
@@ -39477,10 +39551,10 @@ | ||
39477 | 39551 | } |
39478 | 39552 | Free(10LLU + 1, sizeof(uint64_t), stack); |
39479 | 39553 | stack = oldstack; |
39480 | - label = 3323LLU; // continue to unroll stack | |
39554 | + label = 3332LLU; // continue to unroll stack | |
39481 | 39555 | break; |
39482 | 39556 | } |
39483 | - case 3335LLU: // return from reporttype to shadowlock | |
39557 | + case 3344LLU: // return from reporttype to shadowlock | |
39484 | 39558 | { |
39485 | 39559 | uint64_t *oldstack = (uint64_t *)stack[0]; |
39486 | 39560 | // copy mutable arguments back from call to reporttype |
@@ -39493,80 +39567,80 @@ | ||
39493 | 39567 | stack = oldstack; |
39494 | 39568 | fprintf(stderr, "%s", "\n"); |
39495 | 39569 | { |
39496 | - label = 3323LLU; // throw: begin to unroll stack | |
39570 | + label = 3332LLU; // throw: begin to unroll stack | |
39497 | 39571 | break; |
39498 | 39572 | } |
39499 | 39573 | |
39500 | - label = 3327LLU; // default complete | |
39574 | + label = 3336LLU; // default complete | |
39501 | 39575 | break; |
39502 | 39576 | } |
39503 | - case 3327LLU: // completed switch | |
39577 | + case 3336LLU: // completed switch | |
39504 | 39578 | { |
39505 | - label = 3337LLU; // skip deleter | |
39579 | + label = 3346LLU; // skip deleter | |
39506 | 39580 | break; |
39507 | 39581 | } |
39508 | - case 3336LLU: // deleter | |
39582 | + case 3345LLU: // deleter | |
39509 | 39583 | { |
39510 | 39584 | // throw from shadowlock |
39511 | 39585 | if(!stack[base + 19]) |
39512 | 39586 | { |
39513 | - label = 3324LLU; // skip, variable already deleted/unscoped | |
39587 | + label = 3333LLU; // skip, variable already deleted/unscoped | |
39514 | 39588 | break; |
39515 | 39589 | } |
39516 | - label = 3324LLU; // continue unrolling stack, delete next variable | |
39590 | + label = 3333LLU; // continue unrolling stack, delete next variable | |
39517 | 39591 | break; |
39518 | 39592 | } |
39519 | - case 3337LLU: // skipped deleter | |
39593 | + case 3346LLU: // skipped deleter | |
39520 | 39594 | { |
39521 | 39595 | if(!stack[base + 16]/*mutable*/) |
39522 | 39596 | { |
39523 | - label = 3338LLU; // jump to alternative | |
39597 | + label = 3347LLU; // jump to alternative | |
39524 | 39598 | break; |
39525 | 39599 | } |
39526 | 39600 | |
39527 | 39601 | // consequent |
39528 | - label = 3341LLU; // skip deleter | |
39602 | + label = 3350LLU; // skip deleter | |
39529 | 39603 | break; |
39530 | 39604 | } |
39531 | - case 3340LLU: // deleter | |
39605 | + case 3349LLU: // deleter | |
39532 | 39606 | { |
39533 | 39607 | // throw from shadowlock |
39534 | 39608 | if(!stack[base + 19]) |
39535 | 39609 | { |
39536 | - label = 3324LLU; // skip, variable already deleted/unscoped | |
39610 | + label = 3333LLU; // skip, variable already deleted/unscoped | |
39537 | 39611 | break; |
39538 | 39612 | } |
39539 | - label = 3324LLU; // continue unrolling stack, delete next variable | |
39613 | + label = 3333LLU; // continue unrolling stack, delete next variable | |
39540 | 39614 | break; |
39541 | 39615 | } |
39542 | - case 3341LLU: // skipped deleter | |
39616 | + case 3350LLU: // skipped deleter | |
39543 | 39617 | { |
39544 | 39618 | stack[base + 19] = 0; |
39545 | - label = 3339LLU; // consequent complete | |
39619 | + label = 3348LLU; // consequent complete | |
39546 | 39620 | break; |
39547 | 39621 | } |
39548 | - case 3338LLU: // alternative | |
39622 | + case 3347LLU: // alternative | |
39549 | 39623 | { |
39550 | - label = 3343LLU; // skip deleter | |
39624 | + label = 3352LLU; // skip deleter | |
39551 | 39625 | break; |
39552 | 39626 | } |
39553 | - case 3342LLU: // deleter | |
39627 | + case 3351LLU: // deleter | |
39554 | 39628 | { |
39555 | 39629 | // throw from shadowlock |
39556 | 39630 | if(!stack[base + 20]) |
39557 | 39631 | { |
39558 | - label = 3324LLU; // skip, variable already deleted/unscoped | |
39632 | + label = 3333LLU; // skip, variable already deleted/unscoped | |
39559 | 39633 | break; |
39560 | 39634 | } |
39561 | - label = 3324LLU; // continue unrolling stack, delete next variable | |
39635 | + label = 3333LLU; // continue unrolling stack, delete next variable | |
39562 | 39636 | break; |
39563 | 39637 | } |
39564 | - case 3343LLU: // skipped deleter | |
39638 | + case 3352LLU: // skipped deleter | |
39565 | 39639 | { |
39566 | 39640 | // call isparam from shadowlock |
39567 | - stack[base + 21LLU] = 3344LLU/*throw to this address*/; | |
39641 | + stack[base + 21LLU] = 3353LLU/*throw to this address*/; | |
39568 | 39642 | stack[base + 22LLU] = base; |
39569 | - stack[base + 23LLU] = 3345LLU; | |
39643 | + stack[base + 23LLU] = 3354LLU; | |
39570 | 39644 | // arguments for call to isparam |
39571 | 39645 | stack[base + 25LLU] = stack[base + 4]/*fnrescount*/; |
39572 | 39646 | stack[base + 26LLU] = stack[base + 5]/*fnargcount*/; |
@@ -39576,21 +39650,21 @@ | ||
39576 | 39650 | label = 1635LLU; // isparam |
39577 | 39651 | break; |
39578 | 39652 | } |
39579 | - case 3344LLU: // copy-back deleter (isparam to shadowlock) | |
39653 | + case 3353LLU: // copy-back deleter (isparam to shadowlock) | |
39580 | 39654 | { |
39581 | 39655 | // copy mutable arguments back from call to isparam |
39582 | - label = 3324LLU; // continue to roll stack | |
39656 | + label = 3333LLU; // continue to roll stack | |
39583 | 39657 | break; |
39584 | 39658 | } |
39585 | - case 3345LLU: // return from isparam to shadowlock | |
39659 | + case 3354LLU: // return from isparam to shadowlock | |
39586 | 39660 | { |
39587 | 39661 | // copy mutable arguments back from call to isparam |
39588 | 39662 | // copy back results provided by call to isparam |
39589 | 39663 | stack[base + 20] = stack[base + 24LLU]; |
39590 | 39664 | // call or from shadowlock |
39591 | - stack[base + 21LLU] = 3346LLU/*throw to this address*/; | |
39665 | + stack[base + 21LLU] = 3355LLU/*throw to this address*/; | |
39592 | 39666 | stack[base + 22LLU] = base; |
39593 | - stack[base + 23LLU] = 3347LLU; | |
39667 | + stack[base + 23LLU] = 3356LLU; | |
39594 | 39668 | // arguments for call to or |
39595 | 39669 | stack[base + 25LLU] = stack[base + 17]/*substruct*/; |
39596 | 39670 | stack[base + 26LLU] = stack[base + 20]/*param*/; |
@@ -39599,41 +39673,41 @@ | ||
39599 | 39673 | label = 18446744073709551611LLU; // or |
39600 | 39674 | break; |
39601 | 39675 | } |
39602 | - case 3346LLU: // copy-back deleter (or to shadowlock) | |
39676 | + case 3355LLU: // copy-back deleter (or to shadowlock) | |
39603 | 39677 | { |
39604 | 39678 | // copy mutable arguments back from call to or |
39605 | - label = 3342LLU; // continue to roll stack | |
39679 | + label = 3351LLU; // continue to roll stack | |
39606 | 39680 | break; |
39607 | 39681 | } |
39608 | - case 3347LLU: // return from or to shadowlock | |
39682 | + case 3356LLU: // return from or to shadowlock | |
39609 | 39683 | { |
39610 | 39684 | // copy mutable arguments back from call to or |
39611 | 39685 | // copy back results provided by call to or |
39612 | 39686 | stack[base + 19] = stack[base + 24LLU]; |
39613 | - label = 3339LLU; // alternative complete | |
39687 | + label = 3348LLU; // alternative complete | |
39614 | 39688 | break; |
39615 | 39689 | } |
39616 | - case 3339LLU: // completed if-then-else | |
39690 | + case 3348LLU: // completed if-then-else | |
39617 | 39691 | { |
39618 | - label = 3349LLU; // skip deleter | |
39692 | + label = 3358LLU; // skip deleter | |
39619 | 39693 | break; |
39620 | 39694 | } |
39621 | - case 3348LLU: // deleter | |
39695 | + case 3357LLU: // deleter | |
39622 | 39696 | { |
39623 | 39697 | // throw from shadowlock |
39624 | 39698 | if(!stack[base + 20]) |
39625 | 39699 | { |
39626 | - label = 3336LLU; // skip, variable already deleted/unscoped | |
39700 | + label = 3345LLU; // skip, variable already deleted/unscoped | |
39627 | 39701 | break; |
39628 | 39702 | } |
39629 | - label = 3336LLU; // continue unrolling stack, delete next variable | |
39703 | + label = 3345LLU; // continue unrolling stack, delete next variable | |
39630 | 39704 | break; |
39631 | 39705 | } |
39632 | - case 3349LLU: // skipped deleter | |
39706 | + case 3358LLU: // skipped deleter | |
39633 | 39707 | { |
39634 | 39708 | if(!stack[base + 11]/*consume*/) |
39635 | 39709 | { |
39636 | - label = 3350LLU; // jump to alternative | |
39710 | + label = 3359LLU; // jump to alternative | |
39637 | 39711 | break; |
39638 | 39712 | } |
39639 | 39713 |
@@ -39640,21 +39714,21 @@ | ||
39640 | 39714 | // consequent |
39641 | 39715 | if(!stack[base + 16]/*mutable*/) |
39642 | 39716 | { |
39643 | - label = 3352LLU; // jump to alternative | |
39717 | + label = 3361LLU; // jump to alternative | |
39644 | 39718 | break; |
39645 | 39719 | } |
39646 | 39720 | |
39647 | 39721 | // consequent |
39648 | - label = 3353LLU; // consequent complete | |
39722 | + label = 3362LLU; // consequent complete | |
39649 | 39723 | break; |
39650 | 39724 | } |
39651 | - case 3352LLU: // alternative | |
39725 | + case 3361LLU: // alternative | |
39652 | 39726 | { |
39653 | 39727 | fprintf(stderr, "%s", "in function "); |
39654 | 39728 | // call reportid from shadowlock |
39655 | - stack[base + 21LLU] = 3354LLU/*throw to this address*/; | |
39729 | + stack[base + 21LLU] = 3363LLU/*throw to this address*/; | |
39656 | 39730 | stack[base + 22LLU] = base; |
39657 | - stack[base + 23LLU] = 3355LLU; | |
39731 | + stack[base + 23LLU] = 3364LLU; | |
39658 | 39732 | // arguments for call to reportid |
39659 | 39733 | stack[base + 24LLU] = stack[base + 1]/*fnid*/; |
39660 | 39734 | // set stack-base & callee-address |
@@ -39662,13 +39736,13 @@ | ||
39662 | 39736 | label = 18446744073709551586LLU; // reportid |
39663 | 39737 | break; |
39664 | 39738 | } |
39665 | - case 3354LLU: // copy-back deleter (reportid to shadowlock) | |
39739 | + case 3363LLU: // copy-back deleter (reportid to shadowlock) | |
39666 | 39740 | { |
39667 | 39741 | // copy mutable arguments back from call to reportid |
39668 | - label = 3336LLU; // continue to roll stack | |
39742 | + label = 3345LLU; // continue to roll stack | |
39669 | 39743 | break; |
39670 | 39744 | } |
39671 | - case 3355LLU: // return from reportid to shadowlock | |
39745 | + case 3364LLU: // return from reportid to shadowlock | |
39672 | 39746 | { |
39673 | 39747 | // copy mutable arguments back from call to reportid |
39674 | 39748 | fprintf(stderr, "%s", ": "); |
@@ -39676,7 +39750,7 @@ | ||
39676 | 39750 | uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t)); |
39677 | 39751 | if(!newstack) |
39678 | 39752 | { |
39679 | - label = 3336LLU; // throw: begin to unroll stack | |
39753 | + label = 3345LLU; // throw: begin to unroll stack | |
39680 | 39754 | break; |
39681 | 39755 | } |
39682 | 39756 |
@@ -39683,9 +39757,9 @@ | ||
39683 | 39757 | newstack[10LLU] = 9876543210LLU; // overflow-marker |
39684 | 39758 | // call reporttype from shadowlock |
39685 | 39759 | newstack[0] = (uint64_t)stack; // backup stack location |
39686 | - newstack[1] = 3356LLU; | |
39760 | + newstack[1] = 3365LLU; | |
39687 | 39761 | newstack[2] = base; |
39688 | - newstack[3] = 3357LLU; | |
39762 | + newstack[3] = 3366LLU; | |
39689 | 39763 | // arguments for call to reporttype |
39690 | 39764 | newstack[4LLU] = stack[base + 13]/*listtype*/; |
39691 | 39765 | stack = newstack; |
@@ -39694,7 +39768,7 @@ | ||
39694 | 39768 | label = 330LLU; // reporttype |
39695 | 39769 | break; |
39696 | 39770 | } |
39697 | - case 3356LLU: // copy-back deleter (reporttype to shadowlock) | |
39771 | + case 3365LLU: // copy-back deleter (reporttype to shadowlock) | |
39698 | 39772 | { |
39699 | 39773 | uint64_t *oldstack = (uint64_t *)stack[0]; |
39700 | 39774 | // copy mutable arguments back from call to reporttype |
@@ -39705,10 +39779,10 @@ | ||
39705 | 39779 | } |
39706 | 39780 | Free(10LLU + 1, sizeof(uint64_t), stack); |
39707 | 39781 | stack = oldstack; |
39708 | - label = 3336LLU; // continue to unroll stack | |
39782 | + label = 3345LLU; // continue to unroll stack | |
39709 | 39783 | break; |
39710 | 39784 | } |
39711 | - case 3357LLU: // return from reporttype to shadowlock | |
39785 | + case 3366LLU: // return from reporttype to shadowlock | |
39712 | 39786 | { |
39713 | 39787 | uint64_t *oldstack = (uint64_t *)stack[0]; |
39714 | 39788 | // copy mutable arguments back from call to reporttype |
@@ -39721,18 +39795,18 @@ | ||
39721 | 39795 | stack = oldstack; |
39722 | 39796 | fprintf(stderr, "%s", "\n"); |
39723 | 39797 | { |
39724 | - label = 3336LLU; // throw: begin to unroll stack | |
39798 | + label = 3345LLU; // throw: begin to unroll stack | |
39725 | 39799 | break; |
39726 | 39800 | } |
39727 | 39801 | |
39728 | - label = 3353LLU; // alternative complete | |
39802 | + label = 3362LLU; // alternative complete | |
39729 | 39803 | break; |
39730 | 39804 | } |
39731 | - case 3353LLU: // completed if-then-else | |
39805 | + case 3362LLU: // completed if-then-else | |
39732 | 39806 | { |
39733 | 39807 | if(/*scope*/0 != ((uint64_t *)(stack[base + 3]/*scope*/))[0]) |
39734 | 39808 | { |
39735 | - label = 3359LLU; // jump to alternative | |
39809 | + label = 3368LLU; // jump to alternative | |
39736 | 39810 | break; |
39737 | 39811 | } |
39738 | 39812 |
@@ -39740,15 +39814,15 @@ | ||
39740 | 39814 | /*letdefs*/stack[base + 22] = ((uint64_t **)(stack[base + 3]/*scope*/))[1][1]/*letdefs*/; |
39741 | 39815 | |
39742 | 39816 | // case |
39743 | - label = 3362LLU; // skip deleter | |
39817 | + label = 3371LLU; // skip deleter | |
39744 | 39818 | break; |
39745 | 39819 | } |
39746 | - case 3361LLU: // deleter | |
39820 | + case 3370LLU: // deleter | |
39747 | 39821 | { |
39748 | 39822 | // throw from shadowlock |
39749 | 39823 | if(!stack[base + 23]) |
39750 | 39824 | { |
39751 | - label = 3360LLU; // skip, variable already deleted/unscoped | |
39825 | + label = 3369LLU; // skip, variable already deleted/unscoped | |
39752 | 39826 | break; |
39753 | 39827 | } |
39754 | 39828 |
@@ -39757,7 +39831,7 @@ | ||
39757 | 39831 | newstack[0] = (uint64_t)stack; // backup stack location |
39758 | 39832 | newstack[1] = 1234567890; |
39759 | 39833 | newstack[2] = base; |
39760 | - newstack[3] = 3363LLU; | |
39834 | + newstack[3] = 3372LLU; | |
39761 | 39835 | stack = newstack; |
39762 | 39836 | // set stack-base & callee-address |
39763 | 39837 | base = 4/*deloffset*/; |
@@ -39764,21 +39838,21 @@ | ||
39764 | 39838 | label = 310LLU; // ~type |
39765 | 39839 | break; |
39766 | 39840 | } |
39767 | - case 3363LLU: // return from ~type to shadowlock | |
39841 | + case 3372LLU: // return from ~type to shadowlock | |
39768 | 39842 | { |
39769 | 39843 | stack = (uint64_t *)stack[0]; |
39770 | 39844 | // releasing toplevel container |
39771 | 39845 | Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 23] - sizeof(uint64_t) * 4)); |
39772 | 39846 | |
39773 | - label = 3360LLU; // continue unrolling stack, delete next variable | |
39847 | + label = 3369LLU; // continue unrolling stack, delete next variable | |
39774 | 39848 | break; |
39775 | 39849 | } |
39776 | - case 3362LLU: // skipped deleter | |
39850 | + case 3371LLU: // skipped deleter | |
39777 | 39851 | { |
39778 | 39852 | uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t)); |
39779 | 39853 | if(!newstack) |
39780 | 39854 | { |
39781 | - label = 3360LLU; // throw: begin to unroll stack | |
39855 | + label = 3369LLU; // throw: begin to unroll stack | |
39782 | 39856 | break; |
39783 | 39857 | } |
39784 | 39858 |
@@ -39785,9 +39859,9 @@ | ||
39785 | 39859 | newstack[15LLU] = 9876543210LLU; // overflow-marker |
39786 | 39860 | // call copytype from shadowlock |
39787 | 39861 | newstack[0] = (uint64_t)stack; // backup stack location |
39788 | - newstack[1] = 3364LLU; | |
39862 | + newstack[1] = 3373LLU; | |
39789 | 39863 | newstack[2] = base; |
39790 | - newstack[3] = 3365LLU; | |
39864 | + newstack[3] = 3374LLU; | |
39791 | 39865 | // arguments for call to copytype |
39792 | 39866 | newstack[5LLU] = stack[base + 13]/*listtype*/; |
39793 | 39867 | stack = newstack; |
@@ -39796,7 +39870,7 @@ | ||
39796 | 39870 | label = 341LLU; // copytype |
39797 | 39871 | break; |
39798 | 39872 | } |
39799 | - case 3364LLU: // copy-back deleter (copytype to shadowlock) | |
39873 | + case 3373LLU: // copy-back deleter (copytype to shadowlock) | |
39800 | 39874 | { |
39801 | 39875 | uint64_t *oldstack = (uint64_t *)stack[0]; |
39802 | 39876 | // copy mutable arguments back from call to copytype |
@@ -39807,10 +39881,10 @@ | ||
39807 | 39881 | } |
39808 | 39882 | Free(15LLU + 1, sizeof(uint64_t), stack); |
39809 | 39883 | stack = oldstack; |
39810 | - label = 3360LLU; // continue to unroll stack | |
39884 | + label = 3369LLU; // continue to unroll stack | |
39811 | 39885 | break; |
39812 | 39886 | } |
39813 | - case 3365LLU: // return from copytype to shadowlock | |
39887 | + case 3374LLU: // return from copytype to shadowlock | |
39814 | 39888 | { |
39815 | 39889 | uint64_t *oldstack = (uint64_t *)stack[0]; |
39816 | 39890 | // copy mutable arguments back from call to copytype |
@@ -39823,49 +39897,49 @@ | ||
39823 | 39897 | } |
39824 | 39898 | Free(15LLU + 1, sizeof(uint64_t), stack); |
39825 | 39899 | stack = oldstack; |
39826 | - label = 3367LLU; // skip deleter | |
39900 | + label = 3376LLU; // skip deleter | |
39827 | 39901 | break; |
39828 | 39902 | } |
39829 | - case 3366LLU: // deleter | |
39903 | + case 3375LLU: // deleter | |
39830 | 39904 | { |
39831 | 39905 | // throw from shadowlock |
39832 | 39906 | if(!stack[base + 24]) |
39833 | 39907 | { |
39834 | - label = 3361LLU; // skip, variable already deleted/unscoped | |
39908 | + label = 3370LLU; // skip, variable already deleted/unscoped | |
39835 | 39909 | break; |
39836 | 39910 | } |
39837 | - label = 3361LLU; // continue unrolling stack, delete next variable | |
39911 | + label = 3370LLU; // continue unrolling stack, delete next variable | |
39838 | 39912 | break; |
39839 | 39913 | } |
39840 | - case 3367LLU: // skipped deleter | |
39914 | + case 3376LLU: // skipped deleter | |
39841 | 39915 | { |
39842 | 39916 | stack[base + 24] = 0; |
39843 | - label = 3369LLU; // skip deleter | |
39917 | + label = 3378LLU; // skip deleter | |
39844 | 39918 | break; |
39845 | 39919 | } |
39846 | - case 3368LLU: // deleter | |
39920 | + case 3377LLU: // deleter | |
39847 | 39921 | { |
39848 | 39922 | // throw from shadowlock |
39849 | 39923 | if(!stack[base + 25]) |
39850 | 39924 | { |
39851 | - label = 3366LLU; // skip, variable already deleted/unscoped | |
39925 | + label = 3375LLU; // skip, variable already deleted/unscoped | |
39852 | 39926 | break; |
39853 | 39927 | } |
39854 | - label = 3366LLU; // continue unrolling stack, delete next variable | |
39928 | + label = 3375LLU; // continue unrolling stack, delete next variable | |
39855 | 39929 | break; |
39856 | 39930 | } |
39857 | - case 3369LLU: // skipped deleter | |
39931 | + case 3378LLU: // skipped deleter | |
39858 | 39932 | { |
39859 | 39933 | stack[base + 25] = 0; |
39860 | - label = 3371LLU; // skip deleter | |
39934 | + label = 3380LLU; // skip deleter | |
39861 | 39935 | break; |
39862 | 39936 | } |
39863 | - case 3370LLU: // deleter | |
39937 | + case 3379LLU: // deleter | |
39864 | 39938 | { |
39865 | 39939 | // throw from shadowlock |
39866 | 39940 | if(!stack[base + 26]) |
39867 | 39941 | { |
39868 | - label = 3368LLU; // skip, variable already deleted/unscoped | |
39942 | + label = 3377LLU; // skip, variable already deleted/unscoped | |
39869 | 39943 | break; |
39870 | 39944 | } |
39871 | 39945 |
@@ -39874,7 +39948,7 @@ | ||
39874 | 39948 | newstack[0] = (uint64_t)stack; // backup stack location |
39875 | 39949 | newstack[1] = 1234567890; |
39876 | 39950 | newstack[2] = base; |
39877 | - newstack[3] = 3372LLU; | |
39951 | + newstack[3] = 3381LLU; | |
39878 | 39952 | stack = newstack; |
39879 | 39953 | // set stack-base & callee-address |
39880 | 39954 | base = 4/*deloffset*/; |
@@ -39881,21 +39955,21 @@ | ||
39881 | 39955 | label = 486LLU; // ~letdef |
39882 | 39956 | break; |
39883 | 39957 | } |
39884 | - case 3372LLU: // return from ~letdef to shadowlock | |
39958 | + case 3381LLU: // return from ~letdef to shadowlock | |
39885 | 39959 | { |
39886 | 39960 | stack = (uint64_t *)stack[0]; |
39887 | 39961 | // releasing toplevel container |
39888 | 39962 | Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 26] - sizeof(uint64_t) * 4)); |
39889 | 39963 | |
39890 | - label = 3368LLU; // continue unrolling stack, delete next variable | |
39964 | + label = 3377LLU; // continue unrolling stack, delete next variable | |
39891 | 39965 | break; |
39892 | 39966 | } |
39893 | - case 3371LLU: // skipped deleter | |
39967 | + case 3380LLU: // skipped deleter | |
39894 | 39968 | { |
39895 | 39969 | // construct letdef.letdef |
39896 | 39970 | if(!(stack[base + 26] = construct(5))) |
39897 | 39971 | { |
39898 | - label = 3368LLU; // throw: begin to unroll stack | |
39972 | + label = 3377LLU; // throw: begin to unroll stack | |
39899 | 39973 | break; |
39900 | 39974 | } |
39901 | 39975 |
@@ -39921,50 +39995,50 @@ | ||
39921 | 39995 | } |
39922 | 39996 | ((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 22]; |
39923 | 39997 | ((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 21]; |
39924 | - label = 3358LLU; // case complete | |
39998 | + label = 3367LLU; // case complete | |
39925 | 39999 | break; |
39926 | 40000 | } |
39927 | - case 3360LLU: // copy-back deleter (switch) | |
40001 | + case 3369LLU: // copy-back deleter (switch) | |
39928 | 40002 | { |
39929 | 40003 | ((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 22]; |
39930 | 40004 | ((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 21]; |
39931 | - label = 3336LLU; // continue to unroll stack | |
40005 | + label = 3345LLU; // continue to unroll stack | |
39932 | 40006 | break; |
39933 | 40007 | } |
39934 | - case 3359LLU: // try next case | |
40008 | + case 3368LLU: // try next case | |
39935 | 40009 | { |
39936 | 40010 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
39937 | 40011 | exit(-1); |
39938 | 40012 | } |
39939 | - case 3358LLU: // completed switch | |
40013 | + case 3367LLU: // completed switch | |
39940 | 40014 | { |
39941 | - label = 3374LLU; // skip deleter | |
40015 | + label = 3383LLU; // skip deleter | |
39942 | 40016 | break; |
39943 | 40017 | } |
39944 | - case 3373LLU: // deleter | |
40018 | + case 3382LLU: // deleter | |
39945 | 40019 | { |
39946 | 40020 | // throw from shadowlock |
39947 | 40021 | if(!stack[base + 20]) |
39948 | 40022 | { |
39949 | - label = 3336LLU; // skip, variable already deleted/unscoped | |
40023 | + label = 3345LLU; // skip, variable already deleted/unscoped | |
39950 | 40024 | break; |
39951 | 40025 | } |
39952 | - label = 3336LLU; // continue unrolling stack, delete next variable | |
40026 | + label = 3345LLU; // continue unrolling stack, delete next variable | |
39953 | 40027 | break; |
39954 | 40028 | } |
39955 | - case 3374LLU: // skipped deleter | |
40029 | + case 3383LLU: // skipped deleter | |
39956 | 40030 | { |
39957 | 40031 | stack[base + 20] = stack[base + 15]/*listindex*/; |
39958 | - label = 3351LLU; // consequent complete | |
40032 | + label = 3360LLU; // consequent complete | |
39959 | 40033 | break; |
39960 | 40034 | } |
39961 | - case 3350LLU: // alternative | |
40035 | + case 3359LLU: // alternative | |
39962 | 40036 | { |
39963 | 40037 | printf("%s", "\n flippedassign("); |
39964 | 40038 | // call emitvar from shadowlock |
39965 | - stack[base + 21LLU] = 3375LLU/*throw to this address*/; | |
40039 | + stack[base + 21LLU] = 3384LLU/*throw to this address*/; | |
39966 | 40040 | stack[base + 22LLU] = base; |
39967 | - stack[base + 23LLU] = 3376LLU; | |
40041 | + stack[base + 23LLU] = 3385LLU; | |
39968 | 40042 | // arguments for call to emitvar |
39969 | 40043 | stack[base + 24LLU] = stack[base + 1]/*fnid*/; |
39970 | 40044 | stack[base + 25LLU] = stack[base + 14]/*listid*/; |
@@ -39975,53 +40049,53 @@ | ||
39975 | 40049 | label = 749LLU; // emitvar |
39976 | 40050 | break; |
39977 | 40051 | } |
39978 | - case 3375LLU: // copy-back deleter (emitvar to shadowlock) | |
40052 | + case 3384LLU: // copy-back deleter (emitvar to shadowlock) | |
39979 | 40053 | { |
39980 | 40054 | // copy mutable arguments back from call to emitvar |
39981 | - label = 3336LLU; // continue to roll stack | |
40055 | + label = 3345LLU; // continue to roll stack | |
39982 | 40056 | break; |
39983 | 40057 | } |
39984 | - case 3376LLU: // return from emitvar to shadowlock | |
40058 | + case 3385LLU: // return from emitvar to shadowlock | |
39985 | 40059 | { |
39986 | 40060 | // copy mutable arguments back from call to emitvar |
39987 | 40061 | printf("%s", ", &"); |
39988 | - label = 3378LLU; // skip deleter | |
40062 | + label = 3387LLU; // skip deleter | |
39989 | 40063 | break; |
39990 | 40064 | } |
39991 | - case 3377LLU: // deleter | |
40065 | + case 3386LLU: // deleter | |
39992 | 40066 | { |
39993 | 40067 | // throw from shadowlock |
39994 | 40068 | if(!stack[base + 21]) |
39995 | 40069 | { |
39996 | - label = 3336LLU; // skip, variable already deleted/unscoped | |
40070 | + label = 3345LLU; // skip, variable already deleted/unscoped | |
39997 | 40071 | break; |
39998 | 40072 | } |
39999 | - label = 3336LLU; // continue unrolling stack, delete next variable | |
40073 | + label = 3345LLU; // continue unrolling stack, delete next variable | |
40000 | 40074 | break; |
40001 | 40075 | } |
40002 | - case 3378LLU: // skipped deleter | |
40076 | + case 3387LLU: // skipped deleter | |
40003 | 40077 | { |
40004 | 40078 | stack[base + 21] = 0; |
40005 | - label = 3380LLU; // skip deleter | |
40079 | + label = 3389LLU; // skip deleter | |
40006 | 40080 | break; |
40007 | 40081 | } |
40008 | - case 3379LLU: // deleter | |
40082 | + case 3388LLU: // deleter | |
40009 | 40083 | { |
40010 | 40084 | // throw from shadowlock |
40011 | 40085 | if(!stack[base + 22]) |
40012 | 40086 | { |
40013 | - label = 3377LLU; // skip, variable already deleted/unscoped | |
40087 | + label = 3386LLU; // skip, variable already deleted/unscoped | |
40014 | 40088 | break; |
40015 | 40089 | } |
40016 | - label = 3377LLU; // continue unrolling stack, delete next variable | |
40090 | + label = 3386LLU; // continue unrolling stack, delete next variable | |
40017 | 40091 | break; |
40018 | 40092 | } |
40019 | - case 3380LLU: // skipped deleter | |
40093 | + case 3389LLU: // skipped deleter | |
40020 | 40094 | { |
40021 | 40095 | // call newvarraw from shadowlock |
40022 | - stack[base + 23LLU] = 3381LLU/*throw to this address*/; | |
40096 | + stack[base + 23LLU] = 3390LLU/*throw to this address*/; | |
40023 | 40097 | stack[base + 24LLU] = base; |
40024 | - stack[base + 25LLU] = 3382LLU; | |
40098 | + stack[base + 25LLU] = 3391LLU; | |
40025 | 40099 | // arguments for call to newvarraw |
40026 | 40100 | stack[base + 27LLU] = stack[base + 13]/*listtype*/; |
40027 | 40101 | stack[base + 28LLU] = stack[base + 14]/*listid*/; |
@@ -40037,16 +40111,16 @@ | ||
40037 | 40111 | label = 759LLU; // newvarraw |
40038 | 40112 | break; |
40039 | 40113 | } |
40040 | - case 3381LLU: // copy-back deleter (newvarraw to shadowlock) | |
40114 | + case 3390LLU: // copy-back deleter (newvarraw to shadowlock) | |
40041 | 40115 | { |
40042 | 40116 | // copy mutable arguments back from call to newvarraw |
40043 | 40117 | stack[base + 3]/*scope*/ = stack[base + 34LLU]; |
40044 | 40118 | stack[base + 7]/*varcount*/ = stack[base + 33LLU]; |
40045 | 40119 | stack[base + 6]/*fnmaxcount*/ = stack[base + 32LLU]; |
40046 | - label = 3377LLU; // continue to roll stack | |
40120 | + label = 3386LLU; // continue to roll stack | |
40047 | 40121 | break; |
40048 | 40122 | } |
40049 | - case 3382LLU: // return from newvarraw to shadowlock | |
40123 | + case 3391LLU: // return from newvarraw to shadowlock | |
40050 | 40124 | { |
40051 | 40125 | // copy mutable arguments back from call to newvarraw |
40052 | 40126 | stack[base + 3]/*scope*/ = stack[base + 34LLU]; |
@@ -40055,9 +40129,9 @@ | ||
40055 | 40129 | // copy back results provided by call to newvarraw |
40056 | 40130 | stack[base + 22] = stack[base + 26LLU]; |
40057 | 40131 | // call emitvaridx from shadowlock |
40058 | - stack[base + 23LLU] = 3383LLU/*throw to this address*/; | |
40132 | + stack[base + 23LLU] = 3392LLU/*throw to this address*/; | |
40059 | 40133 | stack[base + 24LLU] = base; |
40060 | - stack[base + 25LLU] = 3384LLU; | |
40134 | + stack[base + 25LLU] = 3393LLU; | |
40061 | 40135 | // arguments for call to emitvaridx |
40062 | 40136 | stack[base + 26LLU] = stack[base + 22]/*shadowidx*/; |
40063 | 40137 | // set stack-base & callee-address |
@@ -40065,58 +40139,58 @@ | ||
40065 | 40139 | label = 745LLU; // emitvaridx |
40066 | 40140 | break; |
40067 | 40141 | } |
40068 | - case 3383LLU: // copy-back deleter (emitvaridx to shadowlock) | |
40142 | + case 3392LLU: // copy-back deleter (emitvaridx to shadowlock) | |
40069 | 40143 | { |
40070 | 40144 | // copy mutable arguments back from call to emitvaridx |
40071 | - label = 3379LLU; // continue to roll stack | |
40145 | + label = 3388LLU; // continue to roll stack | |
40072 | 40146 | break; |
40073 | 40147 | } |
40074 | - case 3384LLU: // return from emitvaridx to shadowlock | |
40148 | + case 3393LLU: // return from emitvaridx to shadowlock | |
40075 | 40149 | { |
40076 | 40150 | // copy mutable arguments back from call to emitvaridx |
40077 | 40151 | printf("%s", ");"); |
40078 | - label = 3386LLU; // skip deleter | |
40152 | + label = 3395LLU; // skip deleter | |
40079 | 40153 | break; |
40080 | 40154 | } |
40081 | - case 3385LLU: // deleter | |
40155 | + case 3394LLU: // deleter | |
40082 | 40156 | { |
40083 | 40157 | // throw from shadowlock |
40084 | 40158 | if(!stack[base + 20]) |
40085 | 40159 | { |
40086 | - label = 3379LLU; // skip, variable already deleted/unscoped | |
40160 | + label = 3388LLU; // skip, variable already deleted/unscoped | |
40087 | 40161 | break; |
40088 | 40162 | } |
40089 | - label = 3379LLU; // continue unrolling stack, delete next variable | |
40163 | + label = 3388LLU; // continue unrolling stack, delete next variable | |
40090 | 40164 | break; |
40091 | 40165 | } |
40092 | - case 3386LLU: // skipped deleter | |
40166 | + case 3395LLU: // skipped deleter | |
40093 | 40167 | { |
40094 | 40168 | stack[base + 20] = stack[base + 22]/*shadowidx*/; |
40095 | - label = 3351LLU; // alternative complete | |
40169 | + label = 3360LLU; // alternative complete | |
40096 | 40170 | break; |
40097 | 40171 | } |
40098 | - case 3351LLU: // completed if-then-else | |
40172 | + case 3360LLU: // completed if-then-else | |
40099 | 40173 | { |
40100 | - label = 3388LLU; // skip deleter | |
40174 | + label = 3397LLU; // skip deleter | |
40101 | 40175 | break; |
40102 | 40176 | } |
40103 | - case 3387LLU: // deleter | |
40177 | + case 3396LLU: // deleter | |
40104 | 40178 | { |
40105 | 40179 | // throw from shadowlock |
40106 | 40180 | if(!stack[base + 21]) |
40107 | 40181 | { |
40108 | - label = 3348LLU; // skip, variable already deleted/unscoped | |
40182 | + label = 3357LLU; // skip, variable already deleted/unscoped | |
40109 | 40183 | break; |
40110 | 40184 | } |
40111 | - label = 3348LLU; // continue unrolling stack, delete next variable | |
40185 | + label = 3357LLU; // continue unrolling stack, delete next variable | |
40112 | 40186 | break; |
40113 | 40187 | } |
40114 | - case 3388LLU: // skipped deleter | |
40188 | + case 3397LLU: // skipped deleter | |
40115 | 40189 | { |
40116 | 40190 | // call newvarraw from shadowlock |
40117 | - stack[base + 22LLU] = 3389LLU/*throw to this address*/; | |
40191 | + stack[base + 22LLU] = 3398LLU/*throw to this address*/; | |
40118 | 40192 | stack[base + 23LLU] = base; |
40119 | - stack[base + 24LLU] = 3390LLU; | |
40193 | + stack[base + 24LLU] = 3399LLU; | |
40120 | 40194 | // arguments for call to newvarraw |
40121 | 40195 | stack[base + 26LLU] = stack[base + 18]/*elemtype*/; |
40122 | 40196 | stack[base + 27LLU] = stack[base + 10]/*elemid*/; |
@@ -40132,16 +40206,16 @@ | ||
40132 | 40206 | label = 759LLU; // newvarraw |
40133 | 40207 | break; |
40134 | 40208 | } |
40135 | - case 3389LLU: // copy-back deleter (newvarraw to shadowlock) | |
40209 | + case 3398LLU: // copy-back deleter (newvarraw to shadowlock) | |
40136 | 40210 | { |
40137 | 40211 | // copy mutable arguments back from call to newvarraw |
40138 | 40212 | stack[base + 3]/*scope*/ = stack[base + 33LLU]; |
40139 | 40213 | stack[base + 7]/*varcount*/ = stack[base + 32LLU]; |
40140 | 40214 | stack[base + 6]/*fnmaxcount*/ = stack[base + 31LLU]; |
40141 | - label = 3348LLU; // continue to roll stack | |
40215 | + label = 3357LLU; // continue to roll stack | |
40142 | 40216 | break; |
40143 | 40217 | } |
40144 | - case 3390LLU: // return from newvarraw to shadowlock | |
40218 | + case 3399LLU: // return from newvarraw to shadowlock | |
40145 | 40219 | { |
40146 | 40220 | // copy mutable arguments back from call to newvarraw |
40147 | 40221 | stack[base + 3]/*scope*/ = stack[base + 33LLU]; |
@@ -40149,15 +40223,15 @@ | ||
40149 | 40223 | stack[base + 6]/*fnmaxcount*/ = stack[base + 31LLU]; |
40150 | 40224 | // copy back results provided by call to newvarraw |
40151 | 40225 | stack[base + 21] = stack[base + 25LLU]; |
40152 | - label = 3392LLU; // skip deleter | |
40226 | + label = 3401LLU; // skip deleter | |
40153 | 40227 | break; |
40154 | 40228 | } |
40155 | - case 3391LLU: // deleter | |
40229 | + case 3400LLU: // deleter | |
40156 | 40230 | { |
40157 | 40231 | // throw from shadowlock |
40158 | 40232 | if(!stack[base + 22]) |
40159 | 40233 | { |
40160 | - label = 3387LLU; // skip, variable already deleted/unscoped | |
40234 | + label = 3396LLU; // skip, variable already deleted/unscoped | |
40161 | 40235 | break; |
40162 | 40236 | } |
40163 | 40237 |
@@ -40166,40 +40240,40 @@ | ||
40166 | 40240 | newstack[0] = (uint64_t)stack; // backup stack location |
40167 | 40241 | newstack[1] = 1234567890; |
40168 | 40242 | newstack[2] = base; |
40169 | - newstack[3] = 3393LLU; | |
40243 | + newstack[3] = 3402LLU; | |
40170 | 40244 | stack = newstack; |
40171 | 40245 | // set stack-base & callee-address |
40172 | 40246 | base = 4/*deloffset*/; |
40173 | - label = 3307LLU; // ~popnext | |
40247 | + label = 3316LLU; // ~popnext | |
40174 | 40248 | break; |
40175 | 40249 | } |
40176 | - case 3393LLU: // return from ~popnext to shadowlock | |
40250 | + case 3402LLU: // return from ~popnext to shadowlock | |
40177 | 40251 | { |
40178 | 40252 | stack = (uint64_t *)stack[0]; |
40179 | 40253 | // releasing toplevel container |
40180 | 40254 | Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 22] - sizeof(uint64_t) * 4)); |
40181 | 40255 | |
40182 | - label = 3387LLU; // continue unrolling stack, delete next variable | |
40256 | + label = 3396LLU; // continue unrolling stack, delete next variable | |
40183 | 40257 | break; |
40184 | 40258 | } |
40185 | - case 3392LLU: // skipped deleter | |
40259 | + case 3401LLU: // skipped deleter | |
40186 | 40260 | { |
40187 | 40261 | if(!stack[base + 11]/*consume*/) |
40188 | 40262 | { |
40189 | - label = 3394LLU; // jump to alternative | |
40263 | + label = 3403LLU; // jump to alternative | |
40190 | 40264 | break; |
40191 | 40265 | } |
40192 | 40266 | |
40193 | 40267 | // consequent |
40194 | - label = 3397LLU; // skip deleter | |
40268 | + label = 3406LLU; // skip deleter | |
40195 | 40269 | break; |
40196 | 40270 | } |
40197 | - case 3396LLU: // deleter | |
40271 | + case 3405LLU: // deleter | |
40198 | 40272 | { |
40199 | 40273 | // throw from shadowlock |
40200 | 40274 | if(!stack[base + 22]) |
40201 | 40275 | { |
40202 | - label = 3387LLU; // skip, variable already deleted/unscoped | |
40276 | + label = 3396LLU; // skip, variable already deleted/unscoped | |
40203 | 40277 | break; |
40204 | 40278 | } |
40205 | 40279 |
@@ -40208,58 +40282,58 @@ | ||
40208 | 40282 | newstack[0] = (uint64_t)stack; // backup stack location |
40209 | 40283 | newstack[1] = 1234567890; |
40210 | 40284 | newstack[2] = base; |
40211 | - newstack[3] = 3398LLU; | |
40285 | + newstack[3] = 3407LLU; | |
40212 | 40286 | stack = newstack; |
40213 | 40287 | // set stack-base & callee-address |
40214 | 40288 | base = 4/*deloffset*/; |
40215 | - label = 3307LLU; // ~popnext | |
40289 | + label = 3316LLU; // ~popnext | |
40216 | 40290 | break; |
40217 | 40291 | } |
40218 | - case 3398LLU: // return from ~popnext to shadowlock | |
40292 | + case 3407LLU: // return from ~popnext to shadowlock | |
40219 | 40293 | { |
40220 | 40294 | stack = (uint64_t *)stack[0]; |
40221 | 40295 | // releasing toplevel container |
40222 | 40296 | Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 22] - sizeof(uint64_t) * 4)); |
40223 | 40297 | |
40224 | - label = 3387LLU; // continue unrolling stack, delete next variable | |
40298 | + label = 3396LLU; // continue unrolling stack, delete next variable | |
40225 | 40299 | break; |
40226 | 40300 | } |
40227 | - case 3397LLU: // skipped deleter | |
40301 | + case 3406LLU: // skipped deleter | |
40228 | 40302 | { |
40229 | 40303 | // construct popnext.pop |
40230 | 40304 | if(!(stack[base + 22] = construct(0))) |
40231 | 40305 | { |
40232 | - label = 3387LLU; // throw: begin to unroll stack | |
40306 | + label = 3396LLU; // throw: begin to unroll stack | |
40233 | 40307 | break; |
40234 | 40308 | } |
40235 | 40309 | |
40236 | 40310 | // consequent |
40237 | 40311 | ((uint64_t *)stack[base + 22])[0] = 0; |
40238 | - label = 3395LLU; // consequent complete | |
40312 | + label = 3404LLU; // consequent complete | |
40239 | 40313 | break; |
40240 | 40314 | } |
40241 | - case 3394LLU: // alternative | |
40315 | + case 3403LLU: // alternative | |
40242 | 40316 | { |
40243 | - label = 3400LLU; // skip deleter | |
40317 | + label = 3409LLU; // skip deleter | |
40244 | 40318 | break; |
40245 | 40319 | } |
40246 | - case 3399LLU: // deleter | |
40320 | + case 3408LLU: // deleter | |
40247 | 40321 | { |
40248 | 40322 | // throw from shadowlock |
40249 | 40323 | if(!stack[base + 23]) |
40250 | 40324 | { |
40251 | - label = 3387LLU; // skip, variable already deleted/unscoped | |
40325 | + label = 3396LLU; // skip, variable already deleted/unscoped | |
40252 | 40326 | break; |
40253 | 40327 | } |
40254 | - label = 3387LLU; // continue unrolling stack, delete next variable | |
40328 | + label = 3396LLU; // continue unrolling stack, delete next variable | |
40255 | 40329 | break; |
40256 | 40330 | } |
40257 | - case 3400LLU: // skipped deleter | |
40331 | + case 3409LLU: // skipped deleter | |
40258 | 40332 | { |
40259 | 40333 | // call newvarraw from shadowlock |
40260 | - stack[base + 24LLU] = 3401LLU/*throw to this address*/; | |
40334 | + stack[base + 24LLU] = 3410LLU/*throw to this address*/; | |
40261 | 40335 | stack[base + 25LLU] = base; |
40262 | - stack[base + 26LLU] = 3402LLU; | |
40336 | + stack[base + 26LLU] = 3411LLU; | |
40263 | 40337 | // arguments for call to newvarraw |
40264 | 40338 | stack[base + 28LLU] = stack[base + 13]/*listtype*/; |
40265 | 40339 | stack[base + 29LLU] = 0LLU; |
@@ -40275,16 +40349,16 @@ | ||
40275 | 40349 | label = 759LLU; // newvarraw |
40276 | 40350 | break; |
40277 | 40351 | } |
40278 | - case 3401LLU: // copy-back deleter (newvarraw to shadowlock) | |
40352 | + case 3410LLU: // copy-back deleter (newvarraw to shadowlock) | |
40279 | 40353 | { |
40280 | 40354 | // copy mutable arguments back from call to newvarraw |
40281 | 40355 | stack[base + 3]/*scope*/ = stack[base + 35LLU]; |
40282 | 40356 | stack[base + 7]/*varcount*/ = stack[base + 34LLU]; |
40283 | 40357 | stack[base + 6]/*fnmaxcount*/ = stack[base + 33LLU]; |
40284 | - label = 3387LLU; // continue to roll stack | |
40358 | + label = 3396LLU; // continue to roll stack | |
40285 | 40359 | break; |
40286 | 40360 | } |
40287 | - case 3402LLU: // return from newvarraw to shadowlock | |
40361 | + case 3411LLU: // return from newvarraw to shadowlock | |
40288 | 40362 | { |
40289 | 40363 | // copy mutable arguments back from call to newvarraw |
40290 | 40364 | stack[base + 3]/*scope*/ = stack[base + 35LLU]; |
@@ -40292,15 +40366,15 @@ | ||
40292 | 40366 | stack[base + 6]/*fnmaxcount*/ = stack[base + 33LLU]; |
40293 | 40367 | // copy back results provided by call to newvarraw |
40294 | 40368 | stack[base + 23] = stack[base + 27LLU]; |
40295 | - label = 3404LLU; // skip deleter | |
40369 | + label = 3413LLU; // skip deleter | |
40296 | 40370 | break; |
40297 | 40371 | } |
40298 | - case 3403LLU: // deleter | |
40372 | + case 3412LLU: // deleter | |
40299 | 40373 | { |
40300 | 40374 | // throw from shadowlock |
40301 | 40375 | if(!stack[base + 22]) |
40302 | 40376 | { |
40303 | - label = 3399LLU; // skip, variable already deleted/unscoped | |
40377 | + label = 3408LLU; // skip, variable already deleted/unscoped | |
40304 | 40378 | break; |
40305 | 40379 | } |
40306 | 40380 |
@@ -40309,28 +40383,28 @@ | ||
40309 | 40383 | newstack[0] = (uint64_t)stack; // backup stack location |
40310 | 40384 | newstack[1] = 1234567890; |
40311 | 40385 | newstack[2] = base; |
40312 | - newstack[3] = 3405LLU; | |
40386 | + newstack[3] = 3414LLU; | |
40313 | 40387 | stack = newstack; |
40314 | 40388 | // set stack-base & callee-address |
40315 | 40389 | base = 4/*deloffset*/; |
40316 | - label = 3307LLU; // ~popnext | |
40390 | + label = 3316LLU; // ~popnext | |
40317 | 40391 | break; |
40318 | 40392 | } |
40319 | - case 3405LLU: // return from ~popnext to shadowlock | |
40393 | + case 3414LLU: // return from ~popnext to shadowlock | |
40320 | 40394 | { |
40321 | 40395 | stack = (uint64_t *)stack[0]; |
40322 | 40396 | // releasing toplevel container |
40323 | 40397 | Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 22] - sizeof(uint64_t) * 4)); |
40324 | 40398 | |
40325 | - label = 3399LLU; // continue unrolling stack, delete next variable | |
40399 | + label = 3408LLU; // continue unrolling stack, delete next variable | |
40326 | 40400 | break; |
40327 | 40401 | } |
40328 | - case 3404LLU: // skipped deleter | |
40402 | + case 3413LLU: // skipped deleter | |
40329 | 40403 | { |
40330 | 40404 | // construct popnext.next |
40331 | 40405 | if(!(stack[base + 22] = construct(1))) |
40332 | 40406 | { |
40333 | - label = 3399LLU; // throw: begin to unroll stack | |
40407 | + label = 3408LLU; // throw: begin to unroll stack | |
40334 | 40408 | break; |
40335 | 40409 | } |
40336 | 40410 |
@@ -40337,20 +40411,20 @@ | ||
40337 | 40411 | // consequent |
40338 | 40412 | ((uint64_t *)stack[base + 22])[0] = 1; |
40339 | 40413 | (((uint64_t **)(stack[base + 22]))[1][0]) = stack[base + 23]/*previdx*/; |
40340 | - label = 3395LLU; // alternative complete | |
40414 | + label = 3404LLU; // alternative complete | |
40341 | 40415 | break; |
40342 | 40416 | } |
40343 | - case 3395LLU: // completed if-then-else | |
40417 | + case 3404LLU: // completed if-then-else | |
40344 | 40418 | { |
40345 | - label = 3407LLU; // skip deleter | |
40419 | + label = 3416LLU; // skip deleter | |
40346 | 40420 | break; |
40347 | 40421 | } |
40348 | - case 3406LLU: // deleter | |
40422 | + case 3415LLU: // deleter | |
40349 | 40423 | { |
40350 | 40424 | // throw from shadowlock |
40351 | 40425 | if(!stack[base + 0]) |
40352 | 40426 | { |
40353 | - label = 3391LLU; // skip, variable already deleted/unscoped | |
40427 | + label = 3400LLU; // skip, variable already deleted/unscoped | |
40354 | 40428 | break; |
40355 | 40429 | } |
40356 | 40430 |
@@ -40359,28 +40433,28 @@ | ||
40359 | 40433 | newstack[0] = (uint64_t)stack; // backup stack location |
40360 | 40434 | newstack[1] = 1234567890; |
40361 | 40435 | newstack[2] = base; |
40362 | - newstack[3] = 3408LLU; | |
40436 | + newstack[3] = 3417LLU; | |
40363 | 40437 | stack = newstack; |
40364 | 40438 | // set stack-base & callee-address |
40365 | 40439 | base = 4/*deloffset*/; |
40366 | - label = 3310LLU; // ~listtoelem | |
40440 | + label = 3319LLU; // ~listtoelem | |
40367 | 40441 | break; |
40368 | 40442 | } |
40369 | - case 3408LLU: // return from ~listtoelem to shadowlock | |
40443 | + case 3417LLU: // return from ~listtoelem to shadowlock | |
40370 | 40444 | { |
40371 | 40445 | stack = (uint64_t *)stack[0]; |
40372 | 40446 | // releasing toplevel container |
40373 | 40447 | Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4)); |
40374 | 40448 | |
40375 | - label = 3391LLU; // continue unrolling stack, delete next variable | |
40449 | + label = 3400LLU; // continue unrolling stack, delete next variable | |
40376 | 40450 | break; |
40377 | 40451 | } |
40378 | - case 3407LLU: // skipped deleter | |
40452 | + case 3416LLU: // skipped deleter | |
40379 | 40453 | { |
40380 | 40454 | // construct listtoelem.listtoelem |
40381 | 40455 | if(!(stack[base + 0] = construct(4))) |
40382 | 40456 | { |
40383 | - label = 3391LLU; // throw: begin to unroll stack | |
40457 | + label = 3400LLU; // throw: begin to unroll stack | |
40384 | 40458 | break; |
40385 | 40459 | } |
40386 | 40460 |
@@ -40395,10 +40469,10 @@ | ||
40395 | 40469 | ((uint64_t **)(stack[base + 12]))[1][2] = stack[base + 15]; |
40396 | 40470 | ((uint64_t **)(stack[base + 12]))[1][1] = stack[base + 14]; |
40397 | 40471 | ((uint64_t **)(stack[base + 12]))[1][0] = stack[base + 13]; |
40398 | - label = 3321LLU; // case complete | |
40472 | + label = 3330LLU; // case complete | |
40399 | 40473 | break; |
40400 | 40474 | } |
40401 | - case 3323LLU: // copy-back deleter (switch) | |
40475 | + case 3332LLU: // copy-back deleter (switch) | |
40402 | 40476 | { |
40403 | 40477 | ((uint64_t **)(stack[base + 12]))[1][4] = stack[base + 17]; |
40404 | 40478 | ((uint64_t **)(stack[base + 12]))[1][3] = stack[base + 16]; |
@@ -40405,15 +40479,15 @@ | ||
40405 | 40479 | ((uint64_t **)(stack[base + 12]))[1][2] = stack[base + 15]; |
40406 | 40480 | ((uint64_t **)(stack[base + 12]))[1][1] = stack[base + 14]; |
40407 | 40481 | ((uint64_t **)(stack[base + 12]))[1][0] = stack[base + 13]; |
40408 | - label = 3316LLU; // continue to unroll stack | |
40482 | + label = 3325LLU; // continue to unroll stack | |
40409 | 40483 | break; |
40410 | 40484 | } |
40411 | - case 3322LLU: // try next case | |
40485 | + case 3331LLU: // try next case | |
40412 | 40486 | { |
40413 | 40487 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
40414 | 40488 | exit(-1); |
40415 | 40489 | } |
40416 | - case 3321LLU: // completed switch | |
40490 | + case 3330LLU: // completed switch | |
40417 | 40491 | { |
40418 | 40492 | |
40419 | 40493 | uint64_t *newstack = (uint64_t *)(stack[base + 12] - sizeof(uint64_t) * 4); |
@@ -40421,7 +40495,7 @@ | ||
40421 | 40495 | newstack[0] = (uint64_t)stack; // backup stack location |
40422 | 40496 | newstack[1] = 1234567890; |
40423 | 40497 | newstack[2] = base; |
40424 | - newstack[3] = 3409LLU; | |
40498 | + newstack[3] = 3418LLU; | |
40425 | 40499 | stack = newstack; |
40426 | 40500 | // set stack-base & callee-address |
40427 | 40501 | base = 4/*deloffset*/; |
@@ -40428,7 +40502,7 @@ | ||
40428 | 40502 | label = 486LLU; // ~letdef |
40429 | 40503 | break; |
40430 | 40504 | } |
40431 | - case 3409LLU: // return from ~letdef to shadowlock | |
40505 | + case 3418LLU: // return from ~letdef to shadowlock | |
40432 | 40506 | { |
40433 | 40507 | stack = (uint64_t *)stack[0]; |
40434 | 40508 | // releasing toplevel container |
@@ -40439,13 +40513,13 @@ | ||
40439 | 40513 | base = stack[base - 2]; |
40440 | 40514 | break; |
40441 | 40515 | } |
40442 | - case 3411LLU: // function popnextdel failed | |
40516 | + case 3420LLU: // function popnextdel failed | |
40443 | 40517 | { |
40444 | 40518 | label = stack[base - 3]; |
40445 | 40519 | base = stack[base - 2]; |
40446 | 40520 | break; |
40447 | 40521 | } |
40448 | - case 3410LLU: // popnextdel | |
40522 | + case 3419LLU: // popnextdel | |
40449 | 40523 | { |
40450 | 40524 | //#define arg0 0 |
40451 | 40525 | //#define arg1 1 |
@@ -40452,14 +40526,14 @@ | ||
40452 | 40526 | //#define arg2 2 |
40453 | 40527 | //#define arg3 3 |
40454 | 40528 | flippedassign(stack[base + 2]/*states*/, &stack[base + 4]); |
40455 | - label = 3412LLU; // start to repeat | |
40529 | + label = 3421LLU; // start to repeat | |
40456 | 40530 | break; |
40457 | 40531 | } |
40458 | - case 3412LLU: // repeat from here | |
40532 | + case 3421LLU: // repeat from here | |
40459 | 40533 | { |
40460 | 40534 | if(!stack[base + 4]) |
40461 | 40535 | { |
40462 | - label = 3413LLU; // break loop | |
40536 | + label = 3422LLU; // break loop | |
40463 | 40537 | break; |
40464 | 40538 | } |
40465 | 40539 |
@@ -40469,7 +40543,7 @@ | ||
40469 | 40543 | stack[base + 4] = (uint64_t)(((const struct listnode *)(stack[base + 4]))->next); |
40470 | 40544 | if(/*listtoelem*/0 != ((uint64_t *)(stack[base + 5]/*state*/))[0]) |
40471 | 40545 | { |
40472 | - label = 3416LLU; // jump to alternative | |
40546 | + label = 3425LLU; // jump to alternative | |
40473 | 40547 | break; |
40474 | 40548 | } |
40475 | 40549 |
@@ -40481,7 +40555,7 @@ | ||
40481 | 40555 | // case |
40482 | 40556 | if(/*pop*/0 != ((uint64_t *)(stack[base + 8]/*popnext*/))[0]) |
40483 | 40557 | { |
40484 | - label = 3419LLU; // jump to alternative | |
40558 | + label = 3428LLU; // jump to alternative | |
40485 | 40559 | break; |
40486 | 40560 | } |
40487 | 40561 |
@@ -40490,7 +40564,7 @@ | ||
40490 | 40564 | uint64_t *newstack = (uint64_t *)Calloc(75LLU + 1, sizeof(uint64_t)); |
40491 | 40565 | if(!newstack) |
40492 | 40566 | { |
40493 | - label = 3420LLU; // throw: begin to unroll stack | |
40567 | + label = 3429LLU; // throw: begin to unroll stack | |
40494 | 40568 | break; |
40495 | 40569 | } |
40496 | 40570 |
@@ -40497,9 +40571,9 @@ | ||
40497 | 40571 | newstack[75LLU] = 9876543210LLU; // overflow-marker |
40498 | 40572 | // call calldestr from popnextdel |
40499 | 40573 | newstack[0] = (uint64_t)stack; // backup stack location |
40500 | - newstack[1] = 3421LLU; | |
40574 | + newstack[1] = 3430LLU; | |
40501 | 40575 | newstack[2] = base; |
40502 | - newstack[3] = 3422LLU; | |
40576 | + newstack[3] = 3431LLU; | |
40503 | 40577 | // arguments for call to calldestr |
40504 | 40578 | newstack[4LLU] = stack[base + 0]/*fnid*/; |
40505 | 40579 | newstack[5LLU] = stack[base + 1]/*datadefs*/; |
@@ -40513,7 +40587,7 @@ | ||
40513 | 40587 | label = 1150LLU; // calldestr |
40514 | 40588 | break; |
40515 | 40589 | } |
40516 | - case 3421LLU: // copy-back deleter (calldestr to popnextdel) | |
40590 | + case 3430LLU: // copy-back deleter (calldestr to popnextdel) | |
40517 | 40591 | { |
40518 | 40592 | uint64_t *oldstack = (uint64_t *)stack[0]; |
40519 | 40593 | // copy mutable arguments back from call to calldestr |
@@ -40525,10 +40599,10 @@ | ||
40525 | 40599 | } |
40526 | 40600 | Free(75LLU + 1, sizeof(uint64_t), stack); |
40527 | 40601 | stack = oldstack; |
40528 | - label = 3420LLU; // continue to unroll stack | |
40602 | + label = 3429LLU; // continue to unroll stack | |
40529 | 40603 | break; |
40530 | 40604 | } |
40531 | - case 3422LLU: // return from calldestr to popnextdel | |
40605 | + case 3431LLU: // return from calldestr to popnextdel | |
40532 | 40606 | { |
40533 | 40607 | uint64_t *oldstack = (uint64_t *)stack[0]; |
40534 | 40608 | // copy mutable arguments back from call to calldestr |
@@ -40540,19 +40614,19 @@ | ||
40540 | 40614 | } |
40541 | 40615 | Free(75LLU + 1, sizeof(uint64_t), stack); |
40542 | 40616 | stack = oldstack; |
40543 | - label = 3418LLU; // case complete | |
40617 | + label = 3427LLU; // case complete | |
40544 | 40618 | break; |
40545 | 40619 | } |
40546 | - case 3420LLU: // copy-back deleter (switch) | |
40620 | + case 3429LLU: // copy-back deleter (switch) | |
40547 | 40621 | { |
40548 | - label = 3417LLU; // continue to unroll stack | |
40622 | + label = 3426LLU; // continue to unroll stack | |
40549 | 40623 | break; |
40550 | 40624 | } |
40551 | - case 3419LLU: // try next case | |
40625 | + case 3428LLU: // try next case | |
40552 | 40626 | { |
40553 | 40627 | if(/*next*/1 != ((uint64_t *)(stack[base + 8]/*popnext*/))[0]) |
40554 | 40628 | { |
40555 | - label = 3423LLU; // jump to alternative | |
40629 | + label = 3432LLU; // jump to alternative | |
40556 | 40630 | break; |
40557 | 40631 | } |
40558 | 40632 |
@@ -40561,9 +40635,9 @@ | ||
40561 | 40635 | // case |
40562 | 40636 | printf("%s", "\n ((struct listnode *)("); |
40563 | 40637 | // call emitvaridx from popnextdel |
40564 | - stack[base + 12LLU] = 3425LLU/*throw to this address*/; | |
40638 | + stack[base + 12LLU] = 3434LLU/*throw to this address*/; | |
40565 | 40639 | stack[base + 13LLU] = base; |
40566 | - stack[base + 14LLU] = 3426LLU; | |
40640 | + stack[base + 14LLU] = 3435LLU; | |
40567 | 40641 | // arguments for call to emitvaridx |
40568 | 40642 | stack[base + 15LLU] = stack[base + 11]/*previdx*/; |
40569 | 40643 | // set stack-base & callee-address |
@@ -40571,20 +40645,20 @@ | ||
40571 | 40645 | label = 745LLU; // emitvaridx |
40572 | 40646 | break; |
40573 | 40647 | } |
40574 | - case 3425LLU: // copy-back deleter (emitvaridx to popnextdel) | |
40648 | + case 3434LLU: // copy-back deleter (emitvaridx to popnextdel) | |
40575 | 40649 | { |
40576 | 40650 | // copy mutable arguments back from call to emitvaridx |
40577 | - label = 3424LLU; // continue to roll stack | |
40651 | + label = 3433LLU; // continue to roll stack | |
40578 | 40652 | break; |
40579 | 40653 | } |
40580 | - case 3426LLU: // return from emitvaridx to popnextdel | |
40654 | + case 3435LLU: // return from emitvaridx to popnextdel | |
40581 | 40655 | { |
40582 | 40656 | // copy mutable arguments back from call to emitvaridx |
40583 | 40657 | printf("%s", "/*previous*/))->data = "); |
40584 | 40658 | // call emitvaridx from popnextdel |
40585 | - stack[base + 12LLU] = 3427LLU/*throw to this address*/; | |
40659 | + stack[base + 12LLU] = 3436LLU/*throw to this address*/; | |
40586 | 40660 | stack[base + 13LLU] = base; |
40587 | - stack[base + 14LLU] = 3428LLU; | |
40661 | + stack[base + 14LLU] = 3437LLU; | |
40588 | 40662 | // arguments for call to emitvaridx |
40589 | 40663 | stack[base + 15LLU] = stack[base + 10]/*elemindex*/; |
40590 | 40664 | // set stack-base & callee-address |
@@ -40592,67 +40666,67 @@ | ||
40592 | 40666 | label = 745LLU; // emitvaridx |
40593 | 40667 | break; |
40594 | 40668 | } |
40595 | - case 3427LLU: // copy-back deleter (emitvaridx to popnextdel) | |
40669 | + case 3436LLU: // copy-back deleter (emitvaridx to popnextdel) | |
40596 | 40670 | { |
40597 | 40671 | // copy mutable arguments back from call to emitvaridx |
40598 | - label = 3424LLU; // continue to roll stack | |
40672 | + label = 3433LLU; // continue to roll stack | |
40599 | 40673 | break; |
40600 | 40674 | } |
40601 | - case 3428LLU: // return from emitvaridx to popnextdel | |
40675 | + case 3437LLU: // return from emitvaridx to popnextdel | |
40602 | 40676 | { |
40603 | 40677 | // copy mutable arguments back from call to emitvaridx |
40604 | 40678 | printf("%s", ";"); |
40605 | 40679 | ((uint64_t **)(stack[base + 8]))[1][0] = stack[base + 11]; |
40606 | - label = 3418LLU; // case complete | |
40680 | + label = 3427LLU; // case complete | |
40607 | 40681 | break; |
40608 | 40682 | } |
40609 | - case 3424LLU: // copy-back deleter (switch) | |
40683 | + case 3433LLU: // copy-back deleter (switch) | |
40610 | 40684 | { |
40611 | 40685 | ((uint64_t **)(stack[base + 8]))[1][0] = stack[base + 11]; |
40612 | - label = 3417LLU; // continue to unroll stack | |
40686 | + label = 3426LLU; // continue to unroll stack | |
40613 | 40687 | break; |
40614 | 40688 | } |
40615 | - case 3423LLU: // try next case | |
40689 | + case 3432LLU: // try next case | |
40616 | 40690 | { |
40617 | 40691 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
40618 | 40692 | exit(-1); |
40619 | 40693 | } |
40620 | - case 3418LLU: // completed switch | |
40694 | + case 3427LLU: // completed switch | |
40621 | 40695 | { |
40622 | 40696 | ((uint64_t **)(stack[base + 5]))[1][3] = stack[base + 10]; |
40623 | 40697 | ((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 9]; |
40624 | 40698 | ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8]; |
40625 | 40699 | ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7]; |
40626 | - label = 3415LLU; // case complete | |
40700 | + label = 3424LLU; // case complete | |
40627 | 40701 | break; |
40628 | 40702 | } |
40629 | - case 3417LLU: // copy-back deleter (switch) | |
40703 | + case 3426LLU: // copy-back deleter (switch) | |
40630 | 40704 | { |
40631 | 40705 | ((uint64_t **)(stack[base + 5]))[1][3] = stack[base + 10]; |
40632 | 40706 | ((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 9]; |
40633 | 40707 | ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8]; |
40634 | 40708 | ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7]; |
40635 | - label = 3414LLU; // continue to unroll stack | |
40709 | + label = 3423LLU; // continue to unroll stack | |
40636 | 40710 | break; |
40637 | 40711 | } |
40638 | - case 3416LLU: // try next case | |
40712 | + case 3425LLU: // try next case | |
40639 | 40713 | { |
40640 | 40714 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
40641 | 40715 | exit(-1); |
40642 | 40716 | } |
40643 | - case 3415LLU: // completed switch | |
40717 | + case 3424LLU: // completed switch | |
40644 | 40718 | { |
40645 | 40719 | ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5]; |
40646 | - label = 3412LLU; // repeat | |
40720 | + label = 3421LLU; // repeat | |
40647 | 40721 | break; |
40648 | 40722 | } |
40649 | - case 3414LLU: // copy-back deleter for while next | |
40723 | + case 3423LLU: // copy-back deleter for while next | |
40650 | 40724 | { |
40651 | 40725 | ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5]; |
40652 | - label = 3411LLU; // continue to unroll stack | |
40726 | + label = 3420LLU; // continue to unroll stack | |
40653 | 40727 | break; |
40654 | 40728 | } |
40655 | - case 3413LLU: // loop finished | |
40729 | + case 3422LLU: // loop finished | |
40656 | 40730 | { |
40657 | 40731 | // return from popnextdel |
40658 | 40732 | label = stack[base - 1]; |
@@ -40659,13 +40733,13 @@ | ||
40659 | 40733 | base = stack[base - 2]; |
40660 | 40734 | break; |
40661 | 40735 | } |
40662 | - case 3430LLU: // function procblock failed | |
40736 | + case 3439LLU: // function procblock failed | |
40663 | 40737 | { |
40664 | 40738 | label = stack[base - 3]; |
40665 | 40739 | base = stack[base - 2]; |
40666 | 40740 | break; |
40667 | 40741 | } |
40668 | - case 3429LLU: // procblock | |
40742 | + case 3438LLU: // procblock | |
40669 | 40743 | { |
40670 | 40744 | //#define arg0 0 |
40671 | 40745 | //#define arg1 1 |
@@ -40685,49 +40759,49 @@ | ||
40685 | 40759 | //#define arg15 15 |
40686 | 40760 | //#define arg16 16 |
40687 | 40761 | //#define arg17 17 |
40688 | - label = 3432LLU; // skip deleter | |
40762 | + label = 3441LLU; // skip deleter | |
40689 | 40763 | break; |
40690 | 40764 | } |
40691 | - case 3431LLU: // deleter | |
40765 | + case 3440LLU: // deleter | |
40692 | 40766 | { |
40693 | 40767 | // throw from procblock |
40694 | 40768 | if(!stack[base + 18]) |
40695 | 40769 | { |
40696 | - label = 3430LLU; // skip, variable already deleted/unscoped | |
40770 | + label = 3439LLU; // skip, variable already deleted/unscoped | |
40697 | 40771 | break; |
40698 | 40772 | } |
40699 | - label = 3430LLU; // continue unrolling stack, delete next variable | |
40773 | + label = 3439LLU; // continue unrolling stack, delete next variable | |
40700 | 40774 | break; |
40701 | 40775 | } |
40702 | - case 3432LLU: // skipped deleter | |
40776 | + case 3441LLU: // skipped deleter | |
40703 | 40777 | { |
40704 | 40778 | stack[base + 18] = stack[base + 13]/*varcount*/; |
40705 | - label = 3434LLU; // skip deleter | |
40779 | + label = 3443LLU; // skip deleter | |
40706 | 40780 | break; |
40707 | 40781 | } |
40708 | - case 3433LLU: // deleter | |
40782 | + case 3442LLU: // deleter | |
40709 | 40783 | { |
40710 | 40784 | // throw from procblock |
40711 | 40785 | if(!stack[base + 19]) |
40712 | 40786 | { |
40713 | - label = 3431LLU; // skip, variable already deleted/unscoped | |
40787 | + label = 3440LLU; // skip, variable already deleted/unscoped | |
40714 | 40788 | break; |
40715 | 40789 | } |
40716 | - label = 3431LLU; // continue unrolling stack, delete next variable | |
40790 | + label = 3440LLU; // continue unrolling stack, delete next variable | |
40717 | 40791 | break; |
40718 | 40792 | } |
40719 | - case 3434LLU: // skipped deleter | |
40793 | + case 3443LLU: // skipped deleter | |
40720 | 40794 | { |
40721 | 40795 | stack[base + 19] = stack[base + 14]/*lookahead*/; |
40722 | - label = 3436LLU; // skip deleter | |
40796 | + label = 3445LLU; // skip deleter | |
40723 | 40797 | break; |
40724 | 40798 | } |
40725 | - case 3435LLU: // deleter | |
40799 | + case 3444LLU: // deleter | |
40726 | 40800 | { |
40727 | 40801 | // throw from procblock |
40728 | 40802 | if(!stack[base + 20]) |
40729 | 40803 | { |
40730 | - label = 3433LLU; // skip, variable already deleted/unscoped | |
40804 | + label = 3442LLU; // skip, variable already deleted/unscoped | |
40731 | 40805 | break; |
40732 | 40806 | } |
40733 | 40807 |
@@ -40736,7 +40810,7 @@ | ||
40736 | 40810 | newstack[0] = (uint64_t)stack; // backup stack location |
40737 | 40811 | newstack[1] = 1234567890; |
40738 | 40812 | newstack[2] = base; |
40739 | - newstack[3] = 3437LLU; | |
40813 | + newstack[3] = 3446LLU; | |
40740 | 40814 | stack = newstack; |
40741 | 40815 | // set stack-base & callee-address |
40742 | 40816 | base = 4/*deloffset*/; |
@@ -40743,21 +40817,21 @@ | ||
40743 | 40817 | label = 562LLU; // ~scope |
40744 | 40818 | break; |
40745 | 40819 | } |
40746 | - case 3437LLU: // return from ~scope to procblock | |
40820 | + case 3446LLU: // return from ~scope to procblock | |
40747 | 40821 | { |
40748 | 40822 | stack = (uint64_t *)stack[0]; |
40749 | 40823 | // releasing toplevel container |
40750 | 40824 | Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 20] - sizeof(uint64_t) * 4)); |
40751 | 40825 | |
40752 | - label = 3433LLU; // continue unrolling stack, delete next variable | |
40826 | + label = 3442LLU; // continue unrolling stack, delete next variable | |
40753 | 40827 | break; |
40754 | 40828 | } |
40755 | - case 3436LLU: // skipped deleter | |
40829 | + case 3445LLU: // skipped deleter | |
40756 | 40830 | { |
40757 | 40831 | // call linkscope from procblock |
40758 | - stack[base + 21LLU] = 3438LLU/*throw to this address*/; | |
40832 | + stack[base + 21LLU] = 3447LLU/*throw to this address*/; | |
40759 | 40833 | stack[base + 22LLU] = base; |
40760 | - stack[base + 23LLU] = 3439LLU; | |
40834 | + stack[base + 23LLU] = 3448LLU; | |
40761 | 40835 | // arguments for call to linkscope |
40762 | 40836 | stack[base + 25LLU] = stack[base + 3]/*scope*/; |
40763 | 40837 | // set stack-base & callee-address |
@@ -40765,13 +40839,13 @@ | ||
40765 | 40839 | label = 589LLU; // linkscope |
40766 | 40840 | break; |
40767 | 40841 | } |
40768 | - case 3438LLU: // copy-back deleter (linkscope to procblock) | |
40842 | + case 3447LLU: // copy-back deleter (linkscope to procblock) | |
40769 | 40843 | { |
40770 | 40844 | // copy mutable arguments back from call to linkscope |
40771 | - label = 3433LLU; // continue to roll stack | |
40845 | + label = 3442LLU; // continue to roll stack | |
40772 | 40846 | break; |
40773 | 40847 | } |
40774 | - case 3439LLU: // return from linkscope to procblock | |
40848 | + case 3448LLU: // return from linkscope to procblock | |
40775 | 40849 | { |
40776 | 40850 | // copy mutable arguments back from call to linkscope |
40777 | 40851 | // copy back results provided by call to linkscope |
@@ -40790,22 +40864,22 @@ | ||
40790 | 40864 | /*scopes*/stack[base + 2] = (uint64_t)list; |
40791 | 40865 | MOVE(&list->data, &stack[base + 20]/*newscope*/); |
40792 | 40866 | } |
40793 | - label = 3440LLU; // start to repeat | |
40867 | + label = 3449LLU; // start to repeat | |
40794 | 40868 | break; |
40795 | 40869 | } |
40796 | - case 3440LLU: // repeat from here | |
40870 | + case 3449LLU: // repeat from here | |
40797 | 40871 | { |
40798 | 40872 | if(stack[base + 19]/*lookahead*/ > 0xFF) |
40799 | 40873 | { |
40800 | - label = 3441LLU; // break loop | |
40874 | + label = 3450LLU; // break loop | |
40801 | 40875 | break; |
40802 | 40876 | } |
40803 | 40877 | |
40804 | 40878 | // loop body |
40805 | 40879 | // call skipwscmnt from procblock |
40806 | - stack[base + 20LLU] = 3442LLU/*throw to this address*/; | |
40880 | + stack[base + 20LLU] = 3451LLU/*throw to this address*/; | |
40807 | 40881 | stack[base + 21LLU] = base; |
40808 | - stack[base + 22LLU] = 3443LLU; | |
40882 | + stack[base + 22LLU] = 3452LLU; | |
40809 | 40883 | // arguments for call to skipwscmnt |
40810 | 40884 | stack[base + 24LLU] = stack[base + 19]/*lookahead*/; |
40811 | 40885 | // set stack-base & callee-address |
@@ -40813,38 +40887,38 @@ | ||
40813 | 40887 | label = 18446744073709551580LLU; // skipwscmnt |
40814 | 40888 | break; |
40815 | 40889 | } |
40816 | - case 3442LLU: // copy-back deleter (skipwscmnt to procblock) | |
40890 | + case 3451LLU: // copy-back deleter (skipwscmnt to procblock) | |
40817 | 40891 | { |
40818 | 40892 | // copy mutable arguments back from call to skipwscmnt |
40819 | - label = 3433LLU; // continue to roll stack | |
40893 | + label = 3442LLU; // continue to roll stack | |
40820 | 40894 | break; |
40821 | 40895 | } |
40822 | - case 3443LLU: // return from skipwscmnt to procblock | |
40896 | + case 3452LLU: // return from skipwscmnt to procblock | |
40823 | 40897 | { |
40824 | 40898 | // copy mutable arguments back from call to skipwscmnt |
40825 | 40899 | // copy back results provided by call to skipwscmnt |
40826 | 40900 | stack[base + 19] = stack[base + 23LLU]; |
40827 | - label = 3445LLU; // skip deleter | |
40901 | + label = 3454LLU; // skip deleter | |
40828 | 40902 | break; |
40829 | 40903 | } |
40830 | - case 3444LLU: // deleter | |
40904 | + case 3453LLU: // deleter | |
40831 | 40905 | { |
40832 | 40906 | // throw from procblock |
40833 | 40907 | if(!stack[base + 20]) |
40834 | 40908 | { |
40835 | - label = 3433LLU; // skip, variable already deleted/unscoped | |
40909 | + label = 3442LLU; // skip, variable already deleted/unscoped | |
40836 | 40910 | break; |
40837 | 40911 | } |
40838 | - label = 3433LLU; // continue unrolling stack, delete next variable | |
40912 | + label = 3442LLU; // continue unrolling stack, delete next variable | |
40839 | 40913 | break; |
40840 | 40914 | } |
40841 | - case 3445LLU: // skipped deleter | |
40915 | + case 3454LLU: // skipped deleter | |
40842 | 40916 | { |
40843 | 40917 | stack[base + 20] = 0; |
40844 | 40918 | // call equ from procblock |
40845 | - stack[base + 21LLU] = 3446LLU/*throw to this address*/; | |
40919 | + stack[base + 21LLU] = 3455LLU/*throw to this address*/; | |
40846 | 40920 | stack[base + 22LLU] = base; |
40847 | - stack[base + 23LLU] = 3447LLU; | |
40921 | + stack[base + 23LLU] = 3456LLU; | |
40848 | 40922 | // arguments for call to equ |
40849 | 40923 | stack[base + 25LLU] = stack[base + 19]/*lookahead*/; |
40850 | 40924 | stack[base + 26LLU] = 125LLU; |
@@ -40853,13 +40927,13 @@ | ||
40853 | 40927 | label = 18446744073709551600LLU; // equ |
40854 | 40928 | break; |
40855 | 40929 | } |
40856 | - case 3446LLU: // copy-back deleter (equ to procblock) | |
40930 | + case 3455LLU: // copy-back deleter (equ to procblock) | |
40857 | 40931 | { |
40858 | 40932 | // copy mutable arguments back from call to equ |
40859 | - label = 3444LLU; // continue to roll stack | |
40933 | + label = 3453LLU; // continue to roll stack | |
40860 | 40934 | break; |
40861 | 40935 | } |
40862 | - case 3447LLU: // return from equ to procblock | |
40936 | + case 3456LLU: // return from equ to procblock | |
40863 | 40937 | { |
40864 | 40938 | // copy mutable arguments back from call to equ |
40865 | 40939 | // copy back results provided by call to equ |
@@ -40866,7 +40940,7 @@ | ||
40866 | 40940 | stack[base + 20] = stack[base + 24LLU]; |
40867 | 40941 | if(!stack[base + 20]/*isequal*/) |
40868 | 40942 | { |
40869 | - label = 3448LLU; // jump to alternative | |
40943 | + label = 3457LLU; // jump to alternative | |
40870 | 40944 | break; |
40871 | 40945 | } |
40872 | 40946 |
@@ -40873,7 +40947,7 @@ | ||
40873 | 40947 | // consequent |
40874 | 40948 | if(!stack[base + 4]/*blkresults*/) |
40875 | 40949 | { |
40876 | - label = 3450LLU; // jump to alternative | |
40950 | + label = 3459LLU; // jump to alternative | |
40877 | 40951 | break; |
40878 | 40952 | } |
40879 | 40953 |
@@ -40880,9 +40954,9 @@ | ||
40880 | 40954 | // consequent |
40881 | 40955 | fprintf(stderr, "%s", "in function "); |
40882 | 40956 | // call reportid from procblock |
40883 | - stack[base + 21LLU] = 3452LLU/*throw to this address*/; | |
40957 | + stack[base + 21LLU] = 3461LLU/*throw to this address*/; | |
40884 | 40958 | stack[base + 22LLU] = base; |
40885 | - stack[base + 23LLU] = 3453LLU; | |
40959 | + stack[base + 23LLU] = 3462LLU; | |
40886 | 40960 | // arguments for call to reportid |
40887 | 40961 | stack[base + 24LLU] = stack[base + 8]/*fnid*/; |
40888 | 40962 | // set stack-base & callee-address |
@@ -40890,35 +40964,35 @@ | ||
40890 | 40964 | label = 18446744073709551586LLU; // reportid |
40891 | 40965 | break; |
40892 | 40966 | } |
40893 | - case 3452LLU: // copy-back deleter (reportid to procblock) | |
40967 | + case 3461LLU: // copy-back deleter (reportid to procblock) | |
40894 | 40968 | { |
40895 | 40969 | // copy mutable arguments back from call to reportid |
40896 | - label = 3444LLU; // continue to roll stack | |
40970 | + label = 3453LLU; // continue to roll stack | |
40897 | 40971 | break; |
40898 | 40972 | } |
40899 | - case 3453LLU: // return from reportid to procblock | |
40973 | + case 3462LLU: // return from reportid to procblock | |
40900 | 40974 | { |
40901 | 40975 | // copy mutable arguments back from call to reportid |
40902 | 40976 | fprintf(stderr, "%s", ": missing return\n"); |
40903 | 40977 | { |
40904 | - label = 3444LLU; // throw: begin to unroll stack | |
40978 | + label = 3453LLU; // throw: begin to unroll stack | |
40905 | 40979 | break; |
40906 | 40980 | } |
40907 | 40981 | |
40908 | - label = 3451LLU; // consequent complete | |
40982 | + label = 3460LLU; // consequent complete | |
40909 | 40983 | break; |
40910 | 40984 | } |
40911 | - case 3450LLU: // alternative | |
40985 | + case 3459LLU: // alternative | |
40912 | 40986 | { |
40913 | - label = 3451LLU; // alternative complete | |
40987 | + label = 3460LLU; // alternative complete | |
40914 | 40988 | break; |
40915 | 40989 | } |
40916 | - case 3451LLU: // completed if-then-else | |
40990 | + case 3460LLU: // completed if-then-else | |
40917 | 40991 | { |
40918 | 40992 | // call EOSbyte from procblock |
40919 | - stack[base + 21LLU] = 3454LLU/*throw to this address*/; | |
40993 | + stack[base + 21LLU] = 3463LLU/*throw to this address*/; | |
40920 | 40994 | stack[base + 22LLU] = base; |
40921 | - stack[base + 23LLU] = 3455LLU; | |
40995 | + stack[base + 23LLU] = 3464LLU; | |
40922 | 40996 | // arguments for call to EOSbyte |
40923 | 40997 | // set stack-base & callee-address |
40924 | 40998 | base += 24LLU; |
@@ -40925,26 +40999,26 @@ | ||
40925 | 40999 | label = 77LLU; // EOSbyte |
40926 | 41000 | break; |
40927 | 41001 | } |
40928 | - case 3454LLU: // copy-back deleter (EOSbyte to procblock) | |
41002 | + case 3463LLU: // copy-back deleter (EOSbyte to procblock) | |
40929 | 41003 | { |
40930 | 41004 | // copy mutable arguments back from call to EOSbyte |
40931 | - label = 3444LLU; // continue to roll stack | |
41005 | + label = 3453LLU; // continue to roll stack | |
40932 | 41006 | break; |
40933 | 41007 | } |
40934 | - case 3455LLU: // return from EOSbyte to procblock | |
41008 | + case 3464LLU: // return from EOSbyte to procblock | |
40935 | 41009 | { |
40936 | 41010 | // copy mutable arguments back from call to EOSbyte |
40937 | 41011 | // copy back results provided by call to EOSbyte |
40938 | 41012 | stack[base + 19] = stack[base + 24LLU]; |
40939 | - label = 3449LLU; // consequent complete | |
41013 | + label = 3458LLU; // consequent complete | |
40940 | 41014 | break; |
40941 | 41015 | } |
40942 | - case 3448LLU: // alternative | |
41016 | + case 3457LLU: // alternative | |
40943 | 41017 | { |
40944 | 41018 | // call ParseToken from procblock |
40945 | - stack[base + 21LLU] = 3456LLU/*throw to this address*/; | |
41019 | + stack[base + 21LLU] = 3465LLU/*throw to this address*/; | |
40946 | 41020 | stack[base + 22LLU] = base; |
40947 | - stack[base + 23LLU] = 3457LLU; | |
41021 | + stack[base + 23LLU] = 3466LLU; | |
40948 | 41022 | // arguments for call to ParseToken |
40949 | 41023 | stack[base + 26LLU] = stack[base + 19]/*lookahead*/; |
40950 | 41024 | // set stack-base & callee-address |
@@ -40952,14 +41026,14 @@ | ||
40952 | 41026 | label = 3LLU; // ParseToken |
40953 | 41027 | break; |
40954 | 41028 | } |
40955 | - case 3456LLU: // copy-back deleter (ParseToken to procblock) | |
41029 | + case 3465LLU: // copy-back deleter (ParseToken to procblock) | |
40956 | 41030 | { |
40957 | 41031 | // copy mutable arguments back from call to ParseToken |
40958 | 41032 | stack[base + 19]/*lookahead*/ = stack[base + 26LLU]; |
40959 | - label = 3444LLU; // continue to roll stack | |
41033 | + label = 3453LLU; // continue to roll stack | |
40960 | 41034 | break; |
40961 | 41035 | } |
40962 | - case 3457LLU: // return from ParseToken to procblock | |
41036 | + case 3466LLU: // return from ParseToken to procblock | |
40963 | 41037 | { |
40964 | 41038 | // copy mutable arguments back from call to ParseToken |
40965 | 41039 | stack[base + 19]/*lookahead*/ = stack[base + 26LLU]; |
@@ -40967,9 +41041,9 @@ | ||
40967 | 41041 | stack[base + 15] = stack[base + 24LLU]; |
40968 | 41042 | stack[base + 16] = stack[base + 25LLU]; |
40969 | 41043 | // call equ from procblock |
40970 | - stack[base + 21LLU] = 3458LLU/*throw to this address*/; | |
41044 | + stack[base + 21LLU] = 3467LLU/*throw to this address*/; | |
40971 | 41045 | stack[base + 22LLU] = base; |
40972 | - stack[base + 23LLU] = 3459LLU; | |
41046 | + stack[base + 23LLU] = 3468LLU; | |
40973 | 41047 | // arguments for call to equ |
40974 | 41048 | stack[base + 25LLU] = stack[base + 15]/*variant*/; |
40975 | 41049 | stack[base + 26LLU] = 0LLU; |
@@ -40978,13 +41052,13 @@ | ||
40978 | 41052 | label = 18446744073709551600LLU; // equ |
40979 | 41053 | break; |
40980 | 41054 | } |
40981 | - case 3458LLU: // copy-back deleter (equ to procblock) | |
41055 | + case 3467LLU: // copy-back deleter (equ to procblock) | |
40982 | 41056 | { |
40983 | 41057 | // copy mutable arguments back from call to equ |
40984 | - label = 3444LLU; // continue to roll stack | |
41058 | + label = 3453LLU; // continue to roll stack | |
40985 | 41059 | break; |
40986 | 41060 | } |
40987 | - case 3459LLU: // return from equ to procblock | |
41061 | + case 3468LLU: // return from equ to procblock | |
40988 | 41062 | { |
40989 | 41063 | // copy mutable arguments back from call to equ |
40990 | 41064 | // copy back results provided by call to equ |
@@ -40991,15 +41065,15 @@ | ||
40991 | 41065 | stack[base + 20] = stack[base + 24LLU]; |
40992 | 41066 | if(!stack[base + 20]/*isequal*/) |
40993 | 41067 | { |
40994 | - label = 3460LLU; // jump to alternative | |
41068 | + label = 3469LLU; // jump to alternative | |
40995 | 41069 | break; |
40996 | 41070 | } |
40997 | 41071 | |
40998 | 41072 | // consequent |
40999 | 41073 | // call equ from procblock |
41000 | - stack[base + 21LLU] = 3462LLU/*throw to this address*/; | |
41074 | + stack[base + 21LLU] = 3471LLU/*throw to this address*/; | |
41001 | 41075 | stack[base + 22LLU] = base; |
41002 | - stack[base + 23LLU] = 3463LLU; | |
41076 | + stack[base + 23LLU] = 3472LLU; | |
41003 | 41077 | // arguments for call to equ |
41004 | 41078 | stack[base + 25LLU] = stack[base + 16]/*content*/; |
41005 | 41079 | stack[base + 26LLU] = 123LLU; |
@@ -41008,13 +41082,13 @@ | ||
41008 | 41082 | label = 18446744073709551600LLU; // equ |
41009 | 41083 | break; |
41010 | 41084 | } |
41011 | - case 3462LLU: // copy-back deleter (equ to procblock) | |
41085 | + case 3471LLU: // copy-back deleter (equ to procblock) | |
41012 | 41086 | { |
41013 | 41087 | // copy mutable arguments back from call to equ |
41014 | - label = 3444LLU; // continue to roll stack | |
41088 | + label = 3453LLU; // continue to roll stack | |
41015 | 41089 | break; |
41016 | 41090 | } |
41017 | - case 3463LLU: // return from equ to procblock | |
41091 | + case 3472LLU: // return from equ to procblock | |
41018 | 41092 | { |
41019 | 41093 | // copy mutable arguments back from call to equ |
41020 | 41094 | // copy back results provided by call to equ |
@@ -41021,31 +41095,31 @@ | ||
41021 | 41095 | stack[base + 20] = stack[base + 24LLU]; |
41022 | 41096 | if(!stack[base + 20]/*isequal*/) |
41023 | 41097 | { |
41024 | - label = 3464LLU; // jump to alternative | |
41098 | + label = 3473LLU; // jump to alternative | |
41025 | 41099 | break; |
41026 | 41100 | } |
41027 | 41101 | |
41028 | 41102 | // consequent |
41029 | - label = 3467LLU; // skip deleter | |
41103 | + label = 3476LLU; // skip deleter | |
41030 | 41104 | break; |
41031 | 41105 | } |
41032 | - case 3466LLU: // deleter | |
41106 | + case 3475LLU: // deleter | |
41033 | 41107 | { |
41034 | 41108 | // throw from procblock |
41035 | 41109 | if(!stack[base + 21]) |
41036 | 41110 | { |
41037 | - label = 3444LLU; // skip, variable already deleted/unscoped | |
41111 | + label = 3453LLU; // skip, variable already deleted/unscoped | |
41038 | 41112 | break; |
41039 | 41113 | } |
41040 | 41114 | // delete list |
41041 | - label = 3468LLU; // start to repeat | |
41115 | + label = 3477LLU; // start to repeat | |
41042 | 41116 | break; |
41043 | 41117 | } |
41044 | - case 3468LLU: // repeat from here | |
41118 | + case 3477LLU: // repeat from here | |
41045 | 41119 | { |
41046 | 41120 | if(!stack[base + 21]) |
41047 | 41121 | { |
41048 | - label = 3469LLU; // break loop | |
41122 | + label = 3478LLU; // break loop | |
41049 | 41123 | break; |
41050 | 41124 | } |
41051 | 41125 |
@@ -41056,7 +41130,7 @@ | ||
41056 | 41130 | newstack[0] = (uint64_t)stack; // backup stack location |
41057 | 41131 | newstack[1] = 1234567890; |
41058 | 41132 | newstack[2] = base; |
41059 | - newstack[3] = 3470LLU; | |
41133 | + newstack[3] = 3479LLU; | |
41060 | 41134 | stack = newstack; |
41061 | 41135 | // set stack-base & callee-address |
41062 | 41136 | base = 4/*deloffset*/; |
@@ -41063,7 +41137,7 @@ | ||
41063 | 41137 | label = 399LLU; // ~typeidx |
41064 | 41138 | break; |
41065 | 41139 | } |
41066 | - case 3470LLU: // return from ~typeidx to procblock | |
41140 | + case 3479LLU: // return from ~typeidx to procblock | |
41067 | 41141 | { |
41068 | 41142 | stack = (uint64_t *)stack[0]; |
41069 | 41143 | // releasing toplevel container |
@@ -41074,21 +41148,21 @@ | ||
41074 | 41148 | stack[base + 21] = (uint64_t)list->next; |
41075 | 41149 | Free(1, sizeof(struct listnode), list); |
41076 | 41150 | } |
41077 | - label = 3468LLU; // repeat | |
41151 | + label = 3477LLU; // repeat | |
41078 | 41152 | break; |
41079 | 41153 | } |
41080 | - case 3469LLU: // loop finished | |
41154 | + case 3478LLU: // loop finished | |
41081 | 41155 | { |
41082 | - label = 3444LLU; // continue unrolling stack, delete next variable | |
41156 | + label = 3453LLU; // continue unrolling stack, delete next variable | |
41083 | 41157 | break; |
41084 | 41158 | } |
41085 | - case 3467LLU: // skipped deleter | |
41159 | + case 3476LLU: // skipped deleter | |
41086 | 41160 | { |
41087 | 41161 | stack[base + 21] = 0; |
41088 | 41162 | uint64_t *newstack = (uint64_t *)Calloc(160LLU + 1, sizeof(uint64_t)); |
41089 | 41163 | if(!newstack) |
41090 | 41164 | { |
41091 | - label = 3466LLU; // throw: begin to unroll stack | |
41165 | + label = 3475LLU; // throw: begin to unroll stack | |
41092 | 41166 | break; |
41093 | 41167 | } |
41094 | 41168 |
@@ -41095,9 +41169,9 @@ | ||
41095 | 41169 | newstack[160LLU] = 9876543210LLU; // overflow-marker |
41096 | 41170 | // call procblock from procblock |
41097 | 41171 | newstack[0] = (uint64_t)stack; // backup stack location |
41098 | - newstack[1] = 3471LLU; | |
41172 | + newstack[1] = 3480LLU; | |
41099 | 41173 | newstack[2] = base; |
41100 | - newstack[3] = 3472LLU; | |
41174 | + newstack[3] = 3481LLU; | |
41101 | 41175 | // arguments for call to procblock |
41102 | 41176 | newstack[4LLU] = stack[base + 0]/*fndefs*/; |
41103 | 41177 | newstack[5LLU] = stack[base + 1]/*datadefs*/; |
@@ -41120,10 +41194,10 @@ | ||
41120 | 41194 | stack = newstack; |
41121 | 41195 | // set stack-base & callee-address |
41122 | 41196 | base = 4/*deloffset*/; |
41123 | - label = 3429LLU; // procblock | |
41197 | + label = 3438LLU; // procblock | |
41124 | 41198 | break; |
41125 | 41199 | } |
41126 | - case 3471LLU: // copy-back deleter (procblock to procblock) | |
41200 | + case 3480LLU: // copy-back deleter (procblock to procblock) | |
41127 | 41201 | { |
41128 | 41202 | uint64_t *oldstack = (uint64_t *)stack[0]; |
41129 | 41203 | // copy mutable arguments back from call to procblock |
@@ -41140,10 +41214,10 @@ | ||
41140 | 41214 | } |
41141 | 41215 | Free(160LLU + 1, sizeof(uint64_t), stack); |
41142 | 41216 | stack = oldstack; |
41143 | - label = 3466LLU; // continue to unroll stack | |
41217 | + label = 3475LLU; // continue to unroll stack | |
41144 | 41218 | break; |
41145 | 41219 | } |
41146 | - case 3472LLU: // return from procblock to procblock | |
41220 | + case 3481LLU: // return from procblock to procblock | |
41147 | 41221 | { |
41148 | 41222 | uint64_t *oldstack = (uint64_t *)stack[0]; |
41149 | 41223 | // copy mutable arguments back from call to procblock |
@@ -41161,14 +41235,14 @@ | ||
41161 | 41235 | Free(160LLU + 1, sizeof(uint64_t), stack); |
41162 | 41236 | stack = oldstack; |
41163 | 41237 | // delete list |
41164 | - label = 3473LLU; // start to repeat | |
41238 | + label = 3482LLU; // start to repeat | |
41165 | 41239 | break; |
41166 | 41240 | } |
41167 | - case 3473LLU: // repeat from here | |
41241 | + case 3482LLU: // repeat from here | |
41168 | 41242 | { |
41169 | 41243 | if(!stack[base + 21]) |
41170 | 41244 | { |
41171 | - label = 3474LLU; // break loop | |
41245 | + label = 3483LLU; // break loop | |
41172 | 41246 | break; |
41173 | 41247 | } |
41174 | 41248 |
@@ -41179,7 +41253,7 @@ | ||
41179 | 41253 | newstack[0] = (uint64_t)stack; // backup stack location |
41180 | 41254 | newstack[1] = 1234567890; |
41181 | 41255 | newstack[2] = base; |
41182 | - newstack[3] = 3475LLU; | |
41256 | + newstack[3] = 3484LLU; | |
41183 | 41257 | stack = newstack; |
41184 | 41258 | // set stack-base & callee-address |
41185 | 41259 | base = 4/*deloffset*/; |
@@ -41186,7 +41260,7 @@ | ||
41186 | 41260 | label = 399LLU; // ~typeidx |
41187 | 41261 | break; |
41188 | 41262 | } |
41189 | - case 3475LLU: // return from ~typeidx to procblock | |
41263 | + case 3484LLU: // return from ~typeidx to procblock | |
41190 | 41264 | { |
41191 | 41265 | stack = (uint64_t *)stack[0]; |
41192 | 41266 | // releasing toplevel container |
@@ -41197,20 +41271,20 @@ | ||
41197 | 41271 | stack[base + 21] = (uint64_t)list->next; |
41198 | 41272 | Free(1, sizeof(struct listnode), list); |
41199 | 41273 | } |
41200 | - label = 3473LLU; // repeat | |
41274 | + label = 3482LLU; // repeat | |
41201 | 41275 | break; |
41202 | 41276 | } |
41203 | - case 3474LLU: // loop finished | |
41277 | + case 3483LLU: // loop finished | |
41204 | 41278 | { |
41205 | - label = 3465LLU; // consequent complete | |
41279 | + label = 3474LLU; // consequent complete | |
41206 | 41280 | break; |
41207 | 41281 | } |
41208 | - case 3464LLU: // alternative | |
41282 | + case 3473LLU: // alternative | |
41209 | 41283 | { |
41210 | 41284 | // call equ from procblock |
41211 | - stack[base + 21LLU] = 3476LLU/*throw to this address*/; | |
41285 | + stack[base + 21LLU] = 3485LLU/*throw to this address*/; | |
41212 | 41286 | stack[base + 22LLU] = base; |
41213 | - stack[base + 23LLU] = 3477LLU; | |
41287 | + stack[base + 23LLU] = 3486LLU; | |
41214 | 41288 | // arguments for call to equ |
41215 | 41289 | stack[base + 25LLU] = stack[base + 16]/*content*/; |
41216 | 41290 | stack[base + 26LLU] = 96LLU; |
@@ -41219,13 +41293,13 @@ | ||
41219 | 41293 | label = 18446744073709551600LLU; // equ |
41220 | 41294 | break; |
41221 | 41295 | } |
41222 | - case 3476LLU: // copy-back deleter (equ to procblock) | |
41296 | + case 3485LLU: // copy-back deleter (equ to procblock) | |
41223 | 41297 | { |
41224 | 41298 | // copy mutable arguments back from call to equ |
41225 | - label = 3444LLU; // continue to roll stack | |
41299 | + label = 3453LLU; // continue to roll stack | |
41226 | 41300 | break; |
41227 | 41301 | } |
41228 | - case 3477LLU: // return from equ to procblock | |
41302 | + case 3486LLU: // return from equ to procblock | |
41229 | 41303 | { |
41230 | 41304 | // copy mutable arguments back from call to equ |
41231 | 41305 | // copy back results provided by call to equ |
@@ -41232,15 +41306,15 @@ | ||
41232 | 41306 | stack[base + 20] = stack[base + 24LLU]; |
41233 | 41307 | if(!stack[base + 20]/*isequal*/) |
41234 | 41308 | { |
41235 | - label = 3478LLU; // jump to alternative | |
41309 | + label = 3487LLU; // jump to alternative | |
41236 | 41310 | break; |
41237 | 41311 | } |
41238 | 41312 | |
41239 | 41313 | // consequent |
41240 | 41314 | // call verbatim from procblock |
41241 | - stack[base + 21LLU] = 3480LLU/*throw to this address*/; | |
41315 | + stack[base + 21LLU] = 3489LLU/*throw to this address*/; | |
41242 | 41316 | stack[base + 22LLU] = base; |
41243 | - stack[base + 23LLU] = 3481LLU; | |
41317 | + stack[base + 23LLU] = 3490LLU; | |
41244 | 41318 | // arguments for call to verbatim |
41245 | 41319 | stack[base + 24LLU] = stack[base + 2]/*scopes*/; |
41246 | 41320 | stack[base + 25LLU] = stack[base + 3]/*scope*/; |
@@ -41247,29 +41321,29 @@ | ||
41247 | 41321 | stack[base + 26LLU] = stack[base + 19]/*lookahead*/; |
41248 | 41322 | // set stack-base & callee-address |
41249 | 41323 | base += 24LLU; |
41250 | - label = 3245LLU; // verbatim | |
41324 | + label = 3254LLU; // verbatim | |
41251 | 41325 | break; |
41252 | 41326 | } |
41253 | - case 3480LLU: // copy-back deleter (verbatim to procblock) | |
41327 | + case 3489LLU: // copy-back deleter (verbatim to procblock) | |
41254 | 41328 | { |
41255 | 41329 | // copy mutable arguments back from call to verbatim |
41256 | 41330 | stack[base + 19]/*lookahead*/ = stack[base + 26LLU]; |
41257 | - label = 3444LLU; // continue to roll stack | |
41331 | + label = 3453LLU; // continue to roll stack | |
41258 | 41332 | break; |
41259 | 41333 | } |
41260 | - case 3481LLU: // return from verbatim to procblock | |
41334 | + case 3490LLU: // return from verbatim to procblock | |
41261 | 41335 | { |
41262 | 41336 | // copy mutable arguments back from call to verbatim |
41263 | 41337 | stack[base + 19]/*lookahead*/ = stack[base + 26LLU]; |
41264 | - label = 3479LLU; // consequent complete | |
41338 | + label = 3488LLU; // consequent complete | |
41265 | 41339 | break; |
41266 | 41340 | } |
41267 | - case 3478LLU: // alternative | |
41341 | + case 3487LLU: // alternative | |
41268 | 41342 | { |
41269 | 41343 | // call equ from procblock |
41270 | - stack[base + 21LLU] = 3482LLU/*throw to this address*/; | |
41344 | + stack[base + 21LLU] = 3491LLU/*throw to this address*/; | |
41271 | 41345 | stack[base + 22LLU] = base; |
41272 | - stack[base + 23LLU] = 3483LLU; | |
41346 | + stack[base + 23LLU] = 3492LLU; | |
41273 | 41347 | // arguments for call to equ |
41274 | 41348 | stack[base + 25LLU] = stack[base + 16]/*content*/; |
41275 | 41349 | stack[base + 26LLU] = 40LLU; |
@@ -41278,13 +41352,13 @@ | ||
41278 | 41352 | label = 18446744073709551600LLU; // equ |
41279 | 41353 | break; |
41280 | 41354 | } |
41281 | - case 3482LLU: // copy-back deleter (equ to procblock) | |
41355 | + case 3491LLU: // copy-back deleter (equ to procblock) | |
41282 | 41356 | { |
41283 | 41357 | // copy mutable arguments back from call to equ |
41284 | - label = 3444LLU; // continue to roll stack | |
41358 | + label = 3453LLU; // continue to roll stack | |
41285 | 41359 | break; |
41286 | 41360 | } |
41287 | - case 3483LLU: // return from equ to procblock | |
41361 | + case 3492LLU: // return from equ to procblock | |
41288 | 41362 | { |
41289 | 41363 | // copy mutable arguments back from call to equ |
41290 | 41364 | // copy back results provided by call to equ |
@@ -41291,15 +41365,15 @@ | ||
41291 | 41365 | stack[base + 20] = stack[base + 24LLU]; |
41292 | 41366 | if(!stack[base + 20]/*isequal*/) |
41293 | 41367 | { |
41294 | - label = 3484LLU; // jump to alternative | |
41368 | + label = 3493LLU; // jump to alternative | |
41295 | 41369 | break; |
41296 | 41370 | } |
41297 | 41371 | |
41298 | 41372 | // consequent |
41299 | 41373 | // call PROCCALL from procblock |
41300 | - stack[base + 21LLU] = 3486LLU/*throw to this address*/; | |
41374 | + stack[base + 21LLU] = 3495LLU/*throw to this address*/; | |
41301 | 41375 | stack[base + 22LLU] = base; |
41302 | - stack[base + 23LLU] = 3487LLU; | |
41376 | + stack[base + 23LLU] = 3496LLU; | |
41303 | 41377 | // arguments for call to PROCCALL |
41304 | 41378 | stack[base + 24LLU] = stack[base + 0]/*fndefs*/; |
41305 | 41379 | stack[base + 25LLU] = stack[base + 2]/*scopes*/; |
@@ -41322,7 +41396,7 @@ | ||
41322 | 41396 | label = 2930LLU; // PROCCALL |
41323 | 41397 | break; |
41324 | 41398 | } |
41325 | - case 3486LLU: // copy-back deleter (PROCCALL to procblock) | |
41399 | + case 3495LLU: // copy-back deleter (PROCCALL to procblock) | |
41326 | 41400 | { |
41327 | 41401 | // copy mutable arguments back from call to PROCCALL |
41328 | 41402 | stack[base + 17]/*label*/ = stack[base + 39LLU]; |
@@ -41330,10 +41404,10 @@ | ||
41330 | 41404 | stack[base + 15]/*variant*/ = stack[base + 37LLU]; |
41331 | 41405 | stack[base + 19]/*lookahead*/ = stack[base + 36LLU]; |
41332 | 41406 | stack[base + 12]/*fnmaxcount*/ = stack[base + 35LLU]; |
41333 | - label = 3444LLU; // continue to roll stack | |
41407 | + label = 3453LLU; // continue to roll stack | |
41334 | 41408 | break; |
41335 | 41409 | } |
41336 | - case 3487LLU: // return from PROCCALL to procblock | |
41410 | + case 3496LLU: // return from PROCCALL to procblock | |
41337 | 41411 | { |
41338 | 41412 | // copy mutable arguments back from call to PROCCALL |
41339 | 41413 | stack[base + 17]/*label*/ = stack[base + 39LLU]; |
@@ -41342,9 +41416,9 @@ | ||
41342 | 41416 | stack[base + 19]/*lookahead*/ = stack[base + 36LLU]; |
41343 | 41417 | stack[base + 12]/*fnmaxcount*/ = stack[base + 35LLU]; |
41344 | 41418 | // call DELIMITER from procblock |
41345 | - stack[base + 21LLU] = 3488LLU/*throw to this address*/; | |
41419 | + stack[base + 21LLU] = 3497LLU/*throw to this address*/; | |
41346 | 41420 | stack[base + 22LLU] = base; |
41347 | - stack[base + 23LLU] = 3489LLU; | |
41421 | + stack[base + 23LLU] = 3498LLU; | |
41348 | 41422 | // arguments for call to DELIMITER |
41349 | 41423 | stack[base + 24LLU] = stack[base + 8]/*fnid*/; |
41350 | 41424 | stack[base + 25LLU] = stack[base + 19]/*lookahead*/; |
@@ -41353,27 +41427,27 @@ | ||
41353 | 41427 | label = 17LLU; // DELIMITER |
41354 | 41428 | break; |
41355 | 41429 | } |
41356 | - case 3488LLU: // copy-back deleter (DELIMITER to procblock) | |
41430 | + case 3497LLU: // copy-back deleter (DELIMITER to procblock) | |
41357 | 41431 | { |
41358 | 41432 | // copy mutable arguments back from call to DELIMITER |
41359 | 41433 | stack[base + 19]/*lookahead*/ = stack[base + 25LLU]; |
41360 | - label = 3444LLU; // continue to roll stack | |
41434 | + label = 3453LLU; // continue to roll stack | |
41361 | 41435 | break; |
41362 | 41436 | } |
41363 | - case 3489LLU: // return from DELIMITER to procblock | |
41437 | + case 3498LLU: // return from DELIMITER to procblock | |
41364 | 41438 | { |
41365 | 41439 | // copy mutable arguments back from call to DELIMITER |
41366 | 41440 | stack[base + 19]/*lookahead*/ = stack[base + 25LLU]; |
41367 | - label = 3485LLU; // consequent complete | |
41441 | + label = 3494LLU; // consequent complete | |
41368 | 41442 | break; |
41369 | 41443 | } |
41370 | - case 3484LLU: // alternative | |
41444 | + case 3493LLU: // alternative | |
41371 | 41445 | { |
41372 | 41446 | fprintf(stderr, "%s", "parsing block unexpected token "); |
41373 | 41447 | // call reporttok from procblock |
41374 | - stack[base + 21LLU] = 3490LLU/*throw to this address*/; | |
41448 | + stack[base + 21LLU] = 3499LLU/*throw to this address*/; | |
41375 | 41449 | stack[base + 22LLU] = base; |
41376 | - stack[base + 23LLU] = 3491LLU; | |
41450 | + stack[base + 23LLU] = 3500LLU; | |
41377 | 41451 | // arguments for call to reporttok |
41378 | 41452 | stack[base + 24LLU] = stack[base + 15]/*variant*/; |
41379 | 41453 | stack[base + 25LLU] = stack[base + 16]/*content*/; |
@@ -41382,45 +41456,45 @@ | ||
41382 | 41456 | label = 18446744073709551582LLU; // reporttok |
41383 | 41457 | break; |
41384 | 41458 | } |
41385 | - case 3490LLU: // copy-back deleter (reporttok to procblock) | |
41459 | + case 3499LLU: // copy-back deleter (reporttok to procblock) | |
41386 | 41460 | { |
41387 | 41461 | // copy mutable arguments back from call to reporttok |
41388 | - label = 3444LLU; // continue to roll stack | |
41462 | + label = 3453LLU; // continue to roll stack | |
41389 | 41463 | break; |
41390 | 41464 | } |
41391 | - case 3491LLU: // return from reporttok to procblock | |
41465 | + case 3500LLU: // return from reporttok to procblock | |
41392 | 41466 | { |
41393 | 41467 | // copy mutable arguments back from call to reporttok |
41394 | 41468 | fprintf(stderr, "%s", "\n"); |
41395 | 41469 | { |
41396 | - label = 3444LLU; // throw: begin to unroll stack | |
41470 | + label = 3453LLU; // throw: begin to unroll stack | |
41397 | 41471 | break; |
41398 | 41472 | } |
41399 | 41473 | |
41400 | - label = 3485LLU; // alternative complete | |
41474 | + label = 3494LLU; // alternative complete | |
41401 | 41475 | break; |
41402 | 41476 | } |
41403 | - case 3485LLU: // completed if-then-else | |
41477 | + case 3494LLU: // completed if-then-else | |
41404 | 41478 | { |
41405 | - label = 3479LLU; // alternative complete | |
41479 | + label = 3488LLU; // alternative complete | |
41406 | 41480 | break; |
41407 | 41481 | } |
41408 | - case 3479LLU: // completed if-then-else | |
41482 | + case 3488LLU: // completed if-then-else | |
41409 | 41483 | { |
41410 | - label = 3465LLU; // alternative complete | |
41484 | + label = 3474LLU; // alternative complete | |
41411 | 41485 | break; |
41412 | 41486 | } |
41413 | - case 3465LLU: // completed if-then-else | |
41487 | + case 3474LLU: // completed if-then-else | |
41414 | 41488 | { |
41415 | - label = 3461LLU; // consequent complete | |
41489 | + label = 3470LLU; // consequent complete | |
41416 | 41490 | break; |
41417 | 41491 | } |
41418 | - case 3460LLU: // alternative | |
41492 | + case 3469LLU: // alternative | |
41419 | 41493 | { |
41420 | 41494 | // call equ from procblock |
41421 | - stack[base + 21LLU] = 3492LLU/*throw to this address*/; | |
41495 | + stack[base + 21LLU] = 3501LLU/*throw to this address*/; | |
41422 | 41496 | stack[base + 22LLU] = base; |
41423 | - stack[base + 23LLU] = 3493LLU; | |
41497 | + stack[base + 23LLU] = 3502LLU; | |
41424 | 41498 | // arguments for call to equ |
41425 | 41499 | stack[base + 25LLU] = stack[base + 15]/*variant*/; |
41426 | 41500 | stack[base + 26LLU] = 4LLU; |
@@ -41429,13 +41503,13 @@ | ||
41429 | 41503 | label = 18446744073709551600LLU; // equ |
41430 | 41504 | break; |
41431 | 41505 | } |
41432 | - case 3492LLU: // copy-back deleter (equ to procblock) | |
41506 | + case 3501LLU: // copy-back deleter (equ to procblock) | |
41433 | 41507 | { |
41434 | 41508 | // copy mutable arguments back from call to equ |
41435 | - label = 3444LLU; // continue to roll stack | |
41509 | + label = 3453LLU; // continue to roll stack | |
41436 | 41510 | break; |
41437 | 41511 | } |
41438 | - case 3493LLU: // return from equ to procblock | |
41512 | + case 3502LLU: // return from equ to procblock | |
41439 | 41513 | { |
41440 | 41514 | // copy mutable arguments back from call to equ |
41441 | 41515 | // copy back results provided by call to equ |
@@ -41442,31 +41516,31 @@ | ||
41442 | 41516 | stack[base + 20] = stack[base + 24LLU]; |
41443 | 41517 | if(!stack[base + 20]/*isequal*/) |
41444 | 41518 | { |
41445 | - label = 3494LLU; // jump to alternative | |
41519 | + label = 3503LLU; // jump to alternative | |
41446 | 41520 | break; |
41447 | 41521 | } |
41448 | 41522 | |
41449 | 41523 | // consequent |
41450 | - label = 3497LLU; // skip deleter | |
41524 | + label = 3506LLU; // skip deleter | |
41451 | 41525 | break; |
41452 | 41526 | } |
41453 | - case 3496LLU: // deleter | |
41527 | + case 3505LLU: // deleter | |
41454 | 41528 | { |
41455 | 41529 | // throw from procblock |
41456 | 41530 | if(!stack[base + 21]) |
41457 | 41531 | { |
41458 | - label = 3444LLU; // skip, variable already deleted/unscoped | |
41532 | + label = 3453LLU; // skip, variable already deleted/unscoped | |
41459 | 41533 | break; |
41460 | 41534 | } |
41461 | - label = 3444LLU; // continue unrolling stack, delete next variable | |
41535 | + label = 3453LLU; // continue unrolling stack, delete next variable | |
41462 | 41536 | break; |
41463 | 41537 | } |
41464 | - case 3497LLU: // skipped deleter | |
41538 | + case 3506LLU: // skipped deleter | |
41465 | 41539 | { |
41466 | 41540 | // call equ from procblock |
41467 | - stack[base + 22LLU] = 3498LLU/*throw to this address*/; | |
41541 | + stack[base + 22LLU] = 3507LLU/*throw to this address*/; | |
41468 | 41542 | stack[base + 23LLU] = base; |
41469 | - stack[base + 24LLU] = 3499LLU; | |
41543 | + stack[base + 24LLU] = 3508LLU; | |
41470 | 41544 | // arguments for call to equ |
41471 | 41545 | stack[base + 26LLU] = stack[base + 16]/*content*/; |
41472 | 41546 | stack[base + 27LLU] = 819865187908583424LLU; |
@@ -41475,13 +41549,13 @@ | ||
41475 | 41549 | label = 18446744073709551600LLU; // equ |
41476 | 41550 | break; |
41477 | 41551 | } |
41478 | - case 3498LLU: // copy-back deleter (equ to procblock) | |
41552 | + case 3507LLU: // copy-back deleter (equ to procblock) | |
41479 | 41553 | { |
41480 | 41554 | // copy mutable arguments back from call to equ |
41481 | - label = 3444LLU; // continue to roll stack | |
41555 | + label = 3453LLU; // continue to roll stack | |
41482 | 41556 | break; |
41483 | 41557 | } |
41484 | - case 3499LLU: // return from equ to procblock | |
41558 | + case 3508LLU: // return from equ to procblock | |
41485 | 41559 | { |
41486 | 41560 | // copy mutable arguments back from call to equ |
41487 | 41561 | // copy back results provided by call to equ |
@@ -41488,15 +41562,15 @@ | ||
41488 | 41562 | stack[base + 21] = stack[base + 25LLU]; |
41489 | 41563 | if(!stack[base + 21]/*returnflag*/) |
41490 | 41564 | { |
41491 | - label = 3500LLU; // jump to alternative | |
41565 | + label = 3509LLU; // jump to alternative | |
41492 | 41566 | break; |
41493 | 41567 | } |
41494 | 41568 | |
41495 | 41569 | // consequent |
41496 | 41570 | // call ParseToken from procblock |
41497 | - stack[base + 22LLU] = 3502LLU/*throw to this address*/; | |
41571 | + stack[base + 22LLU] = 3511LLU/*throw to this address*/; | |
41498 | 41572 | stack[base + 23LLU] = base; |
41499 | - stack[base + 24LLU] = 3503LLU; | |
41573 | + stack[base + 24LLU] = 3512LLU; | |
41500 | 41574 | // arguments for call to ParseToken |
41501 | 41575 | stack[base + 27LLU] = stack[base + 19]/*lookahead*/; |
41502 | 41576 | // set stack-base & callee-address |
@@ -41504,14 +41578,14 @@ | ||
41504 | 41578 | label = 3LLU; // ParseToken |
41505 | 41579 | break; |
41506 | 41580 | } |
41507 | - case 3502LLU: // copy-back deleter (ParseToken to procblock) | |
41581 | + case 3511LLU: // copy-back deleter (ParseToken to procblock) | |
41508 | 41582 | { |
41509 | 41583 | // copy mutable arguments back from call to ParseToken |
41510 | 41584 | stack[base + 19]/*lookahead*/ = stack[base + 27LLU]; |
41511 | - label = 3496LLU; // continue to roll stack | |
41585 | + label = 3505LLU; // continue to roll stack | |
41512 | 41586 | break; |
41513 | 41587 | } |
41514 | - case 3503LLU: // return from ParseToken to procblock | |
41588 | + case 3512LLU: // return from ParseToken to procblock | |
41515 | 41589 | { |
41516 | 41590 | // copy mutable arguments back from call to ParseToken |
41517 | 41591 | stack[base + 19]/*lookahead*/ = stack[base + 27LLU]; |
@@ -41519,9 +41593,9 @@ | ||
41519 | 41593 | stack[base + 15] = stack[base + 25LLU]; |
41520 | 41594 | stack[base + 16] = stack[base + 26LLU]; |
41521 | 41595 | // call neq from procblock |
41522 | - stack[base + 22LLU] = 3504LLU/*throw to this address*/; | |
41596 | + stack[base + 22LLU] = 3513LLU/*throw to this address*/; | |
41523 | 41597 | stack[base + 23LLU] = base; |
41524 | - stack[base + 24LLU] = 3505LLU; | |
41598 | + stack[base + 24LLU] = 3514LLU; | |
41525 | 41599 | // arguments for call to neq |
41526 | 41600 | stack[base + 26LLU] = stack[base + 16]/*content*/; |
41527 | 41601 | stack[base + 27LLU] = 657807020572803072LLU; |
@@ -41530,13 +41604,13 @@ | ||
41530 | 41604 | label = 18446744073709551599LLU; // neq |
41531 | 41605 | break; |
41532 | 41606 | } |
41533 | - case 3504LLU: // copy-back deleter (neq to procblock) | |
41607 | + case 3513LLU: // copy-back deleter (neq to procblock) | |
41534 | 41608 | { |
41535 | 41609 | // copy mutable arguments back from call to neq |
41536 | - label = 3496LLU; // continue to roll stack | |
41610 | + label = 3505LLU; // continue to roll stack | |
41537 | 41611 | break; |
41538 | 41612 | } |
41539 | - case 3505LLU: // return from neq to procblock | |
41613 | + case 3514LLU: // return from neq to procblock | |
41540 | 41614 | { |
41541 | 41615 | // copy mutable arguments back from call to neq |
41542 | 41616 | // copy back results provided by call to neq |
@@ -41543,15 +41617,15 @@ | ||
41543 | 41617 | stack[base + 20] = stack[base + 25LLU]; |
41544 | 41618 | if(!stack[base + 20]/*isequal*/) |
41545 | 41619 | { |
41546 | - label = 3506LLU; // jump to alternative | |
41620 | + label = 3515LLU; // jump to alternative | |
41547 | 41621 | break; |
41548 | 41622 | } |
41549 | 41623 | |
41550 | 41624 | // consequent |
41551 | 41625 | // call neq from procblock |
41552 | - stack[base + 22LLU] = 3508LLU/*throw to this address*/; | |
41626 | + stack[base + 22LLU] = 3517LLU/*throw to this address*/; | |
41553 | 41627 | stack[base + 23LLU] = base; |
41554 | - stack[base + 24LLU] = 3509LLU; | |
41628 | + stack[base + 24LLU] = 3518LLU; | |
41555 | 41629 | // arguments for call to neq |
41556 | 41630 | stack[base + 26LLU] = stack[base + 16]/*content*/; |
41557 | 41631 | stack[base + 27LLU] = 842897672560967680LLU; |
@@ -41560,13 +41634,13 @@ | ||
41560 | 41634 | label = 18446744073709551599LLU; // neq |
41561 | 41635 | break; |
41562 | 41636 | } |
41563 | - case 3508LLU: // copy-back deleter (neq to procblock) | |
41637 | + case 3517LLU: // copy-back deleter (neq to procblock) | |
41564 | 41638 | { |
41565 | 41639 | // copy mutable arguments back from call to neq |
41566 | - label = 3496LLU; // continue to roll stack | |
41640 | + label = 3505LLU; // continue to roll stack | |
41567 | 41641 | break; |
41568 | 41642 | } |
41569 | - case 3509LLU: // return from neq to procblock | |
41643 | + case 3518LLU: // return from neq to procblock | |
41570 | 41644 | { |
41571 | 41645 | // copy mutable arguments back from call to neq |
41572 | 41646 | // copy back results provided by call to neq |
@@ -41573,15 +41647,15 @@ | ||
41573 | 41647 | stack[base + 20] = stack[base + 25LLU]; |
41574 | 41648 | if(!stack[base + 20]/*isequal*/) |
41575 | 41649 | { |
41576 | - label = 3510LLU; // jump to alternative | |
41650 | + label = 3519LLU; // jump to alternative | |
41577 | 41651 | break; |
41578 | 41652 | } |
41579 | 41653 | |
41580 | 41654 | // consequent |
41581 | 41655 | // call neq from procblock |
41582 | - stack[base + 22LLU] = 3512LLU/*throw to this address*/; | |
41656 | + stack[base + 22LLU] = 3521LLU/*throw to this address*/; | |
41583 | 41657 | stack[base + 23LLU] = base; |
41584 | - stack[base + 24LLU] = 3513LLU; | |
41658 | + stack[base + 24LLU] = 3522LLU; | |
41585 | 41659 | // arguments for call to neq |
41586 | 41660 | stack[base + 26LLU] = stack[base + 16]/*content*/; |
41587 | 41661 | stack[base + 27LLU] = 859571802316210176LLU; |
@@ -41590,59 +41664,59 @@ | ||
41590 | 41664 | label = 18446744073709551599LLU; // neq |
41591 | 41665 | break; |
41592 | 41666 | } |
41593 | - case 3512LLU: // copy-back deleter (neq to procblock) | |
41667 | + case 3521LLU: // copy-back deleter (neq to procblock) | |
41594 | 41668 | { |
41595 | 41669 | // copy mutable arguments back from call to neq |
41596 | - label = 3496LLU; // continue to roll stack | |
41670 | + label = 3505LLU; // continue to roll stack | |
41597 | 41671 | break; |
41598 | 41672 | } |
41599 | - case 3513LLU: // return from neq to procblock | |
41673 | + case 3522LLU: // return from neq to procblock | |
41600 | 41674 | { |
41601 | 41675 | // copy mutable arguments back from call to neq |
41602 | 41676 | // copy back results provided by call to neq |
41603 | 41677 | stack[base + 20] = stack[base + 25LLU]; |
41604 | - label = 3511LLU; // consequent complete | |
41678 | + label = 3520LLU; // consequent complete | |
41605 | 41679 | break; |
41606 | 41680 | } |
41607 | - case 3510LLU: // alternative | |
41681 | + case 3519LLU: // alternative | |
41608 | 41682 | { |
41609 | - label = 3511LLU; // alternative complete | |
41683 | + label = 3520LLU; // alternative complete | |
41610 | 41684 | break; |
41611 | 41685 | } |
41612 | - case 3511LLU: // completed if-then-else | |
41686 | + case 3520LLU: // completed if-then-else | |
41613 | 41687 | { |
41614 | - label = 3507LLU; // consequent complete | |
41688 | + label = 3516LLU; // consequent complete | |
41615 | 41689 | break; |
41616 | 41690 | } |
41617 | - case 3506LLU: // alternative | |
41691 | + case 3515LLU: // alternative | |
41618 | 41692 | { |
41619 | - label = 3507LLU; // alternative complete | |
41693 | + label = 3516LLU; // alternative complete | |
41620 | 41694 | break; |
41621 | 41695 | } |
41622 | - case 3507LLU: // completed if-then-else | |
41696 | + case 3516LLU: // completed if-then-else | |
41623 | 41697 | { |
41624 | - label = 3501LLU; // consequent complete | |
41698 | + label = 3510LLU; // consequent complete | |
41625 | 41699 | break; |
41626 | 41700 | } |
41627 | - case 3500LLU: // alternative | |
41701 | + case 3509LLU: // alternative | |
41628 | 41702 | { |
41629 | 41703 | stack[base + 20]/*isequal*/ = 0; |
41630 | - label = 3501LLU; // alternative complete | |
41704 | + label = 3510LLU; // alternative complete | |
41631 | 41705 | break; |
41632 | 41706 | } |
41633 | - case 3501LLU: // completed if-then-else | |
41707 | + case 3510LLU: // completed if-then-else | |
41634 | 41708 | { |
41635 | 41709 | if(!stack[base + 20]/*isequal*/) |
41636 | 41710 | { |
41637 | - label = 3514LLU; // jump to alternative | |
41711 | + label = 3523LLU; // jump to alternative | |
41638 | 41712 | break; |
41639 | 41713 | } |
41640 | 41714 | |
41641 | 41715 | // consequent |
41642 | 41716 | // call issimple from procblock |
41643 | - stack[base + 22LLU] = 3516LLU/*throw to this address*/; | |
41717 | + stack[base + 22LLU] = 3525LLU/*throw to this address*/; | |
41644 | 41718 | stack[base + 23LLU] = base; |
41645 | - stack[base + 24LLU] = 3517LLU; | |
41719 | + stack[base + 24LLU] = 3526LLU; | |
41646 | 41720 | // arguments for call to issimple |
41647 | 41721 | stack[base + 26LLU] = stack[base + 15]/*variant*/; |
41648 | 41722 | stack[base + 27LLU] = stack[base + 16]/*content*/; |
@@ -41652,13 +41726,13 @@ | ||
41652 | 41726 | label = 166LLU; // issimple |
41653 | 41727 | break; |
41654 | 41728 | } |
41655 | - case 3516LLU: // copy-back deleter (issimple to procblock) | |
41729 | + case 3525LLU: // copy-back deleter (issimple to procblock) | |
41656 | 41730 | { |
41657 | 41731 | // copy mutable arguments back from call to issimple |
41658 | - label = 3496LLU; // continue to roll stack | |
41732 | + label = 3505LLU; // continue to roll stack | |
41659 | 41733 | break; |
41660 | 41734 | } |
41661 | - case 3517LLU: // return from issimple to procblock | |
41735 | + case 3526LLU: // return from issimple to procblock | |
41662 | 41736 | { |
41663 | 41737 | // copy mutable arguments back from call to issimple |
41664 | 41738 | // copy back results provided by call to issimple |
@@ -41665,15 +41739,15 @@ | ||
41665 | 41739 | stack[base + 20] = stack[base + 25LLU]; |
41666 | 41740 | if(!stack[base + 20]/*isequal*/) |
41667 | 41741 | { |
41668 | - label = 3518LLU; // jump to alternative | |
41742 | + label = 3527LLU; // jump to alternative | |
41669 | 41743 | break; |
41670 | 41744 | } |
41671 | 41745 | |
41672 | 41746 | // consequent |
41673 | 41747 | // call verbatim from procblock |
41674 | - stack[base + 22LLU] = 3520LLU/*throw to this address*/; | |
41748 | + stack[base + 22LLU] = 3529LLU/*throw to this address*/; | |
41675 | 41749 | stack[base + 23LLU] = base; |
41676 | - stack[base + 24LLU] = 3521LLU; | |
41750 | + stack[base + 24LLU] = 3530LLU; | |
41677 | 41751 | // arguments for call to verbatim |
41678 | 41752 | stack[base + 25LLU] = stack[base + 2]/*scopes*/; |
41679 | 41753 | stack[base + 26LLU] = stack[base + 3]/*scope*/; |
@@ -41680,29 +41754,29 @@ | ||
41680 | 41754 | stack[base + 27LLU] = stack[base + 19]/*lookahead*/; |
41681 | 41755 | // set stack-base & callee-address |
41682 | 41756 | base += 25LLU; |
41683 | - label = 3245LLU; // verbatim | |
41757 | + label = 3254LLU; // verbatim | |
41684 | 41758 | break; |
41685 | 41759 | } |
41686 | - case 3520LLU: // copy-back deleter (verbatim to procblock) | |
41760 | + case 3529LLU: // copy-back deleter (verbatim to procblock) | |
41687 | 41761 | { |
41688 | 41762 | // copy mutable arguments back from call to verbatim |
41689 | 41763 | stack[base + 19]/*lookahead*/ = stack[base + 27LLU]; |
41690 | - label = 3496LLU; // continue to roll stack | |
41764 | + label = 3505LLU; // continue to roll stack | |
41691 | 41765 | break; |
41692 | 41766 | } |
41693 | - case 3521LLU: // return from verbatim to procblock | |
41767 | + case 3530LLU: // return from verbatim to procblock | |
41694 | 41768 | { |
41695 | 41769 | // copy mutable arguments back from call to verbatim |
41696 | 41770 | stack[base + 19]/*lookahead*/ = stack[base + 27LLU]; |
41697 | - label = 3519LLU; // consequent complete | |
41771 | + label = 3528LLU; // consequent complete | |
41698 | 41772 | break; |
41699 | 41773 | } |
41700 | - case 3518LLU: // alternative | |
41774 | + case 3527LLU: // alternative | |
41701 | 41775 | { |
41702 | 41776 | // call PROCRETURN from procblock |
41703 | - stack[base + 22LLU] = 3522LLU/*throw to this address*/; | |
41777 | + stack[base + 22LLU] = 3531LLU/*throw to this address*/; | |
41704 | 41778 | stack[base + 23LLU] = base; |
41705 | - stack[base + 24LLU] = 3523LLU; | |
41779 | + stack[base + 24LLU] = 3532LLU; | |
41706 | 41780 | // arguments for call to PROCRETURN |
41707 | 41781 | stack[base + 25LLU] = stack[base + 0]/*fndefs*/; |
41708 | 41782 | stack[base + 26LLU] = stack[base + 1]/*datadefs*/; |
@@ -41727,7 +41801,7 @@ | ||
41727 | 41801 | label = 2812LLU; // PROCRETURN |
41728 | 41802 | break; |
41729 | 41803 | } |
41730 | - case 3522LLU: // copy-back deleter (PROCRETURN to procblock) | |
41804 | + case 3531LLU: // copy-back deleter (PROCRETURN to procblock) | |
41731 | 41805 | { |
41732 | 41806 | // copy mutable arguments back from call to PROCRETURN |
41733 | 41807 | stack[base + 17]/*label*/ = stack[base + 42LLU]; |
@@ -41736,10 +41810,10 @@ | ||
41736 | 41810 | stack[base + 19]/*lookahead*/ = stack[base + 39LLU]; |
41737 | 41811 | stack[base + 12]/*fnmaxcount*/ = stack[base + 38LLU]; |
41738 | 41812 | stack[base + 3]/*scope*/ = stack[base + 28LLU]; |
41739 | - label = 3496LLU; // continue to roll stack | |
41813 | + label = 3505LLU; // continue to roll stack | |
41740 | 41814 | break; |
41741 | 41815 | } |
41742 | - case 3523LLU: // return from PROCRETURN to procblock | |
41816 | + case 3532LLU: // return from PROCRETURN to procblock | |
41743 | 41817 | { |
41744 | 41818 | // copy mutable arguments back from call to PROCRETURN |
41745 | 41819 | stack[base + 17]/*label*/ = stack[base + 42LLU]; |
@@ -41748,15 +41822,15 @@ | ||
41748 | 41822 | stack[base + 19]/*lookahead*/ = stack[base + 39LLU]; |
41749 | 41823 | stack[base + 12]/*fnmaxcount*/ = stack[base + 38LLU]; |
41750 | 41824 | stack[base + 3]/*scope*/ = stack[base + 28LLU]; |
41751 | - label = 3519LLU; // alternative complete | |
41825 | + label = 3528LLU; // alternative complete | |
41752 | 41826 | break; |
41753 | 41827 | } |
41754 | - case 3519LLU: // completed if-then-else | |
41828 | + case 3528LLU: // completed if-then-else | |
41755 | 41829 | { |
41756 | 41830 | // call MATCHPEEK from procblock |
41757 | - stack[base + 22LLU] = 3524LLU/*throw to this address*/; | |
41831 | + stack[base + 22LLU] = 3533LLU/*throw to this address*/; | |
41758 | 41832 | stack[base + 23LLU] = base; |
41759 | - stack[base + 24LLU] = 3525LLU; | |
41833 | + stack[base + 24LLU] = 3534LLU; | |
41760 | 41834 | // arguments for call to MATCHPEEK |
41761 | 41835 | stack[base + 25LLU] = stack[base + 8]/*fnid*/; |
41762 | 41836 | stack[base + 26LLU] = 125LLU; |
@@ -41766,21 +41840,21 @@ | ||
41766 | 41840 | label = 206LLU; // MATCHPEEK |
41767 | 41841 | break; |
41768 | 41842 | } |
41769 | - case 3524LLU: // copy-back deleter (MATCHPEEK to procblock) | |
41843 | + case 3533LLU: // copy-back deleter (MATCHPEEK to procblock) | |
41770 | 41844 | { |
41771 | 41845 | // copy mutable arguments back from call to MATCHPEEK |
41772 | 41846 | stack[base + 19]/*lookahead*/ = stack[base + 27LLU]; |
41773 | - label = 3496LLU; // continue to roll stack | |
41847 | + label = 3505LLU; // continue to roll stack | |
41774 | 41848 | break; |
41775 | 41849 | } |
41776 | - case 3525LLU: // return from MATCHPEEK to procblock | |
41850 | + case 3534LLU: // return from MATCHPEEK to procblock | |
41777 | 41851 | { |
41778 | 41852 | // copy mutable arguments back from call to MATCHPEEK |
41779 | 41853 | stack[base + 19]/*lookahead*/ = stack[base + 27LLU]; |
41780 | 41854 | // call EOSbyte from procblock |
41781 | - stack[base + 22LLU] = 3526LLU/*throw to this address*/; | |
41855 | + stack[base + 22LLU] = 3535LLU/*throw to this address*/; | |
41782 | 41856 | stack[base + 23LLU] = base; |
41783 | - stack[base + 24LLU] = 3527LLU; | |
41857 | + stack[base + 24LLU] = 3536LLU; | |
41784 | 41858 | // arguments for call to EOSbyte |
41785 | 41859 | // set stack-base & callee-address |
41786 | 41860 | base += 25LLU; |
@@ -41787,42 +41861,42 @@ | ||
41787 | 41861 | label = 77LLU; // EOSbyte |
41788 | 41862 | break; |
41789 | 41863 | } |
41790 | - case 3526LLU: // copy-back deleter (EOSbyte to procblock) | |
41864 | + case 3535LLU: // copy-back deleter (EOSbyte to procblock) | |
41791 | 41865 | { |
41792 | 41866 | // copy mutable arguments back from call to EOSbyte |
41793 | - label = 3496LLU; // continue to roll stack | |
41867 | + label = 3505LLU; // continue to roll stack | |
41794 | 41868 | break; |
41795 | 41869 | } |
41796 | - case 3527LLU: // return from EOSbyte to procblock | |
41870 | + case 3536LLU: // return from EOSbyte to procblock | |
41797 | 41871 | { |
41798 | 41872 | // copy mutable arguments back from call to EOSbyte |
41799 | 41873 | // copy back results provided by call to EOSbyte |
41800 | 41874 | stack[base + 19] = stack[base + 25LLU]; |
41801 | - label = 3515LLU; // consequent complete | |
41875 | + label = 3524LLU; // consequent complete | |
41802 | 41876 | break; |
41803 | 41877 | } |
41804 | - case 3514LLU: // alternative | |
41878 | + case 3523LLU: // alternative | |
41805 | 41879 | { |
41806 | - label = 3529LLU; // skip deleter | |
41880 | + label = 3538LLU; // skip deleter | |
41807 | 41881 | break; |
41808 | 41882 | } |
41809 | - case 3528LLU: // deleter | |
41883 | + case 3537LLU: // deleter | |
41810 | 41884 | { |
41811 | 41885 | // throw from procblock |
41812 | 41886 | if(!stack[base + 22]) |
41813 | 41887 | { |
41814 | - label = 3496LLU; // skip, variable already deleted/unscoped | |
41888 | + label = 3505LLU; // skip, variable already deleted/unscoped | |
41815 | 41889 | break; |
41816 | 41890 | } |
41817 | - label = 3496LLU; // continue unrolling stack, delete next variable | |
41891 | + label = 3505LLU; // continue unrolling stack, delete next variable | |
41818 | 41892 | break; |
41819 | 41893 | } |
41820 | - case 3529LLU: // skipped deleter | |
41894 | + case 3538LLU: // skipped deleter | |
41821 | 41895 | { |
41822 | 41896 | // call equ from procblock |
41823 | - stack[base + 23LLU] = 3530LLU/*throw to this address*/; | |
41897 | + stack[base + 23LLU] = 3539LLU/*throw to this address*/; | |
41824 | 41898 | stack[base + 24LLU] = base; |
41825 | - stack[base + 25LLU] = 3531LLU; | |
41899 | + stack[base + 25LLU] = 3540LLU; | |
41826 | 41900 | // arguments for call to equ |
41827 | 41901 | stack[base + 27LLU] = stack[base + 16]/*content*/; |
41828 | 41902 | stack[base + 28LLU] = 910715104645873664LLU; |
@@ -41831,13 +41905,13 @@ | ||
41831 | 41905 | label = 18446744073709551600LLU; // equ |
41832 | 41906 | break; |
41833 | 41907 | } |
41834 | - case 3530LLU: // copy-back deleter (equ to procblock) | |
41908 | + case 3539LLU: // copy-back deleter (equ to procblock) | |
41835 | 41909 | { |
41836 | 41910 | // copy mutable arguments back from call to equ |
41837 | - label = 3496LLU; // continue to roll stack | |
41911 | + label = 3505LLU; // continue to roll stack | |
41838 | 41912 | break; |
41839 | 41913 | } |
41840 | - case 3531LLU: // return from equ to procblock | |
41914 | + case 3540LLU: // return from equ to procblock | |
41841 | 41915 | { |
41842 | 41916 | // copy mutable arguments back from call to equ |
41843 | 41917 | // copy back results provided by call to equ |
@@ -41844,21 +41918,21 @@ | ||
41844 | 41918 | stack[base + 22] = stack[base + 26LLU]; |
41845 | 41919 | if(!stack[base + 22]/*when*/) |
41846 | 41920 | { |
41847 | - label = 3532LLU; // jump to alternative | |
41921 | + label = 3541LLU; // jump to alternative | |
41848 | 41922 | break; |
41849 | 41923 | } |
41850 | 41924 | |
41851 | 41925 | // consequent |
41852 | 41926 | stack[base + 20]/*isequal*/ = 1; |
41853 | - label = 3533LLU; // consequent complete | |
41927 | + label = 3542LLU; // consequent complete | |
41854 | 41928 | break; |
41855 | 41929 | } |
41856 | - case 3532LLU: // alternative | |
41930 | + case 3541LLU: // alternative | |
41857 | 41931 | { |
41858 | 41932 | // call equ from procblock |
41859 | - stack[base + 23LLU] = 3534LLU/*throw to this address*/; | |
41933 | + stack[base + 23LLU] = 3543LLU/*throw to this address*/; | |
41860 | 41934 | stack[base + 24LLU] = base; |
41861 | - stack[base + 25LLU] = 3535LLU; | |
41935 | + stack[base + 25LLU] = 3544LLU; | |
41862 | 41936 | // arguments for call to equ |
41863 | 41937 | stack[base + 27LLU] = stack[base + 16]/*content*/; |
41864 | 41938 | stack[base + 28LLU] = 657807020572803072LLU; |
@@ -41867,33 +41941,33 @@ | ||
41867 | 41941 | label = 18446744073709551600LLU; // equ |
41868 | 41942 | break; |
41869 | 41943 | } |
41870 | - case 3534LLU: // copy-back deleter (equ to procblock) | |
41944 | + case 3543LLU: // copy-back deleter (equ to procblock) | |
41871 | 41945 | { |
41872 | 41946 | // copy mutable arguments back from call to equ |
41873 | - label = 3528LLU; // continue to roll stack | |
41947 | + label = 3537LLU; // continue to roll stack | |
41874 | 41948 | break; |
41875 | 41949 | } |
41876 | - case 3535LLU: // return from equ to procblock | |
41950 | + case 3544LLU: // return from equ to procblock | |
41877 | 41951 | { |
41878 | 41952 | // copy mutable arguments back from call to equ |
41879 | 41953 | // copy back results provided by call to equ |
41880 | 41954 | stack[base + 20] = stack[base + 26LLU]; |
41881 | - label = 3533LLU; // alternative complete | |
41955 | + label = 3542LLU; // alternative complete | |
41882 | 41956 | break; |
41883 | 41957 | } |
41884 | - case 3533LLU: // completed if-then-else | |
41958 | + case 3542LLU: // completed if-then-else | |
41885 | 41959 | { |
41886 | 41960 | if(!stack[base + 20]/*isequal*/) |
41887 | 41961 | { |
41888 | - label = 3536LLU; // jump to alternative | |
41962 | + label = 3545LLU; // jump to alternative | |
41889 | 41963 | break; |
41890 | 41964 | } |
41891 | 41965 | |
41892 | 41966 | // consequent |
41893 | 41967 | // call add from procblock |
41894 | - stack[base + 23LLU] = 3538LLU/*throw to this address*/; | |
41968 | + stack[base + 23LLU] = 3547LLU/*throw to this address*/; | |
41895 | 41969 | stack[base + 24LLU] = base; |
41896 | - stack[base + 25LLU] = 3539LLU; | |
41970 | + stack[base + 25LLU] = 3548LLU; | |
41897 | 41971 | // arguments for call to add |
41898 | 41972 | stack[base + 27LLU] = 1LLU; |
41899 | 41973 | stack[base + 28LLU] = stack[base + 17]/*label*/; |
@@ -41902,38 +41976,38 @@ | ||
41902 | 41976 | label = 18446744073709551605LLU; // add |
41903 | 41977 | break; |
41904 | 41978 | } |
41905 | - case 3538LLU: // copy-back deleter (add to procblock) | |
41979 | + case 3547LLU: // copy-back deleter (add to procblock) | |
41906 | 41980 | { |
41907 | 41981 | // copy mutable arguments back from call to add |
41908 | - label = 3528LLU; // continue to roll stack | |
41982 | + label = 3537LLU; // continue to roll stack | |
41909 | 41983 | break; |
41910 | 41984 | } |
41911 | - case 3539LLU: // return from add to procblock | |
41985 | + case 3548LLU: // return from add to procblock | |
41912 | 41986 | { |
41913 | 41987 | // copy mutable arguments back from call to add |
41914 | 41988 | // copy back results provided by call to add |
41915 | 41989 | stack[base + 17] = stack[base + 26LLU]; |
41916 | - label = 3541LLU; // skip deleter | |
41990 | + label = 3550LLU; // skip deleter | |
41917 | 41991 | break; |
41918 | 41992 | } |
41919 | - case 3540LLU: // deleter | |
41993 | + case 3549LLU: // deleter | |
41920 | 41994 | { |
41921 | 41995 | // throw from procblock |
41922 | 41996 | if(!stack[base + 23]) |
41923 | 41997 | { |
41924 | - label = 3528LLU; // skip, variable already deleted/unscoped | |
41998 | + label = 3537LLU; // skip, variable already deleted/unscoped | |
41925 | 41999 | break; |
41926 | 42000 | } |
41927 | - label = 3528LLU; // continue unrolling stack, delete next variable | |
42001 | + label = 3537LLU; // continue unrolling stack, delete next variable | |
41928 | 42002 | break; |
41929 | 42003 | } |
41930 | - case 3541LLU: // skipped deleter | |
42004 | + case 3550LLU: // skipped deleter | |
41931 | 42005 | { |
41932 | 42006 | stack[base + 23] = stack[base + 17]/*label*/; |
41933 | 42007 | // call add from procblock |
41934 | - stack[base + 24LLU] = 3542LLU/*throw to this address*/; | |
42008 | + stack[base + 24LLU] = 3551LLU/*throw to this address*/; | |
41935 | 42009 | stack[base + 25LLU] = base; |
41936 | - stack[base + 26LLU] = 3543LLU; | |
42010 | + stack[base + 26LLU] = 3552LLU; | |
41937 | 42011 | // arguments for call to add |
41938 | 42012 | stack[base + 28LLU] = 1LLU; |
41939 | 42013 | stack[base + 29LLU] = stack[base + 17]/*label*/; |
@@ -41942,38 +42016,38 @@ | ||
41942 | 42016 | label = 18446744073709551605LLU; // add |
41943 | 42017 | break; |
41944 | 42018 | } |
41945 | - case 3542LLU: // copy-back deleter (add to procblock) | |
42019 | + case 3551LLU: // copy-back deleter (add to procblock) | |
41946 | 42020 | { |
41947 | 42021 | // copy mutable arguments back from call to add |
41948 | - label = 3540LLU; // continue to roll stack | |
42022 | + label = 3549LLU; // continue to roll stack | |
41949 | 42023 | break; |
41950 | 42024 | } |
41951 | - case 3543LLU: // return from add to procblock | |
42025 | + case 3552LLU: // return from add to procblock | |
41952 | 42026 | { |
41953 | 42027 | // copy mutable arguments back from call to add |
41954 | 42028 | // copy back results provided by call to add |
41955 | 42029 | stack[base + 17] = stack[base + 27LLU]; |
41956 | - label = 3545LLU; // skip deleter | |
42030 | + label = 3554LLU; // skip deleter | |
41957 | 42031 | break; |
41958 | 42032 | } |
41959 | - case 3544LLU: // deleter | |
42033 | + case 3553LLU: // deleter | |
41960 | 42034 | { |
41961 | 42035 | // throw from procblock |
41962 | 42036 | if(!stack[base + 24]) |
41963 | 42037 | { |
41964 | - label = 3540LLU; // skip, variable already deleted/unscoped | |
42038 | + label = 3549LLU; // skip, variable already deleted/unscoped | |
41965 | 42039 | break; |
41966 | 42040 | } |
41967 | - label = 3540LLU; // continue unrolling stack, delete next variable | |
42041 | + label = 3549LLU; // continue unrolling stack, delete next variable | |
41968 | 42042 | break; |
41969 | 42043 | } |
41970 | - case 3545LLU: // skipped deleter | |
42044 | + case 3554LLU: // skipped deleter | |
41971 | 42045 | { |
41972 | 42046 | stack[base + 24] = stack[base + 17]/*label*/; |
41973 | 42047 | // call ParseToken from procblock |
41974 | - stack[base + 25LLU] = 3546LLU/*throw to this address*/; | |
42048 | + stack[base + 25LLU] = 3555LLU/*throw to this address*/; | |
41975 | 42049 | stack[base + 26LLU] = base; |
41976 | - stack[base + 27LLU] = 3547LLU; | |
42050 | + stack[base + 27LLU] = 3556LLU; | |
41977 | 42051 | // arguments for call to ParseToken |
41978 | 42052 | stack[base + 30LLU] = stack[base + 19]/*lookahead*/; |
41979 | 42053 | // set stack-base & callee-address |
@@ -41981,14 +42055,14 @@ | ||
41981 | 42055 | label = 3LLU; // ParseToken |
41982 | 42056 | break; |
41983 | 42057 | } |
41984 | - case 3546LLU: // copy-back deleter (ParseToken to procblock) | |
42058 | + case 3555LLU: // copy-back deleter (ParseToken to procblock) | |
41985 | 42059 | { |
41986 | 42060 | // copy mutable arguments back from call to ParseToken |
41987 | 42061 | stack[base + 19]/*lookahead*/ = stack[base + 30LLU]; |
41988 | - label = 3544LLU; // continue to roll stack | |
42062 | + label = 3553LLU; // continue to roll stack | |
41989 | 42063 | break; |
41990 | 42064 | } |
41991 | - case 3547LLU: // return from ParseToken to procblock | |
42065 | + case 3556LLU: // return from ParseToken to procblock | |
41992 | 42066 | { |
41993 | 42067 | // copy mutable arguments back from call to ParseToken |
41994 | 42068 | stack[base + 19]/*lookahead*/ = stack[base + 30LLU]; |
@@ -41996,9 +42070,9 @@ | ||
41996 | 42070 | stack[base + 15] = stack[base + 28LLU]; |
41997 | 42071 | stack[base + 16] = stack[base + 29LLU]; |
41998 | 42072 | // call issimple from procblock |
41999 | - stack[base + 25LLU] = 3548LLU/*throw to this address*/; | |
42073 | + stack[base + 25LLU] = 3557LLU/*throw to this address*/; | |
42000 | 42074 | stack[base + 26LLU] = base; |
42001 | - stack[base + 27LLU] = 3549LLU; | |
42075 | + stack[base + 27LLU] = 3558LLU; | |
42002 | 42076 | // arguments for call to issimple |
42003 | 42077 | stack[base + 29LLU] = stack[base + 15]/*variant*/; |
42004 | 42078 | stack[base + 30LLU] = stack[base + 16]/*content*/; |
@@ -42008,13 +42082,13 @@ | ||
42008 | 42082 | label = 166LLU; // issimple |
42009 | 42083 | break; |
42010 | 42084 | } |
42011 | - case 3548LLU: // copy-back deleter (issimple to procblock) | |
42085 | + case 3557LLU: // copy-back deleter (issimple to procblock) | |
42012 | 42086 | { |
42013 | 42087 | // copy mutable arguments back from call to issimple |
42014 | - label = 3544LLU; // continue to roll stack | |
42088 | + label = 3553LLU; // continue to roll stack | |
42015 | 42089 | break; |
42016 | 42090 | } |
42017 | - case 3549LLU: // return from issimple to procblock | |
42091 | + case 3558LLU: // return from issimple to procblock | |
42018 | 42092 | { |
42019 | 42093 | // copy mutable arguments back from call to issimple |
42020 | 42094 | // copy back results provided by call to issimple |
@@ -42021,7 +42095,7 @@ | ||
42021 | 42095 | stack[base + 20] = stack[base + 28LLU]; |
42022 | 42096 | if(!stack[base + 20]/*isequal*/) |
42023 | 42097 | { |
42024 | - label = 3550LLU; // jump to alternative | |
42098 | + label = 3559LLU; // jump to alternative | |
42025 | 42099 | break; |
42026 | 42100 | } |
42027 | 42101 |
@@ -42028,9 +42102,9 @@ | ||
42028 | 42102 | // consequent |
42029 | 42103 | printf("%s", "\n if(!"); |
42030 | 42104 | // call ParseToken from procblock |
42031 | - stack[base + 25LLU] = 3552LLU/*throw to this address*/; | |
42105 | + stack[base + 25LLU] = 3561LLU/*throw to this address*/; | |
42032 | 42106 | stack[base + 26LLU] = base; |
42033 | - stack[base + 27LLU] = 3553LLU; | |
42107 | + stack[base + 27LLU] = 3562LLU; | |
42034 | 42108 | // arguments for call to ParseToken |
42035 | 42109 | stack[base + 30LLU] = stack[base + 19]/*lookahead*/; |
42036 | 42110 | // set stack-base & callee-address |
@@ -42038,14 +42112,14 @@ | ||
42038 | 42112 | label = 3LLU; // ParseToken |
42039 | 42113 | break; |
42040 | 42114 | } |
42041 | - case 3552LLU: // copy-back deleter (ParseToken to procblock) | |
42115 | + case 3561LLU: // copy-back deleter (ParseToken to procblock) | |
42042 | 42116 | { |
42043 | 42117 | // copy mutable arguments back from call to ParseToken |
42044 | 42118 | stack[base + 19]/*lookahead*/ = stack[base + 30LLU]; |
42045 | - label = 3544LLU; // continue to roll stack | |
42119 | + label = 3553LLU; // continue to roll stack | |
42046 | 42120 | break; |
42047 | 42121 | } |
42048 | - case 3553LLU: // return from ParseToken to procblock | |
42122 | + case 3562LLU: // return from ParseToken to procblock | |
42049 | 42123 | { |
42050 | 42124 | // copy mutable arguments back from call to ParseToken |
42051 | 42125 | stack[base + 19]/*lookahead*/ = stack[base + 30LLU]; |
@@ -42053,9 +42127,9 @@ | ||
42053 | 42127 | stack[base + 15] = stack[base + 28LLU]; |
42054 | 42128 | stack[base + 16] = stack[base + 29LLU]; |
42055 | 42129 | // call equ from procblock |
42056 | - stack[base + 25LLU] = 3554LLU/*throw to this address*/; | |
42130 | + stack[base + 25LLU] = 3563LLU/*throw to this address*/; | |
42057 | 42131 | stack[base + 26LLU] = base; |
42058 | - stack[base + 27LLU] = 3555LLU; | |
42132 | + stack[base + 27LLU] = 3564LLU; | |
42059 | 42133 | // arguments for call to equ |
42060 | 42134 | stack[base + 29LLU] = stack[base + 15]/*variant*/; |
42061 | 42135 | stack[base + 30LLU] = 1LLU; |
@@ -42064,13 +42138,13 @@ | ||
42064 | 42138 | label = 18446744073709551600LLU; // equ |
42065 | 42139 | break; |
42066 | 42140 | } |
42067 | - case 3554LLU: // copy-back deleter (equ to procblock) | |
42141 | + case 3563LLU: // copy-back deleter (equ to procblock) | |
42068 | 42142 | { |
42069 | 42143 | // copy mutable arguments back from call to equ |
42070 | - label = 3544LLU; // continue to roll stack | |
42144 | + label = 3553LLU; // continue to roll stack | |
42071 | 42145 | break; |
42072 | 42146 | } |
42073 | - case 3555LLU: // return from equ to procblock | |
42147 | + case 3564LLU: // return from equ to procblock | |
42074 | 42148 | { |
42075 | 42149 | // copy mutable arguments back from call to equ |
42076 | 42150 | // copy back results provided by call to equ |
@@ -42077,15 +42151,15 @@ | ||
42077 | 42151 | stack[base + 20] = stack[base + 28LLU]; |
42078 | 42152 | if(!stack[base + 20]/*isequal*/) |
42079 | 42153 | { |
42080 | - label = 3556LLU; // jump to alternative | |
42154 | + label = 3565LLU; // jump to alternative | |
42081 | 42155 | break; |
42082 | 42156 | } |
42083 | 42157 | |
42084 | 42158 | // consequent |
42085 | 42159 | // call printnr from procblock |
42086 | - stack[base + 25LLU] = 3558LLU/*throw to this address*/; | |
42160 | + stack[base + 25LLU] = 3567LLU/*throw to this address*/; | |
42087 | 42161 | stack[base + 26LLU] = base; |
42088 | - stack[base + 27LLU] = 3559LLU; | |
42162 | + stack[base + 27LLU] = 3568LLU; | |
42089 | 42163 | // arguments for call to printnr |
42090 | 42164 | stack[base + 28LLU] = stack[base + 16]/*content*/; |
42091 | 42165 | // set stack-base & callee-address |
@@ -42093,24 +42167,24 @@ | ||
42093 | 42167 | label = 18446744073709551590LLU; // printnr |
42094 | 42168 | break; |
42095 | 42169 | } |
42096 | - case 3558LLU: // copy-back deleter (printnr to procblock) | |
42170 | + case 3567LLU: // copy-back deleter (printnr to procblock) | |
42097 | 42171 | { |
42098 | 42172 | // copy mutable arguments back from call to printnr |
42099 | - label = 3544LLU; // continue to roll stack | |
42173 | + label = 3553LLU; // continue to roll stack | |
42100 | 42174 | break; |
42101 | 42175 | } |
42102 | - case 3559LLU: // return from printnr to procblock | |
42176 | + case 3568LLU: // return from printnr to procblock | |
42103 | 42177 | { |
42104 | 42178 | // copy mutable arguments back from call to printnr |
42105 | - label = 3557LLU; // consequent complete | |
42179 | + label = 3566LLU; // consequent complete | |
42106 | 42180 | break; |
42107 | 42181 | } |
42108 | - case 3556LLU: // alternative | |
42182 | + case 3565LLU: // alternative | |
42109 | 42183 | { |
42110 | 42184 | // call equ from procblock |
42111 | - stack[base + 25LLU] = 3560LLU/*throw to this address*/; | |
42185 | + stack[base + 25LLU] = 3569LLU/*throw to this address*/; | |
42112 | 42186 | stack[base + 26LLU] = base; |
42113 | - stack[base + 27LLU] = 3561LLU; | |
42187 | + stack[base + 27LLU] = 3570LLU; | |
42114 | 42188 | // arguments for call to equ |
42115 | 42189 | stack[base + 29LLU] = stack[base + 15]/*variant*/; |
42116 | 42190 | stack[base + 30LLU] = 4LLU; |
@@ -42119,13 +42193,13 @@ | ||
42119 | 42193 | label = 18446744073709551600LLU; // equ |
42120 | 42194 | break; |
42121 | 42195 | } |
42122 | - case 3560LLU: // copy-back deleter (equ to procblock) | |
42196 | + case 3569LLU: // copy-back deleter (equ to procblock) | |
42123 | 42197 | { |
42124 | 42198 | // copy mutable arguments back from call to equ |
42125 | - label = 3544LLU; // continue to roll stack | |
42199 | + label = 3553LLU; // continue to roll stack | |
42126 | 42200 | break; |
42127 | 42201 | } |
42128 | - case 3561LLU: // return from equ to procblock | |
42202 | + case 3570LLU: // return from equ to procblock | |
42129 | 42203 | { |
42130 | 42204 | // copy mutable arguments back from call to equ |
42131 | 42205 | // copy back results provided by call to equ |
@@ -42132,15 +42206,15 @@ | ||
42132 | 42206 | stack[base + 20] = stack[base + 28LLU]; |
42133 | 42207 | if(!stack[base + 20]/*isequal*/) |
42134 | 42208 | { |
42135 | - label = 3562LLU; // jump to alternative | |
42209 | + label = 3571LLU; // jump to alternative | |
42136 | 42210 | break; |
42137 | 42211 | } |
42138 | 42212 | |
42139 | 42213 | // consequent |
42140 | 42214 | // call emitvar from procblock |
42141 | - stack[base + 25LLU] = 3564LLU/*throw to this address*/; | |
42215 | + stack[base + 25LLU] = 3573LLU/*throw to this address*/; | |
42142 | 42216 | stack[base + 26LLU] = base; |
42143 | - stack[base + 27LLU] = 3565LLU; | |
42217 | + stack[base + 27LLU] = 3574LLU; | |
42144 | 42218 | // arguments for call to emitvar |
42145 | 42219 | stack[base + 28LLU] = stack[base + 8]/*fnid*/; |
42146 | 42220 | stack[base + 29LLU] = stack[base + 16]/*content*/; |
@@ -42151,25 +42225,25 @@ | ||
42151 | 42225 | label = 749LLU; // emitvar |
42152 | 42226 | break; |
42153 | 42227 | } |
42154 | - case 3564LLU: // copy-back deleter (emitvar to procblock) | |
42228 | + case 3573LLU: // copy-back deleter (emitvar to procblock) | |
42155 | 42229 | { |
42156 | 42230 | // copy mutable arguments back from call to emitvar |
42157 | - label = 3544LLU; // continue to roll stack | |
42231 | + label = 3553LLU; // continue to roll stack | |
42158 | 42232 | break; |
42159 | 42233 | } |
42160 | - case 3565LLU: // return from emitvar to procblock | |
42234 | + case 3574LLU: // return from emitvar to procblock | |
42161 | 42235 | { |
42162 | 42236 | // copy mutable arguments back from call to emitvar |
42163 | - label = 3563LLU; // consequent complete | |
42237 | + label = 3572LLU; // consequent complete | |
42164 | 42238 | break; |
42165 | 42239 | } |
42166 | - case 3562LLU: // alternative | |
42240 | + case 3571LLU: // alternative | |
42167 | 42241 | { |
42168 | 42242 | fprintf(stderr, "%s", "expected identifier in if-then-else but found "); |
42169 | 42243 | // call reporttok from procblock |
42170 | - stack[base + 25LLU] = 3566LLU/*throw to this address*/; | |
42244 | + stack[base + 25LLU] = 3575LLU/*throw to this address*/; | |
42171 | 42245 | stack[base + 26LLU] = base; |
42172 | - stack[base + 27LLU] = 3567LLU; | |
42246 | + stack[base + 27LLU] = 3576LLU; | |
42173 | 42247 | // arguments for call to reporttok |
42174 | 42248 | stack[base + 28LLU] = stack[base + 15]/*variant*/; |
42175 | 42249 | stack[base + 29LLU] = stack[base + 16]/*content*/; |
@@ -42178,35 +42252,35 @@ | ||
42178 | 42252 | label = 18446744073709551582LLU; // reporttok |
42179 | 42253 | break; |
42180 | 42254 | } |
42181 | - case 3566LLU: // copy-back deleter (reporttok to procblock) | |
42255 | + case 3575LLU: // copy-back deleter (reporttok to procblock) | |
42182 | 42256 | { |
42183 | 42257 | // copy mutable arguments back from call to reporttok |
42184 | - label = 3544LLU; // continue to roll stack | |
42258 | + label = 3553LLU; // continue to roll stack | |
42185 | 42259 | break; |
42186 | 42260 | } |
42187 | - case 3567LLU: // return from reporttok to procblock | |
42261 | + case 3576LLU: // return from reporttok to procblock | |
42188 | 42262 | { |
42189 | 42263 | // copy mutable arguments back from call to reporttok |
42190 | 42264 | fprintf(stderr, "%s", "\n"); |
42191 | 42265 | { |
42192 | - label = 3544LLU; // throw: begin to unroll stack | |
42266 | + label = 3553LLU; // throw: begin to unroll stack | |
42193 | 42267 | break; |
42194 | 42268 | } |
42195 | 42269 | |
42196 | - label = 3563LLU; // alternative complete | |
42270 | + label = 3572LLU; // alternative complete | |
42197 | 42271 | break; |
42198 | 42272 | } |
42199 | - case 3563LLU: // completed if-then-else | |
42273 | + case 3572LLU: // completed if-then-else | |
42200 | 42274 | { |
42201 | - label = 3557LLU; // alternative complete | |
42275 | + label = 3566LLU; // alternative complete | |
42202 | 42276 | break; |
42203 | 42277 | } |
42204 | - case 3557LLU: // completed if-then-else | |
42278 | + case 3566LLU: // completed if-then-else | |
42205 | 42279 | { |
42206 | 42280 | // call matchsym from procblock |
42207 | - stack[base + 25LLU] = 3568LLU/*throw to this address*/; | |
42281 | + stack[base + 25LLU] = 3577LLU/*throw to this address*/; | |
42208 | 42282 | stack[base + 26LLU] = base; |
42209 | - stack[base + 27LLU] = 3569LLU; | |
42283 | + stack[base + 27LLU] = 3578LLU; | |
42210 | 42284 | // arguments for call to matchsym |
42211 | 42285 | stack[base + 28LLU] = stack[base + 8]/*fnid*/; |
42212 | 42286 | stack[base + 29LLU] = 41LLU; |
@@ -42216,14 +42290,14 @@ | ||
42216 | 42290 | label = 246LLU; // matchsym |
42217 | 42291 | break; |
42218 | 42292 | } |
42219 | - case 3568LLU: // copy-back deleter (matchsym to procblock) | |
42293 | + case 3577LLU: // copy-back deleter (matchsym to procblock) | |
42220 | 42294 | { |
42221 | 42295 | // copy mutable arguments back from call to matchsym |
42222 | 42296 | stack[base + 19]/*lookahead*/ = stack[base + 30LLU]; |
42223 | - label = 3544LLU; // continue to roll stack | |
42297 | + label = 3553LLU; // continue to roll stack | |
42224 | 42298 | break; |
42225 | 42299 | } |
42226 | - case 3569LLU: // return from matchsym to procblock | |
42300 | + case 3578LLU: // return from matchsym to procblock | |
42227 | 42301 | { |
42228 | 42302 | // copy mutable arguments back from call to matchsym |
42229 | 42303 | stack[base + 19]/*lookahead*/ = stack[base + 30LLU]; |
@@ -42231,9 +42305,9 @@ | ||
42231 | 42305 | printf("%s", "\n {"); |
42232 | 42306 | printf("%s", "\n label = "); |
42233 | 42307 | // call printnr from procblock |
42234 | - stack[base + 25LLU] = 3570LLU/*throw to this address*/; | |
42308 | + stack[base + 25LLU] = 3579LLU/*throw to this address*/; | |
42235 | 42309 | stack[base + 26LLU] = base; |
42236 | - stack[base + 27LLU] = 3571LLU; | |
42310 | + stack[base + 27LLU] = 3580LLU; | |
42237 | 42311 | // arguments for call to printnr |
42238 | 42312 | stack[base + 28LLU] = stack[base + 23]/*labelalt*/; |
42239 | 42313 | // set stack-base & callee-address |
@@ -42241,13 +42315,13 @@ | ||
42241 | 42315 | label = 18446744073709551590LLU; // printnr |
42242 | 42316 | break; |
42243 | 42317 | } |
42244 | - case 3570LLU: // copy-back deleter (printnr to procblock) | |
42318 | + case 3579LLU: // copy-back deleter (printnr to procblock) | |
42245 | 42319 | { |
42246 | 42320 | // copy mutable arguments back from call to printnr |
42247 | - label = 3544LLU; // continue to roll stack | |
42321 | + label = 3553LLU; // continue to roll stack | |
42248 | 42322 | break; |
42249 | 42323 | } |
42250 | - case 3571LLU: // return from printnr to procblock | |
42324 | + case 3580LLU: // return from printnr to procblock | |
42251 | 42325 | { |
42252 | 42326 | // copy mutable arguments back from call to printnr |
42253 | 42327 | printf("%s", "LLU; // jump to alternative"); |
@@ -42256,9 +42330,9 @@ | ||
42256 | 42330 | printf("%s", "\n"); |
42257 | 42331 | printf("%s", "\n // consequent"); |
42258 | 42332 | // call matchsym from procblock |
42259 | - stack[base + 25LLU] = 3572LLU/*throw to this address*/; | |
42333 | + stack[base + 25LLU] = 3581LLU/*throw to this address*/; | |
42260 | 42334 | stack[base + 26LLU] = base; |
42261 | - stack[base + 27LLU] = 3573LLU; | |
42335 | + stack[base + 27LLU] = 3582LLU; | |
42262 | 42336 | // arguments for call to matchsym |
42263 | 42337 | stack[base + 28LLU] = stack[base + 8]/*fnid*/; |
42264 | 42338 | stack[base + 29LLU] = 123LLU; |
@@ -42268,20 +42342,20 @@ | ||
42268 | 42342 | label = 246LLU; // matchsym |
42269 | 42343 | break; |
42270 | 42344 | } |
42271 | - case 3572LLU: // copy-back deleter (matchsym to procblock) | |
42345 | + case 3581LLU: // copy-back deleter (matchsym to procblock) | |
42272 | 42346 | { |
42273 | 42347 | // copy mutable arguments back from call to matchsym |
42274 | 42348 | stack[base + 19]/*lookahead*/ = stack[base + 30LLU]; |
42275 | - label = 3544LLU; // continue to roll stack | |
42349 | + label = 3553LLU; // continue to roll stack | |
42276 | 42350 | break; |
42277 | 42351 | } |
42278 | - case 3573LLU: // return from matchsym to procblock | |
42352 | + case 3582LLU: // return from matchsym to procblock | |
42279 | 42353 | { |
42280 | 42354 | // copy mutable arguments back from call to matchsym |
42281 | 42355 | stack[base + 19]/*lookahead*/ = stack[base + 30LLU]; |
42282 | 42356 | if(!stack[base + 21]/*returnflag*/) |
42283 | 42357 | { |
42284 | - label = 3574LLU; // jump to alternative | |
42358 | + label = 3583LLU; // jump to alternative | |
42285 | 42359 | break; |
42286 | 42360 | } |
42287 | 42361 |
@@ -42289,7 +42363,7 @@ | ||
42289 | 42363 | uint64_t *newstack = (uint64_t *)Calloc(160LLU + 1, sizeof(uint64_t)); |
42290 | 42364 | if(!newstack) |
42291 | 42365 | { |
42292 | - label = 3544LLU; // throw: begin to unroll stack | |
42366 | + label = 3553LLU; // throw: begin to unroll stack | |
42293 | 42367 | break; |
42294 | 42368 | } |
42295 | 42369 |
@@ -42296,9 +42370,9 @@ | ||
42296 | 42370 | newstack[160LLU] = 9876543210LLU; // overflow-marker |
42297 | 42371 | // call procblock from procblock |
42298 | 42372 | newstack[0] = (uint64_t)stack; // backup stack location |
42299 | - newstack[1] = 3576LLU; | |
42373 | + newstack[1] = 3585LLU; | |
42300 | 42374 | newstack[2] = base; |
42301 | - newstack[3] = 3577LLU; | |
42375 | + newstack[3] = 3586LLU; | |
42302 | 42376 | // arguments for call to procblock |
42303 | 42377 | newstack[4LLU] = stack[base + 0]/*fndefs*/; |
42304 | 42378 | newstack[5LLU] = stack[base + 1]/*datadefs*/; |
@@ -42321,10 +42395,10 @@ | ||
42321 | 42395 | stack = newstack; |
42322 | 42396 | // set stack-base & callee-address |
42323 | 42397 | base = 4/*deloffset*/; |
42324 | - label = 3429LLU; // procblock | |
42398 | + label = 3438LLU; // procblock | |
42325 | 42399 | break; |
42326 | 42400 | } |
42327 | - case 3576LLU: // copy-back deleter (procblock to procblock) | |
42401 | + case 3585LLU: // copy-back deleter (procblock to procblock) | |
42328 | 42402 | { |
42329 | 42403 | uint64_t *oldstack = (uint64_t *)stack[0]; |
42330 | 42404 | // copy mutable arguments back from call to procblock |
@@ -42341,10 +42415,10 @@ | ||
42341 | 42415 | } |
42342 | 42416 | Free(160LLU + 1, sizeof(uint64_t), stack); |
42343 | 42417 | stack = oldstack; |
42344 | - label = 3544LLU; // continue to unroll stack | |
42418 | + label = 3553LLU; // continue to unroll stack | |
42345 | 42419 | break; |
42346 | 42420 | } |
42347 | - case 3577LLU: // return from procblock to procblock | |
42421 | + case 3586LLU: // return from procblock to procblock | |
42348 | 42422 | { |
42349 | 42423 | uint64_t *oldstack = (uint64_t *)stack[0]; |
42350 | 42424 | // copy mutable arguments back from call to procblock |
@@ -42361,31 +42435,31 @@ | ||
42361 | 42435 | } |
42362 | 42436 | Free(160LLU + 1, sizeof(uint64_t), stack); |
42363 | 42437 | stack = oldstack; |
42364 | - label = 3575LLU; // consequent complete | |
42438 | + label = 3584LLU; // consequent complete | |
42365 | 42439 | break; |
42366 | 42440 | } |
42367 | - case 3574LLU: // alternative | |
42441 | + case 3583LLU: // alternative | |
42368 | 42442 | { |
42369 | - label = 3579LLU; // skip deleter | |
42443 | + label = 3588LLU; // skip deleter | |
42370 | 42444 | break; |
42371 | 42445 | } |
42372 | - case 3578LLU: // deleter | |
42446 | + case 3587LLU: // deleter | |
42373 | 42447 | { |
42374 | 42448 | // throw from procblock |
42375 | 42449 | if(!stack[base + 25]) |
42376 | 42450 | { |
42377 | - label = 3544LLU; // skip, variable already deleted/unscoped | |
42451 | + label = 3553LLU; // skip, variable already deleted/unscoped | |
42378 | 42452 | break; |
42379 | 42453 | } |
42380 | 42454 | // delete list |
42381 | - label = 3580LLU; // start to repeat | |
42455 | + label = 3589LLU; // start to repeat | |
42382 | 42456 | break; |
42383 | 42457 | } |
42384 | - case 3580LLU: // repeat from here | |
42458 | + case 3589LLU: // repeat from here | |
42385 | 42459 | { |
42386 | 42460 | if(!stack[base + 25]) |
42387 | 42461 | { |
42388 | - label = 3581LLU; // break loop | |
42462 | + label = 3590LLU; // break loop | |
42389 | 42463 | break; |
42390 | 42464 | } |
42391 | 42465 |
@@ -42396,7 +42470,7 @@ | ||
42396 | 42470 | newstack[0] = (uint64_t)stack; // backup stack location |
42397 | 42471 | newstack[1] = 1234567890; |
42398 | 42472 | newstack[2] = base; |
42399 | - newstack[3] = 3582LLU; | |
42473 | + newstack[3] = 3591LLU; | |
42400 | 42474 | stack = newstack; |
42401 | 42475 | // set stack-base & callee-address |
42402 | 42476 | base = 4/*deloffset*/; |
@@ -42403,7 +42477,7 @@ | ||
42403 | 42477 | label = 399LLU; // ~typeidx |
42404 | 42478 | break; |
42405 | 42479 | } |
42406 | - case 3582LLU: // return from ~typeidx to procblock | |
42480 | + case 3591LLU: // return from ~typeidx to procblock | |
42407 | 42481 | { |
42408 | 42482 | stack = (uint64_t *)stack[0]; |
42409 | 42483 | // releasing toplevel container |
@@ -42414,21 +42488,21 @@ | ||
42414 | 42488 | stack[base + 25] = (uint64_t)list->next; |
42415 | 42489 | Free(1, sizeof(struct listnode), list); |
42416 | 42490 | } |
42417 | - label = 3580LLU; // repeat | |
42491 | + label = 3589LLU; // repeat | |
42418 | 42492 | break; |
42419 | 42493 | } |
42420 | - case 3581LLU: // loop finished | |
42494 | + case 3590LLU: // loop finished | |
42421 | 42495 | { |
42422 | - label = 3544LLU; // continue unrolling stack, delete next variable | |
42496 | + label = 3553LLU; // continue unrolling stack, delete next variable | |
42423 | 42497 | break; |
42424 | 42498 | } |
42425 | - case 3579LLU: // skipped deleter | |
42499 | + case 3588LLU: // skipped deleter | |
42426 | 42500 | { |
42427 | 42501 | stack[base + 25] = 0; |
42428 | 42502 | uint64_t *newstack = (uint64_t *)Calloc(160LLU + 1, sizeof(uint64_t)); |
42429 | 42503 | if(!newstack) |
42430 | 42504 | { |
42431 | - label = 3578LLU; // throw: begin to unroll stack | |
42505 | + label = 3587LLU; // throw: begin to unroll stack | |
42432 | 42506 | break; |
42433 | 42507 | } |
42434 | 42508 |
@@ -42435,9 +42509,9 @@ | ||
42435 | 42509 | newstack[160LLU] = 9876543210LLU; // overflow-marker |
42436 | 42510 | // call procblock from procblock |
42437 | 42511 | newstack[0] = (uint64_t)stack; // backup stack location |
42438 | - newstack[1] = 3583LLU; | |
42512 | + newstack[1] = 3592LLU; | |
42439 | 42513 | newstack[2] = base; |
42440 | - newstack[3] = 3584LLU; | |
42514 | + newstack[3] = 3593LLU; | |
42441 | 42515 | // arguments for call to procblock |
42442 | 42516 | newstack[4LLU] = stack[base + 0]/*fndefs*/; |
42443 | 42517 | newstack[5LLU] = stack[base + 1]/*datadefs*/; |
@@ -42460,10 +42534,10 @@ | ||
42460 | 42534 | stack = newstack; |
42461 | 42535 | // set stack-base & callee-address |
42462 | 42536 | base = 4/*deloffset*/; |
42463 | - label = 3429LLU; // procblock | |
42537 | + label = 3438LLU; // procblock | |
42464 | 42538 | break; |
42465 | 42539 | } |
42466 | - case 3583LLU: // copy-back deleter (procblock to procblock) | |
42540 | + case 3592LLU: // copy-back deleter (procblock to procblock) | |
42467 | 42541 | { |
42468 | 42542 | uint64_t *oldstack = (uint64_t *)stack[0]; |
42469 | 42543 | // copy mutable arguments back from call to procblock |
@@ -42480,10 +42554,10 @@ | ||
42480 | 42554 | } |
42481 | 42555 | Free(160LLU + 1, sizeof(uint64_t), stack); |
42482 | 42556 | stack = oldstack; |
42483 | - label = 3578LLU; // continue to unroll stack | |
42557 | + label = 3587LLU; // continue to unroll stack | |
42484 | 42558 | break; |
42485 | 42559 | } |
42486 | - case 3584LLU: // return from procblock to procblock | |
42560 | + case 3593LLU: // return from procblock to procblock | |
42487 | 42561 | { |
42488 | 42562 | uint64_t *oldstack = (uint64_t *)stack[0]; |
42489 | 42563 | // copy mutable arguments back from call to procblock |
@@ -42501,14 +42575,14 @@ | ||
42501 | 42575 | Free(160LLU + 1, sizeof(uint64_t), stack); |
42502 | 42576 | stack = oldstack; |
42503 | 42577 | // delete list |
42504 | - label = 3585LLU; // start to repeat | |
42578 | + label = 3594LLU; // start to repeat | |
42505 | 42579 | break; |
42506 | 42580 | } |
42507 | - case 3585LLU: // repeat from here | |
42581 | + case 3594LLU: // repeat from here | |
42508 | 42582 | { |
42509 | 42583 | if(!stack[base + 25]) |
42510 | 42584 | { |
42511 | - label = 3586LLU; // break loop | |
42585 | + label = 3595LLU; // break loop | |
42512 | 42586 | break; |
42513 | 42587 | } |
42514 | 42588 |
@@ -42519,7 +42593,7 @@ | ||
42519 | 42593 | newstack[0] = (uint64_t)stack; // backup stack location |
42520 | 42594 | newstack[1] = 1234567890; |
42521 | 42595 | newstack[2] = base; |
42522 | - newstack[3] = 3587LLU; | |
42596 | + newstack[3] = 3596LLU; | |
42523 | 42597 | stack = newstack; |
42524 | 42598 | // set stack-base & callee-address |
42525 | 42599 | base = 4/*deloffset*/; |
@@ -42526,7 +42600,7 @@ | ||
42526 | 42600 | label = 399LLU; // ~typeidx |
42527 | 42601 | break; |
42528 | 42602 | } |
42529 | - case 3587LLU: // return from ~typeidx to procblock | |
42603 | + case 3596LLU: // return from ~typeidx to procblock | |
42530 | 42604 | { |
42531 | 42605 | stack = (uint64_t *)stack[0]; |
42532 | 42606 | // releasing toplevel container |
@@ -42537,21 +42611,21 @@ | ||
42537 | 42611 | stack[base + 25] = (uint64_t)list->next; |
42538 | 42612 | Free(1, sizeof(struct listnode), list); |
42539 | 42613 | } |
42540 | - label = 3585LLU; // repeat | |
42614 | + label = 3594LLU; // repeat | |
42541 | 42615 | break; |
42542 | 42616 | } |
42543 | - case 3586LLU: // loop finished | |
42617 | + case 3595LLU: // loop finished | |
42544 | 42618 | { |
42545 | - label = 3575LLU; // alternative complete | |
42619 | + label = 3584LLU; // alternative complete | |
42546 | 42620 | break; |
42547 | 42621 | } |
42548 | - case 3575LLU: // completed if-then-else | |
42622 | + case 3584LLU: // completed if-then-else | |
42549 | 42623 | { |
42550 | 42624 | printf("%s", "\n label = "); |
42551 | 42625 | // call printnr from procblock |
42552 | - stack[base + 25LLU] = 3588LLU/*throw to this address*/; | |
42626 | + stack[base + 25LLU] = 3597LLU/*throw to this address*/; | |
42553 | 42627 | stack[base + 26LLU] = base; |
42554 | - stack[base + 27LLU] = 3589LLU; | |
42628 | + stack[base + 27LLU] = 3598LLU; | |
42555 | 42629 | // arguments for call to printnr |
42556 | 42630 | stack[base + 28LLU] = stack[base + 24]/*labelskip*/; |
42557 | 42631 | // set stack-base & callee-address |
@@ -42559,13 +42633,13 @@ | ||
42559 | 42633 | label = 18446744073709551590LLU; // printnr |
42560 | 42634 | break; |
42561 | 42635 | } |
42562 | - case 3588LLU: // copy-back deleter (printnr to procblock) | |
42636 | + case 3597LLU: // copy-back deleter (printnr to procblock) | |
42563 | 42637 | { |
42564 | 42638 | // copy mutable arguments back from call to printnr |
42565 | - label = 3544LLU; // continue to roll stack | |
42639 | + label = 3553LLU; // continue to roll stack | |
42566 | 42640 | break; |
42567 | 42641 | } |
42568 | - case 3589LLU: // return from printnr to procblock | |
42642 | + case 3598LLU: // return from printnr to procblock | |
42569 | 42643 | { |
42570 | 42644 | // copy mutable arguments back from call to printnr |
42571 | 42645 | printf("%s", "LLU; // consequent complete"); |
@@ -42573,9 +42647,9 @@ | ||
42573 | 42647 | printf("%s", "\n }"); |
42574 | 42648 | printf("%s", "\n case "); |
42575 | 42649 | // call printnr from procblock |
42576 | - stack[base + 25LLU] = 3590LLU/*throw to this address*/; | |
42650 | + stack[base + 25LLU] = 3599LLU/*throw to this address*/; | |
42577 | 42651 | stack[base + 26LLU] = base; |
42578 | - stack[base + 27LLU] = 3591LLU; | |
42652 | + stack[base + 27LLU] = 3600LLU; | |
42579 | 42653 | // arguments for call to printnr |
42580 | 42654 | stack[base + 28LLU] = stack[base + 23]/*labelalt*/; |
42581 | 42655 | // set stack-base & callee-address |
@@ -42583,42 +42657,42 @@ | ||
42583 | 42657 | label = 18446744073709551590LLU; // printnr |
42584 | 42658 | break; |
42585 | 42659 | } |
42586 | - case 3590LLU: // copy-back deleter (printnr to procblock) | |
42660 | + case 3599LLU: // copy-back deleter (printnr to procblock) | |
42587 | 42661 | { |
42588 | 42662 | // copy mutable arguments back from call to printnr |
42589 | - label = 3544LLU; // continue to roll stack | |
42663 | + label = 3553LLU; // continue to roll stack | |
42590 | 42664 | break; |
42591 | 42665 | } |
42592 | - case 3591LLU: // return from printnr to procblock | |
42666 | + case 3600LLU: // return from printnr to procblock | |
42593 | 42667 | { |
42594 | 42668 | // copy mutable arguments back from call to printnr |
42595 | 42669 | printf("%s", "LLU: // alternative"); |
42596 | 42670 | printf("%s", "\n {"); |
42597 | - label = 3551LLU; // consequent complete | |
42671 | + label = 3560LLU; // consequent complete | |
42598 | 42672 | break; |
42599 | 42673 | } |
42600 | - case 3550LLU: // alternative | |
42674 | + case 3559LLU: // alternative | |
42601 | 42675 | { |
42602 | - label = 3593LLU; // skip deleter | |
42676 | + label = 3602LLU; // skip deleter | |
42603 | 42677 | break; |
42604 | 42678 | } |
42605 | - case 3592LLU: // deleter | |
42679 | + case 3601LLU: // deleter | |
42606 | 42680 | { |
42607 | 42681 | // throw from procblock |
42608 | 42682 | if(!stack[base + 25]) |
42609 | 42683 | { |
42610 | - label = 3544LLU; // skip, variable already deleted/unscoped | |
42684 | + label = 3553LLU; // skip, variable already deleted/unscoped | |
42611 | 42685 | break; |
42612 | 42686 | } |
42613 | - label = 3544LLU; // continue unrolling stack, delete next variable | |
42687 | + label = 3553LLU; // continue unrolling stack, delete next variable | |
42614 | 42688 | break; |
42615 | 42689 | } |
42616 | - case 3593LLU: // skipped deleter | |
42690 | + case 3602LLU: // skipped deleter | |
42617 | 42691 | { |
42618 | 42692 | // call equ from procblock |
42619 | - stack[base + 26LLU] = 3594LLU/*throw to this address*/; | |
42693 | + stack[base + 26LLU] = 3603LLU/*throw to this address*/; | |
42620 | 42694 | stack[base + 27LLU] = base; |
42621 | - stack[base + 28LLU] = 3595LLU; | |
42695 | + stack[base + 28LLU] = 3604LLU; | |
42622 | 42696 | // arguments for call to equ |
42623 | 42697 | stack[base + 30LLU] = stack[base + 16]/*content*/; |
42624 | 42698 | stack[base + 31LLU] = 747825068330975232LLU; |
@@ -42627,13 +42701,13 @@ | ||
42627 | 42701 | label = 18446744073709551600LLU; // equ |
42628 | 42702 | break; |
42629 | 42703 | } |
42630 | - case 3594LLU: // copy-back deleter (equ to procblock) | |
42704 | + case 3603LLU: // copy-back deleter (equ to procblock) | |
42631 | 42705 | { |
42632 | 42706 | // copy mutable arguments back from call to equ |
42633 | - label = 3544LLU; // continue to roll stack | |
42707 | + label = 3553LLU; // continue to roll stack | |
42634 | 42708 | break; |
42635 | 42709 | } |
42636 | - case 3595LLU: // return from equ to procblock | |
42710 | + case 3604LLU: // return from equ to procblock | |
42637 | 42711 | { |
42638 | 42712 | // copy mutable arguments back from call to equ |
42639 | 42713 | // copy back results provided by call to equ |
@@ -42640,37 +42714,37 @@ | ||
42640 | 42714 | stack[base + 20] = stack[base + 29LLU]; |
42641 | 42715 | if(!stack[base + 20]/*isequal*/) |
42642 | 42716 | { |
42643 | - label = 3596LLU; // jump to alternative | |
42717 | + label = 3605LLU; // jump to alternative | |
42644 | 42718 | break; |
42645 | 42719 | } |
42646 | 42720 | |
42647 | 42721 | // consequent |
42648 | - label = 3599LLU; // skip deleter | |
42722 | + label = 3608LLU; // skip deleter | |
42649 | 42723 | break; |
42650 | 42724 | } |
42651 | - case 3598LLU: // deleter | |
42725 | + case 3607LLU: // deleter | |
42652 | 42726 | { |
42653 | 42727 | // throw from procblock |
42654 | 42728 | if(!stack[base + 25]) |
42655 | 42729 | { |
42656 | - label = 3544LLU; // skip, variable already deleted/unscoped | |
42730 | + label = 3553LLU; // skip, variable already deleted/unscoped | |
42657 | 42731 | break; |
42658 | 42732 | } |
42659 | - label = 3544LLU; // continue unrolling stack, delete next variable | |
42733 | + label = 3553LLU; // continue unrolling stack, delete next variable | |
42660 | 42734 | break; |
42661 | 42735 | } |
42662 | - case 3599LLU: // skipped deleter | |
42736 | + case 3608LLU: // skipped deleter | |
42663 | 42737 | { |
42664 | 42738 | stack[base + 25] = 0; |
42665 | - label = 3597LLU; // consequent complete | |
42739 | + label = 3606LLU; // consequent complete | |
42666 | 42740 | break; |
42667 | 42741 | } |
42668 | - case 3596LLU: // alternative | |
42742 | + case 3605LLU: // alternative | |
42669 | 42743 | { |
42670 | 42744 | // call equ from procblock |
42671 | - stack[base + 26LLU] = 3600LLU/*throw to this address*/; | |
42745 | + stack[base + 26LLU] = 3609LLU/*throw to this address*/; | |
42672 | 42746 | stack[base + 27LLU] = base; |
42673 | - stack[base + 28LLU] = 3601LLU; | |
42747 | + stack[base + 28LLU] = 3610LLU; | |
42674 | 42748 | // arguments for call to equ |
42675 | 42749 | stack[base + 30LLU] = stack[base + 16]/*content*/; |
42676 | 42750 | stack[base + 31LLU] = 786630200929550336LLU; |
@@ -42679,13 +42753,13 @@ | ||
42679 | 42753 | label = 18446744073709551600LLU; // equ |
42680 | 42754 | break; |
42681 | 42755 | } |
42682 | - case 3600LLU: // copy-back deleter (equ to procblock) | |
42756 | + case 3609LLU: // copy-back deleter (equ to procblock) | |
42683 | 42757 | { |
42684 | 42758 | // copy mutable arguments back from call to equ |
42685 | - label = 3544LLU; // continue to roll stack | |
42759 | + label = 3553LLU; // continue to roll stack | |
42686 | 42760 | break; |
42687 | 42761 | } |
42688 | - case 3601LLU: // return from equ to procblock | |
42762 | + case 3610LLU: // return from equ to procblock | |
42689 | 42763 | { |
42690 | 42764 | // copy mutable arguments back from call to equ |
42691 | 42765 | // copy back results provided by call to equ |
@@ -42692,38 +42766,38 @@ | ||
42692 | 42766 | stack[base + 20] = stack[base + 29LLU]; |
42693 | 42767 | if(!stack[base + 20]/*isequal*/) |
42694 | 42768 | { |
42695 | - label = 3602LLU; // jump to alternative | |
42769 | + label = 3611LLU; // jump to alternative | |
42696 | 42770 | break; |
42697 | 42771 | } |
42698 | 42772 | |
42699 | 42773 | // consequent |
42700 | - label = 3605LLU; // skip deleter | |
42774 | + label = 3614LLU; // skip deleter | |
42701 | 42775 | break; |
42702 | 42776 | } |
42703 | - case 3604LLU: // deleter | |
42777 | + case 3613LLU: // deleter | |
42704 | 42778 | { |
42705 | 42779 | // throw from procblock |
42706 | 42780 | if(!stack[base + 25]) |
42707 | 42781 | { |
42708 | - label = 3544LLU; // skip, variable already deleted/unscoped | |
42782 | + label = 3553LLU; // skip, variable already deleted/unscoped | |
42709 | 42783 | break; |
42710 | 42784 | } |
42711 | - label = 3544LLU; // continue unrolling stack, delete next variable | |
42785 | + label = 3553LLU; // continue unrolling stack, delete next variable | |
42712 | 42786 | break; |
42713 | 42787 | } |
42714 | - case 3605LLU: // skipped deleter | |
42788 | + case 3614LLU: // skipped deleter | |
42715 | 42789 | { |
42716 | 42790 | stack[base + 25] = 1; |
42717 | - label = 3603LLU; // consequent complete | |
42791 | + label = 3612LLU; // consequent complete | |
42718 | 42792 | break; |
42719 | 42793 | } |
42720 | - case 3602LLU: // alternative | |
42794 | + case 3611LLU: // alternative | |
42721 | 42795 | { |
42722 | 42796 | fprintf(stderr, "%s", "expected '(' but found token "); |
42723 | 42797 | // call reporttok from procblock |
42724 | - stack[base + 26LLU] = 3606LLU/*throw to this address*/; | |
42798 | + stack[base + 26LLU] = 3615LLU/*throw to this address*/; | |
42725 | 42799 | stack[base + 27LLU] = base; |
42726 | - stack[base + 28LLU] = 3607LLU; | |
42800 | + stack[base + 28LLU] = 3616LLU; | |
42727 | 42801 | // arguments for call to reporttok |
42728 | 42802 | stack[base + 29LLU] = stack[base + 15]/*variant*/; |
42729 | 42803 | stack[base + 30LLU] = stack[base + 16]/*content*/; |
@@ -42732,83 +42806,83 @@ | ||
42732 | 42806 | label = 18446744073709551582LLU; // reporttok |
42733 | 42807 | break; |
42734 | 42808 | } |
42735 | - case 3606LLU: // copy-back deleter (reporttok to procblock) | |
42809 | + case 3615LLU: // copy-back deleter (reporttok to procblock) | |
42736 | 42810 | { |
42737 | 42811 | // copy mutable arguments back from call to reporttok |
42738 | - label = 3544LLU; // continue to roll stack | |
42812 | + label = 3553LLU; // continue to roll stack | |
42739 | 42813 | break; |
42740 | 42814 | } |
42741 | - case 3607LLU: // return from reporttok to procblock | |
42815 | + case 3616LLU: // return from reporttok to procblock | |
42742 | 42816 | { |
42743 | 42817 | // copy mutable arguments back from call to reporttok |
42744 | 42818 | fprintf(stderr, "%s", "\n"); |
42745 | 42819 | { |
42746 | - label = 3544LLU; // throw: begin to unroll stack | |
42820 | + label = 3553LLU; // throw: begin to unroll stack | |
42747 | 42821 | break; |
42748 | 42822 | } |
42749 | 42823 | |
42750 | - label = 3603LLU; // alternative complete | |
42824 | + label = 3612LLU; // alternative complete | |
42751 | 42825 | break; |
42752 | 42826 | } |
42753 | - case 3603LLU: // completed if-then-else | |
42827 | + case 3612LLU: // completed if-then-else | |
42754 | 42828 | { |
42755 | - label = 3597LLU; // alternative complete | |
42829 | + label = 3606LLU; // alternative complete | |
42756 | 42830 | break; |
42757 | 42831 | } |
42758 | - case 3597LLU: // completed if-then-else | |
42832 | + case 3606LLU: // completed if-then-else | |
42759 | 42833 | { |
42760 | - label = 3609LLU; // skip deleter | |
42834 | + label = 3618LLU; // skip deleter | |
42761 | 42835 | break; |
42762 | 42836 | } |
42763 | - case 3608LLU: // deleter | |
42837 | + case 3617LLU: // deleter | |
42764 | 42838 | { |
42765 | 42839 | // throw from procblock |
42766 | 42840 | if(!stack[base + 26]) |
42767 | 42841 | { |
42768 | - label = 3592LLU; // skip, variable already deleted/unscoped | |
42842 | + label = 3601LLU; // skip, variable already deleted/unscoped | |
42769 | 42843 | break; |
42770 | 42844 | } |
42771 | - label = 3592LLU; // continue unrolling stack, delete next variable | |
42845 | + label = 3601LLU; // continue unrolling stack, delete next variable | |
42772 | 42846 | break; |
42773 | 42847 | } |
42774 | - case 3609LLU: // skipped deleter | |
42848 | + case 3618LLU: // skipped deleter | |
42775 | 42849 | { |
42776 | - label = 3611LLU; // skip deleter | |
42850 | + label = 3620LLU; // skip deleter | |
42777 | 42851 | break; |
42778 | 42852 | } |
42779 | - case 3610LLU: // deleter | |
42853 | + case 3619LLU: // deleter | |
42780 | 42854 | { |
42781 | 42855 | // throw from procblock |
42782 | 42856 | if(!stack[base + 27]) |
42783 | 42857 | { |
42784 | - label = 3608LLU; // skip, variable already deleted/unscoped | |
42858 | + label = 3617LLU; // skip, variable already deleted/unscoped | |
42785 | 42859 | break; |
42786 | 42860 | } |
42787 | - label = 3608LLU; // continue unrolling stack, delete next variable | |
42861 | + label = 3617LLU; // continue unrolling stack, delete next variable | |
42788 | 42862 | break; |
42789 | 42863 | } |
42790 | - case 3611LLU: // skipped deleter | |
42864 | + case 3620LLU: // skipped deleter | |
42791 | 42865 | { |
42792 | 42866 | // call listtoelem from procblock |
42793 | - stack[base + 28LLU] = 3612LLU/*throw to this address*/; | |
42867 | + stack[base + 28LLU] = 3621LLU/*throw to this address*/; | |
42794 | 42868 | stack[base + 29LLU] = base; |
42795 | - stack[base + 30LLU] = 3613LLU; | |
42869 | + stack[base + 30LLU] = 3622LLU; | |
42796 | 42870 | // arguments for call to listtoelem |
42797 | 42871 | stack[base + 33LLU] = stack[base + 8]/*fnid*/; |
42798 | 42872 | stack[base + 34LLU] = stack[base + 19]/*lookahead*/; |
42799 | 42873 | // set stack-base & callee-address |
42800 | 42874 | base += 31LLU; |
42801 | - label = 3263LLU; // listtoelem | |
42875 | + label = 3272LLU; // listtoelem | |
42802 | 42876 | break; |
42803 | 42877 | } |
42804 | - case 3612LLU: // copy-back deleter (listtoelem to procblock) | |
42878 | + case 3621LLU: // copy-back deleter (listtoelem to procblock) | |
42805 | 42879 | { |
42806 | 42880 | // copy mutable arguments back from call to listtoelem |
42807 | 42881 | stack[base + 19]/*lookahead*/ = stack[base + 34LLU]; |
42808 | - label = 3592LLU; // continue to roll stack | |
42882 | + label = 3601LLU; // continue to roll stack | |
42809 | 42883 | break; |
42810 | 42884 | } |
42811 | - case 3613LLU: // return from listtoelem to procblock | |
42885 | + case 3622LLU: // return from listtoelem to procblock | |
42812 | 42886 | { |
42813 | 42887 | // copy mutable arguments back from call to listtoelem |
42814 | 42888 | stack[base + 19]/*lookahead*/ = stack[base + 34LLU]; |
@@ -42815,15 +42889,15 @@ | ||
42815 | 42889 | // copy back results provided by call to listtoelem |
42816 | 42890 | stack[base + 26] = stack[base + 31LLU]; |
42817 | 42891 | stack[base + 27] = stack[base + 32LLU]; |
42818 | - label = 3615LLU; // skip deleter | |
42892 | + label = 3624LLU; // skip deleter | |
42819 | 42893 | break; |
42820 | 42894 | } |
42821 | - case 3614LLU: // deleter | |
42895 | + case 3623LLU: // deleter | |
42822 | 42896 | { |
42823 | 42897 | // throw from procblock |
42824 | 42898 | if(!stack[base + 28]) |
42825 | 42899 | { |
42826 | - label = 3610LLU; // skip, variable already deleted/unscoped | |
42900 | + label = 3619LLU; // skip, variable already deleted/unscoped | |
42827 | 42901 | break; |
42828 | 42902 | } |
42829 | 42903 |
@@ -42832,7 +42906,7 @@ | ||
42832 | 42906 | newstack[0] = (uint64_t)stack; // backup stack location |
42833 | 42907 | newstack[1] = 1234567890; |
42834 | 42908 | newstack[2] = base; |
42835 | - newstack[3] = 3616LLU; | |
42909 | + newstack[3] = 3625LLU; | |
42836 | 42910 | stack = newstack; |
42837 | 42911 | // set stack-base & callee-address |
42838 | 42912 | base = 4/*deloffset*/; |
@@ -42839,21 +42913,21 @@ | ||
42839 | 42913 | label = 486LLU; // ~letdef |
42840 | 42914 | break; |
42841 | 42915 | } |
42842 | - case 3616LLU: // return from ~letdef to procblock | |
42916 | + case 3625LLU: // return from ~letdef to procblock | |
42843 | 42917 | { |
42844 | 42918 | stack = (uint64_t *)stack[0]; |
42845 | 42919 | // releasing toplevel container |
42846 | 42920 | Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 28] - sizeof(uint64_t) * 4)); |
42847 | 42921 | |
42848 | - label = 3610LLU; // continue unrolling stack, delete next variable | |
42922 | + label = 3619LLU; // continue unrolling stack, delete next variable | |
42849 | 42923 | break; |
42850 | 42924 | } |
42851 | - case 3615LLU: // skipped deleter | |
42925 | + case 3624LLU: // skipped deleter | |
42852 | 42926 | { |
42853 | 42927 | // call FindLet from procblock |
42854 | - stack[base + 29LLU] = 3617LLU/*throw to this address*/; | |
42928 | + stack[base + 29LLU] = 3626LLU/*throw to this address*/; | |
42855 | 42929 | stack[base + 30LLU] = base; |
42856 | - stack[base + 31LLU] = 3618LLU; | |
42930 | + stack[base + 31LLU] = 3627LLU; | |
42857 | 42931 | // arguments for call to FindLet |
42858 | 42932 | stack[base + 33LLU] = stack[base + 8]/*fnid*/; |
42859 | 42933 | stack[base + 34LLU] = stack[base + 26]/*listid*/; |
@@ -42864,13 +42938,13 @@ | ||
42864 | 42938 | label = 619LLU; // FindLet |
42865 | 42939 | break; |
42866 | 42940 | } |
42867 | - case 3617LLU: // copy-back deleter (FindLet to procblock) | |
42941 | + case 3626LLU: // copy-back deleter (FindLet to procblock) | |
42868 | 42942 | { |
42869 | 42943 | // copy mutable arguments back from call to FindLet |
42870 | - label = 3610LLU; // continue to roll stack | |
42944 | + label = 3619LLU; // continue to roll stack | |
42871 | 42945 | break; |
42872 | 42946 | } |
42873 | - case 3618LLU: // return from FindLet to procblock | |
42947 | + case 3627LLU: // return from FindLet to procblock | |
42874 | 42948 | { |
42875 | 42949 | // copy mutable arguments back from call to FindLet |
42876 | 42950 | // copy back results provided by call to FindLet |
@@ -42877,7 +42951,7 @@ | ||
42877 | 42951 | stack[base + 28] = stack[base + 32LLU]; |
42878 | 42952 | if(/*letdef*/0 != ((uint64_t *)(stack[base + 28]/*letdef*/))[0]) |
42879 | 42953 | { |
42880 | - label = 3620LLU; // jump to alternative | |
42954 | + label = 3629LLU; // jump to alternative | |
42881 | 42955 | break; |
42882 | 42956 | } |
42883 | 42957 |
@@ -42891,28 +42965,28 @@ | ||
42891 | 42965 | printf("%s", "\n { // if "); |
42892 | 42966 | if(!stack[base + 25]/*consume*/) |
42893 | 42967 | { |
42894 | - label = 3622LLU; // jump to alternative | |
42968 | + label = 3631LLU; // jump to alternative | |
42895 | 42969 | break; |
42896 | 42970 | } |
42897 | 42971 | |
42898 | 42972 | // consequent |
42899 | 42973 | printf("%s", "pop"); |
42900 | - label = 3623LLU; // consequent complete | |
42974 | + label = 3632LLU; // consequent complete | |
42901 | 42975 | break; |
42902 | 42976 | } |
42903 | - case 3622LLU: // alternative | |
42977 | + case 3631LLU: // alternative | |
42904 | 42978 | { |
42905 | 42979 | printf("%s", "next"); |
42906 | - label = 3623LLU; // alternative complete | |
42980 | + label = 3632LLU; // alternative complete | |
42907 | 42981 | break; |
42908 | 42982 | } |
42909 | - case 3623LLU: // completed if-then-else | |
42983 | + case 3632LLU: // completed if-then-else | |
42910 | 42984 | { |
42911 | 42985 | printf("%s", "\n struct listnode *list = (struct listnode *)"); |
42912 | 42986 | // call emitvaridx from procblock |
42913 | - stack[base + 34LLU] = 3624LLU/*throw to this address*/; | |
42987 | + stack[base + 34LLU] = 3633LLU/*throw to this address*/; | |
42914 | 42988 | stack[base + 35LLU] = base; |
42915 | - stack[base + 36LLU] = 3625LLU; | |
42989 | + stack[base + 36LLU] = 3634LLU; | |
42916 | 42990 | // arguments for call to emitvaridx |
42917 | 42991 | stack[base + 37LLU] = stack[base + 31]/*listindex*/; |
42918 | 42992 | // set stack-base & callee-address |
@@ -42920,20 +42994,20 @@ | ||
42920 | 42994 | label = 745LLU; // emitvaridx |
42921 | 42995 | break; |
42922 | 42996 | } |
42923 | - case 3624LLU: // copy-back deleter (emitvaridx to procblock) | |
42997 | + case 3633LLU: // copy-back deleter (emitvaridx to procblock) | |
42924 | 42998 | { |
42925 | 42999 | // copy mutable arguments back from call to emitvaridx |
42926 | - label = 3621LLU; // continue to roll stack | |
43000 | + label = 3630LLU; // continue to roll stack | |
42927 | 43001 | break; |
42928 | 43002 | } |
42929 | - case 3625LLU: // return from emitvaridx to procblock | |
43003 | + case 3634LLU: // return from emitvaridx to procblock | |
42930 | 43004 | { |
42931 | 43005 | // copy mutable arguments back from call to emitvaridx |
42932 | 43006 | printf("%s", "/*"); |
42933 | 43007 | // call printid from procblock |
42934 | - stack[base + 34LLU] = 3626LLU/*throw to this address*/; | |
43008 | + stack[base + 34LLU] = 3635LLU/*throw to this address*/; | |
42935 | 43009 | stack[base + 35LLU] = base; |
42936 | - stack[base + 36LLU] = 3627LLU; | |
43010 | + stack[base + 36LLU] = 3636LLU; | |
42937 | 43011 | // arguments for call to printid |
42938 | 43012 | stack[base + 37LLU] = stack[base + 30]/*listname*/; |
42939 | 43013 | // set stack-base & callee-address |
@@ -42941,26 +43015,26 @@ | ||
42941 | 43015 | label = 18446744073709551587LLU; // printid |
42942 | 43016 | break; |
42943 | 43017 | } |
42944 | - case 3626LLU: // copy-back deleter (printid to procblock) | |
43018 | + case 3635LLU: // copy-back deleter (printid to procblock) | |
42945 | 43019 | { |
42946 | 43020 | // copy mutable arguments back from call to printid |
42947 | - label = 3621LLU; // continue to roll stack | |
43021 | + label = 3630LLU; // continue to roll stack | |
42948 | 43022 | break; |
42949 | 43023 | } |
42950 | - case 3627LLU: // return from printid to procblock | |
43024 | + case 3636LLU: // return from printid to procblock | |
42951 | 43025 | { |
42952 | 43026 | // copy mutable arguments back from call to printid |
42953 | 43027 | printf("%s", "*/;"); |
42954 | 43028 | printf("%s", "\n if(!list)"); |
42955 | - label = 3629LLU; // skip deleter | |
43029 | + label = 3638LLU; // skip deleter | |
42956 | 43030 | break; |
42957 | 43031 | } |
42958 | - case 3628LLU: // deleter | |
43032 | + case 3637LLU: // deleter | |
42959 | 43033 | { |
42960 | 43034 | // throw from procblock |
42961 | 43035 | if(!stack[base + 34]) |
42962 | 43036 | { |
42963 | - label = 3621LLU; // skip, variable already deleted/unscoped | |
43037 | + label = 3630LLU; // skip, variable already deleted/unscoped | |
42964 | 43038 | break; |
42965 | 43039 | } |
42966 | 43040 |
@@ -42969,7 +43043,7 @@ | ||
42969 | 43043 | newstack[0] = (uint64_t)stack; // backup stack location |
42970 | 43044 | newstack[1] = 1234567890; |
42971 | 43045 | newstack[2] = base; |
42972 | - newstack[3] = 3630LLU; | |
43046 | + newstack[3] = 3639LLU; | |
42973 | 43047 | stack = newstack; |
42974 | 43048 | // set stack-base & callee-address |
42975 | 43049 | base = 4/*deloffset*/; |
@@ -42976,21 +43050,21 @@ | ||
42976 | 43050 | label = 562LLU; // ~scope |
42977 | 43051 | break; |
42978 | 43052 | } |
42979 | - case 3630LLU: // return from ~scope to procblock | |
43053 | + case 3639LLU: // return from ~scope to procblock | |
42980 | 43054 | { |
42981 | 43055 | stack = (uint64_t *)stack[0]; |
42982 | 43056 | // releasing toplevel container |
42983 | 43057 | Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 34] - sizeof(uint64_t) * 4)); |
42984 | 43058 | |
42985 | - label = 3621LLU; // continue unrolling stack, delete next variable | |
43059 | + label = 3630LLU; // continue unrolling stack, delete next variable | |
42986 | 43060 | break; |
42987 | 43061 | } |
42988 | - case 3629LLU: // skipped deleter | |
43062 | + case 3638LLU: // skipped deleter | |
42989 | 43063 | { |
42990 | 43064 | // call linkscope from procblock |
42991 | - stack[base + 35LLU] = 3631LLU/*throw to this address*/; | |
43065 | + stack[base + 35LLU] = 3640LLU/*throw to this address*/; | |
42992 | 43066 | stack[base + 36LLU] = base; |
42993 | - stack[base + 37LLU] = 3632LLU; | |
43067 | + stack[base + 37LLU] = 3641LLU; | |
42994 | 43068 | // arguments for call to linkscope |
42995 | 43069 | stack[base + 39LLU] = stack[base + 3]/*scope*/; |
42996 | 43070 | // set stack-base & callee-address |
@@ -42998,13 +43072,13 @@ | ||
42998 | 43072 | label = 589LLU; // linkscope |
42999 | 43073 | break; |
43000 | 43074 | } |
43001 | - case 3631LLU: // copy-back deleter (linkscope to procblock) | |
43075 | + case 3640LLU: // copy-back deleter (linkscope to procblock) | |
43002 | 43076 | { |
43003 | 43077 | // copy mutable arguments back from call to linkscope |
43004 | - label = 3621LLU; // continue to roll stack | |
43078 | + label = 3630LLU; // continue to roll stack | |
43005 | 43079 | break; |
43006 | 43080 | } |
43007 | - case 3632LLU: // return from linkscope to procblock | |
43081 | + case 3641LLU: // return from linkscope to procblock | |
43008 | 43082 | { |
43009 | 43083 | // copy mutable arguments back from call to linkscope |
43010 | 43084 | // copy back results provided by call to linkscope |
@@ -43023,26 +43097,26 @@ | ||
43023 | 43097 | /*scopes*/stack[base + 2] = (uint64_t)list; |
43024 | 43098 | MOVE(&list->data, &stack[base + 34]/*newscope*/); |
43025 | 43099 | } |
43026 | - label = 3634LLU; // skip deleter | |
43100 | + label = 3643LLU; // skip deleter | |
43027 | 43101 | break; |
43028 | 43102 | } |
43029 | - case 3633LLU: // deleter | |
43103 | + case 3642LLU: // deleter | |
43030 | 43104 | { |
43031 | 43105 | // throw from procblock |
43032 | 43106 | if(!stack[base + 34]) |
43033 | 43107 | { |
43034 | - label = 3621LLU; // skip, variable already deleted/unscoped | |
43108 | + label = 3630LLU; // skip, variable already deleted/unscoped | |
43035 | 43109 | break; |
43036 | 43110 | } |
43037 | - label = 3621LLU; // continue unrolling stack, delete next variable | |
43111 | + label = 3630LLU; // continue unrolling stack, delete next variable | |
43038 | 43112 | break; |
43039 | 43113 | } |
43040 | - case 3634LLU: // skipped deleter | |
43114 | + case 3643LLU: // skipped deleter | |
43041 | 43115 | { |
43042 | 43116 | // call getdeladdr from procblock |
43043 | - stack[base + 35LLU] = 3635LLU/*throw to this address*/; | |
43117 | + stack[base + 35LLU] = 3644LLU/*throw to this address*/; | |
43044 | 43118 | stack[base + 36LLU] = base; |
43045 | - stack[base + 37LLU] = 3636LLU; | |
43119 | + stack[base + 37LLU] = 3645LLU; | |
43046 | 43120 | // arguments for call to getdeladdr |
43047 | 43121 | stack[base + 39LLU] = stack[base + 3]/*scope*/; |
43048 | 43122 | // set stack-base & callee-address |
@@ -43050,21 +43124,21 @@ | ||
43050 | 43124 | label = 596LLU; // getdeladdr |
43051 | 43125 | break; |
43052 | 43126 | } |
43053 | - case 3635LLU: // copy-back deleter (getdeladdr to procblock) | |
43127 | + case 3644LLU: // copy-back deleter (getdeladdr to procblock) | |
43054 | 43128 | { |
43055 | 43129 | // copy mutable arguments back from call to getdeladdr |
43056 | - label = 3621LLU; // continue to roll stack | |
43130 | + label = 3630LLU; // continue to roll stack | |
43057 | 43131 | break; |
43058 | 43132 | } |
43059 | - case 3636LLU: // return from getdeladdr to procblock | |
43133 | + case 3645LLU: // return from getdeladdr to procblock | |
43060 | 43134 | { |
43061 | 43135 | // copy mutable arguments back from call to getdeladdr |
43062 | 43136 | // copy back results provided by call to getdeladdr |
43063 | 43137 | stack[base + 34] = stack[base + 38LLU]; |
43064 | 43138 | // call add from procblock |
43065 | - stack[base + 35LLU] = 3637LLU/*throw to this address*/; | |
43139 | + stack[base + 35LLU] = 3646LLU/*throw to this address*/; | |
43066 | 43140 | stack[base + 36LLU] = base; |
43067 | - stack[base + 37LLU] = 3638LLU; | |
43141 | + stack[base + 37LLU] = 3647LLU; | |
43068 | 43142 | // arguments for call to add |
43069 | 43143 | stack[base + 39LLU] = 1LLU; |
43070 | 43144 | stack[base + 40LLU] = stack[base + 17]/*label*/; |
@@ -43073,43 +43147,43 @@ | ||
43073 | 43147 | label = 18446744073709551605LLU; // add |
43074 | 43148 | break; |
43075 | 43149 | } |
43076 | - case 3637LLU: // copy-back deleter (add to procblock) | |
43150 | + case 3646LLU: // copy-back deleter (add to procblock) | |
43077 | 43151 | { |
43078 | 43152 | // copy mutable arguments back from call to add |
43079 | - label = 3633LLU; // continue to roll stack | |
43153 | + label = 3642LLU; // continue to roll stack | |
43080 | 43154 | break; |
43081 | 43155 | } |
43082 | - case 3638LLU: // return from add to procblock | |
43156 | + case 3647LLU: // return from add to procblock | |
43083 | 43157 | { |
43084 | 43158 | // copy mutable arguments back from call to add |
43085 | 43159 | // copy back results provided by call to add |
43086 | 43160 | stack[base + 17] = stack[base + 38LLU]; |
43087 | - label = 3640LLU; // skip deleter | |
43161 | + label = 3649LLU; // skip deleter | |
43088 | 43162 | break; |
43089 | 43163 | } |
43090 | - case 3639LLU: // deleter | |
43164 | + case 3648LLU: // deleter | |
43091 | 43165 | { |
43092 | 43166 | // throw from procblock |
43093 | 43167 | if(!stack[base + 35]) |
43094 | 43168 | { |
43095 | - label = 3633LLU; // skip, variable already deleted/unscoped | |
43169 | + label = 3642LLU; // skip, variable already deleted/unscoped | |
43096 | 43170 | break; |
43097 | 43171 | } |
43098 | - label = 3633LLU; // continue unrolling stack, delete next variable | |
43172 | + label = 3642LLU; // continue unrolling stack, delete next variable | |
43099 | 43173 | break; |
43100 | 43174 | } |
43101 | - case 3640LLU: // skipped deleter | |
43175 | + case 3649LLU: // skipped deleter | |
43102 | 43176 | { |
43103 | 43177 | stack[base + 35] = stack[base + 17]/*label*/; |
43104 | - label = 3642LLU; // skip deleter | |
43178 | + label = 3651LLU; // skip deleter | |
43105 | 43179 | break; |
43106 | 43180 | } |
43107 | - case 3641LLU: // deleter | |
43181 | + case 3650LLU: // deleter | |
43108 | 43182 | { |
43109 | 43183 | // throw from procblock |
43110 | 43184 | if(!stack[base + 36]) |
43111 | 43185 | { |
43112 | - label = 3639LLU; // skip, variable already deleted/unscoped | |
43186 | + label = 3648LLU; // skip, variable already deleted/unscoped | |
43113 | 43187 | break; |
43114 | 43188 | } |
43115 | 43189 |
@@ -43118,7 +43192,7 @@ | ||
43118 | 43192 | newstack[0] = (uint64_t)stack; // backup stack location |
43119 | 43193 | newstack[1] = 1234567890; |
43120 | 43194 | newstack[2] = base; |
43121 | - newstack[3] = 3643LLU; | |
43195 | + newstack[3] = 3652LLU; | |
43122 | 43196 | stack = newstack; |
43123 | 43197 | // set stack-base & callee-address |
43124 | 43198 | base = 4/*deloffset*/; |
@@ -43125,21 +43199,21 @@ | ||
43125 | 43199 | label = 562LLU; // ~scope |
43126 | 43200 | break; |
43127 | 43201 | } |
43128 | - case 3643LLU: // return from ~scope to procblock | |
43202 | + case 3652LLU: // return from ~scope to procblock | |
43129 | 43203 | { |
43130 | 43204 | stack = (uint64_t *)stack[0]; |
43131 | 43205 | // releasing toplevel container |
43132 | 43206 | Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 36] - sizeof(uint64_t) * 4)); |
43133 | 43207 | |
43134 | - label = 3639LLU; // continue unrolling stack, delete next variable | |
43208 | + label = 3648LLU; // continue unrolling stack, delete next variable | |
43135 | 43209 | break; |
43136 | 43210 | } |
43137 | - case 3642LLU: // skipped deleter | |
43211 | + case 3651LLU: // skipped deleter | |
43138 | 43212 | { |
43139 | 43213 | // call chainscope from procblock |
43140 | - stack[base + 37LLU] = 3644LLU/*throw to this address*/; | |
43214 | + stack[base + 37LLU] = 3653LLU/*throw to this address*/; | |
43141 | 43215 | stack[base + 38LLU] = base; |
43142 | - stack[base + 39LLU] = 3645LLU; | |
43216 | + stack[base + 39LLU] = 3654LLU; | |
43143 | 43217 | // arguments for call to chainscope |
43144 | 43218 | stack[base + 41LLU] = stack[base + 35]/*labelfail*/; |
43145 | 43219 | // set stack-base & callee-address |
@@ -43147,13 +43221,13 @@ | ||
43147 | 43221 | label = 579LLU; // chainscope |
43148 | 43222 | break; |
43149 | 43223 | } |
43150 | - case 3644LLU: // copy-back deleter (chainscope to procblock) | |
43224 | + case 3653LLU: // copy-back deleter (chainscope to procblock) | |
43151 | 43225 | { |
43152 | 43226 | // copy mutable arguments back from call to chainscope |
43153 | - label = 3639LLU; // continue to roll stack | |
43227 | + label = 3648LLU; // continue to roll stack | |
43154 | 43228 | break; |
43155 | 43229 | } |
43156 | - case 3645LLU: // return from chainscope to procblock | |
43230 | + case 3654LLU: // return from chainscope to procblock | |
43157 | 43231 | { |
43158 | 43232 | // copy mutable arguments back from call to chainscope |
43159 | 43233 | // copy back results provided by call to chainscope |
@@ -43174,7 +43248,7 @@ | ||
43174 | 43248 | } |
43175 | 43249 | if(/*typelist*/1 != ((uint64_t *)(stack[base + 29]/*listtype*/))[0]) |
43176 | 43250 | { |
43177 | - label = 3647LLU; // jump to alternative | |
43251 | + label = 3656LLU; // jump to alternative | |
43178 | 43252 | break; |
43179 | 43253 | } |
43180 | 43254 |
@@ -43181,42 +43255,42 @@ | ||
43181 | 43255 | /*subtype*/stack[base + 36] = ((uint64_t **)(stack[base + 29]/*listtype*/))[1][0]/*subtype*/; |
43182 | 43256 | |
43183 | 43257 | // case |
43184 | - label = 3650LLU; // skip deleter | |
43258 | + label = 3659LLU; // skip deleter | |
43185 | 43259 | break; |
43186 | 43260 | } |
43187 | - case 3649LLU: // deleter | |
43261 | + case 3658LLU: // deleter | |
43188 | 43262 | { |
43189 | 43263 | // throw from procblock |
43190 | 43264 | if(!stack[base + 37]) |
43191 | 43265 | { |
43192 | - label = 3648LLU; // skip, variable already deleted/unscoped | |
43266 | + label = 3657LLU; // skip, variable already deleted/unscoped | |
43193 | 43267 | break; |
43194 | 43268 | } |
43195 | - label = 3648LLU; // continue unrolling stack, delete next variable | |
43269 | + label = 3657LLU; // continue unrolling stack, delete next variable | |
43196 | 43270 | break; |
43197 | 43271 | } |
43198 | - case 3650LLU: // skipped deleter | |
43272 | + case 3659LLU: // skipped deleter | |
43199 | 43273 | { |
43200 | - label = 3652LLU; // skip deleter | |
43274 | + label = 3661LLU; // skip deleter | |
43201 | 43275 | break; |
43202 | 43276 | } |
43203 | - case 3651LLU: // deleter | |
43277 | + case 3660LLU: // deleter | |
43204 | 43278 | { |
43205 | 43279 | // throw from procblock |
43206 | 43280 | if(!stack[base + 38]) |
43207 | 43281 | { |
43208 | - label = 3648LLU; // skip, variable already deleted/unscoped | |
43282 | + label = 3657LLU; // skip, variable already deleted/unscoped | |
43209 | 43283 | break; |
43210 | 43284 | } |
43211 | - label = 3648LLU; // continue unrolling stack, delete next variable | |
43285 | + label = 3657LLU; // continue unrolling stack, delete next variable | |
43212 | 43286 | break; |
43213 | 43287 | } |
43214 | - case 3652LLU: // skipped deleter | |
43288 | + case 3661LLU: // skipped deleter | |
43215 | 43289 | { |
43216 | 43290 | // call isparam from procblock |
43217 | - stack[base + 39LLU] = 3653LLU/*throw to this address*/; | |
43291 | + stack[base + 39LLU] = 3662LLU/*throw to this address*/; | |
43218 | 43292 | stack[base + 40LLU] = base; |
43219 | - stack[base + 41LLU] = 3654LLU; | |
43293 | + stack[base + 41LLU] = 3663LLU; | |
43220 | 43294 | // arguments for call to isparam |
43221 | 43295 | stack[base + 43LLU] = stack[base + 10]/*fnrescount*/; |
43222 | 43296 | stack[base + 44LLU] = stack[base + 11]/*fnargcount*/; |
@@ -43226,13 +43300,13 @@ | ||
43226 | 43300 | label = 1635LLU; // isparam |
43227 | 43301 | break; |
43228 | 43302 | } |
43229 | - case 3653LLU: // copy-back deleter (isparam to procblock) | |
43303 | + case 3662LLU: // copy-back deleter (isparam to procblock) | |
43230 | 43304 | { |
43231 | 43305 | // copy mutable arguments back from call to isparam |
43232 | - label = 3648LLU; // continue to roll stack | |
43306 | + label = 3657LLU; // continue to roll stack | |
43233 | 43307 | break; |
43234 | 43308 | } |
43235 | - case 3654LLU: // return from isparam to procblock | |
43309 | + case 3663LLU: // return from isparam to procblock | |
43236 | 43310 | { |
43237 | 43311 | // copy mutable arguments back from call to isparam |
43238 | 43312 | // copy back results provided by call to isparam |
@@ -43239,37 +43313,37 @@ | ||
43239 | 43313 | stack[base + 38] = stack[base + 42LLU]; |
43240 | 43314 | if(!stack[base + 32]/*listmut*/) |
43241 | 43315 | { |
43242 | - label = 3655LLU; // jump to alternative | |
43316 | + label = 3664LLU; // jump to alternative | |
43243 | 43317 | break; |
43244 | 43318 | } |
43245 | 43319 | |
43246 | 43320 | // consequent |
43247 | - label = 3658LLU; // skip deleter | |
43321 | + label = 3667LLU; // skip deleter | |
43248 | 43322 | break; |
43249 | 43323 | } |
43250 | - case 3657LLU: // deleter | |
43324 | + case 3666LLU: // deleter | |
43251 | 43325 | { |
43252 | 43326 | // throw from procblock |
43253 | 43327 | if(!stack[base + 37]) |
43254 | 43328 | { |
43255 | - label = 3651LLU; // skip, variable already deleted/unscoped | |
43329 | + label = 3660LLU; // skip, variable already deleted/unscoped | |
43256 | 43330 | break; |
43257 | 43331 | } |
43258 | - label = 3651LLU; // continue unrolling stack, delete next variable | |
43332 | + label = 3660LLU; // continue unrolling stack, delete next variable | |
43259 | 43333 | break; |
43260 | 43334 | } |
43261 | - case 3658LLU: // skipped deleter | |
43335 | + case 3667LLU: // skipped deleter | |
43262 | 43336 | { |
43263 | 43337 | stack[base + 37] = 0; |
43264 | - label = 3656LLU; // consequent complete | |
43338 | + label = 3665LLU; // consequent complete | |
43265 | 43339 | break; |
43266 | 43340 | } |
43267 | - case 3655LLU: // alternative | |
43341 | + case 3664LLU: // alternative | |
43268 | 43342 | { |
43269 | 43343 | // call or from procblock |
43270 | - stack[base + 39LLU] = 3659LLU/*throw to this address*/; | |
43344 | + stack[base + 39LLU] = 3668LLU/*throw to this address*/; | |
43271 | 43345 | stack[base + 40LLU] = base; |
43272 | - stack[base + 41LLU] = 3660LLU; | |
43346 | + stack[base + 41LLU] = 3669LLU; | |
43273 | 43347 | // arguments for call to or |
43274 | 43348 | stack[base + 43LLU] = stack[base + 33]/*substruct*/; |
43275 | 43349 | stack[base + 44LLU] = stack[base + 38]/*listparam*/; |
@@ -43278,42 +43352,42 @@ | ||
43278 | 43352 | label = 18446744073709551611LLU; // or |
43279 | 43353 | break; |
43280 | 43354 | } |
43281 | - case 3659LLU: // copy-back deleter (or to procblock) | |
43355 | + case 3668LLU: // copy-back deleter (or to procblock) | |
43282 | 43356 | { |
43283 | 43357 | // copy mutable arguments back from call to or |
43284 | - label = 3651LLU; // continue to roll stack | |
43358 | + label = 3660LLU; // continue to roll stack | |
43285 | 43359 | break; |
43286 | 43360 | } |
43287 | - case 3660LLU: // return from or to procblock | |
43361 | + case 3669LLU: // return from or to procblock | |
43288 | 43362 | { |
43289 | 43363 | // copy mutable arguments back from call to or |
43290 | 43364 | // copy back results provided by call to or |
43291 | 43365 | stack[base + 37] = stack[base + 42LLU]; |
43292 | - label = 3656LLU; // alternative complete | |
43366 | + label = 3665LLU; // alternative complete | |
43293 | 43367 | break; |
43294 | 43368 | } |
43295 | - case 3656LLU: // completed if-then-else | |
43369 | + case 3665LLU: // completed if-then-else | |
43296 | 43370 | { |
43297 | - label = 3662LLU; // skip deleter | |
43371 | + label = 3671LLU; // skip deleter | |
43298 | 43372 | break; |
43299 | 43373 | } |
43300 | - case 3661LLU: // deleter | |
43374 | + case 3670LLU: // deleter | |
43301 | 43375 | { |
43302 | 43376 | // throw from procblock |
43303 | 43377 | if(!stack[base + 38]) |
43304 | 43378 | { |
43305 | - label = 3649LLU; // skip, variable already deleted/unscoped | |
43379 | + label = 3658LLU; // skip, variable already deleted/unscoped | |
43306 | 43380 | break; |
43307 | 43381 | } |
43308 | - label = 3649LLU; // continue unrolling stack, delete next variable | |
43382 | + label = 3658LLU; // continue unrolling stack, delete next variable | |
43309 | 43383 | break; |
43310 | 43384 | } |
43311 | - case 3662LLU: // skipped deleter | |
43385 | + case 3671LLU: // skipped deleter | |
43312 | 43386 | { |
43313 | 43387 | // call newvarraw from procblock |
43314 | - stack[base + 39LLU] = 3663LLU/*throw to this address*/; | |
43388 | + stack[base + 39LLU] = 3672LLU/*throw to this address*/; | |
43315 | 43389 | stack[base + 40LLU] = base; |
43316 | - stack[base + 41LLU] = 3664LLU; | |
43390 | + stack[base + 41LLU] = 3673LLU; | |
43317 | 43391 | // arguments for call to newvarraw |
43318 | 43392 | stack[base + 43LLU] = stack[base + 36]/*subtype*/; |
43319 | 43393 | stack[base + 44LLU] = stack[base + 27]/*elemid*/; |
@@ -43329,16 +43403,16 @@ | ||
43329 | 43403 | label = 759LLU; // newvarraw |
43330 | 43404 | break; |
43331 | 43405 | } |
43332 | - case 3663LLU: // copy-back deleter (newvarraw to procblock) | |
43406 | + case 3672LLU: // copy-back deleter (newvarraw to procblock) | |
43333 | 43407 | { |
43334 | 43408 | // copy mutable arguments back from call to newvarraw |
43335 | 43409 | stack[base + 3]/*scope*/ = stack[base + 50LLU]; |
43336 | 43410 | stack[base + 18]/*varcount*/ = stack[base + 49LLU]; |
43337 | 43411 | stack[base + 12]/*fnmaxcount*/ = stack[base + 48LLU]; |
43338 | - label = 3649LLU; // continue to roll stack | |
43412 | + label = 3658LLU; // continue to roll stack | |
43339 | 43413 | break; |
43340 | 43414 | } |
43341 | - case 3664LLU: // return from newvarraw to procblock | |
43415 | + case 3673LLU: // return from newvarraw to procblock | |
43342 | 43416 | { |
43343 | 43417 | // copy mutable arguments back from call to newvarraw |
43344 | 43418 | stack[base + 3]/*scope*/ = stack[base + 50LLU]; |
@@ -43349,9 +43423,9 @@ | ||
43349 | 43423 | printf("%s", "\n {"); |
43350 | 43424 | printf("%s", "\n label = "); |
43351 | 43425 | // call printnr from procblock |
43352 | - stack[base + 39LLU] = 3665LLU/*throw to this address*/; | |
43426 | + stack[base + 39LLU] = 3674LLU/*throw to this address*/; | |
43353 | 43427 | stack[base + 40LLU] = base; |
43354 | - stack[base + 41LLU] = 3666LLU; | |
43428 | + stack[base + 41LLU] = 3675LLU; | |
43355 | 43429 | // arguments for call to printnr |
43356 | 43430 | stack[base + 42LLU] = stack[base + 23]/*labelalt*/; |
43357 | 43431 | // set stack-base & callee-address |
@@ -43359,13 +43433,13 @@ | ||
43359 | 43433 | label = 18446744073709551590LLU; // printnr |
43360 | 43434 | break; |
43361 | 43435 | } |
43362 | - case 3665LLU: // copy-back deleter (printnr to procblock) | |
43436 | + case 3674LLU: // copy-back deleter (printnr to procblock) | |
43363 | 43437 | { |
43364 | 43438 | // copy mutable arguments back from call to printnr |
43365 | - label = 3661LLU; // continue to roll stack | |
43439 | + label = 3670LLU; // continue to roll stack | |
43366 | 43440 | break; |
43367 | 43441 | } |
43368 | - case 3666LLU: // return from printnr to procblock | |
43442 | + case 3675LLU: // return from printnr to procblock | |
43369 | 43443 | { |
43370 | 43444 | // copy mutable arguments back from call to printnr |
43371 | 43445 | printf("%s", "LLU; // jump to alternative"); |
@@ -43374,9 +43448,9 @@ | ||
43374 | 43448 | printf("%s", "\n"); |
43375 | 43449 | printf("%s", "\n // consequent"); |
43376 | 43450 | // call matchsym from procblock |
43377 | - stack[base + 39LLU] = 3667LLU/*throw to this address*/; | |
43451 | + stack[base + 39LLU] = 3676LLU/*throw to this address*/; | |
43378 | 43452 | stack[base + 40LLU] = base; |
43379 | - stack[base + 41LLU] = 3668LLU; | |
43453 | + stack[base + 41LLU] = 3677LLU; | |
43380 | 43454 | // arguments for call to matchsym |
43381 | 43455 | stack[base + 42LLU] = stack[base + 8]/*fnid*/; |
43382 | 43456 | stack[base + 43LLU] = 123LLU; |
@@ -43386,14 +43460,14 @@ | ||
43386 | 43460 | label = 246LLU; // matchsym |
43387 | 43461 | break; |
43388 | 43462 | } |
43389 | - case 3667LLU: // copy-back deleter (matchsym to procblock) | |
43463 | + case 3676LLU: // copy-back deleter (matchsym to procblock) | |
43390 | 43464 | { |
43391 | 43465 | // copy mutable arguments back from call to matchsym |
43392 | 43466 | stack[base + 19]/*lookahead*/ = stack[base + 44LLU]; |
43393 | - label = 3661LLU; // continue to roll stack | |
43467 | + label = 3670LLU; // continue to roll stack | |
43394 | 43468 | break; |
43395 | 43469 | } |
43396 | - case 3668LLU: // return from matchsym to procblock | |
43470 | + case 3677LLU: // return from matchsym to procblock | |
43397 | 43471 | { |
43398 | 43472 | // copy mutable arguments back from call to matchsym |
43399 | 43473 | stack[base + 19]/*lookahead*/ = stack[base + 44LLU]; |
@@ -43400,9 +43474,9 @@ | ||
43400 | 43474 | printf("%s", "\n struct listnode *next = list->next;"); |
43401 | 43475 | printf("%s", "\n /*"); |
43402 | 43476 | // call printid from procblock |
43403 | - stack[base + 39LLU] = 3669LLU/*throw to this address*/; | |
43477 | + stack[base + 39LLU] = 3678LLU/*throw to this address*/; | |
43404 | 43478 | stack[base + 40LLU] = base; |
43405 | - stack[base + 41LLU] = 3670LLU; | |
43479 | + stack[base + 41LLU] = 3679LLU; | |
43406 | 43480 | // arguments for call to printid |
43407 | 43481 | stack[base + 42LLU] = stack[base + 27]/*elemid*/; |
43408 | 43482 | // set stack-base & callee-address |
@@ -43410,20 +43484,20 @@ | ||
43410 | 43484 | label = 18446744073709551587LLU; // printid |
43411 | 43485 | break; |
43412 | 43486 | } |
43413 | - case 3669LLU: // copy-back deleter (printid to procblock) | |
43487 | + case 3678LLU: // copy-back deleter (printid to procblock) | |
43414 | 43488 | { |
43415 | 43489 | // copy mutable arguments back from call to printid |
43416 | - label = 3661LLU; // continue to roll stack | |
43490 | + label = 3670LLU; // continue to roll stack | |
43417 | 43491 | break; |
43418 | 43492 | } |
43419 | - case 3670LLU: // return from printid to procblock | |
43493 | + case 3679LLU: // return from printid to procblock | |
43420 | 43494 | { |
43421 | 43495 | // copy mutable arguments back from call to printid |
43422 | 43496 | printf("%s", "*/"); |
43423 | 43497 | // call emitvaridx from procblock |
43424 | - stack[base + 39LLU] = 3671LLU/*throw to this address*/; | |
43498 | + stack[base + 39LLU] = 3680LLU/*throw to this address*/; | |
43425 | 43499 | stack[base + 40LLU] = base; |
43426 | - stack[base + 41LLU] = 3672LLU; | |
43500 | + stack[base + 41LLU] = 3681LLU; | |
43427 | 43501 | // arguments for call to emitvaridx |
43428 | 43502 | stack[base + 42LLU] = stack[base + 38]/*elemindex*/; |
43429 | 43503 | // set stack-base & callee-address |
@@ -43431,19 +43505,19 @@ | ||
43431 | 43505 | label = 745LLU; // emitvaridx |
43432 | 43506 | break; |
43433 | 43507 | } |
43434 | - case 3671LLU: // copy-back deleter (emitvaridx to procblock) | |
43508 | + case 3680LLU: // copy-back deleter (emitvaridx to procblock) | |
43435 | 43509 | { |
43436 | 43510 | // copy mutable arguments back from call to emitvaridx |
43437 | - label = 3661LLU; // continue to roll stack | |
43511 | + label = 3670LLU; // continue to roll stack | |
43438 | 43512 | break; |
43439 | 43513 | } |
43440 | - case 3672LLU: // return from emitvaridx to procblock | |
43514 | + case 3681LLU: // return from emitvaridx to procblock | |
43441 | 43515 | { |
43442 | 43516 | // copy mutable arguments back from call to emitvaridx |
43443 | 43517 | printf("%s", " = list->data;"); |
43444 | 43518 | if(!stack[base + 25]/*consume*/) |
43445 | 43519 | { |
43446 | - label = 3673LLU; // jump to alternative | |
43520 | + label = 3682LLU; // jump to alternative | |
43447 | 43521 | break; |
43448 | 43522 | } |
43449 | 43523 |
@@ -43451,9 +43525,9 @@ | ||
43451 | 43525 | printf("%s", "\n Free(1, sizeof(struct listnode), list);"); |
43452 | 43526 | printf("%s", "\n /*"); |
43453 | 43527 | // call printid from procblock |
43454 | - stack[base + 39LLU] = 3675LLU/*throw to this address*/; | |
43528 | + stack[base + 39LLU] = 3684LLU/*throw to this address*/; | |
43455 | 43529 | stack[base + 40LLU] = base; |
43456 | - stack[base + 41LLU] = 3676LLU; | |
43530 | + stack[base + 41LLU] = 3685LLU; | |
43457 | 43531 | // arguments for call to printid |
43458 | 43532 | stack[base + 42LLU] = stack[base + 30]/*listname*/; |
43459 | 43533 | // set stack-base & callee-address |
@@ -43461,20 +43535,20 @@ | ||
43461 | 43535 | label = 18446744073709551587LLU; // printid |
43462 | 43536 | break; |
43463 | 43537 | } |
43464 | - case 3675LLU: // copy-back deleter (printid to procblock) | |
43538 | + case 3684LLU: // copy-back deleter (printid to procblock) | |
43465 | 43539 | { |
43466 | 43540 | // copy mutable arguments back from call to printid |
43467 | - label = 3661LLU; // continue to roll stack | |
43541 | + label = 3670LLU; // continue to roll stack | |
43468 | 43542 | break; |
43469 | 43543 | } |
43470 | - case 3676LLU: // return from printid to procblock | |
43544 | + case 3685LLU: // return from printid to procblock | |
43471 | 43545 | { |
43472 | 43546 | // copy mutable arguments back from call to printid |
43473 | 43547 | printf("%s", "*/"); |
43474 | 43548 | // call emitvaridx from procblock |
43475 | - stack[base + 39LLU] = 3677LLU/*throw to this address*/; | |
43549 | + stack[base + 39LLU] = 3686LLU/*throw to this address*/; | |
43476 | 43550 | stack[base + 40LLU] = base; |
43477 | - stack[base + 41LLU] = 3678LLU; | |
43551 | + stack[base + 41LLU] = 3687LLU; | |
43478 | 43552 | // arguments for call to emitvaridx |
43479 | 43553 | stack[base + 42LLU] = stack[base + 31]/*listindex*/; |
43480 | 43554 | // set stack-base & callee-address |
@@ -43482,33 +43556,33 @@ | ||
43482 | 43556 | label = 745LLU; // emitvaridx |
43483 | 43557 | break; |
43484 | 43558 | } |
43485 | - case 3677LLU: // copy-back deleter (emitvaridx to procblock) | |
43559 | + case 3686LLU: // copy-back deleter (emitvaridx to procblock) | |
43486 | 43560 | { |
43487 | 43561 | // copy mutable arguments back from call to emitvaridx |
43488 | - label = 3661LLU; // continue to roll stack | |
43562 | + label = 3670LLU; // continue to roll stack | |
43489 | 43563 | break; |
43490 | 43564 | } |
43491 | - case 3678LLU: // return from emitvaridx to procblock | |
43565 | + case 3687LLU: // return from emitvaridx to procblock | |
43492 | 43566 | { |
43493 | 43567 | // copy mutable arguments back from call to emitvaridx |
43494 | 43568 | printf("%s", " = (uint64_t)next;"); |
43495 | 43569 | if(!stack[base + 32]/*listmut*/) |
43496 | 43570 | { |
43497 | - label = 3679LLU; // jump to alternative | |
43571 | + label = 3688LLU; // jump to alternative | |
43498 | 43572 | break; |
43499 | 43573 | } |
43500 | 43574 | |
43501 | 43575 | // consequent |
43502 | - label = 3680LLU; // consequent complete | |
43576 | + label = 3689LLU; // consequent complete | |
43503 | 43577 | break; |
43504 | 43578 | } |
43505 | - case 3679LLU: // alternative | |
43579 | + case 3688LLU: // alternative | |
43506 | 43580 | { |
43507 | 43581 | fprintf(stderr, "%s", "in function "); |
43508 | 43582 | // call reportid from procblock |
43509 | - stack[base + 39LLU] = 3681LLU/*throw to this address*/; | |
43583 | + stack[base + 39LLU] = 3690LLU/*throw to this address*/; | |
43510 | 43584 | stack[base + 40LLU] = base; |
43511 | - stack[base + 41LLU] = 3682LLU; | |
43585 | + stack[base + 41LLU] = 3691LLU; | |
43512 | 43586 | // arguments for call to reportid |
43513 | 43587 | stack[base + 42LLU] = stack[base + 8]/*fnid*/; |
43514 | 43588 | // set stack-base & callee-address |
@@ -43516,21 +43590,21 @@ | ||
43516 | 43590 | label = 18446744073709551586LLU; // reportid |
43517 | 43591 | break; |
43518 | 43592 | } |
43519 | - case 3681LLU: // copy-back deleter (reportid to procblock) | |
43593 | + case 3690LLU: // copy-back deleter (reportid to procblock) | |
43520 | 43594 | { |
43521 | 43595 | // copy mutable arguments back from call to reportid |
43522 | - label = 3661LLU; // continue to roll stack | |
43596 | + label = 3670LLU; // continue to roll stack | |
43523 | 43597 | break; |
43524 | 43598 | } |
43525 | - case 3682LLU: // return from reportid to procblock | |
43599 | + case 3691LLU: // return from reportid to procblock | |
43526 | 43600 | { |
43527 | 43601 | // copy mutable arguments back from call to reportid |
43528 | 43602 | fprintf(stderr, "%s", ": "); |
43529 | 43603 | fprintf(stderr, "%s", "can't pop from CONSTANT list "); |
43530 | 43604 | // call reportid from procblock |
43531 | - stack[base + 39LLU] = 3683LLU/*throw to this address*/; | |
43605 | + stack[base + 39LLU] = 3692LLU/*throw to this address*/; | |
43532 | 43606 | stack[base + 40LLU] = base; |
43533 | - stack[base + 41LLU] = 3684LLU; | |
43607 | + stack[base + 41LLU] = 3693LLU; | |
43534 | 43608 | // arguments for call to reportid |
43535 | 43609 | stack[base + 42LLU] = stack[base + 30]/*listname*/; |
43536 | 43610 | // set stack-base & callee-address |
@@ -43538,13 +43612,13 @@ | ||
43538 | 43612 | label = 18446744073709551586LLU; // reportid |
43539 | 43613 | break; |
43540 | 43614 | } |
43541 | - case 3683LLU: // copy-back deleter (reportid to procblock) | |
43615 | + case 3692LLU: // copy-back deleter (reportid to procblock) | |
43542 | 43616 | { |
43543 | 43617 | // copy mutable arguments back from call to reportid |
43544 | - label = 3661LLU; // continue to roll stack | |
43618 | + label = 3670LLU; // continue to roll stack | |
43545 | 43619 | break; |
43546 | 43620 | } |
43547 | - case 3684LLU: // return from reportid to procblock | |
43621 | + case 3693LLU: // return from reportid to procblock | |
43548 | 43622 | { |
43549 | 43623 | // copy mutable arguments back from call to reportid |
43550 | 43624 | fprintf(stderr, "%s", " of type "); |
@@ -43551,7 +43625,7 @@ | ||
43551 | 43625 | uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t)); |
43552 | 43626 | if(!newstack) |
43553 | 43627 | { |
43554 | - label = 3661LLU; // throw: begin to unroll stack | |
43628 | + label = 3670LLU; // throw: begin to unroll stack | |
43555 | 43629 | break; |
43556 | 43630 | } |
43557 | 43631 |
@@ -43558,9 +43632,9 @@ | ||
43558 | 43632 | newstack[10LLU] = 9876543210LLU; // overflow-marker |
43559 | 43633 | // call reporttype from procblock |
43560 | 43634 | newstack[0] = (uint64_t)stack; // backup stack location |
43561 | - newstack[1] = 3685LLU; | |
43635 | + newstack[1] = 3694LLU; | |
43562 | 43636 | newstack[2] = base; |
43563 | - newstack[3] = 3686LLU; | |
43637 | + newstack[3] = 3695LLU; | |
43564 | 43638 | // arguments for call to reporttype |
43565 | 43639 | newstack[4LLU] = stack[base + 29]/*listtype*/; |
43566 | 43640 | stack = newstack; |
@@ -43569,7 +43643,7 @@ | ||
43569 | 43643 | label = 330LLU; // reporttype |
43570 | 43644 | break; |
43571 | 43645 | } |
43572 | - case 3685LLU: // copy-back deleter (reporttype to procblock) | |
43646 | + case 3694LLU: // copy-back deleter (reporttype to procblock) | |
43573 | 43647 | { |
43574 | 43648 | uint64_t *oldstack = (uint64_t *)stack[0]; |
43575 | 43649 | // copy mutable arguments back from call to reporttype |
@@ -43580,10 +43654,10 @@ | ||
43580 | 43654 | } |
43581 | 43655 | Free(10LLU + 1, sizeof(uint64_t), stack); |
43582 | 43656 | stack = oldstack; |
43583 | - label = 3661LLU; // continue to unroll stack | |
43657 | + label = 3670LLU; // continue to unroll stack | |
43584 | 43658 | break; |
43585 | 43659 | } |
43586 | - case 3686LLU: // return from reporttype to procblock | |
43660 | + case 3695LLU: // return from reporttype to procblock | |
43587 | 43661 | { |
43588 | 43662 | uint64_t *oldstack = (uint64_t *)stack[0]; |
43589 | 43663 | // copy mutable arguments back from call to reporttype |
@@ -43596,40 +43670,40 @@ | ||
43596 | 43670 | stack = oldstack; |
43597 | 43671 | fprintf(stderr, "%s", "\n"); |
43598 | 43672 | { |
43599 | - label = 3661LLU; // throw: begin to unroll stack | |
43673 | + label = 3670LLU; // throw: begin to unroll stack | |
43600 | 43674 | break; |
43601 | 43675 | } |
43602 | 43676 | |
43603 | - label = 3680LLU; // alternative complete | |
43677 | + label = 3689LLU; // alternative complete | |
43604 | 43678 | break; |
43605 | 43679 | } |
43606 | - case 3680LLU: // completed if-then-else | |
43680 | + case 3689LLU: // completed if-then-else | |
43607 | 43681 | { |
43608 | - label = 3674LLU; // consequent complete | |
43682 | + label = 3683LLU; // consequent complete | |
43609 | 43683 | break; |
43610 | 43684 | } |
43611 | - case 3673LLU: // alternative | |
43685 | + case 3682LLU: // alternative | |
43612 | 43686 | { |
43613 | - label = 3688LLU; // skip deleter | |
43687 | + label = 3697LLU; // skip deleter | |
43614 | 43688 | break; |
43615 | 43689 | } |
43616 | - case 3687LLU: // deleter | |
43690 | + case 3696LLU: // deleter | |
43617 | 43691 | { |
43618 | 43692 | // throw from procblock |
43619 | 43693 | if(!stack[base + 39]) |
43620 | 43694 | { |
43621 | - label = 3661LLU; // skip, variable already deleted/unscoped | |
43695 | + label = 3670LLU; // skip, variable already deleted/unscoped | |
43622 | 43696 | break; |
43623 | 43697 | } |
43624 | - label = 3661LLU; // continue unrolling stack, delete next variable | |
43698 | + label = 3670LLU; // continue unrolling stack, delete next variable | |
43625 | 43699 | break; |
43626 | 43700 | } |
43627 | - case 3688LLU: // skipped deleter | |
43701 | + case 3697LLU: // skipped deleter | |
43628 | 43702 | { |
43629 | 43703 | // call newvarraw from procblock |
43630 | - stack[base + 40LLU] = 3689LLU/*throw to this address*/; | |
43704 | + stack[base + 40LLU] = 3698LLU/*throw to this address*/; | |
43631 | 43705 | stack[base + 41LLU] = base; |
43632 | - stack[base + 42LLU] = 3690LLU; | |
43706 | + stack[base + 42LLU] = 3699LLU; | |
43633 | 43707 | // arguments for call to newvarraw |
43634 | 43708 | stack[base + 44LLU] = stack[base + 29]/*listtype*/; |
43635 | 43709 | stack[base + 45LLU] = stack[base + 30]/*listname*/; |
@@ -43645,16 +43719,16 @@ | ||
43645 | 43719 | label = 759LLU; // newvarraw |
43646 | 43720 | break; |
43647 | 43721 | } |
43648 | - case 3689LLU: // copy-back deleter (newvarraw to procblock) | |
43722 | + case 3698LLU: // copy-back deleter (newvarraw to procblock) | |
43649 | 43723 | { |
43650 | 43724 | // copy mutable arguments back from call to newvarraw |
43651 | 43725 | stack[base + 3]/*scope*/ = stack[base + 51LLU]; |
43652 | 43726 | stack[base + 18]/*varcount*/ = stack[base + 50LLU]; |
43653 | 43727 | stack[base + 12]/*fnmaxcount*/ = stack[base + 49LLU]; |
43654 | - label = 3661LLU; // continue to roll stack | |
43728 | + label = 3670LLU; // continue to roll stack | |
43655 | 43729 | break; |
43656 | 43730 | } |
43657 | - case 3690LLU: // return from newvarraw to procblock | |
43731 | + case 3699LLU: // return from newvarraw to procblock | |
43658 | 43732 | { |
43659 | 43733 | // copy mutable arguments back from call to newvarraw |
43660 | 43734 | stack[base + 3]/*scope*/ = stack[base + 51LLU]; |
@@ -43664,9 +43738,9 @@ | ||
43664 | 43738 | stack[base + 39] = stack[base + 43LLU]; |
43665 | 43739 | printf("%s", "\n /*"); |
43666 | 43740 | // call printid from procblock |
43667 | - stack[base + 40LLU] = 3691LLU/*throw to this address*/; | |
43741 | + stack[base + 40LLU] = 3700LLU/*throw to this address*/; | |
43668 | 43742 | stack[base + 41LLU] = base; |
43669 | - stack[base + 42LLU] = 3692LLU; | |
43743 | + stack[base + 42LLU] = 3701LLU; | |
43670 | 43744 | // arguments for call to printid |
43671 | 43745 | stack[base + 43LLU] = stack[base + 30]/*listname*/; |
43672 | 43746 | // set stack-base & callee-address |
@@ -43674,20 +43748,20 @@ | ||
43674 | 43748 | label = 18446744073709551587LLU; // printid |
43675 | 43749 | break; |
43676 | 43750 | } |
43677 | - case 3691LLU: // copy-back deleter (printid to procblock) | |
43751 | + case 3700LLU: // copy-back deleter (printid to procblock) | |
43678 | 43752 | { |
43679 | 43753 | // copy mutable arguments back from call to printid |
43680 | - label = 3687LLU; // continue to roll stack | |
43754 | + label = 3696LLU; // continue to roll stack | |
43681 | 43755 | break; |
43682 | 43756 | } |
43683 | - case 3692LLU: // return from printid to procblock | |
43757 | + case 3701LLU: // return from printid to procblock | |
43684 | 43758 | { |
43685 | 43759 | // copy mutable arguments back from call to printid |
43686 | 43760 | printf("%s", "*/"); |
43687 | 43761 | // call emitvaridx from procblock |
43688 | - stack[base + 40LLU] = 3693LLU/*throw to this address*/; | |
43762 | + stack[base + 40LLU] = 3702LLU/*throw to this address*/; | |
43689 | 43763 | stack[base + 41LLU] = base; |
43690 | - stack[base + 42LLU] = 3694LLU; | |
43764 | + stack[base + 42LLU] = 3703LLU; | |
43691 | 43765 | // arguments for call to emitvaridx |
43692 | 43766 | stack[base + 43LLU] = stack[base + 39]/*restindex*/; |
43693 | 43767 | // set stack-base & callee-address |
@@ -43695,25 +43769,25 @@ | ||
43695 | 43769 | label = 745LLU; // emitvaridx |
43696 | 43770 | break; |
43697 | 43771 | } |
43698 | - case 3693LLU: // copy-back deleter (emitvaridx to procblock) | |
43772 | + case 3702LLU: // copy-back deleter (emitvaridx to procblock) | |
43699 | 43773 | { |
43700 | 43774 | // copy mutable arguments back from call to emitvaridx |
43701 | - label = 3687LLU; // continue to roll stack | |
43775 | + label = 3696LLU; // continue to roll stack | |
43702 | 43776 | break; |
43703 | 43777 | } |
43704 | - case 3694LLU: // return from emitvaridx to procblock | |
43778 | + case 3703LLU: // return from emitvaridx to procblock | |
43705 | 43779 | { |
43706 | 43780 | // copy mutable arguments back from call to emitvaridx |
43707 | 43781 | printf("%s", " = (uint64_t)next;"); |
43708 | - label = 3674LLU; // alternative complete | |
43782 | + label = 3683LLU; // alternative complete | |
43709 | 43783 | break; |
43710 | 43784 | } |
43711 | - case 3674LLU: // completed if-then-else | |
43785 | + case 3683LLU: // completed if-then-else | |
43712 | 43786 | { |
43713 | 43787 | printf("%s", "\n }"); |
43714 | 43788 | if(!stack[base + 21]/*returnflag*/) |
43715 | 43789 | { |
43716 | - label = 3695LLU; // jump to alternative | |
43790 | + label = 3704LLU; // jump to alternative | |
43717 | 43791 | break; |
43718 | 43792 | } |
43719 | 43793 |
@@ -43721,7 +43795,7 @@ | ||
43721 | 43795 | uint64_t *newstack = (uint64_t *)Calloc(160LLU + 1, sizeof(uint64_t)); |
43722 | 43796 | if(!newstack) |
43723 | 43797 | { |
43724 | - label = 3661LLU; // throw: begin to unroll stack | |
43798 | + label = 3670LLU; // throw: begin to unroll stack | |
43725 | 43799 | break; |
43726 | 43800 | } |
43727 | 43801 |
@@ -43728,9 +43802,9 @@ | ||
43728 | 43802 | newstack[160LLU] = 9876543210LLU; // overflow-marker |
43729 | 43803 | // call procblock from procblock |
43730 | 43804 | newstack[0] = (uint64_t)stack; // backup stack location |
43731 | - newstack[1] = 3697LLU; | |
43805 | + newstack[1] = 3706LLU; | |
43732 | 43806 | newstack[2] = base; |
43733 | - newstack[3] = 3698LLU; | |
43807 | + newstack[3] = 3707LLU; | |
43734 | 43808 | // arguments for call to procblock |
43735 | 43809 | newstack[4LLU] = stack[base + 0]/*fndefs*/; |
43736 | 43810 | newstack[5LLU] = stack[base + 1]/*datadefs*/; |
@@ -43753,10 +43827,10 @@ | ||
43753 | 43827 | stack = newstack; |
43754 | 43828 | // set stack-base & callee-address |
43755 | 43829 | base = 4/*deloffset*/; |
43756 | - label = 3429LLU; // procblock | |
43830 | + label = 3438LLU; // procblock | |
43757 | 43831 | break; |
43758 | 43832 | } |
43759 | - case 3697LLU: // copy-back deleter (procblock to procblock) | |
43833 | + case 3706LLU: // copy-back deleter (procblock to procblock) | |
43760 | 43834 | { |
43761 | 43835 | uint64_t *oldstack = (uint64_t *)stack[0]; |
43762 | 43836 | // copy mutable arguments back from call to procblock |
@@ -43773,10 +43847,10 @@ | ||
43773 | 43847 | } |
43774 | 43848 | Free(160LLU + 1, sizeof(uint64_t), stack); |
43775 | 43849 | stack = oldstack; |
43776 | - label = 3661LLU; // continue to unroll stack | |
43850 | + label = 3670LLU; // continue to unroll stack | |
43777 | 43851 | break; |
43778 | 43852 | } |
43779 | - case 3698LLU: // return from procblock to procblock | |
43853 | + case 3707LLU: // return from procblock to procblock | |
43780 | 43854 | { |
43781 | 43855 | uint64_t *oldstack = (uint64_t *)stack[0]; |
43782 | 43856 | // copy mutable arguments back from call to procblock |
@@ -43793,31 +43867,31 @@ | ||
43793 | 43867 | } |
43794 | 43868 | Free(160LLU + 1, sizeof(uint64_t), stack); |
43795 | 43869 | stack = oldstack; |
43796 | - label = 3696LLU; // consequent complete | |
43870 | + label = 3705LLU; // consequent complete | |
43797 | 43871 | break; |
43798 | 43872 | } |
43799 | - case 3695LLU: // alternative | |
43873 | + case 3704LLU: // alternative | |
43800 | 43874 | { |
43801 | - label = 3700LLU; // skip deleter | |
43875 | + label = 3709LLU; // skip deleter | |
43802 | 43876 | break; |
43803 | 43877 | } |
43804 | - case 3699LLU: // deleter | |
43878 | + case 3708LLU: // deleter | |
43805 | 43879 | { |
43806 | 43880 | // throw from procblock |
43807 | 43881 | if(!stack[base + 39]) |
43808 | 43882 | { |
43809 | - label = 3661LLU; // skip, variable already deleted/unscoped | |
43883 | + label = 3670LLU; // skip, variable already deleted/unscoped | |
43810 | 43884 | break; |
43811 | 43885 | } |
43812 | 43886 | // delete list |
43813 | - label = 3701LLU; // start to repeat | |
43887 | + label = 3710LLU; // start to repeat | |
43814 | 43888 | break; |
43815 | 43889 | } |
43816 | - case 3701LLU: // repeat from here | |
43890 | + case 3710LLU: // repeat from here | |
43817 | 43891 | { |
43818 | 43892 | if(!stack[base + 39]) |
43819 | 43893 | { |
43820 | - label = 3702LLU; // break loop | |
43894 | + label = 3711LLU; // break loop | |
43821 | 43895 | break; |
43822 | 43896 | } |
43823 | 43897 |
@@ -43828,7 +43902,7 @@ | ||
43828 | 43902 | newstack[0] = (uint64_t)stack; // backup stack location |
43829 | 43903 | newstack[1] = 1234567890; |
43830 | 43904 | newstack[2] = base; |
43831 | - newstack[3] = 3703LLU; | |
43905 | + newstack[3] = 3712LLU; | |
43832 | 43906 | stack = newstack; |
43833 | 43907 | // set stack-base & callee-address |
43834 | 43908 | base = 4/*deloffset*/; |
@@ -43835,7 +43909,7 @@ | ||
43835 | 43909 | label = 399LLU; // ~typeidx |
43836 | 43910 | break; |
43837 | 43911 | } |
43838 | - case 3703LLU: // return from ~typeidx to procblock | |
43912 | + case 3712LLU: // return from ~typeidx to procblock | |
43839 | 43913 | { |
43840 | 43914 | stack = (uint64_t *)stack[0]; |
43841 | 43915 | // releasing toplevel container |
@@ -43846,21 +43920,21 @@ | ||
43846 | 43920 | stack[base + 39] = (uint64_t)list->next; |
43847 | 43921 | Free(1, sizeof(struct listnode), list); |
43848 | 43922 | } |
43849 | - label = 3701LLU; // repeat | |
43923 | + label = 3710LLU; // repeat | |
43850 | 43924 | break; |
43851 | 43925 | } |
43852 | - case 3702LLU: // loop finished | |
43926 | + case 3711LLU: // loop finished | |
43853 | 43927 | { |
43854 | - label = 3661LLU; // continue unrolling stack, delete next variable | |
43928 | + label = 3670LLU; // continue unrolling stack, delete next variable | |
43855 | 43929 | break; |
43856 | 43930 | } |
43857 | - case 3700LLU: // skipped deleter | |
43931 | + case 3709LLU: // skipped deleter | |
43858 | 43932 | { |
43859 | 43933 | stack[base + 39] = 0; |
43860 | 43934 | uint64_t *newstack = (uint64_t *)Calloc(160LLU + 1, sizeof(uint64_t)); |
43861 | 43935 | if(!newstack) |
43862 | 43936 | { |
43863 | - label = 3699LLU; // throw: begin to unroll stack | |
43937 | + label = 3708LLU; // throw: begin to unroll stack | |
43864 | 43938 | break; |
43865 | 43939 | } |
43866 | 43940 |
@@ -43867,9 +43941,9 @@ | ||
43867 | 43941 | newstack[160LLU] = 9876543210LLU; // overflow-marker |
43868 | 43942 | // call procblock from procblock |
43869 | 43943 | newstack[0] = (uint64_t)stack; // backup stack location |
43870 | - newstack[1] = 3704LLU; | |
43944 | + newstack[1] = 3713LLU; | |
43871 | 43945 | newstack[2] = base; |
43872 | - newstack[3] = 3705LLU; | |
43946 | + newstack[3] = 3714LLU; | |
43873 | 43947 | // arguments for call to procblock |
43874 | 43948 | newstack[4LLU] = stack[base + 0]/*fndefs*/; |
43875 | 43949 | newstack[5LLU] = stack[base + 1]/*datadefs*/; |
@@ -43892,10 +43966,10 @@ | ||
43892 | 43966 | stack = newstack; |
43893 | 43967 | // set stack-base & callee-address |
43894 | 43968 | base = 4/*deloffset*/; |
43895 | - label = 3429LLU; // procblock | |
43969 | + label = 3438LLU; // procblock | |
43896 | 43970 | break; |
43897 | 43971 | } |
43898 | - case 3704LLU: // copy-back deleter (procblock to procblock) | |
43972 | + case 3713LLU: // copy-back deleter (procblock to procblock) | |
43899 | 43973 | { |
43900 | 43974 | uint64_t *oldstack = (uint64_t *)stack[0]; |
43901 | 43975 | // copy mutable arguments back from call to procblock |
@@ -43912,10 +43986,10 @@ | ||
43912 | 43986 | } |
43913 | 43987 | Free(160LLU + 1, sizeof(uint64_t), stack); |
43914 | 43988 | stack = oldstack; |
43915 | - label = 3699LLU; // continue to unroll stack | |
43989 | + label = 3708LLU; // continue to unroll stack | |
43916 | 43990 | break; |
43917 | 43991 | } |
43918 | - case 3705LLU: // return from procblock to procblock | |
43992 | + case 3714LLU: // return from procblock to procblock | |
43919 | 43993 | { |
43920 | 43994 | uint64_t *oldstack = (uint64_t *)stack[0]; |
43921 | 43995 | // copy mutable arguments back from call to procblock |
@@ -43933,14 +44007,14 @@ | ||
43933 | 44007 | Free(160LLU + 1, sizeof(uint64_t), stack); |
43934 | 44008 | stack = oldstack; |
43935 | 44009 | // delete list |
43936 | - label = 3706LLU; // start to repeat | |
44010 | + label = 3715LLU; // start to repeat | |
43937 | 44011 | break; |
43938 | 44012 | } |
43939 | - case 3706LLU: // repeat from here | |
44013 | + case 3715LLU: // repeat from here | |
43940 | 44014 | { |
43941 | 44015 | if(!stack[base + 39]) |
43942 | 44016 | { |
43943 | - label = 3707LLU; // break loop | |
44017 | + label = 3716LLU; // break loop | |
43944 | 44018 | break; |
43945 | 44019 | } |
43946 | 44020 |
@@ -43951,7 +44025,7 @@ | ||
43951 | 44025 | newstack[0] = (uint64_t)stack; // backup stack location |
43952 | 44026 | newstack[1] = 1234567890; |
43953 | 44027 | newstack[2] = base; |
43954 | - newstack[3] = 3708LLU; | |
44028 | + newstack[3] = 3717LLU; | |
43955 | 44029 | stack = newstack; |
43956 | 44030 | // set stack-base & callee-address |
43957 | 44031 | base = 4/*deloffset*/; |
@@ -43958,7 +44032,7 @@ | ||
43958 | 44032 | label = 399LLU; // ~typeidx |
43959 | 44033 | break; |
43960 | 44034 | } |
43961 | - case 3708LLU: // return from ~typeidx to procblock | |
44035 | + case 3717LLU: // return from ~typeidx to procblock | |
43962 | 44036 | { |
43963 | 44037 | stack = (uint64_t *)stack[0]; |
43964 | 44038 | // releasing toplevel container |
@@ -43969,27 +44043,27 @@ | ||
43969 | 44043 | stack[base + 39] = (uint64_t)list->next; |
43970 | 44044 | Free(1, sizeof(struct listnode), list); |
43971 | 44045 | } |
43972 | - label = 3706LLU; // repeat | |
44046 | + label = 3715LLU; // repeat | |
43973 | 44047 | break; |
43974 | 44048 | } |
43975 | - case 3707LLU: // loop finished | |
44049 | + case 3716LLU: // loop finished | |
43976 | 44050 | { |
43977 | - label = 3696LLU; // alternative complete | |
44051 | + label = 3705LLU; // alternative complete | |
43978 | 44052 | break; |
43979 | 44053 | } |
43980 | - case 3696LLU: // completed if-then-else | |
44054 | + case 3705LLU: // completed if-then-else | |
43981 | 44055 | { |
43982 | 44056 | if(!stack[base + 25]/*consume*/) |
43983 | 44057 | { |
43984 | - label = 3709LLU; // jump to alternative | |
44058 | + label = 3718LLU; // jump to alternative | |
43985 | 44059 | break; |
43986 | 44060 | } |
43987 | 44061 | |
43988 | 44062 | // consequent |
43989 | 44063 | // call closescope from procblock |
43990 | - stack[base + 39LLU] = 3711LLU/*throw to this address*/; | |
44064 | + stack[base + 39LLU] = 3720LLU/*throw to this address*/; | |
43991 | 44065 | stack[base + 40LLU] = base; |
43992 | - stack[base + 41LLU] = 3712LLU; | |
44066 | + stack[base + 41LLU] = 3721LLU; | |
43993 | 44067 | // arguments for call to closescope |
43994 | 44068 | stack[base + 42LLU] = stack[base + 8]/*fnid*/; |
43995 | 44069 | stack[base + 43LLU] = stack[base + 1]/*datadefs*/; |
@@ -43997,25 +44071,25 @@ | ||
43997 | 44071 | stack[base + 45LLU] = stack[base + 17]/*label*/; |
43998 | 44072 | // set stack-base & callee-address |
43999 | 44073 | base += 42LLU; |
44000 | - label = 3190LLU; // closescope | |
44074 | + label = 3199LLU; // closescope | |
44001 | 44075 | break; |
44002 | 44076 | } |
44003 | - case 3711LLU: // copy-back deleter (closescope to procblock) | |
44077 | + case 3720LLU: // copy-back deleter (closescope to procblock) | |
44004 | 44078 | { |
44005 | 44079 | // copy mutable arguments back from call to closescope |
44006 | 44080 | stack[base + 17]/*label*/ = stack[base + 45LLU]; |
44007 | - label = 3661LLU; // continue to roll stack | |
44081 | + label = 3670LLU; // continue to roll stack | |
44008 | 44082 | break; |
44009 | 44083 | } |
44010 | - case 3712LLU: // return from closescope to procblock | |
44084 | + case 3721LLU: // return from closescope to procblock | |
44011 | 44085 | { |
44012 | 44086 | // copy mutable arguments back from call to closescope |
44013 | 44087 | stack[base + 17]/*label*/ = stack[base + 45LLU]; |
44014 | 44088 | printf("%s", "\n label = "); |
44015 | 44089 | // call printnr from procblock |
44016 | - stack[base + 39LLU] = 3713LLU/*throw to this address*/; | |
44090 | + stack[base + 39LLU] = 3722LLU/*throw to this address*/; | |
44017 | 44091 | stack[base + 40LLU] = base; |
44018 | - stack[base + 41LLU] = 3714LLU; | |
44092 | + stack[base + 41LLU] = 3723LLU; | |
44019 | 44093 | // arguments for call to printnr |
44020 | 44094 | stack[base + 42LLU] = stack[base + 24]/*labelskip*/; |
44021 | 44095 | // set stack-base & callee-address |
@@ -44023,13 +44097,13 @@ | ||
44023 | 44097 | label = 18446744073709551590LLU; // printnr |
44024 | 44098 | break; |
44025 | 44099 | } |
44026 | - case 3713LLU: // copy-back deleter (printnr to procblock) | |
44100 | + case 3722LLU: // copy-back deleter (printnr to procblock) | |
44027 | 44101 | { |
44028 | 44102 | // copy mutable arguments back from call to printnr |
44029 | - label = 3661LLU; // continue to roll stack | |
44103 | + label = 3670LLU; // continue to roll stack | |
44030 | 44104 | break; |
44031 | 44105 | } |
44032 | - case 3714LLU: // return from printnr to procblock | |
44106 | + case 3723LLU: // return from printnr to procblock | |
44033 | 44107 | { |
44034 | 44108 | // copy mutable arguments back from call to printnr |
44035 | 44109 | printf("%s", "LLU; // consequent complete"); |
@@ -44037,9 +44111,9 @@ | ||
44037 | 44111 | printf("%s", "\n }"); |
44038 | 44112 | printf("%s", "\n case "); |
44039 | 44113 | // call printnr from procblock |
44040 | - stack[base + 39LLU] = 3715LLU/*throw to this address*/; | |
44114 | + stack[base + 39LLU] = 3724LLU/*throw to this address*/; | |
44041 | 44115 | stack[base + 40LLU] = base; |
44042 | - stack[base + 41LLU] = 3716LLU; | |
44116 | + stack[base + 41LLU] = 3725LLU; | |
44043 | 44117 | // arguments for call to printnr |
44044 | 44118 | stack[base + 42LLU] = stack[base + 35]/*labelfail*/; |
44045 | 44119 | // set stack-base & callee-address |
@@ -44047,21 +44121,21 @@ | ||
44047 | 44121 | label = 18446744073709551590LLU; // printnr |
44048 | 44122 | break; |
44049 | 44123 | } |
44050 | - case 3715LLU: // copy-back deleter (printnr to procblock) | |
44124 | + case 3724LLU: // copy-back deleter (printnr to procblock) | |
44051 | 44125 | { |
44052 | 44126 | // copy mutable arguments back from call to printnr |
44053 | - label = 3661LLU; // continue to roll stack | |
44127 | + label = 3670LLU; // continue to roll stack | |
44054 | 44128 | break; |
44055 | 44129 | } |
44056 | - case 3716LLU: // return from printnr to procblock | |
44130 | + case 3725LLU: // return from printnr to procblock | |
44057 | 44131 | { |
44058 | 44132 | // copy mutable arguments back from call to printnr |
44059 | 44133 | printf("%s", "LLU: // copy-back deleter (if pop)"); |
44060 | 44134 | printf("%s", "\n {"); |
44061 | 44135 | // call closescope from procblock |
44062 | - stack[base + 39LLU] = 3717LLU/*throw to this address*/; | |
44136 | + stack[base + 39LLU] = 3726LLU/*throw to this address*/; | |
44063 | 44137 | stack[base + 40LLU] = base; |
44064 | - stack[base + 41LLU] = 3718LLU; | |
44138 | + stack[base + 41LLU] = 3727LLU; | |
44065 | 44139 | // arguments for call to closescope |
44066 | 44140 | stack[base + 42LLU] = stack[base + 8]/*fnid*/; |
44067 | 44141 | stack[base + 43LLU] = stack[base + 1]/*datadefs*/; |
@@ -44069,25 +44143,25 @@ | ||
44069 | 44143 | stack[base + 45LLU] = stack[base + 17]/*label*/; |
44070 | 44144 | // set stack-base & callee-address |
44071 | 44145 | base += 42LLU; |
44072 | - label = 3190LLU; // closescope | |
44146 | + label = 3199LLU; // closescope | |
44073 | 44147 | break; |
44074 | 44148 | } |
44075 | - case 3717LLU: // copy-back deleter (closescope to procblock) | |
44149 | + case 3726LLU: // copy-back deleter (closescope to procblock) | |
44076 | 44150 | { |
44077 | 44151 | // copy mutable arguments back from call to closescope |
44078 | 44152 | stack[base + 17]/*label*/ = stack[base + 45LLU]; |
44079 | - label = 3661LLU; // continue to roll stack | |
44153 | + label = 3670LLU; // continue to roll stack | |
44080 | 44154 | break; |
44081 | 44155 | } |
44082 | - case 3718LLU: // return from closescope to procblock | |
44156 | + case 3727LLU: // return from closescope to procblock | |
44083 | 44157 | { |
44084 | 44158 | // copy mutable arguments back from call to closescope |
44085 | 44159 | stack[base + 17]/*label*/ = stack[base + 45LLU]; |
44086 | 44160 | printf("%s", "\n label = "); |
44087 | 44161 | // call printnr from procblock |
44088 | - stack[base + 39LLU] = 3719LLU/*throw to this address*/; | |
44162 | + stack[base + 39LLU] = 3728LLU/*throw to this address*/; | |
44089 | 44163 | stack[base + 40LLU] = base; |
44090 | - stack[base + 41LLU] = 3720LLU; | |
44164 | + stack[base + 41LLU] = 3729LLU; | |
44091 | 44165 | // arguments for call to printnr |
44092 | 44166 | stack[base + 42LLU] = stack[base + 34]/*labelthrow*/; |
44093 | 44167 | // set stack-base & callee-address |
@@ -44095,13 +44169,13 @@ | ||
44095 | 44169 | label = 18446744073709551590LLU; // printnr |
44096 | 44170 | break; |
44097 | 44171 | } |
44098 | - case 3719LLU: // copy-back deleter (printnr to procblock) | |
44172 | + case 3728LLU: // copy-back deleter (printnr to procblock) | |
44099 | 44173 | { |
44100 | 44174 | // copy mutable arguments back from call to printnr |
44101 | - label = 3661LLU; // continue to roll stack | |
44175 | + label = 3670LLU; // continue to roll stack | |
44102 | 44176 | break; |
44103 | 44177 | } |
44104 | - case 3720LLU: // return from printnr to procblock | |
44178 | + case 3729LLU: // return from printnr to procblock | |
44105 | 44179 | { |
44106 | 44180 | // copy mutable arguments back from call to printnr |
44107 | 44181 | printf("%s", "LLU; // consequent complete"); |
@@ -44109,9 +44183,9 @@ | ||
44109 | 44183 | printf("%s", "\n }"); |
44110 | 44184 | printf("%s", "\n case "); |
44111 | 44185 | // call printnr from procblock |
44112 | - stack[base + 39LLU] = 3721LLU/*throw to this address*/; | |
44186 | + stack[base + 39LLU] = 3730LLU/*throw to this address*/; | |
44113 | 44187 | stack[base + 40LLU] = base; |
44114 | - stack[base + 41LLU] = 3722LLU; | |
44188 | + stack[base + 41LLU] = 3731LLU; | |
44115 | 44189 | // arguments for call to printnr |
44116 | 44190 | stack[base + 42LLU] = stack[base + 23]/*labelalt*/; |
44117 | 44191 | // set stack-base & callee-address |
@@ -44119,28 +44193,28 @@ | ||
44119 | 44193 | label = 18446744073709551590LLU; // printnr |
44120 | 44194 | break; |
44121 | 44195 | } |
44122 | - case 3721LLU: // copy-back deleter (printnr to procblock) | |
44196 | + case 3730LLU: // copy-back deleter (printnr to procblock) | |
44123 | 44197 | { |
44124 | 44198 | // copy mutable arguments back from call to printnr |
44125 | - label = 3661LLU; // continue to roll stack | |
44199 | + label = 3670LLU; // continue to roll stack | |
44126 | 44200 | break; |
44127 | 44201 | } |
44128 | - case 3722LLU: // return from printnr to procblock | |
44202 | + case 3731LLU: // return from printnr to procblock | |
44129 | 44203 | { |
44130 | 44204 | // copy mutable arguments back from call to printnr |
44131 | 44205 | printf("%s", "LLU: // alternative"); |
44132 | 44206 | printf("%s", "\n {"); |
44133 | - label = 3710LLU; // consequent complete | |
44207 | + label = 3719LLU; // consequent complete | |
44134 | 44208 | break; |
44135 | 44209 | } |
44136 | - case 3709LLU: // alternative | |
44210 | + case 3718LLU: // alternative | |
44137 | 44211 | { |
44138 | 44212 | printf("%s", "\n { // copyback"); |
44139 | 44213 | printf("%s", "\n struct listnode *list = (struct listnode *)"); |
44140 | 44214 | // call emitvaridx from procblock |
44141 | - stack[base + 39LLU] = 3723LLU/*throw to this address*/; | |
44215 | + stack[base + 39LLU] = 3732LLU/*throw to this address*/; | |
44142 | 44216 | stack[base + 40LLU] = base; |
44143 | - stack[base + 41LLU] = 3724LLU; | |
44217 | + stack[base + 41LLU] = 3733LLU; | |
44144 | 44218 | // arguments for call to emitvaridx |
44145 | 44219 | stack[base + 42LLU] = stack[base + 31]/*listindex*/; |
44146 | 44220 | // set stack-base & callee-address |
@@ -44148,20 +44222,20 @@ | ||
44148 | 44222 | label = 745LLU; // emitvaridx |
44149 | 44223 | break; |
44150 | 44224 | } |
44151 | - case 3723LLU: // copy-back deleter (emitvaridx to procblock) | |
44225 | + case 3732LLU: // copy-back deleter (emitvaridx to procblock) | |
44152 | 44226 | { |
44153 | 44227 | // copy mutable arguments back from call to emitvaridx |
44154 | - label = 3661LLU; // continue to roll stack | |
44228 | + label = 3670LLU; // continue to roll stack | |
44155 | 44229 | break; |
44156 | 44230 | } |
44157 | - case 3724LLU: // return from emitvaridx to procblock | |
44231 | + case 3733LLU: // return from emitvaridx to procblock | |
44158 | 44232 | { |
44159 | 44233 | // copy mutable arguments back from call to emitvaridx |
44160 | 44234 | printf("%s", "/*"); |
44161 | 44235 | // call printid from procblock |
44162 | - stack[base + 39LLU] = 3725LLU/*throw to this address*/; | |
44236 | + stack[base + 39LLU] = 3734LLU/*throw to this address*/; | |
44163 | 44237 | stack[base + 40LLU] = base; |
44164 | - stack[base + 41LLU] = 3726LLU; | |
44238 | + stack[base + 41LLU] = 3735LLU; | |
44165 | 44239 | // arguments for call to printid |
44166 | 44240 | stack[base + 42LLU] = stack[base + 30]/*listname*/; |
44167 | 44241 | // set stack-base & callee-address |
@@ -44169,21 +44243,21 @@ | ||
44169 | 44243 | label = 18446744073709551587LLU; // printid |
44170 | 44244 | break; |
44171 | 44245 | } |
44172 | - case 3725LLU: // copy-back deleter (printid to procblock) | |
44246 | + case 3734LLU: // copy-back deleter (printid to procblock) | |
44173 | 44247 | { |
44174 | 44248 | // copy mutable arguments back from call to printid |
44175 | - label = 3661LLU; // continue to roll stack | |
44249 | + label = 3670LLU; // continue to roll stack | |
44176 | 44250 | break; |
44177 | 44251 | } |
44178 | - case 3726LLU: // return from printid to procblock | |
44252 | + case 3735LLU: // return from printid to procblock | |
44179 | 44253 | { |
44180 | 44254 | // copy mutable arguments back from call to printid |
44181 | 44255 | printf("%s", "*/;"); |
44182 | 44256 | printf("%s", "\n list->data = "); |
44183 | 44257 | // call emitvaridx from procblock |
44184 | - stack[base + 39LLU] = 3727LLU/*throw to this address*/; | |
44258 | + stack[base + 39LLU] = 3736LLU/*throw to this address*/; | |
44185 | 44259 | stack[base + 40LLU] = base; |
44186 | - stack[base + 41LLU] = 3728LLU; | |
44260 | + stack[base + 41LLU] = 3737LLU; | |
44187 | 44261 | // arguments for call to emitvaridx |
44188 | 44262 | stack[base + 42LLU] = stack[base + 38]/*elemindex*/; |
44189 | 44263 | // set stack-base & callee-address |
@@ -44191,21 +44265,21 @@ | ||
44191 | 44265 | label = 745LLU; // emitvaridx |
44192 | 44266 | break; |
44193 | 44267 | } |
44194 | - case 3727LLU: // copy-back deleter (emitvaridx to procblock) | |
44268 | + case 3736LLU: // copy-back deleter (emitvaridx to procblock) | |
44195 | 44269 | { |
44196 | 44270 | // copy mutable arguments back from call to emitvaridx |
44197 | - label = 3661LLU; // continue to roll stack | |
44271 | + label = 3670LLU; // continue to roll stack | |
44198 | 44272 | break; |
44199 | 44273 | } |
44200 | - case 3728LLU: // return from emitvaridx to procblock | |
44274 | + case 3737LLU: // return from emitvaridx to procblock | |
44201 | 44275 | { |
44202 | 44276 | // copy mutable arguments back from call to emitvaridx |
44203 | 44277 | printf("%s", ";"); |
44204 | 44278 | printf("%s", "\n list->next = (struct listnode *)"); |
44205 | 44279 | // call emitvar from procblock |
44206 | - stack[base + 39LLU] = 3729LLU/*throw to this address*/; | |
44280 | + stack[base + 39LLU] = 3738LLU/*throw to this address*/; | |
44207 | 44281 | stack[base + 40LLU] = base; |
44208 | - stack[base + 41LLU] = 3730LLU; | |
44282 | + stack[base + 41LLU] = 3739LLU; | |
44209 | 44283 | // arguments for call to emitvar |
44210 | 44284 | stack[base + 42LLU] = stack[base + 8]/*fnid*/; |
44211 | 44285 | stack[base + 43LLU] = stack[base + 30]/*listname*/; |
@@ -44216,13 +44290,13 @@ | ||
44216 | 44290 | label = 749LLU; // emitvar |
44217 | 44291 | break; |
44218 | 44292 | } |
44219 | - case 3729LLU: // copy-back deleter (emitvar to procblock) | |
44293 | + case 3738LLU: // copy-back deleter (emitvar to procblock) | |
44220 | 44294 | { |
44221 | 44295 | // copy mutable arguments back from call to emitvar |
44222 | - label = 3661LLU; // continue to roll stack | |
44296 | + label = 3670LLU; // continue to roll stack | |
44223 | 44297 | break; |
44224 | 44298 | } |
44225 | - case 3730LLU: // return from emitvar to procblock | |
44299 | + case 3739LLU: // return from emitvar to procblock | |
44226 | 44300 | { |
44227 | 44301 | // copy mutable arguments back from call to emitvar |
44228 | 44302 | printf("%s", ";"); |
@@ -44229,9 +44303,9 @@ | ||
44229 | 44303 | printf("%s", "\n }"); |
44230 | 44304 | printf("%s", "\n label = "); |
44231 | 44305 | // call printnr from procblock |
44232 | - stack[base + 39LLU] = 3731LLU/*throw to this address*/; | |
44306 | + stack[base + 39LLU] = 3740LLU/*throw to this address*/; | |
44233 | 44307 | stack[base + 40LLU] = base; |
44234 | - stack[base + 41LLU] = 3732LLU; | |
44308 | + stack[base + 41LLU] = 3741LLU; | |
44235 | 44309 | // arguments for call to printnr |
44236 | 44310 | stack[base + 42LLU] = stack[base + 24]/*labelskip*/; |
44237 | 44311 | // set stack-base & callee-address |
@@ -44239,13 +44313,13 @@ | ||
44239 | 44313 | label = 18446744073709551590LLU; // printnr |
44240 | 44314 | break; |
44241 | 44315 | } |
44242 | - case 3731LLU: // copy-back deleter (printnr to procblock) | |
44316 | + case 3740LLU: // copy-back deleter (printnr to procblock) | |
44243 | 44317 | { |
44244 | 44318 | // copy mutable arguments back from call to printnr |
44245 | - label = 3661LLU; // continue to roll stack | |
44319 | + label = 3670LLU; // continue to roll stack | |
44246 | 44320 | break; |
44247 | 44321 | } |
44248 | - case 3732LLU: // return from printnr to procblock | |
44322 | + case 3741LLU: // return from printnr to procblock | |
44249 | 44323 | { |
44250 | 44324 | // copy mutable arguments back from call to printnr |
44251 | 44325 | printf("%s", "LLU; // consequent complete"); |
@@ -44253,9 +44327,9 @@ | ||
44253 | 44327 | printf("%s", "\n }"); |
44254 | 44328 | printf("%s", "\n case "); |
44255 | 44329 | // call printnr from procblock |
44256 | - stack[base + 39LLU] = 3733LLU/*throw to this address*/; | |
44330 | + stack[base + 39LLU] = 3742LLU/*throw to this address*/; | |
44257 | 44331 | stack[base + 40LLU] = base; |
44258 | - stack[base + 41LLU] = 3734LLU; | |
44332 | + stack[base + 41LLU] = 3743LLU; | |
44259 | 44333 | // arguments for call to printnr |
44260 | 44334 | stack[base + 42LLU] = stack[base + 23]/*labelalt*/; |
44261 | 44335 | // set stack-base & callee-address |
@@ -44263,40 +44337,40 @@ | ||
44263 | 44337 | label = 18446744073709551590LLU; // printnr |
44264 | 44338 | break; |
44265 | 44339 | } |
44266 | - case 3733LLU: // copy-back deleter (printnr to procblock) | |
44340 | + case 3742LLU: // copy-back deleter (printnr to procblock) | |
44267 | 44341 | { |
44268 | 44342 | // copy mutable arguments back from call to printnr |
44269 | - label = 3661LLU; // continue to roll stack | |
44343 | + label = 3670LLU; // continue to roll stack | |
44270 | 44344 | break; |
44271 | 44345 | } |
44272 | - case 3734LLU: // return from printnr to procblock | |
44346 | + case 3743LLU: // return from printnr to procblock | |
44273 | 44347 | { |
44274 | 44348 | // copy mutable arguments back from call to printnr |
44275 | 44349 | printf("%s", "LLU: // alternative"); |
44276 | 44350 | printf("%s", "\n {"); |
44277 | - label = 3710LLU; // alternative complete | |
44351 | + label = 3719LLU; // alternative complete | |
44278 | 44352 | break; |
44279 | 44353 | } |
44280 | - case 3710LLU: // completed if-then-else | |
44354 | + case 3719LLU: // completed if-then-else | |
44281 | 44355 | { |
44282 | 44356 | ((uint64_t **)(stack[base + 29]))[1][0] = stack[base + 36]; |
44283 | - label = 3646LLU; // case complete | |
44357 | + label = 3655LLU; // case complete | |
44284 | 44358 | break; |
44285 | 44359 | } |
44286 | - case 3648LLU: // copy-back deleter (switch) | |
44360 | + case 3657LLU: // copy-back deleter (switch) | |
44287 | 44361 | { |
44288 | 44362 | ((uint64_t **)(stack[base + 29]))[1][0] = stack[base + 36]; |
44289 | - label = 3639LLU; // continue to unroll stack | |
44363 | + label = 3648LLU; // continue to unroll stack | |
44290 | 44364 | break; |
44291 | 44365 | } |
44292 | - case 3647LLU: // try next case | |
44366 | + case 3656LLU: // try next case | |
44293 | 44367 | { |
44294 | 44368 | // default |
44295 | 44369 | fprintf(stderr, "%s", "in function "); |
44296 | 44370 | // call reportid from procblock |
44297 | - stack[base + 36LLU] = 3735LLU/*throw to this address*/; | |
44371 | + stack[base + 36LLU] = 3744LLU/*throw to this address*/; | |
44298 | 44372 | stack[base + 37LLU] = base; |
44299 | - stack[base + 38LLU] = 3736LLU; | |
44373 | + stack[base + 38LLU] = 3745LLU; | |
44300 | 44374 | // arguments for call to reportid |
44301 | 44375 | stack[base + 39LLU] = stack[base + 8]/*fnid*/; |
44302 | 44376 | // set stack-base & callee-address |
@@ -44304,13 +44378,13 @@ | ||
44304 | 44378 | label = 18446744073709551586LLU; // reportid |
44305 | 44379 | break; |
44306 | 44380 | } |
44307 | - case 3735LLU: // copy-back deleter (reportid to procblock) | |
44381 | + case 3744LLU: // copy-back deleter (reportid to procblock) | |
44308 | 44382 | { |
44309 | 44383 | // copy mutable arguments back from call to reportid |
44310 | - label = 3639LLU; // continue to roll stack | |
44384 | + label = 3648LLU; // continue to roll stack | |
44311 | 44385 | break; |
44312 | 44386 | } |
44313 | - case 3736LLU: // return from reportid to procblock | |
44387 | + case 3745LLU: // return from reportid to procblock | |
44314 | 44388 | { |
44315 | 44389 | // copy mutable arguments back from call to reportid |
44316 | 44390 | fprintf(stderr, "%s", ": "); |
@@ -44317,28 +44391,28 @@ | ||
44317 | 44391 | fprintf(stderr, "%s", "can only "); |
44318 | 44392 | if(!stack[base + 25]/*consume*/) |
44319 | 44393 | { |
44320 | - label = 3737LLU; // jump to alternative | |
44394 | + label = 3746LLU; // jump to alternative | |
44321 | 44395 | break; |
44322 | 44396 | } |
44323 | 44397 | |
44324 | 44398 | // consequent |
44325 | 44399 | printf("%s", "pop"); |
44326 | - label = 3738LLU; // consequent complete | |
44400 | + label = 3747LLU; // consequent complete | |
44327 | 44401 | break; |
44328 | 44402 | } |
44329 | - case 3737LLU: // alternative | |
44403 | + case 3746LLU: // alternative | |
44330 | 44404 | { |
44331 | 44405 | printf("%s", "next"); |
44332 | - label = 3738LLU; // alternative complete | |
44406 | + label = 3747LLU; // alternative complete | |
44333 | 44407 | break; |
44334 | 44408 | } |
44335 | - case 3738LLU: // completed if-then-else | |
44409 | + case 3747LLU: // completed if-then-else | |
44336 | 44410 | { |
44337 | 44411 | printf("%s", " from list but type of "); |
44338 | 44412 | // call reportid from procblock |
44339 | - stack[base + 36LLU] = 3739LLU/*throw to this address*/; | |
44413 | + stack[base + 36LLU] = 3748LLU/*throw to this address*/; | |
44340 | 44414 | stack[base + 37LLU] = base; |
44341 | - stack[base + 38LLU] = 3740LLU; | |
44415 | + stack[base + 38LLU] = 3749LLU; | |
44342 | 44416 | // arguments for call to reportid |
44343 | 44417 | stack[base + 39LLU] = stack[base + 30]/*listname*/; |
44344 | 44418 | // set stack-base & callee-address |
@@ -44346,13 +44420,13 @@ | ||
44346 | 44420 | label = 18446744073709551586LLU; // reportid |
44347 | 44421 | break; |
44348 | 44422 | } |
44349 | - case 3739LLU: // copy-back deleter (reportid to procblock) | |
44423 | + case 3748LLU: // copy-back deleter (reportid to procblock) | |
44350 | 44424 | { |
44351 | 44425 | // copy mutable arguments back from call to reportid |
44352 | - label = 3639LLU; // continue to roll stack | |
44426 | + label = 3648LLU; // continue to roll stack | |
44353 | 44427 | break; |
44354 | 44428 | } |
44355 | - case 3740LLU: // return from reportid to procblock | |
44429 | + case 3749LLU: // return from reportid to procblock | |
44356 | 44430 | { |
44357 | 44431 | // copy mutable arguments back from call to reportid |
44358 | 44432 | fprintf(stderr, "%s", " is "); |
@@ -44359,7 +44433,7 @@ | ||
44359 | 44433 | uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t)); |
44360 | 44434 | if(!newstack) |
44361 | 44435 | { |
44362 | - label = 3639LLU; // throw: begin to unroll stack | |
44436 | + label = 3648LLU; // throw: begin to unroll stack | |
44363 | 44437 | break; |
44364 | 44438 | } |
44365 | 44439 |
@@ -44366,9 +44440,9 @@ | ||
44366 | 44440 | newstack[10LLU] = 9876543210LLU; // overflow-marker |
44367 | 44441 | // call reporttype from procblock |
44368 | 44442 | newstack[0] = (uint64_t)stack; // backup stack location |
44369 | - newstack[1] = 3741LLU; | |
44443 | + newstack[1] = 3750LLU; | |
44370 | 44444 | newstack[2] = base; |
44371 | - newstack[3] = 3742LLU; | |
44445 | + newstack[3] = 3751LLU; | |
44372 | 44446 | // arguments for call to reporttype |
44373 | 44447 | newstack[4LLU] = stack[base + 29]/*listtype*/; |
44374 | 44448 | stack = newstack; |
@@ -44377,7 +44451,7 @@ | ||
44377 | 44451 | label = 330LLU; // reporttype |
44378 | 44452 | break; |
44379 | 44453 | } |
44380 | - case 3741LLU: // copy-back deleter (reporttype to procblock) | |
44454 | + case 3750LLU: // copy-back deleter (reporttype to procblock) | |
44381 | 44455 | { |
44382 | 44456 | uint64_t *oldstack = (uint64_t *)stack[0]; |
44383 | 44457 | // copy mutable arguments back from call to reporttype |
@@ -44388,10 +44462,10 @@ | ||
44388 | 44462 | } |
44389 | 44463 | Free(10LLU + 1, sizeof(uint64_t), stack); |
44390 | 44464 | stack = oldstack; |
44391 | - label = 3639LLU; // continue to unroll stack | |
44465 | + label = 3648LLU; // continue to unroll stack | |
44392 | 44466 | break; |
44393 | 44467 | } |
44394 | - case 3742LLU: // return from reporttype to procblock | |
44468 | + case 3751LLU: // return from reporttype to procblock | |
44395 | 44469 | { |
44396 | 44470 | uint64_t *oldstack = (uint64_t *)stack[0]; |
44397 | 44471 | // copy mutable arguments back from call to reporttype |
@@ -44404,20 +44478,20 @@ | ||
44404 | 44478 | stack = oldstack; |
44405 | 44479 | fprintf(stderr, "%s", "\n"); |
44406 | 44480 | { |
44407 | - label = 3639LLU; // throw: begin to unroll stack | |
44481 | + label = 3648LLU; // throw: begin to unroll stack | |
44408 | 44482 | break; |
44409 | 44483 | } |
44410 | 44484 | |
44411 | - label = 3646LLU; // default complete | |
44485 | + label = 3655LLU; // default complete | |
44412 | 44486 | break; |
44413 | 44487 | } |
44414 | - case 3646LLU: // completed switch | |
44488 | + case 3655LLU: // completed switch | |
44415 | 44489 | { |
44416 | 44490 | { // if pop |
44417 | 44491 | struct listnode *list = (struct listnode *)stack[base + 2]/*scopes*/; |
44418 | 44492 | if(!list) |
44419 | 44493 | { |
44420 | - label = 3743LLU; // jump to alternative | |
44494 | + label = 3752LLU; // jump to alternative | |
44421 | 44495 | break; |
44422 | 44496 | } |
44423 | 44497 |
@@ -44434,7 +44508,7 @@ | ||
44434 | 44508 | newstack[0] = (uint64_t)stack; // backup stack location |
44435 | 44509 | newstack[1] = 1234567890; |
44436 | 44510 | newstack[2] = base; |
44437 | - newstack[3] = 3746LLU; | |
44511 | + newstack[3] = 3755LLU; | |
44438 | 44512 | stack = newstack; |
44439 | 44513 | // set stack-base & callee-address |
44440 | 44514 | base = 4/*deloffset*/; |
@@ -44441,16 +44515,16 @@ | ||
44441 | 44515 | label = 562LLU; // ~scope |
44442 | 44516 | break; |
44443 | 44517 | } |
44444 | - case 3746LLU: // return from ~scope to procblock | |
44518 | + case 3755LLU: // return from ~scope to procblock | |
44445 | 44519 | { |
44446 | 44520 | stack = (uint64_t *)stack[0]; |
44447 | 44521 | // releasing toplevel container |
44448 | 44522 | Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 36] - sizeof(uint64_t) * 4)); |
44449 | 44523 | |
44450 | - label = 3744LLU; // consequent complete | |
44524 | + label = 3753LLU; // consequent complete | |
44451 | 44525 | break; |
44452 | 44526 | } |
44453 | - case 3745LLU: // copy-back deleter (if pop) | |
44527 | + case 3754LLU: // copy-back deleter (if pop) | |
44454 | 44528 | { |
44455 | 44529 | |
44456 | 44530 | uint64_t *newstack = (uint64_t *)(stack[base + 36] - sizeof(uint64_t) * 4); |
@@ -44458,7 +44532,7 @@ | ||
44458 | 44532 | newstack[0] = (uint64_t)stack; // backup stack location |
44459 | 44533 | newstack[1] = 1234567890; |
44460 | 44534 | newstack[2] = base; |
44461 | - newstack[3] = 3747LLU; | |
44535 | + newstack[3] = 3756LLU; | |
44462 | 44536 | stack = newstack; |
44463 | 44537 | // set stack-base & callee-address |
44464 | 44538 | base = 4/*deloffset*/; |
@@ -44465,33 +44539,33 @@ | ||
44465 | 44539 | label = 562LLU; // ~scope |
44466 | 44540 | break; |
44467 | 44541 | } |
44468 | - case 3747LLU: // return from ~scope to procblock | |
44542 | + case 3756LLU: // return from ~scope to procblock | |
44469 | 44543 | { |
44470 | 44544 | stack = (uint64_t *)stack[0]; |
44471 | 44545 | // releasing toplevel container |
44472 | 44546 | Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 36] - sizeof(uint64_t) * 4)); |
44473 | 44547 | |
44474 | - label = 3639LLU; // consequent complete | |
44548 | + label = 3648LLU; // consequent complete | |
44475 | 44549 | break; |
44476 | 44550 | } |
44477 | - case 3743LLU: // alternative | |
44551 | + case 3752LLU: // alternative | |
44478 | 44552 | { |
44479 | 44553 | fprintf(stderr, "%s", "INTERNAL ERROR popping scope\n"); |
44480 | 44554 | { |
44481 | - label = 3639LLU; // throw: begin to unroll stack | |
44555 | + label = 3648LLU; // throw: begin to unroll stack | |
44482 | 44556 | break; |
44483 | 44557 | } |
44484 | 44558 | |
44485 | - label = 3744LLU; // alternative complete | |
44559 | + label = 3753LLU; // alternative complete | |
44486 | 44560 | break; |
44487 | 44561 | } |
44488 | - case 3744LLU: // completed if-then-else | |
44562 | + case 3753LLU: // completed if-then-else | |
44489 | 44563 | { |
44490 | 44564 | { // if pop |
44491 | 44565 | struct listnode *list = (struct listnode *)stack[base + 2]/*scopes*/; |
44492 | 44566 | if(!list) |
44493 | 44567 | { |
44494 | - label = 3748LLU; // jump to alternative | |
44568 | + label = 3757LLU; // jump to alternative | |
44495 | 44569 | break; |
44496 | 44570 | } |
44497 | 44571 |
@@ -44508,7 +44582,7 @@ | ||
44508 | 44582 | newstack[0] = (uint64_t)stack; // backup stack location |
44509 | 44583 | newstack[1] = 1234567890; |
44510 | 44584 | newstack[2] = base; |
44511 | - newstack[3] = 3751LLU; | |
44585 | + newstack[3] = 3760LLU; | |
44512 | 44586 | stack = newstack; |
44513 | 44587 | // set stack-base & callee-address |
44514 | 44588 | base = 4/*deloffset*/; |
@@ -44515,16 +44589,16 @@ | ||
44515 | 44589 | label = 562LLU; // ~scope |
44516 | 44590 | break; |
44517 | 44591 | } |
44518 | - case 3751LLU: // return from ~scope to procblock | |
44592 | + case 3760LLU: // return from ~scope to procblock | |
44519 | 44593 | { |
44520 | 44594 | stack = (uint64_t *)stack[0]; |
44521 | 44595 | // releasing toplevel container |
44522 | 44596 | Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 36] - sizeof(uint64_t) * 4)); |
44523 | 44597 | |
44524 | - label = 3749LLU; // consequent complete | |
44598 | + label = 3758LLU; // consequent complete | |
44525 | 44599 | break; |
44526 | 44600 | } |
44527 | - case 3750LLU: // copy-back deleter (if pop) | |
44601 | + case 3759LLU: // copy-back deleter (if pop) | |
44528 | 44602 | { |
44529 | 44603 | |
44530 | 44604 | uint64_t *newstack = (uint64_t *)(stack[base + 36] - sizeof(uint64_t) * 4); |
@@ -44532,7 +44606,7 @@ | ||
44532 | 44606 | newstack[0] = (uint64_t)stack; // backup stack location |
44533 | 44607 | newstack[1] = 1234567890; |
44534 | 44608 | newstack[2] = base; |
44535 | - newstack[3] = 3752LLU; | |
44609 | + newstack[3] = 3761LLU; | |
44536 | 44610 | stack = newstack; |
44537 | 44611 | // set stack-base & callee-address |
44538 | 44612 | base = 4/*deloffset*/; |
@@ -44539,27 +44613,27 @@ | ||
44539 | 44613 | label = 562LLU; // ~scope |
44540 | 44614 | break; |
44541 | 44615 | } |
44542 | - case 3752LLU: // return from ~scope to procblock | |
44616 | + case 3761LLU: // return from ~scope to procblock | |
44543 | 44617 | { |
44544 | 44618 | stack = (uint64_t *)stack[0]; |
44545 | 44619 | // releasing toplevel container |
44546 | 44620 | Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 36] - sizeof(uint64_t) * 4)); |
44547 | 44621 | |
44548 | - label = 3639LLU; // consequent complete | |
44622 | + label = 3648LLU; // consequent complete | |
44549 | 44623 | break; |
44550 | 44624 | } |
44551 | - case 3748LLU: // alternative | |
44625 | + case 3757LLU: // alternative | |
44552 | 44626 | { |
44553 | 44627 | fprintf(stderr, "%s", "INTERNAL ERROR popping scope\n"); |
44554 | 44628 | { |
44555 | - label = 3639LLU; // throw: begin to unroll stack | |
44629 | + label = 3648LLU; // throw: begin to unroll stack | |
44556 | 44630 | break; |
44557 | 44631 | } |
44558 | 44632 | |
44559 | - label = 3749LLU; // alternative complete | |
44633 | + label = 3758LLU; // alternative complete | |
44560 | 44634 | break; |
44561 | 44635 | } |
44562 | - case 3749LLU: // completed if-then-else | |
44636 | + case 3758LLU: // completed if-then-else | |
44563 | 44637 | { |
44564 | 44638 | ((uint64_t **)(stack[base + 28]))[1][4] = stack[base + 33]; |
44565 | 44639 | ((uint64_t **)(stack[base + 28]))[1][3] = stack[base + 32]; |
@@ -44566,10 +44640,10 @@ | ||
44566 | 44640 | ((uint64_t **)(stack[base + 28]))[1][2] = stack[base + 31]; |
44567 | 44641 | ((uint64_t **)(stack[base + 28]))[1][1] = stack[base + 30]; |
44568 | 44642 | ((uint64_t **)(stack[base + 28]))[1][0] = stack[base + 29]; |
44569 | - label = 3619LLU; // case complete | |
44643 | + label = 3628LLU; // case complete | |
44570 | 44644 | break; |
44571 | 44645 | } |
44572 | - case 3621LLU: // copy-back deleter (switch) | |
44646 | + case 3630LLU: // copy-back deleter (switch) | |
44573 | 44647 | { |
44574 | 44648 | ((uint64_t **)(stack[base + 28]))[1][4] = stack[base + 33]; |
44575 | 44649 | ((uint64_t **)(stack[base + 28]))[1][3] = stack[base + 32]; |
@@ -44576,15 +44650,15 @@ | ||
44576 | 44650 | ((uint64_t **)(stack[base + 28]))[1][2] = stack[base + 31]; |
44577 | 44651 | ((uint64_t **)(stack[base + 28]))[1][1] = stack[base + 30]; |
44578 | 44652 | ((uint64_t **)(stack[base + 28]))[1][0] = stack[base + 29]; |
44579 | - label = 3614LLU; // continue to unroll stack | |
44653 | + label = 3623LLU; // continue to unroll stack | |
44580 | 44654 | break; |
44581 | 44655 | } |
44582 | - case 3620LLU: // try next case | |
44656 | + case 3629LLU: // try next case | |
44583 | 44657 | { |
44584 | 44658 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
44585 | 44659 | exit(-1); |
44586 | 44660 | } |
44587 | - case 3619LLU: // completed switch | |
44661 | + case 3628LLU: // completed switch | |
44588 | 44662 | { |
44589 | 44663 | |
44590 | 44664 | uint64_t *newstack = (uint64_t *)(stack[base + 28] - sizeof(uint64_t) * 4); |
@@ -44592,7 +44666,7 @@ | ||
44592 | 44666 | newstack[0] = (uint64_t)stack; // backup stack location |
44593 | 44667 | newstack[1] = 1234567890; |
44594 | 44668 | newstack[2] = base; |
44595 | - newstack[3] = 3753LLU; | |
44669 | + newstack[3] = 3762LLU; | |
44596 | 44670 | stack = newstack; |
44597 | 44671 | // set stack-base & callee-address |
44598 | 44672 | base = 4/*deloffset*/; |
@@ -44599,20 +44673,20 @@ | ||
44599 | 44673 | label = 486LLU; // ~letdef |
44600 | 44674 | break; |
44601 | 44675 | } |
44602 | - case 3753LLU: // return from ~letdef to procblock | |
44676 | + case 3762LLU: // return from ~letdef to procblock | |
44603 | 44677 | { |
44604 | 44678 | stack = (uint64_t *)stack[0]; |
44605 | 44679 | // releasing toplevel container |
44606 | 44680 | Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 28] - sizeof(uint64_t) * 4)); |
44607 | 44681 | |
44608 | - label = 3551LLU; // alternative complete | |
44682 | + label = 3560LLU; // alternative complete | |
44609 | 44683 | break; |
44610 | 44684 | } |
44611 | - case 3551LLU: // completed if-then-else | |
44685 | + case 3560LLU: // completed if-then-else | |
44612 | 44686 | { |
44613 | 44687 | if(!stack[base + 22]/*when*/) |
44614 | 44688 | { |
44615 | - label = 3754LLU; // jump to alternative | |
44689 | + label = 3763LLU; // jump to alternative | |
44616 | 44690 | break; |
44617 | 44691 | } |
44618 | 44692 |
@@ -44619,7 +44693,7 @@ | ||
44619 | 44693 | // consequent |
44620 | 44694 | if(!stack[base + 21]/*returnflag*/) |
44621 | 44695 | { |
44622 | - label = 3756LLU; // jump to alternative | |
44696 | + label = 3765LLU; // jump to alternative | |
44623 | 44697 | break; |
44624 | 44698 | } |
44625 | 44699 |
@@ -44626,9 +44700,9 @@ | ||
44626 | 44700 | // consequent |
44627 | 44701 | fprintf(stderr, "%s", "in function "); |
44628 | 44702 | // call reportid from procblock |
44629 | - stack[base + 25LLU] = 3758LLU/*throw to this address*/; | |
44703 | + stack[base + 25LLU] = 3767LLU/*throw to this address*/; | |
44630 | 44704 | stack[base + 26LLU] = base; |
44631 | - stack[base + 27LLU] = 3759LLU; | |
44705 | + stack[base + 27LLU] = 3768LLU; | |
44632 | 44706 | // arguments for call to reportid |
44633 | 44707 | stack[base + 28LLU] = stack[base + 8]/*fnid*/; |
44634 | 44708 | // set stack-base & callee-address |
@@ -44636,41 +44710,41 @@ | ||
44636 | 44710 | label = 18446744073709551586LLU; // reportid |
44637 | 44711 | break; |
44638 | 44712 | } |
44639 | - case 3758LLU: // copy-back deleter (reportid to procblock) | |
44713 | + case 3767LLU: // copy-back deleter (reportid to procblock) | |
44640 | 44714 | { |
44641 | 44715 | // copy mutable arguments back from call to reportid |
44642 | - label = 3544LLU; // continue to roll stack | |
44716 | + label = 3553LLU; // continue to roll stack | |
44643 | 44717 | break; |
44644 | 44718 | } |
44645 | - case 3759LLU: // return from reportid to procblock | |
44719 | + case 3768LLU: // return from reportid to procblock | |
44646 | 44720 | { |
44647 | 44721 | // copy mutable arguments back from call to reportid |
44648 | 44722 | fprintf(stderr, "%s", ": "); |
44649 | 44723 | fprintf(stderr, "%s", "can't return from when\n"); |
44650 | 44724 | { |
44651 | - label = 3544LLU; // throw: begin to unroll stack | |
44725 | + label = 3553LLU; // throw: begin to unroll stack | |
44652 | 44726 | break; |
44653 | 44727 | } |
44654 | 44728 | |
44655 | - label = 3757LLU; // consequent complete | |
44729 | + label = 3766LLU; // consequent complete | |
44656 | 44730 | break; |
44657 | 44731 | } |
44658 | - case 3756LLU: // alternative | |
44732 | + case 3765LLU: // alternative | |
44659 | 44733 | { |
44660 | - label = 3757LLU; // alternative complete | |
44734 | + label = 3766LLU; // alternative complete | |
44661 | 44735 | break; |
44662 | 44736 | } |
44663 | - case 3757LLU: // completed if-then-else | |
44737 | + case 3766LLU: // completed if-then-else | |
44664 | 44738 | { |
44665 | - label = 3755LLU; // consequent complete | |
44739 | + label = 3764LLU; // consequent complete | |
44666 | 44740 | break; |
44667 | 44741 | } |
44668 | - case 3754LLU: // alternative | |
44742 | + case 3763LLU: // alternative | |
44669 | 44743 | { |
44670 | 44744 | // call matchid from procblock |
44671 | - stack[base + 25LLU] = 3760LLU/*throw to this address*/; | |
44745 | + stack[base + 25LLU] = 3769LLU/*throw to this address*/; | |
44672 | 44746 | stack[base + 26LLU] = base; |
44673 | - stack[base + 27LLU] = 3761LLU; | |
44747 | + stack[base + 27LLU] = 3770LLU; | |
44674 | 44748 | // arguments for call to matchid |
44675 | 44749 | stack[base + 28LLU] = stack[base + 8]/*fnid*/; |
44676 | 44750 | stack[base + 29LLU] = 587642785557905408LLU; |
@@ -44680,21 +44754,21 @@ | ||
44680 | 44754 | label = 256LLU; // matchid |
44681 | 44755 | break; |
44682 | 44756 | } |
44683 | - case 3760LLU: // copy-back deleter (matchid to procblock) | |
44757 | + case 3769LLU: // copy-back deleter (matchid to procblock) | |
44684 | 44758 | { |
44685 | 44759 | // copy mutable arguments back from call to matchid |
44686 | 44760 | stack[base + 19]/*lookahead*/ = stack[base + 30LLU]; |
44687 | - label = 3544LLU; // continue to roll stack | |
44761 | + label = 3553LLU; // continue to roll stack | |
44688 | 44762 | break; |
44689 | 44763 | } |
44690 | - case 3761LLU: // return from matchid to procblock | |
44764 | + case 3770LLU: // return from matchid to procblock | |
44691 | 44765 | { |
44692 | 44766 | // copy mutable arguments back from call to matchid |
44693 | 44767 | stack[base + 19]/*lookahead*/ = stack[base + 30LLU]; |
44694 | 44768 | // call matchsym from procblock |
44695 | - stack[base + 25LLU] = 3762LLU/*throw to this address*/; | |
44769 | + stack[base + 25LLU] = 3771LLU/*throw to this address*/; | |
44696 | 44770 | stack[base + 26LLU] = base; |
44697 | - stack[base + 27LLU] = 3763LLU; | |
44771 | + stack[base + 27LLU] = 3772LLU; | |
44698 | 44772 | // arguments for call to matchsym |
44699 | 44773 | stack[base + 28LLU] = stack[base + 8]/*fnid*/; |
44700 | 44774 | stack[base + 29LLU] = 123LLU; |
@@ -44704,20 +44778,20 @@ | ||
44704 | 44778 | label = 246LLU; // matchsym |
44705 | 44779 | break; |
44706 | 44780 | } |
44707 | - case 3762LLU: // copy-back deleter (matchsym to procblock) | |
44781 | + case 3771LLU: // copy-back deleter (matchsym to procblock) | |
44708 | 44782 | { |
44709 | 44783 | // copy mutable arguments back from call to matchsym |
44710 | 44784 | stack[base + 19]/*lookahead*/ = stack[base + 30LLU]; |
44711 | - label = 3544LLU; // continue to roll stack | |
44785 | + label = 3553LLU; // continue to roll stack | |
44712 | 44786 | break; |
44713 | 44787 | } |
44714 | - case 3763LLU: // return from matchsym to procblock | |
44788 | + case 3772LLU: // return from matchsym to procblock | |
44715 | 44789 | { |
44716 | 44790 | // copy mutable arguments back from call to matchsym |
44717 | 44791 | stack[base + 19]/*lookahead*/ = stack[base + 30LLU]; |
44718 | 44792 | if(!stack[base + 21]/*returnflag*/) |
44719 | 44793 | { |
44720 | - label = 3764LLU; // jump to alternative | |
44794 | + label = 3773LLU; // jump to alternative | |
44721 | 44795 | break; |
44722 | 44796 | } |
44723 | 44797 |
@@ -44725,7 +44799,7 @@ | ||
44725 | 44799 | uint64_t *newstack = (uint64_t *)Calloc(160LLU + 1, sizeof(uint64_t)); |
44726 | 44800 | if(!newstack) |
44727 | 44801 | { |
44728 | - label = 3544LLU; // throw: begin to unroll stack | |
44802 | + label = 3553LLU; // throw: begin to unroll stack | |
44729 | 44803 | break; |
44730 | 44804 | } |
44731 | 44805 |
@@ -44732,9 +44806,9 @@ | ||
44732 | 44806 | newstack[160LLU] = 9876543210LLU; // overflow-marker |
44733 | 44807 | // call procblock from procblock |
44734 | 44808 | newstack[0] = (uint64_t)stack; // backup stack location |
44735 | - newstack[1] = 3766LLU; | |
44809 | + newstack[1] = 3775LLU; | |
44736 | 44810 | newstack[2] = base; |
44737 | - newstack[3] = 3767LLU; | |
44811 | + newstack[3] = 3776LLU; | |
44738 | 44812 | // arguments for call to procblock |
44739 | 44813 | newstack[4LLU] = stack[base + 0]/*fndefs*/; |
44740 | 44814 | newstack[5LLU] = stack[base + 1]/*datadefs*/; |
@@ -44757,10 +44831,10 @@ | ||
44757 | 44831 | stack = newstack; |
44758 | 44832 | // set stack-base & callee-address |
44759 | 44833 | base = 4/*deloffset*/; |
44760 | - label = 3429LLU; // procblock | |
44834 | + label = 3438LLU; // procblock | |
44761 | 44835 | break; |
44762 | 44836 | } |
44763 | - case 3766LLU: // copy-back deleter (procblock to procblock) | |
44837 | + case 3775LLU: // copy-back deleter (procblock to procblock) | |
44764 | 44838 | { |
44765 | 44839 | uint64_t *oldstack = (uint64_t *)stack[0]; |
44766 | 44840 | // copy mutable arguments back from call to procblock |
@@ -44777,10 +44851,10 @@ | ||
44777 | 44851 | } |
44778 | 44852 | Free(160LLU + 1, sizeof(uint64_t), stack); |
44779 | 44853 | stack = oldstack; |
44780 | - label = 3544LLU; // continue to unroll stack | |
44854 | + label = 3553LLU; // continue to unroll stack | |
44781 | 44855 | break; |
44782 | 44856 | } |
44783 | - case 3767LLU: // return from procblock to procblock | |
44857 | + case 3776LLU: // return from procblock to procblock | |
44784 | 44858 | { |
44785 | 44859 | uint64_t *oldstack = (uint64_t *)stack[0]; |
44786 | 44860 | // copy mutable arguments back from call to procblock |
@@ -44798,9 +44872,9 @@ | ||
44798 | 44872 | Free(160LLU + 1, sizeof(uint64_t), stack); |
44799 | 44873 | stack = oldstack; |
44800 | 44874 | // call MATCHPEEK from procblock |
44801 | - stack[base + 25LLU] = 3768LLU/*throw to this address*/; | |
44875 | + stack[base + 25LLU] = 3777LLU/*throw to this address*/; | |
44802 | 44876 | stack[base + 26LLU] = base; |
44803 | - stack[base + 27LLU] = 3769LLU; | |
44877 | + stack[base + 27LLU] = 3778LLU; | |
44804 | 44878 | // arguments for call to MATCHPEEK |
44805 | 44879 | stack[base + 28LLU] = stack[base + 8]/*fnid*/; |
44806 | 44880 | stack[base + 29LLU] = 125LLU; |
@@ -44810,21 +44884,21 @@ | ||
44810 | 44884 | label = 206LLU; // MATCHPEEK |
44811 | 44885 | break; |
44812 | 44886 | } |
44813 | - case 3768LLU: // copy-back deleter (MATCHPEEK to procblock) | |
44887 | + case 3777LLU: // copy-back deleter (MATCHPEEK to procblock) | |
44814 | 44888 | { |
44815 | 44889 | // copy mutable arguments back from call to MATCHPEEK |
44816 | 44890 | stack[base + 19]/*lookahead*/ = stack[base + 30LLU]; |
44817 | - label = 3544LLU; // continue to roll stack | |
44891 | + label = 3553LLU; // continue to roll stack | |
44818 | 44892 | break; |
44819 | 44893 | } |
44820 | - case 3769LLU: // return from MATCHPEEK to procblock | |
44894 | + case 3778LLU: // return from MATCHPEEK to procblock | |
44821 | 44895 | { |
44822 | 44896 | // copy mutable arguments back from call to MATCHPEEK |
44823 | 44897 | stack[base + 19]/*lookahead*/ = stack[base + 30LLU]; |
44824 | 44898 | // call EOSbyte from procblock |
44825 | - stack[base + 25LLU] = 3770LLU/*throw to this address*/; | |
44899 | + stack[base + 25LLU] = 3779LLU/*throw to this address*/; | |
44826 | 44900 | stack[base + 26LLU] = base; |
44827 | - stack[base + 27LLU] = 3771LLU; | |
44901 | + stack[base + 27LLU] = 3780LLU; | |
44828 | 44902 | // arguments for call to EOSbyte |
44829 | 44903 | // set stack-base & callee-address |
44830 | 44904 | base += 28LLU; |
@@ -44831,42 +44905,42 @@ | ||
44831 | 44905 | label = 77LLU; // EOSbyte |
44832 | 44906 | break; |
44833 | 44907 | } |
44834 | - case 3770LLU: // copy-back deleter (EOSbyte to procblock) | |
44908 | + case 3779LLU: // copy-back deleter (EOSbyte to procblock) | |
44835 | 44909 | { |
44836 | 44910 | // copy mutable arguments back from call to EOSbyte |
44837 | - label = 3544LLU; // continue to roll stack | |
44911 | + label = 3553LLU; // continue to roll stack | |
44838 | 44912 | break; |
44839 | 44913 | } |
44840 | - case 3771LLU: // return from EOSbyte to procblock | |
44914 | + case 3780LLU: // return from EOSbyte to procblock | |
44841 | 44915 | { |
44842 | 44916 | // copy mutable arguments back from call to EOSbyte |
44843 | 44917 | // copy back results provided by call to EOSbyte |
44844 | 44918 | stack[base + 19] = stack[base + 28LLU]; |
44845 | - label = 3765LLU; // consequent complete | |
44919 | + label = 3774LLU; // consequent complete | |
44846 | 44920 | break; |
44847 | 44921 | } |
44848 | - case 3764LLU: // alternative | |
44922 | + case 3773LLU: // alternative | |
44849 | 44923 | { |
44850 | - label = 3773LLU; // skip deleter | |
44924 | + label = 3782LLU; // skip deleter | |
44851 | 44925 | break; |
44852 | 44926 | } |
44853 | - case 3772LLU: // deleter | |
44927 | + case 3781LLU: // deleter | |
44854 | 44928 | { |
44855 | 44929 | // throw from procblock |
44856 | 44930 | if(!stack[base + 25]) |
44857 | 44931 | { |
44858 | - label = 3544LLU; // skip, variable already deleted/unscoped | |
44932 | + label = 3553LLU; // skip, variable already deleted/unscoped | |
44859 | 44933 | break; |
44860 | 44934 | } |
44861 | 44935 | // delete list |
44862 | - label = 3774LLU; // start to repeat | |
44936 | + label = 3783LLU; // start to repeat | |
44863 | 44937 | break; |
44864 | 44938 | } |
44865 | - case 3774LLU: // repeat from here | |
44939 | + case 3783LLU: // repeat from here | |
44866 | 44940 | { |
44867 | 44941 | if(!stack[base + 25]) |
44868 | 44942 | { |
44869 | - label = 3775LLU; // break loop | |
44943 | + label = 3784LLU; // break loop | |
44870 | 44944 | break; |
44871 | 44945 | } |
44872 | 44946 |
@@ -44877,7 +44951,7 @@ | ||
44877 | 44951 | newstack[0] = (uint64_t)stack; // backup stack location |
44878 | 44952 | newstack[1] = 1234567890; |
44879 | 44953 | newstack[2] = base; |
44880 | - newstack[3] = 3776LLU; | |
44954 | + newstack[3] = 3785LLU; | |
44881 | 44955 | stack = newstack; |
44882 | 44956 | // set stack-base & callee-address |
44883 | 44957 | base = 4/*deloffset*/; |
@@ -44884,7 +44958,7 @@ | ||
44884 | 44958 | label = 399LLU; // ~typeidx |
44885 | 44959 | break; |
44886 | 44960 | } |
44887 | - case 3776LLU: // return from ~typeidx to procblock | |
44961 | + case 3785LLU: // return from ~typeidx to procblock | |
44888 | 44962 | { |
44889 | 44963 | stack = (uint64_t *)stack[0]; |
44890 | 44964 | // releasing toplevel container |
@@ -44895,21 +44969,21 @@ | ||
44895 | 44969 | stack[base + 25] = (uint64_t)list->next; |
44896 | 44970 | Free(1, sizeof(struct listnode), list); |
44897 | 44971 | } |
44898 | - label = 3774LLU; // repeat | |
44972 | + label = 3783LLU; // repeat | |
44899 | 44973 | break; |
44900 | 44974 | } |
44901 | - case 3775LLU: // loop finished | |
44975 | + case 3784LLU: // loop finished | |
44902 | 44976 | { |
44903 | - label = 3544LLU; // continue unrolling stack, delete next variable | |
44977 | + label = 3553LLU; // continue unrolling stack, delete next variable | |
44904 | 44978 | break; |
44905 | 44979 | } |
44906 | - case 3773LLU: // skipped deleter | |
44980 | + case 3782LLU: // skipped deleter | |
44907 | 44981 | { |
44908 | 44982 | stack[base + 25] = 0; |
44909 | 44983 | uint64_t *newstack = (uint64_t *)Calloc(160LLU + 1, sizeof(uint64_t)); |
44910 | 44984 | if(!newstack) |
44911 | 44985 | { |
44912 | - label = 3772LLU; // throw: begin to unroll stack | |
44986 | + label = 3781LLU; // throw: begin to unroll stack | |
44913 | 44987 | break; |
44914 | 44988 | } |
44915 | 44989 |
@@ -44916,9 +44990,9 @@ | ||
44916 | 44990 | newstack[160LLU] = 9876543210LLU; // overflow-marker |
44917 | 44991 | // call procblock from procblock |
44918 | 44992 | newstack[0] = (uint64_t)stack; // backup stack location |
44919 | - newstack[1] = 3777LLU; | |
44993 | + newstack[1] = 3786LLU; | |
44920 | 44994 | newstack[2] = base; |
44921 | - newstack[3] = 3778LLU; | |
44995 | + newstack[3] = 3787LLU; | |
44922 | 44996 | // arguments for call to procblock |
44923 | 44997 | newstack[4LLU] = stack[base + 0]/*fndefs*/; |
44924 | 44998 | newstack[5LLU] = stack[base + 1]/*datadefs*/; |
@@ -44941,10 +45015,10 @@ | ||
44941 | 45015 | stack = newstack; |
44942 | 45016 | // set stack-base & callee-address |
44943 | 45017 | base = 4/*deloffset*/; |
44944 | - label = 3429LLU; // procblock | |
45018 | + label = 3438LLU; // procblock | |
44945 | 45019 | break; |
44946 | 45020 | } |
44947 | - case 3777LLU: // copy-back deleter (procblock to procblock) | |
45021 | + case 3786LLU: // copy-back deleter (procblock to procblock) | |
44948 | 45022 | { |
44949 | 45023 | uint64_t *oldstack = (uint64_t *)stack[0]; |
44950 | 45024 | // copy mutable arguments back from call to procblock |
@@ -44961,10 +45035,10 @@ | ||
44961 | 45035 | } |
44962 | 45036 | Free(160LLU + 1, sizeof(uint64_t), stack); |
44963 | 45037 | stack = oldstack; |
44964 | - label = 3772LLU; // continue to unroll stack | |
45038 | + label = 3781LLU; // continue to unroll stack | |
44965 | 45039 | break; |
44966 | 45040 | } |
44967 | - case 3778LLU: // return from procblock to procblock | |
45041 | + case 3787LLU: // return from procblock to procblock | |
44968 | 45042 | { |
44969 | 45043 | uint64_t *oldstack = (uint64_t *)stack[0]; |
44970 | 45044 | // copy mutable arguments back from call to procblock |
@@ -44982,14 +45056,14 @@ | ||
44982 | 45056 | Free(160LLU + 1, sizeof(uint64_t), stack); |
44983 | 45057 | stack = oldstack; |
44984 | 45058 | // delete list |
44985 | - label = 3779LLU; // start to repeat | |
45059 | + label = 3788LLU; // start to repeat | |
44986 | 45060 | break; |
44987 | 45061 | } |
44988 | - case 3779LLU: // repeat from here | |
45062 | + case 3788LLU: // repeat from here | |
44989 | 45063 | { |
44990 | 45064 | if(!stack[base + 25]) |
44991 | 45065 | { |
44992 | - label = 3780LLU; // break loop | |
45066 | + label = 3789LLU; // break loop | |
44993 | 45067 | break; |
44994 | 45068 | } |
44995 | 45069 |
@@ -45000,7 +45074,7 @@ | ||
45000 | 45074 | newstack[0] = (uint64_t)stack; // backup stack location |
45001 | 45075 | newstack[1] = 1234567890; |
45002 | 45076 | newstack[2] = base; |
45003 | - newstack[3] = 3781LLU; | |
45077 | + newstack[3] = 3790LLU; | |
45004 | 45078 | stack = newstack; |
45005 | 45079 | // set stack-base & callee-address |
45006 | 45080 | base = 4/*deloffset*/; |
@@ -45007,7 +45081,7 @@ | ||
45007 | 45081 | label = 399LLU; // ~typeidx |
45008 | 45082 | break; |
45009 | 45083 | } |
45010 | - case 3781LLU: // return from ~typeidx to procblock | |
45084 | + case 3790LLU: // return from ~typeidx to procblock | |
45011 | 45085 | { |
45012 | 45086 | stack = (uint64_t *)stack[0]; |
45013 | 45087 | // releasing toplevel container |
@@ -45018,26 +45092,26 @@ | ||
45018 | 45092 | stack[base + 25] = (uint64_t)list->next; |
45019 | 45093 | Free(1, sizeof(struct listnode), list); |
45020 | 45094 | } |
45021 | - label = 3779LLU; // repeat | |
45095 | + label = 3788LLU; // repeat | |
45022 | 45096 | break; |
45023 | 45097 | } |
45024 | - case 3780LLU: // loop finished | |
45098 | + case 3789LLU: // loop finished | |
45025 | 45099 | { |
45026 | - label = 3765LLU; // alternative complete | |
45100 | + label = 3774LLU; // alternative complete | |
45027 | 45101 | break; |
45028 | 45102 | } |
45029 | - case 3765LLU: // completed if-then-else | |
45103 | + case 3774LLU: // completed if-then-else | |
45030 | 45104 | { |
45031 | - label = 3755LLU; // alternative complete | |
45105 | + label = 3764LLU; // alternative complete | |
45032 | 45106 | break; |
45033 | 45107 | } |
45034 | - case 3755LLU: // completed if-then-else | |
45108 | + case 3764LLU: // completed if-then-else | |
45035 | 45109 | { |
45036 | 45110 | printf("%s", "\n label = "); |
45037 | 45111 | // call printnr from procblock |
45038 | - stack[base + 25LLU] = 3782LLU/*throw to this address*/; | |
45112 | + stack[base + 25LLU] = 3791LLU/*throw to this address*/; | |
45039 | 45113 | stack[base + 26LLU] = base; |
45040 | - stack[base + 27LLU] = 3783LLU; | |
45114 | + stack[base + 27LLU] = 3792LLU; | |
45041 | 45115 | // arguments for call to printnr |
45042 | 45116 | stack[base + 28LLU] = stack[base + 24]/*labelskip*/; |
45043 | 45117 | // set stack-base & callee-address |
@@ -45045,13 +45119,13 @@ | ||
45045 | 45119 | label = 18446744073709551590LLU; // printnr |
45046 | 45120 | break; |
45047 | 45121 | } |
45048 | - case 3782LLU: // copy-back deleter (printnr to procblock) | |
45122 | + case 3791LLU: // copy-back deleter (printnr to procblock) | |
45049 | 45123 | { |
45050 | 45124 | // copy mutable arguments back from call to printnr |
45051 | - label = 3544LLU; // continue to roll stack | |
45125 | + label = 3553LLU; // continue to roll stack | |
45052 | 45126 | break; |
45053 | 45127 | } |
45054 | - case 3783LLU: // return from printnr to procblock | |
45128 | + case 3792LLU: // return from printnr to procblock | |
45055 | 45129 | { |
45056 | 45130 | // copy mutable arguments back from call to printnr |
45057 | 45131 | printf("%s", "LLU; // alternative complete"); |
@@ -45059,9 +45133,9 @@ | ||
45059 | 45133 | printf("%s", "\n }"); |
45060 | 45134 | printf("%s", "\n case "); |
45061 | 45135 | // call printnr from procblock |
45062 | - stack[base + 25LLU] = 3784LLU/*throw to this address*/; | |
45136 | + stack[base + 25LLU] = 3793LLU/*throw to this address*/; | |
45063 | 45137 | stack[base + 26LLU] = base; |
45064 | - stack[base + 27LLU] = 3785LLU; | |
45138 | + stack[base + 27LLU] = 3794LLU; | |
45065 | 45139 | // arguments for call to printnr |
45066 | 45140 | stack[base + 28LLU] = stack[base + 24]/*labelskip*/; |
45067 | 45141 | // set stack-base & callee-address |
@@ -45069,26 +45143,26 @@ | ||
45069 | 45143 | label = 18446744073709551590LLU; // printnr |
45070 | 45144 | break; |
45071 | 45145 | } |
45072 | - case 3784LLU: // copy-back deleter (printnr to procblock) | |
45146 | + case 3793LLU: // copy-back deleter (printnr to procblock) | |
45073 | 45147 | { |
45074 | 45148 | // copy mutable arguments back from call to printnr |
45075 | - label = 3544LLU; // continue to roll stack | |
45149 | + label = 3553LLU; // continue to roll stack | |
45076 | 45150 | break; |
45077 | 45151 | } |
45078 | - case 3785LLU: // return from printnr to procblock | |
45152 | + case 3794LLU: // return from printnr to procblock | |
45079 | 45153 | { |
45080 | 45154 | // copy mutable arguments back from call to printnr |
45081 | 45155 | printf("%s", "LLU: // completed if-then-else"); |
45082 | 45156 | printf("%s", "\n {"); |
45083 | - label = 3537LLU; // consequent complete | |
45157 | + label = 3546LLU; // consequent complete | |
45084 | 45158 | break; |
45085 | 45159 | } |
45086 | - case 3536LLU: // alternative | |
45160 | + case 3545LLU: // alternative | |
45087 | 45161 | { |
45088 | 45162 | // call equ from procblock |
45089 | - stack[base + 23LLU] = 3786LLU/*throw to this address*/; | |
45163 | + stack[base + 23LLU] = 3795LLU/*throw to this address*/; | |
45090 | 45164 | stack[base + 24LLU] = base; |
45091 | - stack[base + 25LLU] = 3787LLU; | |
45165 | + stack[base + 25LLU] = 3796LLU; | |
45092 | 45166 | // arguments for call to equ |
45093 | 45167 | stack[base + 27LLU] = stack[base + 16]/*content*/; |
45094 | 45168 | stack[base + 28LLU] = 910732593752702976LLU; |
@@ -45097,13 +45171,13 @@ | ||
45097 | 45171 | label = 18446744073709551600LLU; // equ |
45098 | 45172 | break; |
45099 | 45173 | } |
45100 | - case 3786LLU: // copy-back deleter (equ to procblock) | |
45174 | + case 3795LLU: // copy-back deleter (equ to procblock) | |
45101 | 45175 | { |
45102 | 45176 | // copy mutable arguments back from call to equ |
45103 | - label = 3528LLU; // continue to roll stack | |
45177 | + label = 3537LLU; // continue to roll stack | |
45104 | 45178 | break; |
45105 | 45179 | } |
45106 | - case 3787LLU: // return from equ to procblock | |
45180 | + case 3796LLU: // return from equ to procblock | |
45107 | 45181 | { |
45108 | 45182 | // copy mutable arguments back from call to equ |
45109 | 45183 | // copy back results provided by call to equ |
@@ -45110,20 +45184,20 @@ | ||
45110 | 45184 | stack[base + 20] = stack[base + 26LLU]; |
45111 | 45185 | if(!stack[base + 20]/*isequal*/) |
45112 | 45186 | { |
45113 | - label = 3788LLU; // jump to alternative | |
45187 | + label = 3797LLU; // jump to alternative | |
45114 | 45188 | break; |
45115 | 45189 | } |
45116 | 45190 | |
45117 | 45191 | // consequent |
45118 | - label = 3791LLU; // skip deleter | |
45192 | + label = 3800LLU; // skip deleter | |
45119 | 45193 | break; |
45120 | 45194 | } |
45121 | - case 3790LLU: // deleter | |
45195 | + case 3799LLU: // deleter | |
45122 | 45196 | { |
45123 | 45197 | // throw from procblock |
45124 | 45198 | if(!stack[base + 23]) |
45125 | 45199 | { |
45126 | - label = 3528LLU; // skip, variable already deleted/unscoped | |
45200 | + label = 3537LLU; // skip, variable already deleted/unscoped | |
45127 | 45201 | break; |
45128 | 45202 | } |
45129 | 45203 |
@@ -45132,7 +45206,7 @@ | ||
45132 | 45206 | newstack[0] = (uint64_t)stack; // backup stack location |
45133 | 45207 | newstack[1] = 1234567890; |
45134 | 45208 | newstack[2] = base; |
45135 | - newstack[3] = 3792LLU; | |
45209 | + newstack[3] = 3801LLU; | |
45136 | 45210 | stack = newstack; |
45137 | 45211 | // set stack-base & callee-address |
45138 | 45212 | base = 4/*deloffset*/; |
@@ -45139,21 +45213,21 @@ | ||
45139 | 45213 | label = 562LLU; // ~scope |
45140 | 45214 | break; |
45141 | 45215 | } |
45142 | - case 3792LLU: // return from ~scope to procblock | |
45216 | + case 3801LLU: // return from ~scope to procblock | |
45143 | 45217 | { |
45144 | 45218 | stack = (uint64_t *)stack[0]; |
45145 | 45219 | // releasing toplevel container |
45146 | 45220 | Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 23] - sizeof(uint64_t) * 4)); |
45147 | 45221 | |
45148 | - label = 3528LLU; // continue unrolling stack, delete next variable | |
45222 | + label = 3537LLU; // continue unrolling stack, delete next variable | |
45149 | 45223 | break; |
45150 | 45224 | } |
45151 | - case 3791LLU: // skipped deleter | |
45225 | + case 3800LLU: // skipped deleter | |
45152 | 45226 | { |
45153 | 45227 | // call linkscope from procblock |
45154 | - stack[base + 24LLU] = 3793LLU/*throw to this address*/; | |
45228 | + stack[base + 24LLU] = 3802LLU/*throw to this address*/; | |
45155 | 45229 | stack[base + 25LLU] = base; |
45156 | - stack[base + 26LLU] = 3794LLU; | |
45230 | + stack[base + 26LLU] = 3803LLU; | |
45157 | 45231 | // arguments for call to linkscope |
45158 | 45232 | stack[base + 28LLU] = stack[base + 3]/*scope*/; |
45159 | 45233 | // set stack-base & callee-address |
@@ -45161,13 +45235,13 @@ | ||
45161 | 45235 | label = 589LLU; // linkscope |
45162 | 45236 | break; |
45163 | 45237 | } |
45164 | - case 3793LLU: // copy-back deleter (linkscope to procblock) | |
45238 | + case 3802LLU: // copy-back deleter (linkscope to procblock) | |
45165 | 45239 | { |
45166 | 45240 | // copy mutable arguments back from call to linkscope |
45167 | - label = 3528LLU; // continue to roll stack | |
45241 | + label = 3537LLU; // continue to roll stack | |
45168 | 45242 | break; |
45169 | 45243 | } |
45170 | - case 3794LLU: // return from linkscope to procblock | |
45244 | + case 3803LLU: // return from linkscope to procblock | |
45171 | 45245 | { |
45172 | 45246 | // copy mutable arguments back from call to linkscope |
45173 | 45247 | // copy back results provided by call to linkscope |
@@ -45187,9 +45261,9 @@ | ||
45187 | 45261 | MOVE(&list->data, &stack[base + 23]/*newscope*/); |
45188 | 45262 | } |
45189 | 45263 | // call add from procblock |
45190 | - stack[base + 23LLU] = 3795LLU/*throw to this address*/; | |
45264 | + stack[base + 23LLU] = 3804LLU/*throw to this address*/; | |
45191 | 45265 | stack[base + 24LLU] = base; |
45192 | - stack[base + 25LLU] = 3796LLU; | |
45266 | + stack[base + 25LLU] = 3805LLU; | |
45193 | 45267 | // arguments for call to add |
45194 | 45268 | stack[base + 27LLU] = 1LLU; |
45195 | 45269 | stack[base + 28LLU] = stack[base + 17]/*label*/; |
@@ -45198,38 +45272,38 @@ | ||
45198 | 45272 | label = 18446744073709551605LLU; // add |
45199 | 45273 | break; |
45200 | 45274 | } |
45201 | - case 3795LLU: // copy-back deleter (add to procblock) | |
45275 | + case 3804LLU: // copy-back deleter (add to procblock) | |
45202 | 45276 | { |
45203 | 45277 | // copy mutable arguments back from call to add |
45204 | - label = 3528LLU; // continue to roll stack | |
45278 | + label = 3537LLU; // continue to roll stack | |
45205 | 45279 | break; |
45206 | 45280 | } |
45207 | - case 3796LLU: // return from add to procblock | |
45281 | + case 3805LLU: // return from add to procblock | |
45208 | 45282 | { |
45209 | 45283 | // copy mutable arguments back from call to add |
45210 | 45284 | // copy back results provided by call to add |
45211 | 45285 | stack[base + 17] = stack[base + 26LLU]; |
45212 | - label = 3798LLU; // skip deleter | |
45286 | + label = 3807LLU; // skip deleter | |
45213 | 45287 | break; |
45214 | 45288 | } |
45215 | - case 3797LLU: // deleter | |
45289 | + case 3806LLU: // deleter | |
45216 | 45290 | { |
45217 | 45291 | // throw from procblock |
45218 | 45292 | if(!stack[base + 23]) |
45219 | 45293 | { |
45220 | - label = 3528LLU; // skip, variable already deleted/unscoped | |
45294 | + label = 3537LLU; // skip, variable already deleted/unscoped | |
45221 | 45295 | break; |
45222 | 45296 | } |
45223 | - label = 3528LLU; // continue unrolling stack, delete next variable | |
45297 | + label = 3537LLU; // continue unrolling stack, delete next variable | |
45224 | 45298 | break; |
45225 | 45299 | } |
45226 | - case 3798LLU: // skipped deleter | |
45300 | + case 3807LLU: // skipped deleter | |
45227 | 45301 | { |
45228 | 45302 | stack[base + 23] = stack[base + 17]/*label*/; |
45229 | 45303 | // call add from procblock |
45230 | - stack[base + 24LLU] = 3799LLU/*throw to this address*/; | |
45304 | + stack[base + 24LLU] = 3808LLU/*throw to this address*/; | |
45231 | 45305 | stack[base + 25LLU] = base; |
45232 | - stack[base + 26LLU] = 3800LLU; | |
45306 | + stack[base + 26LLU] = 3809LLU; | |
45233 | 45307 | // arguments for call to add |
45234 | 45308 | stack[base + 28LLU] = 1LLU; |
45235 | 45309 | stack[base + 29LLU] = stack[base + 17]/*label*/; |
@@ -45238,38 +45312,38 @@ | ||
45238 | 45312 | label = 18446744073709551605LLU; // add |
45239 | 45313 | break; |
45240 | 45314 | } |
45241 | - case 3799LLU: // copy-back deleter (add to procblock) | |
45315 | + case 3808LLU: // copy-back deleter (add to procblock) | |
45242 | 45316 | { |
45243 | 45317 | // copy mutable arguments back from call to add |
45244 | - label = 3797LLU; // continue to roll stack | |
45318 | + label = 3806LLU; // continue to roll stack | |
45245 | 45319 | break; |
45246 | 45320 | } |
45247 | - case 3800LLU: // return from add to procblock | |
45321 | + case 3809LLU: // return from add to procblock | |
45248 | 45322 | { |
45249 | 45323 | // copy mutable arguments back from call to add |
45250 | 45324 | // copy back results provided by call to add |
45251 | 45325 | stack[base + 17] = stack[base + 27LLU]; |
45252 | - label = 3802LLU; // skip deleter | |
45326 | + label = 3811LLU; // skip deleter | |
45253 | 45327 | break; |
45254 | 45328 | } |
45255 | - case 3801LLU: // deleter | |
45329 | + case 3810LLU: // deleter | |
45256 | 45330 | { |
45257 | 45331 | // throw from procblock |
45258 | 45332 | if(!stack[base + 24]) |
45259 | 45333 | { |
45260 | - label = 3797LLU; // skip, variable already deleted/unscoped | |
45334 | + label = 3806LLU; // skip, variable already deleted/unscoped | |
45261 | 45335 | break; |
45262 | 45336 | } |
45263 | - label = 3797LLU; // continue unrolling stack, delete next variable | |
45337 | + label = 3806LLU; // continue unrolling stack, delete next variable | |
45264 | 45338 | break; |
45265 | 45339 | } |
45266 | - case 3802LLU: // skipped deleter | |
45340 | + case 3811LLU: // skipped deleter | |
45267 | 45341 | { |
45268 | 45342 | stack[base + 24] = stack[base + 17]/*label*/; |
45269 | 45343 | // call ParseToken from procblock |
45270 | - stack[base + 25LLU] = 3803LLU/*throw to this address*/; | |
45344 | + stack[base + 25LLU] = 3812LLU/*throw to this address*/; | |
45271 | 45345 | stack[base + 26LLU] = base; |
45272 | - stack[base + 27LLU] = 3804LLU; | |
45346 | + stack[base + 27LLU] = 3813LLU; | |
45273 | 45347 | // arguments for call to ParseToken |
45274 | 45348 | stack[base + 30LLU] = stack[base + 19]/*lookahead*/; |
45275 | 45349 | // set stack-base & callee-address |
@@ -45277,14 +45351,14 @@ | ||
45277 | 45351 | label = 3LLU; // ParseToken |
45278 | 45352 | break; |
45279 | 45353 | } |
45280 | - case 3803LLU: // copy-back deleter (ParseToken to procblock) | |
45354 | + case 3812LLU: // copy-back deleter (ParseToken to procblock) | |
45281 | 45355 | { |
45282 | 45356 | // copy mutable arguments back from call to ParseToken |
45283 | 45357 | stack[base + 19]/*lookahead*/ = stack[base + 30LLU]; |
45284 | - label = 3801LLU; // continue to roll stack | |
45358 | + label = 3810LLU; // continue to roll stack | |
45285 | 45359 | break; |
45286 | 45360 | } |
45287 | - case 3804LLU: // return from ParseToken to procblock | |
45361 | + case 3813LLU: // return from ParseToken to procblock | |
45288 | 45362 | { |
45289 | 45363 | // copy mutable arguments back from call to ParseToken |
45290 | 45364 | stack[base + 19]/*lookahead*/ = stack[base + 30LLU]; |
@@ -45291,42 +45365,42 @@ | ||
45291 | 45365 | // copy back results provided by call to ParseToken |
45292 | 45366 | stack[base + 15] = stack[base + 28LLU]; |
45293 | 45367 | stack[base + 16] = stack[base + 29LLU]; |
45294 | - label = 3806LLU; // skip deleter | |
45368 | + label = 3815LLU; // skip deleter | |
45295 | 45369 | break; |
45296 | 45370 | } |
45297 | - case 3805LLU: // deleter | |
45371 | + case 3814LLU: // deleter | |
45298 | 45372 | { |
45299 | 45373 | // throw from procblock |
45300 | 45374 | if(!stack[base + 25]) |
45301 | 45375 | { |
45302 | - label = 3801LLU; // skip, variable already deleted/unscoped | |
45376 | + label = 3810LLU; // skip, variable already deleted/unscoped | |
45303 | 45377 | break; |
45304 | 45378 | } |
45305 | - label = 3801LLU; // continue unrolling stack, delete next variable | |
45379 | + label = 3810LLU; // continue unrolling stack, delete next variable | |
45306 | 45380 | break; |
45307 | 45381 | } |
45308 | - case 3806LLU: // skipped deleter | |
45382 | + case 3815LLU: // skipped deleter | |
45309 | 45383 | { |
45310 | - label = 3808LLU; // skip deleter | |
45384 | + label = 3817LLU; // skip deleter | |
45311 | 45385 | break; |
45312 | 45386 | } |
45313 | - case 3807LLU: // deleter | |
45387 | + case 3816LLU: // deleter | |
45314 | 45388 | { |
45315 | 45389 | // throw from procblock |
45316 | 45390 | if(!stack[base + 26]) |
45317 | 45391 | { |
45318 | - label = 3805LLU; // skip, variable already deleted/unscoped | |
45392 | + label = 3814LLU; // skip, variable already deleted/unscoped | |
45319 | 45393 | break; |
45320 | 45394 | } |
45321 | - label = 3805LLU; // continue unrolling stack, delete next variable | |
45395 | + label = 3814LLU; // continue unrolling stack, delete next variable | |
45322 | 45396 | break; |
45323 | 45397 | } |
45324 | - case 3808LLU: // skipped deleter | |
45398 | + case 3817LLU: // skipped deleter | |
45325 | 45399 | { |
45326 | 45400 | // call isident from procblock |
45327 | - stack[base + 27LLU] = 3809LLU/*throw to this address*/; | |
45401 | + stack[base + 27LLU] = 3818LLU/*throw to this address*/; | |
45328 | 45402 | stack[base + 28LLU] = base; |
45329 | - stack[base + 29LLU] = 3810LLU; | |
45403 | + stack[base + 29LLU] = 3819LLU; | |
45330 | 45404 | // arguments for call to isident |
45331 | 45405 | stack[base + 31LLU] = stack[base + 15]/*variant*/; |
45332 | 45406 | stack[base + 32LLU] = stack[base + 16]/*content*/; |
@@ -45336,13 +45410,13 @@ | ||
45336 | 45410 | label = 184LLU; // isident |
45337 | 45411 | break; |
45338 | 45412 | } |
45339 | - case 3809LLU: // copy-back deleter (isident to procblock) | |
45413 | + case 3818LLU: // copy-back deleter (isident to procblock) | |
45340 | 45414 | { |
45341 | 45415 | // copy mutable arguments back from call to isident |
45342 | - label = 3801LLU; // continue to roll stack | |
45416 | + label = 3810LLU; // continue to roll stack | |
45343 | 45417 | break; |
45344 | 45418 | } |
45345 | - case 3810LLU: // return from isident to procblock | |
45419 | + case 3819LLU: // return from isident to procblock | |
45346 | 45420 | { |
45347 | 45421 | // copy mutable arguments back from call to isident |
45348 | 45422 | // copy back results provided by call to isident |
@@ -45349,15 +45423,15 @@ | ||
45349 | 45423 | stack[base + 20] = stack[base + 30LLU]; |
45350 | 45424 | if(!stack[base + 20]/*isequal*/) |
45351 | 45425 | { |
45352 | - label = 3811LLU; // jump to alternative | |
45426 | + label = 3820LLU; // jump to alternative | |
45353 | 45427 | break; |
45354 | 45428 | } |
45355 | 45429 | |
45356 | 45430 | // consequent |
45357 | 45431 | // call ParseToken from procblock |
45358 | - stack[base + 27LLU] = 3813LLU/*throw to this address*/; | |
45432 | + stack[base + 27LLU] = 3822LLU/*throw to this address*/; | |
45359 | 45433 | stack[base + 28LLU] = base; |
45360 | - stack[base + 29LLU] = 3814LLU; | |
45434 | + stack[base + 29LLU] = 3823LLU; | |
45361 | 45435 | // arguments for call to ParseToken |
45362 | 45436 | stack[base + 32LLU] = stack[base + 19]/*lookahead*/; |
45363 | 45437 | // set stack-base & callee-address |
@@ -45365,14 +45439,14 @@ | ||
45365 | 45439 | label = 3LLU; // ParseToken |
45366 | 45440 | break; |
45367 | 45441 | } |
45368 | - case 3813LLU: // copy-back deleter (ParseToken to procblock) | |
45442 | + case 3822LLU: // copy-back deleter (ParseToken to procblock) | |
45369 | 45443 | { |
45370 | 45444 | // copy mutable arguments back from call to ParseToken |
45371 | 45445 | stack[base + 19]/*lookahead*/ = stack[base + 32LLU]; |
45372 | - label = 3801LLU; // continue to roll stack | |
45446 | + label = 3810LLU; // continue to roll stack | |
45373 | 45447 | break; |
45374 | 45448 | } |
45375 | - case 3814LLU: // return from ParseToken to procblock | |
45449 | + case 3823LLU: // return from ParseToken to procblock | |
45376 | 45450 | { |
45377 | 45451 | // copy mutable arguments back from call to ParseToken |
45378 | 45452 | stack[base + 19]/*lookahead*/ = stack[base + 32LLU]; |
@@ -45379,49 +45453,49 @@ | ||
45379 | 45453 | // copy back results provided by call to ParseToken |
45380 | 45454 | stack[base + 15] = stack[base + 30LLU]; |
45381 | 45455 | stack[base + 16] = stack[base + 31LLU]; |
45382 | - label = 3816LLU; // skip deleter | |
45456 | + label = 3825LLU; // skip deleter | |
45383 | 45457 | break; |
45384 | 45458 | } |
45385 | - case 3815LLU: // deleter | |
45459 | + case 3824LLU: // deleter | |
45386 | 45460 | { |
45387 | 45461 | // throw from procblock |
45388 | 45462 | if(!stack[base + 25]) |
45389 | 45463 | { |
45390 | - label = 3801LLU; // skip, variable already deleted/unscoped | |
45464 | + label = 3810LLU; // skip, variable already deleted/unscoped | |
45391 | 45465 | break; |
45392 | 45466 | } |
45393 | - label = 3801LLU; // continue unrolling stack, delete next variable | |
45467 | + label = 3810LLU; // continue unrolling stack, delete next variable | |
45394 | 45468 | break; |
45395 | 45469 | } |
45396 | - case 3816LLU: // skipped deleter | |
45470 | + case 3825LLU: // skipped deleter | |
45397 | 45471 | { |
45398 | 45472 | stack[base + 25] = 1; |
45399 | - label = 3818LLU; // skip deleter | |
45473 | + label = 3827LLU; // skip deleter | |
45400 | 45474 | break; |
45401 | 45475 | } |
45402 | - case 3817LLU: // deleter | |
45476 | + case 3826LLU: // deleter | |
45403 | 45477 | { |
45404 | 45478 | // throw from procblock |
45405 | 45479 | if(!stack[base + 26]) |
45406 | 45480 | { |
45407 | - label = 3815LLU; // skip, variable already deleted/unscoped | |
45481 | + label = 3824LLU; // skip, variable already deleted/unscoped | |
45408 | 45482 | break; |
45409 | 45483 | } |
45410 | - label = 3815LLU; // continue unrolling stack, delete next variable | |
45484 | + label = 3824LLU; // continue unrolling stack, delete next variable | |
45411 | 45485 | break; |
45412 | 45486 | } |
45413 | - case 3818LLU: // skipped deleter | |
45487 | + case 3827LLU: // skipped deleter | |
45414 | 45488 | { |
45415 | 45489 | stack[base + 26] = 0; |
45416 | - label = 3812LLU; // consequent complete | |
45490 | + label = 3821LLU; // consequent complete | |
45417 | 45491 | break; |
45418 | 45492 | } |
45419 | - case 3811LLU: // alternative | |
45493 | + case 3820LLU: // alternative | |
45420 | 45494 | { |
45421 | 45495 | // call isident from procblock |
45422 | - stack[base + 27LLU] = 3819LLU/*throw to this address*/; | |
45496 | + stack[base + 27LLU] = 3828LLU/*throw to this address*/; | |
45423 | 45497 | stack[base + 28LLU] = base; |
45424 | - stack[base + 29LLU] = 3820LLU; | |
45498 | + stack[base + 29LLU] = 3829LLU; | |
45425 | 45499 | // arguments for call to isident |
45426 | 45500 | stack[base + 31LLU] = stack[base + 15]/*variant*/; |
45427 | 45501 | stack[base + 32LLU] = stack[base + 16]/*content*/; |
@@ -45431,13 +45505,13 @@ | ||
45431 | 45505 | label = 184LLU; // isident |
45432 | 45506 | break; |
45433 | 45507 | } |
45434 | - case 3819LLU: // copy-back deleter (isident to procblock) | |
45508 | + case 3828LLU: // copy-back deleter (isident to procblock) | |
45435 | 45509 | { |
45436 | 45510 | // copy mutable arguments back from call to isident |
45437 | - label = 3801LLU; // continue to roll stack | |
45511 | + label = 3810LLU; // continue to roll stack | |
45438 | 45512 | break; |
45439 | 45513 | } |
45440 | - case 3820LLU: // return from isident to procblock | |
45514 | + case 3829LLU: // return from isident to procblock | |
45441 | 45515 | { |
45442 | 45516 | // copy mutable arguments back from call to isident |
45443 | 45517 | // copy back results provided by call to isident |
@@ -45444,7 +45518,7 @@ | ||
45444 | 45518 | stack[base + 20] = stack[base + 30LLU]; |
45445 | 45519 | if(!stack[base + 20]/*isequal*/) |
45446 | 45520 | { |
45447 | - label = 3821LLU; // jump to alternative | |
45521 | + label = 3830LLU; // jump to alternative | |
45448 | 45522 | break; |
45449 | 45523 | } |
45450 | 45524 |
@@ -45451,21 +45525,21 @@ | ||
45451 | 45525 | // consequent |
45452 | 45526 | if(!stack[base + 7]/*fnIO*/) |
45453 | 45527 | { |
45454 | - label = 3823LLU; // jump to alternative | |
45528 | + label = 3832LLU; // jump to alternative | |
45455 | 45529 | break; |
45456 | 45530 | } |
45457 | 45531 | |
45458 | 45532 | // consequent |
45459 | - label = 3824LLU; // consequent complete | |
45533 | + label = 3833LLU; // consequent complete | |
45460 | 45534 | break; |
45461 | 45535 | } |
45462 | - case 3823LLU: // alternative | |
45536 | + case 3832LLU: // alternative | |
45463 | 45537 | { |
45464 | 45538 | fprintf(stderr, "%s", "in function "); |
45465 | 45539 | // call reportid from procblock |
45466 | - stack[base + 27LLU] = 3825LLU/*throw to this address*/; | |
45540 | + stack[base + 27LLU] = 3834LLU/*throw to this address*/; | |
45467 | 45541 | stack[base + 28LLU] = base; |
45468 | - stack[base + 29LLU] = 3826LLU; | |
45542 | + stack[base + 29LLU] = 3835LLU; | |
45469 | 45543 | // arguments for call to reportid |
45470 | 45544 | stack[base + 30LLU] = stack[base + 8]/*fnid*/; |
45471 | 45545 | // set stack-base & callee-address |
@@ -45473,31 +45547,31 @@ | ||
45473 | 45547 | label = 18446744073709551586LLU; // reportid |
45474 | 45548 | break; |
45475 | 45549 | } |
45476 | - case 3825LLU: // copy-back deleter (reportid to procblock) | |
45550 | + case 3834LLU: // copy-back deleter (reportid to procblock) | |
45477 | 45551 | { |
45478 | 45552 | // copy mutable arguments back from call to reportid |
45479 | - label = 3801LLU; // continue to roll stack | |
45553 | + label = 3810LLU; // continue to roll stack | |
45480 | 45554 | break; |
45481 | 45555 | } |
45482 | - case 3826LLU: // return from reportid to procblock | |
45556 | + case 3835LLU: // return from reportid to procblock | |
45483 | 45557 | { |
45484 | 45558 | // copy mutable arguments back from call to reportid |
45485 | 45559 | fprintf(stderr, "%s", ": "); |
45486 | 45560 | fprintf(stderr, "%s", "while input used in non-IO environment\n"); |
45487 | 45561 | { |
45488 | - label = 3801LLU; // throw: begin to unroll stack | |
45562 | + label = 3810LLU; // throw: begin to unroll stack | |
45489 | 45563 | break; |
45490 | 45564 | } |
45491 | 45565 | |
45492 | - label = 3824LLU; // alternative complete | |
45566 | + label = 3833LLU; // alternative complete | |
45493 | 45567 | break; |
45494 | 45568 | } |
45495 | - case 3824LLU: // completed if-then-else | |
45569 | + case 3833LLU: // completed if-then-else | |
45496 | 45570 | { |
45497 | 45571 | // call ParseToken from procblock |
45498 | - stack[base + 27LLU] = 3827LLU/*throw to this address*/; | |
45572 | + stack[base + 27LLU] = 3836LLU/*throw to this address*/; | |
45499 | 45573 | stack[base + 28LLU] = base; |
45500 | - stack[base + 29LLU] = 3828LLU; | |
45574 | + stack[base + 29LLU] = 3837LLU; | |
45501 | 45575 | // arguments for call to ParseToken |
45502 | 45576 | stack[base + 32LLU] = stack[base + 19]/*lookahead*/; |
45503 | 45577 | // set stack-base & callee-address |
@@ -45505,14 +45579,14 @@ | ||
45505 | 45579 | label = 3LLU; // ParseToken |
45506 | 45580 | break; |
45507 | 45581 | } |
45508 | - case 3827LLU: // copy-back deleter (ParseToken to procblock) | |
45582 | + case 3836LLU: // copy-back deleter (ParseToken to procblock) | |
45509 | 45583 | { |
45510 | 45584 | // copy mutable arguments back from call to ParseToken |
45511 | 45585 | stack[base + 19]/*lookahead*/ = stack[base + 32LLU]; |
45512 | - label = 3801LLU; // continue to roll stack | |
45586 | + label = 3810LLU; // continue to roll stack | |
45513 | 45587 | break; |
45514 | 45588 | } |
45515 | - case 3828LLU: // return from ParseToken to procblock | |
45589 | + case 3837LLU: // return from ParseToken to procblock | |
45516 | 45590 | { |
45517 | 45591 | // copy mutable arguments back from call to ParseToken |
45518 | 45592 | stack[base + 19]/*lookahead*/ = stack[base + 32LLU]; |
@@ -45519,93 +45593,93 @@ | ||
45519 | 45593 | // copy back results provided by call to ParseToken |
45520 | 45594 | stack[base + 15] = stack[base + 30LLU]; |
45521 | 45595 | stack[base + 16] = stack[base + 31LLU]; |
45522 | - label = 3830LLU; // skip deleter | |
45596 | + label = 3839LLU; // skip deleter | |
45523 | 45597 | break; |
45524 | 45598 | } |
45525 | - case 3829LLU: // deleter | |
45599 | + case 3838LLU: // deleter | |
45526 | 45600 | { |
45527 | 45601 | // throw from procblock |
45528 | 45602 | if(!stack[base + 25]) |
45529 | 45603 | { |
45530 | - label = 3801LLU; // skip, variable already deleted/unscoped | |
45604 | + label = 3810LLU; // skip, variable already deleted/unscoped | |
45531 | 45605 | break; |
45532 | 45606 | } |
45533 | - label = 3801LLU; // continue unrolling stack, delete next variable | |
45607 | + label = 3810LLU; // continue unrolling stack, delete next variable | |
45534 | 45608 | break; |
45535 | 45609 | } |
45536 | - case 3830LLU: // skipped deleter | |
45610 | + case 3839LLU: // skipped deleter | |
45537 | 45611 | { |
45538 | 45612 | stack[base + 25] = 0; |
45539 | - label = 3832LLU; // skip deleter | |
45613 | + label = 3841LLU; // skip deleter | |
45540 | 45614 | break; |
45541 | 45615 | } |
45542 | - case 3831LLU: // deleter | |
45616 | + case 3840LLU: // deleter | |
45543 | 45617 | { |
45544 | 45618 | // throw from procblock |
45545 | 45619 | if(!stack[base + 26]) |
45546 | 45620 | { |
45547 | - label = 3829LLU; // skip, variable already deleted/unscoped | |
45621 | + label = 3838LLU; // skip, variable already deleted/unscoped | |
45548 | 45622 | break; |
45549 | 45623 | } |
45550 | - label = 3829LLU; // continue unrolling stack, delete next variable | |
45624 | + label = 3838LLU; // continue unrolling stack, delete next variable | |
45551 | 45625 | break; |
45552 | 45626 | } |
45553 | - case 3832LLU: // skipped deleter | |
45627 | + case 3841LLU: // skipped deleter | |
45554 | 45628 | { |
45555 | 45629 | stack[base + 26] = 1; |
45556 | - label = 3822LLU; // consequent complete | |
45630 | + label = 3831LLU; // consequent complete | |
45557 | 45631 | break; |
45558 | 45632 | } |
45559 | - case 3821LLU: // alternative | |
45633 | + case 3830LLU: // alternative | |
45560 | 45634 | { |
45561 | - label = 3834LLU; // skip deleter | |
45635 | + label = 3843LLU; // skip deleter | |
45562 | 45636 | break; |
45563 | 45637 | } |
45564 | - case 3833LLU: // deleter | |
45638 | + case 3842LLU: // deleter | |
45565 | 45639 | { |
45566 | 45640 | // throw from procblock |
45567 | 45641 | if(!stack[base + 25]) |
45568 | 45642 | { |
45569 | - label = 3801LLU; // skip, variable already deleted/unscoped | |
45643 | + label = 3810LLU; // skip, variable already deleted/unscoped | |
45570 | 45644 | break; |
45571 | 45645 | } |
45572 | - label = 3801LLU; // continue unrolling stack, delete next variable | |
45646 | + label = 3810LLU; // continue unrolling stack, delete next variable | |
45573 | 45647 | break; |
45574 | 45648 | } |
45575 | - case 3834LLU: // skipped deleter | |
45649 | + case 3843LLU: // skipped deleter | |
45576 | 45650 | { |
45577 | 45651 | stack[base + 25] = 0; |
45578 | - label = 3836LLU; // skip deleter | |
45652 | + label = 3845LLU; // skip deleter | |
45579 | 45653 | break; |
45580 | 45654 | } |
45581 | - case 3835LLU: // deleter | |
45655 | + case 3844LLU: // deleter | |
45582 | 45656 | { |
45583 | 45657 | // throw from procblock |
45584 | 45658 | if(!stack[base + 26]) |
45585 | 45659 | { |
45586 | - label = 3833LLU; // skip, variable already deleted/unscoped | |
45660 | + label = 3842LLU; // skip, variable already deleted/unscoped | |
45587 | 45661 | break; |
45588 | 45662 | } |
45589 | - label = 3833LLU; // continue unrolling stack, delete next variable | |
45663 | + label = 3842LLU; // continue unrolling stack, delete next variable | |
45590 | 45664 | break; |
45591 | 45665 | } |
45592 | - case 3836LLU: // skipped deleter | |
45666 | + case 3845LLU: // skipped deleter | |
45593 | 45667 | { |
45594 | 45668 | stack[base + 26] = 0; |
45595 | - label = 3822LLU; // alternative complete | |
45669 | + label = 3831LLU; // alternative complete | |
45596 | 45670 | break; |
45597 | 45671 | } |
45598 | - case 3822LLU: // completed if-then-else | |
45672 | + case 3831LLU: // completed if-then-else | |
45599 | 45673 | { |
45600 | - label = 3812LLU; // alternative complete | |
45674 | + label = 3821LLU; // alternative complete | |
45601 | 45675 | break; |
45602 | 45676 | } |
45603 | - case 3812LLU: // completed if-then-else | |
45677 | + case 3821LLU: // completed if-then-else | |
45604 | 45678 | { |
45605 | 45679 | // call equ from procblock |
45606 | - stack[base + 27LLU] = 3837LLU/*throw to this address*/; | |
45680 | + stack[base + 27LLU] = 3846LLU/*throw to this address*/; | |
45607 | 45681 | stack[base + 28LLU] = base; |
45608 | - stack[base + 29LLU] = 3838LLU; | |
45682 | + stack[base + 29LLU] = 3847LLU; | |
45609 | 45683 | // arguments for call to equ |
45610 | 45684 | stack[base + 31LLU] = stack[base + 15]/*variant*/; |
45611 | 45685 | stack[base + 32LLU] = 0LLU; |
@@ -45614,13 +45688,13 @@ | ||
45614 | 45688 | label = 18446744073709551600LLU; // equ |
45615 | 45689 | break; |
45616 | 45690 | } |
45617 | - case 3837LLU: // copy-back deleter (equ to procblock) | |
45691 | + case 3846LLU: // copy-back deleter (equ to procblock) | |
45618 | 45692 | { |
45619 | 45693 | // copy mutable arguments back from call to equ |
45620 | - label = 3807LLU; // continue to roll stack | |
45694 | + label = 3816LLU; // continue to roll stack | |
45621 | 45695 | break; |
45622 | 45696 | } |
45623 | - case 3838LLU: // return from equ to procblock | |
45697 | + case 3847LLU: // return from equ to procblock | |
45624 | 45698 | { |
45625 | 45699 | // copy mutable arguments back from call to equ |
45626 | 45700 | // copy back results provided by call to equ |
@@ -45627,15 +45701,15 @@ | ||
45627 | 45701 | stack[base + 20] = stack[base + 30LLU]; |
45628 | 45702 | if(!stack[base + 20]/*isequal*/) |
45629 | 45703 | { |
45630 | - label = 3839LLU; // jump to alternative | |
45704 | + label = 3848LLU; // jump to alternative | |
45631 | 45705 | break; |
45632 | 45706 | } |
45633 | 45707 | |
45634 | 45708 | // consequent |
45635 | 45709 | // call equ from procblock |
45636 | - stack[base + 27LLU] = 3841LLU/*throw to this address*/; | |
45710 | + stack[base + 27LLU] = 3850LLU/*throw to this address*/; | |
45637 | 45711 | stack[base + 28LLU] = base; |
45638 | - stack[base + 29LLU] = 3842LLU; | |
45712 | + stack[base + 29LLU] = 3851LLU; | |
45639 | 45713 | // arguments for call to equ |
45640 | 45714 | stack[base + 31LLU] = stack[base + 16]/*content*/; |
45641 | 45715 | stack[base + 32LLU] = 40LLU; |
@@ -45644,13 +45718,13 @@ | ||
45644 | 45718 | label = 18446744073709551600LLU; // equ |
45645 | 45719 | break; |
45646 | 45720 | } |
45647 | - case 3841LLU: // copy-back deleter (equ to procblock) | |
45721 | + case 3850LLU: // copy-back deleter (equ to procblock) | |
45648 | 45722 | { |
45649 | 45723 | // copy mutable arguments back from call to equ |
45650 | - label = 3807LLU; // continue to roll stack | |
45724 | + label = 3816LLU; // continue to roll stack | |
45651 | 45725 | break; |
45652 | 45726 | } |
45653 | - case 3842LLU: // return from equ to procblock | |
45727 | + case 3851LLU: // return from equ to procblock | |
45654 | 45728 | { |
45655 | 45729 | // copy mutable arguments back from call to equ |
45656 | 45730 | // copy back results provided by call to equ |
@@ -45657,21 +45731,21 @@ | ||
45657 | 45731 | stack[base + 20] = stack[base + 30LLU]; |
45658 | 45732 | if(!stack[base + 20]/*isequal*/) |
45659 | 45733 | { |
45660 | - label = 3843LLU; // jump to alternative | |
45734 | + label = 3852LLU; // jump to alternative | |
45661 | 45735 | break; |
45662 | 45736 | } |
45663 | 45737 | |
45664 | 45738 | // consequent |
45665 | - label = 3844LLU; // consequent complete | |
45739 | + label = 3853LLU; // consequent complete | |
45666 | 45740 | break; |
45667 | 45741 | } |
45668 | - case 3843LLU: // alternative | |
45742 | + case 3852LLU: // alternative | |
45669 | 45743 | { |
45670 | 45744 | fprintf(stderr, "%s", "expected '(' but found token "); |
45671 | 45745 | // call reporttok from procblock |
45672 | - stack[base + 27LLU] = 3845LLU/*throw to this address*/; | |
45746 | + stack[base + 27LLU] = 3854LLU/*throw to this address*/; | |
45673 | 45747 | stack[base + 28LLU] = base; |
45674 | - stack[base + 29LLU] = 3846LLU; | |
45748 | + stack[base + 29LLU] = 3855LLU; | |
45675 | 45749 | // arguments for call to reporttok |
45676 | 45750 | stack[base + 30LLU] = stack[base + 15]/*variant*/; |
45677 | 45751 | stack[base + 31LLU] = stack[base + 16]/*content*/; |
@@ -45680,47 +45754,47 @@ | ||
45680 | 45754 | label = 18446744073709551582LLU; // reporttok |
45681 | 45755 | break; |
45682 | 45756 | } |
45683 | - case 3845LLU: // copy-back deleter (reporttok to procblock) | |
45757 | + case 3854LLU: // copy-back deleter (reporttok to procblock) | |
45684 | 45758 | { |
45685 | 45759 | // copy mutable arguments back from call to reporttok |
45686 | - label = 3807LLU; // continue to roll stack | |
45760 | + label = 3816LLU; // continue to roll stack | |
45687 | 45761 | break; |
45688 | 45762 | } |
45689 | - case 3846LLU: // return from reporttok to procblock | |
45763 | + case 3855LLU: // return from reporttok to procblock | |
45690 | 45764 | { |
45691 | 45765 | // copy mutable arguments back from call to reporttok |
45692 | 45766 | fprintf(stderr, "%s", "\n"); |
45693 | 45767 | { |
45694 | - label = 3807LLU; // throw: begin to unroll stack | |
45768 | + label = 3816LLU; // throw: begin to unroll stack | |
45695 | 45769 | break; |
45696 | 45770 | } |
45697 | 45771 | |
45698 | - label = 3844LLU; // alternative complete | |
45772 | + label = 3853LLU; // alternative complete | |
45699 | 45773 | break; |
45700 | 45774 | } |
45701 | - case 3844LLU: // completed if-then-else | |
45775 | + case 3853LLU: // completed if-then-else | |
45702 | 45776 | { |
45703 | - label = 3848LLU; // skip deleter | |
45777 | + label = 3857LLU; // skip deleter | |
45704 | 45778 | break; |
45705 | 45779 | } |
45706 | - case 3847LLU: // deleter | |
45780 | + case 3856LLU: // deleter | |
45707 | 45781 | { |
45708 | 45782 | // throw from procblock |
45709 | 45783 | if(!stack[base + 27]) |
45710 | 45784 | { |
45711 | - label = 3807LLU; // skip, variable already deleted/unscoped | |
45785 | + label = 3816LLU; // skip, variable already deleted/unscoped | |
45712 | 45786 | break; |
45713 | 45787 | } |
45714 | - label = 3807LLU; // continue unrolling stack, delete next variable | |
45788 | + label = 3816LLU; // continue unrolling stack, delete next variable | |
45715 | 45789 | break; |
45716 | 45790 | } |
45717 | - case 3848LLU: // skipped deleter | |
45791 | + case 3857LLU: // skipped deleter | |
45718 | 45792 | { |
45719 | 45793 | stack[base + 27] = 0; |
45720 | 45794 | // call ParseToken from procblock |
45721 | - stack[base + 28LLU] = 3849LLU/*throw to this address*/; | |
45795 | + stack[base + 28LLU] = 3858LLU/*throw to this address*/; | |
45722 | 45796 | stack[base + 29LLU] = base; |
45723 | - stack[base + 30LLU] = 3850LLU; | |
45797 | + stack[base + 30LLU] = 3859LLU; | |
45724 | 45798 | // arguments for call to ParseToken |
45725 | 45799 | stack[base + 33LLU] = stack[base + 19]/*lookahead*/; |
45726 | 45800 | // set stack-base & callee-address |
@@ -45728,14 +45802,14 @@ | ||
45728 | 45802 | label = 3LLU; // ParseToken |
45729 | 45803 | break; |
45730 | 45804 | } |
45731 | - case 3849LLU: // copy-back deleter (ParseToken to procblock) | |
45805 | + case 3858LLU: // copy-back deleter (ParseToken to procblock) | |
45732 | 45806 | { |
45733 | 45807 | // copy mutable arguments back from call to ParseToken |
45734 | 45808 | stack[base + 19]/*lookahead*/ = stack[base + 33LLU]; |
45735 | - label = 3847LLU; // continue to roll stack | |
45809 | + label = 3856LLU; // continue to roll stack | |
45736 | 45810 | break; |
45737 | 45811 | } |
45738 | - case 3850LLU: // return from ParseToken to procblock | |
45812 | + case 3859LLU: // return from ParseToken to procblock | |
45739 | 45813 | { |
45740 | 45814 | // copy mutable arguments back from call to ParseToken |
45741 | 45815 | stack[base + 19]/*lookahead*/ = stack[base + 33LLU]; |
@@ -45743,9 +45817,9 @@ | ||
45743 | 45817 | stack[base + 15] = stack[base + 31LLU]; |
45744 | 45818 | stack[base + 27] = stack[base + 32LLU]; |
45745 | 45819 | // call equ from procblock |
45746 | - stack[base + 28LLU] = 3851LLU/*throw to this address*/; | |
45820 | + stack[base + 28LLU] = 3860LLU/*throw to this address*/; | |
45747 | 45821 | stack[base + 29LLU] = base; |
45748 | - stack[base + 30LLU] = 3852LLU; | |
45822 | + stack[base + 30LLU] = 3861LLU; | |
45749 | 45823 | // arguments for call to equ |
45750 | 45824 | stack[base + 32LLU] = stack[base + 15]/*variant*/; |
45751 | 45825 | stack[base + 33LLU] = 4LLU; |
@@ -45754,13 +45828,13 @@ | ||
45754 | 45828 | label = 18446744073709551600LLU; // equ |
45755 | 45829 | break; |
45756 | 45830 | } |
45757 | - case 3851LLU: // copy-back deleter (equ to procblock) | |
45831 | + case 3860LLU: // copy-back deleter (equ to procblock) | |
45758 | 45832 | { |
45759 | 45833 | // copy mutable arguments back from call to equ |
45760 | - label = 3847LLU; // continue to roll stack | |
45834 | + label = 3856LLU; // continue to roll stack | |
45761 | 45835 | break; |
45762 | 45836 | } |
45763 | - case 3852LLU: // return from equ to procblock | |
45837 | + case 3861LLU: // return from equ to procblock | |
45764 | 45838 | { |
45765 | 45839 | // copy mutable arguments back from call to equ |
45766 | 45840 | // copy back results provided by call to equ |
@@ -45767,15 +45841,15 @@ | ||
45767 | 45841 | stack[base + 20] = stack[base + 31LLU]; |
45768 | 45842 | if(!stack[base + 20]/*isequal*/) |
45769 | 45843 | { |
45770 | - label = 3853LLU; // jump to alternative | |
45844 | + label = 3862LLU; // jump to alternative | |
45771 | 45845 | break; |
45772 | 45846 | } |
45773 | 45847 | |
45774 | 45848 | // consequent |
45775 | 45849 | // call assertu64 from procblock |
45776 | - stack[base + 28LLU] = 3855LLU/*throw to this address*/; | |
45850 | + stack[base + 28LLU] = 3864LLU/*throw to this address*/; | |
45777 | 45851 | stack[base + 29LLU] = base; |
45778 | - stack[base + 30LLU] = 3856LLU; | |
45852 | + stack[base + 30LLU] = 3865LLU; | |
45779 | 45853 | // arguments for call to assertu64 |
45780 | 45854 | stack[base + 31LLU] = stack[base + 8]/*fnid*/; |
45781 | 45855 | stack[base + 32LLU] = 910732593752702976LLU; |
@@ -45787,25 +45861,25 @@ | ||
45787 | 45861 | label = 2451LLU; // assertu64 |
45788 | 45862 | break; |
45789 | 45863 | } |
45790 | - case 3855LLU: // copy-back deleter (assertu64 to procblock) | |
45864 | + case 3864LLU: // copy-back deleter (assertu64 to procblock) | |
45791 | 45865 | { |
45792 | 45866 | // copy mutable arguments back from call to assertu64 |
45793 | - label = 3847LLU; // continue to roll stack | |
45867 | + label = 3856LLU; // continue to roll stack | |
45794 | 45868 | break; |
45795 | 45869 | } |
45796 | - case 3856LLU: // return from assertu64 to procblock | |
45870 | + case 3865LLU: // return from assertu64 to procblock | |
45797 | 45871 | { |
45798 | 45872 | // copy mutable arguments back from call to assertu64 |
45799 | - label = 3854LLU; // consequent complete | |
45873 | + label = 3863LLU; // consequent complete | |
45800 | 45874 | break; |
45801 | 45875 | } |
45802 | - case 3853LLU: // alternative | |
45876 | + case 3862LLU: // alternative | |
45803 | 45877 | { |
45804 | 45878 | fprintf(stderr, "%s", "expected identifier in while but found "); |
45805 | 45879 | // call reporttok from procblock |
45806 | - stack[base + 28LLU] = 3857LLU/*throw to this address*/; | |
45880 | + stack[base + 28LLU] = 3866LLU/*throw to this address*/; | |
45807 | 45881 | stack[base + 29LLU] = base; |
45808 | - stack[base + 30LLU] = 3858LLU; | |
45882 | + stack[base + 30LLU] = 3867LLU; | |
45809 | 45883 | // arguments for call to reporttok |
45810 | 45884 | stack[base + 31LLU] = stack[base + 15]/*variant*/; |
45811 | 45885 | stack[base + 32LLU] = stack[base + 27]/*loopid*/; |
@@ -45814,30 +45888,30 @@ | ||
45814 | 45888 | label = 18446744073709551582LLU; // reporttok |
45815 | 45889 | break; |
45816 | 45890 | } |
45817 | - case 3857LLU: // copy-back deleter (reporttok to procblock) | |
45891 | + case 3866LLU: // copy-back deleter (reporttok to procblock) | |
45818 | 45892 | { |
45819 | 45893 | // copy mutable arguments back from call to reporttok |
45820 | - label = 3847LLU; // continue to roll stack | |
45894 | + label = 3856LLU; // continue to roll stack | |
45821 | 45895 | break; |
45822 | 45896 | } |
45823 | - case 3858LLU: // return from reporttok to procblock | |
45897 | + case 3867LLU: // return from reporttok to procblock | |
45824 | 45898 | { |
45825 | 45899 | // copy mutable arguments back from call to reporttok |
45826 | 45900 | fprintf(stderr, "%s", "\n"); |
45827 | 45901 | { |
45828 | - label = 3847LLU; // throw: begin to unroll stack | |
45902 | + label = 3856LLU; // throw: begin to unroll stack | |
45829 | 45903 | break; |
45830 | 45904 | } |
45831 | 45905 | |
45832 | - label = 3854LLU; // alternative complete | |
45906 | + label = 3863LLU; // alternative complete | |
45833 | 45907 | break; |
45834 | 45908 | } |
45835 | - case 3854LLU: // completed if-then-else | |
45909 | + case 3863LLU: // completed if-then-else | |
45836 | 45910 | { |
45837 | 45911 | // call matchsym from procblock |
45838 | - stack[base + 28LLU] = 3859LLU/*throw to this address*/; | |
45912 | + stack[base + 28LLU] = 3868LLU/*throw to this address*/; | |
45839 | 45913 | stack[base + 29LLU] = base; |
45840 | - stack[base + 30LLU] = 3860LLU; | |
45914 | + stack[base + 30LLU] = 3869LLU; | |
45841 | 45915 | // arguments for call to matchsym |
45842 | 45916 | stack[base + 31LLU] = stack[base + 8]/*fnid*/; |
45843 | 45917 | stack[base + 32LLU] = 41LLU; |
@@ -45847,28 +45921,28 @@ | ||
45847 | 45921 | label = 246LLU; // matchsym |
45848 | 45922 | break; |
45849 | 45923 | } |
45850 | - case 3859LLU: // copy-back deleter (matchsym to procblock) | |
45924 | + case 3868LLU: // copy-back deleter (matchsym to procblock) | |
45851 | 45925 | { |
45852 | 45926 | // copy mutable arguments back from call to matchsym |
45853 | 45927 | stack[base + 19]/*lookahead*/ = stack[base + 33LLU]; |
45854 | - label = 3847LLU; // continue to roll stack | |
45928 | + label = 3856LLU; // continue to roll stack | |
45855 | 45929 | break; |
45856 | 45930 | } |
45857 | - case 3860LLU: // return from matchsym to procblock | |
45931 | + case 3869LLU: // return from matchsym to procblock | |
45858 | 45932 | { |
45859 | 45933 | // copy mutable arguments back from call to matchsym |
45860 | 45934 | stack[base + 19]/*lookahead*/ = stack[base + 33LLU]; |
45861 | 45935 | if(!stack[base + 25]/*decflag*/) |
45862 | 45936 | { |
45863 | - label = 3861LLU; // jump to alternative | |
45937 | + label = 3870LLU; // jump to alternative | |
45864 | 45938 | break; |
45865 | 45939 | } |
45866 | 45940 | |
45867 | 45941 | // consequent |
45868 | 45942 | // call matchsym from procblock |
45869 | - stack[base + 28LLU] = 3863LLU/*throw to this address*/; | |
45943 | + stack[base + 28LLU] = 3872LLU/*throw to this address*/; | |
45870 | 45944 | stack[base + 29LLU] = base; |
45871 | - stack[base + 30LLU] = 3864LLU; | |
45945 | + stack[base + 30LLU] = 3873LLU; | |
45872 | 45946 | // arguments for call to matchsym |
45873 | 45947 | stack[base + 31LLU] = stack[base + 8]/*fnid*/; |
45874 | 45948 | stack[base + 32LLU] = 45LLU; |
@@ -45878,21 +45952,21 @@ | ||
45878 | 45952 | label = 246LLU; // matchsym |
45879 | 45953 | break; |
45880 | 45954 | } |
45881 | - case 3863LLU: // copy-back deleter (matchsym to procblock) | |
45955 | + case 3872LLU: // copy-back deleter (matchsym to procblock) | |
45882 | 45956 | { |
45883 | 45957 | // copy mutable arguments back from call to matchsym |
45884 | 45958 | stack[base + 19]/*lookahead*/ = stack[base + 33LLU]; |
45885 | - label = 3847LLU; // continue to roll stack | |
45959 | + label = 3856LLU; // continue to roll stack | |
45886 | 45960 | break; |
45887 | 45961 | } |
45888 | - case 3864LLU: // return from matchsym to procblock | |
45962 | + case 3873LLU: // return from matchsym to procblock | |
45889 | 45963 | { |
45890 | 45964 | // copy mutable arguments back from call to matchsym |
45891 | 45965 | stack[base + 19]/*lookahead*/ = stack[base + 33LLU]; |
45892 | 45966 | // call matchsym from procblock |
45893 | - stack[base + 28LLU] = 3865LLU/*throw to this address*/; | |
45967 | + stack[base + 28LLU] = 3874LLU/*throw to this address*/; | |
45894 | 45968 | stack[base + 29LLU] = base; |
45895 | - stack[base + 30LLU] = 3866LLU; | |
45969 | + stack[base + 30LLU] = 3875LLU; | |
45896 | 45970 | // arguments for call to matchsym |
45897 | 45971 | stack[base + 31LLU] = stack[base + 8]/*fnid*/; |
45898 | 45972 | stack[base + 32LLU] = 62LLU; |
@@ -45902,21 +45976,21 @@ | ||
45902 | 45976 | label = 246LLU; // matchsym |
45903 | 45977 | break; |
45904 | 45978 | } |
45905 | - case 3865LLU: // copy-back deleter (matchsym to procblock) | |
45979 | + case 3874LLU: // copy-back deleter (matchsym to procblock) | |
45906 | 45980 | { |
45907 | 45981 | // copy mutable arguments back from call to matchsym |
45908 | 45982 | stack[base + 19]/*lookahead*/ = stack[base + 33LLU]; |
45909 | - label = 3847LLU; // continue to roll stack | |
45983 | + label = 3856LLU; // continue to roll stack | |
45910 | 45984 | break; |
45911 | 45985 | } |
45912 | - case 3866LLU: // return from matchsym to procblock | |
45986 | + case 3875LLU: // return from matchsym to procblock | |
45913 | 45987 | { |
45914 | 45988 | // copy mutable arguments back from call to matchsym |
45915 | 45989 | stack[base + 19]/*lookahead*/ = stack[base + 33LLU]; |
45916 | 45990 | // call matchsym from procblock |
45917 | - stack[base + 28LLU] = 3867LLU/*throw to this address*/; | |
45991 | + stack[base + 28LLU] = 3876LLU/*throw to this address*/; | |
45918 | 45992 | stack[base + 29LLU] = base; |
45919 | - stack[base + 30LLU] = 3868LLU; | |
45993 | + stack[base + 30LLU] = 3877LLU; | |
45920 | 45994 | // arguments for call to matchsym |
45921 | 45995 | stack[base + 31LLU] = stack[base + 8]/*fnid*/; |
45922 | 45996 | stack[base + 32LLU] = 40LLU; |
@@ -45926,38 +46000,38 @@ | ||
45926 | 46000 | label = 246LLU; // matchsym |
45927 | 46001 | break; |
45928 | 46002 | } |
45929 | - case 3867LLU: // copy-back deleter (matchsym to procblock) | |
46003 | + case 3876LLU: // copy-back deleter (matchsym to procblock) | |
45930 | 46004 | { |
45931 | 46005 | // copy mutable arguments back from call to matchsym |
45932 | 46006 | stack[base + 19]/*lookahead*/ = stack[base + 33LLU]; |
45933 | - label = 3847LLU; // continue to roll stack | |
46007 | + label = 3856LLU; // continue to roll stack | |
45934 | 46008 | break; |
45935 | 46009 | } |
45936 | - case 3868LLU: // return from matchsym to procblock | |
46010 | + case 3877LLU: // return from matchsym to procblock | |
45937 | 46011 | { |
45938 | 46012 | // copy mutable arguments back from call to matchsym |
45939 | 46013 | stack[base + 19]/*lookahead*/ = stack[base + 33LLU]; |
45940 | - label = 3870LLU; // skip deleter | |
46014 | + label = 3879LLU; // skip deleter | |
45941 | 46015 | break; |
45942 | 46016 | } |
45943 | - case 3869LLU: // deleter | |
46017 | + case 3878LLU: // deleter | |
45944 | 46018 | { |
45945 | 46019 | // throw from procblock |
45946 | 46020 | if(!stack[base + 28]) |
45947 | 46021 | { |
45948 | - label = 3847LLU; // skip, variable already deleted/unscoped | |
46022 | + label = 3856LLU; // skip, variable already deleted/unscoped | |
45949 | 46023 | break; |
45950 | 46024 | } |
45951 | - label = 3847LLU; // continue unrolling stack, delete next variable | |
46025 | + label = 3856LLU; // continue unrolling stack, delete next variable | |
45952 | 46026 | break; |
45953 | 46027 | } |
45954 | - case 3870LLU: // skipped deleter | |
46028 | + case 3879LLU: // skipped deleter | |
45955 | 46029 | { |
45956 | 46030 | stack[base + 28] = 0; |
45957 | 46031 | // call ParseToken from procblock |
45958 | - stack[base + 29LLU] = 3871LLU/*throw to this address*/; | |
46032 | + stack[base + 29LLU] = 3880LLU/*throw to this address*/; | |
45959 | 46033 | stack[base + 30LLU] = base; |
45960 | - stack[base + 31LLU] = 3872LLU; | |
46034 | + stack[base + 31LLU] = 3881LLU; | |
45961 | 46035 | // arguments for call to ParseToken |
45962 | 46036 | stack[base + 34LLU] = stack[base + 19]/*lookahead*/; |
45963 | 46037 | // set stack-base & callee-address |
@@ -45965,14 +46039,14 @@ | ||
45965 | 46039 | label = 3LLU; // ParseToken |
45966 | 46040 | break; |
45967 | 46041 | } |
45968 | - case 3871LLU: // copy-back deleter (ParseToken to procblock) | |
46042 | + case 3880LLU: // copy-back deleter (ParseToken to procblock) | |
45969 | 46043 | { |
45970 | 46044 | // copy mutable arguments back from call to ParseToken |
45971 | 46045 | stack[base + 19]/*lookahead*/ = stack[base + 34LLU]; |
45972 | - label = 3869LLU; // continue to roll stack | |
46046 | + label = 3878LLU; // continue to roll stack | |
45973 | 46047 | break; |
45974 | 46048 | } |
45975 | - case 3872LLU: // return from ParseToken to procblock | |
46049 | + case 3881LLU: // return from ParseToken to procblock | |
45976 | 46050 | { |
45977 | 46051 | // copy mutable arguments back from call to ParseToken |
45978 | 46052 | stack[base + 19]/*lookahead*/ = stack[base + 34LLU]; |
@@ -45980,9 +46054,9 @@ | ||
45980 | 46054 | stack[base + 15] = stack[base + 32LLU]; |
45981 | 46055 | stack[base + 28] = stack[base + 33LLU]; |
45982 | 46056 | // call equ from procblock |
45983 | - stack[base + 29LLU] = 3873LLU/*throw to this address*/; | |
46057 | + stack[base + 29LLU] = 3882LLU/*throw to this address*/; | |
45984 | 46058 | stack[base + 30LLU] = base; |
45985 | - stack[base + 31LLU] = 3874LLU; | |
46059 | + stack[base + 31LLU] = 3883LLU; | |
45986 | 46060 | // arguments for call to equ |
45987 | 46061 | stack[base + 33LLU] = stack[base + 15]/*variant*/; |
45988 | 46062 | stack[base + 34LLU] = 4LLU; |
@@ -45991,13 +46065,13 @@ | ||
45991 | 46065 | label = 18446744073709551600LLU; // equ |
45992 | 46066 | break; |
45993 | 46067 | } |
45994 | - case 3873LLU: // copy-back deleter (equ to procblock) | |
46068 | + case 3882LLU: // copy-back deleter (equ to procblock) | |
45995 | 46069 | { |
45996 | 46070 | // copy mutable arguments back from call to equ |
45997 | - label = 3869LLU; // continue to roll stack | |
46071 | + label = 3878LLU; // continue to roll stack | |
45998 | 46072 | break; |
45999 | 46073 | } |
46000 | - case 3874LLU: // return from equ to procblock | |
46074 | + case 3883LLU: // return from equ to procblock | |
46001 | 46075 | { |
46002 | 46076 | // copy mutable arguments back from call to equ |
46003 | 46077 | // copy back results provided by call to equ |
@@ -46004,15 +46078,15 @@ | ||
46004 | 46078 | stack[base + 20] = stack[base + 32LLU]; |
46005 | 46079 | if(!stack[base + 20]/*isequal*/) |
46006 | 46080 | { |
46007 | - label = 3875LLU; // jump to alternative | |
46081 | + label = 3884LLU; // jump to alternative | |
46008 | 46082 | break; |
46009 | 46083 | } |
46010 | 46084 | |
46011 | 46085 | // consequent |
46012 | 46086 | // call assertu64 from procblock |
46013 | - stack[base + 29LLU] = 3877LLU/*throw to this address*/; | |
46087 | + stack[base + 29LLU] = 3886LLU/*throw to this address*/; | |
46014 | 46088 | stack[base + 30LLU] = base; |
46015 | - stack[base + 31LLU] = 3878LLU; | |
46089 | + stack[base + 31LLU] = 3887LLU; | |
46016 | 46090 | // arguments for call to assertu64 |
46017 | 46091 | stack[base + 32LLU] = stack[base + 8]/*fnid*/; |
46018 | 46092 | stack[base + 33LLU] = 910732593752702976LLU; |
@@ -46024,25 +46098,25 @@ | ||
46024 | 46098 | label = 2451LLU; // assertu64 |
46025 | 46099 | break; |
46026 | 46100 | } |
46027 | - case 3877LLU: // copy-back deleter (assertu64 to procblock) | |
46101 | + case 3886LLU: // copy-back deleter (assertu64 to procblock) | |
46028 | 46102 | { |
46029 | 46103 | // copy mutable arguments back from call to assertu64 |
46030 | - label = 3869LLU; // continue to roll stack | |
46104 | + label = 3878LLU; // continue to roll stack | |
46031 | 46105 | break; |
46032 | 46106 | } |
46033 | - case 3878LLU: // return from assertu64 to procblock | |
46107 | + case 3887LLU: // return from assertu64 to procblock | |
46034 | 46108 | { |
46035 | 46109 | // copy mutable arguments back from call to assertu64 |
46036 | - label = 3876LLU; // consequent complete | |
46110 | + label = 3885LLU; // consequent complete | |
46037 | 46111 | break; |
46038 | 46112 | } |
46039 | - case 3875LLU: // alternative | |
46113 | + case 3884LLU: // alternative | |
46040 | 46114 | { |
46041 | 46115 | fprintf(stderr, "%s", "expected identifier in while but found "); |
46042 | 46116 | // call reporttok from procblock |
46043 | - stack[base + 29LLU] = 3879LLU/*throw to this address*/; | |
46117 | + stack[base + 29LLU] = 3888LLU/*throw to this address*/; | |
46044 | 46118 | stack[base + 30LLU] = base; |
46045 | - stack[base + 31LLU] = 3880LLU; | |
46119 | + stack[base + 31LLU] = 3889LLU; | |
46046 | 46120 | // arguments for call to reporttok |
46047 | 46121 | stack[base + 32LLU] = stack[base + 15]/*variant*/; |
46048 | 46122 | stack[base + 33LLU] = stack[base + 28]/*counterid*/; |
@@ -46051,30 +46125,30 @@ | ||
46051 | 46125 | label = 18446744073709551582LLU; // reporttok |
46052 | 46126 | break; |
46053 | 46127 | } |
46054 | - case 3879LLU: // copy-back deleter (reporttok to procblock) | |
46128 | + case 3888LLU: // copy-back deleter (reporttok to procblock) | |
46055 | 46129 | { |
46056 | 46130 | // copy mutable arguments back from call to reporttok |
46057 | - label = 3869LLU; // continue to roll stack | |
46131 | + label = 3878LLU; // continue to roll stack | |
46058 | 46132 | break; |
46059 | 46133 | } |
46060 | - case 3880LLU: // return from reporttok to procblock | |
46134 | + case 3889LLU: // return from reporttok to procblock | |
46061 | 46135 | { |
46062 | 46136 | // copy mutable arguments back from call to reporttok |
46063 | 46137 | fprintf(stderr, "%s", "\n"); |
46064 | 46138 | { |
46065 | - label = 3869LLU; // throw: begin to unroll stack | |
46139 | + label = 3878LLU; // throw: begin to unroll stack | |
46066 | 46140 | break; |
46067 | 46141 | } |
46068 | 46142 | |
46069 | - label = 3876LLU; // alternative complete | |
46143 | + label = 3885LLU; // alternative complete | |
46070 | 46144 | break; |
46071 | 46145 | } |
46072 | - case 3876LLU: // completed if-then-else | |
46146 | + case 3885LLU: // completed if-then-else | |
46073 | 46147 | { |
46074 | 46148 | // call matchsym from procblock |
46075 | - stack[base + 29LLU] = 3881LLU/*throw to this address*/; | |
46149 | + stack[base + 29LLU] = 3890LLU/*throw to this address*/; | |
46076 | 46150 | stack[base + 30LLU] = base; |
46077 | - stack[base + 31LLU] = 3882LLU; | |
46151 | + stack[base + 31LLU] = 3891LLU; | |
46078 | 46152 | // arguments for call to matchsym |
46079 | 46153 | stack[base + 32LLU] = stack[base + 8]/*fnid*/; |
46080 | 46154 | stack[base + 33LLU] = 41LLU; |
@@ -46084,26 +46158,26 @@ | ||
46084 | 46158 | label = 246LLU; // matchsym |
46085 | 46159 | break; |
46086 | 46160 | } |
46087 | - case 3881LLU: // copy-back deleter (matchsym to procblock) | |
46161 | + case 3890LLU: // copy-back deleter (matchsym to procblock) | |
46088 | 46162 | { |
46089 | 46163 | // copy mutable arguments back from call to matchsym |
46090 | 46164 | stack[base + 19]/*lookahead*/ = stack[base + 34LLU]; |
46091 | - label = 3869LLU; // continue to roll stack | |
46165 | + label = 3878LLU; // continue to roll stack | |
46092 | 46166 | break; |
46093 | 46167 | } |
46094 | - case 3882LLU: // return from matchsym to procblock | |
46168 | + case 3891LLU: // return from matchsym to procblock | |
46095 | 46169 | { |
46096 | 46170 | // copy mutable arguments back from call to matchsym |
46097 | 46171 | stack[base + 19]/*lookahead*/ = stack[base + 34LLU]; |
46098 | - label = 3884LLU; // skip deleter | |
46172 | + label = 3893LLU; // skip deleter | |
46099 | 46173 | break; |
46100 | 46174 | } |
46101 | - case 3883LLU: // deleter | |
46175 | + case 3892LLU: // deleter | |
46102 | 46176 | { |
46103 | 46177 | // throw from procblock |
46104 | 46178 | if(!stack[base + 29]) |
46105 | 46179 | { |
46106 | - label = 3869LLU; // skip, variable already deleted/unscoped | |
46180 | + label = 3878LLU; // skip, variable already deleted/unscoped | |
46107 | 46181 | break; |
46108 | 46182 | } |
46109 | 46183 |
@@ -46112,7 +46186,7 @@ | ||
46112 | 46186 | newstack[0] = (uint64_t)stack; // backup stack location |
46113 | 46187 | newstack[1] = 1234567890; |
46114 | 46188 | newstack[2] = base; |
46115 | - newstack[3] = 3885LLU; | |
46189 | + newstack[3] = 3894LLU; | |
46116 | 46190 | stack = newstack; |
46117 | 46191 | // set stack-base & callee-address |
46118 | 46192 | base = 4/*deloffset*/; |
@@ -46119,21 +46193,21 @@ | ||
46119 | 46193 | label = 310LLU; // ~type |
46120 | 46194 | break; |
46121 | 46195 | } |
46122 | - case 3885LLU: // return from ~type to procblock | |
46196 | + case 3894LLU: // return from ~type to procblock | |
46123 | 46197 | { |
46124 | 46198 | stack = (uint64_t *)stack[0]; |
46125 | 46199 | // releasing toplevel container |
46126 | 46200 | Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 29] - sizeof(uint64_t) * 4)); |
46127 | 46201 | |
46128 | - label = 3869LLU; // continue unrolling stack, delete next variable | |
46202 | + label = 3878LLU; // continue unrolling stack, delete next variable | |
46129 | 46203 | break; |
46130 | 46204 | } |
46131 | - case 3884LLU: // skipped deleter | |
46205 | + case 3893LLU: // skipped deleter | |
46132 | 46206 | { |
46133 | 46207 | // call mktypedata from procblock |
46134 | - stack[base + 30LLU] = 3886LLU/*throw to this address*/; | |
46208 | + stack[base + 30LLU] = 3895LLU/*throw to this address*/; | |
46135 | 46209 | stack[base + 31LLU] = base; |
46136 | - stack[base + 32LLU] = 3887LLU; | |
46210 | + stack[base + 32LLU] = 3896LLU; | |
46137 | 46211 | // arguments for call to mktypedata |
46138 | 46212 | stack[base + 34LLU] = 881834713755418624LLU; |
46139 | 46213 | // set stack-base & callee-address |
@@ -46141,37 +46215,37 @@ | ||
46141 | 46215 | label = 314LLU; // mktypedata |
46142 | 46216 | break; |
46143 | 46217 | } |
46144 | - case 3886LLU: // copy-back deleter (mktypedata to procblock) | |
46218 | + case 3895LLU: // copy-back deleter (mktypedata to procblock) | |
46145 | 46219 | { |
46146 | 46220 | // copy mutable arguments back from call to mktypedata |
46147 | - label = 3869LLU; // continue to roll stack | |
46221 | + label = 3878LLU; // continue to roll stack | |
46148 | 46222 | break; |
46149 | 46223 | } |
46150 | - case 3887LLU: // return from mktypedata to procblock | |
46224 | + case 3896LLU: // return from mktypedata to procblock | |
46151 | 46225 | { |
46152 | 46226 | // copy mutable arguments back from call to mktypedata |
46153 | 46227 | // copy back results provided by call to mktypedata |
46154 | 46228 | stack[base + 29] = stack[base + 33LLU]; |
46155 | - label = 3889LLU; // skip deleter | |
46229 | + label = 3898LLU; // skip deleter | |
46156 | 46230 | break; |
46157 | 46231 | } |
46158 | - case 3888LLU: // deleter | |
46232 | + case 3897LLU: // deleter | |
46159 | 46233 | { |
46160 | 46234 | // throw from procblock |
46161 | 46235 | if(!stack[base + 30]) |
46162 | 46236 | { |
46163 | - label = 3883LLU; // skip, variable already deleted/unscoped | |
46237 | + label = 3892LLU; // skip, variable already deleted/unscoped | |
46164 | 46238 | break; |
46165 | 46239 | } |
46166 | - label = 3883LLU; // continue unrolling stack, delete next variable | |
46240 | + label = 3892LLU; // continue unrolling stack, delete next variable | |
46167 | 46241 | break; |
46168 | 46242 | } |
46169 | - case 3889LLU: // skipped deleter | |
46243 | + case 3898LLU: // skipped deleter | |
46170 | 46244 | { |
46171 | 46245 | // call newvarraw from procblock |
46172 | - stack[base + 31LLU] = 3890LLU/*throw to this address*/; | |
46246 | + stack[base + 31LLU] = 3899LLU/*throw to this address*/; | |
46173 | 46247 | stack[base + 32LLU] = base; |
46174 | - stack[base + 33LLU] = 3891LLU; | |
46248 | + stack[base + 33LLU] = 3900LLU; | |
46175 | 46249 | // arguments for call to newvarraw |
46176 | 46250 | stack[base + 35LLU] = stack[base + 29]/*counttype*/; |
46177 | 46251 | stack[base + 36LLU] = stack[base + 28]/*counterid*/; |
@@ -46187,16 +46261,16 @@ | ||
46187 | 46261 | label = 759LLU; // newvarraw |
46188 | 46262 | break; |
46189 | 46263 | } |
46190 | - case 3890LLU: // copy-back deleter (newvarraw to procblock) | |
46264 | + case 3899LLU: // copy-back deleter (newvarraw to procblock) | |
46191 | 46265 | { |
46192 | 46266 | // copy mutable arguments back from call to newvarraw |
46193 | 46267 | stack[base + 3]/*scope*/ = stack[base + 42LLU]; |
46194 | 46268 | stack[base + 18]/*varcount*/ = stack[base + 41LLU]; |
46195 | 46269 | stack[base + 12]/*fnmaxcount*/ = stack[base + 40LLU]; |
46196 | - label = 3883LLU; // continue to roll stack | |
46270 | + label = 3892LLU; // continue to roll stack | |
46197 | 46271 | break; |
46198 | 46272 | } |
46199 | - case 3891LLU: // return from newvarraw to procblock | |
46273 | + case 3900LLU: // return from newvarraw to procblock | |
46200 | 46274 | { |
46201 | 46275 | // copy mutable arguments back from call to newvarraw |
46202 | 46276 | stack[base + 3]/*scope*/ = stack[base + 42LLU]; |
@@ -46206,9 +46280,9 @@ | ||
46206 | 46280 | stack[base + 30] = stack[base + 34LLU]; |
46207 | 46281 | printf("%s", "\n "); |
46208 | 46282 | // call emitvaridx from procblock |
46209 | - stack[base + 31LLU] = 3892LLU/*throw to this address*/; | |
46283 | + stack[base + 31LLU] = 3901LLU/*throw to this address*/; | |
46210 | 46284 | stack[base + 32LLU] = base; |
46211 | - stack[base + 33LLU] = 3893LLU; | |
46285 | + stack[base + 33LLU] = 3902LLU; | |
46212 | 46286 | // arguments for call to emitvaridx |
46213 | 46287 | stack[base + 34LLU] = stack[base + 30]/*counteridx*/; |
46214 | 46288 | // set stack-base & callee-address |
@@ -46216,20 +46290,20 @@ | ||
46216 | 46290 | label = 745LLU; // emitvaridx |
46217 | 46291 | break; |
46218 | 46292 | } |
46219 | - case 3892LLU: // copy-back deleter (emitvaridx to procblock) | |
46293 | + case 3901LLU: // copy-back deleter (emitvaridx to procblock) | |
46220 | 46294 | { |
46221 | 46295 | // copy mutable arguments back from call to emitvaridx |
46222 | - label = 3888LLU; // continue to roll stack | |
46296 | + label = 3897LLU; // continue to roll stack | |
46223 | 46297 | break; |
46224 | 46298 | } |
46225 | - case 3893LLU: // return from emitvaridx to procblock | |
46299 | + case 3902LLU: // return from emitvaridx to procblock | |
46226 | 46300 | { |
46227 | 46301 | // copy mutable arguments back from call to emitvaridx |
46228 | 46302 | printf("%s", " = "); |
46229 | 46303 | // call emitvar from procblock |
46230 | - stack[base + 31LLU] = 3894LLU/*throw to this address*/; | |
46304 | + stack[base + 31LLU] = 3903LLU/*throw to this address*/; | |
46231 | 46305 | stack[base + 32LLU] = base; |
46232 | - stack[base + 33LLU] = 3895LLU; | |
46306 | + stack[base + 33LLU] = 3904LLU; | |
46233 | 46307 | // arguments for call to emitvar |
46234 | 46308 | stack[base + 34LLU] = stack[base + 8]/*fnid*/; |
46235 | 46309 | stack[base + 35LLU] = stack[base + 27]/*loopid*/; |
@@ -46240,21 +46314,21 @@ | ||
46240 | 46314 | label = 749LLU; // emitvar |
46241 | 46315 | break; |
46242 | 46316 | } |
46243 | - case 3894LLU: // copy-back deleter (emitvar to procblock) | |
46317 | + case 3903LLU: // copy-back deleter (emitvar to procblock) | |
46244 | 46318 | { |
46245 | 46319 | // copy mutable arguments back from call to emitvar |
46246 | - label = 3888LLU; // continue to roll stack | |
46320 | + label = 3897LLU; // continue to roll stack | |
46247 | 46321 | break; |
46248 | 46322 | } |
46249 | - case 3895LLU: // return from emitvar to procblock | |
46323 | + case 3904LLU: // return from emitvar to procblock | |
46250 | 46324 | { |
46251 | 46325 | // copy mutable arguments back from call to emitvar |
46252 | 46326 | printf("%s", ";\n"); |
46253 | 46327 | printf("%s", "\n label = "); |
46254 | 46328 | // call printnr from procblock |
46255 | - stack[base + 31LLU] = 3896LLU/*throw to this address*/; | |
46329 | + stack[base + 31LLU] = 3905LLU/*throw to this address*/; | |
46256 | 46330 | stack[base + 32LLU] = base; |
46257 | - stack[base + 33LLU] = 3897LLU; | |
46331 | + stack[base + 33LLU] = 3906LLU; | |
46258 | 46332 | // arguments for call to printnr |
46259 | 46333 | stack[base + 34LLU] = stack[base + 23]/*labelloop*/; |
46260 | 46334 | // set stack-base & callee-address |
@@ -46262,13 +46336,13 @@ | ||
46262 | 46336 | label = 18446744073709551590LLU; // printnr |
46263 | 46337 | break; |
46264 | 46338 | } |
46265 | - case 3896LLU: // copy-back deleter (printnr to procblock) | |
46339 | + case 3905LLU: // copy-back deleter (printnr to procblock) | |
46266 | 46340 | { |
46267 | 46341 | // copy mutable arguments back from call to printnr |
46268 | - label = 3888LLU; // continue to roll stack | |
46342 | + label = 3897LLU; // continue to roll stack | |
46269 | 46343 | break; |
46270 | 46344 | } |
46271 | - case 3897LLU: // return from printnr to procblock | |
46345 | + case 3906LLU: // return from printnr to procblock | |
46272 | 46346 | { |
46273 | 46347 | // copy mutable arguments back from call to printnr |
46274 | 46348 | printf("%s", "LLU; // start to repeat"); |
@@ -46276,9 +46350,9 @@ | ||
46276 | 46350 | printf("%s", "\n }"); |
46277 | 46351 | printf("%s", "\n case "); |
46278 | 46352 | // call printnr from procblock |
46279 | - stack[base + 31LLU] = 3898LLU/*throw to this address*/; | |
46353 | + stack[base + 31LLU] = 3907LLU/*throw to this address*/; | |
46280 | 46354 | stack[base + 32LLU] = base; |
46281 | - stack[base + 33LLU] = 3899LLU; | |
46355 | + stack[base + 33LLU] = 3908LLU; | |
46282 | 46356 | // arguments for call to printnr |
46283 | 46357 | stack[base + 34LLU] = stack[base + 23]/*labelloop*/; |
46284 | 46358 | // set stack-base & callee-address |
@@ -46286,13 +46360,13 @@ | ||
46286 | 46360 | label = 18446744073709551590LLU; // printnr |
46287 | 46361 | break; |
46288 | 46362 | } |
46289 | - case 3898LLU: // copy-back deleter (printnr to procblock) | |
46363 | + case 3907LLU: // copy-back deleter (printnr to procblock) | |
46290 | 46364 | { |
46291 | 46365 | // copy mutable arguments back from call to printnr |
46292 | - label = 3888LLU; // continue to roll stack | |
46366 | + label = 3897LLU; // continue to roll stack | |
46293 | 46367 | break; |
46294 | 46368 | } |
46295 | - case 3899LLU: // return from printnr to procblock | |
46369 | + case 3908LLU: // return from printnr to procblock | |
46296 | 46370 | { |
46297 | 46371 | // copy mutable arguments back from call to printnr |
46298 | 46372 | printf("%s", "LLU: // repeat from here"); |
@@ -46299,9 +46373,9 @@ | ||
46299 | 46373 | printf("%s", "\n {"); |
46300 | 46374 | printf("%s", "\n if(!"); |
46301 | 46375 | // call emitvaridx from procblock |
46302 | - stack[base + 31LLU] = 3900LLU/*throw to this address*/; | |
46376 | + stack[base + 31LLU] = 3909LLU/*throw to this address*/; | |
46303 | 46377 | stack[base + 32LLU] = base; |
46304 | - stack[base + 33LLU] = 3901LLU; | |
46378 | + stack[base + 33LLU] = 3910LLU; | |
46305 | 46379 | // arguments for call to emitvaridx |
46306 | 46380 | stack[base + 34LLU] = stack[base + 30]/*counteridx*/; |
46307 | 46381 | // set stack-base & callee-address |
@@ -46309,13 +46383,13 @@ | ||
46309 | 46383 | label = 745LLU; // emitvaridx |
46310 | 46384 | break; |
46311 | 46385 | } |
46312 | - case 3900LLU: // copy-back deleter (emitvaridx to procblock) | |
46386 | + case 3909LLU: // copy-back deleter (emitvaridx to procblock) | |
46313 | 46387 | { |
46314 | 46388 | // copy mutable arguments back from call to emitvaridx |
46315 | - label = 3888LLU; // continue to roll stack | |
46389 | + label = 3897LLU; // continue to roll stack | |
46316 | 46390 | break; |
46317 | 46391 | } |
46318 | - case 3901LLU: // return from emitvaridx to procblock | |
46392 | + case 3910LLU: // return from emitvaridx to procblock | |
46319 | 46393 | { |
46320 | 46394 | // copy mutable arguments back from call to emitvaridx |
46321 | 46395 | printf("%s", "--)"); |
@@ -46325,7 +46399,7 @@ | ||
46325 | 46399 | newstack[0] = (uint64_t)stack; // backup stack location |
46326 | 46400 | newstack[1] = 1234567890; |
46327 | 46401 | newstack[2] = base; |
46328 | - newstack[3] = 3902LLU; | |
46402 | + newstack[3] = 3911LLU; | |
46329 | 46403 | stack = newstack; |
46330 | 46404 | // set stack-base & callee-address |
46331 | 46405 | base = 4/*deloffset*/; |
@@ -46332,22 +46406,22 @@ | ||
46332 | 46406 | label = 310LLU; // ~type |
46333 | 46407 | break; |
46334 | 46408 | } |
46335 | - case 3902LLU: // return from ~type to procblock | |
46409 | + case 3911LLU: // return from ~type to procblock | |
46336 | 46410 | { |
46337 | 46411 | stack = (uint64_t *)stack[0]; |
46338 | 46412 | // releasing toplevel container |
46339 | 46413 | Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 29] - sizeof(uint64_t) * 4)); |
46340 | 46414 | |
46341 | - label = 3862LLU; // consequent complete | |
46415 | + label = 3871LLU; // consequent complete | |
46342 | 46416 | break; |
46343 | 46417 | } |
46344 | - case 3861LLU: // alternative | |
46418 | + case 3870LLU: // alternative | |
46345 | 46419 | { |
46346 | 46420 | printf("%s", "\n label = "); |
46347 | 46421 | // call printnr from procblock |
46348 | - stack[base + 28LLU] = 3903LLU/*throw to this address*/; | |
46422 | + stack[base + 28LLU] = 3912LLU/*throw to this address*/; | |
46349 | 46423 | stack[base + 29LLU] = base; |
46350 | - stack[base + 30LLU] = 3904LLU; | |
46424 | + stack[base + 30LLU] = 3913LLU; | |
46351 | 46425 | // arguments for call to printnr |
46352 | 46426 | stack[base + 31LLU] = stack[base + 23]/*labelloop*/; |
46353 | 46427 | // set stack-base & callee-address |
@@ -46355,13 +46429,13 @@ | ||
46355 | 46429 | label = 18446744073709551590LLU; // printnr |
46356 | 46430 | break; |
46357 | 46431 | } |
46358 | - case 3903LLU: // copy-back deleter (printnr to procblock) | |
46432 | + case 3912LLU: // copy-back deleter (printnr to procblock) | |
46359 | 46433 | { |
46360 | 46434 | // copy mutable arguments back from call to printnr |
46361 | - label = 3847LLU; // continue to roll stack | |
46435 | + label = 3856LLU; // continue to roll stack | |
46362 | 46436 | break; |
46363 | 46437 | } |
46364 | - case 3904LLU: // return from printnr to procblock | |
46438 | + case 3913LLU: // return from printnr to procblock | |
46365 | 46439 | { |
46366 | 46440 | // copy mutable arguments back from call to printnr |
46367 | 46441 | printf("%s", "LLU; // start to repeat"); |
@@ -46369,9 +46443,9 @@ | ||
46369 | 46443 | printf("%s", "\n }"); |
46370 | 46444 | printf("%s", "\n case "); |
46371 | 46445 | // call printnr from procblock |
46372 | - stack[base + 28LLU] = 3905LLU/*throw to this address*/; | |
46446 | + stack[base + 28LLU] = 3914LLU/*throw to this address*/; | |
46373 | 46447 | stack[base + 29LLU] = base; |
46374 | - stack[base + 30LLU] = 3906LLU; | |
46448 | + stack[base + 30LLU] = 3915LLU; | |
46375 | 46449 | // arguments for call to printnr |
46376 | 46450 | stack[base + 31LLU] = stack[base + 23]/*labelloop*/; |
46377 | 46451 | // set stack-base & callee-address |
@@ -46379,13 +46453,13 @@ | ||
46379 | 46453 | label = 18446744073709551590LLU; // printnr |
46380 | 46454 | break; |
46381 | 46455 | } |
46382 | - case 3905LLU: // copy-back deleter (printnr to procblock) | |
46456 | + case 3914LLU: // copy-back deleter (printnr to procblock) | |
46383 | 46457 | { |
46384 | 46458 | // copy mutable arguments back from call to printnr |
46385 | - label = 3847LLU; // continue to roll stack | |
46459 | + label = 3856LLU; // continue to roll stack | |
46386 | 46460 | break; |
46387 | 46461 | } |
46388 | - case 3906LLU: // return from printnr to procblock | |
46462 | + case 3915LLU: // return from printnr to procblock | |
46389 | 46463 | { |
46390 | 46464 | // copy mutable arguments back from call to printnr |
46391 | 46465 | printf("%s", "LLU: // repeat from here"); |
@@ -46392,31 +46466,31 @@ | ||
46392 | 46466 | printf("%s", "\n {"); |
46393 | 46467 | if(!stack[base + 26]/*inputflag*/) |
46394 | 46468 | { |
46395 | - label = 3907LLU; // jump to alternative | |
46469 | + label = 3916LLU; // jump to alternative | |
46396 | 46470 | break; |
46397 | 46471 | } |
46398 | 46472 | |
46399 | 46473 | // consequent |
46400 | - label = 3910LLU; // skip deleter | |
46474 | + label = 3919LLU; // skip deleter | |
46401 | 46475 | break; |
46402 | 46476 | } |
46403 | - case 3909LLU: // deleter | |
46477 | + case 3918LLU: // deleter | |
46404 | 46478 | { |
46405 | 46479 | // throw from procblock |
46406 | 46480 | if(!stack[base + 28]) |
46407 | 46481 | { |
46408 | - label = 3847LLU; // skip, variable already deleted/unscoped | |
46482 | + label = 3856LLU; // skip, variable already deleted/unscoped | |
46409 | 46483 | break; |
46410 | 46484 | } |
46411 | - label = 3847LLU; // continue unrolling stack, delete next variable | |
46485 | + label = 3856LLU; // continue unrolling stack, delete next variable | |
46412 | 46486 | break; |
46413 | 46487 | } |
46414 | - case 3910LLU: // skipped deleter | |
46488 | + case 3919LLU: // skipped deleter | |
46415 | 46489 | { |
46416 | 46490 | // call findletmut from procblock |
46417 | - stack[base + 29LLU] = 3911LLU/*throw to this address*/; | |
46491 | + stack[base + 29LLU] = 3920LLU/*throw to this address*/; | |
46418 | 46492 | stack[base + 30LLU] = base; |
46419 | - stack[base + 31LLU] = 3912LLU; | |
46493 | + stack[base + 31LLU] = 3921LLU; | |
46420 | 46494 | // arguments for call to findletmut |
46421 | 46495 | stack[base + 33LLU] = stack[base + 8]/*fnid*/; |
46422 | 46496 | stack[base + 34LLU] = stack[base + 27]/*loopid*/; |
@@ -46427,13 +46501,13 @@ | ||
46427 | 46501 | label = 718LLU; // findletmut |
46428 | 46502 | break; |
46429 | 46503 | } |
46430 | - case 3911LLU: // copy-back deleter (findletmut to procblock) | |
46504 | + case 3920LLU: // copy-back deleter (findletmut to procblock) | |
46431 | 46505 | { |
46432 | 46506 | // copy mutable arguments back from call to findletmut |
46433 | - label = 3847LLU; // continue to roll stack | |
46507 | + label = 3856LLU; // continue to roll stack | |
46434 | 46508 | break; |
46435 | 46509 | } |
46436 | - case 3912LLU: // return from findletmut to procblock | |
46510 | + case 3921LLU: // return from findletmut to procblock | |
46437 | 46511 | { |
46438 | 46512 | // copy mutable arguments back from call to findletmut |
46439 | 46513 | // copy back results provided by call to findletmut |
@@ -46440,21 +46514,21 @@ | ||
46440 | 46514 | stack[base + 28] = stack[base + 32LLU]; |
46441 | 46515 | if(!stack[base + 28]/*mutable*/) |
46442 | 46516 | { |
46443 | - label = 3913LLU; // jump to alternative | |
46517 | + label = 3922LLU; // jump to alternative | |
46444 | 46518 | break; |
46445 | 46519 | } |
46446 | 46520 | |
46447 | 46521 | // consequent |
46448 | - label = 3914LLU; // consequent complete | |
46522 | + label = 3923LLU; // consequent complete | |
46449 | 46523 | break; |
46450 | 46524 | } |
46451 | - case 3913LLU: // alternative | |
46525 | + case 3922LLU: // alternative | |
46452 | 46526 | { |
46453 | 46527 | fprintf(stderr, "%s", "in function "); |
46454 | 46528 | // call reportid from procblock |
46455 | - stack[base + 29LLU] = 3915LLU/*throw to this address*/; | |
46529 | + stack[base + 29LLU] = 3924LLU/*throw to this address*/; | |
46456 | 46530 | stack[base + 30LLU] = base; |
46457 | - stack[base + 31LLU] = 3916LLU; | |
46531 | + stack[base + 31LLU] = 3925LLU; | |
46458 | 46532 | // arguments for call to reportid |
46459 | 46533 | stack[base + 32LLU] = stack[base + 8]/*fnid*/; |
46460 | 46534 | // set stack-base & callee-address |
@@ -46462,21 +46536,21 @@ | ||
46462 | 46536 | label = 18446744073709551586LLU; // reportid |
46463 | 46537 | break; |
46464 | 46538 | } |
46465 | - case 3915LLU: // copy-back deleter (reportid to procblock) | |
46539 | + case 3924LLU: // copy-back deleter (reportid to procblock) | |
46466 | 46540 | { |
46467 | 46541 | // copy mutable arguments back from call to reportid |
46468 | - label = 3909LLU; // continue to roll stack | |
46542 | + label = 3918LLU; // continue to roll stack | |
46469 | 46543 | break; |
46470 | 46544 | } |
46471 | - case 3916LLU: // return from reportid to procblock | |
46545 | + case 3925LLU: // return from reportid to procblock | |
46472 | 46546 | { |
46473 | 46547 | // copy mutable arguments back from call to reportid |
46474 | 46548 | fprintf(stderr, "%s", ": "); |
46475 | 46549 | fprintf(stderr, "%s", "while input requires mutable variable but found constant "); |
46476 | 46550 | // call reportid from procblock |
46477 | - stack[base + 29LLU] = 3917LLU/*throw to this address*/; | |
46551 | + stack[base + 29LLU] = 3926LLU/*throw to this address*/; | |
46478 | 46552 | stack[base + 30LLU] = base; |
46479 | - stack[base + 31LLU] = 3918LLU; | |
46553 | + stack[base + 31LLU] = 3927LLU; | |
46480 | 46554 | // arguments for call to reportid |
46481 | 46555 | stack[base + 32LLU] = stack[base + 27]/*loopid*/; |
46482 | 46556 | // set stack-base & callee-address |
@@ -46484,31 +46558,31 @@ | ||
46484 | 46558 | label = 18446744073709551586LLU; // reportid |
46485 | 46559 | break; |
46486 | 46560 | } |
46487 | - case 3917LLU: // copy-back deleter (reportid to procblock) | |
46561 | + case 3926LLU: // copy-back deleter (reportid to procblock) | |
46488 | 46562 | { |
46489 | 46563 | // copy mutable arguments back from call to reportid |
46490 | - label = 3909LLU; // continue to roll stack | |
46564 | + label = 3918LLU; // continue to roll stack | |
46491 | 46565 | break; |
46492 | 46566 | } |
46493 | - case 3918LLU: // return from reportid to procblock | |
46567 | + case 3927LLU: // return from reportid to procblock | |
46494 | 46568 | { |
46495 | 46569 | // copy mutable arguments back from call to reportid |
46496 | 46570 | fprintf(stderr, "%s", "\n"); |
46497 | 46571 | { |
46498 | - label = 3909LLU; // throw: begin to unroll stack | |
46572 | + label = 3918LLU; // throw: begin to unroll stack | |
46499 | 46573 | break; |
46500 | 46574 | } |
46501 | 46575 | |
46502 | - label = 3914LLU; // alternative complete | |
46576 | + label = 3923LLU; // alternative complete | |
46503 | 46577 | break; |
46504 | 46578 | } |
46505 | - case 3914LLU: // completed if-then-else | |
46579 | + case 3923LLU: // completed if-then-else | |
46506 | 46580 | { |
46507 | 46581 | printf("%s", "\n if("); |
46508 | 46582 | // call emitvar from procblock |
46509 | - stack[base + 29LLU] = 3919LLU/*throw to this address*/; | |
46583 | + stack[base + 29LLU] = 3928LLU/*throw to this address*/; | |
46510 | 46584 | stack[base + 30LLU] = base; |
46511 | - stack[base + 31LLU] = 3920LLU; | |
46585 | + stack[base + 31LLU] = 3929LLU; | |
46512 | 46586 | // arguments for call to emitvar |
46513 | 46587 | stack[base + 32LLU] = stack[base + 8]/*fnid*/; |
46514 | 46588 | stack[base + 33LLU] = stack[base + 27]/*loopid*/; |
@@ -46519,26 +46593,26 @@ | ||
46519 | 46593 | label = 749LLU; // emitvar |
46520 | 46594 | break; |
46521 | 46595 | } |
46522 | - case 3919LLU: // copy-back deleter (emitvar to procblock) | |
46596 | + case 3928LLU: // copy-back deleter (emitvar to procblock) | |
46523 | 46597 | { |
46524 | 46598 | // copy mutable arguments back from call to emitvar |
46525 | - label = 3909LLU; // continue to roll stack | |
46599 | + label = 3918LLU; // continue to roll stack | |
46526 | 46600 | break; |
46527 | 46601 | } |
46528 | - case 3920LLU: // return from emitvar to procblock | |
46602 | + case 3929LLU: // return from emitvar to procblock | |
46529 | 46603 | { |
46530 | 46604 | // copy mutable arguments back from call to emitvar |
46531 | 46605 | printf("%s", " > 0xFF)"); |
46532 | - label = 3908LLU; // consequent complete | |
46606 | + label = 3917LLU; // consequent complete | |
46533 | 46607 | break; |
46534 | 46608 | } |
46535 | - case 3907LLU: // alternative | |
46609 | + case 3916LLU: // alternative | |
46536 | 46610 | { |
46537 | 46611 | printf("%s", "\n if(!"); |
46538 | 46612 | // call emitvar from procblock |
46539 | - stack[base + 28LLU] = 3921LLU/*throw to this address*/; | |
46613 | + stack[base + 28LLU] = 3930LLU/*throw to this address*/; | |
46540 | 46614 | stack[base + 29LLU] = base; |
46541 | - stack[base + 30LLU] = 3922LLU; | |
46615 | + stack[base + 30LLU] = 3931LLU; | |
46542 | 46616 | // arguments for call to emitvar |
46543 | 46617 | stack[base + 31LLU] = stack[base + 8]/*fnid*/; |
46544 | 46618 | stack[base + 32LLU] = stack[base + 27]/*loopid*/; |
@@ -46549,21 +46623,21 @@ | ||
46549 | 46623 | label = 749LLU; // emitvar |
46550 | 46624 | break; |
46551 | 46625 | } |
46552 | - case 3921LLU: // copy-back deleter (emitvar to procblock) | |
46626 | + case 3930LLU: // copy-back deleter (emitvar to procblock) | |
46553 | 46627 | { |
46554 | 46628 | // copy mutable arguments back from call to emitvar |
46555 | - label = 3847LLU; // continue to roll stack | |
46629 | + label = 3856LLU; // continue to roll stack | |
46556 | 46630 | break; |
46557 | 46631 | } |
46558 | - case 3922LLU: // return from emitvar to procblock | |
46632 | + case 3931LLU: // return from emitvar to procblock | |
46559 | 46633 | { |
46560 | 46634 | // copy mutable arguments back from call to emitvar |
46561 | 46635 | printf("%s", ")"); |
46562 | 46636 | fprintf(stderr, "%s", "in function "); |
46563 | 46637 | // call reportid from procblock |
46564 | - stack[base + 28LLU] = 3923LLU/*throw to this address*/; | |
46638 | + stack[base + 28LLU] = 3932LLU/*throw to this address*/; | |
46565 | 46639 | stack[base + 29LLU] = base; |
46566 | - stack[base + 30LLU] = 3924LLU; | |
46640 | + stack[base + 30LLU] = 3933LLU; | |
46567 | 46641 | // arguments for call to reportid |
46568 | 46642 | stack[base + 31LLU] = stack[base + 8]/*fnid*/; |
46569 | 46643 | // set stack-base & callee-address |
@@ -46571,35 +46645,35 @@ | ||
46571 | 46645 | label = 18446744073709551586LLU; // reportid |
46572 | 46646 | break; |
46573 | 46647 | } |
46574 | - case 3923LLU: // copy-back deleter (reportid to procblock) | |
46648 | + case 3932LLU: // copy-back deleter (reportid to procblock) | |
46575 | 46649 | { |
46576 | 46650 | // copy mutable arguments back from call to reportid |
46577 | - label = 3847LLU; // continue to roll stack | |
46651 | + label = 3856LLU; // continue to roll stack | |
46578 | 46652 | break; |
46579 | 46653 | } |
46580 | - case 3924LLU: // return from reportid to procblock | |
46654 | + case 3933LLU: // return from reportid to procblock | |
46581 | 46655 | { |
46582 | 46656 | // copy mutable arguments back from call to reportid |
46583 | 46657 | fprintf(stderr, "%s", ": plain while loop deactivated\n"); |
46584 | 46658 | { |
46585 | - label = 3847LLU; // throw: begin to unroll stack | |
46659 | + label = 3856LLU; // throw: begin to unroll stack | |
46586 | 46660 | break; |
46587 | 46661 | } |
46588 | 46662 | |
46589 | - label = 3908LLU; // alternative complete | |
46663 | + label = 3917LLU; // alternative complete | |
46590 | 46664 | break; |
46591 | 46665 | } |
46592 | - case 3908LLU: // completed if-then-else | |
46666 | + case 3917LLU: // completed if-then-else | |
46593 | 46667 | { |
46594 | - label = 3862LLU; // alternative complete | |
46668 | + label = 3871LLU; // alternative complete | |
46595 | 46669 | break; |
46596 | 46670 | } |
46597 | - case 3862LLU: // completed if-then-else | |
46671 | + case 3871LLU: // completed if-then-else | |
46598 | 46672 | { |
46599 | 46673 | // call matchsym from procblock |
46600 | - stack[base + 28LLU] = 3925LLU/*throw to this address*/; | |
46674 | + stack[base + 28LLU] = 3934LLU/*throw to this address*/; | |
46601 | 46675 | stack[base + 29LLU] = base; |
46602 | - stack[base + 30LLU] = 3926LLU; | |
46676 | + stack[base + 30LLU] = 3935LLU; | |
46603 | 46677 | // arguments for call to matchsym |
46604 | 46678 | stack[base + 31LLU] = stack[base + 8]/*fnid*/; |
46605 | 46679 | stack[base + 32LLU] = 123LLU; |
@@ -46609,14 +46683,14 @@ | ||
46609 | 46683 | label = 246LLU; // matchsym |
46610 | 46684 | break; |
46611 | 46685 | } |
46612 | - case 3925LLU: // copy-back deleter (matchsym to procblock) | |
46686 | + case 3934LLU: // copy-back deleter (matchsym to procblock) | |
46613 | 46687 | { |
46614 | 46688 | // copy mutable arguments back from call to matchsym |
46615 | 46689 | stack[base + 19]/*lookahead*/ = stack[base + 33LLU]; |
46616 | - label = 3847LLU; // continue to roll stack | |
46690 | + label = 3856LLU; // continue to roll stack | |
46617 | 46691 | break; |
46618 | 46692 | } |
46619 | - case 3926LLU: // return from matchsym to procblock | |
46693 | + case 3935LLU: // return from matchsym to procblock | |
46620 | 46694 | { |
46621 | 46695 | // copy mutable arguments back from call to matchsym |
46622 | 46696 | stack[base + 19]/*lookahead*/ = stack[base + 33LLU]; |
@@ -46623,9 +46697,9 @@ | ||
46623 | 46697 | printf("%s", "\n {"); |
46624 | 46698 | printf("%s", "\n label = "); |
46625 | 46699 | // call printnr from procblock |
46626 | - stack[base + 28LLU] = 3927LLU/*throw to this address*/; | |
46700 | + stack[base + 28LLU] = 3936LLU/*throw to this address*/; | |
46627 | 46701 | stack[base + 29LLU] = base; |
46628 | - stack[base + 30LLU] = 3928LLU; | |
46702 | + stack[base + 30LLU] = 3937LLU; | |
46629 | 46703 | // arguments for call to printnr |
46630 | 46704 | stack[base + 31LLU] = stack[base + 24]/*labelskip*/; |
46631 | 46705 | // set stack-base & callee-address |
@@ -46633,13 +46707,13 @@ | ||
46633 | 46707 | label = 18446744073709551590LLU; // printnr |
46634 | 46708 | break; |
46635 | 46709 | } |
46636 | - case 3927LLU: // copy-back deleter (printnr to procblock) | |
46710 | + case 3936LLU: // copy-back deleter (printnr to procblock) | |
46637 | 46711 | { |
46638 | 46712 | // copy mutable arguments back from call to printnr |
46639 | - label = 3847LLU; // continue to roll stack | |
46713 | + label = 3856LLU; // continue to roll stack | |
46640 | 46714 | break; |
46641 | 46715 | } |
46642 | - case 3928LLU: // return from printnr to procblock | |
46716 | + case 3937LLU: // return from printnr to procblock | |
46643 | 46717 | { |
46644 | 46718 | // copy mutable arguments back from call to printnr |
46645 | 46719 | printf("%s", "LLU; // break loop"); |
@@ -46647,26 +46721,26 @@ | ||
46647 | 46721 | printf("%s", "\n }"); |
46648 | 46722 | printf("%s", "\n"); |
46649 | 46723 | printf("%s", "\n // loop body"); |
46650 | - label = 3930LLU; // skip deleter | |
46724 | + label = 3939LLU; // skip deleter | |
46651 | 46725 | break; |
46652 | 46726 | } |
46653 | - case 3929LLU: // deleter | |
46727 | + case 3938LLU: // deleter | |
46654 | 46728 | { |
46655 | 46729 | // throw from procblock |
46656 | 46730 | if(!stack[base + 28]) |
46657 | 46731 | { |
46658 | - label = 3847LLU; // skip, variable already deleted/unscoped | |
46732 | + label = 3856LLU; // skip, variable already deleted/unscoped | |
46659 | 46733 | break; |
46660 | 46734 | } |
46661 | 46735 | // delete list |
46662 | - label = 3931LLU; // start to repeat | |
46736 | + label = 3940LLU; // start to repeat | |
46663 | 46737 | break; |
46664 | 46738 | } |
46665 | - case 3931LLU: // repeat from here | |
46739 | + case 3940LLU: // repeat from here | |
46666 | 46740 | { |
46667 | 46741 | if(!stack[base + 28]) |
46668 | 46742 | { |
46669 | - label = 3932LLU; // break loop | |
46743 | + label = 3941LLU; // break loop | |
46670 | 46744 | break; |
46671 | 46745 | } |
46672 | 46746 |
@@ -46677,7 +46751,7 @@ | ||
46677 | 46751 | newstack[0] = (uint64_t)stack; // backup stack location |
46678 | 46752 | newstack[1] = 1234567890; |
46679 | 46753 | newstack[2] = base; |
46680 | - newstack[3] = 3933LLU; | |
46754 | + newstack[3] = 3942LLU; | |
46681 | 46755 | stack = newstack; |
46682 | 46756 | // set stack-base & callee-address |
46683 | 46757 | base = 4/*deloffset*/; |
@@ -46684,7 +46758,7 @@ | ||
46684 | 46758 | label = 399LLU; // ~typeidx |
46685 | 46759 | break; |
46686 | 46760 | } |
46687 | - case 3933LLU: // return from ~typeidx to procblock | |
46761 | + case 3942LLU: // return from ~typeidx to procblock | |
46688 | 46762 | { |
46689 | 46763 | stack = (uint64_t *)stack[0]; |
46690 | 46764 | // releasing toplevel container |
@@ -46695,21 +46769,21 @@ | ||
46695 | 46769 | stack[base + 28] = (uint64_t)list->next; |
46696 | 46770 | Free(1, sizeof(struct listnode), list); |
46697 | 46771 | } |
46698 | - label = 3931LLU; // repeat | |
46772 | + label = 3940LLU; // repeat | |
46699 | 46773 | break; |
46700 | 46774 | } |
46701 | - case 3932LLU: // loop finished | |
46775 | + case 3941LLU: // loop finished | |
46702 | 46776 | { |
46703 | - label = 3847LLU; // continue unrolling stack, delete next variable | |
46777 | + label = 3856LLU; // continue unrolling stack, delete next variable | |
46704 | 46778 | break; |
46705 | 46779 | } |
46706 | - case 3930LLU: // skipped deleter | |
46780 | + case 3939LLU: // skipped deleter | |
46707 | 46781 | { |
46708 | 46782 | stack[base + 28] = 0; |
46709 | 46783 | uint64_t *newstack = (uint64_t *)Calloc(160LLU + 1, sizeof(uint64_t)); |
46710 | 46784 | if(!newstack) |
46711 | 46785 | { |
46712 | - label = 3929LLU; // throw: begin to unroll stack | |
46786 | + label = 3938LLU; // throw: begin to unroll stack | |
46713 | 46787 | break; |
46714 | 46788 | } |
46715 | 46789 |
@@ -46716,9 +46790,9 @@ | ||
46716 | 46790 | newstack[160LLU] = 9876543210LLU; // overflow-marker |
46717 | 46791 | // call procblock from procblock |
46718 | 46792 | newstack[0] = (uint64_t)stack; // backup stack location |
46719 | - newstack[1] = 3934LLU; | |
46793 | + newstack[1] = 3943LLU; | |
46720 | 46794 | newstack[2] = base; |
46721 | - newstack[3] = 3935LLU; | |
46795 | + newstack[3] = 3944LLU; | |
46722 | 46796 | // arguments for call to procblock |
46723 | 46797 | newstack[4LLU] = stack[base + 0]/*fndefs*/; |
46724 | 46798 | newstack[5LLU] = stack[base + 1]/*datadefs*/; |
@@ -46741,10 +46815,10 @@ | ||
46741 | 46815 | stack = newstack; |
46742 | 46816 | // set stack-base & callee-address |
46743 | 46817 | base = 4/*deloffset*/; |
46744 | - label = 3429LLU; // procblock | |
46818 | + label = 3438LLU; // procblock | |
46745 | 46819 | break; |
46746 | 46820 | } |
46747 | - case 3934LLU: // copy-back deleter (procblock to procblock) | |
46821 | + case 3943LLU: // copy-back deleter (procblock to procblock) | |
46748 | 46822 | { |
46749 | 46823 | uint64_t *oldstack = (uint64_t *)stack[0]; |
46750 | 46824 | // copy mutable arguments back from call to procblock |
@@ -46761,10 +46835,10 @@ | ||
46761 | 46835 | } |
46762 | 46836 | Free(160LLU + 1, sizeof(uint64_t), stack); |
46763 | 46837 | stack = oldstack; |
46764 | - label = 3929LLU; // continue to unroll stack | |
46838 | + label = 3938LLU; // continue to unroll stack | |
46765 | 46839 | break; |
46766 | 46840 | } |
46767 | - case 3935LLU: // return from procblock to procblock | |
46841 | + case 3944LLU: // return from procblock to procblock | |
46768 | 46842 | { |
46769 | 46843 | uint64_t *oldstack = (uint64_t *)stack[0]; |
46770 | 46844 | // copy mutable arguments back from call to procblock |
@@ -46782,14 +46856,14 @@ | ||
46782 | 46856 | Free(160LLU + 1, sizeof(uint64_t), stack); |
46783 | 46857 | stack = oldstack; |
46784 | 46858 | // delete list |
46785 | - label = 3936LLU; // start to repeat | |
46859 | + label = 3945LLU; // start to repeat | |
46786 | 46860 | break; |
46787 | 46861 | } |
46788 | - case 3936LLU: // repeat from here | |
46862 | + case 3945LLU: // repeat from here | |
46789 | 46863 | { |
46790 | 46864 | if(!stack[base + 28]) |
46791 | 46865 | { |
46792 | - label = 3937LLU; // break loop | |
46866 | + label = 3946LLU; // break loop | |
46793 | 46867 | break; |
46794 | 46868 | } |
46795 | 46869 |
@@ -46800,7 +46874,7 @@ | ||
46800 | 46874 | newstack[0] = (uint64_t)stack; // backup stack location |
46801 | 46875 | newstack[1] = 1234567890; |
46802 | 46876 | newstack[2] = base; |
46803 | - newstack[3] = 3938LLU; | |
46877 | + newstack[3] = 3947LLU; | |
46804 | 46878 | stack = newstack; |
46805 | 46879 | // set stack-base & callee-address |
46806 | 46880 | base = 4/*deloffset*/; |
@@ -46807,7 +46881,7 @@ | ||
46807 | 46881 | label = 399LLU; // ~typeidx |
46808 | 46882 | break; |
46809 | 46883 | } |
46810 | - case 3938LLU: // return from ~typeidx to procblock | |
46884 | + case 3947LLU: // return from ~typeidx to procblock | |
46811 | 46885 | { |
46812 | 46886 | stack = (uint64_t *)stack[0]; |
46813 | 46887 | // releasing toplevel container |
@@ -46818,14 +46892,14 @@ | ||
46818 | 46892 | stack[base + 28] = (uint64_t)list->next; |
46819 | 46893 | Free(1, sizeof(struct listnode), list); |
46820 | 46894 | } |
46821 | - label = 3936LLU; // repeat | |
46895 | + label = 3945LLU; // repeat | |
46822 | 46896 | break; |
46823 | 46897 | } |
46824 | - case 3937LLU: // loop finished | |
46898 | + case 3946LLU: // loop finished | |
46825 | 46899 | { |
46826 | 46900 | if(!stack[base + 26]/*inputflag*/) |
46827 | 46901 | { |
46828 | - label = 3939LLU; // jump to alternative | |
46902 | + label = 3948LLU; // jump to alternative | |
46829 | 46903 | break; |
46830 | 46904 | } |
46831 | 46905 |
@@ -46832,9 +46906,9 @@ | ||
46832 | 46906 | // consequent |
46833 | 46907 | printf("%s", "\n if("); |
46834 | 46908 | // call emitvar from procblock |
46835 | - stack[base + 28LLU] = 3941LLU/*throw to this address*/; | |
46909 | + stack[base + 28LLU] = 3950LLU/*throw to this address*/; | |
46836 | 46910 | stack[base + 29LLU] = base; |
46837 | - stack[base + 30LLU] = 3942LLU; | |
46911 | + stack[base + 30LLU] = 3951LLU; | |
46838 | 46912 | // arguments for call to emitvar |
46839 | 46913 | stack[base + 31LLU] = stack[base + 8]/*fnid*/; |
46840 | 46914 | stack[base + 32LLU] = stack[base + 27]/*loopid*/; |
@@ -46845,20 +46919,20 @@ | ||
46845 | 46919 | label = 749LLU; // emitvar |
46846 | 46920 | break; |
46847 | 46921 | } |
46848 | - case 3941LLU: // copy-back deleter (emitvar to procblock) | |
46922 | + case 3950LLU: // copy-back deleter (emitvar to procblock) | |
46849 | 46923 | { |
46850 | 46924 | // copy mutable arguments back from call to emitvar |
46851 | - label = 3847LLU; // continue to roll stack | |
46925 | + label = 3856LLU; // continue to roll stack | |
46852 | 46926 | break; |
46853 | 46927 | } |
46854 | - case 3942LLU: // return from emitvar to procblock | |
46928 | + case 3951LLU: // return from emitvar to procblock | |
46855 | 46929 | { |
46856 | 46930 | // copy mutable arguments back from call to emitvar |
46857 | 46931 | printf("%s", " <= 0xFF) "); |
46858 | 46932 | // call emitvar from procblock |
46859 | - stack[base + 28LLU] = 3943LLU/*throw to this address*/; | |
46933 | + stack[base + 28LLU] = 3952LLU/*throw to this address*/; | |
46860 | 46934 | stack[base + 29LLU] = base; |
46861 | - stack[base + 30LLU] = 3944LLU; | |
46935 | + stack[base + 30LLU] = 3953LLU; | |
46862 | 46936 | // arguments for call to emitvar |
46863 | 46937 | stack[base + 31LLU] = stack[base + 8]/*fnid*/; |
46864 | 46938 | stack[base + 32LLU] = stack[base + 27]/*loopid*/; |
@@ -46869,31 +46943,31 @@ | ||
46869 | 46943 | label = 749LLU; // emitvar |
46870 | 46944 | break; |
46871 | 46945 | } |
46872 | - case 3943LLU: // copy-back deleter (emitvar to procblock) | |
46946 | + case 3952LLU: // copy-back deleter (emitvar to procblock) | |
46873 | 46947 | { |
46874 | 46948 | // copy mutable arguments back from call to emitvar |
46875 | - label = 3847LLU; // continue to roll stack | |
46949 | + label = 3856LLU; // continue to roll stack | |
46876 | 46950 | break; |
46877 | 46951 | } |
46878 | - case 3944LLU: // return from emitvar to procblock | |
46952 | + case 3953LLU: // return from emitvar to procblock | |
46879 | 46953 | { |
46880 | 46954 | // copy mutable arguments back from call to emitvar |
46881 | 46955 | printf("%s", " = getchar();"); |
46882 | - label = 3940LLU; // consequent complete | |
46956 | + label = 3949LLU; // consequent complete | |
46883 | 46957 | break; |
46884 | 46958 | } |
46885 | - case 3939LLU: // alternative | |
46959 | + case 3948LLU: // alternative | |
46886 | 46960 | { |
46887 | - label = 3940LLU; // alternative complete | |
46961 | + label = 3949LLU; // alternative complete | |
46888 | 46962 | break; |
46889 | 46963 | } |
46890 | - case 3940LLU: // completed if-then-else | |
46964 | + case 3949LLU: // completed if-then-else | |
46891 | 46965 | { |
46892 | 46966 | printf("%s", "\n label = "); |
46893 | 46967 | // call printnr from procblock |
46894 | - stack[base + 28LLU] = 3945LLU/*throw to this address*/; | |
46968 | + stack[base + 28LLU] = 3954LLU/*throw to this address*/; | |
46895 | 46969 | stack[base + 29LLU] = base; |
46896 | - stack[base + 30LLU] = 3946LLU; | |
46970 | + stack[base + 30LLU] = 3955LLU; | |
46897 | 46971 | // arguments for call to printnr |
46898 | 46972 | stack[base + 31LLU] = stack[base + 23]/*labelloop*/; |
46899 | 46973 | // set stack-base & callee-address |
@@ -46901,13 +46975,13 @@ | ||
46901 | 46975 | label = 18446744073709551590LLU; // printnr |
46902 | 46976 | break; |
46903 | 46977 | } |
46904 | - case 3945LLU: // copy-back deleter (printnr to procblock) | |
46978 | + case 3954LLU: // copy-back deleter (printnr to procblock) | |
46905 | 46979 | { |
46906 | 46980 | // copy mutable arguments back from call to printnr |
46907 | - label = 3847LLU; // continue to roll stack | |
46981 | + label = 3856LLU; // continue to roll stack | |
46908 | 46982 | break; |
46909 | 46983 | } |
46910 | - case 3946LLU: // return from printnr to procblock | |
46984 | + case 3955LLU: // return from printnr to procblock | |
46911 | 46985 | { |
46912 | 46986 | // copy mutable arguments back from call to printnr |
46913 | 46987 | printf("%s", "LLU; // repeat"); |
@@ -46915,9 +46989,9 @@ | ||
46915 | 46989 | printf("%s", "\n }"); |
46916 | 46990 | printf("%s", "\n case "); |
46917 | 46991 | // call printnr from procblock |
46918 | - stack[base + 28LLU] = 3947LLU/*throw to this address*/; | |
46992 | + stack[base + 28LLU] = 3956LLU/*throw to this address*/; | |
46919 | 46993 | stack[base + 29LLU] = base; |
46920 | - stack[base + 30LLU] = 3948LLU; | |
46994 | + stack[base + 30LLU] = 3957LLU; | |
46921 | 46995 | // arguments for call to printnr |
46922 | 46996 | stack[base + 31LLU] = stack[base + 24]/*labelskip*/; |
46923 | 46997 | // set stack-base & callee-address |
@@ -46925,25 +46999,25 @@ | ||
46925 | 46999 | label = 18446744073709551590LLU; // printnr |
46926 | 47000 | break; |
46927 | 47001 | } |
46928 | - case 3947LLU: // copy-back deleter (printnr to procblock) | |
47002 | + case 3956LLU: // copy-back deleter (printnr to procblock) | |
46929 | 47003 | { |
46930 | 47004 | // copy mutable arguments back from call to printnr |
46931 | - label = 3847LLU; // continue to roll stack | |
47005 | + label = 3856LLU; // continue to roll stack | |
46932 | 47006 | break; |
46933 | 47007 | } |
46934 | - case 3948LLU: // return from printnr to procblock | |
47008 | + case 3957LLU: // return from printnr to procblock | |
46935 | 47009 | { |
46936 | 47010 | // copy mutable arguments back from call to printnr |
46937 | 47011 | printf("%s", "LLU: // loop finished"); |
46938 | 47012 | printf("%s", "\n {"); |
46939 | - label = 3840LLU; // consequent complete | |
47013 | + label = 3849LLU; // consequent complete | |
46940 | 47014 | break; |
46941 | 47015 | } |
46942 | - case 3839LLU: // alternative | |
47016 | + case 3848LLU: // alternative | |
46943 | 47017 | { |
46944 | 47018 | if(!stack[base + 25]/*decflag*/) |
46945 | 47019 | { |
46946 | - label = 3949LLU; // jump to alternative | |
47020 | + label = 3958LLU; // jump to alternative | |
46947 | 47021 | break; |
46948 | 47022 | } |
46949 | 47023 |
@@ -46950,9 +47024,9 @@ | ||
46950 | 47024 | // consequent |
46951 | 47025 | fprintf(stderr, "%s", "in function "); |
46952 | 47026 | // call reportid from procblock |
46953 | - stack[base + 27LLU] = 3951LLU/*throw to this address*/; | |
47027 | + stack[base + 27LLU] = 3960LLU/*throw to this address*/; | |
46954 | 47028 | stack[base + 28LLU] = base; |
46955 | - stack[base + 29LLU] = 3952LLU; | |
47029 | + stack[base + 29LLU] = 3961LLU; | |
46956 | 47030 | // arguments for call to reportid |
46957 | 47031 | stack[base + 30LLU] = stack[base + 8]/*fnid*/; |
46958 | 47032 | // set stack-base & callee-address |
@@ -46960,20 +47034,20 @@ | ||
46960 | 47034 | label = 18446744073709551586LLU; // reportid |
46961 | 47035 | break; |
46962 | 47036 | } |
46963 | - case 3951LLU: // copy-back deleter (reportid to procblock) | |
47037 | + case 3960LLU: // copy-back deleter (reportid to procblock) | |
46964 | 47038 | { |
46965 | 47039 | // copy mutable arguments back from call to reportid |
46966 | - label = 3807LLU; // continue to roll stack | |
47040 | + label = 3816LLU; // continue to roll stack | |
46967 | 47041 | break; |
46968 | 47042 | } |
46969 | - case 3952LLU: // return from reportid to procblock | |
47043 | + case 3961LLU: // return from reportid to procblock | |
46970 | 47044 | { |
46971 | 47045 | // copy mutable arguments back from call to reportid |
46972 | 47046 | fprintf(stderr, "%s", ": while dec expected '(' but found "); |
46973 | 47047 | // call reporttok from procblock |
46974 | - stack[base + 27LLU] = 3953LLU/*throw to this address*/; | |
47048 | + stack[base + 27LLU] = 3962LLU/*throw to this address*/; | |
46975 | 47049 | stack[base + 28LLU] = base; |
46976 | - stack[base + 29LLU] = 3954LLU; | |
47050 | + stack[base + 29LLU] = 3963LLU; | |
46977 | 47051 | // arguments for call to reporttok |
46978 | 47052 | stack[base + 30LLU] = stack[base + 15]/*variant*/; |
46979 | 47053 | stack[base + 31LLU] = stack[base + 16]/*content*/; |
@@ -46982,34 +47056,34 @@ | ||
46982 | 47056 | label = 18446744073709551582LLU; // reporttok |
46983 | 47057 | break; |
46984 | 47058 | } |
46985 | - case 3953LLU: // copy-back deleter (reporttok to procblock) | |
47059 | + case 3962LLU: // copy-back deleter (reporttok to procblock) | |
46986 | 47060 | { |
46987 | 47061 | // copy mutable arguments back from call to reporttok |
46988 | - label = 3807LLU; // continue to roll stack | |
47062 | + label = 3816LLU; // continue to roll stack | |
46989 | 47063 | break; |
46990 | 47064 | } |
46991 | - case 3954LLU: // return from reporttok to procblock | |
47065 | + case 3963LLU: // return from reporttok to procblock | |
46992 | 47066 | { |
46993 | 47067 | // copy mutable arguments back from call to reporttok |
46994 | 47068 | fprintf(stderr, "%s", "\n"); |
46995 | 47069 | { |
46996 | - label = 3807LLU; // throw: begin to unroll stack | |
47070 | + label = 3816LLU; // throw: begin to unroll stack | |
46997 | 47071 | break; |
46998 | 47072 | } |
46999 | 47073 | |
47000 | - label = 3950LLU; // consequent complete | |
47074 | + label = 3959LLU; // consequent complete | |
47001 | 47075 | break; |
47002 | 47076 | } |
47003 | - case 3949LLU: // alternative | |
47077 | + case 3958LLU: // alternative | |
47004 | 47078 | { |
47005 | - label = 3950LLU; // alternative complete | |
47079 | + label = 3959LLU; // alternative complete | |
47006 | 47080 | break; |
47007 | 47081 | } |
47008 | - case 3950LLU: // completed if-then-else | |
47082 | + case 3959LLU: // completed if-then-else | |
47009 | 47083 | { |
47010 | 47084 | if(!stack[base + 26]/*inputflag*/) |
47011 | 47085 | { |
47012 | - label = 3955LLU; // jump to alternative | |
47086 | + label = 3964LLU; // jump to alternative | |
47013 | 47087 | break; |
47014 | 47088 | } |
47015 | 47089 |
@@ -47016,9 +47090,9 @@ | ||
47016 | 47090 | // consequent |
47017 | 47091 | fprintf(stderr, "%s", "in function "); |
47018 | 47092 | // call reportid from procblock |
47019 | - stack[base + 27LLU] = 3957LLU/*throw to this address*/; | |
47093 | + stack[base + 27LLU] = 3966LLU/*throw to this address*/; | |
47020 | 47094 | stack[base + 28LLU] = base; |
47021 | - stack[base + 29LLU] = 3958LLU; | |
47095 | + stack[base + 29LLU] = 3967LLU; | |
47022 | 47096 | // arguments for call to reportid |
47023 | 47097 | stack[base + 30LLU] = stack[base + 8]/*fnid*/; |
47024 | 47098 | // set stack-base & callee-address |
@@ -47026,20 +47100,20 @@ | ||
47026 | 47100 | label = 18446744073709551586LLU; // reportid |
47027 | 47101 | break; |
47028 | 47102 | } |
47029 | - case 3957LLU: // copy-back deleter (reportid to procblock) | |
47103 | + case 3966LLU: // copy-back deleter (reportid to procblock) | |
47030 | 47104 | { |
47031 | 47105 | // copy mutable arguments back from call to reportid |
47032 | - label = 3807LLU; // continue to roll stack | |
47106 | + label = 3816LLU; // continue to roll stack | |
47033 | 47107 | break; |
47034 | 47108 | } |
47035 | - case 3958LLU: // return from reportid to procblock | |
47109 | + case 3967LLU: // return from reportid to procblock | |
47036 | 47110 | { |
47037 | 47111 | // copy mutable arguments back from call to reportid |
47038 | 47112 | fprintf(stderr, "%s", ": while input expected '(' but found "); |
47039 | 47113 | // call reporttok from procblock |
47040 | - stack[base + 27LLU] = 3959LLU/*throw to this address*/; | |
47114 | + stack[base + 27LLU] = 3968LLU/*throw to this address*/; | |
47041 | 47115 | stack[base + 28LLU] = base; |
47042 | - stack[base + 29LLU] = 3960LLU; | |
47116 | + stack[base + 29LLU] = 3969LLU; | |
47043 | 47117 | // arguments for call to reporttok |
47044 | 47118 | stack[base + 30LLU] = stack[base + 15]/*variant*/; |
47045 | 47119 | stack[base + 31LLU] = stack[base + 16]/*content*/; |
@@ -47048,51 +47122,51 @@ | ||
47048 | 47122 | label = 18446744073709551582LLU; // reporttok |
47049 | 47123 | break; |
47050 | 47124 | } |
47051 | - case 3959LLU: // copy-back deleter (reporttok to procblock) | |
47125 | + case 3968LLU: // copy-back deleter (reporttok to procblock) | |
47052 | 47126 | { |
47053 | 47127 | // copy mutable arguments back from call to reporttok |
47054 | - label = 3807LLU; // continue to roll stack | |
47128 | + label = 3816LLU; // continue to roll stack | |
47055 | 47129 | break; |
47056 | 47130 | } |
47057 | - case 3960LLU: // return from reporttok to procblock | |
47131 | + case 3969LLU: // return from reporttok to procblock | |
47058 | 47132 | { |
47059 | 47133 | // copy mutable arguments back from call to reporttok |
47060 | 47134 | fprintf(stderr, "%s", "\n"); |
47061 | 47135 | { |
47062 | - label = 3807LLU; // throw: begin to unroll stack | |
47136 | + label = 3816LLU; // throw: begin to unroll stack | |
47063 | 47137 | break; |
47064 | 47138 | } |
47065 | 47139 | |
47066 | - label = 3956LLU; // consequent complete | |
47140 | + label = 3965LLU; // consequent complete | |
47067 | 47141 | break; |
47068 | 47142 | } |
47069 | - case 3955LLU: // alternative | |
47143 | + case 3964LLU: // alternative | |
47070 | 47144 | { |
47071 | - label = 3956LLU; // alternative complete | |
47145 | + label = 3965LLU; // alternative complete | |
47072 | 47146 | break; |
47073 | 47147 | } |
47074 | - case 3956LLU: // completed if-then-else | |
47148 | + case 3965LLU: // completed if-then-else | |
47075 | 47149 | { |
47076 | - label = 3962LLU; // skip deleter | |
47150 | + label = 3971LLU; // skip deleter | |
47077 | 47151 | break; |
47078 | 47152 | } |
47079 | - case 3961LLU: // deleter | |
47153 | + case 3970LLU: // deleter | |
47080 | 47154 | { |
47081 | 47155 | // throw from procblock |
47082 | 47156 | if(!stack[base + 27]) |
47083 | 47157 | { |
47084 | - label = 3807LLU; // skip, variable already deleted/unscoped | |
47158 | + label = 3816LLU; // skip, variable already deleted/unscoped | |
47085 | 47159 | break; |
47086 | 47160 | } |
47087 | - label = 3807LLU; // continue unrolling stack, delete next variable | |
47161 | + label = 3816LLU; // continue unrolling stack, delete next variable | |
47088 | 47162 | break; |
47089 | 47163 | } |
47090 | - case 3962LLU: // skipped deleter | |
47164 | + case 3971LLU: // skipped deleter | |
47091 | 47165 | { |
47092 | 47166 | // call getdeladdr from procblock |
47093 | - stack[base + 28LLU] = 3963LLU/*throw to this address*/; | |
47167 | + stack[base + 28LLU] = 3972LLU/*throw to this address*/; | |
47094 | 47168 | stack[base + 29LLU] = base; |
47095 | - stack[base + 30LLU] = 3964LLU; | |
47169 | + stack[base + 30LLU] = 3973LLU; | |
47096 | 47170 | // arguments for call to getdeladdr |
47097 | 47171 | stack[base + 32LLU] = stack[base + 3]/*scope*/; |
47098 | 47172 | // set stack-base & callee-address |
@@ -47100,21 +47174,21 @@ | ||
47100 | 47174 | label = 596LLU; // getdeladdr |
47101 | 47175 | break; |
47102 | 47176 | } |
47103 | - case 3963LLU: // copy-back deleter (getdeladdr to procblock) | |
47177 | + case 3972LLU: // copy-back deleter (getdeladdr to procblock) | |
47104 | 47178 | { |
47105 | 47179 | // copy mutable arguments back from call to getdeladdr |
47106 | - label = 3807LLU; // continue to roll stack | |
47180 | + label = 3816LLU; // continue to roll stack | |
47107 | 47181 | break; |
47108 | 47182 | } |
47109 | - case 3964LLU: // return from getdeladdr to procblock | |
47183 | + case 3973LLU: // return from getdeladdr to procblock | |
47110 | 47184 | { |
47111 | 47185 | // copy mutable arguments back from call to getdeladdr |
47112 | 47186 | // copy back results provided by call to getdeladdr |
47113 | 47187 | stack[base + 27] = stack[base + 31LLU]; |
47114 | 47188 | // call add from procblock |
47115 | - stack[base + 28LLU] = 3965LLU/*throw to this address*/; | |
47189 | + stack[base + 28LLU] = 3974LLU/*throw to this address*/; | |
47116 | 47190 | stack[base + 29LLU] = base; |
47117 | - stack[base + 30LLU] = 3966LLU; | |
47191 | + stack[base + 30LLU] = 3975LLU; | |
47118 | 47192 | // arguments for call to add |
47119 | 47193 | stack[base + 32LLU] = 1LLU; |
47120 | 47194 | stack[base + 33LLU] = stack[base + 17]/*label*/; |
@@ -47123,37 +47197,37 @@ | ||
47123 | 47197 | label = 18446744073709551605LLU; // add |
47124 | 47198 | break; |
47125 | 47199 | } |
47126 | - case 3965LLU: // copy-back deleter (add to procblock) | |
47200 | + case 3974LLU: // copy-back deleter (add to procblock) | |
47127 | 47201 | { |
47128 | 47202 | // copy mutable arguments back from call to add |
47129 | - label = 3961LLU; // continue to roll stack | |
47203 | + label = 3970LLU; // continue to roll stack | |
47130 | 47204 | break; |
47131 | 47205 | } |
47132 | - case 3966LLU: // return from add to procblock | |
47206 | + case 3975LLU: // return from add to procblock | |
47133 | 47207 | { |
47134 | 47208 | // copy mutable arguments back from call to add |
47135 | 47209 | // copy back results provided by call to add |
47136 | 47210 | stack[base + 17] = stack[base + 31LLU]; |
47137 | - label = 3968LLU; // skip deleter | |
47211 | + label = 3977LLU; // skip deleter | |
47138 | 47212 | break; |
47139 | 47213 | } |
47140 | - case 3967LLU: // deleter | |
47214 | + case 3976LLU: // deleter | |
47141 | 47215 | { |
47142 | 47216 | // throw from procblock |
47143 | 47217 | if(!stack[base + 28]) |
47144 | 47218 | { |
47145 | - label = 3961LLU; // skip, variable already deleted/unscoped | |
47219 | + label = 3970LLU; // skip, variable already deleted/unscoped | |
47146 | 47220 | break; |
47147 | 47221 | } |
47148 | - label = 3961LLU; // continue unrolling stack, delete next variable | |
47222 | + label = 3970LLU; // continue unrolling stack, delete next variable | |
47149 | 47223 | break; |
47150 | 47224 | } |
47151 | - case 3968LLU: // skipped deleter | |
47225 | + case 3977LLU: // skipped deleter | |
47152 | 47226 | { |
47153 | 47227 | stack[base + 28] = stack[base + 17]/*label*/; |
47154 | 47228 | if(/*scope*/0 != ((uint64_t *)(stack[base + 3]/*scope*/))[0]) |
47155 | 47229 | { |
47156 | - label = 3970LLU; // jump to alternative | |
47230 | + label = 3979LLU; // jump to alternative | |
47157 | 47231 | break; |
47158 | 47232 | } |
47159 | 47233 |
@@ -47164,60 +47238,60 @@ | ||
47164 | 47238 | stack[base + 29]/*deleteaddr*/ = stack[base + 28]/*labelfail*/; |
47165 | 47239 | ((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 30]; |
47166 | 47240 | ((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 29]; |
47167 | - label = 3969LLU; // case complete | |
47241 | + label = 3978LLU; // case complete | |
47168 | 47242 | break; |
47169 | 47243 | } |
47170 | - case 3971LLU: // copy-back deleter (switch) | |
47244 | + case 3980LLU: // copy-back deleter (switch) | |
47171 | 47245 | { |
47172 | 47246 | ((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 30]; |
47173 | 47247 | ((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 29]; |
47174 | - label = 3967LLU; // continue to unroll stack | |
47248 | + label = 3976LLU; // continue to unroll stack | |
47175 | 47249 | break; |
47176 | 47250 | } |
47177 | - case 3970LLU: // try next case | |
47251 | + case 3979LLU: // try next case | |
47178 | 47252 | { |
47179 | 47253 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
47180 | 47254 | exit(-1); |
47181 | 47255 | } |
47182 | - case 3969LLU: // completed switch | |
47256 | + case 3978LLU: // completed switch | |
47183 | 47257 | { |
47184 | - label = 3973LLU; // skip deleter | |
47258 | + label = 3982LLU; // skip deleter | |
47185 | 47259 | break; |
47186 | 47260 | } |
47187 | - case 3972LLU: // deleter | |
47261 | + case 3981LLU: // deleter | |
47188 | 47262 | { |
47189 | 47263 | // throw from procblock |
47190 | 47264 | if(!stack[base + 29]) |
47191 | 47265 | { |
47192 | - label = 3967LLU; // skip, variable already deleted/unscoped | |
47266 | + label = 3976LLU; // skip, variable already deleted/unscoped | |
47193 | 47267 | break; |
47194 | 47268 | } |
47195 | - label = 3967LLU; // continue unrolling stack, delete next variable | |
47269 | + label = 3976LLU; // continue unrolling stack, delete next variable | |
47196 | 47270 | break; |
47197 | 47271 | } |
47198 | - case 3973LLU: // skipped deleter | |
47272 | + case 3982LLU: // skipped deleter | |
47199 | 47273 | { |
47200 | 47274 | stack[base + 29] = 1; |
47201 | - label = 3975LLU; // skip deleter | |
47275 | + label = 3984LLU; // skip deleter | |
47202 | 47276 | break; |
47203 | 47277 | } |
47204 | - case 3974LLU: // deleter | |
47278 | + case 3983LLU: // deleter | |
47205 | 47279 | { |
47206 | 47280 | // throw from procblock |
47207 | 47281 | if(!stack[base + 30]) |
47208 | 47282 | { |
47209 | - label = 3972LLU; // skip, variable already deleted/unscoped | |
47283 | + label = 3981LLU; // skip, variable already deleted/unscoped | |
47210 | 47284 | break; |
47211 | 47285 | } |
47212 | 47286 | // delete list |
47213 | - label = 3976LLU; // start to repeat | |
47287 | + label = 3985LLU; // start to repeat | |
47214 | 47288 | break; |
47215 | 47289 | } |
47216 | - case 3976LLU: // repeat from here | |
47290 | + case 3985LLU: // repeat from here | |
47217 | 47291 | { |
47218 | 47292 | if(!stack[base + 30]) |
47219 | 47293 | { |
47220 | - label = 3977LLU; // break loop | |
47294 | + label = 3986LLU; // break loop | |
47221 | 47295 | break; |
47222 | 47296 | } |
47223 | 47297 |
@@ -47227,36 +47301,36 @@ | ||
47227 | 47301 | stack[base + 30] = (uint64_t)list->next; |
47228 | 47302 | Free(1, sizeof(struct listnode), list); |
47229 | 47303 | } |
47230 | - label = 3976LLU; // repeat | |
47304 | + label = 3985LLU; // repeat | |
47231 | 47305 | break; |
47232 | 47306 | } |
47233 | - case 3977LLU: // loop finished | |
47307 | + case 3986LLU: // loop finished | |
47234 | 47308 | { |
47235 | - label = 3972LLU; // continue unrolling stack, delete next variable | |
47309 | + label = 3981LLU; // continue unrolling stack, delete next variable | |
47236 | 47310 | break; |
47237 | 47311 | } |
47238 | - case 3975LLU: // skipped deleter | |
47312 | + case 3984LLU: // skipped deleter | |
47239 | 47313 | { |
47240 | - label = 3979LLU; // skip deleter | |
47314 | + label = 3988LLU; // skip deleter | |
47241 | 47315 | break; |
47242 | 47316 | } |
47243 | - case 3978LLU: // deleter | |
47317 | + case 3987LLU: // deleter | |
47244 | 47318 | { |
47245 | 47319 | // throw from procblock |
47246 | 47320 | if(!stack[base + 31]) |
47247 | 47321 | { |
47248 | - label = 3974LLU; // skip, variable already deleted/unscoped | |
47322 | + label = 3983LLU; // skip, variable already deleted/unscoped | |
47249 | 47323 | break; |
47250 | 47324 | } |
47251 | 47325 | // delete list |
47252 | - label = 3980LLU; // start to repeat | |
47326 | + label = 3989LLU; // start to repeat | |
47253 | 47327 | break; |
47254 | 47328 | } |
47255 | - case 3980LLU: // repeat from here | |
47329 | + case 3989LLU: // repeat from here | |
47256 | 47330 | { |
47257 | 47331 | if(!stack[base + 31]) |
47258 | 47332 | { |
47259 | - label = 3981LLU; // break loop | |
47333 | + label = 3990LLU; // break loop | |
47260 | 47334 | break; |
47261 | 47335 | } |
47262 | 47336 |
@@ -47266,36 +47340,36 @@ | ||
47266 | 47340 | stack[base + 31] = (uint64_t)list->next; |
47267 | 47341 | Free(1, sizeof(struct listnode), list); |
47268 | 47342 | } |
47269 | - label = 3980LLU; // repeat | |
47343 | + label = 3989LLU; // repeat | |
47270 | 47344 | break; |
47271 | 47345 | } |
47272 | - case 3981LLU: // loop finished | |
47346 | + case 3990LLU: // loop finished | |
47273 | 47347 | { |
47274 | - label = 3974LLU; // continue unrolling stack, delete next variable | |
47348 | + label = 3983LLU; // continue unrolling stack, delete next variable | |
47275 | 47349 | break; |
47276 | 47350 | } |
47277 | - case 3979LLU: // skipped deleter | |
47351 | + case 3988LLU: // skipped deleter | |
47278 | 47352 | { |
47279 | - label = 3983LLU; // skip deleter | |
47353 | + label = 3992LLU; // skip deleter | |
47280 | 47354 | break; |
47281 | 47355 | } |
47282 | - case 3982LLU: // deleter | |
47356 | + case 3991LLU: // deleter | |
47283 | 47357 | { |
47284 | 47358 | // throw from procblock |
47285 | 47359 | if(!stack[base + 30]) |
47286 | 47360 | { |
47287 | - label = 3972LLU; // skip, variable already deleted/unscoped | |
47361 | + label = 3981LLU; // skip, variable already deleted/unscoped | |
47288 | 47362 | break; |
47289 | 47363 | } |
47290 | 47364 | // delete list |
47291 | - label = 3984LLU; // start to repeat | |
47365 | + label = 3993LLU; // start to repeat | |
47292 | 47366 | break; |
47293 | 47367 | } |
47294 | - case 3984LLU: // repeat from here | |
47368 | + case 3993LLU: // repeat from here | |
47295 | 47369 | { |
47296 | 47370 | if(!stack[base + 30]) |
47297 | 47371 | { |
47298 | - label = 3985LLU; // break loop | |
47372 | + label = 3994LLU; // break loop | |
47299 | 47373 | break; |
47300 | 47374 | } |
47301 | 47375 |
@@ -47305,37 +47379,37 @@ | ||
47305 | 47379 | stack[base + 30] = (uint64_t)list->next; |
47306 | 47380 | Free(1, sizeof(struct listnode), list); |
47307 | 47381 | } |
47308 | - label = 3984LLU; // repeat | |
47382 | + label = 3993LLU; // repeat | |
47309 | 47383 | break; |
47310 | 47384 | } |
47311 | - case 3985LLU: // loop finished | |
47385 | + case 3994LLU: // loop finished | |
47312 | 47386 | { |
47313 | - label = 3972LLU; // continue unrolling stack, delete next variable | |
47387 | + label = 3981LLU; // continue unrolling stack, delete next variable | |
47314 | 47388 | break; |
47315 | 47389 | } |
47316 | - case 3983LLU: // skipped deleter | |
47390 | + case 3992LLU: // skipped deleter | |
47317 | 47391 | { |
47318 | 47392 | stack[base + 30] = 0; |
47319 | - label = 3987LLU; // skip deleter | |
47393 | + label = 3996LLU; // skip deleter | |
47320 | 47394 | break; |
47321 | 47395 | } |
47322 | - case 3986LLU: // deleter | |
47396 | + case 3995LLU: // deleter | |
47323 | 47397 | { |
47324 | 47398 | // throw from procblock |
47325 | 47399 | if(!stack[base + 31]) |
47326 | 47400 | { |
47327 | - label = 3982LLU; // skip, variable already deleted/unscoped | |
47401 | + label = 3991LLU; // skip, variable already deleted/unscoped | |
47328 | 47402 | break; |
47329 | 47403 | } |
47330 | 47404 | // delete list |
47331 | - label = 3988LLU; // start to repeat | |
47405 | + label = 3997LLU; // start to repeat | |
47332 | 47406 | break; |
47333 | 47407 | } |
47334 | - case 3988LLU: // repeat from here | |
47408 | + case 3997LLU: // repeat from here | |
47335 | 47409 | { |
47336 | 47410 | if(!stack[base + 31]) |
47337 | 47411 | { |
47338 | - label = 3989LLU; // break loop | |
47412 | + label = 3998LLU; // break loop | |
47339 | 47413 | break; |
47340 | 47414 | } |
47341 | 47415 |
@@ -47345,37 +47419,37 @@ | ||
47345 | 47419 | stack[base + 31] = (uint64_t)list->next; |
47346 | 47420 | Free(1, sizeof(struct listnode), list); |
47347 | 47421 | } |
47348 | - label = 3988LLU; // repeat | |
47422 | + label = 3997LLU; // repeat | |
47349 | 47423 | break; |
47350 | 47424 | } |
47351 | - case 3989LLU: // loop finished | |
47425 | + case 3998LLU: // loop finished | |
47352 | 47426 | { |
47353 | - label = 3982LLU; // continue unrolling stack, delete next variable | |
47427 | + label = 3991LLU; // continue unrolling stack, delete next variable | |
47354 | 47428 | break; |
47355 | 47429 | } |
47356 | - case 3987LLU: // skipped deleter | |
47430 | + case 3996LLU: // skipped deleter | |
47357 | 47431 | { |
47358 | 47432 | stack[base + 31] = 0; |
47359 | - label = 3991LLU; // skip deleter | |
47433 | + label = 4000LLU; // skip deleter | |
47360 | 47434 | break; |
47361 | 47435 | } |
47362 | - case 3990LLU: // deleter | |
47436 | + case 3999LLU: // deleter | |
47363 | 47437 | { |
47364 | 47438 | // throw from procblock |
47365 | 47439 | if(!stack[base + 32]) |
47366 | 47440 | { |
47367 | - label = 3978LLU; // skip, variable already deleted/unscoped | |
47441 | + label = 3987LLU; // skip, variable already deleted/unscoped | |
47368 | 47442 | break; |
47369 | 47443 | } |
47370 | 47444 | // delete list |
47371 | - label = 3992LLU; // start to repeat | |
47445 | + label = 4001LLU; // start to repeat | |
47372 | 47446 | break; |
47373 | 47447 | } |
47374 | - case 3992LLU: // repeat from here | |
47448 | + case 4001LLU: // repeat from here | |
47375 | 47449 | { |
47376 | 47450 | if(!stack[base + 32]) |
47377 | 47451 | { |
47378 | - label = 3993LLU; // break loop | |
47452 | + label = 4002LLU; // break loop | |
47379 | 47453 | break; |
47380 | 47454 | } |
47381 | 47455 |
@@ -47386,14 +47460,14 @@ | ||
47386 | 47460 | newstack[0] = (uint64_t)stack; // backup stack location |
47387 | 47461 | newstack[1] = 1234567890; |
47388 | 47462 | newstack[2] = base; |
47389 | - newstack[3] = 3994LLU; | |
47463 | + newstack[3] = 4003LLU; | |
47390 | 47464 | stack = newstack; |
47391 | 47465 | // set stack-base & callee-address |
47392 | 47466 | base = 4/*deloffset*/; |
47393 | - label = 3310LLU; // ~listtoelem | |
47467 | + label = 3319LLU; // ~listtoelem | |
47394 | 47468 | break; |
47395 | 47469 | } |
47396 | - case 3994LLU: // return from ~listtoelem to procblock | |
47470 | + case 4003LLU: // return from ~listtoelem to procblock | |
47397 | 47471 | { |
47398 | 47472 | stack = (uint64_t *)stack[0]; |
47399 | 47473 | // releasing toplevel container |
@@ -47404,25 +47478,25 @@ | ||
47404 | 47478 | stack[base + 32] = (uint64_t)list->next; |
47405 | 47479 | Free(1, sizeof(struct listnode), list); |
47406 | 47480 | } |
47407 | - label = 3992LLU; // repeat | |
47481 | + label = 4001LLU; // repeat | |
47408 | 47482 | break; |
47409 | 47483 | } |
47410 | - case 3993LLU: // loop finished | |
47484 | + case 4002LLU: // loop finished | |
47411 | 47485 | { |
47412 | - label = 3978LLU; // continue unrolling stack, delete next variable | |
47486 | + label = 3987LLU; // continue unrolling stack, delete next variable | |
47413 | 47487 | break; |
47414 | 47488 | } |
47415 | - case 3991LLU: // skipped deleter | |
47489 | + case 4000LLU: // skipped deleter | |
47416 | 47490 | { |
47417 | 47491 | stack[base + 32] = 0; |
47418 | - label = 3995LLU; // start to repeat | |
47492 | + label = 4004LLU; // start to repeat | |
47419 | 47493 | break; |
47420 | 47494 | } |
47421 | - case 3995LLU: // repeat from here | |
47495 | + case 4004LLU: // repeat from here | |
47422 | 47496 | { |
47423 | 47497 | if(stack[base + 19]/*lookahead*/ > 0xFF) |
47424 | 47498 | { |
47425 | - label = 3996LLU; // break loop | |
47499 | + label = 4005LLU; // break loop | |
47426 | 47500 | break; |
47427 | 47501 | } |
47428 | 47502 |
@@ -47429,21 +47503,21 @@ | ||
47429 | 47503 | // loop body |
47430 | 47504 | if(!stack[base + 29]/*first*/) |
47431 | 47505 | { |
47432 | - label = 3997LLU; // jump to alternative | |
47506 | + label = 4006LLU; // jump to alternative | |
47433 | 47507 | break; |
47434 | 47508 | } |
47435 | 47509 | |
47436 | 47510 | // consequent |
47437 | 47511 | stack[base + 29]/*first*/ = 0; |
47438 | - label = 3998LLU; // consequent complete | |
47512 | + label = 4007LLU; // consequent complete | |
47439 | 47513 | break; |
47440 | 47514 | } |
47441 | - case 3997LLU: // alternative | |
47515 | + case 4006LLU: // alternative | |
47442 | 47516 | { |
47443 | 47517 | // call ParseToken from procblock |
47444 | - stack[base + 33LLU] = 3999LLU/*throw to this address*/; | |
47518 | + stack[base + 33LLU] = 4008LLU/*throw to this address*/; | |
47445 | 47519 | stack[base + 34LLU] = base; |
47446 | - stack[base + 35LLU] = 4000LLU; | |
47520 | + stack[base + 35LLU] = 4009LLU; | |
47447 | 47521 | // arguments for call to ParseToken |
47448 | 47522 | stack[base + 38LLU] = stack[base + 19]/*lookahead*/; |
47449 | 47523 | // set stack-base & callee-address |
@@ -47451,14 +47525,14 @@ | ||
47451 | 47525 | label = 3LLU; // ParseToken |
47452 | 47526 | break; |
47453 | 47527 | } |
47454 | - case 3999LLU: // copy-back deleter (ParseToken to procblock) | |
47528 | + case 4008LLU: // copy-back deleter (ParseToken to procblock) | |
47455 | 47529 | { |
47456 | 47530 | // copy mutable arguments back from call to ParseToken |
47457 | 47531 | stack[base + 19]/*lookahead*/ = stack[base + 38LLU]; |
47458 | - label = 3990LLU; // continue to roll stack | |
47532 | + label = 3999LLU; // continue to roll stack | |
47459 | 47533 | break; |
47460 | 47534 | } |
47461 | - case 4000LLU: // return from ParseToken to procblock | |
47535 | + case 4009LLU: // return from ParseToken to procblock | |
47462 | 47536 | { |
47463 | 47537 | // copy mutable arguments back from call to ParseToken |
47464 | 47538 | stack[base + 19]/*lookahead*/ = stack[base + 38LLU]; |
@@ -47465,20 +47539,20 @@ | ||
47465 | 47539 | // copy back results provided by call to ParseToken |
47466 | 47540 | stack[base + 15] = stack[base + 36LLU]; |
47467 | 47541 | stack[base + 16] = stack[base + 37LLU]; |
47468 | - label = 3998LLU; // alternative complete | |
47542 | + label = 4007LLU; // alternative complete | |
47469 | 47543 | break; |
47470 | 47544 | } |
47471 | - case 3998LLU: // completed if-then-else | |
47545 | + case 4007LLU: // completed if-then-else | |
47472 | 47546 | { |
47473 | - label = 4002LLU; // skip deleter | |
47547 | + label = 4011LLU; // skip deleter | |
47474 | 47548 | break; |
47475 | 47549 | } |
47476 | - case 4001LLU: // deleter | |
47550 | + case 4010LLU: // deleter | |
47477 | 47551 | { |
47478 | 47552 | // throw from procblock |
47479 | 47553 | if(!stack[base + 33]) |
47480 | 47554 | { |
47481 | - label = 3990LLU; // skip, variable already deleted/unscoped | |
47555 | + label = 3999LLU; // skip, variable already deleted/unscoped | |
47482 | 47556 | break; |
47483 | 47557 | } |
47484 | 47558 |
@@ -47487,44 +47561,44 @@ | ||
47487 | 47561 | newstack[0] = (uint64_t)stack; // backup stack location |
47488 | 47562 | newstack[1] = 1234567890; |
47489 | 47563 | newstack[2] = base; |
47490 | - newstack[3] = 4003LLU; | |
47564 | + newstack[3] = 4012LLU; | |
47491 | 47565 | stack = newstack; |
47492 | 47566 | // set stack-base & callee-address |
47493 | 47567 | base = 4/*deloffset*/; |
47494 | - label = 3310LLU; // ~listtoelem | |
47568 | + label = 3319LLU; // ~listtoelem | |
47495 | 47569 | break; |
47496 | 47570 | } |
47497 | - case 4003LLU: // return from ~listtoelem to procblock | |
47571 | + case 4012LLU: // return from ~listtoelem to procblock | |
47498 | 47572 | { |
47499 | 47573 | stack = (uint64_t *)stack[0]; |
47500 | 47574 | // releasing toplevel container |
47501 | 47575 | Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 33] - sizeof(uint64_t) * 4)); |
47502 | 47576 | |
47503 | - label = 3990LLU; // continue unrolling stack, delete next variable | |
47577 | + label = 3999LLU; // continue unrolling stack, delete next variable | |
47504 | 47578 | break; |
47505 | 47579 | } |
47506 | - case 4002LLU: // skipped deleter | |
47580 | + case 4011LLU: // skipped deleter | |
47507 | 47581 | { |
47508 | - label = 4005LLU; // skip deleter | |
47582 | + label = 4014LLU; // skip deleter | |
47509 | 47583 | break; |
47510 | 47584 | } |
47511 | - case 4004LLU: // deleter | |
47585 | + case 4013LLU: // deleter | |
47512 | 47586 | { |
47513 | 47587 | // throw from procblock |
47514 | 47588 | if(!stack[base + 34]) |
47515 | 47589 | { |
47516 | - label = 3990LLU; // skip, variable already deleted/unscoped | |
47590 | + label = 3999LLU; // skip, variable already deleted/unscoped | |
47517 | 47591 | break; |
47518 | 47592 | } |
47519 | - label = 3990LLU; // continue unrolling stack, delete next variable | |
47593 | + label = 3999LLU; // continue unrolling stack, delete next variable | |
47520 | 47594 | break; |
47521 | 47595 | } |
47522 | - case 4005LLU: // skipped deleter | |
47596 | + case 4014LLU: // skipped deleter | |
47523 | 47597 | { |
47524 | 47598 | // call equ from procblock |
47525 | - stack[base + 35LLU] = 4006LLU/*throw to this address*/; | |
47599 | + stack[base + 35LLU] = 4015LLU/*throw to this address*/; | |
47526 | 47600 | stack[base + 36LLU] = base; |
47527 | - stack[base + 37LLU] = 4007LLU; | |
47601 | + stack[base + 37LLU] = 4016LLU; | |
47528 | 47602 | // arguments for call to equ |
47529 | 47603 | stack[base + 39LLU] = stack[base + 16]/*content*/; |
47530 | 47604 | stack[base + 40LLU] = 747825068330975232LLU; |
@@ -47533,13 +47607,13 @@ | ||
47533 | 47607 | label = 18446744073709551600LLU; // equ |
47534 | 47608 | break; |
47535 | 47609 | } |
47536 | - case 4006LLU: // copy-back deleter (equ to procblock) | |
47610 | + case 4015LLU: // copy-back deleter (equ to procblock) | |
47537 | 47611 | { |
47538 | 47612 | // copy mutable arguments back from call to equ |
47539 | - label = 3990LLU; // continue to roll stack | |
47613 | + label = 3999LLU; // continue to roll stack | |
47540 | 47614 | break; |
47541 | 47615 | } |
47542 | - case 4007LLU: // return from equ to procblock | |
47616 | + case 4016LLU: // return from equ to procblock | |
47543 | 47617 | { |
47544 | 47618 | // copy mutable arguments back from call to equ |
47545 | 47619 | // copy back results provided by call to equ |
@@ -47546,37 +47620,37 @@ | ||
47546 | 47620 | stack[base + 20] = stack[base + 38LLU]; |
47547 | 47621 | if(!stack[base + 20]/*isequal*/) |
47548 | 47622 | { |
47549 | - label = 4008LLU; // jump to alternative | |
47623 | + label = 4017LLU; // jump to alternative | |
47550 | 47624 | break; |
47551 | 47625 | } |
47552 | 47626 | |
47553 | 47627 | // consequent |
47554 | - label = 4011LLU; // skip deleter | |
47628 | + label = 4020LLU; // skip deleter | |
47555 | 47629 | break; |
47556 | 47630 | } |
47557 | - case 4010LLU: // deleter | |
47631 | + case 4019LLU: // deleter | |
47558 | 47632 | { |
47559 | 47633 | // throw from procblock |
47560 | 47634 | if(!stack[base + 34]) |
47561 | 47635 | { |
47562 | - label = 3990LLU; // skip, variable already deleted/unscoped | |
47636 | + label = 3999LLU; // skip, variable already deleted/unscoped | |
47563 | 47637 | break; |
47564 | 47638 | } |
47565 | - label = 3990LLU; // continue unrolling stack, delete next variable | |
47639 | + label = 3999LLU; // continue unrolling stack, delete next variable | |
47566 | 47640 | break; |
47567 | 47641 | } |
47568 | - case 4011LLU: // skipped deleter | |
47642 | + case 4020LLU: // skipped deleter | |
47569 | 47643 | { |
47570 | 47644 | stack[base + 34] = 0; |
47571 | - label = 4009LLU; // consequent complete | |
47645 | + label = 4018LLU; // consequent complete | |
47572 | 47646 | break; |
47573 | 47647 | } |
47574 | - case 4008LLU: // alternative | |
47648 | + case 4017LLU: // alternative | |
47575 | 47649 | { |
47576 | 47650 | // call equ from procblock |
47577 | - stack[base + 35LLU] = 4012LLU/*throw to this address*/; | |
47651 | + stack[base + 35LLU] = 4021LLU/*throw to this address*/; | |
47578 | 47652 | stack[base + 36LLU] = base; |
47579 | - stack[base + 37LLU] = 4013LLU; | |
47653 | + stack[base + 37LLU] = 4022LLU; | |
47580 | 47654 | // arguments for call to equ |
47581 | 47655 | stack[base + 39LLU] = stack[base + 16]/*content*/; |
47582 | 47656 | stack[base + 40LLU] = 786630200929550336LLU; |
@@ -47585,13 +47659,13 @@ | ||
47585 | 47659 | label = 18446744073709551600LLU; // equ |
47586 | 47660 | break; |
47587 | 47661 | } |
47588 | - case 4012LLU: // copy-back deleter (equ to procblock) | |
47662 | + case 4021LLU: // copy-back deleter (equ to procblock) | |
47589 | 47663 | { |
47590 | 47664 | // copy mutable arguments back from call to equ |
47591 | - label = 3990LLU; // continue to roll stack | |
47665 | + label = 3999LLU; // continue to roll stack | |
47592 | 47666 | break; |
47593 | 47667 | } |
47594 | - case 4013LLU: // return from equ to procblock | |
47668 | + case 4022LLU: // return from equ to procblock | |
47595 | 47669 | { |
47596 | 47670 | // copy mutable arguments back from call to equ |
47597 | 47671 | // copy back results provided by call to equ |
@@ -47598,38 +47672,38 @@ | ||
47598 | 47672 | stack[base + 20] = stack[base + 38LLU]; |
47599 | 47673 | if(!stack[base + 20]/*isequal*/) |
47600 | 47674 | { |
47601 | - label = 4014LLU; // jump to alternative | |
47675 | + label = 4023LLU; // jump to alternative | |
47602 | 47676 | break; |
47603 | 47677 | } |
47604 | 47678 | |
47605 | 47679 | // consequent |
47606 | - label = 4017LLU; // skip deleter | |
47680 | + label = 4026LLU; // skip deleter | |
47607 | 47681 | break; |
47608 | 47682 | } |
47609 | - case 4016LLU: // deleter | |
47683 | + case 4025LLU: // deleter | |
47610 | 47684 | { |
47611 | 47685 | // throw from procblock |
47612 | 47686 | if(!stack[base + 34]) |
47613 | 47687 | { |
47614 | - label = 3990LLU; // skip, variable already deleted/unscoped | |
47688 | + label = 3999LLU; // skip, variable already deleted/unscoped | |
47615 | 47689 | break; |
47616 | 47690 | } |
47617 | - label = 3990LLU; // continue unrolling stack, delete next variable | |
47691 | + label = 3999LLU; // continue unrolling stack, delete next variable | |
47618 | 47692 | break; |
47619 | 47693 | } |
47620 | - case 4017LLU: // skipped deleter | |
47694 | + case 4026LLU: // skipped deleter | |
47621 | 47695 | { |
47622 | 47696 | stack[base + 34] = 1; |
47623 | - label = 4015LLU; // consequent complete | |
47697 | + label = 4024LLU; // consequent complete | |
47624 | 47698 | break; |
47625 | 47699 | } |
47626 | - case 4014LLU: // alternative | |
47700 | + case 4023LLU: // alternative | |
47627 | 47701 | { |
47628 | 47702 | fprintf(stderr, "%s", "in function "); |
47629 | 47703 | // call reportid from procblock |
47630 | - stack[base + 35LLU] = 4018LLU/*throw to this address*/; | |
47704 | + stack[base + 35LLU] = 4027LLU/*throw to this address*/; | |
47631 | 47705 | stack[base + 36LLU] = base; |
47632 | - stack[base + 37LLU] = 4019LLU; | |
47706 | + stack[base + 37LLU] = 4028LLU; | |
47633 | 47707 | // arguments for call to reportid |
47634 | 47708 | stack[base + 38LLU] = stack[base + 8]/*fnid*/; |
47635 | 47709 | // set stack-base & callee-address |
@@ -47637,21 +47711,21 @@ | ||
47637 | 47711 | label = 18446744073709551586LLU; // reportid |
47638 | 47712 | break; |
47639 | 47713 | } |
47640 | - case 4018LLU: // copy-back deleter (reportid to procblock) | |
47714 | + case 4027LLU: // copy-back deleter (reportid to procblock) | |
47641 | 47715 | { |
47642 | 47716 | // copy mutable arguments back from call to reportid |
47643 | - label = 3990LLU; // continue to roll stack | |
47717 | + label = 3999LLU; // continue to roll stack | |
47644 | 47718 | break; |
47645 | 47719 | } |
47646 | - case 4019LLU: // return from reportid to procblock | |
47720 | + case 4028LLU: // return from reportid to procblock | |
47647 | 47721 | { |
47648 | 47722 | // copy mutable arguments back from call to reportid |
47649 | 47723 | fprintf(stderr, "%s", ": "); |
47650 | 47724 | fprintf(stderr, "%s", "expected next but found token "); |
47651 | 47725 | // call reporttok from procblock |
47652 | - stack[base + 35LLU] = 4020LLU/*throw to this address*/; | |
47726 | + stack[base + 35LLU] = 4029LLU/*throw to this address*/; | |
47653 | 47727 | stack[base + 36LLU] = base; |
47654 | - stack[base + 37LLU] = 4021LLU; | |
47728 | + stack[base + 37LLU] = 4030LLU; | |
47655 | 47729 | // arguments for call to reporttok |
47656 | 47730 | stack[base + 38LLU] = stack[base + 15]/*variant*/; |
47657 | 47731 | stack[base + 39LLU] = stack[base + 16]/*content*/; |
@@ -47660,83 +47734,83 @@ | ||
47660 | 47734 | label = 18446744073709551582LLU; // reporttok |
47661 | 47735 | break; |
47662 | 47736 | } |
47663 | - case 4020LLU: // copy-back deleter (reporttok to procblock) | |
47737 | + case 4029LLU: // copy-back deleter (reporttok to procblock) | |
47664 | 47738 | { |
47665 | 47739 | // copy mutable arguments back from call to reporttok |
47666 | - label = 3990LLU; // continue to roll stack | |
47740 | + label = 3999LLU; // continue to roll stack | |
47667 | 47741 | break; |
47668 | 47742 | } |
47669 | - case 4021LLU: // return from reporttok to procblock | |
47743 | + case 4030LLU: // return from reporttok to procblock | |
47670 | 47744 | { |
47671 | 47745 | // copy mutable arguments back from call to reporttok |
47672 | 47746 | fprintf(stderr, "%s", "\n"); |
47673 | 47747 | { |
47674 | - label = 3990LLU; // throw: begin to unroll stack | |
47748 | + label = 3999LLU; // throw: begin to unroll stack | |
47675 | 47749 | break; |
47676 | 47750 | } |
47677 | 47751 | |
47678 | - label = 4015LLU; // alternative complete | |
47752 | + label = 4024LLU; // alternative complete | |
47679 | 47753 | break; |
47680 | 47754 | } |
47681 | - case 4015LLU: // completed if-then-else | |
47755 | + case 4024LLU: // completed if-then-else | |
47682 | 47756 | { |
47683 | - label = 4009LLU; // alternative complete | |
47757 | + label = 4018LLU; // alternative complete | |
47684 | 47758 | break; |
47685 | 47759 | } |
47686 | - case 4009LLU: // completed if-then-else | |
47760 | + case 4018LLU: // completed if-then-else | |
47687 | 47761 | { |
47688 | - label = 4023LLU; // skip deleter | |
47762 | + label = 4032LLU; // skip deleter | |
47689 | 47763 | break; |
47690 | 47764 | } |
47691 | - case 4022LLU: // deleter | |
47765 | + case 4031LLU: // deleter | |
47692 | 47766 | { |
47693 | 47767 | // throw from procblock |
47694 | 47768 | if(!stack[base + 35]) |
47695 | 47769 | { |
47696 | - label = 4004LLU; // skip, variable already deleted/unscoped | |
47770 | + label = 4013LLU; // skip, variable already deleted/unscoped | |
47697 | 47771 | break; |
47698 | 47772 | } |
47699 | - label = 4004LLU; // continue unrolling stack, delete next variable | |
47773 | + label = 4013LLU; // continue unrolling stack, delete next variable | |
47700 | 47774 | break; |
47701 | 47775 | } |
47702 | - case 4023LLU: // skipped deleter | |
47776 | + case 4032LLU: // skipped deleter | |
47703 | 47777 | { |
47704 | - label = 4025LLU; // skip deleter | |
47778 | + label = 4034LLU; // skip deleter | |
47705 | 47779 | break; |
47706 | 47780 | } |
47707 | - case 4024LLU: // deleter | |
47781 | + case 4033LLU: // deleter | |
47708 | 47782 | { |
47709 | 47783 | // throw from procblock |
47710 | 47784 | if(!stack[base + 36]) |
47711 | 47785 | { |
47712 | - label = 4022LLU; // skip, variable already deleted/unscoped | |
47786 | + label = 4031LLU; // skip, variable already deleted/unscoped | |
47713 | 47787 | break; |
47714 | 47788 | } |
47715 | - label = 4022LLU; // continue unrolling stack, delete next variable | |
47789 | + label = 4031LLU; // continue unrolling stack, delete next variable | |
47716 | 47790 | break; |
47717 | 47791 | } |
47718 | - case 4025LLU: // skipped deleter | |
47792 | + case 4034LLU: // skipped deleter | |
47719 | 47793 | { |
47720 | 47794 | // call listtoelem from procblock |
47721 | - stack[base + 37LLU] = 4026LLU/*throw to this address*/; | |
47795 | + stack[base + 37LLU] = 4035LLU/*throw to this address*/; | |
47722 | 47796 | stack[base + 38LLU] = base; |
47723 | - stack[base + 39LLU] = 4027LLU; | |
47797 | + stack[base + 39LLU] = 4036LLU; | |
47724 | 47798 | // arguments for call to listtoelem |
47725 | 47799 | stack[base + 42LLU] = stack[base + 8]/*fnid*/; |
47726 | 47800 | stack[base + 43LLU] = stack[base + 19]/*lookahead*/; |
47727 | 47801 | // set stack-base & callee-address |
47728 | 47802 | base += 40LLU; |
47729 | - label = 3263LLU; // listtoelem | |
47803 | + label = 3272LLU; // listtoelem | |
47730 | 47804 | break; |
47731 | 47805 | } |
47732 | - case 4026LLU: // copy-back deleter (listtoelem to procblock) | |
47806 | + case 4035LLU: // copy-back deleter (listtoelem to procblock) | |
47733 | 47807 | { |
47734 | 47808 | // copy mutable arguments back from call to listtoelem |
47735 | 47809 | stack[base + 19]/*lookahead*/ = stack[base + 43LLU]; |
47736 | - label = 4004LLU; // continue to roll stack | |
47810 | + label = 4013LLU; // continue to roll stack | |
47737 | 47811 | break; |
47738 | 47812 | } |
47739 | - case 4027LLU: // return from listtoelem to procblock | |
47813 | + case 4036LLU: // return from listtoelem to procblock | |
47740 | 47814 | { |
47741 | 47815 | // copy mutable arguments back from call to listtoelem |
47742 | 47816 | stack[base + 19]/*lookahead*/ = stack[base + 43LLU]; |
@@ -47744,9 +47818,9 @@ | ||
47744 | 47818 | stack[base + 35] = stack[base + 40LLU]; |
47745 | 47819 | stack[base + 36] = stack[base + 41LLU]; |
47746 | 47820 | // call existsid from procblock |
47747 | - stack[base + 37LLU] = 4028LLU/*throw to this address*/; | |
47821 | + stack[base + 37LLU] = 4037LLU/*throw to this address*/; | |
47748 | 47822 | stack[base + 38LLU] = base; |
47749 | - stack[base + 39LLU] = 4029LLU; | |
47823 | + stack[base + 39LLU] = 4038LLU; | |
47750 | 47824 | // arguments for call to existsid |
47751 | 47825 | stack[base + 41LLU] = stack[base + 30]/*listids*/; |
47752 | 47826 | stack[base + 42LLU] = stack[base + 35]/*listid*/; |
@@ -47755,13 +47829,13 @@ | ||
47755 | 47829 | label = 153LLU; // existsid |
47756 | 47830 | break; |
47757 | 47831 | } |
47758 | - case 4028LLU: // copy-back deleter (existsid to procblock) | |
47832 | + case 4037LLU: // copy-back deleter (existsid to procblock) | |
47759 | 47833 | { |
47760 | 47834 | // copy mutable arguments back from call to existsid |
47761 | - label = 4024LLU; // continue to roll stack | |
47835 | + label = 4033LLU; // continue to roll stack | |
47762 | 47836 | break; |
47763 | 47837 | } |
47764 | - case 4029LLU: // return from existsid to procblock | |
47838 | + case 4038LLU: // return from existsid to procblock | |
47765 | 47839 | { |
47766 | 47840 | // copy mutable arguments back from call to existsid |
47767 | 47841 | // copy back results provided by call to existsid |
@@ -47768,7 +47842,7 @@ | ||
47768 | 47842 | stack[base + 20] = stack[base + 40LLU]; |
47769 | 47843 | if(!stack[base + 20]/*isequal*/) |
47770 | 47844 | { |
47771 | - label = 4030LLU; // jump to alternative | |
47845 | + label = 4039LLU; // jump to alternative | |
47772 | 47846 | break; |
47773 | 47847 | } |
47774 | 47848 |
@@ -47775,9 +47849,9 @@ | ||
47775 | 47849 | // consequent |
47776 | 47850 | fprintf(stderr, "%s", "in function "); |
47777 | 47851 | // call reportid from procblock |
47778 | - stack[base + 37LLU] = 4032LLU/*throw to this address*/; | |
47852 | + stack[base + 37LLU] = 4041LLU/*throw to this address*/; | |
47779 | 47853 | stack[base + 38LLU] = base; |
47780 | - stack[base + 39LLU] = 4033LLU; | |
47854 | + stack[base + 39LLU] = 4042LLU; | |
47781 | 47855 | // arguments for call to reportid |
47782 | 47856 | stack[base + 40LLU] = stack[base + 8]/*fnid*/; |
47783 | 47857 | // set stack-base & callee-address |
@@ -47785,20 +47859,20 @@ | ||
47785 | 47859 | label = 18446744073709551586LLU; // reportid |
47786 | 47860 | break; |
47787 | 47861 | } |
47788 | - case 4032LLU: // copy-back deleter (reportid to procblock) | |
47862 | + case 4041LLU: // copy-back deleter (reportid to procblock) | |
47789 | 47863 | { |
47790 | 47864 | // copy mutable arguments back from call to reportid |
47791 | - label = 4024LLU; // continue to roll stack | |
47865 | + label = 4033LLU; // continue to roll stack | |
47792 | 47866 | break; |
47793 | 47867 | } |
47794 | - case 4033LLU: // return from reportid to procblock | |
47868 | + case 4042LLU: // return from reportid to procblock | |
47795 | 47869 | { |
47796 | 47870 | // copy mutable arguments back from call to reportid |
47797 | 47871 | fprintf(stderr, "%s", ": duplicate list "); |
47798 | 47872 | // call printid from procblock |
47799 | - stack[base + 37LLU] = 4034LLU/*throw to this address*/; | |
47873 | + stack[base + 37LLU] = 4043LLU/*throw to this address*/; | |
47800 | 47874 | stack[base + 38LLU] = base; |
47801 | - stack[base + 39LLU] = 4035LLU; | |
47875 | + stack[base + 39LLU] = 4044LLU; | |
47802 | 47876 | // arguments for call to printid |
47803 | 47877 | stack[base + 40LLU] = stack[base + 35]/*listid*/; |
47804 | 47878 | // set stack-base & callee-address |
@@ -47806,30 +47880,30 @@ | ||
47806 | 47880 | label = 18446744073709551587LLU; // printid |
47807 | 47881 | break; |
47808 | 47882 | } |
47809 | - case 4034LLU: // copy-back deleter (printid to procblock) | |
47883 | + case 4043LLU: // copy-back deleter (printid to procblock) | |
47810 | 47884 | { |
47811 | 47885 | // copy mutable arguments back from call to printid |
47812 | - label = 4024LLU; // continue to roll stack | |
47886 | + label = 4033LLU; // continue to roll stack | |
47813 | 47887 | break; |
47814 | 47888 | } |
47815 | - case 4035LLU: // return from printid to procblock | |
47889 | + case 4044LLU: // return from printid to procblock | |
47816 | 47890 | { |
47817 | 47891 | // copy mutable arguments back from call to printid |
47818 | 47892 | printf("%s", " in while-loop\n"); |
47819 | 47893 | { |
47820 | - label = 4024LLU; // throw: begin to unroll stack | |
47894 | + label = 4033LLU; // throw: begin to unroll stack | |
47821 | 47895 | break; |
47822 | 47896 | } |
47823 | 47897 | |
47824 | - label = 4031LLU; // consequent complete | |
47898 | + label = 4040LLU; // consequent complete | |
47825 | 47899 | break; |
47826 | 47900 | } |
47827 | - case 4030LLU: // alternative | |
47901 | + case 4039LLU: // alternative | |
47828 | 47902 | { |
47829 | - label = 4031LLU; // alternative complete | |
47903 | + label = 4040LLU; // alternative complete | |
47830 | 47904 | break; |
47831 | 47905 | } |
47832 | - case 4031LLU: // completed if-then-else | |
47906 | + case 4040LLU: // completed if-then-else | |
47833 | 47907 | { |
47834 | 47908 | { |
47835 | 47909 | struct listnode *list = (struct listnode *)Calloc(1, sizeof(struct listnode)); |
@@ -47845,9 +47919,9 @@ | ||
47845 | 47919 | list->data = stack[base + 35]/*listid*/; |
47846 | 47920 | } |
47847 | 47921 | // call existsid from procblock |
47848 | - stack[base + 37LLU] = 4036LLU/*throw to this address*/; | |
47922 | + stack[base + 37LLU] = 4045LLU/*throw to this address*/; | |
47849 | 47923 | stack[base + 38LLU] = base; |
47850 | - stack[base + 39LLU] = 4037LLU; | |
47924 | + stack[base + 39LLU] = 4046LLU; | |
47851 | 47925 | // arguments for call to existsid |
47852 | 47926 | stack[base + 41LLU] = stack[base + 31]/*elemids*/; |
47853 | 47927 | stack[base + 42LLU] = stack[base + 36]/*elemid*/; |
@@ -47856,13 +47930,13 @@ | ||
47856 | 47930 | label = 153LLU; // existsid |
47857 | 47931 | break; |
47858 | 47932 | } |
47859 | - case 4036LLU: // copy-back deleter (existsid to procblock) | |
47933 | + case 4045LLU: // copy-back deleter (existsid to procblock) | |
47860 | 47934 | { |
47861 | 47935 | // copy mutable arguments back from call to existsid |
47862 | - label = 4024LLU; // continue to roll stack | |
47936 | + label = 4033LLU; // continue to roll stack | |
47863 | 47937 | break; |
47864 | 47938 | } |
47865 | - case 4037LLU: // return from existsid to procblock | |
47939 | + case 4046LLU: // return from existsid to procblock | |
47866 | 47940 | { |
47867 | 47941 | // copy mutable arguments back from call to existsid |
47868 | 47942 | // copy back results provided by call to existsid |
@@ -47869,7 +47943,7 @@ | ||
47869 | 47943 | stack[base + 20] = stack[base + 40LLU]; |
47870 | 47944 | if(!stack[base + 20]/*isequal*/) |
47871 | 47945 | { |
47872 | - label = 4038LLU; // jump to alternative | |
47946 | + label = 4047LLU; // jump to alternative | |
47873 | 47947 | break; |
47874 | 47948 | } |
47875 | 47949 |
@@ -47876,9 +47950,9 @@ | ||
47876 | 47950 | // consequent |
47877 | 47951 | fprintf(stderr, "%s", "in function "); |
47878 | 47952 | // call reportid from procblock |
47879 | - stack[base + 37LLU] = 4040LLU/*throw to this address*/; | |
47953 | + stack[base + 37LLU] = 4049LLU/*throw to this address*/; | |
47880 | 47954 | stack[base + 38LLU] = base; |
47881 | - stack[base + 39LLU] = 4041LLU; | |
47955 | + stack[base + 39LLU] = 4050LLU; | |
47882 | 47956 | // arguments for call to reportid |
47883 | 47957 | stack[base + 40LLU] = stack[base + 8]/*fnid*/; |
47884 | 47958 | // set stack-base & callee-address |
@@ -47886,20 +47960,20 @@ | ||
47886 | 47960 | label = 18446744073709551586LLU; // reportid |
47887 | 47961 | break; |
47888 | 47962 | } |
47889 | - case 4040LLU: // copy-back deleter (reportid to procblock) | |
47963 | + case 4049LLU: // copy-back deleter (reportid to procblock) | |
47890 | 47964 | { |
47891 | 47965 | // copy mutable arguments back from call to reportid |
47892 | - label = 4024LLU; // continue to roll stack | |
47966 | + label = 4033LLU; // continue to roll stack | |
47893 | 47967 | break; |
47894 | 47968 | } |
47895 | - case 4041LLU: // return from reportid to procblock | |
47969 | + case 4050LLU: // return from reportid to procblock | |
47896 | 47970 | { |
47897 | 47971 | // copy mutable arguments back from call to reportid |
47898 | 47972 | fprintf(stderr, "%s", ": duplicate list-element "); |
47899 | 47973 | // call printid from procblock |
47900 | - stack[base + 37LLU] = 4042LLU/*throw to this address*/; | |
47974 | + stack[base + 37LLU] = 4051LLU/*throw to this address*/; | |
47901 | 47975 | stack[base + 38LLU] = base; |
47902 | - stack[base + 39LLU] = 4043LLU; | |
47976 | + stack[base + 39LLU] = 4052LLU; | |
47903 | 47977 | // arguments for call to printid |
47904 | 47978 | stack[base + 40LLU] = stack[base + 36]/*elemid*/; |
47905 | 47979 | // set stack-base & callee-address |
@@ -47907,30 +47981,30 @@ | ||
47907 | 47981 | label = 18446744073709551587LLU; // printid |
47908 | 47982 | break; |
47909 | 47983 | } |
47910 | - case 4042LLU: // copy-back deleter (printid to procblock) | |
47984 | + case 4051LLU: // copy-back deleter (printid to procblock) | |
47911 | 47985 | { |
47912 | 47986 | // copy mutable arguments back from call to printid |
47913 | - label = 4024LLU; // continue to roll stack | |
47987 | + label = 4033LLU; // continue to roll stack | |
47914 | 47988 | break; |
47915 | 47989 | } |
47916 | - case 4043LLU: // return from printid to procblock | |
47990 | + case 4052LLU: // return from printid to procblock | |
47917 | 47991 | { |
47918 | 47992 | // copy mutable arguments back from call to printid |
47919 | 47993 | printf("%s", " in while-loop\n"); |
47920 | 47994 | { |
47921 | - label = 4024LLU; // throw: begin to unroll stack | |
47995 | + label = 4033LLU; // throw: begin to unroll stack | |
47922 | 47996 | break; |
47923 | 47997 | } |
47924 | 47998 | |
47925 | - label = 4039LLU; // consequent complete | |
47999 | + label = 4048LLU; // consequent complete | |
47926 | 48000 | break; |
47927 | 48001 | } |
47928 | - case 4038LLU: // alternative | |
48002 | + case 4047LLU: // alternative | |
47929 | 48003 | { |
47930 | - label = 4039LLU; // alternative complete | |
48004 | + label = 4048LLU; // alternative complete | |
47931 | 48005 | break; |
47932 | 48006 | } |
47933 | - case 4039LLU: // completed if-then-else | |
48007 | + case 4048LLU: // completed if-then-else | |
47934 | 48008 | { |
47935 | 48009 | { |
47936 | 48010 | struct listnode *list = (struct listnode *)Calloc(1, sizeof(struct listnode)); |
@@ -47946,9 +48020,9 @@ | ||
47946 | 48020 | list->data = stack[base + 36]/*elemid*/; |
47947 | 48021 | } |
47948 | 48022 | // call shadowlock from procblock |
47949 | - stack[base + 37LLU] = 4044LLU/*throw to this address*/; | |
48023 | + stack[base + 37LLU] = 4053LLU/*throw to this address*/; | |
47950 | 48024 | stack[base + 38LLU] = base; |
47951 | - stack[base + 39LLU] = 4045LLU; | |
48025 | + stack[base + 39LLU] = 4054LLU; | |
47952 | 48026 | // arguments for call to shadowlock |
47953 | 48027 | stack[base + 41LLU] = stack[base + 8]/*fnid*/; |
47954 | 48028 | stack[base + 42LLU] = stack[base + 2]/*scopes*/; |
@@ -47963,10 +48037,10 @@ | ||
47963 | 48037 | stack[base + 51LLU] = stack[base + 34]/*consume*/; |
47964 | 48038 | // set stack-base & callee-address |
47965 | 48039 | base += 40LLU; |
47966 | - label = 3314LLU; // shadowlock | |
48040 | + label = 3323LLU; // shadowlock | |
47967 | 48041 | break; |
47968 | 48042 | } |
47969 | - case 4044LLU: // copy-back deleter (shadowlock to procblock) | |
48043 | + case 4053LLU: // copy-back deleter (shadowlock to procblock) | |
47970 | 48044 | { |
47971 | 48045 | // copy mutable arguments back from call to shadowlock |
47972 | 48046 | stack[base + 17]/*label*/ = stack[base + 48LLU]; |
@@ -47973,10 +48047,10 @@ | ||
47973 | 48047 | stack[base + 18]/*varcount*/ = stack[base + 47LLU]; |
47974 | 48048 | stack[base + 12]/*fnmaxcount*/ = stack[base + 46LLU]; |
47975 | 48049 | stack[base + 3]/*scope*/ = stack[base + 43LLU]; |
47976 | - label = 4024LLU; // continue to roll stack | |
48050 | + label = 4033LLU; // continue to roll stack | |
47977 | 48051 | break; |
47978 | 48052 | } |
47979 | - case 4045LLU: // return from shadowlock to procblock | |
48053 | + case 4054LLU: // return from shadowlock to procblock | |
47980 | 48054 | { |
47981 | 48055 | // copy mutable arguments back from call to shadowlock |
47982 | 48056 | stack[base + 17]/*label*/ = stack[base + 48LLU]; |
@@ -47999,9 +48073,9 @@ | ||
47999 | 48073 | MOVE(&list->data, &stack[base + 33]/*state*/); |
48000 | 48074 | } |
48001 | 48075 | // call skipwscmnt from procblock |
48002 | - stack[base + 34LLU] = 4046LLU/*throw to this address*/; | |
48076 | + stack[base + 34LLU] = 4055LLU/*throw to this address*/; | |
48003 | 48077 | stack[base + 35LLU] = base; |
48004 | - stack[base + 36LLU] = 4047LLU; | |
48078 | + stack[base + 36LLU] = 4056LLU; | |
48005 | 48079 | // arguments for call to skipwscmnt |
48006 | 48080 | stack[base + 38LLU] = stack[base + 19]/*lookahead*/; |
48007 | 48081 | // set stack-base & callee-address |
@@ -48009,21 +48083,21 @@ | ||
48009 | 48083 | label = 18446744073709551580LLU; // skipwscmnt |
48010 | 48084 | break; |
48011 | 48085 | } |
48012 | - case 4046LLU: // copy-back deleter (skipwscmnt to procblock) | |
48086 | + case 4055LLU: // copy-back deleter (skipwscmnt to procblock) | |
48013 | 48087 | { |
48014 | 48088 | // copy mutable arguments back from call to skipwscmnt |
48015 | - label = 4001LLU; // continue to roll stack | |
48089 | + label = 4010LLU; // continue to roll stack | |
48016 | 48090 | break; |
48017 | 48091 | } |
48018 | - case 4047LLU: // return from skipwscmnt to procblock | |
48092 | + case 4056LLU: // return from skipwscmnt to procblock | |
48019 | 48093 | { |
48020 | 48094 | // copy mutable arguments back from call to skipwscmnt |
48021 | 48095 | // copy back results provided by call to skipwscmnt |
48022 | 48096 | stack[base + 19] = stack[base + 37LLU]; |
48023 | 48097 | // call equ from procblock |
48024 | - stack[base + 34LLU] = 4048LLU/*throw to this address*/; | |
48098 | + stack[base + 34LLU] = 4057LLU/*throw to this address*/; | |
48025 | 48099 | stack[base + 35LLU] = base; |
48026 | - stack[base + 36LLU] = 4049LLU; | |
48100 | + stack[base + 36LLU] = 4058LLU; | |
48027 | 48101 | // arguments for call to equ |
48028 | 48102 | stack[base + 38LLU] = 123LLU; |
48029 | 48103 | stack[base + 39LLU] = stack[base + 19]/*lookahead*/; |
@@ -48032,13 +48106,13 @@ | ||
48032 | 48106 | label = 18446744073709551600LLU; // equ |
48033 | 48107 | break; |
48034 | 48108 | } |
48035 | - case 4048LLU: // copy-back deleter (equ to procblock) | |
48109 | + case 4057LLU: // copy-back deleter (equ to procblock) | |
48036 | 48110 | { |
48037 | 48111 | // copy mutable arguments back from call to equ |
48038 | - label = 4001LLU; // continue to roll stack | |
48112 | + label = 4010LLU; // continue to roll stack | |
48039 | 48113 | break; |
48040 | 48114 | } |
48041 | - case 4049LLU: // return from equ to procblock | |
48115 | + case 4058LLU: // return from equ to procblock | |
48042 | 48116 | { |
48043 | 48117 | // copy mutable arguments back from call to equ |
48044 | 48118 | // copy back results provided by call to equ |
@@ -48045,15 +48119,15 @@ | ||
48045 | 48119 | stack[base + 20] = stack[base + 37LLU]; |
48046 | 48120 | if(!stack[base + 20]/*isequal*/) |
48047 | 48121 | { |
48048 | - label = 4050LLU; // jump to alternative | |
48122 | + label = 4059LLU; // jump to alternative | |
48049 | 48123 | break; |
48050 | 48124 | } |
48051 | 48125 | |
48052 | 48126 | // consequent |
48053 | 48127 | // call EOSbyte from procblock |
48054 | - stack[base + 34LLU] = 4052LLU/*throw to this address*/; | |
48128 | + stack[base + 34LLU] = 4061LLU/*throw to this address*/; | |
48055 | 48129 | stack[base + 35LLU] = base; |
48056 | - stack[base + 36LLU] = 4053LLU; | |
48130 | + stack[base + 36LLU] = 4062LLU; | |
48057 | 48131 | // arguments for call to EOSbyte |
48058 | 48132 | // set stack-base & callee-address |
48059 | 48133 | base += 37LLU; |
@@ -48060,26 +48134,26 @@ | ||
48060 | 48134 | label = 77LLU; // EOSbyte |
48061 | 48135 | break; |
48062 | 48136 | } |
48063 | - case 4052LLU: // copy-back deleter (EOSbyte to procblock) | |
48137 | + case 4061LLU: // copy-back deleter (EOSbyte to procblock) | |
48064 | 48138 | { |
48065 | 48139 | // copy mutable arguments back from call to EOSbyte |
48066 | - label = 4001LLU; // continue to roll stack | |
48140 | + label = 4010LLU; // continue to roll stack | |
48067 | 48141 | break; |
48068 | 48142 | } |
48069 | - case 4053LLU: // return from EOSbyte to procblock | |
48143 | + case 4062LLU: // return from EOSbyte to procblock | |
48070 | 48144 | { |
48071 | 48145 | // copy mutable arguments back from call to EOSbyte |
48072 | 48146 | // copy back results provided by call to EOSbyte |
48073 | 48147 | stack[base + 19] = stack[base + 37LLU]; |
48074 | - label = 4051LLU; // consequent complete | |
48148 | + label = 4060LLU; // consequent complete | |
48075 | 48149 | break; |
48076 | 48150 | } |
48077 | - case 4050LLU: // alternative | |
48151 | + case 4059LLU: // alternative | |
48078 | 48152 | { |
48079 | 48153 | // call MATCHPEEK from procblock |
48080 | - stack[base + 34LLU] = 4054LLU/*throw to this address*/; | |
48154 | + stack[base + 34LLU] = 4063LLU/*throw to this address*/; | |
48081 | 48155 | stack[base + 35LLU] = base; |
48082 | - stack[base + 36LLU] = 4055LLU; | |
48156 | + stack[base + 36LLU] = 4064LLU; | |
48083 | 48157 | // arguments for call to MATCHPEEK |
48084 | 48158 | stack[base + 37LLU] = stack[base + 8]/*fnid*/; |
48085 | 48159 | stack[base + 38LLU] = 44LLU; |
@@ -48089,32 +48163,32 @@ | ||
48089 | 48163 | label = 206LLU; // MATCHPEEK |
48090 | 48164 | break; |
48091 | 48165 | } |
48092 | - case 4054LLU: // copy-back deleter (MATCHPEEK to procblock) | |
48166 | + case 4063LLU: // copy-back deleter (MATCHPEEK to procblock) | |
48093 | 48167 | { |
48094 | 48168 | // copy mutable arguments back from call to MATCHPEEK |
48095 | 48169 | stack[base + 19]/*lookahead*/ = stack[base + 39LLU]; |
48096 | - label = 4001LLU; // continue to roll stack | |
48170 | + label = 4010LLU; // continue to roll stack | |
48097 | 48171 | break; |
48098 | 48172 | } |
48099 | - case 4055LLU: // return from MATCHPEEK to procblock | |
48173 | + case 4064LLU: // return from MATCHPEEK to procblock | |
48100 | 48174 | { |
48101 | 48175 | // copy mutable arguments back from call to MATCHPEEK |
48102 | 48176 | stack[base + 19]/*lookahead*/ = stack[base + 39LLU]; |
48103 | - label = 4051LLU; // alternative complete | |
48177 | + label = 4060LLU; // alternative complete | |
48104 | 48178 | break; |
48105 | 48179 | } |
48106 | - case 4051LLU: // completed if-then-else | |
48180 | + case 4060LLU: // completed if-then-else | |
48107 | 48181 | { |
48108 | 48182 | if(stack[base + 19]/*lookahead*/ <= 0xFF) stack[base + 19]/*lookahead*/ = getchar(); |
48109 | - label = 3995LLU; // repeat | |
48183 | + label = 4004LLU; // repeat | |
48110 | 48184 | break; |
48111 | 48185 | } |
48112 | - case 3996LLU: // loop finished | |
48186 | + case 4005LLU: // loop finished | |
48113 | 48187 | { |
48114 | 48188 | // call getbyte from procblock |
48115 | - stack[base + 33LLU] = 4056LLU/*throw to this address*/; | |
48189 | + stack[base + 33LLU] = 4065LLU/*throw to this address*/; | |
48116 | 48190 | stack[base + 34LLU] = base; |
48117 | - stack[base + 35LLU] = 4057LLU; | |
48191 | + stack[base + 35LLU] = 4066LLU; | |
48118 | 48192 | // arguments for call to getbyte |
48119 | 48193 | // set stack-base & callee-address |
48120 | 48194 | base += 36LLU; |
@@ -48121,13 +48195,13 @@ | ||
48121 | 48195 | label = 18446744073709551593LLU; // getbyte |
48122 | 48196 | break; |
48123 | 48197 | } |
48124 | - case 4056LLU: // copy-back deleter (getbyte to procblock) | |
48198 | + case 4065LLU: // copy-back deleter (getbyte to procblock) | |
48125 | 48199 | { |
48126 | 48200 | // copy mutable arguments back from call to getbyte |
48127 | - label = 3990LLU; // continue to roll stack | |
48201 | + label = 3999LLU; // continue to roll stack | |
48128 | 48202 | break; |
48129 | 48203 | } |
48130 | - case 4057LLU: // return from getbyte to procblock | |
48204 | + case 4066LLU: // return from getbyte to procblock | |
48131 | 48205 | { |
48132 | 48206 | // copy mutable arguments back from call to getbyte |
48133 | 48207 | // copy back results provided by call to getbyte |
@@ -48134,9 +48208,9 @@ | ||
48134 | 48208 | stack[base + 19] = stack[base + 36LLU]; |
48135 | 48209 | printf("%s", "\n label = "); |
48136 | 48210 | // call printnr from procblock |
48137 | - stack[base + 33LLU] = 4058LLU/*throw to this address*/; | |
48211 | + stack[base + 33LLU] = 4067LLU/*throw to this address*/; | |
48138 | 48212 | stack[base + 34LLU] = base; |
48139 | - stack[base + 35LLU] = 4059LLU; | |
48213 | + stack[base + 35LLU] = 4068LLU; | |
48140 | 48214 | // arguments for call to printnr |
48141 | 48215 | stack[base + 36LLU] = stack[base + 23]/*labelloop*/; |
48142 | 48216 | // set stack-base & callee-address |
@@ -48144,13 +48218,13 @@ | ||
48144 | 48218 | label = 18446744073709551590LLU; // printnr |
48145 | 48219 | break; |
48146 | 48220 | } |
48147 | - case 4058LLU: // copy-back deleter (printnr to procblock) | |
48221 | + case 4067LLU: // copy-back deleter (printnr to procblock) | |
48148 | 48222 | { |
48149 | 48223 | // copy mutable arguments back from call to printnr |
48150 | - label = 3990LLU; // continue to roll stack | |
48224 | + label = 3999LLU; // continue to roll stack | |
48151 | 48225 | break; |
48152 | 48226 | } |
48153 | - case 4059LLU: // return from printnr to procblock | |
48227 | + case 4068LLU: // return from printnr to procblock | |
48154 | 48228 | { |
48155 | 48229 | // copy mutable arguments back from call to printnr |
48156 | 48230 | printf("%s", "LLU; // start to repeat"); |
@@ -48158,9 +48232,9 @@ | ||
48158 | 48232 | printf("%s", "\n }"); |
48159 | 48233 | printf("%s", "\n case "); |
48160 | 48234 | // call printnr from procblock |
48161 | - stack[base + 33LLU] = 4060LLU/*throw to this address*/; | |
48235 | + stack[base + 33LLU] = 4069LLU/*throw to this address*/; | |
48162 | 48236 | stack[base + 34LLU] = base; |
48163 | - stack[base + 35LLU] = 4061LLU; | |
48237 | + stack[base + 35LLU] = 4070LLU; | |
48164 | 48238 | // arguments for call to printnr |
48165 | 48239 | stack[base + 36LLU] = stack[base + 23]/*labelloop*/; |
48166 | 48240 | // set stack-base & callee-address |
@@ -48168,13 +48242,13 @@ | ||
48168 | 48242 | label = 18446744073709551590LLU; // printnr |
48169 | 48243 | break; |
48170 | 48244 | } |
48171 | - case 4060LLU: // copy-back deleter (printnr to procblock) | |
48245 | + case 4069LLU: // copy-back deleter (printnr to procblock) | |
48172 | 48246 | { |
48173 | 48247 | // copy mutable arguments back from call to printnr |
48174 | - label = 3990LLU; // continue to roll stack | |
48248 | + label = 3999LLU; // continue to roll stack | |
48175 | 48249 | break; |
48176 | 48250 | } |
48177 | - case 4061LLU: // return from printnr to procblock | |
48251 | + case 4070LLU: // return from printnr to procblock | |
48178 | 48252 | { |
48179 | 48253 | // copy mutable arguments back from call to printnr |
48180 | 48254 | printf("%s", "LLU: // repeat from here"); |
@@ -48181,14 +48255,14 @@ | ||
48181 | 48255 | printf("%s", "\n {"); |
48182 | 48256 | printf("%s", "\n if("); |
48183 | 48257 | flippedassign(stack[base + 32]/*states*/, &stack[base + 33]); |
48184 | - label = 4062LLU; // start to repeat | |
48258 | + label = 4071LLU; // start to repeat | |
48185 | 48259 | break; |
48186 | 48260 | } |
48187 | - case 4062LLU: // repeat from here | |
48261 | + case 4071LLU: // repeat from here | |
48188 | 48262 | { |
48189 | 48263 | if(!stack[base + 33]) |
48190 | 48264 | { |
48191 | - label = 4063LLU; // break loop | |
48265 | + label = 4072LLU; // break loop | |
48192 | 48266 | break; |
48193 | 48267 | } |
48194 | 48268 |
@@ -48198,7 +48272,7 @@ | ||
48198 | 48272 | stack[base + 33] = (uint64_t)(((const struct listnode *)(stack[base + 33]))->next); |
48199 | 48273 | if(/*listtoelem*/0 != ((uint64_t *)(stack[base + 34]/*state*/))[0]) |
48200 | 48274 | { |
48201 | - label = 4066LLU; // jump to alternative | |
48275 | + label = 4075LLU; // jump to alternative | |
48202 | 48276 | break; |
48203 | 48277 | } |
48204 | 48278 |
@@ -48210,9 +48284,9 @@ | ||
48210 | 48284 | // case |
48211 | 48285 | printf("%s", "!"); |
48212 | 48286 | // call emitvaridx from procblock |
48213 | - stack[base + 40LLU] = 4068LLU/*throw to this address*/; | |
48287 | + stack[base + 40LLU] = 4077LLU/*throw to this address*/; | |
48214 | 48288 | stack[base + 41LLU] = base; |
48215 | - stack[base + 42LLU] = 4069LLU; | |
48289 | + stack[base + 42LLU] = 4078LLU; | |
48216 | 48290 | // arguments for call to emitvaridx |
48217 | 48291 | stack[base + 43LLU] = stack[base + 36]/*listindex*/; |
48218 | 48292 | // set stack-base & callee-address |
@@ -48220,13 +48294,13 @@ | ||
48220 | 48294 | label = 745LLU; // emitvaridx |
48221 | 48295 | break; |
48222 | 48296 | } |
48223 | - case 4068LLU: // copy-back deleter (emitvaridx to procblock) | |
48297 | + case 4077LLU: // copy-back deleter (emitvaridx to procblock) | |
48224 | 48298 | { |
48225 | 48299 | // copy mutable arguments back from call to emitvaridx |
48226 | - label = 4067LLU; // continue to roll stack | |
48300 | + label = 4076LLU; // continue to roll stack | |
48227 | 48301 | break; |
48228 | 48302 | } |
48229 | - case 4069LLU: // return from emitvaridx to procblock | |
48303 | + case 4078LLU: // return from emitvaridx to procblock | |
48230 | 48304 | { |
48231 | 48305 | // copy mutable arguments back from call to emitvaridx |
48232 | 48306 | ((uint64_t **)(stack[base + 34]))[1][3] = stack[base + 39]; |
@@ -48233,62 +48307,62 @@ | ||
48233 | 48307 | ((uint64_t **)(stack[base + 34]))[1][2] = stack[base + 38]; |
48234 | 48308 | ((uint64_t **)(stack[base + 34]))[1][1] = stack[base + 37]; |
48235 | 48309 | ((uint64_t **)(stack[base + 34]))[1][0] = stack[base + 36]; |
48236 | - label = 4065LLU; // case complete | |
48310 | + label = 4074LLU; // case complete | |
48237 | 48311 | break; |
48238 | 48312 | } |
48239 | - case 4067LLU: // copy-back deleter (switch) | |
48313 | + case 4076LLU: // copy-back deleter (switch) | |
48240 | 48314 | { |
48241 | 48315 | ((uint64_t **)(stack[base + 34]))[1][3] = stack[base + 39]; |
48242 | 48316 | ((uint64_t **)(stack[base + 34]))[1][2] = stack[base + 38]; |
48243 | 48317 | ((uint64_t **)(stack[base + 34]))[1][1] = stack[base + 37]; |
48244 | 48318 | ((uint64_t **)(stack[base + 34]))[1][0] = stack[base + 36]; |
48245 | - label = 4064LLU; // continue to unroll stack | |
48319 | + label = 4073LLU; // continue to unroll stack | |
48246 | 48320 | break; |
48247 | 48321 | } |
48248 | - case 4066LLU: // try next case | |
48322 | + case 4075LLU: // try next case | |
48249 | 48323 | { |
48250 | 48324 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
48251 | 48325 | exit(-1); |
48252 | 48326 | } |
48253 | - case 4065LLU: // completed switch | |
48327 | + case 4074LLU: // completed switch | |
48254 | 48328 | { |
48255 | 48329 | if(!stack[base + 33]/*states*/) |
48256 | 48330 | { |
48257 | - label = 4070LLU; // jump to alternative | |
48331 | + label = 4079LLU; // jump to alternative | |
48258 | 48332 | break; |
48259 | 48333 | } |
48260 | 48334 | |
48261 | 48335 | // consequent |
48262 | 48336 | printf("%s", " || "); |
48263 | - label = 4071LLU; // consequent complete | |
48337 | + label = 4080LLU; // consequent complete | |
48264 | 48338 | break; |
48265 | 48339 | } |
48266 | - case 4070LLU: // alternative | |
48340 | + case 4079LLU: // alternative | |
48267 | 48341 | { |
48268 | - label = 4071LLU; // alternative complete | |
48342 | + label = 4080LLU; // alternative complete | |
48269 | 48343 | break; |
48270 | 48344 | } |
48271 | - case 4071LLU: // completed if-then-else | |
48345 | + case 4080LLU: // completed if-then-else | |
48272 | 48346 | { |
48273 | 48347 | ((struct listnode *)(stack[base + 35]/*previous*/))->data = stack[base + 34]; |
48274 | - label = 4062LLU; // repeat | |
48348 | + label = 4071LLU; // repeat | |
48275 | 48349 | break; |
48276 | 48350 | } |
48277 | - case 4064LLU: // copy-back deleter for while next | |
48351 | + case 4073LLU: // copy-back deleter for while next | |
48278 | 48352 | { |
48279 | 48353 | ((struct listnode *)(stack[base + 35]/*previous*/))->data = stack[base + 34]; |
48280 | - label = 3990LLU; // continue to unroll stack | |
48354 | + label = 3999LLU; // continue to unroll stack | |
48281 | 48355 | break; |
48282 | 48356 | } |
48283 | - case 4063LLU: // loop finished | |
48357 | + case 4072LLU: // loop finished | |
48284 | 48358 | { |
48285 | 48359 | printf("%s", ")"); |
48286 | 48360 | printf("%s", "\n {"); |
48287 | 48361 | printf("%s", "\n label = "); |
48288 | 48362 | // call printnr from procblock |
48289 | - stack[base + 36LLU] = 4072LLU/*throw to this address*/; | |
48363 | + stack[base + 36LLU] = 4081LLU/*throw to this address*/; | |
48290 | 48364 | stack[base + 37LLU] = base; |
48291 | - stack[base + 38LLU] = 4073LLU; | |
48365 | + stack[base + 38LLU] = 4082LLU; | |
48292 | 48366 | // arguments for call to printnr |
48293 | 48367 | stack[base + 39LLU] = stack[base + 24]/*labelskip*/; |
48294 | 48368 | // set stack-base & callee-address |
@@ -48296,13 +48370,13 @@ | ||
48296 | 48370 | label = 18446744073709551590LLU; // printnr |
48297 | 48371 | break; |
48298 | 48372 | } |
48299 | - case 4072LLU: // copy-back deleter (printnr to procblock) | |
48373 | + case 4081LLU: // copy-back deleter (printnr to procblock) | |
48300 | 48374 | { |
48301 | 48375 | // copy mutable arguments back from call to printnr |
48302 | - label = 3990LLU; // continue to roll stack | |
48376 | + label = 3999LLU; // continue to roll stack | |
48303 | 48377 | break; |
48304 | 48378 | } |
48305 | - case 4073LLU: // return from printnr to procblock | |
48379 | + case 4082LLU: // return from printnr to procblock | |
48306 | 48380 | { |
48307 | 48381 | // copy mutable arguments back from call to printnr |
48308 | 48382 | printf("%s", "LLU; // break loop"); |
@@ -48311,14 +48385,14 @@ | ||
48311 | 48385 | printf("%s", "\n"); |
48312 | 48386 | printf("%s", "\n // loop body"); |
48313 | 48387 | flippedassign(stack[base + 32]/*states*/, &stack[base + 36]); |
48314 | - label = 4074LLU; // start to repeat | |
48388 | + label = 4083LLU; // start to repeat | |
48315 | 48389 | break; |
48316 | 48390 | } |
48317 | - case 4074LLU: // repeat from here | |
48391 | + case 4083LLU: // repeat from here | |
48318 | 48392 | { |
48319 | 48393 | if(!stack[base + 36]) |
48320 | 48394 | { |
48321 | - label = 4075LLU; // break loop | |
48395 | + label = 4084LLU; // break loop | |
48322 | 48396 | break; |
48323 | 48397 | } |
48324 | 48398 |
@@ -48328,7 +48402,7 @@ | ||
48328 | 48402 | stack[base + 36] = (uint64_t)(((const struct listnode *)(stack[base + 36]))->next); |
48329 | 48403 | if(/*listtoelem*/0 != ((uint64_t *)(stack[base + 37]/*state*/))[0]) |
48330 | 48404 | { |
48331 | - label = 4078LLU; // jump to alternative | |
48405 | + label = 4087LLU; // jump to alternative | |
48332 | 48406 | break; |
48333 | 48407 | } |
48334 | 48408 |
@@ -48340,9 +48414,9 @@ | ||
48340 | 48414 | // case |
48341 | 48415 | printf("%s", "\n "); |
48342 | 48416 | // call emitvaridx from procblock |
48343 | - stack[base + 43LLU] = 4080LLU/*throw to this address*/; | |
48417 | + stack[base + 43LLU] = 4089LLU/*throw to this address*/; | |
48344 | 48418 | stack[base + 44LLU] = base; |
48345 | - stack[base + 45LLU] = 4081LLU; | |
48419 | + stack[base + 45LLU] = 4090LLU; | |
48346 | 48420 | // arguments for call to emitvaridx |
48347 | 48421 | stack[base + 46LLU] = stack[base + 42]/*elemindex*/; |
48348 | 48422 | // set stack-base & callee-address |
@@ -48350,20 +48424,20 @@ | ||
48350 | 48424 | label = 745LLU; // emitvaridx |
48351 | 48425 | break; |
48352 | 48426 | } |
48353 | - case 4080LLU: // copy-back deleter (emitvaridx to procblock) | |
48427 | + case 4089LLU: // copy-back deleter (emitvaridx to procblock) | |
48354 | 48428 | { |
48355 | 48429 | // copy mutable arguments back from call to emitvaridx |
48356 | - label = 4079LLU; // continue to roll stack | |
48430 | + label = 4088LLU; // continue to roll stack | |
48357 | 48431 | break; |
48358 | 48432 | } |
48359 | - case 4081LLU: // return from emitvaridx to procblock | |
48433 | + case 4090LLU: // return from emitvaridx to procblock | |
48360 | 48434 | { |
48361 | 48435 | // copy mutable arguments back from call to emitvaridx |
48362 | 48436 | printf("%s", " = (uint64_t)(((const struct listnode *)("); |
48363 | 48437 | // call emitvaridx from procblock |
48364 | - stack[base + 43LLU] = 4082LLU/*throw to this address*/; | |
48438 | + stack[base + 43LLU] = 4091LLU/*throw to this address*/; | |
48365 | 48439 | stack[base + 44LLU] = base; |
48366 | - stack[base + 45LLU] = 4083LLU; | |
48440 | + stack[base + 45LLU] = 4092LLU; | |
48367 | 48441 | // arguments for call to emitvaridx |
48368 | 48442 | stack[base + 46LLU] = stack[base + 39]/*listindex*/; |
48369 | 48443 | // set stack-base & callee-address |
@@ -48371,13 +48445,13 @@ | ||
48371 | 48445 | label = 745LLU; // emitvaridx |
48372 | 48446 | break; |
48373 | 48447 | } |
48374 | - case 4082LLU: // copy-back deleter (emitvaridx to procblock) | |
48448 | + case 4091LLU: // copy-back deleter (emitvaridx to procblock) | |
48375 | 48449 | { |
48376 | 48450 | // copy mutable arguments back from call to emitvaridx |
48377 | - label = 4079LLU; // continue to roll stack | |
48451 | + label = 4088LLU; // continue to roll stack | |
48378 | 48452 | break; |
48379 | 48453 | } |
48380 | - case 4083LLU: // return from emitvaridx to procblock | |
48454 | + case 4092LLU: // return from emitvaridx to procblock | |
48381 | 48455 | { |
48382 | 48456 | // copy mutable arguments back from call to emitvaridx |
48383 | 48457 | printf("%s", "))->data);"); |
@@ -48385,46 +48459,46 @@ | ||
48385 | 48459 | ((uint64_t **)(stack[base + 37]))[1][2] = stack[base + 41]; |
48386 | 48460 | ((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40]; |
48387 | 48461 | ((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39]; |
48388 | - label = 4077LLU; // case complete | |
48462 | + label = 4086LLU; // case complete | |
48389 | 48463 | break; |
48390 | 48464 | } |
48391 | - case 4079LLU: // copy-back deleter (switch) | |
48465 | + case 4088LLU: // copy-back deleter (switch) | |
48392 | 48466 | { |
48393 | 48467 | ((uint64_t **)(stack[base + 37]))[1][3] = stack[base + 42]; |
48394 | 48468 | ((uint64_t **)(stack[base + 37]))[1][2] = stack[base + 41]; |
48395 | 48469 | ((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40]; |
48396 | 48470 | ((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39]; |
48397 | - label = 4076LLU; // continue to unroll stack | |
48471 | + label = 4085LLU; // continue to unroll stack | |
48398 | 48472 | break; |
48399 | 48473 | } |
48400 | - case 4078LLU: // try next case | |
48474 | + case 4087LLU: // try next case | |
48401 | 48475 | { |
48402 | 48476 | fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n"); |
48403 | 48477 | exit(-1); |
48404 | 48478 | } |
48405 | - case 4077LLU: // completed switch | |
48479 | + case 4086LLU: // completed switch | |
48406 | 48480 | { |
48407 | 48481 | ((struct listnode *)(stack[base + 38]/*previous*/))->data = stack[base + 37]; |
48408 | - label = 4074LLU; // repeat | |
48482 | + label = 4083LLU; // repeat | |
48409 | 48483 | break; |
48410 | 48484 | } |
48411 | - case 4076LLU: // copy-back deleter for while next | |
48485 | + case 4085LLU: // copy-back deleter for while next | |
48412 | 48486 | { |
48413 | 48487 | ((struct listnode *)(stack[base + 38]/*previous*/))->data = stack[base + 37]; |
48414 | - label = 3990LLU; // continue to unroll stack | |
48488 | + label = 3999LLU; // continue to unroll stack | |
48415 | 48489 | break; |
48416 | 48490 | } |
48417 | - case 4075LLU: // loop finished | |
48491 | + case 4084LLU: // loop finished | |
48418 | 48492 | { |
48419 | 48493 | flippedassign(stack[base + 32]/*states*/, &stack[base + 39]); |
48420 | - label = 4084LLU; // start to repeat | |
48494 | + label = 4093LLU; // start to repeat | |
48421 | 48495 | break; |
48422 | 48496 | } |
48423 | - case 4084LLU: // repeat from here | |
48497 | + case 4093LLU: // repeat from here | |
48424 | 48498 | { |
48425 | 48499 | if(!stack[base + 39]) |
48426 | 48500 | { |
48427 | - label = 4085LLU; // break loop | |
48501 | + label = 4094LLU; // break loop | |
48428 | 48502 | break; |
48429 | 48503 | } |
48430 | 48504 |
@@ -48434,7 +48508,7 @@ | ||
48434 | 48508 | stack[base + 39] = (uint64_t)(((const struct listnode *)(stack[base + 39]))->next); |
48435 | 48509 | if(/*listtoelem*/0 != ((uint64_t *)(stack[base + 40]/*state*/))[0]) |
48436 | 48510 | { |
48437 | - label = 4088LLU; // jump to alternative | |
48511 | + label = 4097LLU; // jump to alternative | |
48438 | 48512 | break; |
48439 | 48513 | } |
48440 | 48514 |
@@ -48446,7 +48520,7 @@ | ||
48446 | 48520 | // case |
48447 | 48521 | if(/*pop*/0 != ((uint64_t *)(stack[base + 43]/*popnext*/))[0]) |
48448 | 48522 | { |
48449 | - label = 4091LLU; // jump to alternative | |
48523 | + label = 4100LLU; // jump to alternative | |
48450 | 48524 | break; |
48451 | 48525 | } |
48452 | 48526 |
@@ -48455,9 +48529,9 @@ | ||
48455 | 48529 | printf("%s", "\n {"); |
48456 | 48530 | printf("%s", "\n struct listnode *list = (struct listnode *)("); |
48457 | 48531 | // call emitvaridx from procblock |
48458 | - stack[base + 46LLU] = 4093LLU/*throw to this address*/; | |
48532 | + stack[base + 46LLU] = 4102LLU/*throw to this address*/; | |
48459 | 48533 | stack[base + 47LLU] = base; |
48460 | - stack[base + 48LLU] = 4094LLU; | |
48534 | + stack[base + 48LLU] = 4103LLU; | |
48461 | 48535 | // arguments for call to emitvaridx |
48462 | 48536 | stack[base + 49LLU] = stack[base + 42]/*listindex*/; |
48463 | 48537 | // set stack-base & callee-address |
@@ -48465,21 +48539,21 @@ | ||
48465 | 48539 | label = 745LLU; // emitvaridx |
48466 | 48540 | break; |
48467 | 48541 | } |
48468 | - case 4093LLU: // copy-back deleter (emitvaridx to procblock) | |
48542 | + case 4102LLU: / |
Part of diff was cut off due to size limit. Use your local client to view the full diff.