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 * callnret0.go 17 * 18 * Created on Apr 15, 2017 19 * Author Massimiliano Ghilardi 20 */ 21 22package fast 23 24import ( 25 r "reflect" 26 "github.com/cosmos72/gomacro/base/reflect" 27) 28 29func (c *Comp) call0ret0(call *Call, maxdepth int) func(env *Env) { 30 expr := call.Fun 31 funsym := expr.Sym 32 if funsym == nil { 33 exprfun := expr.AsX1() 34 return func(env *Env) { 35 fun := exprfun(env).Interface().(func()) 36 fun() 37 } 38 } 39 40 var cachedfunv r.Value 41 var cachedfun func() 42 43 funupn := funsym.Upn 44 funindex := funsym.Desc.Index() 45 switch funupn { 46 case maxdepth - 1: 47 return func(env *Env) { 48 funv := env.FileEnv.Vals[funindex] 49 if cachedfunv != funv { 50 cachedfunv = funv 51 cachedfun = funv.Interface().(func()) 52 } 53 cachedfun() 54 } 55 case 0: 56 return func(env *Env) { 57 fun := env.Vals[funindex].Interface().(func()) 58 fun() 59 } 60 case 1: 61 return func(env *Env) { 62 fun := env.Outer.Vals[funindex].Interface().(func()) 63 fun() 64 } 65 case 2: 66 return func(env *Env) { 67 fun := env.Outer.Outer.Vals[funindex].Interface().(func()) 68 fun() 69 } 70 default: 71 return func(env *Env) { 72 env = env.Outer.Outer.Outer.Outer 73 for i := 3; i < funupn; i++ { 74 env = env.Outer 75 } 76 77 fun := env.Vals[funindex].Interface().(func()) 78 fun() 79 } 80 } 81} 82func (c *Comp) call1ret0(call *Call, maxdepth int) func(env *Env) { 83 expr := call.Fun 84 exprfun := expr.AsX1() 85 funsym := expr.Sym 86 funupn, funindex := -1, -1 87 if funsym != nil { 88 funupn = funsym.Upn 89 funindex = funsym.Desc.Index() 90 if funindex == NoIndex { 91 c.Errorf("internal error: call1ret0() invoked for constant function %#v. use call_builtin() instead", expr) 92 } 93 94 } 95 arg := call.Args[0] 96 argfun := call.MakeArgfunsX1()[0] 97 98 var cachedfunv r.Value 99 var ret func(env *Env) 100 101 t := expr.Type.In(0) 102 k := t.Kind() 103 if reflect.KindToType(k) == t.ReflectType() { 104 switch k { 105 case r.Bool: 106 107 if arg.Const() { 108 argconst := r.ValueOf(arg.Value).Bool() 109 if funsym != nil && funupn == maxdepth-1 { 110 var cachedfun func(bool, 111 112 ) 113 ret = func(env *Env) { 114 funv := env.FileEnv.Vals[funindex] 115 if cachedfunv != funv { 116 cachedfunv = funv 117 cachedfun = funv.Interface().(func( 118 119 bool)) 120 } 121 122 cachedfun(argconst) 123 } 124 } else { 125 ret = func(env *Env) { 126 fun := exprfun(env).Interface().(func(bool, 127 128 )) 129 130 fun(argconst) 131 } 132 } 133 134 } else { 135 argfun := arg.Fun.(func(env *Env) bool) 136 if funsym != nil && funupn == maxdepth-1 { 137 var cachedfun func(bool, 138 139 ) 140 ret = func(env *Env) { 141 funv := env.FileEnv.Vals[funindex] 142 if cachedfunv != funv { 143 cachedfunv = funv 144 cachedfun = funv.Interface().(func( 145 146 bool)) 147 } 148 149 arg := argfun(env) 150 151 cachedfun(arg) 152 } 153 } else { 154 ret = func(env *Env) { 155 fun := exprfun(env).Interface().(func(bool, 156 157 )) 158 arg := argfun(env) 159 160 fun(arg) 161 } 162 } 163 164 } 165 case r.Int: 166 167 if arg.Const() { 168 argconst := int(r.ValueOf(arg.Value).Int()) 169 if funsym != nil && funupn == maxdepth-1 { 170 var cachedfun func(int, 171 172 ) 173 ret = func(env *Env) { 174 funv := env.FileEnv.Vals[funindex] 175 if cachedfunv != funv { 176 cachedfunv = funv 177 cachedfun = funv.Interface().(func( 178 179 int)) 180 } 181 182 cachedfun(argconst) 183 } 184 } else { 185 ret = func(env *Env) { 186 fun := exprfun(env).Interface().(func(int, 187 188 )) 189 190 fun(argconst) 191 } 192 } 193 194 } else { 195 argfun := arg.Fun.(func(env *Env) int) 196 if funsym != nil && funupn == maxdepth-1 { 197 var cachedfun func(int, 198 199 ) 200 ret = func(env *Env) { 201 funv := env.FileEnv.Vals[funindex] 202 if cachedfunv != funv { 203 cachedfunv = funv 204 cachedfun = funv.Interface().(func( 205 206 int)) 207 } 208 209 arg := argfun(env) 210 211 cachedfun(arg) 212 } 213 } else { 214 ret = func(env *Env) { 215 fun := exprfun(env).Interface().(func(int, 216 217 )) 218 arg := argfun(env) 219 220 fun(arg) 221 } 222 } 223 224 } 225 case r.Int8: 226 if arg.Const() { 227 argconst := int8(r.ValueOf(arg.Value).Int()) 228 if funsym != nil && funupn == maxdepth-1 { 229 var cachedfun func(int8, 230 231 ) 232 ret = func(env *Env) { 233 funv := env.FileEnv.Vals[funindex] 234 if cachedfunv != funv { 235 cachedfunv = funv 236 cachedfun = funv.Interface().(func( 237 238 int8)) 239 } 240 241 cachedfun(argconst) 242 } 243 } else { 244 ret = func(env *Env) { 245 fun := exprfun(env).Interface().(func(int8, 246 247 )) 248 249 fun(argconst) 250 } 251 } 252 253 } else { 254 argfun := arg.Fun.(func(env *Env) int8) 255 if funsym != nil && funupn == maxdepth-1 { 256 var cachedfun func(int8, 257 258 ) 259 ret = func(env *Env) { 260 funv := env.FileEnv.Vals[funindex] 261 if cachedfunv != funv { 262 cachedfunv = funv 263 cachedfun = funv.Interface().(func( 264 265 int8)) 266 } 267 268 arg := argfun(env) 269 270 cachedfun(arg) 271 } 272 } else { 273 ret = func(env *Env) { 274 fun := exprfun(env).Interface().(func(int8, 275 276 )) 277 arg := argfun(env) 278 279 fun(arg) 280 } 281 } 282 283 } 284 case r.Int16: 285 if arg.Const() { 286 argconst := int16(r.ValueOf(arg.Value).Int()) 287 if funsym != nil && funupn == maxdepth-1 { 288 var cachedfun func(int16, 289 290 ) 291 ret = func(env *Env) { 292 funv := env.FileEnv.Vals[funindex] 293 if cachedfunv != funv { 294 cachedfunv = funv 295 cachedfun = funv.Interface().(func( 296 297 int16)) 298 } 299 300 cachedfun(argconst) 301 } 302 } else { 303 ret = func(env *Env) { 304 fun := exprfun(env).Interface().(func(int16, 305 306 )) 307 308 fun(argconst) 309 } 310 } 311 312 } else { 313 argfun := arg.Fun.(func(env *Env) int16) 314 if funsym != nil && funupn == maxdepth-1 { 315 var cachedfun func(int16, 316 317 ) 318 ret = func(env *Env) { 319 funv := env.FileEnv.Vals[funindex] 320 if cachedfunv != funv { 321 cachedfunv = funv 322 cachedfun = funv.Interface().(func( 323 324 int16)) 325 } 326 327 arg := argfun(env) 328 329 cachedfun(arg) 330 } 331 } else { 332 ret = func(env *Env) { 333 fun := exprfun(env).Interface().(func(int16, 334 335 )) 336 arg := argfun(env) 337 338 fun(arg) 339 } 340 } 341 342 } 343 case r.Int32: 344 if arg.Const() { 345 argconst := int32(r.ValueOf(arg.Value).Int()) 346 if funsym != nil && funupn == maxdepth-1 { 347 var cachedfun func(int32, 348 349 ) 350 ret = func(env *Env) { 351 funv := env.FileEnv.Vals[funindex] 352 if cachedfunv != funv { 353 cachedfunv = funv 354 cachedfun = funv.Interface().(func( 355 356 int32)) 357 } 358 359 cachedfun(argconst) 360 } 361 } else { 362 ret = func(env *Env) { 363 fun := exprfun(env).Interface().(func(int32, 364 365 )) 366 367 fun(argconst) 368 } 369 } 370 371 } else { 372 argfun := arg.Fun.(func(env *Env) int32) 373 if funsym != nil && funupn == maxdepth-1 { 374 var cachedfun func(int32, 375 376 ) 377 ret = func(env *Env) { 378 funv := env.FileEnv.Vals[funindex] 379 if cachedfunv != funv { 380 cachedfunv = funv 381 cachedfun = funv.Interface().(func( 382 383 int32)) 384 } 385 386 arg := argfun(env) 387 388 cachedfun(arg) 389 } 390 } else { 391 ret = func(env *Env) { 392 fun := exprfun(env).Interface().(func(int32, 393 394 )) 395 arg := argfun(env) 396 397 fun(arg) 398 } 399 } 400 401 } 402 case r.Int64: 403 if arg.Const() { 404 argconst := r.ValueOf(arg.Value).Int() 405 if funsym != nil && funupn == maxdepth-1 { 406 var cachedfun func(int64, 407 ) 408 ret = func(env *Env) { 409 funv := env.FileEnv.Vals[funindex] 410 if cachedfunv != funv { 411 cachedfunv = funv 412 cachedfun = funv.Interface().(func( 413 414 int64)) 415 } 416 417 cachedfun(argconst) 418 } 419 } else { 420 ret = func(env *Env) { 421 fun := exprfun(env).Interface().(func(int64, 422 423 )) 424 425 fun(argconst) 426 } 427 } 428 429 } else { 430 argfun := arg.Fun.(func(env *Env) int64) 431 if funsym != nil && funupn == maxdepth-1 { 432 var cachedfun func(int64, 433 434 ) 435 ret = func(env *Env) { 436 funv := env.FileEnv.Vals[funindex] 437 if cachedfunv != funv { 438 cachedfunv = funv 439 cachedfun = funv.Interface().(func( 440 441 int64)) 442 } 443 444 arg := argfun(env) 445 446 cachedfun(arg) 447 } 448 } else { 449 ret = func(env *Env) { 450 fun := exprfun(env).Interface().(func(int64, 451 452 )) 453 arg := argfun(env) 454 455 fun(arg) 456 } 457 } 458 459 } 460 case r.Uint: 461 if arg.Const() { 462 argconst := 463 464 uint(r.ValueOf(arg.Value).Uint()) 465 if funsym != nil && funupn == maxdepth-1 { 466 var cachedfun func(uint) 467 ret = func(env *Env) { 468 funv := env.FileEnv.Vals[funindex] 469 if cachedfunv != funv { 470 cachedfunv = funv 471 cachedfun = funv.Interface().(func( 472 473 uint)) 474 } 475 476 cachedfun(argconst) 477 } 478 } else { 479 ret = func(env *Env) { 480 fun := exprfun(env).Interface().(func(uint, 481 482 )) 483 484 fun(argconst) 485 } 486 } 487 488 } else { 489 argfun := arg.Fun.(func(env *Env) uint) 490 if funsym != nil && funupn == maxdepth-1 { 491 var cachedfun func(uint, 492 493 ) 494 ret = func(env *Env) { 495 funv := env.FileEnv.Vals[funindex] 496 if cachedfunv != funv { 497 cachedfunv = funv 498 cachedfun = funv.Interface().(func( 499 500 uint)) 501 } 502 503 arg := argfun(env) 504 505 cachedfun(arg) 506 } 507 } else { 508 ret = func(env *Env) { 509 fun := exprfun(env).Interface().(func(uint, 510 511 )) 512 arg := argfun(env) 513 514 fun(arg) 515 } 516 } 517 518 } 519 case r.Uint8: 520 if arg.Const() { 521 argconst := 522 523 uint8(r.ValueOf(arg.Value).Uint()) 524 if funsym != nil && funupn == maxdepth-1 { 525 var cachedfun func( 526 uint8) 527 ret = func(env *Env) { 528 funv := env.FileEnv.Vals[funindex] 529 if cachedfunv != funv { 530 cachedfunv = funv 531 cachedfun = funv.Interface().(func( 532 533 uint8)) 534 } 535 536 cachedfun(argconst) 537 } 538 } else { 539 ret = func(env *Env) { 540 fun := exprfun(env).Interface().(func(uint8, 541 542 )) 543 544 fun(argconst) 545 } 546 } 547 548 } else { 549 argfun := arg.Fun.(func(env *Env) uint8) 550 if funsym != nil && funupn == maxdepth-1 { 551 var cachedfun func(uint8, 552 553 ) 554 ret = func(env *Env) { 555 funv := env.FileEnv.Vals[funindex] 556 if cachedfunv != funv { 557 cachedfunv = funv 558 cachedfun = funv.Interface().(func( 559 560 uint8)) 561 } 562 563 arg := argfun(env) 564 565 cachedfun(arg) 566 } 567 } else { 568 ret = func(env *Env) { 569 fun := exprfun(env).Interface().(func(uint8, 570 571 )) 572 arg := argfun(env) 573 574 fun(arg) 575 } 576 } 577 578 } 579 case r.Uint16: 580 if arg.Const() { 581 argconst := 582 583 uint16(r.ValueOf(arg.Value).Uint()) 584 if funsym != nil && funupn == maxdepth-1 { 585 var cachedfun func( 586 587 uint16) 588 ret = func(env *Env) { 589 funv := env.FileEnv.Vals[funindex] 590 if cachedfunv != funv { 591 cachedfunv = funv 592 cachedfun = funv.Interface().(func( 593 594 uint16)) 595 } 596 597 cachedfun(argconst) 598 } 599 } else { 600 ret = func(env *Env) { 601 fun := exprfun(env).Interface().(func(uint16, 602 603 )) 604 605 fun(argconst) 606 } 607 } 608 609 } else { 610 argfun := arg.Fun.(func(env *Env) uint16) 611 if funsym != nil && funupn == maxdepth-1 { 612 var cachedfun func(uint16, 613 614 ) 615 ret = func(env *Env) { 616 funv := env.FileEnv.Vals[funindex] 617 if cachedfunv != funv { 618 cachedfunv = funv 619 cachedfun = funv.Interface().(func( 620 621 uint16)) 622 } 623 624 arg := argfun(env) 625 626 cachedfun(arg) 627 } 628 } else { 629 ret = func(env *Env) { 630 fun := exprfun(env).Interface().(func(uint16, 631 632 )) 633 arg := argfun(env) 634 635 fun(arg) 636 } 637 } 638 639 } 640 case r.Uint32: 641 if arg.Const() { 642 argconst := 643 644 uint32(r.ValueOf(arg.Value).Uint()) 645 if funsym != nil && funupn == maxdepth-1 { 646 var cachedfun func( 647 648 uint32) 649 ret = func(env *Env) { 650 funv := env.FileEnv.Vals[funindex] 651 if cachedfunv != funv { 652 cachedfunv = funv 653 cachedfun = funv.Interface().(func( 654 655 uint32)) 656 } 657 658 cachedfun(argconst) 659 } 660 } else { 661 ret = func(env *Env) { 662 fun := exprfun(env).Interface().(func(uint32, 663 664 )) 665 666 fun(argconst) 667 } 668 } 669 670 } else { 671 argfun := arg.Fun.(func(env *Env) uint32) 672 if funsym != nil && funupn == maxdepth-1 { 673 var cachedfun func(uint32, 674 675 ) 676 ret = func(env *Env) { 677 funv := env.FileEnv.Vals[funindex] 678 if cachedfunv != funv { 679 cachedfunv = funv 680 cachedfun = funv.Interface().(func( 681 682 uint32)) 683 } 684 685 arg := argfun(env) 686 687 cachedfun(arg) 688 } 689 } else { 690 ret = func(env *Env) { 691 fun := exprfun(env).Interface().(func(uint32, 692 693 )) 694 arg := argfun(env) 695 696 fun(arg) 697 } 698 } 699 700 } 701 case r.Uint64: 702 if arg.Const() { 703 argconst := r.ValueOf(arg.Value).Uint() 704 if funsym != nil && funupn == maxdepth-1 { 705 var cachedfun func( 706 707 uint64) 708 ret = func(env *Env) { 709 funv := env.FileEnv.Vals[funindex] 710 if cachedfunv != funv { 711 cachedfunv = funv 712 cachedfun = funv.Interface().(func( 713 714 uint64)) 715 } 716 717 cachedfun(argconst) 718 } 719 } else { 720 ret = func(env *Env) { 721 fun := exprfun(env).Interface().(func(uint64, 722 723 )) 724 725 fun(argconst) 726 } 727 } 728 729 } else { 730 argfun := arg.Fun.(func(env *Env) uint64) 731 if funsym != nil && funupn == maxdepth-1 { 732 var cachedfun func(uint64, 733 734 ) 735 ret = func(env *Env) { 736 funv := env.FileEnv.Vals[funindex] 737 if cachedfunv != funv { 738 cachedfunv = funv 739 cachedfun = funv.Interface().(func( 740 741 uint64)) 742 } 743 744 arg := argfun(env) 745 746 cachedfun(arg) 747 } 748 } else { 749 ret = func(env *Env) { 750 fun := exprfun(env).Interface().(func(uint64, 751 752 )) 753 arg := argfun(env) 754 755 fun(arg) 756 } 757 } 758 759 } 760 case r.Uintptr: 761 if arg.Const() { 762 argconst := 763 764 uintptr(r.ValueOf(arg.Value).Uint()) 765 if funsym != nil && funupn == maxdepth-1 { 766 var cachedfun func( 767 768 uintptr) 769 ret = func(env *Env) { 770 funv := env.FileEnv.Vals[funindex] 771 if cachedfunv != funv { 772 cachedfunv = funv 773 cachedfun = funv.Interface().(func( 774 775 uintptr)) 776 } 777 778 cachedfun(argconst) 779 } 780 } else { 781 ret = func(env *Env) { 782 fun := exprfun(env).Interface().(func(uintptr, 783 784 )) 785 786 fun(argconst) 787 } 788 } 789 790 } else { 791 argfun := arg.Fun.(func(env *Env) uintptr) 792 if funsym != nil && funupn == maxdepth-1 { 793 var cachedfun func(uintptr, 794 795 ) 796 ret = func(env *Env) { 797 funv := env.FileEnv.Vals[funindex] 798 if cachedfunv != funv { 799 cachedfunv = funv 800 cachedfun = funv.Interface().(func( 801 802 uintptr)) 803 } 804 805 arg := argfun(env) 806 807 cachedfun(arg) 808 } 809 } else { 810 ret = func(env *Env) { 811 fun := exprfun(env).Interface().(func(uintptr, 812 813 )) 814 arg := argfun(env) 815 816 fun(arg) 817 } 818 } 819 820 } 821 case r.Float32: 822 if arg.Const() { 823 argconst := 824 825 float32(r.ValueOf(arg.Value).Float()) 826 if funsym != nil && funupn == maxdepth-1 { 827 var cachedfun func( 828 829 float32) 830 ret = func(env *Env) { 831 funv := env.FileEnv.Vals[funindex] 832 if cachedfunv != funv { 833 cachedfunv = funv 834 cachedfun = funv.Interface().(func( 835 836 float32)) 837 } 838 839 cachedfun(argconst) 840 } 841 } else { 842 ret = func(env *Env) { 843 fun := exprfun(env).Interface().(func(float32, 844 845 )) 846 847 fun(argconst) 848 } 849 } 850 851 } else { 852 argfun := arg.Fun.(func(env *Env) float32) 853 if funsym != nil && funupn == maxdepth-1 { 854 var cachedfun func(float32, 855 856 ) 857 ret = func(env *Env) { 858 funv := env.FileEnv.Vals[funindex] 859 if cachedfunv != funv { 860 cachedfunv = funv 861 cachedfun = funv.Interface().(func( 862 863 float32)) 864 } 865 866 arg := argfun(env) 867 868 cachedfun(arg) 869 } 870 } else { 871 ret = func(env *Env) { 872 fun := exprfun(env).Interface().(func(float32, 873 874 )) 875 arg := argfun(env) 876 877 fun(arg) 878 } 879 } 880 881 } 882 case r.Float64: 883 if arg.Const() { 884 argconst := r.ValueOf(arg.Value).Float() 885 if funsym != nil && funupn == maxdepth-1 { 886 var cachedfun func( 887 888 float64) 889 ret = func(env *Env) { 890 funv := env.FileEnv.Vals[funindex] 891 if cachedfunv != funv { 892 cachedfunv = funv 893 cachedfun = funv.Interface().(func( 894 895 float64)) 896 } 897 898 cachedfun(argconst) 899 } 900 } else { 901 ret = func(env *Env) { 902 fun := exprfun(env).Interface().(func(float64, 903 904 )) 905 906 fun(argconst) 907 } 908 } 909 910 } else { 911 argfun := arg.Fun.(func(env *Env) float64) 912 if funsym != nil && funupn == maxdepth-1 { 913 var cachedfun func(float64, 914 915 ) 916 ret = func(env *Env) { 917 funv := env.FileEnv.Vals[funindex] 918 if cachedfunv != funv { 919 cachedfunv = funv 920 cachedfun = funv.Interface().(func( 921 922 float64)) 923 } 924 925 arg := argfun(env) 926 927 cachedfun(arg) 928 } 929 } else { 930 ret = func(env *Env) { 931 fun := exprfun(env).Interface().(func(float64, 932 933 )) 934 arg := argfun(env) 935 936 fun(arg) 937 } 938 } 939 940 } 941 case r.Complex64: 942 if arg.Const() { 943 argconst := 944 945 complex64(r.ValueOf(arg.Value).Complex()) 946 if funsym != nil && funupn == maxdepth-1 { 947 var cachedfun func( 948 949 complex64) 950 ret = func(env *Env) { 951 funv := env.FileEnv.Vals[funindex] 952 if cachedfunv != funv { 953 cachedfunv = funv 954 cachedfun = funv.Interface().(func( 955 956 complex64)) 957 } 958 959 cachedfun(argconst) 960 } 961 } else { 962 ret = func(env *Env) { 963 fun := exprfun(env).Interface().(func(complex64, 964 )) 965 966 fun(argconst) 967 } 968 } 969 970 } else { 971 argfun := arg.Fun.(func(env *Env) complex64) 972 if funsym != nil && funupn == maxdepth-1 { 973 var cachedfun func(complex64, 974 975 ) 976 ret = func(env *Env) { 977 funv := env.FileEnv.Vals[funindex] 978 if cachedfunv != funv { 979 cachedfunv = funv 980 cachedfun = funv.Interface().(func( 981 982 complex64)) 983 } 984 985 arg := argfun(env) 986 987 cachedfun(arg) 988 } 989 } else { 990 ret = func(env *Env) { 991 fun := exprfun(env).Interface().(func(complex64, 992 993 )) 994 arg := argfun(env) 995 996 fun(arg) 997 } 998 } 999 1000 } 1001 case r.Complex128: 1002 if arg.Const() { 1003 argconst := r.ValueOf(arg.Value).Complex() 1004 if funsym != nil && funupn == maxdepth-1 { 1005 var cachedfun func( 1006 1007 complex128) 1008 ret = func(env *Env) { 1009 funv := env.FileEnv.Vals[funindex] 1010 if cachedfunv != funv { 1011 cachedfunv = funv 1012 cachedfun = funv.Interface().(func( 1013 1014 complex128)) 1015 } 1016 1017 cachedfun(argconst) 1018 } 1019 } else { 1020 ret = func(env *Env) { 1021 fun := exprfun(env).Interface().(func(complex128)) 1022 1023 fun(argconst) 1024 } 1025 } 1026 1027 } else { 1028 argfun := arg.Fun.(func(env *Env) complex128) 1029 if funsym != nil && funupn == maxdepth-1 { 1030 var cachedfun func(complex128, 1031 1032 ) 1033 ret = func(env *Env) { 1034 funv := env.FileEnv.Vals[funindex] 1035 if cachedfunv != funv { 1036 cachedfunv = funv 1037 cachedfun = funv.Interface().(func( 1038 1039 complex128)) 1040 } 1041 1042 arg := argfun(env) 1043 1044 cachedfun(arg) 1045 } 1046 } else { 1047 ret = func(env *Env) { 1048 fun := exprfun(env).Interface().(func(complex128, 1049 1050 )) 1051 arg := argfun(env) 1052 1053 fun(arg) 1054 } 1055 } 1056 1057 } 1058 case r.String: 1059 if arg.Const() { 1060 argconst := r.ValueOf(arg.Value).String() 1061 if funsym != nil && funupn == maxdepth-1 { 1062 var cachedfun func( 1063 1064 string) 1065 ret = func(env *Env) { 1066 funv := env.FileEnv.Vals[funindex] 1067 if cachedfunv != funv { 1068 cachedfunv = funv 1069 cachedfun = funv.Interface().(func( 1070 1071 string)) 1072 } 1073 1074 cachedfun(argconst) 1075 } 1076 } else { 1077 ret = func(env *Env) { 1078 fun := exprfun(env).Interface().(func( 1079 string)) 1080 1081 fun(argconst) 1082 } 1083 } 1084 1085 } else { 1086 argfun := arg.Fun.(func(env *Env) string) 1087 if funsym != nil && funupn == maxdepth-1 { 1088 var cachedfun func(string, 1089 1090 ) 1091 ret = func(env *Env) { 1092 funv := env.FileEnv.Vals[funindex] 1093 if cachedfunv != funv { 1094 cachedfunv = funv 1095 cachedfun = funv.Interface().(func( 1096 1097 string)) 1098 } 1099 1100 arg := argfun(env) 1101 1102 cachedfun(arg) 1103 } 1104 } else { 1105 ret = func(env *Env) { 1106 fun := exprfun(env).Interface().(func(string, 1107 1108 )) 1109 arg := argfun(env) 1110 1111 fun(arg) 1112 } 1113 } 1114 1115 } 1116 } 1117 } 1118 1119 if ret == nil { 1120 ret = func(env *Env) { 1121 funv := exprfun(env) 1122 1123 argv := []r.Value{ 1124 argfun(env), 1125 } 1126 callxr(funv, argv) 1127 } 1128 } 1129 return ret 1130} 1131func (c *Comp) call2ret0(call *Call, maxdepth int) func(env *Env) { 1132 expr := call.Fun 1133 exprfun := expr.AsX1() 1134 funsym := expr.Sym 1135 funupn, funindex := -1, -1 1136 if funsym != nil { 1137 funupn = funsym.Upn 1138 funindex = funsym.Desc.Index() 1139 if funindex == NoIndex { 1140 c.Errorf("internal error: call2ret0() invoked for constant function %#v. use call_builtin() instead", expr) 1141 } 1142 1143 } 1144 args := call.Args 1145 argfunsX1 := call.MakeArgfunsX1() 1146 argfuns := [2]func(*Env) r.Value{ 1147 argfunsX1[0], 1148 argfunsX1[1], 1149 } 1150 var cachedfunv r.Value 1151 var ret func(env *Env) 1152 1153 t := expr.Type.In(0) 1154 rt := t.ReflectType() 1155 k := t.Kind() 1156 if reflect.KindToType(k) == rt && expr.Type.In(1).ReflectType() == rt { 1157 switch k { 1158 case r.Bool: 1159 { 1160 arg0fun := args[0].WithFun().(func(*Env) bool) 1161 arg1fun := args[1].WithFun().(func(*Env) bool) 1162 1163 if funsym != nil && funupn == maxdepth-1 { 1164 var cachedfun func(bool, bool, 1165 1166 ) 1167 ret = func(env *Env) { 1168 funv := env.FileEnv.Vals[funindex] 1169 if cachedfunv != funv { 1170 cachedfunv = funv 1171 cachedfun = funv.Interface().(func( 1172 1173 bool, bool)) 1174 } 1175 1176 arg0 := arg0fun(env) 1177 arg1 := arg1fun(env) 1178 cachedfun(arg0, arg1) 1179 } 1180 } else { 1181 ret = func(env *Env) { 1182 fun := exprfun(env).Interface().(func(bool, bool, 1183 1184 )) 1185 arg0 := arg0fun(env) 1186 arg1 := arg1fun(env) 1187 fun(arg0, arg1) 1188 } 1189 } 1190 1191 } 1192 case r.Int: 1193 { 1194 arg0fun := args[0].WithFun().(func(*Env) int) 1195 arg1fun := args[1].WithFun().(func(*Env) int) 1196 1197 if funsym != nil && funupn == maxdepth-1 { 1198 var cachedfun func(int, int, 1199 ) 1200 ret = func(env *Env) { 1201 funv := env.FileEnv.Vals[funindex] 1202 if cachedfunv != funv { 1203 cachedfunv = funv 1204 cachedfun = funv.Interface().(func( 1205 1206 int, int)) 1207 } 1208 1209 arg0 := arg0fun(env) 1210 arg1 := arg1fun(env) 1211 cachedfun(arg0, arg1) 1212 } 1213 } else { 1214 ret = func(env *Env) { 1215 fun := exprfun(env).Interface().(func(int, int, 1216 1217 )) 1218 arg0 := arg0fun(env) 1219 arg1 := arg1fun(env) 1220 fun(arg0, arg1) 1221 } 1222 } 1223 1224 } 1225 case r.Int8: 1226 { 1227 arg0fun := args[0].WithFun().(func(*Env) int8) 1228 arg1fun := args[1].WithFun().(func(*Env) int8) 1229 1230 if funsym != nil && funupn == maxdepth-1 { 1231 var cachedfun func(int8, int8) 1232 ret = func(env *Env) { 1233 funv := env.FileEnv.Vals[funindex] 1234 if cachedfunv != funv { 1235 cachedfunv = funv 1236 cachedfun = funv.Interface().(func( 1237 1238 int8, int8)) 1239 } 1240 1241 arg0 := arg0fun(env) 1242 arg1 := arg1fun(env) 1243 cachedfun(arg0, arg1) 1244 } 1245 } else { 1246 ret = func(env *Env) { 1247 fun := exprfun(env).Interface().(func(int8, int8, 1248 1249 )) 1250 arg0 := arg0fun(env) 1251 arg1 := arg1fun(env) 1252 fun(arg0, arg1) 1253 } 1254 } 1255 1256 } 1257 case r.Int16: 1258 { 1259 arg0fun := args[0].WithFun().(func(*Env) int16) 1260 arg1fun := args[1].WithFun().(func(*Env) int16) 1261 1262 if funsym != nil && funupn == maxdepth-1 { 1263 var cachedfun func( 1264 int16, int16) 1265 ret = func(env *Env) { 1266 funv := env.FileEnv.Vals[funindex] 1267 if cachedfunv != funv { 1268 cachedfunv = funv 1269 cachedfun = funv.Interface().(func( 1270 1271 int16, int16)) 1272 } 1273 1274 arg0 := arg0fun(env) 1275 arg1 := arg1fun(env) 1276 cachedfun(arg0, arg1) 1277 } 1278 } else { 1279 ret = func(env *Env) { 1280 fun := exprfun(env).Interface().(func(int16, int16, 1281 1282 )) 1283 arg0 := arg0fun(env) 1284 arg1 := arg1fun(env) 1285 fun(arg0, arg1) 1286 } 1287 } 1288 1289 } 1290 case r.Int32: 1291 { 1292 arg0fun := args[0].WithFun().(func(*Env) int32) 1293 arg1fun := args[1].WithFun().(func(*Env) int32) 1294 1295 if funsym != nil && funupn == maxdepth-1 { 1296 var cachedfun func( 1297 1298 int32, int32) 1299 ret = func(env *Env) { 1300 funv := env.FileEnv.Vals[funindex] 1301 if cachedfunv != funv { 1302 cachedfunv = funv 1303 cachedfun = funv.Interface().(func( 1304 1305 int32, int32)) 1306 } 1307 1308 arg0 := arg0fun(env) 1309 arg1 := arg1fun(env) 1310 cachedfun(arg0, arg1) 1311 } 1312 } else { 1313 ret = func(env *Env) { 1314 fun := exprfun(env).Interface().(func(int32, int32, 1315 1316 )) 1317 arg0 := arg0fun(env) 1318 arg1 := arg1fun(env) 1319 fun(arg0, arg1) 1320 } 1321 } 1322 1323 } 1324 case r.Int64: 1325 { 1326 arg0fun := args[0].WithFun().(func(*Env) int64) 1327 arg1fun := args[1].WithFun().(func(*Env) int64) 1328 1329 if funsym != nil && funupn == maxdepth-1 { 1330 var cachedfun func( 1331 1332 int64, int64) 1333 ret = func(env *Env) { 1334 funv := env.FileEnv.Vals[funindex] 1335 if cachedfunv != funv { 1336 cachedfunv = funv 1337 cachedfun = funv.Interface().(func( 1338 1339 int64, int64)) 1340 } 1341 1342 arg0 := arg0fun(env) 1343 arg1 := arg1fun(env) 1344 cachedfun(arg0, arg1) 1345 } 1346 } else { 1347 ret = func(env *Env) { 1348 fun := exprfun(env).Interface().(func(int64, int64, 1349 1350 )) 1351 arg0 := arg0fun(env) 1352 arg1 := arg1fun(env) 1353 fun(arg0, arg1) 1354 } 1355 } 1356 1357 } 1358 case r.Uint: 1359 { 1360 arg0fun := args[0].WithFun().(func(*Env) uint) 1361 arg1fun := args[1].WithFun().(func(*Env) uint) 1362 1363 if funsym != nil && funupn == maxdepth-1 { 1364 var cachedfun func( 1365 1366 uint, uint) 1367 ret = func(env *Env) { 1368 funv := env.FileEnv.Vals[funindex] 1369 if cachedfunv != funv { 1370 cachedfunv = funv 1371 cachedfun = funv.Interface().(func( 1372 1373 uint, uint)) 1374 } 1375 1376 arg0 := arg0fun(env) 1377 arg1 := arg1fun(env) 1378 cachedfun(arg0, arg1) 1379 } 1380 } else { 1381 ret = func(env *Env) { 1382 fun := exprfun(env).Interface().(func(uint, uint, 1383 1384 )) 1385 arg0 := arg0fun(env) 1386 arg1 := arg1fun(env) 1387 fun(arg0, arg1) 1388 } 1389 } 1390 1391 } 1392 case r.Uint8: 1393 { 1394 arg0fun := args[0].WithFun().(func(*Env) uint8) 1395 arg1fun := args[1].WithFun().(func(*Env) uint8) 1396 1397 if funsym != nil && funupn == maxdepth-1 { 1398 var cachedfun func( 1399 1400 uint8, uint8) 1401 ret = func(env *Env) { 1402 funv := env.FileEnv.Vals[funindex] 1403 if cachedfunv != funv { 1404 cachedfunv = funv 1405 cachedfun = funv.Interface().(func( 1406 1407 uint8, uint8)) 1408 } 1409 1410 arg0 := arg0fun(env) 1411 arg1 := arg1fun(env) 1412 cachedfun(arg0, arg1) 1413 } 1414 } else { 1415 ret = func(env *Env) { 1416 fun := exprfun(env).Interface().(func(uint8, uint8, 1417 1418 )) 1419 arg0 := arg0fun(env) 1420 arg1 := arg1fun(env) 1421 fun(arg0, arg1) 1422 } 1423 } 1424 1425 } 1426 case r.Uint16: 1427 { 1428 arg0fun := args[0].WithFun().(func(*Env) uint16) 1429 arg1fun := args[1].WithFun().(func(*Env) uint16) 1430 1431 if funsym != nil && funupn == maxdepth-1 { 1432 var cachedfun func( 1433 1434 uint16, uint16) 1435 ret = func(env *Env) { 1436 funv := env.FileEnv.Vals[funindex] 1437 if cachedfunv != funv { 1438 cachedfunv = funv 1439 cachedfun = funv.Interface().(func( 1440 1441 uint16, uint16)) 1442 } 1443 1444 arg0 := arg0fun(env) 1445 arg1 := arg1fun(env) 1446 cachedfun(arg0, arg1) 1447 } 1448 } else { 1449 ret = func(env *Env) { 1450 fun := exprfun(env).Interface().(func(uint16, uint16, 1451 1452 )) 1453 arg0 := arg0fun(env) 1454 arg1 := arg1fun(env) 1455 fun(arg0, arg1) 1456 } 1457 } 1458 1459 } 1460 case r.Uint32: 1461 { 1462 arg0fun := args[0].WithFun().(func(*Env) uint32) 1463 arg1fun := args[1].WithFun().(func(*Env) uint32) 1464 1465 if funsym != nil && funupn == maxdepth-1 { 1466 var cachedfun func( 1467 1468 uint32, uint32) 1469 ret = func(env *Env) { 1470 funv := env.FileEnv.Vals[funindex] 1471 if cachedfunv != funv { 1472 cachedfunv = funv 1473 cachedfun = funv.Interface().(func( 1474 1475 uint32, uint32)) 1476 } 1477 1478 arg0 := arg0fun(env) 1479 arg1 := arg1fun(env) 1480 cachedfun(arg0, arg1) 1481 } 1482 } else { 1483 ret = func(env *Env) { 1484 fun := exprfun(env).Interface().(func(uint32, uint32, 1485 1486 )) 1487 arg0 := arg0fun(env) 1488 arg1 := arg1fun(env) 1489 fun(arg0, arg1) 1490 } 1491 } 1492 1493 } 1494 case r.Uint64: 1495 { 1496 arg0fun := args[0].WithFun().(func(*Env) uint64) 1497 arg1fun := args[1].WithFun().(func(*Env) uint64) 1498 1499 if funsym != nil && funupn == maxdepth-1 { 1500 var cachedfun func( 1501 1502 uint64, uint64) 1503 ret = func(env *Env) { 1504 funv := env.FileEnv.Vals[funindex] 1505 if cachedfunv != funv { 1506 cachedfunv = funv 1507 cachedfun = funv.Interface().(func( 1508 1509 uint64, uint64)) 1510 } 1511 1512 arg0 := arg0fun(env) 1513 arg1 := arg1fun(env) 1514 cachedfun(arg0, arg1) 1515 } 1516 } else { 1517 ret = func(env *Env) { 1518 fun := exprfun(env).Interface().(func(uint64, uint64, 1519 1520 )) 1521 arg0 := arg0fun(env) 1522 arg1 := arg1fun(env) 1523 fun(arg0, arg1) 1524 } 1525 } 1526 1527 } 1528 case r.Uintptr: 1529 { 1530 arg0fun := args[0].WithFun().(func(*Env) uintptr) 1531 arg1fun := args[1].WithFun().(func(*Env) uintptr) 1532 1533 if funsym != nil && funupn == maxdepth-1 { 1534 var cachedfun func( 1535 1536 uintptr, uintptr) 1537 ret = func(env *Env) { 1538 funv := env.FileEnv.Vals[funindex] 1539 if cachedfunv != funv { 1540 cachedfunv = funv 1541 cachedfun = funv.Interface().(func( 1542 1543 uintptr, uintptr)) 1544 } 1545 1546 arg0 := arg0fun(env) 1547 arg1 := arg1fun(env) 1548 cachedfun(arg0, arg1) 1549 } 1550 } else { 1551 ret = func(env *Env) { 1552 fun := exprfun(env).Interface().(func(uintptr, uintptr, 1553 )) 1554 arg0 := arg0fun(env) 1555 arg1 := arg1fun(env) 1556 fun(arg0, arg1) 1557 } 1558 } 1559 1560 } 1561 case r.Float32: 1562 { 1563 arg0fun := args[0].WithFun().(func(*Env) float32) 1564 arg1fun := args[1].WithFun().(func(*Env) float32) 1565 1566 if funsym != nil && funupn == maxdepth-1 { 1567 var cachedfun func( 1568 1569 float32, float32) 1570 ret = func(env *Env) { 1571 funv := env.FileEnv.Vals[funindex] 1572 if cachedfunv != funv { 1573 cachedfunv = funv 1574 cachedfun = funv.Interface().(func( 1575 1576 float32, float32)) 1577 } 1578 1579 arg0 := arg0fun(env) 1580 arg1 := arg1fun(env) 1581 cachedfun(arg0, arg1) 1582 } 1583 } else { 1584 ret = func(env *Env) { 1585 fun := exprfun(env).Interface().(func(float32, float32)) 1586 arg0 := arg0fun(env) 1587 arg1 := arg1fun(env) 1588 fun(arg0, arg1) 1589 } 1590 } 1591 1592 } 1593 case r.Float64: 1594 { 1595 arg0fun := args[0].WithFun().(func(*Env) float64) 1596 arg1fun := args[1].WithFun().(func(*Env) float64) 1597 1598 if funsym != nil && funupn == maxdepth-1 { 1599 var cachedfun func( 1600 1601 float64, float64) 1602 ret = func(env *Env) { 1603 funv := env.FileEnv.Vals[funindex] 1604 if cachedfunv != funv { 1605 cachedfunv = funv 1606 cachedfun = funv.Interface().(func( 1607 1608 float64, float64)) 1609 } 1610 1611 arg0 := arg0fun(env) 1612 arg1 := arg1fun(env) 1613 cachedfun(arg0, arg1) 1614 } 1615 } else { 1616 ret = func(env *Env) { 1617 fun := exprfun(env).Interface().(func( 1618 float64, float64)) 1619 arg0 := arg0fun(env) 1620 arg1 := arg1fun(env) 1621 fun(arg0, arg1) 1622 } 1623 } 1624 1625 } 1626 case r.Complex64: 1627 { 1628 arg0fun := args[0].WithFun().(func(*Env) complex64) 1629 arg1fun := args[1].WithFun().(func(*Env) complex64) 1630 1631 if funsym != nil && funupn == maxdepth-1 { 1632 var cachedfun func( 1633 1634 complex64, complex64) 1635 ret = func(env *Env) { 1636 funv := env.FileEnv.Vals[funindex] 1637 if cachedfunv != funv { 1638 cachedfunv = funv 1639 cachedfun = funv.Interface().(func( 1640 1641 complex64, complex64)) 1642 } 1643 1644 arg0 := arg0fun(env) 1645 arg1 := arg1fun(env) 1646 cachedfun(arg0, arg1) 1647 } 1648 } else { 1649 ret = func(env *Env) { 1650 fun := exprfun(env).Interface().(func( 1651 1652 complex64, complex64)) 1653 arg0 := arg0fun(env) 1654 arg1 := arg1fun(env) 1655 fun(arg0, arg1) 1656 } 1657 } 1658 1659 } 1660 case r.Complex128: 1661 { 1662 arg0fun := args[0].WithFun().(func(*Env) complex128) 1663 arg1fun := args[1].WithFun().(func(*Env) complex128) 1664 1665 if funsym != nil && funupn == maxdepth-1 { 1666 var cachedfun func( 1667 1668 complex128, complex128) 1669 ret = func(env *Env) { 1670 funv := env.FileEnv.Vals[funindex] 1671 if cachedfunv != funv { 1672 cachedfunv = funv 1673 cachedfun = funv.Interface().(func( 1674 1675 complex128, complex128)) 1676 } 1677 1678 arg0 := arg0fun(env) 1679 arg1 := arg1fun(env) 1680 cachedfun(arg0, arg1) 1681 } 1682 } else { 1683 ret = func(env *Env) { 1684 fun := exprfun(env).Interface().(func( 1685 1686 complex128, complex128)) 1687 arg0 := arg0fun(env) 1688 arg1 := arg1fun(env) 1689 fun(arg0, arg1) 1690 } 1691 } 1692 1693 } 1694 case r.String: 1695 { 1696 arg0fun := args[0].WithFun().(func(*Env) string) 1697 arg1fun := args[1].WithFun().(func(*Env) string) 1698 1699 if funsym != nil && funupn == maxdepth-1 { 1700 var cachedfun func( 1701 1702 string, string) 1703 ret = func(env *Env) { 1704 funv := env.FileEnv.Vals[funindex] 1705 if cachedfunv != funv { 1706 cachedfunv = funv 1707 cachedfun = funv.Interface().(func( 1708 1709 string, string)) 1710 } 1711 1712 arg0 := arg0fun(env) 1713 arg1 := arg1fun(env) 1714 cachedfun(arg0, arg1) 1715 } 1716 } else { 1717 ret = func(env *Env) { 1718 fun := exprfun(env).Interface().(func( 1719 1720 string, string)) 1721 arg0 := arg0fun(env) 1722 arg1 := arg1fun(env) 1723 fun(arg0, arg1) 1724 } 1725 } 1726 1727 } 1728 } 1729 } 1730 1731 if ret == nil { 1732 ret = func(env *Env) { 1733 funv := exprfun(env) 1734 1735 argv := []r.Value{ 1736 argfuns[0](env), 1737 argfuns[1](env), 1738 } 1739 callxr(funv, argv) 1740 } 1741 } 1742 return ret 1743} 1744