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