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