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