1package interp 2 3// Code generated by 'go run ../internal/cmd/genop/genop.go'. DO NOT EDIT. 4 5import ( 6 "go/constant" 7 "go/token" 8 "reflect" 9) 10 11// Arithmetic operators 12 13func 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 197func 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 222func 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 307func 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 326func 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 411func 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 430func 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 583func 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 606func 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 691func 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 710func 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 863func 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 895func 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 980func 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 999func 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 1084func 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 1103func 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 1188func 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 1207func 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 1360func 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 1383func 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 1468func 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 1489func 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 1623func 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 1690func 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 1757func 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 1869func 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 1936func 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 2048func 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 2115func 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 2182func 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 2249func 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 2361func 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 2428func 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 2484func 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 2540func 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 2559func 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 2582func 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 2598func 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 2621func 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 2628 if c0.typ.cat == aliasT || c1.typ.cat == aliasT { 2629 switch { 2630 case isInterface: 2631 v0 := genValue(c0) 2632 v1 := genValue(c1) 2633 dest := genValue(n) 2634 n.exec = func(f *frame) bltn { 2635 i0 := v0(f).Interface() 2636 i1 := v1(f).Interface() 2637 dest(f).Set(reflect.ValueOf(i0 == i1).Convert(typ)) 2638 return tnext 2639 } 2640 case c0.rval.IsValid(): 2641 i0 := c0.rval.Interface() 2642 v1 := genValue(c1) 2643 if n.fnext != nil { 2644 fnext := getExec(n.fnext) 2645 n.exec = func(f *frame) bltn { 2646 i1 := v1(f).Interface() 2647 if i0 == i1 { 2648 dest(f).SetBool(true) 2649 return tnext 2650 } 2651 dest(f).SetBool(false) 2652 return fnext 2653 } 2654 } else { 2655 dest := genValue(n) 2656 n.exec = func(f *frame) bltn { 2657 i1 := v1(f).Interface() 2658 dest(f).SetBool(i0 == i1) 2659 return tnext 2660 } 2661 } 2662 case c1.rval.IsValid(): 2663 i1 := c1.rval.Interface() 2664 v0 := genValue(c0) 2665 if n.fnext != nil { 2666 fnext := getExec(n.fnext) 2667 n.exec = func(f *frame) bltn { 2668 i0 := v0(f).Interface() 2669 if i0 == i1 { 2670 dest(f).SetBool(true) 2671 return tnext 2672 } 2673 dest(f).SetBool(false) 2674 return fnext 2675 } 2676 } else { 2677 dest := genValue(n) 2678 n.exec = func(f *frame) bltn { 2679 i0 := v0(f).Interface() 2680 dest(f).SetBool(i0 == i1) 2681 return tnext 2682 } 2683 } 2684 default: 2685 v0 := genValue(c0) 2686 v1 := genValue(c1) 2687 if n.fnext != nil { 2688 fnext := getExec(n.fnext) 2689 n.exec = func(f *frame) bltn { 2690 i0 := v0(f).Interface() 2691 i1 := v1(f).Interface() 2692 if i0 == i1 { 2693 dest(f).SetBool(true) 2694 return tnext 2695 } 2696 dest(f).SetBool(false) 2697 return fnext 2698 } 2699 } else { 2700 dest := genValue(n) 2701 n.exec = func(f *frame) bltn { 2702 i0 := v0(f).Interface() 2703 i1 := v1(f).Interface() 2704 dest(f).SetBool(i0 == i1) 2705 return tnext 2706 } 2707 } 2708 } 2709 return 2710 } 2711 2712 switch t0, t1 := c0.typ.TypeOf(), c1.typ.TypeOf(); { 2713 case isString(t0) || isString(t1): 2714 switch { 2715 case isInterface: 2716 v0 := genValueString(c0) 2717 v1 := genValueString(c1) 2718 n.exec = func(f *frame) bltn { 2719 _, s0 := v0(f) 2720 _, s1 := v1(f) 2721 dest(f).Set(reflect.ValueOf(s0 == s1).Convert(typ)) 2722 return tnext 2723 } 2724 case c0.rval.IsValid(): 2725 s0 := vString(c0.rval) 2726 v1 := genValueString(c1) 2727 if n.fnext != nil { 2728 fnext := getExec(n.fnext) 2729 n.exec = func(f *frame) bltn { 2730 _, s1 := v1(f) 2731 if s0 == s1 { 2732 dest(f).SetBool(true) 2733 return tnext 2734 } 2735 dest(f).SetBool(false) 2736 return fnext 2737 } 2738 } else { 2739 n.exec = func(f *frame) bltn { 2740 _, s1 := v1(f) 2741 dest(f).SetBool(s0 == s1) 2742 return tnext 2743 } 2744 } 2745 case c1.rval.IsValid(): 2746 s1 := vString(c1.rval) 2747 v0 := genValueString(c0) 2748 if n.fnext != nil { 2749 fnext := getExec(n.fnext) 2750 n.exec = func(f *frame) bltn { 2751 _, s0 := v0(f) 2752 if s0 == s1 { 2753 dest(f).SetBool(true) 2754 return tnext 2755 } 2756 dest(f).SetBool(false) 2757 return fnext 2758 } 2759 } else { 2760 n.exec = func(f *frame) bltn { 2761 _, s0 := v0(f) 2762 dest(f).SetBool(s0 == s1) 2763 return tnext 2764 } 2765 } 2766 default: 2767 v0 := genValueString(c0) 2768 v1 := genValueString(c1) 2769 if n.fnext != nil { 2770 fnext := getExec(n.fnext) 2771 n.exec = func(f *frame) bltn { 2772 _, s0 := v0(f) 2773 _, s1 := v1(f) 2774 if s0 == s1 { 2775 dest(f).SetBool(true) 2776 return tnext 2777 } 2778 dest(f).SetBool(false) 2779 return fnext 2780 } 2781 } else { 2782 n.exec = func(f *frame) bltn { 2783 _, s0 := v0(f) 2784 _, s1 := v1(f) 2785 dest(f).SetBool(s0 == s1) 2786 return tnext 2787 } 2788 } 2789 } 2790 case isFloat(t0) || isFloat(t1): 2791 switch { 2792 case isInterface: 2793 v0 := genValueFloat(c0) 2794 v1 := genValueFloat(c1) 2795 n.exec = func(f *frame) bltn { 2796 _, s0 := v0(f) 2797 _, s1 := v1(f) 2798 dest(f).Set(reflect.ValueOf(s0 == s1).Convert(typ)) 2799 return tnext 2800 } 2801 case c0.rval.IsValid(): 2802 s0 := vFloat(c0.rval) 2803 v1 := genValueFloat(c1) 2804 if n.fnext != nil { 2805 fnext := getExec(n.fnext) 2806 n.exec = func(f *frame) bltn { 2807 _, s1 := v1(f) 2808 if s0 == s1 { 2809 dest(f).SetBool(true) 2810 return tnext 2811 } 2812 dest(f).SetBool(false) 2813 return fnext 2814 } 2815 } else { 2816 n.exec = func(f *frame) bltn { 2817 _, s1 := v1(f) 2818 dest(f).SetBool(s0 == s1) 2819 return tnext 2820 } 2821 } 2822 case c1.rval.IsValid(): 2823 s1 := vFloat(c1.rval) 2824 v0 := genValueFloat(c0) 2825 if n.fnext != nil { 2826 fnext := getExec(n.fnext) 2827 n.exec = func(f *frame) bltn { 2828 _, s0 := v0(f) 2829 if s0 == s1 { 2830 dest(f).SetBool(true) 2831 return tnext 2832 } 2833 dest(f).SetBool(false) 2834 return fnext 2835 } 2836 } else { 2837 dest := genValue(n) 2838 n.exec = func(f *frame) bltn { 2839 _, s0 := v0(f) 2840 dest(f).SetBool(s0 == s1) 2841 return tnext 2842 } 2843 } 2844 default: 2845 v0 := genValueFloat(c0) 2846 v1 := genValueFloat(c1) 2847 if n.fnext != nil { 2848 fnext := getExec(n.fnext) 2849 n.exec = func(f *frame) bltn { 2850 _, s0 := v0(f) 2851 _, s1 := v1(f) 2852 if s0 == s1 { 2853 dest(f).SetBool(true) 2854 return tnext 2855 } 2856 dest(f).SetBool(false) 2857 return fnext 2858 } 2859 } else { 2860 dest := genValue(n) 2861 n.exec = func(f *frame) bltn { 2862 _, s0 := v0(f) 2863 _, s1 := v1(f) 2864 dest(f).SetBool(s0 == s1) 2865 return tnext 2866 } 2867 } 2868 } 2869 case isUint(t0) || isUint(t1): 2870 switch { 2871 case isInterface: 2872 v0 := genValueUint(c0) 2873 v1 := genValueUint(c1) 2874 n.exec = func(f *frame) bltn { 2875 _, s0 := v0(f) 2876 _, s1 := v1(f) 2877 dest(f).Set(reflect.ValueOf(s0 == s1).Convert(typ)) 2878 return tnext 2879 } 2880 case c0.rval.IsValid(): 2881 s0 := vUint(c0.rval) 2882 v1 := genValueUint(c1) 2883 if n.fnext != nil { 2884 fnext := getExec(n.fnext) 2885 n.exec = func(f *frame) bltn { 2886 _, s1 := v1(f) 2887 if s0 == s1 { 2888 dest(f).SetBool(true) 2889 return tnext 2890 } 2891 dest(f).SetBool(false) 2892 return fnext 2893 } 2894 } else { 2895 dest := genValue(n) 2896 n.exec = func(f *frame) bltn { 2897 _, s1 := v1(f) 2898 dest(f).SetBool(s0 == s1) 2899 return tnext 2900 } 2901 } 2902 case c1.rval.IsValid(): 2903 s1 := vUint(c1.rval) 2904 v0 := genValueUint(c0) 2905 if n.fnext != nil { 2906 fnext := getExec(n.fnext) 2907 n.exec = func(f *frame) bltn { 2908 _, s0 := v0(f) 2909 if s0 == s1 { 2910 dest(f).SetBool(true) 2911 return tnext 2912 } 2913 dest(f).SetBool(false) 2914 return fnext 2915 } 2916 } else { 2917 dest := genValue(n) 2918 n.exec = func(f *frame) bltn { 2919 _, s0 := v0(f) 2920 dest(f).SetBool(s0 == s1) 2921 return tnext 2922 } 2923 } 2924 default: 2925 v0 := genValueUint(c0) 2926 v1 := genValueUint(c1) 2927 if n.fnext != nil { 2928 fnext := getExec(n.fnext) 2929 n.exec = func(f *frame) bltn { 2930 _, s0 := v0(f) 2931 _, s1 := v1(f) 2932 if s0 == s1 { 2933 dest(f).SetBool(true) 2934 return tnext 2935 } 2936 dest(f).SetBool(false) 2937 return fnext 2938 } 2939 } else { 2940 dest := genValue(n) 2941 n.exec = func(f *frame) bltn { 2942 _, s0 := v0(f) 2943 _, s1 := v1(f) 2944 dest(f).SetBool(s0 == s1) 2945 return tnext 2946 } 2947 } 2948 } 2949 case isInt(t0) || isInt(t1): 2950 switch { 2951 case isInterface: 2952 v0 := genValueInt(c0) 2953 v1 := genValueInt(c1) 2954 n.exec = func(f *frame) bltn { 2955 _, s0 := v0(f) 2956 _, s1 := v1(f) 2957 dest(f).Set(reflect.ValueOf(s0 == s1).Convert(typ)) 2958 return tnext 2959 } 2960 case c0.rval.IsValid(): 2961 s0 := vInt(c0.rval) 2962 v1 := genValueInt(c1) 2963 if n.fnext != nil { 2964 fnext := getExec(n.fnext) 2965 n.exec = func(f *frame) bltn { 2966 _, s1 := v1(f) 2967 if s0 == s1 { 2968 dest(f).SetBool(true) 2969 return tnext 2970 } 2971 dest(f).SetBool(false) 2972 return fnext 2973 } 2974 } else { 2975 dest := genValue(n) 2976 n.exec = func(f *frame) bltn { 2977 _, s1 := v1(f) 2978 dest(f).SetBool(s0 == s1) 2979 return tnext 2980 } 2981 } 2982 case c1.rval.IsValid(): 2983 s1 := vInt(c1.rval) 2984 v0 := genValueInt(c0) 2985 if n.fnext != nil { 2986 fnext := getExec(n.fnext) 2987 n.exec = func(f *frame) bltn { 2988 _, s0 := v0(f) 2989 if s0 == s1 { 2990 dest(f).SetBool(true) 2991 return tnext 2992 } 2993 dest(f).SetBool(false) 2994 return fnext 2995 } 2996 } else { 2997 dest := genValue(n) 2998 n.exec = func(f *frame) bltn { 2999 _, s0 := v0(f) 3000 dest(f).SetBool(s0 == s1) 3001 return tnext 3002 } 3003 } 3004 default: 3005 v0 := genValueInt(c0) 3006 v1 := genValueInt(c1) 3007 if n.fnext != nil { 3008 fnext := getExec(n.fnext) 3009 n.exec = func(f *frame) bltn { 3010 _, s0 := v0(f) 3011 _, s1 := v1(f) 3012 if s0 == s1 { 3013 dest(f).SetBool(true) 3014 return tnext 3015 } 3016 dest(f).SetBool(false) 3017 return fnext 3018 } 3019 } else { 3020 dest := genValue(n) 3021 n.exec = func(f *frame) bltn { 3022 _, s0 := v0(f) 3023 _, s1 := v1(f) 3024 dest(f).SetBool(s0 == s1) 3025 return tnext 3026 } 3027 } 3028 } 3029 case isComplex(t0) || isComplex(t1): 3030 switch { 3031 case isInterface: 3032 v0 := genComplex(c0) 3033 v1 := genComplex(c1) 3034 n.exec = func(f *frame) bltn { 3035 s0 := v0(f) 3036 s1 := v1(f) 3037 dest(f).Set(reflect.ValueOf(s0 == s1).Convert(typ)) 3038 return tnext 3039 } 3040 case c0.rval.IsValid(): 3041 s0 := vComplex(c0.rval) 3042 v1 := genComplex(c1) 3043 if n.fnext != nil { 3044 fnext := getExec(n.fnext) 3045 n.exec = func(f *frame) bltn { 3046 s1 := v1(f) 3047 if s0 == s1 { 3048 dest(f).SetBool(true) 3049 return tnext 3050 } 3051 dest(f).SetBool(false) 3052 return fnext 3053 } 3054 } else { 3055 n.exec = func(f *frame) bltn { 3056 s1 := v1(f) 3057 dest(f).SetBool(s0 == s1) 3058 return tnext 3059 } 3060 } 3061 case c1.rval.IsValid(): 3062 s1 := vComplex(c1.rval) 3063 v0 := genComplex(c0) 3064 if n.fnext != nil { 3065 fnext := getExec(n.fnext) 3066 n.exec = func(f *frame) bltn { 3067 s0 := v0(f) 3068 if s0 == s1 { 3069 dest(f).SetBool(true) 3070 return tnext 3071 } 3072 dest(f).SetBool(false) 3073 return fnext 3074 } 3075 } else { 3076 dest := genValue(n) 3077 n.exec = func(f *frame) bltn { 3078 s0 := v0(f) 3079 dest(f).SetBool(s0 == s1) 3080 return tnext 3081 } 3082 } 3083 default: 3084 v0 := genComplex(c0) 3085 v1 := genComplex(c1) 3086 if n.fnext != nil { 3087 fnext := getExec(n.fnext) 3088 n.exec = func(f *frame) bltn { 3089 s0 := v0(f) 3090 s1 := v1(f) 3091 if s0 == s1 { 3092 dest(f).SetBool(true) 3093 return tnext 3094 } 3095 dest(f).SetBool(false) 3096 return fnext 3097 } 3098 } else { 3099 n.exec = func(f *frame) bltn { 3100 s0 := v0(f) 3101 s1 := v1(f) 3102 dest(f).SetBool(s0 == s1) 3103 return tnext 3104 } 3105 } 3106 } 3107 default: 3108 switch { 3109 case isInterface: 3110 v0 := genValue(c0) 3111 v1 := genValue(c1) 3112 n.exec = func(f *frame) bltn { 3113 i0 := v0(f).Interface() 3114 i1 := v1(f).Interface() 3115 dest(f).Set(reflect.ValueOf(i0 == i1).Convert(typ)) 3116 return tnext 3117 } 3118 case c0.rval.IsValid(): 3119 i0 := c0.rval.Interface() 3120 v1 := genValue(c1) 3121 if n.fnext != nil { 3122 fnext := getExec(n.fnext) 3123 n.exec = func(f *frame) bltn { 3124 i1 := v1(f).Interface() 3125 if i0 == i1 { 3126 dest(f).SetBool(true) 3127 return tnext 3128 } 3129 dest(f).SetBool(false) 3130 return fnext 3131 } 3132 } else { 3133 dest := genValue(n) 3134 n.exec = func(f *frame) bltn { 3135 i1 := v1(f).Interface() 3136 dest(f).SetBool(i0 == i1) 3137 return tnext 3138 } 3139 } 3140 case c1.rval.IsValid(): 3141 i1 := c1.rval.Interface() 3142 v0 := genValue(c0) 3143 if n.fnext != nil { 3144 fnext := getExec(n.fnext) 3145 n.exec = func(f *frame) bltn { 3146 i0 := v0(f).Interface() 3147 if i0 == i1 { 3148 dest(f).SetBool(true) 3149 return tnext 3150 } 3151 dest(f).SetBool(false) 3152 return fnext 3153 } 3154 } else { 3155 dest := genValue(n) 3156 n.exec = func(f *frame) bltn { 3157 i0 := v0(f).Interface() 3158 dest(f).SetBool(i0 == i1) 3159 return tnext 3160 } 3161 } 3162 default: 3163 v0 := genValue(c0) 3164 v1 := genValue(c1) 3165 if n.fnext != nil { 3166 fnext := getExec(n.fnext) 3167 n.exec = func(f *frame) bltn { 3168 i0 := v0(f).Interface() 3169 i1 := v1(f).Interface() 3170 if i0 == i1 { 3171 dest(f).SetBool(true) 3172 return tnext 3173 } 3174 dest(f).SetBool(false) 3175 return fnext 3176 } 3177 } else { 3178 dest := genValue(n) 3179 n.exec = func(f *frame) bltn { 3180 i0 := v0(f).Interface() 3181 i1 := v1(f).Interface() 3182 dest(f).SetBool(i0 == i1) 3183 return tnext 3184 } 3185 } 3186 } 3187 } 3188} 3189 3190func greater(n *node) { 3191 tnext := getExec(n.tnext) 3192 dest := genValueOutput(n, reflect.TypeOf(true)) 3193 typ := n.typ.concrete().TypeOf() 3194 isInterface := n.typ.TypeOf().Kind() == reflect.Interface 3195 c0, c1 := n.child[0], n.child[1] 3196 3197 switch t0, t1 := c0.typ.TypeOf(), c1.typ.TypeOf(); { 3198 case isString(t0) || isString(t1): 3199 switch { 3200 case isInterface: 3201 v0 := genValueString(c0) 3202 v1 := genValueString(c1) 3203 n.exec = func(f *frame) bltn { 3204 _, s0 := v0(f) 3205 _, s1 := v1(f) 3206 dest(f).Set(reflect.ValueOf(s0 > s1).Convert(typ)) 3207 return tnext 3208 } 3209 case c0.rval.IsValid(): 3210 s0 := vString(c0.rval) 3211 v1 := genValueString(c1) 3212 if n.fnext != nil { 3213 fnext := getExec(n.fnext) 3214 n.exec = func(f *frame) bltn { 3215 _, s1 := v1(f) 3216 if s0 > s1 { 3217 dest(f).SetBool(true) 3218 return tnext 3219 } 3220 dest(f).SetBool(false) 3221 return fnext 3222 } 3223 } else { 3224 n.exec = func(f *frame) bltn { 3225 _, s1 := v1(f) 3226 dest(f).SetBool(s0 > s1) 3227 return tnext 3228 } 3229 } 3230 case c1.rval.IsValid(): 3231 s1 := vString(c1.rval) 3232 v0 := genValueString(c0) 3233 if n.fnext != nil { 3234 fnext := getExec(n.fnext) 3235 n.exec = func(f *frame) bltn { 3236 _, s0 := v0(f) 3237 if s0 > s1 { 3238 dest(f).SetBool(true) 3239 return tnext 3240 } 3241 dest(f).SetBool(false) 3242 return fnext 3243 } 3244 } else { 3245 n.exec = func(f *frame) bltn { 3246 _, s0 := v0(f) 3247 dest(f).SetBool(s0 > s1) 3248 return tnext 3249 } 3250 } 3251 default: 3252 v0 := genValueString(c0) 3253 v1 := genValueString(c1) 3254 if n.fnext != nil { 3255 fnext := getExec(n.fnext) 3256 n.exec = func(f *frame) bltn { 3257 _, s0 := v0(f) 3258 _, s1 := v1(f) 3259 if s0 > s1 { 3260 dest(f).SetBool(true) 3261 return tnext 3262 } 3263 dest(f).SetBool(false) 3264 return fnext 3265 } 3266 } else { 3267 n.exec = func(f *frame) bltn { 3268 _, s0 := v0(f) 3269 _, s1 := v1(f) 3270 dest(f).SetBool(s0 > s1) 3271 return tnext 3272 } 3273 } 3274 } 3275 case isFloat(t0) || isFloat(t1): 3276 switch { 3277 case isInterface: 3278 v0 := genValueFloat(c0) 3279 v1 := genValueFloat(c1) 3280 n.exec = func(f *frame) bltn { 3281 _, s0 := v0(f) 3282 _, s1 := v1(f) 3283 dest(f).Set(reflect.ValueOf(s0 > s1).Convert(typ)) 3284 return tnext 3285 } 3286 case c0.rval.IsValid(): 3287 s0 := vFloat(c0.rval) 3288 v1 := genValueFloat(c1) 3289 if n.fnext != nil { 3290 fnext := getExec(n.fnext) 3291 n.exec = func(f *frame) bltn { 3292 _, s1 := v1(f) 3293 if s0 > s1 { 3294 dest(f).SetBool(true) 3295 return tnext 3296 } 3297 dest(f).SetBool(false) 3298 return fnext 3299 } 3300 } else { 3301 n.exec = func(f *frame) bltn { 3302 _, s1 := v1(f) 3303 dest(f).SetBool(s0 > s1) 3304 return tnext 3305 } 3306 } 3307 case c1.rval.IsValid(): 3308 s1 := vFloat(c1.rval) 3309 v0 := genValueFloat(c0) 3310 if n.fnext != nil { 3311 fnext := getExec(n.fnext) 3312 n.exec = func(f *frame) bltn { 3313 _, s0 := v0(f) 3314 if s0 > s1 { 3315 dest(f).SetBool(true) 3316 return tnext 3317 } 3318 dest(f).SetBool(false) 3319 return fnext 3320 } 3321 } else { 3322 dest := genValue(n) 3323 n.exec = func(f *frame) bltn { 3324 _, s0 := v0(f) 3325 dest(f).SetBool(s0 > s1) 3326 return tnext 3327 } 3328 } 3329 default: 3330 v0 := genValueFloat(c0) 3331 v1 := genValueFloat(c1) 3332 if n.fnext != nil { 3333 fnext := getExec(n.fnext) 3334 n.exec = func(f *frame) bltn { 3335 _, s0 := v0(f) 3336 _, s1 := v1(f) 3337 if s0 > s1 { 3338 dest(f).SetBool(true) 3339 return tnext 3340 } 3341 dest(f).SetBool(false) 3342 return fnext 3343 } 3344 } else { 3345 dest := genValue(n) 3346 n.exec = func(f *frame) bltn { 3347 _, s0 := v0(f) 3348 _, s1 := v1(f) 3349 dest(f).SetBool(s0 > s1) 3350 return tnext 3351 } 3352 } 3353 } 3354 case isUint(t0) || isUint(t1): 3355 switch { 3356 case isInterface: 3357 v0 := genValueUint(c0) 3358 v1 := genValueUint(c1) 3359 n.exec = func(f *frame) bltn { 3360 _, s0 := v0(f) 3361 _, s1 := v1(f) 3362 dest(f).Set(reflect.ValueOf(s0 > s1).Convert(typ)) 3363 return tnext 3364 } 3365 case c0.rval.IsValid(): 3366 s0 := vUint(c0.rval) 3367 v1 := genValueUint(c1) 3368 if n.fnext != nil { 3369 fnext := getExec(n.fnext) 3370 n.exec = func(f *frame) bltn { 3371 _, s1 := v1(f) 3372 if s0 > s1 { 3373 dest(f).SetBool(true) 3374 return tnext 3375 } 3376 dest(f).SetBool(false) 3377 return fnext 3378 } 3379 } else { 3380 dest := genValue(n) 3381 n.exec = func(f *frame) bltn { 3382 _, s1 := v1(f) 3383 dest(f).SetBool(s0 > s1) 3384 return tnext 3385 } 3386 } 3387 case c1.rval.IsValid(): 3388 s1 := vUint(c1.rval) 3389 v0 := genValueUint(c0) 3390 if n.fnext != nil { 3391 fnext := getExec(n.fnext) 3392 n.exec = func(f *frame) bltn { 3393 _, s0 := v0(f) 3394 if s0 > s1 { 3395 dest(f).SetBool(true) 3396 return tnext 3397 } 3398 dest(f).SetBool(false) 3399 return fnext 3400 } 3401 } else { 3402 dest := genValue(n) 3403 n.exec = func(f *frame) bltn { 3404 _, s0 := v0(f) 3405 dest(f).SetBool(s0 > s1) 3406 return tnext 3407 } 3408 } 3409 default: 3410 v0 := genValueUint(c0) 3411 v1 := genValueUint(c1) 3412 if n.fnext != nil { 3413 fnext := getExec(n.fnext) 3414 n.exec = func(f *frame) bltn { 3415 _, s0 := v0(f) 3416 _, s1 := v1(f) 3417 if s0 > s1 { 3418 dest(f).SetBool(true) 3419 return tnext 3420 } 3421 dest(f).SetBool(false) 3422 return fnext 3423 } 3424 } else { 3425 dest := genValue(n) 3426 n.exec = func(f *frame) bltn { 3427 _, s0 := v0(f) 3428 _, s1 := v1(f) 3429 dest(f).SetBool(s0 > s1) 3430 return tnext 3431 } 3432 } 3433 } 3434 case isInt(t0) || isInt(t1): 3435 switch { 3436 case isInterface: 3437 v0 := genValueInt(c0) 3438 v1 := genValueInt(c1) 3439 n.exec = func(f *frame) bltn { 3440 _, s0 := v0(f) 3441 _, s1 := v1(f) 3442 dest(f).Set(reflect.ValueOf(s0 > s1).Convert(typ)) 3443 return tnext 3444 } 3445 case c0.rval.IsValid(): 3446 s0 := vInt(c0.rval) 3447 v1 := genValueInt(c1) 3448 if n.fnext != nil { 3449 fnext := getExec(n.fnext) 3450 n.exec = func(f *frame) bltn { 3451 _, s1 := v1(f) 3452 if s0 > s1 { 3453 dest(f).SetBool(true) 3454 return tnext 3455 } 3456 dest(f).SetBool(false) 3457 return fnext 3458 } 3459 } else { 3460 dest := genValue(n) 3461 n.exec = func(f *frame) bltn { 3462 _, s1 := v1(f) 3463 dest(f).SetBool(s0 > s1) 3464 return tnext 3465 } 3466 } 3467 case c1.rval.IsValid(): 3468 s1 := vInt(c1.rval) 3469 v0 := genValueInt(c0) 3470 if n.fnext != nil { 3471 fnext := getExec(n.fnext) 3472 n.exec = func(f *frame) bltn { 3473 _, s0 := v0(f) 3474 if s0 > s1 { 3475 dest(f).SetBool(true) 3476 return tnext 3477 } 3478 dest(f).SetBool(false) 3479 return fnext 3480 } 3481 } else { 3482 dest := genValue(n) 3483 n.exec = func(f *frame) bltn { 3484 _, s0 := v0(f) 3485 dest(f).SetBool(s0 > s1) 3486 return tnext 3487 } 3488 } 3489 default: 3490 v0 := genValueInt(c0) 3491 v1 := genValueInt(c1) 3492 if n.fnext != nil { 3493 fnext := getExec(n.fnext) 3494 n.exec = func(f *frame) bltn { 3495 _, s0 := v0(f) 3496 _, s1 := v1(f) 3497 if s0 > s1 { 3498 dest(f).SetBool(true) 3499 return tnext 3500 } 3501 dest(f).SetBool(false) 3502 return fnext 3503 } 3504 } else { 3505 dest := genValue(n) 3506 n.exec = func(f *frame) bltn { 3507 _, s0 := v0(f) 3508 _, s1 := v1(f) 3509 dest(f).SetBool(s0 > s1) 3510 return tnext 3511 } 3512 } 3513 } 3514 } 3515} 3516 3517func greaterEqual(n *node) { 3518 tnext := getExec(n.tnext) 3519 dest := genValueOutput(n, reflect.TypeOf(true)) 3520 typ := n.typ.concrete().TypeOf() 3521 isInterface := n.typ.TypeOf().Kind() == reflect.Interface 3522 c0, c1 := n.child[0], n.child[1] 3523 3524 switch t0, t1 := c0.typ.TypeOf(), c1.typ.TypeOf(); { 3525 case isString(t0) || isString(t1): 3526 switch { 3527 case isInterface: 3528 v0 := genValueString(c0) 3529 v1 := genValueString(c1) 3530 n.exec = func(f *frame) bltn { 3531 _, s0 := v0(f) 3532 _, s1 := v1(f) 3533 dest(f).Set(reflect.ValueOf(s0 >= s1).Convert(typ)) 3534 return tnext 3535 } 3536 case c0.rval.IsValid(): 3537 s0 := vString(c0.rval) 3538 v1 := genValueString(c1) 3539 if n.fnext != nil { 3540 fnext := getExec(n.fnext) 3541 n.exec = func(f *frame) bltn { 3542 _, s1 := v1(f) 3543 if s0 >= s1 { 3544 dest(f).SetBool(true) 3545 return tnext 3546 } 3547 dest(f).SetBool(false) 3548 return fnext 3549 } 3550 } else { 3551 n.exec = func(f *frame) bltn { 3552 _, s1 := v1(f) 3553 dest(f).SetBool(s0 >= s1) 3554 return tnext 3555 } 3556 } 3557 case c1.rval.IsValid(): 3558 s1 := vString(c1.rval) 3559 v0 := genValueString(c0) 3560 if n.fnext != nil { 3561 fnext := getExec(n.fnext) 3562 n.exec = func(f *frame) bltn { 3563 _, s0 := v0(f) 3564 if s0 >= s1 { 3565 dest(f).SetBool(true) 3566 return tnext 3567 } 3568 dest(f).SetBool(false) 3569 return fnext 3570 } 3571 } else { 3572 n.exec = func(f *frame) bltn { 3573 _, s0 := v0(f) 3574 dest(f).SetBool(s0 >= s1) 3575 return tnext 3576 } 3577 } 3578 default: 3579 v0 := genValueString(c0) 3580 v1 := genValueString(c1) 3581 if n.fnext != nil { 3582 fnext := getExec(n.fnext) 3583 n.exec = func(f *frame) bltn { 3584 _, s0 := v0(f) 3585 _, s1 := v1(f) 3586 if s0 >= s1 { 3587 dest(f).SetBool(true) 3588 return tnext 3589 } 3590 dest(f).SetBool(false) 3591 return fnext 3592 } 3593 } else { 3594 n.exec = func(f *frame) bltn { 3595 _, s0 := v0(f) 3596 _, s1 := v1(f) 3597 dest(f).SetBool(s0 >= s1) 3598 return tnext 3599 } 3600 } 3601 } 3602 case isFloat(t0) || isFloat(t1): 3603 switch { 3604 case isInterface: 3605 v0 := genValueFloat(c0) 3606 v1 := genValueFloat(c1) 3607 n.exec = func(f *frame) bltn { 3608 _, s0 := v0(f) 3609 _, s1 := v1(f) 3610 dest(f).Set(reflect.ValueOf(s0 >= s1).Convert(typ)) 3611 return tnext 3612 } 3613 case c0.rval.IsValid(): 3614 s0 := vFloat(c0.rval) 3615 v1 := genValueFloat(c1) 3616 if n.fnext != nil { 3617 fnext := getExec(n.fnext) 3618 n.exec = func(f *frame) bltn { 3619 _, s1 := v1(f) 3620 if s0 >= s1 { 3621 dest(f).SetBool(true) 3622 return tnext 3623 } 3624 dest(f).SetBool(false) 3625 return fnext 3626 } 3627 } else { 3628 n.exec = func(f *frame) bltn { 3629 _, s1 := v1(f) 3630 dest(f).SetBool(s0 >= s1) 3631 return tnext 3632 } 3633 } 3634 case c1.rval.IsValid(): 3635 s1 := vFloat(c1.rval) 3636 v0 := genValueFloat(c0) 3637 if n.fnext != nil { 3638 fnext := getExec(n.fnext) 3639 n.exec = func(f *frame) bltn { 3640 _, s0 := v0(f) 3641 if s0 >= s1 { 3642 dest(f).SetBool(true) 3643 return tnext 3644 } 3645 dest(f).SetBool(false) 3646 return fnext 3647 } 3648 } else { 3649 dest := genValue(n) 3650 n.exec = func(f *frame) bltn { 3651 _, s0 := v0(f) 3652 dest(f).SetBool(s0 >= s1) 3653 return tnext 3654 } 3655 } 3656 default: 3657 v0 := genValueFloat(c0) 3658 v1 := genValueFloat(c1) 3659 if n.fnext != nil { 3660 fnext := getExec(n.fnext) 3661 n.exec = func(f *frame) bltn { 3662 _, s0 := v0(f) 3663 _, s1 := v1(f) 3664 if s0 >= s1 { 3665 dest(f).SetBool(true) 3666 return tnext 3667 } 3668 dest(f).SetBool(false) 3669 return fnext 3670 } 3671 } else { 3672 dest := genValue(n) 3673 n.exec = func(f *frame) bltn { 3674 _, s0 := v0(f) 3675 _, s1 := v1(f) 3676 dest(f).SetBool(s0 >= s1) 3677 return tnext 3678 } 3679 } 3680 } 3681 case isUint(t0) || isUint(t1): 3682 switch { 3683 case isInterface: 3684 v0 := genValueUint(c0) 3685 v1 := genValueUint(c1) 3686 n.exec = func(f *frame) bltn { 3687 _, s0 := v0(f) 3688 _, s1 := v1(f) 3689 dest(f).Set(reflect.ValueOf(s0 >= s1).Convert(typ)) 3690 return tnext 3691 } 3692 case c0.rval.IsValid(): 3693 s0 := vUint(c0.rval) 3694 v1 := genValueUint(c1) 3695 if n.fnext != nil { 3696 fnext := getExec(n.fnext) 3697 n.exec = func(f *frame) bltn { 3698 _, s1 := v1(f) 3699 if s0 >= s1 { 3700 dest(f).SetBool(true) 3701 return tnext 3702 } 3703 dest(f).SetBool(false) 3704 return fnext 3705 } 3706 } else { 3707 dest := genValue(n) 3708 n.exec = func(f *frame) bltn { 3709 _, s1 := v1(f) 3710 dest(f).SetBool(s0 >= s1) 3711 return tnext 3712 } 3713 } 3714 case c1.rval.IsValid(): 3715 s1 := vUint(c1.rval) 3716 v0 := genValueUint(c0) 3717 if n.fnext != nil { 3718 fnext := getExec(n.fnext) 3719 n.exec = func(f *frame) bltn { 3720 _, s0 := v0(f) 3721 if s0 >= s1 { 3722 dest(f).SetBool(true) 3723 return tnext 3724 } 3725 dest(f).SetBool(false) 3726 return fnext 3727 } 3728 } else { 3729 dest := genValue(n) 3730 n.exec = func(f *frame) bltn { 3731 _, s0 := v0(f) 3732 dest(f).SetBool(s0 >= s1) 3733 return tnext 3734 } 3735 } 3736 default: 3737 v0 := genValueUint(c0) 3738 v1 := genValueUint(c1) 3739 if n.fnext != nil { 3740 fnext := getExec(n.fnext) 3741 n.exec = func(f *frame) bltn { 3742 _, s0 := v0(f) 3743 _, s1 := v1(f) 3744 if s0 >= s1 { 3745 dest(f).SetBool(true) 3746 return tnext 3747 } 3748 dest(f).SetBool(false) 3749 return fnext 3750 } 3751 } else { 3752 dest := genValue(n) 3753 n.exec = func(f *frame) bltn { 3754 _, s0 := v0(f) 3755 _, s1 := v1(f) 3756 dest(f).SetBool(s0 >= s1) 3757 return tnext 3758 } 3759 } 3760 } 3761 case isInt(t0) || isInt(t1): 3762 switch { 3763 case isInterface: 3764 v0 := genValueInt(c0) 3765 v1 := genValueInt(c1) 3766 n.exec = func(f *frame) bltn { 3767 _, s0 := v0(f) 3768 _, s1 := v1(f) 3769 dest(f).Set(reflect.ValueOf(s0 >= s1).Convert(typ)) 3770 return tnext 3771 } 3772 case c0.rval.IsValid(): 3773 s0 := vInt(c0.rval) 3774 v1 := genValueInt(c1) 3775 if n.fnext != nil { 3776 fnext := getExec(n.fnext) 3777 n.exec = func(f *frame) bltn { 3778 _, s1 := v1(f) 3779 if s0 >= s1 { 3780 dest(f).SetBool(true) 3781 return tnext 3782 } 3783 dest(f).SetBool(false) 3784 return fnext 3785 } 3786 } else { 3787 dest := genValue(n) 3788 n.exec = func(f *frame) bltn { 3789 _, s1 := v1(f) 3790 dest(f).SetBool(s0 >= s1) 3791 return tnext 3792 } 3793 } 3794 case c1.rval.IsValid(): 3795 s1 := vInt(c1.rval) 3796 v0 := genValueInt(c0) 3797 if n.fnext != nil { 3798 fnext := getExec(n.fnext) 3799 n.exec = func(f *frame) bltn { 3800 _, s0 := v0(f) 3801 if s0 >= s1 { 3802 dest(f).SetBool(true) 3803 return tnext 3804 } 3805 dest(f).SetBool(false) 3806 return fnext 3807 } 3808 } else { 3809 dest := genValue(n) 3810 n.exec = func(f *frame) bltn { 3811 _, s0 := v0(f) 3812 dest(f).SetBool(s0 >= s1) 3813 return tnext 3814 } 3815 } 3816 default: 3817 v0 := genValueInt(c0) 3818 v1 := genValueInt(c1) 3819 if n.fnext != nil { 3820 fnext := getExec(n.fnext) 3821 n.exec = func(f *frame) bltn { 3822 _, s0 := v0(f) 3823 _, s1 := v1(f) 3824 if s0 >= s1 { 3825 dest(f).SetBool(true) 3826 return tnext 3827 } 3828 dest(f).SetBool(false) 3829 return fnext 3830 } 3831 } else { 3832 dest := genValue(n) 3833 n.exec = func(f *frame) bltn { 3834 _, s0 := v0(f) 3835 _, s1 := v1(f) 3836 dest(f).SetBool(s0 >= s1) 3837 return tnext 3838 } 3839 } 3840 } 3841 } 3842} 3843 3844func lower(n *node) { 3845 tnext := getExec(n.tnext) 3846 dest := genValueOutput(n, reflect.TypeOf(true)) 3847 typ := n.typ.concrete().TypeOf() 3848 isInterface := n.typ.TypeOf().Kind() == reflect.Interface 3849 c0, c1 := n.child[0], n.child[1] 3850 3851 switch t0, t1 := c0.typ.TypeOf(), c1.typ.TypeOf(); { 3852 case isString(t0) || isString(t1): 3853 switch { 3854 case isInterface: 3855 v0 := genValueString(c0) 3856 v1 := genValueString(c1) 3857 n.exec = func(f *frame) bltn { 3858 _, s0 := v0(f) 3859 _, s1 := v1(f) 3860 dest(f).Set(reflect.ValueOf(s0 < s1).Convert(typ)) 3861 return tnext 3862 } 3863 case c0.rval.IsValid(): 3864 s0 := vString(c0.rval) 3865 v1 := genValueString(c1) 3866 if n.fnext != nil { 3867 fnext := getExec(n.fnext) 3868 n.exec = func(f *frame) bltn { 3869 _, s1 := v1(f) 3870 if s0 < s1 { 3871 dest(f).SetBool(true) 3872 return tnext 3873 } 3874 dest(f).SetBool(false) 3875 return fnext 3876 } 3877 } else { 3878 n.exec = func(f *frame) bltn { 3879 _, s1 := v1(f) 3880 dest(f).SetBool(s0 < s1) 3881 return tnext 3882 } 3883 } 3884 case c1.rval.IsValid(): 3885 s1 := vString(c1.rval) 3886 v0 := genValueString(c0) 3887 if n.fnext != nil { 3888 fnext := getExec(n.fnext) 3889 n.exec = func(f *frame) bltn { 3890 _, s0 := v0(f) 3891 if s0 < s1 { 3892 dest(f).SetBool(true) 3893 return tnext 3894 } 3895 dest(f).SetBool(false) 3896 return fnext 3897 } 3898 } else { 3899 n.exec = func(f *frame) bltn { 3900 _, s0 := v0(f) 3901 dest(f).SetBool(s0 < s1) 3902 return tnext 3903 } 3904 } 3905 default: 3906 v0 := genValueString(c0) 3907 v1 := genValueString(c1) 3908 if n.fnext != nil { 3909 fnext := getExec(n.fnext) 3910 n.exec = func(f *frame) bltn { 3911 _, s0 := v0(f) 3912 _, s1 := v1(f) 3913 if s0 < s1 { 3914 dest(f).SetBool(true) 3915 return tnext 3916 } 3917 dest(f).SetBool(false) 3918 return fnext 3919 } 3920 } else { 3921 n.exec = func(f *frame) bltn { 3922 _, s0 := v0(f) 3923 _, s1 := v1(f) 3924 dest(f).SetBool(s0 < s1) 3925 return tnext 3926 } 3927 } 3928 } 3929 case isFloat(t0) || isFloat(t1): 3930 switch { 3931 case isInterface: 3932 v0 := genValueFloat(c0) 3933 v1 := genValueFloat(c1) 3934 n.exec = func(f *frame) bltn { 3935 _, s0 := v0(f) 3936 _, s1 := v1(f) 3937 dest(f).Set(reflect.ValueOf(s0 < s1).Convert(typ)) 3938 return tnext 3939 } 3940 case c0.rval.IsValid(): 3941 s0 := vFloat(c0.rval) 3942 v1 := genValueFloat(c1) 3943 if n.fnext != nil { 3944 fnext := getExec(n.fnext) 3945 n.exec = func(f *frame) bltn { 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 _, s1 := v1(f) 3957 dest(f).SetBool(s0 < s1) 3958 return tnext 3959 } 3960 } 3961 case c1.rval.IsValid(): 3962 s1 := vFloat(c1.rval) 3963 v0 := genValueFloat(c0) 3964 if n.fnext != nil { 3965 fnext := getExec(n.fnext) 3966 n.exec = func(f *frame) bltn { 3967 _, s0 := v0(f) 3968 if s0 < s1 { 3969 dest(f).SetBool(true) 3970 return tnext 3971 } 3972 dest(f).SetBool(false) 3973 return fnext 3974 } 3975 } else { 3976 dest := genValue(n) 3977 n.exec = func(f *frame) bltn { 3978 _, s0 := v0(f) 3979 dest(f).SetBool(s0 < s1) 3980 return tnext 3981 } 3982 } 3983 default: 3984 v0 := genValueFloat(c0) 3985 v1 := genValueFloat(c1) 3986 if n.fnext != nil { 3987 fnext := getExec(n.fnext) 3988 n.exec = func(f *frame) bltn { 3989 _, s0 := v0(f) 3990 _, s1 := v1(f) 3991 if s0 < s1 { 3992 dest(f).SetBool(true) 3993 return tnext 3994 } 3995 dest(f).SetBool(false) 3996 return fnext 3997 } 3998 } else { 3999 dest := genValue(n) 4000 n.exec = func(f *frame) bltn { 4001 _, s0 := v0(f) 4002 _, s1 := v1(f) 4003 dest(f).SetBool(s0 < s1) 4004 return tnext 4005 } 4006 } 4007 } 4008 case isUint(t0) || isUint(t1): 4009 switch { 4010 case isInterface: 4011 v0 := genValueUint(c0) 4012 v1 := genValueUint(c1) 4013 n.exec = func(f *frame) bltn { 4014 _, s0 := v0(f) 4015 _, s1 := v1(f) 4016 dest(f).Set(reflect.ValueOf(s0 < s1).Convert(typ)) 4017 return tnext 4018 } 4019 case c0.rval.IsValid(): 4020 s0 := vUint(c0.rval) 4021 v1 := genValueUint(c1) 4022 if n.fnext != nil { 4023 fnext := getExec(n.fnext) 4024 n.exec = func(f *frame) bltn { 4025 _, s1 := v1(f) 4026 if s0 < s1 { 4027 dest(f).SetBool(true) 4028 return tnext 4029 } 4030 dest(f).SetBool(false) 4031 return fnext 4032 } 4033 } else { 4034 dest := genValue(n) 4035 n.exec = func(f *frame) bltn { 4036 _, s1 := v1(f) 4037 dest(f).SetBool(s0 < s1) 4038 return tnext 4039 } 4040 } 4041 case c1.rval.IsValid(): 4042 s1 := vUint(c1.rval) 4043 v0 := genValueUint(c0) 4044 if n.fnext != nil { 4045 fnext := getExec(n.fnext) 4046 n.exec = func(f *frame) bltn { 4047 _, s0 := v0(f) 4048 if s0 < s1 { 4049 dest(f).SetBool(true) 4050 return tnext 4051 } 4052 dest(f).SetBool(false) 4053 return fnext 4054 } 4055 } else { 4056 dest := genValue(n) 4057 n.exec = func(f *frame) bltn { 4058 _, s0 := v0(f) 4059 dest(f).SetBool(s0 < s1) 4060 return tnext 4061 } 4062 } 4063 default: 4064 v0 := genValueUint(c0) 4065 v1 := genValueUint(c1) 4066 if n.fnext != nil { 4067 fnext := getExec(n.fnext) 4068 n.exec = func(f *frame) bltn { 4069 _, s0 := v0(f) 4070 _, s1 := v1(f) 4071 if s0 < s1 { 4072 dest(f).SetBool(true) 4073 return tnext 4074 } 4075 dest(f).SetBool(false) 4076 return fnext 4077 } 4078 } else { 4079 dest := genValue(n) 4080 n.exec = func(f *frame) bltn { 4081 _, s0 := v0(f) 4082 _, s1 := v1(f) 4083 dest(f).SetBool(s0 < s1) 4084 return tnext 4085 } 4086 } 4087 } 4088 case isInt(t0) || isInt(t1): 4089 switch { 4090 case isInterface: 4091 v0 := genValueInt(c0) 4092 v1 := genValueInt(c1) 4093 n.exec = func(f *frame) bltn { 4094 _, s0 := v0(f) 4095 _, s1 := v1(f) 4096 dest(f).Set(reflect.ValueOf(s0 < s1).Convert(typ)) 4097 return tnext 4098 } 4099 case c0.rval.IsValid(): 4100 s0 := vInt(c0.rval) 4101 v1 := genValueInt(c1) 4102 if n.fnext != nil { 4103 fnext := getExec(n.fnext) 4104 n.exec = func(f *frame) bltn { 4105 _, s1 := v1(f) 4106 if s0 < s1 { 4107 dest(f).SetBool(true) 4108 return tnext 4109 } 4110 dest(f).SetBool(false) 4111 return fnext 4112 } 4113 } else { 4114 dest := genValue(n) 4115 n.exec = func(f *frame) bltn { 4116 _, s1 := v1(f) 4117 dest(f).SetBool(s0 < s1) 4118 return tnext 4119 } 4120 } 4121 case c1.rval.IsValid(): 4122 s1 := vInt(c1.rval) 4123 v0 := genValueInt(c0) 4124 if n.fnext != nil { 4125 fnext := getExec(n.fnext) 4126 n.exec = func(f *frame) bltn { 4127 _, s0 := v0(f) 4128 if s0 < s1 { 4129 dest(f).SetBool(true) 4130 return tnext 4131 } 4132 dest(f).SetBool(false) 4133 return fnext 4134 } 4135 } else { 4136 dest := genValue(n) 4137 n.exec = func(f *frame) bltn { 4138 _, s0 := v0(f) 4139 dest(f).SetBool(s0 < s1) 4140 return tnext 4141 } 4142 } 4143 default: 4144 v0 := genValueInt(c0) 4145 v1 := genValueInt(c1) 4146 if n.fnext != nil { 4147 fnext := getExec(n.fnext) 4148 n.exec = func(f *frame) bltn { 4149 _, s0 := v0(f) 4150 _, s1 := v1(f) 4151 if s0 < s1 { 4152 dest(f).SetBool(true) 4153 return tnext 4154 } 4155 dest(f).SetBool(false) 4156 return fnext 4157 } 4158 } else { 4159 dest := genValue(n) 4160 n.exec = func(f *frame) bltn { 4161 _, s0 := v0(f) 4162 _, s1 := v1(f) 4163 dest(f).SetBool(s0 < s1) 4164 return tnext 4165 } 4166 } 4167 } 4168 } 4169} 4170 4171func lowerEqual(n *node) { 4172 tnext := getExec(n.tnext) 4173 dest := genValueOutput(n, reflect.TypeOf(true)) 4174 typ := n.typ.concrete().TypeOf() 4175 isInterface := n.typ.TypeOf().Kind() == reflect.Interface 4176 c0, c1 := n.child[0], n.child[1] 4177 4178 switch t0, t1 := c0.typ.TypeOf(), c1.typ.TypeOf(); { 4179 case isString(t0) || isString(t1): 4180 switch { 4181 case isInterface: 4182 v0 := genValueString(c0) 4183 v1 := genValueString(c1) 4184 n.exec = func(f *frame) bltn { 4185 _, s0 := v0(f) 4186 _, s1 := v1(f) 4187 dest(f).Set(reflect.ValueOf(s0 <= s1).Convert(typ)) 4188 return tnext 4189 } 4190 case c0.rval.IsValid(): 4191 s0 := vString(c0.rval) 4192 v1 := genValueString(c1) 4193 if n.fnext != nil { 4194 fnext := getExec(n.fnext) 4195 n.exec = func(f *frame) bltn { 4196 _, s1 := v1(f) 4197 if s0 <= s1 { 4198 dest(f).SetBool(true) 4199 return tnext 4200 } 4201 dest(f).SetBool(false) 4202 return fnext 4203 } 4204 } else { 4205 n.exec = func(f *frame) bltn { 4206 _, s1 := v1(f) 4207 dest(f).SetBool(s0 <= s1) 4208 return tnext 4209 } 4210 } 4211 case c1.rval.IsValid(): 4212 s1 := vString(c1.rval) 4213 v0 := genValueString(c0) 4214 if n.fnext != nil { 4215 fnext := getExec(n.fnext) 4216 n.exec = func(f *frame) bltn { 4217 _, s0 := v0(f) 4218 if s0 <= s1 { 4219 dest(f).SetBool(true) 4220 return tnext 4221 } 4222 dest(f).SetBool(false) 4223 return fnext 4224 } 4225 } else { 4226 n.exec = func(f *frame) bltn { 4227 _, s0 := v0(f) 4228 dest(f).SetBool(s0 <= s1) 4229 return tnext 4230 } 4231 } 4232 default: 4233 v0 := genValueString(c0) 4234 v1 := genValueString(c1) 4235 if n.fnext != nil { 4236 fnext := getExec(n.fnext) 4237 n.exec = func(f *frame) bltn { 4238 _, s0 := v0(f) 4239 _, s1 := v1(f) 4240 if s0 <= s1 { 4241 dest(f).SetBool(true) 4242 return tnext 4243 } 4244 dest(f).SetBool(false) 4245 return fnext 4246 } 4247 } else { 4248 n.exec = func(f *frame) bltn { 4249 _, s0 := v0(f) 4250 _, s1 := v1(f) 4251 dest(f).SetBool(s0 <= s1) 4252 return tnext 4253 } 4254 } 4255 } 4256 case isFloat(t0) || isFloat(t1): 4257 switch { 4258 case isInterface: 4259 v0 := genValueFloat(c0) 4260 v1 := genValueFloat(c1) 4261 n.exec = func(f *frame) bltn { 4262 _, s0 := v0(f) 4263 _, s1 := v1(f) 4264 dest(f).Set(reflect.ValueOf(s0 <= s1).Convert(typ)) 4265 return tnext 4266 } 4267 case c0.rval.IsValid(): 4268 s0 := vFloat(c0.rval) 4269 v1 := genValueFloat(c1) 4270 if n.fnext != nil { 4271 fnext := getExec(n.fnext) 4272 n.exec = func(f *frame) bltn { 4273 _, s1 := v1(f) 4274 if s0 <= s1 { 4275 dest(f).SetBool(true) 4276 return tnext 4277 } 4278 dest(f).SetBool(false) 4279 return fnext 4280 } 4281 } else { 4282 n.exec = func(f *frame) bltn { 4283 _, s1 := v1(f) 4284 dest(f).SetBool(s0 <= s1) 4285 return tnext 4286 } 4287 } 4288 case c1.rval.IsValid(): 4289 s1 := vFloat(c1.rval) 4290 v0 := genValueFloat(c0) 4291 if n.fnext != nil { 4292 fnext := getExec(n.fnext) 4293 n.exec = func(f *frame) bltn { 4294 _, s0 := v0(f) 4295 if s0 <= s1 { 4296 dest(f).SetBool(true) 4297 return tnext 4298 } 4299 dest(f).SetBool(false) 4300 return fnext 4301 } 4302 } else { 4303 dest := genValue(n) 4304 n.exec = func(f *frame) bltn { 4305 _, s0 := v0(f) 4306 dest(f).SetBool(s0 <= s1) 4307 return tnext 4308 } 4309 } 4310 default: 4311 v0 := genValueFloat(c0) 4312 v1 := genValueFloat(c1) 4313 if n.fnext != nil { 4314 fnext := getExec(n.fnext) 4315 n.exec = func(f *frame) bltn { 4316 _, s0 := v0(f) 4317 _, s1 := v1(f) 4318 if s0 <= s1 { 4319 dest(f).SetBool(true) 4320 return tnext 4321 } 4322 dest(f).SetBool(false) 4323 return fnext 4324 } 4325 } else { 4326 dest := genValue(n) 4327 n.exec = func(f *frame) bltn { 4328 _, s0 := v0(f) 4329 _, s1 := v1(f) 4330 dest(f).SetBool(s0 <= s1) 4331 return tnext 4332 } 4333 } 4334 } 4335 case isUint(t0) || isUint(t1): 4336 switch { 4337 case isInterface: 4338 v0 := genValueUint(c0) 4339 v1 := genValueUint(c1) 4340 n.exec = func(f *frame) bltn { 4341 _, s0 := v0(f) 4342 _, s1 := v1(f) 4343 dest(f).Set(reflect.ValueOf(s0 <= s1).Convert(typ)) 4344 return tnext 4345 } 4346 case c0.rval.IsValid(): 4347 s0 := vUint(c0.rval) 4348 v1 := genValueUint(c1) 4349 if n.fnext != nil { 4350 fnext := getExec(n.fnext) 4351 n.exec = func(f *frame) bltn { 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 _, s1 := v1(f) 4364 dest(f).SetBool(s0 <= s1) 4365 return tnext 4366 } 4367 } 4368 case c1.rval.IsValid(): 4369 s1 := vUint(c1.rval) 4370 v0 := genValueUint(c0) 4371 if n.fnext != nil { 4372 fnext := getExec(n.fnext) 4373 n.exec = func(f *frame) bltn { 4374 _, s0 := v0(f) 4375 if s0 <= s1 { 4376 dest(f).SetBool(true) 4377 return tnext 4378 } 4379 dest(f).SetBool(false) 4380 return fnext 4381 } 4382 } else { 4383 dest := genValue(n) 4384 n.exec = func(f *frame) bltn { 4385 _, s0 := v0(f) 4386 dest(f).SetBool(s0 <= s1) 4387 return tnext 4388 } 4389 } 4390 default: 4391 v0 := genValueUint(c0) 4392 v1 := genValueUint(c1) 4393 if n.fnext != nil { 4394 fnext := getExec(n.fnext) 4395 n.exec = func(f *frame) bltn { 4396 _, s0 := v0(f) 4397 _, s1 := v1(f) 4398 if s0 <= s1 { 4399 dest(f).SetBool(true) 4400 return tnext 4401 } 4402 dest(f).SetBool(false) 4403 return fnext 4404 } 4405 } else { 4406 dest := genValue(n) 4407 n.exec = func(f *frame) bltn { 4408 _, s0 := v0(f) 4409 _, s1 := v1(f) 4410 dest(f).SetBool(s0 <= s1) 4411 return tnext 4412 } 4413 } 4414 } 4415 case isInt(t0) || isInt(t1): 4416 switch { 4417 case isInterface: 4418 v0 := genValueInt(c0) 4419 v1 := genValueInt(c1) 4420 n.exec = func(f *frame) bltn { 4421 _, s0 := v0(f) 4422 _, s1 := v1(f) 4423 dest(f).Set(reflect.ValueOf(s0 <= s1).Convert(typ)) 4424 return tnext 4425 } 4426 case c0.rval.IsValid(): 4427 s0 := vInt(c0.rval) 4428 v1 := genValueInt(c1) 4429 if n.fnext != nil { 4430 fnext := getExec(n.fnext) 4431 n.exec = func(f *frame) bltn { 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 _, s1 := v1(f) 4444 dest(f).SetBool(s0 <= s1) 4445 return tnext 4446 } 4447 } 4448 case c1.rval.IsValid(): 4449 s1 := vInt(c1.rval) 4450 v0 := genValueInt(c0) 4451 if n.fnext != nil { 4452 fnext := getExec(n.fnext) 4453 n.exec = func(f *frame) bltn { 4454 _, s0 := v0(f) 4455 if s0 <= s1 { 4456 dest(f).SetBool(true) 4457 return tnext 4458 } 4459 dest(f).SetBool(false) 4460 return fnext 4461 } 4462 } else { 4463 dest := genValue(n) 4464 n.exec = func(f *frame) bltn { 4465 _, s0 := v0(f) 4466 dest(f).SetBool(s0 <= s1) 4467 return tnext 4468 } 4469 } 4470 default: 4471 v0 := genValueInt(c0) 4472 v1 := genValueInt(c1) 4473 if n.fnext != nil { 4474 fnext := getExec(n.fnext) 4475 n.exec = func(f *frame) bltn { 4476 _, s0 := v0(f) 4477 _, s1 := v1(f) 4478 if s0 <= s1 { 4479 dest(f).SetBool(true) 4480 return tnext 4481 } 4482 dest(f).SetBool(false) 4483 return fnext 4484 } 4485 } else { 4486 dest := genValue(n) 4487 n.exec = func(f *frame) bltn { 4488 _, s0 := v0(f) 4489 _, s1 := v1(f) 4490 dest(f).SetBool(s0 <= s1) 4491 return tnext 4492 } 4493 } 4494 } 4495 } 4496} 4497 4498func notEqual(n *node) { 4499 tnext := getExec(n.tnext) 4500 dest := genValueOutput(n, reflect.TypeOf(true)) 4501 typ := n.typ.concrete().TypeOf() 4502 isInterface := n.typ.TypeOf().Kind() == reflect.Interface 4503 c0, c1 := n.child[0], n.child[1] 4504 4505 if c0.typ.cat == aliasT || c1.typ.cat == aliasT { 4506 switch { 4507 case isInterface: 4508 v0 := genValue(c0) 4509 v1 := genValue(c1) 4510 dest := genValue(n) 4511 n.exec = func(f *frame) bltn { 4512 i0 := v0(f).Interface() 4513 i1 := v1(f).Interface() 4514 dest(f).Set(reflect.ValueOf(i0 != i1).Convert(typ)) 4515 return tnext 4516 } 4517 case c0.rval.IsValid(): 4518 i0 := c0.rval.Interface() 4519 v1 := genValue(c1) 4520 if n.fnext != nil { 4521 fnext := getExec(n.fnext) 4522 n.exec = func(f *frame) bltn { 4523 i1 := v1(f).Interface() 4524 if i0 != i1 { 4525 dest(f).SetBool(true) 4526 return tnext 4527 } 4528 dest(f).SetBool(false) 4529 return fnext 4530 } 4531 } else { 4532 dest := genValue(n) 4533 n.exec = func(f *frame) bltn { 4534 i1 := v1(f).Interface() 4535 dest(f).SetBool(i0 != i1) 4536 return tnext 4537 } 4538 } 4539 case c1.rval.IsValid(): 4540 i1 := c1.rval.Interface() 4541 v0 := genValue(c0) 4542 if n.fnext != nil { 4543 fnext := getExec(n.fnext) 4544 n.exec = func(f *frame) bltn { 4545 i0 := v0(f).Interface() 4546 if i0 != i1 { 4547 dest(f).SetBool(true) 4548 return tnext 4549 } 4550 dest(f).SetBool(false) 4551 return fnext 4552 } 4553 } else { 4554 dest := genValue(n) 4555 n.exec = func(f *frame) bltn { 4556 i0 := v0(f).Interface() 4557 dest(f).SetBool(i0 != i1) 4558 return tnext 4559 } 4560 } 4561 default: 4562 v0 := genValue(c0) 4563 v1 := genValue(c1) 4564 if n.fnext != nil { 4565 fnext := getExec(n.fnext) 4566 n.exec = func(f *frame) bltn { 4567 i0 := v0(f).Interface() 4568 i1 := v1(f).Interface() 4569 if i0 != i1 { 4570 dest(f).SetBool(true) 4571 return tnext 4572 } 4573 dest(f).SetBool(false) 4574 return fnext 4575 } 4576 } else { 4577 dest := genValue(n) 4578 n.exec = func(f *frame) bltn { 4579 i0 := v0(f).Interface() 4580 i1 := v1(f).Interface() 4581 dest(f).SetBool(i0 != i1) 4582 return tnext 4583 } 4584 } 4585 } 4586 return 4587 } 4588 4589 switch t0, t1 := c0.typ.TypeOf(), c1.typ.TypeOf(); { 4590 case isString(t0) || isString(t1): 4591 switch { 4592 case isInterface: 4593 v0 := genValueString(c0) 4594 v1 := genValueString(c1) 4595 n.exec = func(f *frame) bltn { 4596 _, s0 := v0(f) 4597 _, s1 := v1(f) 4598 dest(f).Set(reflect.ValueOf(s0 != s1).Convert(typ)) 4599 return tnext 4600 } 4601 case c0.rval.IsValid(): 4602 s0 := vString(c0.rval) 4603 v1 := genValueString(c1) 4604 if n.fnext != nil { 4605 fnext := getExec(n.fnext) 4606 n.exec = func(f *frame) bltn { 4607 _, s1 := v1(f) 4608 if s0 != s1 { 4609 dest(f).SetBool(true) 4610 return tnext 4611 } 4612 dest(f).SetBool(false) 4613 return fnext 4614 } 4615 } else { 4616 n.exec = func(f *frame) bltn { 4617 _, s1 := v1(f) 4618 dest(f).SetBool(s0 != s1) 4619 return tnext 4620 } 4621 } 4622 case c1.rval.IsValid(): 4623 s1 := vString(c1.rval) 4624 v0 := genValueString(c0) 4625 if n.fnext != nil { 4626 fnext := getExec(n.fnext) 4627 n.exec = func(f *frame) bltn { 4628 _, s0 := v0(f) 4629 if s0 != s1 { 4630 dest(f).SetBool(true) 4631 return tnext 4632 } 4633 dest(f).SetBool(false) 4634 return fnext 4635 } 4636 } else { 4637 n.exec = func(f *frame) bltn { 4638 _, s0 := v0(f) 4639 dest(f).SetBool(s0 != s1) 4640 return tnext 4641 } 4642 } 4643 default: 4644 v0 := genValueString(c0) 4645 v1 := genValueString(c1) 4646 if n.fnext != nil { 4647 fnext := getExec(n.fnext) 4648 n.exec = func(f *frame) bltn { 4649 _, s0 := v0(f) 4650 _, s1 := v1(f) 4651 if s0 != s1 { 4652 dest(f).SetBool(true) 4653 return tnext 4654 } 4655 dest(f).SetBool(false) 4656 return fnext 4657 } 4658 } else { 4659 n.exec = func(f *frame) bltn { 4660 _, s0 := v0(f) 4661 _, s1 := v1(f) 4662 dest(f).SetBool(s0 != s1) 4663 return tnext 4664 } 4665 } 4666 } 4667 case isFloat(t0) || isFloat(t1): 4668 switch { 4669 case isInterface: 4670 v0 := genValueFloat(c0) 4671 v1 := genValueFloat(c1) 4672 n.exec = func(f *frame) bltn { 4673 _, s0 := v0(f) 4674 _, s1 := v1(f) 4675 dest(f).Set(reflect.ValueOf(s0 != s1).Convert(typ)) 4676 return tnext 4677 } 4678 case c0.rval.IsValid(): 4679 s0 := vFloat(c0.rval) 4680 v1 := genValueFloat(c1) 4681 if n.fnext != nil { 4682 fnext := getExec(n.fnext) 4683 n.exec = func(f *frame) bltn { 4684 _, s1 := v1(f) 4685 if s0 != s1 { 4686 dest(f).SetBool(true) 4687 return tnext 4688 } 4689 dest(f).SetBool(false) 4690 return fnext 4691 } 4692 } else { 4693 n.exec = func(f *frame) bltn { 4694 _, s1 := v1(f) 4695 dest(f).SetBool(s0 != s1) 4696 return tnext 4697 } 4698 } 4699 case c1.rval.IsValid(): 4700 s1 := vFloat(c1.rval) 4701 v0 := genValueFloat(c0) 4702 if n.fnext != nil { 4703 fnext := getExec(n.fnext) 4704 n.exec = func(f *frame) bltn { 4705 _, s0 := v0(f) 4706 if s0 != s1 { 4707 dest(f).SetBool(true) 4708 return tnext 4709 } 4710 dest(f).SetBool(false) 4711 return fnext 4712 } 4713 } else { 4714 dest := genValue(n) 4715 n.exec = func(f *frame) bltn { 4716 _, s0 := v0(f) 4717 dest(f).SetBool(s0 != s1) 4718 return tnext 4719 } 4720 } 4721 default: 4722 v0 := genValueFloat(c0) 4723 v1 := genValueFloat(c1) 4724 if n.fnext != nil { 4725 fnext := getExec(n.fnext) 4726 n.exec = func(f *frame) bltn { 4727 _, s0 := v0(f) 4728 _, s1 := v1(f) 4729 if s0 != s1 { 4730 dest(f).SetBool(true) 4731 return tnext 4732 } 4733 dest(f).SetBool(false) 4734 return fnext 4735 } 4736 } else { 4737 dest := genValue(n) 4738 n.exec = func(f *frame) bltn { 4739 _, s0 := v0(f) 4740 _, s1 := v1(f) 4741 dest(f).SetBool(s0 != s1) 4742 return tnext 4743 } 4744 } 4745 } 4746 case isUint(t0) || isUint(t1): 4747 switch { 4748 case isInterface: 4749 v0 := genValueUint(c0) 4750 v1 := genValueUint(c1) 4751 n.exec = func(f *frame) bltn { 4752 _, s0 := v0(f) 4753 _, s1 := v1(f) 4754 dest(f).Set(reflect.ValueOf(s0 != s1).Convert(typ)) 4755 return tnext 4756 } 4757 case c0.rval.IsValid(): 4758 s0 := vUint(c0.rval) 4759 v1 := genValueUint(c1) 4760 if n.fnext != nil { 4761 fnext := getExec(n.fnext) 4762 n.exec = func(f *frame) bltn { 4763 _, s1 := v1(f) 4764 if s0 != s1 { 4765 dest(f).SetBool(true) 4766 return tnext 4767 } 4768 dest(f).SetBool(false) 4769 return fnext 4770 } 4771 } else { 4772 dest := genValue(n) 4773 n.exec = func(f *frame) bltn { 4774 _, s1 := v1(f) 4775 dest(f).SetBool(s0 != s1) 4776 return tnext 4777 } 4778 } 4779 case c1.rval.IsValid(): 4780 s1 := vUint(c1.rval) 4781 v0 := genValueUint(c0) 4782 if n.fnext != nil { 4783 fnext := getExec(n.fnext) 4784 n.exec = func(f *frame) bltn { 4785 _, s0 := v0(f) 4786 if s0 != s1 { 4787 dest(f).SetBool(true) 4788 return tnext 4789 } 4790 dest(f).SetBool(false) 4791 return fnext 4792 } 4793 } else { 4794 dest := genValue(n) 4795 n.exec = func(f *frame) bltn { 4796 _, s0 := v0(f) 4797 dest(f).SetBool(s0 != s1) 4798 return tnext 4799 } 4800 } 4801 default: 4802 v0 := genValueUint(c0) 4803 v1 := genValueUint(c1) 4804 if n.fnext != nil { 4805 fnext := getExec(n.fnext) 4806 n.exec = func(f *frame) bltn { 4807 _, s0 := v0(f) 4808 _, s1 := v1(f) 4809 if s0 != s1 { 4810 dest(f).SetBool(true) 4811 return tnext 4812 } 4813 dest(f).SetBool(false) 4814 return fnext 4815 } 4816 } else { 4817 dest := genValue(n) 4818 n.exec = func(f *frame) bltn { 4819 _, s0 := v0(f) 4820 _, s1 := v1(f) 4821 dest(f).SetBool(s0 != s1) 4822 return tnext 4823 } 4824 } 4825 } 4826 case isInt(t0) || isInt(t1): 4827 switch { 4828 case isInterface: 4829 v0 := genValueInt(c0) 4830 v1 := genValueInt(c1) 4831 n.exec = func(f *frame) bltn { 4832 _, s0 := v0(f) 4833 _, s1 := v1(f) 4834 dest(f).Set(reflect.ValueOf(s0 != s1).Convert(typ)) 4835 return tnext 4836 } 4837 case c0.rval.IsValid(): 4838 s0 := vInt(c0.rval) 4839 v1 := genValueInt(c1) 4840 if n.fnext != nil { 4841 fnext := getExec(n.fnext) 4842 n.exec = func(f *frame) bltn { 4843 _, s1 := v1(f) 4844 if s0 != s1 { 4845 dest(f).SetBool(true) 4846 return tnext 4847 } 4848 dest(f).SetBool(false) 4849 return fnext 4850 } 4851 } else { 4852 dest := genValue(n) 4853 n.exec = func(f *frame) bltn { 4854 _, s1 := v1(f) 4855 dest(f).SetBool(s0 != s1) 4856 return tnext 4857 } 4858 } 4859 case c1.rval.IsValid(): 4860 s1 := vInt(c1.rval) 4861 v0 := genValueInt(c0) 4862 if n.fnext != nil { 4863 fnext := getExec(n.fnext) 4864 n.exec = func(f *frame) bltn { 4865 _, s0 := v0(f) 4866 if s0 != s1 { 4867 dest(f).SetBool(true) 4868 return tnext 4869 } 4870 dest(f).SetBool(false) 4871 return fnext 4872 } 4873 } else { 4874 dest := genValue(n) 4875 n.exec = func(f *frame) bltn { 4876 _, s0 := v0(f) 4877 dest(f).SetBool(s0 != s1) 4878 return tnext 4879 } 4880 } 4881 default: 4882 v0 := genValueInt(c0) 4883 v1 := genValueInt(c1) 4884 if n.fnext != nil { 4885 fnext := getExec(n.fnext) 4886 n.exec = func(f *frame) bltn { 4887 _, s0 := v0(f) 4888 _, s1 := v1(f) 4889 if s0 != s1 { 4890 dest(f).SetBool(true) 4891 return tnext 4892 } 4893 dest(f).SetBool(false) 4894 return fnext 4895 } 4896 } else { 4897 dest := genValue(n) 4898 n.exec = func(f *frame) bltn { 4899 _, s0 := v0(f) 4900 _, s1 := v1(f) 4901 dest(f).SetBool(s0 != s1) 4902 return tnext 4903 } 4904 } 4905 } 4906 case isComplex(t0) || isComplex(t1): 4907 switch { 4908 case isInterface: 4909 v0 := genComplex(c0) 4910 v1 := genComplex(c1) 4911 n.exec = func(f *frame) bltn { 4912 s0 := v0(f) 4913 s1 := v1(f) 4914 dest(f).Set(reflect.ValueOf(s0 != s1).Convert(typ)) 4915 return tnext 4916 } 4917 case c0.rval.IsValid(): 4918 s0 := vComplex(c0.rval) 4919 v1 := genComplex(c1) 4920 if n.fnext != nil { 4921 fnext := getExec(n.fnext) 4922 n.exec = func(f *frame) bltn { 4923 s1 := v1(f) 4924 if s0 != s1 { 4925 dest(f).SetBool(true) 4926 return tnext 4927 } 4928 dest(f).SetBool(false) 4929 return fnext 4930 } 4931 } else { 4932 n.exec = func(f *frame) bltn { 4933 s1 := v1(f) 4934 dest(f).SetBool(s0 != s1) 4935 return tnext 4936 } 4937 } 4938 case c1.rval.IsValid(): 4939 s1 := vComplex(c1.rval) 4940 v0 := genComplex(c0) 4941 if n.fnext != nil { 4942 fnext := getExec(n.fnext) 4943 n.exec = func(f *frame) bltn { 4944 s0 := v0(f) 4945 if s0 != s1 { 4946 dest(f).SetBool(true) 4947 return tnext 4948 } 4949 dest(f).SetBool(false) 4950 return fnext 4951 } 4952 } else { 4953 dest := genValue(n) 4954 n.exec = func(f *frame) bltn { 4955 s0 := v0(f) 4956 dest(f).SetBool(s0 != s1) 4957 return tnext 4958 } 4959 } 4960 default: 4961 v0 := genComplex(c0) 4962 v1 := genComplex(c1) 4963 if n.fnext != nil { 4964 fnext := getExec(n.fnext) 4965 n.exec = func(f *frame) bltn { 4966 s0 := v0(f) 4967 s1 := v1(f) 4968 if s0 != s1 { 4969 dest(f).SetBool(true) 4970 return tnext 4971 } 4972 dest(f).SetBool(false) 4973 return fnext 4974 } 4975 } else { 4976 n.exec = func(f *frame) bltn { 4977 s0 := v0(f) 4978 s1 := v1(f) 4979 dest(f).SetBool(s0 != s1) 4980 return tnext 4981 } 4982 } 4983 } 4984 default: 4985 switch { 4986 case isInterface: 4987 v0 := genValue(c0) 4988 v1 := genValue(c1) 4989 n.exec = func(f *frame) bltn { 4990 i0 := v0(f).Interface() 4991 i1 := v1(f).Interface() 4992 dest(f).Set(reflect.ValueOf(i0 != i1).Convert(typ)) 4993 return tnext 4994 } 4995 case c0.rval.IsValid(): 4996 i0 := c0.rval.Interface() 4997 v1 := genValue(c1) 4998 if n.fnext != nil { 4999 fnext := getExec(n.fnext) 5000 n.exec = func(f *frame) bltn { 5001 i1 := v1(f).Interface() 5002 if i0 != i1 { 5003 dest(f).SetBool(true) 5004 return tnext 5005 } 5006 dest(f).SetBool(false) 5007 return fnext 5008 } 5009 } else { 5010 dest := genValue(n) 5011 n.exec = func(f *frame) bltn { 5012 i1 := v1(f).Interface() 5013 dest(f).SetBool(i0 != i1) 5014 return tnext 5015 } 5016 } 5017 case c1.rval.IsValid(): 5018 i1 := c1.rval.Interface() 5019 v0 := genValue(c0) 5020 if n.fnext != nil { 5021 fnext := getExec(n.fnext) 5022 n.exec = func(f *frame) bltn { 5023 i0 := v0(f).Interface() 5024 if i0 != i1 { 5025 dest(f).SetBool(true) 5026 return tnext 5027 } 5028 dest(f).SetBool(false) 5029 return fnext 5030 } 5031 } else { 5032 dest := genValue(n) 5033 n.exec = func(f *frame) bltn { 5034 i0 := v0(f).Interface() 5035 dest(f).SetBool(i0 != i1) 5036 return tnext 5037 } 5038 } 5039 default: 5040 v0 := genValue(c0) 5041 v1 := genValue(c1) 5042 if n.fnext != nil { 5043 fnext := getExec(n.fnext) 5044 n.exec = func(f *frame) bltn { 5045 i0 := v0(f).Interface() 5046 i1 := v1(f).Interface() 5047 if i0 != i1 { 5048 dest(f).SetBool(true) 5049 return tnext 5050 } 5051 dest(f).SetBool(false) 5052 return fnext 5053 } 5054 } else { 5055 dest := genValue(n) 5056 n.exec = func(f *frame) bltn { 5057 i0 := v0(f).Interface() 5058 i1 := v1(f).Interface() 5059 dest(f).SetBool(i0 != i1) 5060 return tnext 5061 } 5062 } 5063 } 5064 } 5065} 5066