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 * var_shifts.go 17 * 18 * Created on May 17, 2017 19 * Author Massimiliano Ghilardi 20 */ 21 22package fast 23 24import ( 25 "go/token" 26 r "reflect" 27 "unsafe" 28 29 "github.com/cosmos72/gomacro/base/reflect" 30) 31 32func (c *Comp) varShlConst(va *Var, val I) Stmt { 33 t := va.Type 34 upn := va.Upn 35 index := va.Desc.Index() 36 intbinds := va.Desc.Class() == IntBind 37 38 t2 := r.TypeOf(val) 39 if t2 == nil || reflect.Category(t2.Kind()) != r.Uint { 40 c.Errorf(`invalid operator %s= between <%v> and <%v>`, token.SHL, t, t2) 41 } 42 43 if isLiteralNumber(val, 0) { 44 return nil 45 } 46 { 47 val := r.ValueOf(val).Uint() 48 var ret Stmt 49 switch t.Kind() { 50 case r.Int: 51 switch upn { 52 case 0: 53 54 if intbinds { 55 ret = func(env *Env) (Stmt, *Env) { 56 *(*int)(unsafe.Pointer(&env.Ints[index])) <<= val 57 58 env.IP++ 59 return env.Code[env.IP], env 60 } 61 } else { 62 ret = func(env *Env) (Stmt, *Env) { 63 { 64 lhs := env. 65 Vals[index] 66 lhs.SetInt(lhs.Int() << 67 val, 68 ) 69 } 70 71 env.IP++ 72 return env.Code[env.IP], env 73 } 74 } 75 case 1: 76 77 if intbinds { 78 ret = func(env *Env) (Stmt, *Env) { 79 *(*int)(unsafe.Pointer(&env. 80 Outer.Ints[index])) <<= val 81 82 env.IP++ 83 return env.Code[env.IP], env 84 } 85 } else { 86 ret = func(env *Env) (Stmt, *Env) { 87 { 88 lhs := env. 89 Outer. 90 Vals[index] 91 lhs.SetInt(lhs.Int() << 92 val, 93 ) 94 } 95 96 env.IP++ 97 return env.Code[env.IP], env 98 } 99 } 100 case 2: 101 102 if intbinds { 103 ret = func(env *Env) (Stmt, *Env) { 104 *(*int)(unsafe.Pointer(&env. 105 Outer.Outer.Ints[index])) <<= val 106 107 env.IP++ 108 return env.Code[env.IP], env 109 } 110 } else { 111 ret = func(env *Env) (Stmt, *Env) { 112 { 113 lhs := env. 114 Outer.Outer. 115 Vals[index] 116 lhs.SetInt(lhs.Int() << 117 val, 118 ) 119 } 120 121 env.IP++ 122 return env.Code[env.IP], env 123 } 124 } 125 case c.Depth - 1: 126 127 if intbinds { 128 ret = func(env *Env) (Stmt, *Env) { 129 *(*int)(unsafe.Pointer(&env.FileEnv.Ints[index])) <<= val 130 131 env.IP++ 132 return env.Code[env.IP], env 133 } 134 } else { 135 ret = func(env *Env) (Stmt, *Env) { 136 { 137 lhs := env.FileEnv. 138 Vals[index] 139 lhs.SetInt(lhs.Int() << 140 val, 141 ) 142 } 143 144 env.IP++ 145 return env.Code[env.IP], env 146 } 147 } 148 default: 149 150 if intbinds { 151 ret = func(env *Env) (Stmt, *Env) { 152 o := env.Outer.Outer.Outer 153 for i := 3; i < upn; i++ { 154 o = o.Outer 155 } 156 *(*int)(unsafe.Pointer(&o.Ints[index])) <<= val 157 158 env.IP++ 159 return env.Code[env.IP], env 160 } 161 } else { 162 ret = func(env *Env) (Stmt, *Env) { 163 o := env.Outer.Outer.Outer 164 for i := 3; i < upn; i++ { 165 o = o.Outer 166 } 167 { 168 lhs := 169 170 o.Vals[index] 171 lhs.SetInt(lhs.Int() << 172 val, 173 ) 174 } 175 176 env.IP++ 177 return env.Code[env.IP], env 178 } 179 } 180 } 181 case r.Int8: 182 switch upn { 183 case 0: 184 185 if intbinds { 186 ret = func(env *Env) (Stmt, *Env) { 187 *(*int8)(unsafe.Pointer(&env.Ints[index])) <<= val 188 189 env.IP++ 190 return env.Code[env.IP], env 191 } 192 } else { 193 ret = func(env *Env) (Stmt, *Env) { 194 { 195 lhs := env. 196 Vals[index] 197 lhs.SetInt(lhs.Int() << 198 val, 199 ) 200 } 201 202 env.IP++ 203 return env.Code[env.IP], env 204 } 205 } 206 case 1: 207 208 if intbinds { 209 ret = func(env *Env) (Stmt, *Env) { 210 *(*int8)(unsafe.Pointer(&env. 211 Outer.Ints[index])) <<= val 212 213 env.IP++ 214 return env.Code[env.IP], env 215 } 216 } else { 217 ret = func(env *Env) (Stmt, *Env) { 218 { 219 lhs := env. 220 Outer. 221 Vals[index] 222 lhs.SetInt(lhs.Int() << 223 val, 224 ) 225 } 226 227 env.IP++ 228 return env.Code[env.IP], env 229 } 230 } 231 case 2: 232 233 if intbinds { 234 ret = func(env *Env) (Stmt, *Env) { 235 *(*int8)(unsafe.Pointer(&env. 236 Outer.Outer.Ints[index])) <<= val 237 238 env.IP++ 239 return env.Code[env.IP], env 240 } 241 } else { 242 ret = func(env *Env) (Stmt, *Env) { 243 { 244 lhs := env. 245 Outer.Outer. 246 Vals[index] 247 lhs.SetInt(lhs.Int() << 248 val, 249 ) 250 } 251 252 env.IP++ 253 return env.Code[env.IP], env 254 } 255 } 256 case c.Depth - 1: 257 258 if intbinds { 259 ret = func(env *Env) (Stmt, *Env) { 260 *(*int8)(unsafe.Pointer(&env.FileEnv.Ints[index])) <<= val 261 262 env.IP++ 263 return env.Code[env.IP], env 264 } 265 } else { 266 ret = func(env *Env) (Stmt, *Env) { 267 { 268 lhs := env.FileEnv. 269 Vals[index] 270 lhs.SetInt(lhs.Int() << 271 val, 272 ) 273 } 274 275 env.IP++ 276 return env.Code[env.IP], env 277 } 278 } 279 default: 280 281 if intbinds { 282 ret = func(env *Env) (Stmt, *Env) { 283 o := env.Outer.Outer.Outer 284 for i := 3; i < upn; i++ { 285 o = o.Outer 286 } 287 *(*int8)(unsafe.Pointer(&o.Ints[index])) <<= val 288 289 env.IP++ 290 return env.Code[env.IP], env 291 } 292 } else { 293 ret = func(env *Env) (Stmt, *Env) { 294 o := env.Outer.Outer.Outer 295 for i := 3; i < upn; i++ { 296 o = o.Outer 297 } 298 { 299 lhs := 300 301 o.Vals[index] 302 lhs.SetInt(lhs.Int() << 303 val, 304 ) 305 } 306 307 env.IP++ 308 return env.Code[env.IP], env 309 } 310 } 311 } 312 case r.Int16: 313 switch upn { 314 case 0: 315 316 if intbinds { 317 ret = func(env *Env) (Stmt, *Env) { 318 *(*int16)(unsafe.Pointer(&env.Ints[index])) <<= val 319 320 env.IP++ 321 return env.Code[env.IP], env 322 } 323 } else { 324 ret = func(env *Env) (Stmt, *Env) { 325 { 326 lhs := env. 327 Vals[index] 328 lhs.SetInt(lhs.Int() << 329 val, 330 ) 331 } 332 333 env.IP++ 334 return env.Code[env.IP], env 335 } 336 } 337 case 1: 338 339 if intbinds { 340 ret = func(env *Env) (Stmt, *Env) { 341 *(*int16)(unsafe.Pointer(&env. 342 Outer.Ints[index])) <<= val 343 344 env.IP++ 345 return env.Code[env.IP], env 346 } 347 } else { 348 ret = func(env *Env) (Stmt, *Env) { 349 { 350 lhs := env. 351 Outer. 352 Vals[index] 353 lhs.SetInt(lhs.Int() << 354 val, 355 ) 356 } 357 358 env.IP++ 359 return env.Code[env.IP], env 360 } 361 } 362 case 2: 363 364 if intbinds { 365 ret = func(env *Env) (Stmt, *Env) { 366 *(*int16)(unsafe.Pointer(&env. 367 Outer.Outer.Ints[index])) <<= val 368 369 env.IP++ 370 return env.Code[env.IP], env 371 } 372 } else { 373 ret = func(env *Env) (Stmt, *Env) { 374 { 375 lhs := env. 376 Outer.Outer. 377 Vals[index] 378 lhs.SetInt(lhs.Int() << 379 val, 380 ) 381 } 382 383 env.IP++ 384 return env.Code[env.IP], env 385 } 386 } 387 case c.Depth - 1: 388 389 if intbinds { 390 ret = func(env *Env) (Stmt, *Env) { 391 *(*int16)(unsafe.Pointer(&env.FileEnv.Ints[index])) <<= val 392 393 env.IP++ 394 return env.Code[env.IP], env 395 } 396 } else { 397 ret = func(env *Env) (Stmt, *Env) { 398 { 399 lhs := env.FileEnv. 400 Vals[index] 401 lhs.SetInt(lhs.Int() << 402 val, 403 ) 404 } 405 406 env.IP++ 407 return env.Code[env.IP], env 408 } 409 } 410 default: 411 412 if intbinds { 413 ret = func(env *Env) (Stmt, *Env) { 414 o := env.Outer.Outer.Outer 415 for i := 3; i < upn; i++ { 416 o = o.Outer 417 } 418 *(*int16)(unsafe.Pointer(&o.Ints[index])) <<= val 419 420 env.IP++ 421 return env.Code[env.IP], env 422 } 423 } else { 424 ret = func(env *Env) (Stmt, *Env) { 425 o := env.Outer.Outer.Outer 426 for i := 3; i < upn; i++ { 427 o = o.Outer 428 } 429 { 430 lhs := 431 432 o.Vals[index] 433 lhs.SetInt(lhs.Int() << 434 val, 435 ) 436 } 437 438 env.IP++ 439 return env.Code[env.IP], env 440 } 441 } 442 } 443 case r.Int32: 444 switch upn { 445 case 0: 446 447 if intbinds { 448 ret = func(env *Env) (Stmt, *Env) { 449 *(*int32)(unsafe.Pointer(&env.Ints[index])) <<= val 450 451 env.IP++ 452 return env.Code[env.IP], env 453 } 454 } else { 455 ret = func(env *Env) (Stmt, *Env) { 456 { 457 lhs := env. 458 Vals[index] 459 lhs.SetInt(lhs.Int() << 460 val, 461 ) 462 } 463 464 env.IP++ 465 return env.Code[env.IP], env 466 } 467 } 468 case 1: 469 470 if intbinds { 471 ret = func(env *Env) (Stmt, *Env) { 472 *(*int32)(unsafe.Pointer(&env. 473 Outer.Ints[index])) <<= val 474 475 env.IP++ 476 return env.Code[env.IP], env 477 } 478 } else { 479 ret = func(env *Env) (Stmt, *Env) { 480 { 481 lhs := env. 482 Outer. 483 Vals[index] 484 lhs.SetInt(lhs.Int() << 485 val, 486 ) 487 } 488 489 env.IP++ 490 return env.Code[env.IP], env 491 } 492 } 493 case 2: 494 495 if intbinds { 496 ret = func(env *Env) (Stmt, *Env) { 497 *(*int32)(unsafe.Pointer(&env. 498 Outer.Outer.Ints[index])) <<= val 499 500 env.IP++ 501 return env.Code[env.IP], env 502 } 503 } else { 504 ret = func(env *Env) (Stmt, *Env) { 505 { 506 lhs := env. 507 Outer.Outer. 508 Vals[index] 509 lhs.SetInt(lhs.Int() << 510 val, 511 ) 512 } 513 514 env.IP++ 515 return env.Code[env.IP], env 516 } 517 } 518 case c.Depth - 1: 519 520 if intbinds { 521 ret = func(env *Env) (Stmt, *Env) { 522 *(*int32)(unsafe.Pointer(&env.FileEnv.Ints[index])) <<= val 523 524 env.IP++ 525 return env.Code[env.IP], env 526 } 527 } else { 528 ret = func(env *Env) (Stmt, *Env) { 529 { 530 lhs := env.FileEnv. 531 Vals[index] 532 lhs.SetInt(lhs.Int() << 533 val, 534 ) 535 } 536 537 env.IP++ 538 return env.Code[env.IP], env 539 } 540 } 541 default: 542 543 if intbinds { 544 ret = func(env *Env) (Stmt, *Env) { 545 o := env.Outer.Outer.Outer 546 for i := 3; i < upn; i++ { 547 o = o.Outer 548 } 549 *(*int32)(unsafe.Pointer(&o.Ints[index])) <<= val 550 551 env.IP++ 552 return env.Code[env.IP], env 553 } 554 } else { 555 ret = func(env *Env) (Stmt, *Env) { 556 o := env.Outer.Outer.Outer 557 for i := 3; i < upn; i++ { 558 o = o.Outer 559 } 560 { 561 lhs := 562 563 o.Vals[index] 564 lhs.SetInt(lhs.Int() << 565 val, 566 ) 567 } 568 569 env.IP++ 570 return env.Code[env.IP], env 571 } 572 } 573 } 574 case r.Int64: 575 switch upn { 576 case 0: 577 578 if intbinds { 579 ret = func(env *Env) (Stmt, *Env) { 580 *(*int64)(unsafe.Pointer(&env.Ints[index])) <<= val 581 582 env.IP++ 583 return env.Code[env.IP], env 584 } 585 } else { 586 ret = func(env *Env) (Stmt, *Env) { 587 { 588 lhs := env. 589 Vals[index] 590 lhs.SetInt(lhs.Int() << 591 val, 592 ) 593 } 594 595 env.IP++ 596 return env.Code[env.IP], env 597 } 598 } 599 case 1: 600 601 if intbinds { 602 ret = func(env *Env) (Stmt, *Env) { 603 *(*int64)(unsafe.Pointer(&env. 604 Outer.Ints[index])) <<= val 605 606 env.IP++ 607 return env.Code[env.IP], env 608 } 609 } else { 610 ret = func(env *Env) (Stmt, *Env) { 611 { 612 lhs := env. 613 Outer. 614 Vals[index] 615 lhs.SetInt(lhs.Int() << 616 val, 617 ) 618 } 619 620 env.IP++ 621 return env.Code[env.IP], env 622 } 623 } 624 case 2: 625 626 if intbinds { 627 ret = func(env *Env) (Stmt, *Env) { 628 *(*int64)(unsafe.Pointer(&env. 629 Outer.Outer.Ints[index])) <<= val 630 631 env.IP++ 632 return env.Code[env.IP], env 633 } 634 } else { 635 ret = func(env *Env) (Stmt, *Env) { 636 { 637 lhs := env. 638 Outer.Outer. 639 Vals[index] 640 lhs.SetInt(lhs.Int() << 641 val, 642 ) 643 } 644 645 env.IP++ 646 return env.Code[env.IP], env 647 } 648 } 649 case c.Depth - 1: 650 651 if intbinds { 652 ret = func(env *Env) (Stmt, *Env) { 653 *(*int64)(unsafe.Pointer(&env.FileEnv.Ints[index])) <<= val 654 655 env.IP++ 656 return env.Code[env.IP], env 657 } 658 } else { 659 ret = func(env *Env) (Stmt, *Env) { 660 { 661 lhs := env.FileEnv. 662 Vals[index] 663 lhs.SetInt(lhs.Int() << 664 val, 665 ) 666 } 667 668 env.IP++ 669 return env.Code[env.IP], env 670 } 671 } 672 default: 673 674 if intbinds { 675 ret = func(env *Env) (Stmt, *Env) { 676 o := env.Outer.Outer.Outer 677 for i := 3; i < upn; i++ { 678 o = o.Outer 679 } 680 *(*int64)(unsafe.Pointer(&o.Ints[index])) <<= val 681 682 env.IP++ 683 return env.Code[env.IP], env 684 } 685 } else { 686 ret = func(env *Env) (Stmt, *Env) { 687 o := env.Outer.Outer.Outer 688 for i := 3; i < upn; i++ { 689 o = o.Outer 690 } 691 { 692 lhs := 693 694 o.Vals[index] 695 lhs.SetInt(lhs.Int() << 696 val, 697 ) 698 } 699 700 env.IP++ 701 return env.Code[env.IP], env 702 } 703 } 704 } 705 case r.Uint: 706 switch upn { 707 case 0: 708 709 if intbinds { 710 ret = func(env *Env) (Stmt, *Env) { 711 *(*uint)(unsafe.Pointer(&env.Ints[index])) <<= val 712 713 env.IP++ 714 return env.Code[env.IP], env 715 } 716 } else { 717 ret = func(env *Env) (Stmt, *Env) { 718 { 719 lhs := env. 720 Vals[index] 721 lhs.SetUint(lhs.Uint() << 722 val, 723 ) 724 } 725 726 env.IP++ 727 return env.Code[env.IP], env 728 } 729 } 730 case 1: 731 732 if intbinds { 733 ret = func(env *Env) (Stmt, *Env) { 734 *(*uint)(unsafe.Pointer(&env. 735 Outer.Ints[index])) <<= val 736 737 env.IP++ 738 return env.Code[env.IP], env 739 } 740 } else { 741 ret = func(env *Env) (Stmt, *Env) { 742 { 743 lhs := env. 744 Outer. 745 Vals[index] 746 lhs.SetUint(lhs.Uint() << 747 val, 748 ) 749 } 750 751 env.IP++ 752 return env.Code[env.IP], env 753 } 754 } 755 case 2: 756 757 if intbinds { 758 ret = func(env *Env) (Stmt, *Env) { 759 *(*uint)(unsafe.Pointer(&env. 760 Outer.Outer.Ints[index])) <<= val 761 762 env.IP++ 763 return env.Code[env.IP], env 764 } 765 } else { 766 ret = func(env *Env) (Stmt, *Env) { 767 { 768 lhs := env. 769 Outer.Outer. 770 Vals[index] 771 lhs.SetUint(lhs.Uint() << 772 val, 773 ) 774 } 775 776 env.IP++ 777 return env.Code[env.IP], env 778 } 779 } 780 case c.Depth - 1: 781 782 if intbinds { 783 ret = func(env *Env) (Stmt, *Env) { 784 *(*uint)(unsafe.Pointer(&env.FileEnv.Ints[index])) <<= val 785 786 env.IP++ 787 return env.Code[env.IP], env 788 } 789 } else { 790 ret = func(env *Env) (Stmt, *Env) { 791 { 792 lhs := env.FileEnv. 793 Vals[index] 794 lhs.SetUint(lhs.Uint() << 795 val, 796 ) 797 } 798 799 env.IP++ 800 return env.Code[env.IP], env 801 } 802 } 803 default: 804 805 if intbinds { 806 ret = func(env *Env) (Stmt, *Env) { 807 o := env.Outer.Outer.Outer 808 for i := 3; i < upn; i++ { 809 o = o.Outer 810 } 811 *(*uint)(unsafe.Pointer(&o.Ints[index])) <<= val 812 813 env.IP++ 814 return env.Code[env.IP], env 815 } 816 } else { 817 ret = func(env *Env) (Stmt, *Env) { 818 o := env.Outer.Outer.Outer 819 for i := 3; i < upn; i++ { 820 o = o.Outer 821 } 822 { 823 lhs := 824 825 o.Vals[index] 826 lhs.SetUint(lhs.Uint() << 827 val, 828 ) 829 } 830 831 env.IP++ 832 return env.Code[env.IP], env 833 } 834 } 835 } 836 case r.Uint8: 837 switch upn { 838 case 0: 839 840 if intbinds { 841 ret = func(env *Env) (Stmt, *Env) { 842 *(*uint8)(unsafe.Pointer(&env.Ints[index])) <<= val 843 844 env.IP++ 845 return env.Code[env.IP], env 846 } 847 } else { 848 ret = func(env *Env) (Stmt, *Env) { 849 { 850 lhs := env. 851 Vals[index] 852 lhs.SetUint(lhs.Uint() << 853 val, 854 ) 855 } 856 857 env.IP++ 858 return env.Code[env.IP], env 859 } 860 } 861 case 1: 862 863 if intbinds { 864 ret = func(env *Env) (Stmt, *Env) { 865 *(*uint8)(unsafe.Pointer(&env. 866 Outer.Ints[index])) <<= val 867 868 env.IP++ 869 return env.Code[env.IP], env 870 } 871 } else { 872 ret = func(env *Env) (Stmt, *Env) { 873 { 874 lhs := env. 875 Outer. 876 Vals[index] 877 lhs.SetUint(lhs.Uint() << 878 val, 879 ) 880 } 881 882 env.IP++ 883 return env.Code[env.IP], env 884 } 885 } 886 case 2: 887 888 if intbinds { 889 ret = func(env *Env) (Stmt, *Env) { 890 *(*uint8)(unsafe.Pointer(&env. 891 Outer.Outer.Ints[index])) <<= val 892 893 env.IP++ 894 return env.Code[env.IP], env 895 } 896 } else { 897 ret = func(env *Env) (Stmt, *Env) { 898 { 899 lhs := env. 900 Outer.Outer. 901 Vals[index] 902 lhs.SetUint(lhs.Uint() << 903 val, 904 ) 905 } 906 907 env.IP++ 908 return env.Code[env.IP], env 909 } 910 } 911 case c.Depth - 1: 912 913 if intbinds { 914 ret = func(env *Env) (Stmt, *Env) { 915 *(*uint8)(unsafe.Pointer(&env.FileEnv.Ints[index])) <<= val 916 917 env.IP++ 918 return env.Code[env.IP], env 919 } 920 } else { 921 ret = func(env *Env) (Stmt, *Env) { 922 { 923 lhs := env.FileEnv. 924 Vals[index] 925 lhs.SetUint(lhs.Uint() << 926 val, 927 ) 928 } 929 930 env.IP++ 931 return env.Code[env.IP], env 932 } 933 } 934 default: 935 936 if intbinds { 937 ret = func(env *Env) (Stmt, *Env) { 938 o := env.Outer.Outer.Outer 939 for i := 3; i < upn; i++ { 940 o = o.Outer 941 } 942 *(*uint8)(unsafe.Pointer(&o.Ints[index])) <<= val 943 944 env.IP++ 945 return env.Code[env.IP], env 946 } 947 } else { 948 ret = func(env *Env) (Stmt, *Env) { 949 o := env.Outer.Outer.Outer 950 for i := 3; i < upn; i++ { 951 o = o.Outer 952 } 953 { 954 lhs := 955 956 o.Vals[index] 957 lhs.SetUint(lhs.Uint() << 958 val, 959 ) 960 } 961 962 env.IP++ 963 return env.Code[env.IP], env 964 } 965 } 966 } 967 case r.Uint16: 968 switch upn { 969 case 0: 970 971 if intbinds { 972 ret = func(env *Env) (Stmt, *Env) { 973 *(*uint16)(unsafe.Pointer(&env.Ints[index])) <<= val 974 975 env.IP++ 976 return env.Code[env.IP], env 977 } 978 } else { 979 ret = func(env *Env) (Stmt, *Env) { 980 { 981 lhs := env. 982 Vals[index] 983 lhs.SetUint(lhs.Uint() << 984 val, 985 ) 986 } 987 988 env.IP++ 989 return env.Code[env.IP], env 990 } 991 } 992 case 1: 993 994 if intbinds { 995 ret = func(env *Env) (Stmt, *Env) { 996 *(*uint16)(unsafe.Pointer(&env. 997 Outer.Ints[index])) <<= val 998 999 env.IP++ 1000 return env.Code[env.IP], env 1001 } 1002 } else { 1003 ret = func(env *Env) (Stmt, *Env) { 1004 { 1005 lhs := env. 1006 Outer. 1007 Vals[index] 1008 lhs.SetUint(lhs.Uint() << 1009 val, 1010 ) 1011 } 1012 1013 env.IP++ 1014 return env.Code[env.IP], env 1015 } 1016 } 1017 case 2: 1018 1019 if intbinds { 1020 ret = func(env *Env) (Stmt, *Env) { 1021 *(*uint16)(unsafe.Pointer(&env. 1022 Outer.Outer.Ints[index])) <<= val 1023 1024 env.IP++ 1025 return env.Code[env.IP], env 1026 } 1027 } else { 1028 ret = func(env *Env) (Stmt, *Env) { 1029 { 1030 lhs := env. 1031 Outer.Outer. 1032 Vals[index] 1033 lhs.SetUint(lhs.Uint() << 1034 val, 1035 ) 1036 } 1037 1038 env.IP++ 1039 return env.Code[env.IP], env 1040 } 1041 } 1042 case c.Depth - 1: 1043 1044 if intbinds { 1045 ret = func(env *Env) (Stmt, *Env) { 1046 *(*uint16)(unsafe.Pointer(&env.FileEnv.Ints[index])) <<= val 1047 1048 env.IP++ 1049 return env.Code[env.IP], env 1050 } 1051 } else { 1052 ret = func(env *Env) (Stmt, *Env) { 1053 { 1054 lhs := env.FileEnv. 1055 Vals[index] 1056 lhs.SetUint(lhs.Uint() << 1057 val, 1058 ) 1059 } 1060 1061 env.IP++ 1062 return env.Code[env.IP], env 1063 } 1064 } 1065 default: 1066 1067 if intbinds { 1068 ret = func(env *Env) (Stmt, *Env) { 1069 o := env.Outer.Outer.Outer 1070 for i := 3; i < upn; i++ { 1071 o = o.Outer 1072 } 1073 *(*uint16)(unsafe.Pointer(&o.Ints[index])) <<= val 1074 1075 env.IP++ 1076 return env.Code[env.IP], env 1077 } 1078 } else { 1079 ret = func(env *Env) (Stmt, *Env) { 1080 o := env.Outer.Outer.Outer 1081 for i := 3; i < upn; i++ { 1082 o = o.Outer 1083 } 1084 { 1085 lhs := 1086 1087 o.Vals[index] 1088 lhs.SetUint(lhs.Uint() << 1089 val, 1090 ) 1091 } 1092 1093 env.IP++ 1094 return env.Code[env.IP], env 1095 } 1096 } 1097 } 1098 case r.Uint32: 1099 switch upn { 1100 case 0: 1101 1102 if intbinds { 1103 ret = func(env *Env) (Stmt, *Env) { 1104 *(*uint32)(unsafe.Pointer(&env.Ints[index])) <<= val 1105 1106 env.IP++ 1107 return env.Code[env.IP], env 1108 } 1109 } else { 1110 ret = func(env *Env) (Stmt, *Env) { 1111 { 1112 lhs := env. 1113 Vals[index] 1114 lhs.SetUint(lhs.Uint() << 1115 val, 1116 ) 1117 } 1118 1119 env.IP++ 1120 return env.Code[env.IP], env 1121 } 1122 } 1123 case 1: 1124 1125 if intbinds { 1126 ret = func(env *Env) (Stmt, *Env) { 1127 *(*uint32)(unsafe.Pointer(&env. 1128 Outer.Ints[index])) <<= val 1129 1130 env.IP++ 1131 return env.Code[env.IP], env 1132 } 1133 } else { 1134 ret = func(env *Env) (Stmt, *Env) { 1135 { 1136 lhs := env. 1137 Outer. 1138 Vals[index] 1139 lhs.SetUint(lhs.Uint() << 1140 val, 1141 ) 1142 } 1143 1144 env.IP++ 1145 return env.Code[env.IP], env 1146 } 1147 } 1148 case 2: 1149 1150 if intbinds { 1151 ret = func(env *Env) (Stmt, *Env) { 1152 *(*uint32)(unsafe.Pointer(&env. 1153 Outer.Outer.Ints[index])) <<= val 1154 1155 env.IP++ 1156 return env.Code[env.IP], env 1157 } 1158 } else { 1159 ret = func(env *Env) (Stmt, *Env) { 1160 { 1161 lhs := env. 1162 Outer.Outer. 1163 Vals[index] 1164 lhs.SetUint(lhs.Uint() << 1165 val, 1166 ) 1167 } 1168 1169 env.IP++ 1170 return env.Code[env.IP], env 1171 } 1172 } 1173 case c.Depth - 1: 1174 1175 if intbinds { 1176 ret = func(env *Env) (Stmt, *Env) { 1177 *(*uint32)(unsafe.Pointer(&env.FileEnv.Ints[index])) <<= val 1178 1179 env.IP++ 1180 return env.Code[env.IP], env 1181 } 1182 } else { 1183 ret = func(env *Env) (Stmt, *Env) { 1184 { 1185 lhs := env.FileEnv. 1186 Vals[index] 1187 lhs.SetUint(lhs.Uint() << 1188 val, 1189 ) 1190 } 1191 1192 env.IP++ 1193 return env.Code[env.IP], env 1194 } 1195 } 1196 default: 1197 1198 if intbinds { 1199 ret = func(env *Env) (Stmt, *Env) { 1200 o := env.Outer.Outer.Outer 1201 for i := 3; i < upn; i++ { 1202 o = o.Outer 1203 } 1204 *(*uint32)(unsafe.Pointer(&o.Ints[index])) <<= val 1205 1206 env.IP++ 1207 return env.Code[env.IP], env 1208 } 1209 } else { 1210 ret = func(env *Env) (Stmt, *Env) { 1211 o := env.Outer.Outer.Outer 1212 for i := 3; i < upn; i++ { 1213 o = o.Outer 1214 } 1215 { 1216 lhs := 1217 1218 o.Vals[index] 1219 lhs.SetUint(lhs.Uint() << 1220 val, 1221 ) 1222 } 1223 1224 env.IP++ 1225 return env.Code[env.IP], env 1226 } 1227 } 1228 } 1229 case r.Uint64: 1230 switch upn { 1231 case 0: 1232 1233 if intbinds { 1234 ret = func(env *Env) (Stmt, *Env) { 1235 env. 1236 Ints[index] <<= val 1237 1238 env.IP++ 1239 return env.Code[env.IP], env 1240 } 1241 } else { 1242 ret = func(env *Env) (Stmt, *Env) { 1243 { 1244 lhs := env. 1245 Vals[index] 1246 lhs.SetUint(lhs.Uint() << 1247 val, 1248 ) 1249 } 1250 1251 env.IP++ 1252 return env.Code[env.IP], env 1253 } 1254 } 1255 case 1: 1256 1257 if intbinds { 1258 ret = func(env *Env) (Stmt, *Env) { 1259 env. 1260 Outer. 1261 Ints[index] <<= val 1262 1263 env.IP++ 1264 return env.Code[env.IP], env 1265 } 1266 } else { 1267 ret = func(env *Env) (Stmt, *Env) { 1268 { 1269 lhs := env. 1270 Outer. 1271 Vals[index] 1272 lhs.SetUint(lhs.Uint() << 1273 val, 1274 ) 1275 } 1276 1277 env.IP++ 1278 return env.Code[env.IP], env 1279 } 1280 } 1281 case 2: 1282 1283 if intbinds { 1284 ret = func(env *Env) (Stmt, *Env) { 1285 env. 1286 Outer.Outer. 1287 Ints[index] <<= val 1288 1289 env.IP++ 1290 return env.Code[env.IP], env 1291 } 1292 } else { 1293 ret = func(env *Env) (Stmt, *Env) { 1294 { 1295 lhs := env. 1296 Outer.Outer. 1297 Vals[index] 1298 lhs.SetUint(lhs.Uint() << 1299 val, 1300 ) 1301 } 1302 1303 env.IP++ 1304 return env.Code[env.IP], env 1305 } 1306 } 1307 case c.Depth - 1: 1308 1309 if intbinds { 1310 ret = func(env *Env) (Stmt, *Env) { 1311 env.FileEnv. 1312 Ints[index] <<= val 1313 1314 env.IP++ 1315 return env.Code[env.IP], env 1316 } 1317 } else { 1318 ret = func(env *Env) (Stmt, *Env) { 1319 { 1320 lhs := env.FileEnv. 1321 Vals[index] 1322 lhs.SetUint(lhs.Uint() << 1323 val, 1324 ) 1325 } 1326 1327 env.IP++ 1328 return env.Code[env.IP], env 1329 } 1330 } 1331 default: 1332 1333 if intbinds { 1334 ret = func(env *Env) (Stmt, *Env) { 1335 o := env.Outer.Outer.Outer 1336 for i := 3; i < upn; i++ { 1337 o = o.Outer 1338 } 1339 1340 o.Ints[index] <<= val 1341 1342 env.IP++ 1343 return env.Code[env.IP], env 1344 } 1345 } else { 1346 ret = func(env *Env) (Stmt, *Env) { 1347 o := env.Outer.Outer.Outer 1348 for i := 3; i < upn; i++ { 1349 o = o.Outer 1350 } 1351 { 1352 lhs := 1353 1354 o.Vals[index] 1355 lhs.SetUint(lhs.Uint() << 1356 val, 1357 ) 1358 } 1359 1360 env.IP++ 1361 return env.Code[env.IP], env 1362 } 1363 } 1364 } 1365 case r.Uintptr: 1366 switch upn { 1367 case 0: 1368 1369 if intbinds { 1370 ret = func(env *Env) (Stmt, *Env) { 1371 *(*uintptr)(unsafe.Pointer(&env.Ints[index])) <<= val 1372 1373 env.IP++ 1374 return env.Code[env.IP], env 1375 } 1376 } else { 1377 ret = func(env *Env) (Stmt, *Env) { 1378 { 1379 lhs := env. 1380 Vals[index] 1381 lhs.SetUint(lhs.Uint() << 1382 val, 1383 ) 1384 } 1385 1386 env.IP++ 1387 return env.Code[env.IP], env 1388 } 1389 } 1390 case 1: 1391 1392 if intbinds { 1393 ret = func(env *Env) (Stmt, *Env) { 1394 *(*uintptr)(unsafe.Pointer(&env. 1395 Outer.Ints[index])) <<= val 1396 1397 env.IP++ 1398 return env.Code[env.IP], env 1399 } 1400 } else { 1401 ret = func(env *Env) (Stmt, *Env) { 1402 { 1403 lhs := env. 1404 Outer. 1405 Vals[index] 1406 lhs.SetUint(lhs.Uint() << 1407 val, 1408 ) 1409 } 1410 1411 env.IP++ 1412 return env.Code[env.IP], env 1413 } 1414 } 1415 case 2: 1416 1417 if intbinds { 1418 ret = func(env *Env) (Stmt, *Env) { 1419 *(*uintptr)(unsafe.Pointer(&env. 1420 Outer.Outer.Ints[index])) <<= val 1421 1422 env.IP++ 1423 return env.Code[env.IP], env 1424 } 1425 } else { 1426 ret = func(env *Env) (Stmt, *Env) { 1427 { 1428 lhs := env. 1429 Outer.Outer. 1430 Vals[index] 1431 lhs.SetUint(lhs.Uint() << 1432 val, 1433 ) 1434 } 1435 1436 env.IP++ 1437 return env.Code[env.IP], env 1438 } 1439 } 1440 case c.Depth - 1: 1441 1442 if intbinds { 1443 ret = func(env *Env) (Stmt, *Env) { 1444 *(*uintptr)(unsafe.Pointer(&env.FileEnv.Ints[index])) <<= val 1445 1446 env.IP++ 1447 return env.Code[env.IP], env 1448 } 1449 } else { 1450 ret = func(env *Env) (Stmt, *Env) { 1451 { 1452 lhs := env.FileEnv. 1453 Vals[index] 1454 lhs.SetUint(lhs.Uint() << 1455 val, 1456 ) 1457 } 1458 1459 env.IP++ 1460 return env.Code[env.IP], env 1461 } 1462 } 1463 default: 1464 1465 if intbinds { 1466 ret = func(env *Env) (Stmt, *Env) { 1467 o := env.Outer.Outer.Outer 1468 for i := 3; i < upn; i++ { 1469 o = o.Outer 1470 } 1471 *(*uintptr)(unsafe.Pointer(&o.Ints[index])) <<= val 1472 1473 env.IP++ 1474 return env.Code[env.IP], env 1475 } 1476 } else { 1477 ret = func(env *Env) (Stmt, *Env) { 1478 o := env.Outer.Outer.Outer 1479 for i := 3; i < upn; i++ { 1480 o = o.Outer 1481 } 1482 { 1483 lhs := 1484 1485 o.Vals[index] 1486 lhs.SetUint(lhs.Uint() << 1487 val, 1488 ) 1489 } 1490 1491 env.IP++ 1492 return env.Code[env.IP], env 1493 } 1494 } 1495 } 1496 default: 1497 c.Errorf(`invalid operator %s= between <%v> and <%v>`, token.SHL, t, t2) 1498 1499 } 1500 return ret 1501 } 1502} 1503func (c *Comp) varShlExpr(va *Var, function I) Stmt { 1504 t := va.Type 1505 upn := va.Upn 1506 index := va.Desc.Index() 1507 intbinds := va.Desc.Class() == IntBind 1508 1509 t2 := funTypeOut(function) 1510 if t2 == nil || reflect.Category(t2.Kind()) != r.Uint { 1511 c.Errorf(`invalid operator %s= between <%v> and <%v>`, token.SHL, t, t2) 1512 } 1513 1514 fun := asFunUint8(function) 1515 { 1516 var ret Stmt 1517 switch t.Kind() { 1518 case r.Int: 1519 switch upn { 1520 case 0: 1521 1522 if intbinds { 1523 ret = func(env *Env) (Stmt, *Env) { 1524 *(*int)(unsafe.Pointer(&env.Ints[index])) <<= fun(env) 1525 1526 env.IP++ 1527 return env.Code[env.IP], env 1528 } 1529 } else { 1530 ret = func(env *Env) (Stmt, *Env) { 1531 { 1532 lhs := env. 1533 Vals[index] 1534 lhs.SetInt(lhs.Int() << 1535 fun(env), 1536 ) 1537 } 1538 1539 env.IP++ 1540 return env.Code[env.IP], env 1541 } 1542 } 1543 case 1: 1544 1545 if intbinds { 1546 ret = func(env *Env) (Stmt, *Env) { 1547 *(*int)(unsafe.Pointer(&env. 1548 Outer.Ints[index])) <<= fun(env) 1549 1550 env.IP++ 1551 return env.Code[env.IP], env 1552 } 1553 } else { 1554 ret = func(env *Env) (Stmt, *Env) { 1555 { 1556 lhs := env. 1557 Outer. 1558 Vals[index] 1559 lhs.SetInt(lhs.Int() << 1560 fun(env), 1561 ) 1562 } 1563 1564 env.IP++ 1565 return env.Code[env.IP], env 1566 } 1567 } 1568 case 2: 1569 1570 if intbinds { 1571 ret = func(env *Env) (Stmt, *Env) { 1572 *(*int)(unsafe.Pointer(&env. 1573 Outer.Outer.Ints[index])) <<= fun(env) 1574 1575 env.IP++ 1576 return env.Code[env.IP], env 1577 } 1578 } else { 1579 ret = func(env *Env) (Stmt, *Env) { 1580 { 1581 lhs := env. 1582 Outer.Outer. 1583 Vals[index] 1584 lhs.SetInt(lhs.Int() << 1585 fun(env), 1586 ) 1587 } 1588 1589 env.IP++ 1590 return env.Code[env.IP], env 1591 } 1592 } 1593 case c.Depth - 1: 1594 1595 if intbinds { 1596 ret = func(env *Env) (Stmt, *Env) { 1597 *(*int)(unsafe.Pointer(&env.FileEnv.Ints[index])) <<= fun(env) 1598 1599 env.IP++ 1600 return env.Code[env.IP], env 1601 } 1602 } else { 1603 ret = func(env *Env) (Stmt, *Env) { 1604 { 1605 lhs := env.FileEnv. 1606 Vals[index] 1607 lhs.SetInt(lhs.Int() << 1608 fun(env), 1609 ) 1610 } 1611 1612 env.IP++ 1613 return env.Code[env.IP], env 1614 } 1615 } 1616 default: 1617 1618 if intbinds { 1619 ret = func(env *Env) (Stmt, *Env) { 1620 o := env.Outer.Outer.Outer 1621 for i := 3; i < upn; i++ { 1622 o = o.Outer 1623 } 1624 *(*int)(unsafe.Pointer(&o.Ints[index])) <<= fun(env) 1625 1626 env.IP++ 1627 return env.Code[env.IP], env 1628 } 1629 } else { 1630 ret = func(env *Env) (Stmt, *Env) { 1631 o := env.Outer.Outer.Outer 1632 for i := 3; i < upn; i++ { 1633 o = o.Outer 1634 } 1635 { 1636 lhs := 1637 1638 o.Vals[index] 1639 lhs.SetInt(lhs.Int() << 1640 fun(env), 1641 ) 1642 } 1643 1644 env.IP++ 1645 return env.Code[env.IP], env 1646 } 1647 } 1648 } 1649 case r.Int8: 1650 switch upn { 1651 case 0: 1652 1653 if intbinds { 1654 ret = func(env *Env) (Stmt, *Env) { 1655 *(*int8)(unsafe.Pointer(&env.Ints[index])) <<= fun(env) 1656 1657 env.IP++ 1658 return env.Code[env.IP], env 1659 } 1660 } else { 1661 ret = func(env *Env) (Stmt, *Env) { 1662 { 1663 lhs := env. 1664 Vals[index] 1665 lhs.SetInt(lhs.Int() << 1666 fun(env), 1667 ) 1668 } 1669 1670 env.IP++ 1671 return env.Code[env.IP], env 1672 } 1673 } 1674 case 1: 1675 1676 if intbinds { 1677 ret = func(env *Env) (Stmt, *Env) { 1678 *(*int8)(unsafe.Pointer(&env. 1679 Outer.Ints[index])) <<= fun(env) 1680 1681 env.IP++ 1682 return env.Code[env.IP], env 1683 } 1684 } else { 1685 ret = func(env *Env) (Stmt, *Env) { 1686 { 1687 lhs := env. 1688 Outer. 1689 Vals[index] 1690 lhs.SetInt(lhs.Int() << 1691 fun(env), 1692 ) 1693 } 1694 1695 env.IP++ 1696 return env.Code[env.IP], env 1697 } 1698 } 1699 case 2: 1700 1701 if intbinds { 1702 ret = func(env *Env) (Stmt, *Env) { 1703 *(*int8)(unsafe.Pointer(&env. 1704 Outer.Outer.Ints[index])) <<= fun(env) 1705 1706 env.IP++ 1707 return env.Code[env.IP], env 1708 } 1709 } else { 1710 ret = func(env *Env) (Stmt, *Env) { 1711 { 1712 lhs := env. 1713 Outer.Outer. 1714 Vals[index] 1715 lhs.SetInt(lhs.Int() << 1716 fun(env), 1717 ) 1718 } 1719 1720 env.IP++ 1721 return env.Code[env.IP], env 1722 } 1723 } 1724 case c.Depth - 1: 1725 1726 if intbinds { 1727 ret = func(env *Env) (Stmt, *Env) { 1728 *(*int8)(unsafe.Pointer(&env.FileEnv.Ints[index])) <<= fun(env) 1729 1730 env.IP++ 1731 return env.Code[env.IP], env 1732 } 1733 } else { 1734 ret = func(env *Env) (Stmt, *Env) { 1735 { 1736 lhs := env.FileEnv. 1737 Vals[index] 1738 lhs.SetInt(lhs.Int() << 1739 fun(env), 1740 ) 1741 } 1742 1743 env.IP++ 1744 return env.Code[env.IP], env 1745 } 1746 } 1747 default: 1748 1749 if intbinds { 1750 ret = func(env *Env) (Stmt, *Env) { 1751 o := env.Outer.Outer.Outer 1752 for i := 3; i < upn; i++ { 1753 o = o.Outer 1754 } 1755 *(*int8)(unsafe.Pointer(&o.Ints[index])) <<= fun(env) 1756 1757 env.IP++ 1758 return env.Code[env.IP], env 1759 } 1760 } else { 1761 ret = func(env *Env) (Stmt, *Env) { 1762 o := env.Outer.Outer.Outer 1763 for i := 3; i < upn; i++ { 1764 o = o.Outer 1765 } 1766 { 1767 lhs := 1768 1769 o.Vals[index] 1770 lhs.SetInt(lhs.Int() << 1771 fun(env), 1772 ) 1773 } 1774 1775 env.IP++ 1776 return env.Code[env.IP], env 1777 } 1778 } 1779 } 1780 case r.Int16: 1781 switch upn { 1782 case 0: 1783 1784 if intbinds { 1785 ret = func(env *Env) (Stmt, *Env) { 1786 *(*int16)(unsafe.Pointer(&env.Ints[index])) <<= fun(env) 1787 1788 env.IP++ 1789 return env.Code[env.IP], env 1790 } 1791 } else { 1792 ret = func(env *Env) (Stmt, *Env) { 1793 { 1794 lhs := env. 1795 Vals[index] 1796 lhs.SetInt(lhs.Int() << 1797 fun(env), 1798 ) 1799 } 1800 1801 env.IP++ 1802 return env.Code[env.IP], env 1803 } 1804 } 1805 case 1: 1806 1807 if intbinds { 1808 ret = func(env *Env) (Stmt, *Env) { 1809 *(*int16)(unsafe.Pointer(&env. 1810 Outer.Ints[index])) <<= fun(env) 1811 1812 env.IP++ 1813 return env.Code[env.IP], env 1814 } 1815 } else { 1816 ret = func(env *Env) (Stmt, *Env) { 1817 { 1818 lhs := env. 1819 Outer. 1820 Vals[index] 1821 lhs.SetInt(lhs.Int() << 1822 fun(env), 1823 ) 1824 } 1825 1826 env.IP++ 1827 return env.Code[env.IP], env 1828 } 1829 } 1830 case 2: 1831 1832 if intbinds { 1833 ret = func(env *Env) (Stmt, *Env) { 1834 *(*int16)(unsafe.Pointer(&env. 1835 Outer.Outer.Ints[index])) <<= fun(env) 1836 1837 env.IP++ 1838 return env.Code[env.IP], env 1839 } 1840 } else { 1841 ret = func(env *Env) (Stmt, *Env) { 1842 { 1843 lhs := env. 1844 Outer.Outer. 1845 Vals[index] 1846 lhs.SetInt(lhs.Int() << 1847 fun(env), 1848 ) 1849 } 1850 1851 env.IP++ 1852 return env.Code[env.IP], env 1853 } 1854 } 1855 case c.Depth - 1: 1856 1857 if intbinds { 1858 ret = func(env *Env) (Stmt, *Env) { 1859 *(*int16)(unsafe.Pointer(&env.FileEnv.Ints[index])) <<= fun(env) 1860 1861 env.IP++ 1862 return env.Code[env.IP], env 1863 } 1864 } else { 1865 ret = func(env *Env) (Stmt, *Env) { 1866 { 1867 lhs := env.FileEnv. 1868 Vals[index] 1869 lhs.SetInt(lhs.Int() << 1870 fun(env), 1871 ) 1872 } 1873 1874 env.IP++ 1875 return env.Code[env.IP], env 1876 } 1877 } 1878 default: 1879 1880 if intbinds { 1881 ret = func(env *Env) (Stmt, *Env) { 1882 o := env.Outer.Outer.Outer 1883 for i := 3; i < upn; i++ { 1884 o = o.Outer 1885 } 1886 *(*int16)(unsafe.Pointer(&o.Ints[index])) <<= fun(env) 1887 1888 env.IP++ 1889 return env.Code[env.IP], env 1890 } 1891 } else { 1892 ret = func(env *Env) (Stmt, *Env) { 1893 o := env.Outer.Outer.Outer 1894 for i := 3; i < upn; i++ { 1895 o = o.Outer 1896 } 1897 { 1898 lhs := 1899 1900 o.Vals[index] 1901 lhs.SetInt(lhs.Int() << 1902 fun(env), 1903 ) 1904 } 1905 1906 env.IP++ 1907 return env.Code[env.IP], env 1908 } 1909 } 1910 } 1911 case r.Int32: 1912 switch upn { 1913 case 0: 1914 1915 if intbinds { 1916 ret = func(env *Env) (Stmt, *Env) { 1917 *(*int32)(unsafe.Pointer(&env.Ints[index])) <<= fun(env) 1918 1919 env.IP++ 1920 return env.Code[env.IP], env 1921 } 1922 } else { 1923 ret = func(env *Env) (Stmt, *Env) { 1924 { 1925 lhs := env. 1926 Vals[index] 1927 lhs.SetInt(lhs.Int() << 1928 fun(env), 1929 ) 1930 } 1931 1932 env.IP++ 1933 return env.Code[env.IP], env 1934 } 1935 } 1936 case 1: 1937 1938 if intbinds { 1939 ret = func(env *Env) (Stmt, *Env) { 1940 *(*int32)(unsafe.Pointer(&env. 1941 Outer.Ints[index])) <<= fun(env) 1942 1943 env.IP++ 1944 return env.Code[env.IP], env 1945 } 1946 } else { 1947 ret = func(env *Env) (Stmt, *Env) { 1948 { 1949 lhs := env. 1950 Outer. 1951 Vals[index] 1952 lhs.SetInt(lhs.Int() << 1953 fun(env), 1954 ) 1955 } 1956 1957 env.IP++ 1958 return env.Code[env.IP], env 1959 } 1960 } 1961 case 2: 1962 1963 if intbinds { 1964 ret = func(env *Env) (Stmt, *Env) { 1965 *(*int32)(unsafe.Pointer(&env. 1966 Outer.Outer.Ints[index])) <<= fun(env) 1967 1968 env.IP++ 1969 return env.Code[env.IP], env 1970 } 1971 } else { 1972 ret = func(env *Env) (Stmt, *Env) { 1973 { 1974 lhs := env. 1975 Outer.Outer. 1976 Vals[index] 1977 lhs.SetInt(lhs.Int() << 1978 fun(env), 1979 ) 1980 } 1981 1982 env.IP++ 1983 return env.Code[env.IP], env 1984 } 1985 } 1986 case c.Depth - 1: 1987 1988 if intbinds { 1989 ret = func(env *Env) (Stmt, *Env) { 1990 *(*int32)(unsafe.Pointer(&env.FileEnv.Ints[index])) <<= fun(env) 1991 1992 env.IP++ 1993 return env.Code[env.IP], env 1994 } 1995 } else { 1996 ret = func(env *Env) (Stmt, *Env) { 1997 { 1998 lhs := env.FileEnv. 1999 Vals[index] 2000 lhs.SetInt(lhs.Int() << 2001 fun(env), 2002 ) 2003 } 2004 2005 env.IP++ 2006 return env.Code[env.IP], env 2007 } 2008 } 2009 default: 2010 2011 if intbinds { 2012 ret = func(env *Env) (Stmt, *Env) { 2013 o := env.Outer.Outer.Outer 2014 for i := 3; i < upn; i++ { 2015 o = o.Outer 2016 } 2017 *(*int32)(unsafe.Pointer(&o.Ints[index])) <<= fun(env) 2018 2019 env.IP++ 2020 return env.Code[env.IP], env 2021 } 2022 } else { 2023 ret = func(env *Env) (Stmt, *Env) { 2024 o := env.Outer.Outer.Outer 2025 for i := 3; i < upn; i++ { 2026 o = o.Outer 2027 } 2028 { 2029 lhs := 2030 2031 o.Vals[index] 2032 lhs.SetInt(lhs.Int() << 2033 fun(env), 2034 ) 2035 } 2036 2037 env.IP++ 2038 return env.Code[env.IP], env 2039 } 2040 } 2041 } 2042 case r.Int64: 2043 switch upn { 2044 case 0: 2045 2046 if intbinds { 2047 ret = func(env *Env) (Stmt, *Env) { 2048 *(*int64)(unsafe.Pointer(&env.Ints[index])) <<= fun(env) 2049 2050 env.IP++ 2051 return env.Code[env.IP], env 2052 } 2053 } else { 2054 ret = func(env *Env) (Stmt, *Env) { 2055 { 2056 lhs := env. 2057 Vals[index] 2058 lhs.SetInt(lhs.Int() << 2059 fun(env), 2060 ) 2061 } 2062 2063 env.IP++ 2064 return env.Code[env.IP], env 2065 } 2066 } 2067 case 1: 2068 2069 if intbinds { 2070 ret = func(env *Env) (Stmt, *Env) { 2071 *(*int64)(unsafe.Pointer(&env. 2072 Outer.Ints[index])) <<= fun(env) 2073 2074 env.IP++ 2075 return env.Code[env.IP], env 2076 } 2077 } else { 2078 ret = func(env *Env) (Stmt, *Env) { 2079 { 2080 lhs := env. 2081 Outer. 2082 Vals[index] 2083 lhs.SetInt(lhs.Int() << 2084 fun(env), 2085 ) 2086 } 2087 2088 env.IP++ 2089 return env.Code[env.IP], env 2090 } 2091 } 2092 case 2: 2093 2094 if intbinds { 2095 ret = func(env *Env) (Stmt, *Env) { 2096 *(*int64)(unsafe.Pointer(&env. 2097 Outer.Outer.Ints[index])) <<= fun(env) 2098 2099 env.IP++ 2100 return env.Code[env.IP], env 2101 } 2102 } else { 2103 ret = func(env *Env) (Stmt, *Env) { 2104 { 2105 lhs := env. 2106 Outer.Outer. 2107 Vals[index] 2108 lhs.SetInt(lhs.Int() << 2109 fun(env), 2110 ) 2111 } 2112 2113 env.IP++ 2114 return env.Code[env.IP], env 2115 } 2116 } 2117 case c.Depth - 1: 2118 2119 if intbinds { 2120 ret = func(env *Env) (Stmt, *Env) { 2121 *(*int64)(unsafe.Pointer(&env.FileEnv.Ints[index])) <<= fun(env) 2122 2123 env.IP++ 2124 return env.Code[env.IP], env 2125 } 2126 } else { 2127 ret = func(env *Env) (Stmt, *Env) { 2128 { 2129 lhs := env.FileEnv. 2130 Vals[index] 2131 lhs.SetInt(lhs.Int() << 2132 fun(env), 2133 ) 2134 } 2135 2136 env.IP++ 2137 return env.Code[env.IP], env 2138 } 2139 } 2140 default: 2141 2142 if intbinds { 2143 ret = func(env *Env) (Stmt, *Env) { 2144 o := env.Outer.Outer.Outer 2145 for i := 3; i < upn; i++ { 2146 o = o.Outer 2147 } 2148 *(*int64)(unsafe.Pointer(&o.Ints[index])) <<= fun(env) 2149 2150 env.IP++ 2151 return env.Code[env.IP], env 2152 } 2153 } else { 2154 ret = func(env *Env) (Stmt, *Env) { 2155 o := env.Outer.Outer.Outer 2156 for i := 3; i < upn; i++ { 2157 o = o.Outer 2158 } 2159 { 2160 lhs := 2161 2162 o.Vals[index] 2163 lhs.SetInt(lhs.Int() << 2164 fun(env), 2165 ) 2166 } 2167 2168 env.IP++ 2169 return env.Code[env.IP], env 2170 } 2171 } 2172 } 2173 case r.Uint: 2174 switch upn { 2175 case 0: 2176 2177 if intbinds { 2178 ret = func(env *Env) (Stmt, *Env) { 2179 *(*uint)(unsafe.Pointer(&env.Ints[index])) <<= fun(env) 2180 2181 env.IP++ 2182 return env.Code[env.IP], env 2183 } 2184 } else { 2185 ret = func(env *Env) (Stmt, *Env) { 2186 { 2187 lhs := env. 2188 Vals[index] 2189 lhs.SetUint(lhs.Uint() << 2190 fun(env), 2191 ) 2192 } 2193 2194 env.IP++ 2195 return env.Code[env.IP], env 2196 } 2197 } 2198 case 1: 2199 2200 if intbinds { 2201 ret = func(env *Env) (Stmt, *Env) { 2202 *(*uint)(unsafe.Pointer(&env. 2203 Outer.Ints[index])) <<= fun(env) 2204 2205 env.IP++ 2206 return env.Code[env.IP], env 2207 } 2208 } else { 2209 ret = func(env *Env) (Stmt, *Env) { 2210 { 2211 lhs := env. 2212 Outer. 2213 Vals[index] 2214 lhs.SetUint(lhs.Uint() << 2215 fun(env), 2216 ) 2217 } 2218 2219 env.IP++ 2220 return env.Code[env.IP], env 2221 } 2222 } 2223 case 2: 2224 2225 if intbinds { 2226 ret = func(env *Env) (Stmt, *Env) { 2227 *(*uint)(unsafe.Pointer(&env. 2228 Outer.Outer.Ints[index])) <<= fun(env) 2229 2230 env.IP++ 2231 return env.Code[env.IP], env 2232 } 2233 } else { 2234 ret = func(env *Env) (Stmt, *Env) { 2235 { 2236 lhs := env. 2237 Outer.Outer. 2238 Vals[index] 2239 lhs.SetUint(lhs.Uint() << 2240 fun(env), 2241 ) 2242 } 2243 2244 env.IP++ 2245 return env.Code[env.IP], env 2246 } 2247 } 2248 case c.Depth - 1: 2249 2250 if intbinds { 2251 ret = func(env *Env) (Stmt, *Env) { 2252 *(*uint)(unsafe.Pointer(&env.FileEnv.Ints[index])) <<= fun(env) 2253 2254 env.IP++ 2255 return env.Code[env.IP], env 2256 } 2257 } else { 2258 ret = func(env *Env) (Stmt, *Env) { 2259 { 2260 lhs := env.FileEnv. 2261 Vals[index] 2262 lhs.SetUint(lhs.Uint() << 2263 fun(env), 2264 ) 2265 } 2266 2267 env.IP++ 2268 return env.Code[env.IP], env 2269 } 2270 } 2271 default: 2272 2273 if intbinds { 2274 ret = func(env *Env) (Stmt, *Env) { 2275 o := env.Outer.Outer.Outer 2276 for i := 3; i < upn; i++ { 2277 o = o.Outer 2278 } 2279 *(*uint)(unsafe.Pointer(&o.Ints[index])) <<= fun(env) 2280 2281 env.IP++ 2282 return env.Code[env.IP], env 2283 } 2284 } else { 2285 ret = func(env *Env) (Stmt, *Env) { 2286 o := env.Outer.Outer.Outer 2287 for i := 3; i < upn; i++ { 2288 o = o.Outer 2289 } 2290 { 2291 lhs := 2292 2293 o.Vals[index] 2294 lhs.SetUint(lhs.Uint() << 2295 fun(env), 2296 ) 2297 } 2298 2299 env.IP++ 2300 return env.Code[env.IP], env 2301 } 2302 } 2303 } 2304 case r.Uint8: 2305 switch upn { 2306 case 0: 2307 2308 if intbinds { 2309 ret = func(env *Env) (Stmt, *Env) { 2310 *(*uint8)(unsafe.Pointer(&env.Ints[index])) <<= fun(env) 2311 2312 env.IP++ 2313 return env.Code[env.IP], env 2314 } 2315 } else { 2316 ret = func(env *Env) (Stmt, *Env) { 2317 { 2318 lhs := env. 2319 Vals[index] 2320 lhs.SetUint(lhs.Uint() << 2321 fun(env), 2322 ) 2323 } 2324 2325 env.IP++ 2326 return env.Code[env.IP], env 2327 } 2328 } 2329 case 1: 2330 2331 if intbinds { 2332 ret = func(env *Env) (Stmt, *Env) { 2333 *(*uint8)(unsafe.Pointer(&env. 2334 Outer.Ints[index])) <<= fun(env) 2335 2336 env.IP++ 2337 return env.Code[env.IP], env 2338 } 2339 } else { 2340 ret = func(env *Env) (Stmt, *Env) { 2341 { 2342 lhs := env. 2343 Outer. 2344 Vals[index] 2345 lhs.SetUint(lhs.Uint() << 2346 fun(env), 2347 ) 2348 } 2349 2350 env.IP++ 2351 return env.Code[env.IP], env 2352 } 2353 } 2354 case 2: 2355 2356 if intbinds { 2357 ret = func(env *Env) (Stmt, *Env) { 2358 *(*uint8)(unsafe.Pointer(&env. 2359 Outer.Outer.Ints[index])) <<= fun(env) 2360 2361 env.IP++ 2362 return env.Code[env.IP], env 2363 } 2364 } else { 2365 ret = func(env *Env) (Stmt, *Env) { 2366 { 2367 lhs := env. 2368 Outer.Outer. 2369 Vals[index] 2370 lhs.SetUint(lhs.Uint() << 2371 fun(env), 2372 ) 2373 } 2374 2375 env.IP++ 2376 return env.Code[env.IP], env 2377 } 2378 } 2379 case c.Depth - 1: 2380 2381 if intbinds { 2382 ret = func(env *Env) (Stmt, *Env) { 2383 *(*uint8)(unsafe.Pointer(&env.FileEnv.Ints[index])) <<= fun(env) 2384 2385 env.IP++ 2386 return env.Code[env.IP], env 2387 } 2388 } else { 2389 ret = func(env *Env) (Stmt, *Env) { 2390 { 2391 lhs := env.FileEnv. 2392 Vals[index] 2393 lhs.SetUint(lhs.Uint() << 2394 fun(env), 2395 ) 2396 } 2397 2398 env.IP++ 2399 return env.Code[env.IP], env 2400 } 2401 } 2402 default: 2403 2404 if intbinds { 2405 ret = func(env *Env) (Stmt, *Env) { 2406 o := env.Outer.Outer.Outer 2407 for i := 3; i < upn; i++ { 2408 o = o.Outer 2409 } 2410 *(*uint8)(unsafe.Pointer(&o.Ints[index])) <<= fun(env) 2411 2412 env.IP++ 2413 return env.Code[env.IP], env 2414 } 2415 } else { 2416 ret = func(env *Env) (Stmt, *Env) { 2417 o := env.Outer.Outer.Outer 2418 for i := 3; i < upn; i++ { 2419 o = o.Outer 2420 } 2421 { 2422 lhs := 2423 2424 o.Vals[index] 2425 lhs.SetUint(lhs.Uint() << 2426 fun(env), 2427 ) 2428 } 2429 2430 env.IP++ 2431 return env.Code[env.IP], env 2432 } 2433 } 2434 } 2435 case r.Uint16: 2436 switch upn { 2437 case 0: 2438 2439 if intbinds { 2440 ret = func(env *Env) (Stmt, *Env) { 2441 *(*uint16)(unsafe.Pointer(&env.Ints[index])) <<= fun(env) 2442 2443 env.IP++ 2444 return env.Code[env.IP], env 2445 } 2446 } else { 2447 ret = func(env *Env) (Stmt, *Env) { 2448 { 2449 lhs := env. 2450 Vals[index] 2451 lhs.SetUint(lhs.Uint() << 2452 fun(env), 2453 ) 2454 } 2455 2456 env.IP++ 2457 return env.Code[env.IP], env 2458 } 2459 } 2460 case 1: 2461 2462 if intbinds { 2463 ret = func(env *Env) (Stmt, *Env) { 2464 *(*uint16)(unsafe.Pointer(&env. 2465 Outer.Ints[index])) <<= fun(env) 2466 2467 env.IP++ 2468 return env.Code[env.IP], env 2469 } 2470 } else { 2471 ret = func(env *Env) (Stmt, *Env) { 2472 { 2473 lhs := env. 2474 Outer. 2475 Vals[index] 2476 lhs.SetUint(lhs.Uint() << 2477 fun(env), 2478 ) 2479 } 2480 2481 env.IP++ 2482 return env.Code[env.IP], env 2483 } 2484 } 2485 case 2: 2486 2487 if intbinds { 2488 ret = func(env *Env) (Stmt, *Env) { 2489 *(*uint16)(unsafe.Pointer(&env. 2490 Outer.Outer.Ints[index])) <<= fun(env) 2491 2492 env.IP++ 2493 return env.Code[env.IP], env 2494 } 2495 } else { 2496 ret = func(env *Env) (Stmt, *Env) { 2497 { 2498 lhs := env. 2499 Outer.Outer. 2500 Vals[index] 2501 lhs.SetUint(lhs.Uint() << 2502 fun(env), 2503 ) 2504 } 2505 2506 env.IP++ 2507 return env.Code[env.IP], env 2508 } 2509 } 2510 case c.Depth - 1: 2511 2512 if intbinds { 2513 ret = func(env *Env) (Stmt, *Env) { 2514 *(*uint16)(unsafe.Pointer(&env.FileEnv.Ints[index])) <<= fun(env) 2515 2516 env.IP++ 2517 return env.Code[env.IP], env 2518 } 2519 } else { 2520 ret = func(env *Env) (Stmt, *Env) { 2521 { 2522 lhs := env.FileEnv. 2523 Vals[index] 2524 lhs.SetUint(lhs.Uint() << 2525 fun(env), 2526 ) 2527 } 2528 2529 env.IP++ 2530 return env.Code[env.IP], env 2531 } 2532 } 2533 default: 2534 2535 if intbinds { 2536 ret = func(env *Env) (Stmt, *Env) { 2537 o := env.Outer.Outer.Outer 2538 for i := 3; i < upn; i++ { 2539 o = o.Outer 2540 } 2541 *(*uint16)(unsafe.Pointer(&o.Ints[index])) <<= fun(env) 2542 2543 env.IP++ 2544 return env.Code[env.IP], env 2545 } 2546 } else { 2547 ret = func(env *Env) (Stmt, *Env) { 2548 o := env.Outer.Outer.Outer 2549 for i := 3; i < upn; i++ { 2550 o = o.Outer 2551 } 2552 { 2553 lhs := 2554 2555 o.Vals[index] 2556 lhs.SetUint(lhs.Uint() << 2557 fun(env), 2558 ) 2559 } 2560 2561 env.IP++ 2562 return env.Code[env.IP], env 2563 } 2564 } 2565 } 2566 case r.Uint32: 2567 switch upn { 2568 case 0: 2569 2570 if intbinds { 2571 ret = func(env *Env) (Stmt, *Env) { 2572 *(*uint32)(unsafe.Pointer(&env.Ints[index])) <<= fun(env) 2573 2574 env.IP++ 2575 return env.Code[env.IP], env 2576 } 2577 } else { 2578 ret = func(env *Env) (Stmt, *Env) { 2579 { 2580 lhs := env. 2581 Vals[index] 2582 lhs.SetUint(lhs.Uint() << 2583 fun(env), 2584 ) 2585 } 2586 2587 env.IP++ 2588 return env.Code[env.IP], env 2589 } 2590 } 2591 case 1: 2592 2593 if intbinds { 2594 ret = func(env *Env) (Stmt, *Env) { 2595 *(*uint32)(unsafe.Pointer(&env. 2596 Outer.Ints[index])) <<= fun(env) 2597 2598 env.IP++ 2599 return env.Code[env.IP], env 2600 } 2601 } else { 2602 ret = func(env *Env) (Stmt, *Env) { 2603 { 2604 lhs := env. 2605 Outer. 2606 Vals[index] 2607 lhs.SetUint(lhs.Uint() << 2608 fun(env), 2609 ) 2610 } 2611 2612 env.IP++ 2613 return env.Code[env.IP], env 2614 } 2615 } 2616 case 2: 2617 2618 if intbinds { 2619 ret = func(env *Env) (Stmt, *Env) { 2620 *(*uint32)(unsafe.Pointer(&env. 2621 Outer.Outer.Ints[index])) <<= fun(env) 2622 2623 env.IP++ 2624 return env.Code[env.IP], env 2625 } 2626 } else { 2627 ret = func(env *Env) (Stmt, *Env) { 2628 { 2629 lhs := env. 2630 Outer.Outer. 2631 Vals[index] 2632 lhs.SetUint(lhs.Uint() << 2633 fun(env), 2634 ) 2635 } 2636 2637 env.IP++ 2638 return env.Code[env.IP], env 2639 } 2640 } 2641 case c.Depth - 1: 2642 2643 if intbinds { 2644 ret = func(env *Env) (Stmt, *Env) { 2645 *(*uint32)(unsafe.Pointer(&env.FileEnv.Ints[index])) <<= fun(env) 2646 2647 env.IP++ 2648 return env.Code[env.IP], env 2649 } 2650 } else { 2651 ret = func(env *Env) (Stmt, *Env) { 2652 { 2653 lhs := env.FileEnv. 2654 Vals[index] 2655 lhs.SetUint(lhs.Uint() << 2656 fun(env), 2657 ) 2658 } 2659 2660 env.IP++ 2661 return env.Code[env.IP], env 2662 } 2663 } 2664 default: 2665 2666 if intbinds { 2667 ret = func(env *Env) (Stmt, *Env) { 2668 o := env.Outer.Outer.Outer 2669 for i := 3; i < upn; i++ { 2670 o = o.Outer 2671 } 2672 *(*uint32)(unsafe.Pointer(&o.Ints[index])) <<= fun(env) 2673 2674 env.IP++ 2675 return env.Code[env.IP], env 2676 } 2677 } else { 2678 ret = func(env *Env) (Stmt, *Env) { 2679 o := env.Outer.Outer.Outer 2680 for i := 3; i < upn; i++ { 2681 o = o.Outer 2682 } 2683 { 2684 lhs := 2685 2686 o.Vals[index] 2687 lhs.SetUint(lhs.Uint() << 2688 fun(env), 2689 ) 2690 } 2691 2692 env.IP++ 2693 return env.Code[env.IP], env 2694 } 2695 } 2696 } 2697 case r.Uint64: 2698 switch upn { 2699 case 0: 2700 2701 if intbinds { 2702 ret = func(env *Env) (Stmt, *Env) { 2703 env. 2704 Ints[index] <<= fun(env) 2705 2706 env.IP++ 2707 return env.Code[env.IP], env 2708 } 2709 } else { 2710 ret = func(env *Env) (Stmt, *Env) { 2711 { 2712 lhs := env. 2713 Vals[index] 2714 lhs.SetUint(lhs.Uint() << 2715 fun(env), 2716 ) 2717 } 2718 2719 env.IP++ 2720 return env.Code[env.IP], env 2721 } 2722 } 2723 case 1: 2724 2725 if intbinds { 2726 ret = func(env *Env) (Stmt, *Env) { 2727 env. 2728 Outer. 2729 Ints[index] <<= fun(env) 2730 2731 env.IP++ 2732 return env.Code[env.IP], env 2733 } 2734 } else { 2735 ret = func(env *Env) (Stmt, *Env) { 2736 { 2737 lhs := env. 2738 Outer. 2739 Vals[index] 2740 lhs.SetUint(lhs.Uint() << 2741 fun(env), 2742 ) 2743 } 2744 2745 env.IP++ 2746 return env.Code[env.IP], env 2747 } 2748 } 2749 case 2: 2750 2751 if intbinds { 2752 ret = func(env *Env) (Stmt, *Env) { 2753 env. 2754 Outer.Outer. 2755 Ints[index] <<= fun(env) 2756 2757 env.IP++ 2758 return env.Code[env.IP], env 2759 } 2760 } else { 2761 ret = func(env *Env) (Stmt, *Env) { 2762 { 2763 lhs := env. 2764 Outer.Outer. 2765 Vals[index] 2766 lhs.SetUint(lhs.Uint() << 2767 fun(env), 2768 ) 2769 } 2770 2771 env.IP++ 2772 return env.Code[env.IP], env 2773 } 2774 } 2775 case c.Depth - 1: 2776 2777 if intbinds { 2778 ret = func(env *Env) (Stmt, *Env) { 2779 env.FileEnv. 2780 Ints[index] <<= fun(env) 2781 2782 env.IP++ 2783 return env.Code[env.IP], env 2784 } 2785 } else { 2786 ret = func(env *Env) (Stmt, *Env) { 2787 { 2788 lhs := env.FileEnv. 2789 Vals[index] 2790 lhs.SetUint(lhs.Uint() << 2791 fun(env), 2792 ) 2793 } 2794 2795 env.IP++ 2796 return env.Code[env.IP], env 2797 } 2798 } 2799 default: 2800 2801 if intbinds { 2802 ret = func(env *Env) (Stmt, *Env) { 2803 o := env.Outer.Outer.Outer 2804 for i := 3; i < upn; i++ { 2805 o = o.Outer 2806 } 2807 2808 o.Ints[index] <<= fun(env) 2809 2810 env.IP++ 2811 return env.Code[env.IP], env 2812 } 2813 } else { 2814 ret = func(env *Env) (Stmt, *Env) { 2815 o := env.Outer.Outer.Outer 2816 for i := 3; i < upn; i++ { 2817 o = o.Outer 2818 } 2819 { 2820 lhs := 2821 2822 o.Vals[index] 2823 lhs.SetUint(lhs.Uint() << 2824 fun(env), 2825 ) 2826 } 2827 2828 env.IP++ 2829 return env.Code[env.IP], env 2830 } 2831 } 2832 } 2833 case r.Uintptr: 2834 switch upn { 2835 case 0: 2836 2837 if intbinds { 2838 ret = func(env *Env) (Stmt, *Env) { 2839 *(*uintptr)(unsafe.Pointer(&env.Ints[index])) <<= fun(env) 2840 2841 env.IP++ 2842 return env.Code[env.IP], env 2843 } 2844 } else { 2845 ret = func(env *Env) (Stmt, *Env) { 2846 { 2847 lhs := env. 2848 Vals[index] 2849 lhs.SetUint(lhs.Uint() << 2850 fun(env), 2851 ) 2852 } 2853 2854 env.IP++ 2855 return env.Code[env.IP], env 2856 } 2857 } 2858 case 1: 2859 2860 if intbinds { 2861 ret = func(env *Env) (Stmt, *Env) { 2862 *(*uintptr)(unsafe.Pointer(&env. 2863 Outer.Ints[index])) <<= fun(env) 2864 2865 env.IP++ 2866 return env.Code[env.IP], env 2867 } 2868 } else { 2869 ret = func(env *Env) (Stmt, *Env) { 2870 { 2871 lhs := env. 2872 Outer. 2873 Vals[index] 2874 lhs.SetUint(lhs.Uint() << 2875 fun(env), 2876 ) 2877 } 2878 2879 env.IP++ 2880 return env.Code[env.IP], env 2881 } 2882 } 2883 case 2: 2884 2885 if intbinds { 2886 ret = func(env *Env) (Stmt, *Env) { 2887 *(*uintptr)(unsafe.Pointer(&env. 2888 Outer.Outer.Ints[index])) <<= fun(env) 2889 2890 env.IP++ 2891 return env.Code[env.IP], env 2892 } 2893 } else { 2894 ret = func(env *Env) (Stmt, *Env) { 2895 { 2896 lhs := env. 2897 Outer.Outer. 2898 Vals[index] 2899 lhs.SetUint(lhs.Uint() << 2900 fun(env), 2901 ) 2902 } 2903 2904 env.IP++ 2905 return env.Code[env.IP], env 2906 } 2907 } 2908 case c.Depth - 1: 2909 2910 if intbinds { 2911 ret = func(env *Env) (Stmt, *Env) { 2912 *(*uintptr)(unsafe.Pointer(&env.FileEnv.Ints[index])) <<= fun(env) 2913 2914 env.IP++ 2915 return env.Code[env.IP], env 2916 } 2917 } else { 2918 ret = func(env *Env) (Stmt, *Env) { 2919 { 2920 lhs := env.FileEnv. 2921 Vals[index] 2922 lhs.SetUint(lhs.Uint() << 2923 fun(env), 2924 ) 2925 } 2926 2927 env.IP++ 2928 return env.Code[env.IP], env 2929 } 2930 } 2931 default: 2932 2933 if intbinds { 2934 ret = func(env *Env) (Stmt, *Env) { 2935 o := env.Outer.Outer.Outer 2936 for i := 3; i < upn; i++ { 2937 o = o.Outer 2938 } 2939 *(*uintptr)(unsafe.Pointer(&o.Ints[index])) <<= fun(env) 2940 2941 env.IP++ 2942 return env.Code[env.IP], env 2943 } 2944 } else { 2945 ret = func(env *Env) (Stmt, *Env) { 2946 o := env.Outer.Outer.Outer 2947 for i := 3; i < upn; i++ { 2948 o = o.Outer 2949 } 2950 { 2951 lhs := 2952 2953 o.Vals[index] 2954 lhs.SetUint(lhs.Uint() << 2955 fun(env), 2956 ) 2957 } 2958 2959 env.IP++ 2960 return env.Code[env.IP], env 2961 } 2962 } 2963 } 2964 default: 2965 c.Errorf(`invalid operator %s= between <%v> and <%v>`, token.SHL, t, t2) 2966 2967 } 2968 return ret 2969 } 2970} 2971func (c *Comp) varShrConst(va *Var, val I) Stmt { 2972 t := va.Type 2973 upn := va.Upn 2974 index := va.Desc.Index() 2975 intbinds := va.Desc.Class() == IntBind 2976 2977 t2 := r.TypeOf(val) 2978 if t2 == nil || reflect.Category(t2.Kind()) != r.Uint { 2979 c.Errorf(`invalid operator %s= between <%v> and <%v>`, token.SHR, t, t2) 2980 } 2981 2982 if isLiteralNumber(val, 0) { 2983 return nil 2984 } 2985 { 2986 val := r.ValueOf(val).Uint() 2987 var ret Stmt 2988 switch t.Kind() { 2989 case r.Int: 2990 switch upn { 2991 case 0: 2992 2993 if intbinds { 2994 ret = func(env *Env) (Stmt, *Env) { 2995 *(*int)(unsafe.Pointer(&env.Ints[index])) >>= val 2996 2997 env.IP++ 2998 return env.Code[env.IP], env 2999 } 3000 } else { 3001 ret = func(env *Env) (Stmt, *Env) { 3002 { 3003 lhs := env. 3004 Vals[index] 3005 lhs.SetInt(lhs.Int() >> 3006 val, 3007 ) 3008 } 3009 3010 env.IP++ 3011 return env.Code[env.IP], env 3012 } 3013 } 3014 case 1: 3015 3016 if intbinds { 3017 ret = func(env *Env) (Stmt, *Env) { 3018 *(*int)(unsafe.Pointer(&env. 3019 Outer.Ints[index])) >>= val 3020 3021 env.IP++ 3022 return env.Code[env.IP], env 3023 } 3024 } else { 3025 ret = func(env *Env) (Stmt, *Env) { 3026 { 3027 lhs := env. 3028 Outer. 3029 Vals[index] 3030 lhs.SetInt(lhs.Int() >> 3031 val, 3032 ) 3033 } 3034 3035 env.IP++ 3036 return env.Code[env.IP], env 3037 } 3038 } 3039 case 2: 3040 3041 if intbinds { 3042 ret = func(env *Env) (Stmt, *Env) { 3043 *(*int)(unsafe.Pointer(&env. 3044 Outer.Outer.Ints[index])) >>= val 3045 3046 env.IP++ 3047 return env.Code[env.IP], env 3048 } 3049 } else { 3050 ret = func(env *Env) (Stmt, *Env) { 3051 { 3052 lhs := env. 3053 Outer.Outer. 3054 Vals[index] 3055 lhs.SetInt(lhs.Int() >> 3056 val, 3057 ) 3058 } 3059 3060 env.IP++ 3061 return env.Code[env.IP], env 3062 } 3063 } 3064 case c.Depth - 1: 3065 3066 if intbinds { 3067 ret = func(env *Env) (Stmt, *Env) { 3068 *(*int)(unsafe.Pointer(&env.FileEnv.Ints[index])) >>= val 3069 3070 env.IP++ 3071 return env.Code[env.IP], env 3072 } 3073 } else { 3074 ret = func(env *Env) (Stmt, *Env) { 3075 { 3076 lhs := env.FileEnv. 3077 Vals[index] 3078 lhs.SetInt(lhs.Int() >> 3079 val, 3080 ) 3081 } 3082 3083 env.IP++ 3084 return env.Code[env.IP], env 3085 } 3086 } 3087 default: 3088 3089 if intbinds { 3090 ret = func(env *Env) (Stmt, *Env) { 3091 o := env.Outer.Outer.Outer 3092 for i := 3; i < upn; i++ { 3093 o = o.Outer 3094 } 3095 *(*int)(unsafe.Pointer(&o.Ints[index])) >>= val 3096 3097 env.IP++ 3098 return env.Code[env.IP], env 3099 } 3100 } else { 3101 ret = func(env *Env) (Stmt, *Env) { 3102 o := env.Outer.Outer.Outer 3103 for i := 3; i < upn; i++ { 3104 o = o.Outer 3105 } 3106 { 3107 lhs := 3108 3109 o.Vals[index] 3110 lhs.SetInt(lhs.Int() >> 3111 val, 3112 ) 3113 } 3114 3115 env.IP++ 3116 return env.Code[env.IP], env 3117 } 3118 } 3119 } 3120 case r.Int8: 3121 switch upn { 3122 case 0: 3123 3124 if intbinds { 3125 ret = func(env *Env) (Stmt, *Env) { 3126 *(*int8)(unsafe.Pointer(&env.Ints[index])) >>= val 3127 3128 env.IP++ 3129 return env.Code[env.IP], env 3130 } 3131 } else { 3132 ret = func(env *Env) (Stmt, *Env) { 3133 { 3134 lhs := env. 3135 Vals[index] 3136 lhs.SetInt(lhs.Int() >> 3137 val, 3138 ) 3139 } 3140 3141 env.IP++ 3142 return env.Code[env.IP], env 3143 } 3144 } 3145 case 1: 3146 3147 if intbinds { 3148 ret = func(env *Env) (Stmt, *Env) { 3149 *(*int8)(unsafe.Pointer(&env. 3150 Outer.Ints[index])) >>= val 3151 3152 env.IP++ 3153 return env.Code[env.IP], env 3154 } 3155 } else { 3156 ret = func(env *Env) (Stmt, *Env) { 3157 { 3158 lhs := env. 3159 Outer. 3160 Vals[index] 3161 lhs.SetInt(lhs.Int() >> 3162 val, 3163 ) 3164 } 3165 3166 env.IP++ 3167 return env.Code[env.IP], env 3168 } 3169 } 3170 case 2: 3171 3172 if intbinds { 3173 ret = func(env *Env) (Stmt, *Env) { 3174 *(*int8)(unsafe.Pointer(&env. 3175 Outer.Outer.Ints[index])) >>= val 3176 3177 env.IP++ 3178 return env.Code[env.IP], env 3179 } 3180 } else { 3181 ret = func(env *Env) (Stmt, *Env) { 3182 { 3183 lhs := env. 3184 Outer.Outer. 3185 Vals[index] 3186 lhs.SetInt(lhs.Int() >> 3187 val, 3188 ) 3189 } 3190 3191 env.IP++ 3192 return env.Code[env.IP], env 3193 } 3194 } 3195 case c.Depth - 1: 3196 3197 if intbinds { 3198 ret = func(env *Env) (Stmt, *Env) { 3199 *(*int8)(unsafe.Pointer(&env.FileEnv.Ints[index])) >>= val 3200 3201 env.IP++ 3202 return env.Code[env.IP], env 3203 } 3204 } else { 3205 ret = func(env *Env) (Stmt, *Env) { 3206 { 3207 lhs := env.FileEnv. 3208 Vals[index] 3209 lhs.SetInt(lhs.Int() >> 3210 val, 3211 ) 3212 } 3213 3214 env.IP++ 3215 return env.Code[env.IP], env 3216 } 3217 } 3218 default: 3219 3220 if intbinds { 3221 ret = func(env *Env) (Stmt, *Env) { 3222 o := env.Outer.Outer.Outer 3223 for i := 3; i < upn; i++ { 3224 o = o.Outer 3225 } 3226 *(*int8)(unsafe.Pointer(&o.Ints[index])) >>= val 3227 3228 env.IP++ 3229 return env.Code[env.IP], env 3230 } 3231 } else { 3232 ret = func(env *Env) (Stmt, *Env) { 3233 o := env.Outer.Outer.Outer 3234 for i := 3; i < upn; i++ { 3235 o = o.Outer 3236 } 3237 { 3238 lhs := 3239 3240 o.Vals[index] 3241 lhs.SetInt(lhs.Int() >> 3242 val, 3243 ) 3244 } 3245 3246 env.IP++ 3247 return env.Code[env.IP], env 3248 } 3249 } 3250 } 3251 case r.Int16: 3252 switch upn { 3253 case 0: 3254 3255 if intbinds { 3256 ret = func(env *Env) (Stmt, *Env) { 3257 *(*int16)(unsafe.Pointer(&env.Ints[index])) >>= val 3258 3259 env.IP++ 3260 return env.Code[env.IP], env 3261 } 3262 } else { 3263 ret = func(env *Env) (Stmt, *Env) { 3264 { 3265 lhs := env. 3266 Vals[index] 3267 lhs.SetInt(lhs.Int() >> 3268 val, 3269 ) 3270 } 3271 3272 env.IP++ 3273 return env.Code[env.IP], env 3274 } 3275 } 3276 case 1: 3277 3278 if intbinds { 3279 ret = func(env *Env) (Stmt, *Env) { 3280 *(*int16)(unsafe.Pointer(&env. 3281 Outer.Ints[index])) >>= val 3282 3283 env.IP++ 3284 return env.Code[env.IP], env 3285 } 3286 } else { 3287 ret = func(env *Env) (Stmt, *Env) { 3288 { 3289 lhs := env. 3290 Outer. 3291 Vals[index] 3292 lhs.SetInt(lhs.Int() >> 3293 val, 3294 ) 3295 } 3296 3297 env.IP++ 3298 return env.Code[env.IP], env 3299 } 3300 } 3301 case 2: 3302 3303 if intbinds { 3304 ret = func(env *Env) (Stmt, *Env) { 3305 *(*int16)(unsafe.Pointer(&env. 3306 Outer.Outer.Ints[index])) >>= val 3307 3308 env.IP++ 3309 return env.Code[env.IP], env 3310 } 3311 } else { 3312 ret = func(env *Env) (Stmt, *Env) { 3313 { 3314 lhs := env. 3315 Outer.Outer. 3316 Vals[index] 3317 lhs.SetInt(lhs.Int() >> 3318 val, 3319 ) 3320 } 3321 3322 env.IP++ 3323 return env.Code[env.IP], env 3324 } 3325 } 3326 case c.Depth - 1: 3327 3328 if intbinds { 3329 ret = func(env *Env) (Stmt, *Env) { 3330 *(*int16)(unsafe.Pointer(&env.FileEnv.Ints[index])) >>= val 3331 3332 env.IP++ 3333 return env.Code[env.IP], env 3334 } 3335 } else { 3336 ret = func(env *Env) (Stmt, *Env) { 3337 { 3338 lhs := env.FileEnv. 3339 Vals[index] 3340 lhs.SetInt(lhs.Int() >> 3341 val, 3342 ) 3343 } 3344 3345 env.IP++ 3346 return env.Code[env.IP], env 3347 } 3348 } 3349 default: 3350 3351 if intbinds { 3352 ret = func(env *Env) (Stmt, *Env) { 3353 o := env.Outer.Outer.Outer 3354 for i := 3; i < upn; i++ { 3355 o = o.Outer 3356 } 3357 *(*int16)(unsafe.Pointer(&o.Ints[index])) >>= val 3358 3359 env.IP++ 3360 return env.Code[env.IP], env 3361 } 3362 } else { 3363 ret = func(env *Env) (Stmt, *Env) { 3364 o := env.Outer.Outer.Outer 3365 for i := 3; i < upn; i++ { 3366 o = o.Outer 3367 } 3368 { 3369 lhs := 3370 3371 o.Vals[index] 3372 lhs.SetInt(lhs.Int() >> 3373 val, 3374 ) 3375 } 3376 3377 env.IP++ 3378 return env.Code[env.IP], env 3379 } 3380 } 3381 } 3382 case r.Int32: 3383 switch upn { 3384 case 0: 3385 3386 if intbinds { 3387 ret = func(env *Env) (Stmt, *Env) { 3388 *(*int32)(unsafe.Pointer(&env.Ints[index])) >>= val 3389 3390 env.IP++ 3391 return env.Code[env.IP], env 3392 } 3393 } else { 3394 ret = func(env *Env) (Stmt, *Env) { 3395 { 3396 lhs := env. 3397 Vals[index] 3398 lhs.SetInt(lhs.Int() >> 3399 val, 3400 ) 3401 } 3402 3403 env.IP++ 3404 return env.Code[env.IP], env 3405 } 3406 } 3407 case 1: 3408 3409 if intbinds { 3410 ret = func(env *Env) (Stmt, *Env) { 3411 *(*int32)(unsafe.Pointer(&env. 3412 Outer.Ints[index])) >>= val 3413 3414 env.IP++ 3415 return env.Code[env.IP], env 3416 } 3417 } else { 3418 ret = func(env *Env) (Stmt, *Env) { 3419 { 3420 lhs := env. 3421 Outer. 3422 Vals[index] 3423 lhs.SetInt(lhs.Int() >> 3424 val, 3425 ) 3426 } 3427 3428 env.IP++ 3429 return env.Code[env.IP], env 3430 } 3431 } 3432 case 2: 3433 3434 if intbinds { 3435 ret = func(env *Env) (Stmt, *Env) { 3436 *(*int32)(unsafe.Pointer(&env. 3437 Outer.Outer.Ints[index])) >>= val 3438 3439 env.IP++ 3440 return env.Code[env.IP], env 3441 } 3442 } else { 3443 ret = func(env *Env) (Stmt, *Env) { 3444 { 3445 lhs := env. 3446 Outer.Outer. 3447 Vals[index] 3448 lhs.SetInt(lhs.Int() >> 3449 val, 3450 ) 3451 } 3452 3453 env.IP++ 3454 return env.Code[env.IP], env 3455 } 3456 } 3457 case c.Depth - 1: 3458 3459 if intbinds { 3460 ret = func(env *Env) (Stmt, *Env) { 3461 *(*int32)(unsafe.Pointer(&env.FileEnv.Ints[index])) >>= val 3462 3463 env.IP++ 3464 return env.Code[env.IP], env 3465 } 3466 } else { 3467 ret = func(env *Env) (Stmt, *Env) { 3468 { 3469 lhs := env.FileEnv. 3470 Vals[index] 3471 lhs.SetInt(lhs.Int() >> 3472 val, 3473 ) 3474 } 3475 3476 env.IP++ 3477 return env.Code[env.IP], env 3478 } 3479 } 3480 default: 3481 3482 if intbinds { 3483 ret = func(env *Env) (Stmt, *Env) { 3484 o := env.Outer.Outer.Outer 3485 for i := 3; i < upn; i++ { 3486 o = o.Outer 3487 } 3488 *(*int32)(unsafe.Pointer(&o.Ints[index])) >>= val 3489 3490 env.IP++ 3491 return env.Code[env.IP], env 3492 } 3493 } else { 3494 ret = func(env *Env) (Stmt, *Env) { 3495 o := env.Outer.Outer.Outer 3496 for i := 3; i < upn; i++ { 3497 o = o.Outer 3498 } 3499 { 3500 lhs := 3501 3502 o.Vals[index] 3503 lhs.SetInt(lhs.Int() >> 3504 val, 3505 ) 3506 } 3507 3508 env.IP++ 3509 return env.Code[env.IP], env 3510 } 3511 } 3512 } 3513 case r.Int64: 3514 switch upn { 3515 case 0: 3516 3517 if intbinds { 3518 ret = func(env *Env) (Stmt, *Env) { 3519 *(*int64)(unsafe.Pointer(&env.Ints[index])) >>= val 3520 3521 env.IP++ 3522 return env.Code[env.IP], env 3523 } 3524 } else { 3525 ret = func(env *Env) (Stmt, *Env) { 3526 { 3527 lhs := env. 3528 Vals[index] 3529 lhs.SetInt(lhs.Int() >> 3530 val, 3531 ) 3532 } 3533 3534 env.IP++ 3535 return env.Code[env.IP], env 3536 } 3537 } 3538 case 1: 3539 3540 if intbinds { 3541 ret = func(env *Env) (Stmt, *Env) { 3542 *(*int64)(unsafe.Pointer(&env. 3543 Outer.Ints[index])) >>= val 3544 3545 env.IP++ 3546 return env.Code[env.IP], env 3547 } 3548 } else { 3549 ret = func(env *Env) (Stmt, *Env) { 3550 { 3551 lhs := env. 3552 Outer. 3553 Vals[index] 3554 lhs.SetInt(lhs.Int() >> 3555 val, 3556 ) 3557 } 3558 3559 env.IP++ 3560 return env.Code[env.IP], env 3561 } 3562 } 3563 case 2: 3564 3565 if intbinds { 3566 ret = func(env *Env) (Stmt, *Env) { 3567 *(*int64)(unsafe.Pointer(&env. 3568 Outer.Outer.Ints[index])) >>= val 3569 3570 env.IP++ 3571 return env.Code[env.IP], env 3572 } 3573 } else { 3574 ret = func(env *Env) (Stmt, *Env) { 3575 { 3576 lhs := env. 3577 Outer.Outer. 3578 Vals[index] 3579 lhs.SetInt(lhs.Int() >> 3580 val, 3581 ) 3582 } 3583 3584 env.IP++ 3585 return env.Code[env.IP], env 3586 } 3587 } 3588 case c.Depth - 1: 3589 3590 if intbinds { 3591 ret = func(env *Env) (Stmt, *Env) { 3592 *(*int64)(unsafe.Pointer(&env.FileEnv.Ints[index])) >>= val 3593 3594 env.IP++ 3595 return env.Code[env.IP], env 3596 } 3597 } else { 3598 ret = func(env *Env) (Stmt, *Env) { 3599 { 3600 lhs := env.FileEnv. 3601 Vals[index] 3602 lhs.SetInt(lhs.Int() >> 3603 val, 3604 ) 3605 } 3606 3607 env.IP++ 3608 return env.Code[env.IP], env 3609 } 3610 } 3611 default: 3612 3613 if intbinds { 3614 ret = func(env *Env) (Stmt, *Env) { 3615 o := env.Outer.Outer.Outer 3616 for i := 3; i < upn; i++ { 3617 o = o.Outer 3618 } 3619 *(*int64)(unsafe.Pointer(&o.Ints[index])) >>= val 3620 3621 env.IP++ 3622 return env.Code[env.IP], env 3623 } 3624 } else { 3625 ret = func(env *Env) (Stmt, *Env) { 3626 o := env.Outer.Outer.Outer 3627 for i := 3; i < upn; i++ { 3628 o = o.Outer 3629 } 3630 { 3631 lhs := 3632 3633 o.Vals[index] 3634 lhs.SetInt(lhs.Int() >> 3635 val, 3636 ) 3637 } 3638 3639 env.IP++ 3640 return env.Code[env.IP], env 3641 } 3642 } 3643 } 3644 case r.Uint: 3645 switch upn { 3646 case 0: 3647 3648 if intbinds { 3649 ret = func(env *Env) (Stmt, *Env) { 3650 *(*uint)(unsafe.Pointer(&env.Ints[index])) >>= val 3651 3652 env.IP++ 3653 return env.Code[env.IP], env 3654 } 3655 } else { 3656 ret = func(env *Env) (Stmt, *Env) { 3657 { 3658 lhs := env. 3659 Vals[index] 3660 lhs.SetUint(lhs.Uint() >> 3661 val, 3662 ) 3663 } 3664 3665 env.IP++ 3666 return env.Code[env.IP], env 3667 } 3668 } 3669 case 1: 3670 3671 if intbinds { 3672 ret = func(env *Env) (Stmt, *Env) { 3673 *(*uint)(unsafe.Pointer(&env. 3674 Outer.Ints[index])) >>= val 3675 3676 env.IP++ 3677 return env.Code[env.IP], env 3678 } 3679 } else { 3680 ret = func(env *Env) (Stmt, *Env) { 3681 { 3682 lhs := env. 3683 Outer. 3684 Vals[index] 3685 lhs.SetUint(lhs.Uint() >> 3686 val, 3687 ) 3688 } 3689 3690 env.IP++ 3691 return env.Code[env.IP], env 3692 } 3693 } 3694 case 2: 3695 3696 if intbinds { 3697 ret = func(env *Env) (Stmt, *Env) { 3698 *(*uint)(unsafe.Pointer(&env. 3699 Outer.Outer.Ints[index])) >>= val 3700 3701 env.IP++ 3702 return env.Code[env.IP], env 3703 } 3704 } else { 3705 ret = func(env *Env) (Stmt, *Env) { 3706 { 3707 lhs := env. 3708 Outer.Outer. 3709 Vals[index] 3710 lhs.SetUint(lhs.Uint() >> 3711 val, 3712 ) 3713 } 3714 3715 env.IP++ 3716 return env.Code[env.IP], env 3717 } 3718 } 3719 case c.Depth - 1: 3720 3721 if intbinds { 3722 ret = func(env *Env) (Stmt, *Env) { 3723 *(*uint)(unsafe.Pointer(&env.FileEnv.Ints[index])) >>= val 3724 3725 env.IP++ 3726 return env.Code[env.IP], env 3727 } 3728 } else { 3729 ret = func(env *Env) (Stmt, *Env) { 3730 { 3731 lhs := env.FileEnv. 3732 Vals[index] 3733 lhs.SetUint(lhs.Uint() >> 3734 val, 3735 ) 3736 } 3737 3738 env.IP++ 3739 return env.Code[env.IP], env 3740 } 3741 } 3742 default: 3743 3744 if intbinds { 3745 ret = func(env *Env) (Stmt, *Env) { 3746 o := env.Outer.Outer.Outer 3747 for i := 3; i < upn; i++ { 3748 o = o.Outer 3749 } 3750 *(*uint)(unsafe.Pointer(&o.Ints[index])) >>= val 3751 3752 env.IP++ 3753 return env.Code[env.IP], env 3754 } 3755 } else { 3756 ret = func(env *Env) (Stmt, *Env) { 3757 o := env.Outer.Outer.Outer 3758 for i := 3; i < upn; i++ { 3759 o = o.Outer 3760 } 3761 { 3762 lhs := 3763 3764 o.Vals[index] 3765 lhs.SetUint(lhs.Uint() >> 3766 val, 3767 ) 3768 } 3769 3770 env.IP++ 3771 return env.Code[env.IP], env 3772 } 3773 } 3774 } 3775 case r.Uint8: 3776 switch upn { 3777 case 0: 3778 3779 if intbinds { 3780 ret = func(env *Env) (Stmt, *Env) { 3781 *(*uint8)(unsafe.Pointer(&env.Ints[index])) >>= val 3782 3783 env.IP++ 3784 return env.Code[env.IP], env 3785 } 3786 } else { 3787 ret = func(env *Env) (Stmt, *Env) { 3788 { 3789 lhs := env. 3790 Vals[index] 3791 lhs.SetUint(lhs.Uint() >> 3792 val, 3793 ) 3794 } 3795 3796 env.IP++ 3797 return env.Code[env.IP], env 3798 } 3799 } 3800 case 1: 3801 3802 if intbinds { 3803 ret = func(env *Env) (Stmt, *Env) { 3804 *(*uint8)(unsafe.Pointer(&env. 3805 Outer.Ints[index])) >>= val 3806 3807 env.IP++ 3808 return env.Code[env.IP], env 3809 } 3810 } else { 3811 ret = func(env *Env) (Stmt, *Env) { 3812 { 3813 lhs := env. 3814 Outer. 3815 Vals[index] 3816 lhs.SetUint(lhs.Uint() >> 3817 val, 3818 ) 3819 } 3820 3821 env.IP++ 3822 return env.Code[env.IP], env 3823 } 3824 } 3825 case 2: 3826 3827 if intbinds { 3828 ret = func(env *Env) (Stmt, *Env) { 3829 *(*uint8)(unsafe.Pointer(&env. 3830 Outer.Outer.Ints[index])) >>= val 3831 3832 env.IP++ 3833 return env.Code[env.IP], env 3834 } 3835 } else { 3836 ret = func(env *Env) (Stmt, *Env) { 3837 { 3838 lhs := env. 3839 Outer.Outer. 3840 Vals[index] 3841 lhs.SetUint(lhs.Uint() >> 3842 val, 3843 ) 3844 } 3845 3846 env.IP++ 3847 return env.Code[env.IP], env 3848 } 3849 } 3850 case c.Depth - 1: 3851 3852 if intbinds { 3853 ret = func(env *Env) (Stmt, *Env) { 3854 *(*uint8)(unsafe.Pointer(&env.FileEnv.Ints[index])) >>= val 3855 3856 env.IP++ 3857 return env.Code[env.IP], env 3858 } 3859 } else { 3860 ret = func(env *Env) (Stmt, *Env) { 3861 { 3862 lhs := env.FileEnv. 3863 Vals[index] 3864 lhs.SetUint(lhs.Uint() >> 3865 val, 3866 ) 3867 } 3868 3869 env.IP++ 3870 return env.Code[env.IP], env 3871 } 3872 } 3873 default: 3874 3875 if intbinds { 3876 ret = func(env *Env) (Stmt, *Env) { 3877 o := env.Outer.Outer.Outer 3878 for i := 3; i < upn; i++ { 3879 o = o.Outer 3880 } 3881 *(*uint8)(unsafe.Pointer(&o.Ints[index])) >>= val 3882 3883 env.IP++ 3884 return env.Code[env.IP], env 3885 } 3886 } else { 3887 ret = func(env *Env) (Stmt, *Env) { 3888 o := env.Outer.Outer.Outer 3889 for i := 3; i < upn; i++ { 3890 o = o.Outer 3891 } 3892 { 3893 lhs := 3894 3895 o.Vals[index] 3896 lhs.SetUint(lhs.Uint() >> 3897 val, 3898 ) 3899 } 3900 3901 env.IP++ 3902 return env.Code[env.IP], env 3903 } 3904 } 3905 } 3906 case r.Uint16: 3907 switch upn { 3908 case 0: 3909 3910 if intbinds { 3911 ret = func(env *Env) (Stmt, *Env) { 3912 *(*uint16)(unsafe.Pointer(&env.Ints[index])) >>= val 3913 3914 env.IP++ 3915 return env.Code[env.IP], env 3916 } 3917 } else { 3918 ret = func(env *Env) (Stmt, *Env) { 3919 { 3920 lhs := env. 3921 Vals[index] 3922 lhs.SetUint(lhs.Uint() >> 3923 val, 3924 ) 3925 } 3926 3927 env.IP++ 3928 return env.Code[env.IP], env 3929 } 3930 } 3931 case 1: 3932 3933 if intbinds { 3934 ret = func(env *Env) (Stmt, *Env) { 3935 *(*uint16)(unsafe.Pointer(&env. 3936 Outer.Ints[index])) >>= val 3937 3938 env.IP++ 3939 return env.Code[env.IP], env 3940 } 3941 } else { 3942 ret = func(env *Env) (Stmt, *Env) { 3943 { 3944 lhs := env. 3945 Outer. 3946 Vals[index] 3947 lhs.SetUint(lhs.Uint() >> 3948 val, 3949 ) 3950 } 3951 3952 env.IP++ 3953 return env.Code[env.IP], env 3954 } 3955 } 3956 case 2: 3957 3958 if intbinds { 3959 ret = func(env *Env) (Stmt, *Env) { 3960 *(*uint16)(unsafe.Pointer(&env. 3961 Outer.Outer.Ints[index])) >>= val 3962 3963 env.IP++ 3964 return env.Code[env.IP], env 3965 } 3966 } else { 3967 ret = func(env *Env) (Stmt, *Env) { 3968 { 3969 lhs := env. 3970 Outer.Outer. 3971 Vals[index] 3972 lhs.SetUint(lhs.Uint() >> 3973 val, 3974 ) 3975 } 3976 3977 env.IP++ 3978 return env.Code[env.IP], env 3979 } 3980 } 3981 case c.Depth - 1: 3982 3983 if intbinds { 3984 ret = func(env *Env) (Stmt, *Env) { 3985 *(*uint16)(unsafe.Pointer(&env.FileEnv.Ints[index])) >>= val 3986 3987 env.IP++ 3988 return env.Code[env.IP], env 3989 } 3990 } else { 3991 ret = func(env *Env) (Stmt, *Env) { 3992 { 3993 lhs := env.FileEnv. 3994 Vals[index] 3995 lhs.SetUint(lhs.Uint() >> 3996 val, 3997 ) 3998 } 3999 4000 env.IP++ 4001 return env.Code[env.IP], env 4002 } 4003 } 4004 default: 4005 4006 if intbinds { 4007 ret = func(env *Env) (Stmt, *Env) { 4008 o := env.Outer.Outer.Outer 4009 for i := 3; i < upn; i++ { 4010 o = o.Outer 4011 } 4012 *(*uint16)(unsafe.Pointer(&o.Ints[index])) >>= val 4013 4014 env.IP++ 4015 return env.Code[env.IP], env 4016 } 4017 } else { 4018 ret = func(env *Env) (Stmt, *Env) { 4019 o := env.Outer.Outer.Outer 4020 for i := 3; i < upn; i++ { 4021 o = o.Outer 4022 } 4023 { 4024 lhs := 4025 4026 o.Vals[index] 4027 lhs.SetUint(lhs.Uint() >> 4028 val, 4029 ) 4030 } 4031 4032 env.IP++ 4033 return env.Code[env.IP], env 4034 } 4035 } 4036 } 4037 case r.Uint32: 4038 switch upn { 4039 case 0: 4040 4041 if intbinds { 4042 ret = func(env *Env) (Stmt, *Env) { 4043 *(*uint32)(unsafe.Pointer(&env.Ints[index])) >>= val 4044 4045 env.IP++ 4046 return env.Code[env.IP], env 4047 } 4048 } else { 4049 ret = func(env *Env) (Stmt, *Env) { 4050 { 4051 lhs := env. 4052 Vals[index] 4053 lhs.SetUint(lhs.Uint() >> 4054 val, 4055 ) 4056 } 4057 4058 env.IP++ 4059 return env.Code[env.IP], env 4060 } 4061 } 4062 case 1: 4063 4064 if intbinds { 4065 ret = func(env *Env) (Stmt, *Env) { 4066 *(*uint32)(unsafe.Pointer(&env. 4067 Outer.Ints[index])) >>= val 4068 4069 env.IP++ 4070 return env.Code[env.IP], env 4071 } 4072 } else { 4073 ret = func(env *Env) (Stmt, *Env) { 4074 { 4075 lhs := env. 4076 Outer. 4077 Vals[index] 4078 lhs.SetUint(lhs.Uint() >> 4079 val, 4080 ) 4081 } 4082 4083 env.IP++ 4084 return env.Code[env.IP], env 4085 } 4086 } 4087 case 2: 4088 4089 if intbinds { 4090 ret = func(env *Env) (Stmt, *Env) { 4091 *(*uint32)(unsafe.Pointer(&env. 4092 Outer.Outer.Ints[index])) >>= val 4093 4094 env.IP++ 4095 return env.Code[env.IP], env 4096 } 4097 } else { 4098 ret = func(env *Env) (Stmt, *Env) { 4099 { 4100 lhs := env. 4101 Outer.Outer. 4102 Vals[index] 4103 lhs.SetUint(lhs.Uint() >> 4104 val, 4105 ) 4106 } 4107 4108 env.IP++ 4109 return env.Code[env.IP], env 4110 } 4111 } 4112 case c.Depth - 1: 4113 4114 if intbinds { 4115 ret = func(env *Env) (Stmt, *Env) { 4116 *(*uint32)(unsafe.Pointer(&env.FileEnv.Ints[index])) >>= val 4117 4118 env.IP++ 4119 return env.Code[env.IP], env 4120 } 4121 } else { 4122 ret = func(env *Env) (Stmt, *Env) { 4123 { 4124 lhs := env.FileEnv. 4125 Vals[index] 4126 lhs.SetUint(lhs.Uint() >> 4127 val, 4128 ) 4129 } 4130 4131 env.IP++ 4132 return env.Code[env.IP], env 4133 } 4134 } 4135 default: 4136 4137 if intbinds { 4138 ret = func(env *Env) (Stmt, *Env) { 4139 o := env.Outer.Outer.Outer 4140 for i := 3; i < upn; i++ { 4141 o = o.Outer 4142 } 4143 *(*uint32)(unsafe.Pointer(&o.Ints[index])) >>= val 4144 4145 env.IP++ 4146 return env.Code[env.IP], env 4147 } 4148 } else { 4149 ret = func(env *Env) (Stmt, *Env) { 4150 o := env.Outer.Outer.Outer 4151 for i := 3; i < upn; i++ { 4152 o = o.Outer 4153 } 4154 { 4155 lhs := 4156 4157 o.Vals[index] 4158 lhs.SetUint(lhs.Uint() >> 4159 val, 4160 ) 4161 } 4162 4163 env.IP++ 4164 return env.Code[env.IP], env 4165 } 4166 } 4167 } 4168 case r.Uint64: 4169 switch upn { 4170 case 0: 4171 4172 if intbinds { 4173 ret = func(env *Env) (Stmt, *Env) { 4174 env. 4175 Ints[index] >>= val 4176 4177 env.IP++ 4178 return env.Code[env.IP], env 4179 } 4180 } else { 4181 ret = func(env *Env) (Stmt, *Env) { 4182 { 4183 lhs := env. 4184 Vals[index] 4185 lhs.SetUint(lhs.Uint() >> 4186 val, 4187 ) 4188 } 4189 4190 env.IP++ 4191 return env.Code[env.IP], env 4192 } 4193 } 4194 case 1: 4195 4196 if intbinds { 4197 ret = func(env *Env) (Stmt, *Env) { 4198 env. 4199 Outer. 4200 Ints[index] >>= val 4201 4202 env.IP++ 4203 return env.Code[env.IP], env 4204 } 4205 } else { 4206 ret = func(env *Env) (Stmt, *Env) { 4207 { 4208 lhs := env. 4209 Outer. 4210 Vals[index] 4211 lhs.SetUint(lhs.Uint() >> 4212 val, 4213 ) 4214 } 4215 4216 env.IP++ 4217 return env.Code[env.IP], env 4218 } 4219 } 4220 case 2: 4221 4222 if intbinds { 4223 ret = func(env *Env) (Stmt, *Env) { 4224 env. 4225 Outer.Outer. 4226 Ints[index] >>= val 4227 4228 env.IP++ 4229 return env.Code[env.IP], env 4230 } 4231 } else { 4232 ret = func(env *Env) (Stmt, *Env) { 4233 { 4234 lhs := env. 4235 Outer.Outer. 4236 Vals[index] 4237 lhs.SetUint(lhs.Uint() >> 4238 val, 4239 ) 4240 } 4241 4242 env.IP++ 4243 return env.Code[env.IP], env 4244 } 4245 } 4246 case c.Depth - 1: 4247 4248 if intbinds { 4249 ret = func(env *Env) (Stmt, *Env) { 4250 env.FileEnv. 4251 Ints[index] >>= val 4252 4253 env.IP++ 4254 return env.Code[env.IP], env 4255 } 4256 } else { 4257 ret = func(env *Env) (Stmt, *Env) { 4258 { 4259 lhs := env.FileEnv. 4260 Vals[index] 4261 lhs.SetUint(lhs.Uint() >> 4262 val, 4263 ) 4264 } 4265 4266 env.IP++ 4267 return env.Code[env.IP], env 4268 } 4269 } 4270 default: 4271 4272 if intbinds { 4273 ret = func(env *Env) (Stmt, *Env) { 4274 o := env.Outer.Outer.Outer 4275 for i := 3; i < upn; i++ { 4276 o = o.Outer 4277 } 4278 4279 o.Ints[index] >>= val 4280 4281 env.IP++ 4282 return env.Code[env.IP], env 4283 } 4284 } else { 4285 ret = func(env *Env) (Stmt, *Env) { 4286 o := env.Outer.Outer.Outer 4287 for i := 3; i < upn; i++ { 4288 o = o.Outer 4289 } 4290 { 4291 lhs := 4292 4293 o.Vals[index] 4294 lhs.SetUint(lhs.Uint() >> 4295 val, 4296 ) 4297 } 4298 4299 env.IP++ 4300 return env.Code[env.IP], env 4301 } 4302 } 4303 } 4304 case r.Uintptr: 4305 switch upn { 4306 case 0: 4307 4308 if intbinds { 4309 ret = func(env *Env) (Stmt, *Env) { 4310 *(*uintptr)(unsafe.Pointer(&env.Ints[index])) >>= val 4311 4312 env.IP++ 4313 return env.Code[env.IP], env 4314 } 4315 } else { 4316 ret = func(env *Env) (Stmt, *Env) { 4317 { 4318 lhs := env. 4319 Vals[index] 4320 lhs.SetUint(lhs.Uint() >> 4321 val, 4322 ) 4323 } 4324 4325 env.IP++ 4326 return env.Code[env.IP], env 4327 } 4328 } 4329 case 1: 4330 4331 if intbinds { 4332 ret = func(env *Env) (Stmt, *Env) { 4333 *(*uintptr)(unsafe.Pointer(&env. 4334 Outer.Ints[index])) >>= val 4335 4336 env.IP++ 4337 return env.Code[env.IP], env 4338 } 4339 } else { 4340 ret = func(env *Env) (Stmt, *Env) { 4341 { 4342 lhs := env. 4343 Outer. 4344 Vals[index] 4345 lhs.SetUint(lhs.Uint() >> 4346 val, 4347 ) 4348 } 4349 4350 env.IP++ 4351 return env.Code[env.IP], env 4352 } 4353 } 4354 case 2: 4355 4356 if intbinds { 4357 ret = func(env *Env) (Stmt, *Env) { 4358 *(*uintptr)(unsafe.Pointer(&env. 4359 Outer.Outer.Ints[index])) >>= val 4360 4361 env.IP++ 4362 return env.Code[env.IP], env 4363 } 4364 } else { 4365 ret = func(env *Env) (Stmt, *Env) { 4366 { 4367 lhs := env. 4368 Outer.Outer. 4369 Vals[index] 4370 lhs.SetUint(lhs.Uint() >> 4371 val, 4372 ) 4373 } 4374 4375 env.IP++ 4376 return env.Code[env.IP], env 4377 } 4378 } 4379 case c.Depth - 1: 4380 4381 if intbinds { 4382 ret = func(env *Env) (Stmt, *Env) { 4383 *(*uintptr)(unsafe.Pointer(&env.FileEnv.Ints[index])) >>= val 4384 4385 env.IP++ 4386 return env.Code[env.IP], env 4387 } 4388 } else { 4389 ret = func(env *Env) (Stmt, *Env) { 4390 { 4391 lhs := env.FileEnv. 4392 Vals[index] 4393 lhs.SetUint(lhs.Uint() >> 4394 val, 4395 ) 4396 } 4397 4398 env.IP++ 4399 return env.Code[env.IP], env 4400 } 4401 } 4402 default: 4403 4404 if intbinds { 4405 ret = func(env *Env) (Stmt, *Env) { 4406 o := env.Outer.Outer.Outer 4407 for i := 3; i < upn; i++ { 4408 o = o.Outer 4409 } 4410 *(*uintptr)(unsafe.Pointer(&o.Ints[index])) >>= val 4411 4412 env.IP++ 4413 return env.Code[env.IP], env 4414 } 4415 } else { 4416 ret = func(env *Env) (Stmt, *Env) { 4417 o := env.Outer.Outer.Outer 4418 for i := 3; i < upn; i++ { 4419 o = o.Outer 4420 } 4421 { 4422 lhs := 4423 4424 o.Vals[index] 4425 lhs.SetUint(lhs.Uint() >> 4426 val, 4427 ) 4428 } 4429 4430 env.IP++ 4431 return env.Code[env.IP], env 4432 } 4433 } 4434 } 4435 default: 4436 c.Errorf(`invalid operator %s= between <%v> and <%v>`, token.SHR, t, t2) 4437 4438 } 4439 return ret 4440 } 4441} 4442func (c *Comp) varShrExpr(va *Var, function I) Stmt { 4443 t := va.Type 4444 upn := va.Upn 4445 index := va.Desc.Index() 4446 intbinds := va.Desc.Class() == IntBind 4447 4448 t2 := funTypeOut(function) 4449 if t2 == nil || reflect.Category(t2.Kind()) != r.Uint { 4450 c.Errorf(`invalid operator %s= between <%v> and <%v>`, token.SHR, t, t2) 4451 } 4452 4453 fun := asFunUint8(function) 4454 { 4455 var ret Stmt 4456 switch t.Kind() { 4457 case r.Int: 4458 switch upn { 4459 case 0: 4460 4461 if intbinds { 4462 ret = func(env *Env) (Stmt, *Env) { 4463 *(*int)(unsafe.Pointer(&env.Ints[index])) >>= fun(env) 4464 4465 env.IP++ 4466 return env.Code[env.IP], env 4467 } 4468 } else { 4469 ret = func(env *Env) (Stmt, *Env) { 4470 { 4471 lhs := env. 4472 Vals[index] 4473 lhs.SetInt(lhs.Int() >> 4474 fun(env), 4475 ) 4476 } 4477 4478 env.IP++ 4479 return env.Code[env.IP], env 4480 } 4481 } 4482 case 1: 4483 4484 if intbinds { 4485 ret = func(env *Env) (Stmt, *Env) { 4486 *(*int)(unsafe.Pointer(&env. 4487 Outer.Ints[index])) >>= fun(env) 4488 4489 env.IP++ 4490 return env.Code[env.IP], env 4491 } 4492 } else { 4493 ret = func(env *Env) (Stmt, *Env) { 4494 { 4495 lhs := env. 4496 Outer. 4497 Vals[index] 4498 lhs.SetInt(lhs.Int() >> 4499 fun(env), 4500 ) 4501 } 4502 4503 env.IP++ 4504 return env.Code[env.IP], env 4505 } 4506 } 4507 case 2: 4508 4509 if intbinds { 4510 ret = func(env *Env) (Stmt, *Env) { 4511 *(*int)(unsafe.Pointer(&env. 4512 Outer.Outer.Ints[index])) >>= fun(env) 4513 4514 env.IP++ 4515 return env.Code[env.IP], env 4516 } 4517 } else { 4518 ret = func(env *Env) (Stmt, *Env) { 4519 { 4520 lhs := env. 4521 Outer.Outer. 4522 Vals[index] 4523 lhs.SetInt(lhs.Int() >> 4524 fun(env), 4525 ) 4526 } 4527 4528 env.IP++ 4529 return env.Code[env.IP], env 4530 } 4531 } 4532 case c.Depth - 1: 4533 4534 if intbinds { 4535 ret = func(env *Env) (Stmt, *Env) { 4536 *(*int)(unsafe.Pointer(&env.FileEnv.Ints[index])) >>= fun(env) 4537 4538 env.IP++ 4539 return env.Code[env.IP], env 4540 } 4541 } else { 4542 ret = func(env *Env) (Stmt, *Env) { 4543 { 4544 lhs := env.FileEnv. 4545 Vals[index] 4546 lhs.SetInt(lhs.Int() >> 4547 fun(env), 4548 ) 4549 } 4550 4551 env.IP++ 4552 return env.Code[env.IP], env 4553 } 4554 } 4555 default: 4556 4557 if intbinds { 4558 ret = func(env *Env) (Stmt, *Env) { 4559 o := env.Outer.Outer.Outer 4560 for i := 3; i < upn; i++ { 4561 o = o.Outer 4562 } 4563 *(*int)(unsafe.Pointer(&o.Ints[index])) >>= fun(env) 4564 4565 env.IP++ 4566 return env.Code[env.IP], env 4567 } 4568 } else { 4569 ret = func(env *Env) (Stmt, *Env) { 4570 o := env.Outer.Outer.Outer 4571 for i := 3; i < upn; i++ { 4572 o = o.Outer 4573 } 4574 { 4575 lhs := 4576 4577 o.Vals[index] 4578 lhs.SetInt(lhs.Int() >> 4579 fun(env), 4580 ) 4581 } 4582 4583 env.IP++ 4584 return env.Code[env.IP], env 4585 } 4586 } 4587 } 4588 case r.Int8: 4589 switch upn { 4590 case 0: 4591 4592 if intbinds { 4593 ret = func(env *Env) (Stmt, *Env) { 4594 *(*int8)(unsafe.Pointer(&env.Ints[index])) >>= fun(env) 4595 4596 env.IP++ 4597 return env.Code[env.IP], env 4598 } 4599 } else { 4600 ret = func(env *Env) (Stmt, *Env) { 4601 { 4602 lhs := env. 4603 Vals[index] 4604 lhs.SetInt(lhs.Int() >> 4605 fun(env), 4606 ) 4607 } 4608 4609 env.IP++ 4610 return env.Code[env.IP], env 4611 } 4612 } 4613 case 1: 4614 4615 if intbinds { 4616 ret = func(env *Env) (Stmt, *Env) { 4617 *(*int8)(unsafe.Pointer(&env. 4618 Outer.Ints[index])) >>= fun(env) 4619 4620 env.IP++ 4621 return env.Code[env.IP], env 4622 } 4623 } else { 4624 ret = func(env *Env) (Stmt, *Env) { 4625 { 4626 lhs := env. 4627 Outer. 4628 Vals[index] 4629 lhs.SetInt(lhs.Int() >> 4630 fun(env), 4631 ) 4632 } 4633 4634 env.IP++ 4635 return env.Code[env.IP], env 4636 } 4637 } 4638 case 2: 4639 4640 if intbinds { 4641 ret = func(env *Env) (Stmt, *Env) { 4642 *(*int8)(unsafe.Pointer(&env. 4643 Outer.Outer.Ints[index])) >>= fun(env) 4644 4645 env.IP++ 4646 return env.Code[env.IP], env 4647 } 4648 } else { 4649 ret = func(env *Env) (Stmt, *Env) { 4650 { 4651 lhs := env. 4652 Outer.Outer. 4653 Vals[index] 4654 lhs.SetInt(lhs.Int() >> 4655 fun(env), 4656 ) 4657 } 4658 4659 env.IP++ 4660 return env.Code[env.IP], env 4661 } 4662 } 4663 case c.Depth - 1: 4664 4665 if intbinds { 4666 ret = func(env *Env) (Stmt, *Env) { 4667 *(*int8)(unsafe.Pointer(&env.FileEnv.Ints[index])) >>= fun(env) 4668 4669 env.IP++ 4670 return env.Code[env.IP], env 4671 } 4672 } else { 4673 ret = func(env *Env) (Stmt, *Env) { 4674 { 4675 lhs := env.FileEnv. 4676 Vals[index] 4677 lhs.SetInt(lhs.Int() >> 4678 fun(env), 4679 ) 4680 } 4681 4682 env.IP++ 4683 return env.Code[env.IP], env 4684 } 4685 } 4686 default: 4687 4688 if intbinds { 4689 ret = func(env *Env) (Stmt, *Env) { 4690 o := env.Outer.Outer.Outer 4691 for i := 3; i < upn; i++ { 4692 o = o.Outer 4693 } 4694 *(*int8)(unsafe.Pointer(&o.Ints[index])) >>= fun(env) 4695 4696 env.IP++ 4697 return env.Code[env.IP], env 4698 } 4699 } else { 4700 ret = func(env *Env) (Stmt, *Env) { 4701 o := env.Outer.Outer.Outer 4702 for i := 3; i < upn; i++ { 4703 o = o.Outer 4704 } 4705 { 4706 lhs := 4707 4708 o.Vals[index] 4709 lhs.SetInt(lhs.Int() >> 4710 fun(env), 4711 ) 4712 } 4713 4714 env.IP++ 4715 return env.Code[env.IP], env 4716 } 4717 } 4718 } 4719 case r.Int16: 4720 switch upn { 4721 case 0: 4722 4723 if intbinds { 4724 ret = func(env *Env) (Stmt, *Env) { 4725 *(*int16)(unsafe.Pointer(&env.Ints[index])) >>= fun(env) 4726 4727 env.IP++ 4728 return env.Code[env.IP], env 4729 } 4730 } else { 4731 ret = func(env *Env) (Stmt, *Env) { 4732 { 4733 lhs := env. 4734 Vals[index] 4735 lhs.SetInt(lhs.Int() >> 4736 fun(env), 4737 ) 4738 } 4739 4740 env.IP++ 4741 return env.Code[env.IP], env 4742 } 4743 } 4744 case 1: 4745 4746 if intbinds { 4747 ret = func(env *Env) (Stmt, *Env) { 4748 *(*int16)(unsafe.Pointer(&env. 4749 Outer.Ints[index])) >>= fun(env) 4750 4751 env.IP++ 4752 return env.Code[env.IP], env 4753 } 4754 } else { 4755 ret = func(env *Env) (Stmt, *Env) { 4756 { 4757 lhs := env. 4758 Outer. 4759 Vals[index] 4760 lhs.SetInt(lhs.Int() >> 4761 fun(env), 4762 ) 4763 } 4764 4765 env.IP++ 4766 return env.Code[env.IP], env 4767 } 4768 } 4769 case 2: 4770 4771 if intbinds { 4772 ret = func(env *Env) (Stmt, *Env) { 4773 *(*int16)(unsafe.Pointer(&env. 4774 Outer.Outer.Ints[index])) >>= fun(env) 4775 4776 env.IP++ 4777 return env.Code[env.IP], env 4778 } 4779 } else { 4780 ret = func(env *Env) (Stmt, *Env) { 4781 { 4782 lhs := env. 4783 Outer.Outer. 4784 Vals[index] 4785 lhs.SetInt(lhs.Int() >> 4786 fun(env), 4787 ) 4788 } 4789 4790 env.IP++ 4791 return env.Code[env.IP], env 4792 } 4793 } 4794 case c.Depth - 1: 4795 4796 if intbinds { 4797 ret = func(env *Env) (Stmt, *Env) { 4798 *(*int16)(unsafe.Pointer(&env.FileEnv.Ints[index])) >>= fun(env) 4799 4800 env.IP++ 4801 return env.Code[env.IP], env 4802 } 4803 } else { 4804 ret = func(env *Env) (Stmt, *Env) { 4805 { 4806 lhs := env.FileEnv. 4807 Vals[index] 4808 lhs.SetInt(lhs.Int() >> 4809 fun(env), 4810 ) 4811 } 4812 4813 env.IP++ 4814 return env.Code[env.IP], env 4815 } 4816 } 4817 default: 4818 4819 if intbinds { 4820 ret = func(env *Env) (Stmt, *Env) { 4821 o := env.Outer.Outer.Outer 4822 for i := 3; i < upn; i++ { 4823 o = o.Outer 4824 } 4825 *(*int16)(unsafe.Pointer(&o.Ints[index])) >>= fun(env) 4826 4827 env.IP++ 4828 return env.Code[env.IP], env 4829 } 4830 } else { 4831 ret = func(env *Env) (Stmt, *Env) { 4832 o := env.Outer.Outer.Outer 4833 for i := 3; i < upn; i++ { 4834 o = o.Outer 4835 } 4836 { 4837 lhs := 4838 4839 o.Vals[index] 4840 lhs.SetInt(lhs.Int() >> 4841 fun(env), 4842 ) 4843 } 4844 4845 env.IP++ 4846 return env.Code[env.IP], env 4847 } 4848 } 4849 } 4850 case r.Int32: 4851 switch upn { 4852 case 0: 4853 4854 if intbinds { 4855 ret = func(env *Env) (Stmt, *Env) { 4856 *(*int32)(unsafe.Pointer(&env.Ints[index])) >>= fun(env) 4857 4858 env.IP++ 4859 return env.Code[env.IP], env 4860 } 4861 } else { 4862 ret = func(env *Env) (Stmt, *Env) { 4863 { 4864 lhs := env. 4865 Vals[index] 4866 lhs.SetInt(lhs.Int() >> 4867 fun(env), 4868 ) 4869 } 4870 4871 env.IP++ 4872 return env.Code[env.IP], env 4873 } 4874 } 4875 case 1: 4876 4877 if intbinds { 4878 ret = func(env *Env) (Stmt, *Env) { 4879 *(*int32)(unsafe.Pointer(&env. 4880 Outer.Ints[index])) >>= fun(env) 4881 4882 env.IP++ 4883 return env.Code[env.IP], env 4884 } 4885 } else { 4886 ret = func(env *Env) (Stmt, *Env) { 4887 { 4888 lhs := env. 4889 Outer. 4890 Vals[index] 4891 lhs.SetInt(lhs.Int() >> 4892 fun(env), 4893 ) 4894 } 4895 4896 env.IP++ 4897 return env.Code[env.IP], env 4898 } 4899 } 4900 case 2: 4901 4902 if intbinds { 4903 ret = func(env *Env) (Stmt, *Env) { 4904 *(*int32)(unsafe.Pointer(&env. 4905 Outer.Outer.Ints[index])) >>= fun(env) 4906 4907 env.IP++ 4908 return env.Code[env.IP], env 4909 } 4910 } else { 4911 ret = func(env *Env) (Stmt, *Env) { 4912 { 4913 lhs := env. 4914 Outer.Outer. 4915 Vals[index] 4916 lhs.SetInt(lhs.Int() >> 4917 fun(env), 4918 ) 4919 } 4920 4921 env.IP++ 4922 return env.Code[env.IP], env 4923 } 4924 } 4925 case c.Depth - 1: 4926 4927 if intbinds { 4928 ret = func(env *Env) (Stmt, *Env) { 4929 *(*int32)(unsafe.Pointer(&env.FileEnv.Ints[index])) >>= fun(env) 4930 4931 env.IP++ 4932 return env.Code[env.IP], env 4933 } 4934 } else { 4935 ret = func(env *Env) (Stmt, *Env) { 4936 { 4937 lhs := env.FileEnv. 4938 Vals[index] 4939 lhs.SetInt(lhs.Int() >> 4940 fun(env), 4941 ) 4942 } 4943 4944 env.IP++ 4945 return env.Code[env.IP], env 4946 } 4947 } 4948 default: 4949 4950 if intbinds { 4951 ret = func(env *Env) (Stmt, *Env) { 4952 o := env.Outer.Outer.Outer 4953 for i := 3; i < upn; i++ { 4954 o = o.Outer 4955 } 4956 *(*int32)(unsafe.Pointer(&o.Ints[index])) >>= fun(env) 4957 4958 env.IP++ 4959 return env.Code[env.IP], env 4960 } 4961 } else { 4962 ret = func(env *Env) (Stmt, *Env) { 4963 o := env.Outer.Outer.Outer 4964 for i := 3; i < upn; i++ { 4965 o = o.Outer 4966 } 4967 { 4968 lhs := 4969 4970 o.Vals[index] 4971 lhs.SetInt(lhs.Int() >> 4972 fun(env), 4973 ) 4974 } 4975 4976 env.IP++ 4977 return env.Code[env.IP], env 4978 } 4979 } 4980 } 4981 case r.Int64: 4982 switch upn { 4983 case 0: 4984 4985 if intbinds { 4986 ret = func(env *Env) (Stmt, *Env) { 4987 *(*int64)(unsafe.Pointer(&env.Ints[index])) >>= fun(env) 4988 4989 env.IP++ 4990 return env.Code[env.IP], env 4991 } 4992 } else { 4993 ret = func(env *Env) (Stmt, *Env) { 4994 { 4995 lhs := env. 4996 Vals[index] 4997 lhs.SetInt(lhs.Int() >> 4998 fun(env), 4999 ) 5000 } 5001 5002 env.IP++ 5003 return env.Code[env.IP], env 5004 } 5005 } 5006 case 1: 5007 5008 if intbinds { 5009 ret = func(env *Env) (Stmt, *Env) { 5010 *(*int64)(unsafe.Pointer(&env. 5011 Outer.Ints[index])) >>= fun(env) 5012 5013 env.IP++ 5014 return env.Code[env.IP], env 5015 } 5016 } else { 5017 ret = func(env *Env) (Stmt, *Env) { 5018 { 5019 lhs := env. 5020 Outer. 5021 Vals[index] 5022 lhs.SetInt(lhs.Int() >> 5023 fun(env), 5024 ) 5025 } 5026 5027 env.IP++ 5028 return env.Code[env.IP], env 5029 } 5030 } 5031 case 2: 5032 5033 if intbinds { 5034 ret = func(env *Env) (Stmt, *Env) { 5035 *(*int64)(unsafe.Pointer(&env. 5036 Outer.Outer.Ints[index])) >>= fun(env) 5037 5038 env.IP++ 5039 return env.Code[env.IP], env 5040 } 5041 } else { 5042 ret = func(env *Env) (Stmt, *Env) { 5043 { 5044 lhs := env. 5045 Outer.Outer. 5046 Vals[index] 5047 lhs.SetInt(lhs.Int() >> 5048 fun(env), 5049 ) 5050 } 5051 5052 env.IP++ 5053 return env.Code[env.IP], env 5054 } 5055 } 5056 case c.Depth - 1: 5057 5058 if intbinds { 5059 ret = func(env *Env) (Stmt, *Env) { 5060 *(*int64)(unsafe.Pointer(&env.FileEnv.Ints[index])) >>= fun(env) 5061 5062 env.IP++ 5063 return env.Code[env.IP], env 5064 } 5065 } else { 5066 ret = func(env *Env) (Stmt, *Env) { 5067 { 5068 lhs := env.FileEnv. 5069 Vals[index] 5070 lhs.SetInt(lhs.Int() >> 5071 fun(env), 5072 ) 5073 } 5074 5075 env.IP++ 5076 return env.Code[env.IP], env 5077 } 5078 } 5079 default: 5080 5081 if intbinds { 5082 ret = func(env *Env) (Stmt, *Env) { 5083 o := env.Outer.Outer.Outer 5084 for i := 3; i < upn; i++ { 5085 o = o.Outer 5086 } 5087 *(*int64)(unsafe.Pointer(&o.Ints[index])) >>= fun(env) 5088 5089 env.IP++ 5090 return env.Code[env.IP], env 5091 } 5092 } else { 5093 ret = func(env *Env) (Stmt, *Env) { 5094 o := env.Outer.Outer.Outer 5095 for i := 3; i < upn; i++ { 5096 o = o.Outer 5097 } 5098 { 5099 lhs := 5100 5101 o.Vals[index] 5102 lhs.SetInt(lhs.Int() >> 5103 fun(env), 5104 ) 5105 } 5106 5107 env.IP++ 5108 return env.Code[env.IP], env 5109 } 5110 } 5111 } 5112 case r.Uint: 5113 switch upn { 5114 case 0: 5115 5116 if intbinds { 5117 ret = func(env *Env) (Stmt, *Env) { 5118 *(*uint)(unsafe.Pointer(&env.Ints[index])) >>= fun(env) 5119 5120 env.IP++ 5121 return env.Code[env.IP], env 5122 } 5123 } else { 5124 ret = func(env *Env) (Stmt, *Env) { 5125 { 5126 lhs := env. 5127 Vals[index] 5128 lhs.SetUint(lhs.Uint() >> 5129 fun(env), 5130 ) 5131 } 5132 5133 env.IP++ 5134 return env.Code[env.IP], env 5135 } 5136 } 5137 case 1: 5138 5139 if intbinds { 5140 ret = func(env *Env) (Stmt, *Env) { 5141 *(*uint)(unsafe.Pointer(&env. 5142 Outer.Ints[index])) >>= fun(env) 5143 5144 env.IP++ 5145 return env.Code[env.IP], env 5146 } 5147 } else { 5148 ret = func(env *Env) (Stmt, *Env) { 5149 { 5150 lhs := env. 5151 Outer. 5152 Vals[index] 5153 lhs.SetUint(lhs.Uint() >> 5154 fun(env), 5155 ) 5156 } 5157 5158 env.IP++ 5159 return env.Code[env.IP], env 5160 } 5161 } 5162 case 2: 5163 5164 if intbinds { 5165 ret = func(env *Env) (Stmt, *Env) { 5166 *(*uint)(unsafe.Pointer(&env. 5167 Outer.Outer.Ints[index])) >>= fun(env) 5168 5169 env.IP++ 5170 return env.Code[env.IP], env 5171 } 5172 } else { 5173 ret = func(env *Env) (Stmt, *Env) { 5174 { 5175 lhs := env. 5176 Outer.Outer. 5177 Vals[index] 5178 lhs.SetUint(lhs.Uint() >> 5179 fun(env), 5180 ) 5181 } 5182 5183 env.IP++ 5184 return env.Code[env.IP], env 5185 } 5186 } 5187 case c.Depth - 1: 5188 5189 if intbinds { 5190 ret = func(env *Env) (Stmt, *Env) { 5191 *(*uint)(unsafe.Pointer(&env.FileEnv.Ints[index])) >>= fun(env) 5192 5193 env.IP++ 5194 return env.Code[env.IP], env 5195 } 5196 } else { 5197 ret = func(env *Env) (Stmt, *Env) { 5198 { 5199 lhs := env.FileEnv. 5200 Vals[index] 5201 lhs.SetUint(lhs.Uint() >> 5202 fun(env), 5203 ) 5204 } 5205 5206 env.IP++ 5207 return env.Code[env.IP], env 5208 } 5209 } 5210 default: 5211 5212 if intbinds { 5213 ret = func(env *Env) (Stmt, *Env) { 5214 o := env.Outer.Outer.Outer 5215 for i := 3; i < upn; i++ { 5216 o = o.Outer 5217 } 5218 *(*uint)(unsafe.Pointer(&o.Ints[index])) >>= fun(env) 5219 5220 env.IP++ 5221 return env.Code[env.IP], env 5222 } 5223 } else { 5224 ret = func(env *Env) (Stmt, *Env) { 5225 o := env.Outer.Outer.Outer 5226 for i := 3; i < upn; i++ { 5227 o = o.Outer 5228 } 5229 { 5230 lhs := 5231 5232 o.Vals[index] 5233 lhs.SetUint(lhs.Uint() >> 5234 fun(env), 5235 ) 5236 } 5237 5238 env.IP++ 5239 return env.Code[env.IP], env 5240 } 5241 } 5242 } 5243 case r.Uint8: 5244 switch upn { 5245 case 0: 5246 5247 if intbinds { 5248 ret = func(env *Env) (Stmt, *Env) { 5249 *(*uint8)(unsafe.Pointer(&env.Ints[index])) >>= fun(env) 5250 5251 env.IP++ 5252 return env.Code[env.IP], env 5253 } 5254 } else { 5255 ret = func(env *Env) (Stmt, *Env) { 5256 { 5257 lhs := env. 5258 Vals[index] 5259 lhs.SetUint(lhs.Uint() >> 5260 fun(env), 5261 ) 5262 } 5263 5264 env.IP++ 5265 return env.Code[env.IP], env 5266 } 5267 } 5268 case 1: 5269 5270 if intbinds { 5271 ret = func(env *Env) (Stmt, *Env) { 5272 *(*uint8)(unsafe.Pointer(&env. 5273 Outer.Ints[index])) >>= fun(env) 5274 5275 env.IP++ 5276 return env.Code[env.IP], env 5277 } 5278 } else { 5279 ret = func(env *Env) (Stmt, *Env) { 5280 { 5281 lhs := env. 5282 Outer. 5283 Vals[index] 5284 lhs.SetUint(lhs.Uint() >> 5285 fun(env), 5286 ) 5287 } 5288 5289 env.IP++ 5290 return env.Code[env.IP], env 5291 } 5292 } 5293 case 2: 5294 5295 if intbinds { 5296 ret = func(env *Env) (Stmt, *Env) { 5297 *(*uint8)(unsafe.Pointer(&env. 5298 Outer.Outer.Ints[index])) >>= fun(env) 5299 5300 env.IP++ 5301 return env.Code[env.IP], env 5302 } 5303 } else { 5304 ret = func(env *Env) (Stmt, *Env) { 5305 { 5306 lhs := env. 5307 Outer.Outer. 5308 Vals[index] 5309 lhs.SetUint(lhs.Uint() >> 5310 fun(env), 5311 ) 5312 } 5313 5314 env.IP++ 5315 return env.Code[env.IP], env 5316 } 5317 } 5318 case c.Depth - 1: 5319 5320 if intbinds { 5321 ret = func(env *Env) (Stmt, *Env) { 5322 *(*uint8)(unsafe.Pointer(&env.FileEnv.Ints[index])) >>= fun(env) 5323 5324 env.IP++ 5325 return env.Code[env.IP], env 5326 } 5327 } else { 5328 ret = func(env *Env) (Stmt, *Env) { 5329 { 5330 lhs := env.FileEnv. 5331 Vals[index] 5332 lhs.SetUint(lhs.Uint() >> 5333 fun(env), 5334 ) 5335 } 5336 5337 env.IP++ 5338 return env.Code[env.IP], env 5339 } 5340 } 5341 default: 5342 5343 if intbinds { 5344 ret = func(env *Env) (Stmt, *Env) { 5345 o := env.Outer.Outer.Outer 5346 for i := 3; i < upn; i++ { 5347 o = o.Outer 5348 } 5349 *(*uint8)(unsafe.Pointer(&o.Ints[index])) >>= fun(env) 5350 5351 env.IP++ 5352 return env.Code[env.IP], env 5353 } 5354 } else { 5355 ret = func(env *Env) (Stmt, *Env) { 5356 o := env.Outer.Outer.Outer 5357 for i := 3; i < upn; i++ { 5358 o = o.Outer 5359 } 5360 { 5361 lhs := 5362 5363 o.Vals[index] 5364 lhs.SetUint(lhs.Uint() >> 5365 fun(env), 5366 ) 5367 } 5368 5369 env.IP++ 5370 return env.Code[env.IP], env 5371 } 5372 } 5373 } 5374 case r.Uint16: 5375 switch upn { 5376 case 0: 5377 5378 if intbinds { 5379 ret = func(env *Env) (Stmt, *Env) { 5380 *(*uint16)(unsafe.Pointer(&env.Ints[index])) >>= fun(env) 5381 5382 env.IP++ 5383 return env.Code[env.IP], env 5384 } 5385 } else { 5386 ret = func(env *Env) (Stmt, *Env) { 5387 { 5388 lhs := env. 5389 Vals[index] 5390 lhs.SetUint(lhs.Uint() >> 5391 fun(env), 5392 ) 5393 } 5394 5395 env.IP++ 5396 return env.Code[env.IP], env 5397 } 5398 } 5399 case 1: 5400 5401 if intbinds { 5402 ret = func(env *Env) (Stmt, *Env) { 5403 *(*uint16)(unsafe.Pointer(&env. 5404 Outer.Ints[index])) >>= fun(env) 5405 5406 env.IP++ 5407 return env.Code[env.IP], env 5408 } 5409 } else { 5410 ret = func(env *Env) (Stmt, *Env) { 5411 { 5412 lhs := env. 5413 Outer. 5414 Vals[index] 5415 lhs.SetUint(lhs.Uint() >> 5416 fun(env), 5417 ) 5418 } 5419 5420 env.IP++ 5421 return env.Code[env.IP], env 5422 } 5423 } 5424 case 2: 5425 5426 if intbinds { 5427 ret = func(env *Env) (Stmt, *Env) { 5428 *(*uint16)(unsafe.Pointer(&env. 5429 Outer.Outer.Ints[index])) >>= fun(env) 5430 5431 env.IP++ 5432 return env.Code[env.IP], env 5433 } 5434 } else { 5435 ret = func(env *Env) (Stmt, *Env) { 5436 { 5437 lhs := env. 5438 Outer.Outer. 5439 Vals[index] 5440 lhs.SetUint(lhs.Uint() >> 5441 fun(env), 5442 ) 5443 } 5444 5445 env.IP++ 5446 return env.Code[env.IP], env 5447 } 5448 } 5449 case c.Depth - 1: 5450 5451 if intbinds { 5452 ret = func(env *Env) (Stmt, *Env) { 5453 *(*uint16)(unsafe.Pointer(&env.FileEnv.Ints[index])) >>= fun(env) 5454 5455 env.IP++ 5456 return env.Code[env.IP], env 5457 } 5458 } else { 5459 ret = func(env *Env) (Stmt, *Env) { 5460 { 5461 lhs := env.FileEnv. 5462 Vals[index] 5463 lhs.SetUint(lhs.Uint() >> 5464 fun(env), 5465 ) 5466 } 5467 5468 env.IP++ 5469 return env.Code[env.IP], env 5470 } 5471 } 5472 default: 5473 5474 if intbinds { 5475 ret = func(env *Env) (Stmt, *Env) { 5476 o := env.Outer.Outer.Outer 5477 for i := 3; i < upn; i++ { 5478 o = o.Outer 5479 } 5480 *(*uint16)(unsafe.Pointer(&o.Ints[index])) >>= fun(env) 5481 5482 env.IP++ 5483 return env.Code[env.IP], env 5484 } 5485 } else { 5486 ret = func(env *Env) (Stmt, *Env) { 5487 o := env.Outer.Outer.Outer 5488 for i := 3; i < upn; i++ { 5489 o = o.Outer 5490 } 5491 { 5492 lhs := 5493 5494 o.Vals[index] 5495 lhs.SetUint(lhs.Uint() >> 5496 fun(env), 5497 ) 5498 } 5499 5500 env.IP++ 5501 return env.Code[env.IP], env 5502 } 5503 } 5504 } 5505 case r.Uint32: 5506 switch upn { 5507 case 0: 5508 5509 if intbinds { 5510 ret = func(env *Env) (Stmt, *Env) { 5511 *(*uint32)(unsafe.Pointer(&env.Ints[index])) >>= fun(env) 5512 5513 env.IP++ 5514 return env.Code[env.IP], env 5515 } 5516 } else { 5517 ret = func(env *Env) (Stmt, *Env) { 5518 { 5519 lhs := env. 5520 Vals[index] 5521 lhs.SetUint(lhs.Uint() >> 5522 fun(env), 5523 ) 5524 } 5525 5526 env.IP++ 5527 return env.Code[env.IP], env 5528 } 5529 } 5530 case 1: 5531 5532 if intbinds { 5533 ret = func(env *Env) (Stmt, *Env) { 5534 *(*uint32)(unsafe.Pointer(&env. 5535 Outer.Ints[index])) >>= fun(env) 5536 5537 env.IP++ 5538 return env.Code[env.IP], env 5539 } 5540 } else { 5541 ret = func(env *Env) (Stmt, *Env) { 5542 { 5543 lhs := env. 5544 Outer. 5545 Vals[index] 5546 lhs.SetUint(lhs.Uint() >> 5547 fun(env), 5548 ) 5549 } 5550 5551 env.IP++ 5552 return env.Code[env.IP], env 5553 } 5554 } 5555 case 2: 5556 5557 if intbinds { 5558 ret = func(env *Env) (Stmt, *Env) { 5559 *(*uint32)(unsafe.Pointer(&env. 5560 Outer.Outer.Ints[index])) >>= fun(env) 5561 5562 env.IP++ 5563 return env.Code[env.IP], env 5564 } 5565 } else { 5566 ret = func(env *Env) (Stmt, *Env) { 5567 { 5568 lhs := env. 5569 Outer.Outer. 5570 Vals[index] 5571 lhs.SetUint(lhs.Uint() >> 5572 fun(env), 5573 ) 5574 } 5575 5576 env.IP++ 5577 return env.Code[env.IP], env 5578 } 5579 } 5580 case c.Depth - 1: 5581 5582 if intbinds { 5583 ret = func(env *Env) (Stmt, *Env) { 5584 *(*uint32)(unsafe.Pointer(&env.FileEnv.Ints[index])) >>= fun(env) 5585 5586 env.IP++ 5587 return env.Code[env.IP], env 5588 } 5589 } else { 5590 ret = func(env *Env) (Stmt, *Env) { 5591 { 5592 lhs := env.FileEnv. 5593 Vals[index] 5594 lhs.SetUint(lhs.Uint() >> 5595 fun(env), 5596 ) 5597 } 5598 5599 env.IP++ 5600 return env.Code[env.IP], env 5601 } 5602 } 5603 default: 5604 5605 if intbinds { 5606 ret = func(env *Env) (Stmt, *Env) { 5607 o := env.Outer.Outer.Outer 5608 for i := 3; i < upn; i++ { 5609 o = o.Outer 5610 } 5611 *(*uint32)(unsafe.Pointer(&o.Ints[index])) >>= fun(env) 5612 5613 env.IP++ 5614 return env.Code[env.IP], env 5615 } 5616 } else { 5617 ret = func(env *Env) (Stmt, *Env) { 5618 o := env.Outer.Outer.Outer 5619 for i := 3; i < upn; i++ { 5620 o = o.Outer 5621 } 5622 { 5623 lhs := 5624 5625 o.Vals[index] 5626 lhs.SetUint(lhs.Uint() >> 5627 fun(env), 5628 ) 5629 } 5630 5631 env.IP++ 5632 return env.Code[env.IP], env 5633 } 5634 } 5635 } 5636 case r.Uint64: 5637 switch upn { 5638 case 0: 5639 5640 if intbinds { 5641 ret = func(env *Env) (Stmt, *Env) { 5642 env. 5643 Ints[index] >>= fun(env) 5644 5645 env.IP++ 5646 return env.Code[env.IP], env 5647 } 5648 } else { 5649 ret = func(env *Env) (Stmt, *Env) { 5650 { 5651 lhs := env. 5652 Vals[index] 5653 lhs.SetUint(lhs.Uint() >> 5654 fun(env), 5655 ) 5656 } 5657 5658 env.IP++ 5659 return env.Code[env.IP], env 5660 } 5661 } 5662 case 1: 5663 5664 if intbinds { 5665 ret = func(env *Env) (Stmt, *Env) { 5666 env. 5667 Outer. 5668 Ints[index] >>= fun(env) 5669 5670 env.IP++ 5671 return env.Code[env.IP], env 5672 } 5673 } else { 5674 ret = func(env *Env) (Stmt, *Env) { 5675 { 5676 lhs := env. 5677 Outer. 5678 Vals[index] 5679 lhs.SetUint(lhs.Uint() >> 5680 fun(env), 5681 ) 5682 } 5683 5684 env.IP++ 5685 return env.Code[env.IP], env 5686 } 5687 } 5688 case 2: 5689 5690 if intbinds { 5691 ret = func(env *Env) (Stmt, *Env) { 5692 env. 5693 Outer.Outer. 5694 Ints[index] >>= fun(env) 5695 5696 env.IP++ 5697 return env.Code[env.IP], env 5698 } 5699 } else { 5700 ret = func(env *Env) (Stmt, *Env) { 5701 { 5702 lhs := env. 5703 Outer.Outer. 5704 Vals[index] 5705 lhs.SetUint(lhs.Uint() >> 5706 fun(env), 5707 ) 5708 } 5709 5710 env.IP++ 5711 return env.Code[env.IP], env 5712 } 5713 } 5714 case c.Depth - 1: 5715 5716 if intbinds { 5717 ret = func(env *Env) (Stmt, *Env) { 5718 env.FileEnv. 5719 Ints[index] >>= fun(env) 5720 5721 env.IP++ 5722 return env.Code[env.IP], env 5723 } 5724 } else { 5725 ret = func(env *Env) (Stmt, *Env) { 5726 { 5727 lhs := env.FileEnv. 5728 Vals[index] 5729 lhs.SetUint(lhs.Uint() >> 5730 fun(env), 5731 ) 5732 } 5733 5734 env.IP++ 5735 return env.Code[env.IP], env 5736 } 5737 } 5738 default: 5739 5740 if intbinds { 5741 ret = func(env *Env) (Stmt, *Env) { 5742 o := env.Outer.Outer.Outer 5743 for i := 3; i < upn; i++ { 5744 o = o.Outer 5745 } 5746 5747 o.Ints[index] >>= fun(env) 5748 5749 env.IP++ 5750 return env.Code[env.IP], env 5751 } 5752 } else { 5753 ret = func(env *Env) (Stmt, *Env) { 5754 o := env.Outer.Outer.Outer 5755 for i := 3; i < upn; i++ { 5756 o = o.Outer 5757 } 5758 { 5759 lhs := 5760 5761 o.Vals[index] 5762 lhs.SetUint(lhs.Uint() >> 5763 fun(env), 5764 ) 5765 } 5766 5767 env.IP++ 5768 return env.Code[env.IP], env 5769 } 5770 } 5771 } 5772 case r.Uintptr: 5773 switch upn { 5774 case 0: 5775 5776 if intbinds { 5777 ret = func(env *Env) (Stmt, *Env) { 5778 *(*uintptr)(unsafe.Pointer(&env.Ints[index])) >>= fun(env) 5779 5780 env.IP++ 5781 return env.Code[env.IP], env 5782 } 5783 } else { 5784 ret = func(env *Env) (Stmt, *Env) { 5785 { 5786 lhs := env. 5787 Vals[index] 5788 lhs.SetUint(lhs.Uint() >> 5789 fun(env), 5790 ) 5791 } 5792 5793 env.IP++ 5794 return env.Code[env.IP], env 5795 } 5796 } 5797 case 1: 5798 5799 if intbinds { 5800 ret = func(env *Env) (Stmt, *Env) { 5801 *(*uintptr)(unsafe.Pointer(&env. 5802 Outer.Ints[index])) >>= fun(env) 5803 5804 env.IP++ 5805 return env.Code[env.IP], env 5806 } 5807 } else { 5808 ret = func(env *Env) (Stmt, *Env) { 5809 { 5810 lhs := env. 5811 Outer. 5812 Vals[index] 5813 lhs.SetUint(lhs.Uint() >> 5814 fun(env), 5815 ) 5816 } 5817 5818 env.IP++ 5819 return env.Code[env.IP], env 5820 } 5821 } 5822 case 2: 5823 5824 if intbinds { 5825 ret = func(env *Env) (Stmt, *Env) { 5826 *(*uintptr)(unsafe.Pointer(&env. 5827 Outer.Outer.Ints[index])) >>= fun(env) 5828 5829 env.IP++ 5830 return env.Code[env.IP], env 5831 } 5832 } else { 5833 ret = func(env *Env) (Stmt, *Env) { 5834 { 5835 lhs := env. 5836 Outer.Outer. 5837 Vals[index] 5838 lhs.SetUint(lhs.Uint() >> 5839 fun(env), 5840 ) 5841 } 5842 5843 env.IP++ 5844 return env.Code[env.IP], env 5845 } 5846 } 5847 case c.Depth - 1: 5848 5849 if intbinds { 5850 ret = func(env *Env) (Stmt, *Env) { 5851 *(*uintptr)(unsafe.Pointer(&env.FileEnv.Ints[index])) >>= fun(env) 5852 5853 env.IP++ 5854 return env.Code[env.IP], env 5855 } 5856 } else { 5857 ret = func(env *Env) (Stmt, *Env) { 5858 { 5859 lhs := env.FileEnv. 5860 Vals[index] 5861 lhs.SetUint(lhs.Uint() >> 5862 fun(env), 5863 ) 5864 } 5865 5866 env.IP++ 5867 return env.Code[env.IP], env 5868 } 5869 } 5870 default: 5871 5872 if intbinds { 5873 ret = func(env *Env) (Stmt, *Env) { 5874 o := env.Outer.Outer.Outer 5875 for i := 3; i < upn; i++ { 5876 o = o.Outer 5877 } 5878 *(*uintptr)(unsafe.Pointer(&o.Ints[index])) >>= fun(env) 5879 5880 env.IP++ 5881 return env.Code[env.IP], env 5882 } 5883 } else { 5884 ret = func(env *Env) (Stmt, *Env) { 5885 o := env.Outer.Outer.Outer 5886 for i := 3; i < upn; i++ { 5887 o = o.Outer 5888 } 5889 { 5890 lhs := 5891 5892 o.Vals[index] 5893 lhs.SetUint(lhs.Uint() >> 5894 fun(env), 5895 ) 5896 } 5897 5898 env.IP++ 5899 return env.Code[env.IP], env 5900 } 5901 } 5902 } 5903 default: 5904 c.Errorf(`invalid operator %s= between <%v> and <%v>`, token.SHR, t, t2) 5905 5906 } 5907 return ret 5908 } 5909} 5910func asFunUint8(fun I) func(*Env) uint8 { 5911 var f func(*Env) uint8 5912 switch fun := fun.(type) { 5913 case func(*Env) uint: 5914 return func(env *Env) uint8 { 5915 val := fun(env) 5916 if val > 255 { 5917 val = 255 5918 } 5919 return uint8(val) 5920 } 5921 case func(*Env) uint8: 5922 f = fun 5923 case func(*Env) uint16: 5924 return func(env *Env) uint8 { 5925 val := fun(env) 5926 if val > 255 { 5927 val = 255 5928 } 5929 return uint8(val) 5930 } 5931 case func(*Env) uint32: 5932 return func(env *Env) uint8 { 5933 val := fun(env) 5934 if val > 255 { 5935 val = 255 5936 } 5937 return uint8(val) 5938 } 5939 5940 case func(*Env) uint64: 5941 return func(env *Env) uint8 { 5942 val := fun(env) 5943 if val > 255 { 5944 val = 255 5945 } 5946 return uint8(val) 5947 } 5948 5949 case func(*Env) uintptr: 5950 return func(env *Env) uint8 { 5951 val := fun(env) 5952 if val > 255 { 5953 val = 255 5954 } 5955 return uint8(val) 5956 } 5957 5958 } 5959 return f 5960} 5961