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