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