src/ops/cmp.ops

   1 /*
   2  * $Id$
   3 ** cmp.ops
   4 */
   5
   6 =head1 NAME
   7
   8 cmp.ops - Comparison Opcodes
   9
  10 =cut
  11
  12 =head1 DESCRIPTION
  13
  14 Operations that compare two registers against each other.
  15 Some of these operations affect control flow directly; others
  16 do not.
  17
  18 When making changes to any ops file, run C<make bootstrap-ops> to regenerate
  19 all generated ops files.
  20
  21 =cut
  22
  23 ###############################################################################
  24
  25 =head2 Flow control comparison operators
  26
  27 These operators branch based on the relationship between
  28 their operands.
  29
  30 =over 4
  31
  32 =cut
  33
  34 ########################################
  35
  36 =item B<eq>(in INT, in INT, inconst LABEL)
  37
  38 =item B<eq>(in NUM, in NUM, inconst LABEL)
  39
  40 =item B<eq>(in STR, in STR, inconst LABEL)
  41
  42 =item B<eq>(invar PMC, invar PMC, inconst LABEL)
  43
  44 =item B<eq>(invar PMC, in INT, inconst LABEL)
  45
  46 =item B<eq>(invar PMC, in NUM, inconst LABEL)
  47
  48 =item B<eq>(invar PMC, in STR, inconst LABEL)
  49
  50 =item B<eq_str>(invar PMC, invar PMC, inconst LABEL)
  51
  52 =item B<eq_num>(invar PMC, invar PMC, inconst LABEL)
  53
  54 =item B<eq_addr>(in STR, in STR, inconst LABEL)
  55
  56 =item B<eq_addr>(invar PMC, invar PMC, inconst LABEL)
  57
  58 Branch if $1 is equal to $2. For PMCs this does a generic comparison,
  59 whatever that is for the involved PMCs. Mixed PMC number/string
  60 operands do a numeric or string comparison respectively.
  61
  62 B<eq_str> and B<eq_num> enforce string or number comparisons.
  63
  64 B<eq_addr> compares the address of the objects or strings.
  65
  66 =cut
  67
  68 inline op eq(in INT, in INT, inconst LABEL) :base_core {
  69     if ($1 == $2) {
  70         goto OFFSET($3);
  71     }
  72 }
  73
  74 inline op eq(in NUM, in NUM, inconst LABEL) :base_core {
  75     if ($1 == $2) {
  76         goto OFFSET($3);
  77     }
  78 }
  79
  80 op eq(in STR, in STR, inconst LABEL) :base_core {
  81     if (Parrot_str_equal(interp, $1, $2)) {
  82         goto OFFSET($3);
  83     }
  84 }
  85
  86 op eq(invar PMC, invar PMC, inconst LABEL) :base_core {
  87     if (VTABLE_is_equal(interp, $1, $2)) {
  88         goto OFFSET($3);
  89     }
  90 }
  91
  92 op eq(invar PMC, in INT, inconst LABEL) :base_core {
  93     PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer);
  94     VTABLE_set_integer_native(interp, temp, $2);
  95
  96     if (VTABLE_is_equal(interp, $1, temp)) {
  97         Parrot_pmc_free_temporary(interp, temp);
  98         goto OFFSET($3);
  99     }
 100
 101     Parrot_pmc_free_temporary(interp, temp);
 102 }
 103
 104 op eq(invar PMC, in NUM, inconst LABEL) :base_core {
 105     /*
 106      * the get_number and get_string should probably
 107      * be also replaced with code like above, as
 108      * overriding the compare multi subs wouldn't
 109      * have any effect with the current code
 110      */
 111     if (VTABLE_get_number(interp, $1) == $2) {
 112         goto OFFSET($3);
 113     }
 114 }
 115
 116 op eq(invar PMC, in STR, inconst LABEL) :base_core {
 117     if (Parrot_str_equal(interp, VTABLE_get_string(interp, $1), $2)) {
 118         goto OFFSET($3);
 119     }
 120 }
 121
 122 op eq_str(invar PMC, invar PMC, inconst LABEL) :base_core {
 123     if (VTABLE_is_equal_string(interp, $1, $2)) {
 124         goto OFFSET($3);
 125     }
 126 }
 127
 128 op eq_num(invar PMC, invar PMC, inconst LABEL) :base_core {
 129     if (VTABLE_is_equal_num(interp, $1, $2)) {
 130         goto OFFSET($3);
 131     }
 132 }
 133
 134 op eq_addr(in STR, in STR, inconst LABEL) :base_core {
 135     if ($1 == $2) {
 136         goto OFFSET($3);
 137     }
 138 }
 139
 140 op eq_addr(invar PMC, invar PMC, inconst LABEL) :base_core {
 141     if ($1 == $2) {
 142         goto OFFSET($3);
 143     }
 144 }
 145
 146 ########################################
 147
 148 =item B<ne>(in INT, in INT, inconst LABEL)
 149
 150 =item B<ne>(in NUM, in NUM, inconst LABEL)
 151
 152 =item B<ne>(in STR, in STR, inconst LABEL)
 153
 154 =item B<ne>(invar PMC, invar PMC, inconst LABEL)
 155
 156 =item B<ne>(invar PMC, in INT, inconst LABEL)
 157
 158 =item B<ne>(invar PMC, in NUM, inconst LABEL)
 159
 160 =item B<ne>(invar PMC, in STR, inconst LABEL)
 161
 162 =item B<ne_str>(invar PMC, invar PMC, inconst LABEL)
 163
 164 =item B<ne_num>(invar PMC, invar PMC, inconst LABEL)
 165
 166 =item B<ne_addr>(in STR, in STR, inconst LABEL)
 167
 168 =item B<ne_addr>(invar PMC, invar PMC, inconst LABEL)
 169
 170 Branch if $1 is not equal to $2.
 171
 172 =cut
 173
 174 inline op ne(in INT, in INT, inconst LABEL) :base_core {
 175     if ($1 != $2) {
 176         goto OFFSET($3);
 177     }
 178 }
 179
 180 inline op ne(in NUM, in NUM, inconst LABEL) :base_core {
 181     if ($1 != $2) {
 182         goto OFFSET($3);
 183     }
 184 }
 185
 186 op ne(in STR, in STR, inconst LABEL) :base_core {
 187     if (Parrot_str_not_equal(interp, $1, $2)) {
 188         goto OFFSET($3);
 189     }
 190 }
 191
 192 op ne(invar PMC, invar PMC, inconst LABEL) :base_core {
 193     if (!VTABLE_is_equal(interp, $1, $2)) {
 194         goto OFFSET($3);
 195     }
 196 }
 197
 198 op ne(invar PMC, in INT, inconst LABEL) :base_core {
 199     PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer);
 200     VTABLE_set_integer_native(interp, temp, $2);
 201
 202     if (!VTABLE_is_equal(interp, $1, temp)) {
 203         Parrot_pmc_free_temporary(interp, temp);
 204         goto OFFSET($3);
 205     }
 206
 207     Parrot_pmc_free_temporary(interp, temp);
 208 }
 209
 210 op ne(invar PMC, in NUM, inconst LABEL) :base_core {
 211     if (VTABLE_get_number(interp, $1) != $2) {
 212         goto OFFSET($3);
 213     }
 214 }
 215
 216 op ne(invar PMC, in STR, inconst LABEL) :base_core {
 217     if (Parrot_str_not_equal(interp, VTABLE_get_string(interp, $1), $2)) {
 218         goto OFFSET($3);
 219     }
 220 }
 221
 222 op ne_str(invar PMC, invar PMC, inconst LABEL) :base_core {
 223     if (VTABLE_cmp_string(interp, $1, $2) != 0) {
 224         goto OFFSET($3);
 225     }
 226 }
 227
 228 op ne_num(invar PMC, invar PMC, inconst LABEL) :base_core {
 229     if (VTABLE_cmp_num(interp, $1, $2) != 0) {
 230         goto OFFSET($3);
 231     }
 232 }
 233
 234 op ne_addr(in STR, in STR, inconst LABEL) :base_core {
 235     if ($1 != $2) {
 236         goto OFFSET($3);
 237     }
 238 }
 239
 240 op ne_addr(invar PMC, invar PMC, inconst LABEL) :base_core {
 241     if ($1 != $2) {
 242         goto OFFSET($3);
 243     }
 244 }
 245
 246 ########################################
 247
 248 =item B<lt>(in INT, in INT, inconst LABEL)
 249
 250 =item B<lt>(in NUM, in NUM, inconst LABEL)
 251
 252 =item B<lt>(in STR, in STR, inconst LABEL)
 253
 254 =item B<lt>(invar PMC, invar PMC, inconst LABEL)
 255
 256 =item B<lt>(invar PMC, in INT, inconst LABEL)
 257
 258 =item B<lt>(invar PMC, in NUM, inconst LABEL)
 259
 260 =item B<lt>(invar PMC, in STR, inconst LABEL)
 261
 262 =item B<lt_str>(invar PMC, invar PMC, inconst LABEL)
 263
 264 =item B<lt_num>(invar PMC, invar PMC, inconst LABEL)
 265
 266 Branch if $1 is less than $2.
 267
 268 =cut
 269
 270 inline op lt(in INT, in INT, inconst LABEL) :base_core {
 271     if ($1 < $2) {
 272         goto OFFSET($3);
 273     }
 274 }
 275
 276 inline op lt(in NUM, in NUM, inconst LABEL) :base_core {
 277     if ($1 < $2) {
 278         goto OFFSET($3);
 279     }
 280 }
 281
 282 op lt(in STR, in STR, inconst LABEL) :base_core {
 283     if (Parrot_str_compare(interp, $1, $2) < 0) {
 284         goto OFFSET($3);
 285     }
 286 }
 287
 288 op lt(invar PMC, invar PMC, inconst LABEL) :base_core {
 289     if (VTABLE_cmp(interp, $1, $2) < 0) {
 290         goto OFFSET($3);
 291     }
 292 }
 293
 294 op lt(invar PMC, in INT, inconst LABEL) :base_core {
 295     PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer);
 296     VTABLE_set_integer_native(interp, temp, $2);
 297
 298     if (VTABLE_cmp(interp, $1, temp) < 0) {
 299         Parrot_pmc_free_temporary(interp, temp);
 300         goto OFFSET($3);
 301     }
 302
 303     Parrot_pmc_free_temporary(interp, temp);
 304 }
 305
 306 op lt(invar PMC, in NUM, inconst LABEL) :base_core {
 307     if (VTABLE_get_number(interp, $1) < $2) {
 308         goto OFFSET($3);
 309     }
 310 }
 311
 312 op lt(invar PMC, in STR, inconst LABEL) :base_core {
 313     if (Parrot_str_compare(interp, VTABLE_get_string(interp, $1), $2) < 0) {
 314         goto OFFSET($3);
 315     }
 316 }
 317
 318 op lt_str(invar PMC, invar PMC, inconst LABEL) :base_core {
 319     if (VTABLE_cmp_string(interp, $1, $2) < 0) {
 320         goto OFFSET($3);
 321     }
 322 }
 323
 324 op lt_num(invar PMC, invar PMC, inconst LABEL) :base_core {
 325     if (VTABLE_cmp_num(interp, $1, $2) < 0) {
 326         goto OFFSET($3);
 327     }
 328 }
 329
 330 ########################################
 331
 332 =item B<le>(in INT, in INT, inconst LABEL)
 333
 334 =item B<le>(in NUM, in NUM, inconst LABEL)
 335
 336 =item B<le>(in STR, in STR, inconst LABEL)
 337
 338 =item B<le>(invar PMC, invar PMC, inconst LABEL)
 339
 340 =item B<le>(invar PMC, in INT, inconst LABEL)
 341
 342 =item B<le>(invar PMC, in NUM, inconst LABEL)
 343
 344 =item B<le>(invar PMC, in STR, inconst LABEL)
 345
 346 =item B<le_str>(invar PMC, invar PMC, inconst LABEL)
 347
 348 =item B<le_num>(invar PMC, invar PMC, inconst LABEL)
 349
 350 Branch if $1 is less than or equal to $2.
 351
 352 =cut
 353
 354 inline op le(in INT, in INT, inconst LABEL) :base_core {
 355     if ($1 <= $2) {
 356         goto OFFSET($3);
 357     }
 358 }
 359
 360 inline op le(in NUM, in NUM, inconst LABEL) :base_core {
 361     if ($1 <= $2) {
 362         goto OFFSET($3);
 363     }
 364 }
 365
 366 op le(in STR, in STR, inconst LABEL) :base_core {
 367     if (Parrot_str_compare(interp, $1, $2) <= 0) {
 368         goto OFFSET($3);
 369     }
 370 }
 371
 372 op le(invar PMC, invar PMC, inconst LABEL) :base_core {
 373     if (VTABLE_cmp(interp, $1, $2) <= 0) {
 374         goto OFFSET($3);
 375     }
 376 }
 377
 378 op le(invar PMC, in INT, inconst LABEL) :base_core {
 379     PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer);
 380     VTABLE_set_integer_native(interp, temp, $2);
 381
 382     if (VTABLE_cmp(interp, $1, temp) <= 0) {
 383         Parrot_pmc_free_temporary(interp, temp);
 384         goto OFFSET($3);
 385     }
 386
 387     Parrot_pmc_free_temporary(interp, temp);
 388 }
 389
 390 op le(invar PMC, in NUM, inconst LABEL) :base_core {
 391     if (VTABLE_get_number(interp, $1) <= $2) {
 392         goto OFFSET($3);
 393     }
 394 }
 395
 396 op le(invar PMC, in STR, inconst LABEL) :base_core {
 397     if (Parrot_str_compare(interp, VTABLE_get_string(interp, $1), $2) <= 0) {
 398         goto OFFSET($3);
 399     }
 400 }
 401
 402 op le_str(invar PMC, invar PMC, inconst LABEL) :base_core {
 403     if (VTABLE_cmp_string(interp, $1, $2) <= 0) {
 404         goto OFFSET($3);
 405     }
 406 }
 407
 408 op le_num(invar PMC, invar PMC, inconst LABEL) :base_core {
 409     if (VTABLE_cmp_num(interp, $1, $2) <= 0) {
 410         goto OFFSET($3);
 411     }
 412 }
 413
 414 ########################################
 415
 416 =item B<gt>(invar PMC, invar PMC, inconst LABEL)
 417
 418 =item B<gt>(invar PMC, in INT, inconst LABEL)
 419
 420 =item B<gt>(invar PMC, in NUM, inconst LABEL)
 421
 422 =item B<gt>(invar PMC, in STR, inconst LABEL)
 423
 424 =item B<gt_str>(invar PMC, invar PMC, inconst LABEL)
 425
 426 =item B<gt_num>(invar PMC, invar PMC, inconst LABEL)
 427
 428 Branch if $1 is greater than $2.
 429
 430 =cut
 431
 432 op gt(invar PMC, invar PMC, inconst LABEL) :base_core {
 433     if (VTABLE_cmp(interp, $1, $2) > 0) {
 434         goto OFFSET($3);
 435     }
 436 }
 437
 438 op gt(invar PMC, in INT, inconst LABEL) :base_core {
 439     PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer);
 440     VTABLE_set_integer_native(interp, temp, $2);
 441
 442     if (VTABLE_cmp(interp, $1, temp) > 0) {
 443         Parrot_pmc_free_temporary(interp, temp);
 444         goto OFFSET($3);
 445     }
 446
 447     Parrot_pmc_free_temporary(interp, temp);
 448 }
 449
 450 op gt(invar PMC, in NUM, inconst LABEL) :base_core {
 451     if (VTABLE_get_number(interp, $1) > $2) {
 452         goto OFFSET($3);
 453     }
 454 }
 455
 456 op gt(invar PMC, in STR, inconst LABEL) :base_core {
 457     if (Parrot_str_compare(interp, VTABLE_get_string(interp, $1), $2) > 0) {
 458         goto OFFSET($3);
 459     }
 460 }
 461
 462 op gt_str(invar PMC, invar PMC, inconst LABEL) :base_core {
 463     if (VTABLE_cmp_string(interp, $1, $2) > 0) {
 464         goto OFFSET($3);
 465     }
 466 }
 467
 468 op gt_num(invar PMC, invar PMC, inconst LABEL) :base_core {
 469     if (VTABLE_cmp_num(interp, $1, $2) > 0) {
 470         goto OFFSET($3);
 471     }
 472 }
 473
 474 ########################################
 475
 476 =item B<ge>(invar PMC, invar PMC, inconst LABEL)
 477
 478 =item B<ge>(invar PMC, in INT, inconst LABEL)
 479
 480 =item B<ge>(invar PMC, in NUM, inconst LABEL)
 481
 482 =item B<ge>(invar PMC, in STR, inconst LABEL)
 483
 484 =item B<ge_str>(invar PMC, invar PMC, inconst LABEL)
 485
 486 =item B<ge_num>(invar PMC, invar PMC, inconst LABEL)
 487
 488 Branch if $1 is greater than or equal to $2.
 489
 490 =cut
 491
 492 op ge(invar PMC, invar PMC, inconst LABEL) :base_core {
 493     if (VTABLE_cmp(interp, $1, $2) >= 0) {
 494         goto OFFSET($3);
 495     }
 496 }
 497
 498 op ge(invar PMC, in INT, inconst LABEL) :base_core {
 499     PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer);
 500     VTABLE_set_integer_native(interp, temp, $2);
 501
 502     if (VTABLE_cmp(interp, $1, temp) >= 0) {
 503         Parrot_pmc_free_temporary(interp, temp);
 504         goto OFFSET($3);
 505     }
 506
 507     Parrot_pmc_free_temporary(interp, temp);
 508 }
 509
 510 op ge(invar PMC, in NUM, inconst LABEL) :base_core {
 511     if (VTABLE_get_number(interp, $1) >= $2) {
 512         goto OFFSET($3);
 513     }
 514 }
 515
 516 op ge(invar PMC, in STR, inconst LABEL) :base_core {
 517     if (Parrot_str_compare(interp, VTABLE_get_string(interp, $1), $2) >= 0) {
 518         goto OFFSET($3);
 519     }
 520 }
 521
 522 op ge_str(invar PMC, invar PMC, inconst LABEL) :base_core {
 523     if (VTABLE_cmp_string(interp, $1, $2) >= 0) {
 524         goto OFFSET($3);
 525     }
 526 }
 527
 528 op ge_num(invar PMC, invar PMC, inconst LABEL) :base_core {
 529     if (VTABLE_cmp_num(interp, $1, $2) >= 0) {
 530         goto OFFSET($3);
 531     }
 532 }
 533
 534 ########################################
 535
 536 =item B<if_null>(invar PMC, inconst LABEL)
 537
 538 Branch to $2 if $1 is a NULL PMC.
 539
 540 =item B<if_null>(invar STR, inconst LABEL)
 541
 542 Branch to $2 if $1 is a NULL STRING.
 543
 544 =cut
 545
 546 op if_null(invar PMC, inconst LABEL) {
 547     if (PMC_IS_NULL($1)) {
 548         goto OFFSET($2);
 549     }
 550 }
 551
 552 op if_null(invar STR, inconst LABEL) {
 553     if (STRING_IS_NULL($1)) {
 554         goto OFFSET($2);
 555     }
 556 }
 557
 558 ########################################
 559
 560 =item B<unless_null>(invar PMC, inconst LABEL)
 561
 562 Branch to $2 if $1 is I<not> a NULL PMC.
 563
 564 =item B<unless_null>(invar STR, inconst LABEL)
 565
 566 Branch to $2 if $1 is I<not> a NULL STRING.
 567
 568 =cut
 569
 570 op unless_null(invar PMC, inconst LABEL) {
 571     if (!PMC_IS_NULL($1)) {
 572         goto OFFSET($2);
 573     }
 574 }
 575
 576 op unless_null(invar STR, inconst LABEL) {
 577     if (!STRING_IS_NULL($1)) {
 578         goto OFFSET($2);
 579     }
 580 }
 581
 582 =back
 583
 584 =cut
 585
 586
 587 ###############################################################################
 588
 589 =head2 Non-flow control comparison ops
 590
 591 These ops do comparisons and truth testing without doing flow control.
 592
 593 =over 4
 594
 595 =item B<cmp>(out INT, in INT, in INT)
 596
 597 =item B<cmp>(out INT, in NUM, in NUM)
 598
 599 =item B<cmp>(out INT, in STR, in STR)
 600
 601 =item B<cmp>(out INT, invar PMC, invar PMC)
 602
 603 =item B<cmp>(out INT, invar PMC, in INT)
 604
 605 =item B<cmp>(out INT, invar PMC, in NUM)
 606
 607 =item B<cmp>(out INT, invar PMC, in STR)
 608
 609 =item B<cmp_str>(out INT, invar PMC, invar PMC)
 610
 611 =item B<cmp_num>(out INT, invar PMC, invar PMC)
 612
 613 Sets $1 to -1 if $2 < $3, +1 if $2 > $3, and 0 otherwise.
 614
 615 =cut
 616
 617 inline op cmp(out INT, in INT, in INT) :base_core {
 618     $1 = $2 < $3 ? -1 :
 619          $2 > $3 ? +1 :
 620          0;
 621 }
 622
 623 inline op cmp(out INT, in NUM, in NUM) :base_core {
 624     $1 = $2 < $3 ? -1 :
 625          $2 > $3 ? +1 :
 626          0;
 627 }
 628
 629 inline op cmp(out INT, in STR, in STR) :base_core {
 630     $1 = Parrot_str_compare(interp, $2, $3);
 631 }
 632
 633 inline op cmp(out INT, invar PMC, invar PMC) :base_core {
 634     $1 = VTABLE_cmp(interp, $2, $3);
 635 }
 636
 637 inline op cmp(out INT, invar PMC, in INT) :base_core {
 638     const INTVAL l = VTABLE_get_integer(interp, $2);
 639     $1 = l < $3 ? -1 :
 640          l > $3 ? +1 :
 641          0;
 642 }
 643
 644 inline op cmp(out INT, invar PMC, in NUM) :base_core {
 645     const FLOATVAL l = VTABLE_get_number(interp, $2);
 646     $1 = l < $3 ? -1 :
 647          l > $3 ? +1 :
 648          0;
 649 }
 650
 651 inline op cmp(out INT, invar PMC, in STR) :base_core {
 652     STRING* const l = VTABLE_get_string(interp, $2);
 653     $1 = Parrot_str_compare(interp, l, $3);
 654 }
 655
 656 inline op cmp_str(out INT, invar PMC, invar PMC) :base_core {
 657     $1 = VTABLE_cmp_string(interp, $2, $3);
 658 }
 659
 660 inline op cmp_num(out INT, invar PMC, invar PMC) :base_core {
 661     $1 = VTABLE_cmp_num(interp, $2, $3);
 662 }
 663
 664 =item B<cmp_pmc>(out PMC, invar PMC, invar PMC)
 665
 666 Does the same thing as the other cmp_* variants, but puts a PMC in $1.  This is
 667 useful for avoiding the semipredicate problem in HLLs where two aggregate PMCs
 668 are not always comparable.
 669
 670 =cut
 671
 672 inline op cmp_pmc(out PMC, invar PMC, invar PMC) :base_core {
 673     $1 = VTABLE_cmp_pmc(interp, $2, $3);
 674 }
 675
 676 ########################################
 677
 678 =item B<issame>(out INT, invar PMC, invar PMC)
 679
 680 =item B<issame>(out INT, in STR, in STR)
 681
 682 Sets $1 to 1 or 0, depending on the identity of the 2 objects.
 683 The identity is the PMCs memory address.
 684
 685 =item B<isntsame>(out INT, invar PMC, invar PMC)
 686
 687 =item B<isntsame>(out INT, in STR, in STR)
 688
 689 Sets $1 to 0 or 1, depending on the identity of the 2 objects.
 690
 691 =item B<istrue>(out INT, invar PMC)
 692
 693 Sets $1 to 1 or 0, depending on whether $2 is true or not.
 694
 695 =item B<isfalse>(out INT, invar PMC)
 696
 697 Sets $1 to 1 or 0, depending on whether $2 is false or not.
 698
 699 =item B<isnull>(out INT, in PMC)
 700
 701 Sets $1 to 1 if the object is null, 0 otherwise.
 702
 703 =item B<isnull>(out INT, in STR)
 704
 705 Sets $1 to 1 if the string is null, 0 otherwise.
 706
 707 =cut
 708
 709 inline op issame(out INT, invar PMC, invar PMC) {
 710     if ($2 == $3)
 711         $1 = 1;
 712     else
 713         $1 = VTABLE_is_same(interp, $2, $3);
 714 }
 715
 716 inline op issame(out INT, in STR, in STR) {
 717     $1 = $2 == $3;
 718 }
 719
 720 inline op isntsame(out INT, invar PMC, invar PMC) {
 721     if ($2 == $3)
 722         $1 = 0;
 723     else
 724         $1 = !VTABLE_is_same(interp, $2, $3);
 725 }
 726
 727 inline op isntsame(out INT, in STR, in STR) {
 728     $1 = $2 != $3;
 729 }
 730
 731 inline op istrue(out INT, invar PMC) {
 732     $1 = VTABLE_get_bool(interp, $2);
 733 }
 734
 735 inline op isfalse(out INT, invar PMC) {
 736     $1 = !VTABLE_get_bool(interp, $2);
 737 }
 738
 739 inline op isnull(out INT, in PMC) {
 740     $1 = PMC_IS_NULL($2);
 741 }
 742
 743 inline op isnull(out INT, in STR) {
 744     $1 = STRING_IS_NULL($2);
 745 }
 746
 747 =item B<isgt>(out INT, in INT, in INT)
 748
 749 =item B<isgt>(out INT, in NUM, in NUM)
 750
 751 =item B<isgt>(out INT, in STR, in STR)
 752
 753 These 3 opcodes are valid, but create as their reverse.
 754
 755 =item B<isgt>(out INT, invar PMC, invar PMC)
 756
 757 Sets $1 to 1 if $2 is greater than $3.
 758
 759 =cut
 760
 761 inline op isgt(out INT, invar PMC, invar PMC) {
 762     $1 = (VTABLE_cmp(interp, $2, $3) > 0);
 763 }
 764
 765 =item B<isge>(out INT, in INT, in INT)
 766
 767 =item B<isge>(out INT, in NUM, in NUM)
 768
 769 =item B<isge>(out INT, in STR, in STR)
 770
 771 These 3 opcodes are valid, but create as their reverse.
 772
 773 =item B<isge>(out INT, invar PMC, invar PMC)
 774
 775 Sets $1 to 1 if $2 is greater than or equal to $3.
 776
 777 =cut
 778
 779 inline op isge(out INT, invar PMC, invar PMC) {
 780     $1 = (VTABLE_cmp(interp, $2, $3) >= 0);
 781 }
 782
 783 =item B<isle>(out INT, in INT, in INT)
 784
 785 =item B<isle>(out INT, in NUM, in NUM)
 786
 787 =item B<isle>(out INT, in STR, in STR)
 788
 789 =item B<isle>(out INT, invar PMC, invar PMC)
 790
 791 Sets $1 to 1 if $2 is less than or equal to $3.
 792
 793 =cut
 794
 795 inline op isle(out INT, in INT, in INT) {
 796     $1 = $2 <= $3;
 797 }
 798
 799 inline op isle(out INT, in NUM, in NUM) {
 800     $1 = $2 <= $3;
 801 }
 802
 803 inline op isle(out INT, in STR, in STR) {
 804     $1 = Parrot_str_compare(interp, $2, $3) <= 0;
 805 }
 806
 807 inline op isle(out INT, invar PMC, invar PMC) {
 808     $1 = (VTABLE_cmp(interp, $2, $3) <= 0);
 809 }
 810
 811 =item B<islt>(out INT, in INT, in INT)
 812
 813 =item B<islt>(out INT, in NUM, in NUM)
 814
 815 =item B<islt>(out INT, in STR, in STR)
 816
 817 =item B<islt>(out INT, invar PMC, invar PMC)
 818
 819 Sets $1 to 1 if $2 is less than $3.
 820
 821 =cut
 822
 823 inline op islt(out INT, in INT, in INT) {
 824     $1 = ($2 < $3) ? 1 : 0;
 825 }
 826
 827 inline op islt(out INT, in NUM, in NUM) {
 828     $1 = $2 < $3;
 829 }
 830
 831 inline op islt(out INT, in STR, in STR) {
 832     $1 = Parrot_str_compare(interp, $2, $3) < 0;
 833 }
 834
 835 inline op islt(out INT, invar PMC, invar PMC) {
 836     $1 = (VTABLE_cmp(interp, $2, $3) < 0);
 837 }
 838
 839 =item B<iseq>(out INT, in INT, in INT)
 840
 841 =item B<iseq>(out INT, in NUM, in NUM)
 842
 843 =item B<iseq>(out INT, in STR, in STR)
 844
 845 =item B<iseq>(out INT, invar PMC, invar PMC)
 846
 847 Sets $1 to 1 if $2 is equal to $3.
 848
 849 =cut
 850
 851 inline op iseq(out INT, in INT, in INT) {
 852     $1 = ($2 == $3) ? 1 : 0;
 853 }
 854
 855 inline op iseq(out INT, in NUM, in NUM) {
 856     $1 = $2 == $3;
 857 }
 858
 859 inline op iseq(out INT, in STR, in STR) {
 860     $1 = (Parrot_str_equal(interp, $2, $3) ? 1 : 0);
 861 }
 862
 863 inline op iseq(out INT, invar PMC, invar PMC) {
 864     if (&$2 == &$3)
 865         $1 = 1;
 866     else
 867         $1 = VTABLE_is_equal(interp, $2, $3);
 868 }
 869
 870 =item B<isne>(out INT, in INT, in INT)
 871
 872 =item B<isne>(out INT, in NUM, in NUM)
 873
 874 =item B<isne>(out INT, in STR, in STR)
 875
 876 =item B<isne>(out INT, invar PMC, invar PMC)
 877
 878 Sets $1 to 1 if $2 is not equal to $3.
 879
 880 =cut
 881
 882 inline op isne(out INT, in INT, in INT) {
 883     $1 = ($2 == $3) ? 0 : 1;
 884 }
 885
 886 inline op isne(out INT, in NUM, in NUM) {
 887     $1 = $2 != $3;
 888 }
 889
 890 inline op isne(out INT, in STR, in STR) {
 891     $1 = (Parrot_str_not_equal(interp, $2, $3) ? 1 : 0);
 892 }
 893
 894 inline op isne(out INT, invar PMC, invar PMC) {
 895     if (&$2 == &$3)
 896         $1 = 0;
 897     else
 898         $1 = !VTABLE_is_equal(interp, $2, $3);
 899 }
 900
 901 =back
 902
 903 =cut
 904
 905
 906 ###############################################################################
 907
 908 =head2 Logical operations
 909
 910 These operations apply logical functions to their arguments.
 911
 912 =over 4
 913
 914 =cut
 915
 916 ########################################
 917
 918 =item B<and>(out INT, in INT, in INT)
 919
 920 =item B<and>(invar PMC, invar PMC, invar PMC)
 921
 922 Short-circuiting logical and.  Returns $2 if it's false, else returns $3.
 923
 924 =cut
 925
 926 inline op and(out INT, in INT, in INT) :base_core {
 927     $1 = $2 ? $3 : $2;
 928 }
 929
 930 inline op and(invar PMC, invar PMC, invar PMC) :base_core {
 931     $1 = VTABLE_get_bool(interp, $2) ? $3 : $2;
 932 }
 933
 934 ########################################
 935
 936 =item B<not>(inout INT)
 937
 938 =item B<not>(invar PMC)
 939
 940 Set the boolean state of $1 to the opposite of the boolean state from $1.
 941
 942 =item B<not>(out INT, in INT)
 943
 944 =item B<not>(out PMC, invar PMC)
 945
 946 =cut
 947
 948 inline op not(inout INT) :base_core {
 949     $1 = ! $1;
 950 }
 951
 952 inline op not(out INT, in INT) :base_core {
 953     $1 = ! $2;
 954 }
 955
 956 inline op not(invar PMC) :base_core {
 957     VTABLE_set_bool(interp, $1, !VTABLE_get_bool(interp, $1));
 958 }
 959
 960 inline op not(out PMC, invar PMC) :base_core {
 961     $1 = Parrot_pmc_new(interp, VTABLE_type(interp, $2));
 962     VTABLE_set_bool(interp, $1, (!VTABLE_get_bool(interp, $2)));
 963 }
 964
 965 ########################################
 966
 967 =item B<or>(out INT, in INT, in INT)
 968
 969 =item B<or>(invar PMC, invar PMC, invar PMC)
 970
 971 Short-circuiting logical or.  Returns $2 if it's true, else returns $3.
 972
 973 =cut
 974
 975 inline op or(out INT, in INT, in INT) :base_core {
 976     $1 = $2 ? $2 : $3;
 977 }
 978
 979 inline op or(invar PMC, invar PMC, invar PMC) :base_core {
 980     $1 = VTABLE_get_bool(interp, $2) ? $2 : $3;
 981 }
 982
 983 ########################################
 984
 985 =item B<xor>(out INT, in INT, in INT)
 986
 987 =item B<xor>(invar PMC, invar PMC, invar PMC)
 988
 989 Logical xor.  Returns $2 if it's true and $3 isn't,
 990 returns $3 if it's true and $2 isn't, else returns false.
 991
 992 =cut
 993
 994 inline op xor(out INT, in INT, in INT) :base_core {
 995     $1 = ($2 && ! $3) ? $2 : ($3 && ! $2) ? $3 : 0;
 996 }
 997
 998 inline op xor(invar PMC, invar PMC, invar PMC) :base_core {
 999     const INTVAL a = VTABLE_get_bool(interp, $2);
1000     const INTVAL b = VTABLE_get_bool(interp, $3);
1001     if (a && ! b)
1002         $1 = $2;
1003     else
1004         if (b && ! a)
1005             $1 = $3 ;
1006         else{
1007             $1 = Parrot_pmc_new(interp, VTABLE_type(interp, $2));
1008             VTABLE_set_bool(interp, $1, 0);
1009         }
1010 }
1011
1012 =back
1013
1014 =cut
1015
1016
1017 ###############################################################################
1018
1019 =head1 COPYRIGHT
1020
1021 Copyright (C) 2001-2010, Parrot Foundation.
1022
1023 =head1 LICENSE
1024
1025 This program is free software. It is subject to the same license
1026 as the Parrot interpreter itself.
1027
1028 =cut
1029
1030 /*
1031  * Local variables:
1032  *   c-file-style: "parrot"
1033  * End:
1034  * vim: expandtab shiftwidth=4:
1035  */