1// ------------------------------------------------------------- 2// DO NOT EDIT! this file was generated automatically by gomacro 3// Any change will be lost when the file is re-generated 4// ------------------------------------------------------------- 5 6/* 7 * gomacro - A Go interpreter with Lisp-like macros 8 * 9 * Copyright (C) 2017-2019 Massimiliano Ghilardi 10 * 11 * This Source Code Form is subject to the terms of the Mozilla Public 12 * License, v. 2.0. If a copy of the MPL was not distributed with this 13 * file, You can obtain one at http://mozilla.org/MPL/2.0/. 14 * 15 * 16 * func2ret0.go 17 * 18 * Created on Apr 16, 2017 19 * Author Massimiliano Ghilardi 20 */ 21 22package fast 23 24import ( 25 r "reflect" 26 "unsafe" 27 28 . "github.com/cosmos72/gomacro/base" 29 "github.com/cosmos72/gomacro/base/reflect" 30 xr "github.com/cosmos72/gomacro/xreflect" 31) 32 33func (c *Comp) func2ret0(t xr.Type, m *funcMaker) func(*Env) r.Value { 34 karg0 := t.In(0).Kind() 35 karg1 := t.In(1).Kind() 36 37 if !reflect.IsOptimizedKind(karg0) || !reflect.IsOptimizedKind(karg1) { 38 return nil 39 } 40 41 indexes := &[2]int{ 42 m.Param[0].Desc.Index(), 43 m.Param[1].Desc.Index(), 44 } 45 var debugC *Comp 46 if c.Globals.Options&OptDebugger != 0 { 47 debugC = c 48 } 49 50 var ret func(*Env) r.Value 51 switch karg0 { 52 case r.Bool: 53 ret = func2ret0Bool(m, indexes, karg1, debugC) 54 55 case r.Int: 56 ret = func2ret0Int(m, indexes, karg1, debugC) 57 58 case r.Int8: 59 ret = func2ret0Int8(m, indexes, karg1, debugC) 60 61 case r.Int16: 62 ret = func2ret0Int16(m, indexes, karg1, debugC) 63 64 case r.Int32: 65 ret = func2ret0Int32(m, indexes, karg1, debugC) 66 67 case r.Int64: 68 ret = func2ret0Int64(m, indexes, karg1, debugC) 69 70 case r.Uint: 71 ret = func2ret0Uint(m, indexes, karg1, debugC) 72 73 case r.Uint8: 74 ret = func2ret0Uint8(m, indexes, karg1, debugC) 75 76 case r.Uint16: 77 ret = func2ret0Uint16(m, indexes, karg1, debugC) 78 79 case r.Uint32: 80 ret = func2ret0Uint32(m, indexes, karg1, debugC) 81 82 case r.Uint64: 83 ret = func2ret0Uint64(m, indexes, karg1, debugC) 84 85 case r.Uintptr: 86 ret = func2ret0Uintptr(m, indexes, karg1, debugC) 87 88 case r.Float32: 89 ret = func2ret0Float32(m, indexes, karg1, debugC) 90 91 case r.Float64: 92 ret = func2ret0Float64(m, indexes, karg1, debugC) 93 94 case r.Complex64: 95 ret = func2ret0Complex64(m, indexes, karg1, debugC) 96 97 case r.Complex128: 98 ret = func2ret0Complex128(m, indexes, karg1, debugC) 99 100 case r.String: 101 ret = func2ret0String(m, indexes, karg1, debugC) 102 103 } 104 return ret 105} 106func func2ret0Bool(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value { 107 108 nbind := m.nbind 109 nintbind := m.nintbind 110 funcbody := m.funcbody 111 var ret func(*Env) r.Value 112 switch karg1 { 113 case r.Bool: 114 115 { 116 if funcbody == nil { 117 funv := r.ValueOf(func(bool, 118 119 bool, 120 121 ) {}) 122 ret = func(env *Env) r.Value { return funv } 123 124 break 125 } 126 ret = func(env *Env) r.Value { 127 128 env.MarkUsedByClosure() 129 return r.ValueOf(func(arg0 bool, 130 131 arg1 bool, 132 133 ) { 134 env := newEnv4Func(env, nbind, nintbind, debugC) 135 136 *(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 137 138 *(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 139 140 funcbody(env) 141 142 env.freeEnv4Func() 143 }) 144 } 145 } 146 case r.Int: 147 148 { 149 if funcbody == nil { 150 funv := r.ValueOf(func(bool, 151 152 int, 153 154 ) {}) 155 ret = func(env *Env) r.Value { return funv } 156 157 break 158 } 159 ret = func(env *Env) r.Value { 160 161 env.MarkUsedByClosure() 162 return r.ValueOf(func(arg0 bool, 163 164 arg1 int, 165 166 ) { 167 env := newEnv4Func(env, nbind, nintbind, debugC) 168 169 *(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 170 171 *(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 172 173 funcbody(env) 174 175 env.freeEnv4Func() 176 }) 177 } 178 } 179 case r.Int8: 180 181 { 182 if funcbody == nil { 183 funv := r.ValueOf(func(bool, 184 185 int8, 186 187 ) {}) 188 ret = func(env *Env) r.Value { return funv } 189 190 break 191 } 192 ret = func(env *Env) r.Value { 193 194 env.MarkUsedByClosure() 195 return r.ValueOf(func(arg0 bool, 196 197 arg1 int8, 198 199 ) { 200 env := newEnv4Func(env, nbind, nintbind, debugC) 201 202 *(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 203 204 *(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 205 206 funcbody(env) 207 208 env.freeEnv4Func() 209 }) 210 } 211 } 212 case r.Int16: 213 { 214 if funcbody == nil { 215 funv := r.ValueOf(func(bool, 216 217 int16, 218 219 ) {}) 220 ret = func(env *Env) r.Value { return funv } 221 222 break 223 } 224 ret = func(env *Env) r.Value { 225 226 env.MarkUsedByClosure() 227 return r.ValueOf(func(arg0 bool, 228 229 arg1 int16, 230 231 ) { 232 env := newEnv4Func(env, nbind, nintbind, debugC) 233 234 *(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 235 236 *(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 237 238 funcbody(env) 239 240 env.freeEnv4Func() 241 }) 242 } 243 } 244 case r.Int32: 245 { 246 if funcbody == nil { 247 funv := r.ValueOf(func(bool, 248 249 int32, 250 251 ) {}) 252 ret = func(env *Env) r.Value { return funv } 253 254 break 255 } 256 ret = func(env *Env) r.Value { 257 258 env.MarkUsedByClosure() 259 return r.ValueOf(func(arg0 bool, 260 261 arg1 int32, 262 263 ) { 264 env := newEnv4Func(env, nbind, nintbind, debugC) 265 266 *(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 267 268 *(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 269 270 funcbody(env) 271 272 env.freeEnv4Func() 273 }) 274 } 275 } 276 case r.Int64: 277 { 278 if funcbody == nil { 279 funv := r.ValueOf(func(bool, 280 281 int64, 282 ) {}) 283 ret = func(env *Env) r.Value { return funv } 284 285 break 286 } 287 ret = func(env *Env) r.Value { 288 289 env.MarkUsedByClosure() 290 return r.ValueOf(func(arg0 bool, 291 292 arg1 int64, 293 294 ) { 295 env := newEnv4Func(env, nbind, nintbind, debugC) 296 297 *(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 298 299 *(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 300 301 funcbody(env) 302 303 env.freeEnv4Func() 304 }) 305 } 306 } 307 case r.Uint: 308 { 309 if funcbody == nil { 310 funv := r.ValueOf(func(bool, 311 312 uint) {}) 313 ret = func(env *Env) r.Value { return funv } 314 315 break 316 } 317 ret = func(env *Env) r.Value { 318 319 env.MarkUsedByClosure() 320 return r.ValueOf(func(arg0 bool, 321 322 arg1 uint, 323 324 ) { 325 env := newEnv4Func(env, nbind, nintbind, debugC) 326 327 *(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 328 329 *(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 330 331 funcbody(env) 332 333 env.freeEnv4Func() 334 }) 335 } 336 } 337 case r.Uint8: 338 { 339 if funcbody == nil { 340 funv := r.ValueOf(func(bool, 341 342 uint8) {}) 343 ret = func(env *Env) r.Value { return funv } 344 345 break 346 } 347 ret = func(env *Env) r.Value { 348 349 env.MarkUsedByClosure() 350 return r.ValueOf(func(arg0 bool, 351 352 arg1 uint8, 353 354 ) { 355 env := newEnv4Func(env, nbind, nintbind, debugC) 356 357 *(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 358 359 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 360 361 funcbody(env) 362 363 env.freeEnv4Func() 364 }) 365 } 366 } 367 case r.Uint16: 368 { 369 if funcbody == nil { 370 funv := r.ValueOf(func(bool, 371 372 uint16) {}) 373 ret = func(env *Env) r.Value { return funv } 374 375 break 376 } 377 ret = func(env *Env) r.Value { 378 379 env.MarkUsedByClosure() 380 return r.ValueOf(func(arg0 bool, 381 382 arg1 uint16, 383 384 ) { 385 env := newEnv4Func(env, nbind, nintbind, debugC) 386 387 *(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 388 389 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 390 391 funcbody(env) 392 393 env.freeEnv4Func() 394 }) 395 } 396 } 397 case r.Uint32: 398 { 399 if funcbody == nil { 400 funv := r.ValueOf(func(bool, 401 402 uint32) {}) 403 ret = func(env *Env) r.Value { return funv } 404 405 break 406 } 407 ret = func(env *Env) r.Value { 408 409 env.MarkUsedByClosure() 410 return r.ValueOf(func(arg0 bool, 411 412 arg1 uint32, 413 414 ) { 415 env := newEnv4Func(env, nbind, nintbind, debugC) 416 417 *(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 418 419 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 420 421 funcbody(env) 422 423 env.freeEnv4Func() 424 }) 425 } 426 } 427 case r.Uint64: 428 { 429 if funcbody == nil { 430 funv := r.ValueOf(func(bool, 431 432 uint64) {}) 433 ret = func(env *Env) r.Value { return funv } 434 435 break 436 } 437 ret = func(env *Env) r.Value { 438 439 env.MarkUsedByClosure() 440 return r.ValueOf(func(arg0 bool, 441 442 arg1 uint64, 443 444 ) { 445 env := newEnv4Func(env, nbind, nintbind, debugC) 446 447 *(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 448 449 env.Ints[indexes[1]] = arg1 450 451 funcbody(env) 452 453 env.freeEnv4Func() 454 }) 455 } 456 } 457 case r.Uintptr: 458 { 459 if funcbody == nil { 460 funv := r.ValueOf(func(bool, 461 462 uintptr) {}) 463 ret = func(env *Env) r.Value { return funv } 464 465 break 466 } 467 ret = func(env *Env) r.Value { 468 469 env.MarkUsedByClosure() 470 return r.ValueOf(func(arg0 bool, 471 472 arg1 uintptr, 473 474 ) { 475 env := newEnv4Func(env, nbind, nintbind, debugC) 476 477 *(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 478 479 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 480 481 funcbody(env) 482 483 env.freeEnv4Func() 484 }) 485 } 486 } 487 case r.Float32: 488 { 489 if funcbody == nil { 490 funv := r.ValueOf(func(bool, 491 492 float32) {}) 493 ret = func(env *Env) r.Value { return funv } 494 495 break 496 } 497 ret = func(env *Env) r.Value { 498 499 env.MarkUsedByClosure() 500 return r.ValueOf(func(arg0 bool, 501 502 arg1 float32, 503 504 ) { 505 env := newEnv4Func(env, nbind, nintbind, debugC) 506 507 *(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 508 509 *(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 510 511 funcbody(env) 512 513 env.freeEnv4Func() 514 }) 515 } 516 } 517 case r.Float64: 518 { 519 if funcbody == nil { 520 funv := r.ValueOf(func(bool, 521 522 float64) {}) 523 ret = func(env *Env) r.Value { return funv } 524 525 break 526 } 527 ret = func(env *Env) r.Value { 528 529 env.MarkUsedByClosure() 530 return r.ValueOf(func(arg0 bool, 531 532 arg1 float64, 533 534 ) { 535 env := newEnv4Func(env, nbind, nintbind, debugC) 536 537 *(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 538 539 *(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 540 541 funcbody(env) 542 543 env.freeEnv4Func() 544 }) 545 } 546 } 547 case r.Complex64: 548 { 549 if funcbody == nil { 550 funv := r.ValueOf(func(bool, 551 552 complex64) {}) 553 ret = func(env *Env) r.Value { return funv } 554 555 break 556 } 557 ret = func(env *Env) r.Value { 558 559 env.MarkUsedByClosure() 560 return r.ValueOf(func(arg0 bool, 561 562 arg1 complex64, 563 ) { 564 env := newEnv4Func(env, nbind, nintbind, debugC) 565 566 *(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 567 568 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 569 570 funcbody(env) 571 572 env.freeEnv4Func() 573 }) 574 } 575 } 576 case r.Complex128: 577 { 578 if funcbody == nil { 579 funv := r.ValueOf(func(bool, 580 581 complex128) {}) 582 ret = func(env *Env) r.Value { return funv } 583 584 break 585 } 586 ret = func(env *Env) r.Value { 587 588 env.MarkUsedByClosure() 589 return r.ValueOf(func(arg0 bool, 590 591 arg1 complex128) { 592 env := newEnv4Func(env, nbind, nintbind, debugC) 593 594 *(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 595 596 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 597 598 funcbody(env) 599 600 env.freeEnv4Func() 601 }) 602 } 603 } 604 case r.String: 605 { 606 if funcbody == nil { 607 funv := r.ValueOf(func(bool, 608 609 string) {}) 610 ret = func(env *Env) r.Value { return funv } 611 612 break 613 } 614 ret = func(env *Env) r.Value { 615 616 env.MarkUsedByClosure() 617 return r.ValueOf(func(arg0 bool, 618 619 arg1 string) { 620 env := newEnv4Func(env, nbind, nintbind, debugC) 621 622 *(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 623 624 { 625 place := r.New(TypeOfString).Elem() 626 place.SetString(arg1, 627 ) 628 env.Vals[indexes[1]] = place 629 } 630 631 funcbody(env) 632 633 env.freeEnv4Func() 634 }) 635 } 636 } 637 } 638 return ret 639} 640func func2ret0Int(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value { 641 642 nbind := m.nbind 643 nintbind := m.nintbind 644 funcbody := m.funcbody 645 var ret func(*Env) r.Value 646 switch karg1 { 647 case r.Bool: 648 649 { 650 if funcbody == nil { 651 funv := r.ValueOf(func(int, 652 653 bool, 654 655 ) {}) 656 ret = func(env *Env) r.Value { return funv } 657 658 break 659 } 660 ret = func(env *Env) r.Value { 661 662 env.MarkUsedByClosure() 663 return r.ValueOf(func(arg0 int, 664 665 arg1 bool, 666 667 ) { 668 env := newEnv4Func(env, nbind, nintbind, debugC) 669 670 *(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 671 672 *(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 673 674 funcbody(env) 675 676 env.freeEnv4Func() 677 }) 678 } 679 } 680 case r.Int: 681 682 { 683 if funcbody == nil { 684 funv := r.ValueOf(func(int, 685 686 int, 687 688 ) {}) 689 ret = func(env *Env) r.Value { return funv } 690 691 break 692 } 693 ret = func(env *Env) r.Value { 694 695 env.MarkUsedByClosure() 696 return r.ValueOf(func(arg0 int, 697 698 arg1 int, 699 700 ) { 701 env := newEnv4Func(env, nbind, nintbind, debugC) 702 703 *(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 704 705 *(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 706 707 funcbody(env) 708 709 env.freeEnv4Func() 710 }) 711 } 712 } 713 case r.Int8: 714 715 { 716 if funcbody == nil { 717 funv := r.ValueOf(func(int, 718 719 int8, 720 721 ) {}) 722 ret = func(env *Env) r.Value { return funv } 723 724 break 725 } 726 ret = func(env *Env) r.Value { 727 728 env.MarkUsedByClosure() 729 return r.ValueOf(func(arg0 int, 730 731 arg1 int8, 732 733 ) { 734 env := newEnv4Func(env, nbind, nintbind, debugC) 735 736 *(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 737 738 *(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 739 740 funcbody(env) 741 742 env.freeEnv4Func() 743 }) 744 } 745 } 746 case r.Int16: 747 { 748 if funcbody == nil { 749 funv := r.ValueOf(func(int, 750 751 int16, 752 753 ) {}) 754 ret = func(env *Env) r.Value { return funv } 755 756 break 757 } 758 ret = func(env *Env) r.Value { 759 760 env.MarkUsedByClosure() 761 return r.ValueOf(func(arg0 int, 762 763 arg1 int16, 764 765 ) { 766 env := newEnv4Func(env, nbind, nintbind, debugC) 767 768 *(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 769 770 *(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 771 772 funcbody(env) 773 774 env.freeEnv4Func() 775 }) 776 } 777 } 778 case r.Int32: 779 { 780 if funcbody == nil { 781 funv := r.ValueOf(func(int, 782 783 int32, 784 785 ) {}) 786 ret = func(env *Env) r.Value { return funv } 787 788 break 789 } 790 ret = func(env *Env) r.Value { 791 792 env.MarkUsedByClosure() 793 return r.ValueOf(func(arg0 int, 794 795 arg1 int32, 796 797 ) { 798 env := newEnv4Func(env, nbind, nintbind, debugC) 799 800 *(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 801 802 *(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 803 804 funcbody(env) 805 806 env.freeEnv4Func() 807 }) 808 } 809 } 810 case r.Int64: 811 { 812 if funcbody == nil { 813 funv := r.ValueOf(func(int, 814 815 int64, 816 ) {}) 817 ret = func(env *Env) r.Value { return funv } 818 819 break 820 } 821 ret = func(env *Env) r.Value { 822 823 env.MarkUsedByClosure() 824 return r.ValueOf(func(arg0 int, 825 826 arg1 int64, 827 828 ) { 829 env := newEnv4Func(env, nbind, nintbind, debugC) 830 831 *(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 832 833 *(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 834 835 funcbody(env) 836 837 env.freeEnv4Func() 838 }) 839 } 840 } 841 case r.Uint: 842 { 843 if funcbody == nil { 844 funv := r.ValueOf(func(int, 845 846 uint) {}) 847 ret = func(env *Env) r.Value { return funv } 848 849 break 850 } 851 ret = func(env *Env) r.Value { 852 853 env.MarkUsedByClosure() 854 return r.ValueOf(func(arg0 int, 855 856 arg1 uint, 857 858 ) { 859 env := newEnv4Func(env, nbind, nintbind, debugC) 860 861 *(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 862 863 *(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 864 865 funcbody(env) 866 867 env.freeEnv4Func() 868 }) 869 } 870 } 871 case r.Uint8: 872 { 873 if funcbody == nil { 874 funv := r.ValueOf(func(int, 875 876 uint8) {}) 877 ret = func(env *Env) r.Value { return funv } 878 879 break 880 } 881 ret = func(env *Env) r.Value { 882 883 env.MarkUsedByClosure() 884 return r.ValueOf(func(arg0 int, 885 886 arg1 uint8, 887 888 ) { 889 env := newEnv4Func(env, nbind, nintbind, debugC) 890 891 *(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 892 893 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 894 895 funcbody(env) 896 897 env.freeEnv4Func() 898 }) 899 } 900 } 901 case r.Uint16: 902 { 903 if funcbody == nil { 904 funv := r.ValueOf(func(int, 905 906 uint16) {}) 907 ret = func(env *Env) r.Value { return funv } 908 909 break 910 } 911 ret = func(env *Env) r.Value { 912 913 env.MarkUsedByClosure() 914 return r.ValueOf(func(arg0 int, 915 916 arg1 uint16, 917 918 ) { 919 env := newEnv4Func(env, nbind, nintbind, debugC) 920 921 *(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 922 923 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 924 925 funcbody(env) 926 927 env.freeEnv4Func() 928 }) 929 } 930 } 931 case r.Uint32: 932 { 933 if funcbody == nil { 934 funv := r.ValueOf(func(int, 935 936 uint32) {}) 937 ret = func(env *Env) r.Value { return funv } 938 939 break 940 } 941 ret = func(env *Env) r.Value { 942 943 env.MarkUsedByClosure() 944 return r.ValueOf(func(arg0 int, 945 946 arg1 uint32, 947 948 ) { 949 env := newEnv4Func(env, nbind, nintbind, debugC) 950 951 *(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 952 953 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 954 955 funcbody(env) 956 957 env.freeEnv4Func() 958 }) 959 } 960 } 961 case r.Uint64: 962 { 963 if funcbody == nil { 964 funv := r.ValueOf(func(int, 965 966 uint64) {}) 967 ret = func(env *Env) r.Value { return funv } 968 969 break 970 } 971 ret = func(env *Env) r.Value { 972 973 env.MarkUsedByClosure() 974 return r.ValueOf(func(arg0 int, 975 976 arg1 uint64, 977 978 ) { 979 env := newEnv4Func(env, nbind, nintbind, debugC) 980 981 *(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 982 983 env.Ints[indexes[1]] = arg1 984 985 funcbody(env) 986 987 env.freeEnv4Func() 988 }) 989 } 990 } 991 case r.Uintptr: 992 { 993 if funcbody == nil { 994 funv := r.ValueOf(func(int, 995 996 uintptr) {}) 997 ret = func(env *Env) r.Value { return funv } 998 999 break 1000 } 1001 ret = func(env *Env) r.Value { 1002 1003 env.MarkUsedByClosure() 1004 return r.ValueOf(func(arg0 int, 1005 1006 arg1 uintptr, 1007 1008 ) { 1009 env := newEnv4Func(env, nbind, nintbind, debugC) 1010 1011 *(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 1012 1013 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 1014 1015 funcbody(env) 1016 1017 env.freeEnv4Func() 1018 }) 1019 } 1020 } 1021 case r.Float32: 1022 { 1023 if funcbody == nil { 1024 funv := r.ValueOf(func(int, 1025 1026 float32) {}) 1027 ret = func(env *Env) r.Value { return funv } 1028 1029 break 1030 } 1031 ret = func(env *Env) r.Value { 1032 1033 env.MarkUsedByClosure() 1034 return r.ValueOf(func(arg0 int, 1035 1036 arg1 float32, 1037 1038 ) { 1039 env := newEnv4Func(env, nbind, nintbind, debugC) 1040 1041 *(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 1042 1043 *(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 1044 1045 funcbody(env) 1046 1047 env.freeEnv4Func() 1048 }) 1049 } 1050 } 1051 case r.Float64: 1052 { 1053 if funcbody == nil { 1054 funv := r.ValueOf(func(int, 1055 1056 float64) {}) 1057 ret = func(env *Env) r.Value { return funv } 1058 1059 break 1060 } 1061 ret = func(env *Env) r.Value { 1062 1063 env.MarkUsedByClosure() 1064 return r.ValueOf(func(arg0 int, 1065 1066 arg1 float64, 1067 1068 ) { 1069 env := newEnv4Func(env, nbind, nintbind, debugC) 1070 1071 *(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 1072 1073 *(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 1074 1075 funcbody(env) 1076 1077 env.freeEnv4Func() 1078 }) 1079 } 1080 } 1081 case r.Complex64: 1082 { 1083 if funcbody == nil { 1084 funv := r.ValueOf(func(int, 1085 1086 complex64) {}) 1087 ret = func(env *Env) r.Value { return funv } 1088 1089 break 1090 } 1091 ret = func(env *Env) r.Value { 1092 1093 env.MarkUsedByClosure() 1094 return r.ValueOf(func(arg0 int, 1095 1096 arg1 complex64, 1097 ) { 1098 env := newEnv4Func(env, nbind, nintbind, debugC) 1099 1100 *(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 1101 1102 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 1103 1104 funcbody(env) 1105 1106 env.freeEnv4Func() 1107 }) 1108 } 1109 } 1110 case r.Complex128: 1111 { 1112 if funcbody == nil { 1113 funv := r.ValueOf(func(int, 1114 1115 complex128) {}) 1116 ret = func(env *Env) r.Value { return funv } 1117 1118 break 1119 } 1120 ret = func(env *Env) r.Value { 1121 1122 env.MarkUsedByClosure() 1123 return r.ValueOf(func(arg0 int, 1124 1125 arg1 complex128) { 1126 env := newEnv4Func(env, nbind, nintbind, debugC) 1127 1128 *(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 1129 1130 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 1131 1132 funcbody(env) 1133 1134 env.freeEnv4Func() 1135 }) 1136 } 1137 } 1138 case r.String: 1139 { 1140 if funcbody == nil { 1141 funv := r.ValueOf(func(int, 1142 1143 string) {}) 1144 ret = func(env *Env) r.Value { return funv } 1145 1146 break 1147 } 1148 ret = func(env *Env) r.Value { 1149 1150 env.MarkUsedByClosure() 1151 return r.ValueOf(func(arg0 int, 1152 1153 arg1 string) { 1154 env := newEnv4Func(env, nbind, nintbind, debugC) 1155 1156 *(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 1157 1158 { 1159 place := r.New(TypeOfString).Elem() 1160 place.SetString(arg1, 1161 ) 1162 env.Vals[indexes[1]] = place 1163 } 1164 1165 funcbody(env) 1166 1167 env.freeEnv4Func() 1168 }) 1169 } 1170 } 1171 } 1172 return ret 1173} 1174func func2ret0Int8(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value { 1175 1176 nbind := m.nbind 1177 nintbind := m.nintbind 1178 funcbody := m.funcbody 1179 var ret func(*Env) r.Value 1180 switch karg1 { 1181 case r.Bool: 1182 1183 { 1184 if funcbody == nil { 1185 funv := r.ValueOf(func(int8, 1186 1187 bool, 1188 1189 ) {}) 1190 ret = func(env *Env) r.Value { return funv } 1191 1192 break 1193 } 1194 ret = func(env *Env) r.Value { 1195 1196 env.MarkUsedByClosure() 1197 return r.ValueOf(func(arg0 int8, 1198 1199 arg1 bool, 1200 1201 ) { 1202 env := newEnv4Func(env, nbind, nintbind, debugC) 1203 1204 *(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 1205 1206 *(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 1207 1208 funcbody(env) 1209 1210 env.freeEnv4Func() 1211 }) 1212 } 1213 } 1214 case r.Int: 1215 1216 { 1217 if funcbody == nil { 1218 funv := r.ValueOf(func(int8, 1219 1220 int, 1221 1222 ) {}) 1223 ret = func(env *Env) r.Value { return funv } 1224 1225 break 1226 } 1227 ret = func(env *Env) r.Value { 1228 1229 env.MarkUsedByClosure() 1230 return r.ValueOf(func(arg0 int8, 1231 1232 arg1 int, 1233 1234 ) { 1235 env := newEnv4Func(env, nbind, nintbind, debugC) 1236 1237 *(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 1238 1239 *(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 1240 1241 funcbody(env) 1242 1243 env.freeEnv4Func() 1244 }) 1245 } 1246 } 1247 case r.Int8: 1248 1249 { 1250 if funcbody == nil { 1251 funv := r.ValueOf(func(int8, 1252 1253 int8, 1254 1255 ) {}) 1256 ret = func(env *Env) r.Value { return funv } 1257 1258 break 1259 } 1260 ret = func(env *Env) r.Value { 1261 1262 env.MarkUsedByClosure() 1263 return r.ValueOf(func(arg0 int8, 1264 1265 arg1 int8, 1266 1267 ) { 1268 env := newEnv4Func(env, nbind, nintbind, debugC) 1269 1270 *(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 1271 1272 *(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 1273 1274 funcbody(env) 1275 1276 env.freeEnv4Func() 1277 }) 1278 } 1279 } 1280 case r.Int16: 1281 { 1282 if funcbody == nil { 1283 funv := r.ValueOf(func(int8, 1284 1285 int16, 1286 1287 ) {}) 1288 ret = func(env *Env) r.Value { return funv } 1289 1290 break 1291 } 1292 ret = func(env *Env) r.Value { 1293 1294 env.MarkUsedByClosure() 1295 return r.ValueOf(func(arg0 int8, 1296 1297 arg1 int16, 1298 1299 ) { 1300 env := newEnv4Func(env, nbind, nintbind, debugC) 1301 1302 *(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 1303 1304 *(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 1305 1306 funcbody(env) 1307 1308 env.freeEnv4Func() 1309 }) 1310 } 1311 } 1312 case r.Int32: 1313 { 1314 if funcbody == nil { 1315 funv := r.ValueOf(func(int8, 1316 1317 int32, 1318 1319 ) {}) 1320 ret = func(env *Env) r.Value { return funv } 1321 1322 break 1323 } 1324 ret = func(env *Env) r.Value { 1325 1326 env.MarkUsedByClosure() 1327 return r.ValueOf(func(arg0 int8, 1328 1329 arg1 int32, 1330 1331 ) { 1332 env := newEnv4Func(env, nbind, nintbind, debugC) 1333 1334 *(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 1335 1336 *(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 1337 1338 funcbody(env) 1339 1340 env.freeEnv4Func() 1341 }) 1342 } 1343 } 1344 case r.Int64: 1345 { 1346 if funcbody == nil { 1347 funv := r.ValueOf(func(int8, 1348 1349 int64, 1350 ) {}) 1351 ret = func(env *Env) r.Value { return funv } 1352 1353 break 1354 } 1355 ret = func(env *Env) r.Value { 1356 1357 env.MarkUsedByClosure() 1358 return r.ValueOf(func(arg0 int8, 1359 1360 arg1 int64, 1361 1362 ) { 1363 env := newEnv4Func(env, nbind, nintbind, debugC) 1364 1365 *(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 1366 1367 *(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 1368 1369 funcbody(env) 1370 1371 env.freeEnv4Func() 1372 }) 1373 } 1374 } 1375 case r.Uint: 1376 { 1377 if funcbody == nil { 1378 funv := r.ValueOf(func(int8, 1379 1380 uint) {}) 1381 ret = func(env *Env) r.Value { return funv } 1382 1383 break 1384 } 1385 ret = func(env *Env) r.Value { 1386 1387 env.MarkUsedByClosure() 1388 return r.ValueOf(func(arg0 int8, 1389 1390 arg1 uint, 1391 1392 ) { 1393 env := newEnv4Func(env, nbind, nintbind, debugC) 1394 1395 *(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 1396 1397 *(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 1398 1399 funcbody(env) 1400 1401 env.freeEnv4Func() 1402 }) 1403 } 1404 } 1405 case r.Uint8: 1406 { 1407 if funcbody == nil { 1408 funv := r.ValueOf(func(int8, 1409 1410 uint8) {}) 1411 ret = func(env *Env) r.Value { return funv } 1412 1413 break 1414 } 1415 ret = func(env *Env) r.Value { 1416 1417 env.MarkUsedByClosure() 1418 return r.ValueOf(func(arg0 int8, 1419 1420 arg1 uint8, 1421 1422 ) { 1423 env := newEnv4Func(env, nbind, nintbind, debugC) 1424 1425 *(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 1426 1427 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 1428 1429 funcbody(env) 1430 1431 env.freeEnv4Func() 1432 }) 1433 } 1434 } 1435 case r.Uint16: 1436 { 1437 if funcbody == nil { 1438 funv := r.ValueOf(func(int8, 1439 1440 uint16) {}) 1441 ret = func(env *Env) r.Value { return funv } 1442 1443 break 1444 } 1445 ret = func(env *Env) r.Value { 1446 1447 env.MarkUsedByClosure() 1448 return r.ValueOf(func(arg0 int8, 1449 1450 arg1 uint16, 1451 1452 ) { 1453 env := newEnv4Func(env, nbind, nintbind, debugC) 1454 1455 *(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 1456 1457 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 1458 1459 funcbody(env) 1460 1461 env.freeEnv4Func() 1462 }) 1463 } 1464 } 1465 case r.Uint32: 1466 { 1467 if funcbody == nil { 1468 funv := r.ValueOf(func(int8, 1469 1470 uint32) {}) 1471 ret = func(env *Env) r.Value { return funv } 1472 1473 break 1474 } 1475 ret = func(env *Env) r.Value { 1476 1477 env.MarkUsedByClosure() 1478 return r.ValueOf(func(arg0 int8, 1479 1480 arg1 uint32, 1481 1482 ) { 1483 env := newEnv4Func(env, nbind, nintbind, debugC) 1484 1485 *(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 1486 1487 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 1488 1489 funcbody(env) 1490 1491 env.freeEnv4Func() 1492 }) 1493 } 1494 } 1495 case r.Uint64: 1496 { 1497 if funcbody == nil { 1498 funv := r.ValueOf(func(int8, 1499 1500 uint64) {}) 1501 ret = func(env *Env) r.Value { return funv } 1502 1503 break 1504 } 1505 ret = func(env *Env) r.Value { 1506 1507 env.MarkUsedByClosure() 1508 return r.ValueOf(func(arg0 int8, 1509 1510 arg1 uint64, 1511 1512 ) { 1513 env := newEnv4Func(env, nbind, nintbind, debugC) 1514 1515 *(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 1516 1517 env.Ints[indexes[1]] = arg1 1518 1519 funcbody(env) 1520 1521 env.freeEnv4Func() 1522 }) 1523 } 1524 } 1525 case r.Uintptr: 1526 { 1527 if funcbody == nil { 1528 funv := r.ValueOf(func(int8, 1529 1530 uintptr) {}) 1531 ret = func(env *Env) r.Value { return funv } 1532 1533 break 1534 } 1535 ret = func(env *Env) r.Value { 1536 1537 env.MarkUsedByClosure() 1538 return r.ValueOf(func(arg0 int8, 1539 1540 arg1 uintptr, 1541 1542 ) { 1543 env := newEnv4Func(env, nbind, nintbind, debugC) 1544 1545 *(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 1546 1547 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 1548 1549 funcbody(env) 1550 1551 env.freeEnv4Func() 1552 }) 1553 } 1554 } 1555 case r.Float32: 1556 { 1557 if funcbody == nil { 1558 funv := r.ValueOf(func(int8, 1559 1560 float32) {}) 1561 ret = func(env *Env) r.Value { return funv } 1562 1563 break 1564 } 1565 ret = func(env *Env) r.Value { 1566 1567 env.MarkUsedByClosure() 1568 return r.ValueOf(func(arg0 int8, 1569 1570 arg1 float32, 1571 1572 ) { 1573 env := newEnv4Func(env, nbind, nintbind, debugC) 1574 1575 *(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 1576 1577 *(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 1578 1579 funcbody(env) 1580 1581 env.freeEnv4Func() 1582 }) 1583 } 1584 } 1585 case r.Float64: 1586 { 1587 if funcbody == nil { 1588 funv := r.ValueOf(func(int8, 1589 1590 float64) {}) 1591 ret = func(env *Env) r.Value { return funv } 1592 1593 break 1594 } 1595 ret = func(env *Env) r.Value { 1596 1597 env.MarkUsedByClosure() 1598 return r.ValueOf(func(arg0 int8, 1599 1600 arg1 float64, 1601 1602 ) { 1603 env := newEnv4Func(env, nbind, nintbind, debugC) 1604 1605 *(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 1606 1607 *(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 1608 1609 funcbody(env) 1610 1611 env.freeEnv4Func() 1612 }) 1613 } 1614 } 1615 case r.Complex64: 1616 { 1617 if funcbody == nil { 1618 funv := r.ValueOf(func(int8, 1619 1620 complex64) {}) 1621 ret = func(env *Env) r.Value { return funv } 1622 1623 break 1624 } 1625 ret = func(env *Env) r.Value { 1626 1627 env.MarkUsedByClosure() 1628 return r.ValueOf(func(arg0 int8, 1629 1630 arg1 complex64, 1631 ) { 1632 env := newEnv4Func(env, nbind, nintbind, debugC) 1633 1634 *(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 1635 1636 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 1637 1638 funcbody(env) 1639 1640 env.freeEnv4Func() 1641 }) 1642 } 1643 } 1644 case r.Complex128: 1645 { 1646 if funcbody == nil { 1647 funv := r.ValueOf(func(int8, 1648 1649 complex128) {}) 1650 ret = func(env *Env) r.Value { return funv } 1651 1652 break 1653 } 1654 ret = func(env *Env) r.Value { 1655 1656 env.MarkUsedByClosure() 1657 return r.ValueOf(func(arg0 int8, 1658 1659 arg1 complex128) { 1660 env := newEnv4Func(env, nbind, nintbind, debugC) 1661 1662 *(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 1663 1664 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 1665 1666 funcbody(env) 1667 1668 env.freeEnv4Func() 1669 }) 1670 } 1671 } 1672 case r.String: 1673 { 1674 if funcbody == nil { 1675 funv := r.ValueOf(func(int8, 1676 1677 string) {}) 1678 ret = func(env *Env) r.Value { return funv } 1679 1680 break 1681 } 1682 ret = func(env *Env) r.Value { 1683 1684 env.MarkUsedByClosure() 1685 return r.ValueOf(func(arg0 int8, 1686 1687 arg1 string) { 1688 env := newEnv4Func(env, nbind, nintbind, debugC) 1689 1690 *(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 1691 1692 { 1693 place := r.New(TypeOfString).Elem() 1694 place.SetString(arg1, 1695 ) 1696 env.Vals[indexes[1]] = place 1697 } 1698 1699 funcbody(env) 1700 1701 env.freeEnv4Func() 1702 }) 1703 } 1704 } 1705 } 1706 return ret 1707} 1708func func2ret0Int16(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value { 1709 1710 nbind := m.nbind 1711 nintbind := m.nintbind 1712 funcbody := m.funcbody 1713 var ret func(*Env) r.Value 1714 switch karg1 { 1715 case r.Bool: 1716 1717 { 1718 if funcbody == nil { 1719 funv := r.ValueOf(func(int16, 1720 1721 bool, 1722 1723 ) {}) 1724 ret = func(env *Env) r.Value { return funv } 1725 1726 break 1727 } 1728 ret = func(env *Env) r.Value { 1729 1730 env.MarkUsedByClosure() 1731 return r.ValueOf(func(arg0 int16, 1732 1733 arg1 bool, 1734 1735 ) { 1736 env := newEnv4Func(env, nbind, nintbind, debugC) 1737 1738 *(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 1739 1740 *(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 1741 1742 funcbody(env) 1743 1744 env.freeEnv4Func() 1745 }) 1746 } 1747 } 1748 case r.Int: 1749 1750 { 1751 if funcbody == nil { 1752 funv := r.ValueOf(func(int16, 1753 1754 int, 1755 1756 ) {}) 1757 ret = func(env *Env) r.Value { return funv } 1758 1759 break 1760 } 1761 ret = func(env *Env) r.Value { 1762 1763 env.MarkUsedByClosure() 1764 return r.ValueOf(func(arg0 int16, 1765 1766 arg1 int, 1767 1768 ) { 1769 env := newEnv4Func(env, nbind, nintbind, debugC) 1770 1771 *(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 1772 1773 *(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 1774 1775 funcbody(env) 1776 1777 env.freeEnv4Func() 1778 }) 1779 } 1780 } 1781 case r.Int8: 1782 1783 { 1784 if funcbody == nil { 1785 funv := r.ValueOf(func(int16, 1786 1787 int8, 1788 1789 ) {}) 1790 ret = func(env *Env) r.Value { return funv } 1791 1792 break 1793 } 1794 ret = func(env *Env) r.Value { 1795 1796 env.MarkUsedByClosure() 1797 return r.ValueOf(func(arg0 int16, 1798 1799 arg1 int8, 1800 1801 ) { 1802 env := newEnv4Func(env, nbind, nintbind, debugC) 1803 1804 *(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 1805 1806 *(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 1807 1808 funcbody(env) 1809 1810 env.freeEnv4Func() 1811 }) 1812 } 1813 } 1814 case r.Int16: 1815 { 1816 if funcbody == nil { 1817 funv := r.ValueOf(func(int16, 1818 1819 int16, 1820 1821 ) {}) 1822 ret = func(env *Env) r.Value { return funv } 1823 1824 break 1825 } 1826 ret = func(env *Env) r.Value { 1827 1828 env.MarkUsedByClosure() 1829 return r.ValueOf(func(arg0 int16, 1830 1831 arg1 int16, 1832 1833 ) { 1834 env := newEnv4Func(env, nbind, nintbind, debugC) 1835 1836 *(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 1837 1838 *(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 1839 1840 funcbody(env) 1841 1842 env.freeEnv4Func() 1843 }) 1844 } 1845 } 1846 case r.Int32: 1847 { 1848 if funcbody == nil { 1849 funv := r.ValueOf(func(int16, 1850 1851 int32, 1852 1853 ) {}) 1854 ret = func(env *Env) r.Value { return funv } 1855 1856 break 1857 } 1858 ret = func(env *Env) r.Value { 1859 1860 env.MarkUsedByClosure() 1861 return r.ValueOf(func(arg0 int16, 1862 1863 arg1 int32, 1864 1865 ) { 1866 env := newEnv4Func(env, nbind, nintbind, debugC) 1867 1868 *(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 1869 1870 *(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 1871 1872 funcbody(env) 1873 1874 env.freeEnv4Func() 1875 }) 1876 } 1877 } 1878 case r.Int64: 1879 { 1880 if funcbody == nil { 1881 funv := r.ValueOf(func(int16, 1882 1883 int64, 1884 ) {}) 1885 ret = func(env *Env) r.Value { return funv } 1886 1887 break 1888 } 1889 ret = func(env *Env) r.Value { 1890 1891 env.MarkUsedByClosure() 1892 return r.ValueOf(func(arg0 int16, 1893 1894 arg1 int64, 1895 1896 ) { 1897 env := newEnv4Func(env, nbind, nintbind, debugC) 1898 1899 *(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 1900 1901 *(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 1902 1903 funcbody(env) 1904 1905 env.freeEnv4Func() 1906 }) 1907 } 1908 } 1909 case r.Uint: 1910 { 1911 if funcbody == nil { 1912 funv := r.ValueOf(func(int16, 1913 1914 uint) {}) 1915 ret = func(env *Env) r.Value { return funv } 1916 1917 break 1918 } 1919 ret = func(env *Env) r.Value { 1920 1921 env.MarkUsedByClosure() 1922 return r.ValueOf(func(arg0 int16, 1923 1924 arg1 uint, 1925 1926 ) { 1927 env := newEnv4Func(env, nbind, nintbind, debugC) 1928 1929 *(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 1930 1931 *(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 1932 1933 funcbody(env) 1934 1935 env.freeEnv4Func() 1936 }) 1937 } 1938 } 1939 case r.Uint8: 1940 { 1941 if funcbody == nil { 1942 funv := r.ValueOf(func(int16, 1943 1944 uint8) {}) 1945 ret = func(env *Env) r.Value { return funv } 1946 1947 break 1948 } 1949 ret = func(env *Env) r.Value { 1950 1951 env.MarkUsedByClosure() 1952 return r.ValueOf(func(arg0 int16, 1953 1954 arg1 uint8, 1955 1956 ) { 1957 env := newEnv4Func(env, nbind, nintbind, debugC) 1958 1959 *(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 1960 1961 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 1962 1963 funcbody(env) 1964 1965 env.freeEnv4Func() 1966 }) 1967 } 1968 } 1969 case r.Uint16: 1970 { 1971 if funcbody == nil { 1972 funv := r.ValueOf(func(int16, 1973 1974 uint16) {}) 1975 ret = func(env *Env) r.Value { return funv } 1976 1977 break 1978 } 1979 ret = func(env *Env) r.Value { 1980 1981 env.MarkUsedByClosure() 1982 return r.ValueOf(func(arg0 int16, 1983 1984 arg1 uint16, 1985 1986 ) { 1987 env := newEnv4Func(env, nbind, nintbind, debugC) 1988 1989 *(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 1990 1991 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 1992 1993 funcbody(env) 1994 1995 env.freeEnv4Func() 1996 }) 1997 } 1998 } 1999 case r.Uint32: 2000 { 2001 if funcbody == nil { 2002 funv := r.ValueOf(func(int16, 2003 2004 uint32) {}) 2005 ret = func(env *Env) r.Value { return funv } 2006 2007 break 2008 } 2009 ret = func(env *Env) r.Value { 2010 2011 env.MarkUsedByClosure() 2012 return r.ValueOf(func(arg0 int16, 2013 2014 arg1 uint32, 2015 2016 ) { 2017 env := newEnv4Func(env, nbind, nintbind, debugC) 2018 2019 *(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 2020 2021 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 2022 2023 funcbody(env) 2024 2025 env.freeEnv4Func() 2026 }) 2027 } 2028 } 2029 case r.Uint64: 2030 { 2031 if funcbody == nil { 2032 funv := r.ValueOf(func(int16, 2033 2034 uint64) {}) 2035 ret = func(env *Env) r.Value { return funv } 2036 2037 break 2038 } 2039 ret = func(env *Env) r.Value { 2040 2041 env.MarkUsedByClosure() 2042 return r.ValueOf(func(arg0 int16, 2043 2044 arg1 uint64, 2045 2046 ) { 2047 env := newEnv4Func(env, nbind, nintbind, debugC) 2048 2049 *(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 2050 2051 env.Ints[indexes[1]] = arg1 2052 2053 funcbody(env) 2054 2055 env.freeEnv4Func() 2056 }) 2057 } 2058 } 2059 case r.Uintptr: 2060 { 2061 if funcbody == nil { 2062 funv := r.ValueOf(func(int16, 2063 2064 uintptr) {}) 2065 ret = func(env *Env) r.Value { return funv } 2066 2067 break 2068 } 2069 ret = func(env *Env) r.Value { 2070 2071 env.MarkUsedByClosure() 2072 return r.ValueOf(func(arg0 int16, 2073 2074 arg1 uintptr, 2075 2076 ) { 2077 env := newEnv4Func(env, nbind, nintbind, debugC) 2078 2079 *(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 2080 2081 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 2082 2083 funcbody(env) 2084 2085 env.freeEnv4Func() 2086 }) 2087 } 2088 } 2089 case r.Float32: 2090 { 2091 if funcbody == nil { 2092 funv := r.ValueOf(func(int16, 2093 2094 float32) {}) 2095 ret = func(env *Env) r.Value { return funv } 2096 2097 break 2098 } 2099 ret = func(env *Env) r.Value { 2100 2101 env.MarkUsedByClosure() 2102 return r.ValueOf(func(arg0 int16, 2103 2104 arg1 float32, 2105 2106 ) { 2107 env := newEnv4Func(env, nbind, nintbind, debugC) 2108 2109 *(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 2110 2111 *(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 2112 2113 funcbody(env) 2114 2115 env.freeEnv4Func() 2116 }) 2117 } 2118 } 2119 case r.Float64: 2120 { 2121 if funcbody == nil { 2122 funv := r.ValueOf(func(int16, 2123 2124 float64) {}) 2125 ret = func(env *Env) r.Value { return funv } 2126 2127 break 2128 } 2129 ret = func(env *Env) r.Value { 2130 2131 env.MarkUsedByClosure() 2132 return r.ValueOf(func(arg0 int16, 2133 2134 arg1 float64, 2135 2136 ) { 2137 env := newEnv4Func(env, nbind, nintbind, debugC) 2138 2139 *(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 2140 2141 *(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 2142 2143 funcbody(env) 2144 2145 env.freeEnv4Func() 2146 }) 2147 } 2148 } 2149 case r.Complex64: 2150 { 2151 if funcbody == nil { 2152 funv := r.ValueOf(func(int16, 2153 2154 complex64) {}) 2155 ret = func(env *Env) r.Value { return funv } 2156 2157 break 2158 } 2159 ret = func(env *Env) r.Value { 2160 2161 env.MarkUsedByClosure() 2162 return r.ValueOf(func(arg0 int16, 2163 2164 arg1 complex64, 2165 ) { 2166 env := newEnv4Func(env, nbind, nintbind, debugC) 2167 2168 *(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 2169 2170 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 2171 2172 funcbody(env) 2173 2174 env.freeEnv4Func() 2175 }) 2176 } 2177 } 2178 case r.Complex128: 2179 { 2180 if funcbody == nil { 2181 funv := r.ValueOf(func(int16, 2182 2183 complex128) {}) 2184 ret = func(env *Env) r.Value { return funv } 2185 2186 break 2187 } 2188 ret = func(env *Env) r.Value { 2189 2190 env.MarkUsedByClosure() 2191 return r.ValueOf(func(arg0 int16, 2192 2193 arg1 complex128) { 2194 env := newEnv4Func(env, nbind, nintbind, debugC) 2195 2196 *(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 2197 2198 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 2199 2200 funcbody(env) 2201 2202 env.freeEnv4Func() 2203 }) 2204 } 2205 } 2206 case r.String: 2207 { 2208 if funcbody == nil { 2209 funv := r.ValueOf(func(int16, 2210 2211 string) {}) 2212 ret = func(env *Env) r.Value { return funv } 2213 2214 break 2215 } 2216 ret = func(env *Env) r.Value { 2217 2218 env.MarkUsedByClosure() 2219 return r.ValueOf(func(arg0 int16, 2220 2221 arg1 string) { 2222 env := newEnv4Func(env, nbind, nintbind, debugC) 2223 2224 *(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 2225 2226 { 2227 place := r.New(TypeOfString).Elem() 2228 place.SetString(arg1, 2229 ) 2230 env.Vals[indexes[1]] = place 2231 } 2232 2233 funcbody(env) 2234 2235 env.freeEnv4Func() 2236 }) 2237 } 2238 } 2239 } 2240 return ret 2241} 2242func func2ret0Int32(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value { 2243 2244 nbind := m.nbind 2245 nintbind := m.nintbind 2246 funcbody := m.funcbody 2247 var ret func(*Env) r.Value 2248 switch karg1 { 2249 case r.Bool: 2250 2251 { 2252 if funcbody == nil { 2253 funv := r.ValueOf(func(int32, 2254 2255 bool, 2256 2257 ) {}) 2258 ret = func(env *Env) r.Value { return funv } 2259 2260 break 2261 } 2262 ret = func(env *Env) r.Value { 2263 2264 env.MarkUsedByClosure() 2265 return r.ValueOf(func(arg0 int32, 2266 2267 arg1 bool, 2268 2269 ) { 2270 env := newEnv4Func(env, nbind, nintbind, debugC) 2271 2272 *(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 2273 2274 *(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 2275 2276 funcbody(env) 2277 2278 env.freeEnv4Func() 2279 }) 2280 } 2281 } 2282 case r.Int: 2283 2284 { 2285 if funcbody == nil { 2286 funv := r.ValueOf(func(int32, 2287 2288 int, 2289 2290 ) {}) 2291 ret = func(env *Env) r.Value { return funv } 2292 2293 break 2294 } 2295 ret = func(env *Env) r.Value { 2296 2297 env.MarkUsedByClosure() 2298 return r.ValueOf(func(arg0 int32, 2299 2300 arg1 int, 2301 2302 ) { 2303 env := newEnv4Func(env, nbind, nintbind, debugC) 2304 2305 *(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 2306 2307 *(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 2308 2309 funcbody(env) 2310 2311 env.freeEnv4Func() 2312 }) 2313 } 2314 } 2315 case r.Int8: 2316 2317 { 2318 if funcbody == nil { 2319 funv := r.ValueOf(func(int32, 2320 2321 int8, 2322 2323 ) {}) 2324 ret = func(env *Env) r.Value { return funv } 2325 2326 break 2327 } 2328 ret = func(env *Env) r.Value { 2329 2330 env.MarkUsedByClosure() 2331 return r.ValueOf(func(arg0 int32, 2332 2333 arg1 int8, 2334 2335 ) { 2336 env := newEnv4Func(env, nbind, nintbind, debugC) 2337 2338 *(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 2339 2340 *(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 2341 2342 funcbody(env) 2343 2344 env.freeEnv4Func() 2345 }) 2346 } 2347 } 2348 case r.Int16: 2349 { 2350 if funcbody == nil { 2351 funv := r.ValueOf(func(int32, 2352 2353 int16, 2354 2355 ) {}) 2356 ret = func(env *Env) r.Value { return funv } 2357 2358 break 2359 } 2360 ret = func(env *Env) r.Value { 2361 2362 env.MarkUsedByClosure() 2363 return r.ValueOf(func(arg0 int32, 2364 2365 arg1 int16, 2366 2367 ) { 2368 env := newEnv4Func(env, nbind, nintbind, debugC) 2369 2370 *(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 2371 2372 *(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 2373 2374 funcbody(env) 2375 2376 env.freeEnv4Func() 2377 }) 2378 } 2379 } 2380 case r.Int32: 2381 { 2382 if funcbody == nil { 2383 funv := r.ValueOf(func(int32, 2384 2385 int32, 2386 2387 ) {}) 2388 ret = func(env *Env) r.Value { return funv } 2389 2390 break 2391 } 2392 ret = func(env *Env) r.Value { 2393 2394 env.MarkUsedByClosure() 2395 return r.ValueOf(func(arg0 int32, 2396 2397 arg1 int32, 2398 2399 ) { 2400 env := newEnv4Func(env, nbind, nintbind, debugC) 2401 2402 *(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 2403 2404 *(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 2405 2406 funcbody(env) 2407 2408 env.freeEnv4Func() 2409 }) 2410 } 2411 } 2412 case r.Int64: 2413 { 2414 if funcbody == nil { 2415 funv := r.ValueOf(func(int32, 2416 2417 int64, 2418 ) {}) 2419 ret = func(env *Env) r.Value { return funv } 2420 2421 break 2422 } 2423 ret = func(env *Env) r.Value { 2424 2425 env.MarkUsedByClosure() 2426 return r.ValueOf(func(arg0 int32, 2427 2428 arg1 int64, 2429 2430 ) { 2431 env := newEnv4Func(env, nbind, nintbind, debugC) 2432 2433 *(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 2434 2435 *(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 2436 2437 funcbody(env) 2438 2439 env.freeEnv4Func() 2440 }) 2441 } 2442 } 2443 case r.Uint: 2444 { 2445 if funcbody == nil { 2446 funv := r.ValueOf(func(int32, 2447 2448 uint) {}) 2449 ret = func(env *Env) r.Value { return funv } 2450 2451 break 2452 } 2453 ret = func(env *Env) r.Value { 2454 2455 env.MarkUsedByClosure() 2456 return r.ValueOf(func(arg0 int32, 2457 2458 arg1 uint, 2459 2460 ) { 2461 env := newEnv4Func(env, nbind, nintbind, debugC) 2462 2463 *(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 2464 2465 *(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 2466 2467 funcbody(env) 2468 2469 env.freeEnv4Func() 2470 }) 2471 } 2472 } 2473 case r.Uint8: 2474 { 2475 if funcbody == nil { 2476 funv := r.ValueOf(func(int32, 2477 2478 uint8) {}) 2479 ret = func(env *Env) r.Value { return funv } 2480 2481 break 2482 } 2483 ret = func(env *Env) r.Value { 2484 2485 env.MarkUsedByClosure() 2486 return r.ValueOf(func(arg0 int32, 2487 2488 arg1 uint8, 2489 2490 ) { 2491 env := newEnv4Func(env, nbind, nintbind, debugC) 2492 2493 *(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 2494 2495 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 2496 2497 funcbody(env) 2498 2499 env.freeEnv4Func() 2500 }) 2501 } 2502 } 2503 case r.Uint16: 2504 { 2505 if funcbody == nil { 2506 funv := r.ValueOf(func(int32, 2507 2508 uint16) {}) 2509 ret = func(env *Env) r.Value { return funv } 2510 2511 break 2512 } 2513 ret = func(env *Env) r.Value { 2514 2515 env.MarkUsedByClosure() 2516 return r.ValueOf(func(arg0 int32, 2517 2518 arg1 uint16, 2519 2520 ) { 2521 env := newEnv4Func(env, nbind, nintbind, debugC) 2522 2523 *(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 2524 2525 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 2526 2527 funcbody(env) 2528 2529 env.freeEnv4Func() 2530 }) 2531 } 2532 } 2533 case r.Uint32: 2534 { 2535 if funcbody == nil { 2536 funv := r.ValueOf(func(int32, 2537 2538 uint32) {}) 2539 ret = func(env *Env) r.Value { return funv } 2540 2541 break 2542 } 2543 ret = func(env *Env) r.Value { 2544 2545 env.MarkUsedByClosure() 2546 return r.ValueOf(func(arg0 int32, 2547 2548 arg1 uint32, 2549 2550 ) { 2551 env := newEnv4Func(env, nbind, nintbind, debugC) 2552 2553 *(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 2554 2555 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 2556 2557 funcbody(env) 2558 2559 env.freeEnv4Func() 2560 }) 2561 } 2562 } 2563 case r.Uint64: 2564 { 2565 if funcbody == nil { 2566 funv := r.ValueOf(func(int32, 2567 2568 uint64) {}) 2569 ret = func(env *Env) r.Value { return funv } 2570 2571 break 2572 } 2573 ret = func(env *Env) r.Value { 2574 2575 env.MarkUsedByClosure() 2576 return r.ValueOf(func(arg0 int32, 2577 2578 arg1 uint64, 2579 2580 ) { 2581 env := newEnv4Func(env, nbind, nintbind, debugC) 2582 2583 *(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 2584 2585 env.Ints[indexes[1]] = arg1 2586 2587 funcbody(env) 2588 2589 env.freeEnv4Func() 2590 }) 2591 } 2592 } 2593 case r.Uintptr: 2594 { 2595 if funcbody == nil { 2596 funv := r.ValueOf(func(int32, 2597 2598 uintptr) {}) 2599 ret = func(env *Env) r.Value { return funv } 2600 2601 break 2602 } 2603 ret = func(env *Env) r.Value { 2604 2605 env.MarkUsedByClosure() 2606 return r.ValueOf(func(arg0 int32, 2607 2608 arg1 uintptr, 2609 2610 ) { 2611 env := newEnv4Func(env, nbind, nintbind, debugC) 2612 2613 *(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 2614 2615 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 2616 2617 funcbody(env) 2618 2619 env.freeEnv4Func() 2620 }) 2621 } 2622 } 2623 case r.Float32: 2624 { 2625 if funcbody == nil { 2626 funv := r.ValueOf(func(int32, 2627 2628 float32) {}) 2629 ret = func(env *Env) r.Value { return funv } 2630 2631 break 2632 } 2633 ret = func(env *Env) r.Value { 2634 2635 env.MarkUsedByClosure() 2636 return r.ValueOf(func(arg0 int32, 2637 2638 arg1 float32, 2639 2640 ) { 2641 env := newEnv4Func(env, nbind, nintbind, debugC) 2642 2643 *(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 2644 2645 *(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 2646 2647 funcbody(env) 2648 2649 env.freeEnv4Func() 2650 }) 2651 } 2652 } 2653 case r.Float64: 2654 { 2655 if funcbody == nil { 2656 funv := r.ValueOf(func(int32, 2657 2658 float64) {}) 2659 ret = func(env *Env) r.Value { return funv } 2660 2661 break 2662 } 2663 ret = func(env *Env) r.Value { 2664 2665 env.MarkUsedByClosure() 2666 return r.ValueOf(func(arg0 int32, 2667 2668 arg1 float64, 2669 2670 ) { 2671 env := newEnv4Func(env, nbind, nintbind, debugC) 2672 2673 *(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 2674 2675 *(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 2676 2677 funcbody(env) 2678 2679 env.freeEnv4Func() 2680 }) 2681 } 2682 } 2683 case r.Complex64: 2684 { 2685 if funcbody == nil { 2686 funv := r.ValueOf(func(int32, 2687 2688 complex64) {}) 2689 ret = func(env *Env) r.Value { return funv } 2690 2691 break 2692 } 2693 ret = func(env *Env) r.Value { 2694 2695 env.MarkUsedByClosure() 2696 return r.ValueOf(func(arg0 int32, 2697 2698 arg1 complex64, 2699 ) { 2700 env := newEnv4Func(env, nbind, nintbind, debugC) 2701 2702 *(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 2703 2704 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 2705 2706 funcbody(env) 2707 2708 env.freeEnv4Func() 2709 }) 2710 } 2711 } 2712 case r.Complex128: 2713 { 2714 if funcbody == nil { 2715 funv := r.ValueOf(func(int32, 2716 2717 complex128) {}) 2718 ret = func(env *Env) r.Value { return funv } 2719 2720 break 2721 } 2722 ret = func(env *Env) r.Value { 2723 2724 env.MarkUsedByClosure() 2725 return r.ValueOf(func(arg0 int32, 2726 2727 arg1 complex128) { 2728 env := newEnv4Func(env, nbind, nintbind, debugC) 2729 2730 *(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 2731 2732 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 2733 2734 funcbody(env) 2735 2736 env.freeEnv4Func() 2737 }) 2738 } 2739 } 2740 case r.String: 2741 { 2742 if funcbody == nil { 2743 funv := r.ValueOf(func(int32, 2744 2745 string) {}) 2746 ret = func(env *Env) r.Value { return funv } 2747 2748 break 2749 } 2750 ret = func(env *Env) r.Value { 2751 2752 env.MarkUsedByClosure() 2753 return r.ValueOf(func(arg0 int32, 2754 2755 arg1 string) { 2756 env := newEnv4Func(env, nbind, nintbind, debugC) 2757 2758 *(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 2759 2760 { 2761 place := r.New(TypeOfString).Elem() 2762 place.SetString(arg1, 2763 ) 2764 env.Vals[indexes[1]] = place 2765 } 2766 2767 funcbody(env) 2768 2769 env.freeEnv4Func() 2770 }) 2771 } 2772 } 2773 } 2774 return ret 2775} 2776func func2ret0Int64(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value { 2777 2778 nbind := m.nbind 2779 nintbind := m.nintbind 2780 funcbody := m.funcbody 2781 var ret func(*Env) r.Value 2782 switch karg1 { 2783 case r.Bool: 2784 2785 { 2786 if funcbody == nil { 2787 funv := r.ValueOf(func(int64, 2788 2789 bool, 2790 2791 ) {}) 2792 ret = func(env *Env) r.Value { return funv } 2793 2794 break 2795 } 2796 ret = func(env *Env) r.Value { 2797 2798 env.MarkUsedByClosure() 2799 return r.ValueOf(func(arg0 int64, 2800 2801 arg1 bool, 2802 2803 ) { 2804 env := newEnv4Func(env, nbind, nintbind, debugC) 2805 2806 *(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 2807 2808 *(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 2809 2810 funcbody(env) 2811 2812 env.freeEnv4Func() 2813 }) 2814 } 2815 } 2816 case r.Int: 2817 2818 { 2819 if funcbody == nil { 2820 funv := r.ValueOf(func(int64, 2821 2822 int, 2823 2824 ) {}) 2825 ret = func(env *Env) r.Value { return funv } 2826 2827 break 2828 } 2829 ret = func(env *Env) r.Value { 2830 2831 env.MarkUsedByClosure() 2832 return r.ValueOf(func(arg0 int64, 2833 2834 arg1 int, 2835 2836 ) { 2837 env := newEnv4Func(env, nbind, nintbind, debugC) 2838 2839 *(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 2840 2841 *(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 2842 2843 funcbody(env) 2844 2845 env.freeEnv4Func() 2846 }) 2847 } 2848 } 2849 case r.Int8: 2850 2851 { 2852 if funcbody == nil { 2853 funv := r.ValueOf(func(int64, 2854 2855 int8, 2856 2857 ) {}) 2858 ret = func(env *Env) r.Value { return funv } 2859 2860 break 2861 } 2862 ret = func(env *Env) r.Value { 2863 2864 env.MarkUsedByClosure() 2865 return r.ValueOf(func(arg0 int64, 2866 2867 arg1 int8, 2868 2869 ) { 2870 env := newEnv4Func(env, nbind, nintbind, debugC) 2871 2872 *(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 2873 2874 *(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 2875 2876 funcbody(env) 2877 2878 env.freeEnv4Func() 2879 }) 2880 } 2881 } 2882 case r.Int16: 2883 { 2884 if funcbody == nil { 2885 funv := r.ValueOf(func(int64, 2886 2887 int16, 2888 2889 ) {}) 2890 ret = func(env *Env) r.Value { return funv } 2891 2892 break 2893 } 2894 ret = func(env *Env) r.Value { 2895 2896 env.MarkUsedByClosure() 2897 return r.ValueOf(func(arg0 int64, 2898 2899 arg1 int16, 2900 2901 ) { 2902 env := newEnv4Func(env, nbind, nintbind, debugC) 2903 2904 *(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 2905 2906 *(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 2907 2908 funcbody(env) 2909 2910 env.freeEnv4Func() 2911 }) 2912 } 2913 } 2914 case r.Int32: 2915 { 2916 if funcbody == nil { 2917 funv := r.ValueOf(func(int64, 2918 2919 int32, 2920 2921 ) {}) 2922 ret = func(env *Env) r.Value { return funv } 2923 2924 break 2925 } 2926 ret = func(env *Env) r.Value { 2927 2928 env.MarkUsedByClosure() 2929 return r.ValueOf(func(arg0 int64, 2930 2931 arg1 int32, 2932 2933 ) { 2934 env := newEnv4Func(env, nbind, nintbind, debugC) 2935 2936 *(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 2937 2938 *(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 2939 2940 funcbody(env) 2941 2942 env.freeEnv4Func() 2943 }) 2944 } 2945 } 2946 case r.Int64: 2947 { 2948 if funcbody == nil { 2949 funv := r.ValueOf(func(int64, 2950 2951 int64, 2952 ) {}) 2953 ret = func(env *Env) r.Value { return funv } 2954 2955 break 2956 } 2957 ret = func(env *Env) r.Value { 2958 2959 env.MarkUsedByClosure() 2960 return r.ValueOf(func(arg0 int64, 2961 2962 arg1 int64, 2963 2964 ) { 2965 env := newEnv4Func(env, nbind, nintbind, debugC) 2966 2967 *(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 2968 2969 *(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 2970 2971 funcbody(env) 2972 2973 env.freeEnv4Func() 2974 }) 2975 } 2976 } 2977 case r.Uint: 2978 { 2979 if funcbody == nil { 2980 funv := r.ValueOf(func(int64, 2981 2982 uint) {}) 2983 ret = func(env *Env) r.Value { return funv } 2984 2985 break 2986 } 2987 ret = func(env *Env) r.Value { 2988 2989 env.MarkUsedByClosure() 2990 return r.ValueOf(func(arg0 int64, 2991 2992 arg1 uint, 2993 2994 ) { 2995 env := newEnv4Func(env, nbind, nintbind, debugC) 2996 2997 *(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 2998 2999 *(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 3000 3001 funcbody(env) 3002 3003 env.freeEnv4Func() 3004 }) 3005 } 3006 } 3007 case r.Uint8: 3008 { 3009 if funcbody == nil { 3010 funv := r.ValueOf(func(int64, 3011 3012 uint8) {}) 3013 ret = func(env *Env) r.Value { return funv } 3014 3015 break 3016 } 3017 ret = func(env *Env) r.Value { 3018 3019 env.MarkUsedByClosure() 3020 return r.ValueOf(func(arg0 int64, 3021 3022 arg1 uint8, 3023 3024 ) { 3025 env := newEnv4Func(env, nbind, nintbind, debugC) 3026 3027 *(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 3028 3029 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 3030 3031 funcbody(env) 3032 3033 env.freeEnv4Func() 3034 }) 3035 } 3036 } 3037 case r.Uint16: 3038 { 3039 if funcbody == nil { 3040 funv := r.ValueOf(func(int64, 3041 3042 uint16) {}) 3043 ret = func(env *Env) r.Value { return funv } 3044 3045 break 3046 } 3047 ret = func(env *Env) r.Value { 3048 3049 env.MarkUsedByClosure() 3050 return r.ValueOf(func(arg0 int64, 3051 3052 arg1 uint16, 3053 3054 ) { 3055 env := newEnv4Func(env, nbind, nintbind, debugC) 3056 3057 *(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 3058 3059 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 3060 3061 funcbody(env) 3062 3063 env.freeEnv4Func() 3064 }) 3065 } 3066 } 3067 case r.Uint32: 3068 { 3069 if funcbody == nil { 3070 funv := r.ValueOf(func(int64, 3071 3072 uint32) {}) 3073 ret = func(env *Env) r.Value { return funv } 3074 3075 break 3076 } 3077 ret = func(env *Env) r.Value { 3078 3079 env.MarkUsedByClosure() 3080 return r.ValueOf(func(arg0 int64, 3081 3082 arg1 uint32, 3083 3084 ) { 3085 env := newEnv4Func(env, nbind, nintbind, debugC) 3086 3087 *(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 3088 3089 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 3090 3091 funcbody(env) 3092 3093 env.freeEnv4Func() 3094 }) 3095 } 3096 } 3097 case r.Uint64: 3098 { 3099 if funcbody == nil { 3100 funv := r.ValueOf(func(int64, 3101 3102 uint64) {}) 3103 ret = func(env *Env) r.Value { return funv } 3104 3105 break 3106 } 3107 ret = func(env *Env) r.Value { 3108 3109 env.MarkUsedByClosure() 3110 return r.ValueOf(func(arg0 int64, 3111 3112 arg1 uint64, 3113 3114 ) { 3115 env := newEnv4Func(env, nbind, nintbind, debugC) 3116 3117 *(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 3118 3119 env.Ints[indexes[1]] = arg1 3120 3121 funcbody(env) 3122 3123 env.freeEnv4Func() 3124 }) 3125 } 3126 } 3127 case r.Uintptr: 3128 { 3129 if funcbody == nil { 3130 funv := r.ValueOf(func(int64, 3131 3132 uintptr) {}) 3133 ret = func(env *Env) r.Value { return funv } 3134 3135 break 3136 } 3137 ret = func(env *Env) r.Value { 3138 3139 env.MarkUsedByClosure() 3140 return r.ValueOf(func(arg0 int64, 3141 3142 arg1 uintptr, 3143 3144 ) { 3145 env := newEnv4Func(env, nbind, nintbind, debugC) 3146 3147 *(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 3148 3149 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 3150 3151 funcbody(env) 3152 3153 env.freeEnv4Func() 3154 }) 3155 } 3156 } 3157 case r.Float32: 3158 { 3159 if funcbody == nil { 3160 funv := r.ValueOf(func(int64, 3161 3162 float32) {}) 3163 ret = func(env *Env) r.Value { return funv } 3164 3165 break 3166 } 3167 ret = func(env *Env) r.Value { 3168 3169 env.MarkUsedByClosure() 3170 return r.ValueOf(func(arg0 int64, 3171 3172 arg1 float32, 3173 3174 ) { 3175 env := newEnv4Func(env, nbind, nintbind, debugC) 3176 3177 *(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 3178 3179 *(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 3180 3181 funcbody(env) 3182 3183 env.freeEnv4Func() 3184 }) 3185 } 3186 } 3187 case r.Float64: 3188 { 3189 if funcbody == nil { 3190 funv := r.ValueOf(func(int64, 3191 3192 float64) {}) 3193 ret = func(env *Env) r.Value { return funv } 3194 3195 break 3196 } 3197 ret = func(env *Env) r.Value { 3198 3199 env.MarkUsedByClosure() 3200 return r.ValueOf(func(arg0 int64, 3201 3202 arg1 float64, 3203 3204 ) { 3205 env := newEnv4Func(env, nbind, nintbind, debugC) 3206 3207 *(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 3208 3209 *(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 3210 3211 funcbody(env) 3212 3213 env.freeEnv4Func() 3214 }) 3215 } 3216 } 3217 case r.Complex64: 3218 { 3219 if funcbody == nil { 3220 funv := r.ValueOf(func(int64, 3221 3222 complex64) {}) 3223 ret = func(env *Env) r.Value { return funv } 3224 3225 break 3226 } 3227 ret = func(env *Env) r.Value { 3228 3229 env.MarkUsedByClosure() 3230 return r.ValueOf(func(arg0 int64, 3231 3232 arg1 complex64, 3233 ) { 3234 env := newEnv4Func(env, nbind, nintbind, debugC) 3235 3236 *(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 3237 3238 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 3239 3240 funcbody(env) 3241 3242 env.freeEnv4Func() 3243 }) 3244 } 3245 } 3246 case r.Complex128: 3247 { 3248 if funcbody == nil { 3249 funv := r.ValueOf(func(int64, 3250 3251 complex128) {}) 3252 ret = func(env *Env) r.Value { return funv } 3253 3254 break 3255 } 3256 ret = func(env *Env) r.Value { 3257 3258 env.MarkUsedByClosure() 3259 return r.ValueOf(func(arg0 int64, 3260 3261 arg1 complex128) { 3262 env := newEnv4Func(env, nbind, nintbind, debugC) 3263 3264 *(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 3265 3266 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 3267 3268 funcbody(env) 3269 3270 env.freeEnv4Func() 3271 }) 3272 } 3273 } 3274 case r.String: 3275 { 3276 if funcbody == nil { 3277 funv := r.ValueOf(func(int64, 3278 3279 string) {}) 3280 ret = func(env *Env) r.Value { return funv } 3281 3282 break 3283 } 3284 ret = func(env *Env) r.Value { 3285 3286 env.MarkUsedByClosure() 3287 return r.ValueOf(func(arg0 int64, 3288 3289 arg1 string) { 3290 env := newEnv4Func(env, nbind, nintbind, debugC) 3291 3292 *(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 3293 3294 { 3295 place := r.New(TypeOfString).Elem() 3296 place.SetString(arg1, 3297 ) 3298 env.Vals[indexes[1]] = place 3299 } 3300 3301 funcbody(env) 3302 3303 env.freeEnv4Func() 3304 }) 3305 } 3306 } 3307 } 3308 return ret 3309} 3310func func2ret0Uint(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value { 3311 3312 nbind := m.nbind 3313 nintbind := m.nintbind 3314 funcbody := m.funcbody 3315 var ret func(*Env) r.Value 3316 switch karg1 { 3317 case r.Bool: 3318 3319 { 3320 if funcbody == nil { 3321 funv := r.ValueOf(func(uint, 3322 3323 bool, 3324 3325 ) {}) 3326 ret = func(env *Env) r.Value { return funv } 3327 3328 break 3329 } 3330 ret = func(env *Env) r.Value { 3331 3332 env.MarkUsedByClosure() 3333 return r.ValueOf(func(arg0 uint, 3334 3335 arg1 bool, 3336 3337 ) { 3338 env := newEnv4Func(env, nbind, nintbind, debugC) 3339 3340 *(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 3341 3342 *(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 3343 3344 funcbody(env) 3345 3346 env.freeEnv4Func() 3347 }) 3348 } 3349 } 3350 case r.Int: 3351 3352 { 3353 if funcbody == nil { 3354 funv := r.ValueOf(func(uint, 3355 3356 int, 3357 3358 ) {}) 3359 ret = func(env *Env) r.Value { return funv } 3360 3361 break 3362 } 3363 ret = func(env *Env) r.Value { 3364 3365 env.MarkUsedByClosure() 3366 return r.ValueOf(func(arg0 uint, 3367 3368 arg1 int, 3369 3370 ) { 3371 env := newEnv4Func(env, nbind, nintbind, debugC) 3372 3373 *(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 3374 3375 *(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 3376 3377 funcbody(env) 3378 3379 env.freeEnv4Func() 3380 }) 3381 } 3382 } 3383 case r.Int8: 3384 3385 { 3386 if funcbody == nil { 3387 funv := r.ValueOf(func(uint, 3388 3389 int8, 3390 3391 ) {}) 3392 ret = func(env *Env) r.Value { return funv } 3393 3394 break 3395 } 3396 ret = func(env *Env) r.Value { 3397 3398 env.MarkUsedByClosure() 3399 return r.ValueOf(func(arg0 uint, 3400 3401 arg1 int8, 3402 3403 ) { 3404 env := newEnv4Func(env, nbind, nintbind, debugC) 3405 3406 *(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 3407 3408 *(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 3409 3410 funcbody(env) 3411 3412 env.freeEnv4Func() 3413 }) 3414 } 3415 } 3416 case r.Int16: 3417 { 3418 if funcbody == nil { 3419 funv := r.ValueOf(func(uint, 3420 3421 int16, 3422 3423 ) {}) 3424 ret = func(env *Env) r.Value { return funv } 3425 3426 break 3427 } 3428 ret = func(env *Env) r.Value { 3429 3430 env.MarkUsedByClosure() 3431 return r.ValueOf(func(arg0 uint, 3432 3433 arg1 int16, 3434 3435 ) { 3436 env := newEnv4Func(env, nbind, nintbind, debugC) 3437 3438 *(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 3439 3440 *(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 3441 3442 funcbody(env) 3443 3444 env.freeEnv4Func() 3445 }) 3446 } 3447 } 3448 case r.Int32: 3449 { 3450 if funcbody == nil { 3451 funv := r.ValueOf(func(uint, 3452 3453 int32, 3454 3455 ) {}) 3456 ret = func(env *Env) r.Value { return funv } 3457 3458 break 3459 } 3460 ret = func(env *Env) r.Value { 3461 3462 env.MarkUsedByClosure() 3463 return r.ValueOf(func(arg0 uint, 3464 3465 arg1 int32, 3466 3467 ) { 3468 env := newEnv4Func(env, nbind, nintbind, debugC) 3469 3470 *(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 3471 3472 *(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 3473 3474 funcbody(env) 3475 3476 env.freeEnv4Func() 3477 }) 3478 } 3479 } 3480 case r.Int64: 3481 { 3482 if funcbody == nil { 3483 funv := r.ValueOf(func(uint, 3484 3485 int64, 3486 ) {}) 3487 ret = func(env *Env) r.Value { return funv } 3488 3489 break 3490 } 3491 ret = func(env *Env) r.Value { 3492 3493 env.MarkUsedByClosure() 3494 return r.ValueOf(func(arg0 uint, 3495 3496 arg1 int64, 3497 3498 ) { 3499 env := newEnv4Func(env, nbind, nintbind, debugC) 3500 3501 *(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 3502 3503 *(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 3504 3505 funcbody(env) 3506 3507 env.freeEnv4Func() 3508 }) 3509 } 3510 } 3511 case r.Uint: 3512 { 3513 if funcbody == nil { 3514 funv := r.ValueOf(func(uint, 3515 3516 uint) {}) 3517 ret = func(env *Env) r.Value { return funv } 3518 3519 break 3520 } 3521 ret = func(env *Env) r.Value { 3522 3523 env.MarkUsedByClosure() 3524 return r.ValueOf(func(arg0 uint, 3525 3526 arg1 uint, 3527 3528 ) { 3529 env := newEnv4Func(env, nbind, nintbind, debugC) 3530 3531 *(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 3532 3533 *(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 3534 3535 funcbody(env) 3536 3537 env.freeEnv4Func() 3538 }) 3539 } 3540 } 3541 case r.Uint8: 3542 { 3543 if funcbody == nil { 3544 funv := r.ValueOf(func(uint, 3545 3546 uint8) {}) 3547 ret = func(env *Env) r.Value { return funv } 3548 3549 break 3550 } 3551 ret = func(env *Env) r.Value { 3552 3553 env.MarkUsedByClosure() 3554 return r.ValueOf(func(arg0 uint, 3555 3556 arg1 uint8, 3557 3558 ) { 3559 env := newEnv4Func(env, nbind, nintbind, debugC) 3560 3561 *(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 3562 3563 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 3564 3565 funcbody(env) 3566 3567 env.freeEnv4Func() 3568 }) 3569 } 3570 } 3571 case r.Uint16: 3572 { 3573 if funcbody == nil { 3574 funv := r.ValueOf(func(uint, 3575 3576 uint16) {}) 3577 ret = func(env *Env) r.Value { return funv } 3578 3579 break 3580 } 3581 ret = func(env *Env) r.Value { 3582 3583 env.MarkUsedByClosure() 3584 return r.ValueOf(func(arg0 uint, 3585 3586 arg1 uint16, 3587 3588 ) { 3589 env := newEnv4Func(env, nbind, nintbind, debugC) 3590 3591 *(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 3592 3593 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 3594 3595 funcbody(env) 3596 3597 env.freeEnv4Func() 3598 }) 3599 } 3600 } 3601 case r.Uint32: 3602 { 3603 if funcbody == nil { 3604 funv := r.ValueOf(func(uint, 3605 3606 uint32) {}) 3607 ret = func(env *Env) r.Value { return funv } 3608 3609 break 3610 } 3611 ret = func(env *Env) r.Value { 3612 3613 env.MarkUsedByClosure() 3614 return r.ValueOf(func(arg0 uint, 3615 3616 arg1 uint32, 3617 3618 ) { 3619 env := newEnv4Func(env, nbind, nintbind, debugC) 3620 3621 *(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 3622 3623 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 3624 3625 funcbody(env) 3626 3627 env.freeEnv4Func() 3628 }) 3629 } 3630 } 3631 case r.Uint64: 3632 { 3633 if funcbody == nil { 3634 funv := r.ValueOf(func(uint, 3635 3636 uint64) {}) 3637 ret = func(env *Env) r.Value { return funv } 3638 3639 break 3640 } 3641 ret = func(env *Env) r.Value { 3642 3643 env.MarkUsedByClosure() 3644 return r.ValueOf(func(arg0 uint, 3645 3646 arg1 uint64, 3647 3648 ) { 3649 env := newEnv4Func(env, nbind, nintbind, debugC) 3650 3651 *(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 3652 3653 env.Ints[indexes[1]] = arg1 3654 3655 funcbody(env) 3656 3657 env.freeEnv4Func() 3658 }) 3659 } 3660 } 3661 case r.Uintptr: 3662 { 3663 if funcbody == nil { 3664 funv := r.ValueOf(func(uint, 3665 3666 uintptr) {}) 3667 ret = func(env *Env) r.Value { return funv } 3668 3669 break 3670 } 3671 ret = func(env *Env) r.Value { 3672 3673 env.MarkUsedByClosure() 3674 return r.ValueOf(func(arg0 uint, 3675 3676 arg1 uintptr, 3677 3678 ) { 3679 env := newEnv4Func(env, nbind, nintbind, debugC) 3680 3681 *(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 3682 3683 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 3684 3685 funcbody(env) 3686 3687 env.freeEnv4Func() 3688 }) 3689 } 3690 } 3691 case r.Float32: 3692 { 3693 if funcbody == nil { 3694 funv := r.ValueOf(func(uint, 3695 3696 float32) {}) 3697 ret = func(env *Env) r.Value { return funv } 3698 3699 break 3700 } 3701 ret = func(env *Env) r.Value { 3702 3703 env.MarkUsedByClosure() 3704 return r.ValueOf(func(arg0 uint, 3705 3706 arg1 float32, 3707 3708 ) { 3709 env := newEnv4Func(env, nbind, nintbind, debugC) 3710 3711 *(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 3712 3713 *(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 3714 3715 funcbody(env) 3716 3717 env.freeEnv4Func() 3718 }) 3719 } 3720 } 3721 case r.Float64: 3722 { 3723 if funcbody == nil { 3724 funv := r.ValueOf(func(uint, 3725 3726 float64) {}) 3727 ret = func(env *Env) r.Value { return funv } 3728 3729 break 3730 } 3731 ret = func(env *Env) r.Value { 3732 3733 env.MarkUsedByClosure() 3734 return r.ValueOf(func(arg0 uint, 3735 3736 arg1 float64, 3737 3738 ) { 3739 env := newEnv4Func(env, nbind, nintbind, debugC) 3740 3741 *(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 3742 3743 *(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 3744 3745 funcbody(env) 3746 3747 env.freeEnv4Func() 3748 }) 3749 } 3750 } 3751 case r.Complex64: 3752 { 3753 if funcbody == nil { 3754 funv := r.ValueOf(func(uint, 3755 3756 complex64) {}) 3757 ret = func(env *Env) r.Value { return funv } 3758 3759 break 3760 } 3761 ret = func(env *Env) r.Value { 3762 3763 env.MarkUsedByClosure() 3764 return r.ValueOf(func(arg0 uint, 3765 3766 arg1 complex64, 3767 ) { 3768 env := newEnv4Func(env, nbind, nintbind, debugC) 3769 3770 *(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 3771 3772 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 3773 3774 funcbody(env) 3775 3776 env.freeEnv4Func() 3777 }) 3778 } 3779 } 3780 case r.Complex128: 3781 { 3782 if funcbody == nil { 3783 funv := r.ValueOf(func(uint, 3784 3785 complex128) {}) 3786 ret = func(env *Env) r.Value { return funv } 3787 3788 break 3789 } 3790 ret = func(env *Env) r.Value { 3791 3792 env.MarkUsedByClosure() 3793 return r.ValueOf(func(arg0 uint, 3794 3795 arg1 complex128) { 3796 env := newEnv4Func(env, nbind, nintbind, debugC) 3797 3798 *(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 3799 3800 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 3801 3802 funcbody(env) 3803 3804 env.freeEnv4Func() 3805 }) 3806 } 3807 } 3808 case r.String: 3809 { 3810 if funcbody == nil { 3811 funv := r.ValueOf(func(uint, 3812 3813 string) {}) 3814 ret = func(env *Env) r.Value { return funv } 3815 3816 break 3817 } 3818 ret = func(env *Env) r.Value { 3819 3820 env.MarkUsedByClosure() 3821 return r.ValueOf(func(arg0 uint, 3822 3823 arg1 string) { 3824 env := newEnv4Func(env, nbind, nintbind, debugC) 3825 3826 *(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 3827 3828 { 3829 place := r.New(TypeOfString).Elem() 3830 place.SetString(arg1, 3831 ) 3832 env.Vals[indexes[1]] = place 3833 } 3834 3835 funcbody(env) 3836 3837 env.freeEnv4Func() 3838 }) 3839 } 3840 } 3841 } 3842 return ret 3843} 3844func func2ret0Uint8(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value { 3845 3846 nbind := m.nbind 3847 nintbind := m.nintbind 3848 funcbody := m.funcbody 3849 var ret func(*Env) r.Value 3850 switch karg1 { 3851 case r.Bool: 3852 3853 { 3854 if funcbody == nil { 3855 funv := r.ValueOf(func(uint8, 3856 3857 bool, 3858 3859 ) {}) 3860 ret = func(env *Env) r.Value { return funv } 3861 3862 break 3863 } 3864 ret = func(env *Env) r.Value { 3865 3866 env.MarkUsedByClosure() 3867 return r.ValueOf(func(arg0 uint8, 3868 3869 arg1 bool, 3870 3871 ) { 3872 env := newEnv4Func(env, nbind, nintbind, debugC) 3873 3874 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 3875 3876 *(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 3877 3878 funcbody(env) 3879 3880 env.freeEnv4Func() 3881 }) 3882 } 3883 } 3884 case r.Int: 3885 3886 { 3887 if funcbody == nil { 3888 funv := r.ValueOf(func(uint8, 3889 3890 int, 3891 3892 ) {}) 3893 ret = func(env *Env) r.Value { return funv } 3894 3895 break 3896 } 3897 ret = func(env *Env) r.Value { 3898 3899 env.MarkUsedByClosure() 3900 return r.ValueOf(func(arg0 uint8, 3901 3902 arg1 int, 3903 3904 ) { 3905 env := newEnv4Func(env, nbind, nintbind, debugC) 3906 3907 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 3908 3909 *(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 3910 3911 funcbody(env) 3912 3913 env.freeEnv4Func() 3914 }) 3915 } 3916 } 3917 case r.Int8: 3918 3919 { 3920 if funcbody == nil { 3921 funv := r.ValueOf(func(uint8, 3922 3923 int8, 3924 3925 ) {}) 3926 ret = func(env *Env) r.Value { return funv } 3927 3928 break 3929 } 3930 ret = func(env *Env) r.Value { 3931 3932 env.MarkUsedByClosure() 3933 return r.ValueOf(func(arg0 uint8, 3934 3935 arg1 int8, 3936 3937 ) { 3938 env := newEnv4Func(env, nbind, nintbind, debugC) 3939 3940 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 3941 3942 *(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 3943 3944 funcbody(env) 3945 3946 env.freeEnv4Func() 3947 }) 3948 } 3949 } 3950 case r.Int16: 3951 { 3952 if funcbody == nil { 3953 funv := r.ValueOf(func(uint8, 3954 3955 int16, 3956 3957 ) {}) 3958 ret = func(env *Env) r.Value { return funv } 3959 3960 break 3961 } 3962 ret = func(env *Env) r.Value { 3963 3964 env.MarkUsedByClosure() 3965 return r.ValueOf(func(arg0 uint8, 3966 3967 arg1 int16, 3968 3969 ) { 3970 env := newEnv4Func(env, nbind, nintbind, debugC) 3971 3972 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 3973 3974 *(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 3975 3976 funcbody(env) 3977 3978 env.freeEnv4Func() 3979 }) 3980 } 3981 } 3982 case r.Int32: 3983 { 3984 if funcbody == nil { 3985 funv := r.ValueOf(func(uint8, 3986 3987 int32, 3988 3989 ) {}) 3990 ret = func(env *Env) r.Value { return funv } 3991 3992 break 3993 } 3994 ret = func(env *Env) r.Value { 3995 3996 env.MarkUsedByClosure() 3997 return r.ValueOf(func(arg0 uint8, 3998 3999 arg1 int32, 4000 4001 ) { 4002 env := newEnv4Func(env, nbind, nintbind, debugC) 4003 4004 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 4005 4006 *(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 4007 4008 funcbody(env) 4009 4010 env.freeEnv4Func() 4011 }) 4012 } 4013 } 4014 case r.Int64: 4015 { 4016 if funcbody == nil { 4017 funv := r.ValueOf(func(uint8, 4018 4019 int64, 4020 ) {}) 4021 ret = func(env *Env) r.Value { return funv } 4022 4023 break 4024 } 4025 ret = func(env *Env) r.Value { 4026 4027 env.MarkUsedByClosure() 4028 return r.ValueOf(func(arg0 uint8, 4029 4030 arg1 int64, 4031 4032 ) { 4033 env := newEnv4Func(env, nbind, nintbind, debugC) 4034 4035 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 4036 4037 *(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 4038 4039 funcbody(env) 4040 4041 env.freeEnv4Func() 4042 }) 4043 } 4044 } 4045 case r.Uint: 4046 { 4047 if funcbody == nil { 4048 funv := r.ValueOf(func(uint8, 4049 4050 uint) {}) 4051 ret = func(env *Env) r.Value { return funv } 4052 4053 break 4054 } 4055 ret = func(env *Env) r.Value { 4056 4057 env.MarkUsedByClosure() 4058 return r.ValueOf(func(arg0 uint8, 4059 4060 arg1 uint, 4061 4062 ) { 4063 env := newEnv4Func(env, nbind, nintbind, debugC) 4064 4065 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 4066 4067 *(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 4068 4069 funcbody(env) 4070 4071 env.freeEnv4Func() 4072 }) 4073 } 4074 } 4075 case r.Uint8: 4076 { 4077 if funcbody == nil { 4078 funv := r.ValueOf(func(uint8, 4079 4080 uint8) {}) 4081 ret = func(env *Env) r.Value { return funv } 4082 4083 break 4084 } 4085 ret = func(env *Env) r.Value { 4086 4087 env.MarkUsedByClosure() 4088 return r.ValueOf(func(arg0 uint8, 4089 4090 arg1 uint8, 4091 4092 ) { 4093 env := newEnv4Func(env, nbind, nintbind, debugC) 4094 4095 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 4096 4097 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 4098 4099 funcbody(env) 4100 4101 env.freeEnv4Func() 4102 }) 4103 } 4104 } 4105 case r.Uint16: 4106 { 4107 if funcbody == nil { 4108 funv := r.ValueOf(func(uint8, 4109 4110 uint16) {}) 4111 ret = func(env *Env) r.Value { return funv } 4112 4113 break 4114 } 4115 ret = func(env *Env) r.Value { 4116 4117 env.MarkUsedByClosure() 4118 return r.ValueOf(func(arg0 uint8, 4119 4120 arg1 uint16, 4121 4122 ) { 4123 env := newEnv4Func(env, nbind, nintbind, debugC) 4124 4125 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 4126 4127 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 4128 4129 funcbody(env) 4130 4131 env.freeEnv4Func() 4132 }) 4133 } 4134 } 4135 case r.Uint32: 4136 { 4137 if funcbody == nil { 4138 funv := r.ValueOf(func(uint8, 4139 4140 uint32) {}) 4141 ret = func(env *Env) r.Value { return funv } 4142 4143 break 4144 } 4145 ret = func(env *Env) r.Value { 4146 4147 env.MarkUsedByClosure() 4148 return r.ValueOf(func(arg0 uint8, 4149 4150 arg1 uint32, 4151 4152 ) { 4153 env := newEnv4Func(env, nbind, nintbind, debugC) 4154 4155 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 4156 4157 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 4158 4159 funcbody(env) 4160 4161 env.freeEnv4Func() 4162 }) 4163 } 4164 } 4165 case r.Uint64: 4166 { 4167 if funcbody == nil { 4168 funv := r.ValueOf(func(uint8, 4169 4170 uint64) {}) 4171 ret = func(env *Env) r.Value { return funv } 4172 4173 break 4174 } 4175 ret = func(env *Env) r.Value { 4176 4177 env.MarkUsedByClosure() 4178 return r.ValueOf(func(arg0 uint8, 4179 4180 arg1 uint64, 4181 4182 ) { 4183 env := newEnv4Func(env, nbind, nintbind, debugC) 4184 4185 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 4186 4187 env.Ints[indexes[1]] = arg1 4188 4189 funcbody(env) 4190 4191 env.freeEnv4Func() 4192 }) 4193 } 4194 } 4195 case r.Uintptr: 4196 { 4197 if funcbody == nil { 4198 funv := r.ValueOf(func(uint8, 4199 4200 uintptr) {}) 4201 ret = func(env *Env) r.Value { return funv } 4202 4203 break 4204 } 4205 ret = func(env *Env) r.Value { 4206 4207 env.MarkUsedByClosure() 4208 return r.ValueOf(func(arg0 uint8, 4209 4210 arg1 uintptr, 4211 4212 ) { 4213 env := newEnv4Func(env, nbind, nintbind, debugC) 4214 4215 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 4216 4217 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 4218 4219 funcbody(env) 4220 4221 env.freeEnv4Func() 4222 }) 4223 } 4224 } 4225 case r.Float32: 4226 { 4227 if funcbody == nil { 4228 funv := r.ValueOf(func(uint8, 4229 4230 float32) {}) 4231 ret = func(env *Env) r.Value { return funv } 4232 4233 break 4234 } 4235 ret = func(env *Env) r.Value { 4236 4237 env.MarkUsedByClosure() 4238 return r.ValueOf(func(arg0 uint8, 4239 4240 arg1 float32, 4241 4242 ) { 4243 env := newEnv4Func(env, nbind, nintbind, debugC) 4244 4245 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 4246 4247 *(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 4248 4249 funcbody(env) 4250 4251 env.freeEnv4Func() 4252 }) 4253 } 4254 } 4255 case r.Float64: 4256 { 4257 if funcbody == nil { 4258 funv := r.ValueOf(func(uint8, 4259 4260 float64) {}) 4261 ret = func(env *Env) r.Value { return funv } 4262 4263 break 4264 } 4265 ret = func(env *Env) r.Value { 4266 4267 env.MarkUsedByClosure() 4268 return r.ValueOf(func(arg0 uint8, 4269 4270 arg1 float64, 4271 4272 ) { 4273 env := newEnv4Func(env, nbind, nintbind, debugC) 4274 4275 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 4276 4277 *(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 4278 4279 funcbody(env) 4280 4281 env.freeEnv4Func() 4282 }) 4283 } 4284 } 4285 case r.Complex64: 4286 { 4287 if funcbody == nil { 4288 funv := r.ValueOf(func(uint8, 4289 4290 complex64) {}) 4291 ret = func(env *Env) r.Value { return funv } 4292 4293 break 4294 } 4295 ret = func(env *Env) r.Value { 4296 4297 env.MarkUsedByClosure() 4298 return r.ValueOf(func(arg0 uint8, 4299 4300 arg1 complex64, 4301 ) { 4302 env := newEnv4Func(env, nbind, nintbind, debugC) 4303 4304 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 4305 4306 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 4307 4308 funcbody(env) 4309 4310 env.freeEnv4Func() 4311 }) 4312 } 4313 } 4314 case r.Complex128: 4315 { 4316 if funcbody == nil { 4317 funv := r.ValueOf(func(uint8, 4318 4319 complex128) {}) 4320 ret = func(env *Env) r.Value { return funv } 4321 4322 break 4323 } 4324 ret = func(env *Env) r.Value { 4325 4326 env.MarkUsedByClosure() 4327 return r.ValueOf(func(arg0 uint8, 4328 4329 arg1 complex128) { 4330 env := newEnv4Func(env, nbind, nintbind, debugC) 4331 4332 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 4333 4334 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 4335 4336 funcbody(env) 4337 4338 env.freeEnv4Func() 4339 }) 4340 } 4341 } 4342 case r.String: 4343 { 4344 if funcbody == nil { 4345 funv := r.ValueOf(func(uint8, 4346 4347 string) {}) 4348 ret = func(env *Env) r.Value { return funv } 4349 4350 break 4351 } 4352 ret = func(env *Env) r.Value { 4353 4354 env.MarkUsedByClosure() 4355 return r.ValueOf(func(arg0 uint8, 4356 4357 arg1 string) { 4358 env := newEnv4Func(env, nbind, nintbind, debugC) 4359 4360 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 4361 4362 { 4363 place := r.New(TypeOfString).Elem() 4364 place.SetString(arg1, 4365 ) 4366 env.Vals[indexes[1]] = place 4367 } 4368 4369 funcbody(env) 4370 4371 env.freeEnv4Func() 4372 }) 4373 } 4374 } 4375 } 4376 return ret 4377} 4378func func2ret0Uint16(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value { 4379 4380 nbind := m.nbind 4381 nintbind := m.nintbind 4382 funcbody := m.funcbody 4383 var ret func(*Env) r.Value 4384 switch karg1 { 4385 case r.Bool: 4386 4387 { 4388 if funcbody == nil { 4389 funv := r.ValueOf(func(uint16, 4390 4391 bool, 4392 4393 ) {}) 4394 ret = func(env *Env) r.Value { return funv } 4395 4396 break 4397 } 4398 ret = func(env *Env) r.Value { 4399 4400 env.MarkUsedByClosure() 4401 return r.ValueOf(func(arg0 uint16, 4402 4403 arg1 bool, 4404 4405 ) { 4406 env := newEnv4Func(env, nbind, nintbind, debugC) 4407 4408 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 4409 4410 *(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 4411 4412 funcbody(env) 4413 4414 env.freeEnv4Func() 4415 }) 4416 } 4417 } 4418 case r.Int: 4419 4420 { 4421 if funcbody == nil { 4422 funv := r.ValueOf(func(uint16, 4423 4424 int, 4425 4426 ) {}) 4427 ret = func(env *Env) r.Value { return funv } 4428 4429 break 4430 } 4431 ret = func(env *Env) r.Value { 4432 4433 env.MarkUsedByClosure() 4434 return r.ValueOf(func(arg0 uint16, 4435 4436 arg1 int, 4437 4438 ) { 4439 env := newEnv4Func(env, nbind, nintbind, debugC) 4440 4441 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 4442 4443 *(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 4444 4445 funcbody(env) 4446 4447 env.freeEnv4Func() 4448 }) 4449 } 4450 } 4451 case r.Int8: 4452 4453 { 4454 if funcbody == nil { 4455 funv := r.ValueOf(func(uint16, 4456 4457 int8, 4458 4459 ) {}) 4460 ret = func(env *Env) r.Value { return funv } 4461 4462 break 4463 } 4464 ret = func(env *Env) r.Value { 4465 4466 env.MarkUsedByClosure() 4467 return r.ValueOf(func(arg0 uint16, 4468 4469 arg1 int8, 4470 4471 ) { 4472 env := newEnv4Func(env, nbind, nintbind, debugC) 4473 4474 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 4475 4476 *(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 4477 4478 funcbody(env) 4479 4480 env.freeEnv4Func() 4481 }) 4482 } 4483 } 4484 case r.Int16: 4485 { 4486 if funcbody == nil { 4487 funv := r.ValueOf(func(uint16, 4488 4489 int16, 4490 4491 ) {}) 4492 ret = func(env *Env) r.Value { return funv } 4493 4494 break 4495 } 4496 ret = func(env *Env) r.Value { 4497 4498 env.MarkUsedByClosure() 4499 return r.ValueOf(func(arg0 uint16, 4500 4501 arg1 int16, 4502 4503 ) { 4504 env := newEnv4Func(env, nbind, nintbind, debugC) 4505 4506 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 4507 4508 *(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 4509 4510 funcbody(env) 4511 4512 env.freeEnv4Func() 4513 }) 4514 } 4515 } 4516 case r.Int32: 4517 { 4518 if funcbody == nil { 4519 funv := r.ValueOf(func(uint16, 4520 4521 int32, 4522 4523 ) {}) 4524 ret = func(env *Env) r.Value { return funv } 4525 4526 break 4527 } 4528 ret = func(env *Env) r.Value { 4529 4530 env.MarkUsedByClosure() 4531 return r.ValueOf(func(arg0 uint16, 4532 4533 arg1 int32, 4534 4535 ) { 4536 env := newEnv4Func(env, nbind, nintbind, debugC) 4537 4538 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 4539 4540 *(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 4541 4542 funcbody(env) 4543 4544 env.freeEnv4Func() 4545 }) 4546 } 4547 } 4548 case r.Int64: 4549 { 4550 if funcbody == nil { 4551 funv := r.ValueOf(func(uint16, 4552 4553 int64, 4554 ) {}) 4555 ret = func(env *Env) r.Value { return funv } 4556 4557 break 4558 } 4559 ret = func(env *Env) r.Value { 4560 4561 env.MarkUsedByClosure() 4562 return r.ValueOf(func(arg0 uint16, 4563 4564 arg1 int64, 4565 4566 ) { 4567 env := newEnv4Func(env, nbind, nintbind, debugC) 4568 4569 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 4570 4571 *(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 4572 4573 funcbody(env) 4574 4575 env.freeEnv4Func() 4576 }) 4577 } 4578 } 4579 case r.Uint: 4580 { 4581 if funcbody == nil { 4582 funv := r.ValueOf(func(uint16, 4583 4584 uint) {}) 4585 ret = func(env *Env) r.Value { return funv } 4586 4587 break 4588 } 4589 ret = func(env *Env) r.Value { 4590 4591 env.MarkUsedByClosure() 4592 return r.ValueOf(func(arg0 uint16, 4593 4594 arg1 uint, 4595 4596 ) { 4597 env := newEnv4Func(env, nbind, nintbind, debugC) 4598 4599 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 4600 4601 *(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 4602 4603 funcbody(env) 4604 4605 env.freeEnv4Func() 4606 }) 4607 } 4608 } 4609 case r.Uint8: 4610 { 4611 if funcbody == nil { 4612 funv := r.ValueOf(func(uint16, 4613 4614 uint8) {}) 4615 ret = func(env *Env) r.Value { return funv } 4616 4617 break 4618 } 4619 ret = func(env *Env) r.Value { 4620 4621 env.MarkUsedByClosure() 4622 return r.ValueOf(func(arg0 uint16, 4623 4624 arg1 uint8, 4625 4626 ) { 4627 env := newEnv4Func(env, nbind, nintbind, debugC) 4628 4629 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 4630 4631 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 4632 4633 funcbody(env) 4634 4635 env.freeEnv4Func() 4636 }) 4637 } 4638 } 4639 case r.Uint16: 4640 { 4641 if funcbody == nil { 4642 funv := r.ValueOf(func(uint16, 4643 4644 uint16) {}) 4645 ret = func(env *Env) r.Value { return funv } 4646 4647 break 4648 } 4649 ret = func(env *Env) r.Value { 4650 4651 env.MarkUsedByClosure() 4652 return r.ValueOf(func(arg0 uint16, 4653 4654 arg1 uint16, 4655 4656 ) { 4657 env := newEnv4Func(env, nbind, nintbind, debugC) 4658 4659 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 4660 4661 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 4662 4663 funcbody(env) 4664 4665 env.freeEnv4Func() 4666 }) 4667 } 4668 } 4669 case r.Uint32: 4670 { 4671 if funcbody == nil { 4672 funv := r.ValueOf(func(uint16, 4673 4674 uint32) {}) 4675 ret = func(env *Env) r.Value { return funv } 4676 4677 break 4678 } 4679 ret = func(env *Env) r.Value { 4680 4681 env.MarkUsedByClosure() 4682 return r.ValueOf(func(arg0 uint16, 4683 4684 arg1 uint32, 4685 4686 ) { 4687 env := newEnv4Func(env, nbind, nintbind, debugC) 4688 4689 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 4690 4691 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 4692 4693 funcbody(env) 4694 4695 env.freeEnv4Func() 4696 }) 4697 } 4698 } 4699 case r.Uint64: 4700 { 4701 if funcbody == nil { 4702 funv := r.ValueOf(func(uint16, 4703 4704 uint64) {}) 4705 ret = func(env *Env) r.Value { return funv } 4706 4707 break 4708 } 4709 ret = func(env *Env) r.Value { 4710 4711 env.MarkUsedByClosure() 4712 return r.ValueOf(func(arg0 uint16, 4713 4714 arg1 uint64, 4715 4716 ) { 4717 env := newEnv4Func(env, nbind, nintbind, debugC) 4718 4719 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 4720 4721 env.Ints[indexes[1]] = arg1 4722 4723 funcbody(env) 4724 4725 env.freeEnv4Func() 4726 }) 4727 } 4728 } 4729 case r.Uintptr: 4730 { 4731 if funcbody == nil { 4732 funv := r.ValueOf(func(uint16, 4733 4734 uintptr) {}) 4735 ret = func(env *Env) r.Value { return funv } 4736 4737 break 4738 } 4739 ret = func(env *Env) r.Value { 4740 4741 env.MarkUsedByClosure() 4742 return r.ValueOf(func(arg0 uint16, 4743 4744 arg1 uintptr, 4745 4746 ) { 4747 env := newEnv4Func(env, nbind, nintbind, debugC) 4748 4749 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 4750 4751 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 4752 4753 funcbody(env) 4754 4755 env.freeEnv4Func() 4756 }) 4757 } 4758 } 4759 case r.Float32: 4760 { 4761 if funcbody == nil { 4762 funv := r.ValueOf(func(uint16, 4763 4764 float32) {}) 4765 ret = func(env *Env) r.Value { return funv } 4766 4767 break 4768 } 4769 ret = func(env *Env) r.Value { 4770 4771 env.MarkUsedByClosure() 4772 return r.ValueOf(func(arg0 uint16, 4773 4774 arg1 float32, 4775 4776 ) { 4777 env := newEnv4Func(env, nbind, nintbind, debugC) 4778 4779 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 4780 4781 *(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 4782 4783 funcbody(env) 4784 4785 env.freeEnv4Func() 4786 }) 4787 } 4788 } 4789 case r.Float64: 4790 { 4791 if funcbody == nil { 4792 funv := r.ValueOf(func(uint16, 4793 4794 float64) {}) 4795 ret = func(env *Env) r.Value { return funv } 4796 4797 break 4798 } 4799 ret = func(env *Env) r.Value { 4800 4801 env.MarkUsedByClosure() 4802 return r.ValueOf(func(arg0 uint16, 4803 4804 arg1 float64, 4805 4806 ) { 4807 env := newEnv4Func(env, nbind, nintbind, debugC) 4808 4809 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 4810 4811 *(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 4812 4813 funcbody(env) 4814 4815 env.freeEnv4Func() 4816 }) 4817 } 4818 } 4819 case r.Complex64: 4820 { 4821 if funcbody == nil { 4822 funv := r.ValueOf(func(uint16, 4823 4824 complex64) {}) 4825 ret = func(env *Env) r.Value { return funv } 4826 4827 break 4828 } 4829 ret = func(env *Env) r.Value { 4830 4831 env.MarkUsedByClosure() 4832 return r.ValueOf(func(arg0 uint16, 4833 4834 arg1 complex64, 4835 ) { 4836 env := newEnv4Func(env, nbind, nintbind, debugC) 4837 4838 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 4839 4840 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 4841 4842 funcbody(env) 4843 4844 env.freeEnv4Func() 4845 }) 4846 } 4847 } 4848 case r.Complex128: 4849 { 4850 if funcbody == nil { 4851 funv := r.ValueOf(func(uint16, 4852 4853 complex128) {}) 4854 ret = func(env *Env) r.Value { return funv } 4855 4856 break 4857 } 4858 ret = func(env *Env) r.Value { 4859 4860 env.MarkUsedByClosure() 4861 return r.ValueOf(func(arg0 uint16, 4862 4863 arg1 complex128) { 4864 env := newEnv4Func(env, nbind, nintbind, debugC) 4865 4866 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 4867 4868 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 4869 4870 funcbody(env) 4871 4872 env.freeEnv4Func() 4873 }) 4874 } 4875 } 4876 case r.String: 4877 { 4878 if funcbody == nil { 4879 funv := r.ValueOf(func(uint16, 4880 4881 string) {}) 4882 ret = func(env *Env) r.Value { return funv } 4883 4884 break 4885 } 4886 ret = func(env *Env) r.Value { 4887 4888 env.MarkUsedByClosure() 4889 return r.ValueOf(func(arg0 uint16, 4890 4891 arg1 string) { 4892 env := newEnv4Func(env, nbind, nintbind, debugC) 4893 4894 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 4895 4896 { 4897 place := r.New(TypeOfString).Elem() 4898 place.SetString(arg1, 4899 ) 4900 env.Vals[indexes[1]] = place 4901 } 4902 4903 funcbody(env) 4904 4905 env.freeEnv4Func() 4906 }) 4907 } 4908 } 4909 } 4910 return ret 4911} 4912func func2ret0Uint32(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value { 4913 4914 nbind := m.nbind 4915 nintbind := m.nintbind 4916 funcbody := m.funcbody 4917 var ret func(*Env) r.Value 4918 switch karg1 { 4919 case r.Bool: 4920 4921 { 4922 if funcbody == nil { 4923 funv := r.ValueOf(func(uint32, 4924 4925 bool, 4926 4927 ) {}) 4928 ret = func(env *Env) r.Value { return funv } 4929 4930 break 4931 } 4932 ret = func(env *Env) r.Value { 4933 4934 env.MarkUsedByClosure() 4935 return r.ValueOf(func(arg0 uint32, 4936 4937 arg1 bool, 4938 4939 ) { 4940 env := newEnv4Func(env, nbind, nintbind, debugC) 4941 4942 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 4943 4944 *(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 4945 4946 funcbody(env) 4947 4948 env.freeEnv4Func() 4949 }) 4950 } 4951 } 4952 case r.Int: 4953 4954 { 4955 if funcbody == nil { 4956 funv := r.ValueOf(func(uint32, 4957 4958 int, 4959 4960 ) {}) 4961 ret = func(env *Env) r.Value { return funv } 4962 4963 break 4964 } 4965 ret = func(env *Env) r.Value { 4966 4967 env.MarkUsedByClosure() 4968 return r.ValueOf(func(arg0 uint32, 4969 4970 arg1 int, 4971 4972 ) { 4973 env := newEnv4Func(env, nbind, nintbind, debugC) 4974 4975 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 4976 4977 *(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 4978 4979 funcbody(env) 4980 4981 env.freeEnv4Func() 4982 }) 4983 } 4984 } 4985 case r.Int8: 4986 4987 { 4988 if funcbody == nil { 4989 funv := r.ValueOf(func(uint32, 4990 4991 int8, 4992 4993 ) {}) 4994 ret = func(env *Env) r.Value { return funv } 4995 4996 break 4997 } 4998 ret = func(env *Env) r.Value { 4999 5000 env.MarkUsedByClosure() 5001 return r.ValueOf(func(arg0 uint32, 5002 5003 arg1 int8, 5004 5005 ) { 5006 env := newEnv4Func(env, nbind, nintbind, debugC) 5007 5008 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 5009 5010 *(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 5011 5012 funcbody(env) 5013 5014 env.freeEnv4Func() 5015 }) 5016 } 5017 } 5018 case r.Int16: 5019 { 5020 if funcbody == nil { 5021 funv := r.ValueOf(func(uint32, 5022 5023 int16, 5024 5025 ) {}) 5026 ret = func(env *Env) r.Value { return funv } 5027 5028 break 5029 } 5030 ret = func(env *Env) r.Value { 5031 5032 env.MarkUsedByClosure() 5033 return r.ValueOf(func(arg0 uint32, 5034 5035 arg1 int16, 5036 5037 ) { 5038 env := newEnv4Func(env, nbind, nintbind, debugC) 5039 5040 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 5041 5042 *(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 5043 5044 funcbody(env) 5045 5046 env.freeEnv4Func() 5047 }) 5048 } 5049 } 5050 case r.Int32: 5051 { 5052 if funcbody == nil { 5053 funv := r.ValueOf(func(uint32, 5054 5055 int32, 5056 5057 ) {}) 5058 ret = func(env *Env) r.Value { return funv } 5059 5060 break 5061 } 5062 ret = func(env *Env) r.Value { 5063 5064 env.MarkUsedByClosure() 5065 return r.ValueOf(func(arg0 uint32, 5066 5067 arg1 int32, 5068 5069 ) { 5070 env := newEnv4Func(env, nbind, nintbind, debugC) 5071 5072 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 5073 5074 *(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 5075 5076 funcbody(env) 5077 5078 env.freeEnv4Func() 5079 }) 5080 } 5081 } 5082 case r.Int64: 5083 { 5084 if funcbody == nil { 5085 funv := r.ValueOf(func(uint32, 5086 5087 int64, 5088 ) {}) 5089 ret = func(env *Env) r.Value { return funv } 5090 5091 break 5092 } 5093 ret = func(env *Env) r.Value { 5094 5095 env.MarkUsedByClosure() 5096 return r.ValueOf(func(arg0 uint32, 5097 5098 arg1 int64, 5099 5100 ) { 5101 env := newEnv4Func(env, nbind, nintbind, debugC) 5102 5103 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 5104 5105 *(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 5106 5107 funcbody(env) 5108 5109 env.freeEnv4Func() 5110 }) 5111 } 5112 } 5113 case r.Uint: 5114 { 5115 if funcbody == nil { 5116 funv := r.ValueOf(func(uint32, 5117 5118 uint) {}) 5119 ret = func(env *Env) r.Value { return funv } 5120 5121 break 5122 } 5123 ret = func(env *Env) r.Value { 5124 5125 env.MarkUsedByClosure() 5126 return r.ValueOf(func(arg0 uint32, 5127 5128 arg1 uint, 5129 5130 ) { 5131 env := newEnv4Func(env, nbind, nintbind, debugC) 5132 5133 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 5134 5135 *(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 5136 5137 funcbody(env) 5138 5139 env.freeEnv4Func() 5140 }) 5141 } 5142 } 5143 case r.Uint8: 5144 { 5145 if funcbody == nil { 5146 funv := r.ValueOf(func(uint32, 5147 5148 uint8) {}) 5149 ret = func(env *Env) r.Value { return funv } 5150 5151 break 5152 } 5153 ret = func(env *Env) r.Value { 5154 5155 env.MarkUsedByClosure() 5156 return r.ValueOf(func(arg0 uint32, 5157 5158 arg1 uint8, 5159 5160 ) { 5161 env := newEnv4Func(env, nbind, nintbind, debugC) 5162 5163 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 5164 5165 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 5166 5167 funcbody(env) 5168 5169 env.freeEnv4Func() 5170 }) 5171 } 5172 } 5173 case r.Uint16: 5174 { 5175 if funcbody == nil { 5176 funv := r.ValueOf(func(uint32, 5177 5178 uint16) {}) 5179 ret = func(env *Env) r.Value { return funv } 5180 5181 break 5182 } 5183 ret = func(env *Env) r.Value { 5184 5185 env.MarkUsedByClosure() 5186 return r.ValueOf(func(arg0 uint32, 5187 5188 arg1 uint16, 5189 5190 ) { 5191 env := newEnv4Func(env, nbind, nintbind, debugC) 5192 5193 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 5194 5195 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 5196 5197 funcbody(env) 5198 5199 env.freeEnv4Func() 5200 }) 5201 } 5202 } 5203 case r.Uint32: 5204 { 5205 if funcbody == nil { 5206 funv := r.ValueOf(func(uint32, 5207 5208 uint32) {}) 5209 ret = func(env *Env) r.Value { return funv } 5210 5211 break 5212 } 5213 ret = func(env *Env) r.Value { 5214 5215 env.MarkUsedByClosure() 5216 return r.ValueOf(func(arg0 uint32, 5217 5218 arg1 uint32, 5219 5220 ) { 5221 env := newEnv4Func(env, nbind, nintbind, debugC) 5222 5223 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 5224 5225 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 5226 5227 funcbody(env) 5228 5229 env.freeEnv4Func() 5230 }) 5231 } 5232 } 5233 case r.Uint64: 5234 { 5235 if funcbody == nil { 5236 funv := r.ValueOf(func(uint32, 5237 5238 uint64) {}) 5239 ret = func(env *Env) r.Value { return funv } 5240 5241 break 5242 } 5243 ret = func(env *Env) r.Value { 5244 5245 env.MarkUsedByClosure() 5246 return r.ValueOf(func(arg0 uint32, 5247 5248 arg1 uint64, 5249 5250 ) { 5251 env := newEnv4Func(env, nbind, nintbind, debugC) 5252 5253 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 5254 5255 env.Ints[indexes[1]] = arg1 5256 5257 funcbody(env) 5258 5259 env.freeEnv4Func() 5260 }) 5261 } 5262 } 5263 case r.Uintptr: 5264 { 5265 if funcbody == nil { 5266 funv := r.ValueOf(func(uint32, 5267 5268 uintptr) {}) 5269 ret = func(env *Env) r.Value { return funv } 5270 5271 break 5272 } 5273 ret = func(env *Env) r.Value { 5274 5275 env.MarkUsedByClosure() 5276 return r.ValueOf(func(arg0 uint32, 5277 5278 arg1 uintptr, 5279 5280 ) { 5281 env := newEnv4Func(env, nbind, nintbind, debugC) 5282 5283 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 5284 5285 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 5286 5287 funcbody(env) 5288 5289 env.freeEnv4Func() 5290 }) 5291 } 5292 } 5293 case r.Float32: 5294 { 5295 if funcbody == nil { 5296 funv := r.ValueOf(func(uint32, 5297 5298 float32) {}) 5299 ret = func(env *Env) r.Value { return funv } 5300 5301 break 5302 } 5303 ret = func(env *Env) r.Value { 5304 5305 env.MarkUsedByClosure() 5306 return r.ValueOf(func(arg0 uint32, 5307 5308 arg1 float32, 5309 5310 ) { 5311 env := newEnv4Func(env, nbind, nintbind, debugC) 5312 5313 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 5314 5315 *(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 5316 5317 funcbody(env) 5318 5319 env.freeEnv4Func() 5320 }) 5321 } 5322 } 5323 case r.Float64: 5324 { 5325 if funcbody == nil { 5326 funv := r.ValueOf(func(uint32, 5327 5328 float64) {}) 5329 ret = func(env *Env) r.Value { return funv } 5330 5331 break 5332 } 5333 ret = func(env *Env) r.Value { 5334 5335 env.MarkUsedByClosure() 5336 return r.ValueOf(func(arg0 uint32, 5337 5338 arg1 float64, 5339 5340 ) { 5341 env := newEnv4Func(env, nbind, nintbind, debugC) 5342 5343 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 5344 5345 *(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 5346 5347 funcbody(env) 5348 5349 env.freeEnv4Func() 5350 }) 5351 } 5352 } 5353 case r.Complex64: 5354 { 5355 if funcbody == nil { 5356 funv := r.ValueOf(func(uint32, 5357 5358 complex64) {}) 5359 ret = func(env *Env) r.Value { return funv } 5360 5361 break 5362 } 5363 ret = func(env *Env) r.Value { 5364 5365 env.MarkUsedByClosure() 5366 return r.ValueOf(func(arg0 uint32, 5367 5368 arg1 complex64, 5369 ) { 5370 env := newEnv4Func(env, nbind, nintbind, debugC) 5371 5372 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 5373 5374 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 5375 5376 funcbody(env) 5377 5378 env.freeEnv4Func() 5379 }) 5380 } 5381 } 5382 case r.Complex128: 5383 { 5384 if funcbody == nil { 5385 funv := r.ValueOf(func(uint32, 5386 5387 complex128) {}) 5388 ret = func(env *Env) r.Value { return funv } 5389 5390 break 5391 } 5392 ret = func(env *Env) r.Value { 5393 5394 env.MarkUsedByClosure() 5395 return r.ValueOf(func(arg0 uint32, 5396 5397 arg1 complex128) { 5398 env := newEnv4Func(env, nbind, nintbind, debugC) 5399 5400 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 5401 5402 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 5403 5404 funcbody(env) 5405 5406 env.freeEnv4Func() 5407 }) 5408 } 5409 } 5410 case r.String: 5411 { 5412 if funcbody == nil { 5413 funv := r.ValueOf(func(uint32, 5414 5415 string) {}) 5416 ret = func(env *Env) r.Value { return funv } 5417 5418 break 5419 } 5420 ret = func(env *Env) r.Value { 5421 5422 env.MarkUsedByClosure() 5423 return r.ValueOf(func(arg0 uint32, 5424 5425 arg1 string) { 5426 env := newEnv4Func(env, nbind, nintbind, debugC) 5427 5428 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 5429 5430 { 5431 place := r.New(TypeOfString).Elem() 5432 place.SetString(arg1, 5433 ) 5434 env.Vals[indexes[1]] = place 5435 } 5436 5437 funcbody(env) 5438 5439 env.freeEnv4Func() 5440 }) 5441 } 5442 } 5443 } 5444 return ret 5445} 5446func func2ret0Uint64(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value { 5447 5448 nbind := m.nbind 5449 nintbind := m.nintbind 5450 funcbody := m.funcbody 5451 var ret func(*Env) r.Value 5452 switch karg1 { 5453 case r.Bool: 5454 5455 { 5456 if funcbody == nil { 5457 funv := r.ValueOf(func(uint64, 5458 5459 bool, 5460 5461 ) {}) 5462 ret = func(env *Env) r.Value { return funv } 5463 5464 break 5465 } 5466 ret = func(env *Env) r.Value { 5467 5468 env.MarkUsedByClosure() 5469 return r.ValueOf(func(arg0 uint64, 5470 5471 arg1 bool, 5472 5473 ) { 5474 env := newEnv4Func(env, nbind, nintbind, debugC) 5475 env.Ints[indexes[0]] = arg0 5476 5477 *(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 5478 5479 funcbody(env) 5480 5481 env.freeEnv4Func() 5482 }) 5483 } 5484 } 5485 case r.Int: 5486 5487 { 5488 if funcbody == nil { 5489 funv := r.ValueOf(func(uint64, 5490 5491 int, 5492 5493 ) {}) 5494 ret = func(env *Env) r.Value { return funv } 5495 5496 break 5497 } 5498 ret = func(env *Env) r.Value { 5499 5500 env.MarkUsedByClosure() 5501 return r.ValueOf(func(arg0 uint64, 5502 5503 arg1 int, 5504 5505 ) { 5506 env := newEnv4Func(env, nbind, nintbind, debugC) 5507 env.Ints[indexes[0]] = arg0 5508 5509 *(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 5510 5511 funcbody(env) 5512 5513 env.freeEnv4Func() 5514 }) 5515 } 5516 } 5517 case r.Int8: 5518 5519 { 5520 if funcbody == nil { 5521 funv := r.ValueOf(func(uint64, 5522 5523 int8, 5524 5525 ) {}) 5526 ret = func(env *Env) r.Value { return funv } 5527 5528 break 5529 } 5530 ret = func(env *Env) r.Value { 5531 5532 env.MarkUsedByClosure() 5533 return r.ValueOf(func(arg0 uint64, 5534 5535 arg1 int8, 5536 5537 ) { 5538 env := newEnv4Func(env, nbind, nintbind, debugC) 5539 env.Ints[indexes[0]] = arg0 5540 5541 *(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 5542 5543 funcbody(env) 5544 5545 env.freeEnv4Func() 5546 }) 5547 } 5548 } 5549 case r.Int16: 5550 { 5551 if funcbody == nil { 5552 funv := r.ValueOf(func(uint64, 5553 5554 int16, 5555 5556 ) {}) 5557 ret = func(env *Env) r.Value { return funv } 5558 5559 break 5560 } 5561 ret = func(env *Env) r.Value { 5562 5563 env.MarkUsedByClosure() 5564 return r.ValueOf(func(arg0 uint64, 5565 5566 arg1 int16, 5567 5568 ) { 5569 env := newEnv4Func(env, nbind, nintbind, debugC) 5570 env.Ints[indexes[0]] = arg0 5571 5572 *(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 5573 5574 funcbody(env) 5575 5576 env.freeEnv4Func() 5577 }) 5578 } 5579 } 5580 case r.Int32: 5581 { 5582 if funcbody == nil { 5583 funv := r.ValueOf(func(uint64, 5584 5585 int32, 5586 5587 ) {}) 5588 ret = func(env *Env) r.Value { return funv } 5589 5590 break 5591 } 5592 ret = func(env *Env) r.Value { 5593 5594 env.MarkUsedByClosure() 5595 return r.ValueOf(func(arg0 uint64, 5596 5597 arg1 int32, 5598 5599 ) { 5600 env := newEnv4Func(env, nbind, nintbind, debugC) 5601 env.Ints[indexes[0]] = arg0 5602 5603 *(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 5604 5605 funcbody(env) 5606 5607 env.freeEnv4Func() 5608 }) 5609 } 5610 } 5611 case r.Int64: 5612 { 5613 if funcbody == nil { 5614 funv := r.ValueOf(func(uint64, 5615 5616 int64, 5617 ) {}) 5618 ret = func(env *Env) r.Value { return funv } 5619 5620 break 5621 } 5622 ret = func(env *Env) r.Value { 5623 5624 env.MarkUsedByClosure() 5625 return r.ValueOf(func(arg0 uint64, 5626 5627 arg1 int64, 5628 5629 ) { 5630 env := newEnv4Func(env, nbind, nintbind, debugC) 5631 env.Ints[indexes[0]] = arg0 5632 5633 *(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 5634 5635 funcbody(env) 5636 5637 env.freeEnv4Func() 5638 }) 5639 } 5640 } 5641 case r.Uint: 5642 { 5643 if funcbody == nil { 5644 funv := r.ValueOf(func(uint64, 5645 5646 uint) {}) 5647 ret = func(env *Env) r.Value { return funv } 5648 5649 break 5650 } 5651 ret = func(env *Env) r.Value { 5652 5653 env.MarkUsedByClosure() 5654 return r.ValueOf(func(arg0 uint64, 5655 5656 arg1 uint, 5657 5658 ) { 5659 env := newEnv4Func(env, nbind, nintbind, debugC) 5660 env.Ints[indexes[0]] = arg0 5661 5662 *(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 5663 5664 funcbody(env) 5665 5666 env.freeEnv4Func() 5667 }) 5668 } 5669 } 5670 case r.Uint8: 5671 { 5672 if funcbody == nil { 5673 funv := r.ValueOf(func(uint64, 5674 5675 uint8) {}) 5676 ret = func(env *Env) r.Value { return funv } 5677 5678 break 5679 } 5680 ret = func(env *Env) r.Value { 5681 5682 env.MarkUsedByClosure() 5683 return r.ValueOf(func(arg0 uint64, 5684 5685 arg1 uint8, 5686 5687 ) { 5688 env := newEnv4Func(env, nbind, nintbind, debugC) 5689 env.Ints[indexes[0]] = arg0 5690 5691 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 5692 5693 funcbody(env) 5694 5695 env.freeEnv4Func() 5696 }) 5697 } 5698 } 5699 case r.Uint16: 5700 { 5701 if funcbody == nil { 5702 funv := r.ValueOf(func(uint64, 5703 5704 uint16) {}) 5705 ret = func(env *Env) r.Value { return funv } 5706 5707 break 5708 } 5709 ret = func(env *Env) r.Value { 5710 5711 env.MarkUsedByClosure() 5712 return r.ValueOf(func(arg0 uint64, 5713 5714 arg1 uint16, 5715 5716 ) { 5717 env := newEnv4Func(env, nbind, nintbind, debugC) 5718 env.Ints[indexes[0]] = arg0 5719 5720 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 5721 5722 funcbody(env) 5723 5724 env.freeEnv4Func() 5725 }) 5726 } 5727 } 5728 case r.Uint32: 5729 { 5730 if funcbody == nil { 5731 funv := r.ValueOf(func(uint64, 5732 5733 uint32) {}) 5734 ret = func(env *Env) r.Value { return funv } 5735 5736 break 5737 } 5738 ret = func(env *Env) r.Value { 5739 5740 env.MarkUsedByClosure() 5741 return r.ValueOf(func(arg0 uint64, 5742 5743 arg1 uint32, 5744 5745 ) { 5746 env := newEnv4Func(env, nbind, nintbind, debugC) 5747 env.Ints[indexes[0]] = arg0 5748 5749 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 5750 5751 funcbody(env) 5752 5753 env.freeEnv4Func() 5754 }) 5755 } 5756 } 5757 case r.Uint64: 5758 { 5759 if funcbody == nil { 5760 funv := r.ValueOf(func(uint64, 5761 5762 uint64) {}) 5763 ret = func(env *Env) r.Value { return funv } 5764 5765 break 5766 } 5767 ret = func(env *Env) r.Value { 5768 5769 env.MarkUsedByClosure() 5770 return r.ValueOf(func(arg0 uint64, 5771 5772 arg1 uint64, 5773 5774 ) { 5775 env := newEnv4Func(env, nbind, nintbind, debugC) 5776 env.Ints[indexes[0]] = arg0 5777 5778 env.Ints[indexes[1]] = arg1 5779 5780 funcbody(env) 5781 5782 env.freeEnv4Func() 5783 }) 5784 } 5785 } 5786 case r.Uintptr: 5787 { 5788 if funcbody == nil { 5789 funv := r.ValueOf(func(uint64, 5790 5791 uintptr) {}) 5792 ret = func(env *Env) r.Value { return funv } 5793 5794 break 5795 } 5796 ret = func(env *Env) r.Value { 5797 5798 env.MarkUsedByClosure() 5799 return r.ValueOf(func(arg0 uint64, 5800 5801 arg1 uintptr, 5802 5803 ) { 5804 env := newEnv4Func(env, nbind, nintbind, debugC) 5805 env.Ints[indexes[0]] = arg0 5806 5807 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 5808 5809 funcbody(env) 5810 5811 env.freeEnv4Func() 5812 }) 5813 } 5814 } 5815 case r.Float32: 5816 { 5817 if funcbody == nil { 5818 funv := r.ValueOf(func(uint64, 5819 5820 float32) {}) 5821 ret = func(env *Env) r.Value { return funv } 5822 5823 break 5824 } 5825 ret = func(env *Env) r.Value { 5826 5827 env.MarkUsedByClosure() 5828 return r.ValueOf(func(arg0 uint64, 5829 5830 arg1 float32, 5831 5832 ) { 5833 env := newEnv4Func(env, nbind, nintbind, debugC) 5834 env.Ints[indexes[0]] = arg0 5835 5836 *(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 5837 5838 funcbody(env) 5839 5840 env.freeEnv4Func() 5841 }) 5842 } 5843 } 5844 case r.Float64: 5845 { 5846 if funcbody == nil { 5847 funv := r.ValueOf(func(uint64, 5848 5849 float64) {}) 5850 ret = func(env *Env) r.Value { return funv } 5851 5852 break 5853 } 5854 ret = func(env *Env) r.Value { 5855 5856 env.MarkUsedByClosure() 5857 return r.ValueOf(func(arg0 uint64, 5858 5859 arg1 float64, 5860 5861 ) { 5862 env := newEnv4Func(env, nbind, nintbind, debugC) 5863 env.Ints[indexes[0]] = arg0 5864 5865 *(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 5866 5867 funcbody(env) 5868 5869 env.freeEnv4Func() 5870 }) 5871 } 5872 } 5873 case r.Complex64: 5874 { 5875 if funcbody == nil { 5876 funv := r.ValueOf(func(uint64, 5877 5878 complex64) {}) 5879 ret = func(env *Env) r.Value { return funv } 5880 5881 break 5882 } 5883 ret = func(env *Env) r.Value { 5884 5885 env.MarkUsedByClosure() 5886 return r.ValueOf(func(arg0 uint64, 5887 5888 arg1 complex64, 5889 ) { 5890 env := newEnv4Func(env, nbind, nintbind, debugC) 5891 env.Ints[indexes[0]] = arg0 5892 5893 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 5894 5895 funcbody(env) 5896 5897 env.freeEnv4Func() 5898 }) 5899 } 5900 } 5901 case r.Complex128: 5902 { 5903 if funcbody == nil { 5904 funv := r.ValueOf(func(uint64, 5905 5906 complex128) {}) 5907 ret = func(env *Env) r.Value { return funv } 5908 5909 break 5910 } 5911 ret = func(env *Env) r.Value { 5912 5913 env.MarkUsedByClosure() 5914 return r.ValueOf(func(arg0 uint64, 5915 5916 arg1 complex128) { 5917 env := newEnv4Func(env, nbind, nintbind, debugC) 5918 env.Ints[indexes[0]] = arg0 5919 5920 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 5921 5922 funcbody(env) 5923 5924 env.freeEnv4Func() 5925 }) 5926 } 5927 } 5928 case r.String: 5929 { 5930 if funcbody == nil { 5931 funv := r.ValueOf(func(uint64, 5932 5933 string) {}) 5934 ret = func(env *Env) r.Value { return funv } 5935 5936 break 5937 } 5938 ret = func(env *Env) r.Value { 5939 5940 env.MarkUsedByClosure() 5941 return r.ValueOf(func(arg0 uint64, 5942 5943 arg1 string) { 5944 env := newEnv4Func(env, nbind, nintbind, debugC) 5945 env.Ints[indexes[0]] = arg0 5946 5947 { 5948 place := r.New(TypeOfString).Elem() 5949 place.SetString(arg1, 5950 ) 5951 env.Vals[indexes[1]] = place 5952 } 5953 5954 funcbody(env) 5955 5956 env.freeEnv4Func() 5957 }) 5958 } 5959 } 5960 } 5961 return ret 5962} 5963func func2ret0Uintptr(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value { 5964 5965 nbind := m.nbind 5966 nintbind := m.nintbind 5967 funcbody := m.funcbody 5968 var ret func(*Env) r.Value 5969 switch karg1 { 5970 case r.Bool: 5971 5972 { 5973 if funcbody == nil { 5974 funv := r.ValueOf(func(uintptr, 5975 5976 bool, 5977 5978 ) {}) 5979 ret = func(env *Env) r.Value { return funv } 5980 5981 break 5982 } 5983 ret = func(env *Env) r.Value { 5984 5985 env.MarkUsedByClosure() 5986 return r.ValueOf(func(arg0 uintptr, 5987 5988 arg1 bool, 5989 5990 ) { 5991 env := newEnv4Func(env, nbind, nintbind, debugC) 5992 5993 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 5994 5995 *(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 5996 5997 funcbody(env) 5998 5999 env.freeEnv4Func() 6000 }) 6001 } 6002 } 6003 case r.Int: 6004 6005 { 6006 if funcbody == nil { 6007 funv := r.ValueOf(func(uintptr, 6008 6009 int, 6010 6011 ) {}) 6012 ret = func(env *Env) r.Value { return funv } 6013 6014 break 6015 } 6016 ret = func(env *Env) r.Value { 6017 6018 env.MarkUsedByClosure() 6019 return r.ValueOf(func(arg0 uintptr, 6020 6021 arg1 int, 6022 6023 ) { 6024 env := newEnv4Func(env, nbind, nintbind, debugC) 6025 6026 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 6027 6028 *(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 6029 6030 funcbody(env) 6031 6032 env.freeEnv4Func() 6033 }) 6034 } 6035 } 6036 case r.Int8: 6037 6038 { 6039 if funcbody == nil { 6040 funv := r.ValueOf(func(uintptr, 6041 6042 int8, 6043 6044 ) {}) 6045 ret = func(env *Env) r.Value { return funv } 6046 6047 break 6048 } 6049 ret = func(env *Env) r.Value { 6050 6051 env.MarkUsedByClosure() 6052 return r.ValueOf(func(arg0 uintptr, 6053 6054 arg1 int8, 6055 6056 ) { 6057 env := newEnv4Func(env, nbind, nintbind, debugC) 6058 6059 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 6060 6061 *(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 6062 6063 funcbody(env) 6064 6065 env.freeEnv4Func() 6066 }) 6067 } 6068 } 6069 case r.Int16: 6070 { 6071 if funcbody == nil { 6072 funv := r.ValueOf(func(uintptr, 6073 6074 int16, 6075 6076 ) {}) 6077 ret = func(env *Env) r.Value { return funv } 6078 6079 break 6080 } 6081 ret = func(env *Env) r.Value { 6082 6083 env.MarkUsedByClosure() 6084 return r.ValueOf(func(arg0 uintptr, 6085 6086 arg1 int16, 6087 6088 ) { 6089 env := newEnv4Func(env, nbind, nintbind, debugC) 6090 6091 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 6092 6093 *(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 6094 6095 funcbody(env) 6096 6097 env.freeEnv4Func() 6098 }) 6099 } 6100 } 6101 case r.Int32: 6102 { 6103 if funcbody == nil { 6104 funv := r.ValueOf(func(uintptr, 6105 6106 int32, 6107 6108 ) {}) 6109 ret = func(env *Env) r.Value { return funv } 6110 6111 break 6112 } 6113 ret = func(env *Env) r.Value { 6114 6115 env.MarkUsedByClosure() 6116 return r.ValueOf(func(arg0 uintptr, 6117 6118 arg1 int32, 6119 6120 ) { 6121 env := newEnv4Func(env, nbind, nintbind, debugC) 6122 6123 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 6124 6125 *(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 6126 6127 funcbody(env) 6128 6129 env.freeEnv4Func() 6130 }) 6131 } 6132 } 6133 case r.Int64: 6134 { 6135 if funcbody == nil { 6136 funv := r.ValueOf(func(uintptr, 6137 6138 int64, 6139 ) {}) 6140 ret = func(env *Env) r.Value { return funv } 6141 6142 break 6143 } 6144 ret = func(env *Env) r.Value { 6145 6146 env.MarkUsedByClosure() 6147 return r.ValueOf(func(arg0 uintptr, 6148 6149 arg1 int64, 6150 6151 ) { 6152 env := newEnv4Func(env, nbind, nintbind, debugC) 6153 6154 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 6155 6156 *(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 6157 6158 funcbody(env) 6159 6160 env.freeEnv4Func() 6161 }) 6162 } 6163 } 6164 case r.Uint: 6165 { 6166 if funcbody == nil { 6167 funv := r.ValueOf(func(uintptr, 6168 6169 uint) {}) 6170 ret = func(env *Env) r.Value { return funv } 6171 6172 break 6173 } 6174 ret = func(env *Env) r.Value { 6175 6176 env.MarkUsedByClosure() 6177 return r.ValueOf(func(arg0 uintptr, 6178 6179 arg1 uint, 6180 6181 ) { 6182 env := newEnv4Func(env, nbind, nintbind, debugC) 6183 6184 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 6185 6186 *(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 6187 6188 funcbody(env) 6189 6190 env.freeEnv4Func() 6191 }) 6192 } 6193 } 6194 case r.Uint8: 6195 { 6196 if funcbody == nil { 6197 funv := r.ValueOf(func(uintptr, 6198 6199 uint8) {}) 6200 ret = func(env *Env) r.Value { return funv } 6201 6202 break 6203 } 6204 ret = func(env *Env) r.Value { 6205 6206 env.MarkUsedByClosure() 6207 return r.ValueOf(func(arg0 uintptr, 6208 6209 arg1 uint8, 6210 6211 ) { 6212 env := newEnv4Func(env, nbind, nintbind, debugC) 6213 6214 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 6215 6216 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 6217 6218 funcbody(env) 6219 6220 env.freeEnv4Func() 6221 }) 6222 } 6223 } 6224 case r.Uint16: 6225 { 6226 if funcbody == nil { 6227 funv := r.ValueOf(func(uintptr, 6228 6229 uint16) {}) 6230 ret = func(env *Env) r.Value { return funv } 6231 6232 break 6233 } 6234 ret = func(env *Env) r.Value { 6235 6236 env.MarkUsedByClosure() 6237 return r.ValueOf(func(arg0 uintptr, 6238 6239 arg1 uint16, 6240 6241 ) { 6242 env := newEnv4Func(env, nbind, nintbind, debugC) 6243 6244 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 6245 6246 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 6247 6248 funcbody(env) 6249 6250 env.freeEnv4Func() 6251 }) 6252 } 6253 } 6254 case r.Uint32: 6255 { 6256 if funcbody == nil { 6257 funv := r.ValueOf(func(uintptr, 6258 6259 uint32) {}) 6260 ret = func(env *Env) r.Value { return funv } 6261 6262 break 6263 } 6264 ret = func(env *Env) r.Value { 6265 6266 env.MarkUsedByClosure() 6267 return r.ValueOf(func(arg0 uintptr, 6268 6269 arg1 uint32, 6270 6271 ) { 6272 env := newEnv4Func(env, nbind, nintbind, debugC) 6273 6274 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 6275 6276 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 6277 6278 funcbody(env) 6279 6280 env.freeEnv4Func() 6281 }) 6282 } 6283 } 6284 case r.Uint64: 6285 { 6286 if funcbody == nil { 6287 funv := r.ValueOf(func(uintptr, 6288 6289 uint64) {}) 6290 ret = func(env *Env) r.Value { return funv } 6291 6292 break 6293 } 6294 ret = func(env *Env) r.Value { 6295 6296 env.MarkUsedByClosure() 6297 return r.ValueOf(func(arg0 uintptr, 6298 6299 arg1 uint64, 6300 6301 ) { 6302 env := newEnv4Func(env, nbind, nintbind, debugC) 6303 6304 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 6305 6306 env.Ints[indexes[1]] = arg1 6307 6308 funcbody(env) 6309 6310 env.freeEnv4Func() 6311 }) 6312 } 6313 } 6314 case r.Uintptr: 6315 { 6316 if funcbody == nil { 6317 funv := r.ValueOf(func(uintptr, 6318 6319 uintptr) {}) 6320 ret = func(env *Env) r.Value { return funv } 6321 6322 break 6323 } 6324 ret = func(env *Env) r.Value { 6325 6326 env.MarkUsedByClosure() 6327 return r.ValueOf(func(arg0 uintptr, 6328 6329 arg1 uintptr, 6330 6331 ) { 6332 env := newEnv4Func(env, nbind, nintbind, debugC) 6333 6334 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 6335 6336 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 6337 6338 funcbody(env) 6339 6340 env.freeEnv4Func() 6341 }) 6342 } 6343 } 6344 case r.Float32: 6345 { 6346 if funcbody == nil { 6347 funv := r.ValueOf(func(uintptr, 6348 6349 float32) {}) 6350 ret = func(env *Env) r.Value { return funv } 6351 6352 break 6353 } 6354 ret = func(env *Env) r.Value { 6355 6356 env.MarkUsedByClosure() 6357 return r.ValueOf(func(arg0 uintptr, 6358 6359 arg1 float32, 6360 6361 ) { 6362 env := newEnv4Func(env, nbind, nintbind, debugC) 6363 6364 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 6365 6366 *(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 6367 6368 funcbody(env) 6369 6370 env.freeEnv4Func() 6371 }) 6372 } 6373 } 6374 case r.Float64: 6375 { 6376 if funcbody == nil { 6377 funv := r.ValueOf(func(uintptr, 6378 6379 float64) {}) 6380 ret = func(env *Env) r.Value { return funv } 6381 6382 break 6383 } 6384 ret = func(env *Env) r.Value { 6385 6386 env.MarkUsedByClosure() 6387 return r.ValueOf(func(arg0 uintptr, 6388 6389 arg1 float64, 6390 6391 ) { 6392 env := newEnv4Func(env, nbind, nintbind, debugC) 6393 6394 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 6395 6396 *(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 6397 6398 funcbody(env) 6399 6400 env.freeEnv4Func() 6401 }) 6402 } 6403 } 6404 case r.Complex64: 6405 { 6406 if funcbody == nil { 6407 funv := r.ValueOf(func(uintptr, 6408 6409 complex64) {}) 6410 ret = func(env *Env) r.Value { return funv } 6411 6412 break 6413 } 6414 ret = func(env *Env) r.Value { 6415 6416 env.MarkUsedByClosure() 6417 return r.ValueOf(func(arg0 uintptr, 6418 6419 arg1 complex64, 6420 ) { 6421 env := newEnv4Func(env, nbind, nintbind, debugC) 6422 6423 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 6424 6425 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 6426 6427 funcbody(env) 6428 6429 env.freeEnv4Func() 6430 }) 6431 } 6432 } 6433 case r.Complex128: 6434 { 6435 if funcbody == nil { 6436 funv := r.ValueOf(func(uintptr, 6437 6438 complex128) {}) 6439 ret = func(env *Env) r.Value { return funv } 6440 6441 break 6442 } 6443 ret = func(env *Env) r.Value { 6444 6445 env.MarkUsedByClosure() 6446 return r.ValueOf(func(arg0 uintptr, 6447 6448 arg1 complex128) { 6449 env := newEnv4Func(env, nbind, nintbind, debugC) 6450 6451 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 6452 6453 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 6454 6455 funcbody(env) 6456 6457 env.freeEnv4Func() 6458 }) 6459 } 6460 } 6461 case r.String: 6462 { 6463 if funcbody == nil { 6464 funv := r.ValueOf(func(uintptr, 6465 6466 string) {}) 6467 ret = func(env *Env) r.Value { return funv } 6468 6469 break 6470 } 6471 ret = func(env *Env) r.Value { 6472 6473 env.MarkUsedByClosure() 6474 return r.ValueOf(func(arg0 uintptr, 6475 6476 arg1 string) { 6477 env := newEnv4Func(env, nbind, nintbind, debugC) 6478 6479 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 6480 6481 { 6482 place := r.New(TypeOfString).Elem() 6483 place.SetString(arg1, 6484 ) 6485 env.Vals[indexes[1]] = place 6486 } 6487 6488 funcbody(env) 6489 6490 env.freeEnv4Func() 6491 }) 6492 } 6493 } 6494 } 6495 return ret 6496} 6497func func2ret0Float32(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value { 6498 6499 nbind := m.nbind 6500 nintbind := m.nintbind 6501 funcbody := m.funcbody 6502 var ret func(*Env) r.Value 6503 switch karg1 { 6504 case r.Bool: 6505 6506 { 6507 if funcbody == nil { 6508 funv := r.ValueOf(func(float32, 6509 6510 bool, 6511 6512 ) {}) 6513 ret = func(env *Env) r.Value { return funv } 6514 6515 break 6516 } 6517 ret = func(env *Env) r.Value { 6518 6519 env.MarkUsedByClosure() 6520 return r.ValueOf(func(arg0 float32, 6521 6522 arg1 bool, 6523 6524 ) { 6525 env := newEnv4Func(env, nbind, nintbind, debugC) 6526 6527 *(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 6528 6529 *(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 6530 6531 funcbody(env) 6532 6533 env.freeEnv4Func() 6534 }) 6535 } 6536 } 6537 case r.Int: 6538 6539 { 6540 if funcbody == nil { 6541 funv := r.ValueOf(func(float32, 6542 6543 int, 6544 6545 ) {}) 6546 ret = func(env *Env) r.Value { return funv } 6547 6548 break 6549 } 6550 ret = func(env *Env) r.Value { 6551 6552 env.MarkUsedByClosure() 6553 return r.ValueOf(func(arg0 float32, 6554 6555 arg1 int, 6556 6557 ) { 6558 env := newEnv4Func(env, nbind, nintbind, debugC) 6559 6560 *(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 6561 6562 *(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 6563 6564 funcbody(env) 6565 6566 env.freeEnv4Func() 6567 }) 6568 } 6569 } 6570 case r.Int8: 6571 6572 { 6573 if funcbody == nil { 6574 funv := r.ValueOf(func(float32, 6575 6576 int8, 6577 6578 ) {}) 6579 ret = func(env *Env) r.Value { return funv } 6580 6581 break 6582 } 6583 ret = func(env *Env) r.Value { 6584 6585 env.MarkUsedByClosure() 6586 return r.ValueOf(func(arg0 float32, 6587 6588 arg1 int8, 6589 6590 ) { 6591 env := newEnv4Func(env, nbind, nintbind, debugC) 6592 6593 *(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 6594 6595 *(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 6596 6597 funcbody(env) 6598 6599 env.freeEnv4Func() 6600 }) 6601 } 6602 } 6603 case r.Int16: 6604 { 6605 if funcbody == nil { 6606 funv := r.ValueOf(func(float32, 6607 6608 int16, 6609 6610 ) {}) 6611 ret = func(env *Env) r.Value { return funv } 6612 6613 break 6614 } 6615 ret = func(env *Env) r.Value { 6616 6617 env.MarkUsedByClosure() 6618 return r.ValueOf(func(arg0 float32, 6619 6620 arg1 int16, 6621 6622 ) { 6623 env := newEnv4Func(env, nbind, nintbind, debugC) 6624 6625 *(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 6626 6627 *(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 6628 6629 funcbody(env) 6630 6631 env.freeEnv4Func() 6632 }) 6633 } 6634 } 6635 case r.Int32: 6636 { 6637 if funcbody == nil { 6638 funv := r.ValueOf(func(float32, 6639 6640 int32, 6641 6642 ) {}) 6643 ret = func(env *Env) r.Value { return funv } 6644 6645 break 6646 } 6647 ret = func(env *Env) r.Value { 6648 6649 env.MarkUsedByClosure() 6650 return r.ValueOf(func(arg0 float32, 6651 6652 arg1 int32, 6653 6654 ) { 6655 env := newEnv4Func(env, nbind, nintbind, debugC) 6656 6657 *(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 6658 6659 *(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 6660 6661 funcbody(env) 6662 6663 env.freeEnv4Func() 6664 }) 6665 } 6666 } 6667 case r.Int64: 6668 { 6669 if funcbody == nil { 6670 funv := r.ValueOf(func(float32, 6671 6672 int64, 6673 ) {}) 6674 ret = func(env *Env) r.Value { return funv } 6675 6676 break 6677 } 6678 ret = func(env *Env) r.Value { 6679 6680 env.MarkUsedByClosure() 6681 return r.ValueOf(func(arg0 float32, 6682 6683 arg1 int64, 6684 6685 ) { 6686 env := newEnv4Func(env, nbind, nintbind, debugC) 6687 6688 *(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 6689 6690 *(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 6691 6692 funcbody(env) 6693 6694 env.freeEnv4Func() 6695 }) 6696 } 6697 } 6698 case r.Uint: 6699 { 6700 if funcbody == nil { 6701 funv := r.ValueOf(func(float32, 6702 6703 uint) {}) 6704 ret = func(env *Env) r.Value { return funv } 6705 6706 break 6707 } 6708 ret = func(env *Env) r.Value { 6709 6710 env.MarkUsedByClosure() 6711 return r.ValueOf(func(arg0 float32, 6712 6713 arg1 uint, 6714 6715 ) { 6716 env := newEnv4Func(env, nbind, nintbind, debugC) 6717 6718 *(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 6719 6720 *(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 6721 6722 funcbody(env) 6723 6724 env.freeEnv4Func() 6725 }) 6726 } 6727 } 6728 case r.Uint8: 6729 { 6730 if funcbody == nil { 6731 funv := r.ValueOf(func(float32, 6732 6733 uint8) {}) 6734 ret = func(env *Env) r.Value { return funv } 6735 6736 break 6737 } 6738 ret = func(env *Env) r.Value { 6739 6740 env.MarkUsedByClosure() 6741 return r.ValueOf(func(arg0 float32, 6742 6743 arg1 uint8, 6744 6745 ) { 6746 env := newEnv4Func(env, nbind, nintbind, debugC) 6747 6748 *(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 6749 6750 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 6751 6752 funcbody(env) 6753 6754 env.freeEnv4Func() 6755 }) 6756 } 6757 } 6758 case r.Uint16: 6759 { 6760 if funcbody == nil { 6761 funv := r.ValueOf(func(float32, 6762 6763 uint16) {}) 6764 ret = func(env *Env) r.Value { return funv } 6765 6766 break 6767 } 6768 ret = func(env *Env) r.Value { 6769 6770 env.MarkUsedByClosure() 6771 return r.ValueOf(func(arg0 float32, 6772 6773 arg1 uint16, 6774 6775 ) { 6776 env := newEnv4Func(env, nbind, nintbind, debugC) 6777 6778 *(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 6779 6780 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 6781 6782 funcbody(env) 6783 6784 env.freeEnv4Func() 6785 }) 6786 } 6787 } 6788 case r.Uint32: 6789 { 6790 if funcbody == nil { 6791 funv := r.ValueOf(func(float32, 6792 6793 uint32) {}) 6794 ret = func(env *Env) r.Value { return funv } 6795 6796 break 6797 } 6798 ret = func(env *Env) r.Value { 6799 6800 env.MarkUsedByClosure() 6801 return r.ValueOf(func(arg0 float32, 6802 6803 arg1 uint32, 6804 6805 ) { 6806 env := newEnv4Func(env, nbind, nintbind, debugC) 6807 6808 *(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 6809 6810 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 6811 6812 funcbody(env) 6813 6814 env.freeEnv4Func() 6815 }) 6816 } 6817 } 6818 case r.Uint64: 6819 { 6820 if funcbody == nil { 6821 funv := r.ValueOf(func(float32, 6822 6823 uint64) {}) 6824 ret = func(env *Env) r.Value { return funv } 6825 6826 break 6827 } 6828 ret = func(env *Env) r.Value { 6829 6830 env.MarkUsedByClosure() 6831 return r.ValueOf(func(arg0 float32, 6832 6833 arg1 uint64, 6834 6835 ) { 6836 env := newEnv4Func(env, nbind, nintbind, debugC) 6837 6838 *(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 6839 6840 env.Ints[indexes[1]] = arg1 6841 6842 funcbody(env) 6843 6844 env.freeEnv4Func() 6845 }) 6846 } 6847 } 6848 case r.Uintptr: 6849 { 6850 if funcbody == nil { 6851 funv := r.ValueOf(func(float32, 6852 6853 uintptr) {}) 6854 ret = func(env *Env) r.Value { return funv } 6855 6856 break 6857 } 6858 ret = func(env *Env) r.Value { 6859 6860 env.MarkUsedByClosure() 6861 return r.ValueOf(func(arg0 float32, 6862 6863 arg1 uintptr, 6864 6865 ) { 6866 env := newEnv4Func(env, nbind, nintbind, debugC) 6867 6868 *(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 6869 6870 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 6871 6872 funcbody(env) 6873 6874 env.freeEnv4Func() 6875 }) 6876 } 6877 } 6878 case r.Float32: 6879 { 6880 if funcbody == nil { 6881 funv := r.ValueOf(func(float32, 6882 6883 float32) {}) 6884 ret = func(env *Env) r.Value { return funv } 6885 6886 break 6887 } 6888 ret = func(env *Env) r.Value { 6889 6890 env.MarkUsedByClosure() 6891 return r.ValueOf(func(arg0 float32, 6892 6893 arg1 float32, 6894 6895 ) { 6896 env := newEnv4Func(env, nbind, nintbind, debugC) 6897 6898 *(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 6899 6900 *(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 6901 6902 funcbody(env) 6903 6904 env.freeEnv4Func() 6905 }) 6906 } 6907 } 6908 case r.Float64: 6909 { 6910 if funcbody == nil { 6911 funv := r.ValueOf(func(float32, 6912 6913 float64) {}) 6914 ret = func(env *Env) r.Value { return funv } 6915 6916 break 6917 } 6918 ret = func(env *Env) r.Value { 6919 6920 env.MarkUsedByClosure() 6921 return r.ValueOf(func(arg0 float32, 6922 6923 arg1 float64, 6924 6925 ) { 6926 env := newEnv4Func(env, nbind, nintbind, debugC) 6927 6928 *(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 6929 6930 *(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 6931 6932 funcbody(env) 6933 6934 env.freeEnv4Func() 6935 }) 6936 } 6937 } 6938 case r.Complex64: 6939 { 6940 if funcbody == nil { 6941 funv := r.ValueOf(func(float32, 6942 6943 complex64) {}) 6944 ret = func(env *Env) r.Value { return funv } 6945 6946 break 6947 } 6948 ret = func(env *Env) r.Value { 6949 6950 env.MarkUsedByClosure() 6951 return r.ValueOf(func(arg0 float32, 6952 6953 arg1 complex64, 6954 ) { 6955 env := newEnv4Func(env, nbind, nintbind, debugC) 6956 6957 *(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 6958 6959 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 6960 6961 funcbody(env) 6962 6963 env.freeEnv4Func() 6964 }) 6965 } 6966 } 6967 case r.Complex128: 6968 { 6969 if funcbody == nil { 6970 funv := r.ValueOf(func(float32, 6971 6972 complex128) {}) 6973 ret = func(env *Env) r.Value { return funv } 6974 6975 break 6976 } 6977 ret = func(env *Env) r.Value { 6978 6979 env.MarkUsedByClosure() 6980 return r.ValueOf(func(arg0 float32, 6981 6982 arg1 complex128) { 6983 env := newEnv4Func(env, nbind, nintbind, debugC) 6984 6985 *(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 6986 6987 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 6988 6989 funcbody(env) 6990 6991 env.freeEnv4Func() 6992 }) 6993 } 6994 } 6995 case r.String: 6996 { 6997 if funcbody == nil { 6998 funv := r.ValueOf(func(float32, 6999 7000 string) {}) 7001 ret = func(env *Env) r.Value { return funv } 7002 7003 break 7004 } 7005 ret = func(env *Env) r.Value { 7006 7007 env.MarkUsedByClosure() 7008 return r.ValueOf(func(arg0 float32, 7009 7010 arg1 string) { 7011 env := newEnv4Func(env, nbind, nintbind, debugC) 7012 7013 *(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 7014 7015 { 7016 place := r.New(TypeOfString).Elem() 7017 place.SetString(arg1, 7018 ) 7019 env.Vals[indexes[1]] = place 7020 } 7021 7022 funcbody(env) 7023 7024 env.freeEnv4Func() 7025 }) 7026 } 7027 } 7028 } 7029 return ret 7030} 7031func func2ret0Float64(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value { 7032 7033 nbind := m.nbind 7034 nintbind := m.nintbind 7035 funcbody := m.funcbody 7036 var ret func(*Env) r.Value 7037 switch karg1 { 7038 case r.Bool: 7039 7040 { 7041 if funcbody == nil { 7042 funv := r.ValueOf(func(float64, 7043 7044 bool, 7045 7046 ) {}) 7047 ret = func(env *Env) r.Value { return funv } 7048 7049 break 7050 } 7051 ret = func(env *Env) r.Value { 7052 7053 env.MarkUsedByClosure() 7054 return r.ValueOf(func(arg0 float64, 7055 7056 arg1 bool, 7057 7058 ) { 7059 env := newEnv4Func(env, nbind, nintbind, debugC) 7060 7061 *(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 7062 7063 *(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 7064 7065 funcbody(env) 7066 7067 env.freeEnv4Func() 7068 }) 7069 } 7070 } 7071 case r.Int: 7072 7073 { 7074 if funcbody == nil { 7075 funv := r.ValueOf(func(float64, 7076 7077 int, 7078 7079 ) {}) 7080 ret = func(env *Env) r.Value { return funv } 7081 7082 break 7083 } 7084 ret = func(env *Env) r.Value { 7085 7086 env.MarkUsedByClosure() 7087 return r.ValueOf(func(arg0 float64, 7088 7089 arg1 int, 7090 7091 ) { 7092 env := newEnv4Func(env, nbind, nintbind, debugC) 7093 7094 *(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 7095 7096 *(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 7097 7098 funcbody(env) 7099 7100 env.freeEnv4Func() 7101 }) 7102 } 7103 } 7104 case r.Int8: 7105 7106 { 7107 if funcbody == nil { 7108 funv := r.ValueOf(func(float64, 7109 7110 int8, 7111 7112 ) {}) 7113 ret = func(env *Env) r.Value { return funv } 7114 7115 break 7116 } 7117 ret = func(env *Env) r.Value { 7118 7119 env.MarkUsedByClosure() 7120 return r.ValueOf(func(arg0 float64, 7121 7122 arg1 int8, 7123 7124 ) { 7125 env := newEnv4Func(env, nbind, nintbind, debugC) 7126 7127 *(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 7128 7129 *(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 7130 7131 funcbody(env) 7132 7133 env.freeEnv4Func() 7134 }) 7135 } 7136 } 7137 case r.Int16: 7138 { 7139 if funcbody == nil { 7140 funv := r.ValueOf(func(float64, 7141 7142 int16, 7143 7144 ) {}) 7145 ret = func(env *Env) r.Value { return funv } 7146 7147 break 7148 } 7149 ret = func(env *Env) r.Value { 7150 7151 env.MarkUsedByClosure() 7152 return r.ValueOf(func(arg0 float64, 7153 7154 arg1 int16, 7155 7156 ) { 7157 env := newEnv4Func(env, nbind, nintbind, debugC) 7158 7159 *(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 7160 7161 *(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 7162 7163 funcbody(env) 7164 7165 env.freeEnv4Func() 7166 }) 7167 } 7168 } 7169 case r.Int32: 7170 { 7171 if funcbody == nil { 7172 funv := r.ValueOf(func(float64, 7173 7174 int32, 7175 7176 ) {}) 7177 ret = func(env *Env) r.Value { return funv } 7178 7179 break 7180 } 7181 ret = func(env *Env) r.Value { 7182 7183 env.MarkUsedByClosure() 7184 return r.ValueOf(func(arg0 float64, 7185 7186 arg1 int32, 7187 7188 ) { 7189 env := newEnv4Func(env, nbind, nintbind, debugC) 7190 7191 *(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 7192 7193 *(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 7194 7195 funcbody(env) 7196 7197 env.freeEnv4Func() 7198 }) 7199 } 7200 } 7201 case r.Int64: 7202 { 7203 if funcbody == nil { 7204 funv := r.ValueOf(func(float64, 7205 7206 int64, 7207 ) {}) 7208 ret = func(env *Env) r.Value { return funv } 7209 7210 break 7211 } 7212 ret = func(env *Env) r.Value { 7213 7214 env.MarkUsedByClosure() 7215 return r.ValueOf(func(arg0 float64, 7216 7217 arg1 int64, 7218 7219 ) { 7220 env := newEnv4Func(env, nbind, nintbind, debugC) 7221 7222 *(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 7223 7224 *(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 7225 7226 funcbody(env) 7227 7228 env.freeEnv4Func() 7229 }) 7230 } 7231 } 7232 case r.Uint: 7233 { 7234 if funcbody == nil { 7235 funv := r.ValueOf(func(float64, 7236 7237 uint) {}) 7238 ret = func(env *Env) r.Value { return funv } 7239 7240 break 7241 } 7242 ret = func(env *Env) r.Value { 7243 7244 env.MarkUsedByClosure() 7245 return r.ValueOf(func(arg0 float64, 7246 7247 arg1 uint, 7248 7249 ) { 7250 env := newEnv4Func(env, nbind, nintbind, debugC) 7251 7252 *(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 7253 7254 *(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 7255 7256 funcbody(env) 7257 7258 env.freeEnv4Func() 7259 }) 7260 } 7261 } 7262 case r.Uint8: 7263 { 7264 if funcbody == nil { 7265 funv := r.ValueOf(func(float64, 7266 7267 uint8) {}) 7268 ret = func(env *Env) r.Value { return funv } 7269 7270 break 7271 } 7272 ret = func(env *Env) r.Value { 7273 7274 env.MarkUsedByClosure() 7275 return r.ValueOf(func(arg0 float64, 7276 7277 arg1 uint8, 7278 7279 ) { 7280 env := newEnv4Func(env, nbind, nintbind, debugC) 7281 7282 *(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 7283 7284 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 7285 7286 funcbody(env) 7287 7288 env.freeEnv4Func() 7289 }) 7290 } 7291 } 7292 case r.Uint16: 7293 { 7294 if funcbody == nil { 7295 funv := r.ValueOf(func(float64, 7296 7297 uint16) {}) 7298 ret = func(env *Env) r.Value { return funv } 7299 7300 break 7301 } 7302 ret = func(env *Env) r.Value { 7303 7304 env.MarkUsedByClosure() 7305 return r.ValueOf(func(arg0 float64, 7306 7307 arg1 uint16, 7308 7309 ) { 7310 env := newEnv4Func(env, nbind, nintbind, debugC) 7311 7312 *(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 7313 7314 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 7315 7316 funcbody(env) 7317 7318 env.freeEnv4Func() 7319 }) 7320 } 7321 } 7322 case r.Uint32: 7323 { 7324 if funcbody == nil { 7325 funv := r.ValueOf(func(float64, 7326 7327 uint32) {}) 7328 ret = func(env *Env) r.Value { return funv } 7329 7330 break 7331 } 7332 ret = func(env *Env) r.Value { 7333 7334 env.MarkUsedByClosure() 7335 return r.ValueOf(func(arg0 float64, 7336 7337 arg1 uint32, 7338 7339 ) { 7340 env := newEnv4Func(env, nbind, nintbind, debugC) 7341 7342 *(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 7343 7344 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 7345 7346 funcbody(env) 7347 7348 env.freeEnv4Func() 7349 }) 7350 } 7351 } 7352 case r.Uint64: 7353 { 7354 if funcbody == nil { 7355 funv := r.ValueOf(func(float64, 7356 7357 uint64) {}) 7358 ret = func(env *Env) r.Value { return funv } 7359 7360 break 7361 } 7362 ret = func(env *Env) r.Value { 7363 7364 env.MarkUsedByClosure() 7365 return r.ValueOf(func(arg0 float64, 7366 7367 arg1 uint64, 7368 7369 ) { 7370 env := newEnv4Func(env, nbind, nintbind, debugC) 7371 7372 *(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 7373 7374 env.Ints[indexes[1]] = arg1 7375 7376 funcbody(env) 7377 7378 env.freeEnv4Func() 7379 }) 7380 } 7381 } 7382 case r.Uintptr: 7383 { 7384 if funcbody == nil { 7385 funv := r.ValueOf(func(float64, 7386 7387 uintptr) {}) 7388 ret = func(env *Env) r.Value { return funv } 7389 7390 break 7391 } 7392 ret = func(env *Env) r.Value { 7393 7394 env.MarkUsedByClosure() 7395 return r.ValueOf(func(arg0 float64, 7396 7397 arg1 uintptr, 7398 7399 ) { 7400 env := newEnv4Func(env, nbind, nintbind, debugC) 7401 7402 *(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 7403 7404 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 7405 7406 funcbody(env) 7407 7408 env.freeEnv4Func() 7409 }) 7410 } 7411 } 7412 case r.Float32: 7413 { 7414 if funcbody == nil { 7415 funv := r.ValueOf(func(float64, 7416 7417 float32) {}) 7418 ret = func(env *Env) r.Value { return funv } 7419 7420 break 7421 } 7422 ret = func(env *Env) r.Value { 7423 7424 env.MarkUsedByClosure() 7425 return r.ValueOf(func(arg0 float64, 7426 7427 arg1 float32, 7428 7429 ) { 7430 env := newEnv4Func(env, nbind, nintbind, debugC) 7431 7432 *(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 7433 7434 *(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 7435 7436 funcbody(env) 7437 7438 env.freeEnv4Func() 7439 }) 7440 } 7441 } 7442 case r.Float64: 7443 { 7444 if funcbody == nil { 7445 funv := r.ValueOf(func(float64, 7446 7447 float64) {}) 7448 ret = func(env *Env) r.Value { return funv } 7449 7450 break 7451 } 7452 ret = func(env *Env) r.Value { 7453 7454 env.MarkUsedByClosure() 7455 return r.ValueOf(func(arg0 float64, 7456 7457 arg1 float64, 7458 7459 ) { 7460 env := newEnv4Func(env, nbind, nintbind, debugC) 7461 7462 *(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 7463 7464 *(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 7465 7466 funcbody(env) 7467 7468 env.freeEnv4Func() 7469 }) 7470 } 7471 } 7472 case r.Complex64: 7473 { 7474 if funcbody == nil { 7475 funv := r.ValueOf(func(float64, 7476 7477 complex64) {}) 7478 ret = func(env *Env) r.Value { return funv } 7479 7480 break 7481 } 7482 ret = func(env *Env) r.Value { 7483 7484 env.MarkUsedByClosure() 7485 return r.ValueOf(func(arg0 float64, 7486 7487 arg1 complex64, 7488 ) { 7489 env := newEnv4Func(env, nbind, nintbind, debugC) 7490 7491 *(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 7492 7493 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 7494 7495 funcbody(env) 7496 7497 env.freeEnv4Func() 7498 }) 7499 } 7500 } 7501 case r.Complex128: 7502 { 7503 if funcbody == nil { 7504 funv := r.ValueOf(func(float64, 7505 7506 complex128) {}) 7507 ret = func(env *Env) r.Value { return funv } 7508 7509 break 7510 } 7511 ret = func(env *Env) r.Value { 7512 7513 env.MarkUsedByClosure() 7514 return r.ValueOf(func(arg0 float64, 7515 7516 arg1 complex128) { 7517 env := newEnv4Func(env, nbind, nintbind, debugC) 7518 7519 *(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 7520 7521 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 7522 7523 funcbody(env) 7524 7525 env.freeEnv4Func() 7526 }) 7527 } 7528 } 7529 case r.String: 7530 { 7531 if funcbody == nil { 7532 funv := r.ValueOf(func(float64, 7533 7534 string) {}) 7535 ret = func(env *Env) r.Value { return funv } 7536 7537 break 7538 } 7539 ret = func(env *Env) r.Value { 7540 7541 env.MarkUsedByClosure() 7542 return r.ValueOf(func(arg0 float64, 7543 7544 arg1 string) { 7545 env := newEnv4Func(env, nbind, nintbind, debugC) 7546 7547 *(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 7548 7549 { 7550 place := r.New(TypeOfString).Elem() 7551 place.SetString(arg1, 7552 ) 7553 env.Vals[indexes[1]] = place 7554 } 7555 7556 funcbody(env) 7557 7558 env.freeEnv4Func() 7559 }) 7560 } 7561 } 7562 } 7563 return ret 7564} 7565func func2ret0Complex64(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value { 7566 7567 nbind := m.nbind 7568 nintbind := m.nintbind 7569 funcbody := m.funcbody 7570 var ret func(*Env) r.Value 7571 switch karg1 { 7572 case r.Bool: 7573 7574 { 7575 if funcbody == nil { 7576 funv := r.ValueOf(func(complex64, 7577 7578 bool, 7579 7580 ) {}) 7581 ret = func(env *Env) r.Value { return funv } 7582 7583 break 7584 } 7585 ret = func(env *Env) r.Value { 7586 7587 env.MarkUsedByClosure() 7588 return r.ValueOf(func(arg0 complex64, 7589 7590 arg1 bool, 7591 7592 ) { 7593 env := newEnv4Func(env, nbind, nintbind, debugC) 7594 7595 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 7596 7597 *(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 7598 7599 funcbody(env) 7600 7601 env.freeEnv4Func() 7602 }) 7603 } 7604 } 7605 case r.Int: 7606 7607 { 7608 if funcbody == nil { 7609 funv := r.ValueOf(func(complex64, 7610 7611 int, 7612 7613 ) {}) 7614 ret = func(env *Env) r.Value { return funv } 7615 7616 break 7617 } 7618 ret = func(env *Env) r.Value { 7619 7620 env.MarkUsedByClosure() 7621 return r.ValueOf(func(arg0 complex64, 7622 7623 arg1 int, 7624 7625 ) { 7626 env := newEnv4Func(env, nbind, nintbind, debugC) 7627 7628 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 7629 7630 *(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 7631 7632 funcbody(env) 7633 7634 env.freeEnv4Func() 7635 }) 7636 } 7637 } 7638 case r.Int8: 7639 7640 { 7641 if funcbody == nil { 7642 funv := r.ValueOf(func(complex64, 7643 7644 int8, 7645 7646 ) {}) 7647 ret = func(env *Env) r.Value { return funv } 7648 7649 break 7650 } 7651 ret = func(env *Env) r.Value { 7652 7653 env.MarkUsedByClosure() 7654 return r.ValueOf(func(arg0 complex64, 7655 7656 arg1 int8, 7657 7658 ) { 7659 env := newEnv4Func(env, nbind, nintbind, debugC) 7660 7661 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 7662 7663 *(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 7664 7665 funcbody(env) 7666 7667 env.freeEnv4Func() 7668 }) 7669 } 7670 } 7671 case r.Int16: 7672 { 7673 if funcbody == nil { 7674 funv := r.ValueOf(func(complex64, 7675 7676 int16, 7677 7678 ) {}) 7679 ret = func(env *Env) r.Value { return funv } 7680 7681 break 7682 } 7683 ret = func(env *Env) r.Value { 7684 7685 env.MarkUsedByClosure() 7686 return r.ValueOf(func(arg0 complex64, 7687 7688 arg1 int16, 7689 7690 ) { 7691 env := newEnv4Func(env, nbind, nintbind, debugC) 7692 7693 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 7694 7695 *(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 7696 7697 funcbody(env) 7698 7699 env.freeEnv4Func() 7700 }) 7701 } 7702 } 7703 case r.Int32: 7704 { 7705 if funcbody == nil { 7706 funv := r.ValueOf(func(complex64, 7707 7708 int32, 7709 7710 ) {}) 7711 ret = func(env *Env) r.Value { return funv } 7712 7713 break 7714 } 7715 ret = func(env *Env) r.Value { 7716 7717 env.MarkUsedByClosure() 7718 return r.ValueOf(func(arg0 complex64, 7719 7720 arg1 int32, 7721 7722 ) { 7723 env := newEnv4Func(env, nbind, nintbind, debugC) 7724 7725 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 7726 7727 *(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 7728 7729 funcbody(env) 7730 7731 env.freeEnv4Func() 7732 }) 7733 } 7734 } 7735 case r.Int64: 7736 { 7737 if funcbody == nil { 7738 funv := r.ValueOf(func(complex64, 7739 7740 int64, 7741 ) {}) 7742 ret = func(env *Env) r.Value { return funv } 7743 7744 break 7745 } 7746 ret = func(env *Env) r.Value { 7747 7748 env.MarkUsedByClosure() 7749 return r.ValueOf(func(arg0 complex64, 7750 7751 arg1 int64, 7752 7753 ) { 7754 env := newEnv4Func(env, nbind, nintbind, debugC) 7755 7756 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 7757 7758 *(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 7759 7760 funcbody(env) 7761 7762 env.freeEnv4Func() 7763 }) 7764 } 7765 } 7766 case r.Uint: 7767 { 7768 if funcbody == nil { 7769 funv := r.ValueOf(func(complex64, 7770 7771 uint) {}) 7772 ret = func(env *Env) r.Value { return funv } 7773 7774 break 7775 } 7776 ret = func(env *Env) r.Value { 7777 7778 env.MarkUsedByClosure() 7779 return r.ValueOf(func(arg0 complex64, 7780 7781 arg1 uint, 7782 7783 ) { 7784 env := newEnv4Func(env, nbind, nintbind, debugC) 7785 7786 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 7787 7788 *(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 7789 7790 funcbody(env) 7791 7792 env.freeEnv4Func() 7793 }) 7794 } 7795 } 7796 case r.Uint8: 7797 { 7798 if funcbody == nil { 7799 funv := r.ValueOf(func(complex64, 7800 7801 uint8) {}) 7802 ret = func(env *Env) r.Value { return funv } 7803 7804 break 7805 } 7806 ret = func(env *Env) r.Value { 7807 7808 env.MarkUsedByClosure() 7809 return r.ValueOf(func(arg0 complex64, 7810 7811 arg1 uint8, 7812 7813 ) { 7814 env := newEnv4Func(env, nbind, nintbind, debugC) 7815 7816 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 7817 7818 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 7819 7820 funcbody(env) 7821 7822 env.freeEnv4Func() 7823 }) 7824 } 7825 } 7826 case r.Uint16: 7827 { 7828 if funcbody == nil { 7829 funv := r.ValueOf(func(complex64, 7830 7831 uint16) {}) 7832 ret = func(env *Env) r.Value { return funv } 7833 7834 break 7835 } 7836 ret = func(env *Env) r.Value { 7837 7838 env.MarkUsedByClosure() 7839 return r.ValueOf(func(arg0 complex64, 7840 7841 arg1 uint16, 7842 7843 ) { 7844 env := newEnv4Func(env, nbind, nintbind, debugC) 7845 7846 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 7847 7848 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 7849 7850 funcbody(env) 7851 7852 env.freeEnv4Func() 7853 }) 7854 } 7855 } 7856 case r.Uint32: 7857 { 7858 if funcbody == nil { 7859 funv := r.ValueOf(func(complex64, 7860 7861 uint32) {}) 7862 ret = func(env *Env) r.Value { return funv } 7863 7864 break 7865 } 7866 ret = func(env *Env) r.Value { 7867 7868 env.MarkUsedByClosure() 7869 return r.ValueOf(func(arg0 complex64, 7870 7871 arg1 uint32, 7872 7873 ) { 7874 env := newEnv4Func(env, nbind, nintbind, debugC) 7875 7876 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 7877 7878 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 7879 7880 funcbody(env) 7881 7882 env.freeEnv4Func() 7883 }) 7884 } 7885 } 7886 case r.Uint64: 7887 { 7888 if funcbody == nil { 7889 funv := r.ValueOf(func(complex64, 7890 7891 uint64) {}) 7892 ret = func(env *Env) r.Value { return funv } 7893 7894 break 7895 } 7896 ret = func(env *Env) r.Value { 7897 7898 env.MarkUsedByClosure() 7899 return r.ValueOf(func(arg0 complex64, 7900 7901 arg1 uint64, 7902 7903 ) { 7904 env := newEnv4Func(env, nbind, nintbind, debugC) 7905 7906 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 7907 7908 env.Ints[indexes[1]] = arg1 7909 7910 funcbody(env) 7911 7912 env.freeEnv4Func() 7913 }) 7914 } 7915 } 7916 case r.Uintptr: 7917 { 7918 if funcbody == nil { 7919 funv := r.ValueOf(func(complex64, 7920 7921 uintptr) {}) 7922 ret = func(env *Env) r.Value { return funv } 7923 7924 break 7925 } 7926 ret = func(env *Env) r.Value { 7927 7928 env.MarkUsedByClosure() 7929 return r.ValueOf(func(arg0 complex64, 7930 7931 arg1 uintptr, 7932 7933 ) { 7934 env := newEnv4Func(env, nbind, nintbind, debugC) 7935 7936 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 7937 7938 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 7939 7940 funcbody(env) 7941 7942 env.freeEnv4Func() 7943 }) 7944 } 7945 } 7946 case r.Float32: 7947 { 7948 if funcbody == nil { 7949 funv := r.ValueOf(func(complex64, 7950 7951 float32) {}) 7952 ret = func(env *Env) r.Value { return funv } 7953 7954 break 7955 } 7956 ret = func(env *Env) r.Value { 7957 7958 env.MarkUsedByClosure() 7959 return r.ValueOf(func(arg0 complex64, 7960 7961 arg1 float32, 7962 7963 ) { 7964 env := newEnv4Func(env, nbind, nintbind, debugC) 7965 7966 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 7967 7968 *(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 7969 7970 funcbody(env) 7971 7972 env.freeEnv4Func() 7973 }) 7974 } 7975 } 7976 case r.Float64: 7977 { 7978 if funcbody == nil { 7979 funv := r.ValueOf(func(complex64, 7980 7981 float64) {}) 7982 ret = func(env *Env) r.Value { return funv } 7983 7984 break 7985 } 7986 ret = func(env *Env) r.Value { 7987 7988 env.MarkUsedByClosure() 7989 return r.ValueOf(func(arg0 complex64, 7990 7991 arg1 float64, 7992 7993 ) { 7994 env := newEnv4Func(env, nbind, nintbind, debugC) 7995 7996 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 7997 7998 *(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 7999 8000 funcbody(env) 8001 8002 env.freeEnv4Func() 8003 }) 8004 } 8005 } 8006 case r.Complex64: 8007 { 8008 if funcbody == nil { 8009 funv := r.ValueOf(func(complex64, 8010 8011 complex64) {}) 8012 ret = func(env *Env) r.Value { return funv } 8013 8014 break 8015 } 8016 ret = func(env *Env) r.Value { 8017 8018 env.MarkUsedByClosure() 8019 return r.ValueOf(func(arg0 complex64, 8020 8021 arg1 complex64, 8022 ) { 8023 env := newEnv4Func(env, nbind, nintbind, debugC) 8024 8025 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 8026 8027 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 8028 8029 funcbody(env) 8030 8031 env.freeEnv4Func() 8032 }) 8033 } 8034 } 8035 case r.Complex128: 8036 { 8037 if funcbody == nil { 8038 funv := r.ValueOf(func(complex64, 8039 8040 complex128) {}) 8041 ret = func(env *Env) r.Value { return funv } 8042 8043 break 8044 } 8045 ret = func(env *Env) r.Value { 8046 8047 env.MarkUsedByClosure() 8048 return r.ValueOf(func(arg0 complex64, 8049 8050 arg1 complex128) { 8051 env := newEnv4Func(env, nbind, nintbind, debugC) 8052 8053 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 8054 8055 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 8056 8057 funcbody(env) 8058 8059 env.freeEnv4Func() 8060 }) 8061 } 8062 } 8063 case r.String: 8064 { 8065 if funcbody == nil { 8066 funv := r.ValueOf(func(complex64, 8067 8068 string) {}) 8069 ret = func(env *Env) r.Value { return funv } 8070 8071 break 8072 } 8073 ret = func(env *Env) r.Value { 8074 8075 env.MarkUsedByClosure() 8076 return r.ValueOf(func(arg0 complex64, 8077 8078 arg1 string) { 8079 env := newEnv4Func(env, nbind, nintbind, debugC) 8080 8081 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 8082 8083 { 8084 place := r.New(TypeOfString).Elem() 8085 place.SetString(arg1, 8086 ) 8087 env.Vals[indexes[1]] = place 8088 } 8089 8090 funcbody(env) 8091 8092 env.freeEnv4Func() 8093 }) 8094 } 8095 } 8096 } 8097 return ret 8098} 8099func func2ret0Complex128(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value { 8100 8101 nbind := m.nbind 8102 nintbind := m.nintbind 8103 funcbody := m.funcbody 8104 var ret func(*Env) r.Value 8105 switch karg1 { 8106 case r.Bool: 8107 8108 { 8109 if funcbody == nil { 8110 funv := r.ValueOf(func(complex128, 8111 8112 bool, 8113 8114 ) {}) 8115 ret = func(env *Env) r.Value { return funv } 8116 8117 break 8118 } 8119 ret = func(env *Env) r.Value { 8120 8121 env.MarkUsedByClosure() 8122 return r.ValueOf(func(arg0 complex128, 8123 8124 arg1 bool, 8125 8126 ) { 8127 env := newEnv4Func(env, nbind, nintbind, debugC) 8128 8129 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 8130 8131 *(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 8132 8133 funcbody(env) 8134 8135 env.freeEnv4Func() 8136 }) 8137 } 8138 } 8139 case r.Int: 8140 8141 { 8142 if funcbody == nil { 8143 funv := r.ValueOf(func(complex128, 8144 8145 int, 8146 8147 ) {}) 8148 ret = func(env *Env) r.Value { return funv } 8149 8150 break 8151 } 8152 ret = func(env *Env) r.Value { 8153 8154 env.MarkUsedByClosure() 8155 return r.ValueOf(func(arg0 complex128, 8156 8157 arg1 int, 8158 8159 ) { 8160 env := newEnv4Func(env, nbind, nintbind, debugC) 8161 8162 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 8163 8164 *(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 8165 8166 funcbody(env) 8167 8168 env.freeEnv4Func() 8169 }) 8170 } 8171 } 8172 case r.Int8: 8173 8174 { 8175 if funcbody == nil { 8176 funv := r.ValueOf(func(complex128, 8177 8178 int8, 8179 8180 ) {}) 8181 ret = func(env *Env) r.Value { return funv } 8182 8183 break 8184 } 8185 ret = func(env *Env) r.Value { 8186 8187 env.MarkUsedByClosure() 8188 return r.ValueOf(func(arg0 complex128, 8189 8190 arg1 int8, 8191 8192 ) { 8193 env := newEnv4Func(env, nbind, nintbind, debugC) 8194 8195 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 8196 8197 *(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 8198 8199 funcbody(env) 8200 8201 env.freeEnv4Func() 8202 }) 8203 } 8204 } 8205 case r.Int16: 8206 { 8207 if funcbody == nil { 8208 funv := r.ValueOf(func(complex128, 8209 8210 int16, 8211 8212 ) {}) 8213 ret = func(env *Env) r.Value { return funv } 8214 8215 break 8216 } 8217 ret = func(env *Env) r.Value { 8218 8219 env.MarkUsedByClosure() 8220 return r.ValueOf(func(arg0 complex128, 8221 8222 arg1 int16, 8223 8224 ) { 8225 env := newEnv4Func(env, nbind, nintbind, debugC) 8226 8227 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 8228 8229 *(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 8230 8231 funcbody(env) 8232 8233 env.freeEnv4Func() 8234 }) 8235 } 8236 } 8237 case r.Int32: 8238 { 8239 if funcbody == nil { 8240 funv := r.ValueOf(func(complex128, 8241 8242 int32, 8243 8244 ) {}) 8245 ret = func(env *Env) r.Value { return funv } 8246 8247 break 8248 } 8249 ret = func(env *Env) r.Value { 8250 8251 env.MarkUsedByClosure() 8252 return r.ValueOf(func(arg0 complex128, 8253 8254 arg1 int32, 8255 8256 ) { 8257 env := newEnv4Func(env, nbind, nintbind, debugC) 8258 8259 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 8260 8261 *(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 8262 8263 funcbody(env) 8264 8265 env.freeEnv4Func() 8266 }) 8267 } 8268 } 8269 case r.Int64: 8270 { 8271 if funcbody == nil { 8272 funv := r.ValueOf(func(complex128, 8273 8274 int64, 8275 ) {}) 8276 ret = func(env *Env) r.Value { return funv } 8277 8278 break 8279 } 8280 ret = func(env *Env) r.Value { 8281 8282 env.MarkUsedByClosure() 8283 return r.ValueOf(func(arg0 complex128, 8284 8285 arg1 int64, 8286 8287 ) { 8288 env := newEnv4Func(env, nbind, nintbind, debugC) 8289 8290 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 8291 8292 *(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 8293 8294 funcbody(env) 8295 8296 env.freeEnv4Func() 8297 }) 8298 } 8299 } 8300 case r.Uint: 8301 { 8302 if funcbody == nil { 8303 funv := r.ValueOf(func(complex128, 8304 8305 uint) {}) 8306 ret = func(env *Env) r.Value { return funv } 8307 8308 break 8309 } 8310 ret = func(env *Env) r.Value { 8311 8312 env.MarkUsedByClosure() 8313 return r.ValueOf(func(arg0 complex128, 8314 8315 arg1 uint, 8316 8317 ) { 8318 env := newEnv4Func(env, nbind, nintbind, debugC) 8319 8320 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 8321 8322 *(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 8323 8324 funcbody(env) 8325 8326 env.freeEnv4Func() 8327 }) 8328 } 8329 } 8330 case r.Uint8: 8331 { 8332 if funcbody == nil { 8333 funv := r.ValueOf(func(complex128, 8334 8335 uint8) {}) 8336 ret = func(env *Env) r.Value { return funv } 8337 8338 break 8339 } 8340 ret = func(env *Env) r.Value { 8341 8342 env.MarkUsedByClosure() 8343 return r.ValueOf(func(arg0 complex128, 8344 8345 arg1 uint8, 8346 8347 ) { 8348 env := newEnv4Func(env, nbind, nintbind, debugC) 8349 8350 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 8351 8352 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 8353 8354 funcbody(env) 8355 8356 env.freeEnv4Func() 8357 }) 8358 } 8359 } 8360 case r.Uint16: 8361 { 8362 if funcbody == nil { 8363 funv := r.ValueOf(func(complex128, 8364 8365 uint16) {}) 8366 ret = func(env *Env) r.Value { return funv } 8367 8368 break 8369 } 8370 ret = func(env *Env) r.Value { 8371 8372 env.MarkUsedByClosure() 8373 return r.ValueOf(func(arg0 complex128, 8374 8375 arg1 uint16, 8376 8377 ) { 8378 env := newEnv4Func(env, nbind, nintbind, debugC) 8379 8380 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 8381 8382 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 8383 8384 funcbody(env) 8385 8386 env.freeEnv4Func() 8387 }) 8388 } 8389 } 8390 case r.Uint32: 8391 { 8392 if funcbody == nil { 8393 funv := r.ValueOf(func(complex128, 8394 8395 uint32) {}) 8396 ret = func(env *Env) r.Value { return funv } 8397 8398 break 8399 } 8400 ret = func(env *Env) r.Value { 8401 8402 env.MarkUsedByClosure() 8403 return r.ValueOf(func(arg0 complex128, 8404 8405 arg1 uint32, 8406 8407 ) { 8408 env := newEnv4Func(env, nbind, nintbind, debugC) 8409 8410 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 8411 8412 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 8413 8414 funcbody(env) 8415 8416 env.freeEnv4Func() 8417 }) 8418 } 8419 } 8420 case r.Uint64: 8421 { 8422 if funcbody == nil { 8423 funv := r.ValueOf(func(complex128, 8424 8425 uint64) {}) 8426 ret = func(env *Env) r.Value { return funv } 8427 8428 break 8429 } 8430 ret = func(env *Env) r.Value { 8431 8432 env.MarkUsedByClosure() 8433 return r.ValueOf(func(arg0 complex128, 8434 8435 arg1 uint64, 8436 8437 ) { 8438 env := newEnv4Func(env, nbind, nintbind, debugC) 8439 8440 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 8441 8442 env.Ints[indexes[1]] = arg1 8443 8444 funcbody(env) 8445 8446 env.freeEnv4Func() 8447 }) 8448 } 8449 } 8450 case r.Uintptr: 8451 { 8452 if funcbody == nil { 8453 funv := r.ValueOf(func(complex128, 8454 8455 uintptr) {}) 8456 ret = func(env *Env) r.Value { return funv } 8457 8458 break 8459 } 8460 ret = func(env *Env) r.Value { 8461 8462 env.MarkUsedByClosure() 8463 return r.ValueOf(func(arg0 complex128, 8464 8465 arg1 uintptr, 8466 8467 ) { 8468 env := newEnv4Func(env, nbind, nintbind, debugC) 8469 8470 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 8471 8472 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 8473 8474 funcbody(env) 8475 8476 env.freeEnv4Func() 8477 }) 8478 } 8479 } 8480 case r.Float32: 8481 { 8482 if funcbody == nil { 8483 funv := r.ValueOf(func(complex128, 8484 8485 float32) {}) 8486 ret = func(env *Env) r.Value { return funv } 8487 8488 break 8489 } 8490 ret = func(env *Env) r.Value { 8491 8492 env.MarkUsedByClosure() 8493 return r.ValueOf(func(arg0 complex128, 8494 8495 arg1 float32, 8496 8497 ) { 8498 env := newEnv4Func(env, nbind, nintbind, debugC) 8499 8500 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 8501 8502 *(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 8503 8504 funcbody(env) 8505 8506 env.freeEnv4Func() 8507 }) 8508 } 8509 } 8510 case r.Float64: 8511 { 8512 if funcbody == nil { 8513 funv := r.ValueOf(func(complex128, 8514 8515 float64) {}) 8516 ret = func(env *Env) r.Value { return funv } 8517 8518 break 8519 } 8520 ret = func(env *Env) r.Value { 8521 8522 env.MarkUsedByClosure() 8523 return r.ValueOf(func(arg0 complex128, 8524 8525 arg1 float64, 8526 8527 ) { 8528 env := newEnv4Func(env, nbind, nintbind, debugC) 8529 8530 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 8531 8532 *(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 8533 8534 funcbody(env) 8535 8536 env.freeEnv4Func() 8537 }) 8538 } 8539 } 8540 case r.Complex64: 8541 { 8542 if funcbody == nil { 8543 funv := r.ValueOf(func(complex128, 8544 8545 complex64) {}) 8546 ret = func(env *Env) r.Value { return funv } 8547 8548 break 8549 } 8550 ret = func(env *Env) r.Value { 8551 8552 env.MarkUsedByClosure() 8553 return r.ValueOf(func(arg0 complex128, 8554 8555 arg1 complex64, 8556 ) { 8557 env := newEnv4Func(env, nbind, nintbind, debugC) 8558 8559 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 8560 8561 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 8562 8563 funcbody(env) 8564 8565 env.freeEnv4Func() 8566 }) 8567 } 8568 } 8569 case r.Complex128: 8570 { 8571 if funcbody == nil { 8572 funv := r.ValueOf(func(complex128, 8573 8574 complex128) {}) 8575 ret = func(env *Env) r.Value { return funv } 8576 8577 break 8578 } 8579 ret = func(env *Env) r.Value { 8580 8581 env.MarkUsedByClosure() 8582 return r.ValueOf(func(arg0 complex128, 8583 8584 arg1 complex128) { 8585 env := newEnv4Func(env, nbind, nintbind, debugC) 8586 8587 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 8588 8589 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 8590 8591 funcbody(env) 8592 8593 env.freeEnv4Func() 8594 }) 8595 } 8596 } 8597 case r.String: 8598 { 8599 if funcbody == nil { 8600 funv := r.ValueOf(func(complex128, 8601 8602 string) {}) 8603 ret = func(env *Env) r.Value { return funv } 8604 8605 break 8606 } 8607 ret = func(env *Env) r.Value { 8608 8609 env.MarkUsedByClosure() 8610 return r.ValueOf(func(arg0 complex128, 8611 8612 arg1 string) { 8613 env := newEnv4Func(env, nbind, nintbind, debugC) 8614 8615 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0 8616 8617 { 8618 place := r.New(TypeOfString).Elem() 8619 place.SetString(arg1, 8620 ) 8621 env.Vals[indexes[1]] = place 8622 } 8623 8624 funcbody(env) 8625 8626 env.freeEnv4Func() 8627 }) 8628 } 8629 } 8630 } 8631 return ret 8632} 8633func func2ret0String(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value { 8634 8635 nbind := m.nbind 8636 nintbind := m.nintbind 8637 funcbody := m.funcbody 8638 var ret func(*Env) r.Value 8639 switch karg1 { 8640 case r.Bool: 8641 8642 { 8643 if funcbody == nil { 8644 funv := r.ValueOf(func(string, 8645 8646 bool, 8647 8648 ) {}) 8649 ret = func(env *Env) r.Value { return funv } 8650 8651 break 8652 } 8653 ret = func(env *Env) r.Value { 8654 8655 env.MarkUsedByClosure() 8656 return r.ValueOf(func(arg0 string, 8657 8658 arg1 bool, 8659 8660 ) { 8661 env := newEnv4Func(env, nbind, nintbind, debugC) 8662 { 8663 place := r.New(TypeOfString).Elem() 8664 place.SetString(arg0, 8665 ) 8666 env.Vals[indexes[0]] = place 8667 } 8668 8669 *(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 8670 8671 funcbody(env) 8672 8673 env.freeEnv4Func() 8674 }) 8675 } 8676 } 8677 case r.Int: 8678 8679 { 8680 if funcbody == nil { 8681 funv := r.ValueOf(func(string, 8682 8683 int, 8684 8685 ) {}) 8686 ret = func(env *Env) r.Value { return funv } 8687 8688 break 8689 } 8690 ret = func(env *Env) r.Value { 8691 8692 env.MarkUsedByClosure() 8693 return r.ValueOf(func(arg0 string, 8694 8695 arg1 int, 8696 8697 ) { 8698 env := newEnv4Func(env, nbind, nintbind, debugC) 8699 { 8700 place := r.New(TypeOfString).Elem() 8701 place.SetString(arg0, 8702 ) 8703 env.Vals[indexes[0]] = place 8704 } 8705 8706 *(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 8707 8708 funcbody(env) 8709 8710 env.freeEnv4Func() 8711 }) 8712 } 8713 } 8714 case r.Int8: 8715 8716 { 8717 if funcbody == nil { 8718 funv := r.ValueOf(func(string, 8719 8720 int8, 8721 8722 ) {}) 8723 ret = func(env *Env) r.Value { return funv } 8724 8725 break 8726 } 8727 ret = func(env *Env) r.Value { 8728 8729 env.MarkUsedByClosure() 8730 return r.ValueOf(func(arg0 string, 8731 8732 arg1 int8, 8733 8734 ) { 8735 env := newEnv4Func(env, nbind, nintbind, debugC) 8736 { 8737 place := r.New(TypeOfString).Elem() 8738 place.SetString(arg0, 8739 ) 8740 env.Vals[indexes[0]] = place 8741 } 8742 8743 *(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 8744 8745 funcbody(env) 8746 8747 env.freeEnv4Func() 8748 }) 8749 } 8750 } 8751 case r.Int16: 8752 { 8753 if funcbody == nil { 8754 funv := r.ValueOf(func(string, 8755 8756 int16, 8757 8758 ) {}) 8759 ret = func(env *Env) r.Value { return funv } 8760 8761 break 8762 } 8763 ret = func(env *Env) r.Value { 8764 8765 env.MarkUsedByClosure() 8766 return r.ValueOf(func(arg0 string, 8767 8768 arg1 int16, 8769 8770 ) { 8771 env := newEnv4Func(env, nbind, nintbind, debugC) 8772 { 8773 place := r.New(TypeOfString).Elem() 8774 place.SetString(arg0, 8775 ) 8776 env.Vals[indexes[0]] = place 8777 } 8778 8779 *(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 8780 8781 funcbody(env) 8782 8783 env.freeEnv4Func() 8784 }) 8785 } 8786 } 8787 case r.Int32: 8788 { 8789 if funcbody == nil { 8790 funv := r.ValueOf(func(string, 8791 8792 int32, 8793 8794 ) {}) 8795 ret = func(env *Env) r.Value { return funv } 8796 8797 break 8798 } 8799 ret = func(env *Env) r.Value { 8800 8801 env.MarkUsedByClosure() 8802 return r.ValueOf(func(arg0 string, 8803 8804 arg1 int32, 8805 8806 ) { 8807 env := newEnv4Func(env, nbind, nintbind, debugC) 8808 { 8809 place := r.New(TypeOfString).Elem() 8810 place.SetString(arg0, 8811 ) 8812 env.Vals[indexes[0]] = place 8813 } 8814 8815 *(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 8816 8817 funcbody(env) 8818 8819 env.freeEnv4Func() 8820 }) 8821 } 8822 } 8823 case r.Int64: 8824 { 8825 if funcbody == nil { 8826 funv := r.ValueOf(func(string, 8827 8828 int64, 8829 ) {}) 8830 ret = func(env *Env) r.Value { return funv } 8831 8832 break 8833 } 8834 ret = func(env *Env) r.Value { 8835 8836 env.MarkUsedByClosure() 8837 return r.ValueOf(func(arg0 string, 8838 8839 arg1 int64, 8840 8841 ) { 8842 env := newEnv4Func(env, nbind, nintbind, debugC) 8843 { 8844 place := r.New(TypeOfString).Elem() 8845 place.SetString(arg0, 8846 ) 8847 env.Vals[indexes[0]] = place 8848 } 8849 8850 *(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 8851 8852 funcbody(env) 8853 8854 env.freeEnv4Func() 8855 }) 8856 } 8857 } 8858 case r.Uint: 8859 { 8860 if funcbody == nil { 8861 funv := r.ValueOf(func(string, 8862 8863 uint) {}) 8864 ret = func(env *Env) r.Value { return funv } 8865 8866 break 8867 } 8868 ret = func(env *Env) r.Value { 8869 8870 env.MarkUsedByClosure() 8871 return r.ValueOf(func(arg0 string, 8872 8873 arg1 uint, 8874 8875 ) { 8876 env := newEnv4Func(env, nbind, nintbind, debugC) 8877 { 8878 place := r.New(TypeOfString).Elem() 8879 place.SetString(arg0, 8880 ) 8881 env.Vals[indexes[0]] = place 8882 } 8883 8884 *(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 8885 8886 funcbody(env) 8887 8888 env.freeEnv4Func() 8889 }) 8890 } 8891 } 8892 case r.Uint8: 8893 { 8894 if funcbody == nil { 8895 funv := r.ValueOf(func(string, 8896 8897 uint8) {}) 8898 ret = func(env *Env) r.Value { return funv } 8899 8900 break 8901 } 8902 ret = func(env *Env) r.Value { 8903 8904 env.MarkUsedByClosure() 8905 return r.ValueOf(func(arg0 string, 8906 8907 arg1 uint8, 8908 8909 ) { 8910 env := newEnv4Func(env, nbind, nintbind, debugC) 8911 { 8912 place := r.New(TypeOfString).Elem() 8913 place.SetString(arg0, 8914 ) 8915 env.Vals[indexes[0]] = place 8916 } 8917 8918 *(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 8919 8920 funcbody(env) 8921 8922 env.freeEnv4Func() 8923 }) 8924 } 8925 } 8926 case r.Uint16: 8927 { 8928 if funcbody == nil { 8929 funv := r.ValueOf(func(string, 8930 8931 uint16) {}) 8932 ret = func(env *Env) r.Value { return funv } 8933 8934 break 8935 } 8936 ret = func(env *Env) r.Value { 8937 8938 env.MarkUsedByClosure() 8939 return r.ValueOf(func(arg0 string, 8940 8941 arg1 uint16, 8942 8943 ) { 8944 env := newEnv4Func(env, nbind, nintbind, debugC) 8945 { 8946 place := r.New(TypeOfString).Elem() 8947 place.SetString(arg0, 8948 ) 8949 env.Vals[indexes[0]] = place 8950 } 8951 8952 *(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 8953 8954 funcbody(env) 8955 8956 env.freeEnv4Func() 8957 }) 8958 } 8959 } 8960 case r.Uint32: 8961 { 8962 if funcbody == nil { 8963 funv := r.ValueOf(func(string, 8964 8965 uint32) {}) 8966 ret = func(env *Env) r.Value { return funv } 8967 8968 break 8969 } 8970 ret = func(env *Env) r.Value { 8971 8972 env.MarkUsedByClosure() 8973 return r.ValueOf(func(arg0 string, 8974 8975 arg1 uint32, 8976 8977 ) { 8978 env := newEnv4Func(env, nbind, nintbind, debugC) 8979 { 8980 place := r.New(TypeOfString).Elem() 8981 place.SetString(arg0, 8982 ) 8983 env.Vals[indexes[0]] = place 8984 } 8985 8986 *(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 8987 8988 funcbody(env) 8989 8990 env.freeEnv4Func() 8991 }) 8992 } 8993 } 8994 case r.Uint64: 8995 { 8996 if funcbody == nil { 8997 funv := r.ValueOf(func(string, 8998 8999 uint64) {}) 9000 ret = func(env *Env) r.Value { return funv } 9001 9002 break 9003 } 9004 ret = func(env *Env) r.Value { 9005 9006 env.MarkUsedByClosure() 9007 return r.ValueOf(func(arg0 string, 9008 9009 arg1 uint64, 9010 9011 ) { 9012 env := newEnv4Func(env, nbind, nintbind, debugC) 9013 { 9014 place := r.New(TypeOfString).Elem() 9015 place.SetString(arg0, 9016 ) 9017 env.Vals[indexes[0]] = place 9018 } 9019 9020 env.Ints[indexes[1]] = arg1 9021 9022 funcbody(env) 9023 9024 env.freeEnv4Func() 9025 }) 9026 } 9027 } 9028 case r.Uintptr: 9029 { 9030 if funcbody == nil { 9031 funv := r.ValueOf(func(string, 9032 9033 uintptr) {}) 9034 ret = func(env *Env) r.Value { return funv } 9035 9036 break 9037 } 9038 ret = func(env *Env) r.Value { 9039 9040 env.MarkUsedByClosure() 9041 return r.ValueOf(func(arg0 string, 9042 9043 arg1 uintptr, 9044 9045 ) { 9046 env := newEnv4Func(env, nbind, nintbind, debugC) 9047 { 9048 place := r.New(TypeOfString).Elem() 9049 place.SetString(arg0, 9050 ) 9051 env.Vals[indexes[0]] = place 9052 } 9053 9054 *(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 9055 9056 funcbody(env) 9057 9058 env.freeEnv4Func() 9059 }) 9060 } 9061 } 9062 case r.Float32: 9063 { 9064 if funcbody == nil { 9065 funv := r.ValueOf(func(string, 9066 9067 float32) {}) 9068 ret = func(env *Env) r.Value { return funv } 9069 9070 break 9071 } 9072 ret = func(env *Env) r.Value { 9073 9074 env.MarkUsedByClosure() 9075 return r.ValueOf(func(arg0 string, 9076 9077 arg1 float32, 9078 9079 ) { 9080 env := newEnv4Func(env, nbind, nintbind, debugC) 9081 { 9082 place := r.New(TypeOfString).Elem() 9083 place.SetString(arg0, 9084 ) 9085 env.Vals[indexes[0]] = place 9086 } 9087 9088 *(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 9089 9090 funcbody(env) 9091 9092 env.freeEnv4Func() 9093 }) 9094 } 9095 } 9096 case r.Float64: 9097 { 9098 if funcbody == nil { 9099 funv := r.ValueOf(func(string, 9100 9101 float64) {}) 9102 ret = func(env *Env) r.Value { return funv } 9103 9104 break 9105 } 9106 ret = func(env *Env) r.Value { 9107 9108 env.MarkUsedByClosure() 9109 return r.ValueOf(func(arg0 string, 9110 9111 arg1 float64, 9112 9113 ) { 9114 env := newEnv4Func(env, nbind, nintbind, debugC) 9115 { 9116 place := r.New(TypeOfString).Elem() 9117 place.SetString(arg0, 9118 ) 9119 env.Vals[indexes[0]] = place 9120 } 9121 9122 *(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 9123 9124 funcbody(env) 9125 9126 env.freeEnv4Func() 9127 }) 9128 } 9129 } 9130 case r.Complex64: 9131 { 9132 if funcbody == nil { 9133 funv := r.ValueOf(func(string, 9134 9135 complex64) {}) 9136 ret = func(env *Env) r.Value { return funv } 9137 9138 break 9139 } 9140 ret = func(env *Env) r.Value { 9141 9142 env.MarkUsedByClosure() 9143 return r.ValueOf(func(arg0 string, 9144 9145 arg1 complex64, 9146 ) { 9147 env := newEnv4Func(env, nbind, nintbind, debugC) 9148 { 9149 place := r.New(TypeOfString).Elem() 9150 place.SetString(arg0, 9151 ) 9152 env.Vals[indexes[0]] = place 9153 } 9154 9155 *(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 9156 9157 funcbody(env) 9158 9159 env.freeEnv4Func() 9160 }) 9161 } 9162 } 9163 case r.Complex128: 9164 { 9165 if funcbody == nil { 9166 funv := r.ValueOf(func(string, 9167 9168 complex128) {}) 9169 ret = func(env *Env) r.Value { return funv } 9170 9171 break 9172 } 9173 ret = func(env *Env) r.Value { 9174 9175 env.MarkUsedByClosure() 9176 return r.ValueOf(func(arg0 string, 9177 9178 arg1 complex128) { 9179 env := newEnv4Func(env, nbind, nintbind, debugC) 9180 { 9181 place := r.New(TypeOfString).Elem() 9182 place.SetString(arg0, 9183 ) 9184 env.Vals[indexes[0]] = place 9185 } 9186 9187 *(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1 9188 9189 funcbody(env) 9190 9191 env.freeEnv4Func() 9192 }) 9193 } 9194 } 9195 case r.String: 9196 { 9197 if funcbody == nil { 9198 funv := r.ValueOf(func(string, 9199 9200 string) {}) 9201 ret = func(env *Env) r.Value { return funv } 9202 9203 break 9204 } 9205 ret = func(env *Env) r.Value { 9206 9207 env.MarkUsedByClosure() 9208 return r.ValueOf(func(arg0 string, 9209 9210 arg1 string) { 9211 env := newEnv4Func(env, nbind, nintbind, debugC) 9212 { 9213 place := r.New(TypeOfString).Elem() 9214 place.SetString(arg0, 9215 ) 9216 env.Vals[indexes[0]] = place 9217 } 9218 { 9219 place := r.New(TypeOfString).Elem() 9220 place.SetString(arg1, 9221 ) 9222 env.Vals[indexes[1]] = place 9223 } 9224 9225 funcbody(env) 9226 9227 env.freeEnv4Func() 9228 }) 9229 } 9230 } 9231 } 9232 return ret 9233} 9234