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