1/* 2 * gomacro - A Go interpreter with Lisp-like macros 3 * 4 * Copyright (C) 2017-2019 Massimiliano Ghilardi 5 * 6 * This Source Code Form is subject to the terms of the Mozilla Public 7 * License, v. 2.0. If a copy of the MPL was not distributed with this 8 * file, You can obtain one at http://mozilla.org/MPL/2.0/. 9 * 10 * 11 * identifier.go 12 * 13 * Created on Apr 01, 2017 14 * Author Massimiliano Ghilardi 15 */ 16 17package fast 18 19import ( 20 "go/ast" 21 "go/constant" 22 r "reflect" 23 24 . "github.com/cosmos72/gomacro/base" 25 "github.com/cosmos72/gomacro/base/output" 26 "github.com/cosmos72/gomacro/base/reflect" 27 "github.com/cosmos72/gomacro/base/untyped" 28 xr "github.com/cosmos72/gomacro/xreflect" 29) 30 31func eFalse(*Env) bool { 32 return false 33} 34 35func eTrue(*Env) bool { 36 return true 37} 38 39func eNil(*Env) r.Value { 40 return Nil 41} 42 43func eXVNone(*Env) (r.Value, []r.Value) { 44 return None, nil 45} 46 47func nop() { 48} 49 50var valueOfNopFunc = r.ValueOf(nop) 51 52// opaqueType returns an xr.Type corresponding to rtype but without fields or methods and with the given pkgpath 53func (g *CompGlobals) opaqueType(rtype r.Type, pkgpath string) xr.Type { 54 return g.opaqueNamedType(rtype, rtype.Name(), pkgpath) 55} 56 57// opaqueNamedType returns an xr.Type corresponding to rtype but without fields or methods and with the given name and pkgpath 58func (g *CompGlobals) opaqueNamedType(rtype r.Type, name string, pkgpath string) xr.Type { 59 v := g.Universe 60 switch k := rtype.Kind(); k { 61 case r.Ptr: 62 telem := g.opaqueType(rtype.Elem(), pkgpath) 63 t := v.PtrTo(telem) 64 v.ReflectTypes[rtype] = t 65 return t 66 case r.Struct: 67 break 68 default: 69 g.Errorf("internal error: unimplemented opaqueNamedType for kind=%v, expecting kind=Struct", k) 70 } 71 t := v.NamedOf(name, pkgpath, r.Struct) 72 t.SetUnderlying(v.TypeOf(struct{}{})) 73 t.UnsafeForceReflectType(rtype) 74 v.ReflectTypes[rtype] = t // also cache Type in g.Universe.ReflectTypes 75 // g.Debugf("initialized opaque type %v <%v> <%v>", t.Kind(), t.GoType(), t.ReflectType()) 76 return t 77} 78 79func asIdent(node ast.Expr) *ast.Ident { 80 ident, _ := node.(*ast.Ident) 81 return ident 82} 83 84func (e *Expr) TryAsPred() (value bool, fun func(*Env) bool, err bool) { 85 if e.Untyped() { 86 untyp := e.Value.(UntypedLit) 87 if untyp.Kind != untyped.Bool { 88 return false, nil, true 89 } 90 return constant.BoolVal(untyp.Val), nil, false 91 } 92 if e.Type.Kind() != r.Bool { 93 return false, nil, true 94 } 95 if e.Const() { 96 v := r.ValueOf(e.Value) 97 return v.Bool(), nil, false 98 } 99 switch fun := e.Fun.(type) { 100 case func(*Env) bool: 101 return false, fun, false 102 case func(*Env) (r.Value, []r.Value): 103 e.CheckX1() 104 return false, func(env *Env) bool { 105 ret, _ := fun(env) 106 return ret.Bool() 107 }, false 108 default: 109 fun1 := e.AsX1() 110 return false, func(env *Env) bool { 111 return fun1(env).Bool() 112 }, false 113 } 114} 115 116func (c *Comp) invalidPred(node ast.Expr, x *Expr) Stmt { 117 return c.badPred("invalid", node, x) 118} 119 120func (c *Comp) badPred(reason string, node ast.Expr, x *Expr) Stmt { 121 var t xr.Type = nil 122 if x.NumOut() != 0 { 123 t = x.Out(0) 124 } 125 c.Errorf("%s boolean predicate, expecting <bool> expression, found <%v>: %v", 126 reason, t, node) 127 return nil 128} 129 130func (e *Expr) AsX() func(*Env) { 131 if e == nil || e.Const() { 132 return nil 133 } 134 return funAsX(e.Fun) 135} 136 137func funAsX(any I) func(*Env) { 138 switch fun := any.(type) { 139 case nil: 140 case func(*Env): 141 return fun 142 case func(*Env) r.Value: 143 return func(env *Env) { 144 fun(env) 145 } 146 case func(*Env) (r.Value, []r.Value): 147 return func(env *Env) { 148 fun(env) 149 } 150 case func(*Env) bool: 151 return func(env *Env) { 152 fun(env) 153 } 154 case func(*Env) int: 155 return func(env *Env) { 156 fun(env) 157 } 158 case func(*Env) int8: 159 return func(env *Env) { 160 fun(env) 161 } 162 case func(*Env) int16: 163 return func(env *Env) { 164 fun(env) 165 } 166 case func(*Env) int32: 167 return func(env *Env) { 168 fun(env) 169 } 170 case func(*Env) int64: 171 return func(env *Env) { 172 fun(env) 173 } 174 case func(*Env) uint: 175 return func(env *Env) { 176 fun(env) 177 } 178 case func(*Env) uint8: 179 return func(env *Env) { 180 fun(env) 181 } 182 case func(*Env) uint16: 183 return func(env *Env) { 184 fun(env) 185 } 186 case func(*Env) uint32: 187 return func(env *Env) { 188 fun(env) 189 } 190 case func(*Env) uint64: 191 return func(env *Env) { 192 fun(env) 193 } 194 case func(*Env) uintptr: 195 return func(env *Env) { 196 fun(env) 197 } 198 case func(*Env) float32: 199 return func(env *Env) { 200 fun(env) 201 } 202 case func(*Env) float64: 203 return func(env *Env) { 204 fun(env) 205 } 206 case func(*Env) complex64: 207 return func(env *Env) { 208 fun(env) 209 } 210 case func(*Env) complex128: 211 return func(env *Env) { 212 fun(env) 213 } 214 case func(*Env) string: 215 return func(env *Env) { 216 fun(env) 217 } 218 default: 219 output.Errorf("unsupported function type, cannot convert to func(*Env): %v <%v>", any, r.TypeOf(any)) 220 } 221 return nil 222} 223 224// CheckX1() panics if given expression cannot be used in single-value context, 225// for example because it returns no value at all. 226// It just prints a warning if expression returns multiple values. 227func (e *Expr) CheckX1() { 228 if e != nil && e.Const() { 229 return 230 } 231 if e == nil || e.NumOut() == 0 { 232 output.Errorf("expression returns no values, cannot convert to func(env *Env) r.Value") 233 return 234 } else if e.NumOut() > 1 { 235 output.Warnf("expression returns %d values, using only the first one: %v", e.NumOut(), e.Types) 236 } 237} 238 239func (e *Expr) AsX1() func(*Env) r.Value { 240 if e == nil { 241 return eNil 242 } 243 if e.Const() { 244 return valueAsX1(e.Value, e.Type, COptDefaults) 245 } 246 e.CheckX1() 247 return funAsX1(e.Fun, e.Type) 248} 249 250func (e *Expr) AsXV(opts CompileOptions) func(*Env) (r.Value, []r.Value) { 251 if e == nil { 252 return eXVNone 253 } 254 if e.Const() { 255 return valueAsXV(e.Value, e.Type, opts) 256 } 257 return funAsXV(e.Fun, e.Type) 258} 259 260func valueAsX1(any I, t xr.Type, opts CompileOptions) func(*Env) r.Value { 261 convertuntyped := opts&COptKeepUntyped == 0 262 untyp, untyped := any.(UntypedLit) 263 if untyped && convertuntyped { 264 if t == nil || t.ReflectType() == rtypeOfUntypedLit { 265 t = untyp.DefaultType() 266 } 267 // Debugf("late conversion of untyped constant %v <%v> to <%v>", untyp, r.TypeOf(untyp), t) 268 any = untyp.Convert(t) 269 } 270 v := r.ValueOf(any) 271 if t != nil { 272 rtype := t.ReflectType() 273 if !v.IsValid() { 274 v = r.Zero(rtype) 275 } else if convertuntyped || !untyped { 276 v = convert(v, rtype) 277 } 278 } 279 return func(*Env) r.Value { 280 return v 281 } 282} 283 284func valueAsXV(any I, t xr.Type, opts CompileOptions) func(*Env) (r.Value, []r.Value) { 285 convertuntyped := opts&COptKeepUntyped == 0 286 untyp, untyped := any.(UntypedLit) 287 if convertuntyped { 288 if untyped { 289 if t == nil || t.ReflectType() == rtypeOfUntypedLit { 290 t = untyp.DefaultType() 291 // Debugf("valueAsXV: late conversion of untyped constant %v <%v> to its default type <%v>", untyp, r.TypeOf(untyp), t) 292 } else { 293 // Debugf("valueAsXV: late conversion of untyped constant %v <%v> to <%v>", untyp, r.TypeOf(untyp), t.ReflectType()) 294 } 295 any = untyp.Convert(t) 296 } 297 } 298 v := r.ValueOf(any) 299 if t != nil { 300 rtype := t.ReflectType() 301 if reflect.Type(v) == nil { 302 v = r.Zero(rtype) 303 } else if convertuntyped || !untyped { 304 v = convert(v, rtype) 305 } 306 } 307 return func(*Env) (r.Value, []r.Value) { 308 return v, nil 309 } 310} 311 312func funAsX1(fun I, t xr.Type) func(*Env) r.Value { 313 // output.Debugf("funAsX1() %v -> %v", TypeOf(fun), t) 314 var rt r.Type 315 if t != nil { 316 rt = t.ReflectType() 317 } 318 switch fun := fun.(type) { 319 case nil: 320 case func(*Env): 321 if fun == nil { 322 break 323 } 324 return func(env *Env) r.Value { 325 fun(env) 326 return None 327 } 328 case func(*Env) r.Value: 329 return fun 330 case func(*Env) (r.Value, []r.Value): 331 return func(env *Env) r.Value { 332 ret, _ := fun(env) 333 return ret 334 } 335 case func(*Env) bool: 336 if rt == nil || rt == TypeOfBool { 337 return func(env *Env) r.Value { 338 return r.ValueOf(fun(env)) 339 } 340 } else { 341 return func(env *Env) r.Value { 342 return convert(r.ValueOf(fun(env)), rt) 343 } 344 } 345 case func(*Env) int: 346 if rt == nil || rt == TypeOfInt { 347 return func(env *Env) r.Value { 348 return r.ValueOf(fun(env)) 349 } 350 } else { 351 return func(env *Env) r.Value { 352 return convert(r.ValueOf(fun(env)), rt) 353 } 354 } 355 case func(*Env) int8: 356 if rt == nil || rt == TypeOfInt8 { 357 return func(env *Env) r.Value { 358 return r.ValueOf(fun(env)) 359 } 360 } else { 361 return func(env *Env) r.Value { 362 return convert(r.ValueOf(fun(env)), rt) 363 } 364 } 365 case func(*Env) int16: 366 if rt == nil || rt == TypeOfInt16 { 367 return func(env *Env) r.Value { 368 return r.ValueOf(fun(env)) 369 } 370 } else { 371 return func(env *Env) r.Value { 372 return convert(r.ValueOf(fun(env)), rt) 373 } 374 } 375 case func(*Env) int32: 376 if rt == nil || rt == TypeOfInt32 { 377 return func(env *Env) r.Value { 378 return r.ValueOf(fun(env)) 379 } 380 } else { 381 return func(env *Env) r.Value { 382 return convert(r.ValueOf(fun(env)), rt) 383 } 384 } 385 case func(*Env) int64: 386 if rt == nil || rt == TypeOfInt64 { 387 return func(env *Env) r.Value { 388 return r.ValueOf(fun(env)) 389 } 390 } else { 391 return func(env *Env) r.Value { 392 return convert(r.ValueOf(fun(env)), rt) 393 } 394 } 395 case func(*Env) uint: 396 if rt == nil || rt == TypeOfUint { 397 return func(env *Env) r.Value { 398 return r.ValueOf(fun(env)) 399 } 400 } else { 401 return func(env *Env) r.Value { 402 return convert(r.ValueOf(fun(env)), rt) 403 } 404 } 405 case func(*Env) uint8: 406 if rt == nil || rt == TypeOfUint8 { 407 return func(env *Env) r.Value { 408 return r.ValueOf(fun(env)) 409 } 410 } else { 411 return func(env *Env) r.Value { 412 return convert(r.ValueOf(fun(env)), rt) 413 } 414 } 415 case func(*Env) uint16: 416 if rt == nil || rt == TypeOfUint16 { 417 return func(env *Env) r.Value { 418 return r.ValueOf(fun(env)) 419 } 420 } else { 421 return func(env *Env) r.Value { 422 return convert(r.ValueOf(fun(env)), rt) 423 } 424 } 425 case func(*Env) uint32: 426 if rt == nil || rt == TypeOfUint32 { 427 return func(env *Env) r.Value { 428 return r.ValueOf(fun(env)) 429 } 430 } else { 431 return func(env *Env) r.Value { 432 return convert(r.ValueOf(fun(env)), rt) 433 } 434 } 435 case func(*Env) uint64: 436 if rt == nil || rt == TypeOfUint64 { 437 return func(env *Env) r.Value { 438 return r.ValueOf(fun(env)) 439 } 440 } else { 441 return func(env *Env) r.Value { 442 return convert(r.ValueOf(fun(env)), rt) 443 } 444 } 445 case func(*Env) uintptr: 446 if rt == nil || rt == TypeOfUintptr { 447 return func(env *Env) r.Value { 448 return r.ValueOf(fun(env)) 449 } 450 } else { 451 return func(env *Env) r.Value { 452 return convert(r.ValueOf(fun(env)), rt) 453 } 454 } 455 case func(*Env) float32: 456 if rt == nil || rt == TypeOfFloat32 { 457 return func(env *Env) r.Value { 458 return r.ValueOf(fun(env)) 459 } 460 } else { 461 return func(env *Env) r.Value { 462 return convert(r.ValueOf(fun(env)), rt) 463 } 464 } 465 case func(*Env) float64: 466 if rt == nil || rt == TypeOfFloat64 { 467 return func(env *Env) r.Value { 468 return r.ValueOf(fun(env)) 469 } 470 } else { 471 return func(env *Env) r.Value { 472 return convert(r.ValueOf(fun(env)), rt) 473 } 474 } 475 case func(*Env) complex64: 476 if rt == nil || rt == TypeOfComplex64 { 477 return func(env *Env) r.Value { 478 return r.ValueOf(fun(env)) 479 } 480 } else { 481 return func(env *Env) r.Value { 482 return convert(r.ValueOf(fun(env)), rt) 483 } 484 } 485 case func(*Env) complex128: 486 if rt == nil || rt == TypeOfComplex128 { 487 return func(env *Env) r.Value { 488 return r.ValueOf(fun(env)) 489 } 490 } else { 491 return func(env *Env) r.Value { 492 return convert(r.ValueOf(fun(env)), rt) 493 } 494 } 495 case func(*Env) string: 496 if rt == nil || rt == TypeOfString { 497 return func(env *Env) r.Value { 498 return r.ValueOf(fun(env)) 499 } 500 } else { 501 return func(env *Env) r.Value { 502 return convert(r.ValueOf(fun(env)), rt) 503 } 504 } 505 case func(*Env) *bool: 506 if rt == nil || rt == TypeOfPtrBool { 507 return func(env *Env) r.Value { 508 return r.ValueOf(fun(env)) 509 } 510 } else { 511 return func(env *Env) r.Value { 512 return convert(r.ValueOf(fun(env)), rt) 513 } 514 } 515 case func(*Env) *int: 516 if rt == nil || rt == TypeOfPtrInt { 517 return func(env *Env) r.Value { 518 return r.ValueOf(fun(env)) 519 } 520 } else { 521 return func(env *Env) r.Value { 522 return convert(r.ValueOf(fun(env)), rt) 523 } 524 } 525 case func(*Env) *int8: 526 if rt == nil || rt == TypeOfPtrInt8 { 527 return func(env *Env) r.Value { 528 return r.ValueOf(fun(env)) 529 } 530 } else { 531 return func(env *Env) r.Value { 532 return convert(r.ValueOf(fun(env)), rt) 533 } 534 } 535 case func(*Env) *int16: 536 if rt == nil || rt == TypeOfPtrInt16 { 537 return func(env *Env) r.Value { 538 return r.ValueOf(fun(env)) 539 } 540 } else { 541 return func(env *Env) r.Value { 542 return convert(r.ValueOf(fun(env)), rt) 543 } 544 } 545 case func(*Env) *int32: 546 if rt == nil || rt == TypeOfPtrInt32 { 547 return func(env *Env) r.Value { 548 return r.ValueOf(fun(env)) 549 } 550 } else { 551 return func(env *Env) r.Value { 552 return convert(r.ValueOf(fun(env)), rt) 553 } 554 } 555 case func(*Env) *int64: 556 if rt == nil || rt == TypeOfPtrInt64 { 557 return func(env *Env) r.Value { 558 return r.ValueOf(fun(env)) 559 } 560 } else { 561 return func(env *Env) r.Value { 562 return convert(r.ValueOf(fun(env)), rt) 563 } 564 } 565 case func(*Env) *uint: 566 if rt == nil || rt == TypeOfPtrUint { 567 return func(env *Env) r.Value { 568 return r.ValueOf(fun(env)) 569 } 570 } else { 571 return func(env *Env) r.Value { 572 return convert(r.ValueOf(fun(env)), rt) 573 } 574 } 575 case func(*Env) *uint8: 576 if rt == nil || rt == TypeOfPtrUint8 { 577 return func(env *Env) r.Value { 578 return r.ValueOf(fun(env)) 579 } 580 } else { 581 return func(env *Env) r.Value { 582 return convert(r.ValueOf(fun(env)), rt) 583 } 584 } 585 case func(*Env) *uint16: 586 if rt == nil || rt == TypeOfPtrUint16 { 587 return func(env *Env) r.Value { 588 return r.ValueOf(fun(env)) 589 } 590 } else { 591 return func(env *Env) r.Value { 592 return convert(r.ValueOf(fun(env)), rt) 593 } 594 } 595 case func(*Env) *uint32: 596 if rt == nil || rt == TypeOfPtrUint32 { 597 return func(env *Env) r.Value { 598 return r.ValueOf(fun(env)) 599 } 600 } else { 601 return func(env *Env) r.Value { 602 return convert(r.ValueOf(fun(env)), rt) 603 } 604 } 605 case func(*Env) *uint64: 606 if rt == nil || rt == TypeOfPtrUint64 { 607 return func(env *Env) r.Value { 608 return r.ValueOf(fun(env)) 609 } 610 } else { 611 return func(env *Env) r.Value { 612 return convert(r.ValueOf(fun(env)), rt) 613 } 614 } 615 case func(*Env) *uintptr: 616 if rt == nil || rt == TypeOfPtrUintptr { 617 return func(env *Env) r.Value { 618 return r.ValueOf(fun(env)) 619 } 620 } else { 621 return func(env *Env) r.Value { 622 return convert(r.ValueOf(fun(env)), rt) 623 } 624 } 625 case func(*Env) *float32: 626 if rt == nil || rt == TypeOfPtrFloat32 { 627 return func(env *Env) r.Value { 628 return r.ValueOf(fun(env)) 629 } 630 } else { 631 return func(env *Env) r.Value { 632 return convert(r.ValueOf(fun(env)), rt) 633 } 634 } 635 case func(*Env) *float64: 636 if rt == nil || rt == TypeOfPtrFloat64 { 637 return func(env *Env) r.Value { 638 return r.ValueOf(fun(env)) 639 } 640 } else { 641 return func(env *Env) r.Value { 642 return convert(r.ValueOf(fun(env)), rt) 643 } 644 } 645 case func(*Env) *complex64: 646 if rt == nil || rt == TypeOfPtrComplex64 { 647 return func(env *Env) r.Value { 648 return r.ValueOf(fun(env)) 649 } 650 } else { 651 return func(env *Env) r.Value { 652 return convert(r.ValueOf(fun(env)), rt) 653 } 654 } 655 default: 656 output.Errorf("unsupported expression type, cannot convert to func(*Env) r.Value: %v <%v>", fun, r.TypeOf(fun)) 657 } 658 return nil 659} 660 661func funAsXV(fun I, t xr.Type) func(*Env) (r.Value, []r.Value) { 662 // output.Debugf("funAsXV() %v -> %v", TypeOf(fun), t) 663 var rt r.Type 664 if t != nil { 665 rt = t.ReflectType() 666 } 667 switch fun := fun.(type) { 668 case nil: 669 case func(*Env): 670 if fun == nil { 671 break 672 } 673 return func(env *Env) (r.Value, []r.Value) { 674 fun(env) 675 return None, nil 676 } 677 case func(*Env) r.Value: 678 return func(env *Env) (r.Value, []r.Value) { 679 return fun(env), nil 680 } 681 case func(*Env) (r.Value, []r.Value): 682 return fun 683 case func(*Env) bool: 684 if rt == nil || rt == TypeOfBool { 685 return func(env *Env) (r.Value, []r.Value) { 686 return r.ValueOf(fun(env)), nil 687 } 688 } else { 689 return func(env *Env) (r.Value, []r.Value) { 690 return convert(r.ValueOf(fun(env)), rt), nil 691 } 692 } 693 case func(*Env) int: 694 if rt == nil || rt == TypeOfInt { 695 return func(env *Env) (r.Value, []r.Value) { 696 return r.ValueOf(fun(env)), nil 697 } 698 } else { 699 return func(env *Env) (r.Value, []r.Value) { 700 return convert(r.ValueOf(fun(env)), rt), nil 701 } 702 } 703 case func(*Env) int8: 704 if rt == nil || rt == TypeOfInt8 { 705 return func(env *Env) (r.Value, []r.Value) { 706 return r.ValueOf(fun(env)), nil 707 } 708 } else { 709 return func(env *Env) (r.Value, []r.Value) { 710 return convert(r.ValueOf(fun(env)), rt), nil 711 } 712 } 713 case func(*Env) int16: 714 if rt == nil || rt == TypeOfInt16 { 715 return func(env *Env) (r.Value, []r.Value) { 716 return r.ValueOf(fun(env)), nil 717 } 718 } else { 719 return func(env *Env) (r.Value, []r.Value) { 720 return convert(r.ValueOf(fun(env)), rt), nil 721 } 722 } 723 case func(*Env) int32: 724 if rt == nil || rt == TypeOfInt32 { 725 return func(env *Env) (r.Value, []r.Value) { 726 return r.ValueOf(fun(env)), nil 727 } 728 } else { 729 return func(env *Env) (r.Value, []r.Value) { 730 return convert(r.ValueOf(fun(env)), rt), nil 731 } 732 } 733 case func(*Env) int64: 734 if rt == nil || rt == TypeOfInt64 { 735 return func(env *Env) (r.Value, []r.Value) { 736 return r.ValueOf(fun(env)), nil 737 } 738 } else { 739 return func(env *Env) (r.Value, []r.Value) { 740 return convert(r.ValueOf(fun(env)), rt), nil 741 } 742 } 743 case func(*Env) uint: 744 if rt == nil || rt == TypeOfUint { 745 return func(env *Env) (r.Value, []r.Value) { 746 return r.ValueOf(fun(env)), nil 747 } 748 } else { 749 return func(env *Env) (r.Value, []r.Value) { 750 return convert(r.ValueOf(fun(env)), rt), nil 751 } 752 } 753 case func(*Env) uint8: 754 if rt == nil || rt == TypeOfUint8 { 755 return func(env *Env) (r.Value, []r.Value) { 756 return r.ValueOf(fun(env)), nil 757 } 758 } else { 759 return func(env *Env) (r.Value, []r.Value) { 760 return convert(r.ValueOf(fun(env)), rt), nil 761 } 762 } 763 case func(*Env) uint16: 764 if rt == nil || rt == TypeOfUint16 { 765 return func(env *Env) (r.Value, []r.Value) { 766 return r.ValueOf(fun(env)), nil 767 } 768 } else { 769 return func(env *Env) (r.Value, []r.Value) { 770 return convert(r.ValueOf(fun(env)), rt), nil 771 } 772 } 773 case func(*Env) uint32: 774 if rt == nil || rt == TypeOfUint32 { 775 return func(env *Env) (r.Value, []r.Value) { 776 return r.ValueOf(fun(env)), nil 777 } 778 } else { 779 return func(env *Env) (r.Value, []r.Value) { 780 return convert(r.ValueOf(fun(env)), rt), nil 781 } 782 } 783 case func(*Env) uint64: 784 if rt == nil || rt == TypeOfUint64 { 785 return func(env *Env) (r.Value, []r.Value) { 786 return r.ValueOf(fun(env)), nil 787 } 788 } else { 789 return func(env *Env) (r.Value, []r.Value) { 790 return convert(r.ValueOf(fun(env)), rt), nil 791 } 792 } 793 case func(*Env) uintptr: 794 if rt == nil || rt == TypeOfUintptr { 795 return func(env *Env) (r.Value, []r.Value) { 796 return r.ValueOf(fun(env)), nil 797 } 798 } else { 799 return func(env *Env) (r.Value, []r.Value) { 800 return convert(r.ValueOf(fun(env)), rt), nil 801 } 802 } 803 case func(*Env) float32: 804 if rt == nil || rt == TypeOfFloat32 { 805 return func(env *Env) (r.Value, []r.Value) { 806 return r.ValueOf(fun(env)), nil 807 } 808 } else { 809 return func(env *Env) (r.Value, []r.Value) { 810 return convert(r.ValueOf(fun(env)), rt), nil 811 } 812 } 813 case func(*Env) float64: 814 if rt == nil || rt == TypeOfFloat64 { 815 return func(env *Env) (r.Value, []r.Value) { 816 return r.ValueOf(fun(env)), nil 817 } 818 } else { 819 return func(env *Env) (r.Value, []r.Value) { 820 return convert(r.ValueOf(fun(env)), rt), nil 821 } 822 } 823 case func(*Env) complex64: 824 if rt == nil || rt == TypeOfComplex64 { 825 return func(env *Env) (r.Value, []r.Value) { 826 return r.ValueOf(fun(env)), nil 827 } 828 } else { 829 return func(env *Env) (r.Value, []r.Value) { 830 return convert(r.ValueOf(fun(env)), rt), nil 831 } 832 } 833 case func(*Env) complex128: 834 if rt == nil || rt == TypeOfComplex128 { 835 return func(env *Env) (r.Value, []r.Value) { 836 return r.ValueOf(fun(env)), nil 837 } 838 } else { 839 return func(env *Env) (r.Value, []r.Value) { 840 return convert(r.ValueOf(fun(env)), rt), nil 841 } 842 } 843 case func(*Env) string: 844 if rt == nil || rt == TypeOfString { 845 return func(env *Env) (r.Value, []r.Value) { 846 return r.ValueOf(fun(env)), nil 847 } 848 } else { 849 return func(env *Env) (r.Value, []r.Value) { 850 return convert(r.ValueOf(fun(env)), rt), nil 851 } 852 } 853 case func(*Env) *bool: 854 if rt == nil || rt == TypeOfPtrBool { 855 return func(env *Env) (r.Value, []r.Value) { 856 return r.ValueOf(fun(env)), nil 857 } 858 } else { 859 return func(env *Env) (r.Value, []r.Value) { 860 return convert(r.ValueOf(fun(env)), rt), nil 861 } 862 } 863 case func(*Env) *int: 864 if rt == nil || rt == TypeOfPtrInt { 865 return func(env *Env) (r.Value, []r.Value) { 866 return r.ValueOf(fun(env)), nil 867 } 868 } else { 869 return func(env *Env) (r.Value, []r.Value) { 870 return convert(r.ValueOf(fun(env)), rt), nil 871 } 872 } 873 case func(*Env) *int8: 874 if rt == nil || rt == TypeOfPtrInt8 { 875 return func(env *Env) (r.Value, []r.Value) { 876 return r.ValueOf(fun(env)), nil 877 } 878 } else { 879 return func(env *Env) (r.Value, []r.Value) { 880 return convert(r.ValueOf(fun(env)), rt), nil 881 } 882 } 883 case func(*Env) *int16: 884 if rt == nil || rt == TypeOfPtrInt16 { 885 return func(env *Env) (r.Value, []r.Value) { 886 return r.ValueOf(fun(env)), nil 887 } 888 } else { 889 return func(env *Env) (r.Value, []r.Value) { 890 return convert(r.ValueOf(fun(env)), rt), nil 891 } 892 } 893 case func(*Env) *int32: 894 if rt == nil || rt == TypeOfPtrInt32 { 895 return func(env *Env) (r.Value, []r.Value) { 896 return r.ValueOf(fun(env)), nil 897 } 898 } else { 899 return func(env *Env) (r.Value, []r.Value) { 900 return convert(r.ValueOf(fun(env)), rt), nil 901 } 902 } 903 case func(*Env) *int64: 904 if rt == nil || rt == TypeOfPtrInt64 { 905 return func(env *Env) (r.Value, []r.Value) { 906 return r.ValueOf(fun(env)), nil 907 } 908 } else { 909 return func(env *Env) (r.Value, []r.Value) { 910 return convert(r.ValueOf(fun(env)), rt), nil 911 } 912 } 913 case func(*Env) *uint: 914 if rt == nil || rt == TypeOfPtrUint { 915 return func(env *Env) (r.Value, []r.Value) { 916 return r.ValueOf(fun(env)), nil 917 } 918 } else { 919 return func(env *Env) (r.Value, []r.Value) { 920 return convert(r.ValueOf(fun(env)), rt), nil 921 } 922 } 923 case func(*Env) *uint8: 924 if rt == nil || rt == TypeOfPtrUint8 { 925 return func(env *Env) (r.Value, []r.Value) { 926 return r.ValueOf(fun(env)), nil 927 } 928 } else { 929 return func(env *Env) (r.Value, []r.Value) { 930 return convert(r.ValueOf(fun(env)), rt), nil 931 } 932 } 933 case func(*Env) *uint16: 934 if rt == nil || rt == TypeOfPtrUint16 { 935 return func(env *Env) (r.Value, []r.Value) { 936 return r.ValueOf(fun(env)), nil 937 } 938 } else { 939 return func(env *Env) (r.Value, []r.Value) { 940 return convert(r.ValueOf(fun(env)), rt), nil 941 } 942 } 943 case func(*Env) *uint32: 944 if rt == nil || rt == TypeOfPtrUint32 { 945 return func(env *Env) (r.Value, []r.Value) { 946 return r.ValueOf(fun(env)), nil 947 } 948 } else { 949 return func(env *Env) (r.Value, []r.Value) { 950 return convert(r.ValueOf(fun(env)), rt), nil 951 } 952 } 953 case func(*Env) *uint64: 954 if rt == nil || rt == TypeOfPtrUint64 { 955 return func(env *Env) (r.Value, []r.Value) { 956 return r.ValueOf(fun(env)), nil 957 } 958 } else { 959 return func(env *Env) (r.Value, []r.Value) { 960 return convert(r.ValueOf(fun(env)), rt), nil 961 } 962 } 963 case func(*Env) *uintptr: 964 if rt == nil || rt == TypeOfPtrUintptr { 965 return func(env *Env) (r.Value, []r.Value) { 966 return r.ValueOf(fun(env)), nil 967 } 968 } else { 969 return func(env *Env) (r.Value, []r.Value) { 970 return convert(r.ValueOf(fun(env)), rt), nil 971 } 972 } 973 case func(*Env) *float32: 974 if rt == nil || rt == TypeOfPtrFloat32 { 975 return func(env *Env) (r.Value, []r.Value) { 976 return r.ValueOf(fun(env)), nil 977 } 978 } else { 979 return func(env *Env) (r.Value, []r.Value) { 980 return convert(r.ValueOf(fun(env)), rt), nil 981 } 982 } 983 case func(*Env) *float64: 984 if rt == nil || rt == TypeOfPtrFloat64 { 985 return func(env *Env) (r.Value, []r.Value) { 986 return r.ValueOf(fun(env)), nil 987 } 988 } else { 989 return func(env *Env) (r.Value, []r.Value) { 990 return convert(r.ValueOf(fun(env)), rt), nil 991 } 992 } 993 case func(*Env) *complex64: 994 if rt == nil || rt == TypeOfPtrComplex64 { 995 return func(env *Env) (r.Value, []r.Value) { 996 return r.ValueOf(fun(env)), nil 997 } 998 } else { 999 return func(env *Env) (r.Value, []r.Value) { 1000 return convert(r.ValueOf(fun(env)), rt), nil 1001 } 1002 } 1003 default: 1004 output.Errorf("unsupported expression, cannot convert to func(*Env) (r.Value, []r.Value) : %v <%v>", 1005 fun, r.TypeOf(fun)) 1006 } 1007 return nil 1008} 1009 1010func (e *Expr) exprXVAsI() *Expr { 1011 // Debugf("exprXVAsI() %v -> %v", e.Types, e.Type) 1012 e.CheckX1() 1013 if e.NumOut() <= 1 { 1014 return e 1015 } 1016 fun := e.Fun.(func(*Env) (r.Value, []r.Value)) 1017 t := e.Type 1018 var ret I 1019 switch t.Kind() { 1020 case r.Bool: 1021 ret = func(env *Env) bool { 1022 v, _ := fun(env) 1023 return v.Bool() 1024 } 1025 case r.Int: 1026 ret = func(env *Env) int { 1027 v, _ := fun(env) 1028 return int(v.Int()) 1029 } 1030 case r.Int8: 1031 ret = func(env *Env) int8 { 1032 v, _ := fun(env) 1033 return int8(v.Int()) 1034 } 1035 case r.Int16: 1036 ret = func(env *Env) int16 { 1037 v, _ := fun(env) 1038 return int16(v.Int()) 1039 } 1040 case r.Int32: 1041 ret = func(env *Env) int32 { 1042 v, _ := fun(env) 1043 return int32(v.Int()) 1044 } 1045 case r.Int64: 1046 ret = func(env *Env) int64 { 1047 v, _ := fun(env) 1048 return v.Int() 1049 } 1050 case r.Uint: 1051 ret = func(env *Env) uint { 1052 v, _ := fun(env) 1053 return uint(v.Uint()) 1054 } 1055 case r.Uint8: 1056 ret = func(env *Env) uint8 { 1057 v, _ := fun(env) 1058 return uint8(v.Uint()) 1059 } 1060 case r.Uint16: 1061 ret = func(env *Env) uint16 { 1062 v, _ := fun(env) 1063 return uint16(v.Uint()) 1064 } 1065 case r.Uint32: 1066 ret = func(env *Env) uint32 { 1067 v, _ := fun(env) 1068 return uint32(v.Uint()) 1069 } 1070 case r.Uint64: 1071 ret = func(env *Env) uint64 { 1072 v, _ := fun(env) 1073 return v.Uint() 1074 } 1075 case r.Uintptr: 1076 ret = func(env *Env) uintptr { 1077 v, _ := fun(env) 1078 return uintptr(v.Uint()) 1079 } 1080 case r.Float32: 1081 ret = func(env *Env) float32 { 1082 v, _ := fun(env) 1083 return float32(v.Float()) 1084 } 1085 case r.Float64: 1086 ret = func(env *Env) float64 { 1087 v, _ := fun(env) 1088 return v.Float() 1089 } 1090 case r.Complex64: 1091 ret = func(env *Env) complex64 { 1092 v, _ := fun(env) 1093 return complex64(v.Complex()) 1094 } 1095 case r.Complex128: 1096 ret = func(env *Env) complex128 { 1097 v, _ := fun(env) 1098 return v.Complex() 1099 } 1100 case r.String: 1101 ret = func(env *Env) string { 1102 v, _ := fun(env) 1103 return v.String() 1104 } 1105 default: 1106 ret = func(env *Env) r.Value { 1107 v, _ := fun(env) 1108 return v 1109 } 1110 } 1111 return exprFun(t, ret) 1112} 1113 1114func (e *Expr) AsStmt(c *Comp) Stmt { 1115 if e == nil || e.Const() { 1116 return nil 1117 } 1118 if stmt := c.Jit.AsStmt(e); stmt != nil { 1119 return stmt 1120 } 1121 return funAsStmt(e.Fun) 1122} 1123 1124func funAsStmt(fun I) Stmt { 1125 var ret func(env *Env) (Stmt, *Env) 1126 1127 switch fun := fun.(type) { 1128 case nil: 1129 case func(*Env): 1130 ret = func(env *Env) (Stmt, *Env) { 1131 fun(env) 1132 env.IP++ 1133 return env.Code[env.IP], env 1134 } 1135 case func(*Env) r.Value: 1136 ret = func(env *Env) (Stmt, *Env) { 1137 fun(env) 1138 env.IP++ 1139 return env.Code[env.IP], env 1140 } 1141 case func(*Env) (r.Value, []r.Value): 1142 ret = func(env *Env) (Stmt, *Env) { 1143 fun(env) 1144 env.IP++ 1145 return env.Code[env.IP], env 1146 } 1147 case func(*Env) bool: 1148 ret = func(env *Env) (Stmt, *Env) { 1149 fun(env) 1150 env.IP++ 1151 return env.Code[env.IP], env 1152 } 1153 case func(*Env) int: 1154 ret = func(env *Env) (Stmt, *Env) { 1155 fun(env) 1156 env.IP++ 1157 return env.Code[env.IP], env 1158 } 1159 case func(*Env) int8: 1160 ret = func(env *Env) (Stmt, *Env) { 1161 fun(env) 1162 env.IP++ 1163 return env.Code[env.IP], env 1164 } 1165 case func(*Env) int16: 1166 ret = func(env *Env) (Stmt, *Env) { 1167 fun(env) 1168 env.IP++ 1169 return env.Code[env.IP], env 1170 } 1171 case func(*Env) int32: 1172 ret = func(env *Env) (Stmt, *Env) { 1173 fun(env) 1174 env.IP++ 1175 return env.Code[env.IP], env 1176 } 1177 case func(*Env) int64: 1178 ret = func(env *Env) (Stmt, *Env) { 1179 fun(env) 1180 env.IP++ 1181 return env.Code[env.IP], env 1182 } 1183 case func(*Env) uint: 1184 ret = func(env *Env) (Stmt, *Env) { 1185 fun(env) 1186 env.IP++ 1187 return env.Code[env.IP], env 1188 } 1189 case func(*Env) uint8: 1190 ret = func(env *Env) (Stmt, *Env) { 1191 fun(env) 1192 env.IP++ 1193 return env.Code[env.IP], env 1194 } 1195 case func(*Env) uint16: 1196 ret = func(env *Env) (Stmt, *Env) { 1197 fun(env) 1198 env.IP++ 1199 return env.Code[env.IP], env 1200 } 1201 case func(*Env) uint32: 1202 ret = func(env *Env) (Stmt, *Env) { 1203 fun(env) 1204 env.IP++ 1205 return env.Code[env.IP], env 1206 } 1207 case func(*Env) uint64: 1208 ret = func(env *Env) (Stmt, *Env) { 1209 fun(env) 1210 env.IP++ 1211 return env.Code[env.IP], env 1212 } 1213 case func(*Env) uintptr: 1214 ret = func(env *Env) (Stmt, *Env) { 1215 fun(env) 1216 env.IP++ 1217 return env.Code[env.IP], env 1218 } 1219 case func(*Env) float32: 1220 ret = func(env *Env) (Stmt, *Env) { 1221 fun(env) 1222 env.IP++ 1223 return env.Code[env.IP], env 1224 } 1225 case func(*Env) float64: 1226 ret = func(env *Env) (Stmt, *Env) { 1227 fun(env) 1228 env.IP++ 1229 return env.Code[env.IP], env 1230 } 1231 case func(*Env) complex64: 1232 ret = func(env *Env) (Stmt, *Env) { 1233 fun(env) 1234 env.IP++ 1235 return env.Code[env.IP], env 1236 } 1237 case func(*Env) complex128: 1238 ret = func(env *Env) (Stmt, *Env) { 1239 fun(env) 1240 env.IP++ 1241 return env.Code[env.IP], env 1242 } 1243 case func(*Env) string: 1244 ret = func(env *Env) (Stmt, *Env) { 1245 fun(env) 1246 env.IP++ 1247 return env.Code[env.IP], env 1248 } 1249 default: 1250 1251 output.Errorf("unsupported expression type, cannot convert to Stmt : %v <%v>", 1252 fun, r.TypeOf(fun)) 1253 } 1254 return ret 1255} 1256 1257// funTypeOut returns the first return type of given function 1258func funTypeOut(fun I) r.Type { 1259 rt := r.TypeOf(fun) 1260 if rt == nil || rt.Kind() != r.Func || rt.NumOut() == 0 { 1261 return nil 1262 } 1263 return rt.Out(0) 1264} 1265 1266// funTypeOuts returns the return types of given function 1267func funTypeOuts(fun I) []r.Type { 1268 rt := r.TypeOf(fun) 1269 if rt == nil || rt.Kind() != r.Func { 1270 return []r.Type{rt} 1271 } 1272 n := rt.NumOut() 1273 rts := make([]r.Type, n) 1274 for i := 0; i < n; i++ { 1275 rts[i] = rt.Out(i) 1276 } 1277 return rts 1278} 1279 1280// exprList merges together a list of expressions, 1281// and returns an expression that evaluates each one 1282func exprList(list []*Expr, opts CompileOptions) *Expr { 1283 // skip constant expressions (except the last one) 1284 var n int 1285 for i, ni := 0, len(list)-1; i <= ni; i++ { 1286 // preserve the last expression even if constant 1287 // because it will be returned to the user 1288 if i == ni || !list[i].Const() { 1289 list[n] = list[i] 1290 n++ 1291 } 1292 } 1293 switch n { 1294 case 0: 1295 return nil 1296 case 1: 1297 return list[0] 1298 } 1299 list = list[:n] 1300 1301 funs := make([]func(*Env), n-1) 1302 for i := range funs { 1303 funs[i] = list[i].AsX() 1304 } 1305 return &Expr{ 1306 Lit: Lit{Type: list[n-1].Type}, 1307 Types: list[n-1].Types, 1308 Fun: funList(funs, list[n-1], opts), 1309 } 1310} 1311 1312// funList merges together a list of functions, 1313// and returns a function that evaluates each one 1314func funList(funs []func(*Env), last *Expr, opts CompileOptions) I { 1315 var rt r.Type 1316 if last.Type != nil { 1317 // keep untyped constants only if requested 1318 if opts != COptKeepUntyped && last.Untyped() { 1319 last.ConstTo(last.DefaultType()) 1320 } 1321 rt = last.Type.ReflectType() 1322 } 1323 switch fun := last.WithFun().(type) { 1324 case nil: 1325 return func(env *Env) { 1326 for _, f := range funs { 1327 f(env) 1328 } 1329 } 1330 case func(*Env): 1331 return func(env *Env) { 1332 for _, f := range funs { 1333 f(env) 1334 } 1335 fun(env) 1336 } 1337 case func(*Env) r.Value: 1338 return func(env *Env) r.Value { 1339 for _, f := range funs { 1340 f(env) 1341 } 1342 return fun(env) 1343 } 1344 case func(*Env) (r.Value, []r.Value): 1345 return func(env *Env) (r.Value, []r.Value) { 1346 for _, f := range funs { 1347 f(env) 1348 } 1349 return fun(env) 1350 } 1351 case func(*Env) bool: 1352 if rt == nil || rt == TypeOfBool { 1353 return func(env *Env) bool { 1354 for _, f := range funs { 1355 f(env) 1356 } 1357 return fun(env) 1358 } 1359 } else { 1360 return func(env *Env) r.Value { 1361 for _, f := range funs { 1362 f(env) 1363 } 1364 return convert(r.ValueOf(fun(env)), rt) 1365 } 1366 } 1367 case func(*Env) int: 1368 if rt == nil || rt == TypeOfInt { 1369 return func(env *Env) int { 1370 for _, f := range funs { 1371 f(env) 1372 } 1373 return fun(env) 1374 } 1375 } else { 1376 return func(env *Env) r.Value { 1377 for _, f := range funs { 1378 f(env) 1379 } 1380 return convert(r.ValueOf(fun(env)), rt) 1381 } 1382 } 1383 case func(*Env) int8: 1384 if rt == nil || rt == TypeOfInt8 { 1385 return func(env *Env) int8 { 1386 for _, f := range funs { 1387 f(env) 1388 } 1389 return fun(env) 1390 } 1391 } else { 1392 return func(env *Env) r.Value { 1393 for _, f := range funs { 1394 f(env) 1395 } 1396 return convert(r.ValueOf(fun(env)), rt) 1397 } 1398 } 1399 case func(*Env) int16: 1400 if rt == nil || rt == TypeOfInt16 { 1401 return func(env *Env) int16 { 1402 for _, f := range funs { 1403 f(env) 1404 } 1405 return fun(env) 1406 } 1407 } else { 1408 return func(env *Env) r.Value { 1409 for _, f := range funs { 1410 f(env) 1411 } 1412 return convert(r.ValueOf(fun(env)), rt) 1413 } 1414 } 1415 case func(*Env) int32: 1416 if rt == nil || rt == TypeOfInt32 { 1417 return func(env *Env) int32 { 1418 for _, f := range funs { 1419 f(env) 1420 } 1421 return fun(env) 1422 } 1423 } else { 1424 return func(env *Env) r.Value { 1425 for _, f := range funs { 1426 f(env) 1427 } 1428 return convert(r.ValueOf(fun(env)), rt) 1429 } 1430 } 1431 case func(*Env) int64: 1432 if rt == nil || rt == TypeOfInt64 { 1433 return func(env *Env) int64 { 1434 for _, f := range funs { 1435 f(env) 1436 } 1437 return fun(env) 1438 } 1439 } else { 1440 return func(env *Env) r.Value { 1441 for _, f := range funs { 1442 f(env) 1443 } 1444 return convert(r.ValueOf(fun(env)), rt) 1445 } 1446 } 1447 case func(*Env) uint: 1448 if rt == nil || rt == TypeOfUint { 1449 return func(env *Env) uint { 1450 for _, f := range funs { 1451 f(env) 1452 } 1453 return fun(env) 1454 } 1455 } else { 1456 return func(env *Env) r.Value { 1457 for _, f := range funs { 1458 f(env) 1459 } 1460 return convert(r.ValueOf(fun(env)), rt) 1461 } 1462 } 1463 case func(*Env) uint8: 1464 if rt == nil || rt == TypeOfUint8 { 1465 return func(env *Env) uint8 { 1466 for _, f := range funs { 1467 f(env) 1468 } 1469 return fun(env) 1470 } 1471 } else { 1472 return func(env *Env) r.Value { 1473 for _, f := range funs { 1474 f(env) 1475 } 1476 return convert(r.ValueOf(fun(env)), rt) 1477 } 1478 } 1479 case func(*Env) uint16: 1480 if rt == nil || rt == TypeOfUint16 { 1481 return func(env *Env) uint16 { 1482 for _, f := range funs { 1483 f(env) 1484 } 1485 return fun(env) 1486 } 1487 } else { 1488 return func(env *Env) r.Value { 1489 for _, f := range funs { 1490 f(env) 1491 } 1492 return convert(r.ValueOf(fun(env)), rt) 1493 } 1494 } 1495 case func(*Env) uint32: 1496 if rt == nil || rt == TypeOfUint32 { 1497 return func(env *Env) uint32 { 1498 for _, f := range funs { 1499 f(env) 1500 } 1501 return fun(env) 1502 } 1503 } else { 1504 return func(env *Env) r.Value { 1505 for _, f := range funs { 1506 f(env) 1507 } 1508 return convert(r.ValueOf(fun(env)), rt) 1509 } 1510 } 1511 case func(*Env) uint64: 1512 if rt == nil || rt == TypeOfUint64 { 1513 return func(env *Env) uint64 { 1514 for _, f := range funs { 1515 f(env) 1516 } 1517 return fun(env) 1518 } 1519 } else { 1520 return func(env *Env) r.Value { 1521 for _, f := range funs { 1522 f(env) 1523 } 1524 return convert(r.ValueOf(fun(env)), rt) 1525 } 1526 } 1527 case func(*Env) uintptr: 1528 if rt == nil || rt == TypeOfUintptr { 1529 return func(env *Env) uintptr { 1530 for _, f := range funs { 1531 f(env) 1532 } 1533 return fun(env) 1534 } 1535 } else { 1536 return func(env *Env) r.Value { 1537 for _, f := range funs { 1538 f(env) 1539 } 1540 return convert(r.ValueOf(fun(env)), rt) 1541 } 1542 } 1543 case func(*Env) float32: 1544 if rt == nil || rt == TypeOfFloat32 { 1545 return func(env *Env) float32 { 1546 for _, f := range funs { 1547 f(env) 1548 } 1549 return fun(env) 1550 } 1551 } else { 1552 return func(env *Env) r.Value { 1553 for _, f := range funs { 1554 f(env) 1555 } 1556 return convert(r.ValueOf(fun(env)), rt) 1557 } 1558 } 1559 case func(*Env) float64: 1560 if rt == nil || rt == TypeOfFloat64 { 1561 return func(env *Env) float64 { 1562 for _, f := range funs { 1563 f(env) 1564 } 1565 return fun(env) 1566 } 1567 } else { 1568 return func(env *Env) r.Value { 1569 for _, f := range funs { 1570 f(env) 1571 } 1572 return convert(r.ValueOf(fun(env)), rt) 1573 } 1574 } 1575 case func(*Env) complex64: 1576 if rt == nil || rt == TypeOfComplex64 { 1577 return func(env *Env) complex64 { 1578 for _, f := range funs { 1579 f(env) 1580 } 1581 return fun(env) 1582 } 1583 } else { 1584 return func(env *Env) r.Value { 1585 for _, f := range funs { 1586 f(env) 1587 } 1588 return convert(r.ValueOf(fun(env)), rt) 1589 } 1590 } 1591 case func(*Env) complex128: 1592 if rt == nil || rt == TypeOfComplex128 { 1593 return func(env *Env) complex128 { 1594 for _, f := range funs { 1595 f(env) 1596 } 1597 return fun(env) 1598 } 1599 } else { 1600 return func(env *Env) r.Value { 1601 for _, f := range funs { 1602 f(env) 1603 } 1604 return convert(r.ValueOf(fun(env)), rt) 1605 } 1606 } 1607 case func(*Env) string: 1608 if rt == nil || rt == TypeOfString { 1609 return func(env *Env) string { 1610 for _, f := range funs { 1611 f(env) 1612 } 1613 return fun(env) 1614 } 1615 } else { 1616 return func(env *Env) r.Value { 1617 for _, f := range funs { 1618 f(env) 1619 } 1620 return convert(r.ValueOf(fun(env)), rt) 1621 } 1622 } 1623 default: 1624 switch last.NumOut() { 1625 case 0: 1626 fun := last.AsX() 1627 return func(env *Env) { 1628 for _, f := range funs { 1629 f(env) 1630 } 1631 fun(env) 1632 } 1633 case 1: 1634 var zero r.Value 1635 if rt != nil { 1636 zero = r.Zero(rt) 1637 } 1638 fun := last.AsX1() 1639 return func(env *Env) r.Value { 1640 for _, f := range funs { 1641 f(env) 1642 } 1643 ret := fun(env) 1644 if ret == Nil { 1645 ret = zero 1646 } else if rt != nil && rt != ret.Type() { 1647 ret = convert(ret, rt) 1648 } 1649 return ret 1650 } 1651 default: 1652 var zero []r.Value 1653 var rt []r.Type 1654 for i, t := range last.Types { 1655 if t != nil { 1656 rt[i] = t.ReflectType() 1657 zero[i] = r.Zero(rt[i]) 1658 } 1659 } 1660 fun := last.AsXV(opts) 1661 return func(env *Env) (r.Value, []r.Value) { 1662 for _, f := range funs { 1663 f(env) 1664 } 1665 _, rets := fun(env) 1666 for i, ret := range rets { 1667 if ret == Nil { 1668 rets[i] = zero[i] 1669 } else if rt != nil && rt[i] != ret.Type() { 1670 rets[i] = convert(ret, rt[i]) 1671 } 1672 } 1673 return rets[0], rets 1674 } 1675 } 1676 } 1677} 1678 1679// unwrapBind compiles a conversion from a "mis-typed" bind stored in env.Binds[] as reflect.Value 1680// into a correctly-typed expression 1681func unwrapBind(bind *Bind, t xr.Type) *Expr { 1682 idx := bind.Desc.Index() 1683 var ret I 1684 switch t.Kind() { 1685 case r.Bool: 1686 ret = func(env *Env) bool { 1687 return env.Vals[idx].Bool() 1688 } 1689 case r.Int: 1690 ret = func(env *Env) int { 1691 return int(env.Vals[idx].Int()) 1692 } 1693 case r.Int8: 1694 ret = func(env *Env) int8 { 1695 return int8(env.Vals[idx].Int()) 1696 } 1697 case r.Int16: 1698 ret = func(env *Env) int16 { 1699 return int16(env.Vals[idx].Int()) 1700 } 1701 case r.Int32: 1702 ret = func(env *Env) int32 { 1703 return int32(env.Vals[idx].Int()) 1704 } 1705 case r.Int64: 1706 ret = func(env *Env) int64 { 1707 return env.Vals[idx].Int() 1708 } 1709 case r.Uint: 1710 ret = func(env *Env) uint { 1711 return uint(env.Vals[idx].Uint()) 1712 } 1713 case r.Uint8: 1714 ret = func(env *Env) uint8 { 1715 return uint8(env.Vals[idx].Uint()) 1716 } 1717 case r.Uint16: 1718 ret = func(env *Env) uint16 { 1719 return uint16(env.Vals[idx].Uint()) 1720 } 1721 case r.Uint32: 1722 ret = func(env *Env) uint32 { 1723 return uint32(env.Vals[idx].Uint()) 1724 } 1725 case r.Uint64: 1726 ret = func(env *Env) uint64 { 1727 return env.Vals[idx].Uint() 1728 } 1729 case r.Uintptr: 1730 ret = func(env *Env) uintptr { 1731 return uintptr(env.Vals[idx].Uint()) 1732 } 1733 case r.Float32: 1734 ret = func(env *Env) float32 { 1735 return float32(env.Vals[idx].Float()) 1736 } 1737 case r.Float64: 1738 ret = func(env *Env) float64 { 1739 return env.Vals[idx].Float() 1740 } 1741 case r.Complex64: 1742 ret = func(env *Env) complex64 { 1743 return complex64(env.Vals[idx].Complex()) 1744 } 1745 case r.Complex128: 1746 ret = func(env *Env) complex128 { 1747 return env.Vals[idx].Complex() 1748 } 1749 case r.String: 1750 ret = func(env *Env) string { 1751 return env.Vals[idx].String() 1752 } 1753 default: 1754 rtype := t.ReflectType() 1755 zero := r.Zero(rtype) 1756 ret = func(env *Env) r.Value { 1757 v := env.Vals[idx] 1758 if !v.IsValid() { 1759 v = zero 1760 } else if v.Type() != rtype { 1761 v = convert(v, rtype) 1762 } 1763 return v 1764 } 1765 } 1766 return exprFun(t, ret) 1767} 1768 1769// unwrapBindUp1 compiles a conversion from a "mis-typed" bind stored in env.Outer.Binds[] as reflect.Value 1770// into a correctly-typed expression 1771func unwrapBindUp1(bind *Bind, t xr.Type) *Expr { 1772 idx := bind.Desc.Index() 1773 var ret I 1774 switch t.Kind() { 1775 case r.Bool: 1776 ret = func(env *Env) bool { 1777 return env.Outer.Vals[idx].Bool() 1778 } 1779 case r.Int: 1780 ret = func(env *Env) int { 1781 return int(env.Outer.Vals[idx].Int()) 1782 } 1783 case r.Int8: 1784 ret = func(env *Env) int8 { 1785 return int8(env.Outer.Vals[idx].Int()) 1786 } 1787 case r.Int16: 1788 ret = func(env *Env) int16 { 1789 return int16(env.Outer.Vals[idx].Int()) 1790 } 1791 case r.Int32: 1792 ret = func(env *Env) int32 { 1793 return int32(env.Outer.Vals[idx].Int()) 1794 } 1795 case r.Int64: 1796 ret = func(env *Env) int64 { 1797 return env.Outer.Vals[idx].Int() 1798 } 1799 case r.Uint: 1800 ret = func(env *Env) uint { 1801 return uint(env.Outer.Vals[idx].Uint()) 1802 } 1803 case r.Uint8: 1804 ret = func(env *Env) uint8 { 1805 return uint8(env.Outer.Vals[idx].Uint()) 1806 } 1807 case r.Uint16: 1808 ret = func(env *Env) uint16 { 1809 return uint16(env.Outer.Vals[idx].Uint()) 1810 } 1811 case r.Uint32: 1812 ret = func(env *Env) uint32 { 1813 return uint32(env.Outer.Vals[idx].Uint()) 1814 } 1815 case r.Uint64: 1816 ret = func(env *Env) uint64 { 1817 return env.Outer.Vals[idx].Uint() 1818 } 1819 case r.Uintptr: 1820 ret = func(env *Env) uintptr { 1821 return uintptr(env.Outer.Vals[idx].Uint()) 1822 } 1823 case r.Float32: 1824 ret = func(env *Env) float32 { 1825 return float32(env.Outer.Vals[idx].Float()) 1826 } 1827 case r.Float64: 1828 ret = func(env *Env) float64 { 1829 return env.Outer.Vals[idx].Float() 1830 } 1831 case r.Complex64: 1832 ret = func(env *Env) complex64 { 1833 return complex64(env.Outer.Vals[idx].Complex()) 1834 } 1835 case r.Complex128: 1836 ret = func(env *Env) complex128 { 1837 return env.Outer.Vals[idx].Complex() 1838 } 1839 case r.String: 1840 ret = func(env *Env) string { 1841 return env.Outer.Vals[idx].String() 1842 } 1843 default: 1844 rtype := t.ReflectType() 1845 zero := r.Zero(rtype) 1846 ret = func(env *Env) r.Value { 1847 v := env.Outer.Vals[idx] 1848 if !v.IsValid() { 1849 v = zero 1850 } else if v.Type() != rtype { 1851 v = convert(v, rtype) 1852 } 1853 return v 1854 } 1855 } 1856 return exprFun(t, ret) 1857} 1858