github.com/HaHadaxigua/yaegi@v1.0.1/interp/op.go (about) 1 package interp 2 3 // Code generated by 'go run ../internal/cmd/genop/genop.go'. DO NOT EDIT. 4 5 import ( 6 "go/constant" 7 "go/token" 8 "reflect" 9 ) 10 11 // Arithmetic operators 12 13 func add(n *node) { 14 next := getExec(n.tnext) 15 typ := n.typ.concrete().TypeOf() 16 isInterface := n.typ.TypeOf().Kind() == reflect.Interface 17 dest := genValueOutput(n, typ) 18 c0, c1 := n.child[0], n.child[1] 19 20 switch typ.Kind() { 21 case reflect.String: 22 switch { 23 case isInterface: 24 v0 := genValue(c0) 25 v1 := genValue(c1) 26 n.exec = func(f *frame) bltn { 27 dest(f).Set(reflect.ValueOf(v0(f).String() + v1(f).String()).Convert(typ)) 28 return next 29 } 30 case c0.rval.IsValid(): 31 s0 := vString(c0.rval) 32 v1 := genValue(c1) 33 n.exec = func(f *frame) bltn { 34 dest(f).SetString(s0 + v1(f).String()) 35 return next 36 } 37 case c1.rval.IsValid(): 38 v0 := genValue(c0) 39 s1 := vString(c1.rval) 40 n.exec = func(f *frame) bltn { 41 dest(f).SetString(v0(f).String() + s1) 42 return next 43 } 44 default: 45 v0 := genValue(c0) 46 v1 := genValue(c1) 47 n.exec = func(f *frame) bltn { 48 dest(f).SetString(v0(f).String() + v1(f).String()) 49 return next 50 } 51 } 52 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 53 switch { 54 case isInterface: 55 v0 := genValueInt(c0) 56 v1 := genValueInt(c1) 57 n.exec = func(f *frame) bltn { 58 _, i := v0(f) 59 _, j := v1(f) 60 dest(f).Set(reflect.ValueOf(i + j).Convert(typ)) 61 return next 62 } 63 case c0.rval.IsValid(): 64 i := vInt(c0.rval) 65 v1 := genValueInt(c1) 66 n.exec = func(f *frame) bltn { 67 _, j := v1(f) 68 dest(f).SetInt(i + j) 69 return next 70 } 71 case c1.rval.IsValid(): 72 v0 := genValueInt(c0) 73 j := vInt(c1.rval) 74 n.exec = func(f *frame) bltn { 75 _, i := v0(f) 76 dest(f).SetInt(i + j) 77 return next 78 } 79 default: 80 v0 := genValueInt(c0) 81 v1 := genValueInt(c1) 82 n.exec = func(f *frame) bltn { 83 _, i := v0(f) 84 _, j := v1(f) 85 dest(f).SetInt(i + j) 86 return next 87 } 88 } 89 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 90 switch { 91 case isInterface: 92 v0 := genValueUint(c0) 93 v1 := genValueUint(c1) 94 n.exec = func(f *frame) bltn { 95 _, i := v0(f) 96 _, j := v1(f) 97 dest(f).Set(reflect.ValueOf(i + j).Convert(typ)) 98 return next 99 } 100 case c0.rval.IsValid(): 101 i := vUint(c0.rval) 102 v1 := genValueUint(c1) 103 n.exec = func(f *frame) bltn { 104 _, j := v1(f) 105 dest(f).SetUint(i + j) 106 return next 107 } 108 case c1.rval.IsValid(): 109 j := vUint(c1.rval) 110 v0 := genValueUint(c0) 111 n.exec = func(f *frame) bltn { 112 _, i := v0(f) 113 dest(f).SetUint(i + j) 114 return next 115 } 116 default: 117 v0 := genValueUint(c0) 118 v1 := genValueUint(c1) 119 n.exec = func(f *frame) bltn { 120 _, i := v0(f) 121 _, j := v1(f) 122 dest(f).SetUint(i + j) 123 return next 124 } 125 } 126 case reflect.Float32, reflect.Float64: 127 switch { 128 case isInterface: 129 v0 := genValueFloat(c0) 130 v1 := genValueFloat(c1) 131 n.exec = func(f *frame) bltn { 132 _, i := v0(f) 133 _, j := v1(f) 134 dest(f).Set(reflect.ValueOf(i + j).Convert(typ)) 135 return next 136 } 137 case c0.rval.IsValid(): 138 i := vFloat(c0.rval) 139 v1 := genValueFloat(c1) 140 n.exec = func(f *frame) bltn { 141 _, j := v1(f) 142 dest(f).SetFloat(i + j) 143 return next 144 } 145 case c1.rval.IsValid(): 146 j := vFloat(c1.rval) 147 v0 := genValueFloat(c0) 148 n.exec = func(f *frame) bltn { 149 _, i := v0(f) 150 dest(f).SetFloat(i + j) 151 return next 152 } 153 default: 154 v0 := genValueFloat(c0) 155 v1 := genValueFloat(c1) 156 n.exec = func(f *frame) bltn { 157 _, i := v0(f) 158 _, j := v1(f) 159 dest(f).SetFloat(i + j) 160 return next 161 } 162 } 163 case reflect.Complex64, reflect.Complex128: 164 switch { 165 case isInterface: 166 v0 := genComplex(c0) 167 v1 := genComplex(c1) 168 n.exec = func(f *frame) bltn { 169 dest(f).Set(reflect.ValueOf(v0(f) + v1(f)).Convert(typ)) 170 return next 171 } 172 case c0.rval.IsValid(): 173 r0 := vComplex(c0.rval) 174 v1 := genComplex(c1) 175 n.exec = func(f *frame) bltn { 176 dest(f).SetComplex(r0 + v1(f)) 177 return next 178 } 179 case c1.rval.IsValid(): 180 r1 := vComplex(c1.rval) 181 v0 := genComplex(c0) 182 n.exec = func(f *frame) bltn { 183 dest(f).SetComplex(v0(f) + r1) 184 return next 185 } 186 default: 187 v0 := genComplex(c0) 188 v1 := genComplex(c1) 189 n.exec = func(f *frame) bltn { 190 dest(f).SetComplex(v0(f) + v1(f)) 191 return next 192 } 193 } 194 } 195 } 196 197 func addConst(n *node) { 198 v0, v1 := n.child[0].rval, n.child[1].rval 199 isConst := (v0.IsValid() && isConstantValue(v0.Type())) && (v1.IsValid() && isConstantValue(v1.Type())) 200 t := n.typ.rtype 201 if isConst { 202 t = constVal 203 } 204 n.rval = reflect.New(t).Elem() 205 switch { 206 case isConst: 207 v := constant.BinaryOp(vConstantValue(v0), token.ADD, vConstantValue(v1)) 208 n.rval.Set(reflect.ValueOf(v)) 209 case isString(t): 210 n.rval.SetString(vString(v0) + vString(v1)) 211 case isComplex(t): 212 n.rval.SetComplex(vComplex(v0) + vComplex(v1)) 213 case isFloat(t): 214 n.rval.SetFloat(vFloat(v0) + vFloat(v1)) 215 case isUint(t): 216 n.rval.SetUint(vUint(v0) + vUint(v1)) 217 case isInt(t): 218 n.rval.SetInt(vInt(v0) + vInt(v1)) 219 } 220 } 221 222 func and(n *node) { 223 next := getExec(n.tnext) 224 typ := n.typ.concrete().TypeOf() 225 isInterface := n.typ.TypeOf().Kind() == reflect.Interface 226 dest := genValueOutput(n, typ) 227 c0, c1 := n.child[0], n.child[1] 228 229 switch typ.Kind() { 230 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 231 switch { 232 case isInterface: 233 v0 := genValueInt(c0) 234 v1 := genValueInt(c1) 235 n.exec = func(f *frame) bltn { 236 _, i := v0(f) 237 _, j := v1(f) 238 dest(f).Set(reflect.ValueOf(i & j).Convert(typ)) 239 return next 240 } 241 case c0.rval.IsValid(): 242 i := vInt(c0.rval) 243 v1 := genValueInt(c1) 244 n.exec = func(f *frame) bltn { 245 _, j := v1(f) 246 dest(f).SetInt(i & j) 247 return next 248 } 249 case c1.rval.IsValid(): 250 v0 := genValueInt(c0) 251 j := vInt(c1.rval) 252 n.exec = func(f *frame) bltn { 253 _, i := v0(f) 254 dest(f).SetInt(i & j) 255 return next 256 } 257 default: 258 v0 := genValueInt(c0) 259 v1 := genValueInt(c1) 260 n.exec = func(f *frame) bltn { 261 _, i := v0(f) 262 _, j := v1(f) 263 dest(f).SetInt(i & j) 264 return next 265 } 266 } 267 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 268 switch { 269 case isInterface: 270 v0 := genValueUint(c0) 271 v1 := genValueUint(c1) 272 n.exec = func(f *frame) bltn { 273 _, i := v0(f) 274 _, j := v1(f) 275 dest(f).Set(reflect.ValueOf(i & j).Convert(typ)) 276 return next 277 } 278 case c0.rval.IsValid(): 279 i := vUint(c0.rval) 280 v1 := genValueUint(c1) 281 n.exec = func(f *frame) bltn { 282 _, j := v1(f) 283 dest(f).SetUint(i & j) 284 return next 285 } 286 case c1.rval.IsValid(): 287 j := vUint(c1.rval) 288 v0 := genValueUint(c0) 289 n.exec = func(f *frame) bltn { 290 _, i := v0(f) 291 dest(f).SetUint(i & j) 292 return next 293 } 294 default: 295 v0 := genValueUint(c0) 296 v1 := genValueUint(c1) 297 n.exec = func(f *frame) bltn { 298 _, i := v0(f) 299 _, j := v1(f) 300 dest(f).SetUint(i & j) 301 return next 302 } 303 } 304 } 305 } 306 307 func andConst(n *node) { 308 v0, v1 := n.child[0].rval, n.child[1].rval 309 isConst := (v0.IsValid() && isConstantValue(v0.Type())) && (v1.IsValid() && isConstantValue(v1.Type())) 310 t := n.typ.rtype 311 if isConst { 312 t = constVal 313 } 314 n.rval = reflect.New(t).Elem() 315 switch { 316 case isConst: 317 v := constant.BinaryOp(constant.ToInt(vConstantValue(v0)), token.AND, constant.ToInt(vConstantValue(v1))) 318 n.rval.Set(reflect.ValueOf(v)) 319 case isUint(t): 320 n.rval.SetUint(vUint(v0) & vUint(v1)) 321 case isInt(t): 322 n.rval.SetInt(vInt(v0) & vInt(v1)) 323 } 324 } 325 326 func andNot(n *node) { 327 next := getExec(n.tnext) 328 typ := n.typ.concrete().TypeOf() 329 isInterface := n.typ.TypeOf().Kind() == reflect.Interface 330 dest := genValueOutput(n, typ) 331 c0, c1 := n.child[0], n.child[1] 332 333 switch typ.Kind() { 334 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 335 switch { 336 case isInterface: 337 v0 := genValueInt(c0) 338 v1 := genValueInt(c1) 339 n.exec = func(f *frame) bltn { 340 _, i := v0(f) 341 _, j := v1(f) 342 dest(f).Set(reflect.ValueOf(i &^ j).Convert(typ)) 343 return next 344 } 345 case c0.rval.IsValid(): 346 i := vInt(c0.rval) 347 v1 := genValueInt(c1) 348 n.exec = func(f *frame) bltn { 349 _, j := v1(f) 350 dest(f).SetInt(i &^ j) 351 return next 352 } 353 case c1.rval.IsValid(): 354 v0 := genValueInt(c0) 355 j := vInt(c1.rval) 356 n.exec = func(f *frame) bltn { 357 _, i := v0(f) 358 dest(f).SetInt(i &^ j) 359 return next 360 } 361 default: 362 v0 := genValueInt(c0) 363 v1 := genValueInt(c1) 364 n.exec = func(f *frame) bltn { 365 _, i := v0(f) 366 _, j := v1(f) 367 dest(f).SetInt(i &^ j) 368 return next 369 } 370 } 371 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 372 switch { 373 case isInterface: 374 v0 := genValueUint(c0) 375 v1 := genValueUint(c1) 376 n.exec = func(f *frame) bltn { 377 _, i := v0(f) 378 _, j := v1(f) 379 dest(f).Set(reflect.ValueOf(i &^ j).Convert(typ)) 380 return next 381 } 382 case c0.rval.IsValid(): 383 i := vUint(c0.rval) 384 v1 := genValueUint(c1) 385 n.exec = func(f *frame) bltn { 386 _, j := v1(f) 387 dest(f).SetUint(i &^ j) 388 return next 389 } 390 case c1.rval.IsValid(): 391 j := vUint(c1.rval) 392 v0 := genValueUint(c0) 393 n.exec = func(f *frame) bltn { 394 _, i := v0(f) 395 dest(f).SetUint(i &^ j) 396 return next 397 } 398 default: 399 v0 := genValueUint(c0) 400 v1 := genValueUint(c1) 401 n.exec = func(f *frame) bltn { 402 _, i := v0(f) 403 _, j := v1(f) 404 dest(f).SetUint(i &^ j) 405 return next 406 } 407 } 408 } 409 } 410 411 func andNotConst(n *node) { 412 v0, v1 := n.child[0].rval, n.child[1].rval 413 isConst := (v0.IsValid() && isConstantValue(v0.Type())) && (v1.IsValid() && isConstantValue(v1.Type())) 414 t := n.typ.rtype 415 if isConst { 416 t = constVal 417 } 418 n.rval = reflect.New(t).Elem() 419 switch { 420 case isConst: 421 v := constant.BinaryOp(constant.ToInt(vConstantValue(v0)), token.AND_NOT, constant.ToInt(vConstantValue(v1))) 422 n.rval.Set(reflect.ValueOf(v)) 423 case isUint(t): 424 n.rval.SetUint(vUint(v0) &^ vUint(v1)) 425 case isInt(t): 426 n.rval.SetInt(vInt(v0) &^ vInt(v1)) 427 } 428 } 429 430 func mul(n *node) { 431 next := getExec(n.tnext) 432 typ := n.typ.concrete().TypeOf() 433 isInterface := n.typ.TypeOf().Kind() == reflect.Interface 434 dest := genValueOutput(n, typ) 435 c0, c1 := n.child[0], n.child[1] 436 437 switch typ.Kind() { 438 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 439 switch { 440 case isInterface: 441 v0 := genValueInt(c0) 442 v1 := genValueInt(c1) 443 n.exec = func(f *frame) bltn { 444 _, i := v0(f) 445 _, j := v1(f) 446 dest(f).Set(reflect.ValueOf(i * j).Convert(typ)) 447 return next 448 } 449 case c0.rval.IsValid(): 450 i := vInt(c0.rval) 451 v1 := genValueInt(c1) 452 n.exec = func(f *frame) bltn { 453 _, j := v1(f) 454 dest(f).SetInt(i * j) 455 return next 456 } 457 case c1.rval.IsValid(): 458 v0 := genValueInt(c0) 459 j := vInt(c1.rval) 460 n.exec = func(f *frame) bltn { 461 _, i := v0(f) 462 dest(f).SetInt(i * j) 463 return next 464 } 465 default: 466 v0 := genValueInt(c0) 467 v1 := genValueInt(c1) 468 n.exec = func(f *frame) bltn { 469 _, i := v0(f) 470 _, j := v1(f) 471 dest(f).SetInt(i * j) 472 return next 473 } 474 } 475 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 476 switch { 477 case isInterface: 478 v0 := genValueUint(c0) 479 v1 := genValueUint(c1) 480 n.exec = func(f *frame) bltn { 481 _, i := v0(f) 482 _, j := v1(f) 483 dest(f).Set(reflect.ValueOf(i * j).Convert(typ)) 484 return next 485 } 486 case c0.rval.IsValid(): 487 i := vUint(c0.rval) 488 v1 := genValueUint(c1) 489 n.exec = func(f *frame) bltn { 490 _, j := v1(f) 491 dest(f).SetUint(i * j) 492 return next 493 } 494 case c1.rval.IsValid(): 495 j := vUint(c1.rval) 496 v0 := genValueUint(c0) 497 n.exec = func(f *frame) bltn { 498 _, i := v0(f) 499 dest(f).SetUint(i * j) 500 return next 501 } 502 default: 503 v0 := genValueUint(c0) 504 v1 := genValueUint(c1) 505 n.exec = func(f *frame) bltn { 506 _, i := v0(f) 507 _, j := v1(f) 508 dest(f).SetUint(i * j) 509 return next 510 } 511 } 512 case reflect.Float32, reflect.Float64: 513 switch { 514 case isInterface: 515 v0 := genValueFloat(c0) 516 v1 := genValueFloat(c1) 517 n.exec = func(f *frame) bltn { 518 _, i := v0(f) 519 _, j := v1(f) 520 dest(f).Set(reflect.ValueOf(i * j).Convert(typ)) 521 return next 522 } 523 case c0.rval.IsValid(): 524 i := vFloat(c0.rval) 525 v1 := genValueFloat(c1) 526 n.exec = func(f *frame) bltn { 527 _, j := v1(f) 528 dest(f).SetFloat(i * j) 529 return next 530 } 531 case c1.rval.IsValid(): 532 j := vFloat(c1.rval) 533 v0 := genValueFloat(c0) 534 n.exec = func(f *frame) bltn { 535 _, i := v0(f) 536 dest(f).SetFloat(i * j) 537 return next 538 } 539 default: 540 v0 := genValueFloat(c0) 541 v1 := genValueFloat(c1) 542 n.exec = func(f *frame) bltn { 543 _, i := v0(f) 544 _, j := v1(f) 545 dest(f).SetFloat(i * j) 546 return next 547 } 548 } 549 case reflect.Complex64, reflect.Complex128: 550 switch { 551 case isInterface: 552 v0 := genComplex(c0) 553 v1 := genComplex(c1) 554 n.exec = func(f *frame) bltn { 555 dest(f).Set(reflect.ValueOf(v0(f) * v1(f)).Convert(typ)) 556 return next 557 } 558 case c0.rval.IsValid(): 559 r0 := vComplex(c0.rval) 560 v1 := genComplex(c1) 561 n.exec = func(f *frame) bltn { 562 dest(f).SetComplex(r0 * v1(f)) 563 return next 564 } 565 case c1.rval.IsValid(): 566 r1 := vComplex(c1.rval) 567 v0 := genComplex(c0) 568 n.exec = func(f *frame) bltn { 569 dest(f).SetComplex(v0(f) * r1) 570 return next 571 } 572 default: 573 v0 := genComplex(c0) 574 v1 := genComplex(c1) 575 n.exec = func(f *frame) bltn { 576 dest(f).SetComplex(v0(f) * v1(f)) 577 return next 578 } 579 } 580 } 581 } 582 583 func mulConst(n *node) { 584 v0, v1 := n.child[0].rval, n.child[1].rval 585 isConst := (v0.IsValid() && isConstantValue(v0.Type())) && (v1.IsValid() && isConstantValue(v1.Type())) 586 t := n.typ.rtype 587 if isConst { 588 t = constVal 589 } 590 n.rval = reflect.New(t).Elem() 591 switch { 592 case isConst: 593 v := constant.BinaryOp(vConstantValue(v0), token.MUL, vConstantValue(v1)) 594 n.rval.Set(reflect.ValueOf(v)) 595 case isComplex(t): 596 n.rval.SetComplex(vComplex(v0) * vComplex(v1)) 597 case isFloat(t): 598 n.rval.SetFloat(vFloat(v0) * vFloat(v1)) 599 case isUint(t): 600 n.rval.SetUint(vUint(v0) * vUint(v1)) 601 case isInt(t): 602 n.rval.SetInt(vInt(v0) * vInt(v1)) 603 } 604 } 605 606 func or(n *node) { 607 next := getExec(n.tnext) 608 typ := n.typ.concrete().TypeOf() 609 isInterface := n.typ.TypeOf().Kind() == reflect.Interface 610 dest := genValueOutput(n, typ) 611 c0, c1 := n.child[0], n.child[1] 612 613 switch typ.Kind() { 614 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 615 switch { 616 case isInterface: 617 v0 := genValueInt(c0) 618 v1 := genValueInt(c1) 619 n.exec = func(f *frame) bltn { 620 _, i := v0(f) 621 _, j := v1(f) 622 dest(f).Set(reflect.ValueOf(i | j).Convert(typ)) 623 return next 624 } 625 case c0.rval.IsValid(): 626 i := vInt(c0.rval) 627 v1 := genValueInt(c1) 628 n.exec = func(f *frame) bltn { 629 _, j := v1(f) 630 dest(f).SetInt(i | j) 631 return next 632 } 633 case c1.rval.IsValid(): 634 v0 := genValueInt(c0) 635 j := vInt(c1.rval) 636 n.exec = func(f *frame) bltn { 637 _, i := v0(f) 638 dest(f).SetInt(i | j) 639 return next 640 } 641 default: 642 v0 := genValueInt(c0) 643 v1 := genValueInt(c1) 644 n.exec = func(f *frame) bltn { 645 _, i := v0(f) 646 _, j := v1(f) 647 dest(f).SetInt(i | j) 648 return next 649 } 650 } 651 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 652 switch { 653 case isInterface: 654 v0 := genValueUint(c0) 655 v1 := genValueUint(c1) 656 n.exec = func(f *frame) bltn { 657 _, i := v0(f) 658 _, j := v1(f) 659 dest(f).Set(reflect.ValueOf(i | j).Convert(typ)) 660 return next 661 } 662 case c0.rval.IsValid(): 663 i := vUint(c0.rval) 664 v1 := genValueUint(c1) 665 n.exec = func(f *frame) bltn { 666 _, j := v1(f) 667 dest(f).SetUint(i | j) 668 return next 669 } 670 case c1.rval.IsValid(): 671 j := vUint(c1.rval) 672 v0 := genValueUint(c0) 673 n.exec = func(f *frame) bltn { 674 _, i := v0(f) 675 dest(f).SetUint(i | j) 676 return next 677 } 678 default: 679 v0 := genValueUint(c0) 680 v1 := genValueUint(c1) 681 n.exec = func(f *frame) bltn { 682 _, i := v0(f) 683 _, j := v1(f) 684 dest(f).SetUint(i | j) 685 return next 686 } 687 } 688 } 689 } 690 691 func orConst(n *node) { 692 v0, v1 := n.child[0].rval, n.child[1].rval 693 isConst := (v0.IsValid() && isConstantValue(v0.Type())) && (v1.IsValid() && isConstantValue(v1.Type())) 694 t := n.typ.rtype 695 if isConst { 696 t = constVal 697 } 698 n.rval = reflect.New(t).Elem() 699 switch { 700 case isConst: 701 v := constant.BinaryOp(constant.ToInt(vConstantValue(v0)), token.OR, constant.ToInt(vConstantValue(v1))) 702 n.rval.Set(reflect.ValueOf(v)) 703 case isUint(t): 704 n.rval.SetUint(vUint(v0) | vUint(v1)) 705 case isInt(t): 706 n.rval.SetInt(vInt(v0) | vInt(v1)) 707 } 708 } 709 710 func quo(n *node) { 711 next := getExec(n.tnext) 712 typ := n.typ.concrete().TypeOf() 713 isInterface := n.typ.TypeOf().Kind() == reflect.Interface 714 dest := genValueOutput(n, typ) 715 c0, c1 := n.child[0], n.child[1] 716 717 switch typ.Kind() { 718 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 719 switch { 720 case isInterface: 721 v0 := genValueInt(c0) 722 v1 := genValueInt(c1) 723 n.exec = func(f *frame) bltn { 724 _, i := v0(f) 725 _, j := v1(f) 726 dest(f).Set(reflect.ValueOf(i / j).Convert(typ)) 727 return next 728 } 729 case c0.rval.IsValid(): 730 i := vInt(c0.rval) 731 v1 := genValueInt(c1) 732 n.exec = func(f *frame) bltn { 733 _, j := v1(f) 734 dest(f).SetInt(i / j) 735 return next 736 } 737 case c1.rval.IsValid(): 738 v0 := genValueInt(c0) 739 j := vInt(c1.rval) 740 n.exec = func(f *frame) bltn { 741 _, i := v0(f) 742 dest(f).SetInt(i / j) 743 return next 744 } 745 default: 746 v0 := genValueInt(c0) 747 v1 := genValueInt(c1) 748 n.exec = func(f *frame) bltn { 749 _, i := v0(f) 750 _, j := v1(f) 751 dest(f).SetInt(i / j) 752 return next 753 } 754 } 755 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 756 switch { 757 case isInterface: 758 v0 := genValueUint(c0) 759 v1 := genValueUint(c1) 760 n.exec = func(f *frame) bltn { 761 _, i := v0(f) 762 _, j := v1(f) 763 dest(f).Set(reflect.ValueOf(i / j).Convert(typ)) 764 return next 765 } 766 case c0.rval.IsValid(): 767 i := vUint(c0.rval) 768 v1 := genValueUint(c1) 769 n.exec = func(f *frame) bltn { 770 _, j := v1(f) 771 dest(f).SetUint(i / j) 772 return next 773 } 774 case c1.rval.IsValid(): 775 j := vUint(c1.rval) 776 v0 := genValueUint(c0) 777 n.exec = func(f *frame) bltn { 778 _, i := v0(f) 779 dest(f).SetUint(i / j) 780 return next 781 } 782 default: 783 v0 := genValueUint(c0) 784 v1 := genValueUint(c1) 785 n.exec = func(f *frame) bltn { 786 _, i := v0(f) 787 _, j := v1(f) 788 dest(f).SetUint(i / j) 789 return next 790 } 791 } 792 case reflect.Float32, reflect.Float64: 793 switch { 794 case isInterface: 795 v0 := genValueFloat(c0) 796 v1 := genValueFloat(c1) 797 n.exec = func(f *frame) bltn { 798 _, i := v0(f) 799 _, j := v1(f) 800 dest(f).Set(reflect.ValueOf(i / j).Convert(typ)) 801 return next 802 } 803 case c0.rval.IsValid(): 804 i := vFloat(c0.rval) 805 v1 := genValueFloat(c1) 806 n.exec = func(f *frame) bltn { 807 _, j := v1(f) 808 dest(f).SetFloat(i / j) 809 return next 810 } 811 case c1.rval.IsValid(): 812 j := vFloat(c1.rval) 813 v0 := genValueFloat(c0) 814 n.exec = func(f *frame) bltn { 815 _, i := v0(f) 816 dest(f).SetFloat(i / j) 817 return next 818 } 819 default: 820 v0 := genValueFloat(c0) 821 v1 := genValueFloat(c1) 822 n.exec = func(f *frame) bltn { 823 _, i := v0(f) 824 _, j := v1(f) 825 dest(f).SetFloat(i / j) 826 return next 827 } 828 } 829 case reflect.Complex64, reflect.Complex128: 830 switch { 831 case isInterface: 832 v0 := genComplex(c0) 833 v1 := genComplex(c1) 834 n.exec = func(f *frame) bltn { 835 dest(f).Set(reflect.ValueOf(v0(f) / v1(f)).Convert(typ)) 836 return next 837 } 838 case c0.rval.IsValid(): 839 r0 := vComplex(c0.rval) 840 v1 := genComplex(c1) 841 n.exec = func(f *frame) bltn { 842 dest(f).SetComplex(r0 / v1(f)) 843 return next 844 } 845 case c1.rval.IsValid(): 846 r1 := vComplex(c1.rval) 847 v0 := genComplex(c0) 848 n.exec = func(f *frame) bltn { 849 dest(f).SetComplex(v0(f) / r1) 850 return next 851 } 852 default: 853 v0 := genComplex(c0) 854 v1 := genComplex(c1) 855 n.exec = func(f *frame) bltn { 856 dest(f).SetComplex(v0(f) / v1(f)) 857 return next 858 } 859 } 860 } 861 } 862 863 func quoConst(n *node) { 864 v0, v1 := n.child[0].rval, n.child[1].rval 865 isConst := (v0.IsValid() && isConstantValue(v0.Type())) && (v1.IsValid() && isConstantValue(v1.Type())) 866 t := n.typ.rtype 867 if isConst { 868 t = constVal 869 } 870 n.rval = reflect.New(t).Elem() 871 switch { 872 case isConst: 873 var operator token.Token 874 // When the result of the operation is expected to be an int (because both 875 // operands are ints), we want to force the type of the whole expression to be an 876 // int (and not a float), which is achieved by using the QUO_ASSIGN operator. 877 if n.typ.untyped && isInt(n.typ.rtype) { 878 operator = token.QUO_ASSIGN 879 } else { 880 operator = token.QUO 881 } 882 v := constant.BinaryOp(vConstantValue(v0), operator, vConstantValue(v1)) 883 n.rval.Set(reflect.ValueOf(v)) 884 case isComplex(t): 885 n.rval.SetComplex(vComplex(v0) / vComplex(v1)) 886 case isFloat(t): 887 n.rval.SetFloat(vFloat(v0) / vFloat(v1)) 888 case isUint(t): 889 n.rval.SetUint(vUint(v0) / vUint(v1)) 890 case isInt(t): 891 n.rval.SetInt(vInt(v0) / vInt(v1)) 892 } 893 } 894 895 func rem(n *node) { 896 next := getExec(n.tnext) 897 typ := n.typ.concrete().TypeOf() 898 isInterface := n.typ.TypeOf().Kind() == reflect.Interface 899 dest := genValueOutput(n, typ) 900 c0, c1 := n.child[0], n.child[1] 901 902 switch typ.Kind() { 903 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 904 switch { 905 case isInterface: 906 v0 := genValueInt(c0) 907 v1 := genValueInt(c1) 908 n.exec = func(f *frame) bltn { 909 _, i := v0(f) 910 _, j := v1(f) 911 dest(f).Set(reflect.ValueOf(i % j).Convert(typ)) 912 return next 913 } 914 case c0.rval.IsValid(): 915 i := vInt(c0.rval) 916 v1 := genValueInt(c1) 917 n.exec = func(f *frame) bltn { 918 _, j := v1(f) 919 dest(f).SetInt(i % j) 920 return next 921 } 922 case c1.rval.IsValid(): 923 v0 := genValueInt(c0) 924 j := vInt(c1.rval) 925 n.exec = func(f *frame) bltn { 926 _, i := v0(f) 927 dest(f).SetInt(i % j) 928 return next 929 } 930 default: 931 v0 := genValueInt(c0) 932 v1 := genValueInt(c1) 933 n.exec = func(f *frame) bltn { 934 _, i := v0(f) 935 _, j := v1(f) 936 dest(f).SetInt(i % j) 937 return next 938 } 939 } 940 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 941 switch { 942 case isInterface: 943 v0 := genValueUint(c0) 944 v1 := genValueUint(c1) 945 n.exec = func(f *frame) bltn { 946 _, i := v0(f) 947 _, j := v1(f) 948 dest(f).Set(reflect.ValueOf(i % j).Convert(typ)) 949 return next 950 } 951 case c0.rval.IsValid(): 952 i := vUint(c0.rval) 953 v1 := genValueUint(c1) 954 n.exec = func(f *frame) bltn { 955 _, j := v1(f) 956 dest(f).SetUint(i % j) 957 return next 958 } 959 case c1.rval.IsValid(): 960 j := vUint(c1.rval) 961 v0 := genValueUint(c0) 962 n.exec = func(f *frame) bltn { 963 _, i := v0(f) 964 dest(f).SetUint(i % j) 965 return next 966 } 967 default: 968 v0 := genValueUint(c0) 969 v1 := genValueUint(c1) 970 n.exec = func(f *frame) bltn { 971 _, i := v0(f) 972 _, j := v1(f) 973 dest(f).SetUint(i % j) 974 return next 975 } 976 } 977 } 978 } 979 980 func remConst(n *node) { 981 v0, v1 := n.child[0].rval, n.child[1].rval 982 isConst := (v0.IsValid() && isConstantValue(v0.Type())) && (v1.IsValid() && isConstantValue(v1.Type())) 983 t := n.typ.rtype 984 if isConst { 985 t = constVal 986 } 987 n.rval = reflect.New(t).Elem() 988 switch { 989 case isConst: 990 v := constant.BinaryOp(constant.ToInt(vConstantValue(v0)), token.REM, constant.ToInt(vConstantValue(v1))) 991 n.rval.Set(reflect.ValueOf(v)) 992 case isUint(t): 993 n.rval.SetUint(vUint(v0) % vUint(v1)) 994 case isInt(t): 995 n.rval.SetInt(vInt(v0) % vInt(v1)) 996 } 997 } 998 999 func shl(n *node) { 1000 next := getExec(n.tnext) 1001 typ := n.typ.concrete().TypeOf() 1002 isInterface := n.typ.TypeOf().Kind() == reflect.Interface 1003 dest := genValueOutput(n, typ) 1004 c0, c1 := n.child[0], n.child[1] 1005 1006 switch typ.Kind() { 1007 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 1008 switch { 1009 case isInterface: 1010 v0 := genValueInt(c0) 1011 v1 := genValueUint(c1) 1012 n.exec = func(f *frame) bltn { 1013 _, i := v0(f) 1014 _, j := v1(f) 1015 dest(f).Set(reflect.ValueOf(i << j).Convert(typ)) 1016 return next 1017 } 1018 case c0.rval.IsValid(): 1019 i := vInt(c0.rval) 1020 v1 := genValueUint(c1) 1021 n.exec = func(f *frame) bltn { 1022 _, j := v1(f) 1023 dest(f).SetInt(i << j) 1024 return next 1025 } 1026 case c1.rval.IsValid(): 1027 v0 := genValueInt(c0) 1028 j := vUint(c1.rval) 1029 n.exec = func(f *frame) bltn { 1030 _, i := v0(f) 1031 dest(f).SetInt(i << j) 1032 return next 1033 } 1034 default: 1035 v0 := genValueInt(c0) 1036 v1 := genValueUint(c1) 1037 n.exec = func(f *frame) bltn { 1038 _, i := v0(f) 1039 _, j := v1(f) 1040 dest(f).SetInt(i << j) 1041 return next 1042 } 1043 } 1044 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 1045 switch { 1046 case isInterface: 1047 v0 := genValueUint(c0) 1048 v1 := genValueUint(c1) 1049 n.exec = func(f *frame) bltn { 1050 _, i := v0(f) 1051 _, j := v1(f) 1052 dest(f).Set(reflect.ValueOf(i << j).Convert(typ)) 1053 return next 1054 } 1055 case c0.rval.IsValid(): 1056 i := vUint(c0.rval) 1057 v1 := genValueUint(c1) 1058 n.exec = func(f *frame) bltn { 1059 _, j := v1(f) 1060 dest(f).SetUint(i << j) 1061 return next 1062 } 1063 case c1.rval.IsValid(): 1064 j := vUint(c1.rval) 1065 v0 := genValueUint(c0) 1066 n.exec = func(f *frame) bltn { 1067 _, i := v0(f) 1068 dest(f).SetUint(i << j) 1069 return next 1070 } 1071 default: 1072 v0 := genValueUint(c0) 1073 v1 := genValueUint(c1) 1074 n.exec = func(f *frame) bltn { 1075 _, i := v0(f) 1076 _, j := v1(f) 1077 dest(f).SetUint(i << j) 1078 return next 1079 } 1080 } 1081 } 1082 } 1083 1084 func shlConst(n *node) { 1085 v0, v1 := n.child[0].rval, n.child[1].rval 1086 isConst := (v0.IsValid() && isConstantValue(v0.Type())) 1087 t := n.typ.rtype 1088 if isConst { 1089 t = constVal 1090 } 1091 n.rval = reflect.New(t).Elem() 1092 switch { 1093 case isConst: 1094 v := constant.Shift(vConstantValue(v0), token.SHL, uint(vUint(v1))) 1095 n.rval.Set(reflect.ValueOf(v)) 1096 case isUint(t): 1097 n.rval.SetUint(vUint(v0) << vUint(v1)) 1098 case isInt(t): 1099 n.rval.SetInt(vInt(v0) << vUint(v1)) 1100 } 1101 } 1102 1103 func shr(n *node) { 1104 next := getExec(n.tnext) 1105 typ := n.typ.concrete().TypeOf() 1106 isInterface := n.typ.TypeOf().Kind() == reflect.Interface 1107 dest := genValueOutput(n, typ) 1108 c0, c1 := n.child[0], n.child[1] 1109 1110 switch typ.Kind() { 1111 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 1112 switch { 1113 case isInterface: 1114 v0 := genValueInt(c0) 1115 v1 := genValueUint(c1) 1116 n.exec = func(f *frame) bltn { 1117 _, i := v0(f) 1118 _, j := v1(f) 1119 dest(f).Set(reflect.ValueOf(i >> j).Convert(typ)) 1120 return next 1121 } 1122 case c0.rval.IsValid(): 1123 i := vInt(c0.rval) 1124 v1 := genValueUint(c1) 1125 n.exec = func(f *frame) bltn { 1126 _, j := v1(f) 1127 dest(f).SetInt(i >> j) 1128 return next 1129 } 1130 case c1.rval.IsValid(): 1131 v0 := genValueInt(c0) 1132 j := vUint(c1.rval) 1133 n.exec = func(f *frame) bltn { 1134 _, i := v0(f) 1135 dest(f).SetInt(i >> j) 1136 return next 1137 } 1138 default: 1139 v0 := genValueInt(c0) 1140 v1 := genValueUint(c1) 1141 n.exec = func(f *frame) bltn { 1142 _, i := v0(f) 1143 _, j := v1(f) 1144 dest(f).SetInt(i >> j) 1145 return next 1146 } 1147 } 1148 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 1149 switch { 1150 case isInterface: 1151 v0 := genValueUint(c0) 1152 v1 := genValueUint(c1) 1153 n.exec = func(f *frame) bltn { 1154 _, i := v0(f) 1155 _, j := v1(f) 1156 dest(f).Set(reflect.ValueOf(i >> j).Convert(typ)) 1157 return next 1158 } 1159 case c0.rval.IsValid(): 1160 i := vUint(c0.rval) 1161 v1 := genValueUint(c1) 1162 n.exec = func(f *frame) bltn { 1163 _, j := v1(f) 1164 dest(f).SetUint(i >> j) 1165 return next 1166 } 1167 case c1.rval.IsValid(): 1168 j := vUint(c1.rval) 1169 v0 := genValueUint(c0) 1170 n.exec = func(f *frame) bltn { 1171 _, i := v0(f) 1172 dest(f).SetUint(i >> j) 1173 return next 1174 } 1175 default: 1176 v0 := genValueUint(c0) 1177 v1 := genValueUint(c1) 1178 n.exec = func(f *frame) bltn { 1179 _, i := v0(f) 1180 _, j := v1(f) 1181 dest(f).SetUint(i >> j) 1182 return next 1183 } 1184 } 1185 } 1186 } 1187 1188 func shrConst(n *node) { 1189 v0, v1 := n.child[0].rval, n.child[1].rval 1190 isConst := (v0.IsValid() && isConstantValue(v0.Type())) 1191 t := n.typ.rtype 1192 if isConst { 1193 t = constVal 1194 } 1195 n.rval = reflect.New(t).Elem() 1196 switch { 1197 case isConst: 1198 v := constant.Shift(vConstantValue(v0), token.SHR, uint(vUint(v1))) 1199 n.rval.Set(reflect.ValueOf(v)) 1200 case isUint(t): 1201 n.rval.SetUint(vUint(v0) >> vUint(v1)) 1202 case isInt(t): 1203 n.rval.SetInt(vInt(v0) >> vUint(v1)) 1204 } 1205 } 1206 1207 func sub(n *node) { 1208 next := getExec(n.tnext) 1209 typ := n.typ.concrete().TypeOf() 1210 isInterface := n.typ.TypeOf().Kind() == reflect.Interface 1211 dest := genValueOutput(n, typ) 1212 c0, c1 := n.child[0], n.child[1] 1213 1214 switch typ.Kind() { 1215 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 1216 switch { 1217 case isInterface: 1218 v0 := genValueInt(c0) 1219 v1 := genValueInt(c1) 1220 n.exec = func(f *frame) bltn { 1221 _, i := v0(f) 1222 _, j := v1(f) 1223 dest(f).Set(reflect.ValueOf(i - j).Convert(typ)) 1224 return next 1225 } 1226 case c0.rval.IsValid(): 1227 i := vInt(c0.rval) 1228 v1 := genValueInt(c1) 1229 n.exec = func(f *frame) bltn { 1230 _, j := v1(f) 1231 dest(f).SetInt(i - j) 1232 return next 1233 } 1234 case c1.rval.IsValid(): 1235 v0 := genValueInt(c0) 1236 j := vInt(c1.rval) 1237 n.exec = func(f *frame) bltn { 1238 _, i := v0(f) 1239 dest(f).SetInt(i - j) 1240 return next 1241 } 1242 default: 1243 v0 := genValueInt(c0) 1244 v1 := genValueInt(c1) 1245 n.exec = func(f *frame) bltn { 1246 _, i := v0(f) 1247 _, j := v1(f) 1248 dest(f).SetInt(i - j) 1249 return next 1250 } 1251 } 1252 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 1253 switch { 1254 case isInterface: 1255 v0 := genValueUint(c0) 1256 v1 := genValueUint(c1) 1257 n.exec = func(f *frame) bltn { 1258 _, i := v0(f) 1259 _, j := v1(f) 1260 dest(f).Set(reflect.ValueOf(i - j).Convert(typ)) 1261 return next 1262 } 1263 case c0.rval.IsValid(): 1264 i := vUint(c0.rval) 1265 v1 := genValueUint(c1) 1266 n.exec = func(f *frame) bltn { 1267 _, j := v1(f) 1268 dest(f).SetUint(i - j) 1269 return next 1270 } 1271 case c1.rval.IsValid(): 1272 j := vUint(c1.rval) 1273 v0 := genValueUint(c0) 1274 n.exec = func(f *frame) bltn { 1275 _, i := v0(f) 1276 dest(f).SetUint(i - j) 1277 return next 1278 } 1279 default: 1280 v0 := genValueUint(c0) 1281 v1 := genValueUint(c1) 1282 n.exec = func(f *frame) bltn { 1283 _, i := v0(f) 1284 _, j := v1(f) 1285 dest(f).SetUint(i - j) 1286 return next 1287 } 1288 } 1289 case reflect.Float32, reflect.Float64: 1290 switch { 1291 case isInterface: 1292 v0 := genValueFloat(c0) 1293 v1 := genValueFloat(c1) 1294 n.exec = func(f *frame) bltn { 1295 _, i := v0(f) 1296 _, j := v1(f) 1297 dest(f).Set(reflect.ValueOf(i - j).Convert(typ)) 1298 return next 1299 } 1300 case c0.rval.IsValid(): 1301 i := vFloat(c0.rval) 1302 v1 := genValueFloat(c1) 1303 n.exec = func(f *frame) bltn { 1304 _, j := v1(f) 1305 dest(f).SetFloat(i - j) 1306 return next 1307 } 1308 case c1.rval.IsValid(): 1309 j := vFloat(c1.rval) 1310 v0 := genValueFloat(c0) 1311 n.exec = func(f *frame) bltn { 1312 _, i := v0(f) 1313 dest(f).SetFloat(i - j) 1314 return next 1315 } 1316 default: 1317 v0 := genValueFloat(c0) 1318 v1 := genValueFloat(c1) 1319 n.exec = func(f *frame) bltn { 1320 _, i := v0(f) 1321 _, j := v1(f) 1322 dest(f).SetFloat(i - j) 1323 return next 1324 } 1325 } 1326 case reflect.Complex64, reflect.Complex128: 1327 switch { 1328 case isInterface: 1329 v0 := genComplex(c0) 1330 v1 := genComplex(c1) 1331 n.exec = func(f *frame) bltn { 1332 dest(f).Set(reflect.ValueOf(v0(f) - v1(f)).Convert(typ)) 1333 return next 1334 } 1335 case c0.rval.IsValid(): 1336 r0 := vComplex(c0.rval) 1337 v1 := genComplex(c1) 1338 n.exec = func(f *frame) bltn { 1339 dest(f).SetComplex(r0 - v1(f)) 1340 return next 1341 } 1342 case c1.rval.IsValid(): 1343 r1 := vComplex(c1.rval) 1344 v0 := genComplex(c0) 1345 n.exec = func(f *frame) bltn { 1346 dest(f).SetComplex(v0(f) - r1) 1347 return next 1348 } 1349 default: 1350 v0 := genComplex(c0) 1351 v1 := genComplex(c1) 1352 n.exec = func(f *frame) bltn { 1353 dest(f).SetComplex(v0(f) - v1(f)) 1354 return next 1355 } 1356 } 1357 } 1358 } 1359 1360 func subConst(n *node) { 1361 v0, v1 := n.child[0].rval, n.child[1].rval 1362 isConst := (v0.IsValid() && isConstantValue(v0.Type())) && (v1.IsValid() && isConstantValue(v1.Type())) 1363 t := n.typ.rtype 1364 if isConst { 1365 t = constVal 1366 } 1367 n.rval = reflect.New(t).Elem() 1368 switch { 1369 case isConst: 1370 v := constant.BinaryOp(vConstantValue(v0), token.SUB, vConstantValue(v1)) 1371 n.rval.Set(reflect.ValueOf(v)) 1372 case isComplex(t): 1373 n.rval.SetComplex(vComplex(v0) - vComplex(v1)) 1374 case isFloat(t): 1375 n.rval.SetFloat(vFloat(v0) - vFloat(v1)) 1376 case isUint(t): 1377 n.rval.SetUint(vUint(v0) - vUint(v1)) 1378 case isInt(t): 1379 n.rval.SetInt(vInt(v0) - vInt(v1)) 1380 } 1381 } 1382 1383 func xor(n *node) { 1384 next := getExec(n.tnext) 1385 typ := n.typ.concrete().TypeOf() 1386 isInterface := n.typ.TypeOf().Kind() == reflect.Interface 1387 dest := genValueOutput(n, typ) 1388 c0, c1 := n.child[0], n.child[1] 1389 1390 switch typ.Kind() { 1391 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 1392 switch { 1393 case isInterface: 1394 v0 := genValueInt(c0) 1395 v1 := genValueInt(c1) 1396 n.exec = func(f *frame) bltn { 1397 _, i := v0(f) 1398 _, j := v1(f) 1399 dest(f).Set(reflect.ValueOf(i ^ j).Convert(typ)) 1400 return next 1401 } 1402 case c0.rval.IsValid(): 1403 i := vInt(c0.rval) 1404 v1 := genValueInt(c1) 1405 n.exec = func(f *frame) bltn { 1406 _, j := v1(f) 1407 dest(f).SetInt(i ^ j) 1408 return next 1409 } 1410 case c1.rval.IsValid(): 1411 v0 := genValueInt(c0) 1412 j := vInt(c1.rval) 1413 n.exec = func(f *frame) bltn { 1414 _, i := v0(f) 1415 dest(f).SetInt(i ^ j) 1416 return next 1417 } 1418 default: 1419 v0 := genValueInt(c0) 1420 v1 := genValueInt(c1) 1421 n.exec = func(f *frame) bltn { 1422 _, i := v0(f) 1423 _, j := v1(f) 1424 dest(f).SetInt(i ^ j) 1425 return next 1426 } 1427 } 1428 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 1429 switch { 1430 case isInterface: 1431 v0 := genValueUint(c0) 1432 v1 := genValueUint(c1) 1433 n.exec = func(f *frame) bltn { 1434 _, i := v0(f) 1435 _, j := v1(f) 1436 dest(f).Set(reflect.ValueOf(i ^ j).Convert(typ)) 1437 return next 1438 } 1439 case c0.rval.IsValid(): 1440 i := vUint(c0.rval) 1441 v1 := genValueUint(c1) 1442 n.exec = func(f *frame) bltn { 1443 _, j := v1(f) 1444 dest(f).SetUint(i ^ j) 1445 return next 1446 } 1447 case c1.rval.IsValid(): 1448 j := vUint(c1.rval) 1449 v0 := genValueUint(c0) 1450 n.exec = func(f *frame) bltn { 1451 _, i := v0(f) 1452 dest(f).SetUint(i ^ j) 1453 return next 1454 } 1455 default: 1456 v0 := genValueUint(c0) 1457 v1 := genValueUint(c1) 1458 n.exec = func(f *frame) bltn { 1459 _, i := v0(f) 1460 _, j := v1(f) 1461 dest(f).SetUint(i ^ j) 1462 return next 1463 } 1464 } 1465 } 1466 } 1467 1468 func xorConst(n *node) { 1469 v0, v1 := n.child[0].rval, n.child[1].rval 1470 isConst := (v0.IsValid() && isConstantValue(v0.Type())) && (v1.IsValid() && isConstantValue(v1.Type())) 1471 t := n.typ.rtype 1472 if isConst { 1473 t = constVal 1474 } 1475 n.rval = reflect.New(t).Elem() 1476 switch { 1477 case isConst: 1478 v := constant.BinaryOp(constant.ToInt(vConstantValue(v0)), token.XOR, constant.ToInt(vConstantValue(v1))) 1479 n.rval.Set(reflect.ValueOf(v)) 1480 case isUint(t): 1481 n.rval.SetUint(vUint(v0) ^ vUint(v1)) 1482 case isInt(t): 1483 n.rval.SetInt(vInt(v0) ^ vInt(v1)) 1484 } 1485 } 1486 1487 // Assign operators 1488 1489 func addAssign(n *node) { 1490 next := getExec(n.tnext) 1491 typ := n.typ.TypeOf() 1492 c0, c1 := n.child[0], n.child[1] 1493 setMap := isMapEntry(c0) 1494 var mapValue, indexValue func(*frame) reflect.Value 1495 1496 if setMap { 1497 mapValue = genValue(c0.child[0]) 1498 indexValue = genValue(c0.child[1]) 1499 } 1500 1501 if c1.rval.IsValid() { 1502 switch typ.Kind() { 1503 case reflect.String: 1504 v0 := genValueString(c0) 1505 v1 := vString(c1.rval) 1506 n.exec = func(f *frame) bltn { 1507 v, s := v0(f) 1508 v.SetString(s + v1) 1509 if setMap { 1510 mapValue(f).SetMapIndex(indexValue(f), v) 1511 } 1512 return next 1513 } 1514 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 1515 v0 := genValueInt(c0) 1516 j := vInt(c1.rval) 1517 n.exec = func(f *frame) bltn { 1518 v, i := v0(f) 1519 v.SetInt(i + j) 1520 if setMap { 1521 mapValue(f).SetMapIndex(indexValue(f), v) 1522 } 1523 return next 1524 } 1525 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 1526 v0 := genValueUint(c0) 1527 j := vUint(c1.rval) 1528 n.exec = func(f *frame) bltn { 1529 v, i := v0(f) 1530 v.SetUint(i + j) 1531 if setMap { 1532 mapValue(f).SetMapIndex(indexValue(f), v) 1533 } 1534 return next 1535 } 1536 case reflect.Float32, reflect.Float64: 1537 v0 := genValueFloat(c0) 1538 j := vFloat(c1.rval) 1539 n.exec = func(f *frame) bltn { 1540 v, i := v0(f) 1541 v.SetFloat(i + j) 1542 if setMap { 1543 mapValue(f).SetMapIndex(indexValue(f), v) 1544 } 1545 return next 1546 } 1547 case reflect.Complex64, reflect.Complex128: 1548 v0 := genValue(c0) 1549 v1 := vComplex(c1.rval) 1550 n.exec = func(f *frame) bltn { 1551 v := v0(f) 1552 v.SetComplex(v.Complex() + v1) 1553 if setMap { 1554 mapValue(f).SetMapIndex(indexValue(f), v) 1555 } 1556 return next 1557 } 1558 } 1559 } else { 1560 switch typ.Kind() { 1561 case reflect.String: 1562 v0 := genValueString(c0) 1563 v1 := genValue(c1) 1564 n.exec = func(f *frame) bltn { 1565 v, s := v0(f) 1566 v.SetString(s + v1(f).String()) 1567 if setMap { 1568 mapValue(f).SetMapIndex(indexValue(f), v) 1569 } 1570 return next 1571 } 1572 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 1573 v0 := genValueInt(c0) 1574 v1 := genValueInt(c1) 1575 n.exec = func(f *frame) bltn { 1576 v, i := v0(f) 1577 _, j := v1(f) 1578 v.SetInt(i + j) 1579 if setMap { 1580 mapValue(f).SetMapIndex(indexValue(f), v) 1581 } 1582 return next 1583 } 1584 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 1585 v0 := genValueUint(c0) 1586 v1 := genValueUint(c1) 1587 n.exec = func(f *frame) bltn { 1588 v, i := v0(f) 1589 _, j := v1(f) 1590 v.SetUint(i + j) 1591 if setMap { 1592 mapValue(f).SetMapIndex(indexValue(f), v) 1593 } 1594 return next 1595 } 1596 case reflect.Float32, reflect.Float64: 1597 v0 := genValueFloat(c0) 1598 v1 := genValueFloat(c1) 1599 n.exec = func(f *frame) bltn { 1600 v, i := v0(f) 1601 _, j := v1(f) 1602 v.SetFloat(i + j) 1603 if setMap { 1604 mapValue(f).SetMapIndex(indexValue(f), v) 1605 } 1606 return next 1607 } 1608 case reflect.Complex64, reflect.Complex128: 1609 v0 := genValue(c0) 1610 v1 := genValue(c1) 1611 n.exec = func(f *frame) bltn { 1612 v := v0(f) 1613 v.SetComplex(v.Complex() + v1(f).Complex()) 1614 if setMap { 1615 mapValue(f).SetMapIndex(indexValue(f), v) 1616 } 1617 return next 1618 } 1619 } 1620 } 1621 } 1622 1623 func andAssign(n *node) { 1624 next := getExec(n.tnext) 1625 typ := n.typ.TypeOf() 1626 c0, c1 := n.child[0], n.child[1] 1627 setMap := isMapEntry(c0) 1628 var mapValue, indexValue func(*frame) reflect.Value 1629 1630 if setMap { 1631 mapValue = genValue(c0.child[0]) 1632 indexValue = genValue(c0.child[1]) 1633 } 1634 1635 if c1.rval.IsValid() { 1636 switch typ.Kind() { 1637 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 1638 v0 := genValueInt(c0) 1639 j := vInt(c1.rval) 1640 n.exec = func(f *frame) bltn { 1641 v, i := v0(f) 1642 v.SetInt(i & j) 1643 if setMap { 1644 mapValue(f).SetMapIndex(indexValue(f), v) 1645 } 1646 return next 1647 } 1648 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 1649 v0 := genValueUint(c0) 1650 j := vUint(c1.rval) 1651 n.exec = func(f *frame) bltn { 1652 v, i := v0(f) 1653 v.SetUint(i & j) 1654 if setMap { 1655 mapValue(f).SetMapIndex(indexValue(f), v) 1656 } 1657 return next 1658 } 1659 } 1660 } else { 1661 switch typ.Kind() { 1662 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 1663 v0 := genValueInt(c0) 1664 v1 := genValueInt(c1) 1665 n.exec = func(f *frame) bltn { 1666 v, i := v0(f) 1667 _, j := v1(f) 1668 v.SetInt(i & j) 1669 if setMap { 1670 mapValue(f).SetMapIndex(indexValue(f), v) 1671 } 1672 return next 1673 } 1674 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 1675 v0 := genValueUint(c0) 1676 v1 := genValueUint(c1) 1677 n.exec = func(f *frame) bltn { 1678 v, i := v0(f) 1679 _, j := v1(f) 1680 v.SetUint(i & j) 1681 if setMap { 1682 mapValue(f).SetMapIndex(indexValue(f), v) 1683 } 1684 return next 1685 } 1686 } 1687 } 1688 } 1689 1690 func andNotAssign(n *node) { 1691 next := getExec(n.tnext) 1692 typ := n.typ.TypeOf() 1693 c0, c1 := n.child[0], n.child[1] 1694 setMap := isMapEntry(c0) 1695 var mapValue, indexValue func(*frame) reflect.Value 1696 1697 if setMap { 1698 mapValue = genValue(c0.child[0]) 1699 indexValue = genValue(c0.child[1]) 1700 } 1701 1702 if c1.rval.IsValid() { 1703 switch typ.Kind() { 1704 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 1705 v0 := genValueInt(c0) 1706 j := vInt(c1.rval) 1707 n.exec = func(f *frame) bltn { 1708 v, i := v0(f) 1709 v.SetInt(i &^ j) 1710 if setMap { 1711 mapValue(f).SetMapIndex(indexValue(f), v) 1712 } 1713 return next 1714 } 1715 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 1716 v0 := genValueUint(c0) 1717 j := vUint(c1.rval) 1718 n.exec = func(f *frame) bltn { 1719 v, i := v0(f) 1720 v.SetUint(i &^ j) 1721 if setMap { 1722 mapValue(f).SetMapIndex(indexValue(f), v) 1723 } 1724 return next 1725 } 1726 } 1727 } else { 1728 switch typ.Kind() { 1729 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 1730 v0 := genValueInt(c0) 1731 v1 := genValueInt(c1) 1732 n.exec = func(f *frame) bltn { 1733 v, i := v0(f) 1734 _, j := v1(f) 1735 v.SetInt(i &^ j) 1736 if setMap { 1737 mapValue(f).SetMapIndex(indexValue(f), v) 1738 } 1739 return next 1740 } 1741 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 1742 v0 := genValueUint(c0) 1743 v1 := genValueUint(c1) 1744 n.exec = func(f *frame) bltn { 1745 v, i := v0(f) 1746 _, j := v1(f) 1747 v.SetUint(i &^ j) 1748 if setMap { 1749 mapValue(f).SetMapIndex(indexValue(f), v) 1750 } 1751 return next 1752 } 1753 } 1754 } 1755 } 1756 1757 func mulAssign(n *node) { 1758 next := getExec(n.tnext) 1759 typ := n.typ.TypeOf() 1760 c0, c1 := n.child[0], n.child[1] 1761 setMap := isMapEntry(c0) 1762 var mapValue, indexValue func(*frame) reflect.Value 1763 1764 if setMap { 1765 mapValue = genValue(c0.child[0]) 1766 indexValue = genValue(c0.child[1]) 1767 } 1768 1769 if c1.rval.IsValid() { 1770 switch typ.Kind() { 1771 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 1772 v0 := genValueInt(c0) 1773 j := vInt(c1.rval) 1774 n.exec = func(f *frame) bltn { 1775 v, i := v0(f) 1776 v.SetInt(i * j) 1777 if setMap { 1778 mapValue(f).SetMapIndex(indexValue(f), v) 1779 } 1780 return next 1781 } 1782 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 1783 v0 := genValueUint(c0) 1784 j := vUint(c1.rval) 1785 n.exec = func(f *frame) bltn { 1786 v, i := v0(f) 1787 v.SetUint(i * j) 1788 if setMap { 1789 mapValue(f).SetMapIndex(indexValue(f), v) 1790 } 1791 return next 1792 } 1793 case reflect.Float32, reflect.Float64: 1794 v0 := genValueFloat(c0) 1795 j := vFloat(c1.rval) 1796 n.exec = func(f *frame) bltn { 1797 v, i := v0(f) 1798 v.SetFloat(i * j) 1799 if setMap { 1800 mapValue(f).SetMapIndex(indexValue(f), v) 1801 } 1802 return next 1803 } 1804 case reflect.Complex64, reflect.Complex128: 1805 v0 := genValue(c0) 1806 v1 := vComplex(c1.rval) 1807 n.exec = func(f *frame) bltn { 1808 v := v0(f) 1809 v.SetComplex(v.Complex() * v1) 1810 if setMap { 1811 mapValue(f).SetMapIndex(indexValue(f), v) 1812 } 1813 return next 1814 } 1815 } 1816 } else { 1817 switch typ.Kind() { 1818 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 1819 v0 := genValueInt(c0) 1820 v1 := genValueInt(c1) 1821 n.exec = func(f *frame) bltn { 1822 v, i := v0(f) 1823 _, j := v1(f) 1824 v.SetInt(i * j) 1825 if setMap { 1826 mapValue(f).SetMapIndex(indexValue(f), v) 1827 } 1828 return next 1829 } 1830 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 1831 v0 := genValueUint(c0) 1832 v1 := genValueUint(c1) 1833 n.exec = func(f *frame) bltn { 1834 v, i := v0(f) 1835 _, j := v1(f) 1836 v.SetUint(i * j) 1837 if setMap { 1838 mapValue(f).SetMapIndex(indexValue(f), v) 1839 } 1840 return next 1841 } 1842 case reflect.Float32, reflect.Float64: 1843 v0 := genValueFloat(c0) 1844 v1 := genValueFloat(c1) 1845 n.exec = func(f *frame) bltn { 1846 v, i := v0(f) 1847 _, j := v1(f) 1848 v.SetFloat(i * j) 1849 if setMap { 1850 mapValue(f).SetMapIndex(indexValue(f), v) 1851 } 1852 return next 1853 } 1854 case reflect.Complex64, reflect.Complex128: 1855 v0 := genValue(c0) 1856 v1 := genValue(c1) 1857 n.exec = func(f *frame) bltn { 1858 v := v0(f) 1859 v.SetComplex(v.Complex() * v1(f).Complex()) 1860 if setMap { 1861 mapValue(f).SetMapIndex(indexValue(f), v) 1862 } 1863 return next 1864 } 1865 } 1866 } 1867 } 1868 1869 func orAssign(n *node) { 1870 next := getExec(n.tnext) 1871 typ := n.typ.TypeOf() 1872 c0, c1 := n.child[0], n.child[1] 1873 setMap := isMapEntry(c0) 1874 var mapValue, indexValue func(*frame) reflect.Value 1875 1876 if setMap { 1877 mapValue = genValue(c0.child[0]) 1878 indexValue = genValue(c0.child[1]) 1879 } 1880 1881 if c1.rval.IsValid() { 1882 switch typ.Kind() { 1883 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 1884 v0 := genValueInt(c0) 1885 j := vInt(c1.rval) 1886 n.exec = func(f *frame) bltn { 1887 v, i := v0(f) 1888 v.SetInt(i | j) 1889 if setMap { 1890 mapValue(f).SetMapIndex(indexValue(f), v) 1891 } 1892 return next 1893 } 1894 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 1895 v0 := genValueUint(c0) 1896 j := vUint(c1.rval) 1897 n.exec = func(f *frame) bltn { 1898 v, i := v0(f) 1899 v.SetUint(i | j) 1900 if setMap { 1901 mapValue(f).SetMapIndex(indexValue(f), v) 1902 } 1903 return next 1904 } 1905 } 1906 } else { 1907 switch typ.Kind() { 1908 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 1909 v0 := genValueInt(c0) 1910 v1 := genValueInt(c1) 1911 n.exec = func(f *frame) bltn { 1912 v, i := v0(f) 1913 _, j := v1(f) 1914 v.SetInt(i | j) 1915 if setMap { 1916 mapValue(f).SetMapIndex(indexValue(f), v) 1917 } 1918 return next 1919 } 1920 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 1921 v0 := genValueUint(c0) 1922 v1 := genValueUint(c1) 1923 n.exec = func(f *frame) bltn { 1924 v, i := v0(f) 1925 _, j := v1(f) 1926 v.SetUint(i | j) 1927 if setMap { 1928 mapValue(f).SetMapIndex(indexValue(f), v) 1929 } 1930 return next 1931 } 1932 } 1933 } 1934 } 1935 1936 func quoAssign(n *node) { 1937 next := getExec(n.tnext) 1938 typ := n.typ.TypeOf() 1939 c0, c1 := n.child[0], n.child[1] 1940 setMap := isMapEntry(c0) 1941 var mapValue, indexValue func(*frame) reflect.Value 1942 1943 if setMap { 1944 mapValue = genValue(c0.child[0]) 1945 indexValue = genValue(c0.child[1]) 1946 } 1947 1948 if c1.rval.IsValid() { 1949 switch typ.Kind() { 1950 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 1951 v0 := genValueInt(c0) 1952 j := vInt(c1.rval) 1953 n.exec = func(f *frame) bltn { 1954 v, i := v0(f) 1955 v.SetInt(i / j) 1956 if setMap { 1957 mapValue(f).SetMapIndex(indexValue(f), v) 1958 } 1959 return next 1960 } 1961 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 1962 v0 := genValueUint(c0) 1963 j := vUint(c1.rval) 1964 n.exec = func(f *frame) bltn { 1965 v, i := v0(f) 1966 v.SetUint(i / j) 1967 if setMap { 1968 mapValue(f).SetMapIndex(indexValue(f), v) 1969 } 1970 return next 1971 } 1972 case reflect.Float32, reflect.Float64: 1973 v0 := genValueFloat(c0) 1974 j := vFloat(c1.rval) 1975 n.exec = func(f *frame) bltn { 1976 v, i := v0(f) 1977 v.SetFloat(i / j) 1978 if setMap { 1979 mapValue(f).SetMapIndex(indexValue(f), v) 1980 } 1981 return next 1982 } 1983 case reflect.Complex64, reflect.Complex128: 1984 v0 := genValue(c0) 1985 v1 := vComplex(c1.rval) 1986 n.exec = func(f *frame) bltn { 1987 v := v0(f) 1988 v.SetComplex(v.Complex() / v1) 1989 if setMap { 1990 mapValue(f).SetMapIndex(indexValue(f), v) 1991 } 1992 return next 1993 } 1994 } 1995 } else { 1996 switch typ.Kind() { 1997 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 1998 v0 := genValueInt(c0) 1999 v1 := genValueInt(c1) 2000 n.exec = func(f *frame) bltn { 2001 v, i := v0(f) 2002 _, j := v1(f) 2003 v.SetInt(i / j) 2004 if setMap { 2005 mapValue(f).SetMapIndex(indexValue(f), v) 2006 } 2007 return next 2008 } 2009 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 2010 v0 := genValueUint(c0) 2011 v1 := genValueUint(c1) 2012 n.exec = func(f *frame) bltn { 2013 v, i := v0(f) 2014 _, j := v1(f) 2015 v.SetUint(i / j) 2016 if setMap { 2017 mapValue(f).SetMapIndex(indexValue(f), v) 2018 } 2019 return next 2020 } 2021 case reflect.Float32, reflect.Float64: 2022 v0 := genValueFloat(c0) 2023 v1 := genValueFloat(c1) 2024 n.exec = func(f *frame) bltn { 2025 v, i := v0(f) 2026 _, j := v1(f) 2027 v.SetFloat(i / j) 2028 if setMap { 2029 mapValue(f).SetMapIndex(indexValue(f), v) 2030 } 2031 return next 2032 } 2033 case reflect.Complex64, reflect.Complex128: 2034 v0 := genValue(c0) 2035 v1 := genValue(c1) 2036 n.exec = func(f *frame) bltn { 2037 v := v0(f) 2038 v.SetComplex(v.Complex() / v1(f).Complex()) 2039 if setMap { 2040 mapValue(f).SetMapIndex(indexValue(f), v) 2041 } 2042 return next 2043 } 2044 } 2045 } 2046 } 2047 2048 func remAssign(n *node) { 2049 next := getExec(n.tnext) 2050 typ := n.typ.TypeOf() 2051 c0, c1 := n.child[0], n.child[1] 2052 setMap := isMapEntry(c0) 2053 var mapValue, indexValue func(*frame) reflect.Value 2054 2055 if setMap { 2056 mapValue = genValue(c0.child[0]) 2057 indexValue = genValue(c0.child[1]) 2058 } 2059 2060 if c1.rval.IsValid() { 2061 switch typ.Kind() { 2062 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 2063 v0 := genValueInt(c0) 2064 j := vInt(c1.rval) 2065 n.exec = func(f *frame) bltn { 2066 v, i := v0(f) 2067 v.SetInt(i % j) 2068 if setMap { 2069 mapValue(f).SetMapIndex(indexValue(f), v) 2070 } 2071 return next 2072 } 2073 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 2074 v0 := genValueUint(c0) 2075 j := vUint(c1.rval) 2076 n.exec = func(f *frame) bltn { 2077 v, i := v0(f) 2078 v.SetUint(i % j) 2079 if setMap { 2080 mapValue(f).SetMapIndex(indexValue(f), v) 2081 } 2082 return next 2083 } 2084 } 2085 } else { 2086 switch typ.Kind() { 2087 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 2088 v0 := genValueInt(c0) 2089 v1 := genValueInt(c1) 2090 n.exec = func(f *frame) bltn { 2091 v, i := v0(f) 2092 _, j := v1(f) 2093 v.SetInt(i % j) 2094 if setMap { 2095 mapValue(f).SetMapIndex(indexValue(f), v) 2096 } 2097 return next 2098 } 2099 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 2100 v0 := genValueUint(c0) 2101 v1 := genValueUint(c1) 2102 n.exec = func(f *frame) bltn { 2103 v, i := v0(f) 2104 _, j := v1(f) 2105 v.SetUint(i % j) 2106 if setMap { 2107 mapValue(f).SetMapIndex(indexValue(f), v) 2108 } 2109 return next 2110 } 2111 } 2112 } 2113 } 2114 2115 func shlAssign(n *node) { 2116 next := getExec(n.tnext) 2117 typ := n.typ.TypeOf() 2118 c0, c1 := n.child[0], n.child[1] 2119 setMap := isMapEntry(c0) 2120 var mapValue, indexValue func(*frame) reflect.Value 2121 2122 if setMap { 2123 mapValue = genValue(c0.child[0]) 2124 indexValue = genValue(c0.child[1]) 2125 } 2126 2127 if c1.rval.IsValid() { 2128 switch typ.Kind() { 2129 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 2130 v0 := genValueInt(c0) 2131 j := vUint(c1.rval) 2132 n.exec = func(f *frame) bltn { 2133 v, i := v0(f) 2134 v.SetInt(i << j) 2135 if setMap { 2136 mapValue(f).SetMapIndex(indexValue(f), v) 2137 } 2138 return next 2139 } 2140 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 2141 v0 := genValueUint(c0) 2142 j := vUint(c1.rval) 2143 n.exec = func(f *frame) bltn { 2144 v, i := v0(f) 2145 v.SetUint(i << j) 2146 if setMap { 2147 mapValue(f).SetMapIndex(indexValue(f), v) 2148 } 2149 return next 2150 } 2151 } 2152 } else { 2153 switch typ.Kind() { 2154 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 2155 v0 := genValueInt(c0) 2156 v1 := genValueUint(c1) 2157 n.exec = func(f *frame) bltn { 2158 v, i := v0(f) 2159 _, j := v1(f) 2160 v.SetInt(i << j) 2161 if setMap { 2162 mapValue(f).SetMapIndex(indexValue(f), v) 2163 } 2164 return next 2165 } 2166 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 2167 v0 := genValueUint(c0) 2168 v1 := genValueUint(c1) 2169 n.exec = func(f *frame) bltn { 2170 v, i := v0(f) 2171 _, j := v1(f) 2172 v.SetUint(i << j) 2173 if setMap { 2174 mapValue(f).SetMapIndex(indexValue(f), v) 2175 } 2176 return next 2177 } 2178 } 2179 } 2180 } 2181 2182 func shrAssign(n *node) { 2183 next := getExec(n.tnext) 2184 typ := n.typ.TypeOf() 2185 c0, c1 := n.child[0], n.child[1] 2186 setMap := isMapEntry(c0) 2187 var mapValue, indexValue func(*frame) reflect.Value 2188 2189 if setMap { 2190 mapValue = genValue(c0.child[0]) 2191 indexValue = genValue(c0.child[1]) 2192 } 2193 2194 if c1.rval.IsValid() { 2195 switch typ.Kind() { 2196 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 2197 v0 := genValueInt(c0) 2198 j := vUint(c1.rval) 2199 n.exec = func(f *frame) bltn { 2200 v, i := v0(f) 2201 v.SetInt(i >> j) 2202 if setMap { 2203 mapValue(f).SetMapIndex(indexValue(f), v) 2204 } 2205 return next 2206 } 2207 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 2208 v0 := genValueUint(c0) 2209 j := vUint(c1.rval) 2210 n.exec = func(f *frame) bltn { 2211 v, i := v0(f) 2212 v.SetUint(i >> j) 2213 if setMap { 2214 mapValue(f).SetMapIndex(indexValue(f), v) 2215 } 2216 return next 2217 } 2218 } 2219 } else { 2220 switch typ.Kind() { 2221 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 2222 v0 := genValueInt(c0) 2223 v1 := genValueUint(c1) 2224 n.exec = func(f *frame) bltn { 2225 v, i := v0(f) 2226 _, j := v1(f) 2227 v.SetInt(i >> j) 2228 if setMap { 2229 mapValue(f).SetMapIndex(indexValue(f), v) 2230 } 2231 return next 2232 } 2233 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 2234 v0 := genValueUint(c0) 2235 v1 := genValueUint(c1) 2236 n.exec = func(f *frame) bltn { 2237 v, i := v0(f) 2238 _, j := v1(f) 2239 v.SetUint(i >> j) 2240 if setMap { 2241 mapValue(f).SetMapIndex(indexValue(f), v) 2242 } 2243 return next 2244 } 2245 } 2246 } 2247 } 2248 2249 func subAssign(n *node) { 2250 next := getExec(n.tnext) 2251 typ := n.typ.TypeOf() 2252 c0, c1 := n.child[0], n.child[1] 2253 setMap := isMapEntry(c0) 2254 var mapValue, indexValue func(*frame) reflect.Value 2255 2256 if setMap { 2257 mapValue = genValue(c0.child[0]) 2258 indexValue = genValue(c0.child[1]) 2259 } 2260 2261 if c1.rval.IsValid() { 2262 switch typ.Kind() { 2263 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 2264 v0 := genValueInt(c0) 2265 j := vInt(c1.rval) 2266 n.exec = func(f *frame) bltn { 2267 v, i := v0(f) 2268 v.SetInt(i - j) 2269 if setMap { 2270 mapValue(f).SetMapIndex(indexValue(f), v) 2271 } 2272 return next 2273 } 2274 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 2275 v0 := genValueUint(c0) 2276 j := vUint(c1.rval) 2277 n.exec = func(f *frame) bltn { 2278 v, i := v0(f) 2279 v.SetUint(i - j) 2280 if setMap { 2281 mapValue(f).SetMapIndex(indexValue(f), v) 2282 } 2283 return next 2284 } 2285 case reflect.Float32, reflect.Float64: 2286 v0 := genValueFloat(c0) 2287 j := vFloat(c1.rval) 2288 n.exec = func(f *frame) bltn { 2289 v, i := v0(f) 2290 v.SetFloat(i - j) 2291 if setMap { 2292 mapValue(f).SetMapIndex(indexValue(f), v) 2293 } 2294 return next 2295 } 2296 case reflect.Complex64, reflect.Complex128: 2297 v0 := genValue(c0) 2298 v1 := vComplex(c1.rval) 2299 n.exec = func(f *frame) bltn { 2300 v := v0(f) 2301 v.SetComplex(v.Complex() - v1) 2302 if setMap { 2303 mapValue(f).SetMapIndex(indexValue(f), v) 2304 } 2305 return next 2306 } 2307 } 2308 } else { 2309 switch typ.Kind() { 2310 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 2311 v0 := genValueInt(c0) 2312 v1 := genValueInt(c1) 2313 n.exec = func(f *frame) bltn { 2314 v, i := v0(f) 2315 _, j := v1(f) 2316 v.SetInt(i - j) 2317 if setMap { 2318 mapValue(f).SetMapIndex(indexValue(f), v) 2319 } 2320 return next 2321 } 2322 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 2323 v0 := genValueUint(c0) 2324 v1 := genValueUint(c1) 2325 n.exec = func(f *frame) bltn { 2326 v, i := v0(f) 2327 _, j := v1(f) 2328 v.SetUint(i - j) 2329 if setMap { 2330 mapValue(f).SetMapIndex(indexValue(f), v) 2331 } 2332 return next 2333 } 2334 case reflect.Float32, reflect.Float64: 2335 v0 := genValueFloat(c0) 2336 v1 := genValueFloat(c1) 2337 n.exec = func(f *frame) bltn { 2338 v, i := v0(f) 2339 _, j := v1(f) 2340 v.SetFloat(i - j) 2341 if setMap { 2342 mapValue(f).SetMapIndex(indexValue(f), v) 2343 } 2344 return next 2345 } 2346 case reflect.Complex64, reflect.Complex128: 2347 v0 := genValue(c0) 2348 v1 := genValue(c1) 2349 n.exec = func(f *frame) bltn { 2350 v := v0(f) 2351 v.SetComplex(v.Complex() - v1(f).Complex()) 2352 if setMap { 2353 mapValue(f).SetMapIndex(indexValue(f), v) 2354 } 2355 return next 2356 } 2357 } 2358 } 2359 } 2360 2361 func xorAssign(n *node) { 2362 next := getExec(n.tnext) 2363 typ := n.typ.TypeOf() 2364 c0, c1 := n.child[0], n.child[1] 2365 setMap := isMapEntry(c0) 2366 var mapValue, indexValue func(*frame) reflect.Value 2367 2368 if setMap { 2369 mapValue = genValue(c0.child[0]) 2370 indexValue = genValue(c0.child[1]) 2371 } 2372 2373 if c1.rval.IsValid() { 2374 switch typ.Kind() { 2375 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 2376 v0 := genValueInt(c0) 2377 j := vInt(c1.rval) 2378 n.exec = func(f *frame) bltn { 2379 v, i := v0(f) 2380 v.SetInt(i ^ j) 2381 if setMap { 2382 mapValue(f).SetMapIndex(indexValue(f), v) 2383 } 2384 return next 2385 } 2386 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 2387 v0 := genValueUint(c0) 2388 j := vUint(c1.rval) 2389 n.exec = func(f *frame) bltn { 2390 v, i := v0(f) 2391 v.SetUint(i ^ j) 2392 if setMap { 2393 mapValue(f).SetMapIndex(indexValue(f), v) 2394 } 2395 return next 2396 } 2397 } 2398 } else { 2399 switch typ.Kind() { 2400 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 2401 v0 := genValueInt(c0) 2402 v1 := genValueInt(c1) 2403 n.exec = func(f *frame) bltn { 2404 v, i := v0(f) 2405 _, j := v1(f) 2406 v.SetInt(i ^ j) 2407 if setMap { 2408 mapValue(f).SetMapIndex(indexValue(f), v) 2409 } 2410 return next 2411 } 2412 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 2413 v0 := genValueUint(c0) 2414 v1 := genValueUint(c1) 2415 n.exec = func(f *frame) bltn { 2416 v, i := v0(f) 2417 _, j := v1(f) 2418 v.SetUint(i ^ j) 2419 if setMap { 2420 mapValue(f).SetMapIndex(indexValue(f), v) 2421 } 2422 return next 2423 } 2424 } 2425 } 2426 } 2427 2428 func dec(n *node) { 2429 next := getExec(n.tnext) 2430 typ := n.typ.TypeOf() 2431 c0 := n.child[0] 2432 setMap := isMapEntry(c0) 2433 var mapValue, indexValue func(*frame) reflect.Value 2434 2435 if setMap { 2436 mapValue = genValue(c0.child[0]) 2437 indexValue = genValue(c0.child[1]) 2438 } 2439 2440 switch typ.Kind() { 2441 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 2442 v0 := genValueInt(c0) 2443 n.exec = func(f *frame) bltn { 2444 v, i := v0(f) 2445 v.SetInt(i - 1) 2446 if setMap { 2447 mapValue(f).SetMapIndex(indexValue(f), v) 2448 } 2449 return next 2450 } 2451 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: 2452 v0 := genValueUint(c0) 2453 n.exec = func(f *frame) bltn { 2454 v, i := v0(f) 2455 v.SetUint(i - 1) 2456 if setMap { 2457 mapValue(f).SetMapIndex(indexValue(f), v) 2458 } 2459 return next 2460 } 2461 case reflect.Float32, reflect.Float64: 2462 v0 := genValueFloat(c0) 2463 n.exec = func(f *frame) bltn { 2464 v, i := v0(f) 2465 v.SetFloat(i - 1) 2466 if setMap { 2467 mapValue(f).SetMapIndex(indexValue(f), v) 2468 } 2469 return next 2470 } 2471 case reflect.Complex64, reflect.Complex128: 2472 v0 := genValue(c0) 2473 n.exec = func(f *frame) bltn { 2474 v := v0(f) 2475 v.SetComplex(v.Complex() - 1) 2476 if setMap { 2477 mapValue(f).SetMapIndex(indexValue(f), v) 2478 } 2479 return next 2480 } 2481 } 2482 } 2483 2484 func inc(n *node) { 2485 next := getExec(n.tnext) 2486 typ := n.typ.TypeOf() 2487 c0 := n.child[0] 2488 setMap := isMapEntry(c0) 2489 var mapValue, indexValue func(*frame) reflect.Value 2490 2491 if setMap { 2492 mapValue = genValue(c0.child[0]) 2493 indexValue = genValue(c0.child[1]) 2494 } 2495 2496 switch typ.Kind() { 2497 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 2498 v0 := genValueInt(c0) 2499 n.exec = func(f *frame) bltn { 2500 v, i := v0(f) 2501 v.SetInt(i + 1) 2502 if setMap { 2503 mapValue(f).SetMapIndex(indexValue(f), v) 2504 } 2505 return next 2506 } 2507 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: 2508 v0 := genValueUint(c0) 2509 n.exec = func(f *frame) bltn { 2510 v, i := v0(f) 2511 v.SetUint(i + 1) 2512 if setMap { 2513 mapValue(f).SetMapIndex(indexValue(f), v) 2514 } 2515 return next 2516 } 2517 case reflect.Float32, reflect.Float64: 2518 v0 := genValueFloat(c0) 2519 n.exec = func(f *frame) bltn { 2520 v, i := v0(f) 2521 v.SetFloat(i + 1) 2522 if setMap { 2523 mapValue(f).SetMapIndex(indexValue(f), v) 2524 } 2525 return next 2526 } 2527 case reflect.Complex64, reflect.Complex128: 2528 v0 := genValue(c0) 2529 n.exec = func(f *frame) bltn { 2530 v := v0(f) 2531 v.SetComplex(v.Complex() + 1) 2532 if setMap { 2533 mapValue(f).SetMapIndex(indexValue(f), v) 2534 } 2535 return next 2536 } 2537 } 2538 } 2539 2540 func bitNotConst(n *node) { 2541 v0 := n.child[0].rval 2542 isConst := v0.IsValid() && isConstantValue(v0.Type()) 2543 t := n.typ.rtype 2544 if isConst { 2545 t = constVal 2546 } 2547 n.rval = reflect.New(t).Elem() 2548 switch { 2549 case isConst: 2550 v := constant.UnaryOp(token.XOR, vConstantValue(v0), 0) 2551 n.rval.Set(reflect.ValueOf(v)) 2552 case isUint(t): 2553 n.rval.SetUint(^v0.Uint()) 2554 case isInt(t): 2555 n.rval.SetInt(^v0.Int()) 2556 } 2557 } 2558 2559 func negConst(n *node) { 2560 v0 := n.child[0].rval 2561 isConst := v0.IsValid() && isConstantValue(v0.Type()) 2562 t := n.typ.rtype 2563 if isConst { 2564 t = constVal 2565 } 2566 n.rval = reflect.New(t).Elem() 2567 switch { 2568 case isConst: 2569 v := constant.UnaryOp(token.SUB, vConstantValue(v0), 0) 2570 n.rval.Set(reflect.ValueOf(v)) 2571 case isUint(t): 2572 n.rval.SetUint(-v0.Uint()) 2573 case isInt(t): 2574 n.rval.SetInt(-v0.Int()) 2575 case isFloat(t): 2576 n.rval.SetFloat(-v0.Float()) 2577 case isComplex(t): 2578 n.rval.SetComplex(-v0.Complex()) 2579 } 2580 } 2581 2582 func notConst(n *node) { 2583 v0 := n.child[0].rval 2584 isConst := v0.IsValid() && isConstantValue(v0.Type()) 2585 t := n.typ.rtype 2586 if isConst { 2587 t = constVal 2588 } 2589 n.rval = reflect.New(t).Elem() 2590 if isConst { 2591 v := constant.UnaryOp(token.NOT, vConstantValue(v0), 0) 2592 n.rval.Set(reflect.ValueOf(v)) 2593 } else { 2594 n.rval.SetBool(!v0.Bool()) 2595 } 2596 } 2597 2598 func posConst(n *node) { 2599 v0 := n.child[0].rval 2600 isConst := v0.IsValid() && isConstantValue(v0.Type()) 2601 t := n.typ.rtype 2602 if isConst { 2603 t = constVal 2604 } 2605 n.rval = reflect.New(t).Elem() 2606 switch { 2607 case isConst: 2608 v := constant.UnaryOp(token.ADD, vConstantValue(v0), 0) 2609 n.rval.Set(reflect.ValueOf(v)) 2610 case isUint(t): 2611 n.rval.SetUint(+v0.Uint()) 2612 case isInt(t): 2613 n.rval.SetInt(+v0.Int()) 2614 case isFloat(t): 2615 n.rval.SetFloat(+v0.Float()) 2616 case isComplex(t): 2617 n.rval.SetComplex(+v0.Complex()) 2618 } 2619 } 2620 2621 func equal(n *node) { 2622 tnext := getExec(n.tnext) 2623 dest := genValueOutput(n, reflect.TypeOf(true)) 2624 typ := n.typ.concrete().TypeOf() 2625 isInterface := n.typ.TypeOf().Kind() == reflect.Interface 2626 c0, c1 := n.child[0], n.child[1] 2627 t0, t1 := c0.typ.TypeOf(), c1.typ.TypeOf() 2628 2629 if c0.typ.cat == aliasT || c1.typ.cat == aliasT { 2630 switch { 2631 case isInterface: 2632 v0 := genValue(c0) 2633 v1 := genValue(c1) 2634 dest := genValue(n) 2635 n.exec = func(f *frame) bltn { 2636 i0 := v0(f).Interface() 2637 i1 := v1(f).Interface() 2638 dest(f).Set(reflect.ValueOf(i0 == i1).Convert(typ)) 2639 return tnext 2640 } 2641 case c0.rval.IsValid(): 2642 i0 := c0.rval.Interface() 2643 v1 := genValue(c1) 2644 if n.fnext != nil { 2645 fnext := getExec(n.fnext) 2646 n.exec = func(f *frame) bltn { 2647 i1 := v1(f).Interface() 2648 if i0 == i1 { 2649 dest(f).SetBool(true) 2650 return tnext 2651 } 2652 dest(f).SetBool(false) 2653 return fnext 2654 } 2655 } else { 2656 dest := genValue(n) 2657 n.exec = func(f *frame) bltn { 2658 i1 := v1(f).Interface() 2659 dest(f).SetBool(i0 == i1) 2660 return tnext 2661 } 2662 } 2663 case c1.rval.IsValid(): 2664 i1 := c1.rval.Interface() 2665 v0 := genValue(c0) 2666 if n.fnext != nil { 2667 fnext := getExec(n.fnext) 2668 n.exec = func(f *frame) bltn { 2669 i0 := v0(f).Interface() 2670 if i0 == i1 { 2671 dest(f).SetBool(true) 2672 return tnext 2673 } 2674 dest(f).SetBool(false) 2675 return fnext 2676 } 2677 } else { 2678 dest := genValue(n) 2679 n.exec = func(f *frame) bltn { 2680 i0 := v0(f).Interface() 2681 dest(f).SetBool(i0 == i1) 2682 return tnext 2683 } 2684 } 2685 default: 2686 v0 := genValue(c0) 2687 v1 := genValue(c1) 2688 if n.fnext != nil { 2689 fnext := getExec(n.fnext) 2690 n.exec = func(f *frame) bltn { 2691 i0 := v0(f).Interface() 2692 i1 := v1(f).Interface() 2693 if i0 == i1 { 2694 dest(f).SetBool(true) 2695 return tnext 2696 } 2697 dest(f).SetBool(false) 2698 return fnext 2699 } 2700 } else { 2701 dest := genValue(n) 2702 n.exec = func(f *frame) bltn { 2703 i0 := v0(f).Interface() 2704 i1 := v1(f).Interface() 2705 dest(f).SetBool(i0 == i1) 2706 return tnext 2707 } 2708 } 2709 } 2710 return 2711 } 2712 2713 // Do not attempt to optimize '==' or '!=' if an operand is an interface. 2714 // This will preserve proper dynamic type checking at runtime. For static types, 2715 // type checks are already performed, so bypass them if possible. 2716 if t0.Kind() == reflect.Interface || t1.Kind() == reflect.Interface { 2717 v0 := genValue(c0) 2718 v1 := genValue(c1) 2719 if n.fnext != nil { 2720 fnext := getExec(n.fnext) 2721 n.exec = func(f *frame) bltn { 2722 i0 := v0(f).Interface() 2723 i1 := v1(f).Interface() 2724 if i0 == i1 { 2725 dest(f).SetBool(true) 2726 return tnext 2727 } 2728 dest(f).SetBool(false) 2729 return fnext 2730 } 2731 } else { 2732 dest := genValue(n) 2733 n.exec = func(f *frame) bltn { 2734 i0 := v0(f).Interface() 2735 i1 := v1(f).Interface() 2736 dest(f).SetBool(i0 == i1) 2737 return tnext 2738 } 2739 } 2740 return 2741 } 2742 2743 switch { 2744 case isString(t0) || isString(t1): 2745 switch { 2746 case isInterface: 2747 v0 := genValueString(c0) 2748 v1 := genValueString(c1) 2749 n.exec = func(f *frame) bltn { 2750 _, s0 := v0(f) 2751 _, s1 := v1(f) 2752 dest(f).Set(reflect.ValueOf(s0 == s1).Convert(typ)) 2753 return tnext 2754 } 2755 case c0.rval.IsValid(): 2756 s0 := vString(c0.rval) 2757 v1 := genValueString(c1) 2758 if n.fnext != nil { 2759 fnext := getExec(n.fnext) 2760 n.exec = func(f *frame) bltn { 2761 _, s1 := v1(f) 2762 if s0 == s1 { 2763 dest(f).SetBool(true) 2764 return tnext 2765 } 2766 dest(f).SetBool(false) 2767 return fnext 2768 } 2769 } else { 2770 n.exec = func(f *frame) bltn { 2771 _, s1 := v1(f) 2772 dest(f).SetBool(s0 == s1) 2773 return tnext 2774 } 2775 } 2776 case c1.rval.IsValid(): 2777 s1 := vString(c1.rval) 2778 v0 := genValueString(c0) 2779 if n.fnext != nil { 2780 fnext := getExec(n.fnext) 2781 n.exec = func(f *frame) bltn { 2782 _, s0 := v0(f) 2783 if s0 == s1 { 2784 dest(f).SetBool(true) 2785 return tnext 2786 } 2787 dest(f).SetBool(false) 2788 return fnext 2789 } 2790 } else { 2791 n.exec = func(f *frame) bltn { 2792 _, s0 := v0(f) 2793 dest(f).SetBool(s0 == s1) 2794 return tnext 2795 } 2796 } 2797 default: 2798 v0 := genValueString(c0) 2799 v1 := genValueString(c1) 2800 if n.fnext != nil { 2801 fnext := getExec(n.fnext) 2802 n.exec = func(f *frame) bltn { 2803 _, s0 := v0(f) 2804 _, s1 := v1(f) 2805 if s0 == s1 { 2806 dest(f).SetBool(true) 2807 return tnext 2808 } 2809 dest(f).SetBool(false) 2810 return fnext 2811 } 2812 } else { 2813 n.exec = func(f *frame) bltn { 2814 _, s0 := v0(f) 2815 _, s1 := v1(f) 2816 dest(f).SetBool(s0 == s1) 2817 return tnext 2818 } 2819 } 2820 } 2821 case isFloat(t0) || isFloat(t1): 2822 switch { 2823 case isInterface: 2824 v0 := genValueFloat(c0) 2825 v1 := genValueFloat(c1) 2826 n.exec = func(f *frame) bltn { 2827 _, s0 := v0(f) 2828 _, s1 := v1(f) 2829 dest(f).Set(reflect.ValueOf(s0 == s1).Convert(typ)) 2830 return tnext 2831 } 2832 case c0.rval.IsValid(): 2833 s0 := vFloat(c0.rval) 2834 v1 := genValueFloat(c1) 2835 if n.fnext != nil { 2836 fnext := getExec(n.fnext) 2837 n.exec = func(f *frame) bltn { 2838 _, s1 := v1(f) 2839 if s0 == s1 { 2840 dest(f).SetBool(true) 2841 return tnext 2842 } 2843 dest(f).SetBool(false) 2844 return fnext 2845 } 2846 } else { 2847 n.exec = func(f *frame) bltn { 2848 _, s1 := v1(f) 2849 dest(f).SetBool(s0 == s1) 2850 return tnext 2851 } 2852 } 2853 case c1.rval.IsValid(): 2854 s1 := vFloat(c1.rval) 2855 v0 := genValueFloat(c0) 2856 if n.fnext != nil { 2857 fnext := getExec(n.fnext) 2858 n.exec = func(f *frame) bltn { 2859 _, s0 := v0(f) 2860 if s0 == s1 { 2861 dest(f).SetBool(true) 2862 return tnext 2863 } 2864 dest(f).SetBool(false) 2865 return fnext 2866 } 2867 } else { 2868 dest := genValue(n) 2869 n.exec = func(f *frame) bltn { 2870 _, s0 := v0(f) 2871 dest(f).SetBool(s0 == s1) 2872 return tnext 2873 } 2874 } 2875 default: 2876 v0 := genValueFloat(c0) 2877 v1 := genValueFloat(c1) 2878 if n.fnext != nil { 2879 fnext := getExec(n.fnext) 2880 n.exec = func(f *frame) bltn { 2881 _, s0 := v0(f) 2882 _, s1 := v1(f) 2883 if s0 == s1 { 2884 dest(f).SetBool(true) 2885 return tnext 2886 } 2887 dest(f).SetBool(false) 2888 return fnext 2889 } 2890 } else { 2891 dest := genValue(n) 2892 n.exec = func(f *frame) bltn { 2893 _, s0 := v0(f) 2894 _, s1 := v1(f) 2895 dest(f).SetBool(s0 == s1) 2896 return tnext 2897 } 2898 } 2899 } 2900 case isUint(t0) || isUint(t1): 2901 switch { 2902 case isInterface: 2903 v0 := genValueUint(c0) 2904 v1 := genValueUint(c1) 2905 n.exec = func(f *frame) bltn { 2906 _, s0 := v0(f) 2907 _, s1 := v1(f) 2908 dest(f).Set(reflect.ValueOf(s0 == s1).Convert(typ)) 2909 return tnext 2910 } 2911 case c0.rval.IsValid(): 2912 s0 := vUint(c0.rval) 2913 v1 := genValueUint(c1) 2914 if n.fnext != nil { 2915 fnext := getExec(n.fnext) 2916 n.exec = func(f *frame) bltn { 2917 _, s1 := v1(f) 2918 if s0 == s1 { 2919 dest(f).SetBool(true) 2920 return tnext 2921 } 2922 dest(f).SetBool(false) 2923 return fnext 2924 } 2925 } else { 2926 dest := genValue(n) 2927 n.exec = func(f *frame) bltn { 2928 _, s1 := v1(f) 2929 dest(f).SetBool(s0 == s1) 2930 return tnext 2931 } 2932 } 2933 case c1.rval.IsValid(): 2934 s1 := vUint(c1.rval) 2935 v0 := genValueUint(c0) 2936 if n.fnext != nil { 2937 fnext := getExec(n.fnext) 2938 n.exec = func(f *frame) bltn { 2939 _, s0 := v0(f) 2940 if s0 == s1 { 2941 dest(f).SetBool(true) 2942 return tnext 2943 } 2944 dest(f).SetBool(false) 2945 return fnext 2946 } 2947 } else { 2948 dest := genValue(n) 2949 n.exec = func(f *frame) bltn { 2950 _, s0 := v0(f) 2951 dest(f).SetBool(s0 == s1) 2952 return tnext 2953 } 2954 } 2955 default: 2956 v0 := genValueUint(c0) 2957 v1 := genValueUint(c1) 2958 if n.fnext != nil { 2959 fnext := getExec(n.fnext) 2960 n.exec = func(f *frame) bltn { 2961 _, s0 := v0(f) 2962 _, s1 := v1(f) 2963 if s0 == s1 { 2964 dest(f).SetBool(true) 2965 return tnext 2966 } 2967 dest(f).SetBool(false) 2968 return fnext 2969 } 2970 } else { 2971 dest := genValue(n) 2972 n.exec = func(f *frame) bltn { 2973 _, s0 := v0(f) 2974 _, s1 := v1(f) 2975 dest(f).SetBool(s0 == s1) 2976 return tnext 2977 } 2978 } 2979 } 2980 case isInt(t0) || isInt(t1): 2981 switch { 2982 case isInterface: 2983 v0 := genValueInt(c0) 2984 v1 := genValueInt(c1) 2985 n.exec = func(f *frame) bltn { 2986 _, s0 := v0(f) 2987 _, s1 := v1(f) 2988 dest(f).Set(reflect.ValueOf(s0 == s1).Convert(typ)) 2989 return tnext 2990 } 2991 case c0.rval.IsValid(): 2992 s0 := vInt(c0.rval) 2993 v1 := genValueInt(c1) 2994 if n.fnext != nil { 2995 fnext := getExec(n.fnext) 2996 n.exec = func(f *frame) bltn { 2997 _, s1 := v1(f) 2998 if s0 == s1 { 2999 dest(f).SetBool(true) 3000 return tnext 3001 } 3002 dest(f).SetBool(false) 3003 return fnext 3004 } 3005 } else { 3006 dest := genValue(n) 3007 n.exec = func(f *frame) bltn { 3008 _, s1 := v1(f) 3009 dest(f).SetBool(s0 == s1) 3010 return tnext 3011 } 3012 } 3013 case c1.rval.IsValid(): 3014 s1 := vInt(c1.rval) 3015 v0 := genValueInt(c0) 3016 if n.fnext != nil { 3017 fnext := getExec(n.fnext) 3018 n.exec = func(f *frame) bltn { 3019 _, s0 := v0(f) 3020 if s0 == s1 { 3021 dest(f).SetBool(true) 3022 return tnext 3023 } 3024 dest(f).SetBool(false) 3025 return fnext 3026 } 3027 } else { 3028 dest := genValue(n) 3029 n.exec = func(f *frame) bltn { 3030 _, s0 := v0(f) 3031 dest(f).SetBool(s0 == s1) 3032 return tnext 3033 } 3034 } 3035 default: 3036 v0 := genValueInt(c0) 3037 v1 := genValueInt(c1) 3038 if n.fnext != nil { 3039 fnext := getExec(n.fnext) 3040 n.exec = func(f *frame) bltn { 3041 _, s0 := v0(f) 3042 _, s1 := v1(f) 3043 if s0 == s1 { 3044 dest(f).SetBool(true) 3045 return tnext 3046 } 3047 dest(f).SetBool(false) 3048 return fnext 3049 } 3050 } else { 3051 dest := genValue(n) 3052 n.exec = func(f *frame) bltn { 3053 _, s0 := v0(f) 3054 _, s1 := v1(f) 3055 dest(f).SetBool(s0 == s1) 3056 return tnext 3057 } 3058 } 3059 } 3060 case isComplex(t0) || isComplex(t1): 3061 switch { 3062 case isInterface: 3063 v0 := genComplex(c0) 3064 v1 := genComplex(c1) 3065 n.exec = func(f *frame) bltn { 3066 s0 := v0(f) 3067 s1 := v1(f) 3068 dest(f).Set(reflect.ValueOf(s0 == s1).Convert(typ)) 3069 return tnext 3070 } 3071 case c0.rval.IsValid(): 3072 s0 := vComplex(c0.rval) 3073 v1 := genComplex(c1) 3074 if n.fnext != nil { 3075 fnext := getExec(n.fnext) 3076 n.exec = func(f *frame) bltn { 3077 s1 := v1(f) 3078 if s0 == s1 { 3079 dest(f).SetBool(true) 3080 return tnext 3081 } 3082 dest(f).SetBool(false) 3083 return fnext 3084 } 3085 } else { 3086 n.exec = func(f *frame) bltn { 3087 s1 := v1(f) 3088 dest(f).SetBool(s0 == s1) 3089 return tnext 3090 } 3091 } 3092 case c1.rval.IsValid(): 3093 s1 := vComplex(c1.rval) 3094 v0 := genComplex(c0) 3095 if n.fnext != nil { 3096 fnext := getExec(n.fnext) 3097 n.exec = func(f *frame) bltn { 3098 s0 := v0(f) 3099 if s0 == s1 { 3100 dest(f).SetBool(true) 3101 return tnext 3102 } 3103 dest(f).SetBool(false) 3104 return fnext 3105 } 3106 } else { 3107 dest := genValue(n) 3108 n.exec = func(f *frame) bltn { 3109 s0 := v0(f) 3110 dest(f).SetBool(s0 == s1) 3111 return tnext 3112 } 3113 } 3114 default: 3115 v0 := genComplex(c0) 3116 v1 := genComplex(c1) 3117 if n.fnext != nil { 3118 fnext := getExec(n.fnext) 3119 n.exec = func(f *frame) bltn { 3120 s0 := v0(f) 3121 s1 := v1(f) 3122 if s0 == s1 { 3123 dest(f).SetBool(true) 3124 return tnext 3125 } 3126 dest(f).SetBool(false) 3127 return fnext 3128 } 3129 } else { 3130 n.exec = func(f *frame) bltn { 3131 s0 := v0(f) 3132 s1 := v1(f) 3133 dest(f).SetBool(s0 == s1) 3134 return tnext 3135 } 3136 } 3137 } 3138 default: 3139 switch { 3140 case isInterface: 3141 v0 := genValue(c0) 3142 v1 := genValue(c1) 3143 n.exec = func(f *frame) bltn { 3144 i0 := v0(f).Interface() 3145 i1 := v1(f).Interface() 3146 dest(f).Set(reflect.ValueOf(i0 == i1).Convert(typ)) 3147 return tnext 3148 } 3149 case c0.rval.IsValid(): 3150 i0 := c0.rval.Interface() 3151 v1 := genValue(c1) 3152 if n.fnext != nil { 3153 fnext := getExec(n.fnext) 3154 n.exec = func(f *frame) bltn { 3155 i1 := v1(f).Interface() 3156 if i0 == i1 { 3157 dest(f).SetBool(true) 3158 return tnext 3159 } 3160 dest(f).SetBool(false) 3161 return fnext 3162 } 3163 } else { 3164 dest := genValue(n) 3165 n.exec = func(f *frame) bltn { 3166 i1 := v1(f).Interface() 3167 dest(f).SetBool(i0 == i1) 3168 return tnext 3169 } 3170 } 3171 case c1.rval.IsValid(): 3172 i1 := c1.rval.Interface() 3173 v0 := genValue(c0) 3174 if n.fnext != nil { 3175 fnext := getExec(n.fnext) 3176 n.exec = func(f *frame) bltn { 3177 i0 := v0(f).Interface() 3178 if i0 == i1 { 3179 dest(f).SetBool(true) 3180 return tnext 3181 } 3182 dest(f).SetBool(false) 3183 return fnext 3184 } 3185 } else { 3186 dest := genValue(n) 3187 n.exec = func(f *frame) bltn { 3188 i0 := v0(f).Interface() 3189 dest(f).SetBool(i0 == i1) 3190 return tnext 3191 } 3192 } 3193 default: 3194 v0 := genValue(c0) 3195 v1 := genValue(c1) 3196 if n.fnext != nil { 3197 fnext := getExec(n.fnext) 3198 n.exec = func(f *frame) bltn { 3199 i0 := v0(f).Interface() 3200 i1 := v1(f).Interface() 3201 if i0 == i1 { 3202 dest(f).SetBool(true) 3203 return tnext 3204 } 3205 dest(f).SetBool(false) 3206 return fnext 3207 } 3208 } else { 3209 dest := genValue(n) 3210 n.exec = func(f *frame) bltn { 3211 i0 := v0(f).Interface() 3212 i1 := v1(f).Interface() 3213 dest(f).SetBool(i0 == i1) 3214 return tnext 3215 } 3216 } 3217 } 3218 } 3219 } 3220 3221 func greater(n *node) { 3222 tnext := getExec(n.tnext) 3223 dest := genValueOutput(n, reflect.TypeOf(true)) 3224 typ := n.typ.concrete().TypeOf() 3225 isInterface := n.typ.TypeOf().Kind() == reflect.Interface 3226 c0, c1 := n.child[0], n.child[1] 3227 t0, t1 := c0.typ.TypeOf(), c1.typ.TypeOf() 3228 3229 switch { 3230 case isString(t0) || isString(t1): 3231 switch { 3232 case isInterface: 3233 v0 := genValueString(c0) 3234 v1 := genValueString(c1) 3235 n.exec = func(f *frame) bltn { 3236 _, s0 := v0(f) 3237 _, s1 := v1(f) 3238 dest(f).Set(reflect.ValueOf(s0 > s1).Convert(typ)) 3239 return tnext 3240 } 3241 case c0.rval.IsValid(): 3242 s0 := vString(c0.rval) 3243 v1 := genValueString(c1) 3244 if n.fnext != nil { 3245 fnext := getExec(n.fnext) 3246 n.exec = func(f *frame) bltn { 3247 _, s1 := v1(f) 3248 if s0 > s1 { 3249 dest(f).SetBool(true) 3250 return tnext 3251 } 3252 dest(f).SetBool(false) 3253 return fnext 3254 } 3255 } else { 3256 n.exec = func(f *frame) bltn { 3257 _, s1 := v1(f) 3258 dest(f).SetBool(s0 > s1) 3259 return tnext 3260 } 3261 } 3262 case c1.rval.IsValid(): 3263 s1 := vString(c1.rval) 3264 v0 := genValueString(c0) 3265 if n.fnext != nil { 3266 fnext := getExec(n.fnext) 3267 n.exec = func(f *frame) bltn { 3268 _, s0 := v0(f) 3269 if s0 > s1 { 3270 dest(f).SetBool(true) 3271 return tnext 3272 } 3273 dest(f).SetBool(false) 3274 return fnext 3275 } 3276 } else { 3277 n.exec = func(f *frame) bltn { 3278 _, s0 := v0(f) 3279 dest(f).SetBool(s0 > s1) 3280 return tnext 3281 } 3282 } 3283 default: 3284 v0 := genValueString(c0) 3285 v1 := genValueString(c1) 3286 if n.fnext != nil { 3287 fnext := getExec(n.fnext) 3288 n.exec = func(f *frame) bltn { 3289 _, s0 := v0(f) 3290 _, s1 := v1(f) 3291 if s0 > s1 { 3292 dest(f).SetBool(true) 3293 return tnext 3294 } 3295 dest(f).SetBool(false) 3296 return fnext 3297 } 3298 } else { 3299 n.exec = func(f *frame) bltn { 3300 _, s0 := v0(f) 3301 _, s1 := v1(f) 3302 dest(f).SetBool(s0 > s1) 3303 return tnext 3304 } 3305 } 3306 } 3307 case isFloat(t0) || isFloat(t1): 3308 switch { 3309 case isInterface: 3310 v0 := genValueFloat(c0) 3311 v1 := genValueFloat(c1) 3312 n.exec = func(f *frame) bltn { 3313 _, s0 := v0(f) 3314 _, s1 := v1(f) 3315 dest(f).Set(reflect.ValueOf(s0 > s1).Convert(typ)) 3316 return tnext 3317 } 3318 case c0.rval.IsValid(): 3319 s0 := vFloat(c0.rval) 3320 v1 := genValueFloat(c1) 3321 if n.fnext != nil { 3322 fnext := getExec(n.fnext) 3323 n.exec = func(f *frame) bltn { 3324 _, s1 := v1(f) 3325 if s0 > s1 { 3326 dest(f).SetBool(true) 3327 return tnext 3328 } 3329 dest(f).SetBool(false) 3330 return fnext 3331 } 3332 } else { 3333 n.exec = func(f *frame) bltn { 3334 _, s1 := v1(f) 3335 dest(f).SetBool(s0 > s1) 3336 return tnext 3337 } 3338 } 3339 case c1.rval.IsValid(): 3340 s1 := vFloat(c1.rval) 3341 v0 := genValueFloat(c0) 3342 if n.fnext != nil { 3343 fnext := getExec(n.fnext) 3344 n.exec = func(f *frame) bltn { 3345 _, s0 := v0(f) 3346 if s0 > s1 { 3347 dest(f).SetBool(true) 3348 return tnext 3349 } 3350 dest(f).SetBool(false) 3351 return fnext 3352 } 3353 } else { 3354 dest := genValue(n) 3355 n.exec = func(f *frame) bltn { 3356 _, s0 := v0(f) 3357 dest(f).SetBool(s0 > s1) 3358 return tnext 3359 } 3360 } 3361 default: 3362 v0 := genValueFloat(c0) 3363 v1 := genValueFloat(c1) 3364 if n.fnext != nil { 3365 fnext := getExec(n.fnext) 3366 n.exec = func(f *frame) bltn { 3367 _, s0 := v0(f) 3368 _, s1 := v1(f) 3369 if s0 > s1 { 3370 dest(f).SetBool(true) 3371 return tnext 3372 } 3373 dest(f).SetBool(false) 3374 return fnext 3375 } 3376 } else { 3377 dest := genValue(n) 3378 n.exec = func(f *frame) bltn { 3379 _, s0 := v0(f) 3380 _, s1 := v1(f) 3381 dest(f).SetBool(s0 > s1) 3382 return tnext 3383 } 3384 } 3385 } 3386 case isUint(t0) || isUint(t1): 3387 switch { 3388 case isInterface: 3389 v0 := genValueUint(c0) 3390 v1 := genValueUint(c1) 3391 n.exec = func(f *frame) bltn { 3392 _, s0 := v0(f) 3393 _, s1 := v1(f) 3394 dest(f).Set(reflect.ValueOf(s0 > s1).Convert(typ)) 3395 return tnext 3396 } 3397 case c0.rval.IsValid(): 3398 s0 := vUint(c0.rval) 3399 v1 := genValueUint(c1) 3400 if n.fnext != nil { 3401 fnext := getExec(n.fnext) 3402 n.exec = func(f *frame) bltn { 3403 _, s1 := v1(f) 3404 if s0 > s1 { 3405 dest(f).SetBool(true) 3406 return tnext 3407 } 3408 dest(f).SetBool(false) 3409 return fnext 3410 } 3411 } else { 3412 dest := genValue(n) 3413 n.exec = func(f *frame) bltn { 3414 _, s1 := v1(f) 3415 dest(f).SetBool(s0 > s1) 3416 return tnext 3417 } 3418 } 3419 case c1.rval.IsValid(): 3420 s1 := vUint(c1.rval) 3421 v0 := genValueUint(c0) 3422 if n.fnext != nil { 3423 fnext := getExec(n.fnext) 3424 n.exec = func(f *frame) bltn { 3425 _, s0 := v0(f) 3426 if s0 > s1 { 3427 dest(f).SetBool(true) 3428 return tnext 3429 } 3430 dest(f).SetBool(false) 3431 return fnext 3432 } 3433 } else { 3434 dest := genValue(n) 3435 n.exec = func(f *frame) bltn { 3436 _, s0 := v0(f) 3437 dest(f).SetBool(s0 > s1) 3438 return tnext 3439 } 3440 } 3441 default: 3442 v0 := genValueUint(c0) 3443 v1 := genValueUint(c1) 3444 if n.fnext != nil { 3445 fnext := getExec(n.fnext) 3446 n.exec = func(f *frame) bltn { 3447 _, s0 := v0(f) 3448 _, s1 := v1(f) 3449 if s0 > s1 { 3450 dest(f).SetBool(true) 3451 return tnext 3452 } 3453 dest(f).SetBool(false) 3454 return fnext 3455 } 3456 } else { 3457 dest := genValue(n) 3458 n.exec = func(f *frame) bltn { 3459 _, s0 := v0(f) 3460 _, s1 := v1(f) 3461 dest(f).SetBool(s0 > s1) 3462 return tnext 3463 } 3464 } 3465 } 3466 case isInt(t0) || isInt(t1): 3467 switch { 3468 case isInterface: 3469 v0 := genValueInt(c0) 3470 v1 := genValueInt(c1) 3471 n.exec = func(f *frame) bltn { 3472 _, s0 := v0(f) 3473 _, s1 := v1(f) 3474 dest(f).Set(reflect.ValueOf(s0 > s1).Convert(typ)) 3475 return tnext 3476 } 3477 case c0.rval.IsValid(): 3478 s0 := vInt(c0.rval) 3479 v1 := genValueInt(c1) 3480 if n.fnext != nil { 3481 fnext := getExec(n.fnext) 3482 n.exec = func(f *frame) bltn { 3483 _, s1 := v1(f) 3484 if s0 > s1 { 3485 dest(f).SetBool(true) 3486 return tnext 3487 } 3488 dest(f).SetBool(false) 3489 return fnext 3490 } 3491 } else { 3492 dest := genValue(n) 3493 n.exec = func(f *frame) bltn { 3494 _, s1 := v1(f) 3495 dest(f).SetBool(s0 > s1) 3496 return tnext 3497 } 3498 } 3499 case c1.rval.IsValid(): 3500 s1 := vInt(c1.rval) 3501 v0 := genValueInt(c0) 3502 if n.fnext != nil { 3503 fnext := getExec(n.fnext) 3504 n.exec = func(f *frame) bltn { 3505 _, s0 := v0(f) 3506 if s0 > s1 { 3507 dest(f).SetBool(true) 3508 return tnext 3509 } 3510 dest(f).SetBool(false) 3511 return fnext 3512 } 3513 } else { 3514 dest := genValue(n) 3515 n.exec = func(f *frame) bltn { 3516 _, s0 := v0(f) 3517 dest(f).SetBool(s0 > s1) 3518 return tnext 3519 } 3520 } 3521 default: 3522 v0 := genValueInt(c0) 3523 v1 := genValueInt(c1) 3524 if n.fnext != nil { 3525 fnext := getExec(n.fnext) 3526 n.exec = func(f *frame) bltn { 3527 _, s0 := v0(f) 3528 _, s1 := v1(f) 3529 if s0 > s1 { 3530 dest(f).SetBool(true) 3531 return tnext 3532 } 3533 dest(f).SetBool(false) 3534 return fnext 3535 } 3536 } else { 3537 dest := genValue(n) 3538 n.exec = func(f *frame) bltn { 3539 _, s0 := v0(f) 3540 _, s1 := v1(f) 3541 dest(f).SetBool(s0 > s1) 3542 return tnext 3543 } 3544 } 3545 } 3546 } 3547 } 3548 3549 func greaterEqual(n *node) { 3550 tnext := getExec(n.tnext) 3551 dest := genValueOutput(n, reflect.TypeOf(true)) 3552 typ := n.typ.concrete().TypeOf() 3553 isInterface := n.typ.TypeOf().Kind() == reflect.Interface 3554 c0, c1 := n.child[0], n.child[1] 3555 t0, t1 := c0.typ.TypeOf(), c1.typ.TypeOf() 3556 3557 switch { 3558 case isString(t0) || isString(t1): 3559 switch { 3560 case isInterface: 3561 v0 := genValueString(c0) 3562 v1 := genValueString(c1) 3563 n.exec = func(f *frame) bltn { 3564 _, s0 := v0(f) 3565 _, s1 := v1(f) 3566 dest(f).Set(reflect.ValueOf(s0 >= s1).Convert(typ)) 3567 return tnext 3568 } 3569 case c0.rval.IsValid(): 3570 s0 := vString(c0.rval) 3571 v1 := genValueString(c1) 3572 if n.fnext != nil { 3573 fnext := getExec(n.fnext) 3574 n.exec = func(f *frame) bltn { 3575 _, s1 := v1(f) 3576 if s0 >= s1 { 3577 dest(f).SetBool(true) 3578 return tnext 3579 } 3580 dest(f).SetBool(false) 3581 return fnext 3582 } 3583 } else { 3584 n.exec = func(f *frame) bltn { 3585 _, s1 := v1(f) 3586 dest(f).SetBool(s0 >= s1) 3587 return tnext 3588 } 3589 } 3590 case c1.rval.IsValid(): 3591 s1 := vString(c1.rval) 3592 v0 := genValueString(c0) 3593 if n.fnext != nil { 3594 fnext := getExec(n.fnext) 3595 n.exec = func(f *frame) bltn { 3596 _, s0 := v0(f) 3597 if s0 >= s1 { 3598 dest(f).SetBool(true) 3599 return tnext 3600 } 3601 dest(f).SetBool(false) 3602 return fnext 3603 } 3604 } else { 3605 n.exec = func(f *frame) bltn { 3606 _, s0 := v0(f) 3607 dest(f).SetBool(s0 >= s1) 3608 return tnext 3609 } 3610 } 3611 default: 3612 v0 := genValueString(c0) 3613 v1 := genValueString(c1) 3614 if n.fnext != nil { 3615 fnext := getExec(n.fnext) 3616 n.exec = func(f *frame) bltn { 3617 _, s0 := v0(f) 3618 _, s1 := v1(f) 3619 if s0 >= s1 { 3620 dest(f).SetBool(true) 3621 return tnext 3622 } 3623 dest(f).SetBool(false) 3624 return fnext 3625 } 3626 } else { 3627 n.exec = func(f *frame) bltn { 3628 _, s0 := v0(f) 3629 _, s1 := v1(f) 3630 dest(f).SetBool(s0 >= s1) 3631 return tnext 3632 } 3633 } 3634 } 3635 case isFloat(t0) || isFloat(t1): 3636 switch { 3637 case isInterface: 3638 v0 := genValueFloat(c0) 3639 v1 := genValueFloat(c1) 3640 n.exec = func(f *frame) bltn { 3641 _, s0 := v0(f) 3642 _, s1 := v1(f) 3643 dest(f).Set(reflect.ValueOf(s0 >= s1).Convert(typ)) 3644 return tnext 3645 } 3646 case c0.rval.IsValid(): 3647 s0 := vFloat(c0.rval) 3648 v1 := genValueFloat(c1) 3649 if n.fnext != nil { 3650 fnext := getExec(n.fnext) 3651 n.exec = func(f *frame) bltn { 3652 _, s1 := v1(f) 3653 if s0 >= s1 { 3654 dest(f).SetBool(true) 3655 return tnext 3656 } 3657 dest(f).SetBool(false) 3658 return fnext 3659 } 3660 } else { 3661 n.exec = func(f *frame) bltn { 3662 _, s1 := v1(f) 3663 dest(f).SetBool(s0 >= s1) 3664 return tnext 3665 } 3666 } 3667 case c1.rval.IsValid(): 3668 s1 := vFloat(c1.rval) 3669 v0 := genValueFloat(c0) 3670 if n.fnext != nil { 3671 fnext := getExec(n.fnext) 3672 n.exec = func(f *frame) bltn { 3673 _, s0 := v0(f) 3674 if s0 >= s1 { 3675 dest(f).SetBool(true) 3676 return tnext 3677 } 3678 dest(f).SetBool(false) 3679 return fnext 3680 } 3681 } else { 3682 dest := genValue(n) 3683 n.exec = func(f *frame) bltn { 3684 _, s0 := v0(f) 3685 dest(f).SetBool(s0 >= s1) 3686 return tnext 3687 } 3688 } 3689 default: 3690 v0 := genValueFloat(c0) 3691 v1 := genValueFloat(c1) 3692 if n.fnext != nil { 3693 fnext := getExec(n.fnext) 3694 n.exec = func(f *frame) bltn { 3695 _, s0 := v0(f) 3696 _, s1 := v1(f) 3697 if s0 >= s1 { 3698 dest(f).SetBool(true) 3699 return tnext 3700 } 3701 dest(f).SetBool(false) 3702 return fnext 3703 } 3704 } else { 3705 dest := genValue(n) 3706 n.exec = func(f *frame) bltn { 3707 _, s0 := v0(f) 3708 _, s1 := v1(f) 3709 dest(f).SetBool(s0 >= s1) 3710 return tnext 3711 } 3712 } 3713 } 3714 case isUint(t0) || isUint(t1): 3715 switch { 3716 case isInterface: 3717 v0 := genValueUint(c0) 3718 v1 := genValueUint(c1) 3719 n.exec = func(f *frame) bltn { 3720 _, s0 := v0(f) 3721 _, s1 := v1(f) 3722 dest(f).Set(reflect.ValueOf(s0 >= s1).Convert(typ)) 3723 return tnext 3724 } 3725 case c0.rval.IsValid(): 3726 s0 := vUint(c0.rval) 3727 v1 := genValueUint(c1) 3728 if n.fnext != nil { 3729 fnext := getExec(n.fnext) 3730 n.exec = func(f *frame) bltn { 3731 _, s1 := v1(f) 3732 if s0 >= s1 { 3733 dest(f).SetBool(true) 3734 return tnext 3735 } 3736 dest(f).SetBool(false) 3737 return fnext 3738 } 3739 } else { 3740 dest := genValue(n) 3741 n.exec = func(f *frame) bltn { 3742 _, s1 := v1(f) 3743 dest(f).SetBool(s0 >= s1) 3744 return tnext 3745 } 3746 } 3747 case c1.rval.IsValid(): 3748 s1 := vUint(c1.rval) 3749 v0 := genValueUint(c0) 3750 if n.fnext != nil { 3751 fnext := getExec(n.fnext) 3752 n.exec = func(f *frame) bltn { 3753 _, s0 := v0(f) 3754 if s0 >= s1 { 3755 dest(f).SetBool(true) 3756 return tnext 3757 } 3758 dest(f).SetBool(false) 3759 return fnext 3760 } 3761 } else { 3762 dest := genValue(n) 3763 n.exec = func(f *frame) bltn { 3764 _, s0 := v0(f) 3765 dest(f).SetBool(s0 >= s1) 3766 return tnext 3767 } 3768 } 3769 default: 3770 v0 := genValueUint(c0) 3771 v1 := genValueUint(c1) 3772 if n.fnext != nil { 3773 fnext := getExec(n.fnext) 3774 n.exec = func(f *frame) bltn { 3775 _, s0 := v0(f) 3776 _, s1 := v1(f) 3777 if s0 >= s1 { 3778 dest(f).SetBool(true) 3779 return tnext 3780 } 3781 dest(f).SetBool(false) 3782 return fnext 3783 } 3784 } else { 3785 dest := genValue(n) 3786 n.exec = func(f *frame) bltn { 3787 _, s0 := v0(f) 3788 _, s1 := v1(f) 3789 dest(f).SetBool(s0 >= s1) 3790 return tnext 3791 } 3792 } 3793 } 3794 case isInt(t0) || isInt(t1): 3795 switch { 3796 case isInterface: 3797 v0 := genValueInt(c0) 3798 v1 := genValueInt(c1) 3799 n.exec = func(f *frame) bltn { 3800 _, s0 := v0(f) 3801 _, s1 := v1(f) 3802 dest(f).Set(reflect.ValueOf(s0 >= s1).Convert(typ)) 3803 return tnext 3804 } 3805 case c0.rval.IsValid(): 3806 s0 := vInt(c0.rval) 3807 v1 := genValueInt(c1) 3808 if n.fnext != nil { 3809 fnext := getExec(n.fnext) 3810 n.exec = func(f *frame) bltn { 3811 _, s1 := v1(f) 3812 if s0 >= s1 { 3813 dest(f).SetBool(true) 3814 return tnext 3815 } 3816 dest(f).SetBool(false) 3817 return fnext 3818 } 3819 } else { 3820 dest := genValue(n) 3821 n.exec = func(f *frame) bltn { 3822 _, s1 := v1(f) 3823 dest(f).SetBool(s0 >= s1) 3824 return tnext 3825 } 3826 } 3827 case c1.rval.IsValid(): 3828 s1 := vInt(c1.rval) 3829 v0 := genValueInt(c0) 3830 if n.fnext != nil { 3831 fnext := getExec(n.fnext) 3832 n.exec = func(f *frame) bltn { 3833 _, s0 := v0(f) 3834 if s0 >= s1 { 3835 dest(f).SetBool(true) 3836 return tnext 3837 } 3838 dest(f).SetBool(false) 3839 return fnext 3840 } 3841 } else { 3842 dest := genValue(n) 3843 n.exec = func(f *frame) bltn { 3844 _, s0 := v0(f) 3845 dest(f).SetBool(s0 >= s1) 3846 return tnext 3847 } 3848 } 3849 default: 3850 v0 := genValueInt(c0) 3851 v1 := genValueInt(c1) 3852 if n.fnext != nil { 3853 fnext := getExec(n.fnext) 3854 n.exec = func(f *frame) bltn { 3855 _, s0 := v0(f) 3856 _, s1 := v1(f) 3857 if s0 >= s1 { 3858 dest(f).SetBool(true) 3859 return tnext 3860 } 3861 dest(f).SetBool(false) 3862 return fnext 3863 } 3864 } else { 3865 dest := genValue(n) 3866 n.exec = func(f *frame) bltn { 3867 _, s0 := v0(f) 3868 _, s1 := v1(f) 3869 dest(f).SetBool(s0 >= s1) 3870 return tnext 3871 } 3872 } 3873 } 3874 } 3875 } 3876 3877 func lower(n *node) { 3878 tnext := getExec(n.tnext) 3879 dest := genValueOutput(n, reflect.TypeOf(true)) 3880 typ := n.typ.concrete().TypeOf() 3881 isInterface := n.typ.TypeOf().Kind() == reflect.Interface 3882 c0, c1 := n.child[0], n.child[1] 3883 t0, t1 := c0.typ.TypeOf(), c1.typ.TypeOf() 3884 3885 switch { 3886 case isString(t0) || isString(t1): 3887 switch { 3888 case isInterface: 3889 v0 := genValueString(c0) 3890 v1 := genValueString(c1) 3891 n.exec = func(f *frame) bltn { 3892 _, s0 := v0(f) 3893 _, s1 := v1(f) 3894 dest(f).Set(reflect.ValueOf(s0 < s1).Convert(typ)) 3895 return tnext 3896 } 3897 case c0.rval.IsValid(): 3898 s0 := vString(c0.rval) 3899 v1 := genValueString(c1) 3900 if n.fnext != nil { 3901 fnext := getExec(n.fnext) 3902 n.exec = func(f *frame) bltn { 3903 _, s1 := v1(f) 3904 if s0 < s1 { 3905 dest(f).SetBool(true) 3906 return tnext 3907 } 3908 dest(f).SetBool(false) 3909 return fnext 3910 } 3911 } else { 3912 n.exec = func(f *frame) bltn { 3913 _, s1 := v1(f) 3914 dest(f).SetBool(s0 < s1) 3915 return tnext 3916 } 3917 } 3918 case c1.rval.IsValid(): 3919 s1 := vString(c1.rval) 3920 v0 := genValueString(c0) 3921 if n.fnext != nil { 3922 fnext := getExec(n.fnext) 3923 n.exec = func(f *frame) bltn { 3924 _, s0 := v0(f) 3925 if s0 < s1 { 3926 dest(f).SetBool(true) 3927 return tnext 3928 } 3929 dest(f).SetBool(false) 3930 return fnext 3931 } 3932 } else { 3933 n.exec = func(f *frame) bltn { 3934 _, s0 := v0(f) 3935 dest(f).SetBool(s0 < s1) 3936 return tnext 3937 } 3938 } 3939 default: 3940 v0 := genValueString(c0) 3941 v1 := genValueString(c1) 3942 if n.fnext != nil { 3943 fnext := getExec(n.fnext) 3944 n.exec = func(f *frame) bltn { 3945 _, s0 := v0(f) 3946 _, s1 := v1(f) 3947 if s0 < s1 { 3948 dest(f).SetBool(true) 3949 return tnext 3950 } 3951 dest(f).SetBool(false) 3952 return fnext 3953 } 3954 } else { 3955 n.exec = func(f *frame) bltn { 3956 _, s0 := v0(f) 3957 _, s1 := v1(f) 3958 dest(f).SetBool(s0 < s1) 3959 return tnext 3960 } 3961 } 3962 } 3963 case isFloat(t0) || isFloat(t1): 3964 switch { 3965 case isInterface: 3966 v0 := genValueFloat(c0) 3967 v1 := genValueFloat(c1) 3968 n.exec = func(f *frame) bltn { 3969 _, s0 := v0(f) 3970 _, s1 := v1(f) 3971 dest(f).Set(reflect.ValueOf(s0 < s1).Convert(typ)) 3972 return tnext 3973 } 3974 case c0.rval.IsValid(): 3975 s0 := vFloat(c0.rval) 3976 v1 := genValueFloat(c1) 3977 if n.fnext != nil { 3978 fnext := getExec(n.fnext) 3979 n.exec = func(f *frame) bltn { 3980 _, s1 := v1(f) 3981 if s0 < s1 { 3982 dest(f).SetBool(true) 3983 return tnext 3984 } 3985 dest(f).SetBool(false) 3986 return fnext 3987 } 3988 } else { 3989 n.exec = func(f *frame) bltn { 3990 _, s1 := v1(f) 3991 dest(f).SetBool(s0 < s1) 3992 return tnext 3993 } 3994 } 3995 case c1.rval.IsValid(): 3996 s1 := vFloat(c1.rval) 3997 v0 := genValueFloat(c0) 3998 if n.fnext != nil { 3999 fnext := getExec(n.fnext) 4000 n.exec = func(f *frame) bltn { 4001 _, s0 := v0(f) 4002 if s0 < s1 { 4003 dest(f).SetBool(true) 4004 return tnext 4005 } 4006 dest(f).SetBool(false) 4007 return fnext 4008 } 4009 } else { 4010 dest := genValue(n) 4011 n.exec = func(f *frame) bltn { 4012 _, s0 := v0(f) 4013 dest(f).SetBool(s0 < s1) 4014 return tnext 4015 } 4016 } 4017 default: 4018 v0 := genValueFloat(c0) 4019 v1 := genValueFloat(c1) 4020 if n.fnext != nil { 4021 fnext := getExec(n.fnext) 4022 n.exec = func(f *frame) bltn { 4023 _, s0 := v0(f) 4024 _, s1 := v1(f) 4025 if s0 < s1 { 4026 dest(f).SetBool(true) 4027 return tnext 4028 } 4029 dest(f).SetBool(false) 4030 return fnext 4031 } 4032 } else { 4033 dest := genValue(n) 4034 n.exec = func(f *frame) bltn { 4035 _, s0 := v0(f) 4036 _, s1 := v1(f) 4037 dest(f).SetBool(s0 < s1) 4038 return tnext 4039 } 4040 } 4041 } 4042 case isUint(t0) || isUint(t1): 4043 switch { 4044 case isInterface: 4045 v0 := genValueUint(c0) 4046 v1 := genValueUint(c1) 4047 n.exec = func(f *frame) bltn { 4048 _, s0 := v0(f) 4049 _, s1 := v1(f) 4050 dest(f).Set(reflect.ValueOf(s0 < s1).Convert(typ)) 4051 return tnext 4052 } 4053 case c0.rval.IsValid(): 4054 s0 := vUint(c0.rval) 4055 v1 := genValueUint(c1) 4056 if n.fnext != nil { 4057 fnext := getExec(n.fnext) 4058 n.exec = func(f *frame) bltn { 4059 _, s1 := v1(f) 4060 if s0 < s1 { 4061 dest(f).SetBool(true) 4062 return tnext 4063 } 4064 dest(f).SetBool(false) 4065 return fnext 4066 } 4067 } else { 4068 dest := genValue(n) 4069 n.exec = func(f *frame) bltn { 4070 _, s1 := v1(f) 4071 dest(f).SetBool(s0 < s1) 4072 return tnext 4073 } 4074 } 4075 case c1.rval.IsValid(): 4076 s1 := vUint(c1.rval) 4077 v0 := genValueUint(c0) 4078 if n.fnext != nil { 4079 fnext := getExec(n.fnext) 4080 n.exec = func(f *frame) bltn { 4081 _, s0 := v0(f) 4082 if s0 < s1 { 4083 dest(f).SetBool(true) 4084 return tnext 4085 } 4086 dest(f).SetBool(false) 4087 return fnext 4088 } 4089 } else { 4090 dest := genValue(n) 4091 n.exec = func(f *frame) bltn { 4092 _, s0 := v0(f) 4093 dest(f).SetBool(s0 < s1) 4094 return tnext 4095 } 4096 } 4097 default: 4098 v0 := genValueUint(c0) 4099 v1 := genValueUint(c1) 4100 if n.fnext != nil { 4101 fnext := getExec(n.fnext) 4102 n.exec = func(f *frame) bltn { 4103 _, s0 := v0(f) 4104 _, s1 := v1(f) 4105 if s0 < s1 { 4106 dest(f).SetBool(true) 4107 return tnext 4108 } 4109 dest(f).SetBool(false) 4110 return fnext 4111 } 4112 } else { 4113 dest := genValue(n) 4114 n.exec = func(f *frame) bltn { 4115 _, s0 := v0(f) 4116 _, s1 := v1(f) 4117 dest(f).SetBool(s0 < s1) 4118 return tnext 4119 } 4120 } 4121 } 4122 case isInt(t0) || isInt(t1): 4123 switch { 4124 case isInterface: 4125 v0 := genValueInt(c0) 4126 v1 := genValueInt(c1) 4127 n.exec = func(f *frame) bltn { 4128 _, s0 := v0(f) 4129 _, s1 := v1(f) 4130 dest(f).Set(reflect.ValueOf(s0 < s1).Convert(typ)) 4131 return tnext 4132 } 4133 case c0.rval.IsValid(): 4134 s0 := vInt(c0.rval) 4135 v1 := genValueInt(c1) 4136 if n.fnext != nil { 4137 fnext := getExec(n.fnext) 4138 n.exec = func(f *frame) bltn { 4139 _, s1 := v1(f) 4140 if s0 < s1 { 4141 dest(f).SetBool(true) 4142 return tnext 4143 } 4144 dest(f).SetBool(false) 4145 return fnext 4146 } 4147 } else { 4148 dest := genValue(n) 4149 n.exec = func(f *frame) bltn { 4150 _, s1 := v1(f) 4151 dest(f).SetBool(s0 < s1) 4152 return tnext 4153 } 4154 } 4155 case c1.rval.IsValid(): 4156 s1 := vInt(c1.rval) 4157 v0 := genValueInt(c0) 4158 if n.fnext != nil { 4159 fnext := getExec(n.fnext) 4160 n.exec = func(f *frame) bltn { 4161 _, s0 := v0(f) 4162 if s0 < s1 { 4163 dest(f).SetBool(true) 4164 return tnext 4165 } 4166 dest(f).SetBool(false) 4167 return fnext 4168 } 4169 } else { 4170 dest := genValue(n) 4171 n.exec = func(f *frame) bltn { 4172 _, s0 := v0(f) 4173 dest(f).SetBool(s0 < s1) 4174 return tnext 4175 } 4176 } 4177 default: 4178 v0 := genValueInt(c0) 4179 v1 := genValueInt(c1) 4180 if n.fnext != nil { 4181 fnext := getExec(n.fnext) 4182 n.exec = func(f *frame) bltn { 4183 _, s0 := v0(f) 4184 _, s1 := v1(f) 4185 if s0 < s1 { 4186 dest(f).SetBool(true) 4187 return tnext 4188 } 4189 dest(f).SetBool(false) 4190 return fnext 4191 } 4192 } else { 4193 dest := genValue(n) 4194 n.exec = func(f *frame) bltn { 4195 _, s0 := v0(f) 4196 _, s1 := v1(f) 4197 dest(f).SetBool(s0 < s1) 4198 return tnext 4199 } 4200 } 4201 } 4202 } 4203 } 4204 4205 func lowerEqual(n *node) { 4206 tnext := getExec(n.tnext) 4207 dest := genValueOutput(n, reflect.TypeOf(true)) 4208 typ := n.typ.concrete().TypeOf() 4209 isInterface := n.typ.TypeOf().Kind() == reflect.Interface 4210 c0, c1 := n.child[0], n.child[1] 4211 t0, t1 := c0.typ.TypeOf(), c1.typ.TypeOf() 4212 4213 switch { 4214 case isString(t0) || isString(t1): 4215 switch { 4216 case isInterface: 4217 v0 := genValueString(c0) 4218 v1 := genValueString(c1) 4219 n.exec = func(f *frame) bltn { 4220 _, s0 := v0(f) 4221 _, s1 := v1(f) 4222 dest(f).Set(reflect.ValueOf(s0 <= s1).Convert(typ)) 4223 return tnext 4224 } 4225 case c0.rval.IsValid(): 4226 s0 := vString(c0.rval) 4227 v1 := genValueString(c1) 4228 if n.fnext != nil { 4229 fnext := getExec(n.fnext) 4230 n.exec = func(f *frame) bltn { 4231 _, s1 := v1(f) 4232 if s0 <= s1 { 4233 dest(f).SetBool(true) 4234 return tnext 4235 } 4236 dest(f).SetBool(false) 4237 return fnext 4238 } 4239 } else { 4240 n.exec = func(f *frame) bltn { 4241 _, s1 := v1(f) 4242 dest(f).SetBool(s0 <= s1) 4243 return tnext 4244 } 4245 } 4246 case c1.rval.IsValid(): 4247 s1 := vString(c1.rval) 4248 v0 := genValueString(c0) 4249 if n.fnext != nil { 4250 fnext := getExec(n.fnext) 4251 n.exec = func(f *frame) bltn { 4252 _, s0 := v0(f) 4253 if s0 <= s1 { 4254 dest(f).SetBool(true) 4255 return tnext 4256 } 4257 dest(f).SetBool(false) 4258 return fnext 4259 } 4260 } else { 4261 n.exec = func(f *frame) bltn { 4262 _, s0 := v0(f) 4263 dest(f).SetBool(s0 <= s1) 4264 return tnext 4265 } 4266 } 4267 default: 4268 v0 := genValueString(c0) 4269 v1 := genValueString(c1) 4270 if n.fnext != nil { 4271 fnext := getExec(n.fnext) 4272 n.exec = func(f *frame) bltn { 4273 _, s0 := v0(f) 4274 _, s1 := v1(f) 4275 if s0 <= s1 { 4276 dest(f).SetBool(true) 4277 return tnext 4278 } 4279 dest(f).SetBool(false) 4280 return fnext 4281 } 4282 } else { 4283 n.exec = func(f *frame) bltn { 4284 _, s0 := v0(f) 4285 _, s1 := v1(f) 4286 dest(f).SetBool(s0 <= s1) 4287 return tnext 4288 } 4289 } 4290 } 4291 case isFloat(t0) || isFloat(t1): 4292 switch { 4293 case isInterface: 4294 v0 := genValueFloat(c0) 4295 v1 := genValueFloat(c1) 4296 n.exec = func(f *frame) bltn { 4297 _, s0 := v0(f) 4298 _, s1 := v1(f) 4299 dest(f).Set(reflect.ValueOf(s0 <= s1).Convert(typ)) 4300 return tnext 4301 } 4302 case c0.rval.IsValid(): 4303 s0 := vFloat(c0.rval) 4304 v1 := genValueFloat(c1) 4305 if n.fnext != nil { 4306 fnext := getExec(n.fnext) 4307 n.exec = func(f *frame) bltn { 4308 _, s1 := v1(f) 4309 if s0 <= s1 { 4310 dest(f).SetBool(true) 4311 return tnext 4312 } 4313 dest(f).SetBool(false) 4314 return fnext 4315 } 4316 } else { 4317 n.exec = func(f *frame) bltn { 4318 _, s1 := v1(f) 4319 dest(f).SetBool(s0 <= s1) 4320 return tnext 4321 } 4322 } 4323 case c1.rval.IsValid(): 4324 s1 := vFloat(c1.rval) 4325 v0 := genValueFloat(c0) 4326 if n.fnext != nil { 4327 fnext := getExec(n.fnext) 4328 n.exec = func(f *frame) bltn { 4329 _, s0 := v0(f) 4330 if s0 <= s1 { 4331 dest(f).SetBool(true) 4332 return tnext 4333 } 4334 dest(f).SetBool(false) 4335 return fnext 4336 } 4337 } else { 4338 dest := genValue(n) 4339 n.exec = func(f *frame) bltn { 4340 _, s0 := v0(f) 4341 dest(f).SetBool(s0 <= s1) 4342 return tnext 4343 } 4344 } 4345 default: 4346 v0 := genValueFloat(c0) 4347 v1 := genValueFloat(c1) 4348 if n.fnext != nil { 4349 fnext := getExec(n.fnext) 4350 n.exec = func(f *frame) bltn { 4351 _, s0 := v0(f) 4352 _, s1 := v1(f) 4353 if s0 <= s1 { 4354 dest(f).SetBool(true) 4355 return tnext 4356 } 4357 dest(f).SetBool(false) 4358 return fnext 4359 } 4360 } else { 4361 dest := genValue(n) 4362 n.exec = func(f *frame) bltn { 4363 _, s0 := v0(f) 4364 _, s1 := v1(f) 4365 dest(f).SetBool(s0 <= s1) 4366 return tnext 4367 } 4368 } 4369 } 4370 case isUint(t0) || isUint(t1): 4371 switch { 4372 case isInterface: 4373 v0 := genValueUint(c0) 4374 v1 := genValueUint(c1) 4375 n.exec = func(f *frame) bltn { 4376 _, s0 := v0(f) 4377 _, s1 := v1(f) 4378 dest(f).Set(reflect.ValueOf(s0 <= s1).Convert(typ)) 4379 return tnext 4380 } 4381 case c0.rval.IsValid(): 4382 s0 := vUint(c0.rval) 4383 v1 := genValueUint(c1) 4384 if n.fnext != nil { 4385 fnext := getExec(n.fnext) 4386 n.exec = func(f *frame) bltn { 4387 _, s1 := v1(f) 4388 if s0 <= s1 { 4389 dest(f).SetBool(true) 4390 return tnext 4391 } 4392 dest(f).SetBool(false) 4393 return fnext 4394 } 4395 } else { 4396 dest := genValue(n) 4397 n.exec = func(f *frame) bltn { 4398 _, s1 := v1(f) 4399 dest(f).SetBool(s0 <= s1) 4400 return tnext 4401 } 4402 } 4403 case c1.rval.IsValid(): 4404 s1 := vUint(c1.rval) 4405 v0 := genValueUint(c0) 4406 if n.fnext != nil { 4407 fnext := getExec(n.fnext) 4408 n.exec = func(f *frame) bltn { 4409 _, s0 := v0(f) 4410 if s0 <= s1 { 4411 dest(f).SetBool(true) 4412 return tnext 4413 } 4414 dest(f).SetBool(false) 4415 return fnext 4416 } 4417 } else { 4418 dest := genValue(n) 4419 n.exec = func(f *frame) bltn { 4420 _, s0 := v0(f) 4421 dest(f).SetBool(s0 <= s1) 4422 return tnext 4423 } 4424 } 4425 default: 4426 v0 := genValueUint(c0) 4427 v1 := genValueUint(c1) 4428 if n.fnext != nil { 4429 fnext := getExec(n.fnext) 4430 n.exec = func(f *frame) bltn { 4431 _, s0 := v0(f) 4432 _, s1 := v1(f) 4433 if s0 <= s1 { 4434 dest(f).SetBool(true) 4435 return tnext 4436 } 4437 dest(f).SetBool(false) 4438 return fnext 4439 } 4440 } else { 4441 dest := genValue(n) 4442 n.exec = func(f *frame) bltn { 4443 _, s0 := v0(f) 4444 _, s1 := v1(f) 4445 dest(f).SetBool(s0 <= s1) 4446 return tnext 4447 } 4448 } 4449 } 4450 case isInt(t0) || isInt(t1): 4451 switch { 4452 case isInterface: 4453 v0 := genValueInt(c0) 4454 v1 := genValueInt(c1) 4455 n.exec = func(f *frame) bltn { 4456 _, s0 := v0(f) 4457 _, s1 := v1(f) 4458 dest(f).Set(reflect.ValueOf(s0 <= s1).Convert(typ)) 4459 return tnext 4460 } 4461 case c0.rval.IsValid(): 4462 s0 := vInt(c0.rval) 4463 v1 := genValueInt(c1) 4464 if n.fnext != nil { 4465 fnext := getExec(n.fnext) 4466 n.exec = func(f *frame) bltn { 4467 _, s1 := v1(f) 4468 if s0 <= s1 { 4469 dest(f).SetBool(true) 4470 return tnext 4471 } 4472 dest(f).SetBool(false) 4473 return fnext 4474 } 4475 } else { 4476 dest := genValue(n) 4477 n.exec = func(f *frame) bltn { 4478 _, s1 := v1(f) 4479 dest(f).SetBool(s0 <= s1) 4480 return tnext 4481 } 4482 } 4483 case c1.rval.IsValid(): 4484 s1 := vInt(c1.rval) 4485 v0 := genValueInt(c0) 4486 if n.fnext != nil { 4487 fnext := getExec(n.fnext) 4488 n.exec = func(f *frame) bltn { 4489 _, s0 := v0(f) 4490 if s0 <= s1 { 4491 dest(f).SetBool(true) 4492 return tnext 4493 } 4494 dest(f).SetBool(false) 4495 return fnext 4496 } 4497 } else { 4498 dest := genValue(n) 4499 n.exec = func(f *frame) bltn { 4500 _, s0 := v0(f) 4501 dest(f).SetBool(s0 <= s1) 4502 return tnext 4503 } 4504 } 4505 default: 4506 v0 := genValueInt(c0) 4507 v1 := genValueInt(c1) 4508 if n.fnext != nil { 4509 fnext := getExec(n.fnext) 4510 n.exec = func(f *frame) bltn { 4511 _, s0 := v0(f) 4512 _, s1 := v1(f) 4513 if s0 <= s1 { 4514 dest(f).SetBool(true) 4515 return tnext 4516 } 4517 dest(f).SetBool(false) 4518 return fnext 4519 } 4520 } else { 4521 dest := genValue(n) 4522 n.exec = func(f *frame) bltn { 4523 _, s0 := v0(f) 4524 _, s1 := v1(f) 4525 dest(f).SetBool(s0 <= s1) 4526 return tnext 4527 } 4528 } 4529 } 4530 } 4531 } 4532 4533 func notEqual(n *node) { 4534 tnext := getExec(n.tnext) 4535 dest := genValueOutput(n, reflect.TypeOf(true)) 4536 typ := n.typ.concrete().TypeOf() 4537 isInterface := n.typ.TypeOf().Kind() == reflect.Interface 4538 c0, c1 := n.child[0], n.child[1] 4539 t0, t1 := c0.typ.TypeOf(), c1.typ.TypeOf() 4540 4541 if c0.typ.cat == aliasT || c1.typ.cat == aliasT { 4542 switch { 4543 case isInterface: 4544 v0 := genValue(c0) 4545 v1 := genValue(c1) 4546 dest := genValue(n) 4547 n.exec = func(f *frame) bltn { 4548 i0 := v0(f).Interface() 4549 i1 := v1(f).Interface() 4550 dest(f).Set(reflect.ValueOf(i0 != i1).Convert(typ)) 4551 return tnext 4552 } 4553 case c0.rval.IsValid(): 4554 i0 := c0.rval.Interface() 4555 v1 := genValue(c1) 4556 if n.fnext != nil { 4557 fnext := getExec(n.fnext) 4558 n.exec = func(f *frame) bltn { 4559 i1 := v1(f).Interface() 4560 if i0 != i1 { 4561 dest(f).SetBool(true) 4562 return tnext 4563 } 4564 dest(f).SetBool(false) 4565 return fnext 4566 } 4567 } else { 4568 dest := genValue(n) 4569 n.exec = func(f *frame) bltn { 4570 i1 := v1(f).Interface() 4571 dest(f).SetBool(i0 != i1) 4572 return tnext 4573 } 4574 } 4575 case c1.rval.IsValid(): 4576 i1 := c1.rval.Interface() 4577 v0 := genValue(c0) 4578 if n.fnext != nil { 4579 fnext := getExec(n.fnext) 4580 n.exec = func(f *frame) bltn { 4581 i0 := v0(f).Interface() 4582 if i0 != i1 { 4583 dest(f).SetBool(true) 4584 return tnext 4585 } 4586 dest(f).SetBool(false) 4587 return fnext 4588 } 4589 } else { 4590 dest := genValue(n) 4591 n.exec = func(f *frame) bltn { 4592 i0 := v0(f).Interface() 4593 dest(f).SetBool(i0 != i1) 4594 return tnext 4595 } 4596 } 4597 default: 4598 v0 := genValue(c0) 4599 v1 := genValue(c1) 4600 if n.fnext != nil { 4601 fnext := getExec(n.fnext) 4602 n.exec = func(f *frame) bltn { 4603 i0 := v0(f).Interface() 4604 i1 := v1(f).Interface() 4605 if i0 != i1 { 4606 dest(f).SetBool(true) 4607 return tnext 4608 } 4609 dest(f).SetBool(false) 4610 return fnext 4611 } 4612 } else { 4613 dest := genValue(n) 4614 n.exec = func(f *frame) bltn { 4615 i0 := v0(f).Interface() 4616 i1 := v1(f).Interface() 4617 dest(f).SetBool(i0 != i1) 4618 return tnext 4619 } 4620 } 4621 } 4622 return 4623 } 4624 4625 // Do not attempt to optimize '==' or '!=' if an operand is an interface. 4626 // This will preserve proper dynamic type checking at runtime. For static types, 4627 // type checks are already performed, so bypass them if possible. 4628 if t0.Kind() == reflect.Interface || t1.Kind() == reflect.Interface { 4629 v0 := genValue(c0) 4630 v1 := genValue(c1) 4631 if n.fnext != nil { 4632 fnext := getExec(n.fnext) 4633 n.exec = func(f *frame) bltn { 4634 i0 := v0(f).Interface() 4635 i1 := v1(f).Interface() 4636 if i0 != i1 { 4637 dest(f).SetBool(true) 4638 return tnext 4639 } 4640 dest(f).SetBool(false) 4641 return fnext 4642 } 4643 } else { 4644 dest := genValue(n) 4645 n.exec = func(f *frame) bltn { 4646 i0 := v0(f).Interface() 4647 i1 := v1(f).Interface() 4648 dest(f).SetBool(i0 != i1) 4649 return tnext 4650 } 4651 } 4652 return 4653 } 4654 4655 switch { 4656 case isString(t0) || isString(t1): 4657 switch { 4658 case isInterface: 4659 v0 := genValueString(c0) 4660 v1 := genValueString(c1) 4661 n.exec = func(f *frame) bltn { 4662 _, s0 := v0(f) 4663 _, s1 := v1(f) 4664 dest(f).Set(reflect.ValueOf(s0 != s1).Convert(typ)) 4665 return tnext 4666 } 4667 case c0.rval.IsValid(): 4668 s0 := vString(c0.rval) 4669 v1 := genValueString(c1) 4670 if n.fnext != nil { 4671 fnext := getExec(n.fnext) 4672 n.exec = func(f *frame) bltn { 4673 _, s1 := v1(f) 4674 if s0 != s1 { 4675 dest(f).SetBool(true) 4676 return tnext 4677 } 4678 dest(f).SetBool(false) 4679 return fnext 4680 } 4681 } else { 4682 n.exec = func(f *frame) bltn { 4683 _, s1 := v1(f) 4684 dest(f).SetBool(s0 != s1) 4685 return tnext 4686 } 4687 } 4688 case c1.rval.IsValid(): 4689 s1 := vString(c1.rval) 4690 v0 := genValueString(c0) 4691 if n.fnext != nil { 4692 fnext := getExec(n.fnext) 4693 n.exec = func(f *frame) bltn { 4694 _, s0 := v0(f) 4695 if s0 != s1 { 4696 dest(f).SetBool(true) 4697 return tnext 4698 } 4699 dest(f).SetBool(false) 4700 return fnext 4701 } 4702 } else { 4703 n.exec = func(f *frame) bltn { 4704 _, s0 := v0(f) 4705 dest(f).SetBool(s0 != s1) 4706 return tnext 4707 } 4708 } 4709 default: 4710 v0 := genValueString(c0) 4711 v1 := genValueString(c1) 4712 if n.fnext != nil { 4713 fnext := getExec(n.fnext) 4714 n.exec = func(f *frame) bltn { 4715 _, s0 := v0(f) 4716 _, s1 := v1(f) 4717 if s0 != s1 { 4718 dest(f).SetBool(true) 4719 return tnext 4720 } 4721 dest(f).SetBool(false) 4722 return fnext 4723 } 4724 } else { 4725 n.exec = func(f *frame) bltn { 4726 _, s0 := v0(f) 4727 _, s1 := v1(f) 4728 dest(f).SetBool(s0 != s1) 4729 return tnext 4730 } 4731 } 4732 } 4733 case isFloat(t0) || isFloat(t1): 4734 switch { 4735 case isInterface: 4736 v0 := genValueFloat(c0) 4737 v1 := genValueFloat(c1) 4738 n.exec = func(f *frame) bltn { 4739 _, s0 := v0(f) 4740 _, s1 := v1(f) 4741 dest(f).Set(reflect.ValueOf(s0 != s1).Convert(typ)) 4742 return tnext 4743 } 4744 case c0.rval.IsValid(): 4745 s0 := vFloat(c0.rval) 4746 v1 := genValueFloat(c1) 4747 if n.fnext != nil { 4748 fnext := getExec(n.fnext) 4749 n.exec = func(f *frame) bltn { 4750 _, s1 := v1(f) 4751 if s0 != s1 { 4752 dest(f).SetBool(true) 4753 return tnext 4754 } 4755 dest(f).SetBool(false) 4756 return fnext 4757 } 4758 } else { 4759 n.exec = func(f *frame) bltn { 4760 _, s1 := v1(f) 4761 dest(f).SetBool(s0 != s1) 4762 return tnext 4763 } 4764 } 4765 case c1.rval.IsValid(): 4766 s1 := vFloat(c1.rval) 4767 v0 := genValueFloat(c0) 4768 if n.fnext != nil { 4769 fnext := getExec(n.fnext) 4770 n.exec = func(f *frame) bltn { 4771 _, s0 := v0(f) 4772 if s0 != s1 { 4773 dest(f).SetBool(true) 4774 return tnext 4775 } 4776 dest(f).SetBool(false) 4777 return fnext 4778 } 4779 } else { 4780 dest := genValue(n) 4781 n.exec = func(f *frame) bltn { 4782 _, s0 := v0(f) 4783 dest(f).SetBool(s0 != s1) 4784 return tnext 4785 } 4786 } 4787 default: 4788 v0 := genValueFloat(c0) 4789 v1 := genValueFloat(c1) 4790 if n.fnext != nil { 4791 fnext := getExec(n.fnext) 4792 n.exec = func(f *frame) bltn { 4793 _, s0 := v0(f) 4794 _, s1 := v1(f) 4795 if s0 != s1 { 4796 dest(f).SetBool(true) 4797 return tnext 4798 } 4799 dest(f).SetBool(false) 4800 return fnext 4801 } 4802 } else { 4803 dest := genValue(n) 4804 n.exec = func(f *frame) bltn { 4805 _, s0 := v0(f) 4806 _, s1 := v1(f) 4807 dest(f).SetBool(s0 != s1) 4808 return tnext 4809 } 4810 } 4811 } 4812 case isUint(t0) || isUint(t1): 4813 switch { 4814 case isInterface: 4815 v0 := genValueUint(c0) 4816 v1 := genValueUint(c1) 4817 n.exec = func(f *frame) bltn { 4818 _, s0 := v0(f) 4819 _, s1 := v1(f) 4820 dest(f).Set(reflect.ValueOf(s0 != s1).Convert(typ)) 4821 return tnext 4822 } 4823 case c0.rval.IsValid(): 4824 s0 := vUint(c0.rval) 4825 v1 := genValueUint(c1) 4826 if n.fnext != nil { 4827 fnext := getExec(n.fnext) 4828 n.exec = func(f *frame) bltn { 4829 _, s1 := v1(f) 4830 if s0 != s1 { 4831 dest(f).SetBool(true) 4832 return tnext 4833 } 4834 dest(f).SetBool(false) 4835 return fnext 4836 } 4837 } else { 4838 dest := genValue(n) 4839 n.exec = func(f *frame) bltn { 4840 _, s1 := v1(f) 4841 dest(f).SetBool(s0 != s1) 4842 return tnext 4843 } 4844 } 4845 case c1.rval.IsValid(): 4846 s1 := vUint(c1.rval) 4847 v0 := genValueUint(c0) 4848 if n.fnext != nil { 4849 fnext := getExec(n.fnext) 4850 n.exec = func(f *frame) bltn { 4851 _, s0 := v0(f) 4852 if s0 != s1 { 4853 dest(f).SetBool(true) 4854 return tnext 4855 } 4856 dest(f).SetBool(false) 4857 return fnext 4858 } 4859 } else { 4860 dest := genValue(n) 4861 n.exec = func(f *frame) bltn { 4862 _, s0 := v0(f) 4863 dest(f).SetBool(s0 != s1) 4864 return tnext 4865 } 4866 } 4867 default: 4868 v0 := genValueUint(c0) 4869 v1 := genValueUint(c1) 4870 if n.fnext != nil { 4871 fnext := getExec(n.fnext) 4872 n.exec = func(f *frame) bltn { 4873 _, s0 := v0(f) 4874 _, s1 := v1(f) 4875 if s0 != s1 { 4876 dest(f).SetBool(true) 4877 return tnext 4878 } 4879 dest(f).SetBool(false) 4880 return fnext 4881 } 4882 } else { 4883 dest := genValue(n) 4884 n.exec = func(f *frame) bltn { 4885 _, s0 := v0(f) 4886 _, s1 := v1(f) 4887 dest(f).SetBool(s0 != s1) 4888 return tnext 4889 } 4890 } 4891 } 4892 case isInt(t0) || isInt(t1): 4893 switch { 4894 case isInterface: 4895 v0 := genValueInt(c0) 4896 v1 := genValueInt(c1) 4897 n.exec = func(f *frame) bltn { 4898 _, s0 := v0(f) 4899 _, s1 := v1(f) 4900 dest(f).Set(reflect.ValueOf(s0 != s1).Convert(typ)) 4901 return tnext 4902 } 4903 case c0.rval.IsValid(): 4904 s0 := vInt(c0.rval) 4905 v1 := genValueInt(c1) 4906 if n.fnext != nil { 4907 fnext := getExec(n.fnext) 4908 n.exec = func(f *frame) bltn { 4909 _, s1 := v1(f) 4910 if s0 != s1 { 4911 dest(f).SetBool(true) 4912 return tnext 4913 } 4914 dest(f).SetBool(false) 4915 return fnext 4916 } 4917 } else { 4918 dest := genValue(n) 4919 n.exec = func(f *frame) bltn { 4920 _, s1 := v1(f) 4921 dest(f).SetBool(s0 != s1) 4922 return tnext 4923 } 4924 } 4925 case c1.rval.IsValid(): 4926 s1 := vInt(c1.rval) 4927 v0 := genValueInt(c0) 4928 if n.fnext != nil { 4929 fnext := getExec(n.fnext) 4930 n.exec = func(f *frame) bltn { 4931 _, s0 := v0(f) 4932 if s0 != s1 { 4933 dest(f).SetBool(true) 4934 return tnext 4935 } 4936 dest(f).SetBool(false) 4937 return fnext 4938 } 4939 } else { 4940 dest := genValue(n) 4941 n.exec = func(f *frame) bltn { 4942 _, s0 := v0(f) 4943 dest(f).SetBool(s0 != s1) 4944 return tnext 4945 } 4946 } 4947 default: 4948 v0 := genValueInt(c0) 4949 v1 := genValueInt(c1) 4950 if n.fnext != nil { 4951 fnext := getExec(n.fnext) 4952 n.exec = func(f *frame) bltn { 4953 _, s0 := v0(f) 4954 _, s1 := v1(f) 4955 if s0 != s1 { 4956 dest(f).SetBool(true) 4957 return tnext 4958 } 4959 dest(f).SetBool(false) 4960 return fnext 4961 } 4962 } else { 4963 dest := genValue(n) 4964 n.exec = func(f *frame) bltn { 4965 _, s0 := v0(f) 4966 _, s1 := v1(f) 4967 dest(f).SetBool(s0 != s1) 4968 return tnext 4969 } 4970 } 4971 } 4972 case isComplex(t0) || isComplex(t1): 4973 switch { 4974 case isInterface: 4975 v0 := genComplex(c0) 4976 v1 := genComplex(c1) 4977 n.exec = func(f *frame) bltn { 4978 s0 := v0(f) 4979 s1 := v1(f) 4980 dest(f).Set(reflect.ValueOf(s0 != s1).Convert(typ)) 4981 return tnext 4982 } 4983 case c0.rval.IsValid(): 4984 s0 := vComplex(c0.rval) 4985 v1 := genComplex(c1) 4986 if n.fnext != nil { 4987 fnext := getExec(n.fnext) 4988 n.exec = func(f *frame) bltn { 4989 s1 := v1(f) 4990 if s0 != s1 { 4991 dest(f).SetBool(true) 4992 return tnext 4993 } 4994 dest(f).SetBool(false) 4995 return fnext 4996 } 4997 } else { 4998 n.exec = func(f *frame) bltn { 4999 s1 := v1(f) 5000 dest(f).SetBool(s0 != s1) 5001 return tnext 5002 } 5003 } 5004 case c1.rval.IsValid(): 5005 s1 := vComplex(c1.rval) 5006 v0 := genComplex(c0) 5007 if n.fnext != nil { 5008 fnext := getExec(n.fnext) 5009 n.exec = func(f *frame) bltn { 5010 s0 := v0(f) 5011 if s0 != s1 { 5012 dest(f).SetBool(true) 5013 return tnext 5014 } 5015 dest(f).SetBool(false) 5016 return fnext 5017 } 5018 } else { 5019 dest := genValue(n) 5020 n.exec = func(f *frame) bltn { 5021 s0 := v0(f) 5022 dest(f).SetBool(s0 != s1) 5023 return tnext 5024 } 5025 } 5026 default: 5027 v0 := genComplex(c0) 5028 v1 := genComplex(c1) 5029 if n.fnext != nil { 5030 fnext := getExec(n.fnext) 5031 n.exec = func(f *frame) bltn { 5032 s0 := v0(f) 5033 s1 := v1(f) 5034 if s0 != s1 { 5035 dest(f).SetBool(true) 5036 return tnext 5037 } 5038 dest(f).SetBool(false) 5039 return fnext 5040 } 5041 } else { 5042 n.exec = func(f *frame) bltn { 5043 s0 := v0(f) 5044 s1 := v1(f) 5045 dest(f).SetBool(s0 != s1) 5046 return tnext 5047 } 5048 } 5049 } 5050 default: 5051 switch { 5052 case isInterface: 5053 v0 := genValue(c0) 5054 v1 := genValue(c1) 5055 n.exec = func(f *frame) bltn { 5056 i0 := v0(f).Interface() 5057 i1 := v1(f).Interface() 5058 dest(f).Set(reflect.ValueOf(i0 != i1).Convert(typ)) 5059 return tnext 5060 } 5061 case c0.rval.IsValid(): 5062 i0 := c0.rval.Interface() 5063 v1 := genValue(c1) 5064 if n.fnext != nil { 5065 fnext := getExec(n.fnext) 5066 n.exec = func(f *frame) bltn { 5067 i1 := v1(f).Interface() 5068 if i0 != i1 { 5069 dest(f).SetBool(true) 5070 return tnext 5071 } 5072 dest(f).SetBool(false) 5073 return fnext 5074 } 5075 } else { 5076 dest := genValue(n) 5077 n.exec = func(f *frame) bltn { 5078 i1 := v1(f).Interface() 5079 dest(f).SetBool(i0 != i1) 5080 return tnext 5081 } 5082 } 5083 case c1.rval.IsValid(): 5084 i1 := c1.rval.Interface() 5085 v0 := genValue(c0) 5086 if n.fnext != nil { 5087 fnext := getExec(n.fnext) 5088 n.exec = func(f *frame) bltn { 5089 i0 := v0(f).Interface() 5090 if i0 != i1 { 5091 dest(f).SetBool(true) 5092 return tnext 5093 } 5094 dest(f).SetBool(false) 5095 return fnext 5096 } 5097 } else { 5098 dest := genValue(n) 5099 n.exec = func(f *frame) bltn { 5100 i0 := v0(f).Interface() 5101 dest(f).SetBool(i0 != i1) 5102 return tnext 5103 } 5104 } 5105 default: 5106 v0 := genValue(c0) 5107 v1 := genValue(c1) 5108 if n.fnext != nil { 5109 fnext := getExec(n.fnext) 5110 n.exec = func(f *frame) bltn { 5111 i0 := v0(f).Interface() 5112 i1 := v1(f).Interface() 5113 if i0 != i1 { 5114 dest(f).SetBool(true) 5115 return tnext 5116 } 5117 dest(f).SetBool(false) 5118 return fnext 5119 } 5120 } else { 5121 dest := genValue(n) 5122 n.exec = func(f *frame) bltn { 5123 i0 := v0(f).Interface() 5124 i1 := v1(f).Interface() 5125 dest(f).SetBool(i0 != i1) 5126 return tnext 5127 } 5128 } 5129 } 5130 } 5131 }