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 * binary_eql.go 17 * 18 * Created on Apr 02, 2017 19 * Author Massimiliano Ghilardi 20 */ 21 22package fast 23 24import ( 25 "go/ast" 26 "go/token" 27 r "reflect" 28 29 "github.com/cosmos72/gomacro/base/reflect" 30 . "github.com/cosmos72/gomacro/base" 31) 32 33func (c *Comp) Eql(node *ast.BinaryExpr, xe *Expr, ye *Expr) *Expr { 34 if xe.IsNil() { 35 if ye.IsNil() { 36 return c.invalidBinaryExpr(node, xe, ye) 37 } else { 38 return c.eqlneqNil(node, xe, ye) 39 } 40 } else if ye.IsNil() { 41 return c.eqlneqNil(node, xe, ye) 42 } 43 44 if !xe.Type.Comparable() || !xe.Type.Comparable() { 45 return c.invalidBinaryExpr(node, xe, ye) 46 } 47 48 xc, yc := xe.Const(), ye.Const() 49 if xe.Type.Kind() != r.Interface && ye.Type.Kind() != r.Interface { 50 c.toSameFuncType(node, xe, ye) 51 } 52 53 k := xe.Type.Kind() 54 yk := ye.Type.Kind() 55 56 var fun func(env *Env) bool 57 if k != yk { 58 59 } else if xc == yc { 60 x, y := xe.Fun, ye.Fun 61 switch k { 62 case r.Bool: 63 { 64 x := x.(func(*Env) bool) 65 y := y.(func(*Env) bool) 66 fun = func(env *Env) bool { return x(env) == y(env) } 67 68 } 69 case r.Int: 70 { 71 x := x.(func(*Env) int) 72 y := y.(func(*Env) int) 73 fun = func(env *Env) bool { return x(env) == y(env) } 74 75 } 76 case r.Int8: 77 { 78 x := x.(func(*Env) int8) 79 y := y.(func(*Env) int8) 80 fun = func(env *Env) bool { return x(env) == y(env) } 81 82 } 83 case r.Int16: 84 { 85 x := x.(func(*Env) int16) 86 y := y.(func(*Env) int16) 87 fun = func(env *Env) bool { return x(env) == y(env) } 88 89 } 90 case r.Int32: 91 { 92 x := x.(func(*Env) int32) 93 y := y.(func(*Env) int32) 94 fun = func(env *Env) bool { return x(env) == y(env) } 95 96 } 97 case r.Int64: 98 { 99 x := x.(func(*Env) int64) 100 y := y.(func(*Env) int64) 101 fun = func(env *Env) bool { return x(env) == y(env) } 102 103 } 104 case r.Uint: 105 { 106 x := x.(func(*Env) uint) 107 y := y.(func(*Env) uint) 108 fun = func(env *Env) bool { return x(env) == y(env) } 109 110 } 111 case r.Uint8: 112 { 113 x := x.(func(*Env) uint8) 114 y := y.(func(*Env) uint8) 115 fun = func(env *Env) bool { return x(env) == y(env) } 116 117 } 118 case r.Uint16: 119 { 120 x := x.(func(*Env) uint16) 121 y := y.(func(*Env) uint16) 122 fun = func(env *Env) bool { return x(env) == y(env) } 123 124 } 125 case r.Uint32: 126 { 127 x := x.(func(*Env) uint32) 128 y := y.(func(*Env) uint32) 129 fun = func(env *Env) bool { return x(env) == y(env) } 130 131 } 132 case r.Uint64: 133 { 134 x := x.(func(*Env) uint64) 135 y := y.(func(*Env) uint64) 136 fun = func(env *Env) bool { return x(env) == y(env) } 137 138 } 139 case r.Uintptr: 140 { 141 x := x.(func(*Env) uintptr) 142 y := y.(func(*Env) uintptr) 143 fun = func(env *Env) bool { return x(env) == y(env) } 144 145 } 146 147 case r.Float32: 148 { 149 x := x.(func(*Env) float32) 150 y := y.(func(*Env) float32) 151 fun = func(env *Env) bool { return x(env) == y(env) } 152 153 } 154 155 case r.Float64: 156 { 157 x := x.(func(*Env) float64) 158 y := y.(func(*Env) float64) 159 fun = func(env *Env) bool { return x(env) == y(env) } 160 161 } 162 163 case r.Complex64: 164 { 165 x := x.(func(*Env) complex64) 166 y := y.(func(*Env) complex64) 167 fun = func(env *Env) bool { return x(env) == y(env) } 168 169 } 170 171 case r.Complex128: 172 { 173 x := x.(func(*Env) complex128) 174 y := y.(func(*Env) complex128) 175 fun = func(env *Env) bool { return x(env) == y(env) } 176 177 } 178 179 case r.String: 180 { 181 x := x.(func(*Env) string) 182 y := y.(func(*Env) string) 183 fun = func(env *Env) bool { return x(env) == y(env) } 184 185 } 186 187 } 188 189 } else if yc { 190 x := xe.Fun 191 yv := r.ValueOf(ye.Value) 192 if k == r.Bool && yv.Bool() { 193 return xe 194 } 195 switch k { 196 case r.Bool: 197 198 { 199 x := x.(func(*Env) bool) 200 y := yv.Bool() 201 fun = func(env *Env) bool { return x(env) == y } 202 203 } 204 case r.Int: 205 206 { 207 x := x.(func(*Env) int) 208 y := int(yv.Int()) 209 fun = func(env *Env) bool { return x(env) == y } 210 211 } 212 case r.Int8: 213 214 { 215 x := x.(func(*Env) int8) 216 y := int8(yv.Int()) 217 fun = func(env *Env) bool { return x(env) == y } 218 219 } 220 case r.Int16: 221 222 { 223 x := x.(func(*Env) int16) 224 y := int16(yv.Int()) 225 fun = func(env *Env) bool { return x(env) == y } 226 227 } 228 case r.Int32: 229 230 { 231 x := x.(func(*Env) int32) 232 y := int32(yv.Int()) 233 fun = func(env *Env) bool { return x(env) == y } 234 235 } 236 case r.Int64: 237 238 { 239 x := x.(func(*Env) int64) 240 y := yv.Int() 241 fun = func(env *Env) bool { return x(env) == y } 242 243 } 244 case r.Uint: 245 246 { 247 x := x.(func(*Env) uint) 248 y := uint(yv.Uint()) 249 fun = func(env *Env) bool { return x(env) == y } 250 251 } 252 case r.Uint8: 253 254 { 255 x := x.(func(*Env) uint8) 256 y := uint8(yv.Uint()) 257 fun = func(env *Env) bool { return x(env) == y } 258 259 } 260 case r.Uint16: 261 262 { 263 x := x.(func(*Env) uint16) 264 y := uint16(yv.Uint()) 265 fun = func(env *Env) bool { return x(env) == y } 266 267 } 268 case r.Uint32: 269 270 { 271 x := x.(func(*Env) uint32) 272 y := uint32(yv.Uint()) 273 fun = func(env *Env) bool { return x(env) == y } 274 275 } 276 case r.Uint64: 277 278 { 279 x := x.(func(*Env) uint64) 280 y := yv.Uint() 281 fun = func(env *Env) bool { return x(env) == y } 282 283 } 284 case r.Uintptr: 285 286 { 287 x := x.(func(*Env) uintptr) 288 y := uintptr(yv.Uint()) 289 fun = func(env *Env) bool { return x(env) == y } 290 291 } 292 case r.Float32: 293 294 { 295 x := x.(func(*Env) float32) 296 y := 297 298 float32(yv.Float()) 299 fun = func(env *Env) bool { return x(env) == y } 300 301 } 302 case r.Float64: 303 304 { 305 x := x.(func(*Env) float64) 306 y := yv.Float() 307 fun = func(env *Env) bool { return x(env) == y } 308 309 } 310 case r.Complex64: 311 312 { 313 x := x.(func(*Env) complex64) 314 y := 315 316 complex64(yv.Complex()) 317 fun = func(env *Env) bool { return x(env) == y } 318 319 } 320 case r.Complex128: 321 322 { 323 x := x.(func(*Env) complex128) 324 y := yv.Complex() 325 fun = func(env *Env) bool { return x(env) == y } 326 327 } 328 case r.String: 329 330 { 331 x := x.(func(*Env) string) 332 y := yv.String() 333 fun = func(env *Env) bool { return x(env) == y } 334 335 } 336 } 337 338 } else { 339 xv := r.ValueOf(xe.Value) 340 y := ye.Fun 341 if k == r.Bool && xv.Bool() { 342 return ye 343 } 344 switch k { 345 case r.Bool: 346 347 { 348 x := xv.Bool() 349 350 y := y.(func(*Env) bool) 351 fun = func(env *Env) bool { return x == y(env) } 352 353 } 354 case r.Int: 355 356 { 357 x := int( 358 359 xv.Int()) 360 361 y := y.(func(*Env) int) 362 fun = func(env *Env) bool { return x == y(env) } 363 364 } 365 case r.Int8: 366 367 { 368 x := int8( 369 370 xv.Int()) 371 372 y := y.(func(*Env) int8) 373 fun = func(env *Env) bool { return x == y(env) } 374 375 } 376 case r.Int16: 377 378 { 379 x := int16( 380 381 xv.Int()) 382 383 y := y.(func(*Env) int16) 384 fun = func(env *Env) bool { return x == y(env) } 385 386 } 387 case r.Int32: 388 389 { 390 x := int32( 391 392 xv.Int()) 393 394 y := y.(func(*Env) int32) 395 fun = func(env *Env) bool { return x == y(env) } 396 397 } 398 case r.Int64: 399 400 { 401 x := xv.Int() 402 403 y := y.(func(*Env) int64) 404 fun = func(env *Env) bool { return x == y(env) } 405 406 } 407 case r.Uint: 408 409 { 410 x := uint( 411 412 xv.Uint()) 413 414 y := y.(func(*Env) uint) 415 fun = func(env *Env) bool { return x == y(env) } 416 417 } 418 case r.Uint8: 419 420 { 421 x := uint8( 422 423 xv.Uint()) 424 425 y := y.(func(*Env) uint8) 426 fun = func(env *Env) bool { return x == y(env) } 427 428 } 429 case r.Uint16: 430 431 { 432 x := uint16( 433 434 xv.Uint()) 435 436 y := y.(func(*Env) uint16) 437 fun = func(env *Env) bool { return x == y(env) } 438 439 } 440 case r.Uint32: 441 442 { 443 x := uint32( 444 445 xv.Uint()) 446 447 y := y.(func(*Env) uint32) 448 fun = func(env *Env) bool { return x == y(env) } 449 450 } 451 case r.Uint64: 452 453 { 454 x := xv.Uint() 455 456 y := y.(func(*Env) uint64) 457 fun = func(env *Env) bool { return x == y(env) } 458 459 } 460 case r.Uintptr: 461 462 { 463 x := uintptr( 464 465 xv.Uint()) 466 467 y := y.(func(*Env) uintptr) 468 fun = func(env *Env) bool { return x == y(env) } 469 470 } 471 case r.Float32: 472 473 { 474 x := 475 476 float32( 477 478 xv.Float()) 479 480 y := y.(func(*Env) float32) 481 fun = func(env *Env) bool { return x == y(env) } 482 483 } 484 case r.Float64: 485 486 { 487 x := xv.Float() 488 489 y := y.(func(*Env) float64) 490 fun = func(env *Env) bool { return x == y(env) } 491 492 } 493 case r.Complex64: 494 495 { 496 x := 497 498 complex64( 499 500 xv.Complex()) 501 502 y := y.(func(*Env) complex64) 503 fun = func(env *Env) bool { return x == y(env) } 504 505 } 506 case r.Complex128: 507 508 { 509 x := xv.Complex() 510 511 y := y.(func(*Env) complex128) 512 fun = func(env *Env) bool { return x == y(env) } 513 514 } 515 case r.String: 516 517 { 518 x := xv.String() 519 520 y := y.(func(*Env) string) 521 fun = func(env *Env) bool { return x == y(env) } 522 523 } 524 } 525 526 } 527 if fun != nil { 528 return c.exprBool(fun) 529 } 530 return c.eqlneqMisc(node, xe, ye) 531} 532func (c *Comp) Neq(node *ast.BinaryExpr, xe *Expr, ye *Expr) *Expr { 533 if xe.IsNil() { 534 if ye.IsNil() { 535 return c.invalidBinaryExpr(node, xe, ye) 536 } else { 537 return c.eqlneqNil(node, xe, ye) 538 } 539 } else if ye.IsNil() { 540 return c.eqlneqNil(node, xe, ye) 541 } 542 543 if !xe.Type.Comparable() || !xe.Type.Comparable() { 544 return c.invalidBinaryExpr(node, xe, ye) 545 } 546 547 xc, yc := xe.Const(), ye.Const() 548 if xe.Type.Kind() != r.Interface && ye.Type.Kind() != r.Interface { 549 c.toSameFuncType(node, xe, ye) 550 } 551 552 k := xe.Type.Kind() 553 yk := ye.Type.Kind() 554 555 var fun func(env *Env) bool 556 if k != yk { 557 558 } else if xc == yc { 559 x, y := xe.Fun, ye.Fun 560 switch k { 561 case r.Int: 562 { 563 x := x.(func(*Env) int) 564 y := y.(func(*Env) int) 565 fun = func(env *Env) bool { return x(env) != y(env) } 566 567 } 568 case r.Int8: 569 { 570 x := x.(func(*Env) int8) 571 y := y.(func(*Env) int8) 572 fun = func(env *Env) bool { return x(env) != y(env) } 573 574 } 575 case r.Int16: 576 { 577 x := x.(func(*Env) int16) 578 y := y.(func(*Env) int16) 579 fun = func(env *Env) bool { return x(env) != y(env) } 580 581 } 582 case r.Int32: 583 { 584 x := x.(func(*Env) int32) 585 y := y.(func(*Env) int32) 586 fun = func(env *Env) bool { return x(env) != y(env) } 587 588 } 589 case r.Int64: 590 { 591 x := x.(func(*Env) int64) 592 y := y.(func(*Env) int64) 593 fun = func(env *Env) bool { return x(env) != y(env) } 594 595 } 596 case r.Uint: 597 { 598 x := x.(func(*Env) uint) 599 y := y.(func(*Env) uint) 600 fun = func(env *Env) bool { return x(env) != y(env) } 601 602 } 603 case r.Uint8: 604 { 605 x := x.(func(*Env) uint8) 606 y := y.(func(*Env) uint8) 607 fun = func(env *Env) bool { return x(env) != y(env) } 608 609 } 610 case r.Uint16: 611 { 612 x := x.(func(*Env) uint16) 613 y := y.(func(*Env) uint16) 614 fun = func(env *Env) bool { return x(env) != y(env) } 615 616 } 617 case r.Uint32: 618 { 619 x := x.(func(*Env) uint32) 620 y := y.(func(*Env) uint32) 621 fun = func(env *Env) bool { return x(env) != y(env) } 622 623 } 624 case r.Uint64: 625 { 626 x := x.(func(*Env) uint64) 627 y := y.(func(*Env) uint64) 628 fun = func(env *Env) bool { return x(env) != y(env) } 629 630 } 631 case r.Uintptr: 632 { 633 x := x.(func(*Env) uintptr) 634 y := y.(func(*Env) uintptr) 635 fun = func(env *Env) bool { return x(env) != y(env) } 636 637 } 638 639 case r.Float32: 640 { 641 x := x.(func(*Env) float32) 642 y := y.(func(*Env) float32) 643 fun = func(env *Env) bool { return x(env) != y(env) } 644 645 } 646 647 case r.Float64: 648 { 649 x := x.(func(*Env) float64) 650 y := y.(func(*Env) float64) 651 fun = func(env *Env) bool { return x(env) != y(env) } 652 653 } 654 655 case r.Complex64: 656 { 657 x := x.(func(*Env) complex64) 658 y := y.(func(*Env) complex64) 659 fun = func(env *Env) bool { return x(env) != y(env) } 660 661 } 662 663 case r.Complex128: 664 { 665 x := x.(func(*Env) complex128) 666 y := y.(func(*Env) complex128) 667 fun = func(env *Env) bool { return x(env) != y(env) } 668 669 } 670 671 case r.String: 672 { 673 x := x.(func(*Env) string) 674 y := y.(func(*Env) string) 675 fun = func(env *Env) bool { return x(env) != y(env) } 676 677 } 678 679 } 680 681 } else if yc { 682 x := xe.Fun 683 yv := r.ValueOf(ye.Value) 684 if k == r.Bool && !yv.Bool() { 685 return xe 686 } 687 switch k { 688 case r.Int: 689 690 { 691 x := x.(func(*Env) int) 692 y := int(yv.Int()) 693 fun = func(env *Env) bool { return x(env) != y } 694 695 } 696 case r.Int8: 697 698 { 699 x := x.(func(*Env) int8) 700 y := int8(yv.Int()) 701 fun = func(env *Env) bool { return x(env) != y } 702 703 } 704 case r.Int16: 705 706 { 707 x := x.(func(*Env) int16) 708 y := int16(yv.Int()) 709 fun = func(env *Env) bool { return x(env) != y } 710 711 } 712 case r.Int32: 713 714 { 715 x := x.(func(*Env) int32) 716 y := int32(yv.Int()) 717 fun = func(env *Env) bool { return x(env) != y } 718 719 } 720 case r.Int64: 721 722 { 723 x := x.(func(*Env) int64) 724 y := yv.Int() 725 fun = func(env *Env) bool { return x(env) != y } 726 727 } 728 case r.Uint: 729 730 { 731 x := x.(func(*Env) uint) 732 y := uint(yv.Uint()) 733 fun = func(env *Env) bool { return x(env) != y } 734 735 } 736 case r.Uint8: 737 738 { 739 x := x.(func(*Env) uint8) 740 y := uint8(yv.Uint()) 741 fun = func(env *Env) bool { return x(env) != y } 742 743 } 744 case r.Uint16: 745 746 { 747 x := x.(func(*Env) uint16) 748 y := uint16(yv.Uint()) 749 fun = func(env *Env) bool { return x(env) != y } 750 751 } 752 case r.Uint32: 753 754 { 755 x := x.(func(*Env) uint32) 756 y := uint32(yv.Uint()) 757 fun = func(env *Env) bool { return x(env) != y } 758 759 } 760 case r.Uint64: 761 762 { 763 x := x.(func(*Env) uint64) 764 y := yv.Uint() 765 fun = func(env *Env) bool { return x(env) != y } 766 767 } 768 case r.Uintptr: 769 770 { 771 x := x.(func(*Env) uintptr) 772 y := uintptr(yv.Uint()) 773 fun = func(env *Env) bool { return x(env) != y } 774 775 } 776 case r.Float32: 777 778 { 779 x := x.(func(*Env) float32) 780 y := 781 782 float32(yv.Float()) 783 fun = func(env *Env) bool { return x(env) != y } 784 785 } 786 case r.Float64: 787 788 { 789 x := x.(func(*Env) float64) 790 y := yv.Float() 791 fun = func(env *Env) bool { return x(env) != y } 792 793 } 794 case r.Complex64: 795 796 { 797 x := x.(func(*Env) complex64) 798 y := 799 800 complex64(yv.Complex()) 801 fun = func(env *Env) bool { return x(env) != y } 802 803 } 804 case r.Complex128: 805 806 { 807 x := x.(func(*Env) complex128) 808 y := yv.Complex() 809 fun = func(env *Env) bool { return x(env) != y } 810 811 } 812 case r.String: 813 814 { 815 x := x.(func(*Env) string) 816 y := yv.String() 817 fun = func(env *Env) bool { return x(env) != y } 818 819 } 820 } 821 822 } else { 823 xv := r.ValueOf(xe.Value) 824 y := ye.Fun 825 if k == r.Bool && !xv.Bool() { 826 return ye 827 } 828 switch k { 829 case r.Int: 830 831 { 832 x := int( 833 834 xv.Int()) 835 836 y := y.(func(*Env) int) 837 fun = func(env *Env) bool { return x != y(env) } 838 839 } 840 case r.Int8: 841 842 { 843 x := int8( 844 845 xv.Int()) 846 847 y := y.(func(*Env) int8) 848 fun = func(env *Env) bool { return x != y(env) } 849 850 } 851 case r.Int16: 852 853 { 854 x := int16( 855 856 xv.Int()) 857 858 y := y.(func(*Env) int16) 859 fun = func(env *Env) bool { return x != y(env) } 860 861 } 862 case r.Int32: 863 864 { 865 x := int32( 866 867 xv.Int()) 868 869 y := y.(func(*Env) int32) 870 fun = func(env *Env) bool { return x != y(env) } 871 872 } 873 case r.Int64: 874 875 { 876 x := xv.Int() 877 878 y := y.(func(*Env) int64) 879 fun = func(env *Env) bool { return x != y(env) } 880 881 } 882 case r.Uint: 883 884 { 885 x := uint( 886 887 xv.Uint()) 888 889 y := y.(func(*Env) uint) 890 fun = func(env *Env) bool { return x != y(env) } 891 892 } 893 case r.Uint8: 894 895 { 896 x := uint8( 897 898 xv.Uint()) 899 900 y := y.(func(*Env) uint8) 901 fun = func(env *Env) bool { return x != y(env) } 902 903 } 904 case r.Uint16: 905 906 { 907 x := uint16( 908 909 xv.Uint()) 910 911 y := y.(func(*Env) uint16) 912 fun = func(env *Env) bool { return x != y(env) } 913 914 } 915 case r.Uint32: 916 917 { 918 x := uint32( 919 920 xv.Uint()) 921 922 y := y.(func(*Env) uint32) 923 fun = func(env *Env) bool { return x != y(env) } 924 925 } 926 case r.Uint64: 927 928 { 929 x := xv.Uint() 930 931 y := y.(func(*Env) uint64) 932 fun = func(env *Env) bool { return x != y(env) } 933 934 } 935 case r.Uintptr: 936 937 { 938 x := uintptr( 939 940 xv.Uint()) 941 942 y := y.(func(*Env) uintptr) 943 fun = func(env *Env) bool { return x != y(env) } 944 945 } 946 case r.Float32: 947 948 { 949 x := 950 951 float32( 952 953 xv.Float()) 954 955 y := y.(func(*Env) float32) 956 fun = func(env *Env) bool { return x != y(env) } 957 958 } 959 case r.Float64: 960 961 { 962 x := xv.Float() 963 964 y := y.(func(*Env) float64) 965 fun = func(env *Env) bool { return x != y(env) } 966 967 } 968 case r.Complex64: 969 970 { 971 x := 972 973 complex64( 974 975 xv.Complex()) 976 977 y := y.(func(*Env) complex64) 978 fun = func(env *Env) bool { return x != y(env) } 979 980 } 981 case r.Complex128: 982 983 { 984 x := xv.Complex() 985 986 y := y.(func(*Env) complex128) 987 fun = func(env *Env) bool { return x != y(env) } 988 989 } 990 case r.String: 991 992 { 993 x := xv.String() 994 995 y := y.(func(*Env) string) 996 fun = func(env *Env) bool { return x != y(env) } 997 998 } 999 } 1000 1001 } 1002 if fun != nil { 1003 return c.exprBool(fun) 1004 } 1005 return c.eqlneqMisc(node, xe, ye) 1006} 1007func (c *Comp) eqlneqMisc(node *ast.BinaryExpr, xe *Expr, ye *Expr) *Expr { 1008 var fun func(*Env) bool 1009 1010 x := xe.AsX1() 1011 y := ye.AsX1() 1012 t1 := xe.Type 1013 t2 := ye.Type 1014 extractor1 := c.extractor(t1) 1015 extractor2 := c.extractor(t2) 1016 1017 if node.Op == token.EQL { 1018 fun = func(env *Env) bool { 1019 v1 := x(env) 1020 v2 := y(env) 1021 if v1 == Nil || v2 == Nil { 1022 return v1 == v2 1023 } 1024 1025 t1, t2 := t1, t2 1026 if extractor1 != nil { 1027 v1, t1 = extractor1(v1) 1028 } 1029 1030 if extractor2 != nil { 1031 v2, t2 = extractor2(v2) 1032 } 1033 1034 if v1 == Nil || v2 == Nil { 1035 return v1 == v2 1036 } 1037 return v1.Interface() == v2.Interface() && 1038 (t1 == nil || t2 == nil || t1.IdenticalTo(t2)) 1039 } 1040 } else { 1041 fun = func(env *Env) bool { 1042 v1 := x(env) 1043 v2 := y(env) 1044 if v1 == Nil || v2 == Nil { 1045 return v1 != v2 1046 } 1047 1048 t1, t2 := t1, t2 1049 if extractor1 != nil { 1050 v1, t1 = extractor1(v1) 1051 } 1052 1053 if extractor2 != nil { 1054 v2, t2 = extractor2(v2) 1055 } 1056 1057 if v1 == Nil || v2 == Nil { 1058 return v1 != v2 1059 } 1060 return v1.Interface() != v2.Interface() || 1061 t1 != nil && t2 != nil && !t1.IdenticalTo(t2) 1062 } 1063 } 1064 return c.exprBool(fun) 1065} 1066func (c *Comp) eqlneqNil(node *ast.BinaryExpr, xe *Expr, ye *Expr) *Expr { 1067 var e *Expr 1068 if ye.IsNil() { 1069 e = xe 1070 } else { 1071 e = ye 1072 } 1073 1074 if !reflect.IsNillableKind(e.Type.Kind()) { 1075 return c.invalidBinaryExpr(node, xe, ye) 1076 } 1077 1078 var fun func(env *Env) bool 1079 if f, ok := e.Fun.(func(env *Env) (r.Value, []r.Value)); ok { 1080 e.CheckX1() 1081 if node.Op == token.EQL { 1082 fun = func(env *Env) bool { 1083 v, _ := f(env) 1084 vnil := v == Nil || reflect.IsNillableKind(v.Kind()) && v.IsNil() 1085 return vnil 1086 } 1087 } else { 1088 fun = func(env *Env) bool { 1089 v, _ := f(env) 1090 vnil := v == Nil || reflect.IsNillableKind(v.Kind()) && v.IsNil() 1091 return !vnil 1092 } 1093 } 1094 1095 } else { 1096 f := e.AsX1() 1097 if node.Op == token.EQL { 1098 fun = func(env *Env) bool { 1099 v := f(env) 1100 vnil := v == Nil || reflect.IsNillableKind(v.Kind()) && v.IsNil() 1101 return vnil 1102 } 1103 } else { 1104 fun = func(env *Env) bool { 1105 v := f(env) 1106 vnil := v == Nil || reflect.IsNillableKind(v.Kind()) && v.IsNil() 1107 return !vnil 1108 } 1109 } 1110 1111 } 1112 return c.exprBool(fun) 1113} 1114