github.com/goplus/igop@v0.25.0/opcvt.go (about) 1 /* 2 * Copyright (c) 2022 The GoPlus Authors (goplus.org). All rights reserved. 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package igop 18 19 import ( 20 "reflect" 21 22 "github.com/visualfc/xtype" 23 ) 24 25 func cvtInt(ir, ix register, xkind reflect.Kind, xtyp reflect.Type, typ reflect.Type) func(fr *frame) { 26 type T = int 27 t := xtype.TypeOfType(typ) 28 isBasic := typ.PkgPath() == "" 29 if xtyp.PkgPath() == "" { 30 return func(fr *frame) { 31 var v T 32 switch xkind { 33 case reflect.Int: 34 v = T(fr.reg(ix).(int)) 35 case reflect.Int8: 36 v = T(fr.reg(ix).(int8)) 37 case reflect.Int16: 38 v = T(fr.reg(ix).(int16)) 39 case reflect.Int32: 40 v = T(fr.reg(ix).(int32)) 41 case reflect.Int64: 42 v = T(fr.reg(ix).(int64)) 43 case reflect.Uint: 44 v = T(fr.reg(ix).(uint)) 45 case reflect.Uint8: 46 v = T(fr.reg(ix).(uint8)) 47 case reflect.Uint16: 48 v = T(fr.reg(ix).(uint16)) 49 case reflect.Uint32: 50 v = T(fr.reg(ix).(uint32)) 51 case reflect.Uint64: 52 v = T(fr.reg(ix).(uint64)) 53 case reflect.Uintptr: 54 v = T(fr.reg(ix).(uintptr)) 55 case reflect.Float32: 56 v = T(fr.reg(ix).(float32)) 57 case reflect.Float64: 58 v = T(fr.reg(ix).(float64)) 59 } 60 if isBasic { 61 fr.setReg(ir, v) 62 } else { 63 fr.setReg(ir, xtype.Make(t, v)) 64 } 65 } 66 } else { 67 return func(fr *frame) { 68 var v T 69 switch xkind { 70 case reflect.Int: 71 v = T(fr.int(ix)) 72 case reflect.Int8: 73 v = T(fr.int8(ix)) 74 case reflect.Int16: 75 v = T(fr.int16(ix)) 76 case reflect.Int32: 77 v = T(fr.int32(ix)) 78 case reflect.Int64: 79 v = T(fr.int64(ix)) 80 case reflect.Uint: 81 v = T(fr.uint(ix)) 82 case reflect.Uint8: 83 v = T(fr.uint8(ix)) 84 case reflect.Uint16: 85 v = T(fr.uint16(ix)) 86 case reflect.Uint32: 87 v = T(fr.uint32(ix)) 88 case reflect.Uint64: 89 v = T(fr.uint64(ix)) 90 case reflect.Uintptr: 91 v = T(fr.uintptr(ix)) 92 case reflect.Float32: 93 v = T(fr.float32(ix)) 94 case reflect.Float64: 95 v = T(fr.float64(ix)) 96 } 97 if isBasic { 98 fr.setReg(ir, v) 99 } else { 100 fr.setReg(ir, xtype.Make(t, v)) 101 } 102 } 103 } 104 } 105 func cvtInt8(ir, ix register, xkind reflect.Kind, xtyp reflect.Type, typ reflect.Type) func(fr *frame) { 106 type T = int8 107 t := xtype.TypeOfType(typ) 108 isBasic := typ.PkgPath() == "" 109 if xtyp.PkgPath() == "" { 110 return func(fr *frame) { 111 var v T 112 switch xkind { 113 case reflect.Int: 114 v = T(fr.reg(ix).(int)) 115 case reflect.Int8: 116 v = T(fr.reg(ix).(int8)) 117 case reflect.Int16: 118 v = T(fr.reg(ix).(int16)) 119 case reflect.Int32: 120 v = T(fr.reg(ix).(int32)) 121 case reflect.Int64: 122 v = T(fr.reg(ix).(int64)) 123 case reflect.Uint: 124 v = T(fr.reg(ix).(uint)) 125 case reflect.Uint8: 126 v = T(fr.reg(ix).(uint8)) 127 case reflect.Uint16: 128 v = T(fr.reg(ix).(uint16)) 129 case reflect.Uint32: 130 v = T(fr.reg(ix).(uint32)) 131 case reflect.Uint64: 132 v = T(fr.reg(ix).(uint64)) 133 case reflect.Uintptr: 134 v = T(fr.reg(ix).(uintptr)) 135 case reflect.Float32: 136 v = T(fr.reg(ix).(float32)) 137 case reflect.Float64: 138 v = T(fr.reg(ix).(float64)) 139 } 140 if isBasic { 141 fr.setReg(ir, v) 142 } else { 143 fr.setReg(ir, xtype.Make(t, v)) 144 } 145 } 146 } else { 147 return func(fr *frame) { 148 var v T 149 switch xkind { 150 case reflect.Int: 151 v = T(fr.int(ix)) 152 case reflect.Int8: 153 v = T(fr.int8(ix)) 154 case reflect.Int16: 155 v = T(fr.int16(ix)) 156 case reflect.Int32: 157 v = T(fr.int32(ix)) 158 case reflect.Int64: 159 v = T(fr.int64(ix)) 160 case reflect.Uint: 161 v = T(fr.uint(ix)) 162 case reflect.Uint8: 163 v = T(fr.uint8(ix)) 164 case reflect.Uint16: 165 v = T(fr.uint16(ix)) 166 case reflect.Uint32: 167 v = T(fr.uint32(ix)) 168 case reflect.Uint64: 169 v = T(fr.uint64(ix)) 170 case reflect.Uintptr: 171 v = T(fr.uintptr(ix)) 172 case reflect.Float32: 173 v = T(fr.float32(ix)) 174 case reflect.Float64: 175 v = T(fr.float64(ix)) 176 } 177 if isBasic { 178 fr.setReg(ir, v) 179 } else { 180 fr.setReg(ir, xtype.Make(t, v)) 181 } 182 } 183 } 184 } 185 func cvtInt16(ir, ix register, xkind reflect.Kind, xtyp reflect.Type, typ reflect.Type) func(fr *frame) { 186 type T = int16 187 t := xtype.TypeOfType(typ) 188 isBasic := typ.PkgPath() == "" 189 if xtyp.PkgPath() == "" { 190 return func(fr *frame) { 191 var v T 192 switch xkind { 193 case reflect.Int: 194 v = T(fr.reg(ix).(int)) 195 case reflect.Int8: 196 v = T(fr.reg(ix).(int8)) 197 case reflect.Int16: 198 v = T(fr.reg(ix).(int16)) 199 case reflect.Int32: 200 v = T(fr.reg(ix).(int32)) 201 case reflect.Int64: 202 v = T(fr.reg(ix).(int64)) 203 case reflect.Uint: 204 v = T(fr.reg(ix).(uint)) 205 case reflect.Uint8: 206 v = T(fr.reg(ix).(uint8)) 207 case reflect.Uint16: 208 v = T(fr.reg(ix).(uint16)) 209 case reflect.Uint32: 210 v = T(fr.reg(ix).(uint32)) 211 case reflect.Uint64: 212 v = T(fr.reg(ix).(uint64)) 213 case reflect.Uintptr: 214 v = T(fr.reg(ix).(uintptr)) 215 case reflect.Float32: 216 v = T(fr.reg(ix).(float32)) 217 case reflect.Float64: 218 v = T(fr.reg(ix).(float64)) 219 } 220 if isBasic { 221 fr.setReg(ir, v) 222 } else { 223 fr.setReg(ir, xtype.Make(t, v)) 224 } 225 } 226 } else { 227 return func(fr *frame) { 228 var v T 229 switch xkind { 230 case reflect.Int: 231 v = T(fr.int(ix)) 232 case reflect.Int8: 233 v = T(fr.int8(ix)) 234 case reflect.Int16: 235 v = T(fr.int16(ix)) 236 case reflect.Int32: 237 v = T(fr.int32(ix)) 238 case reflect.Int64: 239 v = T(fr.int64(ix)) 240 case reflect.Uint: 241 v = T(fr.uint(ix)) 242 case reflect.Uint8: 243 v = T(fr.uint8(ix)) 244 case reflect.Uint16: 245 v = T(fr.uint16(ix)) 246 case reflect.Uint32: 247 v = T(fr.uint32(ix)) 248 case reflect.Uint64: 249 v = T(fr.uint64(ix)) 250 case reflect.Uintptr: 251 v = T(fr.uintptr(ix)) 252 case reflect.Float32: 253 v = T(fr.float32(ix)) 254 case reflect.Float64: 255 v = T(fr.float64(ix)) 256 } 257 if isBasic { 258 fr.setReg(ir, v) 259 } else { 260 fr.setReg(ir, xtype.Make(t, v)) 261 } 262 } 263 } 264 } 265 func cvtInt32(ir, ix register, xkind reflect.Kind, xtyp reflect.Type, typ reflect.Type) func(fr *frame) { 266 type T = int32 267 t := xtype.TypeOfType(typ) 268 isBasic := typ.PkgPath() == "" 269 if xtyp.PkgPath() == "" { 270 return func(fr *frame) { 271 var v T 272 switch xkind { 273 case reflect.Int: 274 v = T(fr.reg(ix).(int)) 275 case reflect.Int8: 276 v = T(fr.reg(ix).(int8)) 277 case reflect.Int16: 278 v = T(fr.reg(ix).(int16)) 279 case reflect.Int32: 280 v = T(fr.reg(ix).(int32)) 281 case reflect.Int64: 282 v = T(fr.reg(ix).(int64)) 283 case reflect.Uint: 284 v = T(fr.reg(ix).(uint)) 285 case reflect.Uint8: 286 v = T(fr.reg(ix).(uint8)) 287 case reflect.Uint16: 288 v = T(fr.reg(ix).(uint16)) 289 case reflect.Uint32: 290 v = T(fr.reg(ix).(uint32)) 291 case reflect.Uint64: 292 v = T(fr.reg(ix).(uint64)) 293 case reflect.Uintptr: 294 v = T(fr.reg(ix).(uintptr)) 295 case reflect.Float32: 296 v = T(fr.reg(ix).(float32)) 297 case reflect.Float64: 298 v = T(fr.reg(ix).(float64)) 299 } 300 if isBasic { 301 fr.setReg(ir, v) 302 } else { 303 fr.setReg(ir, xtype.Make(t, v)) 304 } 305 } 306 } else { 307 return func(fr *frame) { 308 var v T 309 switch xkind { 310 case reflect.Int: 311 v = T(fr.int(ix)) 312 case reflect.Int8: 313 v = T(fr.int8(ix)) 314 case reflect.Int16: 315 v = T(fr.int16(ix)) 316 case reflect.Int32: 317 v = T(fr.int32(ix)) 318 case reflect.Int64: 319 v = T(fr.int64(ix)) 320 case reflect.Uint: 321 v = T(fr.uint(ix)) 322 case reflect.Uint8: 323 v = T(fr.uint8(ix)) 324 case reflect.Uint16: 325 v = T(fr.uint16(ix)) 326 case reflect.Uint32: 327 v = T(fr.uint32(ix)) 328 case reflect.Uint64: 329 v = T(fr.uint64(ix)) 330 case reflect.Uintptr: 331 v = T(fr.uintptr(ix)) 332 case reflect.Float32: 333 v = T(fr.float32(ix)) 334 case reflect.Float64: 335 v = T(fr.float64(ix)) 336 } 337 if isBasic { 338 fr.setReg(ir, v) 339 } else { 340 fr.setReg(ir, xtype.Make(t, v)) 341 } 342 } 343 } 344 } 345 func cvtInt64(ir, ix register, xkind reflect.Kind, xtyp reflect.Type, typ reflect.Type) func(fr *frame) { 346 type T = int64 347 t := xtype.TypeOfType(typ) 348 isBasic := typ.PkgPath() == "" 349 if xtyp.PkgPath() == "" { 350 return func(fr *frame) { 351 var v T 352 switch xkind { 353 case reflect.Int: 354 v = T(fr.reg(ix).(int)) 355 case reflect.Int8: 356 v = T(fr.reg(ix).(int8)) 357 case reflect.Int16: 358 v = T(fr.reg(ix).(int16)) 359 case reflect.Int32: 360 v = T(fr.reg(ix).(int32)) 361 case reflect.Int64: 362 v = T(fr.reg(ix).(int64)) 363 case reflect.Uint: 364 v = T(fr.reg(ix).(uint)) 365 case reflect.Uint8: 366 v = T(fr.reg(ix).(uint8)) 367 case reflect.Uint16: 368 v = T(fr.reg(ix).(uint16)) 369 case reflect.Uint32: 370 v = T(fr.reg(ix).(uint32)) 371 case reflect.Uint64: 372 v = T(fr.reg(ix).(uint64)) 373 case reflect.Uintptr: 374 v = T(fr.reg(ix).(uintptr)) 375 case reflect.Float32: 376 v = T(fr.reg(ix).(float32)) 377 case reflect.Float64: 378 v = T(fr.reg(ix).(float64)) 379 } 380 if isBasic { 381 fr.setReg(ir, v) 382 } else { 383 fr.setReg(ir, xtype.Make(t, v)) 384 } 385 } 386 } else { 387 return func(fr *frame) { 388 var v T 389 switch xkind { 390 case reflect.Int: 391 v = T(fr.int(ix)) 392 case reflect.Int8: 393 v = T(fr.int8(ix)) 394 case reflect.Int16: 395 v = T(fr.int16(ix)) 396 case reflect.Int32: 397 v = T(fr.int32(ix)) 398 case reflect.Int64: 399 v = T(fr.int64(ix)) 400 case reflect.Uint: 401 v = T(fr.uint(ix)) 402 case reflect.Uint8: 403 v = T(fr.uint8(ix)) 404 case reflect.Uint16: 405 v = T(fr.uint16(ix)) 406 case reflect.Uint32: 407 v = T(fr.uint32(ix)) 408 case reflect.Uint64: 409 v = T(fr.uint64(ix)) 410 case reflect.Uintptr: 411 v = T(fr.uintptr(ix)) 412 case reflect.Float32: 413 v = T(fr.float32(ix)) 414 case reflect.Float64: 415 v = T(fr.float64(ix)) 416 } 417 if isBasic { 418 fr.setReg(ir, v) 419 } else { 420 fr.setReg(ir, xtype.Make(t, v)) 421 } 422 } 423 } 424 } 425 func cvtUint(ir, ix register, xkind reflect.Kind, xtyp reflect.Type, typ reflect.Type) func(fr *frame) { 426 type T = uint 427 t := xtype.TypeOfType(typ) 428 isBasic := typ.PkgPath() == "" 429 if xtyp.PkgPath() == "" { 430 return func(fr *frame) { 431 var v T 432 switch xkind { 433 case reflect.Int: 434 v = T(fr.reg(ix).(int)) 435 case reflect.Int8: 436 v = T(fr.reg(ix).(int8)) 437 case reflect.Int16: 438 v = T(fr.reg(ix).(int16)) 439 case reflect.Int32: 440 v = T(fr.reg(ix).(int32)) 441 case reflect.Int64: 442 v = T(fr.reg(ix).(int64)) 443 case reflect.Uint: 444 v = T(fr.reg(ix).(uint)) 445 case reflect.Uint8: 446 v = T(fr.reg(ix).(uint8)) 447 case reflect.Uint16: 448 v = T(fr.reg(ix).(uint16)) 449 case reflect.Uint32: 450 v = T(fr.reg(ix).(uint32)) 451 case reflect.Uint64: 452 v = T(fr.reg(ix).(uint64)) 453 case reflect.Uintptr: 454 v = T(fr.reg(ix).(uintptr)) 455 case reflect.Float32: 456 v = T(fr.reg(ix).(float32)) 457 case reflect.Float64: 458 v = T(fr.reg(ix).(float64)) 459 } 460 if isBasic { 461 fr.setReg(ir, v) 462 } else { 463 fr.setReg(ir, xtype.Make(t, v)) 464 } 465 } 466 } else { 467 return func(fr *frame) { 468 var v T 469 switch xkind { 470 case reflect.Int: 471 v = T(fr.int(ix)) 472 case reflect.Int8: 473 v = T(fr.int8(ix)) 474 case reflect.Int16: 475 v = T(fr.int16(ix)) 476 case reflect.Int32: 477 v = T(fr.int32(ix)) 478 case reflect.Int64: 479 v = T(fr.int64(ix)) 480 case reflect.Uint: 481 v = T(fr.uint(ix)) 482 case reflect.Uint8: 483 v = T(fr.uint8(ix)) 484 case reflect.Uint16: 485 v = T(fr.uint16(ix)) 486 case reflect.Uint32: 487 v = T(fr.uint32(ix)) 488 case reflect.Uint64: 489 v = T(fr.uint64(ix)) 490 case reflect.Uintptr: 491 v = T(fr.uintptr(ix)) 492 case reflect.Float32: 493 v = T(fr.float32(ix)) 494 case reflect.Float64: 495 v = T(fr.float64(ix)) 496 } 497 if isBasic { 498 fr.setReg(ir, v) 499 } else { 500 fr.setReg(ir, xtype.Make(t, v)) 501 } 502 } 503 } 504 } 505 func cvtUint8(ir, ix register, xkind reflect.Kind, xtyp reflect.Type, typ reflect.Type) func(fr *frame) { 506 type T = uint8 507 t := xtype.TypeOfType(typ) 508 isBasic := typ.PkgPath() == "" 509 if xtyp.PkgPath() == "" { 510 return func(fr *frame) { 511 var v T 512 switch xkind { 513 case reflect.Int: 514 v = T(fr.reg(ix).(int)) 515 case reflect.Int8: 516 v = T(fr.reg(ix).(int8)) 517 case reflect.Int16: 518 v = T(fr.reg(ix).(int16)) 519 case reflect.Int32: 520 v = T(fr.reg(ix).(int32)) 521 case reflect.Int64: 522 v = T(fr.reg(ix).(int64)) 523 case reflect.Uint: 524 v = T(fr.reg(ix).(uint)) 525 case reflect.Uint8: 526 v = T(fr.reg(ix).(uint8)) 527 case reflect.Uint16: 528 v = T(fr.reg(ix).(uint16)) 529 case reflect.Uint32: 530 v = T(fr.reg(ix).(uint32)) 531 case reflect.Uint64: 532 v = T(fr.reg(ix).(uint64)) 533 case reflect.Uintptr: 534 v = T(fr.reg(ix).(uintptr)) 535 case reflect.Float32: 536 v = T(fr.reg(ix).(float32)) 537 case reflect.Float64: 538 v = T(fr.reg(ix).(float64)) 539 } 540 if isBasic { 541 fr.setReg(ir, v) 542 } else { 543 fr.setReg(ir, xtype.Make(t, v)) 544 } 545 } 546 } else { 547 return func(fr *frame) { 548 var v T 549 switch xkind { 550 case reflect.Int: 551 v = T(fr.int(ix)) 552 case reflect.Int8: 553 v = T(fr.int8(ix)) 554 case reflect.Int16: 555 v = T(fr.int16(ix)) 556 case reflect.Int32: 557 v = T(fr.int32(ix)) 558 case reflect.Int64: 559 v = T(fr.int64(ix)) 560 case reflect.Uint: 561 v = T(fr.uint(ix)) 562 case reflect.Uint8: 563 v = T(fr.uint8(ix)) 564 case reflect.Uint16: 565 v = T(fr.uint16(ix)) 566 case reflect.Uint32: 567 v = T(fr.uint32(ix)) 568 case reflect.Uint64: 569 v = T(fr.uint64(ix)) 570 case reflect.Uintptr: 571 v = T(fr.uintptr(ix)) 572 case reflect.Float32: 573 v = T(fr.float32(ix)) 574 case reflect.Float64: 575 v = T(fr.float64(ix)) 576 } 577 if isBasic { 578 fr.setReg(ir, v) 579 } else { 580 fr.setReg(ir, xtype.Make(t, v)) 581 } 582 } 583 } 584 } 585 func cvtUint16(ir, ix register, xkind reflect.Kind, xtyp reflect.Type, typ reflect.Type) func(fr *frame) { 586 type T = uint16 587 t := xtype.TypeOfType(typ) 588 isBasic := typ.PkgPath() == "" 589 if xtyp.PkgPath() == "" { 590 return func(fr *frame) { 591 var v T 592 switch xkind { 593 case reflect.Int: 594 v = T(fr.reg(ix).(int)) 595 case reflect.Int8: 596 v = T(fr.reg(ix).(int8)) 597 case reflect.Int16: 598 v = T(fr.reg(ix).(int16)) 599 case reflect.Int32: 600 v = T(fr.reg(ix).(int32)) 601 case reflect.Int64: 602 v = T(fr.reg(ix).(int64)) 603 case reflect.Uint: 604 v = T(fr.reg(ix).(uint)) 605 case reflect.Uint8: 606 v = T(fr.reg(ix).(uint8)) 607 case reflect.Uint16: 608 v = T(fr.reg(ix).(uint16)) 609 case reflect.Uint32: 610 v = T(fr.reg(ix).(uint32)) 611 case reflect.Uint64: 612 v = T(fr.reg(ix).(uint64)) 613 case reflect.Uintptr: 614 v = T(fr.reg(ix).(uintptr)) 615 case reflect.Float32: 616 v = T(fr.reg(ix).(float32)) 617 case reflect.Float64: 618 v = T(fr.reg(ix).(float64)) 619 } 620 if isBasic { 621 fr.setReg(ir, v) 622 } else { 623 fr.setReg(ir, xtype.Make(t, v)) 624 } 625 } 626 } else { 627 return func(fr *frame) { 628 var v T 629 switch xkind { 630 case reflect.Int: 631 v = T(fr.int(ix)) 632 case reflect.Int8: 633 v = T(fr.int8(ix)) 634 case reflect.Int16: 635 v = T(fr.int16(ix)) 636 case reflect.Int32: 637 v = T(fr.int32(ix)) 638 case reflect.Int64: 639 v = T(fr.int64(ix)) 640 case reflect.Uint: 641 v = T(fr.uint(ix)) 642 case reflect.Uint8: 643 v = T(fr.uint8(ix)) 644 case reflect.Uint16: 645 v = T(fr.uint16(ix)) 646 case reflect.Uint32: 647 v = T(fr.uint32(ix)) 648 case reflect.Uint64: 649 v = T(fr.uint64(ix)) 650 case reflect.Uintptr: 651 v = T(fr.uintptr(ix)) 652 case reflect.Float32: 653 v = T(fr.float32(ix)) 654 case reflect.Float64: 655 v = T(fr.float64(ix)) 656 } 657 if isBasic { 658 fr.setReg(ir, v) 659 } else { 660 fr.setReg(ir, xtype.Make(t, v)) 661 } 662 } 663 } 664 } 665 func cvtUint32(ir, ix register, xkind reflect.Kind, xtyp reflect.Type, typ reflect.Type) func(fr *frame) { 666 type T = uint32 667 t := xtype.TypeOfType(typ) 668 isBasic := typ.PkgPath() == "" 669 if xtyp.PkgPath() == "" { 670 return func(fr *frame) { 671 var v T 672 switch xkind { 673 case reflect.Int: 674 v = T(fr.reg(ix).(int)) 675 case reflect.Int8: 676 v = T(fr.reg(ix).(int8)) 677 case reflect.Int16: 678 v = T(fr.reg(ix).(int16)) 679 case reflect.Int32: 680 v = T(fr.reg(ix).(int32)) 681 case reflect.Int64: 682 v = T(fr.reg(ix).(int64)) 683 case reflect.Uint: 684 v = T(fr.reg(ix).(uint)) 685 case reflect.Uint8: 686 v = T(fr.reg(ix).(uint8)) 687 case reflect.Uint16: 688 v = T(fr.reg(ix).(uint16)) 689 case reflect.Uint32: 690 v = T(fr.reg(ix).(uint32)) 691 case reflect.Uint64: 692 v = T(fr.reg(ix).(uint64)) 693 case reflect.Uintptr: 694 v = T(fr.reg(ix).(uintptr)) 695 case reflect.Float32: 696 v = T(fr.reg(ix).(float32)) 697 case reflect.Float64: 698 v = T(fr.reg(ix).(float64)) 699 } 700 if isBasic { 701 fr.setReg(ir, v) 702 } else { 703 fr.setReg(ir, xtype.Make(t, v)) 704 } 705 } 706 } else { 707 return func(fr *frame) { 708 var v T 709 switch xkind { 710 case reflect.Int: 711 v = T(fr.int(ix)) 712 case reflect.Int8: 713 v = T(fr.int8(ix)) 714 case reflect.Int16: 715 v = T(fr.int16(ix)) 716 case reflect.Int32: 717 v = T(fr.int32(ix)) 718 case reflect.Int64: 719 v = T(fr.int64(ix)) 720 case reflect.Uint: 721 v = T(fr.uint(ix)) 722 case reflect.Uint8: 723 v = T(fr.uint8(ix)) 724 case reflect.Uint16: 725 v = T(fr.uint16(ix)) 726 case reflect.Uint32: 727 v = T(fr.uint32(ix)) 728 case reflect.Uint64: 729 v = T(fr.uint64(ix)) 730 case reflect.Uintptr: 731 v = T(fr.uintptr(ix)) 732 case reflect.Float32: 733 v = T(fr.float32(ix)) 734 case reflect.Float64: 735 v = T(fr.float64(ix)) 736 } 737 if isBasic { 738 fr.setReg(ir, v) 739 } else { 740 fr.setReg(ir, xtype.Make(t, v)) 741 } 742 } 743 } 744 } 745 func cvtUint64(ir, ix register, xkind reflect.Kind, xtyp reflect.Type, typ reflect.Type) func(fr *frame) { 746 type T = uint64 747 t := xtype.TypeOfType(typ) 748 isBasic := typ.PkgPath() == "" 749 if xtyp.PkgPath() == "" { 750 return func(fr *frame) { 751 var v T 752 switch xkind { 753 case reflect.Int: 754 v = T(fr.reg(ix).(int)) 755 case reflect.Int8: 756 v = T(fr.reg(ix).(int8)) 757 case reflect.Int16: 758 v = T(fr.reg(ix).(int16)) 759 case reflect.Int32: 760 v = T(fr.reg(ix).(int32)) 761 case reflect.Int64: 762 v = T(fr.reg(ix).(int64)) 763 case reflect.Uint: 764 v = T(fr.reg(ix).(uint)) 765 case reflect.Uint8: 766 v = T(fr.reg(ix).(uint8)) 767 case reflect.Uint16: 768 v = T(fr.reg(ix).(uint16)) 769 case reflect.Uint32: 770 v = T(fr.reg(ix).(uint32)) 771 case reflect.Uint64: 772 v = T(fr.reg(ix).(uint64)) 773 case reflect.Uintptr: 774 v = T(fr.reg(ix).(uintptr)) 775 case reflect.Float32: 776 v = T(fr.reg(ix).(float32)) 777 case reflect.Float64: 778 v = T(fr.reg(ix).(float64)) 779 } 780 if isBasic { 781 fr.setReg(ir, v) 782 } else { 783 fr.setReg(ir, xtype.Make(t, v)) 784 } 785 } 786 } else { 787 return func(fr *frame) { 788 var v T 789 switch xkind { 790 case reflect.Int: 791 v = T(fr.int(ix)) 792 case reflect.Int8: 793 v = T(fr.int8(ix)) 794 case reflect.Int16: 795 v = T(fr.int16(ix)) 796 case reflect.Int32: 797 v = T(fr.int32(ix)) 798 case reflect.Int64: 799 v = T(fr.int64(ix)) 800 case reflect.Uint: 801 v = T(fr.uint(ix)) 802 case reflect.Uint8: 803 v = T(fr.uint8(ix)) 804 case reflect.Uint16: 805 v = T(fr.uint16(ix)) 806 case reflect.Uint32: 807 v = T(fr.uint32(ix)) 808 case reflect.Uint64: 809 v = T(fr.uint64(ix)) 810 case reflect.Uintptr: 811 v = T(fr.uintptr(ix)) 812 case reflect.Float32: 813 v = T(fr.float32(ix)) 814 case reflect.Float64: 815 v = T(fr.float64(ix)) 816 } 817 if isBasic { 818 fr.setReg(ir, v) 819 } else { 820 fr.setReg(ir, xtype.Make(t, v)) 821 } 822 } 823 } 824 } 825 func cvtUintptr(ir, ix register, xkind reflect.Kind, xtyp reflect.Type, typ reflect.Type) func(fr *frame) { 826 type T = uintptr 827 t := xtype.TypeOfType(typ) 828 isBasic := typ.PkgPath() == "" 829 if xtyp.PkgPath() == "" { 830 return func(fr *frame) { 831 var v T 832 switch xkind { 833 case reflect.Int: 834 v = T(fr.reg(ix).(int)) 835 case reflect.Int8: 836 v = T(fr.reg(ix).(int8)) 837 case reflect.Int16: 838 v = T(fr.reg(ix).(int16)) 839 case reflect.Int32: 840 v = T(fr.reg(ix).(int32)) 841 case reflect.Int64: 842 v = T(fr.reg(ix).(int64)) 843 case reflect.Uint: 844 v = T(fr.reg(ix).(uint)) 845 case reflect.Uint8: 846 v = T(fr.reg(ix).(uint8)) 847 case reflect.Uint16: 848 v = T(fr.reg(ix).(uint16)) 849 case reflect.Uint32: 850 v = T(fr.reg(ix).(uint32)) 851 case reflect.Uint64: 852 v = T(fr.reg(ix).(uint64)) 853 case reflect.Uintptr: 854 v = T(fr.reg(ix).(uintptr)) 855 case reflect.Float32: 856 v = T(fr.reg(ix).(float32)) 857 case reflect.Float64: 858 v = T(fr.reg(ix).(float64)) 859 } 860 if isBasic { 861 fr.setReg(ir, v) 862 } else { 863 fr.setReg(ir, xtype.Make(t, v)) 864 } 865 } 866 } else { 867 return func(fr *frame) { 868 var v T 869 switch xkind { 870 case reflect.Int: 871 v = T(fr.int(ix)) 872 case reflect.Int8: 873 v = T(fr.int8(ix)) 874 case reflect.Int16: 875 v = T(fr.int16(ix)) 876 case reflect.Int32: 877 v = T(fr.int32(ix)) 878 case reflect.Int64: 879 v = T(fr.int64(ix)) 880 case reflect.Uint: 881 v = T(fr.uint(ix)) 882 case reflect.Uint8: 883 v = T(fr.uint8(ix)) 884 case reflect.Uint16: 885 v = T(fr.uint16(ix)) 886 case reflect.Uint32: 887 v = T(fr.uint32(ix)) 888 case reflect.Uint64: 889 v = T(fr.uint64(ix)) 890 case reflect.Uintptr: 891 v = T(fr.uintptr(ix)) 892 case reflect.Float32: 893 v = T(fr.float32(ix)) 894 case reflect.Float64: 895 v = T(fr.float64(ix)) 896 } 897 if isBasic { 898 fr.setReg(ir, v) 899 } else { 900 fr.setReg(ir, xtype.Make(t, v)) 901 } 902 } 903 } 904 } 905 func cvtFloat32(ir, ix register, xkind reflect.Kind, xtyp reflect.Type, typ reflect.Type) func(fr *frame) { 906 type T = float32 907 t := xtype.TypeOfType(typ) 908 isBasic := typ.PkgPath() == "" 909 if xtyp.PkgPath() == "" { 910 return func(fr *frame) { 911 var v T 912 switch xkind { 913 case reflect.Int: 914 v = T(fr.reg(ix).(int)) 915 case reflect.Int8: 916 v = T(fr.reg(ix).(int8)) 917 case reflect.Int16: 918 v = T(fr.reg(ix).(int16)) 919 case reflect.Int32: 920 v = T(fr.reg(ix).(int32)) 921 case reflect.Int64: 922 v = T(fr.reg(ix).(int64)) 923 case reflect.Uint: 924 v = T(fr.reg(ix).(uint)) 925 case reflect.Uint8: 926 v = T(fr.reg(ix).(uint8)) 927 case reflect.Uint16: 928 v = T(fr.reg(ix).(uint16)) 929 case reflect.Uint32: 930 v = T(fr.reg(ix).(uint32)) 931 case reflect.Uint64: 932 v = T(fr.reg(ix).(uint64)) 933 case reflect.Uintptr: 934 v = T(fr.reg(ix).(uintptr)) 935 case reflect.Float32: 936 v = T(fr.reg(ix).(float32)) 937 case reflect.Float64: 938 v = T(fr.reg(ix).(float64)) 939 } 940 if isBasic { 941 fr.setReg(ir, v) 942 } else { 943 fr.setReg(ir, xtype.Make(t, v)) 944 } 945 } 946 } else { 947 return func(fr *frame) { 948 var v T 949 switch xkind { 950 case reflect.Int: 951 v = T(fr.int(ix)) 952 case reflect.Int8: 953 v = T(fr.int8(ix)) 954 case reflect.Int16: 955 v = T(fr.int16(ix)) 956 case reflect.Int32: 957 v = T(fr.int32(ix)) 958 case reflect.Int64: 959 v = T(fr.int64(ix)) 960 case reflect.Uint: 961 v = T(fr.uint(ix)) 962 case reflect.Uint8: 963 v = T(fr.uint8(ix)) 964 case reflect.Uint16: 965 v = T(fr.uint16(ix)) 966 case reflect.Uint32: 967 v = T(fr.uint32(ix)) 968 case reflect.Uint64: 969 v = T(fr.uint64(ix)) 970 case reflect.Uintptr: 971 v = T(fr.uintptr(ix)) 972 case reflect.Float32: 973 v = T(fr.float32(ix)) 974 case reflect.Float64: 975 v = T(fr.float64(ix)) 976 } 977 if isBasic { 978 fr.setReg(ir, v) 979 } else { 980 fr.setReg(ir, xtype.Make(t, v)) 981 } 982 } 983 } 984 } 985 func cvtFloat64(ir, ix register, xkind reflect.Kind, xtyp reflect.Type, typ reflect.Type) func(fr *frame) { 986 type T = float64 987 t := xtype.TypeOfType(typ) 988 isBasic := typ.PkgPath() == "" 989 if xtyp.PkgPath() == "" { 990 return func(fr *frame) { 991 var v T 992 switch xkind { 993 case reflect.Int: 994 v = T(fr.reg(ix).(int)) 995 case reflect.Int8: 996 v = T(fr.reg(ix).(int8)) 997 case reflect.Int16: 998 v = T(fr.reg(ix).(int16)) 999 case reflect.Int32: 1000 v = T(fr.reg(ix).(int32)) 1001 case reflect.Int64: 1002 v = T(fr.reg(ix).(int64)) 1003 case reflect.Uint: 1004 v = T(fr.reg(ix).(uint)) 1005 case reflect.Uint8: 1006 v = T(fr.reg(ix).(uint8)) 1007 case reflect.Uint16: 1008 v = T(fr.reg(ix).(uint16)) 1009 case reflect.Uint32: 1010 v = T(fr.reg(ix).(uint32)) 1011 case reflect.Uint64: 1012 v = T(fr.reg(ix).(uint64)) 1013 case reflect.Uintptr: 1014 v = T(fr.reg(ix).(uintptr)) 1015 case reflect.Float32: 1016 v = T(fr.reg(ix).(float32)) 1017 case reflect.Float64: 1018 v = T(fr.reg(ix).(float64)) 1019 } 1020 if isBasic { 1021 fr.setReg(ir, v) 1022 } else { 1023 fr.setReg(ir, xtype.Make(t, v)) 1024 } 1025 } 1026 } else { 1027 return func(fr *frame) { 1028 var v T 1029 switch xkind { 1030 case reflect.Int: 1031 v = T(fr.int(ix)) 1032 case reflect.Int8: 1033 v = T(fr.int8(ix)) 1034 case reflect.Int16: 1035 v = T(fr.int16(ix)) 1036 case reflect.Int32: 1037 v = T(fr.int32(ix)) 1038 case reflect.Int64: 1039 v = T(fr.int64(ix)) 1040 case reflect.Uint: 1041 v = T(fr.uint(ix)) 1042 case reflect.Uint8: 1043 v = T(fr.uint8(ix)) 1044 case reflect.Uint16: 1045 v = T(fr.uint16(ix)) 1046 case reflect.Uint32: 1047 v = T(fr.uint32(ix)) 1048 case reflect.Uint64: 1049 v = T(fr.uint64(ix)) 1050 case reflect.Uintptr: 1051 v = T(fr.uintptr(ix)) 1052 case reflect.Float32: 1053 v = T(fr.float32(ix)) 1054 case reflect.Float64: 1055 v = T(fr.float64(ix)) 1056 } 1057 if isBasic { 1058 fr.setReg(ir, v) 1059 } else { 1060 fr.setReg(ir, xtype.Make(t, v)) 1061 } 1062 } 1063 } 1064 } 1065 func cvtComplex64(ir, ix register, xkind reflect.Kind, xtyp reflect.Type, typ reflect.Type) func(fr *frame) { 1066 type T = complex64 1067 t := xtype.TypeOfType(typ) 1068 isBasic := typ.PkgPath() == "" 1069 if xtyp.PkgPath() == "" { 1070 return func(fr *frame) { 1071 var v T 1072 switch xkind { 1073 case reflect.Complex64: 1074 v = T(fr.reg(ix).(complex64)) 1075 case reflect.Complex128: 1076 v = T(fr.reg(ix).(complex128)) 1077 } 1078 if isBasic { 1079 fr.setReg(ir, v) 1080 } else { 1081 fr.setReg(ir, xtype.Make(t, v)) 1082 } 1083 } 1084 } else { 1085 return func(fr *frame) { 1086 var v T 1087 switch xkind { 1088 case reflect.Complex64: 1089 v = T(fr.complex64(ix)) 1090 case reflect.Complex128: 1091 v = T(fr.complex128(ix)) 1092 } 1093 if isBasic { 1094 fr.setReg(ir, v) 1095 } else { 1096 fr.setReg(ir, xtype.Make(t, v)) 1097 } 1098 } 1099 } 1100 } 1101 func cvtComplex128(ir, ix register, xkind reflect.Kind, xtyp reflect.Type, typ reflect.Type) func(fr *frame) { 1102 type T = complex128 1103 t := xtype.TypeOfType(typ) 1104 isBasic := typ.PkgPath() == "" 1105 if xtyp.PkgPath() == "" { 1106 return func(fr *frame) { 1107 var v T 1108 switch xkind { 1109 case reflect.Complex64: 1110 v = T(fr.reg(ix).(complex64)) 1111 case reflect.Complex128: 1112 v = T(fr.reg(ix).(complex128)) 1113 } 1114 if isBasic { 1115 fr.setReg(ir, v) 1116 } else { 1117 fr.setReg(ir, xtype.Make(t, v)) 1118 } 1119 } 1120 } else { 1121 return func(fr *frame) { 1122 var v T 1123 switch xkind { 1124 case reflect.Complex64: 1125 v = T(fr.complex64(ix)) 1126 case reflect.Complex128: 1127 v = T(fr.complex128(ix)) 1128 } 1129 if isBasic { 1130 fr.setReg(ir, v) 1131 } else { 1132 fr.setReg(ir, xtype.Make(t, v)) 1133 } 1134 } 1135 } 1136 }