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 * channel.go 17 * 18 * Created on May 01, 2017 19 * Author Massimiliano Ghilardi 20 */ 21 22package fast 23 24import ( 25 "go/ast" 26 r "reflect" 27 28 . "github.com/cosmos72/gomacro/base" 29 "github.com/cosmos72/gomacro/base/reflect" 30 xr "github.com/cosmos72/gomacro/xreflect" 31) 32 33func (c *Comp) Recv(node *ast.UnaryExpr, xe *Expr) *Expr { 34 t := xe.Type 35 if t.Kind() != r.Chan { 36 return c.badUnaryExpr("expecting channel, found", node, xe) 37 } 38 39 if t.ChanDir()&r.RecvDir == 0 { 40 return c.badUnaryExpr("cannot receive from send-only channel", node, xe) 41 } 42 43 var fun func(env *Env) (r.Value, []r.Value) 44 switch x := xe.Fun.(type) { 45 case func(env *Env) (r.Value, []r.Value): 46 channelfun := x 47 fun = func(env *Env) (r.Value, []r.Value) { 48 channel, _ := channelfun(env) 49 retv, ok := channel.Recv() 50 var okv r.Value 51 if ok { 52 okv = True 53 } else { 54 okv = False 55 } 56 return retv, []r.Value{retv, okv} 57 } 58 default: 59 channelfun := xe.AsX1() 60 fun = func(env *Env) (r.Value, []r.Value) { 61 retv, ok := channelfun(env).Recv() 62 var okv r.Value 63 if ok { 64 okv = True 65 } else { 66 okv = False 67 } 68 return retv, []r.Value{retv, okv} 69 } 70 } 71 types := []xr.Type{t.Elem(), c.TypeOfBool()} 72 return exprXV(types, fun) 73} 74func (c *Comp) Recv1(node *ast.UnaryExpr, xe *Expr) *Expr { 75 t := xe.Type 76 if t.Kind() != r.Chan { 77 return c.badUnaryExpr("expecting channel, found", node, xe) 78 } 79 80 if t.ChanDir()&r.RecvDir == 0 { 81 return c.badUnaryExpr("cannot receive from send-only channel", node, xe) 82 } 83 84 telem := t.Elem() 85 var fun I 86 switch x := xe.Fun.(type) { 87 case func(env *Env) (r.Value, []r.Value): 88 channelfun := x 89 switch telem.Kind() { 90 case r.Bool: 91 fun = func(env *Env) bool { 92 channel, _ := channelfun(env) 93 retv, _ := channel.Recv() 94 return retv.Bool() 95 } 96 case r.Int: 97 fun = func(env *Env) int { 98 channel, _ := channelfun(env) 99 retv, _ := channel.Recv() 100 return int(retv.Int()) 101 } 102 case r.Int8: 103 fun = func(env *Env) int8 { 104 channel, _ := channelfun(env) 105 retv, _ := channel.Recv() 106 return int8(retv.Int()) 107 } 108 case r.Int16: 109 fun = func(env *Env) int16 { 110 channel, _ := channelfun(env) 111 retv, _ := channel.Recv() 112 return int16(retv.Int()) 113 } 114 case r.Int32: 115 fun = func(env *Env) int32 { 116 channel, _ := channelfun(env) 117 retv, _ := channel.Recv() 118 return int32(retv.Int()) 119 } 120 case r.Int64: 121 fun = func(env *Env) int64 { 122 channel, _ := channelfun(env) 123 retv, _ := channel.Recv() 124 return retv.Int() 125 } 126 case r.Uint: 127 fun = func(env *Env) uint { 128 channel, _ := channelfun(env) 129 retv, _ := channel.Recv() 130 return uint(retv.Uint()) 131 } 132 case r.Uint8: 133 fun = func(env *Env) uint8 { 134 channel, _ := channelfun(env) 135 retv, _ := channel.Recv() 136 return uint8(retv.Uint()) 137 } 138 case r.Uint16: 139 fun = func(env *Env) uint16 { 140 channel, _ := channelfun(env) 141 retv, _ := channel.Recv() 142 return uint16(retv.Uint()) 143 } 144 case r.Uint32: 145 fun = func(env *Env) uint32 { 146 channel, _ := channelfun(env) 147 retv, _ := channel.Recv() 148 return uint32(retv.Uint()) 149 } 150 case r.Uint64: 151 fun = func(env *Env) uint64 { 152 channel, _ := channelfun(env) 153 retv, _ := channel.Recv() 154 return retv.Uint() 155 } 156 case r.Uintptr: 157 fun = func(env *Env) uintptr { 158 channel, _ := channelfun(env) 159 retv, _ := channel.Recv() 160 return uintptr(retv.Uint()) 161 } 162 case r.Float32: 163 fun = func(env *Env) float32 { 164 channel, _ := channelfun(env) 165 retv, _ := channel.Recv() 166 return float32(retv.Float()) 167 } 168 case r.Float64: 169 fun = func(env *Env) float64 { 170 channel, _ := channelfun(env) 171 retv, _ := channel.Recv() 172 return retv.Float() 173 } 174 case r.Complex64: 175 fun = func(env *Env) complex64 { 176 channel, _ := channelfun(env) 177 retv, _ := channel.Recv() 178 return complex64(retv.Complex()) 179 } 180 case r.Complex128: 181 fun = func(env *Env) complex128 { 182 channel, _ := channelfun(env) 183 retv, _ := channel.Recv() 184 return retv.Complex() 185 } 186 case r.String: 187 fun = func(env *Env) string { 188 channel, _ := channelfun(env) 189 retv, _ := channel.Recv() 190 return retv.String() 191 } 192 default: 193 fun = func(env *Env) r.Value { 194 channel, _ := channelfun(env) 195 retv, _ := channel.Recv() 196 return retv 197 } 198 199 } 200 default: 201 recvonly := t.ChanDir() == r.RecvDir 202 channelfun := xe.AsX1() 203 switch telem.Kind() { 204 case r.Bool: 205 if telem.ReflectType() != reflect.KindToType(r.Bool, 206 ) { 207 fun = func(env *Env) bool { 208 retv, _ := channelfun(env).Recv() 209 return retv.Bool() 210 } 211 } else if recvonly { 212 fun = func(env *Env) bool { 213 channel := channelfun(env).Interface().(<-chan bool) 214 return <-channel 215 } 216 } else { 217 fun = func(env *Env) bool { 218 channel := channelfun(env).Interface().(chan bool) 219 return <-channel 220 } 221 } 222 case r.Int: 223 if telem.ReflectType() != reflect.KindToType(r.Int, 224 ) { 225 fun = func(env *Env) int { 226 retv, _ := channelfun(env).Recv() 227 return int(retv.Int()) 228 } 229 } else if recvonly { 230 fun = func(env *Env) int { 231 channel := channelfun(env).Interface().(<-chan int) 232 return <-channel 233 } 234 } else { 235 fun = func(env *Env) int { 236 channel := channelfun(env).Interface().(chan int) 237 return <-channel 238 } 239 } 240 case r.Int8: 241 if telem.ReflectType() != reflect.KindToType(r.Int8, 242 ) { 243 fun = func(env *Env) int8 { 244 retv, _ := channelfun(env).Recv() 245 return int8(retv.Int()) 246 } 247 } else if recvonly { 248 fun = func(env *Env) int8 { 249 channel := channelfun(env).Interface().(<-chan int8) 250 return <-channel 251 } 252 } else { 253 fun = func(env *Env) int8 { 254 channel := channelfun(env).Interface().(chan int8) 255 return <-channel 256 } 257 } 258 case r.Int16: 259 if telem.ReflectType() != reflect.KindToType(r.Int16, 260 ) { 261 fun = func(env *Env) int16 { 262 retv, _ := channelfun(env).Recv() 263 return int16(retv.Int()) 264 } 265 } else if recvonly { 266 fun = func(env *Env) int16 { 267 channel := channelfun(env).Interface().(<-chan int16) 268 return <-channel 269 } 270 } else { 271 fun = func(env *Env) int16 { 272 channel := channelfun(env).Interface().(chan int16) 273 return <-channel 274 } 275 } 276 case r.Int32: 277 if telem.ReflectType() != reflect.KindToType(r.Int32, 278 ) { 279 fun = func(env *Env) int32 { 280 retv, _ := channelfun(env).Recv() 281 return int32(retv.Int()) 282 } 283 } else if recvonly { 284 fun = func(env *Env) int32 { 285 channel := channelfun(env).Interface().(<-chan int32) 286 return <-channel 287 } 288 } else { 289 fun = func(env *Env) int32 { 290 channel := channelfun(env).Interface().(chan int32) 291 return <-channel 292 } 293 } 294 case r.Int64: 295 if telem.ReflectType() != reflect.KindToType(r.Int64, 296 ) { 297 fun = func(env *Env) int64 { 298 retv, _ := channelfun(env).Recv() 299 return retv.Int() 300 } 301 } else if recvonly { 302 fun = func(env *Env) int64 { 303 channel := channelfun(env).Interface().(<-chan int64) 304 return <-channel 305 } 306 } else { 307 fun = func(env *Env) int64 { 308 channel := channelfun(env).Interface().(chan int64) 309 return <-channel 310 } 311 } 312 case r.Uint: 313 if telem.ReflectType() != reflect.KindToType(r.Uint, 314 ) { 315 fun = func(env *Env) uint { 316 retv, _ := channelfun(env).Recv() 317 return uint(retv.Uint()) 318 } 319 } else if recvonly { 320 fun = func(env *Env) uint { 321 channel := channelfun(env).Interface().(<-chan uint) 322 return <-channel 323 } 324 } else { 325 fun = func(env *Env) uint { 326 channel := channelfun(env).Interface().(chan uint) 327 return <-channel 328 } 329 } 330 case r.Uint8: 331 if telem.ReflectType() != reflect.KindToType(r.Uint8, 332 ) { 333 fun = func(env *Env) uint8 { 334 retv, _ := channelfun(env).Recv() 335 return uint8(retv.Uint()) 336 } 337 } else if recvonly { 338 fun = func(env *Env) uint8 { 339 channel := channelfun(env).Interface().(<-chan uint8) 340 return <-channel 341 } 342 } else { 343 fun = func(env *Env) uint8 { 344 channel := channelfun(env).Interface().(chan uint8) 345 return <-channel 346 } 347 } 348 case r.Uint16: 349 if telem.ReflectType() != reflect.KindToType(r.Uint16, 350 ) { 351 fun = func(env *Env) uint16 { 352 retv, _ := channelfun(env).Recv() 353 return uint16(retv.Uint()) 354 } 355 } else if recvonly { 356 fun = func(env *Env) uint16 { 357 channel := channelfun(env).Interface().(<-chan uint16) 358 return <-channel 359 } 360 } else { 361 fun = func(env *Env) uint16 { 362 channel := channelfun(env).Interface().(chan uint16) 363 return <-channel 364 } 365 } 366 case r.Uint32: 367 if telem.ReflectType() != reflect.KindToType(r.Uint32, 368 ) { 369 fun = func(env *Env) uint32 { 370 retv, _ := channelfun(env).Recv() 371 return uint32(retv.Uint()) 372 } 373 } else if recvonly { 374 fun = func(env *Env) uint32 { 375 channel := channelfun(env).Interface().(<-chan uint32) 376 return <-channel 377 } 378 } else { 379 fun = func(env *Env) uint32 { 380 channel := channelfun(env).Interface().(chan uint32) 381 return <-channel 382 } 383 } 384 case r.Uint64: 385 if telem.ReflectType() != reflect.KindToType(r.Uint64, 386 ) { 387 fun = func(env *Env) uint64 { 388 retv, _ := channelfun(env).Recv() 389 return retv.Uint() 390 } 391 } else if recvonly { 392 fun = func(env *Env) uint64 { 393 channel := channelfun(env).Interface().(<-chan uint64) 394 return <-channel 395 } 396 } else { 397 fun = func(env *Env) uint64 { 398 channel := channelfun(env).Interface().(chan uint64) 399 return <-channel 400 } 401 } 402 case r.Uintptr: 403 if telem.ReflectType() != reflect.KindToType(r.Uintptr, 404 ) { 405 fun = func(env *Env) uintptr { 406 retv, _ := channelfun(env).Recv() 407 return uintptr(retv.Uint()) 408 } 409 } else if recvonly { 410 fun = func(env *Env) uintptr { 411 channel := channelfun(env).Interface().(<-chan uintptr) 412 return <-channel 413 } 414 } else { 415 fun = func(env *Env) uintptr { 416 channel := channelfun(env).Interface().(chan uintptr) 417 return <-channel 418 } 419 } 420 case r.Float32: 421 if telem.ReflectType() != reflect.KindToType(r.Float32, 422 ) { 423 fun = func(env *Env) float32 { 424 retv, _ := channelfun(env).Recv() 425 return float32(retv.Float()) 426 } 427 } else if recvonly { 428 fun = func(env *Env) float32 { 429 channel := channelfun(env).Interface().(<-chan float32) 430 return <-channel 431 } 432 } else { 433 fun = func(env *Env) float32 { 434 channel := channelfun(env).Interface().(chan float32) 435 return <-channel 436 } 437 } 438 case r.Float64: 439 if telem.ReflectType() != reflect.KindToType(r.Float64, 440 ) { 441 fun = func(env *Env) float64 { 442 retv, _ := channelfun(env).Recv() 443 return retv.Float() 444 } 445 } else if recvonly { 446 fun = func(env *Env) float64 { 447 channel := channelfun(env).Interface().(<-chan float64) 448 return <-channel 449 } 450 } else { 451 fun = func(env *Env) float64 { 452 channel := channelfun(env).Interface().(chan float64) 453 return <-channel 454 } 455 } 456 case r.Complex64: 457 if telem.ReflectType() != reflect.KindToType(r.Complex64, 458 ) { 459 fun = func(env *Env) complex64 { 460 retv, _ := channelfun(env).Recv() 461 return complex64(retv.Complex()) 462 } 463 } else if recvonly { 464 fun = func(env *Env) complex64 { 465 channel := channelfun(env).Interface().(<-chan complex64) 466 return <-channel 467 } 468 } else { 469 fun = func(env *Env) complex64 { 470 channel := channelfun(env).Interface().(chan complex64) 471 return <-channel 472 } 473 } 474 case r.Complex128: 475 if telem.ReflectType() != reflect.KindToType(r.Complex128, 476 ) { 477 fun = func(env *Env) complex128 { 478 retv, _ := channelfun(env).Recv() 479 return retv.Complex() 480 } 481 } else if recvonly { 482 fun = func(env *Env) complex128 { 483 channel := channelfun(env).Interface().(<-chan complex128) 484 return <-channel 485 } 486 } else { 487 fun = func(env *Env) complex128 { 488 channel := channelfun(env).Interface().(chan complex128) 489 return <-channel 490 } 491 } 492 case r.String: 493 if telem.ReflectType() != reflect.KindToType(r.String, 494 ) { 495 fun = func(env *Env) string { 496 retv, _ := channelfun(env).Recv() 497 return retv.String() 498 } 499 } else if recvonly { 500 fun = func(env *Env) string { 501 channel := channelfun(env).Interface().(<-chan string) 502 return <-channel 503 } 504 } else { 505 fun = func(env *Env) string { 506 channel := channelfun(env).Interface().(chan string) 507 return <-channel 508 } 509 } 510 default: 511 fun = func(env *Env) r.Value { 512 retv, _ := channelfun(env).Recv() 513 return retv 514 } 515 516 } 517 } 518 return exprFun(telem, fun) 519} 520func (c *Comp) Send(node *ast.SendStmt) { 521 channel := c.Expr1(node.Chan, nil) 522 t := channel.Type 523 if t.Kind() != r.Chan { 524 c.Errorf("cannot send to non-channel type %v: %v", t, node) 525 return 526 } 527 if t.ChanDir()&r.SendDir == 0 { 528 c.Errorf("cannot send to receive-only channel type %v: %v", t, node) 529 return 530 } 531 telem := t.Elem() 532 rtelem := telem.ReflectType() 533 kelem := rtelem.Kind() 534 expr := c.Expr1(node.Value, nil) 535 if expr.Const() { 536 expr.ConstTo(telem) 537 } else if expr.Type == nil || !expr.Type.AssignableTo(telem) { 538 c.Errorf("cannot use %v <%v> as type %v in send", node.Value, expr.Type, telem) 539 return 540 } else { 541 expr.To(c, telem) 542 } 543 544 channelfun := channel.AsX1() 545 sendonly := t.ChanDir() == r.SendDir 546 var stmt Stmt 547 if expr.Const() { 548 v := r.ValueOf(expr.Value) 549 if reflect.KindToType(kelem) == rtelem { 550 switch kelem { 551 case 552 553 r.Bool: 554 value := v.Bool() 555 if sendonly { 556 stmt = func(env *Env) (Stmt, *Env) { 557 channel := channelfun(env).Interface().(chan<- bool) 558 channel <- value 559 env.IP++ 560 return env.Code[env.IP], env 561 } 562 } else { 563 stmt = func(env *Env) (Stmt, *Env) { 564 channel := channelfun(env).Interface().(chan bool) 565 channel <- value 566 env.IP++ 567 return env.Code[env.IP], env 568 } 569 } 570 case 571 572 r.Int: 573 value := 574 575 int(v.Int()) 576 if sendonly { 577 stmt = func(env *Env) (Stmt, *Env) { 578 channel := channelfun(env).Interface().(chan<- int) 579 channel <- value 580 env.IP++ 581 return env.Code[env.IP], env 582 } 583 } else { 584 stmt = func(env *Env) (Stmt, *Env) { 585 channel := channelfun(env).Interface().(chan int) 586 channel <- value 587 env.IP++ 588 return env.Code[env.IP], env 589 } 590 } 591 case 592 593 r.Int8: 594 value := 595 596 int8(v.Int()) 597 if sendonly { 598 stmt = func(env *Env) (Stmt, *Env) { 599 channel := channelfun(env).Interface().(chan<- int8) 600 channel <- value 601 env.IP++ 602 return env.Code[env.IP], env 603 } 604 } else { 605 stmt = func(env *Env) (Stmt, *Env) { 606 channel := channelfun(env).Interface().(chan int8) 607 channel <- value 608 env.IP++ 609 return env.Code[env.IP], env 610 } 611 } 612 case 613 614 r.Int16: 615 value := 616 617 int16(v.Int()) 618 if sendonly { 619 stmt = func(env *Env) (Stmt, *Env) { 620 channel := channelfun(env).Interface().(chan<- int16) 621 channel <- value 622 env.IP++ 623 return env.Code[env.IP], env 624 } 625 } else { 626 stmt = func(env *Env) (Stmt, *Env) { 627 channel := channelfun(env).Interface().(chan int16) 628 channel <- value 629 env.IP++ 630 return env.Code[env.IP], env 631 } 632 } 633 case 634 635 r.Int32: 636 value := 637 638 int32(v.Int()) 639 if sendonly { 640 stmt = func(env *Env) (Stmt, *Env) { 641 channel := channelfun(env).Interface().(chan<- int32) 642 channel <- value 643 env.IP++ 644 return env.Code[env.IP], env 645 } 646 } else { 647 stmt = func(env *Env) (Stmt, *Env) { 648 channel := channelfun(env).Interface().(chan int32) 649 channel <- value 650 env.IP++ 651 return env.Code[env.IP], env 652 } 653 } 654 case 655 656 r.Int64: 657 value := v.Int() 658 if sendonly { 659 stmt = func(env *Env) (Stmt, *Env) { 660 channel := channelfun(env).Interface().(chan<- int64) 661 channel <- value 662 env.IP++ 663 return env.Code[env.IP], env 664 } 665 } else { 666 stmt = func(env *Env) (Stmt, *Env) { 667 channel := channelfun(env).Interface().(chan int64) 668 channel <- value 669 env.IP++ 670 return env.Code[env.IP], env 671 } 672 } 673 case 674 675 r.Uint: 676 value := 677 678 uint(v.Uint()) 679 if sendonly { 680 stmt = func(env *Env) (Stmt, *Env) { 681 channel := channelfun(env).Interface().(chan<- uint) 682 channel <- value 683 env.IP++ 684 return env.Code[env.IP], env 685 } 686 } else { 687 stmt = func(env *Env) (Stmt, *Env) { 688 channel := channelfun(env).Interface().(chan uint) 689 channel <- value 690 env.IP++ 691 return env.Code[env.IP], env 692 } 693 } 694 case 695 696 r.Uint8: 697 value := 698 699 uint8(v.Uint()) 700 if sendonly { 701 stmt = func(env *Env) (Stmt, *Env) { 702 channel := channelfun(env).Interface().(chan<- uint8) 703 channel <- value 704 env.IP++ 705 return env.Code[env.IP], env 706 } 707 } else { 708 stmt = func(env *Env) (Stmt, *Env) { 709 channel := channelfun(env).Interface().(chan uint8) 710 channel <- value 711 env.IP++ 712 return env.Code[env.IP], env 713 } 714 } 715 case 716 717 r.Uint16: 718 value := 719 720 uint16(v.Uint()) 721 if sendonly { 722 stmt = func(env *Env) (Stmt, *Env) { 723 channel := channelfun(env).Interface().(chan<- uint16) 724 channel <- value 725 env.IP++ 726 return env.Code[env.IP], env 727 } 728 } else { 729 stmt = func(env *Env) (Stmt, *Env) { 730 channel := channelfun(env).Interface().(chan uint16) 731 channel <- value 732 env.IP++ 733 return env.Code[env.IP], env 734 } 735 } 736 case 737 738 r.Uint32: 739 value := 740 741 uint32(v.Uint()) 742 if sendonly { 743 stmt = func(env *Env) (Stmt, *Env) { 744 channel := channelfun(env).Interface().(chan<- uint32) 745 channel <- value 746 env.IP++ 747 return env.Code[env.IP], env 748 } 749 } else { 750 stmt = func(env *Env) (Stmt, *Env) { 751 channel := channelfun(env).Interface().(chan uint32) 752 channel <- value 753 env.IP++ 754 return env.Code[env.IP], env 755 } 756 } 757 case 758 759 r.Uint64: 760 value := v.Uint() 761 if sendonly { 762 stmt = func(env *Env) (Stmt, *Env) { 763 channel := channelfun(env).Interface().(chan<- uint64) 764 channel <- value 765 env.IP++ 766 return env.Code[env.IP], env 767 } 768 } else { 769 stmt = func(env *Env) (Stmt, *Env) { 770 channel := channelfun(env).Interface().(chan uint64) 771 channel <- value 772 env.IP++ 773 return env.Code[env.IP], env 774 } 775 } 776 case 777 778 r.Uintptr: 779 value := 780 781 uintptr(v.Uint()) 782 if sendonly { 783 stmt = func(env *Env) (Stmt, *Env) { 784 channel := channelfun(env).Interface().(chan<- uintptr) 785 channel <- value 786 env.IP++ 787 return env.Code[env.IP], env 788 } 789 } else { 790 stmt = func(env *Env) (Stmt, *Env) { 791 channel := channelfun(env).Interface().(chan uintptr) 792 channel <- value 793 env.IP++ 794 return env.Code[env.IP], env 795 } 796 } 797 case 798 799 r.Float32: 800 value := 801 802 float32(v.Float()) 803 if sendonly { 804 stmt = func(env *Env) (Stmt, *Env) { 805 channel := channelfun(env).Interface().(chan<- float32) 806 channel <- value 807 env.IP++ 808 return env.Code[env.IP], env 809 } 810 } else { 811 stmt = func(env *Env) (Stmt, *Env) { 812 channel := channelfun(env).Interface().(chan float32) 813 channel <- value 814 env.IP++ 815 return env.Code[env.IP], env 816 } 817 } 818 case 819 820 r.Float64: 821 value := v.Float() 822 if sendonly { 823 stmt = func(env *Env) (Stmt, *Env) { 824 channel := channelfun(env).Interface().(chan<- float64) 825 channel <- value 826 env.IP++ 827 return env.Code[env.IP], env 828 } 829 } else { 830 stmt = func(env *Env) (Stmt, *Env) { 831 channel := channelfun(env).Interface().(chan float64) 832 channel <- value 833 env.IP++ 834 return env.Code[env.IP], env 835 } 836 } 837 case 838 839 r.Complex64: 840 value := 841 842 complex64(v.Complex()) 843 if sendonly { 844 stmt = func(env *Env) (Stmt, *Env) { 845 channel := channelfun(env).Interface().(chan<- complex64) 846 channel <- value 847 env.IP++ 848 return env.Code[env.IP], env 849 } 850 } else { 851 stmt = func(env *Env) (Stmt, *Env) { 852 channel := channelfun(env).Interface().(chan complex64) 853 channel <- value 854 env.IP++ 855 return env.Code[env.IP], env 856 } 857 } 858 case 859 860 r.Complex128: 861 value := v.Complex() 862 if sendonly { 863 stmt = func(env *Env) (Stmt, *Env) { 864 channel := channelfun(env).Interface().(chan<- complex128) 865 channel <- value 866 env.IP++ 867 return env.Code[env.IP], env 868 } 869 } else { 870 stmt = func(env *Env) (Stmt, *Env) { 871 channel := channelfun(env).Interface().(chan complex128) 872 channel <- value 873 env.IP++ 874 return env.Code[env.IP], env 875 } 876 } 877 case 878 879 r.String: 880 value := v.String() 881 if sendonly { 882 stmt = func(env *Env) (Stmt, *Env) { 883 channel := channelfun(env).Interface().(chan<- string) 884 channel <- value 885 env.IP++ 886 return env.Code[env.IP], env 887 } 888 } else { 889 stmt = func(env *Env) (Stmt, *Env) { 890 channel := channelfun(env).Interface().(chan string) 891 channel <- value 892 env.IP++ 893 return env.Code[env.IP], env 894 } 895 } 896 897 } 898 } 899 900 if stmt == nil { 901 stmt = func(env *Env) (Stmt, *Env) { 902 channel := channelfun(env) 903 channel.Send(v) 904 env.IP++ 905 return env.Code[env.IP], env 906 } 907 } 908 909 } else { 910 if reflect.KindToType(kelem) == rtelem { 911 switch kelem { 912 case 913 914 r.Bool: 915 if exprfun, ok := expr.Fun.(func(*Env) bool); !ok { 916 break 917 } else if sendonly { 918 stmt = func(env *Env) (Stmt, *Env) { 919 channel := channelfun(env).Interface().(chan<- bool) 920 channel <- exprfun(env) 921 env.IP++ 922 return env.Code[env.IP], env 923 } 924 } else { 925 stmt = func(env *Env) (Stmt, *Env) { 926 channel := channelfun(env).Interface().(chan bool) 927 channel <- exprfun(env) 928 env.IP++ 929 return env.Code[env.IP], env 930 } 931 } 932 case 933 934 r.Int: 935 if exprfun, ok := expr.Fun.(func(*Env) int); !ok { 936 break 937 } else if sendonly { 938 stmt = func(env *Env) (Stmt, *Env) { 939 channel := channelfun(env).Interface().(chan<- int) 940 channel <- exprfun(env) 941 env.IP++ 942 return env.Code[env.IP], env 943 } 944 } else { 945 stmt = func(env *Env) (Stmt, *Env) { 946 channel := channelfun(env).Interface().(chan int) 947 channel <- exprfun(env) 948 env.IP++ 949 return env.Code[env.IP], env 950 } 951 } 952 case 953 954 r.Int8: 955 if exprfun, ok := expr.Fun.(func(*Env) int8); !ok { 956 break 957 } else if sendonly { 958 stmt = func(env *Env) (Stmt, *Env) { 959 channel := channelfun(env).Interface().(chan<- int8) 960 channel <- exprfun(env) 961 env.IP++ 962 return env.Code[env.IP], env 963 } 964 } else { 965 stmt = func(env *Env) (Stmt, *Env) { 966 channel := channelfun(env).Interface().(chan int8) 967 channel <- exprfun(env) 968 env.IP++ 969 return env.Code[env.IP], env 970 } 971 } 972 case 973 974 r.Int16: 975 if exprfun, ok := expr.Fun.(func(*Env) int16); !ok { 976 break 977 } else if sendonly { 978 stmt = func(env *Env) (Stmt, *Env) { 979 channel := channelfun(env).Interface().(chan<- int16) 980 channel <- exprfun(env) 981 env.IP++ 982 return env.Code[env.IP], env 983 } 984 } else { 985 stmt = func(env *Env) (Stmt, *Env) { 986 channel := channelfun(env).Interface().(chan int16) 987 channel <- exprfun(env) 988 env.IP++ 989 return env.Code[env.IP], env 990 } 991 } 992 case 993 994 r.Int32: 995 if exprfun, ok := expr.Fun.(func(*Env) int32); !ok { 996 break 997 } else if sendonly { 998 stmt = func(env *Env) (Stmt, *Env) { 999 channel := channelfun(env).Interface().(chan<- int32) 1000 channel <- exprfun(env) 1001 env.IP++ 1002 return env.Code[env.IP], env 1003 } 1004 } else { 1005 stmt = func(env *Env) (Stmt, *Env) { 1006 channel := channelfun(env).Interface().(chan int32) 1007 channel <- exprfun(env) 1008 env.IP++ 1009 return env.Code[env.IP], env 1010 } 1011 } 1012 case 1013 1014 r.Int64: 1015 if exprfun, ok := expr.Fun.(func(*Env) int64); !ok { 1016 break 1017 } else if sendonly { 1018 stmt = func(env *Env) (Stmt, *Env) { 1019 channel := channelfun(env).Interface().(chan<- int64) 1020 channel <- exprfun(env) 1021 env.IP++ 1022 return env.Code[env.IP], env 1023 } 1024 } else { 1025 stmt = func(env *Env) (Stmt, *Env) { 1026 channel := channelfun(env).Interface().(chan int64) 1027 channel <- exprfun(env) 1028 env.IP++ 1029 return env.Code[env.IP], env 1030 } 1031 } 1032 case 1033 1034 r.Uint: 1035 if exprfun, ok := expr.Fun.(func(*Env) uint); !ok { 1036 break 1037 } else if sendonly { 1038 stmt = func(env *Env) (Stmt, *Env) { 1039 channel := channelfun(env).Interface().(chan<- uint) 1040 channel <- exprfun(env) 1041 env.IP++ 1042 return env.Code[env.IP], env 1043 } 1044 } else { 1045 stmt = func(env *Env) (Stmt, *Env) { 1046 channel := channelfun(env).Interface().(chan uint) 1047 channel <- exprfun(env) 1048 env.IP++ 1049 return env.Code[env.IP], env 1050 } 1051 } 1052 case 1053 1054 r.Uint8: 1055 if exprfun, ok := expr.Fun.(func(*Env) uint8); !ok { 1056 break 1057 } else if sendonly { 1058 stmt = func(env *Env) (Stmt, *Env) { 1059 channel := channelfun(env).Interface().(chan<- uint8) 1060 channel <- exprfun(env) 1061 env.IP++ 1062 return env.Code[env.IP], env 1063 } 1064 } else { 1065 stmt = func(env *Env) (Stmt, *Env) { 1066 channel := channelfun(env).Interface().(chan uint8) 1067 channel <- exprfun(env) 1068 env.IP++ 1069 return env.Code[env.IP], env 1070 } 1071 } 1072 case 1073 1074 r.Uint16: 1075 if exprfun, ok := expr.Fun.(func(*Env) uint16); !ok { 1076 break 1077 } else if sendonly { 1078 stmt = func(env *Env) (Stmt, *Env) { 1079 channel := channelfun(env).Interface().(chan<- uint16) 1080 channel <- exprfun(env) 1081 env.IP++ 1082 return env.Code[env.IP], env 1083 } 1084 } else { 1085 stmt = func(env *Env) (Stmt, *Env) { 1086 channel := channelfun(env).Interface().(chan uint16) 1087 channel <- exprfun(env) 1088 env.IP++ 1089 return env.Code[env.IP], env 1090 } 1091 } 1092 case 1093 1094 r.Uint32: 1095 if exprfun, ok := expr.Fun.(func(*Env) uint32); !ok { 1096 break 1097 } else if sendonly { 1098 stmt = func(env *Env) (Stmt, *Env) { 1099 channel := channelfun(env).Interface().(chan<- uint32) 1100 channel <- exprfun(env) 1101 env.IP++ 1102 return env.Code[env.IP], env 1103 } 1104 } else { 1105 stmt = func(env *Env) (Stmt, *Env) { 1106 channel := channelfun(env).Interface().(chan uint32) 1107 channel <- exprfun(env) 1108 env.IP++ 1109 return env.Code[env.IP], env 1110 } 1111 } 1112 case 1113 1114 r.Uint64: 1115 if exprfun, ok := expr.Fun.(func(*Env) uint64); !ok { 1116 break 1117 } else if sendonly { 1118 stmt = func(env *Env) (Stmt, *Env) { 1119 channel := channelfun(env).Interface().(chan<- uint64) 1120 channel <- exprfun(env) 1121 env.IP++ 1122 return env.Code[env.IP], env 1123 } 1124 } else { 1125 stmt = func(env *Env) (Stmt, *Env) { 1126 channel := channelfun(env).Interface().(chan uint64) 1127 channel <- exprfun(env) 1128 env.IP++ 1129 return env.Code[env.IP], env 1130 } 1131 } 1132 case 1133 1134 r.Uintptr: 1135 if exprfun, ok := expr.Fun.(func(*Env) uintptr); !ok { 1136 break 1137 } else if sendonly { 1138 stmt = func(env *Env) (Stmt, *Env) { 1139 channel := channelfun(env).Interface().(chan<- uintptr) 1140 channel <- exprfun(env) 1141 env.IP++ 1142 return env.Code[env.IP], env 1143 } 1144 } else { 1145 stmt = func(env *Env) (Stmt, *Env) { 1146 channel := channelfun(env).Interface().(chan uintptr) 1147 channel <- exprfun(env) 1148 env.IP++ 1149 return env.Code[env.IP], env 1150 } 1151 } 1152 case 1153 1154 r.Float32: 1155 if exprfun, ok := expr.Fun.(func(*Env) float32); !ok { 1156 break 1157 } else if sendonly { 1158 stmt = func(env *Env) (Stmt, *Env) { 1159 channel := channelfun(env).Interface().(chan<- float32) 1160 channel <- exprfun(env) 1161 env.IP++ 1162 return env.Code[env.IP], env 1163 } 1164 } else { 1165 stmt = func(env *Env) (Stmt, *Env) { 1166 channel := channelfun(env).Interface().(chan float32) 1167 channel <- exprfun(env) 1168 env.IP++ 1169 return env.Code[env.IP], env 1170 } 1171 } 1172 case 1173 1174 r.Float64: 1175 if exprfun, ok := expr.Fun.(func(*Env) float64); !ok { 1176 break 1177 } else if sendonly { 1178 stmt = func(env *Env) (Stmt, *Env) { 1179 channel := channelfun(env).Interface().(chan<- float64) 1180 channel <- exprfun(env) 1181 env.IP++ 1182 return env.Code[env.IP], env 1183 } 1184 } else { 1185 stmt = func(env *Env) (Stmt, *Env) { 1186 channel := channelfun(env).Interface().(chan float64) 1187 channel <- exprfun(env) 1188 env.IP++ 1189 return env.Code[env.IP], env 1190 } 1191 } 1192 case 1193 1194 r.Complex64: 1195 if exprfun, ok := expr.Fun.(func(*Env) complex64); !ok { 1196 break 1197 } else if sendonly { 1198 stmt = func(env *Env) (Stmt, *Env) { 1199 channel := channelfun(env).Interface().(chan<- complex64) 1200 channel <- exprfun(env) 1201 env.IP++ 1202 return env.Code[env.IP], env 1203 } 1204 } else { 1205 stmt = func(env *Env) (Stmt, *Env) { 1206 channel := channelfun(env).Interface().(chan complex64) 1207 channel <- exprfun(env) 1208 env.IP++ 1209 return env.Code[env.IP], env 1210 } 1211 } 1212 case 1213 1214 r.Complex128: 1215 if exprfun, ok := expr.Fun.(func(*Env) complex128); !ok { 1216 break 1217 } else if sendonly { 1218 stmt = func(env *Env) (Stmt, *Env) { 1219 channel := channelfun(env).Interface().(chan<- complex128) 1220 channel <- exprfun(env) 1221 env.IP++ 1222 return env.Code[env.IP], env 1223 } 1224 } else { 1225 stmt = func(env *Env) (Stmt, *Env) { 1226 channel := channelfun(env).Interface().(chan complex128) 1227 channel <- exprfun(env) 1228 env.IP++ 1229 return env.Code[env.IP], env 1230 } 1231 } 1232 case 1233 1234 r.String: 1235 if exprfun, ok := expr.Fun.(func(*Env) string); !ok { 1236 break 1237 } else if sendonly { 1238 stmt = func(env *Env) (Stmt, *Env) { 1239 channel := channelfun(env).Interface().(chan<- string) 1240 channel <- exprfun(env) 1241 env.IP++ 1242 return env.Code[env.IP], env 1243 } 1244 } else { 1245 stmt = func(env *Env) (Stmt, *Env) { 1246 channel := channelfun(env).Interface().(chan string) 1247 channel <- exprfun(env) 1248 env.IP++ 1249 return env.Code[env.IP], env 1250 } 1251 } 1252 1253 } 1254 } 1255 1256 if stmt == nil { 1257 exprfun := expr.AsX1() 1258 stmt = func(env *Env) (Stmt, *Env) { 1259 channel := channelfun(env) 1260 value := exprfun(env) 1261 channel.Send(value) 1262 env.IP++ 1263 return env.Code[env.IP], env 1264 } 1265 } 1266 } 1267 c.append(stmt) 1268} 1269