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