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 * func0ret1.go
17 *
18 *  Created on Apr 16, 2017
19 *      Author Massimiliano Ghilardi
20 */
21
22package fast
23
24import (
25	r "reflect"
26	. "github.com/cosmos72/gomacro/base"
27	xr "github.com/cosmos72/gomacro/xreflect"
28)
29
30func (c *Comp) func0ret1(t xr.Type, m *funcMaker) func(*Env) r.Value {
31
32	nbind := m.nbind
33	nintbind := m.nintbind
34	funcbody := m.funcbody
35
36	var debugC *Comp
37	if c.Globals.Options&OptDebugger != 0 {
38		debugC = c
39	}
40
41	tret0 := t.Out(0)
42	kret0 := tret0.Kind()
43	switch kret0 {
44	case r.Bool:
45		{
46			if funcbody == nil {
47				return func(env *Env) r.Value {
48					return r.ValueOf(func() (ret0 bool) { return },
49					)
50				}
51			}
52
53			resultfun := m.resultfun[0].(func(*Env) bool)
54			return func(env *Env) r.Value {
55
56				env.MarkUsedByClosure()
57				return r.ValueOf(func() (ret0 bool,
58
59				) {
60					env := newEnv4Func(env, nbind, nintbind, debugC)
61
62					funcbody(env)
63
64					ret0 = resultfun(env)
65					env.freeEnv4Func()
66					return
67
68				})
69			}
70		}
71	case r.Int:
72		{
73			if funcbody == nil {
74				return func(env *Env) r.Value {
75					return r.ValueOf(func() (ret0 int) { return },
76					)
77				}
78			}
79
80			resultfun := m.resultfun[0].(func(*Env) int)
81			return func(env *Env) r.Value {
82
83				env.MarkUsedByClosure()
84				return r.ValueOf(func() (ret0 int,
85
86				) {
87					env := newEnv4Func(env, nbind, nintbind, debugC)
88
89					funcbody(env)
90
91					ret0 = resultfun(env)
92					env.freeEnv4Func()
93					return
94
95				})
96			}
97		}
98	case r.Int8:
99		{
100			if funcbody == nil {
101				return func(env *Env) r.Value {
102					return r.ValueOf(func() (ret0 int8) { return },
103					)
104				}
105			}
106
107			resultfun := m.resultfun[0].(func(*Env) int8)
108			return func(env *Env) r.Value {
109
110				env.MarkUsedByClosure()
111				return r.ValueOf(func() (ret0 int8,
112
113				) {
114					env := newEnv4Func(env, nbind, nintbind, debugC)
115
116					funcbody(env)
117
118					ret0 = resultfun(env)
119					env.freeEnv4Func()
120					return
121
122				})
123			}
124		}
125	case r.Int16:
126		{
127			if funcbody == nil {
128				return func(env *Env) r.Value {
129					return r.ValueOf(func() (ret0 int16) { return },
130					)
131				}
132			}
133
134			resultfun := m.resultfun[0].(func(*Env) int16)
135			return func(env *Env) r.Value {
136
137				env.MarkUsedByClosure()
138				return r.ValueOf(func() (ret0 int16,
139
140				) {
141					env := newEnv4Func(env, nbind, nintbind, debugC)
142
143					funcbody(env)
144
145					ret0 = resultfun(env)
146					env.freeEnv4Func()
147					return
148
149				})
150			}
151		}
152	case r.Int32:
153		{
154			if funcbody == nil {
155				return func(env *Env) r.Value {
156					return r.ValueOf(func() (ret0 int32) { return },
157					)
158				}
159			}
160
161			resultfun := m.resultfun[0].(func(*Env) int32)
162			return func(env *Env) r.Value {
163
164				env.MarkUsedByClosure()
165				return r.ValueOf(func() (ret0 int32,
166				) {
167					env := newEnv4Func(env, nbind, nintbind, debugC)
168
169					funcbody(env)
170
171					ret0 = resultfun(env)
172					env.freeEnv4Func()
173					return
174
175				})
176			}
177		}
178	case r.Int64:
179		{
180			if funcbody == nil {
181				return func(env *Env) r.Value {
182					return r.ValueOf(func() (ret0 int64) { return },
183					)
184				}
185			}
186
187			resultfun := m.resultfun[0].(func(*Env) int64)
188			return func(env *Env) r.Value {
189
190				env.MarkUsedByClosure()
191				return r.ValueOf(func() (ret0 int64) {
192					env := newEnv4Func(env, nbind, nintbind, debugC)
193
194					funcbody(env)
195
196					ret0 = resultfun(env)
197					env.freeEnv4Func()
198					return
199
200				})
201			}
202		}
203	case r.Uint:
204		{
205			if funcbody == nil {
206				return func(env *Env) r.Value {
207					return r.ValueOf(func() (ret0 uint) { return },
208					)
209				}
210			}
211
212			resultfun := m.resultfun[0].(func(*Env) uint)
213			return func(env *Env) r.Value {
214
215				env.MarkUsedByClosure()
216				return r.ValueOf(func() (ret0 uint) {
217					env := newEnv4Func(env, nbind, nintbind, debugC)
218
219					funcbody(env)
220
221					ret0 = resultfun(env)
222					env.freeEnv4Func()
223					return
224
225				})
226			}
227		}
228	case r.Uint8:
229		{
230			if funcbody == nil {
231				return func(env *Env) r.Value {
232					return r.ValueOf(func() (ret0 uint8) { return },
233					)
234				}
235			}
236
237			resultfun := m.resultfun[0].(func(*Env) uint8)
238			return func(env *Env) r.Value {
239
240				env.MarkUsedByClosure()
241				return r.ValueOf(func() (ret0 uint8) {
242					env := newEnv4Func(env, nbind, nintbind, debugC)
243
244					funcbody(env)
245
246					ret0 = resultfun(env)
247					env.freeEnv4Func()
248					return
249
250				})
251			}
252		}
253	case r.Uint16:
254		{
255			if funcbody == nil {
256				return func(env *Env) r.Value {
257					return r.ValueOf(func() (ret0 uint16) { return },
258					)
259				}
260			}
261
262			resultfun := m.resultfun[0].(func(*Env) uint16)
263			return func(env *Env) r.Value {
264
265				env.MarkUsedByClosure()
266				return r.ValueOf(func() (ret0 uint16) {
267					env := newEnv4Func(env, nbind, nintbind, debugC)
268
269					funcbody(env)
270
271					ret0 = resultfun(env)
272					env.freeEnv4Func()
273					return
274
275				})
276			}
277		}
278	case r.Uint32:
279		{
280			if funcbody == nil {
281				return func(env *Env) r.Value {
282					return r.ValueOf(func() (ret0 uint32) { return },
283					)
284				}
285			}
286
287			resultfun := m.resultfun[0].(func(*Env) uint32)
288			return func(env *Env) r.Value {
289
290				env.MarkUsedByClosure()
291				return r.ValueOf(func() (ret0 uint32) {
292					env := newEnv4Func(env, nbind, nintbind, debugC)
293
294					funcbody(env)
295
296					ret0 = resultfun(env)
297					env.freeEnv4Func()
298					return
299
300				})
301			}
302		}
303	case r.Uint64:
304		{
305			if funcbody == nil {
306				return func(env *Env) r.Value {
307					return r.ValueOf(func() (ret0 uint64) { return },
308					)
309				}
310			}
311
312			resultfun := m.resultfun[0].(func(*Env) uint64)
313			return func(env *Env) r.Value {
314
315				env.MarkUsedByClosure()
316				return r.ValueOf(func() (ret0 uint64) {
317					env := newEnv4Func(env, nbind, nintbind, debugC)
318
319					funcbody(env)
320
321					ret0 = resultfun(env)
322					env.freeEnv4Func()
323					return
324
325				})
326			}
327		}
328	case r.Uintptr:
329		{
330			if funcbody == nil {
331				return func(env *Env) r.Value {
332					return r.ValueOf(func() (ret0 uintptr) { return },
333					)
334				}
335			}
336
337			resultfun := m.resultfun[0].(func(*Env) uintptr)
338			return func(env *Env) r.Value {
339
340				env.MarkUsedByClosure()
341				return r.ValueOf(func() (ret0 uintptr) {
342					env := newEnv4Func(env, nbind, nintbind, debugC)
343
344					funcbody(env)
345
346					ret0 = resultfun(env)
347					env.freeEnv4Func()
348					return
349
350				})
351			}
352		}
353	case r.Float32:
354		{
355			if funcbody == nil {
356				return func(env *Env) r.Value {
357					return r.ValueOf(func() (ret0 float32) { return },
358					)
359				}
360			}
361
362			resultfun := m.resultfun[0].(func(*Env) float32)
363			return func(env *Env) r.Value {
364
365				env.MarkUsedByClosure()
366				return r.ValueOf(func() (ret0 float32) {
367					env := newEnv4Func(env, nbind, nintbind, debugC)
368
369					funcbody(env)
370
371					ret0 = resultfun(env)
372					env.freeEnv4Func()
373					return
374
375				})
376			}
377		}
378	case r.Float64:
379		{
380			if funcbody == nil {
381				return func(env *Env) r.Value {
382					return r.ValueOf(func() (ret0 float64) { return },
383					)
384				}
385			}
386
387			resultfun := m.resultfun[0].(func(*Env) float64)
388			return func(env *Env) r.Value {
389
390				env.MarkUsedByClosure()
391				return r.ValueOf(func() (ret0 float64) {
392					env := newEnv4Func(env, nbind, nintbind, debugC)
393
394					funcbody(env)
395
396					ret0 = resultfun(env)
397					env.freeEnv4Func()
398					return
399
400				})
401			}
402		}
403	case r.Complex64:
404		{
405			if funcbody == nil {
406				return func(env *Env) r.Value {
407					return r.ValueOf(func() (ret0 complex64) { return },
408					)
409				}
410			}
411
412			resultfun := m.resultfun[0].(func(*Env) complex64)
413			return func(env *Env) r.Value {
414
415				env.MarkUsedByClosure()
416				return r.ValueOf(func() (ret0 complex64) {
417					env := newEnv4Func(env, nbind, nintbind, debugC)
418
419					funcbody(env)
420
421					ret0 = resultfun(env)
422					env.freeEnv4Func()
423					return
424
425				})
426			}
427		}
428	case r.Complex128:
429		{
430			if funcbody == nil {
431				return func(env *Env) r.Value {
432					return r.ValueOf(func() (ret0 complex128) { return },
433					)
434				}
435			}
436
437			resultfun := m.resultfun[0].(func(*Env) complex128)
438			return func(env *Env) r.Value {
439
440				env.MarkUsedByClosure()
441				return r.ValueOf(func() (ret0 complex128) {
442					env := newEnv4Func(env, nbind, nintbind, debugC)
443
444					funcbody(env)
445
446					ret0 = resultfun(env)
447					env.freeEnv4Func()
448					return
449
450				})
451			}
452		}
453	case r.String:
454		{
455			if funcbody == nil {
456				return func(env *Env) r.Value {
457					return r.ValueOf(func() (ret0 string) { return },
458					)
459				}
460			}
461
462			resultfun := m.resultfun[0].(func(*Env) string)
463			return func(env *Env) r.Value {
464
465				env.MarkUsedByClosure()
466				return r.ValueOf(func() (ret0 string) {
467					env := newEnv4Func(env, nbind, nintbind, debugC)
468
469					funcbody(env)
470
471					ret0 = resultfun(env)
472					env.freeEnv4Func()
473					return
474
475				})
476			}
477		}
478	default:
479		return nil
480	}
481}
482