1// +build gomacro_fast_compact
2
3/*
4 * gomacro - A Go interpreter with Lisp-like macros
5 *
6 * Copyright (C) 2017-2019 Massimiliano Ghilardi
7 *
8 *     This Source Code Form is subject to the terms of the Mozilla Public
9 *     License, v. 2.0. If a copy of the MPL was not distributed with this
10 *     file, You can obtain one at http://mozilla.org/MPL/2.0/.
11 *
12 *
13 * call1ret1_compact.go
14 *
15 *  Created on Apr 15, 2017
16 *      Author Massimiliano Ghilardi
17 */
18
19package fast
20
21import (
22	r "reflect"
23)
24
25func (c *Comp) call1ret1(call *Call, maxdepth int) I {
26	expr := call.Fun
27	exprfun := expr.AsX1()
28
29	arg := call.Args[0]
30	argfun := arg.AsX1()
31	var ret I
32
33	switch expr.Type.Out(0).Kind() {
34	case r.Bool:
35		ret = func(env *Env) bool {
36			funv := exprfun(env)
37			argv := []r.Value{
38				argfun(env),
39			}
40			retv := funv.Call(argv)[0]
41			return retv.Bool()
42		}
43
44	case r.Int:
45		ret = func(env *Env) int {
46			funv := exprfun(env)
47			argv := []r.Value{
48				argfun(env),
49			}
50			retv := funv.Call(argv)[0]
51			return int(retv.Int())
52		}
53
54	case r.Int8:
55		ret = func(env *Env) int8 {
56			funv := exprfun(env)
57			argv := []r.Value{
58				argfun(env),
59			}
60			retv := funv.Call(argv)[0]
61			return int8(retv.Int())
62		}
63
64	case r.Int16:
65		ret = func(env *Env) int16 {
66			funv := exprfun(env)
67			argv := []r.Value{
68				argfun(env),
69			}
70			retv := funv.Call(argv)[0]
71			return int16(retv.Int())
72		}
73
74	case r.Int32:
75		ret = func(env *Env) int32 {
76			funv := exprfun(env)
77			argv := []r.Value{
78				argfun(env),
79			}
80			retv := funv.Call(argv)[0]
81			return int32(retv.Int())
82		}
83
84	case r.Int64:
85		ret = func(env *Env) int64 {
86			funv := exprfun(env)
87			argv := []r.Value{
88				argfun(env),
89			}
90			retv := funv.Call(argv)[0]
91			return retv.Int()
92		}
93
94	case r.Uint:
95		ret = func(env *Env) uint {
96			funv := exprfun(env)
97			argv := []r.Value{
98				argfun(env),
99			}
100			retv := funv.Call(argv)[0]
101			return uint(retv.Uint())
102		}
103
104	case r.Uint8:
105		ret = func(env *Env) uint8 {
106			funv := exprfun(env)
107			argv := []r.Value{
108				argfun(env),
109			}
110			retv := funv.Call(argv)[0]
111			return uint8(retv.Uint())
112		}
113
114	case r.Uint16:
115		ret = func(env *Env) uint16 {
116			funv := exprfun(env)
117			argv := []r.Value{
118				argfun(env),
119			}
120			retv := funv.Call(argv)[0]
121			return uint16(retv.Uint())
122		}
123
124	case r.Uint32:
125		ret = func(env *Env) uint32 {
126			funv := exprfun(env)
127			argv := []r.Value{
128				argfun(env),
129			}
130			retv := funv.Call(argv)[0]
131			return uint32(retv.Uint())
132		}
133
134	case r.Uint64:
135		ret = func(env *Env) uint64 {
136			funv := exprfun(env)
137			argv := []r.Value{
138				argfun(env),
139			}
140			retv := funv.Call(argv)[0]
141			return retv.Uint()
142		}
143
144	case r.Uintptr:
145		ret = func(env *Env) uintptr {
146			funv := exprfun(env)
147			argv := []r.Value{
148				argfun(env),
149			}
150			retv := funv.Call(argv)[0]
151			return uintptr(retv.Uint())
152		}
153
154	case r.Float32:
155		ret = func(env *Env) float32 {
156			funv := exprfun(env)
157			argv := []r.Value{
158				argfun(env),
159			}
160			retv := funv.Call(argv)[0]
161			return float32(retv.Float())
162		}
163
164	case r.Float64:
165		ret = func(env *Env) float64 {
166			funv := exprfun(env)
167			argv := []r.Value{
168				argfun(env),
169			}
170			retv := funv.Call(argv)[0]
171			return retv.Float()
172		}
173
174	case r.Complex64:
175		ret = func(env *Env) complex64 {
176			funv := exprfun(env)
177			argv := []r.Value{
178				argfun(env),
179			}
180			retv := funv.Call(argv)[0]
181			return complex64(retv.Complex())
182		}
183
184	case r.Complex128:
185		ret = func(env *Env) complex128 {
186			funv := exprfun(env)
187			argv := []r.Value{
188				argfun(env),
189			}
190			retv := funv.Call(argv)[0]
191			return retv.Complex()
192		}
193
194	case r.String:
195		ret = func(env *Env) string {
196			funv := exprfun(env)
197			argv := []r.Value{
198				argfun(env),
199			}
200			retv := funv.Call(argv)[0]
201			return retv.String()
202		}
203	default:
204		ret = func(env *Env) r.Value {
205			funv := exprfun(env)
206			argv := []r.Value{
207				argfun(env),
208			}
209			return funv.Call(argv)[0]
210		}
211	}
212	return ret
213}
214